[net-next-2.6.git] / 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) {
		IRDA_DEBUG(4, "%s(), sending expedited data\n", __func__);
		irlap_data_request(self->irlap, skb, TRUE);
	} else
		irlap_data_request(self->irlap, skb, FALSE);
}

/*
 * 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_DEBUG(2, "%s()\n", __func__);

	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);
}

/*
 * 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_DEBUG(4, "%s()\n", __func__);

	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)) {
		IRDA_DEBUG(3, "%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) {
			IRDA_DEBUG(1, "%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) {
		IRDA_DEBUG(2, "IrLMP, Sorry, no LSAP for received frame!\n");
		IRDA_DEBUG(2, "%s(), slsap_sel = %02x, dlsap_sel = %02x\n",
			   __func__, slsap_sel, dlsap_sel);
		if (fp[0] & CONTROL_BIT) {
			IRDA_DEBUG(2, "%s(), received control frame %02x\n",
				   __func__, fp[2]);
		} else {
			IRDA_DEBUG(2, "%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:
			IRDA_DEBUG(4, "%s(), Disconnect indication!\n",
				   __func__);
			irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
					    skb);
			break;
		case ACCESSMODE_CMD:
			IRDA_DEBUG(0, "Access mode cmd not implemented!\n");
			break;
		case ACCESSMODE_CNF:
			IRDA_DEBUG(0, "Access mode cnf not implemented!\n");
			break;
		default:
			IRDA_DEBUG(0, "%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);
	}
}

/*
 * 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_DEBUG(4, "%s()\n", __func__);

	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) {
		IRDA_DEBUG(0, "%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)) {
		IRDA_DEBUG(0, "%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 {
		IRDA_DEBUG(0, "%s(), found no matching LSAP!\n", __func__);
	}
}
#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_DEBUG(2, "%s()\n", __func__);

	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);
}

/*
 * 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)
{
	IRDA_DEBUG(4, "%s()\n", __func__);

	/* 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);
}

/*
 * 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_DEBUG(4, "%s()\n", __func__);

	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);
}

/*
 * 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);
}

/*
 * 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_DEBUG(4, "%s()\n", __func__);

	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);
}

#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;
}
#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;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4 LT	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>
6819bc2e	11	*
1da177e4 LT	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>
6819bc2e YH	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
1da177e4 LT	19	* the License, or (at your option) any later version.
1da177e4 LT	20	*
96de0e25	21	* Neither Dag Brattli nor University of Tromsø admit liability nor
6819bc2e	22	* provide warranty for any of this software. This material is
1da177e4 LT	23	* provided "AS-IS" and at no charge.
	24	*
	25	********************************************************************/
	26
1da177e4 LT	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
6819bc2e	37	static struct lsap_cb irlmp_find_lsap(struct lap_cb self, __u8 dlsap,
1da177e4 LT	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) {
0dc47877	47	IRDA_DEBUG(4, "%s(), sending expedited data\n", __func__);
1da177e4 LT	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,
6819bc2e	59	__u8 opcode, struct sk_buff *skb)
1da177e4 LT	60	{
1da177e4 LT	61	__u8 *frame;
6819bc2e	62
0dc47877	63	IRDA_DEBUG(2, "%s()\n", __func__);
1da177e4 LT	64
	65	IRDA_ASSERT(self != NULL, return;);
	66	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
	67	IRDA_ASSERT(skb != NULL, return;);
6819bc2e	68
1da177e4	69	frame = skb->data;
6819bc2e	70
1da177e4 LT	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	*/
6819bc2e	90	void irlmp_link_data_indication(struct lap_cb self, struct sk_buff skb,
1da177e4 LT	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;
6819bc2e	97
0dc47877	98	IRDA_DEBUG(4, "%s()\n", __func__);
1da177e4 LT	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	/*
6819bc2e	107	* The next statements may be confusing, but we do this so that
1da177e4 LT	108	* destination LSAP of received frame is source LSAP in our view
1da177e4 LT	109	*/
6819bc2e YH	110	slsap_sel = fp[0] & LSAP_MASK;
6819bc2e YH	111	dlsap_sel = fp[1];
1da177e4 LT	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",
0dc47877	120	__func__, slsap_sel, dlsap_sel);
6819bc2e	121
1da177e4 LT	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);
6819bc2e	125
1da177e4 LT	126	/* Maybe LSAP was already connected, so try one more time */
1da177e4 LT	127	if (!lsap) {
0dc47877	128	IRDA_DEBUG(1, "%s(), incoming connection for LSAP already connected\n", __func__);
1da177e4 LT	129	lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
	130	self->lsaps);
	131	}
	132	} else
6819bc2e	133	lsap = irlmp_find_lsap(self, dlsap_sel, slsap_sel, 0,
1da177e4	134	self->lsaps);
6819bc2e	135
1da177e4 LT	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",
0dc47877	139	__func__, slsap_sel, dlsap_sel);
1da177e4 LT	140	if (fp[0] & CONTROL_BIT) {
1da177e4 LT	141	IRDA_DEBUG(2, "%s(), received control frame %02x\n",
0dc47877	142	__func__, fp[2]);
1da177e4	143	} else {
0dc47877	144	IRDA_DEBUG(2, "%s(), received data frame\n", __func__);
1da177e4 LT	145	}
	146	return;
	147	}
	148
6819bc2e YH	149	/*
6819bc2e YH	150	* Check if we received a control frame?
1da177e4 LT	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",
0dc47877	163	__func__);
6819bc2e	164	irlmp_do_lsap_event(lsap, LM_DISCONNECT_INDICATION,
1da177e4 LT	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",
0dc47877	175	__func__, fp[2]);
1da177e4 LT	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);
6819bc2e	184	} else {
1da177e4 LT	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	*
6819bc2e	196	*
1da177e4 LT	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;
6819bc2e	208
0dc47877	209	IRDA_DEBUG(4, "%s()\n", __func__);
1da177e4 LT	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	/*
6819bc2e	218	* The next statements may be confusing, but we do this so that
1da177e4 LT	219	* destination LSAP of received frame is source LSAP in our view
1da177e4 LT	220	*/
6819bc2e	221	slsap_sel = fp[0] & LSAP_MASK;
1da177e4 LT	222	dlsap_sel = fp[1];
1da177e4 LT	223	pid = fp[2];
6819bc2e	224
1da177e4 LT	225	if (pid & 0x80) {
1da177e4 LT	226	IRDA_DEBUG(0, "%s(), extension in PID not supp!\n",
0dc47877	227	__func__);
1da177e4 LT	228	return;
	229	}
	230
	231	/* Check if frame is addressed to the connectionless LSAP */
	232	if ((slsap_sel != LSAP_CONNLESS) \|\| (dlsap_sel != LSAP_CONNLESS)) {
0dc47877	233	IRDA_DEBUG(0, "%s(), dropping frame!\n", __func__);
1da177e4 LT	234	return;
1da177e4 LT	235	}
6819bc2e	236
1da177e4 LT	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	*/
6819bc2e YH	244	if ((lsap->slsap_sel == slsap_sel) &&
	245	(lsap->dlsap_sel == dlsap_sel) &&
	246	(lsap->pid == pid))
	247	{
1da177e4 LT	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 {
0dc47877	257	IRDA_DEBUG(0, "%s(), found no matching LSAP!\n", __func__);
1da177e4 LT	258	}
	259	}
	260	#endif /* CONFIG_IRDA_ULTRA */
	261
	262	/*
	263	* Function irlmp_link_disconnect_indication (reason, userdata)
	264	*
6819bc2e	265	* IrLAP has disconnected
1da177e4 LT	266	*
1da177e4 LT	267	*/
6819bc2e YH	268	void irlmp_link_disconnect_indication(struct lap_cb *lap,
	269	struct irlap_cb *irlap,
	270	LAP_REASON reason,
1da177e4 LT	271	struct sk_buff *skb)
1da177e4 LT	272	{
0dc47877	273	IRDA_DEBUG(2, "%s()\n", __func__);
1da177e4 LT	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
6819bc2e YH	281	/* FIXME: must do something with the skb if any */
6819bc2e YH	282
1da177e4 LT	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	*/
6819bc2e	295	void irlmp_link_connect_indication(struct lap_cb *self, __u32 saddr,
1da177e4	296	__u32 daddr, struct qos_info *qos,
6819bc2e	297	struct sk_buff *skb)
1da177e4	298	{
0dc47877	299	IRDA_DEBUG(4, "%s()\n", __func__);
1da177e4 LT	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	*/
6819bc2e	317	void irlmp_link_connect_confirm(struct lap_cb self, struct qos_info qos,
1da177e4 LT	318	struct sk_buff *skb)
1da177e4 LT	319	{
0dc47877	320	IRDA_DEBUG(4, "%s()\n", __func__);
1da177e4 LT	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	*/
6819bc2e	362	void irlmp_link_discovery_indication(struct lap_cb *self,
1da177e4 LT	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);
6819bc2e	370
1da177e4 LT	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	{
0dc47877	386	IRDA_DEBUG(4, "%s()\n", __func__);
1da177e4 LT	387
	388	IRDA_ASSERT(self != NULL, return;);
	389	IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;);
6819bc2e	390
1da177e4 LT	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
6819bc2e	423	* 3 parameters, the local lsap, the remote lsap and the remote address.
1da177e4 LT	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,
6819bc2e	436	hashbin_t *queue)
1da177e4 LT	437	{
	438	struct lsap_cb *lsap;
	439	unsigned long flags;
6819bc2e YH	440
6819bc2e YH	441	/*
1da177e4 LT	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
6819bc2e YH	447	if ((self->cache.valid) &&
	448	(self->cache.slsap_sel == slsap_sel) &&
	449	(self->cache.dlsap_sel == dlsap_sel))
1da177e4	450	{
a02cec21	451	return self->cache.lsap;
1da177e4 LT	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) {
6819bc2e YH	459	/*
	460	* If this is an incoming connection, then the destination
	461	* LSAP selector may have been specified as LM_ANY so that
1da177e4 LT	462	* any client can connect. In that case we only need to check
	463	* if the source LSAP (in our view!) match!
	464	*/
6819bc2e YH	465	if ((status == CONNECT_CMD) &&
6819bc2e YH	466	(lsap->slsap_sel == slsap_sel) &&
1da177e4 LT	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	*/
6819bc2e YH	476	if ((lsap->slsap_sel == slsap_sel) &&
6819bc2e YH	477	(lsap->dlsap_sel == dlsap_sel))
1da177e4 LT	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	}