[IRDA]: IrCOMM discovery indication simplification
[linux-2.6.git] / net / irda / irlmp_frame.c
1 /*********************************************************************
2  *
3  * Filename:      irlmp_frame.c
4  * Version:       0.9
5  * Description:   IrLMP frame implementation
6  * Status:        Experimental.
7  * Author:        Dag Brattli <dagb@cs.uit.no>
8  * Created at:    Tue Aug 19 02:09:59 1997
9  * Modified at:   Mon Dec 13 13:41:12 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  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
15  *
16  *     This program is free software; you can redistribute it and/or
17  *     modify it under the terms of the GNU General Public License as
18  *     published by the Free Software Foundation; either version 2 of
19  *     the License, or (at your option) any later version.
20  *
21  *     Neither Dag Brattli nor University of Tromsø admit liability nor
22  *     provide warranty for any of this software. This material is
23  *     provided "AS-IS" and at no charge.
24  *
25  ********************************************************************/
26
27 #include <linux/skbuff.h>
28 #include <linux/kernel.h>
29
30 #include <net/irda/irda.h>
31 #include <net/irda/irlap.h>
32 #include <net/irda/timer.h>
33 #include <net/irda/irlmp.h>
34 #include <net/irda/irlmp_frame.h>
35 #include <net/irda/discovery.h>
36
37 static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap,
38                                        __u8 slsap, int status, hashbin_t *);
39
40 inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
41                                 int expedited, struct sk_buff *skb)
42 {
43         skb->data[0] = dlsap;
44         skb->data[1] = slsap;
45
46         if (expedited) {
47                 IRDA_DEBUG(4, "%s(), sending expedited data\n", __FUNCTION__);
48                 irlap_data_request(self->irlap, skb, TRUE);
49         } else
50                 irlap_data_request(self->irlap, skb, FALSE);
51 }
52
53 /*
54  * Function irlmp_send_lcf_pdu (dlsap, slsap, opcode,skb)
55  *
56  *    Send Link Control Frame to IrLAP
57  */
58 void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
59                         __u8 opcode, struct sk_buff *skb)
60 {
61         __u8 *frame;
62
63         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
64
65         IRDA_ASSERT(self != NULL, return;);
66         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
67         IRDA_ASSERT(skb != NULL, return;);
68
69         frame = skb->data;
70
71         frame[0] = dlsap | CONTROL_BIT;
72         frame[1] = slsap;
73
74         frame[2] = opcode;
75
76         if (opcode == DISCONNECT)
77                 frame[3] = 0x01; /* Service user request */
78         else
79                 frame[3] = 0x00; /* rsvd */
80
81         irlap_data_request(self->irlap, skb, FALSE);
82 }
83
84 /*
85  * Function irlmp_input (skb)
86  *
87  *    Used by IrLAP to pass received data frames to IrLMP layer
88  *
89  */
90 void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
91                                 int unreliable)
92 {
93         struct lsap_cb *lsap;
94         __u8   slsap_sel;   /* Source (this) LSAP address */
95         __u8   dlsap_sel;   /* Destination LSAP address */
96         __u8   *fp;
97
98         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
99
100         IRDA_ASSERT(self != NULL, return;);
101         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
102         IRDA_ASSERT(skb->len > 2, return;);
103
104         fp = skb->data;
105
106         /*
107          *  The next statements may be confusing, but we do this so that
108          *  destination LSAP of received frame is source LSAP in our view
109          */
110         slsap_sel = fp[0] & LSAP_MASK;
111         dlsap_sel = fp[1];
112
113         /*
114          *  Check if this is an incoming connection, since we must deal with
115          *  it in a different way than other established connections.
116          */
117         if ((fp[0] & CONTROL_BIT) && (fp[2] == CONNECT_CMD)) {
118                 IRDA_DEBUG(3, "%s(), incoming connection, "
119                            "source LSAP=%d, dest LSAP=%d\n",
120                            __FUNCTION__, slsap_sel, dlsap_sel);
121
122                 /* Try to find LSAP among the unconnected LSAPs */
123                 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD,
124                                        irlmp->unconnected_lsaps);
125
126                 /* Maybe LSAP was already connected, so try one more time */
127                 if (!lsap) {
128                         IRDA_DEBUG(1, "%s(), incoming connection for LSAP already connected\n", __FUNCTION__);
129                         lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
130                                                self->lsaps);
131                 }
132         } else
133                 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
134                                        self->lsaps);
135
136         if (lsap == NULL) {
137                 IRDA_DEBUG(2, "IrLMP, Sorry, no LSAP for received frame!\n");
138                 IRDA_DEBUG(2, "%s(), slsap_sel = %02x, dlsap_sel = %02x\n",
139                            __FUNCTION__, slsap_sel, dlsap_sel);
140                 if (fp[0] & CONTROL_BIT) {
141                         IRDA_DEBUG(2, "%s(), received control frame %02x\n",
142                                    __FUNCTION__, fp[2]);
143                 } else {
144                         IRDA_DEBUG(2, "%s(), received data frame\n", __FUNCTION__);
145                 }
146                 return;
147         }
148
149         /*
150          *  Check if we received a control frame?
151          */
152         if (fp[0] & CONTROL_BIT) {
153                 switch (fp[2]) {
154                 case CONNECT_CMD:
155                         lsap->lap = self;
156                         irlmp_do_lsap_event(lsap, LM_CONNECT_INDICATION, skb);
157                         break;
158                 case CONNECT_CNF:
159                         irlmp_do_lsap_event(lsap, LM_CONNECT_CONFIRM, skb);
160                         break;
161                 case DISCONNECT:
162                         IRDA_DEBUG(4, "%s(), Disconnect indication!\n",
163                                    __FUNCTION__);
164                         irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
165                                             skb);
166                         break;
167                 case ACCESSMODE_CMD:
168                         IRDA_DEBUG(0, "Access mode cmd not implemented!\n");
169                         break;
170                 case ACCESSMODE_CNF:
171                         IRDA_DEBUG(0, "Access mode cnf not implemented!\n");
172                         break;
173                 default:
174                         IRDA_DEBUG(0, "%s(), Unknown control frame %02x\n",
175                                    __FUNCTION__, fp[2]);
176                         break;
177                 }
178         } else if (unreliable) {
179                 /* Optimize and bypass the state machine if possible */
180                 if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
181                         irlmp_udata_indication(lsap, skb);
182                 else
183                         irlmp_do_lsap_event(lsap, LM_UDATA_INDICATION, skb);
184         } else {
185                 /* Optimize and bypass the state machine if possible */
186                 if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
187                         irlmp_data_indication(lsap, skb);
188                 else
189                         irlmp_do_lsap_event(lsap, LM_DATA_INDICATION, skb);
190         }
191 }
192
193 /*
194  * Function irlmp_link_unitdata_indication (self, skb)
195  *
196  *
197  *
198  */
199 #ifdef CONFIG_IRDA_ULTRA
200 void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb)
201 {
202         struct lsap_cb *lsap;
203         __u8   slsap_sel;   /* Source (this) LSAP address */
204         __u8   dlsap_sel;   /* Destination LSAP address */
205         __u8   pid;         /* Protocol identifier */
206         __u8   *fp;
207         unsigned long flags;
208
209         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
210
211         IRDA_ASSERT(self != NULL, return;);
212         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
213         IRDA_ASSERT(skb->len > 2, return;);
214
215         fp = skb->data;
216
217         /*
218          *  The next statements may be confusing, but we do this so that
219          *  destination LSAP of received frame is source LSAP in our view
220          */
221         slsap_sel = fp[0] & LSAP_MASK;
222         dlsap_sel = fp[1];
223         pid       = fp[2];
224
225         if (pid & 0x80) {
226                 IRDA_DEBUG(0, "%s(), extension in PID not supp!\n",
227                            __FUNCTION__);
228                 return;
229         }
230
231         /* Check if frame is addressed to the connectionless LSAP */
232         if ((slsap_sel != LSAP_CONNLESS) || (dlsap_sel != LSAP_CONNLESS)) {
233                 IRDA_DEBUG(0, "%s(), dropping frame!\n", __FUNCTION__);
234                 return;
235         }
236
237         /* Search the connectionless LSAP */
238         spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
239         lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
240         while (lsap != NULL) {
241                 /*
242                  *  Check if source LSAP and dest LSAP selectors and PID match.
243                  */
244                 if ((lsap->slsap_sel == slsap_sel) &&
245                     (lsap->dlsap_sel == dlsap_sel) &&
246                     (lsap->pid == pid))
247                 {
248                         break;
249                 }
250                 lsap = (struct lsap_cb *) hashbin_get_next(irlmp->unconnected_lsaps);
251         }
252         spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);
253
254         if (lsap)
255                 irlmp_connless_data_indication(lsap, skb);
256         else {
257                 IRDA_DEBUG(0, "%s(), found no matching LSAP!\n", __FUNCTION__);
258         }
259 }
260 #endif /* CONFIG_IRDA_ULTRA */
261
262 /*
263  * Function irlmp_link_disconnect_indication (reason, userdata)
264  *
265  *    IrLAP has disconnected
266  *
267  */
268 void irlmp_link_disconnect_indication(struct lap_cb *lap,
269                                       struct irlap_cb *irlap,
270                                       LAP_REASON reason,
271                                       struct sk_buff *skb)
272 {
273         IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
274
275         IRDA_ASSERT(lap != NULL, return;);
276         IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
277
278         lap->reason = reason;
279         lap->daddr = DEV_ADDR_ANY;
280
281         /* FIXME: must do something with the skb if any */
282
283         /*
284          *  Inform station state machine
285          */
286         irlmp_do_lap_event(lap, LM_LAP_DISCONNECT_INDICATION, NULL);
287 }
288
289 /*
290  * Function irlmp_link_connect_indication (qos)
291  *
292  *    Incoming LAP connection!
293  *
294  */
295 void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
296                                    __u32 daddr, struct qos_info *qos,
297                                    struct sk_buff *skb)
298 {
299         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
300
301         /* Copy QoS settings for this session */
302         self->qos = qos;
303
304         /* Update destination device address */
305         self->daddr = daddr;
306         IRDA_ASSERT(self->saddr == saddr, return;);
307
308         irlmp_do_lap_event(self, LM_LAP_CONNECT_INDICATION, skb);
309 }
310
311 /*
312  * Function irlmp_link_connect_confirm (qos)
313  *
314  *    LAP connection confirmed!
315  *
316  */
317 void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
318                                 struct sk_buff *skb)
319 {
320         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
321
322         IRDA_ASSERT(self != NULL, return;);
323         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
324         IRDA_ASSERT(qos != NULL, return;);
325
326         /* Don't need use the skb for now */
327
328         /* Copy QoS settings for this session */
329         self->qos = qos;
330
331         irlmp_do_lap_event(self, LM_LAP_CONNECT_CONFIRM, NULL);
332 }
333
334 /*
335  * Function irlmp_link_discovery_indication (self, log)
336  *
337  *    Device is discovering us
338  *
339  * It's not an answer to our own discoveries, just another device trying
340  * to perform discovery, but we don't want to miss the opportunity
341  * to exploit this information, because :
342  *      o We may not actively perform discovery (just passive discovery)
343  *      o This type of discovery is much more reliable. In some cases, it
344  *        seem that less than 50% of our discoveries get an answer, while
345  *        we always get ~100% of these.
346  *      o Make faster discovery, statistically divide time of discovery
347  *        events by 2 (important for the latency aspect and user feel)
348  *      o Even is we do active discovery, the other node might not
349  *        answer our discoveries (ex: Palm). The Palm will just perform
350  *        one active discovery and connect directly to us.
351  *
352  * However, when both devices discover each other, they might attempt to
353  * connect to each other following the discovery event, and it would create
354  * collisions on the medium (SNRM battle).
355  * The "fix" for that is to disable all connection requests in IrLAP
356  * for 100ms after a discovery indication by setting the media_busy flag.
357  * Previously, we used to postpone the event which was quite ugly. Now
358  * that IrLAP takes care of this problem, just pass the event up...
359  *
360  * Jean II
361  */
362 void irlmp_link_discovery_indication(struct lap_cb *self,
363                                      discovery_t *discovery)
364 {
365         IRDA_ASSERT(self != NULL, return;);
366         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
367
368         /* Add to main log, cleanup */
369         irlmp_add_discovery(irlmp->cachelog, discovery);
370
371         /* Just handle it the same way as a discovery confirm,
372          * bypass the LM_LAP state machine (see below) */
373         irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_PASSIVE);
374 }
375
376 /*
377  * Function irlmp_link_discovery_confirm (self, log)
378  *
379  *    Called by IrLAP with a list of discoveries after the discovery
380  *    request has been carried out. A NULL log is received if IrLAP
381  *    was unable to carry out the discovery request
382  *
383  */
384 void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log)
385 {
386         IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
387
388         IRDA_ASSERT(self != NULL, return;);
389         IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
390
391         /* Add to main log, cleanup */
392         irlmp_add_discovery_log(irlmp->cachelog, log);
393
394         /* Propagate event to various LSAPs registered for it.
395          * We bypass the LM_LAP state machine because
396          *      1) We do it regardless of the LM_LAP state
397          *      2) It doesn't affect the LM_LAP state
398          *      3) Faster, slimer, simpler, ...
399          * Jean II */
400         irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_ACTIVE);
401 }
402
403 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
404 static inline void irlmp_update_cache(struct lap_cb *lap,
405                                       struct lsap_cb *lsap)
406 {
407         /* Prevent concurrent read to get garbage */
408         lap->cache.valid = FALSE;
409         /* Update cache entry */
410         lap->cache.dlsap_sel = lsap->dlsap_sel;
411         lap->cache.slsap_sel = lsap->slsap_sel;
412         lap->cache.lsap = lsap;
413         lap->cache.valid = TRUE;
414 }
415 #endif
416
417 /*
418  * Function irlmp_find_handle (self, dlsap_sel, slsap_sel, status, queue)
419  *
420  *    Find handle associated with destination and source LSAP
421  *
422  * Any IrDA connection (LSAP/TSAP) is uniquely identified by
423  * 3 parameters, the local lsap, the remote lsap and the remote address.
424  * We may initiate multiple connections to the same remote service
425  * (they will have different local lsap), a remote device may initiate
426  * multiple connections to the same local service (they will have
427  * different remote lsap), or multiple devices may connect to the same
428  * service and may use the same remote lsap (and they will have
429  * different remote address).
430  * So, where is the remote address ? Each LAP connection is made with
431  * a single remote device, so imply a specific remote address.
432  * Jean II
433  */
434 static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel,
435                                        __u8 slsap_sel, int status,
436                                        hashbin_t *queue)
437 {
438         struct lsap_cb *lsap;
439         unsigned long flags;
440
441         /*
442          *  Optimize for the common case. We assume that the last frame
443          *  received is in the same connection as the last one, so check in
444          *  cache first to avoid the linear search
445          */
446 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
447         if ((self->cache.valid) &&
448             (self->cache.slsap_sel == slsap_sel) &&
449             (self->cache.dlsap_sel == dlsap_sel))
450         {
451                 return (self->cache.lsap);
452         }
453 #endif
454
455         spin_lock_irqsave(&queue->hb_spinlock, flags);
456
457         lsap = (struct lsap_cb *) hashbin_get_first(queue);
458         while (lsap != NULL) {
459                 /*
460                  *  If this is an incoming connection, then the destination
461                  *  LSAP selector may have been specified as LM_ANY so that
462                  *  any client can connect. In that case we only need to check
463                  *  if the source LSAP (in our view!) match!
464                  */
465                 if ((status == CONNECT_CMD) &&
466                     (lsap->slsap_sel == slsap_sel) &&
467                     (lsap->dlsap_sel == LSAP_ANY)) {
468                         /* This is where the dest lsap sel is set on incoming
469                          * lsaps */
470                         lsap->dlsap_sel = dlsap_sel;
471                         break;
472                 }
473                 /*
474                  *  Check if source LSAP and dest LSAP selectors match.
475                  */
476                 if ((lsap->slsap_sel == slsap_sel) &&
477                     (lsap->dlsap_sel == dlsap_sel))
478                         break;
479
480                 lsap = (struct lsap_cb *) hashbin_get_next(queue);
481         }
482 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
483         if(lsap)
484                 irlmp_update_cache(self, lsap);
485 #endif
486         spin_unlock_irqrestore(&queue->hb_spinlock, flags);
487
488         /* Return what we've found or NULL */
489         return lsap;
490 }