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 255static int uwbd(void *param) 256{ 257 struct uwb_rc *rc = param; 258 unsigned long flags; 259 struct uwb_event *evt; 260 int should_stop = 0; 261 262 while (1) { 263 wait_event_interruptible_timeout( 264 rc->uwbd.wq, 265 !list_empty(&rc->uwbd.event_list) 266 || (should_stop = kthread_should_stop()), 267 HZ); 268 if (should_stop) 269 break; 270 try_to_freeze(); 271 272 spin_lock_irqsave(&rc->uwbd.event_list_lock, flags); 273 if (!list_empty(&rc->uwbd.event_list)) { 274 evt = list_first_entry(&rc->uwbd.event_list, struct uwb_event, list_node); 275 list_del(&evt->list_node); 276 } else 277 evt = NULL; 278 spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags); 279 280 if (evt) { 281 uwbd_event_handle(evt); 282 kfree(evt); 283 } 284 285 uwb_beca_purge(rc); /* Purge devices that left */ 286 } 287 return 0; 288} 289 290 291/** Start the UWB daemon */ 292void uwbd_start(struct uwb_rc *rc) 293{ 294 rc->uwbd.task = kthread_run(uwbd, rc, "uwbd"); 295 if (rc->uwbd.task == NULL) 296 printk(KERN_ERR "UWB: Cannot start management daemon; " 297 "UWB won't work\n"); 298 else 299 rc->uwbd.pid = rc->uwbd.task->pid; 300} 301 302/* Stop the UWB daemon and free any unprocessed events */ 303void uwbd_stop(struct uwb_rc *rc) 304{ 305 kthread_stop(rc->uwbd.task); 306 uwbd_flush(rc); 307} 308 309/* 310 * Queue an event for the management daemon 311 * 312 * When some lower layer receives an event, it uses this function to 313 * push it forward to the UWB daemon. 314 * 315 * Once you pass the event, you don't own it any more, but the daemon 316 * does. It will uwb_event_free() it when done, so make sure you 317 * uwb_event_alloc()ed it or bad things will happen. 318 * 319 * If the daemon is not running, we just free the event. 320 */ 321void uwbd_event_queue(struct uwb_event *evt) 322{ 323 struct uwb_rc *rc = evt->rc; 324 unsigned long flags; 325 326 spin_lock_irqsave(&rc->uwbd.event_list_lock, flags); 327 if (rc->uwbd.pid != 0) { 328 list_add(&evt->list_node, &rc->uwbd.event_list); 329 wake_up_all(&rc->uwbd.wq); 330 } else { 331 __uwb_rc_put(evt->rc); 332 if (evt->type == UWB_EVT_TYPE_NOTIF) 333 kfree(evt->notif.rceb); 334 kfree(evt); 335 } 336 spin_unlock_irqrestore(&rc->uwbd.event_list_lock, flags); 337 return; 338} 339 340void uwbd_flush(struct uwb_rc *rc) 341{ 342 struct uwb_event *evt, *nxt; 343 344 spin_lock_irq(&rc->uwbd.event_list_lock); 345 list_for_each_entry_safe(evt, nxt, &rc->uwbd.event_list, list_node) { 346 if (evt->rc == rc) { 347 __uwb_rc_put(rc); 348 list_del(&evt->list_node); 349 if (evt->type == UWB_EVT_TYPE_NOTIF) 350 kfree(evt->notif.rceb); 351 kfree(evt); 352 } 353 } 354 spin_unlock_irq(&rc->uwbd.event_list_lock); 355} 356