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