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 static 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
76 static 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 */
ircomm_state_idle(struct ircomm_cb * self,IRCOMM_EVENT event,struct sk_buff * skb,struct ircomm_info * info)91 static 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 */
ircomm_state_waiti(struct ircomm_cb * self,IRCOMM_EVENT event,struct sk_buff * skb,struct ircomm_info * info)120 static 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 */
ircomm_state_waitr(struct ircomm_cb * self,IRCOMM_EVENT event,struct sk_buff * skb,struct ircomm_info * info)150 static 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 */
ircomm_state_conn(struct ircomm_cb * self,IRCOMM_EVENT event,struct sk_buff * skb,struct ircomm_info * info)183 static 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 */
ircomm_do_event(struct ircomm_cb * self,IRCOMM_EVENT event,struct sk_buff * skb,struct ircomm_info * info)225 int 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 */
ircomm_next_state(struct ircomm_cb * self,IRCOMM_STATE state)240 void 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