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