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/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  */
  64 static LIST_HEAD(irlans);
  65
  66 static void *ckey;
  67 static void *skey;
  68
  69 /* Module parameters */
  70 static int eth;   /* Use "eth" or "irlan" name for devices */
  71 static int access = ACCESS_PEER; /* PEER, DIRECT or HOSTED */
  72
  73 #ifdef CONFIG_PROC_FS
  74 static const char *const irlan_access[] = {
  75         "UNKNOWN",
  76         "DIRECT",
  77         "PEER",
  78         "HOSTED"
  79 };
  80
  81 static const char *const irlan_media[] = {
  82         "UNKNOWN",
  83         "802.3",
  84         "802.5"
  85 };
  86
  87 extern struct proc_dir_entry *proc_irda;
  88
  89 static int irlan_seq_open(struct inode *inode, struct file *file);
  90
  91 static 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
  99 extern struct proc_dir_entry *proc_irda;
 100 #endif /* CONFIG_PROC_FS */
 101
 102 static struct irlan_cb *irlan_open(__u32 saddr, __u32 daddr);
 103 static void __irlan_close(struct irlan_cb *self);
 104 static 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);
 107 static void irlan_open_unicast_addr(struct irlan_cb *self);
 108 static void irlan_get_unicast_addr(struct irlan_cb *self);
 109 void irlan_close_tsaps(struct irlan_cb *self);
 110
 111 /*
 112  * Function irlan_init (void)
 113  *
 114  *    Initialize IrLAN layer
 115  *
 116  */
 117 static 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
 161 err_open:
 162         irlmp_unregister_service(skey);
 163 err_skey:
 164         irlmp_unregister_client(ckey);
 165 err_ckey:
 166 #ifdef CONFIG_PROC_FS
 167         remove_proc_entry("irlan", proc_irda);
 168 #endif /* CONFIG_PROC_FS */
 169
 170         return -ENOMEM;
 171 }
 172
 173 static 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  */
 200 static 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  */
 268 static 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 */
 293 struct 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  */
 309 static 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 = instance;
 321         tsap = 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
 356 static 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 = 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  */
 400 static 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 = instance;
 410         tsap = 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
 458 void 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
 497 void 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  */
 531 void 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  */
 585 int 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  */
 619 static 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  */
 636 void 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  */
 669 void 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
 704 void 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  */
 745 static 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  */
 787 void 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  */
 831 void 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  */
 876 static 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  */
 916 void 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  */
 953 int 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
 958 int 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  */
 969 int 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  */
 983 int 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  */
 999 static 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  */
1077 int 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  */
1130 static 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 */
1137 static 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 */
1143 static 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  */
1152 static 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
1190 static 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
1197 static int irlan_seq_open(struct inode *inode, struct file *file)
1198 {
1199         return seq_open(file, &irlan_seq_ops);
1200 }
1201 #endif
1202
1203 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1204 MODULE_DESCRIPTION("The Linux IrDA LAN protocol");
1205 MODULE_LICENSE("GPL");
1206
1207 module_param(eth, bool, 0);
1208 MODULE_PARM_DESC(eth, "Name devices ethX (0) or irlanX (1)");
1209 module_param(access, int, 0);
1210 MODULE_PARM_DESC(access, "Access type DIRECT=1, PEER=2, HOSTED=3");
1211
1212 module_init(irlan_init);
1213 module_exit(irlan_cleanup);
1214