[DCCP]: Fix leak in net/dccp/ipv4.c
[linux-2.6.git] / net / irda / irlap_event.c
1 /*********************************************************************
2  *
3  * Filename:      irlap_event.c
4  * Version:       0.9
5  * Description:   IrLAP state machine implementation
6  * Status:        Experimental.
7  * Author:        Dag Brattli <dag@brattli.net>
8  * Created at:    Sat Aug 16 00:59:29 1997
9  * Modified at:   Sat Dec 25 21:07:57 1999
10  * Modified by:   Dag Brattli <dag@brattli.net>
11  *
12  *     Copyright (c) 1998-2000 Dag Brattli <dag@brattli.net>,
13  *     Copyright (c) 1998      Thomas Davis <ratbert@radiks.net>
14  *     All Rights Reserved.
15  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
16  *
17  *     This program is free software; you can redistribute it and/or
18  *     modify it under the terms of the GNU General Public License as
19  *     published by the Free Software Foundation; either version 2 of
20  *     the License, or (at your option) any later version.
21  *
22  *     Neither Dag Brattli nor University of Tromsø admit liability nor
23  *     provide warranty for any of this software. This material is
24  *     provided "AS-IS" and at no charge.
25  *
26  ********************************************************************/
27
28 #include <linux/config.h>
29 #include <linux/string.h>
30 #include <linux/kernel.h>
31 #include <linux/delay.h>
32 #include <linux/skbuff.h>
33
34 #include <net/irda/irda.h>
35 #include <net/irda/irlap_event.h>
36
37 #include <net/irda/timer.h>
38 #include <net/irda/irlap.h>
39 #include <net/irda/irlap_frame.h>
40 #include <net/irda/qos.h>
41 #include <net/irda/parameters.h>
42 #include <net/irda/irlmp.h>             /* irlmp_flow_indication(), ... */
43
44 #include <net/irda/irda_device.h>
45
46 #ifdef CONFIG_IRDA_FAST_RR
47 int sysctl_fast_poll_increase = 50;
48 #endif
49
50 static int irlap_state_ndm    (struct irlap_cb *self, IRLAP_EVENT event,
51                                struct sk_buff *skb, struct irlap_info *info);
52 static int irlap_state_query  (struct irlap_cb *self, IRLAP_EVENT event,
53                                struct sk_buff *skb, struct irlap_info *info);
54 static int irlap_state_reply  (struct irlap_cb *self, IRLAP_EVENT event,
55                                struct sk_buff *skb, struct irlap_info *info);
56 static int irlap_state_conn   (struct irlap_cb *self, IRLAP_EVENT event,
57                                struct sk_buff *skb, struct irlap_info *info);
58 static int irlap_state_setup  (struct irlap_cb *self, IRLAP_EVENT event,
59                                struct sk_buff *skb, struct irlap_info *info);
60 static int irlap_state_offline(struct irlap_cb *self, IRLAP_EVENT event,
61                                struct sk_buff *skb, struct irlap_info *info);
62 static int irlap_state_xmit_p (struct irlap_cb *self, IRLAP_EVENT event,
63                                struct sk_buff *skb, struct irlap_info *info);
64 static int irlap_state_pclose (struct irlap_cb *self, IRLAP_EVENT event,
65                                struct sk_buff *skb, struct irlap_info *info);
66 static int irlap_state_nrm_p  (struct irlap_cb *self, IRLAP_EVENT event,
67                                struct sk_buff *skb, struct irlap_info *info);
68 static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
69                                   struct sk_buff *skb, struct irlap_info *info);
70 static int irlap_state_reset  (struct irlap_cb *self, IRLAP_EVENT event,
71                                struct sk_buff *skb, struct irlap_info *info);
72 static int irlap_state_nrm_s  (struct irlap_cb *self, IRLAP_EVENT event,
73                                struct sk_buff *skb, struct irlap_info *info);
74 static int irlap_state_xmit_s (struct irlap_cb *self, IRLAP_EVENT event,
75                                struct sk_buff *skb, struct irlap_info *info);
76 static int irlap_state_sclose (struct irlap_cb *self, IRLAP_EVENT event,
77                                struct sk_buff *skb, struct irlap_info *info);
78 static int irlap_state_reset_check(struct irlap_cb *, IRLAP_EVENT event,
79                                    struct sk_buff *, struct irlap_info *);
80
81 #ifdef CONFIG_IRDA_DEBUG
82 static const char *irlap_event[] = {
83         "DISCOVERY_REQUEST",
84         "CONNECT_REQUEST",
85         "CONNECT_RESPONSE",
86         "DISCONNECT_REQUEST",
87         "DATA_REQUEST",
88         "RESET_REQUEST",
89         "RESET_RESPONSE",
90         "SEND_I_CMD",
91         "SEND_UI_FRAME",
92         "RECV_DISCOVERY_XID_CMD",
93         "RECV_DISCOVERY_XID_RSP",
94         "RECV_SNRM_CMD",
95         "RECV_TEST_CMD",
96         "RECV_TEST_RSP",
97         "RECV_UA_RSP",
98         "RECV_DM_RSP",
99         "RECV_RD_RSP",
100         "RECV_I_CMD",
101         "RECV_I_RSP",
102         "RECV_UI_FRAME",
103         "RECV_FRMR_RSP",
104         "RECV_RR_CMD",
105         "RECV_RR_RSP",
106         "RECV_RNR_CMD",
107         "RECV_RNR_RSP",
108         "RECV_REJ_CMD",
109         "RECV_REJ_RSP",
110         "RECV_SREJ_CMD",
111         "RECV_SREJ_RSP",
112         "RECV_DISC_CMD",
113         "SLOT_TIMER_EXPIRED",
114         "QUERY_TIMER_EXPIRED",
115         "FINAL_TIMER_EXPIRED",
116         "POLL_TIMER_EXPIRED",
117         "DISCOVERY_TIMER_EXPIRED",
118         "WD_TIMER_EXPIRED",
119         "BACKOFF_TIMER_EXPIRED",
120         "MEDIA_BUSY_TIMER_EXPIRED",
121 };
122 #endif  /* CONFIG_IRDA_DEBUG */
123
124 const char *irlap_state[] = {
125         "LAP_NDM",
126         "LAP_QUERY",
127         "LAP_REPLY",
128         "LAP_CONN",
129         "LAP_SETUP",
130         "LAP_OFFLINE",
131         "LAP_XMIT_P",
132         "LAP_PCLOSE",
133         "LAP_NRM_P",
134         "LAP_RESET_WAIT",
135         "LAP_RESET",
136         "LAP_NRM_S",
137         "LAP_XMIT_S",
138         "LAP_SCLOSE",
139         "LAP_RESET_CHECK",
140 };
141
142 static int (*state[])(struct irlap_cb *self, IRLAP_EVENT event,
143                       struct sk_buff *skb, struct irlap_info *info) =
144 {
145         irlap_state_ndm,
146         irlap_state_query,
147         irlap_state_reply,
148         irlap_state_conn,
149         irlap_state_setup,
150         irlap_state_offline,
151         irlap_state_xmit_p,
152         irlap_state_pclose,
153         irlap_state_nrm_p,
154         irlap_state_reset_wait,
155         irlap_state_reset,
156         irlap_state_nrm_s,
157         irlap_state_xmit_s,
158         irlap_state_sclose,
159         irlap_state_reset_check,
160 };
161
162 /*
163  * Function irda_poll_timer_expired (data)
164  *
165  *    Poll timer has expired. Normally we must now send a RR frame to the
166  *    remote device
167  */
168 static void irlap_poll_timer_expired(void *data)
169 {
170         struct irlap_cb *self = (struct irlap_cb *) data;
171
172         IRDA_ASSERT(self != NULL, return;);
173         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
174
175         irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL);
176 }
177
178 /*
179  * Calculate and set time before we will have to send back the pf bit
180  * to the peer. Use in primary.
181  * Make sure that state is XMIT_P/XMIT_S when calling this function
182  * (and that nobody messed up with the state). - Jean II
183  */
184 static void irlap_start_poll_timer(struct irlap_cb *self, int timeout)
185 {
186         IRDA_ASSERT(self != NULL, return;);
187         IRDA_ASSERT(self->magic == LAP_MAGIC, return;);
188
189 #ifdef CONFIG_IRDA_FAST_RR
190         /*
191          * Send out the RR frames faster if our own transmit queue is empty, or
192          * if the peer is busy. The effect is a much faster conversation
193          */
194         if (skb_queue_empty(&self->txq) || self->remote_busy) {
195                 if (self->fast_RR == TRUE) {
196                         /*
197                          *  Assert that the fast poll timer has not reached the
198                          *  normal poll timer yet
199                          */
200                         if (self->fast_RR_timeout < timeout) {
201                                 /*
202                                  *  FIXME: this should be a more configurable
203                                  *         function
204                                  */
205                                 self->fast_RR_timeout +=
206                                         (sysctl_fast_poll_increase * HZ/1000);
207
208                                 /* Use this fast(er) timeout instead */
209                                 timeout = self->fast_RR_timeout;
210                         }
211                 } else {
212                         self->fast_RR = TRUE;
213
214                         /* Start with just 0 ms */
215                         self->fast_RR_timeout = 0;
216                         timeout = 0;
217                 }
218         } else
219                 self->fast_RR = FALSE;
220
221         IRDA_DEBUG(3, "%s(), timeout=%d (%ld)\n", __FUNCTION__, timeout, jiffies);
222 #endif /* CONFIG_IRDA_FAST_RR */
223
224         if (timeout == 0)
225                 irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL);
226         else
227                 irda_start_timer(&self->poll_timer, timeout, self,
228                                  irlap_poll_timer_expired);
229 }
230
231 /*
232  * Function irlap_do_event (event, skb, info)
233  *
234  *    Rushes through the state machine without any delay. If state == XMIT
235  *    then send queued data frames.
236  */
237 void irlap_do_event(struct irlap_cb *self, IRLAP_EVENT event,
238                     struct sk_buff *skb, struct irlap_info *info)
239 {
240         int ret;
241
242         if (!self || self->magic != LAP_MAGIC)
243                 return;
244
245         IRDA_DEBUG(3, "%s(), event = %s, state = %s\n", __FUNCTION__,
246                    irlap_event[event], irlap_state[self->state]);
247
248         ret = (*state[self->state])(self, event, skb, info);
249
250         /*
251          *  Check if there are any pending events that needs to be executed
252          */
253         switch (self->state) {
254         case LAP_XMIT_P: /* FALLTHROUGH */
255         case LAP_XMIT_S:
256                 /*
257                  * We just received the pf bit and are at the beginning
258                  * of a new LAP transmit window.
259                  * Check if there are any queued data frames, and do not
260                  * try to disconnect link if we send any data frames, since
261                  * that will change the state away form XMIT
262                  */
263                 IRDA_DEBUG(2, "%s() : queue len = %d\n", __FUNCTION__,
264                            skb_queue_len(&self->txq));
265
266                 if (!skb_queue_empty(&self->txq)) {
267                         /* Prevent race conditions with irlap_data_request() */
268                         self->local_busy = TRUE;
269
270                         /* Theory of operation.
271                          * We send frames up to when we fill the window or
272                          * reach line capacity. Those frames will queue up
273                          * in the device queue, and the driver will slowly
274                          * send them.
275                          * After each frame that we send, we poll the higher
276                          * layer for more data. It's the right time to do
277                          * that because the link layer need to perform the mtt
278                          * and then send the first frame, so we can afford
279                          * to send a bit of time in kernel space.
280                          * The explicit flow indication allow to minimise
281                          * buffers (== lower latency), to avoid higher layer
282                          * polling via timers (== less context switches) and
283                          * to implement a crude scheduler - Jean II */
284
285                         /* Try to send away all queued data frames */
286                         while ((skb = skb_dequeue(&self->txq)) != NULL) {
287                                 /* Send one frame */
288                                 ret = (*state[self->state])(self, SEND_I_CMD,
289                                                             skb, NULL);
290                                 /* Drop reference count.
291                                  * It will be increase as needed in
292                                  * irlap_send_data_xxx() */
293                                 kfree_skb(skb);
294
295                                 /* Poll the higher layers for one more frame */
296                                 irlmp_flow_indication(self->notify.instance,
297                                                       FLOW_START);
298
299                                 if (ret == -EPROTO)
300                                         break; /* Try again later! */
301                         }
302                         /* Finished transmitting */
303                         self->local_busy = FALSE;
304                 } else if (self->disconnect_pending) {
305                         self->disconnect_pending = FALSE;
306
307                         ret = (*state[self->state])(self, DISCONNECT_REQUEST,
308                                                     NULL, NULL);
309                 }
310                 break;
311 /*      case LAP_NDM: */
312 /*      case LAP_CONN: */
313 /*      case LAP_RESET_WAIT: */
314 /*      case LAP_RESET_CHECK: */
315         default:
316                 break;
317         }
318 }
319
320 /*
321  * Function irlap_next_state (self, state)
322  *
323  *    Switches state and provides debug information
324  *
325  */
326 static inline void irlap_next_state(struct irlap_cb *self, IRLAP_STATE state)
327 {
328         /*
329         if (!self || self->magic != LAP_MAGIC)
330                 return;
331
332         IRDA_DEBUG(4, "next LAP state = %s\n", irlap_state[state]);
333         */
334         self->state = state;
335 }
336
337 /*
338  * Function irlap_state_ndm (event, skb, frame)
339  *
340  *    NDM (Normal Disconnected Mode) state
341  *
342  */
343 static int irlap_state_ndm(struct irlap_cb *self, IRLAP_EVENT event,
344                            struct sk_buff *skb, struct irlap_info *info)
345 {
346         discovery_t *discovery_rsp;
347         int ret = 0;
348
349         IRDA_ASSERT(self != NULL, return -1;);
350         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
351
352         switch (event) {
353         case CONNECT_REQUEST:
354                 IRDA_ASSERT(self->netdev != NULL, return -1;);
355
356                 if (self->media_busy) {
357                         /* Note : this will never happen, because we test
358                          * media busy in irlap_connect_request() and
359                          * postpone the event... - Jean II */
360                         IRDA_DEBUG(0, "%s(), CONNECT_REQUEST: media busy!\n",
361                                    __FUNCTION__);
362
363                         /* Always switch state before calling upper layers */
364                         irlap_next_state(self, LAP_NDM);
365
366                         irlap_disconnect_indication(self, LAP_MEDIA_BUSY);
367                 } else {
368                         irlap_send_snrm_frame(self, &self->qos_rx);
369
370                         /* Start Final-bit timer */
371                         irlap_start_final_timer(self, self->final_timeout);
372
373                         self->retry_count = 0;
374                         irlap_next_state(self, LAP_SETUP);
375                 }
376                 break;
377         case RECV_SNRM_CMD:
378                 /* Check if the frame contains and I field */
379                 if (info) {
380                         self->daddr = info->daddr;
381                         self->caddr = info->caddr;
382
383                         irlap_next_state(self, LAP_CONN);
384
385                         irlap_connect_indication(self, skb);
386                 } else {
387                         IRDA_DEBUG(0, "%s(), SNRM frame does not "
388                                    "contain an I field!\n", __FUNCTION__);
389                 }
390                 break;
391         case DISCOVERY_REQUEST:
392                 IRDA_ASSERT(info != NULL, return -1;);
393
394                 if (self->media_busy) {
395                         IRDA_DEBUG(1, "%s(), DISCOVERY_REQUEST: media busy!\n",
396                                    __FUNCTION__);
397                         /* irlap->log.condition = MEDIA_BUSY; */
398
399                         /* This will make IrLMP try again */
400                         irlap_discovery_confirm(self, NULL);
401                         /* Note : the discovery log is not cleaned up here,
402                          * it will be done in irlap_discovery_request()
403                          * Jean II */
404                         return 0;
405                 }
406
407                 self->S = info->S;
408                 self->s = info->s;
409                 irlap_send_discovery_xid_frame(self, info->S, info->s, TRUE,
410                                                info->discovery);
411                 self->frame_sent = FALSE;
412                 self->s++;
413
414                 irlap_start_slot_timer(self, self->slot_timeout);
415                 irlap_next_state(self, LAP_QUERY);
416                 break;
417         case RECV_DISCOVERY_XID_CMD:
418                 IRDA_ASSERT(info != NULL, return -1;);
419
420                 /* Assert that this is not the final slot */
421                 if (info->s <= info->S) {
422                         self->slot = irlap_generate_rand_time_slot(info->S,
423                                                                    info->s);
424                         if (self->slot == info->s) {
425                                 discovery_rsp = irlmp_get_discovery_response();
426                                 discovery_rsp->data.daddr = info->daddr;
427
428                                 irlap_send_discovery_xid_frame(self, info->S,
429                                                                self->slot,
430                                                                FALSE,
431                                                                discovery_rsp);
432                                 self->frame_sent = TRUE;
433                         } else
434                                 self->frame_sent = FALSE;
435
436                         /*
437                          * Go to reply state until end of discovery to
438                          * inhibit our own transmissions. Set the timer
439                          * to not stay forever there... Jean II
440                          */
441                         irlap_start_query_timer(self, info->S, info->s);
442                         irlap_next_state(self, LAP_REPLY);
443                 } else {
444                 /* This is the final slot. How is it possible ?
445                  * This would happen is both discoveries are just slightly
446                  * offset (if they are in sync, all packets are lost).
447                  * Most often, all the discovery requests will be received
448                  * in QUERY state (see my comment there), except for the
449                  * last frame that will come here.
450                  * The big trouble when it happen is that active discovery
451                  * doesn't happen, because nobody answer the discoveries
452                  * frame of the other guy, so the log shows up empty.
453                  * What should we do ?
454                  * Not much. It's too late to answer those discovery frames,
455                  * so we just pass the info to IrLMP who will put it in the
456                  * log (and post an event).
457                  * Another cause would be devices that do discovery much
458                  * slower than us, however the latest fixes should minimise
459                  * those cases...
460                  * Jean II
461                  */
462                         IRDA_DEBUG(1, "%s(), Receiving final discovery request, missed the discovery slots :-(\n", __FUNCTION__);
463
464                         /* Last discovery request -> in the log */
465                         irlap_discovery_indication(self, info->discovery);
466                 }
467                 break;
468         case MEDIA_BUSY_TIMER_EXPIRED:
469                 /* A bunch of events may be postponed because the media is
470                  * busy (usually immediately after we close a connection),
471                  * or while we are doing discovery (state query/reply).
472                  * In all those cases, the media busy flag will be cleared
473                  * when it's OK for us to process those postponed events.
474                  * This event is not mentioned in the state machines in the
475                  * IrLAP spec. It's because they didn't consider Ultra and
476                  * postponing connection request is optional.
477                  * Jean II */
478 #ifdef CONFIG_IRDA_ULTRA
479                 /* Send any pending Ultra frames if any */
480                 if (!skb_queue_empty(&self->txq_ultra)) {
481                         /* We don't send the frame, just post an event.
482                          * Also, previously this code was in timer.c...
483                          * Jean II */
484                         ret = (*state[self->state])(self, SEND_UI_FRAME,
485                                                     NULL, NULL);
486                 }
487 #endif /* CONFIG_IRDA_ULTRA */
488                 /* Check if we should try to connect.
489                  * This code was previously in irlap_do_event() */
490                 if (self->connect_pending) {
491                         self->connect_pending = FALSE;
492
493                         /* This one *should* not pend in this state, except
494                          * if a socket try to connect and immediately
495                          * disconnect. - clear - Jean II */
496                         if (self->disconnect_pending)
497                                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
498                         else
499                                 ret = (*state[self->state])(self,
500                                                             CONNECT_REQUEST,
501                                                             NULL, NULL);
502                         self->disconnect_pending = FALSE;
503                 }
504                 /* Note : one way to test if this code works well (including
505                  * media busy and small busy) is to create a user space
506                  * application generating an Ultra packet every 3.05 sec (or
507                  * 2.95 sec) and to see how it interact with discovery.
508                  * It's fairly easy to check that no packet is lost, that the
509                  * packets are postponed during discovery and that after
510                  * discovery indication you have a 100ms "gap".
511                  * As connection request and Ultra are now processed the same
512                  * way, this avoid the tedious job of trying IrLAP connection
513                  * in all those cases...
514                  * Jean II */
515                 break;
516 #ifdef CONFIG_IRDA_ULTRA
517         case SEND_UI_FRAME:
518         {
519                 int i;
520                 /* Only allowed to repeat an operation twice */
521                 for (i=0; ((i<2) && (self->media_busy == FALSE)); i++) {
522                         skb = skb_dequeue(&self->txq_ultra);
523                         if (skb)
524                                 irlap_send_ui_frame(self, skb, CBROADCAST,
525                                                     CMD_FRAME);
526                         else
527                                 break;
528                         /* irlap_send_ui_frame() won't increase skb reference
529                          * count, so no dev_kfree_skb() - Jean II */
530                 }
531                 if (i == 2) {
532                         /* Force us to listen 500 ms again */
533                         irda_device_set_media_busy(self->netdev, TRUE);
534                 }
535                 break;
536         }
537         case RECV_UI_FRAME:
538                 /* Only accept broadcast frames in NDM mode */
539                 if (info->caddr != CBROADCAST) {
540                         IRDA_DEBUG(0, "%s(), not a broadcast frame!\n",
541                                    __FUNCTION__);
542                 } else
543                         irlap_unitdata_indication(self, skb);
544                 break;
545 #endif /* CONFIG_IRDA_ULTRA */
546         case RECV_TEST_CMD:
547                 /* Remove test frame header */
548                 skb_pull(skb, sizeof(struct test_frame));
549
550                 /*
551                  * Send response. This skb will not be sent out again, and
552                  * will only be used to send out the same info as the cmd
553                  */
554                 irlap_send_test_frame(self, CBROADCAST, info->daddr, skb);
555                 break;
556         case RECV_TEST_RSP:
557                 IRDA_DEBUG(0, "%s() not implemented!\n", __FUNCTION__);
558                 break;
559         default:
560                 IRDA_DEBUG(2, "%s(), Unknown event %s\n", __FUNCTION__,
561                            irlap_event[event]);
562
563                 ret = -1;
564                 break;
565         }
566         return ret;
567 }
568
569 /*
570  * Function irlap_state_query (event, skb, info)
571  *
572  *    QUERY state
573  *
574  */
575 static int irlap_state_query(struct irlap_cb *self, IRLAP_EVENT event,
576                              struct sk_buff *skb, struct irlap_info *info)
577 {
578         int ret = 0;
579
580         IRDA_ASSERT(self != NULL, return -1;);
581         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
582
583         switch (event) {
584         case RECV_DISCOVERY_XID_RSP:
585                 IRDA_ASSERT(info != NULL, return -1;);
586                 IRDA_ASSERT(info->discovery != NULL, return -1;);
587
588                 IRDA_DEBUG(4, "%s(), daddr=%08x\n", __FUNCTION__,
589                            info->discovery->data.daddr);
590
591                 if (!self->discovery_log) {
592                         IRDA_WARNING("%s: discovery log is gone! "
593                                      "maybe the discovery timeout has been set"
594                                      " to short?\n", __FUNCTION__);
595                         break;
596                 }
597                 hashbin_insert(self->discovery_log,
598                                (irda_queue_t *) info->discovery,
599                                info->discovery->data.daddr, NULL);
600
601                 /* Keep state */
602                 /* irlap_next_state(self, LAP_QUERY);  */
603
604                 break;
605         case RECV_DISCOVERY_XID_CMD:
606                 /* Yes, it is possible to receive those frames in this mode.
607                  * Note that most often the last discovery request won't
608                  * occur here but in NDM state (see my comment there).
609                  * What should we do ?
610                  * Not much. We are currently performing our own discovery,
611                  * therefore we can't answer those frames. We don't want
612                  * to change state either. We just pass the info to
613                  * IrLMP who will put it in the log (and post an event).
614                  * Jean II
615                  */
616
617                 IRDA_ASSERT(info != NULL, return -1;);
618
619                 IRDA_DEBUG(1, "%s(), Receiving discovery request (s = %d) while performing discovery :-(\n", __FUNCTION__, info->s);
620
621                 /* Last discovery request ? */
622                 if (info->s == 0xff)
623                         irlap_discovery_indication(self, info->discovery);
624                 break;
625         case SLOT_TIMER_EXPIRED:
626                 /*
627                  * Wait a little longer if we detect an incoming frame. This
628                  * is not mentioned in the spec, but is a good thing to do,
629                  * since we want to work even with devices that violate the
630                  * timing requirements.
631                  */
632                 if (irda_device_is_receiving(self->netdev) && !self->add_wait) {
633                         IRDA_DEBUG(2, "%s(), device is slow to answer, "
634                                    "waiting some more!\n", __FUNCTION__);
635                         irlap_start_slot_timer(self, msecs_to_jiffies(10));
636                         self->add_wait = TRUE;
637                         return ret;
638                 }
639                 self->add_wait = FALSE;
640
641                 if (self->s < self->S) {
642                         irlap_send_discovery_xid_frame(self, self->S,
643                                                        self->s, TRUE,
644                                                        self->discovery_cmd);
645                         self->s++;
646                         irlap_start_slot_timer(self, self->slot_timeout);
647
648                         /* Keep state */
649                         irlap_next_state(self, LAP_QUERY);
650                 } else {
651                         /* This is the final slot! */
652                         irlap_send_discovery_xid_frame(self, self->S, 0xff,
653                                                        TRUE,
654                                                        self->discovery_cmd);
655
656                         /* Always switch state before calling upper layers */
657                         irlap_next_state(self, LAP_NDM);
658
659                         /*
660                          *  We are now finished with the discovery procedure,
661                          *  so now we must return the results
662                          */
663                         irlap_discovery_confirm(self, self->discovery_log);
664
665                         /* IrLMP should now have taken care of the log */
666                         self->discovery_log = NULL;
667                 }
668                 break;
669         default:
670                 IRDA_DEBUG(2, "%s(), Unknown event %s\n", __FUNCTION__,
671                            irlap_event[event]);
672
673                 ret = -1;
674                 break;
675         }
676         return ret;
677 }
678
679 /*
680  * Function irlap_state_reply (self, event, skb, info)
681  *
682  *    REPLY, we have received a XID discovery frame from a device and we
683  *    are waiting for the right time slot to send a response XID frame
684  *
685  */
686 static int irlap_state_reply(struct irlap_cb *self, IRLAP_EVENT event,
687                              struct sk_buff *skb, struct irlap_info *info)
688 {
689         discovery_t *discovery_rsp;
690         int ret=0;
691
692         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
693
694         IRDA_ASSERT(self != NULL, return -1;);
695         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
696
697         switch (event) {
698         case QUERY_TIMER_EXPIRED:
699                 IRDA_DEBUG(0, "%s(), QUERY_TIMER_EXPIRED <%ld>\n",
700                            __FUNCTION__, jiffies);
701                 irlap_next_state(self, LAP_NDM);
702                 break;
703         case RECV_DISCOVERY_XID_CMD:
704                 IRDA_ASSERT(info != NULL, return -1;);
705                 /* Last frame? */
706                 if (info->s == 0xff) {
707                         del_timer(&self->query_timer);
708
709                         /* info->log.condition = REMOTE; */
710
711                         /* Always switch state before calling upper layers */
712                         irlap_next_state(self, LAP_NDM);
713
714                         irlap_discovery_indication(self, info->discovery);
715                 } else {
716                         /* If it's our slot, send our reply */
717                         if ((info->s >= self->slot) && (!self->frame_sent)) {
718                                 discovery_rsp = irlmp_get_discovery_response();
719                                 discovery_rsp->data.daddr = info->daddr;
720
721                                 irlap_send_discovery_xid_frame(self, info->S,
722                                                                self->slot,
723                                                                FALSE,
724                                                                discovery_rsp);
725
726                                 self->frame_sent = TRUE;
727                         }
728                         /* Readjust our timer to accomodate devices
729                          * doing faster or slower discovery than us...
730                          * Jean II */
731                         irlap_start_query_timer(self, info->S, info->s);
732
733                         /* Keep state */
734                         //irlap_next_state(self, LAP_REPLY);
735                 }
736                 break;
737         default:
738                 IRDA_DEBUG(1, "%s(), Unknown event %d, %s\n", __FUNCTION__,
739                            event, irlap_event[event]);
740
741                 ret = -1;
742                 break;
743         }
744         return ret;
745 }
746
747 /*
748  * Function irlap_state_conn (event, skb, info)
749  *
750  *    CONN, we have received a SNRM command and is waiting for the upper
751  *    layer to accept or refuse connection
752  *
753  */
754 static int irlap_state_conn(struct irlap_cb *self, IRLAP_EVENT event,
755                             struct sk_buff *skb, struct irlap_info *info)
756 {
757         int ret = 0;
758
759         IRDA_DEBUG(4, "%s(), event=%s\n", __FUNCTION__, irlap_event[ event]);
760
761         IRDA_ASSERT(self != NULL, return -1;);
762         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
763
764         switch (event) {
765         case CONNECT_RESPONSE:
766                 skb_pull(skb, sizeof(struct snrm_frame));
767
768                 IRDA_ASSERT(self->netdev != NULL, return -1;);
769
770                 irlap_qos_negotiate(self, skb);
771
772                 irlap_initiate_connection_state(self);
773
774                 /*
775                  * Applying the parameters now will make sure we change speed
776                  * *after* we have sent the next frame
777                  */
778                 irlap_apply_connection_parameters(self, FALSE);
779
780                 /*
781                  * Sending this frame will force a speed change after it has
782                  * been sent (i.e. the frame will be sent at 9600).
783                  */
784                 irlap_send_ua_response_frame(self, &self->qos_rx);
785
786 #if 0
787                 /*
788                  * We are allowed to send two frames, but this may increase
789                  * the connect latency, so lets not do it for now.
790                  */
791                 /* This is full of good intentions, but doesn't work in
792                  * practice.
793                  * After sending the first UA response, we switch the
794                  * dongle to the negotiated speed, which is usually
795                  * different than 9600 kb/s.
796                  * From there, there is two solutions :
797                  * 1) The other end has received the first UA response :
798                  * it will set up the connection, move to state LAP_NRM_P,
799                  * and will ignore and drop the second UA response.
800                  * Actually, it's even worse : the other side will almost
801                  * immediately send a RR that will likely collide with the
802                  * UA response (depending on negotiated turnaround).
803                  * 2) The other end has not received the first UA response,
804                  * will stay at 9600 and will never see the second UA response.
805                  * Jean II */
806                 irlap_send_ua_response_frame(self, &self->qos_rx);
807 #endif
808
809                 /*
810                  *  The WD-timer could be set to the duration of the P-timer
811                  *  for this case, but it is recommended to use twice the
812                  *  value (note 3 IrLAP p. 60).
813                  */
814                 irlap_start_wd_timer(self, self->wd_timeout);
815                 irlap_next_state(self, LAP_NRM_S);
816
817                 break;
818         case RECV_DISCOVERY_XID_CMD:
819                 IRDA_DEBUG(3, "%s(), event RECV_DISCOVER_XID_CMD!\n",
820                            __FUNCTION__);
821                 irlap_next_state(self, LAP_NDM);
822
823                 break;
824         case DISCONNECT_REQUEST:
825                 IRDA_DEBUG(0, "%s(), Disconnect request!\n", __FUNCTION__);
826                 irlap_send_dm_frame(self);
827                 irlap_next_state( self, LAP_NDM);
828                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
829                 break;
830         default:
831                 IRDA_DEBUG(1, "%s(), Unknown event %d, %s\n", __FUNCTION__, 
832                            event, irlap_event[event]);
833
834                 ret = -1;
835                 break;
836         }
837
838         return ret;
839 }
840
841 /*
842  * Function irlap_state_setup (event, skb, frame)
843  *
844  *    SETUP state, The local layer has transmitted a SNRM command frame to
845  *    a remote peer layer and is awaiting a reply .
846  *
847  */
848 static int irlap_state_setup(struct irlap_cb *self, IRLAP_EVENT event,
849                              struct sk_buff *skb, struct irlap_info *info)
850 {
851         int ret = 0;
852
853         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
854
855         IRDA_ASSERT(self != NULL, return -1;);
856         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
857
858         switch (event) {
859         case FINAL_TIMER_EXPIRED:
860                 if (self->retry_count < self->N3) {
861 /*
862  *  Perform random backoff, Wait a random number of time units, minimum
863  *  duration half the time taken to transmitt a SNRM frame, maximum duration
864  *  1.5 times the time taken to transmit a SNRM frame. So this time should
865  *  between 15 msecs and 45 msecs.
866  */
867                         irlap_start_backoff_timer(self, msecs_to_jiffies(20 +
868                                                         (jiffies % 30)));
869                 } else {
870                         /* Always switch state before calling upper layers */
871                         irlap_next_state(self, LAP_NDM);
872
873                         irlap_disconnect_indication(self, LAP_FOUND_NONE);
874                 }
875                 break;
876         case BACKOFF_TIMER_EXPIRED:
877                 irlap_send_snrm_frame(self, &self->qos_rx);
878                 irlap_start_final_timer(self, self->final_timeout);
879                 self->retry_count++;
880                 break;
881         case RECV_SNRM_CMD:
882                 IRDA_DEBUG(4, "%s(), SNRM battle!\n", __FUNCTION__);
883
884                 IRDA_ASSERT(skb != NULL, return 0;);
885                 IRDA_ASSERT(info != NULL, return 0;);
886
887                 /*
888                  *  The device with the largest device address wins the battle
889                  *  (both have sent a SNRM command!)
890                  */
891                 if (info &&(info->daddr > self->saddr)) {
892                         del_timer(&self->final_timer);
893                         irlap_initiate_connection_state(self);
894
895                         IRDA_ASSERT(self->netdev != NULL, return -1;);
896
897                         skb_pull(skb, sizeof(struct snrm_frame));
898
899                         irlap_qos_negotiate(self, skb);
900
901                         /* Send UA frame and then change link settings */
902                         irlap_apply_connection_parameters(self, FALSE);
903                         irlap_send_ua_response_frame(self, &self->qos_rx);
904
905                         irlap_next_state(self, LAP_NRM_S);
906                         irlap_connect_confirm(self, skb);
907
908                         /*
909                          *  The WD-timer could be set to the duration of the
910                          *  P-timer for this case, but it is recommended
911                          *  to use twice the value (note 3 IrLAP p. 60).
912                          */
913                         irlap_start_wd_timer(self, self->wd_timeout);
914                 } else {
915                         /* We just ignore the other device! */
916                         irlap_next_state(self, LAP_SETUP);
917                 }
918                 break;
919         case RECV_UA_RSP:
920                 /* Stop F-timer */
921                 del_timer(&self->final_timer);
922
923                 /* Initiate connection state */
924                 irlap_initiate_connection_state(self);
925
926                 /* Negotiate connection parameters */
927                 IRDA_ASSERT(skb->len > 10, return -1;);
928
929                 skb_pull(skb, sizeof(struct ua_frame));
930
931                 IRDA_ASSERT(self->netdev != NULL, return -1;);
932
933                 irlap_qos_negotiate(self, skb);
934
935                 /* Set the new link setting *now* (before the rr frame) */
936                 irlap_apply_connection_parameters(self, TRUE);
937                 self->retry_count = 0;
938
939                 /* Wait for turnaround time to give a chance to the other
940                  * device to be ready to receive us.
941                  * Note : the time to switch speed is typically larger
942                  * than the turnaround time, but as we don't have the other
943                  * side speed switch time, that's our best guess...
944                  * Jean II */
945                 irlap_wait_min_turn_around(self, &self->qos_tx);
946
947                 /* This frame will actually be sent at the new speed */
948                 irlap_send_rr_frame(self, CMD_FRAME);
949
950                 /* The timer is set to half the normal timer to quickly
951                  * detect a failure to negociate the new connection
952                  * parameters. IrLAP 6.11.3.2, note 3.
953                  * Note that currently we don't process this failure
954                  * properly, as we should do a quick disconnect.
955                  * Jean II */
956                 irlap_start_final_timer(self, self->final_timeout/2);
957                 irlap_next_state(self, LAP_NRM_P);
958
959                 irlap_connect_confirm(self, skb);
960                 break;
961         case RECV_DM_RSP:     /* FALLTHROUGH */
962         case RECV_DISC_CMD:
963                 del_timer(&self->final_timer);
964                 irlap_next_state(self, LAP_NDM);
965
966                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
967                 break;
968         default:
969                 IRDA_DEBUG(1, "%s(), Unknown event %d, %s\n", __FUNCTION__,
970                            event, irlap_event[event]);
971
972                 ret = -1;
973                 break;
974         }
975         return ret;
976 }
977
978 /*
979  * Function irlap_state_offline (self, event, skb, info)
980  *
981  *    OFFLINE state, not used for now!
982  *
983  */
984 static int irlap_state_offline(struct irlap_cb *self, IRLAP_EVENT event,
985                                struct sk_buff *skb, struct irlap_info *info)
986 {
987         IRDA_DEBUG( 0, "%s(), Unknown event\n", __FUNCTION__);
988
989         return -1;
990 }
991
992 /*
993  * Function irlap_state_xmit_p (self, event, skb, info)
994  *
995  *    XMIT, Only the primary station has right to transmit, and we
996  *    therefore do not expect to receive any transmissions from other
997  *    stations.
998  *
999  */
1000 static int irlap_state_xmit_p(struct irlap_cb *self, IRLAP_EVENT event,
1001                               struct sk_buff *skb, struct irlap_info *info)
1002 {
1003         int ret = 0;
1004
1005         switch (event) {
1006         case SEND_I_CMD:
1007                 /*
1008                  *  Only send frame if send-window > 0.
1009                  */
1010                 if ((self->window > 0) && (!self->remote_busy)) {
1011                         int nextfit;
1012 #ifdef CONFIG_IRDA_DYNAMIC_WINDOW
1013                         struct sk_buff *skb_next;
1014
1015                         /* With DYNAMIC_WINDOW, we keep the window size
1016                          * maximum, and adapt on the packets we are sending.
1017                          * At 115k, we can send only 2 packets of 2048 bytes
1018                          * in a 500 ms turnaround. Without this option, we
1019                          * would always limit the window to 2. With this
1020                          * option, if we send smaller packets, we can send
1021                          * up to 7 of them (always depending on QoS).
1022                          * Jean II */
1023
1024                         /* Look at the next skb. This is safe, as we are
1025                          * the only consumer of the Tx queue (if we are not,
1026                          * we have other problems) - Jean II */
1027                         skb_next = skb_peek(&self->txq);
1028
1029                         /* Check if a subsequent skb exist and would fit in
1030                          * the current window (with respect to turnaround
1031                          * time).
1032                          * This allow us to properly mark the current packet
1033                          * with the pf bit, to avoid falling back on the
1034                          * second test below, and avoid waiting the
1035                          * end of the window and sending a extra RR.
1036                          * Note : (skb_next != NULL) <=> (skb_queue_len() > 0)
1037                          * Jean II */
1038                         nextfit = ((skb_next != NULL) &&
1039                                    ((skb_next->len + skb->len) <=
1040                                     self->bytes_left));
1041
1042                         /*
1043                          * The current packet may not fit ! Because of test
1044                          * above, this should not happen any more !!!
1045                          *  Test if we have transmitted more bytes over the
1046                          *  link than its possible to do with the current
1047                          *  speed and turn-around-time.
1048                          */
1049                         if((!nextfit) && (skb->len > self->bytes_left)) {
1050                                 IRDA_DEBUG(0, "%s(), Not allowed to transmit"
1051                                            " more bytes!\n", __FUNCTION__);
1052                                 /* Requeue the skb */
1053                                 skb_queue_head(&self->txq, skb_get(skb));
1054                                 /*
1055                                  *  We should switch state to LAP_NRM_P, but
1056                                  *  that is not possible since we must be sure
1057                                  *  that we poll the other side. Since we have
1058                                  *  used up our time, the poll timer should
1059                                  *  trigger anyway now, so we just wait for it
1060                                  *  DB
1061                                  */
1062                                 /*
1063                                  * Sorry, but that's not totally true. If
1064                                  * we send 2000B packets, we may wait another
1065                                  * 1000B until our turnaround expire. That's
1066                                  * why we need to be proactive in avoiding
1067                                  * coming here. - Jean II
1068                                  */
1069                                 return -EPROTO;
1070                         }
1071
1072                         /* Substract space used by this skb */
1073                         self->bytes_left -= skb->len;
1074 #else   /* CONFIG_IRDA_DYNAMIC_WINDOW */
1075                         /* Window has been adjusted for the max packet
1076                          * size, so much simpler... - Jean II */
1077                         nextfit = !skb_queue_empty(&self->txq);
1078 #endif  /* CONFIG_IRDA_DYNAMIC_WINDOW */
1079                         /*
1080                          *  Send data with poll bit cleared only if window > 1
1081                          *  and there is more frames after this one to be sent
1082                          */
1083                         if ((self->window > 1) && (nextfit)) {
1084                                 /* More packet to send in current window */
1085                                 irlap_send_data_primary(self, skb);
1086                                 irlap_next_state(self, LAP_XMIT_P);
1087                         } else {
1088                                 /* Final packet of window */
1089                                 irlap_send_data_primary_poll(self, skb);
1090                                 irlap_next_state(self, LAP_NRM_P);
1091
1092                                 /*
1093                                  * Make sure state machine does not try to send
1094                                  * any more frames
1095                                  */
1096                                 ret = -EPROTO;
1097                         }
1098 #ifdef CONFIG_IRDA_FAST_RR
1099                         /* Peer may want to reply immediately */
1100                         self->fast_RR = FALSE;
1101 #endif /* CONFIG_IRDA_FAST_RR */
1102                 } else {
1103                         IRDA_DEBUG(4, "%s(), Unable to send! remote busy?\n",
1104                                    __FUNCTION__);
1105                         skb_queue_head(&self->txq, skb_get(skb));
1106
1107                         /*
1108                          *  The next ret is important, because it tells
1109                          *  irlap_next_state _not_ to deliver more frames
1110                          */
1111                         ret = -EPROTO;
1112                 }
1113                 break;
1114         case POLL_TIMER_EXPIRED:
1115                 IRDA_DEBUG(3, "%s(), POLL_TIMER_EXPIRED <%ld>\n",
1116                             __FUNCTION__, jiffies);
1117                 irlap_send_rr_frame(self, CMD_FRAME);
1118                 /* Return to NRM properly - Jean II  */
1119                 self->window = self->window_size;
1120 #ifdef CONFIG_IRDA_DYNAMIC_WINDOW
1121                 /* Allowed to transmit a maximum number of bytes again. */
1122                 self->bytes_left = self->line_capacity;
1123 #endif /* CONFIG_IRDA_DYNAMIC_WINDOW */
1124                 irlap_start_final_timer(self, self->final_timeout);
1125                 irlap_next_state(self, LAP_NRM_P);
1126                 break;
1127         case DISCONNECT_REQUEST:
1128                 del_timer(&self->poll_timer);
1129                 irlap_wait_min_turn_around(self, &self->qos_tx);
1130                 irlap_send_disc_frame(self);
1131                 irlap_flush_all_queues(self);
1132                 irlap_start_final_timer(self, self->final_timeout);
1133                 self->retry_count = 0;
1134                 irlap_next_state(self, LAP_PCLOSE);
1135                 break;
1136         case DATA_REQUEST:
1137                 /* Nothing to do, irlap_do_event() will send the packet
1138                  * when we return... - Jean II */
1139                 break;
1140         default:
1141                 IRDA_DEBUG(0, "%s(), Unknown event %s\n",
1142                            __FUNCTION__, irlap_event[event]);
1143
1144                 ret = -EINVAL;
1145                 break;
1146         }
1147         return ret;
1148 }
1149
1150 /*
1151  * Function irlap_state_pclose (event, skb, info)
1152  *
1153  *    PCLOSE state
1154  */
1155 static int irlap_state_pclose(struct irlap_cb *self, IRLAP_EVENT event,
1156                               struct sk_buff *skb, struct irlap_info *info)
1157 {
1158         int ret = 0;
1159
1160         IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
1161
1162         IRDA_ASSERT(self != NULL, return -1;);
1163         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
1164
1165         switch (event) {
1166         case RECV_UA_RSP: /* FALLTHROUGH */
1167         case RECV_DM_RSP:
1168                 del_timer(&self->final_timer);
1169
1170                 /* Set new link parameters */
1171                 irlap_apply_default_connection_parameters(self);
1172
1173                 /* Always switch state before calling upper layers */
1174                 irlap_next_state(self, LAP_NDM);
1175
1176                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
1177                 break;
1178         case FINAL_TIMER_EXPIRED:
1179                 if (self->retry_count < self->N3) {
1180                         irlap_wait_min_turn_around(self, &self->qos_tx);
1181                         irlap_send_disc_frame(self);
1182                         irlap_start_final_timer(self, self->final_timeout);
1183                         self->retry_count++;
1184                         /* Keep state */
1185                 } else {
1186                         irlap_apply_default_connection_parameters(self);
1187
1188                         /*  Always switch state before calling upper layers */
1189                         irlap_next_state(self, LAP_NDM);
1190
1191                         irlap_disconnect_indication(self, LAP_NO_RESPONSE);
1192                 }
1193                 break;
1194         default:
1195                 IRDA_DEBUG(1, "%s(), Unknown event %d\n", __FUNCTION__, event);
1196
1197                 ret = -1;
1198                 break;
1199         }
1200         return ret;
1201 }
1202
1203 /*
1204  * Function irlap_state_nrm_p (self, event, skb, info)
1205  *
1206  *   NRM_P (Normal Response Mode as Primary), The primary station has given
1207  *   permissions to a secondary station to transmit IrLAP resonse frames
1208  *   (by sending a frame with the P bit set). The primary station will not
1209  *   transmit any frames and is expecting to receive frames only from the
1210  *   secondary to which transmission permissions has been given.
1211  */
1212 static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event,
1213                              struct sk_buff *skb, struct irlap_info *info)
1214 {
1215         int ret = 0;
1216         int ns_status;
1217         int nr_status;
1218
1219         switch (event) {
1220         case RECV_I_RSP: /* Optimize for the common case */
1221                 /* FIXME: must check for remote_busy below */
1222 #ifdef CONFIG_IRDA_FAST_RR
1223                 /*
1224                  *  Reset the fast_RR so we can use the fast RR code with
1225                  *  full speed the next time since peer may have more frames
1226                  *  to transmitt
1227                  */
1228                 self->fast_RR = FALSE;
1229 #endif /* CONFIG_IRDA_FAST_RR */
1230                 IRDA_ASSERT( info != NULL, return -1;);
1231
1232                 ns_status = irlap_validate_ns_received(self, info->ns);
1233                 nr_status = irlap_validate_nr_received(self, info->nr);
1234
1235                 /*
1236                  *  Check for expected I(nformation) frame
1237                  */
1238                 if ((ns_status == NS_EXPECTED) && (nr_status == NR_EXPECTED)) {
1239
1240                         /* Update Vr (next frame for us to receive) */
1241                         self->vr = (self->vr + 1) % 8;
1242
1243                         /* Update Nr received, cleanup our retry queue */
1244                         irlap_update_nr_received(self, info->nr);
1245
1246                         /*
1247                          *  Got expected NR, so reset the
1248                          *  retry_count. This is not done by IrLAP spec,
1249                          *  which is strange!
1250                          */
1251                         self->retry_count = 0;
1252                         self->ack_required = TRUE;
1253
1254                         /*  poll bit cleared?  */
1255                         if (!info->pf) {
1256                                 /* Keep state, do not move this line */
1257                                 irlap_next_state(self, LAP_NRM_P);
1258
1259                                 irlap_data_indication(self, skb, FALSE);
1260                         } else {
1261                                 /* No longer waiting for pf */
1262                                 del_timer(&self->final_timer);
1263
1264                                 irlap_wait_min_turn_around(self, &self->qos_tx);
1265
1266                                 /* Call higher layer *before* changing state
1267                                  * to give them a chance to send data in the
1268                                  * next LAP frame.
1269                                  * Jean II */
1270                                 irlap_data_indication(self, skb, FALSE);
1271
1272                                 /* XMIT states are the most dangerous state
1273                                  * to be in, because user requests are
1274                                  * processed directly and may change state.
1275                                  * On the other hand, in NDM_P, those
1276                                  * requests are queued and we will process
1277                                  * them when we return to irlap_do_event().
1278                                  * Jean II
1279                                  */
1280                                 irlap_next_state(self, LAP_XMIT_P);
1281
1282                                 /* This is the last frame.
1283                                  * Make sure it's always called in XMIT state.
1284                                  * - Jean II */
1285                                 irlap_start_poll_timer(self, self->poll_timeout);
1286                         }
1287                         break;
1288
1289                 }
1290                 /* Unexpected next to send (Ns) */
1291                 if ((ns_status == NS_UNEXPECTED) && (nr_status == NR_EXPECTED))
1292                 {
1293                         if (!info->pf) {
1294                                 irlap_update_nr_received(self, info->nr);
1295
1296                                 /*
1297                                  *  Wait until the last frame before doing
1298                                  *  anything
1299                                  */
1300
1301                                 /* Keep state */
1302                                 irlap_next_state(self, LAP_NRM_P);
1303                         } else {
1304                                 IRDA_DEBUG(4,
1305                                        "%s(), missing or duplicate frame!\n",
1306                                            __FUNCTION__);
1307
1308                                 /* Update Nr received */
1309                                 irlap_update_nr_received(self, info->nr);
1310
1311                                 irlap_wait_min_turn_around(self, &self->qos_tx);
1312                                 irlap_send_rr_frame(self, CMD_FRAME);
1313
1314                                 self->ack_required = FALSE;
1315
1316                                 irlap_start_final_timer(self, self->final_timeout);
1317                                 irlap_next_state(self, LAP_NRM_P);
1318                         }
1319                         break;
1320                 }
1321                 /*
1322                  *  Unexpected next to receive (Nr)
1323                  */
1324                 if ((ns_status == NS_EXPECTED) && (nr_status == NR_UNEXPECTED))
1325                 {
1326                         if (info->pf) {
1327                                 self->vr = (self->vr + 1) % 8;
1328
1329                                 /* Update Nr received */
1330                                 irlap_update_nr_received(self, info->nr);
1331
1332                                 /* Resend rejected frames */
1333                                 irlap_resend_rejected_frames(self, CMD_FRAME);
1334
1335                                 self->ack_required = FALSE;
1336
1337                                 /* Make sure we account for the time
1338                                  * to transmit our frames. See comemnts
1339                                  * in irlap_send_data_primary_poll().
1340                                  * Jean II */
1341                                 irlap_start_final_timer(self, 2 * self->final_timeout);
1342
1343                                 /* Keep state, do not move this line */
1344                                 irlap_next_state(self, LAP_NRM_P);
1345
1346                                 irlap_data_indication(self, skb, FALSE);
1347                         } else {
1348                                 /*
1349                                  *  Do not resend frames until the last
1350                                  *  frame has arrived from the other
1351                                  *  device. This is not documented in
1352                                  *  IrLAP!!
1353                                  */
1354                                 self->vr = (self->vr + 1) % 8;
1355
1356                                 /* Update Nr received */
1357                                 irlap_update_nr_received(self, info->nr);
1358
1359                                 self->ack_required = FALSE;
1360
1361                                 /* Keep state, do not move this line!*/
1362                                 irlap_next_state(self, LAP_NRM_P);
1363
1364                                 irlap_data_indication(self, skb, FALSE);
1365                         }
1366                         break;
1367                 }
1368                 /*
1369                  *  Unexpected next to send (Ns) and next to receive (Nr)
1370                  *  Not documented by IrLAP!
1371                  */
1372                 if ((ns_status == NS_UNEXPECTED) &&
1373                     (nr_status == NR_UNEXPECTED))
1374                 {
1375                         IRDA_DEBUG(4, "%s(), unexpected nr and ns!\n",
1376                                    __FUNCTION__);
1377                         if (info->pf) {
1378                                 /* Resend rejected frames */
1379                                 irlap_resend_rejected_frames(self, CMD_FRAME);
1380
1381                                 /* Give peer some time to retransmit! 
1382                                  * But account for our own Tx. */
1383                                 irlap_start_final_timer(self, 2 * self->final_timeout);
1384
1385                                 /* Keep state, do not move this line */
1386                                 irlap_next_state(self, LAP_NRM_P);
1387                         } else {
1388                                 /* Update Nr received */
1389                                 /* irlap_update_nr_received( info->nr); */
1390
1391                                 self->ack_required = FALSE;
1392                         }
1393                         break;
1394                 }
1395
1396                 /*
1397                  *  Invalid NR or NS
1398                  */
1399                 if ((nr_status == NR_INVALID) || (ns_status == NS_INVALID)) {
1400                         if (info->pf) {
1401                                 del_timer(&self->final_timer);
1402
1403                                 irlap_next_state(self, LAP_RESET_WAIT);
1404
1405                                 irlap_disconnect_indication(self, LAP_RESET_INDICATION);
1406                                 self->xmitflag = TRUE;
1407                         } else {
1408                                 del_timer(&self->final_timer);
1409
1410                                 irlap_disconnect_indication(self, LAP_RESET_INDICATION);
1411
1412                                 self->xmitflag = FALSE;
1413                         }
1414                         break;
1415                 }
1416                 IRDA_DEBUG(1, "%s(), Not implemented!\n", __FUNCTION__);
1417                 IRDA_DEBUG(1, "%s(), event=%s, ns_status=%d, nr_status=%d\n",
1418                        __FUNCTION__, irlap_event[event], ns_status, nr_status);
1419                 break;
1420         case RECV_UI_FRAME:
1421                 /* Poll bit cleared? */
1422                 if (!info->pf) {
1423                         irlap_data_indication(self, skb, TRUE);
1424                         irlap_next_state(self, LAP_NRM_P);
1425                 } else {
1426                         del_timer(&self->final_timer);
1427                         irlap_data_indication(self, skb, TRUE);
1428                         irlap_next_state(self, LAP_XMIT_P);
1429                         IRDA_DEBUG(1, "%s: RECV_UI_FRAME: next state %s\n", __FUNCTION__, irlap_state[self->state]);
1430                         irlap_start_poll_timer(self, self->poll_timeout);
1431                 }
1432                 break;
1433         case RECV_RR_RSP:
1434                 /*
1435                  *  If you get a RR, the remote isn't busy anymore,
1436                  *  no matter what the NR
1437                  */
1438                 self->remote_busy = FALSE;
1439
1440                 /*
1441                  *  Nr as expected?
1442                  */
1443                 ret = irlap_validate_nr_received(self, info->nr);
1444                 if (ret == NR_EXPECTED) {
1445                         /* Stop final timer */
1446                         del_timer(&self->final_timer);
1447
1448                         /* Update Nr received */
1449                         irlap_update_nr_received(self, info->nr);
1450
1451                         /*
1452                          *  Got expected NR, so reset the retry_count. This
1453                          *  is not done by the IrLAP standard , which is
1454                          *  strange! DB.
1455                          */
1456                         self->retry_count = 0;
1457                         irlap_wait_min_turn_around(self, &self->qos_tx);
1458
1459                         irlap_next_state(self, LAP_XMIT_P);
1460
1461                         /* Start poll timer */
1462                         irlap_start_poll_timer(self, self->poll_timeout);
1463                 } else if (ret == NR_UNEXPECTED) {
1464                         IRDA_ASSERT(info != NULL, return -1;);
1465                         /*
1466                          *  Unexpected nr!
1467                          */
1468
1469                         /* Update Nr received */
1470                         irlap_update_nr_received(self, info->nr);
1471
1472                         IRDA_DEBUG(4, "RECV_RR_FRAME: Retrans:%d, nr=%d, va=%d, "
1473                               "vs=%d, vr=%d\n",
1474                               self->retry_count, info->nr, self->va,
1475                               self->vs, self->vr);
1476
1477                         /* Resend rejected frames */
1478                         irlap_resend_rejected_frames(self, CMD_FRAME);
1479
1480                         /* Final timer ??? Jean II */
1481
1482                         irlap_next_state(self, LAP_NRM_P);
1483                 } else if (ret == NR_INVALID) {
1484                         IRDA_DEBUG(1, "%s(), Received RR with "
1485                                    "invalid nr !\n", __FUNCTION__);
1486                         del_timer(&self->final_timer);
1487
1488                         irlap_next_state(self, LAP_RESET_WAIT);
1489
1490                         irlap_disconnect_indication(self, LAP_RESET_INDICATION);
1491                         self->xmitflag = TRUE;
1492                 }
1493                 break;
1494         case RECV_RNR_RSP:
1495                 IRDA_ASSERT(info != NULL, return -1;);
1496
1497                 /* Stop final timer */
1498                 del_timer(&self->final_timer);
1499                 self->remote_busy = TRUE;
1500
1501                 /* Update Nr received */
1502                 irlap_update_nr_received(self, info->nr);
1503                 irlap_next_state(self, LAP_XMIT_P);
1504
1505                 /* Start poll timer */
1506                 irlap_start_poll_timer(self, self->poll_timeout);
1507                 break;
1508         case RECV_FRMR_RSP:
1509                 del_timer(&self->final_timer);
1510                 self->xmitflag = TRUE;
1511                 irlap_next_state(self, LAP_RESET_WAIT);
1512                 irlap_reset_indication(self);
1513                 break;
1514         case FINAL_TIMER_EXPIRED:
1515                 /*
1516                  *  We are allowed to wait for additional 300 ms if
1517                  *  final timer expires when we are in the middle
1518                  *  of receiving a frame (page 45, IrLAP). Check that
1519                  *  we only do this once for each frame.
1520                  */
1521                 if (irda_device_is_receiving(self->netdev) && !self->add_wait) {
1522                         IRDA_DEBUG(1, "FINAL_TIMER_EXPIRED when receiving a "
1523                               "frame! Waiting a little bit more!\n");
1524                         irlap_start_final_timer(self, msecs_to_jiffies(300));
1525
1526                         /*
1527                          *  Don't allow this to happen one more time in a row,
1528                          *  or else we can get a pretty tight loop here if
1529                          *  if we only receive half a frame. DB.
1530                          */
1531                         self->add_wait = TRUE;
1532                         break;
1533                 }
1534                 self->add_wait = FALSE;
1535
1536                 /* N2 is the disconnect timer. Until we reach it, we retry */
1537                 if (self->retry_count < self->N2) {
1538                         /* Retry sending the pf bit to the secondary */
1539                         irlap_wait_min_turn_around(self, &self->qos_tx);
1540                         irlap_send_rr_frame(self, CMD_FRAME);
1541
1542                         irlap_start_final_timer(self, self->final_timeout);
1543                         self->retry_count++;
1544                         IRDA_DEBUG(4, "irlap_state_nrm_p: FINAL_TIMER_EXPIRED:"
1545                                    " retry_count=%d\n", self->retry_count);
1546
1547                         /* Early warning event. I'm using a pretty liberal
1548                          * interpretation of the spec and generate an event
1549                          * every time the timer is multiple of N1 (and not
1550                          * only the first time). This allow application
1551                          * to know precisely if connectivity restart...
1552                          * Jean II */
1553                         if((self->retry_count % self->N1) == 0)
1554                                 irlap_status_indication(self,
1555                                                         STATUS_NO_ACTIVITY);
1556
1557                         /* Keep state */
1558                 } else {
1559                         irlap_apply_default_connection_parameters(self);
1560
1561                         /* Always switch state before calling upper layers */
1562                         irlap_next_state(self, LAP_NDM);
1563                         irlap_disconnect_indication(self, LAP_NO_RESPONSE);
1564                 }
1565                 break;
1566         case RECV_REJ_RSP:
1567                 irlap_update_nr_received(self, info->nr);
1568                 if (self->remote_busy) {
1569                         irlap_wait_min_turn_around(self, &self->qos_tx);
1570                         irlap_send_rr_frame(self, CMD_FRAME);
1571                 } else
1572                         irlap_resend_rejected_frames(self, CMD_FRAME);
1573                 irlap_start_final_timer(self, 2 * self->final_timeout);
1574                 break;
1575         case RECV_SREJ_RSP:
1576                 irlap_update_nr_received(self, info->nr);
1577                 if (self->remote_busy) {
1578                         irlap_wait_min_turn_around(self, &self->qos_tx);
1579                         irlap_send_rr_frame(self, CMD_FRAME);
1580                 } else
1581                         irlap_resend_rejected_frame(self, CMD_FRAME);
1582                 irlap_start_final_timer(self, 2 * self->final_timeout);
1583                 break;
1584         case RECV_RD_RSP:
1585                 IRDA_DEBUG(1, "%s(), RECV_RD_RSP\n", __FUNCTION__);
1586
1587                 irlap_flush_all_queues(self);
1588                 irlap_next_state(self, LAP_XMIT_P);
1589                 /* Call back the LAP state machine to do a proper disconnect */
1590                 irlap_disconnect_request(self);
1591                 break;
1592         default:
1593                 IRDA_DEBUG(1, "%s(), Unknown event %s\n",
1594                             __FUNCTION__, irlap_event[event]);
1595
1596                 ret = -1;
1597                 break;
1598         }
1599         return ret;
1600 }
1601
1602 /*
1603  * Function irlap_state_reset_wait (event, skb, info)
1604  *
1605  *    We have informed the service user of a reset condition, and is
1606  *    awaiting reset of disconnect request.
1607  *
1608  */
1609 static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
1610                                   struct sk_buff *skb, struct irlap_info *info)
1611 {
1612         int ret = 0;
1613
1614         IRDA_DEBUG(3, "%s(), event = %s\n", __FUNCTION__, irlap_event[event]);
1615
1616         IRDA_ASSERT(self != NULL, return -1;);
1617         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
1618
1619         switch (event) {
1620         case RESET_REQUEST:
1621                 if (self->xmitflag) {
1622                         irlap_wait_min_turn_around(self, &self->qos_tx);
1623                         irlap_send_snrm_frame(self, NULL);
1624                         irlap_start_final_timer(self, self->final_timeout);
1625                         irlap_next_state(self, LAP_RESET);
1626                 } else {
1627                         irlap_start_final_timer(self, self->final_timeout);
1628                         irlap_next_state(self, LAP_RESET);
1629                 }
1630                 break;
1631         case DISCONNECT_REQUEST:
1632                 irlap_wait_min_turn_around( self, &self->qos_tx);
1633                 irlap_send_disc_frame( self);
1634                 irlap_flush_all_queues( self);
1635                 irlap_start_final_timer( self, self->final_timeout);
1636                 self->retry_count = 0;
1637                 irlap_next_state( self, LAP_PCLOSE);
1638                 break;
1639         default:
1640                 IRDA_DEBUG(2, "%s(), Unknown event %s\n", __FUNCTION__,
1641                            irlap_event[event]);
1642
1643                 ret = -1;
1644                 break;
1645         }
1646         return ret;
1647 }
1648
1649 /*
1650  * Function irlap_state_reset (self, event, skb, info)
1651  *
1652  *    We have sent a SNRM reset command to the peer layer, and is awaiting
1653  *    reply.
1654  *
1655  */
1656 static int irlap_state_reset(struct irlap_cb *self, IRLAP_EVENT event,
1657                              struct sk_buff *skb, struct irlap_info *info)
1658 {
1659         int ret = 0;
1660
1661         IRDA_DEBUG(3, "%s(), event = %s\n", __FUNCTION__, irlap_event[event]);
1662
1663         IRDA_ASSERT(self != NULL, return -1;);
1664         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
1665
1666         switch (event) {
1667         case RECV_DISC_CMD:
1668                 del_timer(&self->final_timer);
1669
1670                 irlap_apply_default_connection_parameters(self);
1671
1672                 /* Always switch state before calling upper layers */
1673                 irlap_next_state(self, LAP_NDM);
1674
1675                 irlap_disconnect_indication(self, LAP_NO_RESPONSE);
1676
1677                 break;
1678         case RECV_UA_RSP:
1679                 del_timer(&self->final_timer);
1680
1681                 /* Initiate connection state */
1682                 irlap_initiate_connection_state(self);
1683
1684                 irlap_reset_confirm();
1685
1686                 self->remote_busy = FALSE;
1687
1688                 irlap_next_state(self, LAP_XMIT_P);
1689
1690                 irlap_start_poll_timer(self, self->poll_timeout);
1691
1692                 break;
1693         case FINAL_TIMER_EXPIRED:
1694                 if (self->retry_count < 3) {
1695                         irlap_wait_min_turn_around(self, &self->qos_tx);
1696
1697                         IRDA_ASSERT(self->netdev != NULL, return -1;);
1698                         irlap_send_snrm_frame(self, self->qos_dev);
1699
1700                         self->retry_count++; /* Experimental!! */
1701
1702                         irlap_start_final_timer(self, self->final_timeout);
1703                         irlap_next_state(self, LAP_RESET);
1704                 } else if (self->retry_count >= self->N3) {
1705                         irlap_apply_default_connection_parameters(self);
1706
1707                         /* Always switch state before calling upper layers */
1708                         irlap_next_state(self, LAP_NDM);
1709
1710                         irlap_disconnect_indication(self, LAP_NO_RESPONSE);
1711                 }
1712                 break;
1713         case RECV_SNRM_CMD:
1714                 /*
1715                  * SNRM frame is not allowed to contain an I-field in this
1716                  * state
1717                  */
1718                 if (!info) {
1719                         IRDA_DEBUG(3, "%s(), RECV_SNRM_CMD\n", __FUNCTION__);
1720                         irlap_initiate_connection_state(self);
1721                         irlap_wait_min_turn_around(self, &self->qos_tx);
1722                         irlap_send_ua_response_frame(self, &self->qos_rx);
1723                         irlap_reset_confirm();
1724                         irlap_start_wd_timer(self, self->wd_timeout);
1725                         irlap_next_state(self, LAP_NDM);
1726                 } else {
1727                         IRDA_DEBUG(0,
1728                                    "%s(), SNRM frame contained an I field!\n",
1729                                    __FUNCTION__);
1730                 }
1731                 break;
1732         default:
1733                 IRDA_DEBUG(1, "%s(), Unknown event %s\n",
1734                            __FUNCTION__, irlap_event[event]);
1735
1736                 ret = -1;
1737                 break;
1738         }
1739         return ret;
1740 }
1741
1742 /*
1743  * Function irlap_state_xmit_s (event, skb, info)
1744  *
1745  *   XMIT_S, The secondary station has been given the right to transmit,
1746  *   and we therefor do not expect to receive any transmissions from other
1747  *   stations.
1748  */
1749 static int irlap_state_xmit_s(struct irlap_cb *self, IRLAP_EVENT event,
1750                               struct sk_buff *skb, struct irlap_info *info)
1751 {
1752         int ret = 0;
1753
1754         IRDA_DEBUG(4, "%s(), event=%s\n", __FUNCTION__, irlap_event[event]);
1755
1756         IRDA_ASSERT(self != NULL, return -ENODEV;);
1757         IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;);
1758
1759         switch (event) {
1760         case SEND_I_CMD:
1761                 /*
1762                  *  Send frame only if send window > 0
1763                  */
1764                 if ((self->window > 0) && (!self->remote_busy)) {
1765                         int nextfit;
1766 #ifdef CONFIG_IRDA_DYNAMIC_WINDOW
1767                         struct sk_buff *skb_next;
1768
1769                         /*
1770                          * Same deal as in irlap_state_xmit_p(), so see
1771                          * the comments at that point.
1772                          * We are the secondary, so there are only subtle
1773                          * differences. - Jean II
1774                          */
1775
1776                         /* Check if a subsequent skb exist and would fit in
1777                          * the current window (with respect to turnaround
1778                          * time). - Jean II */
1779                         skb_next = skb_peek(&self->txq);
1780                         nextfit = ((skb_next != NULL) &&
1781                                    ((skb_next->len + skb->len) <=
1782                                     self->bytes_left));
1783
1784                         /*
1785                          *  Test if we have transmitted more bytes over the
1786                          *  link than its possible to do with the current
1787                          *  speed and turn-around-time.
1788                          */
1789                         if((!nextfit) && (skb->len > self->bytes_left)) {
1790                                 IRDA_DEBUG(0, "%s(), Not allowed to transmit"
1791                                            " more bytes!\n", __FUNCTION__);
1792                                 /* Requeue the skb */
1793                                 skb_queue_head(&self->txq, skb_get(skb));
1794
1795                                 /*
1796                                  *  Switch to NRM_S, this is only possible
1797                                  *  when we are in secondary mode, since we
1798                                  *  must be sure that we don't miss any RR
1799                                  *  frames
1800                                  */
1801                                 self->window = self->window_size;
1802                                 self->bytes_left = self->line_capacity;
1803                                 irlap_start_wd_timer(self, self->wd_timeout);
1804
1805                                 irlap_next_state(self, LAP_NRM_S);
1806                                 /* Slight difference with primary :
1807                                  * here we would wait for the other side to
1808                                  * expire the turnaround. - Jean II */
1809
1810                                 return -EPROTO; /* Try again later */
1811                         }
1812                         /* Substract space used by this skb */
1813                         self->bytes_left -= skb->len;
1814 #else   /* CONFIG_IRDA_DYNAMIC_WINDOW */
1815                         /* Window has been adjusted for the max packet
1816                          * size, so much simpler... - Jean II */
1817                         nextfit = !skb_queue_empty(&self->txq);
1818 #endif /* CONFIG_IRDA_DYNAMIC_WINDOW */
1819                         /*
1820                          *  Send data with final bit cleared only if window > 1
1821                          *  and there is more frames to be sent
1822                          */
1823                         if ((self->window > 1) && (nextfit)) {
1824                                 irlap_send_data_secondary(self, skb);
1825                                 irlap_next_state(self, LAP_XMIT_S);
1826                         } else {
1827                                 irlap_send_data_secondary_final(self, skb);
1828                                 irlap_next_state(self, LAP_NRM_S);
1829
1830                                 /*
1831                                  * Make sure state machine does not try to send
1832                                  * any more frames
1833                                  */
1834                                 ret = -EPROTO;
1835                         }
1836                 } else {
1837                         IRDA_DEBUG(2, "%s(), Unable to send!\n", __FUNCTION__);
1838                         skb_queue_head(&self->txq, skb_get(skb));
1839                         ret = -EPROTO;
1840                 }
1841                 break;
1842         case DISCONNECT_REQUEST:
1843                 irlap_send_rd_frame(self);
1844                 irlap_flush_all_queues(self);
1845                 irlap_start_wd_timer(self, self->wd_timeout);
1846                 irlap_next_state(self, LAP_SCLOSE);
1847                 break;
1848         case DATA_REQUEST:
1849                 /* Nothing to do, irlap_do_event() will send the packet
1850                  * when we return... - Jean II */
1851                 break;
1852         default:
1853                 IRDA_DEBUG(2, "%s(), Unknown event %s\n", __FUNCTION__,
1854                            irlap_event[event]);
1855
1856                 ret = -EINVAL;
1857                 break;
1858         }
1859         return ret;
1860 }
1861
1862 /*
1863  * Function irlap_state_nrm_s (event, skb, info)
1864  *
1865  *    NRM_S (Normal Response Mode as Secondary) state, in this state we are
1866  *    expecting to receive frames from the primary station
1867  *
1868  */
1869 static int irlap_state_nrm_s(struct irlap_cb *self, IRLAP_EVENT event,
1870                              struct sk_buff *skb, struct irlap_info *info)
1871 {
1872         int ns_status;
1873         int nr_status;
1874         int ret = 0;
1875
1876         IRDA_DEBUG(4, "%s(), event=%s\n", __FUNCTION__, irlap_event[ event]);
1877
1878         IRDA_ASSERT(self != NULL, return -1;);
1879         IRDA_ASSERT(self->magic == LAP_MAGIC, return -1;);
1880
1881         switch (event) {
1882         case RECV_I_CMD: /* Optimize for the common case */
1883                 /* FIXME: must check for remote_busy below */
1884                 IRDA_DEBUG(4, "%s(), event=%s nr=%d, vs=%d, ns=%d, "
1885                            "vr=%d, pf=%d\n", __FUNCTION__,
1886                            irlap_event[event], info->nr,
1887                            self->vs, info->ns, self->vr, info->pf);
1888
1889                 self->retry_count = 0;
1890
1891                 ns_status = irlap_validate_ns_received(self, info->ns);
1892                 nr_status = irlap_validate_nr_received(self, info->nr);
1893                 /*
1894                  *  Check for expected I(nformation) frame
1895                  */
1896                 if ((ns_status == NS_EXPECTED) && (nr_status == NR_EXPECTED)) {
1897
1898                         /* Update Vr (next frame for us to receive) */
1899                         self->vr = (self->vr + 1) % 8;
1900
1901                         /* Update Nr received */
1902                         irlap_update_nr_received(self, info->nr);
1903
1904                         /*
1905                          *  poll bit cleared?
1906                          */
1907                         if (!info->pf) {
1908
1909                                 self->ack_required = TRUE;
1910
1911                                 /*
1912                                  *  Starting WD-timer here is optional, but
1913                                  *  not recommended. Note 6 IrLAP p. 83
1914                                  */
1915 #if 0
1916                                 irda_start_timer(WD_TIMER, self->wd_timeout);
1917 #endif
1918                                 /* Keep state, do not move this line */
1919                                 irlap_next_state(self, LAP_NRM_S);
1920
1921                                 irlap_data_indication(self, skb, FALSE);
1922                                 break;
1923                         } else {
1924                                 /*
1925                                  *  We should wait before sending RR, and
1926                                  *  also before changing to XMIT_S
1927                                  *  state. (note 1, IrLAP p. 82)
1928                                  */
1929                                 irlap_wait_min_turn_around(self, &self->qos_tx);
1930
1931                                 /*
1932                                  * Give higher layers a chance to
1933                                  * immediately reply with some data before
1934                                  * we decide if we should send a RR frame
1935                                  * or not
1936                                  */
1937                                 irlap_data_indication(self, skb, FALSE);
1938
1939                                 /* Any pending data requests?  */
1940                                 if (!skb_queue_empty(&self->txq) &&
1941                                     (self->window > 0))
1942                                 {
1943                                         self->ack_required = TRUE;
1944
1945                                         del_timer(&self->wd_timer);
1946
1947                                         irlap_next_state(self, LAP_XMIT_S);
1948                                 } else {
1949                                         irlap_send_rr_frame(self, RSP_FRAME);
1950                                         irlap_start_wd_timer(self,
1951                                                              self->wd_timeout);
1952
1953                                         /* Keep the state */
1954                                         irlap_next_state(self, LAP_NRM_S);
1955                                 }
1956                                 break;
1957                         }
1958                 }
1959                 /*
1960                  *  Check for Unexpected next to send (Ns)
1961                  */
1962                 if ((ns_status == NS_UNEXPECTED) && (nr_status == NR_EXPECTED))
1963                 {
1964                         /* Unexpected next to send, with final bit cleared */
1965                         if (!info->pf) {
1966                                 irlap_update_nr_received(self, info->nr);
1967
1968                                 irlap_start_wd_timer(self, self->wd_timeout);
1969                         } else {
1970                                 /* Update Nr received */
1971                                 irlap_update_nr_received(self, info->nr);
1972
1973                                 irlap_wait_min_turn_around(self, &self->qos_tx);
1974                                 irlap_send_rr_frame(self, RSP_FRAME);
1975
1976                                 irlap_start_wd_timer(self, self->wd_timeout);
1977                         }
1978                         break;
1979                 }
1980
1981                 /*
1982                  *  Unexpected Next to Receive(NR) ?
1983                  */
1984                 if ((ns_status == NS_EXPECTED) && (nr_status == NR_UNEXPECTED))
1985                 {
1986                         if (info->pf) {
1987                                 IRDA_DEBUG(4, "RECV_I_RSP: frame(s) lost\n");
1988
1989                                 self->vr = (self->vr + 1) % 8;
1990
1991                                 /* Update Nr received */
1992                                 irlap_update_nr_received(self, info->nr);
1993
1994                                 /* Resend rejected frames */
1995                                 irlap_resend_rejected_frames(self, RSP_FRAME);
1996
1997                                 /* Keep state, do not move this line */
1998                                 irlap_next_state(self, LAP_NRM_S);
1999
2000                                 irlap_data_indication(self, skb, FALSE);
2001                                 irlap_start_wd_timer(self, self->wd_timeout);
2002                                 break;
2003                         }
2004                         /*
2005                          *  This is not documented in IrLAP!! Unexpected NR
2006                          *  with poll bit cleared
2007                          */
2008                         if (!info->pf) {
2009                                 self->vr = (self->vr + 1) % 8;
2010
2011                                 /* Update Nr received */
2012                                 irlap_update_nr_received(self, info->nr);
2013
2014                                 /* Keep state, do not move this line */
2015                                 irlap_next_state(self, LAP_NRM_S);
2016
2017                                 irlap_data_indication(self, skb, FALSE);
2018                                 irlap_start_wd_timer(self, self->wd_timeout);
2019                         }
2020                         break;
2021                 }
2022
2023                 if (ret == NR_INVALID) {
2024                         IRDA_DEBUG(0, "NRM_S, NR_INVALID not implemented!\n");
2025                 }
2026                 if (ret == NS_INVALID) {
2027                         IRDA_DEBUG(0, "NRM_S, NS_INVALID not implemented!\n");
2028                 }
2029                 break;
2030         case RECV_UI_FRAME:
2031                 /*
2032                  *  poll bit cleared?
2033                  */
2034                 if (!info->pf) {
2035                         irlap_data_indication(self, skb, TRUE);
2036                         irlap_next_state(self, LAP_NRM_S); /* Keep state */
2037                 } else {
2038                         /*
2039                          *  Any pending data requests?
2040                          */
2041                         if (!skb_queue_empty(&self->txq) &&
2042                             (self->window > 0) && !self->remote_busy)
2043                         {
2044                                 irlap_data_indication(self, skb, TRUE);
2045
2046                                 del_timer(&self->wd_timer);
2047
2048                                 irlap_next_state(self, LAP_XMIT_S);
2049                         } else {
2050                                 irlap_data_indication(self, skb, TRUE);
2051
2052                                 irlap_wait_min_turn_around(self, &self->qos_tx);
2053
2054                                 irlap_send_rr_frame(self, RSP_FRAME);
2055                                 self->ack_required = FALSE;
2056
2057                                 irlap_start_wd_timer(self, self->wd_timeout);
2058
2059                                 /* Keep the state */
2060                                 irlap_next_state(self, LAP_NRM_S);
2061                         }
2062                 }
2063                 break;
2064         case RECV_RR_CMD:
2065                 self->retry_count = 0;
2066
2067                 /*
2068                  *  Nr as expected?
2069                  */
2070                 nr_status = irlap_validate_nr_received(self, info->nr);
2071                 if (nr_status == NR_EXPECTED) {
2072                         if (!skb_queue_empty(&self->txq) &&
2073                             (self->window > 0)) {
2074                                 self->remote_busy = FALSE;
2075
2076                                 /* Update Nr received */
2077                                 irlap_update_nr_received(self, info->nr);
2078                                 del_timer(&self->wd_timer);
2079
2080                                 irlap_wait_min_turn_around(self, &self->qos_tx);
2081                                 irlap_next_state(self, LAP_XMIT_S);
2082                         } else {
2083                                 self->remote_busy = FALSE;
2084                                 /* Update Nr received */
2085                                 irlap_update_nr_received(self, info->nr);
2086                                 irlap_wait_min_turn_around(self, &self->qos_tx);
2087                                 irlap_start_wd_timer(self, self->wd_timeout);
2088
2089                                 /* Note : if the link is idle (this case),
2090                                  * we never go in XMIT_S, so we never get a
2091                                  * chance to process any DISCONNECT_REQUEST.
2092                                  * Do it now ! - Jean II */
2093                                 if (self->disconnect_pending) {
2094                                         /* Disconnect */
2095                                         irlap_send_rd_frame(self);
2096                                         irlap_flush_all_queues(self);
2097
2098                                         irlap_next_state(self, LAP_SCLOSE);
2099                                 } else {
2100                                         /* Just send back pf bit */
2101                                         irlap_send_rr_frame(self, RSP_FRAME);
2102
2103                                         irlap_next_state(self, LAP_NRM_S);
2104                                 }
2105                         }
2106                 } else if (nr_status == NR_UNEXPECTED) {
2107                         self->remote_busy = FALSE;
2108                         irlap_update_nr_received(self, info->nr);
2109                         irlap_resend_rejected_frames(self, RSP_FRAME);
2110
2111                         irlap_start_wd_timer(self, self->wd_timeout);
2112
2113                         /* Keep state */
2114                         irlap_next_state(self, LAP_NRM_S);
2115                 } else {
2116                         IRDA_DEBUG(1, "%s(), invalid nr not implemented!\n",
2117                                    __FUNCTION__);
2118                 }
2119                 break;
2120         case RECV_SNRM_CMD:
2121                 /* SNRM frame is not allowed to contain an I-field */
2122                 if (!info) {
2123                         del_timer(&self->wd_timer);
2124                         IRDA_DEBUG(1, "%s(), received SNRM cmd\n", __FUNCTION__);
2125                         irlap_next_state(self, LAP_RESET_CHECK);
2126
2127                         irlap_reset_indication(self);
2128                 } else {
2129                         IRDA_DEBUG(0,
2130                                    "%s(), SNRM frame contained an I-field!\n",
2131                                    __FUNCTION__);
2132
2133                 }
2134                 break;
2135         case RECV_REJ_CMD:
2136                 irlap_update_nr_received(self, info->nr);
2137                 if (self->remote_busy) {
2138                         irlap_wait_min_turn_around(self, &self->qos_tx);
2139                         irlap_send_rr_frame(self, RSP_FRAME);
2140                 } else
2141                         irlap_resend_rejected_frames(self, RSP_FRAME);
2142                 irlap_start_wd_timer(self, self->wd_timeout);
2143                 break;
2144         case RECV_SREJ_CMD:
2145                 irlap_update_nr_received(self, info->nr);
2146                 if (self->remote_busy) {
2147                         irlap_wait_min_turn_around(self, &self->qos_tx);
2148                         irlap_send_rr_frame(self, RSP_FRAME);
2149                 } else
2150                         irlap_resend_rejected_frame(self, RSP_FRAME);
2151                 irlap_start_wd_timer(self, self->wd_timeout);
2152                 break;
2153         case WD_TIMER_EXPIRED:
2154                 /*
2155                  *  Wait until retry_count * n matches negotiated threshold/
2156                  *  disconnect time (note 2 in IrLAP p. 82)
2157                  *
2158                  * Similar to irlap_state_nrm_p() -> FINAL_TIMER_EXPIRED
2159                  * Note : self->wd_timeout = (self->final_timeout * 2),
2160                  *   which explain why we use (self->N2 / 2) here !!!
2161                  * Jean II
2162                  */
2163                 IRDA_DEBUG(1, "%s(), retry_count = %d\n", __FUNCTION__,
2164                            self->retry_count);
2165
2166                 if (self->retry_count < (self->N2 / 2)) {
2167                         /* No retry, just wait for primary */
2168                         irlap_start_wd_timer(self, self->wd_timeout);
2169                         self->retry_count++;
2170
2171                         if((self->retry_count % (self->N1 / 2)) == 0)
2172                                 irlap_status_indication(self,
2173                                                         STATUS_NO_ACTIVITY);
2174                 } else {
2175                         irlap_apply_default_connection_parameters(self);
2176
2177                         /* Always switch state before calling upper layers */
2178                         irlap_next_state(self, LAP_NDM);
2179                         irlap_disconnect_indication(self, LAP_NO_RESPONSE);
2180                 }
2181                 break;
2182         case RECV_DISC_CMD:
2183                 /* Always switch state before calling upper layers */
2184                 irlap_next_state(self, LAP_NDM);
2185
2186                 /* Send disconnect response */
2187                 irlap_wait_min_turn_around(self, &self->qos_tx);
2188                 irlap_send_ua_response_frame(self, NULL);
2189
2190                 del_timer(&self->wd_timer);
2191                 irlap_flush_all_queues(self);
2192                 /* Set default link parameters */
2193                 irlap_apply_default_connection_parameters(self);
2194
2195                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
2196                 break;
2197         case RECV_DISCOVERY_XID_CMD:
2198                 irlap_wait_min_turn_around(self, &self->qos_tx);
2199                 irlap_send_rr_frame(self, RSP_FRAME);
2200                 self->ack_required = TRUE;
2201                 irlap_start_wd_timer(self, self->wd_timeout);
2202                 irlap_next_state(self, LAP_NRM_S);
2203
2204                 break;
2205         case RECV_TEST_CMD:
2206                 /* Remove test frame header (only LAP header in NRM) */
2207                 skb_pull(skb, LAP_ADDR_HEADER + LAP_CTRL_HEADER);
2208
2209                 irlap_wait_min_turn_around(self, &self->qos_tx);
2210                 irlap_start_wd_timer(self, self->wd_timeout);
2211
2212                 /* Send response (info will be copied) */
2213                 irlap_send_test_frame(self, self->caddr, info->daddr, skb);
2214                 break;
2215         default:
2216                 IRDA_DEBUG(1, "%s(), Unknown event %d, (%s)\n", __FUNCTION__,
2217                            event, irlap_event[event]);
2218
2219                 ret = -EINVAL;
2220                 break;
2221         }
2222         return ret;
2223 }
2224
2225 /*
2226  * Function irlap_state_sclose (self, event, skb, info)
2227  */
2228 static int irlap_state_sclose(struct irlap_cb *self, IRLAP_EVENT event,
2229                               struct sk_buff *skb, struct irlap_info *info)
2230 {
2231         int ret = 0;
2232
2233         IRDA_DEBUG(1, "%s()\n", __FUNCTION__);
2234
2235         IRDA_ASSERT(self != NULL, return -ENODEV;);
2236         IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;);
2237
2238         switch (event) {
2239         case RECV_DISC_CMD:
2240                 /* Always switch state before calling upper layers */
2241                 irlap_next_state(self, LAP_NDM);
2242
2243                 /* Send disconnect response */
2244                 irlap_wait_min_turn_around(self, &self->qos_tx);
2245                 irlap_send_ua_response_frame(self, NULL);
2246
2247                 del_timer(&self->wd_timer);
2248                 /* Set default link parameters */
2249                 irlap_apply_default_connection_parameters(self);
2250
2251                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
2252                 break;
2253         case RECV_DM_RSP:
2254                 /* IrLAP-1.1 p.82: in SCLOSE, S and I type RSP frames
2255                  * shall take us down into default NDM state, like DM_RSP
2256                  */
2257         case RECV_RR_RSP:
2258         case RECV_RNR_RSP:
2259         case RECV_REJ_RSP:
2260         case RECV_SREJ_RSP:
2261         case RECV_I_RSP:
2262                 /* Always switch state before calling upper layers */
2263                 irlap_next_state(self, LAP_NDM);
2264
2265                 del_timer(&self->wd_timer);
2266                 irlap_apply_default_connection_parameters(self);
2267
2268                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
2269                 break;
2270         case WD_TIMER_EXPIRED:
2271                 /* Always switch state before calling upper layers */
2272                 irlap_next_state(self, LAP_NDM);
2273
2274                 irlap_apply_default_connection_parameters(self);
2275
2276                 irlap_disconnect_indication(self, LAP_DISC_INDICATION);
2277                 break;
2278         default:
2279                 /* IrLAP-1.1 p.82: in SCLOSE, basically any received frame
2280                  * with pf=1 shall restart the wd-timer and resend the rd:rsp
2281                  */
2282                 if (info != NULL  &&  info->pf) {
2283                         del_timer(&self->wd_timer);
2284                         irlap_wait_min_turn_around(self, &self->qos_tx);
2285                         irlap_send_rd_frame(self);
2286                         irlap_start_wd_timer(self, self->wd_timeout);
2287                         break;          /* stay in SCLOSE */
2288                 }
2289
2290                 IRDA_DEBUG(1, "%s(), Unknown event %d, (%s)\n", __FUNCTION__,
2291                            event, irlap_event[event]);
2292
2293                 ret = -EINVAL;
2294                 break;
2295         }
2296
2297         return -1;
2298 }
2299
2300 static int irlap_state_reset_check( struct irlap_cb *self, IRLAP_EVENT event,
2301                                    struct sk_buff *skb,
2302                                    struct irlap_info *info)
2303 {
2304         int ret = 0;
2305
2306         IRDA_DEBUG(1, "%s(), event=%s\n", __FUNCTION__, irlap_event[event]);
2307
2308         IRDA_ASSERT(self != NULL, return -ENODEV;);
2309         IRDA_ASSERT(self->magic == LAP_MAGIC, return -EBADR;);
2310
2311         switch (event) {
2312         case RESET_RESPONSE:
2313                 irlap_send_ua_response_frame(self, &self->qos_rx);
2314                 irlap_initiate_connection_state(self);
2315                 irlap_start_wd_timer(self, WD_TIMEOUT);
2316                 irlap_flush_all_queues(self);
2317
2318                 irlap_next_state(self, LAP_NRM_S);
2319                 break;
2320         case DISCONNECT_REQUEST:
2321                 irlap_wait_min_turn_around(self, &self->qos_tx);
2322                 irlap_send_rd_frame(self);
2323                 irlap_start_wd_timer(self, WD_TIMEOUT);
2324                 irlap_next_state(self, LAP_SCLOSE);
2325                 break;
2326         default:
2327                 IRDA_DEBUG(1, "%s(), Unknown event %d, (%s)\n", __FUNCTION__,
2328                            event, irlap_event[event]);
2329
2330                 ret = -EINVAL;
2331                 break;
2332         }
2333         return ret;
2334 }