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