PageRenderTime 109ms CodeModel.GetById 33ms app.highlight 64ms RepoModel.GetById 1ms app.codeStats 1ms

/net/irda/irlap_event.c

http://github.com/mirrors/linux
C | 2316 lines | 1309 code | 307 blank | 700 comment | 241 complexity | c113c221fc163573062b46af5303a35b MD5 | raw file

Large files files are truncated, but you can click here to view the full file

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

Large files files are truncated, but you can click here to view the full file