net/irda/irlan/irlan_client_event.c

   1 /*********************************************************************
   2  *
   3  * Filename:      irlan_client_event.c
   4  * Version:       0.9
   5  * Description:   IrLAN client state machine
   6  * Status:        Experimental.
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Sun Aug 31 20:14:37 1997
   9  * Modified at:   Sun Dec 26 21:52:24 1999
  10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11  *
  12  *     Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
  13  *     All Rights Reserved.
  14  *
  15  *     This program is free software; you can redistribute it and/or
  16  *     modify it under the terms of the GNU General Public License as
  17  *     published by the Free Software Foundation; either version 2 of
  18  *     the License, or (at your option) any later version.
  19  *
  20  *     Neither Dag Brattli nor University of Tromsø admit liability nor
  21  *     provide warranty for any of this software. This material is
  22  *     provided "AS-IS" and at no charge.
  23  *
  24  ********************************************************************/
  25
  26 #include <linux/skbuff.h>
  27
  28 #include <net/irda/irda.h>
  29 #include <net/irda/timer.h>
  30 #include <net/irda/irmod.h>
  31 #include <net/irda/iriap.h>
  32 #include <net/irda/irlmp.h>
  33 #include <net/irda/irttp.h>
  34
  35 #include <net/irda/irlan_common.h>
  36 #include <net/irda/irlan_client.h>
  37 #include <net/irda/irlan_event.h>
  38
  39 static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
  40                                     struct sk_buff *skb);
  41 static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
  42                                     struct sk_buff *skb);
  43 static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
  44                                     struct sk_buff *skb);
  45 static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
  46                                     struct sk_buff *skb);
  47 static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
  48                                     struct sk_buff *skb);
  49 static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
  50                                     struct sk_buff *skb);
  51 static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
  52                                     struct sk_buff *skb);
  53 static int irlan_client_state_arb  (struct irlan_cb *self, IRLAN_EVENT event,
  54                                     struct sk_buff *skb);
  55 static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
  56                                     struct sk_buff *skb);
  57 static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
  58                                     struct sk_buff *skb);
  59 static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
  60                                     struct sk_buff *skb);
  61
  62 static int (*state[])(struct irlan_cb *, IRLAN_EVENT event, struct sk_buff *) =
  63 {
  64         irlan_client_state_idle,
  65         irlan_client_state_query,
  66         irlan_client_state_conn,
  67         irlan_client_state_info,
  68         irlan_client_state_media,
  69         irlan_client_state_open,
  70         irlan_client_state_wait,
  71         irlan_client_state_arb,
  72         irlan_client_state_data,
  73         irlan_client_state_close,
  74         irlan_client_state_sync
  75 };
  76
  77 void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
  78                            struct sk_buff *skb)
  79 {
  80         IRDA_ASSERT(self != NULL, return;);
  81         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
  82
  83         (*state[ self->client.state]) (self, event, skb);
  84 }
  85
  86 /*
  87  * Function irlan_client_state_idle (event, skb, info)
  88  *
  89  *    IDLE, We are waiting for an indication that there is a provider
  90  *    available.
  91  */
  92 static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
  93                                    struct sk_buff *skb)
  94 {
  95         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
  96
  97         IRDA_ASSERT(self != NULL, return -1;);
  98         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
  99
 100         switch (event) {
 101         case IRLAN_DISCOVERY_INDICATION:
 102                 if (self->client.iriap) {
 103                         IRDA_WARNING("%s(), busy with a previous query\n",
 104                                      __FUNCTION__);
 105                         return -EBUSY;
 106                 }
 107
 108                 self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
 109                                                 irlan_client_get_value_confirm);
 110                 /* Get some values from peer IAS */
 111                 irlan_next_client_state(self, IRLAN_QUERY);
 112                 iriap_getvaluebyclass_request(self->client.iriap,
 113                                               self->saddr, self->daddr,
 114                                               "IrLAN", "IrDA:TinyTP:LsapSel");
 115                 break;
 116         case IRLAN_WATCHDOG_TIMEOUT:
 117                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 118                 break;
 119         default:
 120                 IRDA_DEBUG(4, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 121                 break;
 122         }
 123         if (skb)
 124                 dev_kfree_skb(skb);
 125
 126         return 0;
 127 }
 128
 129 /*
 130  * Function irlan_client_state_query (event, skb, info)
 131  *
 132  *    QUERY, We have queryed the remote IAS and is ready to connect
 133  *    to provider, just waiting for the confirm.
 134  *
 135  */
 136 static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
 137                                     struct sk_buff *skb)
 138 {
 139         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 140
 141         IRDA_ASSERT(self != NULL, return -1;);
 142         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
 143
 144         switch(event) {
 145         case IRLAN_IAS_PROVIDER_AVAIL:
 146                 IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;);
 147
 148                 self->client.open_retries = 0;
 149
 150                 irttp_connect_request(self->client.tsap_ctrl,
 151                                       self->dtsap_sel_ctrl,
 152                                       self->saddr, self->daddr, NULL,
 153                                       IRLAN_MTU, NULL);
 154                 irlan_next_client_state(self, IRLAN_CONN);
 155                 break;
 156         case IRLAN_IAS_PROVIDER_NOT_AVAIL:
 157                 IRDA_DEBUG(2, "%s(), IAS_PROVIDER_NOT_AVAIL\n", __FUNCTION__ );
 158                 irlan_next_client_state(self, IRLAN_IDLE);
 159
 160                 /* Give the client a kick! */
 161                 if ((self->provider.access_type == ACCESS_PEER) &&
 162                     (self->provider.state != IRLAN_IDLE))
 163                         irlan_client_wakeup(self, self->saddr, self->daddr);
 164                 break;
 165         case IRLAN_LMP_DISCONNECT:
 166         case IRLAN_LAP_DISCONNECT:
 167                 irlan_next_client_state(self, IRLAN_IDLE);
 168                 break;
 169         case IRLAN_WATCHDOG_TIMEOUT:
 170                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 171                 break;
 172         default:
 173                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 174                 break;
 175         }
 176         if (skb)
 177                 dev_kfree_skb(skb);
 178
 179         return 0;
 180 }
 181
 182 /*
 183  * Function irlan_client_state_conn (event, skb, info)
 184  *
 185  *    CONN, We have connected to a provider but has not issued any
 186  *    commands yet.
 187  *
 188  */
 189 static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
 190                                    struct sk_buff *skb)
 191 {
 192         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 193
 194         IRDA_ASSERT(self != NULL, return -1;);
 195
 196         switch (event) {
 197         case IRLAN_CONNECT_COMPLETE:
 198                 /* Send getinfo cmd */
 199                 irlan_get_provider_info(self);
 200                 irlan_next_client_state(self, IRLAN_INFO);
 201                 break;
 202         case IRLAN_LMP_DISCONNECT:
 203         case IRLAN_LAP_DISCONNECT:
 204                 irlan_next_client_state(self, IRLAN_IDLE);
 205                 break;
 206         case IRLAN_WATCHDOG_TIMEOUT:
 207                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 208                 break;
 209         default:
 210                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 211                 break;
 212         }
 213         if (skb)
 214                 dev_kfree_skb(skb);
 215
 216         return 0;
 217 }
 218
 219 /*
 220  * Function irlan_client_state_info (self, event, skb, info)
 221  *
 222  *    INFO, We have issued a GetInfo command and is awaiting a reply.
 223  */
 224 static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
 225                                    struct sk_buff *skb)
 226 {
 227         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 228
 229         IRDA_ASSERT(self != NULL, return -1;);
 230
 231         switch (event) {
 232         case IRLAN_DATA_INDICATION:
 233                 IRDA_ASSERT(skb != NULL, return -1;);
 234
 235                 irlan_client_parse_response(self, skb);
 236
 237                 irlan_next_client_state(self, IRLAN_MEDIA);
 238
 239                 irlan_get_media_char(self);
 240                 break;
 241
 242         case IRLAN_LMP_DISCONNECT:
 243         case IRLAN_LAP_DISCONNECT:
 244                 irlan_next_client_state(self, IRLAN_IDLE);
 245                 break;
 246         case IRLAN_WATCHDOG_TIMEOUT:
 247                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 248                 break;
 249         default:
 250                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 251                 break;
 252         }
 253         if (skb)
 254                 dev_kfree_skb(skb);
 255
 256         return 0;
 257 }
 258
 259 /*
 260  * Function irlan_client_state_media (self, event, skb, info)
 261  *
 262  *    MEDIA, The irlan_client has issued a GetMedia command and is awaiting a
 263  *    reply.
 264  *
 265  */
 266 static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
 267                                     struct sk_buff *skb)
 268 {
 269         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 270
 271         IRDA_ASSERT(self != NULL, return -1;);
 272
 273         switch(event) {
 274         case IRLAN_DATA_INDICATION:
 275                 irlan_client_parse_response(self, skb);
 276                 irlan_open_data_channel(self);
 277                 irlan_next_client_state(self, IRLAN_OPEN);
 278                 break;
 279         case IRLAN_LMP_DISCONNECT:
 280         case IRLAN_LAP_DISCONNECT:
 281                 irlan_next_client_state(self, IRLAN_IDLE);
 282                 break;
 283         case IRLAN_WATCHDOG_TIMEOUT:
 284                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 285                 break;
 286         default:
 287                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 288                 break;
 289         }
 290         if (skb)
 291                 dev_kfree_skb(skb);
 292
 293         return 0;
 294 }
 295
 296 /*
 297  * Function irlan_client_state_open (self, event, skb, info)
 298  *
 299  *    OPEN, The irlan_client has issued a OpenData command and is awaiting a
 300  *    reply
 301  *
 302  */
 303 static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
 304                                    struct sk_buff *skb)
 305 {
 306         struct qos_info qos;
 307
 308         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 309
 310         IRDA_ASSERT(self != NULL, return -1;);
 311
 312         switch(event) {
 313         case IRLAN_DATA_INDICATION:
 314                 irlan_client_parse_response(self, skb);
 315
 316                 /*
 317                  *  Check if we have got the remote TSAP for data
 318                  *  communications
 319                  */
 320                 IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);
 321
 322                 /* Check which access type we are dealing with */
 323                 switch (self->client.access_type) {
 324                 case ACCESS_PEER:
 325                     if (self->provider.state == IRLAN_OPEN) {
 326
 327                             irlan_next_client_state(self, IRLAN_ARB);
 328                             irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
 329                                                   NULL);
 330                     } else {
 331
 332                             irlan_next_client_state(self, IRLAN_WAIT);
 333                     }
 334                     break;
 335                 case ACCESS_DIRECT:
 336                 case ACCESS_HOSTED:
 337                         qos.link_disc_time.bits = 0x01; /* 3 secs */
 338
 339                         irttp_connect_request(self->tsap_data,
 340                                               self->dtsap_sel_data,
 341                                               self->saddr, self->daddr, &qos,
 342                                               IRLAN_MTU, NULL);
 343
 344                         irlan_next_client_state(self, IRLAN_DATA);
 345                         break;
 346                 default:
 347                         IRDA_DEBUG(2, "%s(), unknown access type!\n", __FUNCTION__ );
 348                         break;
 349                 }
 350                 break;
 351         case IRLAN_LMP_DISCONNECT:
 352         case IRLAN_LAP_DISCONNECT:
 353                 irlan_next_client_state(self, IRLAN_IDLE);
 354                 break;
 355         case IRLAN_WATCHDOG_TIMEOUT:
 356                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 357                 break;
 358         default:
 359                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 360                 break;
 361         }
 362
 363         if (skb)
 364                 dev_kfree_skb(skb);
 365
 366         return 0;
 367 }
 368
 369 /*
 370  * Function irlan_client_state_wait (self, event, skb, info)
 371  *
 372  *    WAIT, The irlan_client is waiting for the local provider to enter the
 373  *    provider OPEN state.
 374  *
 375  */
 376 static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
 377                                    struct sk_buff *skb)
 378 {
 379         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 380
 381         IRDA_ASSERT(self != NULL, return -1;);
 382
 383         switch(event) {
 384         case IRLAN_PROVIDER_SIGNAL:
 385                 irlan_next_client_state(self, IRLAN_ARB);
 386                 irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, NULL);
 387                 break;
 388         case IRLAN_LMP_DISCONNECT:
 389         case IRLAN_LAP_DISCONNECT:
 390                 irlan_next_client_state(self, IRLAN_IDLE);
 391                 break;
 392         case IRLAN_WATCHDOG_TIMEOUT:
 393                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 394                 break;
 395         default:
 396                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 397                 break;
 398         }
 399         if (skb)
 400                 dev_kfree_skb(skb);
 401
 402         return 0;
 403 }
 404
 405 static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
 406                                   struct sk_buff *skb)
 407 {
 408         struct qos_info qos;
 409
 410         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 411
 412         IRDA_ASSERT(self != NULL, return -1;);
 413
 414         switch(event) {
 415         case IRLAN_CHECK_CON_ARB:
 416                 if (self->client.recv_arb_val == self->provider.send_arb_val) {
 417                         irlan_next_client_state(self, IRLAN_CLOSE);
 418                         irlan_close_data_channel(self);
 419                 } else if (self->client.recv_arb_val <
 420                            self->provider.send_arb_val)
 421                 {
 422                         qos.link_disc_time.bits = 0x01; /* 3 secs */
 423
 424                         irlan_next_client_state(self, IRLAN_DATA);
 425                         irttp_connect_request(self->tsap_data,
 426                                               self->dtsap_sel_data,
 427                                               self->saddr, self->daddr, &qos,
 428                                               IRLAN_MTU, NULL);
 429                 } else if (self->client.recv_arb_val >
 430                            self->provider.send_arb_val)
 431                 {
 432                         IRDA_DEBUG(2, "%s(), lost the battle :-(\n", __FUNCTION__ );
 433                 }
 434                 break;
 435         case IRLAN_DATA_CONNECT_INDICATION:
 436                 irlan_next_client_state(self, IRLAN_DATA);
 437                 break;
 438         case IRLAN_LMP_DISCONNECT:
 439         case IRLAN_LAP_DISCONNECT:
 440                 irlan_next_client_state(self, IRLAN_IDLE);
 441                 break;
 442         case IRLAN_WATCHDOG_TIMEOUT:
 443                 IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __FUNCTION__ );
 444                 break;
 445         default:
 446                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 447                 break;
 448         }
 449         if (skb)
 450                 dev_kfree_skb(skb);
 451
 452         return 0;
 453 }
 454
 455 /*
 456  * Function irlan_client_state_data (self, event, skb, info)
 457  *
 458  *    DATA, The data channel is connected, allowing data transfers between
 459  *    the local and remote machines.
 460  *
 461  */
 462 static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
 463                                    struct sk_buff *skb)
 464 {
 465         IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
 466
 467         IRDA_ASSERT(self != NULL, return -1;);
 468         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
 469
 470         switch(event) {
 471         case IRLAN_DATA_INDICATION:
 472                 irlan_client_parse_response(self, skb);
 473                 break;
 474         case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
 475         case IRLAN_LAP_DISCONNECT:
 476                 irlan_next_client_state(self, IRLAN_IDLE);
 477                 break;
 478         default:
 479                 IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
 480                 break;
 481         }
 482         if (skb)
 483                 dev_kfree_skb(skb);
 484
 485         return 0;
 486 }
 487
 488 /*
 489  * Function irlan_client_state_close (self, event, skb, info)
 490  *
 491  *
 492  *
 493  */
 494 static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
 495                                     struct sk_buff *skb)
 496 {
 497         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 498
 499         if (skb)
 500                 dev_kfree_skb(skb);
 501
 502         return 0;
 503 }
 504
 505 /*
 506  * Function irlan_client_state_sync (self, event, skb, info)
 507  *
 508  *
 509  *
 510  */
 511 static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
 512                                    struct sk_buff *skb)
 513 {
 514         IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
 515
 516         if (skb)
 517                 dev_kfree_skb(skb);
 518
 519         return 0;
 520 }
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533