Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Newer
Older
100644 491 lines (430 sloc) 14.339 kb
d5e5fd2 Erik Hardesty Initial Palm source
dalingrin authored
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 }
Something went wrong with that request. Please try again.