[net-next-2.6.git] / net / irda / irlan / irlan_provider_event.c

/*********************************************************************
 *
 * Filename:      irlan_provider_event.c
 * Version:       0.9
 * Description:   IrLAN provider state machine)
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Sun Aug 31 20:14:37 1997
 * Modified at:   Sat Oct 30 12:52:41 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 <net/irda/irda.h>
#include <net/irda/iriap.h>
#include <net/irda/irlmp.h>
#include <net/irda/irttp.h>

#include <net/irda/irlan_provider.h>
#include <net/irda/irlan_event.h>

static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
				     struct sk_buff *skb);
static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
				     struct sk_buff *skb);
static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
				     struct sk_buff *skb);
static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
				     struct sk_buff *skb);

static int (*state[])(struct irlan_cb *self, IRLAN_EVENT event,
		      struct sk_buff *skb) =
{
	irlan_provider_state_idle,
	NULL, /* Query */
	NULL, /* Info */
	irlan_provider_state_info,
	NULL, /* Media */
	irlan_provider_state_open,
	NULL, /* Wait */
	NULL, /* Arb */
	irlan_provider_state_data,
	NULL, /* Close */
	NULL, /* Sync */
};

void irlan_do_provider_event(struct irlan_cb *self, IRLAN_EVENT event,
			     struct sk_buff *skb)
{
	IRDA_ASSERT(*state[ self->provider.state] != NULL, return;);

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

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

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

	switch(event) {
	case IRLAN_CONNECT_INDICATION:
	     irlan_provider_connect_response( self, self->provider.tsap_ctrl);
	     irlan_next_provider_state( self, IRLAN_INFO);
	     break;
	default:
		IRDA_DEBUG(4, "%s(), Unknown event %d\n", __FUNCTION__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_provider_state_info (self, event, skb, info)
 *
 *    INFO, We have issued a GetInfo command and is awaiting a reply.
 */
static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
				     struct sk_buff *skb)
{
	int ret;

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

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

	switch(event) {
	case IRLAN_GET_INFO_CMD:
		/* Be sure to use 802.3 in case of peer mode */
		if (self->provider.access_type == ACCESS_PEER) {
			self->media = MEDIA_802_3;

			/* Check if client has started yet */
			if (self->client.state == IRLAN_IDLE) {
				/* This should get the client going */
				irlmp_discovery_request(8);
			}
		}

		irlan_provider_send_reply(self, CMD_GET_PROVIDER_INFO,
					  RSP_SUCCESS);
		/* Keep state */
		break;
	case IRLAN_GET_MEDIA_CMD:
		irlan_provider_send_reply(self, CMD_GET_MEDIA_CHAR,
					  RSP_SUCCESS);
		/* Keep state */
		break;
	case IRLAN_OPEN_DATA_CMD:
		ret = irlan_parse_open_data_cmd(self, skb);
		if (self->provider.access_type == ACCESS_PEER) {
			/* FIXME: make use of random functions! */
			self->provider.send_arb_val = (jiffies & 0xffff);
		}
		irlan_provider_send_reply(self, CMD_OPEN_DATA_CHANNEL, ret);

		if (ret == RSP_SUCCESS) {
			irlan_next_provider_state(self, IRLAN_OPEN);

			/* Signal client that we are now open */
			irlan_do_client_event(self, IRLAN_PROVIDER_SIGNAL, NULL);
		}
		break;
	case IRLAN_LMP_DISCONNECT:  /* FALLTHROUGH */
	case IRLAN_LAP_DISCONNECT:
		irlan_next_provider_state(self, IRLAN_IDLE);
		break;
	default:
		IRDA_DEBUG( 0, "%s(), Unknown event %d\n", __FUNCTION__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

/*
 * Function irlan_provider_state_open (self, event, skb, info)
 *
 *    OPEN, The client has issued a OpenData command and is awaiting a
 *    reply
 *
 */
static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
				     struct sk_buff *skb)
{
	IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );

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

	switch(event) {
	case IRLAN_FILTER_CONFIG_CMD:
		irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb);
		irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
					  RSP_SUCCESS);
		/* Keep state */
		break;
	case IRLAN_DATA_CONNECT_INDICATION:
		irlan_next_provider_state(self, IRLAN_DATA);
		irlan_provider_connect_response(self, self->tsap_data);
		break;
	case IRLAN_LMP_DISCONNECT:  /* FALLTHROUGH */
	case IRLAN_LAP_DISCONNECT:
		irlan_next_provider_state(self, IRLAN_IDLE);
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}

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

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

	switch(event) {
	case IRLAN_FILTER_CONFIG_CMD:
		irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb);
		irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
					  RSP_SUCCESS);
		break;
	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	case IRLAN_LAP_DISCONNECT:
		irlan_next_provider_state(self, IRLAN_IDLE);
		break;
	default:
		IRDA_DEBUG( 0, "%s(), Unknown event %d\n", __FUNCTION__ , event);
		break;
	}
	if (skb)
		dev_kfree_skb(skb);

	return 0;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4 LT	3	* Filename: irlan_provider_event.c
	4	* Version: 0.9
	5	* Description: IrLAN provider 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: Sat Oct 30 12:52:41 1999
	10	* Modified by: Dag Brattli <dagb@cs.uit.no>
6819bc2e	11	*
1da177e4	12	* Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>, All Rights Reserved.
6819bc2e YH	13	*
	14	* This program is free software; you can redistribute it and/or
	15	* modify it under the terms of the GNU General Public License as
	16	* published by the Free Software Foundation; either version 2 of
1da177e4 LT	17	* the License, or (at your option) any later version.
1da177e4 LT	18	*
96de0e25	19	* Neither Dag Brattli nor University of Tromsø admit liability nor
6819bc2e	20	* provide warranty for any of this software. This material is
1da177e4 LT	21	* provided "AS-IS" and at no charge.
	22	*
	23	********************************************************************/
	24
	25	#include <net/irda/irda.h>
	26	#include <net/irda/iriap.h>
	27	#include <net/irda/irlmp.h>
	28	#include <net/irda/irttp.h>
	29
	30	#include <net/irda/irlan_provider.h>
	31	#include <net/irda/irlan_event.h>
	32
6819bc2e	33	static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	34	struct sk_buff *skb);
6819bc2e	35	static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	36	struct sk_buff *skb);
6819bc2e	37	static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4	38	struct sk_buff *skb);
6819bc2e	39	static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4 LT	40	struct sk_buff *skb);
1da177e4 LT	41
6819bc2e YH	42	static int (state[])(struct irlan_cb self, IRLAN_EVENT event,
	43	struct sk_buff *skb) =
	44	{
1da177e4 LT	45	irlan_provider_state_idle,
	46	NULL, /* Query */
	47	NULL, /* Info */
	48	irlan_provider_state_info,
	49	NULL, /* Media */
	50	irlan_provider_state_open,
	51	NULL, /* Wait */
	52	NULL, /* Arb */
	53	irlan_provider_state_data,
	54	NULL, /* Close */
	55	NULL, /* Sync */
	56	};
	57
6819bc2e YH	58	void irlan_do_provider_event(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	59	struct sk_buff *skb)
1da177e4 LT	60	{
	61	IRDA_ASSERT(*state[ self->provider.state] != NULL, return;);
	62
	63	(*state[self->provider.state]) (self, event, skb);
	64	}
	65
	66	/*
	67	* Function irlan_provider_state_idle (event, skb, info)
	68	*
	69	* IDLE, We are waiting for an indication that there is a provider
	70	* available.
	71	*/
	72	static int irlan_provider_state_idle(struct irlan_cb *self, IRLAN_EVENT event,
	73	struct sk_buff *skb)
	74	{
	75	IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
6819bc2e	76
1da177e4	77	IRDA_ASSERT(self != NULL, return -1;);
6819bc2e	78
1da177e4 LT	79	switch(event) {
	80	case IRLAN_CONNECT_INDICATION:
	81	irlan_provider_connect_response( self, self->provider.tsap_ctrl);
	82	irlan_next_provider_state( self, IRLAN_INFO);
	83	break;
	84	default:
	85	IRDA_DEBUG(4, "%s(), Unknown event %d\n", __FUNCTION__ , event);
	86	break;
	87	}
	88	if (skb)
	89	dev_kfree_skb(skb);
	90
	91	return 0;
	92	}
	93
	94	/*
	95	* Function irlan_provider_state_info (self, event, skb, info)
	96	*
	97	* INFO, We have issued a GetInfo command and is awaiting a reply.
	98	*/
6819bc2e YH	99	static int irlan_provider_state_info(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	100	struct sk_buff *skb)
1da177e4 LT	101	{
	102	int ret;
	103
	104	IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
6819bc2e	105
1da177e4 LT	106	IRDA_ASSERT(self != NULL, return -1;);
	107
	108	switch(event) {
	109	case IRLAN_GET_INFO_CMD:
	110	/* Be sure to use 802.3 in case of peer mode */
	111	if (self->provider.access_type == ACCESS_PEER) {
	112	self->media = MEDIA_802_3;
6819bc2e	113
1da177e4 LT	114	/* Check if client has started yet */
	115	if (self->client.state == IRLAN_IDLE) {
	116	/* This should get the client going */
	117	irlmp_discovery_request(8);
	118	}
	119	}
	120
6819bc2e	121	irlan_provider_send_reply(self, CMD_GET_PROVIDER_INFO,
1da177e4 LT	122	RSP_SUCCESS);
	123	/* Keep state */
	124	break;
6819bc2e YH	125	case IRLAN_GET_MEDIA_CMD:
6819bc2e YH	126	irlan_provider_send_reply(self, CMD_GET_MEDIA_CHAR,
1da177e4 LT	127	RSP_SUCCESS);
1da177e4 LT	128	/* Keep state */
6819bc2e	129	break;
1da177e4 LT	130	case IRLAN_OPEN_DATA_CMD:
	131	ret = irlan_parse_open_data_cmd(self, skb);
	132	if (self->provider.access_type == ACCESS_PEER) {
	133	/* FIXME: make use of random functions! */
	134	self->provider.send_arb_val = (jiffies & 0xffff);
	135	}
	136	irlan_provider_send_reply(self, CMD_OPEN_DATA_CHANNEL, ret);
	137
	138	if (ret == RSP_SUCCESS) {
	139	irlan_next_provider_state(self, IRLAN_OPEN);
	140
	141	/* Signal client that we are now open */
	142	irlan_do_client_event(self, IRLAN_PROVIDER_SIGNAL, NULL);
	143	}
	144	break;
	145	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	146	case IRLAN_LAP_DISCONNECT:
	147	irlan_next_provider_state(self, IRLAN_IDLE);
	148	break;
	149	default:
	150	IRDA_DEBUG( 0, "%s(), Unknown event %d\n", __FUNCTION__ , event);
	151	break;
	152	}
	153	if (skb)
	154	dev_kfree_skb(skb);
6819bc2e	155
1da177e4 LT	156	return 0;
	157	}
	158
	159	/*
	160	* Function irlan_provider_state_open (self, event, skb, info)
	161	*
	162	* OPEN, The client has issued a OpenData command and is awaiting a
	163	* reply
	164	*
	165	*/
6819bc2e	166	static int irlan_provider_state_open(struct irlan_cb *self, IRLAN_EVENT event,
1da177e4 LT	167	struct sk_buff *skb)
	168	{
	169	IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
	170
	171	IRDA_ASSERT(self != NULL, return -1;);
	172
	173	switch(event) {
	174	case IRLAN_FILTER_CONFIG_CMD:
	175	irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb);
6819bc2e	176	irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
1da177e4 LT	177	RSP_SUCCESS);
	178	/* Keep state */
	179	break;
6819bc2e	180	case IRLAN_DATA_CONNECT_INDICATION:
1da177e4 LT	181	irlan_next_provider_state(self, IRLAN_DATA);
	182	irlan_provider_connect_response(self, self->tsap_data);
	183	break;
	184	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	185	case IRLAN_LAP_DISCONNECT:
	186	irlan_next_provider_state(self, IRLAN_IDLE);
	187	break;
	188	default:
	189	IRDA_DEBUG(2, "%s(), Unknown event %d\n", __FUNCTION__ , event);
	190	break;
	191	}
	192	if (skb)
	193	dev_kfree_skb(skb);
	194
	195	return 0;
	196	}
	197
	198	/*
	199	* Function irlan_provider_state_data (self, event, skb, info)
	200	*
	201	* DATA, The data channel is connected, allowing data transfers between
	202	* the local and remote machines.
	203	*
	204	*/
6819bc2e YH	205	static int irlan_provider_state_data(struct irlan_cb *self, IRLAN_EVENT event,
6819bc2e YH	206	struct sk_buff *skb)
1da177e4 LT	207	{
	208	IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
	209
	210	IRDA_ASSERT(self != NULL, return -1;);
	211	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
	212
	213	switch(event) {
	214	case IRLAN_FILTER_CONFIG_CMD:
	215	irlan_provider_parse_command(self, CMD_FILTER_OPERATION, skb);
6819bc2e	216	irlan_provider_send_reply(self, CMD_FILTER_OPERATION,
1da177e4 LT	217	RSP_SUCCESS);
	218	break;
	219	case IRLAN_LMP_DISCONNECT: /* FALLTHROUGH */
	220	case IRLAN_LAP_DISCONNECT:
	221	irlan_next_provider_state(self, IRLAN_IDLE);
	222	break;
	223	default:
	224	IRDA_DEBUG( 0, "%s(), Unknown event %d\n", __FUNCTION__ , event);
	225	break;
	226	}
	227	if (skb)
	228	dev_kfree_skb(skb);
6819bc2e	229
1da177e4 LT	230	return 0;
	231	}
	232
	233
	234
	235
	236
	237
	238
	239
	240
	241