[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / irda / iriap_event.c

/*********************************************************************
 *
 * Filename:      iriap_event.c
 * Version:       0.1
 * Description:   IAP Finite State Machine
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Thu Aug 21 00:02:07 1997
 * Modified at:   Wed Mar  1 11:28:34 2000
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1997, 1999-2000 Dag Brattli <dagb@cs.uit.no>,
 *     All Rights Reserved.
 *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <net/irda/irda.h>
#include <net/irda/irlmp.h>
#include <net/irda/iriap.h>
#include <net/irda/iriap_event.h>

static void state_s_disconnect   (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_connecting   (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_call         (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);

static void state_s_make_call    (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_calling      (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_outstanding  (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_replying     (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_wait_for_call(struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_s_wait_active  (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);

static void state_r_disconnect   (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_r_call         (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_r_waiting      (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_r_wait_active  (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_r_receiving    (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_r_execute      (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);
static void state_r_returning    (struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb);

static void (*iriap_state[])(struct iriap_cb *self, IRIAP_EVENT event,
			     struct sk_buff *skb) = {
	/* Client FSM */
	state_s_disconnect,
	state_s_connecting,
	state_s_call,

	/* S-Call FSM */
	state_s_make_call,
	state_s_calling,
	state_s_outstanding,
	state_s_replying,
	state_s_wait_for_call,
	state_s_wait_active,

	/* Server FSM */
	state_r_disconnect,
	state_r_call,

	/* R-Connect FSM */
	state_r_waiting,
	state_r_wait_active,
	state_r_receiving,
	state_r_execute,
	state_r_returning,
};

void iriap_next_client_state(struct iriap_cb *self, IRIAP_STATE state)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	self->client_state = state;
}

void iriap_next_call_state(struct iriap_cb *self, IRIAP_STATE state)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	self->call_state = state;
}

void iriap_next_server_state(struct iriap_cb *self, IRIAP_STATE state)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	self->server_state = state;
}

void iriap_next_r_connect_state(struct iriap_cb *self, IRIAP_STATE state)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	self->r_connect_state = state;
}

void iriap_do_client_event(struct iriap_cb *self, IRIAP_EVENT event,
			   struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	(*iriap_state[ self->client_state]) (self, event, skb);
}

void iriap_do_call_event(struct iriap_cb *self, IRIAP_EVENT event,
			 struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	(*iriap_state[ self->call_state]) (self, event, skb);
}

void iriap_do_server_event(struct iriap_cb *self, IRIAP_EVENT event,
			   struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	(*iriap_state[ self->server_state]) (self, event, skb);
}

void iriap_do_r_connect_event(struct iriap_cb *self, IRIAP_EVENT event,
			      struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	(*iriap_state[ self->r_connect_state]) (self, event, skb);
}


/*
 * Function state_s_disconnect (event, skb)
 *
 *    S-Disconnect, The device has no LSAP connection to a particular
 *    remote device.
 */
static void state_s_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
			       struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	switch (event) {
	case IAP_CALL_REQUEST_GVBC:
		iriap_next_client_state(self, S_CONNECTING);
		IRDA_ASSERT(self->request_skb == NULL, return;);
		/* Don't forget to refcount it -
		 * see iriap_getvaluebyclass_request(). */
		skb_get(skb);
		self->request_skb = skb;
		iriap_connect_request(self);
		break;
	case IAP_LM_DISCONNECT_INDICATION:
		break;
	default:
		IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
		break;
	}
}

/*
 * Function state_s_connecting (self, event, skb)
 *
 *    S-Connecting
 *
 */
static void state_s_connecting(struct iriap_cb *self, IRIAP_EVENT event,
			       struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);

	switch (event) {
	case IAP_LM_CONNECT_CONFIRM:
		/*
		 *  Jump to S-Call FSM
		 */
		iriap_do_call_event(self, IAP_CALL_REQUEST, skb);
		/* iriap_call_request(self, 0,0,0); */
		iriap_next_client_state(self, S_CALL);
		break;
	case IAP_LM_DISCONNECT_INDICATION:
		/* Abort calls */
		iriap_next_call_state(self, S_MAKE_CALL);
		iriap_next_client_state(self, S_DISCONNECT);
		break;
	default:
		IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
		break;
	}
}

/*
 * Function state_s_call (self, event, skb)
 *
 *    S-Call, The device can process calls to a specific remote
 *    device. Whenever the LSAP connection is disconnected, this state
 *    catches that event and clears up
 */
static void state_s_call(struct iriap_cb *self, IRIAP_EVENT event,
			 struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);

	switch (event) {
	case IAP_LM_DISCONNECT_INDICATION:
		/* Abort calls */
		iriap_next_call_state(self, S_MAKE_CALL);
		iriap_next_client_state(self, S_DISCONNECT);
		break;
	default:
		IRDA_DEBUG(0, "state_s_call: Unknown event %d\n", event);
		break;
	}
}

/*
 * Function state_s_make_call (event, skb)
 *
 *    S-Make-Call
 *
 */
static void state_s_make_call(struct iriap_cb *self, IRIAP_EVENT event,
			      struct sk_buff *skb)
{
	struct sk_buff *tx_skb;

	IRDA_ASSERT(self != NULL, return;);

	switch (event) {
	case IAP_CALL_REQUEST:
		/* Already refcounted - see state_s_disconnect() */
		tx_skb = self->request_skb;
		self->request_skb = NULL;

		irlmp_data_request(self->lsap, tx_skb);
		iriap_next_call_state(self, S_OUTSTANDING);
		break;
	default:
		IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
		break;
	}
}

/*
 * Function state_s_calling (event, skb)
 *
 *    S-Calling
 *
 */
static void state_s_calling(struct iriap_cb *self, IRIAP_EVENT event,
			    struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
}

/*
 * Function state_s_outstanding (event, skb)
 *
 *    S-Outstanding, The device is waiting for a response to a command
 *
 */
static void state_s_outstanding(struct iriap_cb *self, IRIAP_EVENT event,
				struct sk_buff *skb)
{
	IRDA_ASSERT(self != NULL, return;);

	switch (event) {
	case IAP_RECV_F_LST:
		/*iriap_send_ack(self);*/
		/*LM_Idle_request(idle); */

		iriap_next_call_state(self, S_WAIT_FOR_CALL);
		break;
	default:
		IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
		break;
	}
}

/*
 * Function state_s_replying (event, skb)
 *
 *    S-Replying, The device is collecting a multiple part response
 */
static void state_s_replying(struct iriap_cb *self, IRIAP_EVENT event,
			     struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
}

/*
 * Function state_s_wait_for_call (event, skb)
 *
 *    S-Wait-for-Call
 *
 */
static void state_s_wait_for_call(struct iriap_cb *self, IRIAP_EVENT event,
				  struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
}


/*
 * Function state_s_wait_active (event, skb)
 *
 *    S-Wait-Active
 *
 */
static void state_s_wait_active(struct iriap_cb *self, IRIAP_EVENT event,
				struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
}

/**************************************************************************
 *
 *  Server FSM
 *
 **************************************************************************/

/*
 * Function state_r_disconnect (self, event, skb)
 *
 *    LM-IAS server is disconnected (not processing any requests!)
 *
 */
static void state_r_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
			       struct sk_buff *skb)
{
	struct sk_buff *tx_skb;

	switch (event) {
	case IAP_LM_CONNECT_INDICATION:
		tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
		if (tx_skb == NULL) {
			IRDA_WARNING("%s: unable to malloc!\n", __FUNCTION__);
			return;
		}

		/* Reserve space for MUX_CONTROL and LAP header */
		skb_reserve(tx_skb, LMP_MAX_HEADER);

		irlmp_connect_response(self->lsap, tx_skb);
		/*LM_Idle_request(idle); */

		iriap_next_server_state(self, R_CALL);

		/*
		 *  Jump to R-Connect FSM, we skip R-Waiting since we do not
		 *  care about LM_Idle_request()!
		 */
		iriap_next_r_connect_state(self, R_RECEIVING);
		break;
	default:
		IRDA_DEBUG(0, "%s(), unknown event %d\n", __FUNCTION__, event);
		break;
	}
}

/*
 * Function state_r_call (self, event, skb)
 */
static void state_r_call(struct iriap_cb *self, IRIAP_EVENT event,
			 struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __FUNCTION__);

	switch (event) {
	case IAP_LM_DISCONNECT_INDICATION:
		/* Abort call */
		iriap_next_server_state(self, R_DISCONNECT);
		iriap_next_r_connect_state(self, R_WAITING);
		break;
	default:
		IRDA_DEBUG(0, "%s(), unknown event!\n", __FUNCTION__);
		break;
	}
}

/*
 *  R-Connect FSM
 */

/*
 * Function state_r_waiting (self, event, skb)
 */
static void state_r_waiting(struct iriap_cb *self, IRIAP_EVENT event,
			    struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
}

static void state_r_wait_active(struct iriap_cb *self, IRIAP_EVENT event,
				struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
}

/*
 * Function state_r_receiving (self, event, skb)
 *
 *    We are receiving a command
 *
 */
static void state_r_receiving(struct iriap_cb *self, IRIAP_EVENT event,
			      struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __FUNCTION__);

	switch (event) {
	case IAP_RECV_F_LST:
		iriap_next_r_connect_state(self, R_EXECUTE);

		iriap_call_indication(self, skb);
		break;
	default:
		IRDA_DEBUG(0, "%s(), unknown event!\n", __FUNCTION__);
		break;
	}
}

/*
 * Function state_r_execute (self, event, skb)
 *
 *    The server is processing the request
 *
 */
static void state_r_execute(struct iriap_cb *self, IRIAP_EVENT event,
			    struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __FUNCTION__);

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

	switch (event) {
	case IAP_CALL_RESPONSE:
		/*
		 *  Since we don't implement the Waiting state, we return
		 *  to state Receiving instead, DB.
		 */
		iriap_next_r_connect_state(self, R_RECEIVING);

		/* Don't forget to refcount it - see
		 * iriap_getvaluebyclass_response(). */
		skb_get(skb);

		irlmp_data_request(self->lsap, skb);
		break;
	default:
		IRDA_DEBUG(0, "%s(), unknown event!\n", __FUNCTION__);
		break;
	}
}

static void state_r_returning(struct iriap_cb *self, IRIAP_EVENT event,
			      struct sk_buff *skb)
{
	IRDA_DEBUG(0, "%s(), event=%d\n", __FUNCTION__, event);

	switch (event) {
	case IAP_RECV_F_LST:
		break;
	default:
		break;
	}
}
Commit	Line	Data
1da177e4 LT	1	/*********************************************************************
	2	*
	3	* Filename: iriap_event.c
	4	* Version: 0.1
	5	* Description: IAP Finite State Machine
	6	* Status: Experimental.
	7	* Author: Dag Brattli <dagb@cs.uit.no>
	8	* Created at: Thu Aug 21 00:02:07 1997
	9	* Modified at: Wed Mar 1 11:28:34 2000
	10	* Modified by: Dag Brattli <dagb@cs.uit.no>
	11	*
	12	* Copyright (c) 1997, 1999-2000 Dag Brattli <dagb@cs.uit.no>,
	13	* All Rights Reserved.
	14	* Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
	15	*
	16	* This program is free software; you can redistribute it and/or
	17	* modify it under the terms of the GNU General Public License as
	18	* published by the Free Software Foundation; either version 2 of
	19	* the License, or (at your option) any later version.
	20	*
96de0e25	21	* Neither Dag Brattli nor University of Tromsø admit liability nor
1da177e4 LT	22	* provide warranty for any of this software. This material is
	23	* provided "AS-IS" and at no charge.
	24	*
	25	********************************************************************/
	26
	27	#include <net/irda/irda.h>
	28	#include <net/irda/irlmp.h>
	29	#include <net/irda/iriap.h>
	30	#include <net/irda/iriap_event.h>
	31
	32	static void state_s_disconnect (struct iriap_cb *self, IRIAP_EVENT event,
	33	struct sk_buff *skb);
	34	static void state_s_connecting (struct iriap_cb *self, IRIAP_EVENT event,
	35	struct sk_buff *skb);
	36	static void state_s_call (struct iriap_cb *self, IRIAP_EVENT event,
	37	struct sk_buff *skb);
	38
	39	static void state_s_make_call (struct iriap_cb *self, IRIAP_EVENT event,
	40	struct sk_buff *skb);
	41	static void state_s_calling (struct iriap_cb *self, IRIAP_EVENT event,
	42	struct sk_buff *skb);
	43	static void state_s_outstanding (struct iriap_cb *self, IRIAP_EVENT event,
	44	struct sk_buff *skb);
	45	static void state_s_replying (struct iriap_cb *self, IRIAP_EVENT event,
	46	struct sk_buff *skb);
	47	static void state_s_wait_for_call(struct iriap_cb *self, IRIAP_EVENT event,
	48	struct sk_buff *skb);
	49	static void state_s_wait_active (struct iriap_cb *self, IRIAP_EVENT event,
	50	struct sk_buff *skb);
	51
	52	static void state_r_disconnect (struct iriap_cb *self, IRIAP_EVENT event,
	53	struct sk_buff *skb);
	54	static void state_r_call (struct iriap_cb *self, IRIAP_EVENT event,
	55	struct sk_buff *skb);
	56	static void state_r_waiting (struct iriap_cb *self, IRIAP_EVENT event,
	57	struct sk_buff *skb);
	58	static void state_r_wait_active (struct iriap_cb *self, IRIAP_EVENT event,
	59	struct sk_buff *skb);
	60	static void state_r_receiving (struct iriap_cb *self, IRIAP_EVENT event,
	61	struct sk_buff *skb);
	62	static void state_r_execute (struct iriap_cb *self, IRIAP_EVENT event,
	63	struct sk_buff *skb);
	64	static void state_r_returning (struct iriap_cb *self, IRIAP_EVENT event,
	65	struct sk_buff *skb);
	66
	67	static void (iriap_state[])(struct iriap_cb self, IRIAP_EVENT event,
	68	struct sk_buff *skb) = {
	69	/* Client FSM */
	70	state_s_disconnect,
	71	state_s_connecting,
	72	state_s_call,
	73
	74	/* S-Call FSM */
	75	state_s_make_call,
	76	state_s_calling,
	77	state_s_outstanding,
	78	state_s_replying,
	79	state_s_wait_for_call,
	80	state_s_wait_active,
	81
	82	/* Server FSM */
	83	state_r_disconnect,
	84	state_r_call,
	85
86	/* R-Connect FSM */
87	state_r_waiting,
88	state_r_wait_active,
89	state_r_receiving,
90	state_r_execute,
91	state_r_returning,
92	};
93
94	void iriap_next_client_state(struct iriap_cb *self, IRIAP_STATE state)
95	{
96	IRDA_ASSERT(self != NULL, return;);
97	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
98
99	self->client_state = state;
100	}
101
102	void iriap_next_call_state(struct iriap_cb *self, IRIAP_STATE state)
103	{
104	IRDA_ASSERT(self != NULL, return;);
105	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
106
107	self->call_state = state;
108	}
109
110	void iriap_next_server_state(struct iriap_cb *self, IRIAP_STATE state)
111	{
112	IRDA_ASSERT(self != NULL, return;);
113	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
114
115	self->server_state = state;
116	}
117
118	void iriap_next_r_connect_state(struct iriap_cb *self, IRIAP_STATE state)
119	{
120	IRDA_ASSERT(self != NULL, return;);
121	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
122
123	self->r_connect_state = state;
124	}
125
126	void iriap_do_client_event(struct iriap_cb *self, IRIAP_EVENT event,
127	struct sk_buff *skb)
128	{
129	IRDA_ASSERT(self != NULL, return;);
130	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
131
132	(*iriap_state[ self->client_state]) (self, event, skb);
133	}
134
135	void iriap_do_call_event(struct iriap_cb *self, IRIAP_EVENT event,
136	struct sk_buff *skb)
137	{
138	IRDA_ASSERT(self != NULL, return;);
139	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
140
141	(*iriap_state[ self->call_state]) (self, event, skb);
142	}
143
144	void iriap_do_server_event(struct iriap_cb *self, IRIAP_EVENT event,
145	struct sk_buff *skb)
146	{
147	IRDA_ASSERT(self != NULL, return;);
148	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
149
150	(*iriap_state[ self->server_state]) (self, event, skb);
151	}
152
153	void iriap_do_r_connect_event(struct iriap_cb *self, IRIAP_EVENT event,
154	struct sk_buff *skb)
155	{
156	IRDA_ASSERT(self != NULL, return;);
157	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
158
159	(*iriap_state[ self->r_connect_state]) (self, event, skb);
160	}
161
162
163	/*
164	* Function state_s_disconnect (event, skb)
165	*
166	* S-Disconnect, The device has no LSAP connection to a particular
167	* remote device.
168	*/
169	static void state_s_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
170	struct sk_buff *skb)
171	{
172	IRDA_ASSERT(self != NULL, return;);
173	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
174
175	switch (event) {
176	case IAP_CALL_REQUEST_GVBC:
177	iriap_next_client_state(self, S_CONNECTING);
178	IRDA_ASSERT(self->request_skb == NULL, return;);
179	/* Don't forget to refcount it -
180	* see iriap_getvaluebyclass_request(). */
181	skb_get(skb);
182	self->request_skb = skb;
183	iriap_connect_request(self);
184	break;
185	case IAP_LM_DISCONNECT_INDICATION:
186	break;
187	default:
188	IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
189	break;
190	}
191	}
192
193	/*
194	* Function state_s_connecting (self, event, skb)
195	*
196	* S-Connecting
197	*
198	*/
199	static void state_s_connecting(struct iriap_cb *self, IRIAP_EVENT event,
200	struct sk_buff *skb)
201	{
202	IRDA_ASSERT(self != NULL, return;);
203	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
204
205	switch (event) {
206	case IAP_LM_CONNECT_CONFIRM:
207	/*
208	* Jump to S-Call FSM
209	*/
210	iriap_do_call_event(self, IAP_CALL_REQUEST, skb);
211	/* iriap_call_request(self, 0,0,0); */
212	iriap_next_client_state(self, S_CALL);
213	break;
214	case IAP_LM_DISCONNECT_INDICATION:
215	/* Abort calls */
216	iriap_next_call_state(self, S_MAKE_CALL);
217	iriap_next_client_state(self, S_DISCONNECT);
218	break;
219	default:
220	IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
221	break;
222	}
223	}
224
225	/*
226	* Function state_s_call (self, event, skb)
227	*
228	* S-Call, The device can process calls to a specific remote
229	* device. Whenever the LSAP connection is disconnected, this state
230	* catches that event and clears up
231	*/
232	static void state_s_call(struct iriap_cb *self, IRIAP_EVENT event,
233	struct sk_buff *skb)
234	{
235	IRDA_ASSERT(self != NULL, return;);
236
237	switch (event) {
238	case IAP_LM_DISCONNECT_INDICATION:
239	/* Abort calls */
240	iriap_next_call_state(self, S_MAKE_CALL);
241	iriap_next_client_state(self, S_DISCONNECT);
242	break;
243	default:
244	IRDA_DEBUG(0, "state_s_call: Unknown event %d\n", event);
245	break;
246	}
247	}
248
249	/*
250	* Function state_s_make_call (event, skb)
251	*
252	* S-Make-Call
253	*
254	*/
255	static void state_s_make_call(struct iriap_cb *self, IRIAP_EVENT event,
256	struct sk_buff *skb)
257	{
258	struct sk_buff *tx_skb;
259
260	IRDA_ASSERT(self != NULL, return;);
261
262	switch (event) {
263	case IAP_CALL_REQUEST:
264	/* Already refcounted - see state_s_disconnect() */
265	tx_skb = self->request_skb;
266	self->request_skb = NULL;
267
268	irlmp_data_request(self->lsap, tx_skb);
269	iriap_next_call_state(self, S_OUTSTANDING);
270	break;
271	default:
272	IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
273	break;
274	}
275	}
276
277	/*
278	* Function state_s_calling (event, skb)
279	*
280	* S-Calling
281	*
282	*/
283	static void state_s_calling(struct iriap_cb *self, IRIAP_EVENT event,
284	struct sk_buff *skb)
285	{
286	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
287	}
288
289	/*
290	* Function state_s_outstanding (event, skb)
291	*
292	* S-Outstanding, The device is waiting for a response to a command
293	*
294	*/
295	static void state_s_outstanding(struct iriap_cb *self, IRIAP_EVENT event,
296	struct sk_buff *skb)
297	{
298	IRDA_ASSERT(self != NULL, return;);
299
300	switch (event) {
301	case IAP_RECV_F_LST:
302	/iriap_send_ack(self);/
303	/LM_Idle_request(idle); /
304
305	iriap_next_call_state(self, S_WAIT_FOR_CALL);
306	break;
307	default:
308	IRDA_DEBUG(0, "%s(), Unknown event %d\n", __FUNCTION__, event);
309	break;
310	}
311	}
312
313	/*
314	* Function state_s_replying (event, skb)
315	*
316	* S-Replying, The device is collecting a multiple part response
317	*/
318	static void state_s_replying(struct iriap_cb *self, IRIAP_EVENT event,
319	struct sk_buff *skb)
320	{
321	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
322	}
323
324	/*
325	* Function state_s_wait_for_call (event, skb)
326	*
327	* S-Wait-for-Call
328	*
329	*/
330	static void state_s_wait_for_call(struct iriap_cb *self, IRIAP_EVENT event,
331	struct sk_buff *skb)
332	{
333	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
334	}
335
336
337	/*
338	* Function state_s_wait_active (event, skb)
339	*
340	* S-Wait-Active
341	*
342	*/
343	static void state_s_wait_active(struct iriap_cb *self, IRIAP_EVENT event,
344	struct sk_buff *skb)
345	{
346	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
347	}
348
349	/**************************************************************************
350	*
351	* Server FSM
352	*
353	**************************************************************************/
354
355	/*
356	* Function state_r_disconnect (self, event, skb)
357	*
358	* LM-IAS server is disconnected (not processing any requests!)
359	*
360	*/
361	static void state_r_disconnect(struct iriap_cb *self, IRIAP_EVENT event,
362	struct sk_buff *skb)
363	{
364	struct sk_buff *tx_skb;
365
366	switch (event) {
367	case IAP_LM_CONNECT_INDICATION:
1b0fee7d	368	tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC);
1da177e4 LT	369	if (tx_skb == NULL) {
	370	IRDA_WARNING("%s: unable to malloc!\n", __FUNCTION__);
	371	return;
	372	}
	373
	374	/* Reserve space for MUX_CONTROL and LAP header */
	375	skb_reserve(tx_skb, LMP_MAX_HEADER);
	376
	377	irlmp_connect_response(self->lsap, tx_skb);
	378	/LM_Idle_request(idle); /
	379
	380	iriap_next_server_state(self, R_CALL);
	381
	382	/*
	383	* Jump to R-Connect FSM, we skip R-Waiting since we do not
	384	* care about LM_Idle_request()!
	385	*/
	386	iriap_next_r_connect_state(self, R_RECEIVING);
	387	break;
	388	default:
	389	IRDA_DEBUG(0, "%s(), unknown event %d\n", __FUNCTION__, event);
	390	break;
	391	}
	392	}
	393
	394	/*
	395	* Function state_r_call (self, event, skb)
	396	*/
	397	static void state_r_call(struct iriap_cb *self, IRIAP_EVENT event,
	398	struct sk_buff *skb)
	399	{
	400	IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
	401
	402	switch (event) {
	403	case IAP_LM_DISCONNECT_INDICATION:
	404	/* Abort call */
	405	iriap_next_server_state(self, R_DISCONNECT);
	406	iriap_next_r_connect_state(self, R_WAITING);
	407	break;
	408	default:
	409	IRDA_DEBUG(0, "%s(), unknown event!\n", __FUNCTION__);
	410	break;
	411	}
	412	}
	413
	414	/*
	415	* R-Connect FSM
	416	*/
	417
	418	/*
	419	* Function state_r_waiting (self, event, skb)
	420	*/
	421	static void state_r_waiting(struct iriap_cb *self, IRIAP_EVENT event,
	422	struct sk_buff *skb)
	423	{
	424	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
	425	}
	426
	427	static void state_r_wait_active(struct iriap_cb *self, IRIAP_EVENT event,
	428	struct sk_buff *skb)
	429	{
	430	IRDA_DEBUG(0, "%s(), Not implemented\n", __FUNCTION__);
	431	}
	432
433	/*
434	* Function state_r_receiving (self, event, skb)
435	*
436	* We are receiving a command
437	*
438	*/
439	static void state_r_receiving(struct iriap_cb *self, IRIAP_EVENT event,
440	struct sk_buff *skb)
441	{
442	IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
443
444	switch (event) {
445	case IAP_RECV_F_LST:
446	iriap_next_r_connect_state(self, R_EXECUTE);
447
448	iriap_call_indication(self, skb);
449	break;
450	default:
451	IRDA_DEBUG(0, "%s(), unknown event!\n", __FUNCTION__);
452	break;
453	}
454	}
455
456	/*
457	* Function state_r_execute (self, event, skb)
458	*
459	* The server is processing the request
460	*
461	*/
462	static void state_r_execute(struct iriap_cb *self, IRIAP_EVENT event,
463	struct sk_buff *skb)
464	{
465	IRDA_DEBUG(4, "%s()\n", __FUNCTION__);
466
467	IRDA_ASSERT(skb != NULL, return;);
468	IRDA_ASSERT(self != NULL, return;);
469	IRDA_ASSERT(self->magic == IAS_MAGIC, return;);
470
471	switch (event) {
472	case IAP_CALL_RESPONSE:
473	/*
474	* Since we don't implement the Waiting state, we return
475	* to state Receiving instead, DB.
476	*/
477	iriap_next_r_connect_state(self, R_RECEIVING);
478
479	/* Don't forget to refcount it - see
480	* iriap_getvaluebyclass_response(). */
481	skb_get(skb);
482
483	irlmp_data_request(self->lsap, skb);
484	break;
485	default:
486	IRDA_DEBUG(0, "%s(), unknown event!\n", __FUNCTION__);
487	break;
488	}
489	}
490
491	static void state_r_returning(struct iriap_cb *self, IRIAP_EVENT event,
492	struct sk_buff *skb)
493	{
494	IRDA_DEBUG(0, "%s(), event=%d\n", __FUNCTION__, event);
495
496	switch (event) {
497	case IAP_RECV_F_LST:
498	break;
499	default:
500	break;
501	}
502	}