[GitHub/moto-9609/android_kernel_motorola_exynos9610.git] / net / irda / irlan / irlan_client_event.c

/*********************************************************************
 *
 * Filename:      irlan_client_event.c
 * Version:       0.9
 * Description:   IrLAN client state machine
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Sun Aug 31 20:14:37 1997
 * Modified at:   Sun Dec 26 21:52:24 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     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/skbuff.h>

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

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

static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_arb  (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);
static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb);

static int (*state[])(struct irlan_cb *, IRLAN_EVENT event, struct sk_buff *) =
{
	irlan_client_state_idle,
	irlan_client_state_query,
	irlan_client_state_conn,
	irlan_client_state_info,
	irlan_client_state_media,
	irlan_client_state_open,
	irlan_client_state_wait,
	irlan_client_state_arb,
	irlan_client_state_data,
	irlan_client_state_close,
	irlan_client_state_sync
};

void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
			   struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	(*state[ self->client.state]) (self, event, skb);
}

/*
 * Function irlan_client_state_idle (event, skb, info)
 *
 *    IDLE, We are waiting for an indication that there is a provider
 *    available.
 */
static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

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

	switch (event) {
	case IRLAN_DISCOVERY_INDICATION:
		if (self->client.iriap) {
			IRDA_WARNING("%s(), busy with a previous query\n",
				     __func__);
			return -EBUSY;
		}

		self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
						irlan_client_get_value_confirm);
		/* Get some values from peer IAS */
		irlan_next_client_state(self, IRLAN_QUERY);
		iriap_getvaluebyclass_request(self->client.iriap,
					      self->saddr, self->daddr,
					      "IrLAN", "IrDA:TinyTP:LsapSel");
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(4, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_query (event, skb, info)
 *
 *    QUERY, We have queryed the remote IAS and is ready to connect
 *    to provider, just waiting for the confirm.
 *
 */
static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

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

	switch(event) {
	case IRLAN_IAS_PROVIDER_AVAIL:
		IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;);

		self->client.open_retries = 0;

		irttp_connect_request(self->client.tsap_ctrl,
				      self->dtsap_sel_ctrl,
				      self->saddr, self->daddr, NULL,
				      IRLAN_MTU, NULL);
		irlan_next_client_state(self, IRLAN_CONN);
		break;
	case IRLAN_IAS_PROVIDER_NOT_AVAIL:
		IRDA_DEBUG(2, "%s(), IAS_PROVIDER_NOT_AVAIL\n", __func__ );
		irlan_next_client_state(self, IRLAN_IDLE);

		/* Give the client a kick! */
		if ((self->provider.access_type == ACCESS_PEER) &&
		    (self->provider.state != IRLAN_IDLE))
			irlan_client_wakeup(self, self->saddr, self->daddr);
		break;
	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_conn (event, skb, info)
 *
 *    CONN, We have connected to a provider but has not issued any
 *    commands yet.
 *
 */
static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(self != NULL, return -1;);

	switch (event) {
	case IRLAN_CONNECT_COMPLETE:
		/* Send getinfo cmd */
		irlan_get_provider_info(self);
		irlan_next_client_state(self, IRLAN_INFO);
		break;
	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_info (self, event, skb, info)
 *
 *    INFO, We have issued a GetInfo command and is awaiting a reply.
 */
static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(self != NULL, return -1;);

	switch (event) {
	case IRLAN_DATA_INDICATION:
		IRDA_ASSERT(skb != NULL, return -1;);

		irlan_client_parse_response(self, skb);

		irlan_next_client_state(self, IRLAN_MEDIA);

		irlan_get_media_char(self);
		break;

	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_media (self, event, skb, info)
 *
 *    MEDIA, The irlan_client has issued a GetMedia command and is awaiting a
 *    reply.
 *
 */
static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(self != NULL, return -1;);

	switch(event) {
	case IRLAN_DATA_INDICATION:
		irlan_client_parse_response(self, skb);
		irlan_open_data_channel(self);
		irlan_next_client_state(self, IRLAN_OPEN);
		break;
	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_open (self, event, skb, info)
 *
 *    OPEN, The irlan_client has issued a OpenData command and is awaiting a
 *    reply
 *
 */
static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	struct qos_info qos;

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

	IRDA_ASSERT(self != NULL, return -1;);

	switch(event) {
	case IRLAN_DATA_INDICATION:
		irlan_client_parse_response(self, skb);

		/*
		 *  Check if we have got the remote TSAP for data
		 *  communications
		 */
		IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);

		/* Check which access type we are dealing with */
		switch (self->client.access_type) {
		case ACCESS_PEER:
		    if (self->provider.state == IRLAN_OPEN) {

			    irlan_next_client_state(self, IRLAN_ARB);
			    irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
						  NULL);
		    } else {

			    irlan_next_client_state(self, IRLAN_WAIT);
		    }
		    break;
		case ACCESS_DIRECT:
		case ACCESS_HOSTED:
			qos.link_disc_time.bits = 0x01; /* 3 secs */

			irttp_connect_request(self->tsap_data,
					      self->dtsap_sel_data,
					      self->saddr, self->daddr, &qos,
					      IRLAN_MTU, NULL);

			irlan_next_client_state(self, IRLAN_DATA);
			break;
		default:
			IRDA_DEBUG(2, "%s(), unknown access type!\n", __func__ );
			break;
		}
		break;
	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}

	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_wait (self, event, skb, info)
 *
 *    WAIT, The irlan_client is waiting for the local provider to enter the
 *    provider OPEN state.
 *
 */
static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(self != NULL, return -1;);

	switch(event) {
	case IRLAN_PROVIDER_SIGNAL:
		irlan_next_client_state(self, IRLAN_ARB);
		irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, NULL);
		break;
	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
				  struct sk_buff *skb)
{
	struct qos_info qos;

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

	IRDA_ASSERT(self != NULL, return -1;);

	switch(event) {
	case IRLAN_CHECK_CON_ARB:
		if (self->client.recv_arb_val == self->provider.send_arb_val) {
			irlan_next_client_state(self, IRLAN_CLOSE);
			irlan_close_data_channel(self);
		} else if (self->client.recv_arb_val <
			   self->provider.send_arb_val)
		{
			qos.link_disc_time.bits = 0x01; /* 3 secs */

			irlan_next_client_state(self, IRLAN_DATA);
			irttp_connect_request(self->tsap_data,
					      self->dtsap_sel_data,
					      self->saddr, self->daddr, &qos,
					      IRLAN_MTU, NULL);
		} else if (self->client.recv_arb_val >
			   self->provider.send_arb_val)
		{
			IRDA_DEBUG(2, "%s(), lost the battle :-(\n", __func__ );
		}
		break;
	case IRLAN_DATA_CONNECT_INDICATION:
		irlan_next_client_state(self, IRLAN_DATA);
		break;
	case IRLAN_LMP_DISCONNECT:
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	case IRLAN_WATCHDOG_TIMEOUT:
		IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_data (self, event, skb, info)
 *
 *    DATA, The data channel is connected, allowing data transfers between
 *    the local and remote machines.
 *
 */
static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __func__ );

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

	switch(event) {
	case IRLAN_DATA_INDICATION:
		irlan_client_parse_response(self, skb);
		break;
	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	case IRLAN_LAP_DISCONNECT:
		irlan_next_client_state(self, IRLAN_IDLE);
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_close (self, event, skb, info)
 *
 *
 *
 */
static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
				    struct sk_buff *skb)
{
	IRDA_DEBUG(2, "%s()\n", __func__ );

	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_client_state_sync (self, event, skb, info)
 *
 *
 *
 */
static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
				   struct sk_buff *skb)
{
	IRDA_DEBUG(2, "%s()\n", __func__ );

	if (skb)
		dev_kfree_skb(skb);

	return 0;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4 LT	3	* Filename: irlan_client_event.c
	4	* Version: 0.9
	5	* Description: IrLAN client state machine
	6	* Status: Experimental.
	7	* Author: Dag Brattli <dagb@cs.uit.no>
	8	* Created at: Sun Aug 31 20:14:37 1997
	9	* Modified at: Sun Dec 26 21:52:24 1999
	10	* Modified by: Dag Brattli <dagb@cs.uit.no>
6819bc2e YH	11	*
6819bc2e YH	12	* Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
1da177e4	13	* All Rights Reserved.
6819bc2e YH	14	*
	15	* This program is free software; you can redistribute it and/or
	16	* modify it under the terms of the GNU General Public License as
	17	* published by the Free Software Foundation; either version 2 of
1da177e4 LT	18	* the License, or (at your option) any later version.
1da177e4 LT	19	*
db955170	20	* Neither Dag Brattli nor University of Tromsø admit liability nor
6819bc2e	21	* provide warranty for any of this software. This material is
1da177e4 LT	22	* provided "AS-IS" and at no charge.
	23	*
	24	********************************************************************/
	25
	26	#include <linux/skbuff.h>
	27
	28	#include <net/irda/irda.h>
	29	#include <net/irda/timer.h>
	30	#include <net/irda/irmod.h>
	31	#include <net/irda/iriap.h>
	32	#include <net/irda/irlmp.h>
	33	#include <net/irda/irttp.h>
	34
	35	#include <net/irda/irlan_common.h>
	36	#include <net/irda/irlan_client.h>
	37	#include <net/irda/irlan_event.h>
	38
6819bc2e	39	static int irlan_client_state_idle (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	40	struct sk_buff *skb);
6819bc2e	41	static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	42	struct sk_buff *skb);
6819bc2e	43	static int irlan_client_state_conn (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	44	struct sk_buff *skb);
6819bc2e	45	static int irlan_client_state_info (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	46	struct sk_buff *skb);
6819bc2e	47	static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	48	struct sk_buff *skb);
6819bc2e	49	static int irlan_client_state_open (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	50	struct sk_buff *skb);
6819bc2e	51	static int irlan_client_state_wait (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	52	struct sk_buff *skb);
6819bc2e	53	static int irlan_client_state_arb (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	54	struct sk_buff *skb);
6819bc2e	55	static int irlan_client_state_data (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	56	struct sk_buff *skb);
6819bc2e	57	static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	58	struct sk_buff *skb);
6819bc2e	59	static int irlan_client_state_sync (struct irlan_cb *self, IRLAN_EVENT event,
1da177e4 LT	60	struct sk_buff *skb);
	61
	62	static int (state[])(struct irlan_cb , IRLAN_EVENT event, struct sk_buff *) =
6819bc2e	63	{
1da177e4 LT	64	irlan_client_state_idle,
	65	irlan_client_state_query,
	66	irlan_client_state_conn,
	67	irlan_client_state_info,
	68	irlan_client_state_media,
	69	irlan_client_state_open,
	70	irlan_client_state_wait,
	71	irlan_client_state_arb,
	72	irlan_client_state_data,
	73	irlan_client_state_close,
	74	irlan_client_state_sync
	75	};
	76
6819bc2e YH	77	void irlan_do_client_event(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	78	struct sk_buff *skb)
1da177e4 LT	79	{
	80	IRDA_ASSERT(self != NULL, return;);
	81	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	82
	83	(*state[ self->client.state]) (self, event, skb);
	84	}
	85
	86	/*
	87	* Function irlan_client_state_idle (event, skb, info)
	88	*
	89	* IDLE, We are waiting for an indication that there is a provider
	90	* available.
	91	*/
6819bc2e YH	92	static int irlan_client_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	93	struct sk_buff *skb)
1da177e4	94	{
0dc47877	95	IRDA_DEBUG(4, "%s()\n", __func__ );
1da177e4 LT	96
	97	IRDA_ASSERT(self != NULL, return -1;);
	98	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
6819bc2e	99
1da177e4 LT	100	switch (event) {
	101	case IRLAN_DISCOVERY_INDICATION:
	102	if (self->client.iriap) {
	103	IRDA_WARNING("%s(), busy with a previous query\n",
0dc47877	104	__func__);
1da177e4 LT	105	return -EBUSY;
1da177e4 LT	106	}
6819bc2e	107
1da177e4 LT	108	self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
	109	irlan_client_get_value_confirm);
	110	/* Get some values from peer IAS */
	111	irlan_next_client_state(self, IRLAN_QUERY);
	112	iriap_getvaluebyclass_request(self->client.iriap,
	113	self->saddr, self->daddr,
	114	"IrLAN", "IrDA:TinyTP:LsapSel");
	115	break;
	116	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	117	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	118	break;
1da177e4 LT	119	default:
0dc47877	120	IRDA_DEBUG(4, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	121	break;
1da177e4 LT	122	}
6819bc2e	123	if (skb)
1da177e4 LT	124	dev_kfree_skb(skb);
	125
	126	return 0;
	127	}
	128
	129	/*
	130	* Function irlan_client_state_query (event, skb, info)
	131	*
	132	* QUERY, We have queryed the remote IAS and is ready to connect
	133	* to provider, just waiting for the confirm.
	134	*
	135	*/
6819bc2e YH	136	static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	137	struct sk_buff *skb)
1da177e4	138	{
0dc47877	139	IRDA_DEBUG(4, "%s()\n", __func__ );
1da177e4 LT	140
	141	IRDA_ASSERT(self != NULL, return -1;);
	142	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
6819bc2e	143
1da177e4 LT	144	switch(event) {
	145	case IRLAN_IAS_PROVIDER_AVAIL:
	146	IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;);
	147
	148	self->client.open_retries = 0;
6819bc2e YH	149
	150	irttp_connect_request(self->client.tsap_ctrl,
	151	self->dtsap_sel_ctrl,
	152	self->saddr, self->daddr, NULL,
1da177e4 LT	153	IRLAN_MTU, NULL);
	154	irlan_next_client_state(self, IRLAN_CONN);
	155	break;
	156	case IRLAN_IAS_PROVIDER_NOT_AVAIL:
0dc47877	157	IRDA_DEBUG(2, "%s(), IAS_PROVIDER_NOT_AVAIL\n", __func__ );
1da177e4 LT	158	irlan_next_client_state(self, IRLAN_IDLE);
	159
	160	/* Give the client a kick! */
6819bc2e	161	if ((self->provider.access_type == ACCESS_PEER) &&
1da177e4 LT	162	(self->provider.state != IRLAN_IDLE))
	163	irlan_client_wakeup(self, self->saddr, self->daddr);
	164	break;
	165	case IRLAN_LMP_DISCONNECT:
	166	case IRLAN_LAP_DISCONNECT:
	167	irlan_next_client_state(self, IRLAN_IDLE);
	168	break;
	169	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	170	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	171	break;
1da177e4 LT	172	default:
0dc47877	173	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	174	break;
	175	}
	176	if (skb)
	177	dev_kfree_skb(skb);
6819bc2e	178
1da177e4 LT	179	return 0;
	180	}
	181
	182	/*
	183	* Function irlan_client_state_conn (event, skb, info)
	184	*
	185	* CONN, We have connected to a provider but has not issued any
	186	* commands yet.
	187	*
	188	*/
6819bc2e YH	189	static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	190	struct sk_buff *skb)
1da177e4	191	{
0dc47877	192	IRDA_DEBUG(4, "%s()\n", __func__ );
6819bc2e	193
1da177e4	194	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	195
1da177e4 LT	196	switch (event) {
	197	case IRLAN_CONNECT_COMPLETE:
	198	/* Send getinfo cmd */
	199	irlan_get_provider_info(self);
	200	irlan_next_client_state(self, IRLAN_INFO);
	201	break;
	202	case IRLAN_LMP_DISCONNECT:
	203	case IRLAN_LAP_DISCONNECT:
	204	irlan_next_client_state(self, IRLAN_IDLE);
	205	break;
	206	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	207	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	208	break;
1da177e4 LT	209	default:
0dc47877	210	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	211	break;
	212	}
	213	if (skb)
	214	dev_kfree_skb(skb);
6819bc2e	215
1da177e4 LT	216	return 0;
	217	}
	218
	219	/*
	220	* Function irlan_client_state_info (self, event, skb, info)
	221	*
	222	* INFO, We have issued a GetInfo command and is awaiting a reply.
	223	*/
6819bc2e YH	224	static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	225	struct sk_buff *skb)
1da177e4	226	{
0dc47877	227	IRDA_DEBUG(4, "%s()\n", __func__ );
1da177e4 LT	228
1da177e4 LT	229	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	230
1da177e4 LT	231	switch (event) {
	232	case IRLAN_DATA_INDICATION:
	233	IRDA_ASSERT(skb != NULL, return -1;);
6819bc2e	234
1da177e4	235	irlan_client_parse_response(self, skb);
6819bc2e	236
1da177e4	237	irlan_next_client_state(self, IRLAN_MEDIA);
6819bc2e	238
1da177e4 LT	239	irlan_get_media_char(self);
1da177e4 LT	240	break;
6819bc2e	241
1da177e4 LT	242	case IRLAN_LMP_DISCONNECT:
	243	case IRLAN_LAP_DISCONNECT:
	244	irlan_next_client_state(self, IRLAN_IDLE);
	245	break;
	246	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	247	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	248	break;
1da177e4 LT	249	default:
0dc47877	250	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	251	break;
	252	}
	253	if (skb)
	254	dev_kfree_skb(skb);
6819bc2e	255
1da177e4 LT	256	return 0;
	257	}
	258
	259	/*
	260	* Function irlan_client_state_media (self, event, skb, info)
	261	*
	262	* MEDIA, The irlan_client has issued a GetMedia command and is awaiting a
	263	* reply.
	264	*
	265	*/
6819bc2e YH	266	static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	267	struct sk_buff *skb)
1da177e4	268	{
0dc47877	269	IRDA_DEBUG(4, "%s()\n", __func__ );
6819bc2e	270
1da177e4 LT	271	IRDA_ASSERT(self != NULL, return -1;);
	272
	273	switch(event) {
	274	case IRLAN_DATA_INDICATION:
	275	irlan_client_parse_response(self, skb);
	276	irlan_open_data_channel(self);
	277	irlan_next_client_state(self, IRLAN_OPEN);
	278	break;
	279	case IRLAN_LMP_DISCONNECT:
	280	case IRLAN_LAP_DISCONNECT:
	281	irlan_next_client_state(self, IRLAN_IDLE);
	282	break;
	283	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	284	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	285	break;
1da177e4 LT	286	default:
0dc47877	287	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	288	break;
	289	}
	290	if (skb)
	291	dev_kfree_skb(skb);
6819bc2e	292
1da177e4 LT	293	return 0;
	294	}
	295
	296	/*
	297	* Function irlan_client_state_open (self, event, skb, info)
	298	*
	299	* OPEN, The irlan_client has issued a OpenData command and is awaiting a
	300	* reply
	301	*
	302	*/
6819bc2e YH	303	static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	304	struct sk_buff *skb)
1da177e4 LT	305	{
	306	struct qos_info qos;
	307
0dc47877	308	IRDA_DEBUG(4, "%s()\n", __func__ );
6819bc2e	309
1da177e4 LT	310	IRDA_ASSERT(self != NULL, return -1;);
	311
	312	switch(event) {
	313	case IRLAN_DATA_INDICATION:
	314	irlan_client_parse_response(self, skb);
6819bc2e	315
1da177e4	316	/*
6819bc2e	317	* Check if we have got the remote TSAP for data
1da177e4 LT	318	* communications
1da177e4 LT	319	*/
6819bc2e	320	IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);
1da177e4 LT	321
	322	/* Check which access type we are dealing with */
	323	switch (self->client.access_type) {
	324	case ACCESS_PEER:
	325	if (self->provider.state == IRLAN_OPEN) {
6819bc2e	326
1da177e4	327	irlan_next_client_state(self, IRLAN_ARB);
6819bc2e	328	irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
1da177e4 LT	329	NULL);
1da177e4 LT	330	} else {
6819bc2e	331
1da177e4 LT	332	irlan_next_client_state(self, IRLAN_WAIT);
	333	}
	334	break;
	335	case ACCESS_DIRECT:
	336	case ACCESS_HOSTED:
	337	qos.link_disc_time.bits = 0x01; /* 3 secs */
6819bc2e YH	338
	339	irttp_connect_request(self->tsap_data,
	340	self->dtsap_sel_data,
	341	self->saddr, self->daddr, &qos,
1da177e4	342	IRLAN_MTU, NULL);
6819bc2e	343
1da177e4 LT	344	irlan_next_client_state(self, IRLAN_DATA);
	345	break;
	346	default:
0dc47877	347	IRDA_DEBUG(2, "%s(), unknown access type!\n", __func__ );
1da177e4 LT	348	break;
	349	}
	350	break;
	351	case IRLAN_LMP_DISCONNECT:
	352	case IRLAN_LAP_DISCONNECT:
	353	irlan_next_client_state(self, IRLAN_IDLE);
	354	break;
	355	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	356	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	357	break;
1da177e4 LT	358	default:
0dc47877	359	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	360	break;
1da177e4 LT	361	}
6819bc2e	362
1da177e4 LT	363	if (skb)
	364	dev_kfree_skb(skb);
	365
	366	return 0;
	367	}
	368
	369	/*
	370	* Function irlan_client_state_wait (self, event, skb, info)
	371	*
	372	* WAIT, The irlan_client is waiting for the local provider to enter the
	373	* provider OPEN state.
	374	*
	375	*/
6819bc2e YH	376	static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	377	struct sk_buff *skb)
1da177e4	378	{
0dc47877	379	IRDA_DEBUG(4, "%s()\n", __func__ );
6819bc2e	380
1da177e4	381	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	382
1da177e4 LT	383	switch(event) {
	384	case IRLAN_PROVIDER_SIGNAL:
	385	irlan_next_client_state(self, IRLAN_ARB);
	386	irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, NULL);
	387	break;
	388	case IRLAN_LMP_DISCONNECT:
	389	case IRLAN_LAP_DISCONNECT:
	390	irlan_next_client_state(self, IRLAN_IDLE);
	391	break;
	392	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	393	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	394	break;
1da177e4 LT	395	default:
0dc47877	396	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	397	break;
	398	}
	399	if (skb)
	400	dev_kfree_skb(skb);
6819bc2e	401
1da177e4 LT	402	return 0;
	403	}
	404
6819bc2e YH	405	static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	406	struct sk_buff *skb)
1da177e4 LT	407	{
	408	struct qos_info qos;
	409
0dc47877	410	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	411
1da177e4 LT	412	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	413
1da177e4 LT	414	switch(event) {
	415	case IRLAN_CHECK_CON_ARB:
	416	if (self->client.recv_arb_val == self->provider.send_arb_val) {
	417	irlan_next_client_state(self, IRLAN_CLOSE);
	418	irlan_close_data_channel(self);
6819bc2e YH	419	} else if (self->client.recv_arb_val <
6819bc2e YH	420	self->provider.send_arb_val)
1da177e4 LT	421	{
	422	qos.link_disc_time.bits = 0x01; /* 3 secs */
	423
	424	irlan_next_client_state(self, IRLAN_DATA);
6819bc2e YH	425	irttp_connect_request(self->tsap_data,
	426	self->dtsap_sel_data,
	427	self->saddr, self->daddr, &qos,
1da177e4 LT	428	IRLAN_MTU, NULL);
1da177e4 LT	429	} else if (self->client.recv_arb_val >
6819bc2e	430	self->provider.send_arb_val)
1da177e4	431	{
0dc47877	432	IRDA_DEBUG(2, "%s(), lost the battle :-(\n", __func__ );
1da177e4 LT	433	}
	434	break;
	435	case IRLAN_DATA_CONNECT_INDICATION:
	436	irlan_next_client_state(self, IRLAN_DATA);
	437	break;
	438	case IRLAN_LMP_DISCONNECT:
	439	case IRLAN_LAP_DISCONNECT:
	440	irlan_next_client_state(self, IRLAN_IDLE);
	441	break;
	442	case IRLAN_WATCHDOG_TIMEOUT:
0dc47877	443	IRDA_DEBUG(2, "%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__ );
1da177e4 LT	444	break;
1da177e4 LT	445	default:
0dc47877	446	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	447	break;
	448	}
	449	if (skb)
	450	dev_kfree_skb(skb);
6819bc2e	451
1da177e4 LT	452	return 0;
	453	}
	454
	455	/*
	456	* Function irlan_client_state_data (self, event, skb, info)
	457	*
	458	* DATA, The data channel is connected, allowing data transfers between
	459	* the local and remote machines.
	460	*
	461	*/
6819bc2e YH	462	static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	463	struct sk_buff *skb)
1da177e4	464	{
0dc47877	465	IRDA_DEBUG(4, "%s()\n", __func__ );
1da177e4 LT	466
	467	IRDA_ASSERT(self != NULL, return -1;);
	468	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
	469
	470	switch(event) {
	471	case IRLAN_DATA_INDICATION:
	472	irlan_client_parse_response(self, skb);
6819bc2e	473	break;
1da177e4 LT	474	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	475	case IRLAN_LAP_DISCONNECT:
	476	irlan_next_client_state(self, IRLAN_IDLE);
	477	break;
	478	default:
0dc47877	479	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	480	break;
	481	}
	482	if (skb)
	483	dev_kfree_skb(skb);
6819bc2e	484
1da177e4 LT	485	return 0;
	486	}
	487
	488	/*
	489	* Function irlan_client_state_close (self, event, skb, info)
	490	*
6819bc2e	491	*
1da177e4 LT	492	*
1da177e4 LT	493	*/
6819bc2e YH	494	static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	495	struct sk_buff *skb)
1da177e4	496	{
0dc47877	497	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	498
	499	if (skb)
	500	dev_kfree_skb(skb);
	501
	502	return 0;
	503	}
	504
	505	/*
	506	* Function irlan_client_state_sync (self, event, skb, info)
	507	*
6819bc2e	508	*
1da177e4 LT	509	*
1da177e4 LT	510	*/
6819bc2e YH	511	static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	512	struct sk_buff *skb)
1da177e4	513	{
0dc47877	514	IRDA_DEBUG(2, "%s()\n", __func__ );
6819bc2e	515
1da177e4 LT	516	if (skb)
1da177e4 LT	517	dev_kfree_skb(skb);
6819bc2e	518
1da177e4 LT	519	return 0;
	520	}
	521
	522
	523
	524
	525
	526
	527
	528
	529
	530
	531
	532
	533