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