1 /*********************************************************************
3 * Filename: irlmp_frame.c
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>
12 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>
13 * All Rights Reserved.
14 * Copyright (c) 2000-2001 Jean Tourrilhes <jt@hpl.hp.com>
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.
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.
25 ********************************************************************/
27 #include <linux/config.h>
28 #include <linux/skbuff.h>
29 #include <linux/kernel.h>
31 #include <net/irda/irda.h>
32 #include <net/irda/irlap.h>
33 #include <net/irda/timer.h>
34 #include <net/irda/irlmp.h>
35 #include <net/irda/irlmp_frame.h>
36 #include <net/irda/discovery.h>
38 static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap,
39 __u8 slsap, int status, hashbin_t *);
41 inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
42 int expedited, struct sk_buff *skb)
48 IRDA_DEBUG(4, "%s(), sending expedited data\n", __FUNCTION__);
49 irlap_data_request(self->irlap, skb, TRUE);
51 irlap_data_request(self->irlap, skb, FALSE);
55 * Function irlmp_send_lcf_pdu (dlsap, slsap, opcode,skb)
57 * Send Link Control Frame to IrLAP
59 void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
60 __u8 opcode, struct sk_buff *skb)
64 IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
66 ASSERT(self != NULL, return;);
67 ASSERT(self->magic == LMP_LAP_MAGIC, return;);
68 ASSERT(skb != NULL, return;);
72 frame[0] = dlsap | CONTROL_BIT;
77 if (opcode == DISCONNECT)
78 frame[3] = 0x01; /* Service user request */
80 frame[3] = 0x00; /* rsvd */
82 irlap_data_request(self->irlap, skb, FALSE);
86 * Function irlmp_input (skb)
88 * Used by IrLAP to pass received data frames to IrLMP layer
91 void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
95 __u8 slsap_sel; /* Source (this) LSAP address */
96 __u8 dlsap_sel; /* Destination LSAP address */
99 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
101 ASSERT(self != NULL, return;);
102 ASSERT(self->magic == LMP_LAP_MAGIC, return;);
103 ASSERT(skb->len > 2, return;);
108 * The next statements may be confusing, but we do this so that
109 * destination LSAP of received frame is source LSAP in our view
111 slsap_sel = fp[0] & LSAP_MASK;
115 * Check if this is an incoming connection, since we must deal with
116 * it in a different way than other established connections.
118 if ((fp[0] & CONTROL_BIT) && (fp[2] == CONNECT_CMD)) {
119 IRDA_DEBUG(3, "%s(), incoming connection, "
120 "source LSAP=%d, dest LSAP=%d\n",
121 __FUNCTION__, slsap_sel, dlsap_sel);
123 /* Try to find LSAP among the unconnected LSAPs */
124 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD,
125 irlmp->unconnected_lsaps);
127 /* Maybe LSAP was already connected, so try one more time */
129 IRDA_DEBUG(1, "%s(), incoming connection for LSAP already connected\n", __FUNCTION__);
130 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
134 lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
138 IRDA_DEBUG(2, "IrLMP, Sorry, no LSAP for received frame!\n");
139 IRDA_DEBUG(2, "%s(), slsap_sel = %02x, dlsap_sel = %02x\n", __FUNCTION__, slsap_sel,
141 if (fp[0] & CONTROL_BIT) {
142 IRDA_DEBUG(2, "%s(), received control frame %02x\n", __FUNCTION__, fp[2]);
144 IRDA_DEBUG(2, "%s(), received data frame\n", __FUNCTION__);
151 * Check if we received a control frame?
153 if (fp[0] & CONTROL_BIT) {
157 irlmp_do_lsap_event(lsap, LM_CONNECT_INDICATION, skb);
160 irlmp_do_lsap_event(lsap, LM_CONNECT_CONFIRM, skb);
163 IRDA_DEBUG(4, "%s(), Disconnect indication!\n", __FUNCTION__);
164 irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
168 IRDA_DEBUG(0, "Access mode cmd not implemented!\n");
172 IRDA_DEBUG(0, "Access mode cnf not implemented!\n");
176 IRDA_DEBUG(0, "%s(), Unknown control frame %02x\n", __FUNCTION__, fp[2]);
180 } else if (unreliable) {
181 /* Optimize and bypass the state machine if possible */
182 if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
183 irlmp_udata_indication(lsap, skb);
185 irlmp_do_lsap_event(lsap, LM_UDATA_INDICATION, skb);
187 /* Optimize and bypass the state machine if possible */
188 if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
189 irlmp_data_indication(lsap, skb);
191 irlmp_do_lsap_event(lsap, LM_DATA_INDICATION, skb);
196 * Function irlmp_link_unitdata_indication (self, skb)
201 #ifdef CONFIG_IRDA_ULTRA
202 void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb)
204 struct lsap_cb *lsap;
205 __u8 slsap_sel; /* Source (this) LSAP address */
206 __u8 dlsap_sel; /* Destination LSAP address */
207 __u8 pid; /* Protocol identifier */
210 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
212 ASSERT(self != NULL, return;);
213 ASSERT(self->magic == LMP_LAP_MAGIC, return;);
214 ASSERT(skb->len > 2, return;);
219 * The next statements may be confusing, but we do this so that
220 * destination LSAP of received frame is source LSAP in our view
222 slsap_sel = fp[0] & LSAP_MASK;
227 IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __FUNCTION__);
233 /* Check if frame is addressed to the connectionless LSAP */
234 if ((slsap_sel != LSAP_CONNLESS) || (dlsap_sel != LSAP_CONNLESS)) {
235 IRDA_DEBUG(0, "%s(), dropping frame!\n", __FUNCTION__);
241 lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
242 while (lsap != NULL) {
244 * Check if source LSAP and dest LSAP selectors and PID match.
246 if ((lsap->slsap_sel == slsap_sel) &&
247 (lsap->dlsap_sel == dlsap_sel) &&
252 lsap = (struct lsap_cb *) hashbin_get_next(irlmp->unconnected_lsaps);
255 irlmp_connless_data_indication(lsap, skb);
257 IRDA_DEBUG(0, "%s(), found no matching LSAP!\n", __FUNCTION__);
261 #endif /* CONFIG_IRDA_ULTRA */
264 * Function irlmp_link_disconnect_indication (reason, userdata)
266 * IrLAP has disconnected
269 void irlmp_link_disconnect_indication(struct lap_cb *lap,
270 struct irlap_cb *irlap,
272 struct sk_buff *userdata)
274 IRDA_DEBUG(2, "%s()\n", __FUNCTION__);
276 ASSERT(lap != NULL, return;);
277 ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
279 lap->reason = reason;
280 lap->daddr = DEV_ADDR_ANY;
282 /* FIXME: must do something with the userdata if any */
284 dev_kfree_skb(userdata);
287 * Inform station state machine
289 irlmp_do_lap_event(lap, LM_LAP_DISCONNECT_INDICATION, NULL);
293 * Function irlmp_link_connect_indication (qos)
295 * Incoming LAP connection!
298 void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
299 __u32 daddr, struct qos_info *qos,
302 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
304 /* Copy QoS settings for this session */
307 /* Update destination device address */
309 ASSERT(self->saddr == saddr, return;);
311 irlmp_do_lap_event(self, LM_LAP_CONNECT_INDICATION, skb);
315 * Function irlmp_link_connect_confirm (qos)
317 * LAP connection confirmed!
320 void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
321 struct sk_buff *userdata)
323 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
325 ASSERT(self != NULL, return;);
326 ASSERT(self->magic == LMP_LAP_MAGIC, return;);
327 ASSERT(qos != NULL, return;);
329 /* Don't need use the userdata for now */
331 dev_kfree_skb(userdata);
333 /* Copy QoS settings for this session */
336 irlmp_do_lap_event(self, LM_LAP_CONNECT_CONFIRM, NULL);
340 * Function irlmp_link_discovery_indication (self, log)
342 * Device is discovering us
344 * It's not an answer to our own discoveries, just another device trying
345 * to perform discovery, but we don't want to miss the opportunity
346 * to exploit this information, because :
347 * o We may not actively perform discovery (just passive discovery)
348 * o This type of discovery is much more reliable. In some cases, it
349 * seem that less than 50% of our discoveries get an answer, while
350 * we always get ~100% of these.
351 * o Make faster discovery, statistically divide time of discovery
352 * events by 2 (important for the latency aspect and user feel)
353 * o Even is we do active discovery, the other node might not
354 * answer our discoveries (ex: Palm). The Palm will just perform
355 * one active discovery and connect directly to us.
357 * However, when both devices discover each other, they might attempt to
358 * connect to each other following the discovery event, and it would create
359 * collisions on the medium (SNRM battle).
360 * The "fix" for that is to disable all connection requests in IrLAP
361 * for 100ms after a discovery indication by setting the media_busy flag.
362 * Previously, we used to postpone the event which was quite ugly. Now
363 * that IrLAP takes care of this problem, just pass the event up...
367 void irlmp_link_discovery_indication(struct lap_cb *self,
368 discovery_t *discovery)
370 ASSERT(self != NULL, return;);
371 ASSERT(self->magic == LMP_LAP_MAGIC, return;);
373 irlmp_add_discovery(irlmp->cachelog, discovery);
375 /* Just handle it the same way as a discovery confirm,
376 * bypass the LM_LAP state machine (see below) */
377 irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_PASSIVE);
381 * Function irlmp_link_discovery_confirm (self, log)
383 * Called by IrLAP with a list of discoveries after the discovery
384 * request has been carried out. A NULL log is received if IrLAP
385 * was unable to carry out the discovery request
388 void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log)
390 IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
392 ASSERT(self != NULL, return;);
393 ASSERT(self->magic == LMP_LAP_MAGIC, return;);
395 irlmp_add_discovery_log(irlmp->cachelog, log);
397 /* Propagate event to various LSAPs registered for it.
398 * We bypass the LM_LAP state machine because
399 * 1) We do it regardless of the LM_LAP state
400 * 2) It doesn't affect the LM_LAP state
401 * 3) Faster, slimer, simpler, ...
403 irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_ACTIVE);
406 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
407 inline void irlmp_update_cache(struct lsap_cb *self)
409 /* Update cache entry */
410 irlmp->cache.dlsap_sel = self->dlsap_sel;
411 irlmp->cache.slsap_sel = self->slsap_sel;
412 irlmp->cache.lsap = self;
413 irlmp->cache.valid = TRUE;
418 * Function irlmp_find_handle (self, dlsap_sel, slsap_sel, status, queue)
420 * Find handle assosiated with destination and source LSAP
423 static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel,
424 __u8 slsap_sel, int status,
427 struct lsap_cb *lsap;
430 * Optimize for the common case. We assume that the last frame
431 * received is in the same connection as the last one, so check in
432 * cache first to avoid the linear search
434 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
435 if ((irlmp->cache.valid) &&
436 (irlmp->cache.slsap_sel == slsap_sel) &&
437 (irlmp->cache.dlsap_sel == dlsap_sel))
439 return (irlmp->cache.lsap);
442 lsap = (struct lsap_cb *) hashbin_get_first(queue);
443 while (lsap != NULL) {
445 * If this is an incoming connection, then the destination
446 * LSAP selector may have been specified as LM_ANY so that
447 * any client can connect. In that case we only need to check
448 * if the source LSAP (in our view!) match!
450 if ((status == CONNECT_CMD) &&
451 (lsap->slsap_sel == slsap_sel) &&
452 (lsap->dlsap_sel == LSAP_ANY))
454 lsap->dlsap_sel = dlsap_sel;
456 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
457 irlmp_update_cache(lsap);
462 * Check if source LSAP and dest LSAP selectors match.
464 if ((lsap->slsap_sel == slsap_sel) &&
465 (lsap->dlsap_sel == dlsap_sel))
467 #ifdef CONFIG_IRDA_CACHE_LAST_LSAP
468 irlmp_update_cache(lsap);
472 lsap = (struct lsap_cb *) hashbin_get_next(queue);
475 /* Sorry not found! */