net/irda/irlmp.c

   1 /*********************************************************************
   2  *
   3  * Filename:      irlmp.c
   4  * Version:       1.0
   5  * Description:   IrDA Link Management Protocol (LMP) layer
   6  * Status:        Stable.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Sun Aug 17 20:54:32 1997
   9  * Modified at:   Wed Jan  5 11:26:03 2000
  10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11  *
  12  *     Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
  13  *     All Rights Reserved.
  14  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
  15  *
  16  *     This program is free software; you can redistribute it and/or
  17  *     modify it under the terms of the GNU General Public License as
  18  *     published by the Free Software Foundation; either version 2 of
  19  *     the License, or (at your option) any later version.
  20  *
  21  *     Neither Dag Brattli nor University of Tromsø admit liability nor
  22  *     provide warranty for any of this software. This material is
  23  *     provided "AS-IS" and at no charge.
  24  *
  25  ********************************************************************/
  26
  27 #include <linux/module.h>
  28 #include <linux/slab.h>
  29 #include <linux/string.h>
  30 #include <linux/skbuff.h>
  31 #include <linux/types.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/init.h>
  34 #include <linux/kmod.h>
  35 #include <linux/random.h>
  36 #include <linux/seq_file.h>
  37
  38 #include <net/irda/irda.h>
  39 #include <net/irda/timer.h>
  40 #include <net/irda/qos.h>
  41 #include <net/irda/irlap.h>
  42 #include <net/irda/iriap.h>
  43 #include <net/irda/irlmp.h>
  44 #include <net/irda/irlmp_frame.h>
  45
  46 #include <asm/unaligned.h>
  47
  48 static __u8 irlmp_find_free_slsap(void);
  49 static int irlmp_slsap_inuse(__u8 slsap_sel);
  50
  51 /* Master structure */
  52 struct irlmp_cb *irlmp = NULL;
  53
  54 /* These can be altered by the sysctl interface */
  55 int  sysctl_discovery         = 0;
  56 int  sysctl_discovery_timeout = 3; /* 3 seconds by default */
  57 int  sysctl_discovery_slots   = 6; /* 6 slots by default */
  58 int  sysctl_lap_keepalive_time = LM_IDLE_TIMEOUT * 1000 / HZ;
  59 char sysctl_devname[65];
  60
  61 static const char *irlmp_reasons[] = {
  62         "ERROR, NOT USED",
  63         "LM_USER_REQUEST",
  64         "LM_LAP_DISCONNECT",
  65         "LM_CONNECT_FAILURE",
  66         "LM_LAP_RESET",
  67         "LM_INIT_DISCONNECT",
  68         "ERROR, NOT USED",
  69         "UNKNOWN",
  70 };
  71
  72 const char *irlmp_reason_str(LM_REASON reason)
  73 {
  74         reason = min_t(size_t, reason, ARRAY_SIZE(irlmp_reasons) - 1);
  75         return irlmp_reasons[reason];
  76 }
  77
  78 /*
  79  * Function irlmp_init (void)
  80  *
  81  *    Create (allocate) the main IrLMP structure
  82  *
  83  */
  84 int __init irlmp_init(void)
  85 {
  86         /* Initialize the irlmp structure. */
  87         irlmp = kzalloc( sizeof(struct irlmp_cb), GFP_KERNEL);
  88         if (irlmp == NULL)
  89                 return -ENOMEM;
  90
  91         irlmp->magic = LMP_MAGIC;
  92
  93         irlmp->clients = hashbin_new(HB_LOCK);
  94         irlmp->services = hashbin_new(HB_LOCK);
  95         irlmp->links = hashbin_new(HB_LOCK);
  96         irlmp->unconnected_lsaps = hashbin_new(HB_LOCK);
  97         irlmp->cachelog = hashbin_new(HB_NOLOCK);
  98
  99         if ((irlmp->clients == NULL) ||
 100             (irlmp->services == NULL) ||
 101             (irlmp->links == NULL) ||
 102             (irlmp->unconnected_lsaps == NULL) ||
 103             (irlmp->cachelog == NULL)) {
 104                 return -ENOMEM;
 105         }
 106
 107         spin_lock_init(&irlmp->cachelog->hb_spinlock);
 108
 109         irlmp->last_lsap_sel = 0x0f; /* Reserved 0x00-0x0f */
 110         strcpy(sysctl_devname, "Linux");
 111
 112         init_timer(&irlmp->discovery_timer);
 113
 114         /* Do discovery every 3 seconds, conditionally */
 115         if (sysctl_discovery)
 116                 irlmp_start_discovery_timer(irlmp,
 117                                             sysctl_discovery_timeout*HZ);
 118
 119         return 0;
 120 }
 121
 122 /*
 123  * Function irlmp_cleanup (void)
 124  *
 125  *    Remove IrLMP layer
 126  *
 127  */
 128 void irlmp_cleanup(void)
 129 {
 130         /* Check for main structure */
 131         IRDA_ASSERT(irlmp != NULL, return;);
 132         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
 133
 134         del_timer(&irlmp->discovery_timer);
 135
 136         hashbin_delete(irlmp->links, (FREE_FUNC) kfree);
 137         hashbin_delete(irlmp->unconnected_lsaps, (FREE_FUNC) kfree);
 138         hashbin_delete(irlmp->clients, (FREE_FUNC) kfree);
 139         hashbin_delete(irlmp->services, (FREE_FUNC) kfree);
 140         hashbin_delete(irlmp->cachelog, (FREE_FUNC) kfree);
 141
 142         /* De-allocate main structure */
 143         kfree(irlmp);
 144         irlmp = NULL;
 145 }
 146
 147 /*
 148  * Function irlmp_open_lsap (slsap, notify)
 149  *
 150  *   Register with IrLMP and create a local LSAP,
 151  *   returns handle to LSAP.
 152  */
 153 struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, notify_t *notify, __u8 pid)
 154 {
 155         struct lsap_cb *self;
 156
 157         IRDA_ASSERT(notify != NULL, return NULL;);
 158         IRDA_ASSERT(irlmp != NULL, return NULL;);
 159         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
 160         IRDA_ASSERT(notify->instance != NULL, return NULL;);
 161
 162         /*  Does the client care which Source LSAP selector it gets?  */
 163         if (slsap_sel == LSAP_ANY) {
 164                 slsap_sel = irlmp_find_free_slsap();
 165                 if (!slsap_sel)
 166                         return NULL;
 167         } else if (irlmp_slsap_inuse(slsap_sel))
 168                 return NULL;
 169
 170         /* Allocate new instance of a LSAP connection */
 171         self = kzalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
 172         if (self == NULL)
 173                 return NULL;
 174
 175         self->magic = LMP_LSAP_MAGIC;
 176         self->slsap_sel = slsap_sel;
 177
 178         /* Fix connectionless LSAP's */
 179         if (slsap_sel == LSAP_CONNLESS) {
 180 #ifdef CONFIG_IRDA_ULTRA
 181                 self->dlsap_sel = LSAP_CONNLESS;
 182                 self->pid = pid;
 183 #endif /* CONFIG_IRDA_ULTRA */
 184         } else
 185                 self->dlsap_sel = LSAP_ANY;
 186         /* self->connected = FALSE; -> already NULL via memset() */
 187
 188         init_timer(&self->watchdog_timer);
 189
 190         self->notify = *notify;
 191
 192         self->lsap_state = LSAP_DISCONNECTED;
 193
 194         /* Insert into queue of unconnected LSAPs */
 195         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self,
 196                        (long) self, NULL);
 197
 198         return self;
 199 }
 200 EXPORT_SYMBOL(irlmp_open_lsap);
 201
 202 /*
 203  * Function __irlmp_close_lsap (self)
 204  *
 205  *    Remove an instance of LSAP
 206  */
 207 static void __irlmp_close_lsap(struct lsap_cb *self)
 208 {
 209         IRDA_ASSERT(self != NULL, return;);
 210         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 211
 212         /*
 213          *  Set some of the variables to preset values
 214          */
 215         self->magic = 0;
 216         del_timer(&self->watchdog_timer); /* Important! */
 217
 218         if (self->conn_skb)
 219                 dev_kfree_skb(self->conn_skb);
 220
 221         kfree(self);
 222 }
 223
 224 /*
 225  * Function irlmp_close_lsap (self)
 226  *
 227  *    Close and remove LSAP
 228  *
 229  */
 230 void irlmp_close_lsap(struct lsap_cb *self)
 231 {
 232         struct lap_cb *lap;
 233         struct lsap_cb *lsap = NULL;
 234
 235         IRDA_ASSERT(self != NULL, return;);
 236         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 237
 238         /*
 239          *  Find out if we should remove this LSAP from a link or from the
 240          *  list of unconnected lsaps (not associated with a link)
 241          */
 242         lap = self->lap;
 243         if (lap) {
 244                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 245                 /* We might close a LSAP before it has completed the
 246                  * connection setup. In those case, higher layers won't
 247                  * send a proper disconnect request. Harmless, except
 248                  * that we will forget to close LAP... - Jean II */
 249                 if(self->lsap_state != LSAP_DISCONNECTED) {
 250                         self->lsap_state = LSAP_DISCONNECTED;
 251                         irlmp_do_lap_event(self->lap,
 252                                            LM_LAP_DISCONNECT_REQUEST, NULL);
 253                 }
 254                 /* Now, remove from the link */
 255                 lsap = hashbin_remove(lap->lsaps, (long) self, NULL);
 256 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 257                 lap->cache.valid = FALSE;
 258 #endif
 259         }
 260         self->lap = NULL;
 261         /* Check if we found the LSAP! If not then try the unconnected lsaps */
 262         if (!lsap) {
 263                 lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self,
 264                                       NULL);
 265         }
 266         if (!lsap) {
 267                 pr_debug("%s(), Looks like somebody has removed me already!\n",
 268                          __func__);
 269                 return;
 270         }
 271         __irlmp_close_lsap(self);
 272 }
 273 EXPORT_SYMBOL(irlmp_close_lsap);
 274
 275 /*
 276  * Function irlmp_register_irlap (saddr, notify)
 277  *
 278  *    Register IrLAP layer with IrLMP. There is possible to have multiple
 279  *    instances of the IrLAP layer, each connected to different IrDA ports
 280  *
 281  */
 282 void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
 283 {
 284         struct lap_cb *lap;
 285
 286         IRDA_ASSERT(irlmp != NULL, return;);
 287         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return;);
 288         IRDA_ASSERT(notify != NULL, return;);
 289
 290         /*
 291          *  Allocate new instance of a LSAP connection
 292          */
 293         lap = kzalloc(sizeof(struct lap_cb), GFP_KERNEL);
 294         if (lap == NULL)
 295                 return;
 296
 297         lap->irlap = irlap;
 298         lap->magic = LMP_LAP_MAGIC;
 299         lap->saddr = saddr;
 300         lap->daddr = DEV_ADDR_ANY;
 301 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 302         lap->cache.valid = FALSE;
 303 #endif
 304         lap->lsaps = hashbin_new(HB_LOCK);
 305         if (lap->lsaps == NULL) {
 306                 net_warn_ratelimited("%s(), unable to kmalloc lsaps\n",
 307                                      __func__);
 308                 kfree(lap);
 309                 return;
 310         }
 311
 312         lap->lap_state = LAP_STANDBY;
 313
 314         init_timer(&lap->idle_timer);
 315
 316         /*
 317          *  Insert into queue of LMP links
 318          */
 319         hashbin_insert(irlmp->links, (irda_queue_t *) lap, lap->saddr, NULL);
 320
 321         /*
 322          *  We set only this variable so IrLAP can tell us on which link the
 323          *  different events happened on
 324          */
 325         irda_notify_init(notify);
 326         notify->instance = lap;
 327 }
 328
 329 /*
 330  * Function irlmp_unregister_irlap (saddr)
 331  *
 332  *    IrLAP layer has been removed!
 333  *
 334  */
 335 void irlmp_unregister_link(__u32 saddr)
 336 {
 337         struct lap_cb *link;
 338
 339         /* We must remove ourselves from the hashbin *first*. This ensure
 340          * that no more LSAPs will be open on this link and no discovery
 341          * will be triggered anymore. Jean II */
 342         link = hashbin_remove(irlmp->links, saddr, NULL);
 343         if (link) {
 344                 IRDA_ASSERT(link->magic == LMP_LAP_MAGIC, return;);
 345
 346                 /* Kill all the LSAPs on this link. Jean II */
 347                 link->reason = LAP_DISC_INDICATION;
 348                 link->daddr = DEV_ADDR_ANY;
 349                 irlmp_do_lap_event(link, LM_LAP_DISCONNECT_INDICATION, NULL);
 350
 351                 /* Remove all discoveries discovered at this link */
 352                 irlmp_expire_discoveries(irlmp->cachelog, link->saddr, TRUE);
 353
 354                 /* Final cleanup */
 355                 del_timer(&link->idle_timer);
 356                 link->magic = 0;
 357                 hashbin_delete(link->lsaps, (FREE_FUNC) __irlmp_close_lsap);
 358                 kfree(link);
 359         }
 360 }
 361
 362 /*
 363  * Function irlmp_connect_request (handle, dlsap, userdata)
 364  *
 365  *    Connect with a peer LSAP
 366  *
 367  */
 368 int irlmp_connect_request(struct lsap_cb *self, __u8 dlsap_sel,
 369                           __u32 saddr, __u32 daddr,
 370                           struct qos_info *qos, struct sk_buff *userdata)
 371 {
 372         struct sk_buff *tx_skb = userdata;
 373         struct lap_cb *lap;
 374         struct lsap_cb *lsap;
 375         int ret;
 376
 377         IRDA_ASSERT(self != NULL, return -EBADR;);
 378         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
 379
 380         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
 381                  __func__, self->slsap_sel, dlsap_sel, saddr, daddr);
 382
 383         if (test_bit(0, &self->connected)) {
 384                 ret = -EISCONN;
 385                 goto err;
 386         }
 387
 388         /* Client must supply destination device address */
 389         if (!daddr) {
 390                 ret = -EINVAL;
 391                 goto err;
 392         }
 393
 394         /* Any userdata? */
 395         if (tx_skb == NULL) {
 396                 tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
 397                 if (!tx_skb)
 398                         return -ENOMEM;
 399
 400                 skb_reserve(tx_skb, LMP_MAX_HEADER);
 401         }
 402
 403         /* Make room for MUX control header (3 bytes) */
 404         IRDA_ASSERT(skb_headroom(tx_skb) >= LMP_CONTROL_HEADER, return -1;);
 405         skb_push(tx_skb, LMP_CONTROL_HEADER);
 406
 407         self->dlsap_sel = dlsap_sel;
 408
 409         /*
 410          * Find the link to where we should try to connect since there may
 411          * be more than one IrDA port on this machine. If the client has
 412          * passed us the saddr (and already knows which link to use), then
 413          * we use that to find the link, if not then we have to look in the
 414          * discovery log and check if any of the links has discovered a
 415          * device with the given daddr
 416          */
 417         if ((!saddr) || (saddr == DEV_ADDR_ANY)) {
 418                 discovery_t *discovery;
 419                 unsigned long flags;
 420
 421                 spin_lock_irqsave(&irlmp->cachelog->hb_spinlock, flags);
 422                 if (daddr != DEV_ADDR_ANY)
 423                         discovery = hashbin_find(irlmp->cachelog, daddr, NULL);
 424                 else {
 425                         pr_debug("%s(), no daddr\n", __func__);
 426                         discovery = (discovery_t *)
 427                                 hashbin_get_first(irlmp->cachelog);
 428                 }
 429
 430                 if (discovery) {
 431                         saddr = discovery->data.saddr;
 432                         daddr = discovery->data.daddr;
 433                 }
 434                 spin_unlock_irqrestore(&irlmp->cachelog->hb_spinlock, flags);
 435         }
 436         lap = hashbin_lock_find(irlmp->links, saddr, NULL);
 437         if (lap == NULL) {
 438                 pr_debug("%s(), Unable to find a usable link!\n", __func__);
 439                 ret = -EHOSTUNREACH;
 440                 goto err;
 441         }
 442
 443         /* Check if LAP is disconnected or already connected */
 444         if (lap->daddr == DEV_ADDR_ANY)
 445                 lap->daddr = daddr;
 446         else if (lap->daddr != daddr) {
 447                 /* Check if some LSAPs are active on this LAP */
 448                 if (HASHBIN_GET_SIZE(lap->lsaps) == 0) {
 449                         /* No active connection, but LAP hasn't been
 450                          * disconnected yet (waiting for timeout in LAP).
 451                          * Maybe we could give LAP a bit of help in this case.
 452                          */
 453                         pr_debug("%s(), sorry, but I'm waiting for LAP to timeout!\n",
 454                                  __func__);
 455                         ret = -EAGAIN;
 456                         goto err;
 457                 }
 458
 459                 /* LAP is already connected to a different node, and LAP
 460                  * can only talk to one node at a time */
 461                 pr_debug("%s(), sorry, but link is busy!\n", __func__);
 462                 ret = -EBUSY;
 463                 goto err;
 464         }
 465
 466         self->lap = lap;
 467
 468         /*
 469          *  Remove LSAP from list of unconnected LSAPs and insert it into the
 470          *  list of connected LSAPs for the particular link
 471          */
 472         lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, NULL);
 473
 474         IRDA_ASSERT(lsap != NULL, return -1;);
 475         IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
 476         IRDA_ASSERT(lsap->lap != NULL, return -1;);
 477         IRDA_ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
 478
 479         hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, (long) self,
 480                        NULL);
 481
 482         set_bit(0, &self->connected);   /* TRUE */
 483
 484         /*
 485          *  User supplied qos specifications?
 486          */
 487         if (qos)
 488                 self->qos = *qos;
 489
 490         irlmp_do_lsap_event(self, LM_CONNECT_REQUEST, tx_skb);
 491
 492         /* Drop reference count - see irlap_data_request(). */
 493         dev_kfree_skb(tx_skb);
 494
 495         return 0;
 496
 497 err:
 498         /* Cleanup */
 499         if(tx_skb)
 500                 dev_kfree_skb(tx_skb);
 501         return ret;
 502 }
 503 EXPORT_SYMBOL(irlmp_connect_request);
 504
 505 /*
 506  * Function irlmp_connect_indication (self)
 507  *
 508  *    Incoming connection
 509  *
 510  */
 511 void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
 512 {
 513         int max_seg_size;
 514         int lap_header_size;
 515         int max_header_size;
 516
 517         IRDA_ASSERT(self != NULL, return;);
 518         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 519         IRDA_ASSERT(skb != NULL, return;);
 520         IRDA_ASSERT(self->lap != NULL, return;);
 521
 522         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
 523                  __func__, self->slsap_sel, self->dlsap_sel);
 524
 525         /* Note : self->lap is set in irlmp_link_data_indication(),
 526          * (case CONNECT_CMD:) because we have no way to set it here.
 527          * Similarly, self->dlsap_sel is usually set in irlmp_find_lsap().
 528          * Jean II */
 529
 530         self->qos = *self->lap->qos;
 531
 532         max_seg_size = self->lap->qos->data_size.value-LMP_HEADER;
 533         lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
 534         max_header_size = LMP_HEADER + lap_header_size;
 535
 536         /* Hide LMP_CONTROL_HEADER header from layer above */
 537         skb_pull(skb, LMP_CONTROL_HEADER);
 538
 539         if (self->notify.connect_indication) {
 540                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
 541                 skb_get(skb);
 542                 self->notify.connect_indication(self->notify.instance, self,
 543                                                 &self->qos, max_seg_size,
 544                                                 max_header_size, skb);
 545         }
 546 }
 547
 548 /*
 549  * Function irlmp_connect_response (handle, userdata)
 550  *
 551  *    Service user is accepting connection
 552  *
 553  */
 554 int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
 555 {
 556         IRDA_ASSERT(self != NULL, return -1;);
 557         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 558         IRDA_ASSERT(userdata != NULL, return -1;);
 559
 560         /* We set the connected bit and move the lsap to the connected list
 561          * in the state machine itself. Jean II */
 562
 563         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
 564                  __func__, self->slsap_sel, self->dlsap_sel);
 565
 566         /* Make room for MUX control header (3 bytes) */
 567         IRDA_ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return -1;);
 568         skb_push(userdata, LMP_CONTROL_HEADER);
 569
 570         irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata);
 571
 572         /* Drop reference count - see irlap_data_request(). */
 573         dev_kfree_skb(userdata);
 574
 575         return 0;
 576 }
 577 EXPORT_SYMBOL(irlmp_connect_response);
 578
 579 /*
 580  * Function irlmp_connect_confirm (handle, skb)
 581  *
 582  *    LSAP connection confirmed peer device!
 583  */
 584 void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
 585 {
 586         int max_header_size;
 587         int lap_header_size;
 588         int max_seg_size;
 589
 590         IRDA_ASSERT(skb != NULL, return;);
 591         IRDA_ASSERT(self != NULL, return;);
 592         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 593         IRDA_ASSERT(self->lap != NULL, return;);
 594
 595         self->qos = *self->lap->qos;
 596
 597         max_seg_size    = self->lap->qos->data_size.value-LMP_HEADER;
 598         lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
 599         max_header_size = LMP_HEADER + lap_header_size;
 600
 601         pr_debug("%s(), max_header_size=%d\n",
 602                  __func__, max_header_size);
 603
 604         /* Hide LMP_CONTROL_HEADER header from layer above */
 605         skb_pull(skb, LMP_CONTROL_HEADER);
 606
 607         if (self->notify.connect_confirm) {
 608                 /* Don't forget to refcount it - see irlap_driver_rcv() */
 609                 skb_get(skb);
 610                 self->notify.connect_confirm(self->notify.instance, self,
 611                                              &self->qos, max_seg_size,
 612                                              max_header_size, skb);
 613         }
 614 }
 615
 616 /*
 617  * Function irlmp_dup (orig, instance)
 618  *
 619  *    Duplicate LSAP, can be used by servers to confirm a connection on a
 620  *    new LSAP so it can keep listening on the old one.
 621  *
 622  */
 623 struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance)
 624 {
 625         struct lsap_cb *new;
 626         unsigned long flags;
 627
 628         spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
 629
 630         /* Only allowed to duplicate unconnected LSAP's, and only LSAPs
 631          * that have received a connect indication. Jean II */
 632         if ((!hashbin_find(irlmp->unconnected_lsaps, (long) orig, NULL)) ||
 633             (orig->lap == NULL)) {
 634                 pr_debug("%s(), invalid LSAP (wrong state)\n",
 635                          __func__);
 636                 spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock,
 637                                        flags);
 638                 return NULL;
 639         }
 640
 641         /* Allocate a new instance */
 642         new = kmemdup(orig, sizeof(*new), GFP_ATOMIC);
 643         if (!new)  {
 644                 pr_debug("%s(), unable to kmalloc\n", __func__);
 645                 spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock,
 646                                        flags);
 647                 return NULL;
 648         }
 649         /* new->lap = orig->lap; => done in the memcpy() */
 650         /* new->slsap_sel = orig->slsap_sel; => done in the memcpy() */
 651         new->conn_skb = NULL;
 652
 653         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
 654
 655         /* Not everything is the same */
 656         new->notify.instance = instance;
 657
 658         init_timer(&new->watchdog_timer);
 659
 660         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) new,
 661                        (long) new, NULL);
 662
 663 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 664         /* Make sure that we invalidate the LSAP cache */
 665         new->lap->cache.valid = FALSE;
 666 #endif /* CONFIG_IRDA_CACHE_LAST_LSAP */
 667
 668         return new;
 669 }
 670
 671 /*
 672  * Function irlmp_disconnect_request (handle, userdata)
 673  *
 674  *    The service user is requesting disconnection, this will not remove the
 675  *    LSAP, but only mark it as disconnected
 676  */
 677 int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
 678 {
 679         struct lsap_cb *lsap;
 680
 681         IRDA_ASSERT(self != NULL, return -1;);
 682         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
 683         IRDA_ASSERT(userdata != NULL, return -1;);
 684
 685         /* Already disconnected ?
 686          * There is a race condition between irlmp_disconnect_indication()
 687          * and us that might mess up the hashbins below. This fixes it.
 688          * Jean II */
 689         if (! test_and_clear_bit(0, &self->connected)) {
 690                 pr_debug("%s(), already disconnected!\n", __func__);
 691                 dev_kfree_skb(userdata);
 692                 return -1;
 693         }
 694
 695         skb_push(userdata, LMP_CONTROL_HEADER);
 696
 697         /*
 698          *  Do the event before the other stuff since we must know
 699          *  which lap layer that the frame should be transmitted on
 700          */
 701         irlmp_do_lsap_event(self, LM_DISCONNECT_REQUEST, userdata);
 702
 703         /* Drop reference count - see irlap_data_request(). */
 704         dev_kfree_skb(userdata);
 705
 706         /*
 707          *  Remove LSAP from list of connected LSAPs for the particular link
 708          *  and insert it into the list of unconnected LSAPs
 709          */
 710         IRDA_ASSERT(self->lap != NULL, return -1;);
 711         IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
 712         IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);
 713
 714         lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
 715 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 716         self->lap->cache.valid = FALSE;
 717 #endif
 718
 719         IRDA_ASSERT(lsap != NULL, return -1;);
 720         IRDA_ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
 721         IRDA_ASSERT(lsap == self, return -1;);
 722
 723         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) self,
 724                        (long) self, NULL);
 725
 726         /* Reset some values */
 727         self->dlsap_sel = LSAP_ANY;
 728         self->lap = NULL;
 729
 730         return 0;
 731 }
 732 EXPORT_SYMBOL(irlmp_disconnect_request);
 733
 734 /*
 735  * Function irlmp_disconnect_indication (reason, userdata)
 736  *
 737  *    LSAP is being closed!
 738  */
 739 void irlmp_disconnect_indication(struct lsap_cb *self, LM_REASON reason,
 740                                  struct sk_buff *skb)
 741 {
 742         struct lsap_cb *lsap;
 743
 744         pr_debug("%s(), reason=%s [%d]\n", __func__,
 745                  irlmp_reason_str(reason), reason);
 746         IRDA_ASSERT(self != NULL, return;);
 747         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
 748
 749         pr_debug("%s(), slsap_sel=%02x, dlsap_sel=%02x\n",
 750                  __func__, self->slsap_sel, self->dlsap_sel);
 751
 752         /* Already disconnected ?
 753          * There is a race condition between irlmp_disconnect_request()
 754          * and us that might mess up the hashbins below. This fixes it.
 755          * Jean II */
 756         if (! test_and_clear_bit(0, &self->connected)) {
 757                 pr_debug("%s(), already disconnected!\n", __func__);
 758                 return;
 759         }
 760
 761         /*
 762          *  Remove association between this LSAP and the link it used
 763          */
 764         IRDA_ASSERT(self->lap != NULL, return;);
 765         IRDA_ASSERT(self->lap->lsaps != NULL, return;);
 766
 767         lsap = hashbin_remove(self->lap->lsaps, (long) self, NULL);
 768 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
 769         self->lap->cache.valid = FALSE;
 770 #endif
 771
 772         IRDA_ASSERT(lsap != NULL, return;);
 773         IRDA_ASSERT(lsap == self, return;);
 774         hashbin_insert(irlmp->unconnected_lsaps, (irda_queue_t *) lsap,
 775                        (long) lsap, NULL);
 776
 777         self->dlsap_sel = LSAP_ANY;
 778         self->lap = NULL;
 779
 780         /*
 781          *  Inform service user
 782          */
 783         if (self->notify.disconnect_indication) {
 784                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
 785                 if(skb)
 786                         skb_get(skb);
 787                 self->notify.disconnect_indication(self->notify.instance,
 788                                                    self, reason, skb);
 789         } else {
 790                 pr_debug("%s(), no handler\n", __func__);
 791         }
 792 }
 793
 794 /*
 795  * Function irlmp_do_expiry (void)
 796  *
 797  *    Do a cleanup of the discovery log (remove old entries)
 798  *
 799  * Note : separate from irlmp_do_discovery() so that we can handle
 800  * passive discovery properly.
 801  */
 802 void irlmp_do_expiry(void)
 803 {
 804         struct lap_cb *lap;
 805
 806         /*
 807          * Expire discovery on all links which are *not* connected.
 808          * On links which are connected, we can't do discovery
 809          * anymore and can't refresh the log, so we freeze the
 810          * discovery log to keep info about the device we are
 811          * connected to.
 812          * This info is mandatory if we want irlmp_connect_request()
 813          * to work properly. - Jean II
 814          */
 815         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
 816         while (lap != NULL) {
 817                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 818
 819                 if (lap->lap_state == LAP_STANDBY) {
 820                         /* Expire discoveries discovered on this link */
 821                         irlmp_expire_discoveries(irlmp->cachelog, lap->saddr,
 822                                                  FALSE);
 823                 }
 824                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
 825         }
 826 }
 827
 828 /*
 829  * Function irlmp_do_discovery (nslots)
 830  *
 831  *    Do some discovery on all links
 832  *
 833  * Note : log expiry is done above.
 834  */
 835 void irlmp_do_discovery(int nslots)
 836 {
 837         struct lap_cb *lap;
 838         __u16 *data_hintsp;
 839
 840         /* Make sure the value is sane */
 841         if ((nslots != 1) && (nslots != 6) && (nslots != 8) && (nslots != 16)){
 842                 net_warn_ratelimited("%s: invalid value for number of slots!\n",
 843                                      __func__);
 844                 nslots = sysctl_discovery_slots = 8;
 845         }
 846
 847         /* Construct new discovery info to be used by IrLAP, */
 848         data_hintsp = (__u16 *) irlmp->discovery_cmd.data.hints;
 849         put_unaligned(irlmp->hints.word, data_hintsp);
 850
 851         /*
 852          *  Set character set for device name (we use ASCII), and
 853          *  copy device name. Remember to make room for a \0 at the
 854          *  end
 855          */
 856         irlmp->discovery_cmd.data.charset = CS_ASCII;
 857         strncpy(irlmp->discovery_cmd.data.info, sysctl_devname,
 858                 NICKNAME_MAX_LEN);
 859         irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.data.info);
 860         irlmp->discovery_cmd.nslots = nslots;
 861
 862         /*
 863          * Try to send discovery packets on all links
 864          */
 865         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
 866         while (lap != NULL) {
 867                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
 868
 869                 if (lap->lap_state == LAP_STANDBY) {
 870                         /* Try to discover */
 871                         irlmp_do_lap_event(lap, LM_LAP_DISCOVERY_REQUEST,
 872                                            NULL);
 873                 }
 874                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
 875         }
 876 }
 877
 878 /*
 879  * Function irlmp_discovery_request (nslots)
 880  *
 881  *    Do a discovery of devices in front of the computer
 882  *
 883  * If the caller has registered a client discovery callback, this
 884  * allow him to receive the full content of the discovery log through
 885  * this callback (as normally he will receive only new discoveries).
 886  */
 887 void irlmp_discovery_request(int nslots)
 888 {
 889         /* Return current cached discovery log (in full) */
 890         irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_LOG);
 891
 892         /*
 893          * Start a single discovery operation if discovery is not already
 894          * running
 895          */
 896         if (!sysctl_discovery) {
 897                 /* Check if user wants to override the default */
 898                 if (nslots == DISCOVERY_DEFAULT_SLOTS)
 899                         nslots = sysctl_discovery_slots;
 900
 901                 irlmp_do_discovery(nslots);
 902                 /* Note : we never do expiry here. Expiry will run on the
 903                  * discovery timer regardless of the state of sysctl_discovery
 904                  * Jean II */
 905         }
 906 }
 907 EXPORT_SYMBOL(irlmp_discovery_request);
 908
 909 /*
 910  * Function irlmp_get_discoveries (pn, mask, slots)
 911  *
 912  *    Return the current discovery log
 913  *
 914  * If discovery is not enabled, you should call this function again
 915  * after 1 or 2 seconds (i.e. after discovery has been done).
 916  */
 917 struct irda_device_info *irlmp_get_discoveries(int *pn, __u16 mask, int nslots)
 918 {
 919         /* If discovery is not enabled, it's likely that the discovery log
 920          * will be empty. So, we trigger a single discovery, so that next
 921          * time the user call us there might be some results in the log.
 922          * Jean II
 923          */
 924         if (!sysctl_discovery) {
 925                 /* Check if user wants to override the default */
 926                 if (nslots == DISCOVERY_DEFAULT_SLOTS)
 927                         nslots = sysctl_discovery_slots;
 928
 929                 /* Start discovery - will complete sometime later */
 930                 irlmp_do_discovery(nslots);
 931                 /* Note : we never do expiry here. Expiry will run on the
 932                  * discovery timer regardless of the state of sysctl_discovery
 933                  * Jean II */
 934         }
 935
 936         /* Return current cached discovery log */
 937         return irlmp_copy_discoveries(irlmp->cachelog, pn, mask, TRUE);
 938 }
 939 EXPORT_SYMBOL(irlmp_get_discoveries);
 940
 941 /*
 942  * Function irlmp_notify_client (log)
 943  *
 944  *    Notify all about discovered devices
 945  *
 946  * Clients registered with IrLMP are :
 947  *      o IrComm
 948  *      o IrLAN
 949  *      o Any socket (in any state - ouch, that may be a lot !)
 950  * The client may have defined a callback to be notified in case of
 951  * partial/selective discovery based on the hints that it passed to IrLMP.
 952  */
 953 static inline void
 954 irlmp_notify_client(irlmp_client_t *client,
 955                     hashbin_t *log, DISCOVERY_MODE mode)
 956 {
 957         discinfo_t *discoveries;        /* Copy of the discovery log */
 958         int     number;                 /* Number of nodes in the log */
 959         int     i;
 960
 961         /* Check if client wants or not partial/selective log (optimisation) */
 962         if (!client->disco_callback)
 963                 return;
 964
 965         /*
 966          * Locking notes :
 967          * the old code was manipulating the log directly, which was
 968          * very racy. Now, we use copy_discoveries, that protects
 969          * itself while dumping the log for us.
 970          * The overhead of the copy is compensated by the fact that
 971          * we only pass new discoveries in normal mode and don't
 972          * pass the same old entry every 3s to the caller as we used
 973          * to do (virtual function calling is expensive).
 974          * Jean II
 975          */
 976
 977         /*
 978          * Now, check all discovered devices (if any), and notify client
 979          * only about the services that the client is interested in
 980          * We also notify only about the new devices unless the caller
 981          * explicitly request a dump of the log. Jean II
 982          */
 983         discoveries = irlmp_copy_discoveries(log, &number,
 984                                              client->hint_mask.word,
 985                                              (mode == DISCOVERY_LOG));
 986         /* Check if the we got some results */
 987         if (discoveries == NULL)
 988                 return; /* No nodes discovered */
 989
 990         /* Pass all entries to the listener */
 991         for(i = 0; i < number; i++)
 992                 client->disco_callback(&(discoveries[i]), mode, client->priv);
 993
 994         /* Free up our buffer */
 995         kfree(discoveries);
 996 }
 997
 998 /*
 999  * Function irlmp_discovery_confirm ( self, log)
1000  *
1001  *    Some device(s) answered to our discovery request! Check to see which
1002  *    device it is, and give indication to the client(s)
1003  *
1004  */
1005 void irlmp_discovery_confirm(hashbin_t *log, DISCOVERY_MODE mode)
1006 {
1007         irlmp_client_t *client;
1008         irlmp_client_t *client_next;
1009
1010         IRDA_ASSERT(log != NULL, return;);
1011
1012         if (!(HASHBIN_GET_SIZE(log)))
1013                 return;
1014
1015         /* For each client - notify callback may touch client list */
1016         client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
1017         while (NULL != hashbin_find_next(irlmp->clients, (long) client, NULL,
1018                                          (void *) &client_next) ) {
1019                 /* Check if we should notify client */
1020                 irlmp_notify_client(client, log, mode);
1021
1022                 client = client_next;
1023         }
1024 }
1025
1026 /*
1027  * Function irlmp_discovery_expiry (expiry)
1028  *
1029  *      This device is no longer been discovered, and therefore it is being
1030  *      purged from the discovery log. Inform all clients who have
1031  *      registered for this event...
1032  *
1033  *      Note : called exclusively from discovery.c
1034  *      Note : this is no longer called under discovery spinlock, so the
1035  *              client can do whatever he wants in the callback.
1036  */
1037 void irlmp_discovery_expiry(discinfo_t *expiries, int number)
1038 {
1039         irlmp_client_t *client;
1040         irlmp_client_t *client_next;
1041         int             i;
1042
1043         IRDA_ASSERT(expiries != NULL, return;);
1044
1045         /* For each client - notify callback may touch client list */
1046         client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
1047         while (NULL != hashbin_find_next(irlmp->clients, (long) client, NULL,
1048                                          (void *) &client_next) ) {
1049
1050                 /* Pass all entries to the listener */
1051                 for(i = 0; i < number; i++) {
1052                         /* Check if we should notify client */
1053                         if ((client->expir_callback) &&
1054                             (client->hint_mask.word &
1055                              get_unaligned((__u16 *)expiries[i].hints)
1056                              & 0x7f7f) )
1057                                 client->expir_callback(&(expiries[i]),
1058                                                        EXPIRY_TIMEOUT,
1059                                                        client->priv);
1060                 }
1061
1062                 /* Next client */
1063                 client = client_next;
1064         }
1065 }
1066
1067 /*
1068  * Function irlmp_get_discovery_response ()
1069  *
1070  *    Used by IrLAP to get the discovery info it needs when answering
1071  *    discovery requests by other devices.
1072  */
1073 discovery_t *irlmp_get_discovery_response(void)
1074 {
1075         IRDA_ASSERT(irlmp != NULL, return NULL;);
1076
1077         put_unaligned(irlmp->hints.word, (__u16 *)irlmp->discovery_rsp.data.hints);
1078
1079         /*
1080          *  Set character set for device name (we use ASCII), and
1081          *  copy device name. Remember to make room for a \0 at the
1082          *  end
1083          */
1084         irlmp->discovery_rsp.data.charset = CS_ASCII;
1085
1086         strncpy(irlmp->discovery_rsp.data.info, sysctl_devname,
1087                 NICKNAME_MAX_LEN);
1088         irlmp->discovery_rsp.name_len = strlen(irlmp->discovery_rsp.data.info);
1089
1090         return &irlmp->discovery_rsp;
1091 }
1092
1093 /*
1094  * Function irlmp_data_request (self, skb)
1095  *
1096  *    Send some data to peer device
1097  *
1098  * Note on skb management :
1099  * After calling the lower layers of the IrDA stack, we always
1100  * kfree() the skb, which drop the reference count (and potentially
1101  * destroy it).
1102  * IrLMP and IrLAP may queue the packet, and in those cases will need
1103  * to use skb_get() to keep it around.
1104  * Jean II
1105  */
1106 int irlmp_data_request(struct lsap_cb *self, struct sk_buff *userdata)
1107 {
1108         int     ret;
1109
1110         IRDA_ASSERT(self != NULL, return -1;);
1111         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
1112
1113         /* Make room for MUX header */
1114         IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
1115         skb_push(userdata, LMP_HEADER);
1116
1117         ret = irlmp_do_lsap_event(self, LM_DATA_REQUEST, userdata);
1118
1119         /* Drop reference count - see irlap_data_request(). */
1120         dev_kfree_skb(userdata);
1121
1122         return ret;
1123 }
1124 EXPORT_SYMBOL(irlmp_data_request);
1125
1126 /*
1127  * Function irlmp_data_indication (handle, skb)
1128  *
1129  *    Got data from LAP layer so pass it up to upper layer
1130  *
1131  */
1132 void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb)
1133 {
1134         /* Hide LMP header from layer above */
1135         skb_pull(skb, LMP_HEADER);
1136
1137         if (self->notify.data_indication) {
1138                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
1139                 skb_get(skb);
1140                 self->notify.data_indication(self->notify.instance, self, skb);
1141         }
1142 }
1143
1144 /*
1145  * Function irlmp_udata_request (self, skb)
1146  */
1147 int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *userdata)
1148 {
1149         int     ret;
1150
1151         IRDA_ASSERT(userdata != NULL, return -1;);
1152
1153         /* Make room for MUX header */
1154         IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER, return -1;);
1155         skb_push(userdata, LMP_HEADER);
1156
1157         ret = irlmp_do_lsap_event(self, LM_UDATA_REQUEST, userdata);
1158
1159         /* Drop reference count - see irlap_data_request(). */
1160         dev_kfree_skb(userdata);
1161
1162         return ret;
1163 }
1164
1165 /*
1166  * Function irlmp_udata_indication (self, skb)
1167  *
1168  *    Send unreliable data (but still within the connection)
1169  *
1170  */
1171 void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb)
1172 {
1173         IRDA_ASSERT(self != NULL, return;);
1174         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
1175         IRDA_ASSERT(skb != NULL, return;);
1176
1177         /* Hide LMP header from layer above */
1178         skb_pull(skb, LMP_HEADER);
1179
1180         if (self->notify.udata_indication) {
1181                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
1182                 skb_get(skb);
1183                 self->notify.udata_indication(self->notify.instance, self,
1184                                               skb);
1185         }
1186 }
1187
1188 /*
1189  * Function irlmp_connless_data_request (self, skb)
1190  */
1191 #ifdef CONFIG_IRDA_ULTRA
1192 int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *userdata,
1193                                 __u8 pid)
1194 {
1195         struct sk_buff *clone_skb;
1196         struct lap_cb *lap;
1197
1198         IRDA_ASSERT(userdata != NULL, return -1;);
1199
1200         /* Make room for MUX and PID header */
1201         IRDA_ASSERT(skb_headroom(userdata) >= LMP_HEADER+LMP_PID_HEADER,
1202                     return -1;);
1203
1204         /* Insert protocol identifier */
1205         skb_push(userdata, LMP_PID_HEADER);
1206         if(self != NULL)
1207           userdata->data[0] = self->pid;
1208         else
1209           userdata->data[0] = pid;
1210
1211         /* Connectionless sockets must use 0x70 */
1212         skb_push(userdata, LMP_HEADER);
1213         userdata->data[0] = userdata->data[1] = LSAP_CONNLESS;
1214
1215         /* Try to send Connectionless  packets out on all links */
1216         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
1217         while (lap != NULL) {
1218                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return -1;);
1219
1220                 clone_skb = skb_clone(userdata, GFP_ATOMIC);
1221                 if (!clone_skb) {
1222                         dev_kfree_skb(userdata);
1223                         return -ENOMEM;
1224                 }
1225
1226                 irlap_unitdata_request(lap->irlap, clone_skb);
1227                 /* irlap_unitdata_request() don't increase refcount,
1228                  * so no dev_kfree_skb() - Jean II */
1229
1230                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
1231         }
1232         dev_kfree_skb(userdata);
1233
1234         return 0;
1235 }
1236 #endif /* CONFIG_IRDA_ULTRA */
1237
1238 /*
1239  * Function irlmp_connless_data_indication (self, skb)
1240  *
1241  *    Receive unreliable data outside any connection. Mostly used by Ultra
1242  *
1243  */
1244 #ifdef CONFIG_IRDA_ULTRA
1245 void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb)
1246 {
1247         IRDA_ASSERT(self != NULL, return;);
1248         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
1249         IRDA_ASSERT(skb != NULL, return;);
1250
1251         /* Hide LMP and PID header from layer above */
1252         skb_pull(skb, LMP_HEADER+LMP_PID_HEADER);
1253
1254         if (self->notify.udata_indication) {
1255                 /* Don't forget to refcount it - see irlap_driver_rcv(). */
1256                 skb_get(skb);
1257                 self->notify.udata_indication(self->notify.instance, self,
1258                                               skb);
1259         }
1260 }
1261 #endif /* CONFIG_IRDA_ULTRA */
1262
1263 /*
1264  * Propagate status indication from LAP to LSAPs (via LMP)
1265  * This don't trigger any change of state in lap_cb, lmp_cb or lsap_cb,
1266  * and the event is stateless, therefore we can bypass both state machines
1267  * and send the event direct to the LSAP user.
1268  * Jean II
1269  */
1270 void irlmp_status_indication(struct lap_cb *self,
1271                              LINK_STATUS link, LOCK_STATUS lock)
1272 {
1273         struct lsap_cb *next;
1274         struct lsap_cb *curr;
1275
1276         /* Send status_indication to all LSAPs using this link */
1277         curr = (struct lsap_cb *) hashbin_get_first( self->lsaps);
1278         while (NULL != hashbin_find_next(self->lsaps, (long) curr, NULL,
1279                                          (void *) &next) ) {
1280                 IRDA_ASSERT(curr->magic == LMP_LSAP_MAGIC, return;);
1281                 /*
1282                  *  Inform service user if he has requested it
1283                  */
1284                 if (curr->notify.status_indication != NULL)
1285                         curr->notify.status_indication(curr->notify.instance,
1286                                                        link, lock);
1287                 else
1288                         pr_debug("%s(), no handler\n", __func__);
1289
1290                 curr = next;
1291         }
1292 }
1293
1294 /*
1295  * Receive flow control indication from LAP.
1296  * LAP want us to send it one more frame. We implement a simple round
1297  * robin scheduler between the active sockets so that we get a bit of
1298  * fairness. Note that the round robin is far from perfect, but it's
1299  * better than nothing.
1300  * We then poll the selected socket so that we can do synchronous
1301  * refilling of IrLAP (which allow to minimise the number of buffers).
1302  * Jean II
1303  */
1304 void irlmp_flow_indication(struct lap_cb *self, LOCAL_FLOW flow)
1305 {
1306         struct lsap_cb *next;
1307         struct lsap_cb *curr;
1308         int     lsap_todo;
1309
1310         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
1311         IRDA_ASSERT(flow == FLOW_START, return;);
1312
1313         /* Get the number of lsap. That's the only safe way to know
1314          * that we have looped around... - Jean II */
1315         lsap_todo = HASHBIN_GET_SIZE(self->lsaps);
1316         pr_debug("%s() : %d lsaps to scan\n", __func__, lsap_todo);
1317
1318         /* Poll lsap in order until the queue is full or until we
1319          * tried them all.
1320          * Most often, the current LSAP will have something to send,
1321          * so we will go through this loop only once. - Jean II */
1322         while((lsap_todo--) &&
1323               (IRLAP_GET_TX_QUEUE_LEN(self->irlap) < LAP_HIGH_THRESHOLD)) {
1324                 /* Try to find the next lsap we should poll. */
1325                 next = self->flow_next;
1326                 /* If we have no lsap, restart from first one */
1327                 if(next == NULL)
1328                         next = (struct lsap_cb *) hashbin_get_first(self->lsaps);
1329                 /* Verify current one and find the next one */
1330                 curr = hashbin_find_next(self->lsaps, (long) next, NULL,
1331                                          (void *) &self->flow_next);
1332                 /* Uh-oh... Paranoia */
1333                 if(curr == NULL)
1334                         break;
1335                 pr_debug("%s() : curr is %p, next was %p and is now %p, still %d to go - queue len = %d\n",
1336                          __func__, curr, next, self->flow_next, lsap_todo,
1337                          IRLAP_GET_TX_QUEUE_LEN(self->irlap));
1338
1339                 /* Inform lsap user that it can send one more packet. */
1340                 if (curr->notify.flow_indication != NULL)
1341                         curr->notify.flow_indication(curr->notify.instance,
1342                                                      curr, flow);
1343                 else
1344                         pr_debug("%s(), no handler\n", __func__);
1345         }
1346 }
1347
1348 #if 0
1349 /*
1350  * Function irlmp_hint_to_service (hint)
1351  *
1352  *    Returns a list of all servics contained in the given hint bits. This
1353  *    function assumes that the hint bits have the size of two bytes only
1354  */
1355 __u8 *irlmp_hint_to_service(__u8 *hint)
1356 {
1357         __u8 *service;
1358         int i = 0;
1359
1360         /*
1361          * Allocate array to store services in. 16 entries should be safe
1362          * since we currently only support 2 hint bytes
1363          */
1364         service = kmalloc(16, GFP_ATOMIC);
1365         if (!service)
1366                 return NULL;
1367
1368         if (!hint[0]) {
1369                 pr_debug("<None>\n");
1370                 kfree(service);
1371                 return NULL;
1372         }
1373         if (hint[0] & HINT_PNP)
1374                 pr_debug("PnP Compatible ");
1375         if (hint[0] & HINT_PDA)
1376                 pr_debug("PDA/Palmtop ");
1377         if (hint[0] & HINT_COMPUTER)
1378                 pr_debug("Computer ");
1379         if (hint[0] & HINT_PRINTER) {
1380                 pr_debug("Printer ");
1381                 service[i++] = S_PRINTER;
1382         }
1383         if (hint[0] & HINT_MODEM)
1384                 pr_debug("Modem ");
1385         if (hint[0] & HINT_FAX)
1386                 pr_debug("Fax ");
1387         if (hint[0] & HINT_LAN) {
1388                 pr_debug("LAN Access ");
1389                 service[i++] = S_LAN;
1390         }
1391         /*
1392          *  Test if extension byte exists. This byte will usually be
1393          *  there, but this is not really required by the standard.
1394          *  (IrLMP p. 29)
1395          */
1396         if (hint[0] & HINT_EXTENSION) {
1397                 if (hint[1] & HINT_TELEPHONY) {
1398                         pr_debug("Telephony ");
1399                         service[i++] = S_TELEPHONY;
1400                 }
1401                 if (hint[1] & HINT_FILE_SERVER)
1402                         pr_debug("File Server ");
1403
1404                 if (hint[1] & HINT_COMM) {
1405                         pr_debug("IrCOMM ");
1406                         service[i++] = S_COMM;
1407                 }
1408                 if (hint[1] & HINT_OBEX) {
1409                         pr_debug("IrOBEX ");
1410                         service[i++] = S_OBEX;
1411                 }
1412         }
1413         pr_debug("\n");
1414
1415         /* So that client can be notified about any discovery */
1416         service[i++] = S_ANY;
1417
1418         service[i] = S_END;
1419
1420         return service;
1421 }
1422 #endif
1423
1424 static const __u16 service_hint_mapping[S_END][2] = {
1425         { HINT_PNP,             0 },                    /* S_PNP */
1426         { HINT_PDA,             0 },                    /* S_PDA */
1427         { HINT_COMPUTER,        0 },                    /* S_COMPUTER */
1428         { HINT_PRINTER,         0 },                    /* S_PRINTER */
1429         { HINT_MODEM,           0 },                    /* S_MODEM */
1430         { HINT_FAX,             0 },                    /* S_FAX */
1431         { HINT_LAN,             0 },                    /* S_LAN */
1432         { HINT_EXTENSION,       HINT_TELEPHONY },       /* S_TELEPHONY */
1433         { HINT_EXTENSION,       HINT_COMM },            /* S_COMM */
1434         { HINT_EXTENSION,       HINT_OBEX },            /* S_OBEX */
1435         { 0xFF,                 0xFF },                 /* S_ANY */
1436 };
1437
1438 /*
1439  * Function irlmp_service_to_hint (service)
1440  *
1441  *    Converts a service type, to a hint bit
1442  *
1443  *    Returns: a 16 bit hint value, with the service bit set
1444  */
1445 __u16 irlmp_service_to_hint(int service)
1446 {
1447         __u16_host_order hint;
1448
1449         hint.byte[0] = service_hint_mapping[service][0];
1450         hint.byte[1] = service_hint_mapping[service][1];
1451
1452         return hint.word;
1453 }
1454 EXPORT_SYMBOL(irlmp_service_to_hint);
1455
1456 /*
1457  * Function irlmp_register_service (service)
1458  *
1459  *    Register local service with IrLMP
1460  *
1461  */
1462 void *irlmp_register_service(__u16 hints)
1463 {
1464         irlmp_service_t *service;
1465
1466         pr_debug("%s(), hints = %04x\n", __func__, hints);
1467
1468         /* Make a new registration */
1469         service = kmalloc(sizeof(irlmp_service_t), GFP_ATOMIC);
1470         if (!service)
1471                 return NULL;
1472
1473         service->hints.word = hints;
1474         hashbin_insert(irlmp->services, (irda_queue_t *) service,
1475                        (long) service, NULL);
1476
1477         irlmp->hints.word |= hints;
1478
1479         return (void *)service;
1480 }
1481 EXPORT_SYMBOL(irlmp_register_service);
1482
1483 /*
1484  * Function irlmp_unregister_service (handle)
1485  *
1486  *    Unregister service with IrLMP.
1487  *
1488  *    Returns: 0 on success, -1 on error
1489  */
1490 int irlmp_unregister_service(void *handle)
1491 {
1492         irlmp_service_t *service;
1493         unsigned long flags;
1494
1495         if (!handle)
1496                 return -1;
1497
1498         /* Caller may call with invalid handle (it's legal) - Jean II */
1499         service = hashbin_lock_find(irlmp->services, (long) handle, NULL);
1500         if (!service) {
1501                 pr_debug("%s(), Unknown service!\n", __func__);
1502                 return -1;
1503         }
1504
1505         hashbin_remove_this(irlmp->services, (irda_queue_t *) service);
1506         kfree(service);
1507
1508         /* Remove old hint bits */
1509         irlmp->hints.word = 0;
1510
1511         /* Refresh current hint bits */
1512         spin_lock_irqsave(&irlmp->services->hb_spinlock, flags);
1513         service = (irlmp_service_t *) hashbin_get_first(irlmp->services);
1514         while (service) {
1515                 irlmp->hints.word |= service->hints.word;
1516
1517                 service = (irlmp_service_t *)hashbin_get_next(irlmp->services);
1518         }
1519         spin_unlock_irqrestore(&irlmp->services->hb_spinlock, flags);
1520         return 0;
1521 }
1522 EXPORT_SYMBOL(irlmp_unregister_service);
1523
1524 /*
1525  * Function irlmp_register_client (hint_mask, callback1, callback2)
1526  *
1527  *    Register a local client with IrLMP
1528  *      First callback is selective discovery (based on hints)
1529  *      Second callback is for selective discovery expiries
1530  *
1531  *    Returns: handle > 0 on success, 0 on error
1532  */
1533 void *irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 disco_clb,
1534                             DISCOVERY_CALLBACK2 expir_clb, void *priv)
1535 {
1536         irlmp_client_t *client;
1537
1538         IRDA_ASSERT(irlmp != NULL, return NULL;);
1539
1540         /* Make a new registration */
1541         client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
1542         if (!client)
1543                 return NULL;
1544
1545         /* Register the details */
1546         client->hint_mask.word = hint_mask;
1547         client->disco_callback = disco_clb;
1548         client->expir_callback = expir_clb;
1549         client->priv = priv;
1550
1551         hashbin_insert(irlmp->clients, (irda_queue_t *) client,
1552                        (long) client, NULL);
1553
1554         return (void *) client;
1555 }
1556 EXPORT_SYMBOL(irlmp_register_client);
1557
1558 /*
1559  * Function irlmp_update_client (handle, hint_mask, callback1, callback2)
1560  *
1561  *    Updates specified client (handle) with possibly new hint_mask and
1562  *    callback
1563  *
1564  *    Returns: 0 on success, -1 on error
1565  */
1566 int irlmp_update_client(void *handle, __u16 hint_mask,
1567                         DISCOVERY_CALLBACK1 disco_clb,
1568                         DISCOVERY_CALLBACK2 expir_clb, void *priv)
1569 {
1570         irlmp_client_t *client;
1571
1572         if (!handle)
1573                 return -1;
1574
1575         client = hashbin_lock_find(irlmp->clients, (long) handle, NULL);
1576         if (!client) {
1577                 pr_debug("%s(), Unknown client!\n", __func__);
1578                 return -1;
1579         }
1580
1581         client->hint_mask.word = hint_mask;
1582         client->disco_callback = disco_clb;
1583         client->expir_callback = expir_clb;
1584         client->priv = priv;
1585
1586         return 0;
1587 }
1588 EXPORT_SYMBOL(irlmp_update_client);
1589
1590 /*
1591  * Function irlmp_unregister_client (handle)
1592  *
1593  *    Returns: 0 on success, -1 on error
1594  *
1595  */
1596 int irlmp_unregister_client(void *handle)
1597 {
1598         struct irlmp_client *client;
1599
1600         if (!handle)
1601                 return -1;
1602
1603         /* Caller may call with invalid handle (it's legal) - Jean II */
1604         client = hashbin_lock_find(irlmp->clients, (long) handle, NULL);
1605         if (!client) {
1606                 pr_debug("%s(), Unknown client!\n", __func__);
1607                 return -1;
1608         }
1609
1610         pr_debug("%s(), removing client!\n", __func__);
1611         hashbin_remove_this(irlmp->clients, (irda_queue_t *) client);
1612         kfree(client);
1613
1614         return 0;
1615 }
1616 EXPORT_SYMBOL(irlmp_unregister_client);
1617
1618 /*
1619  * Function irlmp_slsap_inuse (slsap)
1620  *
1621  *    Check if the given source LSAP selector is in use
1622  *
1623  * This function is clearly not very efficient. On the mitigating side, the
1624  * stack make sure that in 99% of the cases, we are called only once
1625  * for each socket allocation. We could probably keep a bitmap
1626  * of the allocated LSAP, but I'm not sure the complexity is worth it.
1627  * Jean II
1628  */
1629 static int irlmp_slsap_inuse(__u8 slsap_sel)
1630 {
1631         struct lsap_cb *self;
1632         struct lap_cb *lap;
1633         unsigned long flags;
1634
1635         IRDA_ASSERT(irlmp != NULL, return TRUE;);
1636         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return TRUE;);
1637         IRDA_ASSERT(slsap_sel != LSAP_ANY, return TRUE;);
1638
1639 #ifdef CONFIG_IRDA_ULTRA
1640         /* Accept all bindings to the connectionless LSAP */
1641         if (slsap_sel == LSAP_CONNLESS)
1642                 return FALSE;
1643 #endif /* CONFIG_IRDA_ULTRA */
1644
1645         /* Valid values are between 0 and 127 (0x0-0x6F) */
1646         if (slsap_sel > LSAP_MAX)
1647                 return TRUE;
1648
1649         /*
1650          *  Check if slsap is already in use. To do this we have to loop over
1651          *  every IrLAP connection and check every LSAP associated with each
1652          *  the connection.
1653          */
1654         spin_lock_irqsave_nested(&irlmp->links->hb_spinlock, flags,
1655                         SINGLE_DEPTH_NESTING);
1656         lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
1657         while (lap != NULL) {
1658                 IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, goto errlap;);
1659
1660                 /* Careful for priority inversions here !
1661                  * irlmp->links is never taken while another IrDA
1662                  * spinlock is held, so we are safe. Jean II */
1663                 spin_lock(&lap->lsaps->hb_spinlock);
1664
1665                 /* For this IrLAP, check all the LSAPs */
1666                 self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
1667                 while (self != NULL) {
1668                         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
1669                                     goto errlsap;);
1670
1671                         if ((self->slsap_sel == slsap_sel)) {
1672                                 pr_debug("Source LSAP selector=%02x in use\n",
1673                                          self->slsap_sel);
1674                                 goto errlsap;
1675                         }
1676                         self = (struct lsap_cb*) hashbin_get_next(lap->lsaps);
1677                 }
1678                 spin_unlock(&lap->lsaps->hb_spinlock);
1679
1680                 /* Next LAP */
1681                 lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
1682         }
1683         spin_unlock_irqrestore(&irlmp->links->hb_spinlock, flags);
1684
1685         /*
1686          * Server sockets are typically waiting for connections and
1687          * therefore reside in the unconnected list. We don't want
1688          * to give out their LSAPs for obvious reasons...
1689          * Jean II
1690          */
1691         spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
1692
1693         self = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
1694         while (self != NULL) {
1695                 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, goto erruncon;);
1696                 if ((self->slsap_sel == slsap_sel)) {
1697                         pr_debug("Source LSAP selector=%02x in use (unconnected)\n",
1698                                  self->slsap_sel);
1699                         goto erruncon;
1700                 }
1701                 self = (struct lsap_cb*) hashbin_get_next(irlmp->unconnected_lsaps);
1702         }
1703         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
1704
1705         return FALSE;
1706
1707         /* Error exit from within one of the two nested loops.
1708          * Make sure we release the right spinlock in the righ order.
1709          * Jean II */
1710 errlsap:
1711         spin_unlock(&lap->lsaps->hb_spinlock);
1712 IRDA_ASSERT_LABEL(errlap:)
1713         spin_unlock_irqrestore(&irlmp->links->hb_spinlock, flags);
1714         return TRUE;
1715
1716         /* Error exit from within the unconnected loop.
1717          * Just one spinlock to release... Jean II */
1718 erruncon:
1719         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
1720         return TRUE;
1721 }
1722
1723 /*
1724  * Function irlmp_find_free_slsap ()
1725  *
1726  *    Find a free source LSAP to use. This function is called if the service
1727  *    user has requested a source LSAP equal to LM_ANY
1728  */
1729 static __u8 irlmp_find_free_slsap(void)
1730 {
1731         __u8 lsap_sel;
1732         int wrapped = 0;
1733
1734         IRDA_ASSERT(irlmp != NULL, return -1;);
1735         IRDA_ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
1736
1737         /* Most users don't really care which LSAPs they are given,
1738          * and therefore we automatically give them a free LSAP.
1739          * This function try to find a suitable LSAP, i.e. which is
1740          * not in use and is within the acceptable range. Jean II */
1741
1742         do {
1743                 /* Always increment to LSAP number before using it.
1744                  * In theory, we could reuse the last LSAP number, as long
1745                  * as it is no longer in use. Some IrDA stack do that.
1746                  * However, the previous socket may be half closed, i.e.
1747                  * we closed it, we think it's no longer in use, but the
1748                  * other side did not receive our close and think it's
1749                  * active and still send data on it.
1750                  * This is similar to what is done with PIDs and TCP ports.
1751                  * Also, this reduce the number of calls to irlmp_slsap_inuse()
1752                  * which is an expensive function to call.
1753                  * Jean II */
1754                 irlmp->last_lsap_sel++;
1755
1756                 /* Check if we need to wraparound (0x70-0x7f are reserved) */
1757                 if (irlmp->last_lsap_sel > LSAP_MAX) {
1758                         /* 0x00-0x10 are also reserved for well know ports */
1759                         irlmp->last_lsap_sel = 0x10;
1760
1761                         /* Make sure we terminate the loop */
1762                         if (wrapped++) {
1763                                 net_err_ratelimited("%s: no more free LSAPs !\n",
1764                                                     __func__);
1765                                 return 0;
1766                         }
1767                 }
1768
1769                 /* If the LSAP is in use, try the next one.
1770                  * Despite the autoincrement, we need to check if the lsap
1771                  * is really in use or not, first because LSAP may be
1772                  * directly allocated in irlmp_open_lsap(), and also because
1773                  * we may wraparound on old sockets. Jean II */
1774         } while (irlmp_slsap_inuse(irlmp->last_lsap_sel));
1775
1776         /* Got it ! */
1777         lsap_sel = irlmp->last_lsap_sel;
1778         pr_debug("%s(), found free lsap_sel=%02x\n",
1779                  __func__, lsap_sel);
1780
1781         return lsap_sel;
1782 }
1783
1784 /*
1785  * Function irlmp_convert_lap_reason (lap_reason)
1786  *
1787  *    Converts IrLAP disconnect reason codes to IrLMP disconnect reason
1788  *    codes
1789  *
1790  */
1791 LM_REASON irlmp_convert_lap_reason( LAP_REASON lap_reason)
1792 {
1793         int reason = LM_LAP_DISCONNECT;
1794
1795         switch (lap_reason) {
1796         case LAP_DISC_INDICATION: /* Received a disconnect request from peer */
1797                 pr_debug("%s(), LAP_DISC_INDICATION\n", __func__);
1798                 reason = LM_USER_REQUEST;
1799                 break;
1800         case LAP_NO_RESPONSE:    /* To many retransmits without response */
1801                 pr_debug("%s(), LAP_NO_RESPONSE\n", __func__);
1802                 reason = LM_LAP_DISCONNECT;
1803                 break;
1804         case LAP_RESET_INDICATION:
1805                 pr_debug("%s(), LAP_RESET_INDICATION\n", __func__);
1806                 reason = LM_LAP_RESET;
1807                 break;
1808         case LAP_FOUND_NONE:
1809         case LAP_MEDIA_BUSY:
1810         case LAP_PRIMARY_CONFLICT:
1811                 pr_debug("%s(), LAP_FOUND_NONE, LAP_MEDIA_BUSY or LAP_PRIMARY_CONFLICT\n",
1812                          __func__);
1813                 reason = LM_CONNECT_FAILURE;
1814                 break;
1815         default:
1816                 pr_debug("%s(), Unknown IrLAP disconnect reason %d!\n",
1817                          __func__, lap_reason);
1818                 reason = LM_LAP_DISCONNECT;
1819                 break;
1820         }
1821
1822         return reason;
1823 }
1824
1825 #ifdef CONFIG_PROC_FS
1826
1827 struct irlmp_iter_state {
1828         hashbin_t *hashbin;
1829 };
1830
1831 #define LSAP_START_TOKEN        ((void *)1)
1832 #define LINK_START_TOKEN        ((void *)2)
1833
1834 static void *irlmp_seq_hb_idx(struct irlmp_iter_state *iter, loff_t *off)
1835 {
1836         void *element;
1837
1838         spin_lock_irq(&iter->hashbin->hb_spinlock);
1839         for (element = hashbin_get_first(iter->hashbin);
1840              element != NULL;
1841              element = hashbin_get_next(iter->hashbin)) {
1842                 if (!off || (*off)-- == 0) {
1843                         /* NB: hashbin left locked */
1844                         return element;
1845                 }
1846         }
1847         spin_unlock_irq(&iter->hashbin->hb_spinlock);
1848         iter->hashbin = NULL;
1849         return NULL;
1850 }
1851
1852
1853 static void *irlmp_seq_start(struct seq_file *seq, loff_t *pos)
1854 {
1855         struct irlmp_iter_state *iter = seq->private;
1856         void *v;
1857         loff_t off = *pos;
1858
1859         iter->hashbin = NULL;
1860         if (off-- == 0)
1861                 return LSAP_START_TOKEN;
1862
1863         iter->hashbin = irlmp->unconnected_lsaps;
1864         v = irlmp_seq_hb_idx(iter, &off);
1865         if (v)
1866                 return v;
1867
1868         if (off-- == 0)
1869                 return LINK_START_TOKEN;
1870
1871         iter->hashbin = irlmp->links;
1872         return irlmp_seq_hb_idx(iter, &off);
1873 }
1874
1875 static void *irlmp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1876 {
1877         struct irlmp_iter_state *iter = seq->private;
1878
1879         ++*pos;
1880
1881         if (v == LSAP_START_TOKEN) {            /* start of list of lsaps */
1882                 iter->hashbin = irlmp->unconnected_lsaps;
1883                 v = irlmp_seq_hb_idx(iter, NULL);
1884                 return v ? v : LINK_START_TOKEN;
1885         }
1886
1887         if (v == LINK_START_TOKEN) {            /* start of list of links */
1888                 iter->hashbin = irlmp->links;
1889                 return irlmp_seq_hb_idx(iter, NULL);
1890         }
1891
1892         v = hashbin_get_next(iter->hashbin);
1893
1894         if (v == NULL) {                        /* no more in this hash bin */
1895                 spin_unlock_irq(&iter->hashbin->hb_spinlock);
1896
1897                 if (iter->hashbin == irlmp->unconnected_lsaps)
1898                         v =  LINK_START_TOKEN;
1899
1900                 iter->hashbin = NULL;
1901         }
1902         return v;
1903 }
1904
1905 static void irlmp_seq_stop(struct seq_file *seq, void *v)
1906 {
1907         struct irlmp_iter_state *iter = seq->private;
1908
1909         if (iter->hashbin)
1910                 spin_unlock_irq(&iter->hashbin->hb_spinlock);
1911 }
1912
1913 static int irlmp_seq_show(struct seq_file *seq, void *v)
1914 {
1915         const struct irlmp_iter_state *iter = seq->private;
1916         struct lsap_cb *self = v;
1917
1918         if (v == LSAP_START_TOKEN)
1919                 seq_puts(seq, "Unconnected LSAPs:\n");
1920         else if (v == LINK_START_TOKEN)
1921                 seq_puts(seq, "\nRegistered Link Layers:\n");
1922         else if (iter->hashbin == irlmp->unconnected_lsaps) {
1923                 self = v;
1924                 IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -EINVAL; );
1925                 seq_printf(seq, "lsap state: %s, ",
1926                            irlsap_state[ self->lsap_state]);
1927                 seq_printf(seq,
1928                            "slsap_sel: %#02x, dlsap_sel: %#02x, ",
1929                            self->slsap_sel, self->dlsap_sel);
1930                 seq_printf(seq, "(%s)", self->notify.name);
1931                 seq_printf(seq, "\n");
1932         } else if (iter->hashbin == irlmp->links) {
1933                 struct lap_cb *lap = v;
1934
1935                 seq_printf(seq, "lap state: %s, ",
1936                            irlmp_state[lap->lap_state]);
1937
1938                 seq_printf(seq, "saddr: %#08x, daddr: %#08x, ",
1939                            lap->saddr, lap->daddr);
1940                 seq_printf(seq, "num lsaps: %d",
1941                            HASHBIN_GET_SIZE(lap->lsaps));
1942                 seq_printf(seq, "\n");
1943
1944                 /* Careful for priority inversions here !
1945                  * All other uses of attrib spinlock are independent of
1946                  * the object spinlock, so we are safe. Jean II */
1947                 spin_lock(&lap->lsaps->hb_spinlock);
1948
1949                 seq_printf(seq, "\n  Connected LSAPs:\n");
1950                 for (self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
1951                      self != NULL;
1952                      self = (struct lsap_cb *)hashbin_get_next(lap->lsaps)) {
1953                         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC,
1954                                     goto outloop;);
1955                         seq_printf(seq, "  lsap state: %s, ",
1956                                    irlsap_state[ self->lsap_state]);
1957                         seq_printf(seq,
1958                                    "slsap_sel: %#02x, dlsap_sel: %#02x, ",
1959                                    self->slsap_sel, self->dlsap_sel);
1960                         seq_printf(seq, "(%s)", self->notify.name);
1961                         seq_putc(seq, '\n');
1962
1963                 }
1964         IRDA_ASSERT_LABEL(outloop:)
1965                 spin_unlock(&lap->lsaps->hb_spinlock);
1966                 seq_putc(seq, '\n');
1967         } else
1968                 return -EINVAL;
1969
1970         return 0;
1971 }
1972
1973 static const struct seq_operations irlmp_seq_ops = {
1974         .start  = irlmp_seq_start,
1975         .next   = irlmp_seq_next,
1976         .stop   = irlmp_seq_stop,
1977         .show   = irlmp_seq_show,
1978 };
1979
1980 static int irlmp_seq_open(struct inode *inode, struct file *file)
1981 {
1982         IRDA_ASSERT(irlmp != NULL, return -EINVAL;);
1983
1984         return seq_open_private(file, &irlmp_seq_ops,
1985                         sizeof(struct irlmp_iter_state));
1986 }
1987
1988 const struct file_operations irlmp_seq_fops = {
1989         .owner          = THIS_MODULE,
1990         .open           = irlmp_seq_open,
1991         .read           = seq_read,
1992         .llseek         = seq_lseek,
1993         .release        = seq_release_private,
1994 };
1995
1996 #endif /* PROC_FS */