?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.4pre3
[davej-history.git] / net / irda / irlap_event.c
blob936401339cfd4c70d64ac429e3f278037136edd3
1 /*********************************************************************
2 *
3 * Filename: irlap_event.c
4 * Version: 0.8
5 * Description: IrLAP state machine implementation
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sat Aug 16 00:59:29 1997
9 * Modified at: Sun May 9 22:44:32 1999
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 *
12 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
13 * Thomas Davis <ratbert@radiks.net>
14 * All Rights Reserved.
15 *
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation; either version 2 of
19 * the License, or (at your option) any later version.
20 *
21 * Neither Dag Brattli nor University of Tromsø admit liability nor
22 * provide warranty for any of this software. This material is
23 * provided "AS-IS" and at no charge.
24 *
25 ********************************************************************/
26
27 #include <linux/config.h>
28 #include <linux/string.h>
29 #include <linux/kernel.h>
30 #include <linux/delay.h>
31 #include <linux/skbuff.h>
32
33 #include <net/irda/irda.h>
34 #include <net/irda/irlap_event.h>
35
36 #include <net/irda/timer.h>
37 #include <net/irda/irlap.h>
38 #include <net/irda/irlap_frame.h>
39 #include <net/irda/qos.h>
40
41 #include <net/irda/irda_device.h>
42
43 #if CONFIG_IRDA_FAST_RR
44 int sysctl_fast_poll_increase = 50;
45 #endif
46
47 static int irlap_state_ndm (struct irlap_cb *self, IRLAP_EVENT event,
48 struct sk_buff *skb, struct irlap_info *info);
49 static int irlap_state_query (struct irlap_cb *self, IRLAP_EVENT event,
50 struct sk_buff *skb, struct irlap_info *info);
51 static int irlap_state_reply (struct irlap_cb *self, IRLAP_EVENT event,
52 struct sk_buff *skb, struct irlap_info *info);
53 static int irlap_state_conn (struct irlap_cb *self, IRLAP_EVENT event,
54 struct sk_buff *skb, struct irlap_info *info);
55 static int irlap_state_setup (struct irlap_cb *self, IRLAP_EVENT event,
56 struct sk_buff *skb, struct irlap_info *info);
57 static int irlap_state_offline(struct irlap_cb *self, IRLAP_EVENT event,
58 struct sk_buff *skb, struct irlap_info *info);
59 static int irlap_state_xmit_p (struct irlap_cb *self, IRLAP_EVENT event,
60 struct sk_buff *skb, struct irlap_info *info);
61 static int irlap_state_pclose (struct irlap_cb *self, IRLAP_EVENT event,
62 struct sk_buff *skb, struct irlap_info *info);
63 static int irlap_state_nrm_p (struct irlap_cb *self, IRLAP_EVENT event,
64 struct sk_buff *skb, struct irlap_info *info);
65 static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
66 struct sk_buff *skb, struct irlap_info *info);
67 static int irlap_state_reset (struct irlap_cb *self, IRLAP_EVENT event,
68 struct sk_buff *skb, struct irlap_info *info);
69 static int irlap_state_nrm_s (struct irlap_cb *self, IRLAP_EVENT event,
70 struct sk_buff *skb, struct irlap_info *info);
71 static int irlap_state_xmit_s (struct irlap_cb *self, IRLAP_EVENT event,
72 struct sk_buff *skb, struct irlap_info *info);
73 static int irlap_state_sclose (struct irlap_cb *self, IRLAP_EVENT event,
74 struct sk_buff *skb, struct irlap_info *info);
75 static int irlap_state_reset_check(struct irlap_cb *, IRLAP_EVENT event,
76 struct sk_buff *, struct irlap_info *);
77
78 static const char *irlap_event[] = {
79 "DISCOVERY_REQUEST",
80 "CONNECT_REQUEST",
81 "CONNECT_RESPONSE",
82 "DISCONNECT_REQUEST",
83 "DATA_REQUEST",
84 "RESET_REQUEST",
85 "RESET_RESPONSE",
86 "SEND_I_CMD",
87 "RECV_DISCOVERY_XID_CMD",
88 "RECV_DISCOVERY_XID_RSP",
89 "RECV_SNRM_CMD",
90 "RECV_TEST_CMD",
91 "RECV_TEST_RSP",
92 "RECV_UA_RSP",
93 "RECV_DM_RSP",
94 "RECV_I_CMD",
95 "RECV_I_RSP",
96 "RECV_UI_FRAME",
97 "RECV_FRMR_RSP",
98 "RECV_RR_CMD",
99 "RECV_RR_RSP",
100 "RECV_RNR_FRAME",
101 "RECV_DISC_FRAME",
102 "SLOT_TIMER_EXPIRED",
103 "QUERY_TIMER_EXPIRED",
104 "FINAL_TIMER_EXPIRED",
105 "POLL_TIMER_EXPIRED",
106 "DISCOVERY_TIMER_EXPIRED",
107 "WD_TIMER_EXPIRED",
108 "BACKOFF_TIMER_EXPIRED",
109 };
110
111 const char *irlap_state[] = {
112 "LAP_NDM",
113 "LAP_QUERY",
114 "LAP_REPLY",
115 "LAP_CONN",
116 "LAP_SETUP",
117 "LAP_OFFLINE",
118 "LAP_XMIT_P",
119 "LAP_PCLOSE",
120 "LAP_NRM_P",
121 "LAP_RESET_WAIT",
122 "LAP_RESET",
123 "LAP_NRM_S",
124 "LAP_XMIT_S",
125 "LAP_SCLOSE",
126 "LAP_RESET_CHECK",
127 };
128
129 static int (*state[])( struct irlap_cb *self, IRLAP_EVENT event,
130 struct sk_buff *skb, struct irlap_info *info) =
131 {
132 irlap_state_ndm,
133 irlap_state_query,
134 irlap_state_reply,
135 irlap_state_conn,
136 irlap_state_setup,
137 irlap_state_offline,
138 irlap_state_xmit_p,
139 irlap_state_pclose,
140 irlap_state_nrm_p,
141 irlap_state_reset_wait,
142 irlap_state_reset,
143 irlap_state_nrm_s,
144 irlap_state_xmit_s,
145 irlap_state_sclose,
146 irlap_state_reset_check,
147 };
148
149 /*
150 * Function irda_poll_timer_expired (data)
151 *
152 * Poll timer has expired. Normally we must now send a RR frame to the
153 * remote device
154 */
155 static void irlap_poll_timer_expired(unsigned long data)
156 {
157 struct irlap_cb *self = (struct irlap_cb *) data;
158
159 ASSERT(self != NULL, return;);
160 ASSERT(self->magic == LAP_MAGIC, return;);
161
162 irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL);
163 }
164
165 void irlap_start_poll_timer(struct irlap_cb *self, int timeout)
166 {
167 ASSERT(self != NULL, return;);
168 ASSERT(self->magic == LAP_MAGIC, return;);
169
170 #ifdef CONFIG_IRDA_FAST_RR
171 if (skb_queue_len(&self->tx_list) == 0) {
172 if (self->fast_RR == TRUE) {
173 /*
174 * Assert that the fast poll timer has not reached the
175 * normal poll timer yet
176 */
177 if (self->fast_RR_timeout < timeout) {
178 /*
179 * FIXME: this should be a more configurable
180 * function
181 */
182 self->fast_RR_timeout += (sysctl_fast_poll_increase * HZ/1000);
183
184 /* Use this fast(er) timeout instead */
185 timeout = self->fast_RR_timeout;
186 }
187 } else {
188 self->fast_RR = TRUE;
189
190 /* Start with just 0 ms */
191 self->fast_RR_timeout = 0;
192 timeout = 0;
193 }
194 } else
195 self->fast_RR = FALSE;
196
197 DEBUG(4, __FUNCTION__ "(), Timeout=%d\n", timeout);
198 #endif
199 if (timeout == 0)
200 irlap_do_event(self, POLL_TIMER_EXPIRED, NULL, NULL);
201 else
202 irda_start_timer(&self->poll_timer, timeout,
203 (unsigned long) self, irlap_poll_timer_expired);
204 }
205
206 /*
207 * Function irlap_do_event (event, skb, info)
208 *
209 * Rushes through the state machine without any delay. If state == XMIT
210 * then send queued data frames.
211 */
212 void irlap_do_event( struct irlap_cb *self, IRLAP_EVENT event,
213 struct sk_buff *skb, struct irlap_info *info)
214 {
215 int ret;
216
217 if (!self || self->magic != LAP_MAGIC)
218 return;
219
220 DEBUG(4, __FUNCTION__ "(), event = %s, state = %s\n",
221 irlap_event[ event], irlap_state[ self->state]);
222
223 ret = (*state[ self->state]) (self, event, skb, info);
224
225 /*
226 * Check if there are any pending events that needs to be executed
227 */
228 switch (self->state) {
229 case LAP_XMIT_P: /* FALLTHROUGH */
230 case LAP_XMIT_S:
231 /*
232 * Check if there are any queued data frames, and do not
233 * try to disconnect link if we send any data frames, since
234 * that will change the state away form XMIT
235 */
236 if (skb_queue_len(&self->tx_list)) {
237 /* Try to send away all queued data frames */
238 while ((skb = skb_dequeue(&self->tx_list)) != NULL) {
239 ret = (*state[ self->state])(self, SEND_I_CMD,
240 skb, NULL);
241 if ( ret == -EPROTO)
242 break; /* Try again later! */
243 }
244 } else if (self->disconnect_pending) {
245 DEBUG(0, __FUNCTION__ "(), disconnecting!\n");
246 self->disconnect_pending = FALSE;
247
248 ret = (*state[self->state])(self, DISCONNECT_REQUEST,
249 NULL, NULL);
250 }
251 break;
252 case LAP_NDM:
253 /* Check if we should try to connect */
254 if ((self->connect_pending) &&
255 !irda_device_is_media_busy(self->irdev))
256 {
257 self->connect_pending = FALSE;
258
259 ret = (*state[self->state])(self, CONNECT_REQUEST,
260 NULL, NULL);
261 }
262 break;
263 /* case LAP_CONN: */
264 /* case LAP_RESET_WAIT: */
265 /* case LAP_RESET_CHECK: */
266 default:
267 break;
268 }
269 }
270
271 /*
272 * Function irlap_next_state (self, state)
273 *
274 * Switches state and provides debug information
275 *
276 */
277 void irlap_next_state(struct irlap_cb *self, IRLAP_STATE state)
278 {
279 if (!self || self->magic != LAP_MAGIC)
280 return;
281
282 DEBUG(4, "next LAP state = %s\n", irlap_state[ state]);
283
284 self->state = state;
285
286 /*
287 * If we are swithing away from a XMIT state then we are allowed to
288 * transmit a maximum number of bytes again when we enter the XMIT
289 * state again. Since its possible to "switch" from XMIT to XMIT,
290 * we cannot do this when swithing into the XMIT state :-)
291 */
292 if ((state != LAP_XMIT_P) && (state != LAP_XMIT_S))
293 self->bytes_left = self->window_bytes;
294 }
295
296 /*
297 * Function irlap_state_ndm (event, skb, frame)
298 *
299 * NDM (Normal Disconnected Mode) state
300 *
301 */
302 static int irlap_state_ndm( struct irlap_cb *self, IRLAP_EVENT event,
303 struct sk_buff *skb, struct irlap_info *info)
304 {
305 discovery_t *discovery_rsp;
306 int ret = 0;
307
308 DEBUG( 4, __FUNCTION__ "()\n");
309
310 ASSERT( self != NULL, return -1;);
311 ASSERT( self->magic == LAP_MAGIC, return -1;);
312
313 switch(event) {
314 case CONNECT_REQUEST:
315 ASSERT( self->irdev != NULL, return -1;);
316
317 if (irda_device_is_media_busy(self->irdev)) {
318 DEBUG( 0, __FUNCTION__
319 "(), CONNECT_REQUEST: media busy!\n");
320
321 /* Always switch state before calling upper layers */
322 irlap_next_state( self, LAP_NDM);
323
324 irlap_disconnect_indication( self, LAP_MEDIA_BUSY);
325 } else {
326 irlap_send_snrm_frame( self, &self->qos_rx);
327
328 /* Start Final-bit timer */
329 irlap_start_final_timer(self, self->final_timeout);
330
331 self->retry_count = 0;
332 irlap_next_state( self, LAP_SETUP);
333 }
334 break;
335
336 case RECV_SNRM_CMD:
337 self->daddr = info->daddr;
338 self->caddr = info->caddr;
339
340 irlap_next_state( self, LAP_CONN);
341
342 irlap_connect_indication( self, skb);
343 break;
344
345 case DISCOVERY_REQUEST:
346 ASSERT( info != NULL, return -1;);
347
348 if (irda_device_is_media_busy(self->irdev)) {
349 DEBUG(0, __FUNCTION__ "(), media busy!\n");
350 /* irlap->log.condition = MEDIA_BUSY; */
351
352 /* Always switch state before calling upper layers */
353 irlap_next_state(self, LAP_NDM);
354
355 /* This will make IrLMP try again */
356 irlap_discovery_confirm(self, NULL);
357 return 0;
358 }
359
360 self->S = info->S;
361 self->s = info->s;
362 irlap_send_discovery_xid_frame(self, info->S, info->s, TRUE,
363 info->discovery);
364 self->s++;
365
366 irlap_start_slot_timer(self, self->slot_timeout);
367 irlap_next_state(self, LAP_QUERY);
368 break;
369
370 case RECV_DISCOVERY_XID_CMD:
371 ASSERT( info != NULL, return -1;);
372
373 /* Assert that this is not the final slot */
374 if ( info->s <= info->S) {
375 /* self->daddr = info->daddr; */
376 self->slot = irlap_generate_rand_time_slot(info->S,
377 info->s);
378 DEBUG( 4, "XID_CMD: S=%d, s=%d, slot %d\n", info->S,
379 info->s, self->slot);
380
381 if ( self->slot == info->s) {
382 discovery_rsp = irlmp_get_discovery_response();
383 discovery_rsp->daddr = info->daddr;
384
385 irlap_send_discovery_xid_frame(self, info->S,
386 self->slot,
387 FALSE,
388 discovery_rsp);
389 self->frame_sent = TRUE;
390 } else
391 self->frame_sent = FALSE;
392
393 irlap_start_query_timer( self, QUERY_TIMEOUT);
394 irlap_next_state( self, LAP_REPLY);
395 }
396 dev_kfree_skb(skb);
397 break;
398
399 case RECV_TEST_CMD:
400 skb_pull(skb, sizeof(struct test_frame));
401 irlap_send_test_frame(self, info->daddr, skb);
402 dev_kfree_skb(skb);
403 break;
404 case RECV_TEST_RSP:
405 DEBUG(0, __FUNCTION__ "() not implemented!\n");
406 dev_kfree_skb(skb);
407 break;
408 default:
409 DEBUG(2, __FUNCTION__ "(), Unknown event %s",
410 irlap_event[event]);
411 ret = -1;
412 break;
413 }
414 return ret;
415 }
416
417 /*
418 * Function irlap_state_query (event, skb, info)
419 *
420 * QUERY state
421 *
422 */
423 static int irlap_state_query( struct irlap_cb *self, IRLAP_EVENT event,
424 struct sk_buff *skb, struct irlap_info *info)
425 {
426 int ret = 0;
427
428 ASSERT( self != NULL, return -1;);
429 ASSERT( self->magic == LAP_MAGIC, return -1;);
430
431 switch( event) {
432 case RECV_DISCOVERY_XID_RSP:
433 ASSERT( info != NULL, return -1;);
434 ASSERT( info->discovery != NULL, return -1;);
435
436 DEBUG(4, __FUNCTION__ "(), daddr=%08x\n",
437 info->discovery->daddr);
438
439 hashbin_insert( self->discovery_log,
440 (QUEUE *) info->discovery,
441 info->discovery->daddr, NULL);
442
443 dev_kfree_skb(skb);
444
445 /* Keep state */
446 irlap_next_state( self, LAP_QUERY);
447 break;
448 case SLOT_TIMER_EXPIRED:
449 if (self->s < self->S) {
450 irlap_send_discovery_xid_frame(self, self->S,
451 self->s, TRUE,
452 self->discovery_cmd);
453 self->s++;
454 irlap_start_slot_timer(self, self->slot_timeout);
455
456 /* Keep state */
457 irlap_next_state(self, LAP_QUERY);
458 } else {
459 /* This is the final slot! */
460 irlap_send_discovery_xid_frame(self, self->S, 0xff,
461 TRUE,
462 self->discovery_cmd);
463
464 /* Always switch state before calling upper layers */
465 irlap_next_state(self, LAP_NDM);
466
467 /*
468 * We are now finished with the discovery procedure,
469 * so now we must return the results
470 */
471 irlap_discovery_confirm(self, self->discovery_log);
472 }
473 break;
474 default:
475 DEBUG(2, __FUNCTION__ "(), Unknown event %d, %s\n", event,
476 irlap_event[event]);
477
478 if (skb)
479 dev_kfree_skb( skb);
480
481 ret = -1;
482 break;
483 }
484 return ret;
485 }
486
487 /*
488 * Function irlap_state_reply (self, event, skb, info)
489 *
490 * REPLY, we have received a XID discovery frame from a device and we
491 * are waiting for the right time slot to send a response XID frame
492 *
493 */
494 static int irlap_state_reply(struct irlap_cb *self, IRLAP_EVENT event,
495 struct sk_buff *skb, struct irlap_info *info)
496 {
497 discovery_t *discovery_rsp;
498 int ret=0;
499
500 DEBUG(4, __FUNCTION__ "()\n");
501
502 ASSERT(self != NULL, return -1;);
503 ASSERT(self->magic == LAP_MAGIC, return -1;);
504
505 switch(event) {
506 case QUERY_TIMER_EXPIRED:
507 DEBUG(2, __FUNCTION__ "(), QUERY_TIMER_EXPIRED <%ld>\n",
508 jiffies);
509 irlap_next_state(self, LAP_NDM);
510 break;
511 case RECV_DISCOVERY_XID_CMD:
512 ASSERT(info != NULL, return -1;);
513 /*
514 * Last frame?
515 */
516 if (info->s == 0xff) {
517 del_timer(&self->query_timer);
518
519 /* info->log.condition = REMOTE; */
520
521 /* Always switch state before calling upper layers */
522 irlap_next_state(self, LAP_NDM);
523
524 irlap_discovery_indication(self, info->discovery);
525 } else if ((info->s >= self->slot) && (!self->frame_sent)) {
526 discovery_rsp = irlmp_get_discovery_response();
527 discovery_rsp->daddr = info->daddr;
528
529 irlap_send_discovery_xid_frame(self, info->S,
530 self->slot, FALSE,
531 discovery_rsp);
532
533 self->frame_sent = TRUE;
534 irlap_next_state(self, LAP_REPLY);
535 }
536 dev_kfree_skb(skb);
537 break;
538 default:
539 DEBUG(1, __FUNCTION__ "(), Unknown event %d, %s\n", event,
540 irlap_event[event]);
541
542 if ( skb)
543 dev_kfree_skb( skb);
544
545 ret = -1;
546 break;
547 }
548 return ret;
549 }
550
551 /*
552 * Function irlap_state_conn (event, skb, info)
553 *
554 * CONN, we have received a SNRM command and is waiting for the upper
555 * layer to accept or refuse connection
556 *
557 */
558 static int irlap_state_conn(struct irlap_cb *self, IRLAP_EVENT event,
559 struct sk_buff *skb, struct irlap_info *info)
560 {
561 int ret = 0;
562
563 DEBUG(4, __FUNCTION__ "(), event=%s\n", irlap_event[ event]);
564
565 ASSERT(self != NULL, return -1;);
566 ASSERT(self->magic == LAP_MAGIC, return -1;);
567
568 switch (event) {
569 case CONNECT_RESPONSE:
570 /* skb_pull(skb, 11); */
571 skb_pull(skb, sizeof(struct snrm_frame));
572
573 ASSERT(self->irdev != NULL, return -1;);
574 irda_qos_negotiate(&self->qos_rx, &self->qos_tx, skb);
575
576 irlap_initiate_connection_state( self);
577
578 /*
579 * We are allowed to send two frames!
580 */
581 irlap_send_ua_response_frame(self, &self->qos_rx);
582 irlap_send_ua_response_frame(self, &self->qos_rx);
583
584 irlap_apply_connection_parameters(self, &self->qos_tx);
585
586 /*
587 * The WD-timer could be set to the duration of the P-timer
588 * for this case, but it is recommended to use twice the
589 * value (note 3 IrLAP p. 60).
590 */
591 irlap_start_wd_timer(self, self->wd_timeout);
592 irlap_next_state( self, LAP_NRM_S);
593 break;
594
595 case RECV_SNRM_CMD:
596 DEBUG( 3, __FUNCTION__ "(), event RECV_SNRM_CMD!\n");
597 #if 0
598 irlap_next_state( self, LAP_NDM);
599 #endif
600 break;
601
602 case RECV_DISCOVERY_XID_CMD:
603 DEBUG( 3, __FUNCTION__ "(), event RECV_DISCOVER_XID_CMD!\n");
604 irlap_next_state( self, LAP_NDM);
605 break;
606
607 case DISCONNECT_REQUEST:
608 irlap_send_dm_frame( self);
609 irlap_next_state( self, LAP_CONN);
610 break;
611
612 default:
613 DEBUG(1, __FUNCTION__ "(), Unknown event %d, %s\n", event,
614 irlap_event[event]);
615 ret = -1;
616 break;
617 }
618
619 return ret;
620 }
621
622 /*
623 * Function irlap_state_setup (event, skb, frame)
624 *
625 * SETUP state, The local layer has transmitted a SNRM command frame to
626 * a remote peer layer and is awaiting a reply .
627 *
628 */
629 static int irlap_state_setup( struct irlap_cb *self, IRLAP_EVENT event,
630 struct sk_buff *skb, struct irlap_info *info)
631 {
632 int ret = 0;
633
634 DEBUG( 4, __FUNCTION__ "()\n");
635
636 ASSERT( self != NULL, return -1;);
637 ASSERT( self->magic == LAP_MAGIC, return -1;);
638
639 switch( event) {
640 case FINAL_TIMER_EXPIRED:
641 if ( self->retry_count < self->N3) {
642 /*
643 * Perform random backoff, Wait a random number of time units, minimum
644 * duration half the time taken to transmitt a SNRM frame, maximum duration
645 * 1.5 times the time taken to transmit a SNRM frame. So this time should
646 * between 15 msecs and 45 msecs.
647 */
648 irlap_start_backoff_timer( self, 2 + (jiffies % 3));
649 } else {
650 /* Always switch state before calling upper layers */
651 irlap_next_state( self, LAP_NDM);
652
653 irlap_disconnect_indication( self, LAP_FOUND_NONE);
654 }
655 break;
656 case BACKOFF_TIMER_EXPIRED:
657 irlap_send_snrm_frame( self, &self->qos_rx);
658 irlap_start_final_timer( self, self->final_timeout);
659 self->retry_count++;
660 break;
661
662 case RECV_SNRM_CMD:
663 DEBUG( 4, __FUNCTION__ "(), SNRM battle!\n");
664
665 ASSERT( skb != NULL, return 0;);
666 ASSERT( info != NULL, return 0;);
667
668 /*
669 * The device with the largest device address wins the battle
670 * (both have sent a SNRM command!)
671 */
672 if (info->daddr > self->saddr) {
673 del_timer(&self->final_timer);
674 irlap_initiate_connection_state(self);
675
676 ASSERT(self->irdev != NULL, return -1;);
677 /* skb_pull(skb, 11); */
678 skb_pull(skb, sizeof(struct snrm_frame));
679 irda_qos_negotiate(&self->qos_rx, &self->qos_tx, skb);
680
681 irlap_send_ua_response_frame(self, &self->qos_rx);
682 irlap_apply_connection_parameters(self, &self->qos_tx);
683 irlap_connect_confirm(self, skb);
684
685 /*
686 * The WD-timer could be set to the duration of the
687 * P-timer for this case, but it is recommended
688 * to use twice the value (note 3 IrLAP p. 60).
689 */
690 irlap_start_wd_timer(self, self->wd_timeout);
691
692 irlap_next_state(self, LAP_NRM_S);
693 } else {
694 /* We just ignore the other device! */
695 irlap_next_state(self, LAP_SETUP);
696 }
697 break;
698 case RECV_UA_RSP:
699 /* Stop F-timer */
700 del_timer( &self->final_timer);
701
702 /* Initiate connection state */
703 irlap_initiate_connection_state( self);
704
705 /* Negotiate connection parameters */
706 ASSERT( skb->len > 10, return -1;);
707 /* skb_pull(skb, 10); */
708 skb_pull(skb, sizeof(struct ua_frame));
709
710 ASSERT(self->irdev != NULL, return -1;);
711 irda_qos_negotiate( &self->qos_rx, &self->qos_tx, skb);
712
713 irlap_apply_connection_parameters( self, &self->qos_tx);
714 self->retry_count = 0;
715
716 /* This frame will just be sent at the old speed */
717 /* irlap_send_rr_frame( self, CMD_FRAME); */
718
719 irlap_start_final_timer( self, self->final_timeout/2);
720 irlap_next_state( self, LAP_NRM_P);
721
722 irlap_connect_confirm( self, skb);
723 break;
724
725 case RECV_DISC_FRAME:
726 del_timer( &self->final_timer);
727 irlap_next_state( self, LAP_NDM);
728
729 irlap_disconnect_indication( self, LAP_DISC_INDICATION);
730 break;
731
732 /* DM handled in irlap_frame.c, irlap_input() */
733
734 default:
735 DEBUG( 4, "irlap_state_setup: Unknown event");
736 ret = -1;
737 break;
738 }
739 return ret;
740 }
741
742 /*
743 * Function irlap_state_offline (self, event, skb, info)
744 *
745 * OFFLINE state, not used for now!
746 *
747 */
748 static int irlap_state_offline( struct irlap_cb *self, IRLAP_EVENT event,
749 struct sk_buff *skb, struct irlap_info *info)
750 {
751 DEBUG( 0, __FUNCTION__ "(), Unknown event\n");
752
753 return -1;
754 }
755
756 /*
757 * Function irlap_state_xmit_p (self, event, skb, info)
758 *
759 * XMIT, Only the primary station has right to transmit, and we
760 * therefore do not expect to receive any transmissions from other
761 * stations.
762 *
763 */
764 static int irlap_state_xmit_p( struct irlap_cb *self, IRLAP_EVENT event,
765 struct sk_buff *skb, struct irlap_info *info)
766 {
767 int ret = 0;
768
769 ASSERT( self != NULL, return -ENODEV;);
770 ASSERT( self->magic == LAP_MAGIC, return -EBADR;);
771
772 DEBUG( 4, __FUNCTION__ "(), event=%s, vs=%d, vr=%d",
773 irlap_event[ event], self->vs, self->vr);
774
775 switch (event) {
776 case SEND_I_CMD:
777 ASSERT( skb != NULL, return -1;);
778 DEBUG( 4, __FUNCTION__ "(), Window=%d\n", self->window);
779
780 /*
781 * Only send frame if send-window > 0.
782 */
783 if (( self->window > 0) && ( !self->remote_busy)) {
784
785 /*
786 * Test if we have transmitted more bytes over the
787 * link than its possible to do with the current
788 * speed and turn-around-time.
789 */
790 if (( skb->len+self->bofs_count) > self->bytes_left) {
791 DEBUG( 4, __FUNCTION__ "(), Not allowed to "
792 "transmit more bytes!\n");
793 skb_queue_head( &self->tx_list, skb);
794
795 /*
796 * We should switch state to LAP_NRM_P, but
797 * that is not possible since we must be sure
798 * that we poll the other side. Since we have
799 * used up our time, the poll timer should
800 * trigger anyway now,so we just wait for it
801 * DB
802 */
803 return -EPROTO;
804 }
805 self->bytes_left -= ( skb->len + self->bofs_count);
806
807 /*
808 * Send data with poll bit cleared only if window > 1
809 * and there is more frames after this one to be sent
810 */
811 if (( self->window > 1) &&
812 skb_queue_len( &self->tx_list) > 0)
813 {
814 DEBUG( 4, __FUNCTION__ "(), window > 1\n");
815 irlap_send_data_primary( self, skb);
816 irlap_next_state( self, LAP_XMIT_P);
817 } else {
818 DEBUG( 4, __FUNCTION__ "(), window <= 1\n");
819 irlap_send_data_primary_poll( self, skb);
820 irlap_next_state( self, LAP_NRM_P);
821
822 /*
823 * Make sure state machine does not try to send
824 * any more frames
825 */
826 ret = -EPROTO;
827 }
828 #ifdef CONFIG_IRDA_FAST_RR
829 /* Peer may want to reply immediately */
830 self->fast_RR = FALSE;
831 #endif
832 } else {
833 DEBUG( 4, __FUNCTION__
834 "(), Unable to send! remote busy?\n");
835 skb_queue_head(&self->tx_list, skb);
836
837 /*
838 * The next ret is important, because it tells
839 * irlap_next_state _not_ to deliver more frames
840 */
841 ret = -EPROTO;
842 }
843 break;
844 case POLL_TIMER_EXPIRED:
845 irlap_send_rr_frame(self, CMD_FRAME);
846 irlap_start_final_timer(self, self->final_timeout);
847 irlap_next_state(self, LAP_NRM_P);
848 break;
849 case DISCONNECT_REQUEST:
850 del_timer(&self->poll_timer);
851 irlap_wait_min_turn_around(self, &self->qos_tx);
852 irlap_send_disc_frame(self);
853 irlap_flush_all_queues(self);
854 irlap_start_final_timer(self, self->final_timeout);
855 self->retry_count = 0;
856 irlap_next_state(self, LAP_PCLOSE);
857 break;
858 default:
859 DEBUG(0, __FUNCTION__ "(), Unknown event %s\n",
860 irlap_event[event]);
861 ret = -EINVAL;
862 break;
863 }
864 return ret;
865 }
866
867 /*
868 * Function irlap_state_pclose (event, skb, info)
869 *
870 * PCLOSE state
871 */
872 static int irlap_state_pclose( struct irlap_cb *self, IRLAP_EVENT event,
873 struct sk_buff *skb, struct irlap_info *info)
874 {
875 int ret = 0;
876
877 DEBUG(1, __FUNCTION__ "()\n");
878
879 ASSERT( self != NULL, return -1;);
880 ASSERT( self->magic == LAP_MAGIC, return -1;);
881
882 switch( event) {
883 case RECV_UA_RSP:
884 del_timer( &self->final_timer);
885
886 irlap_apply_default_connection_parameters( self);
887
888 /* Always switch state before calling upper layers */
889 irlap_next_state( self, LAP_NDM);
890
891 irlap_disconnect_indication( self, LAP_DISC_INDICATION);
892
893 break;
894 case FINAL_TIMER_EXPIRED:
895 if ( self->retry_count < self->N3) {
896 irlap_wait_min_turn_around( self, &self->qos_tx);
897 irlap_send_disc_frame( self);
898 irlap_start_final_timer( self, self->final_timeout);
899 self->retry_count++;
900 /* Keep state */
901 } else {
902 irlap_apply_default_connection_parameters( self);
903
904 /*
905 * Always switch state before calling upper layers
906 */
907 irlap_next_state( self, LAP_NDM);
908
909 irlap_disconnect_indication( self, LAP_NO_RESPONSE);
910 }
911 break;
912 default:
913 DEBUG(1, __FUNCTION__ "(), Unknown event %d\n", event);
914 ret = -1;
915 break;
916 }
917 return ret;
918 }
919
920 /*
921 * Function irlap_state_nrm_p (self, event, skb, info)
922 *
923 * NRM_P (Normal Response Mode as Primary), The primary station has given
924 * permissions to a secondary station to transmit IrLAP resonse frames
925 * (by sending a frame with the P bit set). The primary station will not
926 * transmit any frames and is expecting to receive frames only from the
927 * secondary to which transmission permissions has been given.
928 */
929 static int irlap_state_nrm_p(struct irlap_cb *self, IRLAP_EVENT event,
930 struct sk_buff *skb, struct irlap_info *info)
931 {
932 int ret = 0;
933 int ns_status;
934 int nr_status;
935
936 ASSERT(self != NULL, return -1;);
937 ASSERT(self->magic == LAP_MAGIC, return -1;);
938
939 switch (event) {
940 case RECV_I_RSP: /* Optimize for the common case */
941 /* FIXME: must check for remote_busy below */
942 #ifdef CONFIG_IRDA_FAST_RR
943 /*
944 * Reset the fast_RR so we can use the fast RR code with
945 * full speed the next time since peer may have more frames
946 * to transmitt
947 */
948 self->fast_RR = FALSE;
949 #endif
950
951 ASSERT( info != NULL, return -1;);
952
953 ns_status = irlap_validate_ns_received(self, info->ns);
954 nr_status = irlap_validate_nr_received(self, info->nr);
955
956 /*
957 * Check for expected I(nformation) frame
958 */
959 if ((ns_status == NS_EXPECTED) && (nr_status == NR_EXPECTED)) {
960 /*
961 * poll bit cleared?
962 */
963 if (!info->pf) {
964 self->vr = (self->vr + 1) % 8;
965
966 /* Update Nr received */
967 irlap_update_nr_received( self, info->nr);
968
969 self->ack_required = TRUE;
970
971 /* Keep state, do not move this line */
972 irlap_next_state(self, LAP_NRM_P);
973
974 irlap_data_indication(self, skb);
975 } else {
976 del_timer(&self->final_timer);
977
978 self->vr = (self->vr + 1) % 8;
979
980 /* Update Nr received */
981 irlap_update_nr_received(self, info->nr);
982
983 /*
984 * Got expected NR, so reset the
985 * retry_count. This is not done by IrLAP,
986 * which is strange!
987 */
988 self->retry_count = 0;
989 self->ack_required = TRUE;
990
991 irlap_wait_min_turn_around(self, &self->qos_tx);
992 /*
993 * Important to switch state before calling
994 * upper layers
995 */
996 irlap_next_state(self, LAP_XMIT_P);
997
998 irlap_data_indication(self, skb);
999
1000 /* This is the last frame */
1001 irlap_start_poll_timer(self, self->poll_timeout);
1002 }
1003 break;
1004
1005 }
1006 /*
1007 * Unexpected next to send (Ns)
1008 */
1009 if ((ns_status == NS_UNEXPECTED) && (nr_status == NR_EXPECTED))
1010 {
1011 if ( !info->pf) {
1012 irlap_update_nr_received( self, info->nr);
1013
1014 /*
1015 * Wait until the last frame before doing
1016 * anything
1017 */
1018
1019 /* Keep state */
1020 irlap_next_state( self, LAP_NRM_P);
1021 } else {
1022 DEBUG( 4, __FUNCTION__
1023 "(), missing or duplicate frame!\n");
1024
1025 /* Update Nr received */
1026 irlap_update_nr_received( self, info->nr);
1027
1028 irlap_wait_min_turn_around( self, &self->qos_tx);
1029 irlap_send_rr_frame( self, CMD_FRAME);
1030
1031 self->ack_required = FALSE;
1032
1033 irlap_start_final_timer( self, self->final_timeout);
1034 irlap_next_state( self, LAP_NRM_P);
1035 }
1036 dev_kfree_skb( skb);
1037 break;
1038 }
1039 /*
1040 * Unexpected next to receive (Nr)
1041 */
1042 if ((ns_status == NS_EXPECTED) && (nr_status == NR_UNEXPECTED))
1043 {
1044 if ( info->pf) {
1045 self->vr = (self->vr + 1) % 8;
1046
1047 /* Update Nr received */
1048 irlap_update_nr_received( self, info->nr);
1049
1050 /* Resend rejected frames */
1051 irlap_resend_rejected_frames( self, CMD_FRAME);
1052
1053 self->ack_required = FALSE;
1054 irlap_start_final_timer( self, self->final_timeout);
1055
1056 /* Keep state, do not move this line */
1057 irlap_next_state( self, LAP_NRM_P);
1058
1059 irlap_data_indication( self, skb);
1060 } else {
1061 /*
1062 * Do not resend frames until the last
1063 * frame has arrived from the other
1064 * device. This is not documented in
1065 * IrLAP!!
1066 */
1067 self->vr = (self->vr + 1) % 8;
1068
1069 /* Update Nr received */
1070 irlap_update_nr_received( self, info->nr);
1071
1072 self->ack_required = FALSE;
1073
1074 /* Keep state, do not move this line!*/
1075 irlap_next_state( self, LAP_NRM_P);
1076
1077 irlap_data_indication( self, skb);
1078 }
1079 break;
1080 }
1081 /*
1082 * Unexpected next to send (Ns) and next to receive (Nr)
1083 * Not documented by IrLAP!
1084 */
1085 if ((ns_status == NS_UNEXPECTED) &&
1086 (nr_status == NR_UNEXPECTED))
1087 {
1088 DEBUG( 4, "IrLAP: unexpected nr and ns!\n");
1089 if ( info->pf) {
1090 /* Resend rejected frames */
1091 irlap_resend_rejected_frames( self, CMD_FRAME);
1092
1093 /* Give peer some time to retransmit! */
1094 irlap_start_final_timer( self, self->final_timeout);
1095
1096 /* Keep state, do not move this line */
1097 irlap_next_state( self, LAP_NRM_P);
1098 } else {
1099 /* Update Nr received */
1100 /* irlap_update_nr_received( info->nr); */
1101
1102 self->ack_required = FALSE;
1103 }
1104 break;
1105 }
1106
1107 /*
1108 * Invalid NR or NS
1109 */
1110 if ((nr_status == NR_INVALID) || (ns_status == NS_INVALID)) {
1111 if (info->pf) {
1112 del_timer(&self->final_timer);
1113
1114 irlap_next_state(self, LAP_RESET_WAIT);
1115
1116 irlap_disconnect_indication(self, LAP_RESET_INDICATION);
1117 self->xmitflag = TRUE;
1118 } else {
1119 del_timer(&self->final_timer);
1120
1121 irlap_disconnect_indication(self, LAP_RESET_INDICATION);
1122
1123 self->xmitflag = FALSE;
1124 }
1125 break;
1126 }
1127 DEBUG(1, __FUNCTION__ "(), Not implemented!\n");
1128 DEBUG(1, __FUNCTION__
1129 "(), event=%s, ns_status=%d, nr_status=%d\n",
1130 irlap_event[ event], ns_status, nr_status);
1131 break;
1132 case RECV_UI_FRAME:
1133 /* poll bit cleared? */
1134 if (!info->pf) {
1135 irlap_unit_data_indication(self, skb);
1136 irlap_next_state(self, LAP_NRM_P);
1137 } else {
1138 del_timer(&self->final_timer);
1139 irlap_unit_data_indication(self, skb);
1140 irlap_start_poll_timer(self, self->poll_timeout);
1141 }
1142 break;
1143 case RECV_RR_RSP:
1144 DEBUG(4, __FUNCTION__ "(), RECV_RR_FRAME: "
1145 "Retrans:%d, nr=%d, va=%d, vs=%d, vr=%d\n",
1146 self->retry_count, info->nr, self->va, self->vs,
1147 self->vr);
1148
1149 ASSERT(info != NULL, return -1;);
1150
1151 /*
1152 * If you get a RR, the remote isn't busy anymore,
1153 * no matter what the NR
1154 */
1155 self->remote_busy = FALSE;
1156
1157 /*
1158 * Nr as expected?
1159 */
1160 ret = irlap_validate_nr_received(self, info->nr);
1161 if (ret == NR_EXPECTED) {
1162 /* Stop final timer */
1163 del_timer(&self->final_timer);
1164
1165 /* Update Nr received */
1166 irlap_update_nr_received(self, info->nr);
1167
1168 /*
1169 * Got expected NR, so reset the retry_count. This
1170 * is not done by the IrLAP standard , which is
1171 * strange! DB.
1172 */
1173 self->retry_count = 0;
1174 irlap_wait_min_turn_around(self, &self->qos_tx);
1175
1176 irlap_next_state(self, LAP_XMIT_P);
1177
1178 /* Start poll timer */
1179 irlap_start_poll_timer(self, self->poll_timeout);
1180 } else if (ret == NR_UNEXPECTED) {
1181 ASSERT( info != NULL, return -1;);
1182 /*
1183 * Unexpected nr!
1184 */
1185
1186 /* Update Nr received */
1187 irlap_update_nr_received( self, info->nr);
1188
1189 DEBUG( 4, "RECV_RR_FRAME: Retrans:%d, nr=%d, va=%d, "
1190 "vs=%d, vr=%d\n",
1191 self->retry_count, info->nr, self->va,
1192 self->vs, self->vr);
1193
1194 /* Resend rejected frames */
1195 irlap_resend_rejected_frames( self, CMD_FRAME);
1196
1197 /*
1198 * Start only if not running, DB
1199 * TODO: Should this one be here?
1200 */
1201 /* if ( !self->final_timer.prev) */
1202 /* irda_start_timer( FINAL_TIMER, self->final_timeout); */
1203
1204 /* Keep state */
1205 irlap_next_state( self, LAP_NRM_P);
1206 } else if (ret == NR_INVALID) {
1207 DEBUG(1, "irlap_state_nrm_p: received RR with "
1208 "invalid nr !\n");
1209 del_timer( &self->final_timer);
1210
1211 irlap_next_state( self, LAP_RESET_WAIT);
1212
1213 irlap_disconnect_indication( self,
1214 LAP_RESET_INDICATION);
1215 self->xmitflag = TRUE;
1216 }
1217 if (skb)
1218 dev_kfree_skb( skb);
1219 break;
1220 case RECV_RNR_FRAME:
1221 DEBUG( 4, "irlap_state_nrm_p: RECV_RNR_FRAME: Retrans:%d, "
1222 "nr=%d, va=%d, vs=%d, vr=%d\n",
1223 self->retry_count, info->nr, self->va, self->vs,
1224 self->vr);
1225
1226 ASSERT( info != NULL, return -1;);
1227
1228 /* Stop final timer */
1229 del_timer( &self->final_timer);
1230 self->remote_busy = TRUE;
1231
1232 /* Update Nr received */
1233 irlap_update_nr_received( self, info->nr);
1234
1235 irlap_next_state( self, LAP_XMIT_P);
1236
1237 /* Start poll timer */
1238 irlap_start_poll_timer( self, self->poll_timeout);
1239
1240 dev_kfree_skb( skb);
1241 break;
1242 case RECV_FRMR_RSP:
1243 del_timer( &self->final_timer);
1244 self->xmitflag = TRUE;
1245 irlap_next_state( self, LAP_RESET_WAIT);
1246 irlap_reset_indication( self);
1247 break;
1248 case FINAL_TIMER_EXPIRED:
1249 /*
1250 * We are allowed to wait for additional 300 ms if
1251 * final timer expires when we are in the middle
1252 * of receiving a frame (page 45, IrLAP). Check that
1253 * we only do this once for each frame.
1254 */
1255 if ( irda_device_is_receiving( self->irdev) &&
1256 !self->add_wait) {
1257 DEBUG( 4, "FINAL_TIMER_EXPIRED when receiving a "
1258 "frame! Waiting a little bit more!\n");
1259 irlap_start_final_timer( self, 30);
1260
1261 /*
1262 * Don't allow this to happen one more time in a row,
1263 * or else we can get a pretty tight loop here if
1264 * if we only receive half a frame. DB.
1265 */
1266 self->add_wait = TRUE;
1267 break;
1268 }
1269 self->add_wait = FALSE;
1270
1271 if (( self->retry_count < self->N2) &&
1272 ( self->retry_count != self->N1)) {
1273
1274 irlap_wait_min_turn_around( self, &self->qos_tx);
1275 irlap_send_rr_frame( self, CMD_FRAME);
1276
1277 irlap_start_final_timer( self, self->final_timeout);
1278 self->retry_count++;
1279
1280 DEBUG( 4, "irlap_state_nrm_p: FINAL_TIMER_EXPIRED:"
1281 " retry_count=%d\n", self->retry_count);
1282 /* Keep state */
1283 } else if ( self->retry_count == self->N1) {
1284 irlap_status_indication( STATUS_NO_ACTIVITY);
1285 irlap_wait_min_turn_around( self, &self->qos_tx);
1286 irlap_send_rr_frame( self, CMD_FRAME);
1287
1288 irlap_start_final_timer( self, self->final_timeout);
1289 self->retry_count++;
1290
1291 DEBUG( 4, "retry count = N1; retry_count=%d\n",
1292 self->retry_count);
1293 /* Keep state */
1294 } else if ( self->retry_count >= self->N2) {
1295 irlap_apply_default_connection_parameters( self);
1296
1297 /* Always switch state before calling upper layers */
1298 irlap_next_state( self, LAP_NDM);
1299 irlap_disconnect_indication( self, LAP_NO_RESPONSE);
1300 }
1301 break;
1302 case RECV_DISC_FRAME: /* FIXME: Check how this is in the standard! */
1303 DEBUG(1, __FUNCTION__ "(), RECV_DISC_FRAME()\n");
1304
1305 /* Always switch state before calling upper layers */
1306 irlap_next_state( self, LAP_NDM);
1307
1308 irlap_wait_min_turn_around( self, &self->qos_tx);
1309 irlap_send_ua_response_frame( self, NULL);
1310
1311 del_timer( &self->final_timer);
1312 /* del_timer( &self->poll_timer); */
1313
1314 irlap_flush_all_queues( self);
1315 irlap_apply_default_connection_parameters( self);
1316
1317 irlap_disconnect_indication( self, LAP_DISC_INDICATION);
1318 if (skb)
1319 dev_kfree_skb( skb);
1320
1321 break;
1322 default:
1323 DEBUG(1, __FUNCTION__ "(), Unknown event %s\n",
1324 irlap_event[event]);
1325 ret = -1;
1326 break;
1327 }
1328 return ret;
1329 }
1330
1331 /*
1332 * Function irlap_state_reset_wait (event, skb, info)
1333 *
1334 * We have informed the service user of a reset condition, and is
1335 * awaiting reset of disconnect request.
1336 *
1337 */
1338 static int irlap_state_reset_wait(struct irlap_cb *self, IRLAP_EVENT event,
1339 struct sk_buff *skb, struct irlap_info *info)
1340 {
1341 int ret = 0;
1342
1343 DEBUG( 3, __FUNCTION__ "(), event = %s\n", irlap_event[event]);
1344
1345 ASSERT( self != NULL, return -1;);
1346 ASSERT( self->magic == LAP_MAGIC, return -1;);
1347
1348 switch( event) {
1349 case RESET_REQUEST:
1350 if ( self->xmitflag) {
1351 irlap_wait_min_turn_around( self, &self->qos_tx);
1352 irlap_send_snrm_frame( self, NULL);
1353 irlap_start_final_timer( self, self->final_timeout);
1354 irlap_next_state( self, LAP_RESET);
1355 } else {
1356 irlap_start_final_timer( self, self->final_timeout);
1357 irlap_next_state( self, LAP_RESET);
1358 }
1359 break;
1360 case DISCONNECT_REQUEST:
1361 irlap_wait_min_turn_around( self, &self->qos_tx);
1362 irlap_send_disc_frame( self);
1363 irlap_flush_all_queues( self);
1364 irlap_start_final_timer( self, self->final_timeout);
1365 self->retry_count = 0;
1366 irlap_next_state( self, LAP_PCLOSE);
1367 break;
1368 default:
1369 DEBUG(1, __FUNCTION__ "(), Unknown event %s\n",
1370 irlap_event[event]);
1371 ret = -1;
1372 break;
1373 }
1374 return ret;
1375 }
1376
1377 /*
1378 * Function irlap_state_reset (self, event, skb, info)
1379 *
1380 * We have sent a SNRM reset command to the peer layer, and is awaiting
1381 * reply.
1382 *
1383 */
1384 static int irlap_state_reset( struct irlap_cb *self, IRLAP_EVENT event,
1385 struct sk_buff *skb, struct irlap_info *info)
1386 {
1387 int ret = 0;
1388
1389 DEBUG(3, __FUNCTION__ "(), event = %s\n", irlap_event[event]);
1390
1391 ASSERT(self != NULL, return -1;);
1392 ASSERT(self->magic == LAP_MAGIC, return -1;);
1393
1394 switch(event) {
1395 case RECV_DISC_FRAME:
1396 del_timer(&self->final_timer);
1397
1398 irlap_apply_default_connection_parameters( self);
1399
1400 /* Always switch state before calling upper layers */
1401 irlap_next_state( self, LAP_NDM);
1402
1403 irlap_disconnect_indication( self, LAP_NO_RESPONSE);
1404 break;
1405 case RECV_UA_RSP:
1406 del_timer( &self->final_timer);
1407
1408 /* Initiate connection state */
1409 irlap_initiate_connection_state( self);
1410
1411 irlap_reset_confirm();
1412
1413 self->remote_busy = FALSE;
1414
1415 irlap_next_state( self, LAP_XMIT_P);
1416
1417 irlap_start_poll_timer( self, self->poll_timeout);
1418 break;
1419 case FINAL_TIMER_EXPIRED:
1420 if ( self->retry_count < 3) {
1421 irlap_wait_min_turn_around( self, &self->qos_tx);
1422
1423 ASSERT( self->irdev != NULL, return -1;);
1424 irlap_send_snrm_frame(self,
1425 irda_device_get_qos( self->irdev));
1426
1427 self->retry_count++; /* Experimental!! */
1428
1429 irlap_start_final_timer( self, self->final_timeout);
1430 irlap_next_state( self, LAP_RESET);
1431 } else if ( self->retry_count >= self->N3) {
1432 irlap_apply_default_connection_parameters( self);
1433
1434 /* Always switch state before calling upper layers */
1435 irlap_next_state( self, LAP_NDM);
1436
1437 irlap_disconnect_indication( self, LAP_NO_RESPONSE);
1438 }
1439 break;
1440
1441 case RECV_SNRM_CMD:
1442 DEBUG(3, "lap_reset: RECV_SNRM_CMD\n");
1443 irlap_initiate_connection_state( self);
1444 irlap_wait_min_turn_around( self, &self->qos_tx);
1445 irlap_send_ua_response_frame( self, &self->qos_rx);
1446 irlap_reset_confirm();
1447 irlap_start_wd_timer( self, self->wd_timeout);
1448 irlap_next_state( self, LAP_NDM);
1449 break;
1450
1451 default:
1452 DEBUG(1, __FUNCTION__ "(), Unknown event %s\n",
1453 irlap_event[ event]);
1454 ret = -1;
1455 break;
1456 }
1457 return ret;
1458 }
1459
1460 /*
1461 * Function irlap_state_xmit_s (event, skb, info)
1462 *
1463 * XMIT_S, The secondary station has been given the right to transmit,
1464 * and we therefor do not expect to receive any transmissions from other
1465 * stations.
1466 */
1467 static int irlap_state_xmit_s( struct irlap_cb *self, IRLAP_EVENT event,
1468 struct sk_buff *skb, struct irlap_info *info)
1469 {
1470 int ret = 0;
1471
1472 DEBUG( 4, __FUNCTION__ "(), event=%s\n", irlap_event[ event]);
1473
1474 ASSERT( self != NULL, return -ENODEV;);
1475 ASSERT( self->magic == LAP_MAGIC, return -EBADR;);
1476
1477 switch( event) {
1478 case SEND_I_CMD:
1479 /*
1480 * Send frame only if send window > 1
1481 */
1482 if (( self->window > 0) && ( !self->remote_busy)) {
1483 /*
1484 * Test if we have transmitted more bytes over the
1485 * link than its possible to do with the current
1486 * speed and turn-around-time.
1487 */
1488 if (( skb->len+self->bofs_count) > self->bytes_left) {
1489 DEBUG( 4, "IrDA: Not allowed to transmit more bytes!\n");
1490 skb_queue_head( &self->tx_list, skb);
1491 /*
1492 * Switch to NRM_S, this is only possible
1493 * when we are in secondary mode, since we
1494 * must be sure that we don't miss any RR
1495 * frames
1496 */
1497 irlap_next_state( self, LAP_NRM_S);
1498
1499 return -EPROTO; /* Try again later */
1500 }
1501 self->bytes_left -= ( skb->len + self->bofs_count);
1502
1503 /*
1504 * Send data with final bit cleared only if window > 1
1505 * and there is more frames to be sent
1506 */
1507 if (( self->window > 1) &&
1508 skb_queue_len( &self->tx_list) > 0)
1509 {
1510 DEBUG( 4, __FUNCTION__ "(), window > 1\n");
1511 irlap_send_data_secondary( self, skb);
1512 irlap_next_state( self, LAP_XMIT_S);
1513 } else {
1514 DEBUG( 4, "(), window <= 1\n");
1515 irlap_send_data_secondary_final( self, skb);
1516 irlap_next_state( self, LAP_NRM_S);
1517
1518 /*
1519 * Make sure state machine does not try to send
1520 * any more frames
1521 */
1522 ret = -EPROTO;
1523 }
1524 } else {
1525 DEBUG(1, __FUNCTION__ "(), Unable to send!\n");
1526 skb_queue_head( &self->tx_list, skb);
1527 ret = -EPROTO;
1528 }
1529 break;
1530 default:
1531 DEBUG(1, __FUNCTION__ "(), Unknown event %s\n",
1532 irlap_event[ event]);
1533 ret = -EINVAL;
1534 break;
1535 }
1536 return ret;
1537 }
1538
1539 /*
1540 * Function irlap_state_nrm_s (event, skb, info)
1541 *
1542 * NRM_S (Normal Response Mode as Secondary) state, in this state we are
1543 * expecting to receive frames from the primary station
1544 *
1545 */
1546 static int irlap_state_nrm_s( struct irlap_cb *self, IRLAP_EVENT event,
1547 struct sk_buff *skb, struct irlap_info *info)
1548 {
1549 int ret = 0;
1550 int ns_status;
1551 int nr_status;
1552
1553 DEBUG( 4, __FUNCTION__ "(), event=%s\n", irlap_event[ event]);
1554
1555 ASSERT( self != NULL, return -1;);
1556 ASSERT( self->magic == LAP_MAGIC, return -1;);
1557
1558 switch(event) {
1559 case RECV_I_CMD: /* Optimize for the common case */
1560 /* FIXME: must check for remote_busy below */
1561 DEBUG( 4, __FUNCTION__ "(), event=%s nr=%d, vs=%d, ns=%d, "
1562 "vr=%d, pf=%d\n", irlap_event[event], info->nr,
1563 self->vs, info->ns, self->vr, info->pf);
1564
1565 self->retry_count = 0;
1566
1567 ns_status = irlap_validate_ns_received( self, info->ns);
1568 nr_status = irlap_validate_nr_received( self, info->nr);
1569 /*
1570 * Check for expected I(nformation) frame
1571 */
1572 if ((ns_status == NS_EXPECTED) && (nr_status == NR_EXPECTED)) {
1573 /*
1574 * poll bit cleared?
1575 */
1576 if (!info->pf) {
1577 self->vr = (self->vr + 1) % 8;
1578
1579 /* Update Nr received */
1580 irlap_update_nr_received( self, info->nr);
1581
1582 self->ack_required = TRUE;
1583
1584 /*
1585 * Starting WD-timer here is optional, but
1586 * not recommended. Note 6 IrLAP p. 83
1587 */
1588 /* irda_start_timer( WD_TIMER, self->wd_timeout); */
1589
1590 /* Keep state, do not move this line */
1591 irlap_next_state( self, LAP_NRM_S);
1592
1593 irlap_data_indication( self, skb);
1594 break;
1595 } else {
1596 self->vr = (self->vr + 1) % 8;
1597
1598 /* Update Nr received */
1599 irlap_update_nr_received( self, info->nr);
1600
1601 /*
1602 * We should wait before sending RR, and
1603 * also before changing to XMIT_S
1604 * state. (note 1, IrLAP p. 82)
1605 */
1606 irlap_wait_min_turn_around(self, &self->qos_tx);
1607
1608 /*
1609 * Give higher layers a chance to
1610 * immediately reply with some data before
1611 * we decide if we should send a RR frame
1612 * or not
1613 */
1614 irlap_data_indication(self, skb);
1615
1616 /* Any pending data requests? */
1617 if ((skb_queue_len(&self->tx_list) > 0) &&
1618 (self->window > 0))
1619 {
1620 self->ack_required = TRUE;
1621
1622 del_timer(&self->wd_timer);
1623
1624 irlap_next_state(self, LAP_XMIT_S);
1625 } else {
1626 irlap_send_rr_frame(self, RSP_FRAME);
1627 irlap_start_wd_timer(self, self->wd_timeout);
1628
1629 /* Keep the state */
1630 irlap_next_state(self, LAP_NRM_S);
1631 }
1632 break;
1633 }
1634 }
1635 /*
1636 * Check for Unexpected next to send (Ns)
1637 */
1638 if (( ns_status == NS_UNEXPECTED) &&
1639 ( nr_status == NR_EXPECTED))
1640 {
1641 /* Unexpected next to send, with final bit cleared */
1642 if ( !info->pf) {
1643 irlap_update_nr_received( self, info->nr);
1644
1645 irlap_start_wd_timer( self, self->wd_timeout);
1646 } else {
1647 /* Update Nr received */
1648 irlap_update_nr_received( self, info->nr);
1649
1650 irlap_wait_min_turn_around( self, &self->qos_tx);
1651 irlap_send_rr_frame( self, CMD_FRAME);
1652
1653 irlap_start_wd_timer( self, self->wd_timeout);
1654 }
1655 dev_kfree_skb( skb);
1656 break;
1657 }
1658
1659 /*
1660 * Unexpected Next to Receive(NR) ?
1661 */
1662 if (( ns_status == NS_EXPECTED) &&
1663 ( nr_status == NR_UNEXPECTED))
1664 {
1665 if ( info->pf) {
1666 DEBUG( 4, "RECV_I_RSP: frame(s) lost\n");
1667
1668 self->vr = (self->vr + 1) % 8;
1669
1670 /* Update Nr received */
1671 irlap_update_nr_received( self, info->nr);
1672
1673 /* Resend rejected frames */
1674 irlap_resend_rejected_frames( self, RSP_FRAME);
1675
1676 /* Keep state, do not move this line */
1677 irlap_next_state( self, LAP_NRM_S);
1678
1679 irlap_data_indication( self, skb);
1680 irlap_start_wd_timer( self, self->wd_timeout);
1681
1682 break;
1683 }
1684 /*
1685 * This is not documented in IrLAP!! Unexpected NR
1686 * with poll bit cleared
1687 */
1688 if ( !info->pf) {
1689 self->vr = (self->vr + 1) % 8;
1690
1691 /* Update Nr received */
1692 irlap_update_nr_received( self, info->nr);
1693
1694 /* Keep state, do not move this line */
1695 irlap_next_state( self, LAP_NRM_S);
1696
1697 irlap_data_indication( self, skb);
1698 irlap_start_wd_timer( self, self->wd_timeout);
1699 }
1700 }
1701
1702 if ( ret == NR_INVALID) {
1703 DEBUG( 0, "NRM_S, NR_INVALID not implemented!\n");
1704 }
1705 if ( ret == NS_INVALID) {
1706 DEBUG( 0, "NRM_S, NS_INVALID not implemented!\n");
1707 }
1708 break;
1709 case RECV_UI_FRAME:
1710 /*
1711 * poll bit cleared?
1712 */
1713 if ( !info->pf) {
1714 irlap_unit_data_indication( self, skb);
1715 irlap_next_state( self, LAP_NRM_S); /* Keep state */
1716 } else {
1717 /*
1718 * Any pending data requests?
1719 */
1720 if (( skb_queue_len( &self->tx_list) > 0) &&
1721 ( self->window > 0) && !self->remote_busy)
1722 {
1723 irlap_unit_data_indication( self, skb);
1724
1725 del_timer( &self->wd_timer);
1726
1727 irlap_next_state( self, LAP_XMIT_S);
1728 } else {
1729 irlap_unit_data_indication( self, skb);
1730
1731 irlap_wait_min_turn_around( self, &self->qos_tx);
1732
1733 irlap_send_rr_frame( self, RSP_FRAME);
1734 self->ack_required = FALSE;
1735
1736 irlap_start_wd_timer( self, self->wd_timeout);
1737
1738 /* Keep the state */
1739 irlap_next_state( self, LAP_NRM_S);
1740 }
1741 }
1742 break;
1743 case RECV_RR_CMD:
1744 self->retry_count = 0;
1745
1746 /*
1747 * Nr as expected?
1748 */
1749 nr_status = irlap_validate_nr_received( self, info->nr);
1750 if ( nr_status == NR_EXPECTED) {
1751 if (( skb_queue_len( &self->tx_list) > 0) &&
1752 ( self->window > 0)) {
1753 self->remote_busy = FALSE;
1754
1755 /* Update Nr received */
1756 irlap_update_nr_received( self, info->nr);
1757 del_timer( &self->wd_timer);
1758
1759 irlap_wait_min_turn_around( self, &self->qos_tx);
1760 irlap_next_state( self, LAP_XMIT_S);
1761 } else {
1762 self->remote_busy = FALSE;
1763 /* Update Nr received */
1764 irlap_update_nr_received( self, info->nr);
1765 irlap_wait_min_turn_around( self, &self->qos_tx);
1766
1767 irlap_send_rr_frame( self, RSP_FRAME);
1768
1769 irlap_start_wd_timer( self, self->wd_timeout);
1770 irlap_next_state( self, LAP_NRM_S);
1771 }
1772 } else if ( nr_status == NR_UNEXPECTED) {
1773 self->remote_busy = FALSE;
1774 irlap_update_nr_received( self, info->nr);
1775 irlap_resend_rejected_frames( self, RSP_FRAME);
1776
1777 irlap_start_wd_timer( self, self->wd_timeout);
1778
1779 /* Keep state */
1780 irlap_next_state( self, LAP_NRM_S);
1781 } else {
1782 DEBUG(1, __FUNCTION__ "(), invalid nr not implemented!\n");
1783 }
1784 if ( skb)
1785 dev_kfree_skb( skb);
1786
1787 break;
1788 case RECV_SNRM_CMD:
1789 del_timer( &self->wd_timer);
1790 DEBUG(1, __FUNCTION__ "(), received SNRM cmd\n");
1791 irlap_next_state( self, LAP_RESET_CHECK);
1792
1793 irlap_reset_indication( self);
1794 break;
1795 case WD_TIMER_EXPIRED:
1796 DEBUG( 4, "WD_TIMER_EXPIRED: %ld\n", jiffies);
1797
1798 /*
1799 * Wait until retry_count * n matches negotiated threshold/
1800 * disconnect time (note 2 in IrLAP p. 82)
1801 */
1802 DEBUG(1, __FUNCTION__ "(), retry_count = %d\n",
1803 self->retry_count);
1804
1805 if (( self->retry_count < (self->N2/2)) &&
1806 ( self->retry_count != self->N1/2)) {
1807
1808 irlap_start_wd_timer( self, self->wd_timeout);
1809 self->retry_count++;
1810 } else if ( self->retry_count == (self->N1/2)) {
1811 irlap_status_indication( STATUS_NO_ACTIVITY);
1812 irlap_start_wd_timer( self, self->wd_timeout);
1813 self->retry_count++;
1814 } else if ( self->retry_count >= self->N2/2) {
1815 irlap_apply_default_connection_parameters( self);
1816
1817 /* Always switch state before calling upper layers */
1818 irlap_next_state( self, LAP_NDM);
1819
1820 irlap_disconnect_indication( self, LAP_NO_RESPONSE);
1821 }
1822 break;
1823
1824 case RECV_DISC_FRAME:
1825 /* Always switch state before calling upper layers */
1826 irlap_next_state( self, LAP_NDM);
1827
1828 irlap_wait_min_turn_around( self, &self->qos_tx);
1829 irlap_send_ua_response_frame( self, NULL);
1830 del_timer( &self->wd_timer);
1831 irlap_flush_all_queues( self);
1832 irlap_apply_default_connection_parameters( self);
1833
1834 irlap_disconnect_indication( self, LAP_DISC_INDICATION);
1835 if (skb)
1836 dev_kfree_skb( skb);
1837
1838 break;
1839
1840 case RECV_DISCOVERY_XID_CMD:
1841 DEBUG( 3, "irlap_state_nrm_s: got event RECV_DISCOVER_XID_CMD!\n");
1842 del_timer( &self->final_timer);
1843
1844 irlap_apply_default_connection_parameters( self);
1845
1846 /* Always switch state before calling upper layers */
1847 irlap_next_state( self, LAP_NDM);
1848
1849 irlap_disconnect_indication( self, LAP_DISC_INDICATION);
1850
1851 #if 0
1852 irlap_wait_min_turn_around( self, &self->qos_session);
1853 irlap_send_rr_frame( RSP_FRAME);
1854 irda_start_timer( WD_TIMER, self->wd_timeout);
1855 irlap_next_state( self, LAP_NRM_S);
1856 #endif
1857 break;
1858 case RECV_TEST_CMD:
1859 skb_pull(skb, sizeof(struct test_frame));
1860 irlap_send_test_frame(self, info->daddr, skb);
1861 dev_kfree_skb(skb);
1862 break;
1863 default:
1864 DEBUG(1, __FUNCTION__ "(), Unknown event %d, (%s)\n",
1865 event, irlap_event[event]);
1866 ret = -1;
1867 break;
1868 }
1869 return ret;
1870 }
1871
1872 /*
1873 * Function irlap_state_sclose (self, event, skb, info)
1874 *
1875 *
1876 *
1877 */
1878 static int irlap_state_sclose( struct irlap_cb *self, IRLAP_EVENT event,
1879 struct sk_buff *skb, struct irlap_info *info)
1880 {
1881 DEBUG( 0, __FUNCTION__ "(), Not implemented!\n");
1882
1883 return -1;
1884 }
1885
1886 static int irlap_state_reset_check( struct irlap_cb *self, IRLAP_EVENT event,
1887 struct sk_buff *skb,
1888 struct irlap_info *info)
1889 {
1890 int ret = 0;
1891
1892 DEBUG(1, __FUNCTION__ "(), event=%s\n", irlap_event[ event]);
1893
1894 ASSERT( self != NULL, return -ENODEV;);
1895 ASSERT( self->magic == LAP_MAGIC, return -EBADR;);
1896
1897 switch( event) {
1898 case RESET_RESPONSE:
1899 irlap_send_ua_response_frame( self, &self->qos_rx);
1900 irlap_initiate_connection_state( self);
1901 irlap_start_wd_timer( self, WD_TIMEOUT);
1902 irlap_flush_all_queues( self);
1903
1904 irlap_next_state( self, LAP_NRM_S);
1905 break;
1906 case DISCONNECT_REQUEST:
1907 irlap_wait_min_turn_around( self, &self->qos_tx);
1908 /* irlap_send_rd_frame(self); */
1909 irlap_start_wd_timer( self, WD_TIMEOUT);
1910 break;
1911 default:
1912 DEBUG(1, __FUNCTION__ "(), Unknown event %d, (%s)\n",
1913 event, irlap_event[event]);
1914 ret = -1;
1915 break;
1916 }
1917
1918 return ret;
1919 }
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux