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