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