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}