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, see <http://www.gnu.org/licenses/>.
  26  *
  27  ********************************************************************/
  28
  29 #include <linux/proc_fs.h>
  30 #include <linux/init.h>
  31
  32 #include <net/irda/irda.h>
  33 #include <net/irda/irlmp.h>
  34 #include <net/irda/iriap.h>
  35 #include <net/irda/irttp.h>
  36 #include <net/irda/irias_object.h>
  37
  38 #include <net/irda/ircomm_core.h>
  39 #include <net/irda/ircomm_event.h>
  40
  41 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
  42                              struct sk_buff *skb, struct ircomm_info *info);
  43 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
  44                               struct sk_buff *skb, struct ircomm_info *info);
  45 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
  46                               struct sk_buff *skb, struct ircomm_info *info);
  47 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
  48                              struct sk_buff *skb, struct ircomm_info *info);
  49
  50 const char *const ircomm_state[] = {
  51         "IRCOMM_IDLE",
  52         "IRCOMM_WAITI",
  53         "IRCOMM_WAITR",
  54         "IRCOMM_CONN",
  55 };
  56
  57 #ifdef CONFIG_IRDA_DEBUG
  58 static const char *const ircomm_event[] = {
  59         "IRCOMM_CONNECT_REQUEST",
  60         "IRCOMM_CONNECT_RESPONSE",
  61         "IRCOMM_TTP_CONNECT_INDICATION",
  62         "IRCOMM_LMP_CONNECT_INDICATION",
  63         "IRCOMM_TTP_CONNECT_CONFIRM",
  64         "IRCOMM_LMP_CONNECT_CONFIRM",
  65
  66         "IRCOMM_LMP_DISCONNECT_INDICATION",
  67         "IRCOMM_TTP_DISCONNECT_INDICATION",
  68         "IRCOMM_DISCONNECT_REQUEST",
  69
  70         "IRCOMM_TTP_DATA_INDICATION",
  71         "IRCOMM_LMP_DATA_INDICATION",
  72         "IRCOMM_DATA_REQUEST",
  73         "IRCOMM_CONTROL_REQUEST",
  74         "IRCOMM_CONTROL_INDICATION",
  75 };
  76 #endif /* CONFIG_IRDA_DEBUG */
  77
  78 static int (*state[])(struct ircomm_cb *self, IRCOMM_EVENT event,
  79                       struct sk_buff *skb, struct ircomm_info *info) =
  80 {
  81         ircomm_state_idle,
  82         ircomm_state_waiti,
  83         ircomm_state_waitr,
  84         ircomm_state_conn,
  85 };
  86
  87 /*
  88  * Function ircomm_state_idle (self, event, skb)
  89  *
  90  *    IrCOMM is currently idle
  91  *
  92  */
  93 static int ircomm_state_idle(struct ircomm_cb *self, IRCOMM_EVENT event,
  94                              struct sk_buff *skb, struct ircomm_info *info)
  95 {
  96         int ret = 0;
  97
  98         switch (event) {
  99         case IRCOMM_CONNECT_REQUEST:
 100                 ircomm_next_state(self, IRCOMM_WAITI);
 101                 ret = self->issue.connect_request(self, skb, info);
 102                 break;
 103         case IRCOMM_TTP_CONNECT_INDICATION:
 104         case IRCOMM_LMP_CONNECT_INDICATION:
 105                 ircomm_next_state(self, IRCOMM_WAITR);
 106                 ircomm_connect_indication(self, skb, info);
 107                 break;
 108         default:
 109                 IRDA_DEBUG(4, "%s(), unknown event: %s\n", __func__ ,
 110                            ircomm_event[event]);
 111                 ret = -EINVAL;
 112         }
 113         return ret;
 114 }
 115
 116 /*
 117  * Function ircomm_state_waiti (self, event, skb)
 118  *
 119  *    The IrCOMM user has requested an IrCOMM connection to the remote
 120  *    device and is awaiting confirmation
 121  */
 122 static int ircomm_state_waiti(struct ircomm_cb *self, IRCOMM_EVENT event,
 123                               struct sk_buff *skb, struct ircomm_info *info)
 124 {
 125         int ret = 0;
 126
 127         switch (event) {
 128         case IRCOMM_TTP_CONNECT_CONFIRM:
 129         case IRCOMM_LMP_CONNECT_CONFIRM:
 130                 ircomm_next_state(self, IRCOMM_CONN);
 131                 ircomm_connect_confirm(self, skb, info);
 132                 break;
 133         case IRCOMM_TTP_DISCONNECT_INDICATION:
 134         case IRCOMM_LMP_DISCONNECT_INDICATION:
 135                 ircomm_next_state(self, IRCOMM_IDLE);
 136                 ircomm_disconnect_indication(self, skb, info);
 137                 break;
 138         default:
 139                 IRDA_DEBUG(0, "%s(), unknown event: %s\n", __func__ ,
 140                            ircomm_event[event]);
 141                 ret = -EINVAL;
 142         }
 143         return ret;
 144 }
 145
 146 /*
 147  * Function ircomm_state_waitr (self, event, skb)
 148  *
 149  *    IrCOMM has received an incoming connection request and is awaiting
 150  *    response from the user
 151  */
 152 static int ircomm_state_waitr(struct ircomm_cb *self, IRCOMM_EVENT event,
 153                               struct sk_buff *skb, struct ircomm_info *info)
 154 {
 155         int ret = 0;
 156
 157         switch (event) {
 158         case IRCOMM_CONNECT_RESPONSE:
 159                 ircomm_next_state(self, IRCOMM_CONN);
 160                 ret = self->issue.connect_response(self, skb);
 161                 break;
 162         case IRCOMM_DISCONNECT_REQUEST:
 163                 ircomm_next_state(self, IRCOMM_IDLE);
 164                 ret = self->issue.disconnect_request(self, skb, info);
 165                 break;
 166         case IRCOMM_TTP_DISCONNECT_INDICATION:
 167         case IRCOMM_LMP_DISCONNECT_INDICATION:
 168                 ircomm_next_state(self, IRCOMM_IDLE);
 169                 ircomm_disconnect_indication(self, skb, info);
 170                 break;
 171         default:
 172                 IRDA_DEBUG(0, "%s(), unknown event = %s\n", __func__ ,
 173                            ircomm_event[event]);
 174                 ret = -EINVAL;
 175         }
 176         return ret;
 177 }
 178
 179 /*
 180  * Function ircomm_state_conn (self, event, skb)
 181  *
 182  *    IrCOMM is connected to the peer IrCOMM device
 183  *
 184  */
 185 static int ircomm_state_conn(struct ircomm_cb *self, IRCOMM_EVENT event,
 186                              struct sk_buff *skb, struct ircomm_info *info)
 187 {
 188         int ret = 0;
 189
 190         switch (event) {
 191         case IRCOMM_DATA_REQUEST:
 192                 ret = self->issue.data_request(self, skb, 0);
 193                 break;
 194         case IRCOMM_TTP_DATA_INDICATION:
 195                 ircomm_process_data(self, skb);
 196                 break;
 197         case IRCOMM_LMP_DATA_INDICATION:
 198                 ircomm_data_indication(self, skb);
 199                 break;
 200         case IRCOMM_CONTROL_REQUEST:
 201                 /* Just send a separate frame for now */
 202                 ret = self->issue.data_request(self, skb, skb->len);
 203                 break;
 204         case IRCOMM_TTP_DISCONNECT_INDICATION:
 205         case IRCOMM_LMP_DISCONNECT_INDICATION:
 206                 ircomm_next_state(self, IRCOMM_IDLE);
 207                 ircomm_disconnect_indication(self, skb, info);
 208                 break;
 209         case IRCOMM_DISCONNECT_REQUEST:
 210                 ircomm_next_state(self, IRCOMM_IDLE);
 211                 ret = self->issue.disconnect_request(self, skb, info);
 212                 break;
 213         default:
 214                 IRDA_DEBUG(0, "%s(), unknown event = %s\n", __func__ ,
 215                            ircomm_event[event]);
 216                 ret = -EINVAL;
 217         }
 218         return ret;
 219 }
 220
 221 /*
 222  * Function ircomm_do_event (self, event, skb)
 223  *
 224  *    Process event
 225  *
 226  */
 227 int ircomm_do_event(struct ircomm_cb *self, IRCOMM_EVENT event,
 228                     struct sk_buff *skb, struct ircomm_info *info)
 229 {
 230         IRDA_DEBUG(4, "%s: state=%s, event=%s\n", __func__ ,
 231                    ircomm_state[self->state], ircomm_event[event]);
 232
 233         return (*state[self->state])(self, event, skb, info);
 234 }
 235
 236 /*
 237  * Function ircomm_next_state (self, state)
 238  *
 239  *    Switch state
 240  *
 241  */
 242 void ircomm_next_state(struct ircomm_cb *self, IRCOMM_STATE state)
 243 {
 244         self->state = state;
 245
 246         IRDA_DEBUG(4, "%s: next state=%s, service type=%d\n", __func__ ,
 247                    ircomm_state[self->state], self->service_type);
 248 }