linux/drivers/uwb/uwbd.c
<<
>>
Prefs
   1/*
   2 * Ultra Wide Band
   3 * Neighborhood Management Daemon
   4 *
   5 * Copyright (C) 2005-2006 Intel Corporation
   6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   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 *
  46 * Events have a type, a subtype, a length, some other stuff and the
  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 */
  71#include <linux/kthread.h>
  72#include <linux/slab.h>
  73#include <linux/module.h>
  74#include <linux/freezer.h>
  75
  76#include "uwb-internal.h"
  77
  78/*
  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 */
  88typedef 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 */
  96struct uwbd_event {
  97        uwbd_evt_handler_f handler;
  98        const char *name;
  99};
 100
 101/* Table of handlers for and properties of the UWBD Radio Control Events */
 102static struct uwbd_event uwbd_urc_events[] = {
 103        [UWB_RC_EVT_IE_RCV] = {
 104                .handler = uwbd_evt_handle_rc_ie_rcv,
 105                .name = "IE_RECEIVED"
 106        },
 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
 139struct uwbd_evt_type_handler {
 140        const char *name;
 141        struct uwbd_event *uwbd_events;
 142        size_t size;
 143};
 144
 145/* Table of handlers for each UWBD Event type. */
 146static 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        },
 152};
 153
 154static const struct uwbd_event uwbd_message_handlers[] = {
 155        [UWB_EVT_MSG_RESET] = {
 156                .handler = uwbd_msg_handle_reset,
 157                .name = "reset",
 158        },
 159};
 160
 161/*
 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 */
 178static
 179int uwbd_event_handle_urc(struct uwb_event *evt)
 180{
 181        int result = -EINVAL;
 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
 191        if (type >= ARRAY_SIZE(uwbd_urc_evt_type_handlers))
 192                goto out;
 193        type_table = &uwbd_urc_evt_type_handlers[type];
 194        if (type_table->uwbd_events == NULL)
 195                goto out;
 196        if (event >= type_table->size)
 197                goto out;
 198        handler = type_table->uwbd_events[event].handler;
 199        if (handler == NULL)
 200                goto out;
 201
 202        result = (*handler)(evt);
 203out:
 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;
 209}
 210
 211static 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
 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);
 227}
 228
 229static 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}
 254
 255/**
 256 * UWB Daemon
 257 *
 258 * Listens to all UWB notifications and takes care to track the state
 259 * of the UWB neighbourhood for the kernel. When we do a run, we
 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 */
 267static int uwbd(void *param)
 268{
 269        struct uwb_rc *rc = param;
 270        unsigned long flags;
 271        struct uwb_event *evt;
 272        int should_stop = 0;
 273
 274        while (1) {
 275                wait_event_interruptible_timeout(
 276                        rc->uwbd.wq,
 277                        !list_empty(&rc->uwbd.event_list)
 278                          || (should_stop = kthread_should_stop()),
 279                        HZ);
 280                if (should_stop)
 281                        break;
 282                try_to_freeze();
 283
 284                spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
 285                if (!list_empty(&rc->uwbd.event_list)) {
 286                        evt = list_first_entry(&rc->uwbd.event_list, struct uwb_event, list_node);
 287                        list_del(&evt->list_node);
 288                } else
 289                        evt = NULL;
 290                spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
 291
 292                if (evt) {
 293                        uwbd_event_handle(evt);
 294                        kfree(evt);
 295                }
 296
 297                uwb_beca_purge(rc);     /* Purge devices that left */
 298        }
 299        return 0;
 300}
 301
 302
 303/** Start the UWB daemon */
 304void uwbd_start(struct uwb_rc *rc)
 305{
 306        rc->uwbd.task = kthread_run(uwbd, rc, "uwbd");
 307        if (rc->uwbd.task == NULL)
 308                printk(KERN_ERR "UWB: Cannot start management daemon; "
 309                       "UWB won't work\n");
 310        else
 311                rc->uwbd.pid = rc->uwbd.task->pid;
 312}
 313
 314/* Stop the UWB daemon and free any unprocessed events */
 315void uwbd_stop(struct uwb_rc *rc)
 316{
 317        kthread_stop(rc->uwbd.task);
 318        uwbd_flush(rc);
 319}
 320
 321/*
 322 * Queue an event for the management daemon
 323 *
 324 * When some lower layer receives an event, it uses this function to
 325 * push it forward to the UWB daemon.
 326 *
 327 * Once you pass the event, you don't own it any more, but the daemon
 328 * does. It will uwb_event_free() it when done, so make sure you
 329 * uwb_event_alloc()ed it or bad things will happen.
 330 *
 331 * If the daemon is not running, we just free the event.
 332 */
 333void uwbd_event_queue(struct uwb_event *evt)
 334{
 335        struct uwb_rc *rc = evt->rc;
 336        unsigned long flags;
 337
 338        spin_lock_irqsave(&rc->uwbd.event_list_lock, flags);
 339        if (rc->uwbd.pid != 0) {
 340                list_add(&evt->list_node, &rc->uwbd.event_list);
 341                wake_up_all(&rc->uwbd.wq);
 342        } else {
 343                __uwb_rc_put(evt->rc);
 344                if (evt->type == UWB_EVT_TYPE_NOTIF)
 345                        kfree(evt->notif.rceb);
 346                kfree(evt);
 347        }
 348        spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags);
 349        return;
 350}
 351
 352void uwbd_flush(struct uwb_rc *rc)
 353{
 354        struct uwb_event *evt, *nxt;
 355
 356        spin_lock_irq(&rc->uwbd.event_list_lock);
 357        list_for_each_entry_safe(evt, nxt, &rc->uwbd.event_list, list_node) {
 358                if (evt->rc == rc) {
 359                        __uwb_rc_put(rc);
 360                        list_del(&evt->list_node);
 361                        if (evt->type == UWB_EVT_TYPE_NOTIF)
 362                                kfree(evt->notif.rceb);
 363                        kfree(evt);
 364                }
 365        }
 366        spin_unlock_irq(&rc->uwbd.event_list_lock);
 367}
 368
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.