Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 1 | /* |
| 2 | * WUSB Wire Adapter: Radio Control Interface (WUSB[8]) |
| 3 | * Notification and Event Handling |
| 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 | * The RC interface of the Host Wire Adapter (USB dongle) or WHCI PCI |
| 24 | * card delivers a stream of notifications and events to the |
| 25 | * notification end event endpoint or area. This code takes care of |
| 26 | * getting a buffer with that data, breaking it up in separate |
| 27 | * notifications and events and then deliver those. |
| 28 | * |
| 29 | * Events are answers to commands and they carry a context ID that |
| 30 | * associates them to the command. Notifications are that, |
| 31 | * notifications, they come out of the blue and have a context ID of |
| 32 | * zero. Think of the context ID kind of like a handler. The |
| 33 | * uwb_rc_neh_* code deals with managing context IDs. |
| 34 | * |
| 35 | * This is why you require a handle to operate on a UWB host. When you |
| 36 | * open a handle a context ID is assigned to you. |
| 37 | * |
| 38 | * So, as it is done is: |
| 39 | * |
| 40 | * 1. Add an event handler [uwb_rc_neh_add()] (assigns a ctx id) |
| 41 | * 2. Issue command [rc->cmd(rc, ...)] |
| 42 | * 3. Arm the timeout timer [uwb_rc_neh_arm()] |
| 43 | * 4, Release the reference to the neh [uwb_rc_neh_put()] |
| 44 | * 5. Wait for the callback |
| 45 | * 6. Command result (RCEB) is passed to the callback |
| 46 | * |
| 47 | * If (2) fails, you should remove the handle [uwb_rc_neh_rm()] |
| 48 | * instead of arming the timer. |
| 49 | * |
| 50 | * Handles are for using in *serialized* code, single thread. |
| 51 | * |
| 52 | * When the notification/event comes, the IRQ handler/endpoint |
| 53 | * callback passes the data read to uwb_rc_neh_grok() which will break |
| 54 | * it up in a discrete series of events, look up who is listening for |
| 55 | * them and execute the pertinent callbacks. |
| 56 | * |
| 57 | * If the reader detects an error while reading the data stream, call |
| 58 | * uwb_rc_neh_error(). |
| 59 | * |
| 60 | * CONSTRAINTS/ASSUMPTIONS: |
| 61 | * |
| 62 | * - Most notifications/events are small (less thank .5k), copying |
| 63 | * around is ok. |
| 64 | * |
| 65 | * - Notifications/events are ALWAYS smaller than PAGE_SIZE |
| 66 | * |
| 67 | * - Notifications/events always come in a single piece (ie: a buffer |
| 68 | * will always contain entire notifications/events). |
| 69 | * |
| 70 | * - we cannot know in advance how long each event is (because they |
| 71 | * lack a length field in their header--smart move by the standards |
| 72 | * body, btw). So we need a facility to get the event size given the |
| 73 | * header. This is what the EST code does (notif/Event Size |
| 74 | * Tables), check nest.c--as well, you can associate the size to |
| 75 | * the handle [w/ neh->extra_size()]. |
| 76 | * |
| 77 | * - Most notifications/events are fixed size; only a few are variable |
| 78 | * size (NEST takes care of that). |
| 79 | * |
| 80 | * - Listeners of events expect them, so they usually provide a |
| 81 | * buffer, as they know the size. Listeners to notifications don't, |
| 82 | * so we allocate their buffers dynamically. |
| 83 | */ |
| 84 | #include <linux/kernel.h> |
| 85 | #include <linux/timer.h> |
| 86 | #include <linux/err.h> |
| 87 | |
| 88 | #include "uwb-internal.h" |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 89 | |
| 90 | /* |
| 91 | * UWB Radio Controller Notification/Event Handle |
| 92 | * |
| 93 | * Represents an entity waiting for an event coming from the UWB Radio |
| 94 | * Controller with a given context id (context) and type (evt_type and |
| 95 | * evt). On reception of the notification/event, the callback (cb) is |
| 96 | * called with the event. |
| 97 | * |
| 98 | * If the timer expires before the event is received, the callback is |
| 99 | * called with -ETIMEDOUT as the event size. |
| 100 | */ |
| 101 | struct uwb_rc_neh { |
| 102 | struct kref kref; |
| 103 | |
| 104 | struct uwb_rc *rc; |
| 105 | u8 evt_type; |
| 106 | __le16 evt; |
| 107 | u8 context; |
| 108 | uwb_rc_cmd_cb_f cb; |
| 109 | void *arg; |
| 110 | |
| 111 | struct timer_list timer; |
| 112 | struct list_head list_node; |
| 113 | }; |
| 114 | |
| 115 | static void uwb_rc_neh_timer(unsigned long arg); |
| 116 | |
| 117 | static void uwb_rc_neh_release(struct kref *kref) |
| 118 | { |
| 119 | struct uwb_rc_neh *neh = container_of(kref, struct uwb_rc_neh, kref); |
| 120 | |
| 121 | kfree(neh); |
| 122 | } |
| 123 | |
| 124 | static void uwb_rc_neh_get(struct uwb_rc_neh *neh) |
| 125 | { |
| 126 | kref_get(&neh->kref); |
| 127 | } |
| 128 | |
| 129 | /** |
| 130 | * uwb_rc_neh_put - release reference to a neh |
| 131 | * @neh: the neh |
| 132 | */ |
| 133 | void uwb_rc_neh_put(struct uwb_rc_neh *neh) |
| 134 | { |
| 135 | kref_put(&neh->kref, uwb_rc_neh_release); |
| 136 | } |
| 137 | |
| 138 | |
| 139 | /** |
| 140 | * Assigns @neh a context id from @rc's pool |
| 141 | * |
| 142 | * @rc: UWB Radio Controller descriptor; @rc->neh_lock taken |
| 143 | * @neh: Notification/Event Handle |
| 144 | * @returns 0 if context id was assigned ok; < 0 errno on error (if |
| 145 | * all the context IDs are taken). |
| 146 | * |
| 147 | * (assumes @wa is locked). |
| 148 | * |
| 149 | * NOTE: WUSB spec reserves context ids 0x00 for notifications and |
| 150 | * 0xff is invalid, so they must not be used. Initialization |
| 151 | * fills up those two in the bitmap so they are not allocated. |
| 152 | * |
Dirk Hohndel | 06fe9fb | 2009-09-28 21:43:57 -0400 | [diff] [blame] | 153 | * We spread the allocation around to reduce the possibility of two |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 154 | * consecutive opened @neh's getting the same context ID assigned (to |
| 155 | * avoid surprises with late events that timed out long time ago). So |
| 156 | * first we search from where @rc->ctx_roll is, if not found, we |
| 157 | * search from zero. |
| 158 | */ |
| 159 | static |
| 160 | int __uwb_rc_ctx_get(struct uwb_rc *rc, struct uwb_rc_neh *neh) |
| 161 | { |
| 162 | int result; |
| 163 | result = find_next_zero_bit(rc->ctx_bm, UWB_RC_CTX_MAX, |
| 164 | rc->ctx_roll++); |
| 165 | if (result < UWB_RC_CTX_MAX) |
| 166 | goto found; |
| 167 | result = find_first_zero_bit(rc->ctx_bm, UWB_RC_CTX_MAX); |
| 168 | if (result < UWB_RC_CTX_MAX) |
| 169 | goto found; |
| 170 | return -ENFILE; |
| 171 | found: |
| 172 | set_bit(result, rc->ctx_bm); |
| 173 | neh->context = result; |
| 174 | return 0; |
| 175 | } |
| 176 | |
| 177 | |
| 178 | /** Releases @neh's context ID back to @rc (@rc->neh_lock is locked). */ |
| 179 | static |
| 180 | void __uwb_rc_ctx_put(struct uwb_rc *rc, struct uwb_rc_neh *neh) |
| 181 | { |
| 182 | struct device *dev = &rc->uwb_dev.dev; |
| 183 | if (neh->context == 0) |
| 184 | return; |
| 185 | if (test_bit(neh->context, rc->ctx_bm) == 0) { |
| 186 | dev_err(dev, "context %u not set in bitmap\n", |
| 187 | neh->context); |
| 188 | WARN_ON(1); |
| 189 | } |
| 190 | clear_bit(neh->context, rc->ctx_bm); |
| 191 | neh->context = 0; |
| 192 | } |
| 193 | |
| 194 | /** |
| 195 | * uwb_rc_neh_add - add a neh for a radio controller command |
| 196 | * @rc: the radio controller |
| 197 | * @cmd: the radio controller command |
| 198 | * @expected_type: the type of the expected response event |
| 199 | * @expected_event: the expected event ID |
| 200 | * @cb: callback for when the event is received |
| 201 | * @arg: argument for the callback |
| 202 | * |
| 203 | * Creates a neh and adds it to the list of those waiting for an |
| 204 | * event. A context ID will be assigned to the command. |
| 205 | */ |
| 206 | struct uwb_rc_neh *uwb_rc_neh_add(struct uwb_rc *rc, struct uwb_rccb *cmd, |
| 207 | u8 expected_type, u16 expected_event, |
| 208 | uwb_rc_cmd_cb_f cb, void *arg) |
| 209 | { |
| 210 | int result; |
| 211 | unsigned long flags; |
| 212 | struct device *dev = &rc->uwb_dev.dev; |
| 213 | struct uwb_rc_neh *neh; |
| 214 | |
| 215 | neh = kzalloc(sizeof(*neh), GFP_KERNEL); |
| 216 | if (neh == NULL) { |
| 217 | result = -ENOMEM; |
| 218 | goto error_kzalloc; |
| 219 | } |
| 220 | |
| 221 | kref_init(&neh->kref); |
| 222 | INIT_LIST_HEAD(&neh->list_node); |
| 223 | init_timer(&neh->timer); |
| 224 | neh->timer.function = uwb_rc_neh_timer; |
| 225 | neh->timer.data = (unsigned long)neh; |
| 226 | |
| 227 | neh->rc = rc; |
| 228 | neh->evt_type = expected_type; |
| 229 | neh->evt = cpu_to_le16(expected_event); |
| 230 | neh->cb = cb; |
| 231 | neh->arg = arg; |
| 232 | |
| 233 | spin_lock_irqsave(&rc->neh_lock, flags); |
| 234 | result = __uwb_rc_ctx_get(rc, neh); |
| 235 | if (result >= 0) { |
| 236 | cmd->bCommandContext = neh->context; |
| 237 | list_add_tail(&neh->list_node, &rc->neh_list); |
| 238 | uwb_rc_neh_get(neh); |
| 239 | } |
| 240 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 241 | if (result < 0) |
| 242 | goto error_ctx_get; |
| 243 | |
| 244 | return neh; |
| 245 | |
| 246 | error_ctx_get: |
| 247 | kfree(neh); |
| 248 | error_kzalloc: |
| 249 | dev_err(dev, "cannot open handle to radio controller: %d\n", result); |
| 250 | return ERR_PTR(result); |
| 251 | } |
| 252 | |
| 253 | static void __uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh) |
| 254 | { |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 255 | __uwb_rc_ctx_put(rc, neh); |
| 256 | list_del(&neh->list_node); |
| 257 | } |
| 258 | |
| 259 | /** |
| 260 | * uwb_rc_neh_rm - remove a neh. |
| 261 | * @rc: the radio controller |
| 262 | * @neh: the neh to remove |
| 263 | * |
| 264 | * Remove an active neh immediately instead of waiting for the event |
| 265 | * (or a time out). |
| 266 | */ |
| 267 | void uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh) |
| 268 | { |
| 269 | unsigned long flags; |
| 270 | |
| 271 | spin_lock_irqsave(&rc->neh_lock, flags); |
| 272 | __uwb_rc_neh_rm(rc, neh); |
| 273 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 274 | |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 275 | del_timer_sync(&neh->timer); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 276 | uwb_rc_neh_put(neh); |
| 277 | } |
| 278 | |
| 279 | /** |
| 280 | * uwb_rc_neh_arm - arm an event handler timeout timer |
| 281 | * |
| 282 | * @rc: UWB Radio Controller |
| 283 | * @neh: Notification/event handler for @rc |
| 284 | * |
| 285 | * The timer is only armed if the neh is active. |
| 286 | */ |
| 287 | void uwb_rc_neh_arm(struct uwb_rc *rc, struct uwb_rc_neh *neh) |
| 288 | { |
| 289 | unsigned long flags; |
| 290 | |
| 291 | spin_lock_irqsave(&rc->neh_lock, flags); |
| 292 | if (neh->context) |
| 293 | mod_timer(&neh->timer, |
| 294 | jiffies + msecs_to_jiffies(UWB_RC_CMD_TIMEOUT_MS)); |
| 295 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 296 | } |
| 297 | |
| 298 | static void uwb_rc_neh_cb(struct uwb_rc_neh *neh, struct uwb_rceb *rceb, size_t size) |
| 299 | { |
| 300 | (*neh->cb)(neh->rc, neh->arg, rceb, size); |
| 301 | uwb_rc_neh_put(neh); |
| 302 | } |
| 303 | |
| 304 | static bool uwb_rc_neh_match(struct uwb_rc_neh *neh, const struct uwb_rceb *rceb) |
| 305 | { |
| 306 | return neh->evt_type == rceb->bEventType |
| 307 | && neh->evt == rceb->wEvent |
| 308 | && neh->context == rceb->bEventContext; |
| 309 | } |
| 310 | |
| 311 | /** |
| 312 | * Find the handle waiting for a RC Radio Control Event |
| 313 | * |
| 314 | * @rc: UWB Radio Controller |
| 315 | * @rceb: Pointer to the RCEB buffer |
| 316 | * @event_size: Pointer to the size of the RCEB buffer. Might be |
| 317 | * adjusted to take into account the @neh->extra_size |
| 318 | * settings. |
| 319 | * |
| 320 | * If the listener has no buffer (NULL buffer), one is allocated for |
| 321 | * the right size (the amount of data received). @neh->ptr will point |
| 322 | * to the event payload, which always starts with a 'struct |
| 323 | * uwb_rceb'. kfree() it when done. |
| 324 | */ |
| 325 | static |
| 326 | struct uwb_rc_neh *uwb_rc_neh_lookup(struct uwb_rc *rc, |
| 327 | const struct uwb_rceb *rceb) |
| 328 | { |
| 329 | struct uwb_rc_neh *neh = NULL, *h; |
| 330 | unsigned long flags; |
| 331 | |
| 332 | spin_lock_irqsave(&rc->neh_lock, flags); |
| 333 | |
| 334 | list_for_each_entry(h, &rc->neh_list, list_node) { |
| 335 | if (uwb_rc_neh_match(h, rceb)) { |
| 336 | neh = h; |
| 337 | break; |
| 338 | } |
| 339 | } |
| 340 | |
| 341 | if (neh) |
| 342 | __uwb_rc_neh_rm(rc, neh); |
| 343 | |
| 344 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 345 | |
| 346 | return neh; |
| 347 | } |
| 348 | |
| 349 | |
David Vrabel | 02f11ee | 2008-12-12 13:28:48 +0000 | [diff] [blame] | 350 | /* |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 351 | * Process notifications coming from the radio control interface |
| 352 | * |
| 353 | * @rc: UWB Radio Control Interface descriptor |
| 354 | * @neh: Notification/Event Handler @neh->ptr points to |
| 355 | * @uwb_evt->buffer. |
| 356 | * |
| 357 | * This function is called by the event/notif handling subsystem when |
| 358 | * notifications arrive (hwarc_probe() arms a notification/event handle |
| 359 | * that calls back this function for every received notification; this |
| 360 | * function then will rearm itself). |
| 361 | * |
| 362 | * Notification data buffers are dynamically allocated by the NEH |
| 363 | * handling code in neh.c [uwb_rc_neh_lookup()]. What is actually |
| 364 | * allocated is space to contain the notification data. |
| 365 | * |
| 366 | * Buffers are prefixed with a Radio Control Event Block (RCEB) as |
| 367 | * defined by the WUSB Wired-Adapter Radio Control interface. We |
| 368 | * just use it for the notification code. |
| 369 | * |
| 370 | * On each case statement we just transcode endianess of the different |
| 371 | * fields. We declare a pointer to a RCI definition of an event, and |
| 372 | * then to a UWB definition of the same event (which are the same, |
| 373 | * remember). Event if we use different pointers |
| 374 | */ |
| 375 | static |
| 376 | void uwb_rc_notif(struct uwb_rc *rc, struct uwb_rceb *rceb, ssize_t size) |
| 377 | { |
| 378 | struct device *dev = &rc->uwb_dev.dev; |
| 379 | struct uwb_event *uwb_evt; |
| 380 | |
| 381 | if (size == -ESHUTDOWN) |
| 382 | return; |
| 383 | if (size < 0) { |
| 384 | dev_err(dev, "ignoring event with error code %zu\n", |
| 385 | size); |
| 386 | return; |
| 387 | } |
| 388 | |
| 389 | uwb_evt = kzalloc(sizeof(*uwb_evt), GFP_ATOMIC); |
| 390 | if (unlikely(uwb_evt == NULL)) { |
| 391 | dev_err(dev, "no memory to queue event 0x%02x/%04x/%02x\n", |
| 392 | rceb->bEventType, le16_to_cpu(rceb->wEvent), |
| 393 | rceb->bEventContext); |
| 394 | return; |
| 395 | } |
| 396 | uwb_evt->rc = __uwb_rc_get(rc); /* will be put by uwbd's uwbd_event_handle() */ |
| 397 | uwb_evt->ts_jiffies = jiffies; |
| 398 | uwb_evt->type = UWB_EVT_TYPE_NOTIF; |
| 399 | uwb_evt->notif.size = size; |
| 400 | uwb_evt->notif.rceb = rceb; |
| 401 | |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 402 | uwbd_event_queue(uwb_evt); |
| 403 | } |
| 404 | |
| 405 | static void uwb_rc_neh_grok_event(struct uwb_rc *rc, struct uwb_rceb *rceb, size_t size) |
| 406 | { |
| 407 | struct device *dev = &rc->uwb_dev.dev; |
| 408 | struct uwb_rc_neh *neh; |
| 409 | struct uwb_rceb *notif; |
| 410 | |
| 411 | if (rceb->bEventContext == 0) { |
| 412 | notif = kmalloc(size, GFP_ATOMIC); |
| 413 | if (notif) { |
| 414 | memcpy(notif, rceb, size); |
| 415 | uwb_rc_notif(rc, notif, size); |
| 416 | } else |
| 417 | dev_err(dev, "event 0x%02x/%04x/%02x (%zu bytes): no memory\n", |
| 418 | rceb->bEventType, le16_to_cpu(rceb->wEvent), |
| 419 | rceb->bEventContext, size); |
| 420 | } else { |
| 421 | neh = uwb_rc_neh_lookup(rc, rceb); |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 422 | if (neh) { |
| 423 | del_timer_sync(&neh->timer); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 424 | uwb_rc_neh_cb(neh, rceb, size); |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 425 | } else |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 426 | dev_warn(dev, "event 0x%02x/%04x/%02x (%zu bytes): nobody cared\n", |
| 427 | rceb->bEventType, le16_to_cpu(rceb->wEvent), |
| 428 | rceb->bEventContext, size); |
| 429 | } |
| 430 | } |
| 431 | |
| 432 | /** |
| 433 | * Given a buffer with one or more UWB RC events/notifications, break |
| 434 | * them up and dispatch them. |
| 435 | * |
| 436 | * @rc: UWB Radio Controller |
| 437 | * @buf: Buffer with the stream of notifications/events |
| 438 | * @buf_size: Amount of data in the buffer |
| 439 | * |
| 440 | * Note each notification/event starts always with a 'struct |
| 441 | * uwb_rceb', so the minimum size if 4 bytes. |
| 442 | * |
| 443 | * The device may pass us events formatted differently than expected. |
| 444 | * These are first filtered, potentially creating a new event in a new |
| 445 | * memory location. If a new event is created by the filter it is also |
| 446 | * freed here. |
| 447 | * |
| 448 | * For each notif/event, tries to guess the size looking at the EST |
| 449 | * tables, then looks for a neh that is waiting for that event and if |
| 450 | * found, copies the payload to the neh's buffer and calls it back. If |
| 451 | * not, the data is ignored. |
| 452 | * |
| 453 | * Note that if we can't find a size description in the EST tables, we |
| 454 | * still might find a size in the 'neh' handle in uwb_rc_neh_lookup(). |
| 455 | * |
| 456 | * Assumptions: |
| 457 | * |
| 458 | * @rc->neh_lock is NOT taken |
| 459 | * |
| 460 | * We keep track of various sizes here: |
| 461 | * size: contains the size of the buffer that is processed for the |
| 462 | * incoming event. this buffer may contain events that are not |
| 463 | * formatted as WHCI. |
| 464 | * real_size: the actual space taken by this event in the buffer. |
| 465 | * We need to keep track of the real size of an event to be able to |
| 466 | * advance the buffer correctly. |
| 467 | * event_size: the size of the event as expected by the core layer |
| 468 | * [OR] the size of the event after filtering. if the filtering |
| 469 | * created a new event in a new memory location then this is |
| 470 | * effectively the size of a new event buffer |
| 471 | */ |
| 472 | void uwb_rc_neh_grok(struct uwb_rc *rc, void *buf, size_t buf_size) |
| 473 | { |
| 474 | struct device *dev = &rc->uwb_dev.dev; |
| 475 | void *itr; |
| 476 | struct uwb_rceb *rceb; |
| 477 | size_t size, real_size, event_size; |
| 478 | int needtofree; |
| 479 | |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 480 | itr = buf; |
| 481 | size = buf_size; |
| 482 | while (size > 0) { |
| 483 | if (size < sizeof(*rceb)) { |
| 484 | dev_err(dev, "not enough data in event buffer to " |
| 485 | "process incoming events (%zu left, minimum is " |
| 486 | "%zu)\n", size, sizeof(*rceb)); |
| 487 | break; |
| 488 | } |
| 489 | |
| 490 | rceb = itr; |
| 491 | if (rc->filter_event) { |
| 492 | needtofree = rc->filter_event(rc, &rceb, size, |
| 493 | &real_size, &event_size); |
| 494 | if (needtofree < 0 && needtofree != -ENOANO) { |
| 495 | dev_err(dev, "BUG: Unable to filter event " |
| 496 | "(0x%02x/%04x/%02x) from " |
| 497 | "device. \n", rceb->bEventType, |
| 498 | le16_to_cpu(rceb->wEvent), |
| 499 | rceb->bEventContext); |
| 500 | break; |
| 501 | } |
| 502 | } else |
| 503 | needtofree = -ENOANO; |
| 504 | /* do real processing if there was no filtering or the |
| 505 | * filtering didn't act */ |
| 506 | if (needtofree == -ENOANO) { |
| 507 | ssize_t ret = uwb_est_find_size(rc, rceb, size); |
| 508 | if (ret < 0) |
| 509 | break; |
| 510 | if (ret > size) { |
| 511 | dev_err(dev, "BUG: hw sent incomplete event " |
| 512 | "0x%02x/%04x/%02x (%zd bytes), only got " |
| 513 | "%zu bytes. We don't handle that.\n", |
| 514 | rceb->bEventType, le16_to_cpu(rceb->wEvent), |
| 515 | rceb->bEventContext, ret, size); |
| 516 | break; |
| 517 | } |
| 518 | real_size = event_size = ret; |
| 519 | } |
| 520 | uwb_rc_neh_grok_event(rc, rceb, event_size); |
| 521 | |
| 522 | if (needtofree == 1) |
| 523 | kfree(rceb); |
| 524 | |
| 525 | itr += real_size; |
| 526 | size -= real_size; |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 527 | } |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 528 | } |
| 529 | EXPORT_SYMBOL_GPL(uwb_rc_neh_grok); |
| 530 | |
| 531 | |
| 532 | /** |
| 533 | * The entity that reads from the device notification/event channel has |
| 534 | * detected an error. |
| 535 | * |
| 536 | * @rc: UWB Radio Controller |
| 537 | * @error: Errno error code |
| 538 | * |
| 539 | */ |
| 540 | void uwb_rc_neh_error(struct uwb_rc *rc, int error) |
| 541 | { |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 542 | struct uwb_rc_neh *neh; |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 543 | unsigned long flags; |
| 544 | |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 545 | for (;;) { |
| 546 | spin_lock_irqsave(&rc->neh_lock, flags); |
| 547 | if (list_empty(&rc->neh_list)) { |
| 548 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 549 | break; |
| 550 | } |
| 551 | neh = list_first_entry(&rc->neh_list, struct uwb_rc_neh, list_node); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 552 | __uwb_rc_neh_rm(rc, neh); |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 553 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 554 | |
| 555 | del_timer_sync(&neh->timer); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 556 | uwb_rc_neh_cb(neh, NULL, error); |
| 557 | } |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 558 | } |
| 559 | EXPORT_SYMBOL_GPL(uwb_rc_neh_error); |
| 560 | |
| 561 | |
| 562 | static void uwb_rc_neh_timer(unsigned long arg) |
| 563 | { |
| 564 | struct uwb_rc_neh *neh = (struct uwb_rc_neh *)arg; |
| 565 | struct uwb_rc *rc = neh->rc; |
| 566 | unsigned long flags; |
| 567 | |
| 568 | spin_lock_irqsave(&rc->neh_lock, flags); |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 569 | if (neh->context) |
| 570 | __uwb_rc_neh_rm(rc, neh); |
| 571 | else |
| 572 | neh = NULL; |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 573 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 574 | |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 575 | if (neh) |
| 576 | uwb_rc_neh_cb(neh, NULL, -ETIMEDOUT); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 577 | } |
| 578 | |
| 579 | /** Initializes the @rc's neh subsystem |
| 580 | */ |
| 581 | void uwb_rc_neh_create(struct uwb_rc *rc) |
| 582 | { |
| 583 | spin_lock_init(&rc->neh_lock); |
| 584 | INIT_LIST_HEAD(&rc->neh_list); |
| 585 | set_bit(0, rc->ctx_bm); /* 0 is reserved (see [WUSB] table 8-65) */ |
| 586 | set_bit(0xff, rc->ctx_bm); /* and 0xff is invalid */ |
| 587 | rc->ctx_roll = 1; |
| 588 | } |
| 589 | |
| 590 | |
| 591 | /** Release's the @rc's neh subsystem */ |
| 592 | void uwb_rc_neh_destroy(struct uwb_rc *rc) |
| 593 | { |
| 594 | unsigned long flags; |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 595 | struct uwb_rc_neh *neh; |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 596 | |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 597 | for (;;) { |
| 598 | spin_lock_irqsave(&rc->neh_lock, flags); |
| 599 | if (list_empty(&rc->neh_list)) { |
| 600 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 601 | break; |
| 602 | } |
| 603 | neh = list_first_entry(&rc->neh_list, struct uwb_rc_neh, list_node); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 604 | __uwb_rc_neh_rm(rc, neh); |
David Vrabel | 58be81ed | 2008-11-07 18:19:19 +0000 | [diff] [blame] | 605 | spin_unlock_irqrestore(&rc->neh_lock, flags); |
| 606 | |
| 607 | del_timer_sync(&neh->timer); |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 608 | uwb_rc_neh_put(neh); |
| 609 | } |
Inaky Perez-Gonzalez | 0612edf | 2008-09-17 16:34:07 +0100 | [diff] [blame] | 610 | } |