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