[linux-2.6-block.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/system.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_DEBUG(2, "%s()\n", __func__ );

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

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

	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))
	{
			IRDA_DEBUG(0, "%s(), already awake!\n", __func__ );
			return;
	}

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

	if (self->disconnect_reason == LM_USER_REQUEST) {
			IRDA_DEBUG(0, "%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_DEBUG(1, "%s()\n", __func__ );

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

		IRDA_DEBUG(1, "%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;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	self = (struct irlan_cb *) 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 */
	IRDA_DEBUG(2, "%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;

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

	self = (struct irlan_cb *) instance;
	tsap = (struct tsap_cb *) 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_DEBUG(4, "%s()\n", __func__ );

	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) {
		IRDA_DEBUG(2, "%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;

	IRDA_DEBUG(4, "%s()\n", __func__ );

	self = (struct irlan_cb *) 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:
		IRDA_WARNING("IrLAN: Insufficient resources\n");
		break;
	case 2:
		IRDA_WARNING("IrLAN: Invalid command format\n");
		break;
	case 3:
		IRDA_WARNING("IrLAN: Command not supported\n");
		break;
	case 4:
		IRDA_WARNING("IrLAN: Parameter not supported\n");
		break;
	case 5:
		IRDA_WARNING("IrLAN: Value not supported\n");
		break;
	case 6:
		IRDA_WARNING("IrLAN: Not open\n");
		break;
	case 7:
		IRDA_WARNING("IrLAN: Authentication required\n");
		break;
	case 8:
		IRDA_WARNING("IrLAN: Invalid password\n");
		break;
	case 9:
		IRDA_WARNING("IrLAN: Protocol error\n");
		break;
	case 255:
		IRDA_WARNING("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;);

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

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

	if (!skb) {
		IRDA_ERROR("%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];

	IRDA_DEBUG(4, "%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) {
			IRDA_DEBUG(2, "%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;

	IRDA_DEBUG(4, "%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 {
			IRDA_DEBUG(2, "%s(), unknown access type!\n", __func__ );
		}
	}
	/* IRLAN version */
	if (strcmp(param, "IRLAN_VER") == 0) {
		IRDA_DEBUG(4, "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];
		IRDA_DEBUG(4, "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;
		IRDA_DEBUG(2, "%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;
		IRDA_DEBUG(4, "%s(), max frame=%d\n", __func__ ,
			   self->client.max_frame);
	}

	/* RECONNECT_KEY, in case the link goes down! */
	if (strcmp(param, "RECONNECT_KEY") == 0) {
		IRDA_DEBUG(4, "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;
		IRDA_DEBUG(4, "\n");
	}
	/* FILTER_ENTRY, have we got an ethernet address? */
	if (strcmp(param, "FILTER_ENTRY") == 0) {
		bytes = value;
		IRDA_DEBUG(4, "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_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(priv != NULL, return;);

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