Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / net / irda / irlmp_event.c
1 /*********************************************************************
2  *
3  * Filename:      irlmp_event.c
4  * Version:       0.8
5  * Description:   An IrDA LMP event driver for Linux
6  * Status:        Experimental.
7  * Author:        Dag Brattli <dagb@cs.uit.no>
8  * Created at:    Mon Aug  4 20:40:53 1997
9  * Modified at:   Tue Dec 14 23:04:16 1999
10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
11  *
12  *     Copyright (c) 1998-1999 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/kernel.h>
28
29 #include <net/irda/irda.h>
30 #include <net/irda/timer.h>
31 #include <net/irda/irlap.h>
32 #include <net/irda/irlmp.h>
33 #include <net/irda/irlmp_frame.h>
34 #include <net/irda/irlmp_event.h>
35
36 const char *irlmp_state[] = {
37         "LAP_STANDBY",
38         "LAP_U_CONNECT",
39         "LAP_ACTIVE",
40 };
41
42 const char *irlsap_state[] = {
43         "LSAP_DISCONNECTED",
44         "LSAP_CONNECT",
45         "LSAP_CONNECT_PEND",
46         "LSAP_DATA_TRANSFER_READY",
47         "LSAP_SETUP",
48         "LSAP_SETUP_PEND",
49 };
50
51 #ifdef CONFIG_IRDA_DEBUG
52 static const char *irlmp_event[] = {
53         "LM_CONNECT_REQUEST",
54         "LM_CONNECT_CONFIRM",
55         "LM_CONNECT_RESPONSE",
56         "LM_CONNECT_INDICATION",
57
58         "LM_DISCONNECT_INDICATION",
59         "LM_DISCONNECT_REQUEST",
60
61         "LM_DATA_REQUEST",
62         "LM_UDATA_REQUEST",
63         "LM_DATA_INDICATION",
64         "LM_UDATA_INDICATION",
65
66         "LM_WATCHDOG_TIMEOUT",
67
68         /* IrLAP events */
69         "LM_LAP_CONNECT_REQUEST",
70         "LM_LAP_CONNECT_INDICATION",
71         "LM_LAP_CONNECT_CONFIRM",
72         "LM_LAP_DISCONNECT_INDICATION",
73         "LM_LAP_DISCONNECT_REQUEST",
74         "LM_LAP_DISCOVERY_REQUEST",
75         "LM_LAP_DISCOVERY_CONFIRM",
76         "LM_LAP_IDLE_TIMEOUT",
77 };
78 #endif  /* CONFIG_IRDA_DEBUG */
79
80 /* LAP Connection control proto declarations */
81 static void irlmp_state_standby  (struct lap_cb *, IRLMP_EVENT,
82                                   struct sk_buff *);
83 static void irlmp_state_u_connect(struct lap_cb *, IRLMP_EVENT,
84                                   struct sk_buff *);
85 static void irlmp_state_active   (struct lap_cb *, IRLMP_EVENT,
86                                   struct sk_buff *);
87
88 /* LSAP Connection control proto declarations */
89 static int irlmp_state_disconnected(struct lsap_cb *, IRLMP_EVENT,
90                                     struct sk_buff *);
91 static int irlmp_state_connect     (struct lsap_cb *, IRLMP_EVENT,
92                                     struct sk_buff *);
93 static int irlmp_state_connect_pend(struct lsap_cb *, IRLMP_EVENT,
94                                     struct sk_buff *);
95 static int irlmp_state_dtr         (struct lsap_cb *, IRLMP_EVENT,
96                                     struct sk_buff *);
97 static int irlmp_state_setup       (struct lsap_cb *, IRLMP_EVENT,
98                                     struct sk_buff *);
99 static int irlmp_state_setup_pend  (struct lsap_cb *, IRLMP_EVENT,
100                                     struct sk_buff *);
101
102 static void (*lap_state[]) (struct lap_cb *, IRLMP_EVENT, struct sk_buff *) =
103 {
104         irlmp_state_standby,
105         irlmp_state_u_connect,
106         irlmp_state_active,
107 };
108
109 static int (*lsap_state[])( struct lsap_cb *, IRLMP_EVENT, struct sk_buff *) =
110 {
111         irlmp_state_disconnected,
112         irlmp_state_connect,
113         irlmp_state_connect_pend,
114         irlmp_state_dtr,
115         irlmp_state_setup,
116         irlmp_state_setup_pend
117 };
118
119 static inline void irlmp_next_lap_state(struct lap_cb *self,
120                                         IRLMP_STATE state)
121 {
122         /*
123         IRDA_DEBUG(4, "%s(), LMP LAP = %s\n", __FUNCTION__, irlmp_state[state]);
124         */
125         self->lap_state = state;
126 }
127
128 static inline void irlmp_next_lsap_state(struct lsap_cb *self,
129                                          LSAP_STATE state)
130 {
131         /*
132         IRDA_ASSERT(self != NULL, return;);
133         IRDA_DEBUG(4, "%s(), LMP LSAP = %s\n", __FUNCTION__, irlsap_state[state]);
134         */
135         self->lsap_state = state;
136 }
137
138 /* Do connection control events */
139 int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event,
140                         struct sk_buff *skb)
141 {
142         IRDA_ASSERT(self != NULL, return -1;);
143         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
144
145         IRDA_DEBUG(4, "%s(), EVENT = %s, STATE = %s\n",
146                 __FUNCTION__, irlmp_event[event], irlsap_state[ self->lsap_state]);
147
148         return (*lsap_state[self->lsap_state]) (self, event, skb);
149 }
150
151 /*
152  * Function do_lap_event (event, skb, info)
153  *
154  *    Do IrLAP control events
155  *
156  */
157 void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event,
158                         struct sk_buff *skb)
159 {
160         IRDA_ASSERT(self != NULL, return;);
161         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
162
163         IRDA_DEBUG(4, "%s(), EVENT = %s, STATE = %s\n", __FUNCTION__,
164                    irlmp_event[event],
165                    irlmp_state[self->lap_state]);
166
167         (*lap_state[self->lap_state]) (self, event, skb);
168 }
169
170 void irlmp_discovery_timer_expired(void *data)
171 {
172         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
173
174         /* We always cleanup the log (active & passive discovery) */
175         irlmp_do_expiry();
176
177         /* Active discovery is conditional */
178         if (sysctl_discovery)
179                 irlmp_do_discovery(sysctl_discovery_slots);
180
181         /* Restart timer */
182         irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout * HZ);
183 }
184
185 void irlmp_watchdog_timer_expired(void *data)
186 {
187         struct lsap_cb *self = (struct lsap_cb *) data;
188
189         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
190
191         IRDA_ASSERT(self != NULL, return;);
192         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
193
194         irlmp_do_lsap_event(self, LM_WATCHDOG_TIMEOUT, NULL);
195 }
196
197 void irlmp_idle_timer_expired(void *data)
198 {
199         struct lap_cb *self = (struct lap_cb *) data;
200
201         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
202
203         IRDA_ASSERT(self != NULL, return;);
204         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
205
206         irlmp_do_lap_event(self, LM_LAP_IDLE_TIMEOUT, NULL);
207 }
208
209 /*
210  * Send an event on all LSAPs attached to this LAP.
211  */
212 static inline void
213 irlmp_do_all_lsap_event(hashbin_t *     lsap_hashbin,
214                         IRLMP_EVENT     event)
215 {
216         struct lsap_cb *lsap;
217         struct lsap_cb *lsap_next;
218
219         /* Note : this function use the new hashbin_find_next()
220          * function, instead of the old hashbin_get_next().
221          * This make sure that we are always pointing one lsap
222          * ahead, so that if the current lsap is removed as the
223          * result of sending the event, we don't care.
224          * Also, as we store the context ourselves, if an enumeration
225          * of the same lsap hashbin happens as the result of sending the
226          * event, we don't care.
227          * The only problem is if the next lsap is removed. In that case,
228          * hashbin_find_next() will return NULL and we will abort the
229          * enumeration. - Jean II */
230
231         /* Also : we don't accept any skb in input. We can *NOT* pass
232          * the same skb to multiple clients safely, we would need to
233          * skb_clone() it. - Jean II */
234
235         lsap = (struct lsap_cb *) hashbin_get_first(lsap_hashbin);
236
237         while (NULL != hashbin_find_next(lsap_hashbin,
238                                          (long) lsap,
239                                          NULL,
240                                          (void *) &lsap_next) ) {
241                 irlmp_do_lsap_event(lsap, event, NULL);
242                 lsap = lsap_next;
243         }
244 }
245
246 /*********************************************************************
247  *
248  *    LAP connection control states
249  *
250  ********************************************************************/
251
252 /*
253  * Function irlmp_state_standby (event, skb, info)
254  *
255  *    STANDBY, The IrLAP connection does not exist.
256  *
257  */
258 static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event,
259                                 struct sk_buff *skb)
260 {
261         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
262         IRDA_ASSERT(self->irlap != NULL, return;);
263
264         switch (event) {
265         case LM_LAP_DISCOVERY_REQUEST:
266                 /* irlmp_next_station_state( LMP_DISCOVER); */
267
268                 irlap_discovery_request(self->irlap, &irlmp->discovery_cmd);
269                 break;
270         case LM_LAP_CONNECT_INDICATION:
271                 /*  It's important to switch state first, to avoid IrLMP to
272                  *  think that the link is free since IrLMP may then start
273                  *  discovery before the connection is properly set up. DB.
274                  */
275                 irlmp_next_lap_state(self, LAP_ACTIVE);
276
277                 /* Just accept connection TODO, this should be fixed */
278                 irlap_connect_response(self->irlap, skb);
279                 break;
280         case LM_LAP_CONNECT_REQUEST:
281                 IRDA_DEBUG(4, "%s() LS_CONNECT_REQUEST\n", __FUNCTION__);
282
283                 irlmp_next_lap_state(self, LAP_U_CONNECT);
284
285                 /* FIXME: need to set users requested QoS */
286                 irlap_connect_request(self->irlap, self->daddr, NULL, 0);
287                 break;
288         case LM_LAP_DISCONNECT_INDICATION:
289                 IRDA_DEBUG(4, "%s(), Error LM_LAP_DISCONNECT_INDICATION\n",
290                            __FUNCTION__);
291
292                 irlmp_next_lap_state(self, LAP_STANDBY);
293                 break;
294         default:
295                 IRDA_DEBUG(0, "%s(), Unknown event %s\n",
296                            __FUNCTION__, irlmp_event[event]);
297                 break;
298         }
299 }
300
301 /*
302  * Function irlmp_state_u_connect (event, skb, info)
303  *
304  *    U_CONNECT, The layer above has tried to open an LSAP connection but
305  *    since the IrLAP connection does not exist, we must first start an
306  *    IrLAP connection. We are now waiting response from IrLAP.
307  * */
308 static void irlmp_state_u_connect(struct lap_cb *self, IRLMP_EVENT event,
309                                   struct sk_buff *skb)
310 {
311         IRDA_DEBUG(2, "%s(), event=%s\n", __FUNCTION__, irlmp_event[event]);
312
313         switch (event) {
314         case LM_LAP_CONNECT_INDICATION:
315                 /*  It's important to switch state first, to avoid IrLMP to
316                  *  think that the link is free since IrLMP may then start
317                  *  discovery before the connection is properly set up. DB.
318                  */
319                 irlmp_next_lap_state(self, LAP_ACTIVE);
320
321                 /* Just accept connection TODO, this should be fixed */
322                 irlap_connect_response(self->irlap, skb);
323
324                 /* Tell LSAPs that they can start sending data */
325                 irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM);
326
327                 /* Note : by the time we get there (LAP retries and co),
328                  * the lsaps may already have gone. This avoid getting stuck
329                  * forever in LAP_ACTIVE state - Jean II */
330                 if (HASHBIN_GET_SIZE(self->lsaps) == 0) {
331                         IRDA_DEBUG(0, "%s() NO LSAPs !\n",  __FUNCTION__);
332                         irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT);
333                 }
334                 break;
335         case LM_LAP_CONNECT_REQUEST:
336                 /* Already trying to connect */
337                 break;
338         case LM_LAP_CONNECT_CONFIRM:
339                 /* For all lsap_ce E Associated do LS_Connect_confirm */
340                 irlmp_next_lap_state(self, LAP_ACTIVE);
341
342                 /* Tell LSAPs that they can start sending data */
343                 irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM);
344
345                 /* Note : by the time we get there (LAP retries and co),
346                  * the lsaps may already have gone. This avoid getting stuck
347                  * forever in LAP_ACTIVE state - Jean II */
348                 if (HASHBIN_GET_SIZE(self->lsaps) == 0) {
349                         IRDA_DEBUG(0, "%s() NO LSAPs !\n",  __FUNCTION__);
350                         irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT);
351                 }
352                 break;
353         case LM_LAP_DISCONNECT_INDICATION:
354                 IRDA_DEBUG(4, "%s(), LM_LAP_DISCONNECT_INDICATION\n",  __FUNCTION__);
355                 irlmp_next_lap_state(self, LAP_STANDBY);
356
357                 /* Send disconnect event to all LSAPs using this link */
358                 irlmp_do_all_lsap_event(self->lsaps,
359                                         LM_LAP_DISCONNECT_INDICATION);
360                 break;
361         case LM_LAP_DISCONNECT_REQUEST:
362                 IRDA_DEBUG(4, "%s(), LM_LAP_DISCONNECT_REQUEST\n",  __FUNCTION__);
363
364                 /* One of the LSAP did timeout or was closed, if it was
365                  * the last one, try to get out of here - Jean II */
366                 if (HASHBIN_GET_SIZE(self->lsaps) <= 1) {
367                         irlap_disconnect_request(self->irlap);
368                 }
369                 break;
370         default:
371                 IRDA_DEBUG(0, "%s(), Unknown event %s\n",
372                          __FUNCTION__, irlmp_event[event]);
373                 break;
374         }
375 }
376
377 /*
378  * Function irlmp_state_active (event, skb, info)
379  *
380  *    ACTIVE, IrLAP connection is active
381  *
382  */
383 static void irlmp_state_active(struct lap_cb *self, IRLMP_EVENT event,
384                                struct sk_buff *skb)
385 {
386         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
387
388         switch (event) {
389         case LM_LAP_CONNECT_REQUEST:
390                 IRDA_DEBUG(4, "%s(), LS_CONNECT_REQUEST\n", __FUNCTION__);
391
392                 /*
393                  * IrLAP may have a pending disconnect. We tried to close
394                  * IrLAP, but it was postponed because the link was
395                  * busy or we were still sending packets. As we now
396                  * need it, make sure it stays on. Jean II
397                  */
398                 irlap_clear_disconnect(self->irlap);
399
400                 /*
401                  *  LAP connection already active, just bounce back! Since we
402                  *  don't know which LSAP that tried to do this, we have to
403                  *  notify all LSAPs using this LAP, but that should be safe to
404                  *  do anyway.
405                  */
406                 irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM);
407
408                 /* Needed by connect indication */
409                 irlmp_do_all_lsap_event(irlmp->unconnected_lsaps,
410                                         LM_LAP_CONNECT_CONFIRM);
411                 /* Keep state */
412                 break;
413         case LM_LAP_DISCONNECT_REQUEST:
414                 /*
415                  *  Need to find out if we should close IrLAP or not. If there
416                  *  is only one LSAP connection left on this link, that LSAP
417                  *  must be the one that tries to close IrLAP. It will be
418                  *  removed later and moved to the list of unconnected LSAPs
419                  */
420                 if (HASHBIN_GET_SIZE(self->lsaps) > 0) {
421                         /* Timer value is checked in irsysctl - Jean II */
422                         irlmp_start_idle_timer(self, sysctl_lap_keepalive_time * HZ / 1000);
423                 } else {
424                         /* No more connections, so close IrLAP */
425
426                         /* We don't want to change state just yet, because
427                          * we want to reflect accurately the real state of
428                          * the LAP, not the state we wish it was in,
429                          * so that we don't lose LM_LAP_CONNECT_REQUEST.
430                          * In some cases, IrLAP won't close the LAP
431                          * immediately. For example, it might still be
432                          * retrying packets or waiting for the pf bit.
433                          * As the LAP always send a DISCONNECT_INDICATION
434                          * in PCLOSE or SCLOSE, just change state on that.
435                          * Jean II */
436                         irlap_disconnect_request(self->irlap);
437                 }
438                 break;
439         case LM_LAP_IDLE_TIMEOUT:
440                 if (HASHBIN_GET_SIZE(self->lsaps) == 0) {
441                         /* Same reasoning as above - keep state */
442                         irlap_disconnect_request(self->irlap);
443                 }
444                 break;
445         case LM_LAP_DISCONNECT_INDICATION:
446                 irlmp_next_lap_state(self, LAP_STANDBY);
447
448                 /* In some case, at this point our side has already closed
449                  * all lsaps, and we are waiting for the idle_timer to
450                  * expire. If another device reconnect immediately, the
451                  * idle timer will expire in the midle of the connection
452                  * initialisation, screwing up things a lot...
453                  * Therefore, we must stop the timer... */
454                 irlmp_stop_idle_timer(self);
455
456                 /*
457                  *  Inform all connected LSAP's using this link
458                  */
459                 irlmp_do_all_lsap_event(self->lsaps,
460                                         LM_LAP_DISCONNECT_INDICATION);
461
462                 /* Force an expiry of the discovery log.
463                  * Now that the LAP is free, the system may attempt to
464                  * connect to another device. Unfortunately, our entries
465                  * are stale. There is a small window (<3s) before the
466                  * normal discovery will run and where irlmp_connect_request()
467                  * can get the wrong info, so make sure things get
468                  * cleaned *NOW* ;-) - Jean II */
469                 irlmp_do_expiry();
470                 break;
471         default:
472                 IRDA_DEBUG(0, "%s(), Unknown event %s\n",
473                          __FUNCTION__, irlmp_event[event]);
474                 break;
475         }
476 }
477
478 /*********************************************************************
479  *
480  *    LSAP connection control states
481  *
482  ********************************************************************/
483
484 /*
485  * Function irlmp_state_disconnected (event, skb, info)
486  *
487  *    DISCONNECTED
488  *
489  */
490 static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event,
491                                     struct sk_buff *skb)
492 {
493         int ret = 0;
494
495         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
496
497         IRDA_ASSERT(self != NULL, return -1;);
498         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
499
500         switch (event) {
501 #ifdef CONFIG_IRDA_ULTRA
502         case LM_UDATA_INDICATION:
503                 /* This is most bizzare. Those packets are  aka unreliable
504                  * connected, aka IrLPT or SOCK_DGRAM/IRDAPROTO_UNITDATA.
505                  * Why do we pass them as Ultra ??? Jean II */
506                 irlmp_connless_data_indication(self, skb);
507                 break;
508 #endif /* CONFIG_IRDA_ULTRA */
509         case LM_CONNECT_REQUEST:
510                 IRDA_DEBUG(4, "%s(), LM_CONNECT_REQUEST\n", __FUNCTION__);
511
512                 if (self->conn_skb) {
513                         IRDA_WARNING("%s: busy with another request!\n",
514                                      __FUNCTION__);
515                         return -EBUSY;
516                 }
517                 /* Don't forget to refcount it (see irlmp_connect_request()) */
518                 skb_get(skb);
519                 self->conn_skb = skb;
520
521                 irlmp_next_lsap_state(self, LSAP_SETUP_PEND);
522
523                 /* Start watchdog timer (5 secs for now) */
524                 irlmp_start_watchdog_timer(self, 5*HZ);
525
526                 irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL);
527                 break;
528         case LM_CONNECT_INDICATION:
529                 if (self->conn_skb) {
530                         IRDA_WARNING("%s: busy with another request!\n",
531                                      __FUNCTION__);
532                         return -EBUSY;
533                 }
534                 /* Don't forget to refcount it (see irlap_driver_rcv()) */
535                 skb_get(skb);
536                 self->conn_skb = skb;
537
538                 irlmp_next_lsap_state(self, LSAP_CONNECT_PEND);
539
540                 /* Start watchdog timer
541                  * This is not mentionned in the spec, but there is a rare
542                  * race condition that can get the socket stuck.
543                  * If we receive this event while our LAP is closing down,
544                  * the LM_LAP_CONNECT_REQUEST get lost and we get stuck in
545                  * CONNECT_PEND state forever.
546                  * The other cause of getting stuck down there is if the
547                  * higher layer never reply to the CONNECT_INDICATION.
548                  * Anyway, it make sense to make sure that we always have
549                  * a backup plan. 1 second is plenty (should be immediate).
550                  * Jean II */
551                 irlmp_start_watchdog_timer(self, 1*HZ);
552
553                 irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL);
554                 break;
555         default:
556                 IRDA_DEBUG(1, "%s(), Unknown event %s on LSAP %#02x\n",
557                            __FUNCTION__, irlmp_event[event], self->slsap_sel);
558                 break;
559         }
560         return ret;
561 }
562
563 /*
564  * Function irlmp_state_connect (self, event, skb)
565  *
566  *    CONNECT
567  *
568  */
569 static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event,
570                                 struct sk_buff *skb)
571 {
572         struct lsap_cb *lsap;
573         int ret = 0;
574
575         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
576
577         IRDA_ASSERT(self != NULL, return -1;);
578         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
579
580         switch (event) {
581         case LM_CONNECT_RESPONSE:
582                 /*
583                  *  Bind this LSAP to the IrLAP link where the connect was
584                  *  received
585                  */
586                 lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self,
587                                       NULL);
588
589                 IRDA_ASSERT(lsap == self, return -1;);
590                 IRDA_ASSERT(self->lap != NULL, return -1;);
591                 IRDA_ASSERT(self->lap->lsaps != NULL, return -1;);
592
593                 hashbin_insert(self->lap->lsaps, (irda_queue_t *) self,
594                                (long) self, NULL);
595
596                 set_bit(0, &self->connected);   /* TRUE */
597
598                 irlmp_send_lcf_pdu(self->lap, self->dlsap_sel,
599                                    self->slsap_sel, CONNECT_CNF, skb);
600
601                 del_timer(&self->watchdog_timer);
602
603                 irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY);
604                 break;
605         case LM_WATCHDOG_TIMEOUT:
606                 /* May happen, who knows...
607                  * Jean II */
608                 IRDA_DEBUG(0, "%s() WATCHDOG_TIMEOUT!\n",  __FUNCTION__);
609
610                 /* Disconnect, get out... - Jean II */
611                 self->lap = NULL;
612                 self->dlsap_sel = LSAP_ANY;
613                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
614                 break;
615         default:
616                 /* LM_LAP_DISCONNECT_INDICATION : Should never happen, we
617                  * are *not* yet bound to the IrLAP link. Jean II */
618                 IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n", 
619                            __FUNCTION__, irlmp_event[event], self->slsap_sel);
620                 break;
621         }
622         return ret;
623 }
624
625 /*
626  * Function irlmp_state_connect_pend (event, skb, info)
627  *
628  *    CONNECT_PEND
629  *
630  */
631 static int irlmp_state_connect_pend(struct lsap_cb *self, IRLMP_EVENT event,
632                                     struct sk_buff *skb)
633 {
634         struct sk_buff *tx_skb;
635         int ret = 0;
636
637         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
638
639         IRDA_ASSERT(self != NULL, return -1;);
640         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
641
642         switch (event) {
643         case LM_CONNECT_REQUEST:
644                 /* Keep state */
645                 break;
646         case LM_CONNECT_RESPONSE:
647                 IRDA_DEBUG(0, "%s(), LM_CONNECT_RESPONSE, "
648                            "no indication issued yet\n",  __FUNCTION__);
649                 /* Keep state */
650                 break;
651         case LM_DISCONNECT_REQUEST:
652                 IRDA_DEBUG(0, "%s(), LM_DISCONNECT_REQUEST, "
653                            "not yet bound to IrLAP connection\n",  __FUNCTION__);
654                 /* Keep state */
655                 break;
656         case LM_LAP_CONNECT_CONFIRM:
657                 IRDA_DEBUG(4, "%s(), LS_CONNECT_CONFIRM\n",  __FUNCTION__);
658                 irlmp_next_lsap_state(self, LSAP_CONNECT);
659
660                 tx_skb = self->conn_skb;
661                 self->conn_skb = NULL;
662
663                 irlmp_connect_indication(self, tx_skb);
664                 /* Drop reference count - see irlmp_connect_indication(). */
665                 dev_kfree_skb(tx_skb);
666                 break;
667         case LM_WATCHDOG_TIMEOUT:
668                 /* Will happen in some rare cases because of a race condition.
669                  * Just make sure we don't stay there forever...
670                  * Jean II */
671                 IRDA_DEBUG(0, "%s() WATCHDOG_TIMEOUT!\n",  __FUNCTION__);
672
673                 /* Go back to disconnected mode, keep the socket waiting */
674                 self->lap = NULL;
675                 self->dlsap_sel = LSAP_ANY;
676                 if(self->conn_skb)
677                         dev_kfree_skb(self->conn_skb);
678                 self->conn_skb = NULL;
679                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
680                 break;
681         default:
682                 /* LM_LAP_DISCONNECT_INDICATION : Should never happen, we
683                  * are *not* yet bound to the IrLAP link. Jean II */
684                 IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
685                            __FUNCTION__, irlmp_event[event], self->slsap_sel);
686                 break;
687         }
688         return ret;
689 }
690
691 /*
692  * Function irlmp_state_dtr (self, event, skb)
693  *
694  *    DATA_TRANSFER_READY
695  *
696  */
697 static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event,
698                            struct sk_buff *skb)
699 {
700         LM_REASON reason;
701         int ret = 0;
702
703         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
704
705         IRDA_ASSERT(self != NULL, return -1;);
706         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
707         IRDA_ASSERT(self->lap != NULL, return -1;);
708
709         switch (event) {
710         case LM_DATA_REQUEST: /* Optimize for the common case */
711                 irlmp_send_data_pdu(self->lap, self->dlsap_sel,
712                                     self->slsap_sel, FALSE, skb);
713                 break;
714         case LM_DATA_INDICATION: /* Optimize for the common case */
715                 irlmp_data_indication(self, skb);
716                 break;
717         case LM_UDATA_REQUEST:
718                 IRDA_ASSERT(skb != NULL, return -1;);
719                 irlmp_send_data_pdu(self->lap, self->dlsap_sel,
720                                     self->slsap_sel, TRUE, skb);
721                 break;
722         case LM_UDATA_INDICATION:
723                 irlmp_udata_indication(self, skb);
724                 break;
725         case LM_CONNECT_REQUEST:
726                 IRDA_DEBUG(0, "%s(), LM_CONNECT_REQUEST, "
727                            "error, LSAP already connected\n", __FUNCTION__);
728                 /* Keep state */
729                 break;
730         case LM_CONNECT_RESPONSE:
731                 IRDA_DEBUG(0, "%s(), LM_CONNECT_RESPONSE, "
732                            "error, LSAP already connected\n", __FUNCTION__);
733                 /* Keep state */
734                 break;
735         case LM_DISCONNECT_REQUEST:
736                 irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, self->slsap_sel,
737                                    DISCONNECT, skb);
738                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
739                 /* Called only from irlmp_disconnect_request(), will
740                  * unbind from LAP over there. Jean II */
741
742                 /* Try to close the LAP connection if its still there */
743                 if (self->lap) {
744                         IRDA_DEBUG(4, "%s(), trying to close IrLAP\n",
745                                    __FUNCTION__);
746                         irlmp_do_lap_event(self->lap,
747                                            LM_LAP_DISCONNECT_REQUEST,
748                                            NULL);
749                 }
750                 break;
751         case LM_LAP_DISCONNECT_INDICATION:
752                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
753
754                 reason = irlmp_convert_lap_reason(self->lap->reason);
755
756                 irlmp_disconnect_indication(self, reason, NULL);
757                 break;
758         case LM_DISCONNECT_INDICATION:
759                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
760
761                 IRDA_ASSERT(self->lap != NULL, return -1;);
762                 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
763
764                 IRDA_ASSERT(skb != NULL, return -1;);
765                 IRDA_ASSERT(skb->len > 3, return -1;);
766                 reason = skb->data[3];
767
768                  /* Try to close the LAP connection */
769                 IRDA_DEBUG(4, "%s(), trying to close IrLAP\n", __FUNCTION__);
770                 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
771
772                 irlmp_disconnect_indication(self, reason, skb);
773                 break;
774         default:
775                 IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
776                            __FUNCTION__, irlmp_event[event], self->slsap_sel);
777                 break;
778         }
779         return ret;
780 }
781
782 /*
783  * Function irlmp_state_setup (event, skb, info)
784  *
785  *    SETUP, Station Control has set up the underlying IrLAP connection.
786  *    An LSAP connection request has been transmitted to the peer
787  *    LSAP-Connection Control FSM and we are awaiting reply.
788  */
789 static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event,
790                              struct sk_buff *skb)
791 {
792         LM_REASON reason;
793         int ret = 0;
794
795         IRDA_ASSERT(self != NULL, return -1;);
796         IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
797
798         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
799
800         switch (event) {
801         case LM_CONNECT_CONFIRM:
802                 irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY);
803
804                 del_timer(&self->watchdog_timer);
805
806                 irlmp_connect_confirm(self, skb);
807                 break;
808         case LM_DISCONNECT_INDICATION:
809                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
810
811                 IRDA_ASSERT(self->lap != NULL, return -1;);
812                 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
813
814                 IRDA_ASSERT(skb != NULL, return -1;);
815                 IRDA_ASSERT(skb->len > 3, return -1;);
816                 reason = skb->data[3];
817
818                  /* Try to close the LAP connection */
819                 IRDA_DEBUG(4, "%s(), trying to close IrLAP\n",  __FUNCTION__);
820                 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
821
822                 irlmp_disconnect_indication(self, reason, skb);
823                 break;
824         case LM_LAP_DISCONNECT_INDICATION:
825                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
826
827                 del_timer(&self->watchdog_timer);
828
829                 IRDA_ASSERT(self->lap != NULL, return -1;);
830                 IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
831
832                 reason = irlmp_convert_lap_reason(self->lap->reason);
833
834                 irlmp_disconnect_indication(self, reason, skb);
835                 break;
836         case LM_WATCHDOG_TIMEOUT:
837                 IRDA_DEBUG(0, "%s() WATCHDOG_TIMEOUT!\n", __FUNCTION__);
838
839                 IRDA_ASSERT(self->lap != NULL, return -1;);
840                 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
841                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
842
843                 irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL);
844                 break;
845         default:
846                 IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
847                            __FUNCTION__, irlmp_event[event], self->slsap_sel);
848                 break;
849         }
850         return ret;
851 }
852
853 /*
854  * Function irlmp_state_setup_pend (event, skb, info)
855  *
856  *    SETUP_PEND, An LM_CONNECT_REQUEST has been received from the service
857  *    user to set up an LSAP connection. A request has been sent to the
858  *    LAP FSM to set up the underlying IrLAP connection, and we
859  *    are awaiting confirm.
860  */
861 static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event,
862                                   struct sk_buff *skb)
863 {
864         struct sk_buff *tx_skb;
865         LM_REASON reason;
866         int ret = 0;
867
868         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
869
870         IRDA_ASSERT(self != NULL, return -1;);
871         IRDA_ASSERT(irlmp != NULL, return -1;);
872
873         switch (event) {
874         case LM_LAP_CONNECT_CONFIRM:
875                 IRDA_ASSERT(self->conn_skb != NULL, return -1;);
876
877                 tx_skb = self->conn_skb;
878                 self->conn_skb = NULL;
879
880                 irlmp_send_lcf_pdu(self->lap, self->dlsap_sel,
881                                    self->slsap_sel, CONNECT_CMD, tx_skb);
882                 /* Drop reference count - see irlap_data_request(). */
883                 dev_kfree_skb(tx_skb);
884
885                 irlmp_next_lsap_state(self, LSAP_SETUP);
886                 break;
887         case LM_WATCHDOG_TIMEOUT:
888                 IRDA_DEBUG(0, "%s() : WATCHDOG_TIMEOUT !\n",  __FUNCTION__);
889
890                 IRDA_ASSERT(self->lap != NULL, return -1;);
891                 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
892                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
893
894                 irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL);
895                 break;
896         case LM_LAP_DISCONNECT_INDICATION: /* LS_Disconnect.indication */
897                 del_timer( &self->watchdog_timer);
898
899                 irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
900
901                 reason = irlmp_convert_lap_reason(self->lap->reason);
902
903                 irlmp_disconnect_indication(self, reason, NULL);
904                 break;
905         default:
906                 IRDA_DEBUG(0, "%s(), Unknown event %s on LSAP %#02x\n",
907                            __FUNCTION__, irlmp_event[event], self->slsap_sel);
908                 break;
909         }
910         return ret;
911 }