linux/net/irda/irlan/irlan_common.c
<<
>>
Prefs
   1/*********************************************************************
   2 *
   3 * Filename:      irlan_common.c
   4 * Version:       0.9
   5 * Description:   IrDA LAN Access Protocol Implementation
   6 * Status:        Experimental.
   7 * Author:        Dag Brattli <dagb@cs.uit.no>
   8 * Created at:    Sun Aug 31 20:14:37 1997
   9 * Modified at:   Sun Dec 26 21:53:10 1999
  10 * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11 *
  12 *     Copyright (c) 1997, 1999 Dag Brattli <dagb@cs.uit.no>,
  13 *     All Rights Reserved.
  14 *
  15 *     This program is free software; you can redistribute it and/or
  16 *     modify it under the terms of the GNU General Public License as
  17 *     published by the Free Software Foundation; either version 2 of
  18 *     the License, or (at your option) any later version.
  19 *
  20 *     Neither Dag Brattli nor University of Tromsø admit liability nor
  21 *     provide warranty for any of this software. This material is
  22 *     provided "AS-IS" and at no charge.
  23 *
  24 ********************************************************************/
  25
  26#include <linux/module.h>
  27
  28#include <linux/kernel.h>
  29#include <linux/string.h>
  30#include <linux/gfp.h>
  31#include <linux/init.h>
  32#include <linux/errno.h>
  33#include <linux/proc_fs.h>
  34#include <linux/sched.h>
  35#include <linux/seq_file.h>
  36#include <linux/random.h>
  37#include <linux/netdevice.h>
  38#include <linux/etherdevice.h>
  39#include <linux/rtnetlink.h>
  40#include <linux/moduleparam.h>
  41#include <linux/bitops.h>
  42
  43#include <asm/system.h>
  44#include <asm/byteorder.h>
  45
  46#include <net/irda/irda.h>
  47#include <net/irda/irttp.h>
  48#include <net/irda/irlmp.h>
  49#include <net/irda/iriap.h>
  50#include <net/irda/timer.h>
  51
  52#include <net/irda/irlan_common.h>
  53#include <net/irda/irlan_client.h>
  54#include <net/irda/irlan_provider.h>
  55#include <net/irda/irlan_eth.h>
  56#include <net/irda/irlan_filter.h>
  57
  58
  59/* extern char sysctl_devname[]; */
  60
  61/*
  62 *  Master structure
  63 */
  64static LIST_HEAD(irlans);
  65
  66static void *ckey;
  67static void *skey;
  68
  69/* Module parameters */
  70static int eth;   /* Use "eth" or "irlan" name for devices */
  71static int access = ACCESS_PEER; /* PEER, DIRECT or HOSTED */
  72
  73#ifdef CONFIG_PROC_FS
  74static const char *const irlan_access[] = {
  75        "UNKNOWN",
  76        "DIRECT",
  77        "PEER",
  78        "HOSTED"
  79};
  80
  81static const char *const irlan_media[] = {
  82        "UNKNOWN",
  83        "802.3",
  84        "802.5"
  85};
  86
  87extern struct proc_dir_entry *proc_irda;
  88
  89static int irlan_seq_open(struct inode *inode, struct file *file);
  90
  91static const struct file_operations irlan_fops = {
  92        .owner   = THIS_MODULE,
  93        .open    = irlan_seq_open,
  94        .read    = seq_read,
  95        .llseek  = seq_lseek,
  96        .release = seq_release,
  97};
  98
  99extern struct proc_dir_entry *proc_irda;
 100#endif /* CONFIG_PROC_FS */
 101
 102static struct irlan_cb *irlan_open(__u32 saddr, __u32 daddr);
 103static void __irlan_close(struct irlan_cb *self);
 104static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
 105                                __u8 value_byte, __u16 value_short,
 106                                __u8 *value_array, __u16 value_len);
 107static void irlan_open_unicast_addr(struct irlan_cb *self);
 108static void irlan_get_unicast_addr(struct irlan_cb *self);
 109void irlan_close_tsaps(struct irlan_cb *self);
 110
 111/*
 112 * Function irlan_init (void)
 113 *
 114 *    Initialize IrLAN layer
 115 *
 116 */
 117static int __init irlan_init(void)
 118{
 119        struct irlan_cb *new;
 120        __u16 hints;
 121
 122        IRDA_DEBUG(2, "%s()\n", __func__ );
 123
 124#ifdef CONFIG_PROC_FS
 125        { struct proc_dir_entry *proc;
 126        proc = proc_create("irlan", 0, proc_irda, &irlan_fops);
 127        if (!proc) {
 128                printk(KERN_ERR "irlan_init: can't create /proc entry!\n");
 129                return -ENODEV;
 130        }
 131        }
 132#endif /* CONFIG_PROC_FS */
 133
 134        IRDA_DEBUG(4, "%s()\n", __func__ );
 135        hints = irlmp_service_to_hint(S_LAN);
 136
 137        /* Register with IrLMP as a client */
 138        ckey = irlmp_register_client(hints, &irlan_client_discovery_indication,
 139                                     NULL, NULL);
 140        if (!ckey)
 141                goto err_ckey;
 142
 143        /* Register with IrLMP as a service */
 144        skey = irlmp_register_service(hints);
 145        if (!skey)
 146                goto err_skey;
 147
 148        /* Start the master IrLAN instance (the only one for now) */
 149        new = irlan_open(DEV_ADDR_ANY, DEV_ADDR_ANY);
 150        if (!new)
 151                goto err_open;
 152
 153        /* The master will only open its (listen) control TSAP */
 154        irlan_provider_open_ctrl_tsap(new);
 155
 156        /* Do some fast discovery! */
 157        irlmp_discovery_request(DISCOVERY_DEFAULT_SLOTS);
 158
 159        return 0;
 160
 161err_open:
 162        irlmp_unregister_service(skey);
 163err_skey:
 164        irlmp_unregister_client(ckey);
 165err_ckey:
 166#ifdef CONFIG_PROC_FS
 167        remove_proc_entry("irlan", proc_irda);
 168#endif /* CONFIG_PROC_FS */
 169
 170        return -ENOMEM;
 171}
 172
 173static void __exit irlan_cleanup(void)
 174{
 175        struct irlan_cb *self, *next;
 176
 177        IRDA_DEBUG(4, "%s()\n", __func__ );
 178
 179        irlmp_unregister_client(ckey);
 180        irlmp_unregister_service(skey);
 181
 182#ifdef CONFIG_PROC_FS
 183        remove_proc_entry("irlan", proc_irda);
 184#endif /* CONFIG_PROC_FS */
 185
 186        /* Cleanup any leftover network devices */
 187        rtnl_lock();
 188        list_for_each_entry_safe(self, next, &irlans, dev_list) {
 189                __irlan_close(self);
 190        }
 191        rtnl_unlock();
 192}
 193
 194/*
 195 * Function irlan_open (void)
 196 *
 197 *    Open new instance of a client/provider, we should only register the
 198 *    network device if this instance is ment for a particular client/provider
 199 */
 200static struct irlan_cb *irlan_open(__u32 saddr, __u32 daddr)
 201{
 202        struct net_device *dev;
 203        struct irlan_cb *self;
 204
 205        IRDA_DEBUG(2, "%s()\n", __func__ );
 206
 207        /* Create network device with irlan */
 208        dev = alloc_irlandev(eth ? "eth%d" : "irlan%d");
 209        if (!dev)
 210                return NULL;
 211
 212        self = netdev_priv(dev);
 213        self->dev = dev;
 214
 215        /*
 216         *  Initialize local device structure
 217         */
 218        self->magic = IRLAN_MAGIC;
 219        self->saddr = saddr;
 220        self->daddr = daddr;
 221
 222        /* Provider access can only be PEER, DIRECT, or HOSTED */
 223        self->provider.access_type = access;
 224        if (access == ACCESS_DIRECT) {
 225                /*
 226                 * Since we are emulating an IrLAN sever we will have to
 227                 * give ourself an ethernet address!
 228                 */
 229                dev->dev_addr[0] = 0x40;
 230                dev->dev_addr[1] = 0x00;
 231                dev->dev_addr[2] = 0x00;
 232                dev->dev_addr[3] = 0x00;
 233                get_random_bytes(dev->dev_addr+4, 1);
 234                get_random_bytes(dev->dev_addr+5, 1);
 235        }
 236
 237        self->media = MEDIA_802_3;
 238        self->disconnect_reason = LM_USER_REQUEST;
 239        init_timer(&self->watchdog_timer);
 240        init_timer(&self->client.kick_timer);
 241        init_waitqueue_head(&self->open_wait);
 242
 243        skb_queue_head_init(&self->client.txq);
 244
 245        irlan_next_client_state(self, IRLAN_IDLE);
 246        irlan_next_provider_state(self, IRLAN_IDLE);
 247
 248        if (register_netdev(dev)) {
 249                IRDA_DEBUG(2, "%s(), register_netdev() failed!\n",
 250                           __func__ );
 251                self = NULL;
 252                free_netdev(dev);
 253        } else {
 254                rtnl_lock();
 255                list_add_rcu(&self->dev_list, &irlans);
 256                rtnl_unlock();
 257        }
 258
 259        return self;
 260}
 261/*
 262 * Function __irlan_close (self)
 263 *
 264 *    This function closes and deallocates the IrLAN client instances. Be
 265 *    aware that other functions which calls client_close() must
 266 *    remove self from irlans list first.
 267 */
 268static void __irlan_close(struct irlan_cb *self)
 269{
 270        IRDA_DEBUG(2, "%s()\n", __func__ );
 271
 272        ASSERT_RTNL();
 273        IRDA_ASSERT(self != NULL, return;);
 274        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 275
 276        del_timer_sync(&self->watchdog_timer);
 277        del_timer_sync(&self->client.kick_timer);
 278
 279        /* Close all open connections and remove TSAPs */
 280        irlan_close_tsaps(self);
 281
 282        if (self->client.iriap)
 283                iriap_close(self->client.iriap);
 284
 285        /* Remove frames queued on the control channel */
 286        skb_queue_purge(&self->client.txq);
 287
 288        /* Unregister and free self via destructor */
 289        unregister_netdevice(self->dev);
 290}
 291
 292/* Find any instance of irlan, used for client discovery wakeup */
 293struct irlan_cb *irlan_get_any(void)
 294{
 295        struct irlan_cb *self;
 296
 297        list_for_each_entry_rcu(self, &irlans, dev_list) {
 298                return self;
 299        }
 300        return NULL;
 301}
 302
 303/*
 304 * Function irlan_connect_indication (instance, sap, qos, max_sdu_size, skb)
 305 *
 306 *    Here we receive the connect indication for the data channel
 307 *
 308 */
 309static void irlan_connect_indication(void *instance, void *sap,
 310                                     struct qos_info *qos,
 311                                     __u32 max_sdu_size,
 312                                     __u8 max_header_size,
 313                                     struct sk_buff *skb)
 314{
 315        struct irlan_cb *self;
 316        struct tsap_cb *tsap;
 317
 318        IRDA_DEBUG(2, "%s()\n", __func__ );
 319
 320        self = (struct irlan_cb *) instance;
 321        tsap = (struct tsap_cb *) sap;
 322
 323        IRDA_ASSERT(self != NULL, return;);
 324        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 325        IRDA_ASSERT(tsap == self->tsap_data,return;);
 326
 327        self->max_sdu_size = max_sdu_size;
 328        self->max_header_size = max_header_size;
 329
 330        IRDA_DEBUG(0, "%s: We are now connected!\n", __func__);
 331
 332        del_timer(&self->watchdog_timer);
 333
 334        /* If you want to pass the skb to *both* state machines, you will
 335         * need to skb_clone() it, so that you don't free it twice.
 336         * As the state machines don't need it, git rid of it here...
 337         * Jean II */
 338        if (skb)
 339                dev_kfree_skb(skb);
 340
 341        irlan_do_provider_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);
 342        irlan_do_client_event(self, IRLAN_DATA_CONNECT_INDICATION, NULL);
 343
 344        if (self->provider.access_type == ACCESS_PEER) {
 345                /*
 346                 * Data channel is open, so we are now allowed to
 347                 * configure the remote filter
 348                 */
 349                irlan_get_unicast_addr(self);
 350                irlan_open_unicast_addr(self);
 351        }
 352        /* Ready to transfer Ethernet frames (at last) */
 353        netif_start_queue(self->dev); /* Clear reason */
 354}
 355
 356static void irlan_connect_confirm(void *instance, void *sap,
 357                                  struct qos_info *qos,
 358                                  __u32 max_sdu_size,
 359                                  __u8 max_header_size,
 360                                  struct sk_buff *skb)
 361{
 362        struct irlan_cb *self;
 363
 364        self = (struct irlan_cb *) instance;
 365
 366        IRDA_ASSERT(self != NULL, return;);
 367        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 368
 369        self->max_sdu_size = max_sdu_size;
 370        self->max_header_size = max_header_size;
 371
 372        /* TODO: we could set the MTU depending on the max_sdu_size */
 373
 374        IRDA_DEBUG(0, "%s: We are now connected!\n", __func__);
 375        del_timer(&self->watchdog_timer);
 376
 377        /*
 378         * Data channel is open, so we are now allowed to configure the remote
 379         * filter
 380         */
 381        irlan_get_unicast_addr(self);
 382        irlan_open_unicast_addr(self);
 383
 384        /* Open broadcast and multicast filter by default */
 385        irlan_set_broadcast_filter(self, TRUE);
 386        irlan_set_multicast_filter(self, TRUE);
 387
 388        /* Ready to transfer Ethernet frames */
 389        netif_start_queue(self->dev);
 390        self->disconnect_reason = 0; /* Clear reason */
 391        wake_up_interruptible(&self->open_wait);
 392}
 393
 394/*
 395 * Function irlan_client_disconnect_indication (handle)
 396 *
 397 *    Callback function for the IrTTP layer. Indicates a disconnection of
 398 *    the specified connection (handle)
 399 */
 400static void irlan_disconnect_indication(void *instance,
 401                                        void *sap, LM_REASON reason,
 402                                        struct sk_buff *userdata)
 403{
 404        struct irlan_cb *self;
 405        struct tsap_cb *tsap;
 406
 407        IRDA_DEBUG(0, "%s(), reason=%d\n", __func__ , reason);
 408
 409        self = (struct irlan_cb *) instance;
 410        tsap = (struct tsap_cb *) sap;
 411
 412        IRDA_ASSERT(self != NULL, return;);
 413        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 414        IRDA_ASSERT(tsap != NULL, return;);
 415        IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
 416
 417        IRDA_ASSERT(tsap == self->tsap_data, return;);
 418
 419        IRDA_DEBUG(2, "IrLAN, data channel disconnected by peer!\n");
 420
 421        /* Save reason so we know if we should try to reconnect or not */
 422        self->disconnect_reason = reason;
 423
 424        switch (reason) {
 425        case LM_USER_REQUEST: /* User request */
 426                IRDA_DEBUG(2, "%s(), User requested\n", __func__ );
 427                break;
 428        case LM_LAP_DISCONNECT: /* Unexpected IrLAP disconnect */
 429                IRDA_DEBUG(2, "%s(), Unexpected IrLAP disconnect\n", __func__ );
 430                break;
 431        case LM_CONNECT_FAILURE: /* Failed to establish IrLAP connection */
 432                IRDA_DEBUG(2, "%s(), IrLAP connect failed\n", __func__ );
 433                break;
 434        case LM_LAP_RESET:  /* IrLAP reset */
 435                IRDA_DEBUG(2, "%s(), IrLAP reset\n", __func__ );
 436                break;
 437        case LM_INIT_DISCONNECT:
 438                IRDA_DEBUG(2, "%s(), IrLMP connect failed\n", __func__ );
 439                break;
 440        default:
 441                IRDA_ERROR("%s(), Unknown disconnect reason\n", __func__);
 442                break;
 443        }
 444
 445        /* If you want to pass the skb to *both* state machines, you will
 446         * need to skb_clone() it, so that you don't free it twice.
 447         * As the state machines don't need it, git rid of it here...
 448         * Jean II */
 449        if (userdata)
 450                dev_kfree_skb(userdata);
 451
 452        irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
 453        irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
 454
 455        wake_up_interruptible(&self->open_wait);
 456}
 457
 458void irlan_open_data_tsap(struct irlan_cb *self)
 459{
 460        struct tsap_cb *tsap;
 461        notify_t notify;
 462
 463        IRDA_DEBUG(2, "%s()\n", __func__ );
 464
 465        IRDA_ASSERT(self != NULL, return;);
 466        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 467
 468        /* Check if already open */
 469        if (self->tsap_data)
 470                return;
 471
 472        irda_notify_init(&notify);
 473
 474        notify.data_indication       = irlan_eth_receive;
 475        notify.udata_indication      = irlan_eth_receive;
 476        notify.connect_indication    = irlan_connect_indication;
 477        notify.connect_confirm       = irlan_connect_confirm;
 478        notify.flow_indication       = irlan_eth_flow_indication;
 479        notify.disconnect_indication = irlan_disconnect_indication;
 480        notify.instance              = self;
 481        strlcpy(notify.name, "IrLAN data", sizeof(notify.name));
 482
 483        tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, &notify);
 484        if (!tsap) {
 485                IRDA_DEBUG(2, "%s(), Got no tsap!\n", __func__ );
 486                return;
 487        }
 488        self->tsap_data = tsap;
 489
 490        /*
 491         *  This is the data TSAP selector which we will pass to the client
 492         *  when the client ask for it.
 493         */
 494        self->stsap_sel_data = self->tsap_data->stsap_sel;
 495}
 496
 497void irlan_close_tsaps(struct irlan_cb *self)
 498{
 499        IRDA_DEBUG(4, "%s()\n", __func__ );
 500
 501        IRDA_ASSERT(self != NULL, return;);
 502        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 503
 504        /* Disconnect and close all open TSAP connections */
 505        if (self->tsap_data) {
 506                irttp_disconnect_request(self->tsap_data, NULL, P_NORMAL);
 507                irttp_close_tsap(self->tsap_data);
 508                self->tsap_data = NULL;
 509        }
 510        if (self->client.tsap_ctrl) {
 511                irttp_disconnect_request(self->client.tsap_ctrl, NULL,
 512                                         P_NORMAL);
 513                irttp_close_tsap(self->client.tsap_ctrl);
 514                self->client.tsap_ctrl = NULL;
 515        }
 516        if (self->provider.tsap_ctrl) {
 517                irttp_disconnect_request(self->provider.tsap_ctrl, NULL,
 518                                         P_NORMAL);
 519                irttp_close_tsap(self->provider.tsap_ctrl);
 520                self->provider.tsap_ctrl = NULL;
 521        }
 522        self->disconnect_reason = LM_USER_REQUEST;
 523}
 524
 525/*
 526 * Function irlan_ias_register (self, tsap_sel)
 527 *
 528 *    Register with LM-IAS
 529 *
 530 */
 531void irlan_ias_register(struct irlan_cb *self, __u8 tsap_sel)
 532{
 533        struct ias_object *obj;
 534        struct ias_value *new_value;
 535
 536        IRDA_ASSERT(self != NULL, return;);
 537        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 538
 539        /*
 540         * Check if object has already been registered by a previous provider.
 541         * If that is the case, we just change the value of the attribute
 542         */
 543        if (!irias_find_object("IrLAN")) {
 544                obj = irias_new_object("IrLAN", IAS_IRLAN_ID);
 545                irias_add_integer_attrib(obj, "IrDA:TinyTP:LsapSel", tsap_sel,
 546                                         IAS_KERNEL_ATTR);
 547                irias_insert_object(obj);
 548        } else {
 549                new_value = irias_new_integer_value(tsap_sel);
 550                irias_object_change_attribute("IrLAN", "IrDA:TinyTP:LsapSel",
 551                                              new_value);
 552        }
 553
 554        /* Register PnP object only if not registered before */
 555        if (!irias_find_object("PnP")) {
 556                obj = irias_new_object("PnP", IAS_PNP_ID);
 557#if 0
 558                irias_add_string_attrib(obj, "Name", sysctl_devname,
 559                                        IAS_KERNEL_ATTR);
 560#else
 561                irias_add_string_attrib(obj, "Name", "Linux", IAS_KERNEL_ATTR);
 562#endif
 563                irias_add_string_attrib(obj, "DeviceID", "HWP19F0",
 564                                        IAS_KERNEL_ATTR);
 565                irias_add_integer_attrib(obj, "CompCnt", 1, IAS_KERNEL_ATTR);
 566                if (self->provider.access_type == ACCESS_PEER)
 567                        irias_add_string_attrib(obj, "Comp#01", "PNP8389",
 568                                                IAS_KERNEL_ATTR);
 569                else
 570                        irias_add_string_attrib(obj, "Comp#01", "PNP8294",
 571                                                IAS_KERNEL_ATTR);
 572
 573                irias_add_string_attrib(obj, "Manufacturer",
 574                                        "Linux-IrDA Project", IAS_KERNEL_ATTR);
 575                irias_insert_object(obj);
 576        }
 577}
 578
 579/*
 580 * Function irlan_run_ctrl_tx_queue (self)
 581 *
 582 *    Try to send the next command in the control transmit queue
 583 *
 584 */
 585int irlan_run_ctrl_tx_queue(struct irlan_cb *self)
 586{
 587        struct sk_buff *skb;
 588
 589        IRDA_DEBUG(2, "%s()\n", __func__ );
 590
 591        if (irda_lock(&self->client.tx_busy) == FALSE)
 592                return -EBUSY;
 593
 594        skb = skb_dequeue(&self->client.txq);
 595        if (!skb) {
 596                self->client.tx_busy = FALSE;
 597                return 0;
 598        }
 599
 600        /* Check that it's really possible to send commands */
 601        if ((self->client.tsap_ctrl == NULL) ||
 602            (self->client.state == IRLAN_IDLE))
 603        {
 604                self->client.tx_busy = FALSE;
 605                dev_kfree_skb(skb);
 606                return -1;
 607        }
 608        IRDA_DEBUG(2, "%s(), sending ...\n", __func__ );
 609
 610        return irttp_data_request(self->client.tsap_ctrl, skb);
 611}
 612
 613/*
 614 * Function irlan_ctrl_data_request (self, skb)
 615 *
 616 *    This function makes sure that commands on the control channel is being
 617 *    sent in a command/response fashion
 618 */
 619static void irlan_ctrl_data_request(struct irlan_cb *self, struct sk_buff *skb)
 620{
 621        IRDA_DEBUG(2, "%s()\n", __func__ );
 622
 623        /* Queue command */
 624        skb_queue_tail(&self->client.txq, skb);
 625
 626        /* Try to send command */
 627        irlan_run_ctrl_tx_queue(self);
 628}
 629
 630/*
 631 * Function irlan_get_provider_info (self)
 632 *
 633 *    Send Get Provider Information command to peer IrLAN layer
 634 *
 635 */
 636void irlan_get_provider_info(struct irlan_cb *self)
 637{
 638        struct sk_buff *skb;
 639        __u8 *frame;
 640
 641        IRDA_DEBUG(4, "%s()\n", __func__ );
 642
 643        IRDA_ASSERT(self != NULL, return;);
 644        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 645
 646        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER,
 647                        GFP_ATOMIC);
 648        if (!skb)
 649                return;
 650
 651        /* Reserve space for TTP, LMP, and LAP header */
 652        skb_reserve(skb, self->client.max_header_size);
 653        skb_put(skb, 2);
 654
 655        frame = skb->data;
 656
 657        frame[0] = CMD_GET_PROVIDER_INFO;
 658        frame[1] = 0x00;                 /* Zero parameters */
 659
 660        irlan_ctrl_data_request(self, skb);
 661}
 662
 663/*
 664 * Function irlan_open_data_channel (self)
 665 *
 666 *    Send an Open Data Command to provider
 667 *
 668 */
 669void irlan_open_data_channel(struct irlan_cb *self)
 670{
 671        struct sk_buff *skb;
 672        __u8 *frame;
 673
 674        IRDA_DEBUG(4, "%s()\n", __func__ );
 675
 676        IRDA_ASSERT(self != NULL, return;);
 677        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 678
 679        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 680                        IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3") +
 681                        IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "DIRECT"),
 682                        GFP_ATOMIC);
 683        if (!skb)
 684                return;
 685
 686        skb_reserve(skb, self->client.max_header_size);
 687        skb_put(skb, 2);
 688
 689        frame = skb->data;
 690
 691        /* Build frame */
 692        frame[0] = CMD_OPEN_DATA_CHANNEL;
 693        frame[1] = 0x02; /* Two parameters */
 694
 695        irlan_insert_string_param(skb, "MEDIA", "802.3");
 696        irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
 697        /* irlan_insert_string_param(skb, "MODE", "UNRELIABLE"); */
 698
 699/*      self->use_udata = TRUE; */
 700
 701        irlan_ctrl_data_request(self, skb);
 702}
 703
 704void irlan_close_data_channel(struct irlan_cb *self)
 705{
 706        struct sk_buff *skb;
 707        __u8 *frame;
 708
 709        IRDA_DEBUG(4, "%s()\n", __func__ );
 710
 711        IRDA_ASSERT(self != NULL, return;);
 712        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 713
 714        /* Check if the TSAP is still there */
 715        if (self->client.tsap_ctrl == NULL)
 716                return;
 717
 718        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 719                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN"),
 720                        GFP_ATOMIC);
 721        if (!skb)
 722                return;
 723
 724        skb_reserve(skb, self->client.max_header_size);
 725        skb_put(skb, 2);
 726
 727        frame = skb->data;
 728
 729        /* Build frame */
 730        frame[0] = CMD_CLOSE_DATA_CHAN;
 731        frame[1] = 0x01; /* One parameter */
 732
 733        irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
 734
 735        irlan_ctrl_data_request(self, skb);
 736}
 737
 738/*
 739 * Function irlan_open_unicast_addr (self)
 740 *
 741 *    Make IrLAN provider accept ethernet frames addressed to the unicast
 742 *    address.
 743 *
 744 */
 745static void irlan_open_unicast_addr(struct irlan_cb *self)
 746{
 747        struct sk_buff *skb;
 748        __u8 *frame;
 749
 750        IRDA_DEBUG(4, "%s()\n", __func__ );
 751
 752        IRDA_ASSERT(self != NULL, return;);
 753        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 754
 755        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 756                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
 757                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
 758                        IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
 759                        GFP_ATOMIC);
 760        if (!skb)
 761                return;
 762
 763        /* Reserve space for TTP, LMP, and LAP header */
 764        skb_reserve(skb, self->max_header_size);
 765        skb_put(skb, 2);
 766
 767        frame = skb->data;
 768
 769        frame[0] = CMD_FILTER_OPERATION;
 770        frame[1] = 0x03;                 /* Three parameters */
 771        irlan_insert_byte_param(skb, "DATA_CHAN" , self->dtsap_sel_data);
 772        irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
 773        irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
 774
 775        irlan_ctrl_data_request(self, skb);
 776}
 777
 778/*
 779 * Function irlan_set_broadcast_filter (self, status)
 780 *
 781 *    Make IrLAN provider accept ethernet frames addressed to the broadcast
 782 *    address. Be careful with the use of this one, since there may be a lot
 783 *    of broadcast traffic out there. We can still function without this
 784 *    one but then _we_ have to initiate all communication with other
 785 *    hosts, since ARP request for this host will not be answered.
 786 */
 787void irlan_set_broadcast_filter(struct irlan_cb *self, int status)
 788{
 789        struct sk_buff *skb;
 790        __u8 *frame;
 791
 792        IRDA_DEBUG(2, "%s()\n", __func__ );
 793
 794        IRDA_ASSERT(self != NULL, return;);
 795        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 796
 797        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 798                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
 799                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
 800                        /* We may waste one byte here...*/
 801                        IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "FILTER"),
 802                        GFP_ATOMIC);
 803        if (!skb)
 804                return;
 805
 806        /* Reserve space for TTP, LMP, and LAP header */
 807        skb_reserve(skb, self->client.max_header_size);
 808        skb_put(skb, 2);
 809
 810        frame = skb->data;
 811
 812        frame[0] = CMD_FILTER_OPERATION;
 813        frame[1] = 0x03;                 /* Three parameters */
 814        irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
 815        irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
 816        if (status)
 817                irlan_insert_string_param(skb, "FILTER_MODE", "FILTER");
 818        else
 819                irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
 820
 821        irlan_ctrl_data_request(self, skb);
 822}
 823
 824/*
 825 * Function irlan_set_multicast_filter (self, status)
 826 *
 827 *    Make IrLAN provider accept ethernet frames addressed to the multicast
 828 *    address.
 829 *
 830 */
 831void irlan_set_multicast_filter(struct irlan_cb *self, int status)
 832{
 833        struct sk_buff *skb;
 834        __u8 *frame;
 835
 836        IRDA_DEBUG(2, "%s()\n", __func__ );
 837
 838        IRDA_ASSERT(self != NULL, return;);
 839        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 840
 841        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 842                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
 843                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
 844                        /* We may waste one byte here...*/
 845                        IRLAN_STRING_PARAMETER_LEN("FILTER_MODE", "NONE"),
 846                        GFP_ATOMIC);
 847        if (!skb)
 848                return;
 849
 850        /* Reserve space for TTP, LMP, and LAP header */
 851        skb_reserve(skb, self->client.max_header_size);
 852        skb_put(skb, 2);
 853
 854        frame = skb->data;
 855
 856        frame[0] = CMD_FILTER_OPERATION;
 857        frame[1] = 0x03;                 /* Three parameters */
 858        irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
 859        irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
 860        if (status)
 861                irlan_insert_string_param(skb, "FILTER_MODE", "ALL");
 862        else
 863                irlan_insert_string_param(skb, "FILTER_MODE", "NONE");
 864
 865        irlan_ctrl_data_request(self, skb);
 866}
 867
 868/*
 869 * Function irlan_get_unicast_addr (self)
 870 *
 871 *    Retrieves the unicast address from the IrLAN provider. This address
 872 *    will be inserted into the devices structure, so the ethernet layer
 873 *    can construct its packets.
 874 *
 875 */
 876static void irlan_get_unicast_addr(struct irlan_cb *self)
 877{
 878        struct sk_buff *skb;
 879        __u8 *frame;
 880
 881        IRDA_DEBUG(2, "%s()\n", __func__ );
 882
 883        IRDA_ASSERT(self != NULL, return;);
 884        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 885
 886        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 887                        IRLAN_BYTE_PARAMETER_LEN("DATA_CHAN") +
 888                        IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
 889                        IRLAN_STRING_PARAMETER_LEN("FILTER_OPERATION",
 890                                                   "DYNAMIC"),
 891                        GFP_ATOMIC);
 892        if (!skb)
 893                return;
 894
 895        /* Reserve space for TTP, LMP, and LAP header */
 896        skb_reserve(skb, self->client.max_header_size);
 897        skb_put(skb, 2);
 898
 899        frame = skb->data;
 900
 901        frame[0] = CMD_FILTER_OPERATION;
 902        frame[1] = 0x03;                 /* Three parameters */
 903        irlan_insert_byte_param(skb, "DATA_CHAN", self->dtsap_sel_data);
 904        irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
 905        irlan_insert_string_param(skb, "FILTER_OPERATION", "DYNAMIC");
 906
 907        irlan_ctrl_data_request(self, skb);
 908}
 909
 910/*
 911 * Function irlan_get_media_char (self)
 912 *
 913 *
 914 *
 915 */
 916void irlan_get_media_char(struct irlan_cb *self)
 917{
 918        struct sk_buff *skb;
 919        __u8 *frame;
 920
 921        IRDA_DEBUG(4, "%s()\n", __func__ );
 922
 923        IRDA_ASSERT(self != NULL, return;);
 924        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 925
 926        skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
 927                        IRLAN_STRING_PARAMETER_LEN("MEDIA", "802.3"),
 928                        GFP_ATOMIC);
 929
 930        if (!skb)
 931                return;
 932
 933        /* Reserve space for TTP, LMP, and LAP header */
 934        skb_reserve(skb, self->client.max_header_size);
 935        skb_put(skb, 2);
 936
 937        frame = skb->data;
 938
 939        /* Build frame */
 940        frame[0] = CMD_GET_MEDIA_CHAR;
 941        frame[1] = 0x01; /* One parameter */
 942
 943        irlan_insert_string_param(skb, "MEDIA", "802.3");
 944        irlan_ctrl_data_request(self, skb);
 945}
 946
 947/*
 948 * Function insert_byte_param (skb, param, value)
 949 *
 950 *    Insert byte parameter into frame
 951 *
 952 */
 953int irlan_insert_byte_param(struct sk_buff *skb, char *param, __u8 value)
 954{
 955        return __irlan_insert_param(skb, param, IRLAN_BYTE, value, 0, NULL, 0);
 956}
 957
 958int irlan_insert_short_param(struct sk_buff *skb, char *param, __u16 value)
 959{
 960        return __irlan_insert_param(skb, param, IRLAN_SHORT, 0, value, NULL, 0);
 961}
 962
 963/*
 964 * Function insert_string (skb, param, value)
 965 *
 966 *    Insert string parameter into frame
 967 *
 968 */
 969int irlan_insert_string_param(struct sk_buff *skb, char *param, char *string)
 970{
 971        int string_len = strlen(string);
 972
 973        return __irlan_insert_param(skb, param, IRLAN_ARRAY, 0, 0, string,
 974                                    string_len);
 975}
 976
 977/*
 978 * Function insert_array_param(skb, param, value, len_value)
 979 *
 980 *    Insert array parameter into frame
 981 *
 982 */
 983int irlan_insert_array_param(struct sk_buff *skb, char *name, __u8 *array,
 984                             __u16 array_len)
 985{
 986        return __irlan_insert_param(skb, name, IRLAN_ARRAY, 0, 0, array,
 987                                    array_len);
 988}
 989
 990/*
 991 * Function insert_param (skb, param, value, byte)
 992 *
 993 *    Insert parameter at end of buffer, structure of a parameter is:
 994 *
 995 *    -----------------------------------------------------------------------
 996 *    | Name Length[1] | Param Name[1..255] | Val Length[2] | Value[0..1016]|
 997 *    -----------------------------------------------------------------------
 998 */
 999static int __irlan_insert_param(struct sk_buff *skb, char *param, int type,
1000                                __u8 value_byte, __u16 value_short,
1001                                __u8 *value_array, __u16 value_len)
1002{
1003        __u8 *frame;
1004        __u8 param_len;
1005        __le16 tmp_le; /* Temporary value in little endian format */
1006        int n=0;
1007
1008        if (skb == NULL) {
1009                IRDA_DEBUG(2, "%s(), Got NULL skb\n", __func__ );
1010                return 0;
1011        }
1012
1013        param_len = strlen(param);
1014        switch (type) {
1015        case IRLAN_BYTE:
1016                value_len = 1;
1017                break;
1018        case IRLAN_SHORT:
1019                value_len = 2;
1020                break;
1021        case IRLAN_ARRAY:
1022                IRDA_ASSERT(value_array != NULL, return 0;);
1023                IRDA_ASSERT(value_len > 0, return 0;);
1024                break;
1025        default:
1026                IRDA_DEBUG(2, "%s(), Unknown parameter type!\n", __func__ );
1027                return 0;
1028                break;
1029        }
1030
1031        /* Insert at end of sk-buffer */
1032        frame = skb_tail_pointer(skb);
1033
1034        /* Make space for data */
1035        if (skb_tailroom(skb) < (param_len+value_len+3)) {
1036                IRDA_DEBUG(2, "%s(), No more space at end of skb\n", __func__ );
1037                return 0;
1038        }
1039        skb_put(skb, param_len+value_len+3);
1040
1041        /* Insert parameter length */
1042        frame[n++] = param_len;
1043
1044        /* Insert parameter */
1045        memcpy(frame+n, param, param_len); n += param_len;
1046
1047        /* Insert value length (2 byte little endian format, LSB first) */
1048        tmp_le = cpu_to_le16(value_len);
1049        memcpy(frame+n, &tmp_le, 2); n += 2; /* To avoid alignment problems */
1050
1051        /* Insert value */
1052        switch (type) {
1053        case IRLAN_BYTE:
1054                frame[n++] = value_byte;
1055                break;
1056        case IRLAN_SHORT:
1057                tmp_le = cpu_to_le16(value_short);
1058                memcpy(frame+n, &tmp_le, 2); n += 2;
1059                break;
1060        case IRLAN_ARRAY:
1061                memcpy(frame+n, value_array, value_len); n+=value_len;
1062                break;
1063        default:
1064                break;
1065        }
1066        IRDA_ASSERT(n == (param_len+value_len+3), return 0;);
1067
1068        return param_len+value_len+3;
1069}
1070
1071/*
1072 * Function irlan_extract_param (buf, name, value, len)
1073 *
1074 *    Extracts a single parameter name/value pair from buffer and updates
1075 *    the buffer pointer to point to the next name/value pair.
1076 */
1077int irlan_extract_param(__u8 *buf, char *name, char *value, __u16 *len)
1078{
1079        __u8 name_len;
1080        __u16 val_len;
1081        int n=0;
1082
1083        IRDA_DEBUG(4, "%s()\n", __func__ );
1084
1085        /* get length of parameter name (1 byte) */
1086        name_len = buf[n++];
1087
1088        if (name_len > 254) {
1089                IRDA_DEBUG(2, "%s(), name_len > 254\n", __func__ );
1090                return -RSP_INVALID_COMMAND_FORMAT;
1091        }
1092
1093        /* get parameter name */
1094        memcpy(name, buf+n, name_len);
1095        name[name_len] = '\0';
1096        n+=name_len;
1097
1098        /*
1099         *  Get length of parameter value (2 bytes in little endian
1100         *  format)
1101         */
1102        memcpy(&val_len, buf+n, 2); /* To avoid alignment problems */
1103        le16_to_cpus(&val_len); n+=2;
1104
1105        if (val_len > 1016) {
1106                IRDA_DEBUG(2, "%s(), parameter length to long\n", __func__ );
1107                return -RSP_INVALID_COMMAND_FORMAT;
1108        }
1109        *len = val_len;
1110
1111        /* get parameter value */
1112        memcpy(value, buf+n, val_len);
1113        value[val_len] = '\0';
1114        n+=val_len;
1115
1116        IRDA_DEBUG(4, "Parameter: %s ", name);
1117        IRDA_DEBUG(4, "Value: %s\n", value);
1118
1119        return n;
1120}
1121
1122#ifdef CONFIG_PROC_FS
1123
1124/*
1125 * Start of reading /proc entries.
1126 * Return entry at pos,
1127 *      or start_token to indicate print header line
1128 *      or NULL if end of file
1129 */
1130static void *irlan_seq_start(struct seq_file *seq, loff_t *pos)
1131{
1132        rcu_read_lock();
1133        return seq_list_start_head(&irlans, *pos);
1134}
1135
1136/* Return entry after v, and increment pos */
1137static void *irlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1138{
1139        return seq_list_next(v, &irlans, pos);
1140}
1141
1142/* End of reading /proc file */
1143static void irlan_seq_stop(struct seq_file *seq, void *v)
1144{
1145        rcu_read_unlock();
1146}
1147
1148
1149/*
1150 * Show one entry in /proc file.
1151 */
1152static int irlan_seq_show(struct seq_file *seq, void *v)
1153{
1154        if (v == &irlans)
1155                seq_puts(seq, "IrLAN instances:\n");
1156        else {
1157                struct irlan_cb *self = list_entry(v, struct irlan_cb, dev_list);
1158
1159                IRDA_ASSERT(self != NULL, return -1;);
1160                IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
1161
1162                seq_printf(seq,"ifname: %s,\n",
1163                               self->dev->name);
1164                seq_printf(seq,"client state: %s, ",
1165                               irlan_state[ self->client.state]);
1166                seq_printf(seq,"provider state: %s,\n",
1167                               irlan_state[ self->provider.state]);
1168                seq_printf(seq,"saddr: %#08x, ",
1169                               self->saddr);
1170                seq_printf(seq,"daddr: %#08x\n",
1171                               self->daddr);
1172                seq_printf(seq,"version: %d.%d,\n",
1173                               self->version[1], self->version[0]);
1174                seq_printf(seq,"access type: %s\n",
1175                               irlan_access[self->client.access_type]);
1176                seq_printf(seq,"media: %s\n",
1177                               irlan_media[self->media]);
1178
1179                seq_printf(seq,"local filter:\n");
1180                seq_printf(seq,"remote filter: ");
1181                irlan_print_filter(seq, self->client.filter_type);
1182                seq_printf(seq,"tx busy: %s\n",
1183                               netif_queue_stopped(self->dev) ? "TRUE" : "FALSE");
1184
1185                seq_putc(seq,'\n');
1186        }
1187        return 0;
1188}
1189
1190static const struct seq_operations irlan_seq_ops = {
1191        .start = irlan_seq_start,
1192        .next  = irlan_seq_next,
1193        .stop  = irlan_seq_stop,
1194        .show  = irlan_seq_show,
1195};
1196
1197static int irlan_seq_open(struct inode *inode, struct file *file)
1198{
1199        return seq_open(file, &irlan_seq_ops);
1200}
1201#endif
1202
1203MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1204MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
1205MODULE_LICENSE("GPL");
1206
1207module_param(eth, bool, 0);
1208MODULE_PARM_DESC(eth, "Name devices ethX (0) or irlanX (1)");
1209module_param(access, int, 0);
1210MODULE_PARM_DESC(access, "Access type DIRECT=1, PEER=2, HOSTED=3");
1211
1212module_init(irlan_init);
1213module_exit(irlan_cleanup);
1214
1215
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.