[deliverable/linux.git] / net / irda / irlan / irlan_client.c

/*********************************************************************
 *
 * Filename:      irlan_client.c
 * Version:       0.9
 * Description:   IrDA LAN Access Protocol (IrLAN) Client
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Sun Aug 31 20:14:37 1997
 * Modified at:   Tue Dec 14 15:47:02 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 * Sources:       skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
 *                slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
 *                          Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 *
 *     Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
 *     All Rights Reserved.
 *
 *     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/kernel.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>
#include <linux/bitops.h>
#include <net/arp.h>

#include <asm/byteorder.h>

#include <net/irda/irda.h>
#include <net/irda/irttp.h>
#include <net/irda/irlmp.h>
#include <net/irda/irias_object.h>
#include <net/irda/iriap.h>
#include <net/irda/timer.h>

#include <net/irda/irlan_common.h>
#include <net/irda/irlan_event.h>
#include <net/irda/irlan_eth.h>
#include <net/irda/irlan_provider.h>
#include <net/irda/irlan_client.h>

#undef CONFIG_IRLAN_GRATUITOUS_ARP

static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
						    LM_REASON reason,
						    struct sk_buff *);
static int irlan_client_ctrl_data_indication(void *instance, void *sap,
					     struct sk_buff *skb);
static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
					      struct qos_info *qos,
					      __u32 max_sdu_size,
					      __u8 max_header_size,
					      struct sk_buff *);
static void irlan_check_response_param(struct irlan_cb *self, char *param,
				       char *value, int val_len);
static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);

static void irlan_client_kick_timer_expired(void *data)
{
	struct irlan_cb *self = (struct irlan_cb *) data;

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

	/*
	 * If we are in peer mode, the client may not have got the discovery
	 * indication it needs to make progress. If the client is still in
	 * IDLE state, we must kick it to, but only if the provider is not IDLE
	 */
	if ((self->provider.access_type == ACCESS_PEER) &&
	    (self->client.state == IRLAN_IDLE) &&
	    (self->provider.state != IRLAN_IDLE)) {
		irlan_client_wakeup(self, self->saddr, self->daddr);
	}
}

static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout)
{
	irda_start_timer(&self->client.kick_timer, timeout, (void *) self,
			 irlan_client_kick_timer_expired);
}

/*
 * Function irlan_client_wakeup (self, saddr, daddr)
 *
 *    Wake up client
 *
 */
void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/*
	 * Check if we are already awake, or if we are a provider in direct
	 * mode (in that case we must leave the client idle
	 */
	if ((self->client.state != IRLAN_IDLE) ||
	    (self->provider.access_type == ACCESS_DIRECT))
	{
		pr_debug("%s(), already awake!\n", __func__);
			return;
	}

	/* Addresses may have changed! */
	self->saddr = saddr;
	self->daddr = daddr;

	if (self->disconnect_reason == LM_USER_REQUEST) {
		pr_debug("%s(), still stopped by user\n", __func__);
			return;
	}

	/* Open TSAPs */
	irlan_client_open_ctrl_tsap(self);
	irlan_open_data_tsap(self);

	irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL);

	/* Start kick timer */
	irlan_client_start_kick_timer(self, 2*HZ);
}

/*
 * Function irlan_discovery_indication (daddr)
 *
 *    Remote device with IrLAN server support discovered
 *
 */
void irlan_client_discovery_indication(discinfo_t *discovery,
				       DISCOVERY_MODE mode,
				       void *priv)
{
	struct irlan_cb *self;
	__u32 saddr, daddr;

	IRDA_ASSERT(discovery != NULL, return;);

	/*
	 * I didn't check it, but I bet that IrLAN suffer from the same
	 * deficiency as IrComm and doesn't handle two instances
	 * simultaneously connecting to each other.
	 * Same workaround, drop passive discoveries.
	 * Jean II */
	if(mode == DISCOVERY_PASSIVE)
		return;

	saddr = discovery->saddr;
	daddr = discovery->daddr;

	/* Find instance */
	rcu_read_lock();
	self = irlan_get_any();
	if (self) {
		IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;);

		pr_debug("%s(), Found instance (%08x)!\n", __func__ ,
			 daddr);

		irlan_client_wakeup(self, saddr, daddr);
	}
IRDA_ASSERT_LABEL(out:)
	rcu_read_unlock();
}

/*
 * Function irlan_client_data_indication (handle, skb)
 *
 *    This function gets the data that is received on the control channel
 *
 */
static int irlan_client_ctrl_data_indication(void *instance, void *sap,
					     struct sk_buff *skb)
{
	struct irlan_cb *self;

	self = instance;

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

	irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb);

	/* Ready for a new command */
	pr_debug("%s(), clearing tx_busy\n", __func__);
	self->client.tx_busy = FALSE;

	/* Check if we have some queued commands waiting to be sent */
	irlan_run_ctrl_tx_queue(self);

	return 0;
}

static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
						    LM_REASON reason,
						    struct sk_buff *userdata)
{
	struct irlan_cb *self;
	struct tsap_cb *tsap;
	struct sk_buff *skb;

	pr_debug("%s(), reason=%d\n", __func__ , reason);

	self = instance;
	tsap = sap;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	IRDA_ASSERT(tsap != NULL, return;);
	IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);

	IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;);

	/* Remove frames queued on the control channel */
	while ((skb = skb_dequeue(&self->client.txq)) != NULL) {
		dev_kfree_skb(skb);
	}
	self->client.tx_busy = FALSE;

	irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
}

/*
 * Function irlan_client_open_tsaps (self)
 *
 *    Initialize callbacks and open IrTTP TSAPs
 *
 */
static void irlan_client_open_ctrl_tsap(struct irlan_cb *self)
{
	struct tsap_cb *tsap;
	notify_t notify;

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

	/* Check if already open */
	if (self->client.tsap_ctrl)
		return;

	irda_notify_init(&notify);

	/* Set up callbacks */
	notify.data_indication       = irlan_client_ctrl_data_indication;
	notify.connect_confirm       = irlan_client_ctrl_connect_confirm;
	notify.disconnect_indication = irlan_client_ctrl_disconnect_indication;
	notify.instance = self;
	strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name));

	tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, &notify);
	if (!tsap) {
		pr_debug("%s(), Got no tsap!\n", __func__);
		return;
	}
	self->client.tsap_ctrl = tsap;
}

/*
 * Function irlan_client_connect_confirm (handle, skb)
 *
 *    Connection to peer IrLAN laye confirmed
 *
 */
static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
					      struct qos_info *qos,
					      __u32 max_sdu_size,
					      __u8 max_header_size,
					      struct sk_buff *skb)
{
	struct irlan_cb *self;

	self = instance;

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

	self->client.max_sdu_size = max_sdu_size;
	self->client.max_header_size = max_header_size;

	/* TODO: we could set the MTU depending on the max_sdu_size */

	irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL);
}

/*
 * Function print_ret_code (code)
 *
 *    Print return code of request to peer IrLAN layer.
 *
 */
static void print_ret_code(__u8 code)
{
	switch(code) {
	case 0:
		printk(KERN_INFO "Success\n");
		break;
	case 1:
		net_warn_ratelimited("IrLAN: Insufficient resources\n");
		break;
	case 2:
		net_warn_ratelimited("IrLAN: Invalid command format\n");
		break;
	case 3:
		net_warn_ratelimited("IrLAN: Command not supported\n");
		break;
	case 4:
		net_warn_ratelimited("IrLAN: Parameter not supported\n");
		break;
	case 5:
		net_warn_ratelimited("IrLAN: Value not supported\n");
		break;
	case 6:
		net_warn_ratelimited("IrLAN: Not open\n");
		break;
	case 7:
		net_warn_ratelimited("IrLAN: Authentication required\n");
		break;
	case 8:
		net_warn_ratelimited("IrLAN: Invalid password\n");
		break;
	case 9:
		net_warn_ratelimited("IrLAN: Protocol error\n");
		break;
	case 255:
		net_warn_ratelimited("IrLAN: Asynchronous status\n");
		break;
	}
}

/*
 * Function irlan_client_parse_response (self, skb)
 *
 *    Extract all parameters from received buffer, then feed them to
 *    check_params for parsing
 */
void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb)
{
	__u8 *frame;
	__u8 *ptr;
	int count;
	int ret;
	__u16 val_len;
	int i;
	char *name;
	char *value;

	IRDA_ASSERT(skb != NULL, return;);

	pr_debug("%s() skb->len=%d\n", __func__ , (int)skb->len);

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

	if (!skb) {
		net_err_ratelimited("%s(), Got NULL skb!\n", __func__);
		return;
	}
	frame = skb->data;

	/*
	 *  Check return code and print it if not success
	 */
	if (frame[0]) {
		print_ret_code(frame[0]);
		return;
	}

	name = kmalloc(255, GFP_ATOMIC);
	if (!name)
		return;
	value = kmalloc(1016, GFP_ATOMIC);
	if (!value) {
		kfree(name);
		return;
	}

	/* How many parameters? */
	count = frame[1];

	pr_debug("%s(), got %d parameters\n", __func__ , count);

	ptr = frame+2;

	/* For all parameters */
	for (i=0; i<count;i++) {
		ret = irlan_extract_param(ptr, name, value, &val_len);
		if (ret < 0) {
			pr_debug("%s(), IrLAN, Error!\n", __func__);
			break;
		}
		ptr += ret;
		irlan_check_response_param(self, name, value, val_len);
	}
	/* Cleanup */
	kfree(name);
	kfree(value);
}

/*
 * Function irlan_check_response_param (self, param, value, val_len)
 *
 *     Check which parameter is received and update local variables
 *
 */
static void irlan_check_response_param(struct irlan_cb *self, char *param,
				       char *value, int val_len)
{
	__u16 tmp_cpu; /* Temporary value in host order */
	__u8 *bytes;
	int i;

	pr_debug("%s(), parm=%s\n", __func__ , param);

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

	/* Media type */
	if (strcmp(param, "MEDIA") == 0) {
		if (strcmp(value, "802.3") == 0)
			self->media = MEDIA_802_3;
		else
			self->media = MEDIA_802_5;
		return;
	}
	if (strcmp(param, "FILTER_TYPE") == 0) {
		if (strcmp(value, "DIRECTED") == 0)
			self->client.filter_type |= IRLAN_DIRECTED;
		else if (strcmp(value, "FUNCTIONAL") == 0)
			self->client.filter_type |= IRLAN_FUNCTIONAL;
		else if (strcmp(value, "GROUP") == 0)
			self->client.filter_type |= IRLAN_GROUP;
		else if (strcmp(value, "MAC_FRAME") == 0)
			self->client.filter_type |= IRLAN_MAC_FRAME;
		else if (strcmp(value, "MULTICAST") == 0)
			self->client.filter_type |= IRLAN_MULTICAST;
		else if (strcmp(value, "BROADCAST") == 0)
			self->client.filter_type |= IRLAN_BROADCAST;
		else if (strcmp(value, "IPX_SOCKET") == 0)
			self->client.filter_type |= IRLAN_IPX_SOCKET;

	}
	if (strcmp(param, "ACCESS_TYPE") == 0) {
		if (strcmp(value, "DIRECT") == 0)
			self->client.access_type = ACCESS_DIRECT;
		else if (strcmp(value, "PEER") == 0)
			self->client.access_type = ACCESS_PEER;
		else if (strcmp(value, "HOSTED") == 0)
			self->client.access_type = ACCESS_HOSTED;
		else {
			pr_debug("%s(), unknown access type!\n", __func__);
		}
	}
	/* IRLAN version */
	if (strcmp(param, "IRLAN_VER") == 0) {
		pr_debug("IrLAN version %d.%d\n", (__u8)value[0],
			 (__u8)value[1]);

		self->version[0] = value[0];
		self->version[1] = value[1];
		return;
	}
	/* Which remote TSAP to use for data channel */
	if (strcmp(param, "DATA_CHAN") == 0) {
		self->dtsap_sel_data = value[0];
		pr_debug("Data TSAP = %02x\n", self->dtsap_sel_data);
		return;
	}
	if (strcmp(param, "CON_ARB") == 0) {
		memcpy(&tmp_cpu, value, 2); /* Align value */
		le16_to_cpus(&tmp_cpu);     /* Convert to host order */
		self->client.recv_arb_val = tmp_cpu;
		pr_debug("%s(), receive arb val=%d\n", __func__ ,
			 self->client.recv_arb_val);
	}
	if (strcmp(param, "MAX_FRAME") == 0) {
		memcpy(&tmp_cpu, value, 2); /* Align value */
		le16_to_cpus(&tmp_cpu);     /* Convert to host order */
		self->client.max_frame = tmp_cpu;
		pr_debug("%s(), max frame=%d\n", __func__ ,
			 self->client.max_frame);
	}

	/* RECONNECT_KEY, in case the link goes down! */
	if (strcmp(param, "RECONNECT_KEY") == 0) {
		pr_debug("Got reconnect key: ");
		/* for (i = 0; i < val_len; i++) */
/* 			printk("%02x", value[i]); */
		memcpy(self->client.reconnect_key, value, val_len);
		self->client.key_len = val_len;
		pr_debug("\n");
	}
	/* FILTER_ENTRY, have we got an ethernet address? */
	if (strcmp(param, "FILTER_ENTRY") == 0) {
		bytes = value;
		pr_debug("Ethernet address = %pM\n", bytes);
		for (i = 0; i < 6; i++)
			self->dev->dev_addr[i] = bytes[i];
	}
}

/*
 * Function irlan_client_get_value_confirm (obj_id, value)
 *
 *    Got results from remote LM-IAS
 *
 */
void irlan_client_get_value_confirm(int result, __u16 obj_id,
				    struct ias_value *value, void *priv)
{
	struct irlan_cb *self;

	IRDA_ASSERT(priv != NULL, return;);

	self = priv;
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/* We probably don't need to make any more queries */
	iriap_close(self->client.iriap);
	self->client.iriap = NULL;

	/* Check if request succeeded */
	if (result != IAS_SUCCESS) {
		pr_debug("%s(), got NULL value!\n", __func__);
		irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL,
				      NULL);
		return;
	}

	switch (value->type) {
	case IAS_INTEGER:
		self->dtsap_sel_ctrl = value->t.integer;

		if (value->t.integer != -1) {
			irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL,
					      NULL);
			return;
		}
		irias_delete_value(value);
		break;
	default:
		pr_debug("%s(), unknown type!\n", __func__);
		break;
	}
	irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL);
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4 LT	3	* Filename: irlan_client.c
	4	* Version: 0.9
	5	* Description: IrDA LAN Access Protocol (IrLAN) Client
	6	* Status: Experimental.
	7	* Author: Dag Brattli <dagb@cs.uit.no>
	8	* Created at: Sun Aug 31 20:14:37 1997
	9	* Modified at: Tue Dec 14 15:47:02 1999
	10	* Modified by: Dag Brattli <dagb@cs.uit.no>
	11	* Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
	12	* slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
	13	* Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
6819bc2e YH	14	*
6819bc2e YH	15	* Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
1da177e4	16	* All Rights Reserved.
6819bc2e YH	17	*
	18	* This program is free software; you can redistribute it and/or
	19	* modify it under the terms of the GNU General Public License as
	20	* published by the Free Software Foundation; either version 2 of
1da177e4 LT	21	* the License, or (at your option) any later version.
1da177e4 LT	22	*
96de0e25	23	* Neither Dag Brattli nor University of Tromsø admit liability nor
6819bc2e	24	* provide warranty for any of this software. This material is
1da177e4 LT	25	* provided "AS-IS" and at no charge.
	26	*
	27	********************************************************************/
	28
	29	#include <linux/kernel.h>
	30	#include <linux/string.h>
5a0e3ad6	31	#include <linux/slab.h>
1da177e4 LT	32	#include <linux/errno.h>
	33	#include <linux/init.h>
	34	#include <linux/netdevice.h>
	35	#include <linux/etherdevice.h>
	36	#include <linux/if_arp.h>
	37	#include <linux/bitops.h>
	38	#include <net/arp.h>
	39
1da177e4 LT	40	#include <asm/byteorder.h>
	41
	42	#include <net/irda/irda.h>
	43	#include <net/irda/irttp.h>
	44	#include <net/irda/irlmp.h>
	45	#include <net/irda/irias_object.h>
	46	#include <net/irda/iriap.h>
	47	#include <net/irda/timer.h>
	48
	49	#include <net/irda/irlan_common.h>
	50	#include <net/irda/irlan_event.h>
	51	#include <net/irda/irlan_eth.h>
	52	#include <net/irda/irlan_provider.h>
	53	#include <net/irda/irlan_client.h>
	54
	55	#undef CONFIG_IRLAN_GRATUITOUS_ARP
	56
6819bc2e YH	57	static void irlan_client_ctrl_disconnect_indication(void instance, void sap,
6819bc2e YH	58	LM_REASON reason,
1da177e4	59	struct sk_buff *);
6819bc2e	60	static int irlan_client_ctrl_data_indication(void instance, void sap,
1da177e4	61	struct sk_buff *skb);
6819bc2e YH	62	static void irlan_client_ctrl_connect_confirm(void instance, void sap,
6819bc2e YH	63	struct qos_info *qos,
1da177e4 LT	64	__u32 max_sdu_size,
	65	__u8 max_header_size,
	66	struct sk_buff *);
6819bc2e	67	static void irlan_check_response_param(struct irlan_cb self, char param,
1da177e4 LT	68	char *value, int val_len);
	69	static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);
	70
	71	static void irlan_client_kick_timer_expired(void *data)
	72	{
	73	struct irlan_cb self = (struct irlan_cb ) data;
6819bc2e	74
1da177e4 LT	75	IRDA_ASSERT(self != NULL, return;);
1da177e4 LT	76	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
6819bc2e YH	77
6819bc2e YH	78	/*
1da177e4	79	* If we are in peer mode, the client may not have got the discovery
6819bc2e	80	* indication it needs to make progress. If the client is still in
1da177e4	81	* IDLE state, we must kick it to, but only if the provider is not IDLE
6819bc2e YH	82	*/
6819bc2e YH	83	if ((self->provider.access_type == ACCESS_PEER) &&
1da177e4 LT	84	(self->client.state == IRLAN_IDLE) &&
	85	(self->provider.state != IRLAN_IDLE)) {
	86	irlan_client_wakeup(self, self->saddr, self->daddr);
	87	}
	88	}
	89
	90	static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout)
	91	{
6819bc2e	92	irda_start_timer(&self->client.kick_timer, timeout, (void *) self,
1da177e4 LT	93	irlan_client_kick_timer_expired);
	94	}
	95
	96	/*
	97	* Function irlan_client_wakeup (self, saddr, daddr)
	98	*
	99	* Wake up client
	100	*
	101	*/
	102	void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr)
	103	{
1da177e4 LT	104	IRDA_ASSERT(self != NULL, return;);
	105	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	106
6819bc2e	107	/*
1da177e4 LT	108	* Check if we are already awake, or if we are a provider in direct
	109	* mode (in that case we must leave the client idle
	110	*/
6819bc2e	111	if ((self->client.state != IRLAN_IDLE) \|\|
1da177e4 LT	112	(self->provider.access_type == ACCESS_DIRECT))
1da177e4 LT	113	{
955a9d20	114	pr_debug("%s(), already awake!\n", __func__);
1da177e4 LT	115	return;
	116	}
	117
	118	/* Addresses may have changed! */
	119	self->saddr = saddr;
	120	self->daddr = daddr;
	121
	122	if (self->disconnect_reason == LM_USER_REQUEST) {
955a9d20	123	pr_debug("%s(), still stopped by user\n", __func__);
1da177e4 LT	124	return;
	125	}
	126
	127	/* Open TSAPs */
	128	irlan_client_open_ctrl_tsap(self);
	129	irlan_open_data_tsap(self);
	130
	131	irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL);
6819bc2e	132
1da177e4 LT	133	/* Start kick timer */
	134	irlan_client_start_kick_timer(self, 2*HZ);
	135	}
	136
	137	/*
	138	* Function irlan_discovery_indication (daddr)
	139	*
	140	* Remote device with IrLAN server support discovered
	141	*
	142	*/
	143	void irlan_client_discovery_indication(discinfo_t *discovery,
	144	DISCOVERY_MODE mode,
6819bc2e	145	void *priv)
1da177e4 LT	146	{
	147	struct irlan_cb *self;
	148	__u32 saddr, daddr;
6819bc2e	149
1da177e4 LT	150	IRDA_ASSERT(discovery != NULL, return;);
	151
	152	/*
	153	* I didn't check it, but I bet that IrLAN suffer from the same
	154	* deficiency as IrComm and doesn't handle two instances
	155	* simultaneously connecting to each other.
	156	* Same workaround, drop passive discoveries.
	157	* Jean II */
	158	if(mode == DISCOVERY_PASSIVE)
	159	return;
	160
	161	saddr = discovery->saddr;
	162	daddr = discovery->daddr;
	163
	164	/* Find instance */
	165	rcu_read_lock();
	166	self = irlan_get_any();
	167	if (self) {
1bc17311	168	IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;);
1da177e4	169
955a9d20 JP	170	pr_debug("%s(), Found instance (%08x)!\n", __func__ ,
955a9d20 JP	171	daddr);
6819bc2e	172
1da177e4 LT	173	irlan_client_wakeup(self, saddr, daddr);
1da177e4 LT	174	}
1bc17311	175	IRDA_ASSERT_LABEL(out:)
1da177e4 LT	176	rcu_read_unlock();
1da177e4 LT	177	}
6819bc2e	178
1da177e4 LT	179	/*
	180	* Function irlan_client_data_indication (handle, skb)
	181	*
	182	* This function gets the data that is received on the control channel
	183	*
	184	*/
6819bc2e	185	static int irlan_client_ctrl_data_indication(void instance, void sap,
1da177e4 LT	186	struct sk_buff *skb)
	187	{
	188	struct irlan_cb *self;
6819bc2e	189
ea110733	190	self = instance;
6819bc2e	191
1da177e4 LT	192	IRDA_ASSERT(self != NULL, return -1;);
	193	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
	194	IRDA_ASSERT(skb != NULL, return -1;);
1da177e4	195
6819bc2e YH	196	irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb);
	197
	198	/* Ready for a new command */
955a9d20	199	pr_debug("%s(), clearing tx_busy\n", __func__);
1da177e4 LT	200	self->client.tx_busy = FALSE;
	201
	202	/* Check if we have some queued commands waiting to be sent */
	203	irlan_run_ctrl_tx_queue(self);
	204
	205	return 0;
	206	}
	207
6819bc2e YH	208	static void irlan_client_ctrl_disconnect_indication(void instance, void sap,
	209	LM_REASON reason,
	210	struct sk_buff *userdata)
1da177e4 LT	211	{
	212	struct irlan_cb *self;
	213	struct tsap_cb *tsap;
	214	struct sk_buff *skb;
	215
955a9d20	216	pr_debug("%s(), reason=%d\n", __func__ , reason);
6819bc2e	217
ea110733 JP	218	self = instance;
ea110733 JP	219	tsap = sap;
1da177e4 LT	220
1da177e4 LT	221	IRDA_ASSERT(self != NULL, return;);
6819bc2e	222	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
1da177e4 LT	223	IRDA_ASSERT(tsap != NULL, return;);
1da177e4 LT	224	IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
6819bc2e	225
1da177e4 LT	226	IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;);
1da177e4 LT	227
6819bc2e	228	/* Remove frames queued on the control channel */
1da177e4 LT	229	while ((skb = skb_dequeue(&self->client.txq)) != NULL) {
	230	dev_kfree_skb(skb);
	231	}
	232	self->client.tx_busy = FALSE;
	233
	234	irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
	235	}
	236
	237	/*
	238	* Function irlan_client_open_tsaps (self)
	239	*
	240	* Initialize callbacks and open IrTTP TSAPs
	241	*
	242	*/
	243	static void irlan_client_open_ctrl_tsap(struct irlan_cb *self)
	244	{
	245	struct tsap_cb *tsap;
	246	notify_t notify;
	247
1da177e4 LT	248	IRDA_ASSERT(self != NULL, return;);
	249	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	250
	251	/* Check if already open */
	252	if (self->client.tsap_ctrl)
	253	return;
	254
	255	irda_notify_init(&notify);
	256
	257	/* Set up callbacks */
	258	notify.data_indication = irlan_client_ctrl_data_indication;
	259	notify.connect_confirm = irlan_client_ctrl_connect_confirm;
	260	notify.disconnect_indication = irlan_client_ctrl_disconnect_indication;
	261	notify.instance = self;
	262	strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name));
6819bc2e	263
1da177e4 LT	264	tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, &notify);
1da177e4 LT	265	if (!tsap) {
955a9d20	266	pr_debug("%s(), Got no tsap!\n", __func__);
1da177e4 LT	267	return;
	268	}
	269	self->client.tsap_ctrl = tsap;
	270	}
	271
	272	/*
	273	* Function irlan_client_connect_confirm (handle, skb)
	274	*
	275	* Connection to peer IrLAN laye confirmed
	276	*
	277	*/
6819bc2e YH	278	static void irlan_client_ctrl_connect_confirm(void instance, void sap,
6819bc2e YH	279	struct qos_info *qos,
1da177e4 LT	280	__u32 max_sdu_size,
1da177e4 LT	281	__u8 max_header_size,
6819bc2e	282	struct sk_buff *skb)
1da177e4 LT	283	{
	284	struct irlan_cb *self;
	285
ea110733	286	self = instance;
1da177e4 LT	287
	288	IRDA_ASSERT(self != NULL, return;);
	289	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	290
	291	self->client.max_sdu_size = max_sdu_size;
	292	self->client.max_header_size = max_header_size;
	293
	294	/* TODO: we could set the MTU depending on the max_sdu_size */
	295
	296	irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL);
	297	}
	298
	299	/*
	300	* Function print_ret_code (code)
	301	*
	302	* Print return code of request to peer IrLAN layer.
	303	*
	304	*/
6819bc2e	305	static void print_ret_code(__u8 code)
1da177e4 LT	306	{
	307	switch(code) {
	308	case 0:
	309	printk(KERN_INFO "Success\n");
	310	break;
	311	case 1:
6c91023d	312	net_warn_ratelimited("IrLAN: Insufficient resources\n");
1da177e4 LT	313	break;
1da177e4 LT	314	case 2:
6c91023d	315	net_warn_ratelimited("IrLAN: Invalid command format\n");
1da177e4 LT	316	break;
1da177e4 LT	317	case 3:
6c91023d	318	net_warn_ratelimited("IrLAN: Command not supported\n");
1da177e4 LT	319	break;
1da177e4 LT	320	case 4:
6c91023d	321	net_warn_ratelimited("IrLAN: Parameter not supported\n");
1da177e4 LT	322	break;
1da177e4 LT	323	case 5:
6c91023d	324	net_warn_ratelimited("IrLAN: Value not supported\n");
1da177e4 LT	325	break;
1da177e4 LT	326	case 6:
6c91023d	327	net_warn_ratelimited("IrLAN: Not open\n");
1da177e4 LT	328	break;
1da177e4 LT	329	case 7:
6c91023d	330	net_warn_ratelimited("IrLAN: Authentication required\n");
1da177e4 LT	331	break;
1da177e4 LT	332	case 8:
6c91023d	333	net_warn_ratelimited("IrLAN: Invalid password\n");
1da177e4 LT	334	break;
1da177e4 LT	335	case 9:
6c91023d	336	net_warn_ratelimited("IrLAN: Protocol error\n");
1da177e4 LT	337	break;
1da177e4 LT	338	case 255:
6c91023d	339	net_warn_ratelimited("IrLAN: Asynchronous status\n");
1da177e4 LT	340	break;
	341	}
	342	}
	343
	344	/*
	345	* Function irlan_client_parse_response (self, skb)
	346	*
6819bc2e	347	* Extract all parameters from received buffer, then feed them to
1da177e4 LT	348	* check_params for parsing
	349	*/
	350	void irlan_client_parse_response(struct irlan_cb self, struct sk_buff skb)
	351	{
	352	__u8 *frame;
	353	__u8 *ptr;
	354	int count;
	355	int ret;
	356	__u16 val_len;
	357	int i;
6819bc2e YH	358	char *name;
	359	char *value;
	360
	361	IRDA_ASSERT(skb != NULL, return;);
1da177e4	362
955a9d20	363	pr_debug("%s() skb->len=%d\n", __func__ , (int)skb->len);
6819bc2e	364
1da177e4 LT	365	IRDA_ASSERT(self != NULL, return;);
1da177e4 LT	366	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
6819bc2e	367
1da177e4	368	if (!skb) {
6c91023d	369	net_err_ratelimited("%s(), Got NULL skb!\n", __func__);
1da177e4 LT	370	return;
	371	}
	372	frame = skb->data;
6819bc2e YH	373
	374	/*
	375	* Check return code and print it if not success
1da177e4 LT	376	*/
	377	if (frame[0]) {
	378	print_ret_code(frame[0]);
	379	return;
	380	}
6819bc2e	381
1da177e4 LT	382	name = kmalloc(255, GFP_ATOMIC);
	383	if (!name)
	384	return;
	385	value = kmalloc(1016, GFP_ATOMIC);
	386	if (!value) {
	387	kfree(name);
	388	return;
	389	}
	390
	391	/* How many parameters? */
	392	count = frame[1];
	393
955a9d20	394	pr_debug("%s(), got %d parameters\n", __func__ , count);
6819bc2e	395
1da177e4 LT	396	ptr = frame+2;
	397
	398	/* For all parameters */
6819bc2e	399	for (i=0; i<count;i++) {
1da177e4 LT	400	ret = irlan_extract_param(ptr, name, value, &val_len);
1da177e4 LT	401	if (ret < 0) {
955a9d20	402	pr_debug("%s(), IrLAN, Error!\n", __func__);
1da177e4 LT	403	break;
	404	}
	405	ptr += ret;
	406	irlan_check_response_param(self, name, value, val_len);
6819bc2e	407	}
1da177e4 LT	408	/* Cleanup */
	409	kfree(name);
	410	kfree(value);
	411	}
	412
	413	/*
	414	* Function irlan_check_response_param (self, param, value, val_len)
	415	*
	416	* Check which parameter is received and update local variables
	417	*
	418	*/
6819bc2e YH	419	static void irlan_check_response_param(struct irlan_cb self, char param,
6819bc2e YH	420	char *value, int val_len)
1da177e4 LT	421	{
	422	__u16 tmp_cpu; /* Temporary value in host order */
	423	__u8 *bytes;
	424	int i;
	425
955a9d20	426	pr_debug("%s(), parm=%s\n", __func__ , param);
1da177e4 LT	427
	428	IRDA_ASSERT(self != NULL, return;);
	429	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	430
	431	/* Media type */
	432	if (strcmp(param, "MEDIA") == 0) {
	433	if (strcmp(value, "802.3") == 0)
	434	self->media = MEDIA_802_3;
	435	else
	436	self->media = MEDIA_802_5;
	437	return;
	438	}
	439	if (strcmp(param, "FILTER_TYPE") == 0) {
	440	if (strcmp(value, "DIRECTED") == 0)
	441	self->client.filter_type \|= IRLAN_DIRECTED;
	442	else if (strcmp(value, "FUNCTIONAL") == 0)
	443	self->client.filter_type \|= IRLAN_FUNCTIONAL;
	444	else if (strcmp(value, "GROUP") == 0)
	445	self->client.filter_type \|= IRLAN_GROUP;
	446	else if (strcmp(value, "MAC_FRAME") == 0)
	447	self->client.filter_type \|= IRLAN_MAC_FRAME;
	448	else if (strcmp(value, "MULTICAST") == 0)
	449	self->client.filter_type \|= IRLAN_MULTICAST;
	450	else if (strcmp(value, "BROADCAST") == 0)
	451	self->client.filter_type \|= IRLAN_BROADCAST;
	452	else if (strcmp(value, "IPX_SOCKET") == 0)
	453	self->client.filter_type \|= IRLAN_IPX_SOCKET;
6819bc2e	454
1da177e4 LT	455	}
	456	if (strcmp(param, "ACCESS_TYPE") == 0) {
	457	if (strcmp(value, "DIRECT") == 0)
	458	self->client.access_type = ACCESS_DIRECT;
	459	else if (strcmp(value, "PEER") == 0)
	460	self->client.access_type = ACCESS_PEER;
	461	else if (strcmp(value, "HOSTED") == 0)
	462	self->client.access_type = ACCESS_HOSTED;
	463	else {
955a9d20	464	pr_debug("%s(), unknown access type!\n", __func__);
1da177e4 LT	465	}
	466	}
	467	/* IRLAN version */
	468	if (strcmp(param, "IRLAN_VER") == 0) {
955a9d20 JP	469	pr_debug("IrLAN version %d.%d\n", (__u8)value[0],
955a9d20 JP	470	(__u8)value[1]);
1da177e4 LT	471
	472	self->version[0] = value[0];
	473	self->version[1] = value[1];
	474	return;
	475	}
	476	/* Which remote TSAP to use for data channel */
	477	if (strcmp(param, "DATA_CHAN") == 0) {
	478	self->dtsap_sel_data = value[0];
955a9d20	479	pr_debug("Data TSAP = %02x\n", self->dtsap_sel_data);
1da177e4 LT	480	return;
	481	}
	482	if (strcmp(param, "CON_ARB") == 0) {
	483	memcpy(&tmp_cpu, value, 2); /* Align value */
	484	le16_to_cpus(&tmp_cpu); /* Convert to host order */
	485	self->client.recv_arb_val = tmp_cpu;
955a9d20 JP	486	pr_debug("%s(), receive arb val=%d\n", __func__ ,
955a9d20 JP	487	self->client.recv_arb_val);
1da177e4 LT	488	}
	489	if (strcmp(param, "MAX_FRAME") == 0) {
	490	memcpy(&tmp_cpu, value, 2); /* Align value */
	491	le16_to_cpus(&tmp_cpu); /* Convert to host order */
	492	self->client.max_frame = tmp_cpu;
955a9d20 JP	493	pr_debug("%s(), max frame=%d\n", __func__ ,
955a9d20 JP	494	self->client.max_frame);
1da177e4	495	}
6819bc2e	496
1da177e4 LT	497	/* RECONNECT_KEY, in case the link goes down! */
1da177e4 LT	498	if (strcmp(param, "RECONNECT_KEY") == 0) {
955a9d20	499	pr_debug("Got reconnect key: ");
1da177e4 LT	500	/* for (i = 0; i < val_len; i++) */
	501	/* printk("%02x", value[i]); */
	502	memcpy(self->client.reconnect_key, value, val_len);
	503	self->client.key_len = val_len;
955a9d20	504	pr_debug("\n");
1da177e4 LT	505	}
	506	/* FILTER_ENTRY, have we got an ethernet address? */
	507	if (strcmp(param, "FILTER_ENTRY") == 0) {
	508	bytes = value;
955a9d20	509	pr_debug("Ethernet address = %pM\n", bytes);
6819bc2e	510	for (i = 0; i < 6; i++)
1da177e4 LT	511	self->dev->dev_addr[i] = bytes[i];
	512	}
	513	}
	514
	515	/*
	516	* Function irlan_client_get_value_confirm (obj_id, value)
	517	*
	518	* Got results from remote LM-IAS
	519	*
	520	*/
6819bc2e YH	521	void irlan_client_get_value_confirm(int result, __u16 obj_id,
6819bc2e YH	522	struct ias_value value, void priv)
1da177e4 LT	523	{
1da177e4 LT	524	struct irlan_cb *self;
6819bc2e	525
1da177e4 LT	526	IRDA_ASSERT(priv != NULL, return;);
1da177e4 LT	527
ea110733	528	self = priv;
1da177e4 LT	529	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	530
	531	/* We probably don't need to make any more queries */
	532	iriap_close(self->client.iriap);
	533	self->client.iriap = NULL;
	534
	535	/* Check if request succeeded */
	536	if (result != IAS_SUCCESS) {
955a9d20	537	pr_debug("%s(), got NULL value!\n", __func__);
6819bc2e	538	irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL,
1da177e4 LT	539	NULL);
	540	return;
	541	}
	542
	543	switch (value->type) {
	544	case IAS_INTEGER:
	545	self->dtsap_sel_ctrl = value->t.integer;
	546
	547	if (value->t.integer != -1) {
	548	irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL,
	549	NULL);
	550	return;
	551	}
	552	irias_delete_value(value);
	553	break;
	554	default:
955a9d20	555	pr_debug("%s(), unknown type!\n", __func__);
1da177e4 LT	556	break;
	557	}
	558	irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL);
	559	}