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 #ifdef CONFIG_IRDA_DEBUG
  61 static char *ircomm_event[] = {
  62         "IRCOMM_CONNECT_REQUEST",
  63         "IRCOMM_CONNECT_RESPONSE",
  64         "IRCOMM_TTP_CONNECT_INDICATION",
  65         "IRCOMM_LMP_CONNECT_INDICATION",
  66         "IRCOMM_TTP_CONNECT_CONFIRM",
  67         "IRCOMM_LMP_CONNECT_CONFIRM",
  68
  69         "IRCOMM_LMP_DISCONNECT_INDICATION",
  70         "IRCOMM_TTP_DISCONNECT_INDICATION",
  71         "IRCOMM_DISCONNECT_REQUEST",
  72
  73         "IRCOMM_TTP_DATA_INDICATION",
  74         "IRCOMM_LMP_DATA_INDICATION",
  75         "IRCOMM_DATA_REQUEST",
  76         "IRCOMM_CONTROL_REQUEST",
  77         "IRCOMM_CONTROL_INDICATION",
  78 };
  79 #endif /* CONFIG_IRDA_DEBUG */
  80
  81 static int (*state[])(struct ircomm_cb *self, IRCOMM_EVENT event,
  82                       struct sk_buff *skb, struct ircomm_info *info) =
  83 {
  84         ircomm_state_idle,
  85         ircomm_state_waiti,
  86         ircomm_state_waitr,
  87         ircomm_state_conn,
  88 };
  89
  90 /*
  91  * Function ircomm_state_idle (self, event, skb)
  92  *
  93  *    IrCOMM is currently idle
  94  *
  95  */
  96 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
  97                              struct sk_buff *skb, struct ircomm_info *info)
  98 {
  99         int ret = 0;
 100
 101         switch (event) {
 102         case IRCOMM_CONNECT_REQUEST:
 103                 ircomm_next_state(self, IRCOMM_WAITI);
 104                 ret = self->issue.connect_request(self, skb, info);
 105                 break;
 106         case IRCOMM_TTP_CONNECT_INDICATION:
 107         case IRCOMM_LMP_CONNECT_INDICATION:
 108                 ircomm_next_state(self, IRCOMM_WAITR);
 109                 ircomm_connect_indication(self, skb, info);
 110                 break;
 111         default:
 112                 IRDA_DEBUG(4, "%s(), unknown event: %s\n", __FUNCTION__ ,
 113                            ircomm_event[event]);
 114                 ret = -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, "%s(), unknown event: %s\n", __FUNCTION__ ,
 143                            ircomm_event[event]);
 144                 ret = -EINVAL;
 145         }
 146         return ret;
 147 }
 148
 149 /*
 150  * Function ircomm_state_waitr (self, event, skb)
 151  *
 152  *    IrCOMM has received an incoming connection request and is awaiting
 153  *    response from the user
 154  */
 155 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
 156                               struct sk_buff *skb, struct ircomm_info *info)
 157 {
 158         int ret = 0;
 159
 160         switch (event) {
 161         case IRCOMM_CONNECT_RESPONSE:
 162                 ircomm_next_state(self, IRCOMM_CONN);
 163                 ret = self->issue.connect_response(self, skb);
 164                 break;
 165         case IRCOMM_DISCONNECT_REQUEST:
 166                 ircomm_next_state(self, IRCOMM_IDLE);
 167                 ret = self->issue.disconnect_request(self, skb, info);
 168                 break;
 169         case IRCOMM_TTP_DISCONNECT_INDICATION:
 170         case IRCOMM_LMP_DISCONNECT_INDICATION:
 171                 ircomm_next_state(self, IRCOMM_IDLE);
 172                 ircomm_disconnect_indication(self, skb, info);
 173                 break;
 174         default:
 175                 IRDA_DEBUG(0, "%s(), unknown event = %s\n", __FUNCTION__ ,
 176                            ircomm_event[event]);
 177                 ret = -EINVAL;
 178         }
 179         return ret;
 180 }
 181
 182 /*
 183  * Function ircomm_state_conn (self, event, skb)
 184  *
 185  *    IrCOMM is connected to the peer IrCOMM device
 186  *
 187  */
 188 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
 189                              struct sk_buff *skb, struct ircomm_info *info)
 190 {
 191         int ret = 0;
 192
 193         switch (event) {
 194         case IRCOMM_DATA_REQUEST:
 195                 ret = self->issue.data_request(self, skb, 0);
 196                 break;
 197         case IRCOMM_TTP_DATA_INDICATION:
 198                 ircomm_process_data(self, skb);
 199                 break;
 200         case IRCOMM_LMP_DATA_INDICATION:
 201                 ircomm_data_indication(self, skb);
 202                 break;
 203         case IRCOMM_CONTROL_REQUEST:
 204                 /* Just send a separate frame for now */
 205                 ret = self->issue.data_request(self, skb, skb->len);
 206                 break;
 207         case IRCOMM_TTP_DISCONNECT_INDICATION:
 208         case IRCOMM_LMP_DISCONNECT_INDICATION:
 209                 ircomm_next_state(self, IRCOMM_IDLE);
 210                 ircomm_disconnect_indication(self, skb, info);
 211                 break;
 212         case IRCOMM_DISCONNECT_REQUEST:
 213                 ircomm_next_state(self, IRCOMM_IDLE);
 214                 ret = self->issue.disconnect_request(self, skb, info);
 215                 break;
 216         default:
 217                 IRDA_DEBUG(0, "%s(), unknown event = %s\n", __FUNCTION__ ,
 218                            ircomm_event[event]);
 219                 ret = -EINVAL;
 220         }
 221         return ret;
 222 }
 223
 224 /*
 225  * Function ircomm_do_event (self, event, skb)
 226  *
 227  *    Process event
 228  *
 229  */
 230 int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event,
 231                     struct sk_buff *skb, struct ircomm_info *info)
 232 {
 233         IRDA_DEBUG(4, "%s: state=%s, event=%s\n", __FUNCTION__ ,
 234                    ircomm_state[self->state], ircomm_event[event]);
 235
 236         return (*state[self->state])(self, event, skb, info);
 237 }
 238
 239 /*
 240  * Function ircomm_next_state (self, state)
 241  *
 242  *    Switch state
 243  *
 244  */
 245 void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state)
 246 {
 247         self->state = state;
 248
 249         IRDA_DEBUG(4, "%s: next state=%s, service type=%d\n", __FUNCTION__ ,
 250                    ircomm_state[self->state], self->service_type);
 251 }