Release 4.8 net/irda/irlmp_frame.c

/*********************************************************************
 *
 * Filename:      irlmp_frame.c
 * Version:       0.9
 * Description:   IrLMP frame implementation
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Tue Aug 19 02:09:59 1997
 * Modified at:   Mon Dec 13 13:41:12 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>
 *     All Rights Reserved.
 *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <linux/skbuff.h>
#include <linux/kernel.h>

#include <net/irda/irda.h>
#include <net/irda/irlap.h>
#include <net/irda/timer.h>
#include <net/irda/irlmp.h>
#include <net/irda/irlmp_frame.h>
#include <net/irda/discovery.h>

static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap,
				       __u8 slsap, int status, hashbin_t *);



inline void irlmp_send_data_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
				int expedited, struct sk_buff *skb)
{
	skb->data[0] = dlsap;
	skb->data[1] = slsap;

	if (expedited) {
		pr_debug("%s(), sending expedited data\n", __func__);
		irlap_data_request(self->irlap, skb, TRUE);
	} else
		irlap_data_request(self->irlap, skb, FALSE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
75
94.94%
3
50.00%
jean tourrilhes
jean tourrilhes
2
2.53%
1
16.67%
harvey harrison
harvey harrison
1
1.27%
1
16.67%
joe perches
joe perches
1
1.27%
1
16.67%
Total
79
100.00%
6
100.00%

/*
 * Function irlmp_send_lcf_pdu (dlsap, slsap, opcode,skb)
 *
 *    Send Link Control Frame to IrLAP
 */


void irlmp_send_lcf_pdu(struct lap_cb *self, __u8 dlsap, __u8 slsap,
			__u8 opcode, struct sk_buff *skb)
{
	__u8 *frame;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
	IRDA_ASSERT(skb != NULL, return;);

	frame = skb->data;

	frame[0] = dlsap | CONTROL_BIT;
	frame[1] = slsap;

	frame[2] = opcode;

	if (opcode == DISCONNECT)
		frame[3] = 0x01; /* Service user request */
	else
		frame[3] = 0x00; /* rsvd */

	irlap_data_request(self->irlap, skb, FALSE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
109
97.32%
2
66.67%
jean tourrilhes
jean tourrilhes
3
2.68%
1
33.33%
Total
112
100.00%
3
100.00%

/*
 * Function irlmp_input (skb)
 *
 *    Used by IrLAP to pass received data frames to IrLMP layer
 *
 */


void irlmp_link_data_indication(struct lap_cb *self, struct sk_buff *skb,
				int unreliable)
{
	struct lsap_cb *lsap;
	__u8   slsap_sel;   /* Source (this) LSAP address */
	__u8   dlsap_sel;   /* Destination LSAP address */
	__u8   *fp;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
	IRDA_ASSERT(skb->len > 2, return;);

	fp = skb->data;

	/*
         *  The next statements may be confusing, but we do this so that
         *  destination LSAP of received frame is source LSAP in our view
         */
	slsap_sel = fp[0] & LSAP_MASK;
	dlsap_sel = fp[1];

	/*
         *  Check if this is an incoming connection, since we must deal with
         *  it in a different way than other established connections.
         */
	if ((fp[0] & CONTROL_BIT) && (fp[2] == CONNECT_CMD)) {
		pr_debug("%s(), incoming connection, source LSAP=%d, dest LSAP=%d\n",
			 __func__, slsap_sel, dlsap_sel);

		/* Try to find LSAP among the unconnected LSAPs */
		lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, CONNECT_CMD,
				       irlmp->unconnected_lsaps);

		/* Maybe LSAP was already connected, so try one more time */
		if (!lsap) {
			pr_debug("%s(), incoming connection for LSAP already connected\n",
				 __func__);
			lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
					       self->lsaps);
		}
	} else
		lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
				       self->lsaps);

	if (lsap == NULL) {
		pr_debug("IrLMP, Sorry, no LSAP for received frame!\n");
		pr_debug("%s(), slsap_sel = %02x, dlsap_sel = %02x\n",
			 __func__, slsap_sel, dlsap_sel);
		if (fp[0] & CONTROL_BIT) {
			pr_debug("%s(), received control frame %02x\n",
				 __func__, fp[2]);
		} else {
			pr_debug("%s(), received data frame\n", __func__);
		}
		return;
	}

	/*
         *  Check if we received a control frame?
         */
	if (fp[0] & CONTROL_BIT) {
		switch (fp[2]) {
		case CONNECT_CMD:
			lsap->lap = self;
			irlmp_do_lsap_event(lsap, LM_CONNECT_INDICATION, skb);
			break;
		case CONNECT_CNF:
			irlmp_do_lsap_event(lsap, LM_CONNECT_CONFIRM, skb);
			break;
		case DISCONNECT:
			pr_debug("%s(), Disconnect indication!\n",
				 __func__);
			irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
					    skb);
			break;
		case ACCESSMODE_CMD:
			pr_debug("Access mode cmd not implemented!\n");
			break;
		case ACCESSMODE_CNF:
			pr_debug("Access mode cnf not implemented!\n");
			break;
		default:
			pr_debug("%s(), Unknown control frame %02x\n",
				 __func__, fp[2]);
			break;
		}
	} else if (unreliable) {
		/* Optimize and bypass the state machine if possible */
		if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
			irlmp_udata_indication(lsap, skb);
		else
			irlmp_do_lsap_event(lsap, LM_UDATA_INDICATION, skb);
	} else {
		/* Optimize and bypass the state machine if possible */
		if (lsap->lsap_state == LSAP_DATA_TRANSFER_READY)
			irlmp_data_indication(lsap, skb);
		else
			irlmp_do_lsap_event(lsap, LM_DATA_INDICATION, skb);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
371
91.15%
5
50.00%
jean tourrilhes
jean tourrilhes
16
3.93%
2
20.00%
joe perches
joe perches
11
2.70%
1
10.00%
harvey harrison
harvey harrison
7
1.72%
1
10.00%
hideaki yoshifuji
hideaki yoshifuji
2
0.49%
1
10.00%
Total
407
100.00%
10
100.00%

/*
 * Function irlmp_link_unitdata_indication (self, skb)
 *
 *
 *
 */
#ifdef CONFIG_IRDA_ULTRA


void irlmp_link_unitdata_indication(struct lap_cb *self, struct sk_buff *skb)
{
	struct lsap_cb *lsap;
	__u8   slsap_sel;   /* Source (this) LSAP address */
	__u8   dlsap_sel;   /* Destination LSAP address */
	__u8   pid;         /* Protocol identifier */
	__u8   *fp;
	unsigned long flags;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
	IRDA_ASSERT(skb->len > 2, return;);

	fp = skb->data;

	/*
         *  The next statements may be confusing, but we do this so that
         *  destination LSAP of received frame is source LSAP in our view
         */
	slsap_sel = fp[0] & LSAP_MASK;
	dlsap_sel = fp[1];
	pid       = fp[2];

	if (pid & 0x80) {
		pr_debug("%s(), extension in PID not supp!\n",
			 __func__);
		return;
	}

	/* Check if frame is addressed to the connectionless LSAP */
	if ((slsap_sel != LSAP_CONNLESS) || (dlsap_sel != LSAP_CONNLESS)) {
		pr_debug("%s(), dropping frame!\n", __func__);
		return;
	}

	/* Search the connectionless LSAP */
	spin_lock_irqsave(&irlmp->unconnected_lsaps->hb_spinlock, flags);
	lsap = (struct lsap_cb *) hashbin_get_first(irlmp->unconnected_lsaps);
	while (lsap != NULL) {
		/*
                 *  Check if source LSAP and dest LSAP selectors and PID match.
                 */
		if ((lsap->slsap_sel == slsap_sel) &&
		    (lsap->dlsap_sel == dlsap_sel) &&
		    (lsap->pid == pid))
		{
			break;
		}
		lsap = (struct lsap_cb *) hashbin_get_next(irlmp->unconnected_lsaps);
	}
	spin_unlock_irqrestore(&irlmp->unconnected_lsaps->hb_spinlock, flags);

	if (lsap)
		irlmp_connless_data_indication(lsap, skb);
	else {
		pr_debug("%s(), found no matching LSAP!\n", __func__);
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
200
81.63%
1
14.29%
jean tourrilhes
jean tourrilhes
38
15.51%
3
42.86%
joe perches
joe perches
3
1.22%
1
14.29%
harvey harrison
harvey harrison
3
1.22%
1
14.29%
hideaki yoshifuji
hideaki yoshifuji
1
0.41%
1
14.29%
Total
245
100.00%
7
100.00%

#endif /* CONFIG_IRDA_ULTRA */

/*
 * Function irlmp_link_disconnect_indication (reason, userdata)
 *
 *    IrLAP has disconnected
 *
 */


void irlmp_link_disconnect_indication(struct lap_cb *lap,
				      struct irlap_cb *irlap,
				      LAP_REASON reason,
				      struct sk_buff *skb)
{
	IRDA_ASSERT(lap != NULL, return;);
	IRDA_ASSERT(lap->magic == LMP_LAP_MAGIC, return;);

	lap->reason = reason;
	lap->daddr = DEV_ADDR_ANY;

	/* FIXME: must do something with the skb if any */

	/*
         *  Inform station state machine
         */
	irlmp_do_lap_event(lap, LM_LAP_DISCONNECT_INDICATION, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
56
93.33%
2
50.00%
jean tourrilhes
jean tourrilhes
4
6.67%
2
50.00%
Total
60
100.00%
4
100.00%

/*
 * Function irlmp_link_connect_indication (qos)
 *
 *    Incoming LAP connection!
 *
 */


void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
				   __u32 daddr, struct qos_info *qos,
				   struct sk_buff *skb)
{
	/* Copy QoS settings for this session */
	self->qos = qos;

	/* Update destination device address */
	self->daddr = daddr;
	IRDA_ASSERT(self->saddr == saddr, return;);

	irlmp_do_lap_event(self, LM_LAP_CONNECT_INDICATION, skb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
55
98.21%
2
66.67%
jean tourrilhes
jean tourrilhes
1
1.79%
1
33.33%
Total
56
100.00%
3
100.00%

/*
 * Function irlmp_link_connect_confirm (qos)
 *
 *    LAP connection confirmed!
 *
 */


void irlmp_link_connect_confirm(struct lap_cb *self, struct qos_info *qos,
				struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
	IRDA_ASSERT(qos != NULL, return;);

	/* Don't need use the skb for now */

	/* Copy QoS settings for this session */
	self->qos = qos;

	irlmp_do_lap_event(self, LM_LAP_CONNECT_CONFIRM, NULL);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
53
91.38%
1
33.33%
jean tourrilhes
jean tourrilhes
5
8.62%
2
66.67%
Total
58
100.00%
3
100.00%

/*
 * Function irlmp_link_discovery_indication (self, log)
 *
 *    Device is discovering us
 *
 * It's not an answer to our own discoveries, just another device trying
 * to perform discovery, but we don't want to miss the opportunity
 * to exploit this information, because :
 *      o We may not actively perform discovery (just passive discovery)
 *      o This type of discovery is much more reliable. In some cases, it
 *        seem that less than 50% of our discoveries get an answer, while
 *        we always get ~100% of these.
 *      o Make faster discovery, statistically divide time of discovery
 *        events by 2 (important for the latency aspect and user feel)
 *      o Even is we do active discovery, the other node might not
 *        answer our discoveries (ex: Palm). The Palm will just perform
 *        one active discovery and connect directly to us.
 *
 * However, when both devices discover each other, they might attempt to
 * connect to each other following the discovery event, and it would create
 * collisions on the medium (SNRM battle).
 * The "fix" for that is to disable all connection requests in IrLAP
 * for 100ms after a discovery indication by setting the media_busy flag.
 * Previously, we used to postpone the event which was quite ugly. Now
 * that IrLAP takes care of this problem, just pass the event up...
 *
 * Jean II
 */


void irlmp_link_discovery_indication(struct lap_cb *self,
				     discovery_t *discovery)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);

	/* Add to main log, cleanup */
	irlmp_add_discovery(irlmp->cachelog, discovery);

	/* Just handle it the same way as a discovery confirm,
         * bypass the LM_LAP state machine (see below) */
	irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_PASSIVE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
38
79.17%
2
33.33%
jean tourrilhes
jean tourrilhes
5
10.42%
3
50.00%
linus torvalds
linus torvalds
5
10.42%
1
16.67%
Total
48
100.00%
6
100.00%

/*
 * Function irlmp_link_discovery_confirm (self, log)
 *
 *    Called by IrLAP with a list of discoveries after the discovery
 *    request has been carried out. A NULL log is received if IrLAP
 *    was unable to carry out the discovery request
 *
 */


void irlmp_link_discovery_confirm(struct lap_cb *self, hashbin_t *log)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);

	/* Add to main log, cleanup */
	irlmp_add_discovery_log(irlmp->cachelog, log);

	/* Propagate event to various LSAPs registered for it.
         * We bypass the LM_LAP state machine because
         *      1) We do it regardless of the LM_LAP state
         *      2) It doesn't affect the LM_LAP state
         *      3) Faster, slimer, simpler, ...
         * Jean II */
	irlmp_discovery_confirm(irlmp->cachelog, DISCOVERY_ACTIVE);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
38
79.17%
3
42.86%
jean tourrilhes
jean tourrilhes
5
10.42%
3
42.86%
linus torvalds
linus torvalds
5
10.42%
1
14.29%
Total
48
100.00%
7
100.00%

#ifdef CONFIG_IRDA_CACHE_LAST_LSAP


static inline void irlmp_update_cache(struct lap_cb *lap,
				      struct lsap_cb *lsap)
{
	/* Prevent concurrent read to get garbage */
	lap->cache.valid = FALSE;
	/* Update cache entry */
	lap->cache.dlsap_sel = lsap->dlsap_sel;
	lap->cache.slsap_sel = lsap->slsap_sel;
	lap->cache.lsap = lsap;
	lap->cache.valid = TRUE;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
40
63.49%
2
40.00%
jean tourrilhes
jean tourrilhes
22
34.92%
2
40.00%
steven cole
steven cole
1
1.59%
1
20.00%
Total
63
100.00%
5
100.00%

#endif

/*
 * Function irlmp_find_handle (self, dlsap_sel, slsap_sel, status, queue)
 *
 *    Find handle associated with destination and source LSAP
 *
 * Any IrDA connection (LSAP/TSAP) is uniquely identified by
 * 3 parameters, the local lsap, the remote lsap and the remote address.
 * We may initiate multiple connections to the same remote service
 * (they will have different local lsap), a remote device may initiate
 * multiple connections to the same local service (they will have
 * different remote lsap), or multiple devices may connect to the same
 * service and may use the same remote lsap (and they will have
 * different remote address).
 * So, where is the remote address ? Each LAP connection is made with
 * a single remote device, so imply a specific remote address.
 * Jean II
 */


static struct lsap_cb *irlmp_find_lsap(struct lap_cb *self, __u8 dlsap_sel,
				       __u8 slsap_sel, int status,
				       hashbin_t *queue)
{
	struct lsap_cb *lsap;
	unsigned long flags;

	/*
         *  Optimize for the common case. We assume that the last frame
         *  received is in the same connection as the last one, so check in
         *  cache first to avoid the linear search
         */
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
	if ((self->cache.valid) &&
	    (self->cache.slsap_sel == slsap_sel) &&
	    (self->cache.dlsap_sel == dlsap_sel))
	{
		return self->cache.lsap;
	}
#endif

	spin_lock_irqsave(&queue->hb_spinlock, flags);

	lsap = (struct lsap_cb *) hashbin_get_first(queue);
	while (lsap != NULL) {
		/*
                 *  If this is an incoming connection, then the destination
                 *  LSAP selector may have been specified as LM_ANY so that
                 *  any client can connect. In that case we only need to check
                 *  if the source LSAP (in our view!) match!
                 */
		if ((status == CONNECT_CMD) &&
		    (lsap->slsap_sel == slsap_sel) &&
		    (lsap->dlsap_sel == LSAP_ANY)) {
			/* This is where the dest lsap sel is set on incoming
                         * lsaps */
			lsap->dlsap_sel = dlsap_sel;
			break;
		}
		/*
                 *  Check if source LSAP and dest LSAP selectors match.
                 */
		if ((lsap->slsap_sel == slsap_sel) &&
		    (lsap->dlsap_sel == dlsap_sel))
			break;

		lsap = (struct lsap_cb *) hashbin_get_next(queue);
	}
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
	if(lsap)
		irlmp_update_cache(self, lsap);
#endif
	spin_unlock_irqrestore(&queue->hb_spinlock, flags);

	/* Return what we've found or NULL */
	return lsap;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
157
75.85%
2
33.33%
jean tourrilhes
jean tourrilhes
47
22.71%
2
33.33%
hideaki yoshifuji
hideaki yoshifuji
2
0.97%
1
16.67%
steven cole
steven cole
1
0.48%
1
16.67%
Total
207
100.00%
6
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
pre-git
pre-git
1256
86.50%
8
38.10%
jean tourrilhes
jean tourrilhes
148
10.19%
6
28.57%
joe perches
joe perches
15
1.03%
1
4.76%
linus torvalds
linus torvalds
11
0.76%
2
9.52%
harvey harrison
harvey harrison
11
0.76%
1
4.76%
hideaki yoshifuji
hideaki yoshifuji
8
0.55%
1
4.76%
steven cole
steven cole
2
0.14%
1
4.76%
jan engelhardt
jan engelhardt
1
0.07%
1
4.76%
Total
1452
100.00%
21
100.00%
  
Directory: net/irda

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.