net/irda/ircomm/ircomm_event.c

   1 /*********************************************************************
   2  *
   3  * Filename:      ircomm_event.c
   4  * Version:       1.0
   5  * Description:   IrCOMM layer state machine
   6  * Status:        Stable
   7  * Author:        Dag Brattli <dagb@cs.uit.no>
   8  * Created at:    Sun Jun  6 20:33:11 1999
   9  * Modified at:   Sun Dec 12 13:44:32 1999
  10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  11  *
  12  *     Copyright (c) 1999 Dag Brattli, All Rights Reserved.
  13  *
  14  *     This program is free software; you can redistribute it and/or
  15  *     modify it under the terms of the GNU General Public License as
  16  *     published by the Free Software Foundation; either version 2 of
  17  *     the License, or (at your option) any later version.
  18  *
  19  *     This program is distributed in the hope that it will be useful,
  20  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  22  *     GNU General Public License for more details.
  23  *
  24  *     You should have received a copy of the GNU General Public License
  25  *     along with this program; if not, write to the Free Software
  26  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  27  *     MA 02111-1307 USA
  28  *
  29  ********************************************************************/
  30
  31 #include <linux/sched.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/init.h>
  34
  35 #include <net/irda/irda.h>
  36 #include <net/irda/irlmp.h>
  37 #include <net/irda/iriap.h>
  38 #include <net/irda/irttp.h>
  39 #include <net/irda/irias_object.h>
  40
  41 #include <net/irda/ircomm_core.h>
  42 #include <net/irda/ircomm_event.h>
  43
  44 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
  45                              struct sk_buff *skb, struct ircomm_info *info);
  46 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
  47                               struct sk_buff *skb, struct ircomm_info *info);
  48 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
  49                               struct sk_buff *skb, struct ircomm_info *info);
  50 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
  51                              struct sk_buff *skb, struct ircomm_info *info);
  52
  53 char *ircomm_state[] = {
  54         "IRCOMM_IDLE",
  55         "IRCOMM_WAITI",
  56         "IRCOMM_WAITR",
  57         "IRCOMM_CONN",
  58 };
  59
  60 char *ircomm_event[] = {
  61         "IRCOMM_CONNECT_REQUEST",
  62         "IRCOMM_CONNECT_RESPONSE",
  63         "IRCOMM_TTP_CONNECT_INDICATION",
  64         "IRCOMM_LMP_CONNECT_INDICATION",
  65         "IRCOMM_TTP_CONNECT_CONFIRM",
  66         "IRCOMM_LMP_CONNECT_CONFIRM",
  67
  68         "IRCOMM_LMP_DISCONNECT_INDICATION",
  69         "IRCOMM_TTP_DISCONNECT_INDICATION",
  70         "IRCOMM_DISCONNECT_REQUEST",
  71
  72         "IRCOMM_TTP_DATA_INDICATION",
  73         "IRCOMM_LMP_DATA_INDICATION",
  74         "IRCOMM_DATA_REQUEST",
  75         "IRCOMM_CONTROL_REQUEST",
  76         "IRCOMM_CONTROL_INDICATION",
  77 };
  78
  79 static int (*state[])(struct ircomm_cb *self, IRCOMM_EVENT event,
  80                       struct sk_buff *skb, struct ircomm_info *info) =
  81 {
  82         ircomm_state_idle,
  83         ircomm_state_waiti,
  84         ircomm_state_waitr,
  85         ircomm_state_conn,
  86 };
  87
  88 /*
  89  * Function ircomm_state_idle (self, event, skb)
  90  *
  91  *    IrCOMM is currently idle
  92  *
  93  */
  94 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
  95                              struct sk_buff *skb, struct ircomm_info *info)
  96 {
  97         int ret = 0;
  98
  99         switch (event) {
 100         case IRCOMM_CONNECT_REQUEST:
 101                 ircomm_next_state(self, IRCOMM_WAITI);
 102                 ret = self->issue.connect_request(self, skb, info);
 103                 break;
 104         case IRCOMM_TTP_CONNECT_INDICATION:
 105         case IRCOMM_LMP_CONNECT_INDICATION:
 106                 ircomm_next_state(self, IRCOMM_WAITR);
 107                 ircomm_connect_indication(self, skb, info);
 108                 break;
 109         default:
 110                 IRDA_DEBUG(4, __FUNCTION__"(), unknown event: %s\n",
 111                            ircomm_event[event]);
 112                 if (skb)
 113                         dev_kfree_skb(skb);
 114                 return -EINVAL;
 115         }
 116         return ret;
 117 }
 118
 119 /*
 120  * Function ircomm_state_waiti (self, event, skb)
 121  *
 122  *    The IrCOMM user has requested an IrCOMM connection to the remote
 123  *    device and is awaiting confirmation
 124  */
 125 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
 126                               struct sk_buff *skb, struct ircomm_info *info)
 127 {
 128         int ret = 0;
 129
 130         switch (event) {
 131         case IRCOMM_TTP_CONNECT_CONFIRM:
 132         case IRCOMM_LMP_CONNECT_CONFIRM:
 133                 ircomm_next_state(self, IRCOMM_CONN);
 134                 ircomm_connect_confirm(self, skb, info);
 135                 break;
 136         case IRCOMM_TTP_DISCONNECT_INDICATION:
 137         case IRCOMM_LMP_DISCONNECT_INDICATION:
 138                 ircomm_next_state(self, IRCOMM_IDLE);
 139                 ircomm_disconnect_indication(self, skb, info);
 140                 break;
 141         default:
 142                 IRDA_DEBUG(0, __FUNCTION__"(), unknown event: %s\n",
 143                            ircomm_event[event]);
 144                 if (skb)
 145                         dev_kfree_skb(skb);
 146                 ret = -EINVAL;
 147         }
 148         return ret;
 149 }
 150
 151 /*
 152  * Function ircomm_state_waitr (self, event, skb)
 153  *
 154  *    IrCOMM has received an incomming connection request and is awaiting
 155  *    response from the user
 156  */
 157 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
 158                               struct sk_buff *skb, struct ircomm_info *info)
 159 {
 160         int ret = 0;
 161
 162         switch (event) {
 163         case IRCOMM_CONNECT_RESPONSE:
 164                 ircomm_next_state(self, IRCOMM_CONN);
 165                 ret = self->issue.connect_response(self, skb);
 166                 break;
 167         case IRCOMM_DISCONNECT_REQUEST:
 168                 ircomm_next_state(self, IRCOMM_IDLE);
 169                 ret = self->issue.disconnect_request(self, skb, info);
 170                 break;
 171         case IRCOMM_TTP_DISCONNECT_INDICATION:
 172         case IRCOMM_LMP_DISCONNECT_INDICATION:
 173                 ircomm_next_state(self, IRCOMM_IDLE);
 174                 ircomm_disconnect_indication(self, skb, info);
 175                 break;
 176         default:
 177                 IRDA_DEBUG(0, __FUNCTION__ "(), unknown event = %s\n",
 178                            ircomm_event[event]);
 179                 if (skb)
 180                         dev_kfree_skb(skb);
 181                 ret = -EINVAL;
 182         }
 183         return ret;
 184 }
 185
 186 /*
 187  * Function ircomm_state_conn (self, event, skb)
 188  *
 189  *    IrCOMM is connected to the peer IrCOMM device
 190  *
 191  */
 192 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
 193                              struct sk_buff *skb, struct ircomm_info *info)
 194 {
 195         int ret = 0;
 196
 197         switch (event) {
 198         case IRCOMM_DATA_REQUEST:
 199                 ret = self->issue.data_request(self, skb, 0);
 200                 break;
 201         case IRCOMM_TTP_DATA_INDICATION:
 202                 ircomm_process_data(self, skb);
 203                 break;
 204         case IRCOMM_LMP_DATA_INDICATION:
 205                 ircomm_data_indication(self, skb);
 206                 break;
 207         case IRCOMM_CONTROL_REQUEST:
 208                 /* Just send a separate frame for now */
 209                 ret = self->issue.data_request(self, skb, skb->len);
 210                 break;
 211         case IRCOMM_TTP_DISCONNECT_INDICATION:
 212         case IRCOMM_LMP_DISCONNECT_INDICATION:
 213                 ircomm_next_state(self, IRCOMM_IDLE);
 214                 ircomm_disconnect_indication(self, skb, info);
 215                 break;
 216         case IRCOMM_DISCONNECT_REQUEST:
 217                 ircomm_next_state(self, IRCOMM_IDLE);
 218                 ret = self->issue.disconnect_request(self, skb, info);
 219                 break;
 220         default:
 221                 IRDA_DEBUG(0, __FUNCTION__ "(), unknown event = %s\n",
 222                            ircomm_event[event]);
 223                 if (skb)
 224                         dev_kfree_skb(skb);
 225                 ret = -EINVAL;
 226         }
 227         return ret;
 228 }
 229
 230 /*
 231  * Function ircomm_do_event (self, event, skb)
 232  *
 233  *    Process event
 234  *
 235  */
 236 int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event,
 237                     struct sk_buff *skb, struct ircomm_info *info)
 238 {
 239         IRDA_DEBUG(4, __FUNCTION__": state=%s, event=%s\n",
 240                    ircomm_state[self->state], ircomm_event[event]);
 241
 242         return (*state[self->state])(self, event, skb, info);
 243 }
 244
 245 /*
 246  * Function ircomm_next_state (self, state)
 247  *
 248  *    Switch state
 249  *
 250  */
 251 void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state)
 252 {
 253         self->state = state;
 254
 255         IRDA_DEBUG(4, __FUNCTION__": next state=%s, service type=%d\n",
 256                    ircomm_state[self->state], self->service_type);
 257 }