?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.1.16
[linux/fpc-iii.git] / net / irda / irlan / irlan_client_event.c
blobcc93fabbbb199ede3758021ef13261958d3cc641
1 /*********************************************************************
2 *
3 * Filename: irlan_client_event.c
4 * Version: 0.9
5 * Description: IrLAN client state machine
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Aug 31 20:14:37 1997
9 * Modified at: Sun Dec 26 21:52:24 1999
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 *
12 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
13 * All Rights Reserved.
14 *
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of
18 * the License, or (at your option) any later version.
19 *
20 * Neither Dag Brattli nor University of Tromsø admit liability nor
21 * provide warranty for any of this software. This material is
22 * provided "AS-IS" and at no charge.
23 *
24 ********************************************************************/
25
26 #include <linux/skbuff.h>
27
28 #include <net/irda/irda.h>
29 #include <net/irda/timer.h>
30 #include <net/irda/irmod.h>
31 #include <net/irda/iriap.h>
32 #include <net/irda/irlmp.h>
33 #include <net/irda/irttp.h>
34
35 #include <net/irda/irlan_common.h>
36 #include <net/irda/irlan_client.h>
37 #include <net/irda/irlan_event.h>
38
39 static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
40 struct sk_buff *skb);
41 static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
42 struct sk_buff *skb);
43 static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
44 struct sk_buff *skb);
45 static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
46 struct sk_buff *skb);
47 static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
48 struct sk_buff *skb);
49 static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
50 struct sk_buff *skb);
51 static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
52 struct sk_buff *skb);
53 static int irlan_client_state_arb (struct irlan_cb *self, IRLAN_EVENT event,
54 struct sk_buff *skb);
55 static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
56 struct sk_buff *skb);
57 static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
58 struct sk_buff *skb);
59 static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
60 struct sk_buff *skb);
61
62 static int (*state[])(struct irlan_cb *, IRLAN_EVENT event, struct sk_buff *) =
63 {
64 irlan_client_state_idle,
65 irlan_client_state_query,
66 irlan_client_state_conn,
67 irlan_client_state_info,
68 irlan_client_state_media,
69 irlan_client_state_open,
70 irlan_client_state_wait,
71 irlan_client_state_arb,
72 irlan_client_state_data,
73 irlan_client_state_close,
74 irlan_client_state_sync
75 };
76
77 void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
78 struct sk_buff *skb)
79 {
80 IRDA_ASSERT(self != NULL, return;);
81 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
82
83 (*state[ self->client.state]) (self, event, skb);
84 }
85
86 /*
87 * Function irlan_client_state_idle (event, skb, info)
88 *
89 * IDLE, We are waiting for an indication that there is a provider
90 * available.
91 */
92 static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
93 struct sk_buff *skb)
94 {
95 IRDA_ASSERT(self != NULL, return -1;);
96 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
97
98 switch (event) {
99 case IRLAN_DISCOVERY_INDICATION:
100 if (self->client.iriap) {
101 net_warn_ratelimited("%s(), busy with a previous query\n",
102 __func__);
103 return -EBUSY;
104 }
105
106 self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
107 irlan_client_get_value_confirm);
108 /* Get some values from peer IAS */
109 irlan_next_client_state(self, IRLAN_QUERY);
110 iriap_getvaluebyclass_request(self->client.iriap,
111 self->saddr, self->daddr,
112 "IrLAN", "IrDA:TinyTP:LsapSel");
113 break;
114 case IRLAN_WATCHDOG_TIMEOUT:
115 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
116 break;
117 default:
118 pr_debug("%s(), Unknown event %d\n", __func__ , event);
119 break;
120 }
121 if (skb)
122 dev_kfree_skb(skb);
123
124 return 0;
125 }
126
127 /*
128 * Function irlan_client_state_query (event, skb, info)
129 *
130 * QUERY, We have queryed the remote IAS and is ready to connect
131 * to provider, just waiting for the confirm.
132 *
133 */
134 static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
135 struct sk_buff *skb)
136 {
137 IRDA_ASSERT(self != NULL, return -1;);
138 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
139
140 switch(event) {
141 case IRLAN_IAS_PROVIDER_AVAIL:
142 IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;);
143
144 self->client.open_retries = 0;
145
146 irttp_connect_request(self->client.tsap_ctrl,
147 self->dtsap_sel_ctrl,
148 self->saddr, self->daddr, NULL,
149 IRLAN_MTU, NULL);
150 irlan_next_client_state(self, IRLAN_CONN);
151 break;
152 case IRLAN_IAS_PROVIDER_NOT_AVAIL:
153 pr_debug("%s(), IAS_PROVIDER_NOT_AVAIL\n", __func__);
154 irlan_next_client_state(self, IRLAN_IDLE);
155
156 /* Give the client a kick! */
157 if ((self->provider.access_type == ACCESS_PEER) &&
158 (self->provider.state != IRLAN_IDLE))
159 irlan_client_wakeup(self, self->saddr, self->daddr);
160 break;
161 case IRLAN_LMP_DISCONNECT:
162 case IRLAN_LAP_DISCONNECT:
163 irlan_next_client_state(self, IRLAN_IDLE);
164 break;
165 case IRLAN_WATCHDOG_TIMEOUT:
166 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
167 break;
168 default:
169 pr_debug("%s(), Unknown event %d\n", __func__ , event);
170 break;
171 }
172 if (skb)
173 dev_kfree_skb(skb);
174
175 return 0;
176 }
177
178 /*
179 * Function irlan_client_state_conn (event, skb, info)
180 *
181 * CONN, We have connected to a provider but has not issued any
182 * commands yet.
183 *
184 */
185 static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
186 struct sk_buff *skb)
187 {
188 IRDA_ASSERT(self != NULL, return -1;);
189
190 switch (event) {
191 case IRLAN_CONNECT_COMPLETE:
192 /* Send getinfo cmd */
193 irlan_get_provider_info(self);
194 irlan_next_client_state(self, IRLAN_INFO);
195 break;
196 case IRLAN_LMP_DISCONNECT:
197 case IRLAN_LAP_DISCONNECT:
198 irlan_next_client_state(self, IRLAN_IDLE);
199 break;
200 case IRLAN_WATCHDOG_TIMEOUT:
201 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
202 break;
203 default:
204 pr_debug("%s(), Unknown event %d\n", __func__ , event);
205 break;
206 }
207 if (skb)
208 dev_kfree_skb(skb);
209
210 return 0;
211 }
212
213 /*
214 * Function irlan_client_state_info (self, event, skb, info)
215 *
216 * INFO, We have issued a GetInfo command and is awaiting a reply.
217 */
218 static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
219 struct sk_buff *skb)
220 {
221 IRDA_ASSERT(self != NULL, return -1;);
222
223 switch (event) {
224 case IRLAN_DATA_INDICATION:
225 IRDA_ASSERT(skb != NULL, return -1;);
226
227 irlan_client_parse_response(self, skb);
228
229 irlan_next_client_state(self, IRLAN_MEDIA);
230
231 irlan_get_media_char(self);
232 break;
233
234 case IRLAN_LMP_DISCONNECT:
235 case IRLAN_LAP_DISCONNECT:
236 irlan_next_client_state(self, IRLAN_IDLE);
237 break;
238 case IRLAN_WATCHDOG_TIMEOUT:
239 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
240 break;
241 default:
242 pr_debug("%s(), Unknown event %d\n", __func__ , event);
243 break;
244 }
245 if (skb)
246 dev_kfree_skb(skb);
247
248 return 0;
249 }
250
251 /*
252 * Function irlan_client_state_media (self, event, skb, info)
253 *
254 * MEDIA, The irlan_client has issued a GetMedia command and is awaiting a
255 * reply.
256 *
257 */
258 static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
259 struct sk_buff *skb)
260 {
261 IRDA_ASSERT(self != NULL, return -1;);
262
263 switch(event) {
264 case IRLAN_DATA_INDICATION:
265 irlan_client_parse_response(self, skb);
266 irlan_open_data_channel(self);
267 irlan_next_client_state(self, IRLAN_OPEN);
268 break;
269 case IRLAN_LMP_DISCONNECT:
270 case IRLAN_LAP_DISCONNECT:
271 irlan_next_client_state(self, IRLAN_IDLE);
272 break;
273 case IRLAN_WATCHDOG_TIMEOUT:
274 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
275 break;
276 default:
277 pr_debug("%s(), Unknown event %d\n", __func__ , event);
278 break;
279 }
280 if (skb)
281 dev_kfree_skb(skb);
282
283 return 0;
284 }
285
286 /*
287 * Function irlan_client_state_open (self, event, skb, info)
288 *
289 * OPEN, The irlan_client has issued a OpenData command and is awaiting a
290 * reply
291 *
292 */
293 static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
294 struct sk_buff *skb)
295 {
296 struct qos_info qos;
297
298 IRDA_ASSERT(self != NULL, return -1;);
299
300 switch(event) {
301 case IRLAN_DATA_INDICATION:
302 irlan_client_parse_response(self, skb);
303
304 /*
305 * Check if we have got the remote TSAP for data
306 * communications
307 */
308 IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);
309
310 /* Check which access type we are dealing with */
311 switch (self->client.access_type) {
312 case ACCESS_PEER:
313 if (self->provider.state == IRLAN_OPEN) {
314
315 irlan_next_client_state(self, IRLAN_ARB);
316 irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
317 NULL);
318 } else {
319
320 irlan_next_client_state(self, IRLAN_WAIT);
321 }
322 break;
323 case ACCESS_DIRECT:
324 case ACCESS_HOSTED:
325 qos.link_disc_time.bits = 0x01; /* 3 secs */
326
327 irttp_connect_request(self->tsap_data,
328 self->dtsap_sel_data,
329 self->saddr, self->daddr, &qos,
330 IRLAN_MTU, NULL);
331
332 irlan_next_client_state(self, IRLAN_DATA);
333 break;
334 default:
335 pr_debug("%s(), unknown access type!\n", __func__);
336 break;
337 }
338 break;
339 case IRLAN_LMP_DISCONNECT:
340 case IRLAN_LAP_DISCONNECT:
341 irlan_next_client_state(self, IRLAN_IDLE);
342 break;
343 case IRLAN_WATCHDOG_TIMEOUT:
344 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
345 break;
346 default:
347 pr_debug("%s(), Unknown event %d\n", __func__ , event);
348 break;
349 }
350
351 if (skb)
352 dev_kfree_skb(skb);
353
354 return 0;
355 }
356
357 /*
358 * Function irlan_client_state_wait (self, event, skb, info)
359 *
360 * WAIT, The irlan_client is waiting for the local provider to enter the
361 * provider OPEN state.
362 *
363 */
364 static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
365 struct sk_buff *skb)
366 {
367 IRDA_ASSERT(self != NULL, return -1;);
368
369 switch(event) {
370 case IRLAN_PROVIDER_SIGNAL:
371 irlan_next_client_state(self, IRLAN_ARB);
372 irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, NULL);
373 break;
374 case IRLAN_LMP_DISCONNECT:
375 case IRLAN_LAP_DISCONNECT:
376 irlan_next_client_state(self, IRLAN_IDLE);
377 break;
378 case IRLAN_WATCHDOG_TIMEOUT:
379 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
380 break;
381 default:
382 pr_debug("%s(), Unknown event %d\n", __func__ , event);
383 break;
384 }
385 if (skb)
386 dev_kfree_skb(skb);
387
388 return 0;
389 }
390
391 static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
392 struct sk_buff *skb)
393 {
394 struct qos_info qos;
395
396 IRDA_ASSERT(self != NULL, return -1;);
397
398 switch(event) {
399 case IRLAN_CHECK_CON_ARB:
400 if (self->client.recv_arb_val == self->provider.send_arb_val) {
401 irlan_next_client_state(self, IRLAN_CLOSE);
402 irlan_close_data_channel(self);
403 } else if (self->client.recv_arb_val <
404 self->provider.send_arb_val)
405 {
406 qos.link_disc_time.bits = 0x01; /* 3 secs */
407
408 irlan_next_client_state(self, IRLAN_DATA);
409 irttp_connect_request(self->tsap_data,
410 self->dtsap_sel_data,
411 self->saddr, self->daddr, &qos,
412 IRLAN_MTU, NULL);
413 } else if (self->client.recv_arb_val >
414 self->provider.send_arb_val)
415 {
416 pr_debug("%s(), lost the battle :-(\n", __func__);
417 }
418 break;
419 case IRLAN_DATA_CONNECT_INDICATION:
420 irlan_next_client_state(self, IRLAN_DATA);
421 break;
422 case IRLAN_LMP_DISCONNECT:
423 case IRLAN_LAP_DISCONNECT:
424 irlan_next_client_state(self, IRLAN_IDLE);
425 break;
426 case IRLAN_WATCHDOG_TIMEOUT:
427 pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
428 break;
429 default:
430 pr_debug("%s(), Unknown event %d\n", __func__ , event);
431 break;
432 }
433 if (skb)
434 dev_kfree_skb(skb);
435
436 return 0;
437 }
438
439 /*
440 * Function irlan_client_state_data (self, event, skb, info)
441 *
442 * DATA, The data channel is connected, allowing data transfers between
443 * the local and remote machines.
444 *
445 */
446 static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
447 struct sk_buff *skb)
448 {
449 IRDA_ASSERT(self != NULL, return -1;);
450 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
451
452 switch(event) {
453 case IRLAN_DATA_INDICATION:
454 irlan_client_parse_response(self, skb);
455 break;
456 case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
457 case IRLAN_LAP_DISCONNECT:
458 irlan_next_client_state(self, IRLAN_IDLE);
459 break;
460 default:
461 pr_debug("%s(), Unknown event %d\n", __func__ , event);
462 break;
463 }
464 if (skb)
465 dev_kfree_skb(skb);
466
467 return 0;
468 }
469
470 /*
471 * Function irlan_client_state_close (self, event, skb, info)
472 *
473 *
474 *
475 */
476 static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
477 struct sk_buff *skb)
478 {
479 if (skb)
480 dev_kfree_skb(skb);
481
482 return 0;
483 }
484
485 /*
486 * Function irlan_client_state_sync (self, event, skb, info)
487 *
488 *
489 *
490 */
491 static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
492 struct sk_buff *skb)
493 {
494 if (skb)
495 dev_kfree_skb(skb);
496
497 return 0;
498 }
499
500
501
502
503
504
505
506
507
508
509
510
511
Linux with added FPC-III support