net/irda/irlap_event.c

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