]>
Commit | Line | Data |
---|---|---|
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", __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 | */ | |
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", __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 | */ | |
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", __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 | |
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", __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 | */ | |
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", __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 | */ | |
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", __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 | */ | |
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", __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 | */ | |
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", __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 | |
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 | } |