Root/
1 | /* |
2 | * Ultra Wide Band Radio Control |
3 | * Event Size Tables management |
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 | * FIXME: docs |
24 | * |
25 | * Infrastructure, code and data tables for guessing the size of |
26 | * events received on the notification endpoints of UWB radio |
27 | * controllers. |
28 | * |
29 | * You define a table of events and for each, its size and how to get |
30 | * the extra size. |
31 | * |
32 | * ENTRY POINTS: |
33 | * |
34 | * uwb_est_{init/destroy}(): To initialize/release the EST subsystem. |
35 | * |
36 | * uwb_est_[u]register(): To un/register event size tables |
37 | * uwb_est_grow() |
38 | * |
39 | * uwb_est_find_size(): Get the size of an event |
40 | * uwb_est_get_size() |
41 | */ |
42 | #include <linux/spinlock.h> |
43 | #include <linux/slab.h> |
44 | #include <linux/export.h> |
45 | |
46 | #include "uwb-internal.h" |
47 | |
48 | struct uwb_est { |
49 | u16 type_event_high; |
50 | u16 vendor, product; |
51 | u8 entries; |
52 | const struct uwb_est_entry *entry; |
53 | }; |
54 | |
55 | static struct uwb_est *uwb_est; |
56 | static u8 uwb_est_size; |
57 | static u8 uwb_est_used; |
58 | static DEFINE_RWLOCK(uwb_est_lock); |
59 | |
60 | /** |
61 | * WUSB Standard Event Size Table, HWA-RC interface |
62 | * |
63 | * Sizes for events and notifications type 0 (general), high nibble 0. |
64 | */ |
65 | static |
66 | struct uwb_est_entry uwb_est_00_00xx[] = { |
67 | [UWB_RC_EVT_IE_RCV] = { |
68 | .size = sizeof(struct uwb_rc_evt_ie_rcv), |
69 | .offset = 1 + offsetof(struct uwb_rc_evt_ie_rcv, wIELength), |
70 | }, |
71 | [UWB_RC_EVT_BEACON] = { |
72 | .size = sizeof(struct uwb_rc_evt_beacon), |
73 | .offset = 1 + offsetof(struct uwb_rc_evt_beacon, wBeaconInfoLength), |
74 | }, |
75 | [UWB_RC_EVT_BEACON_SIZE] = { |
76 | .size = sizeof(struct uwb_rc_evt_beacon_size), |
77 | }, |
78 | [UWB_RC_EVT_BPOIE_CHANGE] = { |
79 | .size = sizeof(struct uwb_rc_evt_bpoie_change), |
80 | .offset = 1 + offsetof(struct uwb_rc_evt_bpoie_change, |
81 | wBPOIELength), |
82 | }, |
83 | [UWB_RC_EVT_BP_SLOT_CHANGE] = { |
84 | .size = sizeof(struct uwb_rc_evt_bp_slot_change), |
85 | }, |
86 | [UWB_RC_EVT_BP_SWITCH_IE_RCV] = { |
87 | .size = sizeof(struct uwb_rc_evt_bp_switch_ie_rcv), |
88 | .offset = 1 + offsetof(struct uwb_rc_evt_bp_switch_ie_rcv, wIELength), |
89 | }, |
90 | [UWB_RC_EVT_DEV_ADDR_CONFLICT] = { |
91 | .size = sizeof(struct uwb_rc_evt_dev_addr_conflict), |
92 | }, |
93 | [UWB_RC_EVT_DRP_AVAIL] = { |
94 | .size = sizeof(struct uwb_rc_evt_drp_avail) |
95 | }, |
96 | [UWB_RC_EVT_DRP] = { |
97 | .size = sizeof(struct uwb_rc_evt_drp), |
98 | .offset = 1 + offsetof(struct uwb_rc_evt_drp, ie_length), |
99 | }, |
100 | [UWB_RC_EVT_BP_SWITCH_STATUS] = { |
101 | .size = sizeof(struct uwb_rc_evt_bp_switch_status), |
102 | }, |
103 | [UWB_RC_EVT_CMD_FRAME_RCV] = { |
104 | .size = sizeof(struct uwb_rc_evt_cmd_frame_rcv), |
105 | .offset = 1 + offsetof(struct uwb_rc_evt_cmd_frame_rcv, dataLength), |
106 | }, |
107 | [UWB_RC_EVT_CHANNEL_CHANGE_IE_RCV] = { |
108 | .size = sizeof(struct uwb_rc_evt_channel_change_ie_rcv), |
109 | .offset = 1 + offsetof(struct uwb_rc_evt_channel_change_ie_rcv, wIELength), |
110 | }, |
111 | [UWB_RC_CMD_CHANNEL_CHANGE] = { |
112 | .size = sizeof(struct uwb_rc_evt_confirm), |
113 | }, |
114 | [UWB_RC_CMD_DEV_ADDR_MGMT] = { |
115 | .size = sizeof(struct uwb_rc_evt_dev_addr_mgmt) }, |
116 | [UWB_RC_CMD_GET_IE] = { |
117 | .size = sizeof(struct uwb_rc_evt_get_ie), |
118 | .offset = 1 + offsetof(struct uwb_rc_evt_get_ie, wIELength), |
119 | }, |
120 | [UWB_RC_CMD_RESET] = { |
121 | .size = sizeof(struct uwb_rc_evt_confirm), |
122 | }, |
123 | [UWB_RC_CMD_SCAN] = { |
124 | .size = sizeof(struct uwb_rc_evt_confirm), |
125 | }, |
126 | [UWB_RC_CMD_SET_BEACON_FILTER] = { |
127 | .size = sizeof(struct uwb_rc_evt_confirm), |
128 | }, |
129 | [UWB_RC_CMD_SET_DRP_IE] = { |
130 | .size = sizeof(struct uwb_rc_evt_set_drp_ie), |
131 | }, |
132 | [UWB_RC_CMD_SET_IE] = { |
133 | .size = sizeof(struct uwb_rc_evt_set_ie), |
134 | }, |
135 | [UWB_RC_CMD_SET_NOTIFICATION_FILTER] = { |
136 | .size = sizeof(struct uwb_rc_evt_confirm), |
137 | }, |
138 | [UWB_RC_CMD_SET_TX_POWER] = { |
139 | .size = sizeof(struct uwb_rc_evt_confirm), |
140 | }, |
141 | [UWB_RC_CMD_SLEEP] = { |
142 | .size = sizeof(struct uwb_rc_evt_confirm), |
143 | }, |
144 | [UWB_RC_CMD_START_BEACON] = { |
145 | .size = sizeof(struct uwb_rc_evt_confirm), |
146 | }, |
147 | [UWB_RC_CMD_STOP_BEACON] = { |
148 | .size = sizeof(struct uwb_rc_evt_confirm), |
149 | }, |
150 | [UWB_RC_CMD_BP_MERGE] = { |
151 | .size = sizeof(struct uwb_rc_evt_confirm), |
152 | }, |
153 | [UWB_RC_CMD_SEND_COMMAND_FRAME] = { |
154 | .size = sizeof(struct uwb_rc_evt_confirm), |
155 | }, |
156 | [UWB_RC_CMD_SET_ASIE_NOTIF] = { |
157 | .size = sizeof(struct uwb_rc_evt_confirm), |
158 | }, |
159 | }; |
160 | |
161 | static |
162 | struct uwb_est_entry uwb_est_01_00xx[] = { |
163 | [UWB_RC_DAA_ENERGY_DETECTED] = { |
164 | .size = sizeof(struct uwb_rc_evt_daa_energy_detected), |
165 | }, |
166 | [UWB_RC_SET_DAA_ENERGY_MASK] = { |
167 | .size = sizeof(struct uwb_rc_evt_set_daa_energy_mask), |
168 | }, |
169 | [UWB_RC_SET_NOTIFICATION_FILTER_EX] = { |
170 | .size = sizeof(struct uwb_rc_evt_set_notification_filter_ex), |
171 | }, |
172 | }; |
173 | |
174 | /** |
175 | * Initialize the EST subsystem |
176 | * |
177 | * Register the standard tables also. |
178 | * |
179 | * FIXME: tag init |
180 | */ |
181 | int uwb_est_create(void) |
182 | { |
183 | int result; |
184 | |
185 | uwb_est_size = 2; |
186 | uwb_est_used = 0; |
187 | uwb_est = kcalloc(uwb_est_size, sizeof(uwb_est[0]), GFP_KERNEL); |
188 | if (uwb_est == NULL) |
189 | return -ENOMEM; |
190 | |
191 | result = uwb_est_register(UWB_RC_CET_GENERAL, 0, 0xffff, 0xffff, |
192 | uwb_est_00_00xx, ARRAY_SIZE(uwb_est_00_00xx)); |
193 | if (result < 0) |
194 | goto out; |
195 | result = uwb_est_register(UWB_RC_CET_EX_TYPE_1, 0, 0xffff, 0xffff, |
196 | uwb_est_01_00xx, ARRAY_SIZE(uwb_est_01_00xx)); |
197 | out: |
198 | return result; |
199 | } |
200 | |
201 | |
202 | /** Clean it up */ |
203 | void uwb_est_destroy(void) |
204 | { |
205 | kfree(uwb_est); |
206 | uwb_est = NULL; |
207 | uwb_est_size = uwb_est_used = 0; |
208 | } |
209 | |
210 | |
211 | /** |
212 | * Double the capacity of the EST table |
213 | * |
214 | * @returns 0 if ok, < 0 errno no error. |
215 | */ |
216 | static |
217 | int uwb_est_grow(void) |
218 | { |
219 | size_t actual_size = uwb_est_size * sizeof(uwb_est[0]); |
220 | void *new = kmalloc(2 * actual_size, GFP_ATOMIC); |
221 | if (new == NULL) |
222 | return -ENOMEM; |
223 | memcpy(new, uwb_est, actual_size); |
224 | memset(new + actual_size, 0, actual_size); |
225 | kfree(uwb_est); |
226 | uwb_est = new; |
227 | uwb_est_size *= 2; |
228 | return 0; |
229 | } |
230 | |
231 | |
232 | /** |
233 | * Register an event size table |
234 | * |
235 | * Makes room for it if the table is full, and then inserts it in the |
236 | * right position (entries are sorted by type, event_high, vendor and |
237 | * then product). |
238 | * |
239 | * @vendor: vendor code for matching against the device (0x0000 and |
240 | * 0xffff mean any); use 0x0000 to force all to match without |
241 | * checking possible vendor specific ones, 0xfffff to match |
242 | * after checking vendor specific ones. |
243 | * |
244 | * @product: product code from that vendor; same matching rules, use |
245 | * 0x0000 for not allowing vendor specific matches, 0xffff |
246 | * for allowing. |
247 | * |
248 | * This arragement just makes the tables sort differenty. Because the |
249 | * table is sorted by growing type-event_high-vendor-product, a zero |
250 | * vendor will match before than a 0x456a vendor, that will match |
251 | * before a 0xfffff vendor. |
252 | * |
253 | * @returns 0 if ok, < 0 errno on error (-ENOENT if not found). |
254 | */ |
255 | /* FIXME: add bus type to vendor/product code */ |
256 | int uwb_est_register(u8 type, u8 event_high, u16 vendor, u16 product, |
257 | const struct uwb_est_entry *entry, size_t entries) |
258 | { |
259 | unsigned long flags; |
260 | unsigned itr; |
261 | u16 type_event_high; |
262 | int result = 0; |
263 | |
264 | write_lock_irqsave(&uwb_est_lock, flags); |
265 | if (uwb_est_used == uwb_est_size) { |
266 | result = uwb_est_grow(); |
267 | if (result < 0) |
268 | goto out; |
269 | } |
270 | /* Find the right spot to insert it in */ |
271 | type_event_high = type << 8 | event_high; |
272 | for (itr = 0; itr < uwb_est_used; itr++) |
273 | if (uwb_est[itr].type_event_high < type |
274 | && uwb_est[itr].vendor < vendor |
275 | && uwb_est[itr].product < product) |
276 | break; |
277 | |
278 | /* Shift others to make room for the new one? */ |
279 | if (itr < uwb_est_used) |
280 | memmove(&uwb_est[itr+1], &uwb_est[itr], uwb_est_used - itr); |
281 | uwb_est[itr].type_event_high = type << 8 | event_high; |
282 | uwb_est[itr].vendor = vendor; |
283 | uwb_est[itr].product = product; |
284 | uwb_est[itr].entry = entry; |
285 | uwb_est[itr].entries = entries; |
286 | uwb_est_used++; |
287 | out: |
288 | write_unlock_irqrestore(&uwb_est_lock, flags); |
289 | return result; |
290 | } |
291 | EXPORT_SYMBOL_GPL(uwb_est_register); |
292 | |
293 | |
294 | /** |
295 | * Unregister an event size table |
296 | * |
297 | * This just removes the specified entry and moves the ones after it |
298 | * to fill in the gap. This is needed to keep the list sorted; no |
299 | * reallocation is done to reduce the size of the table. |
300 | * |
301 | * We unregister by all the data we used to register instead of by |
302 | * pointer to the @entry array because we might have used the same |
303 | * table for a bunch of IDs (for example). |
304 | * |
305 | * @returns 0 if ok, < 0 errno on error (-ENOENT if not found). |
306 | */ |
307 | int uwb_est_unregister(u8 type, u8 event_high, u16 vendor, u16 product, |
308 | const struct uwb_est_entry *entry, size_t entries) |
309 | { |
310 | unsigned long flags; |
311 | unsigned itr; |
312 | struct uwb_est est_cmp = { |
313 | .type_event_high = type << 8 | event_high, |
314 | .vendor = vendor, |
315 | .product = product, |
316 | .entry = entry, |
317 | .entries = entries |
318 | }; |
319 | write_lock_irqsave(&uwb_est_lock, flags); |
320 | for (itr = 0; itr < uwb_est_used; itr++) |
321 | if (!memcmp(&uwb_est[itr], &est_cmp, sizeof(est_cmp))) |
322 | goto found; |
323 | write_unlock_irqrestore(&uwb_est_lock, flags); |
324 | return -ENOENT; |
325 | |
326 | found: |
327 | if (itr < uwb_est_used - 1) /* Not last one? move ones above */ |
328 | memmove(&uwb_est[itr], &uwb_est[itr+1], uwb_est_used - itr - 1); |
329 | uwb_est_used--; |
330 | write_unlock_irqrestore(&uwb_est_lock, flags); |
331 | return 0; |
332 | } |
333 | EXPORT_SYMBOL_GPL(uwb_est_unregister); |
334 | |
335 | |
336 | /** |
337 | * Get the size of an event from a table |
338 | * |
339 | * @rceb: pointer to the buffer with the event |
340 | * @rceb_size: size of the area pointed to by @rceb in bytes. |
341 | * @returns: > 0 Size of the event |
342 | * -ENOSPC An area big enough was not provided to look |
343 | * ahead into the event's guts and guess the size. |
344 | * -EINVAL Unknown event code (wEvent). |
345 | * |
346 | * This will look at the received RCEB and guess what is the total |
347 | * size. For variable sized events, it will look further ahead into |
348 | * their length field to see how much data should be read. |
349 | * |
350 | * Note this size is *not* final--the neh (Notification/Event Handle) |
351 | * might specificy an extra size to add. |
352 | */ |
353 | static |
354 | ssize_t uwb_est_get_size(struct uwb_rc *uwb_rc, struct uwb_est *est, |
355 | u8 event_low, const struct uwb_rceb *rceb, |
356 | size_t rceb_size) |
357 | { |
358 | unsigned offset; |
359 | ssize_t size; |
360 | struct device *dev = &uwb_rc->uwb_dev.dev; |
361 | const struct uwb_est_entry *entry; |
362 | |
363 | size = -ENOENT; |
364 | if (event_low >= est->entries) { /* in range? */ |
365 | dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: event %u out of range\n", |
366 | est, est->type_event_high, est->vendor, est->product, |
367 | est->entries, event_low); |
368 | goto out; |
369 | } |
370 | size = -ENOENT; |
371 | entry = &est->entry[event_low]; |
372 | if (entry->size == 0 && entry->offset == 0) { /* unknown? */ |
373 | dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: event %u unknown\n", |
374 | est, est->type_event_high, est->vendor, est->product, |
375 | est->entries, event_low); |
376 | goto out; |
377 | } |
378 | offset = entry->offset; /* extra fries with that? */ |
379 | if (offset == 0) |
380 | size = entry->size; |
381 | else { |
382 | /* Ops, got an extra size field at 'offset'--read it */ |
383 | const void *ptr = rceb; |
384 | size_t type_size = 0; |
385 | offset--; |
386 | size = -ENOSPC; /* enough data for more? */ |
387 | switch (entry->type) { |
388 | case UWB_EST_16: type_size = sizeof(__le16); break; |
389 | case UWB_EST_8: type_size = sizeof(u8); break; |
390 | default: BUG(); |
391 | } |
392 | if (offset + type_size > rceb_size) { |
393 | dev_err(dev, "EST %p 0x%04x/%04x/%04x[%u]: " |
394 | "not enough data to read extra size\n", |
395 | est, est->type_event_high, est->vendor, |
396 | est->product, est->entries); |
397 | goto out; |
398 | } |
399 | size = entry->size; |
400 | ptr += offset; |
401 | switch (entry->type) { |
402 | case UWB_EST_16: size += le16_to_cpu(*(__le16 *)ptr); break; |
403 | case UWB_EST_8: size += *(u8 *)ptr; break; |
404 | default: BUG(); |
405 | } |
406 | } |
407 | out: |
408 | return size; |
409 | } |
410 | |
411 | |
412 | /** |
413 | * Guesses the size of a WA event |
414 | * |
415 | * @rceb: pointer to the buffer with the event |
416 | * @rceb_size: size of the area pointed to by @rceb in bytes. |
417 | * @returns: > 0 Size of the event |
418 | * -ENOSPC An area big enough was not provided to look |
419 | * ahead into the event's guts and guess the size. |
420 | * -EINVAL Unknown event code (wEvent). |
421 | * |
422 | * This will look at the received RCEB and guess what is the total |
423 | * size by checking all the tables registered with |
424 | * uwb_est_register(). For variable sized events, it will look further |
425 | * ahead into their length field to see how much data should be read. |
426 | * |
427 | * Note this size is *not* final--the neh (Notification/Event Handle) |
428 | * might specificy an extra size to add or replace. |
429 | */ |
430 | ssize_t uwb_est_find_size(struct uwb_rc *rc, const struct uwb_rceb *rceb, |
431 | size_t rceb_size) |
432 | { |
433 | /* FIXME: add vendor/product data */ |
434 | ssize_t size; |
435 | struct device *dev = &rc->uwb_dev.dev; |
436 | unsigned long flags; |
437 | unsigned itr; |
438 | u16 type_event_high, event; |
439 | u8 *ptr = (u8 *) rceb; |
440 | |
441 | read_lock_irqsave(&uwb_est_lock, flags); |
442 | size = -ENOSPC; |
443 | if (rceb_size < sizeof(*rceb)) |
444 | goto out; |
445 | event = le16_to_cpu(rceb->wEvent); |
446 | type_event_high = rceb->bEventType << 8 | (event & 0xff00) >> 8; |
447 | for (itr = 0; itr < uwb_est_used; itr++) { |
448 | if (uwb_est[itr].type_event_high != type_event_high) |
449 | continue; |
450 | size = uwb_est_get_size(rc, &uwb_est[itr], |
451 | event & 0x00ff, rceb, rceb_size); |
452 | /* try more tables that might handle the same type */ |
453 | if (size != -ENOENT) |
454 | goto out; |
455 | } |
456 | dev_dbg(dev, "event 0x%02x/%04x/%02x: no handlers available; " |
457 | "RCEB %02x %02x %02x %02x\n", |
458 | (unsigned) rceb->bEventType, |
459 | (unsigned) le16_to_cpu(rceb->wEvent), |
460 | (unsigned) rceb->bEventContext, |
461 | ptr[0], ptr[1], ptr[2], ptr[3]); |
462 | size = -ENOENT; |
463 | out: |
464 | read_unlock_irqrestore(&uwb_est_lock, flags); |
465 | return size; |
466 | } |
467 | EXPORT_SYMBOL_GPL(uwb_est_find_size); |
468 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9