Commit | Line | Data |
---|---|---|
0612edfd IPG |
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" | |
89 | #define D_LOCAL 0 | |
90 | #include <linux/uwb/debug.h> | |
91 | ||
92 | /* | |
93 | * UWB Radio Controller Notification/Event Handle | |
94 | * | |
95 | * Represents an entity waiting for an event coming from the UWB Radio | |
96 | * Controller with a given context id (context) and type (evt_type and | |
97 | * evt). On reception of the notification/event, the callback (cb) is | |
98 | * called with the event. | |
99 | * | |
100 | * If the timer expires before the event is received, the callback is | |
101 | * called with -ETIMEDOUT as the event size. | |
102 | */ | |
103 | struct uwb_rc_neh { | |
104 | struct kref kref; | |
105 | ||
106 | struct uwb_rc *rc; | |
107 | u8 evt_type; | |
108 | __le16 evt; | |
109 | u8 context; | |
110 | uwb_rc_cmd_cb_f cb; | |
111 | void *arg; | |
112 | ||
113 | struct timer_list timer; | |
114 | struct list_head list_node; | |
115 | }; | |
116 | ||
117 | static void uwb_rc_neh_timer(unsigned long arg); | |
118 | ||
119 | static void uwb_rc_neh_release(struct kref *kref) | |
120 | { | |
121 | struct uwb_rc_neh *neh = container_of(kref, struct uwb_rc_neh, kref); | |
122 | ||
123 | kfree(neh); | |
124 | } | |
125 | ||
126 | static void uwb_rc_neh_get(struct uwb_rc_neh *neh) | |
127 | { | |
128 | kref_get(&neh->kref); | |
129 | } | |
130 | ||
131 | /** | |
132 | * uwb_rc_neh_put - release reference to a neh | |
133 | * @neh: the neh | |
134 | */ | |
135 | void uwb_rc_neh_put(struct uwb_rc_neh *neh) | |
136 | { | |
137 | kref_put(&neh->kref, uwb_rc_neh_release); | |
138 | } | |
139 | ||
140 | ||
141 | /** | |
142 | * Assigns @neh a context id from @rc's pool | |
143 | * | |
144 | * @rc: UWB Radio Controller descriptor; @rc->neh_lock taken | |
145 | * @neh: Notification/Event Handle | |
146 | * @returns 0 if context id was assigned ok; < 0 errno on error (if | |
147 | * all the context IDs are taken). | |
148 | * | |
149 | * (assumes @wa is locked). | |
150 | * | |
151 | * NOTE: WUSB spec reserves context ids 0x00 for notifications and | |
152 | * 0xff is invalid, so they must not be used. Initialization | |
153 | * fills up those two in the bitmap so they are not allocated. | |
154 | * | |
155 | * We spread the allocation around to reduce the posiblity of two | |
156 | * consecutive opened @neh's getting the same context ID assigned (to | |
157 | * avoid surprises with late events that timed out long time ago). So | |
158 | * first we search from where @rc->ctx_roll is, if not found, we | |
159 | * search from zero. | |
160 | */ | |
161 | static | |
162 | int __uwb_rc_ctx_get(struct uwb_rc *rc, struct uwb_rc_neh *neh) | |
163 | { | |
164 | int result; | |
165 | result = find_next_zero_bit(rc->ctx_bm, UWB_RC_CTX_MAX, | |
166 | rc->ctx_roll++); | |
167 | if (result < UWB_RC_CTX_MAX) | |
168 | goto found; | |
169 | result = find_first_zero_bit(rc->ctx_bm, UWB_RC_CTX_MAX); | |
170 | if (result < UWB_RC_CTX_MAX) | |
171 | goto found; | |
172 | return -ENFILE; | |
173 | found: | |
174 | set_bit(result, rc->ctx_bm); | |
175 | neh->context = result; | |
176 | return 0; | |
177 | } | |
178 | ||
179 | ||
180 | /** Releases @neh's context ID back to @rc (@rc->neh_lock is locked). */ | |
181 | static | |
182 | void __uwb_rc_ctx_put(struct uwb_rc *rc, struct uwb_rc_neh *neh) | |
183 | { | |
184 | struct device *dev = &rc->uwb_dev.dev; | |
185 | if (neh->context == 0) | |
186 | return; | |
187 | if (test_bit(neh->context, rc->ctx_bm) == 0) { | |
188 | dev_err(dev, "context %u not set in bitmap\n", | |
189 | neh->context); | |
190 | WARN_ON(1); | |
191 | } | |
192 | clear_bit(neh->context, rc->ctx_bm); | |
193 | neh->context = 0; | |
194 | } | |
195 | ||
196 | /** | |
197 | * uwb_rc_neh_add - add a neh for a radio controller command | |
198 | * @rc: the radio controller | |
199 | * @cmd: the radio controller command | |
200 | * @expected_type: the type of the expected response event | |
201 | * @expected_event: the expected event ID | |
202 | * @cb: callback for when the event is received | |
203 | * @arg: argument for the callback | |
204 | * | |
205 | * Creates a neh and adds it to the list of those waiting for an | |
206 | * event. A context ID will be assigned to the command. | |
207 | */ | |
208 | struct uwb_rc_neh *uwb_rc_neh_add(struct uwb_rc *rc, struct uwb_rccb *cmd, | |
209 | u8 expected_type, u16 expected_event, | |
210 | uwb_rc_cmd_cb_f cb, void *arg) | |
211 | { | |
212 | int result; | |
213 | unsigned long flags; | |
214 | struct device *dev = &rc->uwb_dev.dev; | |
215 | struct uwb_rc_neh *neh; | |
216 | ||
217 | neh = kzalloc(sizeof(*neh), GFP_KERNEL); | |
218 | if (neh == NULL) { | |
219 | result = -ENOMEM; | |
220 | goto error_kzalloc; | |
221 | } | |
222 | ||
223 | kref_init(&neh->kref); | |
224 | INIT_LIST_HEAD(&neh->list_node); | |
225 | init_timer(&neh->timer); | |
226 | neh->timer.function = uwb_rc_neh_timer; | |
227 | neh->timer.data = (unsigned long)neh; | |
228 | ||
229 | neh->rc = rc; | |
230 | neh->evt_type = expected_type; | |
231 | neh->evt = cpu_to_le16(expected_event); | |
232 | neh->cb = cb; | |
233 | neh->arg = arg; | |
234 | ||
235 | spin_lock_irqsave(&rc->neh_lock, flags); | |
236 | result = __uwb_rc_ctx_get(rc, neh); | |
237 | if (result >= 0) { | |
238 | cmd->bCommandContext = neh->context; | |
239 | list_add_tail(&neh->list_node, &rc->neh_list); | |
240 | uwb_rc_neh_get(neh); | |
241 | } | |
242 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
243 | if (result < 0) | |
244 | goto error_ctx_get; | |
245 | ||
246 | return neh; | |
247 | ||
248 | error_ctx_get: | |
249 | kfree(neh); | |
250 | error_kzalloc: | |
251 | dev_err(dev, "cannot open handle to radio controller: %d\n", result); | |
252 | return ERR_PTR(result); | |
253 | } | |
254 | ||
255 | static void __uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh) | |
256 | { | |
257 | del_timer(&neh->timer); | |
258 | __uwb_rc_ctx_put(rc, neh); | |
259 | list_del(&neh->list_node); | |
260 | } | |
261 | ||
262 | /** | |
263 | * uwb_rc_neh_rm - remove a neh. | |
264 | * @rc: the radio controller | |
265 | * @neh: the neh to remove | |
266 | * | |
267 | * Remove an active neh immediately instead of waiting for the event | |
268 | * (or a time out). | |
269 | */ | |
270 | void uwb_rc_neh_rm(struct uwb_rc *rc, struct uwb_rc_neh *neh) | |
271 | { | |
272 | unsigned long flags; | |
273 | ||
274 | spin_lock_irqsave(&rc->neh_lock, flags); | |
275 | __uwb_rc_neh_rm(rc, neh); | |
276 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
277 | ||
278 | uwb_rc_neh_put(neh); | |
279 | } | |
280 | ||
281 | /** | |
282 | * uwb_rc_neh_arm - arm an event handler timeout timer | |
283 | * | |
284 | * @rc: UWB Radio Controller | |
285 | * @neh: Notification/event handler for @rc | |
286 | * | |
287 | * The timer is only armed if the neh is active. | |
288 | */ | |
289 | void uwb_rc_neh_arm(struct uwb_rc *rc, struct uwb_rc_neh *neh) | |
290 | { | |
291 | unsigned long flags; | |
292 | ||
293 | spin_lock_irqsave(&rc->neh_lock, flags); | |
294 | if (neh->context) | |
295 | mod_timer(&neh->timer, | |
296 | jiffies + msecs_to_jiffies(UWB_RC_CMD_TIMEOUT_MS)); | |
297 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
298 | } | |
299 | ||
300 | static void uwb_rc_neh_cb(struct uwb_rc_neh *neh, struct uwb_rceb *rceb, size_t size) | |
301 | { | |
302 | (*neh->cb)(neh->rc, neh->arg, rceb, size); | |
303 | uwb_rc_neh_put(neh); | |
304 | } | |
305 | ||
306 | static bool uwb_rc_neh_match(struct uwb_rc_neh *neh, const struct uwb_rceb *rceb) | |
307 | { | |
308 | return neh->evt_type == rceb->bEventType | |
309 | && neh->evt == rceb->wEvent | |
310 | && neh->context == rceb->bEventContext; | |
311 | } | |
312 | ||
313 | /** | |
314 | * Find the handle waiting for a RC Radio Control Event | |
315 | * | |
316 | * @rc: UWB Radio Controller | |
317 | * @rceb: Pointer to the RCEB buffer | |
318 | * @event_size: Pointer to the size of the RCEB buffer. Might be | |
319 | * adjusted to take into account the @neh->extra_size | |
320 | * settings. | |
321 | * | |
322 | * If the listener has no buffer (NULL buffer), one is allocated for | |
323 | * the right size (the amount of data received). @neh->ptr will point | |
324 | * to the event payload, which always starts with a 'struct | |
325 | * uwb_rceb'. kfree() it when done. | |
326 | */ | |
327 | static | |
328 | struct uwb_rc_neh *uwb_rc_neh_lookup(struct uwb_rc *rc, | |
329 | const struct uwb_rceb *rceb) | |
330 | { | |
331 | struct uwb_rc_neh *neh = NULL, *h; | |
332 | unsigned long flags; | |
333 | ||
334 | spin_lock_irqsave(&rc->neh_lock, flags); | |
335 | ||
336 | list_for_each_entry(h, &rc->neh_list, list_node) { | |
337 | if (uwb_rc_neh_match(h, rceb)) { | |
338 | neh = h; | |
339 | break; | |
340 | } | |
341 | } | |
342 | ||
343 | if (neh) | |
344 | __uwb_rc_neh_rm(rc, neh); | |
345 | ||
346 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
347 | ||
348 | return neh; | |
349 | } | |
350 | ||
351 | ||
352 | /** | |
353 | * Process notifications coming from the radio control interface | |
354 | * | |
355 | * @rc: UWB Radio Control Interface descriptor | |
356 | * @neh: Notification/Event Handler @neh->ptr points to | |
357 | * @uwb_evt->buffer. | |
358 | * | |
359 | * This function is called by the event/notif handling subsystem when | |
360 | * notifications arrive (hwarc_probe() arms a notification/event handle | |
361 | * that calls back this function for every received notification; this | |
362 | * function then will rearm itself). | |
363 | * | |
364 | * Notification data buffers are dynamically allocated by the NEH | |
365 | * handling code in neh.c [uwb_rc_neh_lookup()]. What is actually | |
366 | * allocated is space to contain the notification data. | |
367 | * | |
368 | * Buffers are prefixed with a Radio Control Event Block (RCEB) as | |
369 | * defined by the WUSB Wired-Adapter Radio Control interface. We | |
370 | * just use it for the notification code. | |
371 | * | |
372 | * On each case statement we just transcode endianess of the different | |
373 | * fields. We declare a pointer to a RCI definition of an event, and | |
374 | * then to a UWB definition of the same event (which are the same, | |
375 | * remember). Event if we use different pointers | |
376 | */ | |
377 | static | |
378 | void uwb_rc_notif(struct uwb_rc *rc, struct uwb_rceb *rceb, ssize_t size) | |
379 | { | |
380 | struct device *dev = &rc->uwb_dev.dev; | |
381 | struct uwb_event *uwb_evt; | |
382 | ||
383 | if (size == -ESHUTDOWN) | |
384 | return; | |
385 | if (size < 0) { | |
386 | dev_err(dev, "ignoring event with error code %zu\n", | |
387 | size); | |
388 | return; | |
389 | } | |
390 | ||
391 | uwb_evt = kzalloc(sizeof(*uwb_evt), GFP_ATOMIC); | |
392 | if (unlikely(uwb_evt == NULL)) { | |
393 | dev_err(dev, "no memory to queue event 0x%02x/%04x/%02x\n", | |
394 | rceb->bEventType, le16_to_cpu(rceb->wEvent), | |
395 | rceb->bEventContext); | |
396 | return; | |
397 | } | |
398 | uwb_evt->rc = __uwb_rc_get(rc); /* will be put by uwbd's uwbd_event_handle() */ | |
399 | uwb_evt->ts_jiffies = jiffies; | |
400 | uwb_evt->type = UWB_EVT_TYPE_NOTIF; | |
401 | uwb_evt->notif.size = size; | |
402 | uwb_evt->notif.rceb = rceb; | |
403 | ||
404 | switch (le16_to_cpu(rceb->wEvent)) { | |
405 | /* Trap some vendor specific events | |
406 | * | |
407 | * FIXME: move this to handling in ptc-est, where we | |
408 | * register a NULL event handler for these two guys | |
409 | * using the Intel IDs. | |
410 | */ | |
411 | case 0x0103: | |
412 | dev_info(dev, "FIXME: DEVICE ADD\n"); | |
413 | return; | |
414 | case 0x0104: | |
415 | dev_info(dev, "FIXME: DEVICE RM\n"); | |
416 | return; | |
417 | default: | |
418 | break; | |
419 | } | |
420 | ||
421 | uwbd_event_queue(uwb_evt); | |
422 | } | |
423 | ||
424 | static void uwb_rc_neh_grok_event(struct uwb_rc *rc, struct uwb_rceb *rceb, size_t size) | |
425 | { | |
426 | struct device *dev = &rc->uwb_dev.dev; | |
427 | struct uwb_rc_neh *neh; | |
428 | struct uwb_rceb *notif; | |
429 | ||
430 | if (rceb->bEventContext == 0) { | |
431 | notif = kmalloc(size, GFP_ATOMIC); | |
432 | if (notif) { | |
433 | memcpy(notif, rceb, size); | |
434 | uwb_rc_notif(rc, notif, size); | |
435 | } else | |
436 | dev_err(dev, "event 0x%02x/%04x/%02x (%zu bytes): no memory\n", | |
437 | rceb->bEventType, le16_to_cpu(rceb->wEvent), | |
438 | rceb->bEventContext, size); | |
439 | } else { | |
440 | neh = uwb_rc_neh_lookup(rc, rceb); | |
441 | if (neh) | |
442 | uwb_rc_neh_cb(neh, rceb, size); | |
8092d7c9 | 443 | else |
0612edfd IPG |
444 | dev_warn(dev, "event 0x%02x/%04x/%02x (%zu bytes): nobody cared\n", |
445 | rceb->bEventType, le16_to_cpu(rceb->wEvent), | |
446 | rceb->bEventContext, size); | |
447 | } | |
448 | } | |
449 | ||
450 | /** | |
451 | * Given a buffer with one or more UWB RC events/notifications, break | |
452 | * them up and dispatch them. | |
453 | * | |
454 | * @rc: UWB Radio Controller | |
455 | * @buf: Buffer with the stream of notifications/events | |
456 | * @buf_size: Amount of data in the buffer | |
457 | * | |
458 | * Note each notification/event starts always with a 'struct | |
459 | * uwb_rceb', so the minimum size if 4 bytes. | |
460 | * | |
461 | * The device may pass us events formatted differently than expected. | |
462 | * These are first filtered, potentially creating a new event in a new | |
463 | * memory location. If a new event is created by the filter it is also | |
464 | * freed here. | |
465 | * | |
466 | * For each notif/event, tries to guess the size looking at the EST | |
467 | * tables, then looks for a neh that is waiting for that event and if | |
468 | * found, copies the payload to the neh's buffer and calls it back. If | |
469 | * not, the data is ignored. | |
470 | * | |
471 | * Note that if we can't find a size description in the EST tables, we | |
472 | * still might find a size in the 'neh' handle in uwb_rc_neh_lookup(). | |
473 | * | |
474 | * Assumptions: | |
475 | * | |
476 | * @rc->neh_lock is NOT taken | |
477 | * | |
478 | * We keep track of various sizes here: | |
479 | * size: contains the size of the buffer that is processed for the | |
480 | * incoming event. this buffer may contain events that are not | |
481 | * formatted as WHCI. | |
482 | * real_size: the actual space taken by this event in the buffer. | |
483 | * We need to keep track of the real size of an event to be able to | |
484 | * advance the buffer correctly. | |
485 | * event_size: the size of the event as expected by the core layer | |
486 | * [OR] the size of the event after filtering. if the filtering | |
487 | * created a new event in a new memory location then this is | |
488 | * effectively the size of a new event buffer | |
489 | */ | |
490 | void uwb_rc_neh_grok(struct uwb_rc *rc, void *buf, size_t buf_size) | |
491 | { | |
492 | struct device *dev = &rc->uwb_dev.dev; | |
493 | void *itr; | |
494 | struct uwb_rceb *rceb; | |
495 | size_t size, real_size, event_size; | |
496 | int needtofree; | |
497 | ||
498 | d_fnstart(3, dev, "(rc %p buf %p %zu buf_size)\n", rc, buf, buf_size); | |
499 | d_printf(2, dev, "groking event block: %zu bytes\n", buf_size); | |
500 | itr = buf; | |
501 | size = buf_size; | |
502 | while (size > 0) { | |
503 | if (size < sizeof(*rceb)) { | |
504 | dev_err(dev, "not enough data in event buffer to " | |
505 | "process incoming events (%zu left, minimum is " | |
506 | "%zu)\n", size, sizeof(*rceb)); | |
507 | break; | |
508 | } | |
509 | ||
510 | rceb = itr; | |
511 | if (rc->filter_event) { | |
512 | needtofree = rc->filter_event(rc, &rceb, size, | |
513 | &real_size, &event_size); | |
514 | if (needtofree < 0 && needtofree != -ENOANO) { | |
515 | dev_err(dev, "BUG: Unable to filter event " | |
516 | "(0x%02x/%04x/%02x) from " | |
517 | "device. \n", rceb->bEventType, | |
518 | le16_to_cpu(rceb->wEvent), | |
519 | rceb->bEventContext); | |
520 | break; | |
521 | } | |
522 | } else | |
523 | needtofree = -ENOANO; | |
524 | /* do real processing if there was no filtering or the | |
525 | * filtering didn't act */ | |
526 | if (needtofree == -ENOANO) { | |
527 | ssize_t ret = uwb_est_find_size(rc, rceb, size); | |
528 | if (ret < 0) | |
529 | break; | |
530 | if (ret > size) { | |
531 | dev_err(dev, "BUG: hw sent incomplete event " | |
532 | "0x%02x/%04x/%02x (%zd bytes), only got " | |
533 | "%zu bytes. We don't handle that.\n", | |
534 | rceb->bEventType, le16_to_cpu(rceb->wEvent), | |
535 | rceb->bEventContext, ret, size); | |
536 | break; | |
537 | } | |
538 | real_size = event_size = ret; | |
539 | } | |
540 | uwb_rc_neh_grok_event(rc, rceb, event_size); | |
541 | ||
542 | if (needtofree == 1) | |
543 | kfree(rceb); | |
544 | ||
545 | itr += real_size; | |
546 | size -= real_size; | |
547 | d_printf(2, dev, "consumed %zd bytes, %zu left\n", | |
548 | event_size, size); | |
549 | } | |
550 | d_fnend(3, dev, "(rc %p buf %p %zu buf_size) = void\n", rc, buf, buf_size); | |
551 | } | |
552 | EXPORT_SYMBOL_GPL(uwb_rc_neh_grok); | |
553 | ||
554 | ||
555 | /** | |
556 | * The entity that reads from the device notification/event channel has | |
557 | * detected an error. | |
558 | * | |
559 | * @rc: UWB Radio Controller | |
560 | * @error: Errno error code | |
561 | * | |
562 | */ | |
563 | void uwb_rc_neh_error(struct uwb_rc *rc, int error) | |
564 | { | |
565 | struct uwb_rc_neh *neh, *next; | |
566 | unsigned long flags; | |
567 | ||
568 | BUG_ON(error >= 0); | |
569 | spin_lock_irqsave(&rc->neh_lock, flags); | |
570 | list_for_each_entry_safe(neh, next, &rc->neh_list, list_node) { | |
571 | __uwb_rc_neh_rm(rc, neh); | |
572 | uwb_rc_neh_cb(neh, NULL, error); | |
573 | } | |
574 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
575 | } | |
576 | EXPORT_SYMBOL_GPL(uwb_rc_neh_error); | |
577 | ||
578 | ||
579 | static void uwb_rc_neh_timer(unsigned long arg) | |
580 | { | |
581 | struct uwb_rc_neh *neh = (struct uwb_rc_neh *)arg; | |
582 | struct uwb_rc *rc = neh->rc; | |
583 | unsigned long flags; | |
584 | ||
585 | spin_lock_irqsave(&rc->neh_lock, flags); | |
586 | __uwb_rc_neh_rm(rc, neh); | |
587 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
588 | ||
589 | uwb_rc_neh_cb(neh, NULL, -ETIMEDOUT); | |
590 | } | |
591 | ||
592 | /** Initializes the @rc's neh subsystem | |
593 | */ | |
594 | void uwb_rc_neh_create(struct uwb_rc *rc) | |
595 | { | |
596 | spin_lock_init(&rc->neh_lock); | |
597 | INIT_LIST_HEAD(&rc->neh_list); | |
598 | set_bit(0, rc->ctx_bm); /* 0 is reserved (see [WUSB] table 8-65) */ | |
599 | set_bit(0xff, rc->ctx_bm); /* and 0xff is invalid */ | |
600 | rc->ctx_roll = 1; | |
601 | } | |
602 | ||
603 | ||
604 | /** Release's the @rc's neh subsystem */ | |
605 | void uwb_rc_neh_destroy(struct uwb_rc *rc) | |
606 | { | |
607 | unsigned long flags; | |
608 | struct uwb_rc_neh *neh, *next; | |
609 | ||
610 | spin_lock_irqsave(&rc->neh_lock, flags); | |
611 | list_for_each_entry_safe(neh, next, &rc->neh_list, list_node) { | |
612 | __uwb_rc_neh_rm(rc, neh); | |
613 | uwb_rc_neh_put(neh); | |
614 | } | |
615 | spin_unlock_irqrestore(&rc->neh_lock, flags); | |
616 | } |