]>
Commit | Line | Data |
---|---|---|
183b9b59 IPG |
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 lenght, 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 | ||
72 | #include <linux/kthread.h> | |
73 | #include <linux/module.h> | |
74 | #include <linux/freezer.h> | |
75 | #include "uwb-internal.h" | |
76 | ||
77 | #define D_LOCAL 1 | |
78 | #include <linux/uwb/debug.h> | |
79 | ||
80 | ||
81 | /** | |
82 | * UWBD Event handler function signature | |
83 | * | |
84 | * Return !0 if the event needs not to be freed (ie the handler | |
85 | * takes/took care of it). 0 means the daemon code will free the | |
86 | * event. | |
87 | * | |
88 | * @evt->rc is already referenced and guaranteed to exist. See | |
89 | * uwb_evt_handle(). | |
90 | */ | |
91 | typedef int (*uwbd_evt_handler_f)(struct uwb_event *); | |
92 | ||
93 | /** | |
94 | * Properties of a UWBD event | |
95 | * | |
96 | * @handler: the function that will handle this event | |
97 | * @name: text name of event | |
98 | */ | |
99 | struct uwbd_event { | |
100 | uwbd_evt_handler_f handler; | |
101 | const char *name; | |
102 | }; | |
103 | ||
104 | /** Table of handlers for and properties of the UWBD Radio Control Events */ | |
105 | static | |
106 | struct uwbd_event uwbd_events[] = { | |
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 | ||
139 | struct uwbd_evt_type_handler { | |
140 | const char *name; | |
141 | struct uwbd_event *uwbd_events; | |
142 | size_t size; | |
143 | }; | |
144 | ||
145 | #define UWBD_EVT_TYPE_HANDLER(n,a) { \ | |
146 | .name = (n), \ | |
147 | .uwbd_events = (a), \ | |
148 | .size = sizeof(a)/sizeof((a)[0]) \ | |
149 | } | |
150 | ||
151 | ||
152 | /** Table of handlers for each UWBD Event type. */ | |
153 | static | |
154 | struct uwbd_evt_type_handler uwbd_evt_type_handlers[] = { | |
155 | [UWB_RC_CET_GENERAL] = UWBD_EVT_TYPE_HANDLER("RC", uwbd_events) | |
156 | }; | |
157 | ||
158 | static const | |
159 | size_t uwbd_evt_type_handlers_len = | |
160 | sizeof(uwbd_evt_type_handlers) / sizeof(uwbd_evt_type_handlers[0]); | |
161 | ||
162 | static const struct uwbd_event uwbd_message_handlers[] = { | |
163 | [UWB_EVT_MSG_RESET] = { | |
164 | .handler = uwbd_msg_handle_reset, | |
165 | .name = "reset", | |
166 | }, | |
167 | }; | |
168 | ||
169 | static DEFINE_MUTEX(uwbd_event_mutex); | |
170 | ||
171 | /** | |
172 | * Handle an URC event passed to the UWB Daemon | |
173 | * | |
174 | * @evt: the event to handle | |
175 | * @returns: 0 if the event can be kfreed, !0 on the contrary | |
176 | * (somebody else took ownership) [coincidentally, returning | |
177 | * a <0 errno code will free it :)]. | |
178 | * | |
179 | * Looks up the two indirection tables (one for the type, one for the | |
180 | * subtype) to decide which function handles it and then calls the | |
181 | * handler. | |
182 | * | |
183 | * The event structure passed to the event handler has the radio | |
184 | * controller in @evt->rc referenced. The reference will be dropped | |
185 | * once the handler returns, so if it needs it for longer (async), | |
186 | * it'll need to take another one. | |
187 | */ | |
188 | static | |
189 | int uwbd_event_handle_urc(struct uwb_event *evt) | |
190 | { | |
183b9b59 IPG |
191 | struct uwbd_evt_type_handler *type_table; |
192 | uwbd_evt_handler_f handler; | |
193 | u8 type, context; | |
194 | u16 event; | |
195 | ||
196 | type = evt->notif.rceb->bEventType; | |
197 | event = le16_to_cpu(evt->notif.rceb->wEvent); | |
198 | context = evt->notif.rceb->bEventContext; | |
199 | ||
200 | if (type > uwbd_evt_type_handlers_len) { | |
8092d7c9 | 201 | printk(KERN_ERR "UWBD: event type %u: unknown (too high)\n", type); |
183b9b59 IPG |
202 | return -EINVAL; |
203 | } | |
204 | type_table = &uwbd_evt_type_handlers[type]; | |
205 | if (type_table->uwbd_events == NULL) { | |
8092d7c9 | 206 | printk(KERN_ERR "UWBD: event type %u: unknown\n", type); |
183b9b59 IPG |
207 | return -EINVAL; |
208 | } | |
209 | if (event > type_table->size) { | |
8092d7c9 DV |
210 | printk(KERN_ERR "UWBD: event %s[%u]: unknown (too high)\n", |
211 | type_table->name, event); | |
183b9b59 IPG |
212 | return -EINVAL; |
213 | } | |
214 | handler = type_table->uwbd_events[event].handler; | |
215 | if (handler == NULL) { | |
8092d7c9 | 216 | printk(KERN_ERR "UWBD: event %s[%u]: unknown\n", type_table->name, event); |
183b9b59 IPG |
217 | return -EINVAL; |
218 | } | |
8092d7c9 | 219 | return (*handler)(evt); |
183b9b59 IPG |
220 | } |
221 | ||
222 | static void uwbd_event_handle_message(struct uwb_event *evt) | |
223 | { | |
224 | struct uwb_rc *rc; | |
225 | int result; | |
226 | ||
227 | rc = evt->rc; | |
228 | ||
229 | if (evt->message < 0 || evt->message >= ARRAY_SIZE(uwbd_message_handlers)) { | |
230 | dev_err(&rc->uwb_dev.dev, "UWBD: invalid message type %d\n", evt->message); | |
231 | return; | |
232 | } | |
233 | ||
234 | /* If this is a reset event we need to drop the | |
235 | * uwbd_event_mutex or it deadlocks when the reset handler | |
236 | * attempts to flush the uwbd events. */ | |
237 | if (evt->message == UWB_EVT_MSG_RESET) | |
238 | mutex_unlock(&uwbd_event_mutex); | |
239 | ||
240 | result = uwbd_message_handlers[evt->message].handler(evt); | |
241 | if (result < 0) | |
242 | dev_err(&rc->uwb_dev.dev, "UWBD: '%s' message failed: %d\n", | |
243 | uwbd_message_handlers[evt->message].name, result); | |
244 | ||
245 | if (evt->message == UWB_EVT_MSG_RESET) | |
246 | mutex_lock(&uwbd_event_mutex); | |
247 | } | |
248 | ||
249 | static void uwbd_event_handle(struct uwb_event *evt) | |
250 | { | |
251 | struct uwb_rc *rc; | |
252 | int should_keep; | |
253 | ||
254 | rc = evt->rc; | |
255 | ||
256 | if (rc->ready) { | |
257 | switch (evt->type) { | |
258 | case UWB_EVT_TYPE_NOTIF: | |
259 | should_keep = uwbd_event_handle_urc(evt); | |
260 | if (should_keep <= 0) | |
261 | kfree(evt->notif.rceb); | |
262 | break; | |
263 | case UWB_EVT_TYPE_MSG: | |
264 | uwbd_event_handle_message(evt); | |
265 | break; | |
266 | default: | |
267 | dev_err(&rc->uwb_dev.dev, "UWBD: invalid event type %d\n", evt->type); | |
268 | break; | |
269 | } | |
270 | } | |
271 | ||
272 | __uwb_rc_put(rc); /* for the __uwb_rc_get() in uwb_rc_notif_cb() */ | |
273 | } | |
274 | /* The UWB Daemon */ | |
275 | ||
276 | ||
277 | /** Daemon's PID: used to decide if we can queue or not */ | |
278 | static int uwbd_pid; | |
279 | /** Daemon's task struct for managing the kthread */ | |
280 | static struct task_struct *uwbd_task; | |
281 | /** Daemon's waitqueue for waiting for new events */ | |
282 | static DECLARE_WAIT_QUEUE_HEAD(uwbd_wq); | |
283 | /** Daemon's list of events; we queue/dequeue here */ | |
284 | static struct list_head uwbd_event_list = LIST_HEAD_INIT(uwbd_event_list); | |
285 | /** Daemon's list lock to protect concurent access */ | |
286 | static DEFINE_SPINLOCK(uwbd_event_list_lock); | |
287 | ||
288 | ||
289 | /** | |
290 | * UWB Daemon | |
291 | * | |
292 | * Listens to all UWB notifications and takes care to track the state | |
293 | * of the UWB neighboorhood for the kernel. When we do a run, we | |
294 | * spinlock, move the list to a private copy and release the | |
295 | * lock. Hold it as little as possible. Not a conflict: it is | |
296 | * guaranteed we own the events in the private list. | |
297 | * | |
298 | * FIXME: should change so we don't have a 1HZ timer all the time, but | |
299 | * only if there are devices. | |
300 | */ | |
301 | static int uwbd(void *unused) | |
302 | { | |
303 | unsigned long flags; | |
304 | struct list_head list = LIST_HEAD_INIT(list); | |
305 | struct uwb_event *evt, *nxt; | |
306 | int should_stop = 0; | |
307 | while (1) { | |
308 | wait_event_interruptible_timeout( | |
309 | uwbd_wq, | |
310 | !list_empty(&uwbd_event_list) | |
311 | || (should_stop = kthread_should_stop()), | |
312 | HZ); | |
313 | if (should_stop) | |
314 | break; | |
315 | try_to_freeze(); | |
316 | ||
317 | mutex_lock(&uwbd_event_mutex); | |
318 | spin_lock_irqsave(&uwbd_event_list_lock, flags); | |
319 | list_splice_init(&uwbd_event_list, &list); | |
320 | spin_unlock_irqrestore(&uwbd_event_list_lock, flags); | |
321 | list_for_each_entry_safe(evt, nxt, &list, list_node) { | |
322 | list_del(&evt->list_node); | |
323 | uwbd_event_handle(evt); | |
324 | kfree(evt); | |
325 | } | |
326 | mutex_unlock(&uwbd_event_mutex); | |
327 | ||
328 | uwb_beca_purge(); /* Purge devices that left */ | |
329 | } | |
330 | return 0; | |
331 | } | |
332 | ||
333 | ||
334 | /** Start the UWB daemon */ | |
335 | void uwbd_start(void) | |
336 | { | |
337 | uwbd_task = kthread_run(uwbd, NULL, "uwbd"); | |
338 | if (uwbd_task == NULL) | |
339 | printk(KERN_ERR "UWB: Cannot start management daemon; " | |
340 | "UWB won't work\n"); | |
341 | else | |
342 | uwbd_pid = uwbd_task->pid; | |
343 | } | |
344 | ||
345 | /* Stop the UWB daemon and free any unprocessed events */ | |
346 | void uwbd_stop(void) | |
347 | { | |
348 | unsigned long flags; | |
349 | struct uwb_event *evt, *nxt; | |
350 | kthread_stop(uwbd_task); | |
351 | spin_lock_irqsave(&uwbd_event_list_lock, flags); | |
352 | uwbd_pid = 0; | |
353 | list_for_each_entry_safe(evt, nxt, &uwbd_event_list, list_node) { | |
354 | if (evt->type == UWB_EVT_TYPE_NOTIF) | |
355 | kfree(evt->notif.rceb); | |
356 | kfree(evt); | |
357 | } | |
358 | spin_unlock_irqrestore(&uwbd_event_list_lock, flags); | |
359 | uwb_beca_release(); | |
360 | } | |
361 | ||
362 | /* | |
363 | * Queue an event for the management daemon | |
364 | * | |
365 | * When some lower layer receives an event, it uses this function to | |
366 | * push it forward to the UWB daemon. | |
367 | * | |
368 | * Once you pass the event, you don't own it any more, but the daemon | |
369 | * does. It will uwb_event_free() it when done, so make sure you | |
370 | * uwb_event_alloc()ed it or bad things will happen. | |
371 | * | |
372 | * If the daemon is not running, we just free the event. | |
373 | */ | |
374 | void uwbd_event_queue(struct uwb_event *evt) | |
375 | { | |
376 | unsigned long flags; | |
377 | spin_lock_irqsave(&uwbd_event_list_lock, flags); | |
378 | if (uwbd_pid != 0) { | |
379 | list_add(&evt->list_node, &uwbd_event_list); | |
380 | wake_up_all(&uwbd_wq); | |
381 | } else { | |
382 | __uwb_rc_put(evt->rc); | |
383 | if (evt->type == UWB_EVT_TYPE_NOTIF) | |
384 | kfree(evt->notif.rceb); | |
385 | kfree(evt); | |
386 | } | |
387 | spin_unlock_irqrestore(&uwbd_event_list_lock, flags); | |
388 | return; | |
389 | } | |
390 | ||
391 | void uwbd_flush(struct uwb_rc *rc) | |
392 | { | |
393 | struct uwb_event *evt, *nxt; | |
394 | ||
395 | mutex_lock(&uwbd_event_mutex); | |
396 | ||
397 | spin_lock_irq(&uwbd_event_list_lock); | |
398 | list_for_each_entry_safe(evt, nxt, &uwbd_event_list, list_node) { | |
399 | if (evt->rc == rc) { | |
400 | __uwb_rc_put(rc); | |
401 | list_del(&evt->list_node); | |
402 | if (evt->type == UWB_EVT_TYPE_NOTIF) | |
403 | kfree(evt->notif.rceb); | |
404 | kfree(evt); | |
405 | } | |
406 | } | |
407 | spin_unlock_irq(&uwbd_event_list_lock); | |
408 | ||
409 | mutex_unlock(&uwbd_event_mutex); | |
410 | } |