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, "%s(), unknown event: %s\n", __FUNCTION__ ,
 111                            ircomm_event[event]);
 112                 ret = -EINVAL;
 113         }
 114         return ret;
 115 }
 116
 117 /*
 118  * Function ircomm_state_waiti (self, event, skb)
 119  *
 120  *    The IrCOMM user has requested an IrCOMM connection to the remote
 121  *    device and is awaiting confirmation
 122  */
 123 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
 124                               struct sk_buff *skb, struct ircomm_info *info)
 125 {
 126         int ret = 0;
 127
 128         switch (event) {
 129         case IRCOMM_TTP_CONNECT_CONFIRM:
 130         case IRCOMM_LMP_CONNECT_CONFIRM:
 131                 ircomm_next_state(self, IRCOMM_CONN);
 132                 ircomm_connect_confirm(self, skb, info);
 133                 break;
 134         case IRCOMM_TTP_DISCONNECT_INDICATION:
 135         case IRCOMM_LMP_DISCONNECT_INDICATION:
 136                 ircomm_next_state(self, IRCOMM_IDLE);
 137                 ircomm_disconnect_indication(self, skb, info);
 138                 break;
 139         default:
 140                 IRDA_DEBUG(0, "%s(), unknown event: %s\n", __FUNCTION__ ,
 141                            ircomm_event[event]);
 142                 ret = -EINVAL;
 143         }
 144         return ret;
 145 }
 146
 147 /*
 148  * Function ircomm_state_waitr (self, event, skb)
 149  *
 150  *    IrCOMM has received an incoming connection request and is awaiting
 151  *    response from the user
 152  */
 153 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
 154                               struct sk_buff *skb, struct ircomm_info *info)
 155 {
 156         int ret = 0;
 157
 158         switch (event) {
 159         case IRCOMM_CONNECT_RESPONSE:
 160                 ircomm_next_state(self, IRCOMM_CONN);
 161                 ret = self->issue.connect_response(self, skb);
 162                 break;
 163         case IRCOMM_DISCONNECT_REQUEST:
 164                 ircomm_next_state(self, IRCOMM_IDLE);
 165                 ret = self->issue.disconnect_request(self, skb, info);
 166                 break;
 167         case IRCOMM_TTP_DISCONNECT_INDICATION:
 168         case IRCOMM_LMP_DISCONNECT_INDICATION:
 169                 ircomm_next_state(self, IRCOMM_IDLE);
 170                 ircomm_disconnect_indication(self, skb, info);
 171                 break;
 172         default:
 173                 IRDA_DEBUG(0, "%s(), unknown event = %s\n", __FUNCTION__ ,
 174                            ircomm_event[event]);
 175                 ret = -EINVAL;
 176         }
 177         return ret;
 178 }
 179
 180 /*
 181  * Function ircomm_state_conn (self, event, skb)
 182  *
 183  *    IrCOMM is connected to the peer IrCOMM device
 184  *
 185  */
 186 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
 187                              struct sk_buff *skb, struct ircomm_info *info)
 188 {
 189         int ret = 0;
 190
 191         switch (event) {
 192         case IRCOMM_DATA_REQUEST:
 193                 ret = self->issue.data_request(self, skb, 0);
 194                 break;
 195         case IRCOMM_TTP_DATA_INDICATION:
 196                 ircomm_process_data(self, skb);
 197                 break;
 198         case IRCOMM_LMP_DATA_INDICATION:
 199                 ircomm_data_indication(self, skb);
 200                 break;
 201         case IRCOMM_CONTROL_REQUEST:
 202                 /* Just send a separate frame for now */
 203                 ret = self->issue.data_request(self, skb, skb->len);
 204                 break;
 205         case IRCOMM_TTP_DISCONNECT_INDICATION:
 206         case IRCOMM_LMP_DISCONNECT_INDICATION:
 207                 ircomm_next_state(self, IRCOMM_IDLE);
 208                 ircomm_disconnect_indication(self, skb, info);
 209                 break;
 210         case IRCOMM_DISCONNECT_REQUEST:
 211                 ircomm_next_state(self, IRCOMM_IDLE);
 212                 ret = self->issue.disconnect_request(self, skb, info);
 213                 break;
 214         default:
 215                 IRDA_DEBUG(0, "%s(), unknown event = %s\n", __FUNCTION__ ,
 216                            ircomm_event[event]);
 217                 ret = -EINVAL;
 218         }
 219         return ret;
 220 }
 221
 222 /*
 223  * Function ircomm_do_event (self, event, skb)
 224  *
 225  *    Process event
 226  *
 227  */
 228 int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event,
 229                     struct sk_buff *skb, struct ircomm_info *info)
 230 {
 231         IRDA_DEBUG(4, "%s: state=%s, event=%s\n", __FUNCTION__ ,
 232                    ircomm_state[self->state], ircomm_event[event]);
 233
 234         return (*state[self->state])(self, event, skb, info);
 235 }
 236
 237 /*
 238  * Function ircomm_next_state (self, state)
 239  *
 240  *    Switch state
 241  *
 242  */
 243 void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state)
 244 {
 245         self->state = state;
 246
 247         IRDA_DEBUG(4, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
 248                    ircomm_state[self->state], self->service_type);
 249 }