[mirror_ubuntu-zesty-kernel.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_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);

	switch (event) {
	case IRLAN_DISCOVERY_INDICATION:
		if (self->client.iriap) {
			net_warn_ratelimited("%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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
		pr_debug("%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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
			pr_debug("%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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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)
		{
			pr_debug("%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:
		pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
		break;
	default:
		pr_debug("%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_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:
		pr_debug("%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)
{
	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)
{
	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	{
1da177e4 LT	95	IRDA_ASSERT(self != NULL, return -1;);
1da177e4 LT	96	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
6819bc2e	97
1da177e4 LT	98	switch (event) {
	99	case IRLAN_DISCOVERY_INDICATION:
	100	if (self->client.iriap) {
6c91023d JP	101	net_warn_ratelimited("%s(), busy with a previous query\n",
6c91023d JP	102	__func__);
1da177e4 LT	103	return -EBUSY;
1da177e4 LT	104	}
6819bc2e	105
1da177e4 LT	106	self->client.iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
	107	irlan_client_get_value_confirm);
	108	/* Get some values from peer IAS */
	109	irlan_next_client_state(self, IRLAN_QUERY);
	110	iriap_getvaluebyclass_request(self->client.iriap,
	111	self->saddr, self->daddr,
	112	"IrLAN", "IrDA:TinyTP:LsapSel");
	113	break;
	114	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	115	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	116	break;
1da177e4 LT	117	default:
955a9d20	118	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	119	break;
1da177e4 LT	120	}
6819bc2e	121	if (skb)
1da177e4 LT	122	dev_kfree_skb(skb);
	123
	124	return 0;
	125	}
	126
	127	/*
	128	* Function irlan_client_state_query (event, skb, info)
	129	*
	130	* QUERY, We have queryed the remote IAS and is ready to connect
	131	* to provider, just waiting for the confirm.
	132	*
	133	*/
6819bc2e YH	134	static int irlan_client_state_query(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	135	struct sk_buff *skb)
1da177e4	136	{
1da177e4 LT	137	IRDA_ASSERT(self != NULL, return -1;);
1da177e4 LT	138	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
6819bc2e	139
1da177e4 LT	140	switch(event) {
	141	case IRLAN_IAS_PROVIDER_AVAIL:
	142	IRDA_ASSERT(self->dtsap_sel_ctrl != 0, return -1;);
	143
	144	self->client.open_retries = 0;
6819bc2e YH	145
	146	irttp_connect_request(self->client.tsap_ctrl,
	147	self->dtsap_sel_ctrl,
	148	self->saddr, self->daddr, NULL,
1da177e4 LT	149	IRLAN_MTU, NULL);
	150	irlan_next_client_state(self, IRLAN_CONN);
	151	break;
	152	case IRLAN_IAS_PROVIDER_NOT_AVAIL:
955a9d20	153	pr_debug("%s(), IAS_PROVIDER_NOT_AVAIL\n", __func__);
1da177e4 LT	154	irlan_next_client_state(self, IRLAN_IDLE);
	155
	156	/* Give the client a kick! */
6819bc2e	157	if ((self->provider.access_type == ACCESS_PEER) &&
1da177e4 LT	158	(self->provider.state != IRLAN_IDLE))
	159	irlan_client_wakeup(self, self->saddr, self->daddr);
	160	break;
	161	case IRLAN_LMP_DISCONNECT:
	162	case IRLAN_LAP_DISCONNECT:
	163	irlan_next_client_state(self, IRLAN_IDLE);
	164	break;
	165	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	166	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	167	break;
1da177e4 LT	168	default:
955a9d20	169	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	170	break;
	171	}
	172	if (skb)
	173	dev_kfree_skb(skb);
6819bc2e	174
1da177e4 LT	175	return 0;
	176	}
	177
	178	/*
	179	* Function irlan_client_state_conn (event, skb, info)
	180	*
	181	* CONN, We have connected to a provider but has not issued any
	182	* commands yet.
	183	*
	184	*/
6819bc2e YH	185	static int irlan_client_state_conn(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	186	struct sk_buff *skb)
1da177e4	187	{
1da177e4	188	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	189
1da177e4 LT	190	switch (event) {
	191	case IRLAN_CONNECT_COMPLETE:
	192	/* Send getinfo cmd */
	193	irlan_get_provider_info(self);
	194	irlan_next_client_state(self, IRLAN_INFO);
	195	break;
	196	case IRLAN_LMP_DISCONNECT:
	197	case IRLAN_LAP_DISCONNECT:
	198	irlan_next_client_state(self, IRLAN_IDLE);
	199	break;
	200	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	201	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	202	break;
1da177e4 LT	203	default:
955a9d20	204	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	205	break;
	206	}
	207	if (skb)
	208	dev_kfree_skb(skb);
6819bc2e	209
1da177e4 LT	210	return 0;
	211	}
	212
	213	/*
	214	* Function irlan_client_state_info (self, event, skb, info)
	215	*
	216	* INFO, We have issued a GetInfo command and is awaiting a reply.
	217	*/
6819bc2e YH	218	static int irlan_client_state_info(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	219	struct sk_buff *skb)
1da177e4	220	{
1da177e4	221	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	222
1da177e4 LT	223	switch (event) {
	224	case IRLAN_DATA_INDICATION:
	225	IRDA_ASSERT(skb != NULL, return -1;);
6819bc2e	226
1da177e4	227	irlan_client_parse_response(self, skb);
6819bc2e	228
1da177e4	229	irlan_next_client_state(self, IRLAN_MEDIA);
6819bc2e	230
1da177e4 LT	231	irlan_get_media_char(self);
1da177e4 LT	232	break;
6819bc2e	233
1da177e4 LT	234	case IRLAN_LMP_DISCONNECT:
	235	case IRLAN_LAP_DISCONNECT:
	236	irlan_next_client_state(self, IRLAN_IDLE);
	237	break;
	238	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	239	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	240	break;
1da177e4 LT	241	default:
955a9d20	242	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	243	break;
	244	}
	245	if (skb)
	246	dev_kfree_skb(skb);
6819bc2e	247
1da177e4 LT	248	return 0;
	249	}
	250
	251	/*
	252	* Function irlan_client_state_media (self, event, skb, info)
	253	*
	254	* MEDIA, The irlan_client has issued a GetMedia command and is awaiting a
	255	* reply.
	256	*
	257	*/
6819bc2e YH	258	static int irlan_client_state_media(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	259	struct sk_buff *skb)
1da177e4	260	{
1da177e4 LT	261	IRDA_ASSERT(self != NULL, return -1;);
	262
	263	switch(event) {
	264	case IRLAN_DATA_INDICATION:
	265	irlan_client_parse_response(self, skb);
	266	irlan_open_data_channel(self);
	267	irlan_next_client_state(self, IRLAN_OPEN);
	268	break;
	269	case IRLAN_LMP_DISCONNECT:
	270	case IRLAN_LAP_DISCONNECT:
	271	irlan_next_client_state(self, IRLAN_IDLE);
	272	break;
	273	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	274	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	275	break;
1da177e4 LT	276	default:
955a9d20	277	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	278	break;
	279	}
	280	if (skb)
	281	dev_kfree_skb(skb);
6819bc2e	282
1da177e4 LT	283	return 0;
	284	}
	285
	286	/*
	287	* Function irlan_client_state_open (self, event, skb, info)
	288	*
	289	* OPEN, The irlan_client has issued a OpenData command and is awaiting a
	290	* reply
	291	*
	292	*/
6819bc2e YH	293	static int irlan_client_state_open(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	294	struct sk_buff *skb)
1da177e4 LT	295	{
	296	struct qos_info qos;
	297
1da177e4 LT	298	IRDA_ASSERT(self != NULL, return -1;);
	299
	300	switch(event) {
	301	case IRLAN_DATA_INDICATION:
	302	irlan_client_parse_response(self, skb);
6819bc2e	303
1da177e4	304	/*
6819bc2e	305	* Check if we have got the remote TSAP for data
1da177e4 LT	306	* communications
1da177e4 LT	307	*/
6819bc2e	308	IRDA_ASSERT(self->dtsap_sel_data != 0, return -1;);
1da177e4 LT	309
	310	/* Check which access type we are dealing with */
	311	switch (self->client.access_type) {
	312	case ACCESS_PEER:
	313	if (self->provider.state == IRLAN_OPEN) {
6819bc2e	314
1da177e4	315	irlan_next_client_state(self, IRLAN_ARB);
6819bc2e	316	irlan_do_client_event(self, IRLAN_CHECK_CON_ARB,
1da177e4 LT	317	NULL);
1da177e4 LT	318	} else {
6819bc2e	319
1da177e4 LT	320	irlan_next_client_state(self, IRLAN_WAIT);
	321	}
	322	break;
	323	case ACCESS_DIRECT:
	324	case ACCESS_HOSTED:
	325	qos.link_disc_time.bits = 0x01; /* 3 secs */
6819bc2e YH	326
	327	irttp_connect_request(self->tsap_data,
	328	self->dtsap_sel_data,
	329	self->saddr, self->daddr, &qos,
1da177e4	330	IRLAN_MTU, NULL);
6819bc2e	331
1da177e4 LT	332	irlan_next_client_state(self, IRLAN_DATA);
	333	break;
	334	default:
955a9d20	335	pr_debug("%s(), unknown access type!\n", __func__);
1da177e4 LT	336	break;
	337	}
	338	break;
	339	case IRLAN_LMP_DISCONNECT:
	340	case IRLAN_LAP_DISCONNECT:
	341	irlan_next_client_state(self, IRLAN_IDLE);
	342	break;
	343	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	344	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	345	break;
1da177e4 LT	346	default:
955a9d20	347	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	348	break;
1da177e4 LT	349	}
6819bc2e	350
1da177e4 LT	351	if (skb)
	352	dev_kfree_skb(skb);
	353
	354	return 0;
	355	}
	356
	357	/*
	358	* Function irlan_client_state_wait (self, event, skb, info)
	359	*
	360	* WAIT, The irlan_client is waiting for the local provider to enter the
	361	* provider OPEN state.
	362	*
	363	*/
6819bc2e YH	364	static int irlan_client_state_wait(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	365	struct sk_buff *skb)
1da177e4	366	{
1da177e4	367	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	368
1da177e4 LT	369	switch(event) {
	370	case IRLAN_PROVIDER_SIGNAL:
	371	irlan_next_client_state(self, IRLAN_ARB);
	372	irlan_do_client_event(self, IRLAN_CHECK_CON_ARB, NULL);
	373	break;
	374	case IRLAN_LMP_DISCONNECT:
	375	case IRLAN_LAP_DISCONNECT:
	376	irlan_next_client_state(self, IRLAN_IDLE);
	377	break;
	378	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	379	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	380	break;
1da177e4 LT	381	default:
955a9d20	382	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	383	break;
	384	}
	385	if (skb)
	386	dev_kfree_skb(skb);
6819bc2e	387
1da177e4 LT	388	return 0;
	389	}
	390
6819bc2e YH	391	static int irlan_client_state_arb(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	392	struct sk_buff *skb)
1da177e4 LT	393	{
	394	struct qos_info qos;
	395
1da177e4	396	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	397
1da177e4 LT	398	switch(event) {
	399	case IRLAN_CHECK_CON_ARB:
	400	if (self->client.recv_arb_val == self->provider.send_arb_val) {
	401	irlan_next_client_state(self, IRLAN_CLOSE);
	402	irlan_close_data_channel(self);
6819bc2e YH	403	} else if (self->client.recv_arb_val <
6819bc2e YH	404	self->provider.send_arb_val)
1da177e4 LT	405	{
	406	qos.link_disc_time.bits = 0x01; /* 3 secs */
	407
	408	irlan_next_client_state(self, IRLAN_DATA);
6819bc2e YH	409	irttp_connect_request(self->tsap_data,
	410	self->dtsap_sel_data,
	411	self->saddr, self->daddr, &qos,
1da177e4 LT	412	IRLAN_MTU, NULL);
1da177e4 LT	413	} else if (self->client.recv_arb_val >
6819bc2e	414	self->provider.send_arb_val)
1da177e4	415	{
955a9d20	416	pr_debug("%s(), lost the battle :-(\n", __func__);
1da177e4 LT	417	}
	418	break;
	419	case IRLAN_DATA_CONNECT_INDICATION:
	420	irlan_next_client_state(self, IRLAN_DATA);
	421	break;
	422	case IRLAN_LMP_DISCONNECT:
	423	case IRLAN_LAP_DISCONNECT:
	424	irlan_next_client_state(self, IRLAN_IDLE);
	425	break;
	426	case IRLAN_WATCHDOG_TIMEOUT:
955a9d20	427	pr_debug("%s(), IRLAN_WATCHDOG_TIMEOUT\n", __func__);
1da177e4 LT	428	break;
1da177e4 LT	429	default:
955a9d20	430	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	431	break;
	432	}
	433	if (skb)
	434	dev_kfree_skb(skb);
6819bc2e	435
1da177e4 LT	436	return 0;
	437	}
	438
	439	/*
	440	* Function irlan_client_state_data (self, event, skb, info)
	441	*
	442	* DATA, The data channel is connected, allowing data transfers between
	443	* the local and remote machines.
	444	*
	445	*/
6819bc2e YH	446	static int irlan_client_state_data(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	447	struct sk_buff *skb)
1da177e4	448	{
1da177e4 LT	449	IRDA_ASSERT(self != NULL, return -1;);
	450	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
	451
	452	switch(event) {
	453	case IRLAN_DATA_INDICATION:
	454	irlan_client_parse_response(self, skb);
6819bc2e	455	break;
1da177e4 LT	456	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	457	case IRLAN_LAP_DISCONNECT:
	458	irlan_next_client_state(self, IRLAN_IDLE);
	459	break;
	460	default:
955a9d20	461	pr_debug("%s(), Unknown event %d\n", __func__ , event);
1da177e4 LT	462	break;
	463	}
	464	if (skb)
	465	dev_kfree_skb(skb);
6819bc2e	466
1da177e4 LT	467	return 0;
	468	}
	469
	470	/*
	471	* Function irlan_client_state_close (self, event, skb, info)
	472	*
6819bc2e	473	*
1da177e4 LT	474	*
1da177e4 LT	475	*/
6819bc2e YH	476	static int irlan_client_state_close(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	477	struct sk_buff *skb)
1da177e4	478	{
1da177e4 LT	479	if (skb)
	480	dev_kfree_skb(skb);
	481
	482	return 0;
	483	}
	484
	485	/*
	486	* Function irlan_client_state_sync (self, event, skb, info)
	487	*
6819bc2e	488	*
1da177e4 LT	489	*
1da177e4 LT	490	*/
6819bc2e YH	491	static int irlan_client_state_sync(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	492	struct sk_buff *skb)
1da177e4	493	{
1da177e4 LT	494	if (skb)
1da177e4 LT	495	dev_kfree_skb(skb);
6819bc2e	496
1da177e4 LT	497	return 0;
	498	}
	499
	500
	501
	502
	503
	504
	505
	506
	507
	508
	509
	510
	511