EVOLUTION-MANAGER

Edit File: uwb.h

/* * Ultra Wide Band * UWB API * * Copyright (C) 2005-2006 Intel Corporation * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version * 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. * * * FIXME: doc: overview of the API, different parts and pointers */ #ifndef __LINUX__UWB_H__ #define __LINUX__UWB_H__ #include <linux/limits.h> #include <linux/device.h> #include <linux/mutex.h> #include <linux/timer.h> #include <linux/wait.h> #include <linux/workqueue.h> #include <linux/uwb/spec.h> #include <asm/page.h> struct uwb_dev; struct uwb_beca_e; struct uwb_rc; struct uwb_rsv; struct uwb_dbg; /** * struct uwb_dev - a UWB Device * @rc: UWB Radio Controller that discovered the device (kind of its * parent). * @bce: a beacon cache entry for this device; or NULL if the device * is a local radio controller. * @mac_addr: the EUI-48 address of this device. * @dev_addr: the current DevAddr used by this device. * @beacon_slot: the slot number the beacon is using. * @streams: bitmap of streams allocated to reservations targeted at * this device. For an RC, this is the streams allocated for * reservations targeted at DevAddrs. * * A UWB device may either by a neighbor or part of a local radio * controller. */ struct uwb_dev { struct mutex mutex; struct list_head list_node; struct device dev; struct uwb_rc *rc; /* radio controller */ struct uwb_beca_e *bce; /* Beacon Cache Entry */ struct uwb_mac_addr mac_addr; struct uwb_dev_addr dev_addr; int beacon_slot; DECLARE_BITMAP(streams, UWB_NUM_STREAMS); DECLARE_BITMAP(last_availability_bm, UWB_NUM_MAS); }; #define to_uwb_dev(d) container_of(d, struct uwb_dev, dev) /** * UWB HWA/WHCI Radio Control {Command|Event} Block context IDs * * RC[CE]Bs have a 'context ID' field that matches the command with * the event received to confirm it. * * Maximum number of context IDs */ enum { UWB_RC_CTX_MAX = 256 }; /** Notification chain head for UWB generated events to listeners */ struct uwb_notifs_chain { struct list_head list; struct mutex mutex; }; /* Beacon cache list */ struct uwb_beca { struct list_head list; size_t entries; struct mutex mutex; }; /* Event handling thread. */ struct uwbd { int pid; struct task_struct *task; wait_queue_head_t wq; struct list_head event_list; spinlock_t event_list_lock; }; /** * struct uwb_mas_bm - a bitmap of all MAS in a superframe * @bm: a bitmap of length #UWB_NUM_MAS */ struct uwb_mas_bm { DECLARE_BITMAP(bm, UWB_NUM_MAS); DECLARE_BITMAP(unsafe_bm, UWB_NUM_MAS); int safe; int unsafe; }; /** * uwb_rsv_state - UWB Reservation state. * * NONE - reservation is not active (no DRP IE being transmitted). * * Owner reservation states: * * INITIATED - owner has sent an initial DRP request. * PENDING - target responded with pending Reason Code. * MODIFIED - reservation manager is modifying an established * reservation with a different MAS allocation. * ESTABLISHED - the reservation has been successfully negotiated. * * Target reservation states: * * DENIED - request is denied. * ACCEPTED - request is accepted. * PENDING - PAL has yet to make a decision to whether to accept or * deny. * * FIXME: further target states TBD. */ enum uwb_rsv_state { UWB_RSV_STATE_NONE = 0, UWB_RSV_STATE_O_INITIATED, UWB_RSV_STATE_O_PENDING, UWB_RSV_STATE_O_MODIFIED, UWB_RSV_STATE_O_ESTABLISHED, UWB_RSV_STATE_O_TO_BE_MOVED, UWB_RSV_STATE_O_MOVE_EXPANDING, UWB_RSV_STATE_O_MOVE_COMBINING, UWB_RSV_STATE_O_MOVE_REDUCING, UWB_RSV_STATE_T_ACCEPTED, UWB_RSV_STATE_T_DENIED, UWB_RSV_STATE_T_CONFLICT, UWB_RSV_STATE_T_PENDING, UWB_RSV_STATE_T_EXPANDING_ACCEPTED, UWB_RSV_STATE_T_EXPANDING_CONFLICT, UWB_RSV_STATE_T_EXPANDING_PENDING, UWB_RSV_STATE_T_EXPANDING_DENIED, UWB_RSV_STATE_T_RESIZED, UWB_RSV_STATE_LAST, }; enum uwb_rsv_target_type { UWB_RSV_TARGET_DEV, UWB_RSV_TARGET_DEVADDR, }; /** * struct uwb_rsv_target - the target of a reservation. * * Reservations unicast and targeted at a single device * (UWB_RSV_TARGET_DEV); or (e.g., in the case of WUSB) targeted at a * specific (private) DevAddr (UWB_RSV_TARGET_DEVADDR). */ struct uwb_rsv_target { enum uwb_rsv_target_type type; union { struct uwb_dev *dev; struct uwb_dev_addr devaddr; }; }; struct uwb_rsv_move { struct uwb_mas_bm final_mas; struct uwb_ie_drp *companion_drp_ie; struct uwb_mas_bm companion_mas; }; /* * Number of streams reserved for reservations targeted at DevAddrs. */ #define UWB_NUM_GLOBAL_STREAMS 1 typedef void (*uwb_rsv_cb_f)(struct uwb_rsv *rsv); /** * struct uwb_rsv - a DRP reservation * * Data structure management: * * @rc: the radio controller this reservation is for * (as target or owner) * @rc_node: a list node for the RC * @pal_node: a list node for the PAL * * Owner and target parameters: * * @owner: the UWB device owning this reservation * @target: the target UWB device * @type: reservation type * * Owner parameters: * * @max_mas: maxiumum number of MAS * @min_mas: minimum number of MAS * @sparsity: owner selected sparsity * @is_multicast: true iff multicast * * @callback: callback function when the reservation completes * @pal_priv: private data for the PAL making the reservation * * Reservation status: * * @status: negotiation status * @stream: stream index allocated for this reservation * @tiebreaker: conflict tiebreaker for this reservation * @mas: reserved MAS * @drp_ie: the DRP IE * @ie_valid: true iff the DRP IE matches the reservation parameters * * DRP reservations are uniquely identified by the owner, target and * stream index. However, when using a DevAddr as a target (e.g., for * a WUSB cluster reservation) the responses may be received from * devices with different DevAddrs. In this case, reservations are * uniquely identified by just the stream index. A number of stream * indexes (UWB_NUM_GLOBAL_STREAMS) are reserved for this. */ struct uwb_rsv { struct uwb_rc *rc; struct list_head rc_node; struct list_head pal_node; struct kref kref; struct uwb_dev *owner; struct uwb_rsv_target target; enum uwb_drp_type type; int max_mas; int min_mas; int max_interval; bool is_multicast; uwb_rsv_cb_f callback; void *pal_priv; enum uwb_rsv_state state; bool needs_release_companion_mas; u8 stream; u8 tiebreaker; struct uwb_mas_bm mas; struct uwb_ie_drp *drp_ie; struct uwb_rsv_move mv; bool ie_valid; struct timer_list timer; struct work_struct handle_timeout_work; }; static const struct uwb_mas_bm uwb_mas_bm_zero = { .bm = { 0 } }; static inline void uwb_mas_bm_copy_le(void *dst, const struct uwb_mas_bm *mas) { bitmap_copy_le(dst, mas->bm, UWB_NUM_MAS); } /** * struct uwb_drp_avail - a radio controller's view of MAS usage * @global: MAS unused by neighbors (excluding reservations targeted * or owned by the local radio controller) or the beaon period * @local: MAS unused by local established reservations * @pending: MAS unused by local pending reservations * @ie: DRP Availability IE to be included in the beacon * @ie_valid: true iff @ie is valid and does not need to regenerated from * @global and @local * * Each radio controller maintains a view of MAS usage or * availability. MAS available for a new reservation are determined * from the intersection of @global, @local, and @pending. * * The radio controller must transmit a DRP Availability IE that's the * intersection of @global and @local. * * A set bit indicates the MAS is unused and available. * * rc->rsvs_mutex should be held before accessing this data structure. * * [ECMA-368] section 17.4.3. */ struct uwb_drp_avail { DECLARE_BITMAP(global, UWB_NUM_MAS); DECLARE_BITMAP(local, UWB_NUM_MAS); DECLARE_BITMAP(pending, UWB_NUM_MAS); struct uwb_ie_drp_avail ie; bool ie_valid; }; struct uwb_drp_backoff_win { u8 window; u8 n; int total_expired; struct timer_list timer; bool can_reserve_extra_mases; }; const char *uwb_rsv_state_str(enum uwb_rsv_state state); const char *uwb_rsv_type_str(enum uwb_drp_type type); struct uwb_rsv *uwb_rsv_create(struct uwb_rc *rc, uwb_rsv_cb_f cb, void *pal_priv); void uwb_rsv_destroy(struct uwb_rsv *rsv); int uwb_rsv_establish(struct uwb_rsv *rsv); int uwb_rsv_modify(struct uwb_rsv *rsv, int max_mas, int min_mas, int sparsity); void uwb_rsv_terminate(struct uwb_rsv *rsv); void uwb_rsv_accept(struct uwb_rsv *rsv, uwb_rsv_cb_f cb, void *pal_priv); void uwb_rsv_get_usable_mas(struct uwb_rsv *orig_rsv, struct uwb_mas_bm *mas); /** * Radio Control Interface instance * * * Life cycle rules: those of the UWB Device. * * @index: an index number for this radio controller, as used in the * device name. * @version: version of protocol supported by this device * @priv: Backend implementation; rw with uwb_dev.dev.sem taken. * @cmd: Backend implementation to execute commands; rw and call * only with uwb_dev.dev.sem taken. * @reset: Hardware reset of radio controller and any PAL controllers. * @filter: Backend implementation to manipulate data to and from device * to be compliant to specification assumed by driver (WHCI * 0.95). * * uwb_dev.dev.mutex is used to execute commands and update * the corresponding structures; can't use a spinlock * because rc->cmd() can sleep. * @ies: This is a dynamically allocated array cacheing the * IEs (settable by the host) that the beacon of this * radio controller is currently sending. * * In reality, we store here the full command we set to * the radio controller (which is basically a command * prefix followed by all the IEs the beacon currently * contains). This way we don't have to realloc and * memcpy when setting it. * * We set this up in uwb_rc_ie_setup(), where we alloc * this struct, call get_ie() [so we know which IEs are * currently being sent, if any]. * * @ies_capacity:Amount of space (in bytes) allocated in @ies. The * amount used is given by sizeof(*ies) plus ies->wIELength * (which is a little endian quantity all the time). * @ies_mutex: protect the IE cache * @dbg: information for the debug interface */ struct uwb_rc { struct uwb_dev uwb_dev; int index; u16 version; struct module *owner; void *priv; int (*start)(struct uwb_rc *rc); void (*stop)(struct uwb_rc *rc); int (*cmd)(struct uwb_rc *, const struct uwb_rccb *, size_t); int (*reset)(struct uwb_rc *rc); int (*filter_cmd)(struct uwb_rc *, struct uwb_rccb **, size_t *); int (*filter_event)(struct uwb_rc *, struct uwb_rceb **, const size_t, size_t *, size_t *); spinlock_t neh_lock; /* protects neh_* and ctx_* */ struct list_head neh_list; /* Open NE handles */ unsigned long ctx_bm[UWB_RC_CTX_MAX / 8 / sizeof(unsigned long)]; u8 ctx_roll; int beaconing; /* Beaconing state [channel number] */ int beaconing_forced; int scanning; enum uwb_scan_type scan_type:3; unsigned ready:1; struct uwb_notifs_chain notifs_chain; struct uwb_beca uwb_beca; struct uwbd uwbd; struct uwb_drp_backoff_win bow; struct uwb_drp_avail drp_avail; struct list_head reservations; struct list_head cnflt_alien_list; struct uwb_mas_bm cnflt_alien_bitmap; struct mutex rsvs_mutex; spinlock_t rsvs_lock; struct workqueue_struct *rsv_workq; struct delayed_work rsv_update_work; struct delayed_work rsv_alien_bp_work; int set_drp_ie_pending; struct mutex ies_mutex; struct uwb_rc_cmd_set_ie *ies; size_t ies_capacity; struct list_head pals; int active_pals; struct uwb_dbg *dbg; }; /** * struct uwb_pal - a UWB PAL * @name: descriptive name for this PAL (wusbhc, wlp, etc.). * @device: a device for the PAL. Used to link the PAL and the radio * controller in sysfs. * @rc: the radio controller the PAL uses. * @channel_changed: called when the channel used by the radio changes. * A channel of -1 means the channel has been stopped. * @new_rsv: called when a peer requests a reservation (may be NULL if * the PAL cannot accept reservation requests). * @channel: channel being used by the PAL; 0 if the PAL isn't using * the radio; -1 if the PAL wishes to use the radio but * cannot. * @debugfs_dir: a debugfs directory which the PAL can use for its own * debugfs files. * * A Protocol Adaptation Layer (PAL) is a user of the WiMedia UWB * radio platform (e.g., WUSB, WLP or Bluetooth UWB AMP). * * The PALs using a radio controller must register themselves to * permit the UWB stack to coordinate usage of the radio between the * various PALs or to allow PALs to response to certain requests from * peers. * * A struct uwb_pal should be embedded in a containing structure * belonging to the PAL and initialized with uwb_pal_init()). Fields * should be set appropriately by the PAL before registering the PAL * with uwb_pal_register(). */ struct uwb_pal { struct list_head node; const char *name; struct device *device; struct uwb_rc *rc; void (*channel_changed)(struct uwb_pal *pal, int channel); void (*new_rsv)(struct uwb_pal *pal, struct uwb_rsv *rsv); int channel; struct dentry *debugfs_dir; }; void uwb_pal_init(struct uwb_pal *pal); int uwb_pal_register(struct uwb_pal *pal); void uwb_pal_unregister(struct uwb_pal *pal); int uwb_radio_start(struct uwb_pal *pal); void uwb_radio_stop(struct uwb_pal *pal); /* * General public API * * This API can be used by UWB device drivers or by those implementing * UWB Radio Controllers */ struct uwb_dev *uwb_dev_get_by_devaddr(struct uwb_rc *rc, const struct uwb_dev_addr *devaddr); struct uwb_dev *uwb_dev_get_by_rc(struct uwb_dev *, struct uwb_rc *); static inline void uwb_dev_get(struct uwb_dev *uwb_dev) { get_device(&uwb_dev->dev); } static inline void uwb_dev_put(struct uwb_dev *uwb_dev) { put_device(&uwb_dev->dev); } struct uwb_dev *uwb_dev_try_get(struct uwb_rc *rc, struct uwb_dev *uwb_dev); /** * Callback function for 'uwb_{dev,rc}_foreach()'. * * @dev: Linux device instance * 'uwb_dev = container_of(dev, struct uwb_dev, dev)' * @priv: Data passed by the caller to 'uwb_{dev,rc}_foreach()'. * * @returns: 0 to continue the iterations, any other val to stop * iterating and return the value to the caller of * _foreach(). */ typedef int (*uwb_dev_for_each_f)(struct device *dev, void *priv); int uwb_dev_for_each(struct uwb_rc *rc, uwb_dev_for_each_f func, void *priv); struct uwb_rc *uwb_rc_alloc(void); struct uwb_rc *uwb_rc_get_by_dev(const struct uwb_dev_addr *); struct uwb_rc *uwb_rc_get_by_grandpa(const struct device *); void uwb_rc_put(struct uwb_rc *rc); typedef void (*uwb_rc_cmd_cb_f)(struct uwb_rc *rc, void *arg, struct uwb_rceb *reply, ssize_t reply_size); int uwb_rc_cmd_async(struct uwb_rc *rc, const char *cmd_name, struct uwb_rccb *cmd, size_t cmd_size, u8 expected_type, u16 expected_event, uwb_rc_cmd_cb_f cb, void *arg); ssize_t uwb_rc_cmd(struct uwb_rc *rc, const char *cmd_name, struct uwb_rccb *cmd, size_t cmd_size, struct uwb_rceb *reply, size_t reply_size); ssize_t uwb_rc_vcmd(struct uwb_rc *rc, const char *cmd_name, struct uwb_rccb *cmd, size_t cmd_size, u8 expected_type, u16 expected_event, struct uwb_rceb **preply); size_t __uwb_addr_print(char *, size_t, const unsigned char *, int); int uwb_rc_dev_addr_set(struct uwb_rc *, const struct uwb_dev_addr *); int uwb_rc_dev_addr_get(struct uwb_rc *, struct uwb_dev_addr *); int uwb_rc_mac_addr_set(struct uwb_rc *, const struct uwb_mac_addr *); int uwb_rc_mac_addr_get(struct uwb_rc *, struct uwb_mac_addr *); int __uwb_mac_addr_assigned_check(struct device *, void *); int __uwb_dev_addr_assigned_check(struct device *, void *); /* Print in @buf a pretty repr of @addr */ static inline size_t uwb_dev_addr_print(char *buf, size_t buf_size, const struct uwb_dev_addr *addr) { return __uwb_addr_print(buf, buf_size, addr->data, 0); } /* Print in @buf a pretty repr of @addr */ static inline size_t uwb_mac_addr_print(char *buf, size_t buf_size, const struct uwb_mac_addr *addr) { return __uwb_addr_print(buf, buf_size, addr->data, 1); } /* @returns 0 if device addresses @addr2 and @addr1 are equal */ static inline int uwb_dev_addr_cmp(const struct uwb_dev_addr *addr1, const struct uwb_dev_addr *addr2) { return memcmp(addr1, addr2, sizeof(*addr1)); } /* @returns 0 if MAC addresses @addr2 and @addr1 are equal */ static inline int uwb_mac_addr_cmp(const struct uwb_mac_addr *addr1, const struct uwb_mac_addr *addr2) { return memcmp(addr1, addr2, sizeof(*addr1)); } /* @returns !0 if a MAC @addr is a broadcast address */ static inline int uwb_mac_addr_bcast(const struct uwb_mac_addr *addr) { struct uwb_mac_addr bcast = { .data = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } }; return !uwb_mac_addr_cmp(addr, &bcast); } /* @returns !0 if a MAC @addr is all zeroes*/ static inline int uwb_mac_addr_unset(const struct uwb_mac_addr *addr) { struct uwb_mac_addr unset = { .data = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }; return !uwb_mac_addr_cmp(addr, &unset); } /* @returns !0 if the address is in use. */ static inline unsigned __uwb_dev_addr_assigned(struct uwb_rc *rc, struct uwb_dev_addr *addr) { return uwb_dev_for_each(rc, __uwb_dev_addr_assigned_check, addr); } /* * UWB Radio Controller API * * This API is used (in addition to the general API) to implement UWB * Radio Controllers. */ void uwb_rc_init(struct uwb_rc *); int uwb_rc_add(struct uwb_rc *, struct device *dev, void *rc_priv); void uwb_rc_rm(struct uwb_rc *); void uwb_rc_neh_grok(struct uwb_rc *, void *, size_t); void uwb_rc_neh_error(struct uwb_rc *, int); void uwb_rc_reset_all(struct uwb_rc *rc); void uwb_rc_pre_reset(struct uwb_rc *rc); int uwb_rc_post_reset(struct uwb_rc *rc); /** * uwb_rsv_is_owner - is the owner of this reservation the RC? * @rsv: the reservation */ static inline bool uwb_rsv_is_owner(struct uwb_rsv *rsv) { return rsv->owner == &rsv->rc->uwb_dev; } /** * enum uwb_notifs - UWB events that can be passed to any listeners * @UWB_NOTIF_ONAIR: a new neighbour has joined the beacon group. * @UWB_NOTIF_OFFAIR: a neighbour has left the beacon group. * * Higher layers can register callback functions with the radio * controller using uwb_notifs_register(). The radio controller * maintains a list of all registered handlers and will notify all * nodes when an event occurs. */ enum uwb_notifs { UWB_NOTIF_ONAIR, UWB_NOTIF_OFFAIR, }; /* Callback function registered with UWB */ struct uwb_notifs_handler { struct list_head list_node; void (*cb)(void *, struct uwb_dev *, enum uwb_notifs); void *data; }; int uwb_notifs_register(struct uwb_rc *, struct uwb_notifs_handler *); int uwb_notifs_deregister(struct uwb_rc *, struct uwb_notifs_handler *); /** * UWB radio controller Event Size Entry (for creating entry tables) * * WUSB and WHCI define events and notifications, and they might have * fixed or variable size. * * Each event/notification has a size which is not necessarily known * in advance based on the event code. As well, vendor specific * events/notifications will have a size impossible to determine * unless we know about the device's specific details. * * It was way too smart of the spec writers not to think that it would * be impossible for a generic driver to skip over vendor specific * events/notifications if there are no LENGTH fields in the HEADER of * each message...the transaction size cannot be counted on as the * spec does not forbid to pack more than one event in a single * transaction. * * Thus, we guess sizes with tables (or for events, when you know the * size ahead of time you can use uwb_rc_neh_extra_size*()). We * register tables with the known events and their sizes, and then we * traverse those tables. For those with variable length, we provide a * way to lookup the size inside the event/notification's * payload. This allows device-specific event size tables to be * registered. * * @size: Size of the payload * * @offset: if != 0, at offset @offset-1 starts a field with a length * that has to be added to @size. The format of the field is * given by @type. * * @type: Type and length of the offset field. Most common is LE 16 * bits (that's why that is zero); others are there mostly to * cover for bugs and weirdos. */ struct uwb_est_entry { size_t size; unsigned offset; enum { UWB_EST_16 = 0, UWB_EST_8 = 1 } type; }; int uwb_est_register(u8 type, u8 code_high, u16 vendor, u16 product, const struct uwb_est_entry *, size_t entries); int uwb_est_unregister(u8 type, u8 code_high, u16 vendor, u16 product, const struct uwb_est_entry *, size_t entries); ssize_t uwb_est_find_size(struct uwb_rc *rc, const struct uwb_rceb *rceb, size_t len); /* -- Misc */ enum { EDC_MAX_ERRORS = 10, EDC_ERROR_TIMEFRAME = HZ, }; /* error density counter */ struct edc { unsigned long timestart; u16 errorcount; }; static inline void edc_init(struct edc *edc) { edc->timestart = jiffies; } /* Called when an error occurred. * This is way to determine if the number of acceptable errors per time * period has been exceeded. It is not accurate as there are cases in which * this scheme will not work, for example if there are periodic occurrences * of errors that straddle updates to the start time. This scheme is * sufficient for our usage. * * @returns 1 if maximum acceptable errors per timeframe has been exceeded. */ static inline int edc_inc(struct edc *err_hist, u16 max_err, u16 timeframe) { unsigned long now; now = jiffies; if (now - err_hist->timestart > timeframe) { err_hist->errorcount = 1; err_hist->timestart = now; } else if (++err_hist->errorcount > max_err) { err_hist->errorcount = 0; err_hist->timestart = now; return 1; } return 0; } /* Information Element handling */ struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len); int uwb_rc_ie_add(struct uwb_rc *uwb_rc, const struct uwb_ie_hdr *ies, size_t size); int uwb_rc_ie_rm(struct uwb_rc *uwb_rc, enum uwb_ie element_id); /* * Transmission statistics * * UWB uses LQI and RSSI (one byte values) for reporting radio signal * strength and line quality indication. We do quick and dirty * averages of those. They are signed values, btw. * * For 8 bit quantities, we keep the min, the max, an accumulator * (@sigma) and a # of samples. When @samples gets to 255, we compute * the average (@sigma / @samples), place it in @sigma and reset * @samples to 1 (so we use it as the first sample). * * Now, statistically speaking, probably I am kicking the kidneys of * some books I have in my shelves collecting dust, but I just want to * get an approx, not the Nobel. * * LOCKING: there is no locking per se, but we try to keep a lockless * schema. Only _add_samples() modifies the values--as long as you * have other locking on top that makes sure that no two calls of * _add_sample() happen at the same time, then we are fine. Now, for * resetting the values we just set @samples to 0 and that makes the * next _add_sample() to start with defaults. Reading the values in * _show() currently can race, so you need to make sure the calls are * under the same lock that protects calls to _add_sample(). FIXME: * currently unlocked (It is not ultraprecise but does the trick. Bite * me). */ struct stats { s8 min, max; s16 sigma; atomic_t samples; }; static inline void stats_init(struct stats *stats) { atomic_set(&stats->samples, 0); wmb(); } static inline void stats_add_sample(struct stats *stats, s8 sample) { s8 min, max; s16 sigma; unsigned samples = atomic_read(&stats->samples); if (samples == 0) { /* it was zero before, so we initialize */ min = 127; max = -128; sigma = 0; } else { min = stats->min; max = stats->max; sigma = stats->sigma; } if (sample < min) /* compute new values */ min = sample; else if (sample > max) max = sample; sigma += sample; stats->min = min; /* commit */ stats->max = max; stats->sigma = sigma; if (atomic_add_return(1, &stats->samples) > 255) { /* wrapped around! reset */ stats->sigma = sigma / 256; atomic_set(&stats->samples, 1); } } static inline ssize_t stats_show(struct stats *stats, char *buf) { int min, max, avg; int samples = atomic_read(&stats->samples); if (samples == 0) min = max = avg = 0; else { min = stats->min; max = stats->max; avg = stats->sigma / samples; } return scnprintf(buf, PAGE_SIZE, "%d %d %d\n", min, max, avg); } static inline ssize_t stats_store(struct stats *stats, const char *buf, size_t size) { stats_init(stats); return size; } #endif /* #ifndef __LINUX__UWB_H__ */