]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | } |