Loading...
Note: File does not exist in v6.8.
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}