5 * Copyright (C) 2005-2006 Intel Corporation
6 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
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.
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.
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
23 * FIXME: doc: overview of the API, different parts and pointers
26 #ifndef __LINUX__UWB_H__
27 #define __LINUX__UWB_H__
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>
43 * struct uwb_dev - a UWB Device
44 * @rc: UWB Radio Controller that discovered the device (kind of its
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.
55 * A UWB device may either by a neighbor or part of a local radio
60 struct list_head list_node
;
62 struct uwb_rc
*rc
; /* radio controller */
63 struct uwb_beca_e
*bce
; /* Beacon Cache Entry */
65 struct uwb_mac_addr mac_addr
;
66 struct uwb_dev_addr dev_addr
;
68 DECLARE_BITMAP(streams
, UWB_NUM_STREAMS
);
70 #define to_uwb_dev(d) container_of(d, struct uwb_dev, dev)
73 * UWB HWA/WHCI Radio Control {Command|Event} Block context IDs
75 * RC[CE]Bs have a 'context ID' field that matches the command with
76 * the event received to confirm it.
78 * Maximum number of context IDs
80 enum { UWB_RC_CTX_MAX
= 256 };
83 /** Notification chain head for UWB generated events to listeners */
84 struct uwb_notifs_chain
{
85 struct list_head list
;
90 * struct uwb_mas_bm - a bitmap of all MAS in a superframe
91 * @bm: a bitmap of length #UWB_NUM_MAS
94 DECLARE_BITMAP(bm
, UWB_NUM_MAS
);
98 * uwb_rsv_state - UWB Reservation state.
100 * NONE - reservation is not active (no DRP IE being transmitted).
102 * Owner reservation states:
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.
110 * Target reservation states:
112 * DENIED - request is denied.
113 * ACCEPTED - request is accepted.
114 * PENDING - PAL has yet to make a decision to whether to accept or
117 * FIXME: further target states TBD.
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
,
132 enum uwb_rsv_target_type
{
134 UWB_RSV_TARGET_DEVADDR
,
138 * struct uwb_rsv_target - the target of a reservation.
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).
144 struct uwb_rsv_target
{
145 enum uwb_rsv_target_type type
;
148 struct uwb_dev_addr devaddr
;
153 * Number of streams reserved for reservations targeted at DevAddrs.
155 #define UWB_NUM_GLOBAL_STREAMS 1
157 typedef void (*uwb_rsv_cb_f
)(struct uwb_rsv
*rsv
);
160 * struct uwb_rsv - a DRP reservation
162 * Data structure management:
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
169 * Owner and target parameters:
171 * @owner: the UWB device owning this reservation
172 * @target: the target UWB device
173 * @type: reservation type
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
182 * @callback: callback function when the reservation completes
183 * @pal_priv: private data for the PAL making the reservation
185 * Reservation status:
187 * @status: negotiation status
188 * @stream: stream index allocated for this reservation
190 * @drp_ie: the DRP IE
191 * @ie_valid: true iff the DRP IE matches the reservation parameters
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.
202 struct list_head rc_node
;
203 struct list_head pal_node
;
206 struct uwb_dev
*owner
;
207 struct uwb_rsv_target target
;
208 enum uwb_drp_type type
;
214 uwb_rsv_cb_f callback
;
217 enum uwb_rsv_state state
;
219 struct uwb_mas_bm mas
;
220 struct uwb_ie_drp
*drp_ie
;
222 struct timer_list timer
;
227 struct uwb_mas_bm uwb_mas_bm_zero
= { .bm
= { 0 } };
229 static inline void uwb_mas_bm_copy_le(void *dst
, const struct uwb_mas_bm
*mas
)
231 bitmap_copy_le(dst
, mas
->bm
, UWB_NUM_MAS
);
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
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.
248 * The radio controller must transmit a DRP Availability IE that's the
249 * intersection of @global and @local.
251 * A set bit indicates the MAS is unused and available.
253 * rc->rsvs_mutex should be held before accessing this data structure.
255 * [ECMA-368] section 17.4.3.
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
;
266 const char *uwb_rsv_state_str(enum uwb_rsv_state state
);
267 const char *uwb_rsv_type_str(enum uwb_drp_type type
);
269 struct uwb_rsv
*uwb_rsv_create(struct uwb_rc
*rc
, uwb_rsv_cb_f cb
,
271 void uwb_rsv_destroy(struct uwb_rsv
*rsv
);
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
);
278 void uwb_rsv_accept(struct uwb_rsv
*rsv
, uwb_rsv_cb_f cb
, void *pal_priv
);
281 * Radio Control Interface instance
284 * Life cycle rules: those of the UWB Device.
286 * @index: an index number for this radio controller, as used in the
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
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.
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.
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].
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
321 struct uwb_dev uwb_dev
;
325 struct module
*owner
;
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,
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)];
340 int beaconing
; /* Beaconing state [channel number] */
342 enum uwb_scan_type scan_type
:3;
344 struct uwb_notifs_chain notifs_chain
;
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
;
352 struct mutex ies_mutex
;
353 struct uwb_rc_cmd_set_ie
*ies
;
357 struct list_head pals
;
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).
371 * A Protocol Adaptation Layer (PAL) is a user of the WiMedia UWB
372 * radio platform (e.g., WUSB, WLP or Bluetooth UWB AMP).
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
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().
385 struct list_head node
;
387 struct device
*device
;
388 void (*new_rsv
)(struct uwb_rsv
*rsv
);
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
);
398 * This API can be used by UWB device drivers or by those implementing
399 * UWB Radio Controllers
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
)
406 get_device(&uwb_dev
->dev
);
408 static inline void uwb_dev_put(struct uwb_dev
*uwb_dev
)
410 put_device(&uwb_dev
->dev
);
412 struct uwb_dev
*uwb_dev_try_get(struct uwb_rc
*rc
, struct uwb_dev
*uwb_dev
);
415 * Callback function for 'uwb_{dev,rc}_foreach()'.
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()'.
421 * @returns: 0 to continue the iterations, any other val to stop
422 * iterating and return the value to the caller of
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
);
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
);
433 typedef void (*uwb_rc_cmd_cb_f
)(struct uwb_rc
*rc
, void *arg
,
434 struct uwb_rceb
*reply
, ssize_t reply_size
);
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
);
450 size_t __uwb_addr_print(char *, size_t, const unsigned char *, int);
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 *);
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
)
463 return __uwb_addr_print(buf
, buf_size
, addr
->data
, 0);
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
)
470 return __uwb_addr_print(buf
, buf_size
, addr
->data
, 1);
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
)
477 return memcmp(addr1
, addr2
, sizeof(*addr1
));
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
)
484 return memcmp(addr1
, addr2
, sizeof(*addr1
));
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
)
490 struct uwb_mac_addr bcast
= {
491 .data
= { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }
493 return !uwb_mac_addr_cmp(addr
, &bcast
);
496 /* @returns !0 if a MAC @addr is all zeroes*/
497 static inline int uwb_mac_addr_unset(const struct uwb_mac_addr
*addr
)
499 struct uwb_mac_addr unset
= {
500 .data
= { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
502 return !uwb_mac_addr_cmp(addr
, &unset
);
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
)
509 return uwb_dev_for_each(rc
, __uwb_dev_addr_assigned_check
, addr
);
513 * UWB Radio Controller API
515 * This API is used (in addition to the general API) to implement UWB
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
);
526 * uwb_rsv_is_owner - is the owner of this reservation the RC?
527 * @rsv: the reservation
529 static inline bool uwb_rsv_is_owner(struct uwb_rsv
*rsv
)
531 return rsv
->owner
== &rsv
->rc
->uwb_dev
;
535 * Events generated by UWB that can be passed to any listeners
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.
543 UWB_NOTIF_BG_JOIN
= 0, /* radio controller joined a beacon group */
544 UWB_NOTIF_BG_LEAVE
= 1, /* radio controller left a beacon group */
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
);
556 int uwb_notifs_register(struct uwb_rc
*, struct uwb_notifs_handler
*);
557 int uwb_notifs_deregister(struct uwb_rc
*, struct uwb_notifs_handler
*);
561 * UWB radio controller Event Size Entry (for creating entry tables)
563 * WUSB and WHCI define events and notifications, and they might have
564 * fixed or variable size.
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.
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
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
586 * @size: Size of the payload
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
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.
596 struct uwb_est_entry
{
599 enum { UWB_EST_16
= 0, UWB_EST_8
= 1 } type
;
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
,
613 EDC_ERROR_TIMEFRAME
= HZ
,
616 /* error density counter */
618 unsigned long timestart
;
623 void edc_init(struct edc
*edc
)
625 edc
->timestart
= jiffies
;
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.
635 * @returns 1 if maximum acceptable errors per timeframe has been exceeded.
637 static inline int edc_inc(struct edc
*err_hist
, u16 max_err
, u16 timeframe
)
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
;
654 /* Information Element handling */
656 /* For representing the state of writing to a buffer when iterating */
662 typedef int (*uwb_ie_f
)(struct uwb_dev
*, const struct uwb_ie_hdr
*,
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
*,
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
);
674 * Transmission statistics
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.
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).
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.
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
707 void stats_init(struct stats
*stats
)
709 atomic_set(&stats
->samples
, 0);
714 void stats_add_sample(struct stats
*stats
, s8 sample
)
718 unsigned samples
= atomic_read(&stats
->samples
);
719 if (samples
== 0) { /* it was zero before, so we initialize */
726 sigma
= stats
->sigma
;
729 if (sample
< min
) /* compute new values */
731 else if (sample
> max
)
735 stats
->min
= min
; /* commit */
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);
745 static inline ssize_t
stats_show(struct stats
*stats
, char *buf
)
748 int samples
= atomic_read(&stats
->samples
);
754 avg
= stats
->sigma
/ samples
;
756 return scnprintf(buf
, PAGE_SIZE
, "%d %d %d\n", min
, max
, avg
);
759 static inline ssize_t
stats_store(struct stats
*stats
, const char *buf
,
766 #endif /* #ifndef __LINUX__UWB_H__ */