~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/irda/irlap_event.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp