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