/* * Ultra Wide Band * Neighborhood Management Daemon * * Copyright (C) 2005-2006 Intel Corporation * Inaky Perez-Gonzalez * * 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 lenght, 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 #include #include #include "uwb-internal.h" #define D_LOCAL 1 #include /** * 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_events[] = { [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; }; #define UWBD_EVT_TYPE_HANDLER(n,a) { \ .name = (n), \ .uwbd_events = (a), \ .size = sizeof(a)/sizeof((a)[0]) \ } /** Table of handlers for each UWBD Event type. */ static struct uwbd_evt_type_handler uwbd_evt_type_handlers[] = { [UWB_RC_CET_GENERAL] = UWBD_EVT_TYPE_HANDLER("RC", uwbd_events) }; static const size_t uwbd_evt_type_handlers_len = sizeof(uwbd_evt_type_handlers) / sizeof(uwbd_evt_type_handlers[0]); static const struct uwbd_event uwbd_message_handlers[] = { [UWB_EVT_MSG_RESET] = { .handler = uwbd_msg_handle_reset, .name = "reset", }, }; static DEFINE_MUTEX(uwbd_event_mutex); /** * 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) { 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 > uwbd_evt_type_handlers_len) { printk(KERN_ERR "UWBD: event type %u: unknown (too high)\n", type); return -EINVAL; } type_table = &uwbd_evt_type_handlers[type]; if (type_table->uwbd_events == NULL) { printk(KERN_ERR "UWBD: event type %u: unknown\n", type); return -EINVAL; } if (event > type_table->size) { printk(KERN_ERR "UWBD: event %s[%u]: unknown (too high)\n", type_table->name, event); return -EINVAL; } handler = type_table->uwbd_events[event].handler; if (handler == NULL) { printk(KERN_ERR "UWBD: event %s[%u]: unknown\n", type_table->name, event); return -EINVAL; } return (*handler)(evt); } 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; } /* If this is a reset event we need to drop the * uwbd_event_mutex or it deadlocks when the reset handler * attempts to flush the uwbd events. */ if (evt->message == UWB_EVT_MSG_RESET) mutex_unlock(&uwbd_event_mutex); 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); if (evt->message == UWB_EVT_MSG_RESET) mutex_lock(&uwbd_event_mutex); } 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() */ } /* The UWB Daemon */ /** Daemon's PID: used to decide if we can queue or not */ static int uwbd_pid; /** Daemon's task struct for managing the kthread */ static struct task_struct *uwbd_task; /** Daemon's waitqueue for waiting for new events */ static DECLARE_WAIT_QUEUE_HEAD(uwbd_wq); /** Daemon's list of events; we queue/dequeue here */ static struct list_head uwbd_event_list = LIST_HEAD_INIT(uwbd_event_list); /** Daemon's list lock to protect concurent access */ static DEFINE_SPINLOCK(uwbd_event_list_lock); /** * UWB Daemon * * Listens to all UWB notifications and takes care to track the state * of the UWB neighboorhood 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 *unused) { unsigned long flags; struct list_head list = LIST_HEAD_INIT(list); struct uwb_event *evt, *nxt; int should_stop = 0; while (1) { wait_event_interruptible_timeout( uwbd_wq, !list_empty(&uwbd_event_list) || (should_stop = kthread_should_stop()), HZ); if (should_stop) break; try_to_freeze(); mutex_lock(&uwbd_event_mutex); spin_lock_irqsave(&uwbd_event_list_lock, flags); list_splice_init(&uwbd_event_list, &list); spin_unlock_irqrestore(&uwbd_event_list_lock, flags); list_for_each_entry_safe(evt, nxt, &list, list_node) { list_del(&evt->list_node); uwbd_event_handle(evt); kfree(evt); } mutex_unlock(&uwbd_event_mutex); uwb_beca_purge(); /* Purge devices that left */ } return 0; } /** Start the UWB daemon */ void uwbd_start(void) { uwbd_task = kthread_run(uwbd, NULL, "uwbd"); if (uwbd_task == NULL) printk(KERN_ERR "UWB: Cannot start management daemon; " "UWB won't work\n"); else uwbd_pid = uwbd_task->pid; } /* Stop the UWB daemon and free any unprocessed events */ void uwbd_stop(void) { unsigned long flags; struct uwb_event *evt, *nxt; kthread_stop(uwbd_task); spin_lock_irqsave(&uwbd_event_list_lock, flags); uwbd_pid = 0; list_for_each_entry_safe(evt, nxt, &uwbd_event_list, list_node) { if (evt->type == UWB_EVT_TYPE_NOTIF) kfree(evt->notif.rceb); kfree(evt); } spin_unlock_irqrestore(&uwbd_event_list_lock, flags); uwb_beca_release(); } /* * 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) { unsigned long flags; spin_lock_irqsave(&uwbd_event_list_lock, flags); if (uwbd_pid != 0) { list_add(&evt->list_node, &uwbd_event_list); wake_up_all(&uwbd_wq); } else { __uwb_rc_put(evt->rc); if (evt->type == UWB_EVT_TYPE_NOTIF) kfree(evt->notif.rceb); kfree(evt); } spin_unlock_irqrestore(&uwbd_event_list_lock, flags); return; } void uwbd_flush(struct uwb_rc *rc) { struct uwb_event *evt, *nxt; mutex_lock(&uwbd_event_mutex); spin_lock_irq(&uwbd_event_list_lock); list_for_each_entry_safe(evt, nxt, &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(&uwbd_event_list_lock); mutex_unlock(&uwbd_event_mutex); }