[linux.git] / drivers / uwb / uwbd.c

/*
 * Ultra Wide Band
 * Neighborhood Management Daemon
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <[email protected]>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 *
 * This daemon takes care of maintaing information that describes the
 * UWB neighborhood that the radios in this machine can see. It also
 * keeps a tab of which devices are visible, makes sure each HC sits
 * on a different channel to avoid interfering, etc.
 *
 * Different drivers (radio controller, device, any API in general)
 * communicate with this daemon through an event queue. Daemon wakes
 * up, takes a list of events and handles them one by one; handling
 * function is extracted from a table based on the event's type and
 * subtype. Events are freed only if the handling function says so.
 *
 *   . Lock protecting the event list has to be an spinlock and locked
 *     with IRQSAVE because it might be called from an interrupt
 *     context (ie: when events arrive and the notification drops
 *     down from the ISR).
 *
 *   . UWB radio controller drivers queue events to the daemon using
 *     uwbd_event_queue(). They just get the event, chew it to make it
 *     look like UWBD likes it and pass it in a buffer allocated with
 *     uwb_event_alloc().
 *
 * EVENTS
 *
 * Events have a type, a subtype, a length, some other stuff and the
 * data blob, which depends on the event. The header is 'struct
 * uwb_event'; for payloads, see 'struct uwbd_evt_*'.
 *
 * EVENT HANDLER TABLES
 *
 * To find a handling function for an event, the type is used to index
 * a subtype-table in the type-table. The subtype-table is indexed
 * with the subtype to get the function that handles the event. Start
 * with the main type-table 'uwbd_evt_type_handler'.
 *
 * DEVICES
 *
 * Devices are created when a bunch of beacons have been received and
 * it is stablished that the device has stable radio presence. CREATED
 * only, not configured. Devices are ONLY configured when an
 * Application-Specific IE Probe is receieved, in which the device
 * declares which Protocol ID it groks. Then the device is CONFIGURED
 * (and the driver->probe() stuff of the device model is invoked).
 *
 * Devices are considered disconnected when a certain number of
 * beacons are not received in an amount of time.
 *
 * Handler functions are called normally uwbd_evt_handle_*().
 */
#include <linux/kthread.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/freezer.h>

#include "uwb-internal.h"

/*
 * UWBD Event handler function signature
 *
 * Return !0 if the event needs not to be freed (ie the handler
 * takes/took care of it). 0 means the daemon code will free the
 * event.
 *
 * @evt->rc is already referenced and guaranteed to exist. See
 * uwb_evt_handle().
 */
typedef int (*uwbd_evt_handler_f)(struct uwb_event *);

/**
 * Properties of a UWBD event
 *
 * @handler:    the function that will handle this event
 * @name:       text name of event
 */
struct uwbd_event {
	uwbd_evt_handler_f handler;
	const char *name;
};

/* Table of handlers for and properties of the UWBD Radio Control Events */
static struct uwbd_event uwbd_urc_events[] = {
	[UWB_RC_EVT_IE_RCV] = {
		.handler = uwbd_evt_handle_rc_ie_rcv,
		.name = "IE_RECEIVED"
	},
	[UWB_RC_EVT_BEACON] = {
		.handler = uwbd_evt_handle_rc_beacon,
		.name = "BEACON_RECEIVED"
	},
	[UWB_RC_EVT_BEACON_SIZE] = {
		.handler = uwbd_evt_handle_rc_beacon_size,
		.name = "BEACON_SIZE_CHANGE"
	},
	[UWB_RC_EVT_BPOIE_CHANGE] = {
		.handler = uwbd_evt_handle_rc_bpoie_change,
		.name = "BPOIE_CHANGE"
	},
	[UWB_RC_EVT_BP_SLOT_CHANGE] = {
		.handler = uwbd_evt_handle_rc_bp_slot_change,
		.name = "BP_SLOT_CHANGE"
	},
	[UWB_RC_EVT_DRP_AVAIL] = {
		.handler = uwbd_evt_handle_rc_drp_avail,
		.name = "DRP_AVAILABILITY_CHANGE"
	},
	[UWB_RC_EVT_DRP] = {
		.handler = uwbd_evt_handle_rc_drp,
		.name = "DRP"
	},
	[UWB_RC_EVT_DEV_ADDR_CONFLICT] = {
		.handler = uwbd_evt_handle_rc_dev_addr_conflict,
		.name = "DEV_ADDR_CONFLICT",
	},
};


struct uwbd_evt_type_handler {
	const char *name;
	struct uwbd_event *uwbd_events;
	size_t size;
};

/* Table of handlers for each UWBD Event type. */
static struct uwbd_evt_type_handler uwbd_urc_evt_type_handlers[] = {
	[UWB_RC_CET_GENERAL] = {
		.name        = "URC",
		.uwbd_events = uwbd_urc_events,
		.size        = ARRAY_SIZE(uwbd_urc_events),
	},
};

static const struct uwbd_event uwbd_message_handlers[] = {
	[UWB_EVT_MSG_RESET] = {
		.handler = uwbd_msg_handle_reset,
		.name = "reset",
	},
};

/*
 * Handle an URC event passed to the UWB Daemon
 *
 * @evt: the event to handle
 * @returns: 0 if the event can be kfreed, !0 on the contrary
 *           (somebody else took ownership) [coincidentally, returning
 *           a <0 errno code will free it :)].
 *
 * Looks up the two indirection tables (one for the type, one for the
 * subtype) to decide which function handles it and then calls the
 * handler.
 *
 * The event structure passed to the event handler has the radio
 * controller in @evt->rc referenced. The reference will be dropped
 * once the handler returns, so if it needs it for longer (async),
 * it'll need to take another one.
 */
static
int uwbd_event_handle_urc(struct uwb_event *evt)
{
	int result = -EINVAL;
	struct uwbd_evt_type_handler *type_table;
	uwbd_evt_handler_f handler;
	u8 type, context;
	u16 event;

	type = evt->notif.rceb->bEventType;
	event = le16_to_cpu(evt->notif.rceb->wEvent);
	context = evt->notif.rceb->bEventContext;

	if (type >= ARRAY_SIZE(uwbd_urc_evt_type_handlers))
		goto out;
	type_table = &uwbd_urc_evt_type_handlers[type];
	if (type_table->uwbd_events == NULL)
		goto out;
	if (event >= type_table->size)
		goto out;
	handler = type_table->uwbd_events[event].handler;
	if (handler == NULL)
		goto out;

	result = (*handler)(evt);
out:
	if (result < 0)
		dev_err(&evt->rc->uwb_dev.dev,
			"UWBD: event 0x%02x/%04x/%02x, handling failed: %d\n",
			type, event, context, result);
	return result;
}

static void uwbd_event_handle_message(struct uwb_event *evt)
{
	struct uwb_rc *rc;
	int result;

	rc = evt->rc;

	if (evt->message < 0 || evt->message >= ARRAY_SIZE(uwbd_message_handlers)) {
		dev_err(&rc->uwb_dev.dev, "UWBD: invalid message type %d\n", evt->message);
		return;
	}

	result = uwbd_message_handlers[evt->message].handler(evt);
	if (result < 0)
		dev_err(&rc->uwb_dev.dev, "UWBD: '%s' message failed: %d\n",
			uwbd_message_handlers[evt->message].name, result);
}

static void uwbd_event_handle(struct uwb_event *evt)
{
	struct uwb_rc *rc;
	int should_keep;

	rc = evt->rc;

	if (rc->ready) {
		switch (evt->type) {
		case UWB_EVT_TYPE_NOTIF:
			should_keep = uwbd_event_handle_urc(evt);
			if (should_keep <= 0)
				kfree(evt->notif.rceb);
			break;
		case UWB_EVT_TYPE_MSG:
			uwbd_event_handle_message(evt);
			break;
		default:
			dev_err(&rc->uwb_dev.dev, "UWBD: invalid event type %d\n", evt->type);
			break;
		}
	}

	__uwb_rc_put(rc);	/* for the __uwb_rc_get() in uwb_rc_notif_cb() */
}

/**
 * UWB Daemon
 *
 * Listens to all UWB notifications and takes care to track the state
 * of the UWB neighbourhood for the kernel. When we do a run, we
 * spinlock, move the list to a private copy and release the
 * lock. Hold it as little as possible. Not a conflict: it is
 * guaranteed we own the events in the private list.
 *
 * FIXME: should change so we don't have a 1HZ timer all the time, but
 *        only if there are devices.
 */
static int uwbd(void *param)
{
	struct uwb_rc *rc = param;
	unsigned long flags;
	struct uwb_event *evt;
	int should_stop = 0;

	while (1) {
		wait_event_interruptible_timeout(
			rc->uwbd.wq,
			!list_empty(&rc->uwbd.event_list)
			  || (should_stop = kthread_should_stop()),
			HZ);
		if (should_stop)
			break;

		spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
		if (!list_empty(&rc->uwbd.event_list)) {
			evt = list_first_entry(&rc->uwbd.event_list, struct uwb_event, list_node);
			list_del(&evt->list_node);
		} else
			evt = NULL;
		spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);

		if (evt) {
			uwbd_event_handle(evt);
			kfree(evt);
		}

		uwb_beca_purge(rc);	/* Purge devices that left */
	}
	return 0;
}


/** Start the UWB daemon */
void uwbd_start(struct uwb_rc *rc)
{
	struct task_struct *task = kthread_run(uwbd, rc, "uwbd");
	if (IS_ERR(task)) {
		rc->uwbd.task = NULL;
		printk(KERN_ERR "UWB: Cannot start management daemon; "
		       "UWB won't work\n");
	} else {
		rc->uwbd.task = task;
		rc->uwbd.pid = rc->uwbd.task->pid;
	}
}

/* Stop the UWB daemon and free any unprocessed events */
void uwbd_stop(struct uwb_rc *rc)
{
	if (rc->uwbd.task)
		kthread_stop(rc->uwbd.task);
	uwbd_flush(rc);
}

/*
 * Queue an event for the management daemon
 *
 * When some lower layer receives an event, it uses this function to
 * push it forward to the UWB daemon.
 *
 * Once you pass the event, you don't own it any more, but the daemon
 * does. It will uwb_event_free() it when done, so make sure you
 * uwb_event_alloc()ed it or bad things will happen.
 *
 * If the daemon is not running, we just free the event.
 */
void uwbd_event_queue(struct uwb_event *evt)
{
	struct uwb_rc *rc = evt->rc;
	unsigned long flags;

	spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
	if (rc->uwbd.pid != 0) {
		list_add(&evt->list_node, &rc->uwbd.event_list);
		wake_up_all(&rc->uwbd.wq);
	} else {
		__uwb_rc_put(evt->rc);
		if (evt->type == UWB_EVT_TYPE_NOTIF)
			kfree(evt->notif.rceb);
		kfree(evt);
	}
	spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
	return;
}

void uwbd_flush(struct uwb_rc *rc)
{
	struct uwb_event *evt, *nxt;

	spin_lock_irq(&rc->uwbd.event_list_lock);
	list_for_each_entry_safe(evt, nxt, &rc->uwbd.event_list, list_node) {
		if (evt->rc == rc) {
			__uwb_rc_put(rc);
			list_del(&evt->list_node);
			if (evt->type == UWB_EVT_TYPE_NOTIF)
				kfree(evt->notif.rceb);
			kfree(evt);
		}
	}
	spin_unlock_irq(&rc->uwbd.event_list_lock);
}
Commit	Line	Data
183b9b59 IPG	1	/*
	2	* Ultra Wide Band
	3	* Neighborhood Management Daemon
	4	*
	5	* Copyright (C) 2005-2006 Intel Corporation
	6	* Inaky Perez-Gonzalez <[email protected]>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License version
	10	* 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	20	* 02110-1301, USA.
	21	*
	22	*
	23	* This daemon takes care of maintaing information that describes the
	24	* UWB neighborhood that the radios in this machine can see. It also
	25	* keeps a tab of which devices are visible, makes sure each HC sits
	26	* on a different channel to avoid interfering, etc.
	27	*
	28	* Different drivers (radio controller, device, any API in general)
	29	* communicate with this daemon through an event queue. Daemon wakes
	30	* up, takes a list of events and handles them one by one; handling
	31	* function is extracted from a table based on the event's type and
	32	* subtype. Events are freed only if the handling function says so.
	33	*
	34	* . Lock protecting the event list has to be an spinlock and locked
	35	* with IRQSAVE because it might be called from an interrupt
	36	* context (ie: when events arrive and the notification drops
	37	* down from the ISR).
	38	*
	39	* . UWB radio controller drivers queue events to the daemon using
	40	* uwbd_event_queue(). They just get the event, chew it to make it
	41	* look like UWBD likes it and pass it in a buffer allocated with
	42	* uwb_event_alloc().
	43	*
	44	* EVENTS
	45	*
1537a363	46	* Events have a type, a subtype, a length, some other stuff and the
183b9b59 IPG	47	* data blob, which depends on the event. The header is 'struct
	48	* uwb_event'; for payloads, see 'struct uwbd_evt_*'.
	49	*
	50	* EVENT HANDLER TABLES
	51	*
	52	* To find a handling function for an event, the type is used to index
	53	* a subtype-table in the type-table. The subtype-table is indexed
	54	* with the subtype to get the function that handles the event. Start
	55	* with the main type-table 'uwbd_evt_type_handler'.
	56	*
	57	* DEVICES
	58	*
	59	* Devices are created when a bunch of beacons have been received and
	60	* it is stablished that the device has stable radio presence. CREATED
	61	* only, not configured. Devices are ONLY configured when an
	62	* Application-Specific IE Probe is receieved, in which the device
	63	* declares which Protocol ID it groks. Then the device is CONFIGURED
	64	* (and the driver->probe() stuff of the device model is invoked).
	65	*
	66	* Devices are considered disconnected when a certain number of
	67	* beacons are not received in an amount of time.
	68	*
	69	* Handler functions are called normally uwbd_evt_handle_*().
	70	*/
183b9b59	71	#include <linux/kthread.h>
5a0e3ad6	72	#include <linux/slab.h>
183b9b59 IPG	73	#include <linux/module.h>
183b9b59 IPG	74	#include <linux/freezer.h>
183b9b59	75
bce83697	76	#include "uwb-internal.h"
183b9b59	77
bce83697	78	/*
183b9b59 IPG	79	* UWBD Event handler function signature
	80	*
	81	* Return !0 if the event needs not to be freed (ie the handler
	82	* takes/took care of it). 0 means the daemon code will free the
	83	* event.
	84	*
	85	* @evt->rc is already referenced and guaranteed to exist. See
	86	* uwb_evt_handle().
	87	*/
	88	typedef int (uwbd_evt_handler_f)(struct uwb_event );
	89
	90	/**
	91	* Properties of a UWBD event
	92	*
	93	* @handler: the function that will handle this event
	94	* @name: text name of event
	95	*/
	96	struct uwbd_event {
	97	uwbd_evt_handler_f handler;
	98	const char *name;
	99	};
	100
bce83697 DV	101	/* Table of handlers for and properties of the UWBD Radio Control Events */
bce83697 DV	102	static struct uwbd_event uwbd_urc_events[] = {
c5995bd2 SP	103	[UWB_RC_EVT_IE_RCV] = {
	104	.handler = uwbd_evt_handle_rc_ie_rcv,
	105	.name = "IE_RECEIVED"
	106	},
183b9b59 IPG	107	[UWB_RC_EVT_BEACON] = {
	108	.handler = uwbd_evt_handle_rc_beacon,
	109	.name = "BEACON_RECEIVED"
	110	},
	111	[UWB_RC_EVT_BEACON_SIZE] = {
	112	.handler = uwbd_evt_handle_rc_beacon_size,
	113	.name = "BEACON_SIZE_CHANGE"
	114	},
	115	[UWB_RC_EVT_BPOIE_CHANGE] = {
	116	.handler = uwbd_evt_handle_rc_bpoie_change,
	117	.name = "BPOIE_CHANGE"
	118	},
	119	[UWB_RC_EVT_BP_SLOT_CHANGE] = {
	120	.handler = uwbd_evt_handle_rc_bp_slot_change,
	121	.name = "BP_SLOT_CHANGE"
	122	},
	123	[UWB_RC_EVT_DRP_AVAIL] = {
	124	.handler = uwbd_evt_handle_rc_drp_avail,
	125	.name = "DRP_AVAILABILITY_CHANGE"
	126	},
	127	[UWB_RC_EVT_DRP] = {
	128	.handler = uwbd_evt_handle_rc_drp,
	129	.name = "DRP"
	130	},
	131	[UWB_RC_EVT_DEV_ADDR_CONFLICT] = {
	132	.handler = uwbd_evt_handle_rc_dev_addr_conflict,
	133	.name = "DEV_ADDR_CONFLICT",
	134	},
	135	};
	136
	137
	138
	139	struct uwbd_evt_type_handler {
	140	const char *name;
	141	struct uwbd_event *uwbd_events;
	142	size_t size;
	143	};
	144
bce83697 DV	145	/* Table of handlers for each UWBD Event type. */
	146	static struct uwbd_evt_type_handler uwbd_urc_evt_type_handlers[] = {
	147	[UWB_RC_CET_GENERAL] = {
	148	.name = "URC",
	149	.uwbd_events = uwbd_urc_events,
	150	.size = ARRAY_SIZE(uwbd_urc_events),
	151	},
183b9b59 IPG	152	};
183b9b59 IPG	153
183b9b59 IPG	154	static const struct uwbd_event uwbd_message_handlers[] = {
	155	[UWB_EVT_MSG_RESET] = {
	156	.handler = uwbd_msg_handle_reset,
	157	.name = "reset",
	158	},
	159	};
	160
bce83697	161	/*
183b9b59 IPG	162	* Handle an URC event passed to the UWB Daemon
	163	*
	164	* @evt: the event to handle
	165	* @returns: 0 if the event can be kfreed, !0 on the contrary
	166	* (somebody else took ownership) [coincidentally, returning
	167	* a <0 errno code will free it :)].
	168	*
	169	* Looks up the two indirection tables (one for the type, one for the
	170	* subtype) to decide which function handles it and then calls the
	171	* handler.
	172	*
	173	* The event structure passed to the event handler has the radio
	174	* controller in @evt->rc referenced. The reference will be dropped
	175	* once the handler returns, so if it needs it for longer (async),
	176	* it'll need to take another one.
	177	*/
	178	static
	179	int uwbd_event_handle_urc(struct uwb_event *evt)
	180	{
bce83697	181	int result = -EINVAL;
183b9b59 IPG	182	struct uwbd_evt_type_handler *type_table;
	183	uwbd_evt_handler_f handler;
	184	u8 type, context;
	185	u16 event;
	186
	187	type = evt->notif.rceb->bEventType;
	188	event = le16_to_cpu(evt->notif.rceb->wEvent);
	189	context = evt->notif.rceb->bEventContext;
	190
3fafdd7c	191	if (type >= ARRAY_SIZE(uwbd_urc_evt_type_handlers))
bce83697 DV	192	goto out;
	193	type_table = &uwbd_urc_evt_type_handlers[type];
	194	if (type_table->uwbd_events == NULL)
	195	goto out;
3fafdd7c	196	if (event >= type_table->size)
bce83697	197	goto out;
183b9b59	198	handler = type_table->uwbd_events[event].handler;
bce83697 DV	199	if (handler == NULL)
	200	goto out;
	201
	202	result = (*handler)(evt);
	203	out:
	204	if (result < 0)
	205	dev_err(&evt->rc->uwb_dev.dev,
	206	"UWBD: event 0x%02x/%04x/%02x, handling failed: %d\n",
	207	type, event, context, result);
	208	return result;
183b9b59 IPG	209	}
	210
	211	static void uwbd_event_handle_message(struct uwb_event *evt)
	212	{
	213	struct uwb_rc *rc;
	214	int result;
	215
	216	rc = evt->rc;
	217
	218	if (evt->message < 0 \|\| evt->message >= ARRAY_SIZE(uwbd_message_handlers)) {
	219	dev_err(&rc->uwb_dev.dev, "UWBD: invalid message type %d\n", evt->message);
	220	return;
	221	}
	222
183b9b59 IPG	223	result = uwbd_message_handlers[evt->message].handler(evt);
	224	if (result < 0)
	225	dev_err(&rc->uwb_dev.dev, "UWBD: '%s' message failed: %d\n",
	226	uwbd_message_handlers[evt->message].name, result);
183b9b59 IPG	227	}
	228
	229	static void uwbd_event_handle(struct uwb_event *evt)
	230	{
	231	struct uwb_rc *rc;
	232	int should_keep;
	233
	234	rc = evt->rc;
	235
	236	if (rc->ready) {
	237	switch (evt->type) {
	238	case UWB_EVT_TYPE_NOTIF:
	239	should_keep = uwbd_event_handle_urc(evt);
	240	if (should_keep <= 0)
	241	kfree(evt->notif.rceb);
	242	break;
	243	case UWB_EVT_TYPE_MSG:
	244	uwbd_event_handle_message(evt);
	245	break;
	246	default:
	247	dev_err(&rc->uwb_dev.dev, "UWBD: invalid event type %d\n", evt->type);
	248	break;
	249	}
	250	}
	251
	252	__uwb_rc_put(rc); /* for the __uwb_rc_get() in uwb_rc_notif_cb() */
	253	}
183b9b59 IPG	254
	255	/**
	256	* UWB Daemon
	257	*
	258	* Listens to all UWB notifications and takes care to track the state
06b72d06	259	* of the UWB neighbourhood for the kernel. When we do a run, we
183b9b59 IPG	260	* spinlock, move the list to a private copy and release the
	261	* lock. Hold it as little as possible. Not a conflict: it is
	262	* guaranteed we own the events in the private list.
	263	*
	264	* FIXME: should change so we don't have a 1HZ timer all the time, but
	265	* only if there are devices.
	266	*/
fec1a593	267	static int uwbd(void *param)
183b9b59	268	{
fec1a593	269	struct uwb_rc *rc = param;
183b9b59	270	unsigned long flags;
fec1a593	271	struct uwb_event *evt;
183b9b59	272	int should_stop = 0;
fec1a593	273
183b9b59 IPG	274	while (1) {
183b9b59 IPG	275	wait_event_interruptible_timeout(
fec1a593 SP	276	rc->uwbd.wq,
fec1a593 SP	277	!list_empty(&rc->uwbd.event_list)
183b9b59 IPG	278	\|\| (should_stop = kthread_should_stop()),
	279	HZ);
	280	if (should_stop)
	281	break;
183b9b59	282
fec1a593 SP	283	spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
	284	if (!list_empty(&rc->uwbd.event_list)) {
	285	evt = list_first_entry(&rc->uwbd.event_list, struct uwb_event, list_node);
183b9b59	286	list_del(&evt->list_node);
fec1a593 SP	287	} else
	288	evt = NULL;
	289	spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
	290
	291	if (evt) {
183b9b59 IPG	292	uwbd_event_handle(evt);
	293	kfree(evt);
	294	}
183b9b59	295
fec1a593	296	uwb_beca_purge(rc); /* Purge devices that left */
183b9b59 IPG	297	}
	298	return 0;
	299	}
	300
	301
	302	/** Start the UWB daemon */
fec1a593	303	void uwbd_start(struct uwb_rc *rc)
183b9b59	304	{
bbf26183 AK	305	struct task_struct *task = kthread_run(uwbd, rc, "uwbd");
	306	if (IS_ERR(task)) {
	307	rc->uwbd.task = NULL;
183b9b59 IPG	308	printk(KERN_ERR "UWB: Cannot start management daemon; "
183b9b59 IPG	309	"UWB won't work\n");
bbf26183 AK	310	} else {
bbf26183 AK	311	rc->uwbd.task = task;
fec1a593	312	rc->uwbd.pid = rc->uwbd.task->pid;
bbf26183	313	}
183b9b59 IPG	314	}
	315
	316	/* Stop the UWB daemon and free any unprocessed events */
fec1a593	317	void uwbd_stop(struct uwb_rc *rc)
183b9b59	318	{
bbf26183 AK	319	if (rc->uwbd.task)
bbf26183 AK	320	kthread_stop(rc->uwbd.task);
fec1a593	321	uwbd_flush(rc);
183b9b59 IPG	322	}
	323
	324	/*
	325	* Queue an event for the management daemon
	326	*
	327	* When some lower layer receives an event, it uses this function to
	328	* push it forward to the UWB daemon.
	329	*
	330	* Once you pass the event, you don't own it any more, but the daemon
	331	* does. It will uwb_event_free() it when done, so make sure you
	332	* uwb_event_alloc()ed it or bad things will happen.
	333	*
	334	* If the daemon is not running, we just free the event.
	335	*/
	336	void uwbd_event_queue(struct uwb_event *evt)
	337	{
fec1a593	338	struct uwb_rc *rc = evt->rc;
183b9b59	339	unsigned long flags;
fec1a593 SP	340
	341	spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
	342	if (rc->uwbd.pid != 0) {
	343	list_add(&evt->list_node, &rc->uwbd.event_list);
	344	wake_up_all(&rc->uwbd.wq);
183b9b59 IPG	345	} else {
	346	__uwb_rc_put(evt->rc);
	347	if (evt->type == UWB_EVT_TYPE_NOTIF)
	348	kfree(evt->notif.rceb);
	349	kfree(evt);
	350	}
fec1a593	351	spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
183b9b59 IPG	352	return;
	353	}
	354
	355	void uwbd_flush(struct uwb_rc *rc)
	356	{
	357	struct uwb_event evt, nxt;
	358
fec1a593 SP	359	spin_lock_irq(&rc->uwbd.event_list_lock);
fec1a593 SP	360	list_for_each_entry_safe(evt, nxt, &rc->uwbd.event_list, list_node) {
183b9b59 IPG	361	if (evt->rc == rc) {
	362	__uwb_rc_put(rc);
	363	list_del(&evt->list_node);
	364	if (evt->type == UWB_EVT_TYPE_NOTIF)
	365	kfree(evt->notif.rceb);
	366	kfree(evt);
	367	}
	368	}
fec1a593	369	spin_unlock_irq(&rc->uwbd.event_list_lock);
183b9b59	370	}