PageRenderTime 80ms CodeModel.GetById 12ms app.highlight 60ms RepoModel.GetById 1ms app.codeStats 1ms

/include/linux/uwb.h

https://github.com/airy09/android_kernel_sony_apq8064
C Header | 831 lines | 404 code | 85 blank | 342 comment | 14 complexity | 91b1960a3eaec9f6d6e4d7782ec774be MD5 | raw file
  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__ */