Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux...
[firefly-linux-kernel-4.4.55.git] / net / irda / irlan / irlan_client_event.c
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