net/irda/irlan/irlan_common.c

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