linux/net/irda/irlap_event.c
<<
>>
Prefs
   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
  47int sysctl_fast_poll_increase = 50;
  48#endif
  49
  50static int irlap_state_ndm    (struct irlap_cb *self, IRLAP_EVENT event,
  51                               struct sk_buff *skb, struct irlap_info *info);
  52static int irlap_state_query  (struct irlap_cb *self, IRLAP_EVENT event,
  53                               struct sk_buff *skb, struct irlap_info *info);
  54static int irlap_state_reply  (struct irlap_cb *self, IRLAP_EVENT event,
  55                               struct sk_buff *skb, struct irlap_info *info);
  56static int irlap_state_conn   (struct irlap_cb *self, IRLAP_EVENT event,
  57                               struct sk_buff *skb, struct irlap_info *info);
  58static int irlap_state_setup  (struct irlap_cb *self, IRLAP_EVENT event,
  59                               struct sk_buff *skb, struct irlap_info *info);
  60static int irlap_state_offline(struct irlap_cb *self, IRLAP_EVENT event,
  61                               struct sk_buff *skb, struct irlap_info *info);
  62static int irlap_state_xmit_p (struct irlap_cb *self, IRLAP_EVENT event,
  63                               struct sk_buff *skb, struct irlap_info *info);
  64static int irlap_state_pclose (struct irlap_cb *self, IRLAP_EVENT event,
  65                               struct sk_buff *skb, struct irlap_info *info);
  66static int irlap_state_nrm_p  (struct irlap_cb *self, IRLAP_EVENT event,
  67                               struct sk_buff *skb, struct irlap_info *info);
  68static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
  69                                  struct sk_buff *skb, struct irlap_info *info);
  70static int irlap_state_reset  (struct irlap_cb *self, IRLAP_EVENT event,
  71                               struct sk_buff *skb, struct irlap_info *info);
  72static int irlap_state_nrm_s  (struct irlap_cb *self, IRLAP_EVENT event,
  73                               struct sk_buff *skb, struct irlap_info *info);
  74static int irlap_state_xmit_s (struct irlap_cb *self, IRLAP_EVENT event,
  75                               struct sk_buff *skb, struct irlap_info *info);
  76static int irlap_state_sclose (struct irlap_cb *self, IRLAP_EVENT event,
  77                               struct sk_buff *skb, struct irlap_info *info);
  78static int irlap_state_reset_check(struct irlap_cb *, IRLAP_EVENT event,
  79                                   struct sk_buff *, struct irlap_info *);
  80
  81#ifdef CONFIG_IRDA_DEBUG
  82static 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
 124const 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
 142static 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 */
 168static 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 */
 184static 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 */
 237void 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 */
 326static 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 */
 558static 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 */
 669static 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 */
 737static 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 */
 831static 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 */
 967static 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 */
 983static 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 */
1137static 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 */
1194static 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 */
1608static 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 */
1655static 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 */
1748static 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 */
1868static 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 */
2227static 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
2296static 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}
2331
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.