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