1/* 2 * Ultra Wide Band 3 * UWB API 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: doc: overview of the API, different parts and pointers 24 */ 25 26#ifndef __LINUX__UWB_H__ 27#define __LINUX__UWB_H__ 28 29#include <linux/limits.h> 30#include <linux/device.h> 31#include <linux/mutex.h> 32#include <linux/timer.h> 33#include <linux/wait.h> 34#include <linux/workqueue.h> 35#include <linux/uwb/spec.h> 36#include <asm/page.h> 37 38struct uwb_dev; 39struct uwb_beca_e; 40struct uwb_rc; 41struct uwb_rsv; 42struct uwb_dbg; 43 44/** 45 * struct uwb_dev - a UWB Device 46 * @rc: UWB Radio Controller that discovered the device (kind of its 47 * parent). 48 * @bce: a beacon cache entry for this device; or NULL if the device 49 * is a local radio controller. 50 * @mac_addr: the EUI-48 address of this device. 51 * @dev_addr: the current DevAddr used by this device. 52 * @beacon_slot: the slot number the beacon is using. 53 * @streams: bitmap of streams allocated to reservations targeted at 54 * this device. For an RC, this is the streams allocated for 55 * reservations targeted at DevAddrs. 56 * 57 * A UWB device may either by a neighbor or part of a local radio 58 * controller. 59 */ 60struct uwb_dev { 61 struct mutex mutex; 62 struct list_head list_node; 63 struct device dev; 64 struct uwb_rc *rc; /* radio controller */ 65 struct uwb_beca_e *bce; /* Beacon Cache Entry */ 66 67 struct uwb_mac_addr mac_addr; 68 struct uwb_dev_addr dev_addr; 69 int beacon_slot; 70 DECLARE_BITMAP(streams, UWB_NUM_STREAMS); 71 DECLARE_BITMAP(last_availability_bm, UWB_NUM_MAS); 72}; 73#define to_uwb_dev(d) container_of(d, struct uwb_dev, dev) 74 75/** 76 * UWB HWA/WHCI Radio Control {Command|Event} Block context IDs 77 * 78 * RC[CE]Bs have a 'context ID' field that matches the command with 79 * the event received to confirm it. 80 * 81 * Maximum number of context IDs 82 */ 83enum { UWB_RC_CTX_MAX = 256 }; 84 85 86/** Notification chain head for UWB generated events to listeners */ 87struct uwb_notifs_chain { 88 struct list_head list; 89 struct mutex mutex; 90}; 91 92/* Beacon cache list */ 93struct uwb_beca { 94 struct list_head list; 95 size_t entries; 96 struct mutex mutex; 97}; 98 99/* Event handling thread. */ 100struct uwbd { 101 int pid; 102 struct task_struct *task; 103 wait_queue_head_t wq; 104 struct list_head event_list; 105 spinlock_t event_list_lock; 106}; 107 108/** 109 * struct uwb_mas_bm - a bitmap of all MAS in a superframe 110 * @bm: a bitmap of length #UWB_NUM_MAS 111 */ 112struct uwb_mas_bm { 113 DECLARE_BITMAP(bm, UWB_NUM_MAS); 114 DECLARE_BITMAP(unsafe_bm, UWB_NUM_MAS); 115 int safe; 116 int unsafe; 117}; 118 119/** 120 * uwb_rsv_state - UWB Reservation state. 121 * 122 * NONE - reservation is not active (no DRP IE being transmitted). 123 * 124 * Owner reservation states: 125 * 126 * INITIATED - owner has sent an initial DRP request. 127 * PENDING - target responded with pending Reason Code. 128 * MODIFIED - reservation manager is modifying an established 129 * reservation with a different MAS allocation. 130 * ESTABLISHED - the reservation has been successfully negotiated. 131 * 132 * Target reservation states: 133 * 134 * DENIED - request is denied. 135 * ACCEPTED - request is accepted. 136 * PENDING - PAL has yet to make a decision to whether to accept or 137 * deny. 138 * 139 * FIXME: further target states TBD. 140 */ 141enum uwb_rsv_state { 142 UWB_RSV_STATE_NONE = 0, 143 UWB_RSV_STATE_O_INITIATED, 144 UWB_RSV_STATE_O_PENDING, 145 UWB_RSV_STATE_O_MODIFIED, 146 UWB_RSV_STATE_O_ESTABLISHED, 147 UWB_RSV_STATE_O_TO_BE_MOVED, 148 UWB_RSV_STATE_O_MOVE_EXPANDING, 149 UWB_RSV_STATE_O_MOVE_COMBINING, 150 UWB_RSV_STATE_O_MOVE_REDUCING, 151 UWB_RSV_STATE_T_ACCEPTED, 152 UWB_RSV_STATE_T_DENIED, 153 UWB_RSV_STATE_T_CONFLICT, 154 UWB_RSV_STATE_T_PENDING, 155 UWB_RSV_STATE_T_EXPANDING_ACCEPTED, 156 UWB_RSV_STATE_T_EXPANDING_CONFLICT, 157 UWB_RSV_STATE_T_EXPANDING_PENDING, 158 UWB_RSV_STATE_T_EXPANDING_DENIED, 159 UWB_RSV_STATE_T_RESIZED, 160 161 UWB_RSV_STATE_LAST, 162}; 163 164enum uwb_rsv_target_type { 165 UWB_RSV_TARGET_DEV, 166 UWB_RSV_TARGET_DEVADDR, 167}; 168 169/** 170 * struct uwb_rsv_target - the target of a reservation. 171 * 172 * Reservations unicast and targeted at a single device 173 * (UWB_RSV_TARGET_DEV); or (e.g., in the case of WUSB) targeted at a 174 * specific (private) DevAddr (UWB_RSV_TARGET_DEVADDR). 175 */ 176struct uwb_rsv_target { 177 enum uwb_rsv_target_type type; 178 union { 179 struct uwb_dev *dev; 180 struct uwb_dev_addr devaddr; 181 }; 182}; 183 184struct uwb_rsv_move { 185 struct uwb_mas_bm final_mas; 186 struct uwb_ie_drp *companion_drp_ie; 187 struct uwb_mas_bm companion_mas; 188}; 189 190/* 191 * Number of streams reserved for reservations targeted at DevAddrs. 192 */ 193#define UWB_NUM_GLOBAL_STREAMS 1 194 195typedef void (*uwb_rsv_cb_f)(struct uwb_rsv *rsv); 196 197/** 198 * struct uwb_rsv - a DRP reservation 199 * 200 * Data structure management: 201 * 202 * @rc: the radio controller this reservation is for 203 * (as target or owner) 204 * @rc_node: a list node for the RC 205 * @pal_node: a list node for the PAL 206 * 207 * Owner and target parameters: 208 * 209 * @owner: the UWB device owning this reservation 210 * @target: the target UWB device 211 * @type: reservation type 212 * 213 * Owner parameters: 214 * 215 * @max_mas: maxiumum number of MAS 216 * @min_mas: minimum number of MAS 217 * @sparsity: owner selected sparsity 218 * @is_multicast: true iff multicast 219 * 220 * @callback: callback function when the reservation completes 221 * @pal_priv: private data for the PAL making the reservation 222 * 223 * Reservation status: 224 * 225 * @status: negotiation status 226 * @stream: stream index allocated for this reservation 227 * @tiebreaker: conflict tiebreaker for this reservation 228 * @mas: reserved MAS 229 * @drp_ie: the DRP IE 230 * @ie_valid: true iff the DRP IE matches the reservation parameters 231 * 232 * DRP reservations are uniquely identified by the owner, target and 233 * stream index. However, when using a DevAddr as a target (e.g., for 234 * a WUSB cluster reservation) the responses may be received from 235 * devices with different DevAddrs. In this case, reservations are 236 * uniquely identified by just the stream index. A number of stream 237 * indexes (UWB_NUM_GLOBAL_STREAMS) are reserved for this. 238 */ 239struct uwb_rsv { 240 struct uwb_rc *rc; 241 struct list_head rc_node; 242 struct list_head pal_node; 243 struct kref kref; 244 245 struct uwb_dev *owner; 246 struct uwb_rsv_target target; 247 enum uwb_drp_type type; 248 int max_mas; 249 int min_mas; 250 int max_interval; 251 bool is_multicast; 252 253 uwb_rsv_cb_f callback; 254 void *pal_priv; 255 256 enum uwb_rsv_state state; 257 bool needs_release_companion_mas; 258 u8 stream; 259 u8 tiebreaker; 260 struct uwb_mas_bm mas; 261 struct uwb_ie_drp *drp_ie; 262 struct uwb_rsv_move mv; 263 bool ie_valid; 264 struct timer_list timer; 265 struct work_struct handle_timeout_work; 266}; 267 268static const 269struct uwb_mas_bm uwb_mas_bm_zero = { .bm = { 0 } }; 270 271static inline void uwb_mas_bm_copy_le(void *dst, const struct uwb_mas_bm *mas) 272{ 273 bitmap_copy_le(dst, mas->bm, UWB_NUM_MAS); 274} 275 276/** 277 * struct uwb_drp_avail - a radio controller's view of MAS usage 278 * @global: MAS unused by neighbors (excluding reservations targeted 279 * or owned by the local radio controller) or the beaon period 280 * @local: MAS unused by local established reservations 281 * @pending: MAS unused by local pending reservations 282 * @ie: DRP Availability IE to be included in the beacon 283 * @ie_valid: true iff @ie is valid and does not need to regenerated from 284 * @global and @local 285 * 286 * Each radio controller maintains a view of MAS usage or 287 * availability. MAS available for a new reservation are determined 288 * from the intersection of @global, @local, and @pending. 289 * 290 * The radio controller must transmit a DRP Availability IE that's the 291 * intersection of @global and @local. 292 * 293 * A set bit indicates the MAS is unused and available. 294 * 295 * rc->rsvs_mutex should be held before accessing this data structure. 296 * 297 * [ECMA-368] section 17.4.3. 298 */ 299struct uwb_drp_avail { 300 DECLARE_BITMAP(global, UWB_NUM_MAS); 301 DECLARE_BITMAP(local, UWB_NUM_MAS); 302 DECLARE_BITMAP(pending, UWB_NUM_MAS); 303 struct uwb_ie_drp_avail ie; 304 bool ie_valid; 305}; 306 307struct uwb_drp_backoff_win { 308 u8 window; 309 u8 n; 310 int total_expired; 311 struct timer_list timer; 312 bool can_reserve_extra_mases; 313}; 314 315const char *uwb_rsv_state_str(enum uwb_rsv_state state); 316const char *uwb_rsv_type_str(enum uwb_drp_type type); 317 318struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, 319 void *pal_priv); 320void uwb_rsv_destroy(struct uwb_rsv *rsv); 321 322int uwb_rsv_establish(struct uwb_rsv *rsv); 323int uwb_rsv_modify(struct uwb_rsv *rsv, 324 int max_mas, int min_mas, int sparsity); 325void uwb_rsv_terminate(struct uwb_rsv *rsv); 326 327void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv); 328 329void uwb_rsv_get_usable_mas(struct uwb_rsv *orig_rsv, struct uwb_mas_bm *mas); 330 331/** 332 * Radio Control Interface instance 333 * 334 * 335 * Life cycle rules: those of the UWB Device. 336 * 337 * @index: an index number for this radio controller, as used in the 338 * device name. 339 * @version: version of protocol supported by this device 340 * @priv: Backend implementation; rw with uwb_dev.dev.sem taken. 341 * @cmd: Backend implementation to execute commands; rw and call 342 * only with uwb_dev.dev.sem taken. 343 * @reset: Hardware reset of radio controller and any PAL controllers. 344 * @filter: Backend implementation to manipulate data to and from device 345 * to be compliant to specification assumed by driver (WHCI 346 * 0.95). 347 * 348 * uwb_dev.dev.mutex is used to execute commands and update 349 * the corresponding structures; can't use a spinlock 350 * because rc->cmd() can sleep. 351 * @ies: This is a dynamically allocated array cacheing the 352 * IEs (settable by the host) that the beacon of this 353 * radio controller is currently sending. 354 * 355 * In reality, we store here the full command we set to 356 * the radio controller (which is basically a command 357 * prefix followed by all the IEs the beacon currently 358 * contains). This way we don't have to realloc and 359 * memcpy when setting it. 360 * 361 * We set this up in uwb_rc_ie_setup(), where we alloc 362 * this struct, call get_ie() [so we know which IEs are 363 * currently being sent, if any]. 364 * 365 * @ies_capacity:Amount of space (in bytes) allocated in @ies. The 366 * amount used is given by sizeof(*ies) plus ies->wIELength 367 * (which is a little endian quantity all the time). 368 * @ies_mutex: protect the IE cache 369 * @dbg: information for the debug interface 370 */ 371struct uwb_rc { 372 struct uwb_dev uwb_dev; 373 int index; 374 u16 version; 375 376 struct module *owner; 377 void *priv; 378 int (*start)(struct uwb_rc *rc); 379 void (*stop)(struct uwb_rc *rc); 380 int (*cmd)(struct uwb_rc *, const struct uwb_rccb *, size_t); 381 int (*reset)(struct uwb_rc *rc); 382 int (*filter_cmd)(struct uwb_rc *, struct uwb_rccb **, size_t *); 383 int (*filter_event)(struct uwb_rc *, struct uwb_rceb **, const size_t, 384 size_t *, size_t *); 385 386 spinlock_t neh_lock; /* protects neh_* and ctx_* */ 387 struct list_head neh_list; /* Open NE handles */ 388 unsigned long ctx_bm[UWB_RC_CTX_MAX / 8 / sizeof(unsigned long)]; 389 u8 ctx_roll; 390 391 int beaconing; /* Beaconing state [channel number] */ 392 int beaconing_forced; 393 int scanning; 394 enum uwb_scan_type scan_type:3; 395 unsigned ready:1; 396 struct uwb_notifs_chain notifs_chain; 397 struct uwb_beca uwb_beca; 398 399 struct uwbd uwbd; 400 401 struct uwb_drp_backoff_win bow; 402 struct uwb_drp_avail drp_avail; 403 struct list_head reservations; 404 struct list_head cnflt_alien_list; 405 struct uwb_mas_bm cnflt_alien_bitmap; 406 struct mutex rsvs_mutex; 407 spinlock_t rsvs_lock; 408 struct workqueue_struct *rsv_workq; 409 410 struct delayed_work rsv_update_work; 411 struct delayed_work rsv_alien_bp_work; 412 int set_drp_ie_pending; 413 struct mutex ies_mutex; 414 struct uwb_rc_cmd_set_ie *ies; 415 size_t ies_capacity; 416 417 struct list_head pals; 418 int active_pals; 419 420 struct uwb_dbg *dbg; 421}; 422 423 424/** 425 * struct uwb_pal - a UWB PAL 426 * @name: descriptive name for this PAL (wusbhc, wlp, etc.). 427 * @device: a device for the PAL. Used to link the PAL and the radio 428 * controller in sysfs. 429 * @rc: the radio controller the PAL uses. 430 * @channel_changed: called when the channel used by the radio changes. 431 * A channel of -1 means the channel has been stopped. 432 * @new_rsv: called when a peer requests a reservation (may be NULL if 433 * the PAL cannot accept reservation requests). 434 * @channel: channel being used by the PAL; 0 if the PAL isn't using 435 * the radio; -1 if the PAL wishes to use the radio but 436 * cannot. 437 * @debugfs_dir: a debugfs directory which the PAL can use for its own 438 * debugfs files. 439 * 440 * A Protocol Adaptation Layer (PAL) is a user of the WiMedia UWB 441 * radio platform (e.g., WUSB, WLP or Bluetooth UWB AMP). 442 * 443 * The PALs using a radio controller must register themselves to 444 * permit the UWB stack to coordinate usage of the radio between the 445 * various PALs or to allow PALs to response to certain requests from 446 * peers. 447 * 448 * A struct uwb_pal should be embedded in a containing structure 449 * belonging to the PAL and initialized with uwb_pal_init()). Fields 450 * should be set appropriately by the PAL before registering the PAL 451 * with uwb_pal_register(). 452 */ 453struct uwb_pal { 454 struct list_head node; 455 const char *name; 456 struct device *device; 457 struct uwb_rc *rc; 458 459 void (*channel_changed)(struct uwb_pal *pal, int channel); 460 void (*new_rsv)(struct uwb_pal *pal, struct uwb_rsv *rsv); 461 462 int channel; 463 struct dentry *debugfs_dir; 464}; 465 466void uwb_pal_init(struct uwb_pal *pal); 467int uwb_pal_register(struct uwb_pal *pal); 468void uwb_pal_unregister(struct uwb_pal *pal); 469 470int uwb_radio_start(struct uwb_pal *pal); 471void uwb_radio_stop(struct uwb_pal *pal); 472 473/* 474 * General public API 475 * 476 * This API can be used by UWB device drivers or by those implementing 477 * UWB Radio Controllers 478 */ 479struct uwb_dev *uwb_dev_get_by_devaddr(struct uwb_rc *rc, 480 const struct uwb_dev_addr *devaddr); 481struct uwb_dev *uwb_dev_get_by_rc(struct uwb_dev *, struct uwb_rc *); 482static inline void uwb_dev_get(struct uwb_dev *uwb_dev) 483{ 484 get_device(&uwb_dev->dev); 485} 486static inline void uwb_dev_put(struct uwb_dev *uwb_dev) 487{ 488 put_device(&uwb_dev->dev); 489} 490struct uwb_dev *uwb_dev_try_get(struct uwb_rc *rc, struct uwb_dev *uwb_dev); 491 492/** 493 * Callback function for 'uwb_{dev,rc}_foreach()'. 494 * 495 * @dev: Linux device instance 496 * 'uwb_dev = container_of(dev, struct uwb_dev, dev)' 497 * @priv: Data passed by the caller to 'uwb_{dev,rc}_foreach()'. 498 * 499 * @returns: 0 to continue the iterations, any other val to stop 500 * iterating and return the value to the caller of 501 * _foreach(). 502 */ 503typedef int (*uwb_dev_for_each_f)(struct device *dev, void *priv); 504int uwb_dev_for_each(struct uwb_rc *rc, uwb_dev_for_each_f func, void *priv); 505 506struct uwb_rc *uwb_rc_alloc(void); 507struct uwb_rc *uwb_rc_get_by_dev(const struct uwb_dev_addr *); 508struct uwb_rc *uwb_rc_get_by_grandpa(const struct device *); 509void uwb_rc_put(struct uwb_rc *rc); 510 511typedef void (*uwb_rc_cmd_cb_f)(struct uwb_rc *rc, void *arg, 512 struct uwb_rceb *reply, ssize_t reply_size); 513 514int uwb_rc_cmd_async(struct uwb_rc *rc, const char *cmd_name, 515 struct uwb_rccb *cmd, size_t cmd_size, 516 u8 expected_type, u16 expected_event, 517 uwb_rc_cmd_cb_f cb, void *arg); 518ssize_t uwb_rc_cmd(struct uwb_rc *rc, const char *cmd_name, 519 struct uwb_rccb *cmd, size_t cmd_size, 520 struct uwb_rceb *reply, size_t reply_size); 521ssize_t uwb_rc_vcmd(struct uwb_rc *rc, const char *cmd_name, 522 struct uwb_rccb *cmd, size_t cmd_size, 523 u8 expected_type, u16 expected_event, 524 struct uwb_rceb **preply); 525 526size_t __uwb_addr_print(char *, size_t, const unsigned char *, int); 527 528int uwb_rc_dev_addr_set(struct uwb_rc *, const struct uwb_dev_addr *); 529int uwb_rc_dev_addr_get(struct uwb_rc *, struct uwb_dev_addr *); 530int uwb_rc_mac_addr_set(struct uwb_rc *, const struct uwb_mac_addr *); 531int uwb_rc_mac_addr_get(struct uwb_rc *, struct uwb_mac_addr *); 532int __uwb_mac_addr_assigned_check(struct device *, void *); 533int __uwb_dev_addr_assigned_check(struct device *, void *); 534 535/* Print in @buf a pretty repr of @addr */ 536static inline size_t uwb_dev_addr_print(char *buf, size_t buf_size, 537 const struct uwb_dev_addr *addr) 538{ 539 return __uwb_addr_print(buf, buf_size, addr->data, 0); 540} 541 542/* Print in @buf a pretty repr of @addr */ 543static inline size_t uwb_mac_addr_print(char *buf, size_t buf_size, 544 const struct uwb_mac_addr *addr) 545{ 546 return __uwb_addr_print(buf, buf_size, addr->data, 1); 547} 548 549/* @returns 0 if device addresses @addr2 and @addr1 are equal */ 550static inline int uwb_dev_addr_cmp(const struct uwb_dev_addr *addr1, 551 const struct uwb_dev_addr *addr2) 552{ 553 return memcmp(addr1, addr2, sizeof(*addr1)); 554} 555 556/* @returns 0 if MAC addresses @addr2 and @addr1 are equal */ 557static inline int uwb_mac_addr_cmp(const struct uwb_mac_addr *addr1, 558 const struct uwb_mac_addr *addr2) 559{ 560 return memcmp(addr1, addr2, sizeof(*addr1)); 561} 562 563/* @returns !0 if a MAC @addr is a broadcast address */ 564static inline int uwb_mac_addr_bcast(const struct uwb_mac_addr *addr) 565{ 566 struct uwb_mac_addr bcast = { 567 .data = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } 568 }; 569 return !uwb_mac_addr_cmp(addr, &bcast); 570} 571 572/* @returns !0 if a MAC @addr is all zeroes*/ 573static inline int uwb_mac_addr_unset(const struct uwb_mac_addr *addr) 574{ 575 struct uwb_mac_addr unset = { 576 .data = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } 577 }; 578 return !uwb_mac_addr_cmp(addr, &unset); 579} 580 581/* @returns !0 if the address is in use. */ 582static inline unsigned __uwb_dev_addr_assigned(struct uwb_rc *rc, 583 struct uwb_dev_addr *addr) 584{ 585 return uwb_dev_for_each(rc, __uwb_dev_addr_assigned_check, addr); 586} 587 588/* 589 * UWB Radio Controller API 590 * 591 * This API is used (in addition to the general API) to implement UWB 592 * Radio Controllers. 593 */ 594void uwb_rc_init(struct uwb_rc *); 595int uwb_rc_add(struct uwb_rc *, struct device *dev, void *rc_priv); 596void uwb_rc_rm(struct uwb_rc *); 597void uwb_rc_neh_grok(struct uwb_rc *, void *, size_t); 598void uwb_rc_neh_error(struct uwb_rc *, int); 599void uwb_rc_reset_all(struct uwb_rc *rc); 600void uwb_rc_pre_reset(struct uwb_rc *rc); 601int uwb_rc_post_reset(struct uwb_rc *rc); 602 603/** 604 * uwb_rsv_is_owner - is the owner of this reservation the RC? 605 * @rsv: the reservation 606 */ 607static inline bool uwb_rsv_is_owner(struct uwb_rsv *rsv) 608{ 609 return rsv->owner == &rsv->rc->uwb_dev; 610} 611 612/** 613 * enum uwb_notifs - UWB events that can be passed to any listeners 614 * @UWB_NOTIF_ONAIR: a new neighbour has joined the beacon group. 615 * @UWB_NOTIF_OFFAIR: a neighbour has left the beacon group. 616 * 617 * Higher layers can register callback functions with the radio 618 * controller using uwb_notifs_register(). The radio controller 619 * maintains a list of all registered handlers and will notify all 620 * nodes when an event occurs. 621 */ 622enum uwb_notifs { 623 UWB_NOTIF_ONAIR, 624 UWB_NOTIF_OFFAIR, 625}; 626 627/* Callback function registered with UWB */ 628struct uwb_notifs_handler { 629 struct list_head list_node; 630 void (*cb)(void *, struct uwb_dev *, enum uwb_notifs); 631 void *data; 632}; 633 634int uwb_notifs_register(struct uwb_rc *, struct uwb_notifs_handler *); 635int uwb_notifs_deregister(struct uwb_rc *, struct uwb_notifs_handler *); 636 637 638/** 639 * UWB radio controller Event Size Entry (for creating entry tables) 640 * 641 * WUSB and WHCI define events and notifications, and they might have 642 * fixed or variable size. 643 * 644 * Each event/notification has a size which is not necessarily known 645 * in advance based on the event code. As well, vendor specific 646 * events/notifications will have a size impossible to determine 647 * unless we know about the device's specific details. 648 * 649 * It was way too smart of the spec writers not to think that it would 650 * be impossible for a generic driver to skip over vendor specific 651 * events/notifications if there are no LENGTH fields in the HEADER of 652 * each message...the transaction size cannot be counted on as the 653 * spec does not forbid to pack more than one event in a single 654 * transaction. 655 * 656 * Thus, we guess sizes with tables (or for events, when you know the 657 * size ahead of time you can use uwb_rc_neh_extra_size*()). We 658 * register tables with the known events and their sizes, and then we 659 * traverse those tables. For those with variable length, we provide a 660 * way to lookup the size inside the event/notification's 661 * payload. This allows device-specific event size tables to be 662 * registered. 663 * 664 * @size: Size of the payload 665 * 666 * @offset: if != 0, at offset @offset-1 starts a field with a length 667 * that has to be added to @size. The format of the field is 668 * given by @type. 669 * 670 * @type: Type and length of the offset field. Most common is LE 16 671 * bits (that's why that is zero); others are there mostly to 672 * cover for bugs and weirdos. 673 */ 674struct uwb_est_entry { 675 size_t size; 676 unsigned offset; 677 enum { UWB_EST_16 = 0, UWB_EST_8 = 1 } type; 678}; 679 680int uwb_est_register(u8 type, u8 code_high, u16 vendor, u16 product, 681 const struct uwb_est_entry *, size_t entries); 682int uwb_est_unregister(u8 type, u8 code_high, u16 vendor, u16 product, 683 const struct uwb_est_entry *, size_t entries); 684ssize_t uwb_est_find_size(struct uwb_rc *rc, const struct uwb_rceb *rceb, 685 size_t len); 686 687/* -- Misc */ 688 689enum { 690 EDC_MAX_ERRORS = 10, 691 EDC_ERROR_TIMEFRAME = HZ, 692}; 693 694/* error density counter */ 695struct edc { 696 unsigned long timestart; 697 u16 errorcount; 698}; 699 700static inline 701void edc_init(struct edc *edc) 702{ 703 edc->timestart = jiffies; 704} 705 706/* Called when an error occurred. 707 * This is way to determine if the number of acceptable errors per time 708 * period has been exceeded. It is not accurate as there are cases in which 709 * this scheme will not work, for example if there are periodic occurrences 710 * of errors that straddle updates to the start time. This scheme is 711 * sufficient for our usage. 712 * 713 * @returns 1 if maximum acceptable errors per timeframe has been exceeded. 714 */ 715static inline int edc_inc(struct edc *err_hist, u16 max_err, u16 timeframe) 716{ 717 unsigned long now; 718 719 now = jiffies; 720 if (now - err_hist->timestart > timeframe) { 721 err_hist->errorcount = 1; 722 err_hist->timestart = now; 723 } else if (++err_hist->errorcount > max_err) { 724 err_hist->errorcount = 0; 725 err_hist->timestart = now; 726 return 1; 727 } 728 return 0; 729} 730 731 732/* Information Element handling */ 733 734struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len); 735int uwb_rc_ie_add(struct uwb_rc *uwb_rc, const struct uwb_ie_hdr *ies, size_t size); 736int uwb_rc_ie_rm(struct uwb_rc *uwb_rc, enum uwb_ie element_id); 737 738/* 739 * Transmission statistics 740 * 741 * UWB uses LQI and RSSI (one byte values) for reporting radio signal 742 * strength and line quality indication. We do quick and dirty 743 * averages of those. They are signed values, btw. 744 * 745 * For 8 bit quantities, we keep the min, the max, an accumulator 746 * (@sigma) and a # of samples. When @samples gets to 255, we compute 747 * the average (@sigma / @samples), place it in @sigma and reset 748 * @samples to 1 (so we use it as the first sample). 749 * 750 * Now, statistically speaking, probably I am kicking the kidneys of 751 * some books I have in my shelves collecting dust, but I just want to 752 * get an approx, not the Nobel. 753 * 754 * LOCKING: there is no locking per se, but we try to keep a lockless 755 * schema. Only _add_samples() modifies the values--as long as you 756 * have other locking on top that makes sure that no two calls of 757 * _add_sample() happen at the same time, then we are fine. Now, for 758 * resetting the values we just set @samples to 0 and that makes the 759 * next _add_sample() to start with defaults. Reading the values in 760 * _show() currently can race, so you need to make sure the calls are 761 * under the same lock that protects calls to _add_sample(). FIXME: 762 * currently unlocked (It is not ultraprecise but does the trick. Bite 763 * me). 764 */ 765struct stats { 766 s8 min, max; 767 s16 sigma; 768 atomic_t samples; 769}; 770 771static inline 772void stats_init(struct stats *stats) 773{ 774 atomic_set(&stats->samples, 0); 775 wmb(); 776} 777 778static inline 779void stats_add_sample(struct stats *stats, s8 sample) 780{ 781 s8 min, max; 782 s16 sigma; 783 unsigned samples = atomic_read(&stats->samples); 784 if (samples == 0) { /* it was zero before, so we initialize */ 785 min = 127; 786 max = -128; 787 sigma = 0; 788 } else { 789 min = stats->min; 790 max = stats->max; 791 sigma = stats->sigma; 792 } 793 794 if (sample < min) /* compute new values */ 795 min = sample; 796 else if (sample > max) 797 max = sample; 798 sigma += sample; 799 800 stats->min = min; /* commit */ 801 stats->max = max; 802 stats->sigma = sigma; 803 if (atomic_add_return(1, &stats->samples) > 255) { 804 /* wrapped around! reset */ 805 stats->sigma = sigma / 256; 806 atomic_set(&stats->samples, 1); 807 } 808} 809 810static inline ssize_t stats_show(struct stats *stats, char *buf) 811{ 812 int min, max, avg; 813 int samples = atomic_read(&stats->samples); 814 if (samples == 0) 815 min = max = avg = 0; 816 else { 817 min = stats->min; 818 max = stats->max; 819 avg = stats->sigma / samples; 820 } 821 return scnprintf(buf, PAGE_SIZE, "%d %d %d\n", min, max, avg); 822} 823 824static inline ssize_t stats_store(struct stats *stats, const char *buf, 825 size_t size) 826{ 827 stats_init(stats); 828 return size; 829} 830 831#endif /* #ifndef __LINUX__UWB_H__ */ 832