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