renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-12-16 01:04:08 +08:00
Code

uwb: add the uwb include files

Browse Source 
Signed-off-by: David Vrabel <david.vrabel@csr.com>
This commit is contained in:
Inaky Perez-Gonzalez 2008-09-17 16:34:05 +01:00 committed by David Vrabel
parent 99d368bc9e
commit 34e95e41f1
5 changed files with 2362 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

761
include/linux/uwb.h Normal file
View File

@ -0,0 +1,761 @@
/*
* 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/workqueue.h>
#include <linux/uwb/spec.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);
};
#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;
};
/**
* 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);
};
/**
* 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,
UWB_RSV_STATE_O_INITIATED,
UWB_RSV_STATE_O_PENDING,
UWB_RSV_STATE_O_MODIFIED,
UWB_RSV_STATE_O_ESTABLISHED,
UWB_RSV_STATE_T_ACCEPTED,
UWB_RSV_STATE_T_DENIED,
UWB_RSV_STATE_T_PENDING,
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;
};
};
/*
* 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
* @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 uwb_dev *owner;
struct uwb_rsv_target target;
enum uwb_drp_type type;
int max_mas;
int min_mas;
int sparsity;
bool is_multicast;
uwb_rsv_cb_f callback;
void *pal_priv;
enum uwb_rsv_state state;
u8 stream;
struct uwb_mas_bm mas;
struct uwb_ie_drp *drp_ie;
bool ie_valid;
struct timer_list timer;
bool expired;
};
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 targetted
* 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;
};
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);
/**
* 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 scanning;
enum uwb_scan_type scan_type:3;
unsigned ready:1;
struct uwb_notifs_chain notifs_chain;
struct uwb_drp_avail drp_avail;
struct list_head reservations;
struct mutex rsvs_mutex;
struct workqueue_struct *rsv_workq;
struct work_struct rsv_update_work;
struct mutex ies_mutex;
struct uwb_rc_cmd_set_ie *ies;
size_t ies_capacity;
spinlock_t pal_lock;
struct list_head pals;
struct uwb_dbg *dbg;
};
/**
* struct uwb_pal - a UWB PAL
* @new_rsv: called when a peer requests a reservation (may be NULL if
* the PAL cannot accept reservation requests).
*
* 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;
void (*new_rsv)(struct uwb_rsv *rsv);
};
void uwb_pal_init(struct uwb_pal *pal);
int uwb_pal_register(struct uwb_rc *rc, struct uwb_pal *pal);
void uwb_pal_unregister(struct uwb_rc *rc, 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);
ssize_t uwb_rc_get_ie(struct uwb_rc *, struct uwb_rc_evt_get_ie **);
int uwb_bg_joined(struct uwb_rc *rc);
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);
/**
* 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;
}
/**
* Events generated by UWB that can be passed to any listeners
*
* 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_BG_JOIN = 0, /* radio controller joined a beacon group */
UWB_NOTIF_BG_LEAVE = 1, /* radio controller left a beacon group */
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 occured.
* 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 occurences
* 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 */
/* For representing the state of writing to a buffer when iterating */
struct uwb_buf_ctx {
char *buf;
size_t bytes, size;
};
typedef int (*uwb_ie_f)(struct uwb_dev *, const struct uwb_ie_hdr *,
size_t, void *);
struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len);
ssize_t uwb_ie_for_each(struct uwb_dev *uwb_dev, uwb_ie_f fn, void *data,
const void *buf, size_t size);
int uwb_ie_dump_hex(struct uwb_dev *, const struct uwb_ie_hdr *,
size_t, void *);
int uwb_rc_set_ie(struct uwb_rc *, struct uwb_rc_cmd_set_ie *);
struct uwb_ie_hdr *uwb_ie_next(void **ptr, size_t *len);
/*
* 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__ */

57
include/linux/uwb/debug-cmd.h Normal file
View File

@ -0,0 +1,57 @@
/*
* Ultra Wide Band
* Debug interface commands
*
* Copyright (C) 2008 Cambridge Silicon Radio Ltd.
*
* 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, see <http://www.gnu.org/licenses/>.
*/
#ifndef __LINUX__UWB__DEBUG_CMD_H__
#define __LINUX__UWB__DEBUG_CMD_H__
#include <linux/types.h>
/*
* Debug interface commands
*
* UWB_DBG_CMD_RSV_ESTABLISH: Establish a new unicast reservation.
*
* UWB_DBG_CMD_RSV_TERMINATE: Terminate the Nth reservation.
*/
enum uwb_dbg_cmd_type {
UWB_DBG_CMD_RSV_ESTABLISH = 1,
UWB_DBG_CMD_RSV_TERMINATE = 2,
};
struct uwb_dbg_cmd_rsv_establish {
__u8 target[6];
__u8 type;
__u16 max_mas;
__u16 min_mas;
__u8 sparsity;
};
struct uwb_dbg_cmd_rsv_terminate {
int index;
};
struct uwb_dbg_cmd {
__u32 type;
union {
struct uwb_dbg_cmd_rsv_establish rsv_establish;
struct uwb_dbg_cmd_rsv_terminate rsv_terminate;
};
};
#endif /* #ifndef __LINUX__UWB__DEBUG_CMD_H__ */

82
include/linux/uwb/debug.h Normal file
View File

@ -0,0 +1,82 @@
/*
* Ultra Wide Band
* Debug Support
*
* 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
* Invoke like:
*
* #define D_LOCAL 4
* #include <linux/uwb/debug.h>
*
* At the end of your include files.
*/
#include <linux/types.h>
struct device;
extern void dump_bytes(struct device *dev, const void *_buf, size_t rsize);
/* Master debug switch; !0 enables, 0 disables */
#define D_MASTER (!0)
/* Local (per-file) debug switch; #define before #including */
#ifndef D_LOCAL
#define D_LOCAL 0
#endif
#undef __d_printf
#undef d_fnstart
#undef d_fnend
#undef d_printf
#undef d_dump
#define __d_printf(l, _tag, _dev, f, a...) \
do { \
struct device *__dev = (_dev); \
if (D_MASTER && D_LOCAL >= (l)) { \
char __head[64] = ""; \
if (_dev != NULL) { \
if ((unsigned long)__dev < 4096) \
printk(KERN_ERR "E: Corrupt dev %p\n", \
__dev); \
else \
snprintf(__head, sizeof(__head), \
"%s %s: ", \
dev_driver_string(__dev), \
__dev->bus_id); \
} \
printk(KERN_ERR "%s%s" _tag ": " f, __head, \
__func__, ## a); \
} \
} while (0 && _dev)
#define d_fnstart(l, _dev, f, a...) \
__d_printf(l, " FNSTART", _dev, f, ## a)
#define d_fnend(l, _dev, f, a...) \
__d_printf(l, " FNEND", _dev, f, ## a)
#define d_printf(l, _dev, f, a...) \
__d_printf(l, "", _dev, f, ## a)
#define d_dump(l, _dev, ptr, size) \
do { \
struct device *__dev = _dev; \
if (D_MASTER && D_LOCAL >= (l)) \
dump_bytes(__dev, ptr, size); \
} while (0 && _dev)
#define d_test(l) (D_MASTER && D_LOCAL >= (l))

727
include/linux/uwb/spec.h Normal file
View File

@ -0,0 +1,727 @@
/*
* Ultra Wide Band
* UWB Standard definitions
*
* 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.
*
*
* All these definitions are based on the ECMA-368 standard.
*
* Note all definitions are Little Endian in the wire, and we will
* convert them to host order before operating on the bitfields (that
* yes, we use extensively).
*/
#ifndef __LINUX__UWB_SPEC_H__
#define __LINUX__UWB_SPEC_H__
#include <linux/types.h>
#include <linux/bitmap.h>
#define i1480_FW 0x00000303
/* #define i1480_FW 0x00000302 */
/**
* Number of Medium Access Slots in a superframe.
*
* UWB divides time in SuperFrames, each one divided in 256 pieces, or
* Medium Access Slots. See MBOA MAC[5.4.5] for details. The MAS is the
* basic bandwidth allocation unit in UWB.
*/
enum { UWB_NUM_MAS = 256 };
/**
* Number of Zones in superframe.
*
* UWB divides the superframe into zones with numbering starting from BPST.
* See MBOA MAC[16.8.6]
*/
enum { UWB_NUM_ZONES = 16 };
/*
* Number of MAS in a zone.
*/
#define UWB_MAS_PER_ZONE (UWB_NUM_MAS / UWB_NUM_ZONES)
/*
* Number of streams per DRP reservation between a pair of devices.
*
* [ECMA-368] section 16.8.6.
*/
enum { UWB_NUM_STREAMS = 8 };
/*
* mMasLength
*
* The length of a MAS in microseconds.
*
* [ECMA-368] section 17.16.
*/
enum { UWB_MAS_LENGTH_US = 256 };
/*
* mBeaconSlotLength
*
* The length of the beacon slot in microseconds.
*
* [ECMA-368] section 17.16
*/
enum { UWB_BEACON_SLOT_LENGTH_US = 85 };
/*
* mMaxLostBeacons
*
* The number beacons missing in consecutive superframes before a
* device can be considered as unreachable.
*
* [ECMA-368] section 17.16
*/
enum { UWB_MAX_LOST_BEACONS = 3 };
/*
* Length of a superframe in microseconds.
*/
#define UWB_SUPERFRAME_LENGTH_US (UWB_MAS_LENGTH_US * UWB_NUM_MAS)
/**
* UWB MAC address
*
* It is *imperative* that this struct is exactly 6 packed bytes (as
* it is also used to define headers sent down and up the wire/radio).
*/
struct uwb_mac_addr {
u8 data[6];
} __attribute__((packed));
/**
* UWB device address
*
* It is *imperative* that this struct is exactly 6 packed bytes (as
* it is also used to define headers sent down and up the wire/radio).
*/
struct uwb_dev_addr {
u8 data[2];
} __attribute__((packed));
/**
* Types of UWB addresses
*
* Order matters (by size).
*/
enum uwb_addr_type {
UWB_ADDR_DEV = 0,
UWB_ADDR_MAC = 1,
};
/** Size of a char buffer for printing a MAC/device address */
enum { UWB_ADDR_STRSIZE = 32 };
/** UWB WiMedia protocol IDs. */
enum uwb_prid {
UWB_PRID_WLP_RESERVED = 0x0000,
UWB_PRID_WLP = 0x0001,
UWB_PRID_WUSB_BOT = 0x0010,
UWB_PRID_WUSB = 0x0010,
UWB_PRID_WUSB_TOP = 0x001F,
};
/** PHY Rate (MBOA MAC[7.8.12, Table 61]) */
enum uwb_phy_rate {
UWB_PHY_RATE_53 = 0,
UWB_PHY_RATE_80,
UWB_PHY_RATE_106,
UWB_PHY_RATE_160,
UWB_PHY_RATE_200,
UWB_PHY_RATE_320,
UWB_PHY_RATE_400,
UWB_PHY_RATE_480,
UWB_PHY_RATE_INVALID
};
/**
* Different ways to scan (MBOA MAC[6.2.2, Table 8], WUSB[Table 8-78])
*/
enum uwb_scan_type {
UWB_SCAN_ONLY = 0,
UWB_SCAN_OUTSIDE_BP,
UWB_SCAN_WHILE_INACTIVE,
UWB_SCAN_DISABLED,
UWB_SCAN_ONLY_STARTTIME,
UWB_SCAN_TOP
};
/** ACK Policy types (MBOA MAC[7.2.1.3]) */
enum uwb_ack_pol {
UWB_ACK_NO = 0,
UWB_ACK_INM = 1,
UWB_ACK_B = 2,
UWB_ACK_B_REQ = 3,
};
/** DRP reservation types ([ECMA-368 table 106) */
enum uwb_drp_type {
UWB_DRP_TYPE_ALIEN_BP = 0,
UWB_DRP_TYPE_HARD,
UWB_DRP_TYPE_SOFT,
UWB_DRP_TYPE_PRIVATE,
UWB_DRP_TYPE_PCA,
};
/** DRP Reason Codes ([ECMA-368] table 107) */
enum uwb_drp_reason {
UWB_DRP_REASON_ACCEPTED = 0,
UWB_DRP_REASON_CONFLICT,
UWB_DRP_REASON_PENDING,
UWB_DRP_REASON_DENIED,
UWB_DRP_REASON_MODIFIED,
};
/**
* DRP Notification Reason Codes (WHCI 0.95 [3.1.4.9])
*/
enum uwb_drp_notif_reason {
UWB_DRP_NOTIF_DRP_IE_RCVD = 0,
UWB_DRP_NOTIF_CONFLICT,
UWB_DRP_NOTIF_TERMINATE,
};
/** Allocation of MAS slots in a DRP request MBOA MAC[7.8.7] */
struct uwb_drp_alloc {
__le16 zone_bm;
__le16 mas_bm;
} __attribute__((packed));
/** General MAC Header format (ECMA-368[16.2]) */
struct uwb_mac_frame_hdr {
__le16 Frame_Control;
struct uwb_dev_addr DestAddr;
struct uwb_dev_addr SrcAddr;
__le16 Sequence_Control;
__le16 Access_Information;
} __attribute__((packed));
/**
* uwb_beacon_frame - a beacon frame including MAC headers
*
* [ECMA] section 16.3.
*/
struct uwb_beacon_frame {
struct uwb_mac_frame_hdr hdr;
struct uwb_mac_addr Device_Identifier; /* may be a NULL EUI-48 */
u8 Beacon_Slot_Number;
u8 Device_Control;
u8 IEData[];
} __attribute__((packed));
/** Information Element codes (MBOA MAC[T54]) */
enum uwb_ie {
UWB_PCA_AVAILABILITY = 2,
UWB_IE_DRP_AVAILABILITY = 8,
UWB_IE_DRP = 9,
UWB_BP_SWITCH_IE = 11,
UWB_MAC_CAPABILITIES_IE = 12,
UWB_PHY_CAPABILITIES_IE = 13,
UWB_APP_SPEC_PROBE_IE = 15,
UWB_IDENTIFICATION_IE = 19,
UWB_MASTER_KEY_ID_IE = 20,
UWB_IE_WLP = 250, /* WiMedia Logical Link Control Protocol WLP 0.99 */
UWB_APP_SPEC_IE = 255,
};
/**
* Header common to all Information Elements (IEs)
*/
struct uwb_ie_hdr {
u8 element_id; /* enum uwb_ie */
u8 length;
} __attribute__((packed));
/** Dynamic Reservation Protocol IE (MBOA MAC[7.8.6]) */
struct uwb_ie_drp {
struct uwb_ie_hdr hdr;
__le16 drp_control;
struct uwb_dev_addr dev_addr;
struct uwb_drp_alloc allocs[];
} __attribute__((packed));
static inline int uwb_ie_drp_type(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 0) & 0x7;
}
static inline int uwb_ie_drp_stream_index(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 3) & 0x7;
}
static inline int uwb_ie_drp_reason_code(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 6) & 0x7;
}
static inline int uwb_ie_drp_status(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 9) & 0x1;
}
static inline int uwb_ie_drp_owner(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 10) & 0x1;
}
static inline int uwb_ie_drp_tiebreaker(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 11) & 0x1;
}
static inline int uwb_ie_drp_unsafe(struct uwb_ie_drp *ie)
{
return (le16_to_cpu(ie->drp_control) >> 12) & 0x1;
}
static inline void uwb_ie_drp_set_type(struct uwb_ie_drp *ie, enum uwb_drp_type type)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (drp_control & ~(0x7 << 0)) | (type << 0);
ie->drp_control = cpu_to_le16(drp_control);
}
static inline void uwb_ie_drp_set_stream_index(struct uwb_ie_drp *ie, int stream_index)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (drp_control & ~(0x7 << 3)) | (stream_index << 3);
ie->drp_control = cpu_to_le16(drp_control);
}
static inline void uwb_ie_drp_set_reason_code(struct uwb_ie_drp *ie,
enum uwb_drp_reason reason_code)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (ie->drp_control & ~(0x7 << 6)) | (reason_code << 6);
ie->drp_control = cpu_to_le16(drp_control);
}
static inline void uwb_ie_drp_set_status(struct uwb_ie_drp *ie, int status)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (drp_control & ~(0x1 << 9)) | (status << 9);
ie->drp_control = cpu_to_le16(drp_control);
}
static inline void uwb_ie_drp_set_owner(struct uwb_ie_drp *ie, int owner)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (drp_control & ~(0x1 << 10)) | (owner << 10);
ie->drp_control = cpu_to_le16(drp_control);
}
static inline void uwb_ie_drp_set_tiebreaker(struct uwb_ie_drp *ie, int tiebreaker)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (drp_control & ~(0x1 << 11)) | (tiebreaker << 11);
ie->drp_control = cpu_to_le16(drp_control);
}
static inline void uwb_ie_drp_set_unsafe(struct uwb_ie_drp *ie, int unsafe)
{
u16 drp_control = le16_to_cpu(ie->drp_control);
drp_control = (drp_control & ~(0x1 << 12)) | (unsafe << 12);
ie->drp_control = cpu_to_le16(drp_control);
}
/** Dynamic Reservation Protocol IE (MBOA MAC[7.8.7]) */
struct uwb_ie_drp_avail {
struct uwb_ie_hdr hdr;
DECLARE_BITMAP(bmp, UWB_NUM_MAS);
} __attribute__((packed));
/**
* The Vendor ID is set to an OUI that indicates the vendor of the device.
* ECMA-368 [16.8.10]
*/
struct uwb_vendor_id {
u8 data[3];
} __attribute__((packed));
/**
* The device type ID
* FIXME: clarify what this means
* ECMA-368 [16.8.10]
*/
struct uwb_device_type_id {
u8 data[3];
} __attribute__((packed));
/**
* UWB device information types
* ECMA-368 [16.8.10]
*/
enum uwb_dev_info_type {
UWB_DEV_INFO_VENDOR_ID = 0,
UWB_DEV_INFO_VENDOR_TYPE,
UWB_DEV_INFO_NAME,
};
/**
* UWB device information found in Identification IE
* ECMA-368 [16.8.10]
*/
struct uwb_dev_info {
u8 type; /* enum uwb_dev_info_type */
u8 length;
u8 data[];
} __attribute__((packed));
/**
* UWB Identification IE
* ECMA-368 [16.8.10]
*/
struct uwb_identification_ie {
struct uwb_ie_hdr hdr;
struct uwb_dev_info info[];
} __attribute__((packed));
/*
* UWB Radio Controller
*
* These definitions are common to the Radio Control layers as
* exported by the WUSB1.0 HWA and WHCI interfaces.
*/
/** Radio Control Command Block (WUSB1.0[Table 8-65] and WHCI 0.95) */
struct uwb_rccb {
u8 bCommandType; /* enum hwa_cet */
__le16 wCommand; /* Command code */
u8 bCommandContext; /* Context ID */
} __attribute__((packed));
/** Radio Control Event Block (WUSB[table 8-66], WHCI 0.95) */
struct uwb_rceb {
u8 bEventType; /* enum hwa_cet */
__le16 wEvent; /* Event code */
u8 bEventContext; /* Context ID */
} __attribute__((packed));
enum {
UWB_RC_CET_GENERAL = 0, /* General Command/Event type */
UWB_RC_CET_EX_TYPE_1 = 1, /* Extended Type 1 Command/Event type */
};
/* Commands to the radio controller */
enum uwb_rc_cmd {
UWB_RC_CMD_CHANNEL_CHANGE = 16,
UWB_RC_CMD_DEV_ADDR_MGMT = 17, /* Device Address Management */
UWB_RC_CMD_GET_IE = 18, /* GET Information Elements */
UWB_RC_CMD_RESET = 19,
UWB_RC_CMD_SCAN = 20, /* Scan management */
UWB_RC_CMD_SET_BEACON_FILTER = 21,
UWB_RC_CMD_SET_DRP_IE = 22, /* Dynamic Reservation Protocol IEs */
UWB_RC_CMD_SET_IE = 23, /* Information Element management */
UWB_RC_CMD_SET_NOTIFICATION_FILTER = 24,
UWB_RC_CMD_SET_TX_POWER = 25,
UWB_RC_CMD_SLEEP = 26,
UWB_RC_CMD_START_BEACON = 27,
UWB_RC_CMD_STOP_BEACON = 28,
UWB_RC_CMD_BP_MERGE = 29,
UWB_RC_CMD_SEND_COMMAND_FRAME = 30,
UWB_RC_CMD_SET_ASIE_NOTIF = 31,
};
/* Notifications from the radio controller */
enum uwb_rc_evt {
UWB_RC_EVT_IE_RCV = 0,
UWB_RC_EVT_BEACON = 1,
UWB_RC_EVT_BEACON_SIZE = 2,
UWB_RC_EVT_BPOIE_CHANGE = 3,
UWB_RC_EVT_BP_SLOT_CHANGE = 4,
UWB_RC_EVT_BP_SWITCH_IE_RCV = 5,
UWB_RC_EVT_DEV_ADDR_CONFLICT = 6,
UWB_RC_EVT_DRP_AVAIL = 7,
UWB_RC_EVT_DRP = 8,
UWB_RC_EVT_BP_SWITCH_STATUS = 9,
UWB_RC_EVT_CMD_FRAME_RCV = 10,
UWB_RC_EVT_CHANNEL_CHANGE_IE_RCV = 11,
/* Events (command responses) use the same code as the command */
UWB_RC_EVT_UNKNOWN_CMD_RCV = 65535,
};
enum uwb_rc_extended_type_1_cmd {
UWB_RC_SET_DAA_ENERGY_MASK = 32,
UWB_RC_SET_NOTIFICATION_FILTER_EX = 33,
};
enum uwb_rc_extended_type_1_evt {
UWB_RC_DAA_ENERGY_DETECTED = 0,
};
/* Radio Control Result Code. [WHCI] table 3-3. */
enum {
UWB_RC_RES_SUCCESS = 0,
UWB_RC_RES_FAIL,
UWB_RC_RES_FAIL_HARDWARE,
UWB_RC_RES_FAIL_NO_SLOTS,
UWB_RC_RES_FAIL_BEACON_TOO_LARGE,
UWB_RC_RES_FAIL_INVALID_PARAMETER,
UWB_RC_RES_FAIL_UNSUPPORTED_PWR_LEVEL,
UWB_RC_RES_FAIL_INVALID_IE_DATA,
UWB_RC_RES_FAIL_BEACON_SIZE_EXCEEDED,
UWB_RC_RES_FAIL_CANCELLED,
UWB_RC_RES_FAIL_INVALID_STATE,
UWB_RC_RES_FAIL_INVALID_SIZE,
UWB_RC_RES_FAIL_ACK_NOT_RECEIVED,
UWB_RC_RES_FAIL_NO_MORE_ASIE_NOTIF,
UWB_RC_RES_FAIL_TIME_OUT = 255,
};
/* Confirm event. [WHCI] section 3.1.3.1 etc. */
struct uwb_rc_evt_confirm {
struct uwb_rceb rceb;
u8 bResultCode;
} __attribute__((packed));
/* Device Address Management event. [WHCI] section 3.1.3.2. */
struct uwb_rc_evt_dev_addr_mgmt {
struct uwb_rceb rceb;
u8 baAddr[6];
u8 bResultCode;
} __attribute__((packed));
/* Get IE Event. [WHCI] section 3.1.3.3. */
struct uwb_rc_evt_get_ie {
struct uwb_rceb rceb;
__le16 wIELength;
u8 IEData[];
} __attribute__((packed));
/* Set DRP IE Event. [WHCI] section 3.1.3.7. */
struct uwb_rc_evt_set_drp_ie {
struct uwb_rceb rceb;
__le16 wRemainingSpace;
u8 bResultCode;
} __attribute__((packed));
/* Set IE Event. [WHCI] section 3.1.3.8. */
struct uwb_rc_evt_set_ie {
struct uwb_rceb rceb;
__le16 RemainingSpace;
u8 bResultCode;
} __attribute__((packed));
/* Scan command. [WHCI] 3.1.3.5. */
struct uwb_rc_cmd_scan {
struct uwb_rccb rccb;
u8 bChannelNumber;
u8 bScanState;
__le16 wStartTime;
} __attribute__((packed));
/* Set DRP IE command. [WHCI] section 3.1.3.7. */
struct uwb_rc_cmd_set_drp_ie {
struct uwb_rccb rccb;
__le16 wIELength;
struct uwb_ie_drp IEData[];
} __attribute__((packed));
/* Set IE command. [WHCI] section 3.1.3.8. */
struct uwb_rc_cmd_set_ie {
struct uwb_rccb rccb;
__le16 wIELength;
u8 IEData[];
} __attribute__((packed));
/* Set DAA Energy Mask event. [WHCI 0.96] section 3.1.3.17. */
struct uwb_rc_evt_set_daa_energy_mask {
struct uwb_rceb rceb;
__le16 wLength;
u8 result;
} __attribute__((packed));
/* Set Notification Filter Extended event. [WHCI 0.96] section 3.1.3.18. */
struct uwb_rc_evt_set_notification_filter_ex {
struct uwb_rceb rceb;
__le16 wLength;
u8 result;
} __attribute__((packed));
/* IE Received notification. [WHCI] section 3.1.4.1. */
struct uwb_rc_evt_ie_rcv {
struct uwb_rceb rceb;
struct uwb_dev_addr SrcAddr;
__le16 wIELength;
u8 IEData[];
} __attribute__((packed));
/* Type of the received beacon. [WHCI] section 3.1.4.2. */
enum uwb_rc_beacon_type {
UWB_RC_BEACON_TYPE_SCAN = 0,
UWB_RC_BEACON_TYPE_NEIGHBOR,
UWB_RC_BEACON_TYPE_OL_ALIEN,
UWB_RC_BEACON_TYPE_NOL_ALIEN,
};
/* Beacon received notification. [WHCI] 3.1.4.2. */
struct uwb_rc_evt_beacon {
struct uwb_rceb rceb;
u8 bChannelNumber;
u8 bBeaconType;
__le16 wBPSTOffset;
u8 bLQI;
u8 bRSSI;
__le16 wBeaconInfoLength;
u8 BeaconInfo[];
} __attribute__((packed));
/* Beacon Size Change notification. [WHCI] section 3.1.4.3 */
struct uwb_rc_evt_beacon_size {
struct uwb_rceb rceb;
__le16 wNewBeaconSize;
} __attribute__((packed));
/* BPOIE Change notification. [WHCI] section 3.1.4.4. */
struct uwb_rc_evt_bpoie_change {
struct uwb_rceb rceb;
__le16 wBPOIELength;
u8 BPOIE[];
} __attribute__((packed));
/* Beacon Slot Change notification. [WHCI] section 3.1.4.5. */
struct uwb_rc_evt_bp_slot_change {
struct uwb_rceb rceb;
u8 slot_info;
} __attribute__((packed));
static inline int uwb_rc_evt_bp_slot_change_slot_num(
const struct uwb_rc_evt_bp_slot_change *evt)
{
return evt->slot_info & 0x7f;
}
static inline int uwb_rc_evt_bp_slot_change_no_slot(
const struct uwb_rc_evt_bp_slot_change *evt)
{
return (evt->slot_info & 0x80) >> 7;
}
/* BP Switch IE Received notification. [WHCI] section 3.1.4.6. */
struct uwb_rc_evt_bp_switch_ie_rcv {
struct uwb_rceb rceb;
struct uwb_dev_addr wSrcAddr;
__le16 wIELength;
u8 IEData[];
} __attribute__((packed));
/* DevAddr Conflict notification. [WHCI] section 3.1.4.7. */
struct uwb_rc_evt_dev_addr_conflict {
struct uwb_rceb rceb;
} __attribute__((packed));
/* DRP notification. [WHCI] section 3.1.4.9. */
struct uwb_rc_evt_drp {
struct uwb_rceb rceb;
struct uwb_dev_addr src_addr;
u8 reason;
u8 beacon_slot_number;
__le16 ie_length;
u8 ie_data[];
} __attribute__((packed));
static inline enum uwb_drp_notif_reason uwb_rc_evt_drp_reason(struct uwb_rc_evt_drp *evt)
{
return evt->reason & 0x0f;
}
/* DRP Availability Change notification. [WHCI] section 3.1.4.8. */
struct uwb_rc_evt_drp_avail {
struct uwb_rceb rceb;
DECLARE_BITMAP(bmp, UWB_NUM_MAS);
} __attribute__((packed));
/* BP switch status notification. [WHCI] section 3.1.4.10. */
struct uwb_rc_evt_bp_switch_status {
struct uwb_rceb rceb;
u8 status;
u8 slot_offset;
__le16 bpst_offset;
u8 move_countdown;
} __attribute__((packed));
/* Command Frame Received notification. [WHCI] section 3.1.4.11. */
struct uwb_rc_evt_cmd_frame_rcv {
struct uwb_rceb rceb;
__le16 receive_time;
struct uwb_dev_addr wSrcAddr;
struct uwb_dev_addr wDstAddr;
__le16 control;
__le16 reserved;
__le16 dataLength;
u8 data[];
} __attribute__((packed));
/* Channel Change IE Received notification. [WHCI] section 3.1.4.12. */
struct uwb_rc_evt_channel_change_ie_rcv {
struct uwb_rceb rceb;
struct uwb_dev_addr wSrcAddr;
__le16 wIELength;
u8 IEData[];
} __attribute__((packed));
/* DAA Energy Detected notification. [WHCI 0.96] section 3.1.4.14. */
struct uwb_rc_evt_daa_energy_detected {
struct uwb_rceb rceb;
__le16 wLength;
u8 bandID;
u8 reserved;
u8 toneBmp[16];
} __attribute__((packed));
/**
* Radio Control Interface Class Descriptor
*
* WUSB 1.0 [8.6.1.2]
*/
struct uwb_rc_control_intf_class_desc {
u8 bLength;
u8 bDescriptorType;
__le16 bcdRCIVersion;
} __attribute__((packed));
#endif /* #ifndef __LINUX__UWB_SPEC_H__ */

735
include/linux/wlp.h Normal file
View File

@ -0,0 +1,735 @@
/*
* WiMedia Logical Link Control Protocol (WLP)
*
* Copyright (C) 2005-2006 Intel Corporation
* Reinette Chatre <reinette.chatre@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: docs
*
* - Does not (yet) include support for WLP control frames
* WLP Draft 0.99 [6.5].
*
* A visual representation of the data structures.
*
* wssidB wssidB
* ^ ^
* | |
* wssidA wssidA
* wlp interface { ^ ^
* ... | |
* ... ... wssid wssid ...
* wlp --- ... | |
* }; neighbors --> neighbA --> neighbB
* ...
* wss
* ...
* eda cache --> neighborA --> neighborB --> neighborC ...
*/
#ifndef __LINUX__WLP_H_
#define __LINUX__WLP_H_
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/list.h>
#include <linux/uwb.h>
/**
* WLP Protocol ID
* WLP Draft 0.99 [6.2]
*
* The MUX header for all WLP frames
*/
#define WLP_PROTOCOL_ID 0x0100
/**
* WLP Version
* WLP version placed in the association frames (WLP 0.99 [6.6])
*/
#define WLP_VERSION 0x10
/**
* Bytes needed to print UUID as string
*/
#define WLP_WSS_UUID_STRSIZE 48
/**
* Bytes needed to print nonce as string
*/
#define WLP_WSS_NONCE_STRSIZE 48
/**
* Size used for WLP name size
*
* The WSS name is set to 65 bytes, 1 byte larger than the maximum
* allowed by the WLP spec. This is to have a null terminated string
* for display to the user. A maximum of 64 bytes will still be used
* when placing the WSS name field in association frames.
*/
#define WLP_WSS_NAME_SIZE 65
/**
* Number of bytes added by WLP to data frame
*
* A data frame transmitted from a host will be placed in a Standard or
* Abbreviated WLP frame. These have an extra 4 bytes of header (struct
* wlp_frame_std_abbrv_hdr).
* When the stack sends this data frame for transmission it needs to ensure
* there is enough headroom for this header.
*/
#define WLP_DATA_HLEN 4
/**
* State of device regarding WLP Service Set
*
* WLP_WSS_STATE_NONE: the host does not participate in any WSS
* WLP_WSS_STATE_PART_ENROLLED: used as part of the enrollment sequence
* ("Partial Enroll"). This state is used to
* indicate the first part of enrollment that is
* unsecure. If the WSS is unsecure then the
* state will promptly go to WLP_WSS_STATE_ENROLLED,
* if the WSS is not secure then the enrollment
* procedure is a few more steps before we are
* enrolled.
* WLP_WSS_STATE_ENROLLED: the host is enrolled in a WSS
* WLP_WSS_STATE_ACTIVE: WSS is activated
* WLP_WSS_STATE_CONNECTED: host is connected to neighbor in WSS
*
*/
enum wlp_wss_state {
WLP_WSS_STATE_NONE = 0,
WLP_WSS_STATE_PART_ENROLLED,
WLP_WSS_STATE_ENROLLED,
WLP_WSS_STATE_ACTIVE,
WLP_WSS_STATE_CONNECTED,
};
/**
* WSS Secure status
* WLP 0.99 Table 6
*
* Set to one if the WSS is secure, zero if it is not secure
*/
enum wlp_wss_sec_status {
WLP_WSS_UNSECURE = 0,
WLP_WSS_SECURE,
};
/**
* WLP frame type
* WLP Draft 0.99 [6.2 Table 1]
*/
enum wlp_frame_type {
WLP_FRAME_STANDARD = 0,
WLP_FRAME_ABBREVIATED,
WLP_FRAME_CONTROL,
WLP_FRAME_ASSOCIATION,
};
/**
* WLP Association Message Type
* WLP Draft 0.99 [6.6.1.2 Table 8]
*/
enum wlp_assoc_type {
WLP_ASSOC_D1 = 2,
WLP_ASSOC_D2 = 3,
WLP_ASSOC_M1 = 4,
WLP_ASSOC_M2 = 5,
WLP_ASSOC_M3 = 7,
WLP_ASSOC_M4 = 8,
WLP_ASSOC_M5 = 9,
WLP_ASSOC_M6 = 10,
WLP_ASSOC_M7 = 11,
WLP_ASSOC_M8 = 12,
WLP_ASSOC_F0 = 14,
WLP_ASSOC_E1 = 32,
WLP_ASSOC_E2 = 33,
WLP_ASSOC_C1 = 34,
WLP_ASSOC_C2 = 35,
WLP_ASSOC_C3 = 36,
WLP_ASSOC_C4 = 37,
};
/**
* WLP Attribute Type
* WLP Draft 0.99 [6.6.1 Table 6]
*/
enum wlp_attr_type {
WLP_ATTR_AUTH = 0x1005, /* Authenticator */
WLP_ATTR_DEV_NAME = 0x1011, /* Device Name */
WLP_ATTR_DEV_PWD_ID = 0x1012, /* Device Password ID */
WLP_ATTR_E_HASH1 = 0x1014, /* E-Hash1 */
WLP_ATTR_E_HASH2 = 0x1015, /* E-Hash2 */
WLP_ATTR_E_SNONCE1 = 0x1016, /* E-SNonce1 */
WLP_ATTR_E_SNONCE2 = 0x1017, /* E-SNonce2 */
WLP_ATTR_ENCR_SET = 0x1018, /* Encrypted Settings */
WLP_ATTR_ENRL_NONCE = 0x101A, /* Enrollee Nonce */
WLP_ATTR_KEYWRAP_AUTH = 0x101E, /* Key Wrap Authenticator */
WLP_ATTR_MANUF = 0x1021, /* Manufacturer */
WLP_ATTR_MSG_TYPE = 0x1022, /* Message Type */
WLP_ATTR_MODEL_NAME = 0x1023, /* Model Name */
WLP_ATTR_MODEL_NR = 0x1024, /* Model Number */
WLP_ATTR_PUB_KEY = 0x1032, /* Public Key */
WLP_ATTR_REG_NONCE = 0x1039, /* Registrar Nonce */
WLP_ATTR_R_HASH1 = 0x103D, /* R-Hash1 */
WLP_ATTR_R_HASH2 = 0x103E, /* R-Hash2 */
WLP_ATTR_R_SNONCE1 = 0x103F, /* R-SNonce1 */
WLP_ATTR_R_SNONCE2 = 0x1040, /* R-SNonce2 */
WLP_ATTR_SERIAL = 0x1042, /* Serial number */
WLP_ATTR_UUID_E = 0x1047, /* UUID-E */
WLP_ATTR_UUID_R = 0x1048, /* UUID-R */
WLP_ATTR_PRI_DEV_TYPE = 0x1054, /* Primary Device Type */
WLP_ATTR_SEC_DEV_TYPE = 0x1055, /* Secondary Device Type */
WLP_ATTR_PORT_DEV = 0x1056, /* Portable Device */
WLP_ATTR_APP_EXT = 0x1058, /* Application Extension */
WLP_ATTR_WLP_VER = 0x2000, /* WLP Version */
WLP_ATTR_WSSID = 0x2001, /* WSSID */
WLP_ATTR_WSS_NAME = 0x2002, /* WSS Name */
WLP_ATTR_WSS_SEC_STAT = 0x2003, /* WSS Secure Status */
WLP_ATTR_WSS_BCAST = 0x2004, /* WSS Broadcast Address */
WLP_ATTR_WSS_M_KEY = 0x2005, /* WSS Master Key */
WLP_ATTR_ACC_ENRL = 0x2006, /* Accepting Enrollment */
WLP_ATTR_WSS_INFO = 0x2007, /* WSS Information */
WLP_ATTR_WSS_SEL_MTHD = 0x2008, /* WSS Selection Method */
WLP_ATTR_ASSC_MTHD_LIST = 0x2009, /* Association Methods List */
WLP_ATTR_SEL_ASSC_MTHD = 0x200A, /* Selected Association Method */
WLP_ATTR_ENRL_HASH_COMM = 0x200B, /* Enrollee Hash Commitment */
WLP_ATTR_WSS_TAG = 0x200C, /* WSS Tag */
WLP_ATTR_WSS_VIRT = 0x200D, /* WSS Virtual EUI-48 */
WLP_ATTR_WLP_ASSC_ERR = 0x200E, /* WLP Association Error */
WLP_ATTR_VNDR_EXT = 0x200F, /* Vendor Extension */
};
/**
* WLP Category ID of primary/secondary device
* WLP Draft 0.99 [6.6.1.8 Table 12]
*/
enum wlp_dev_category_id {
WLP_DEV_CAT_COMPUTER = 1,
WLP_DEV_CAT_INPUT,
WLP_DEV_CAT_PRINT_SCAN_FAX_COPIER,
WLP_DEV_CAT_CAMERA,
WLP_DEV_CAT_STORAGE,
WLP_DEV_CAT_INFRASTRUCTURE,
WLP_DEV_CAT_DISPLAY,
WLP_DEV_CAT_MULTIM,
WLP_DEV_CAT_GAMING,
WLP_DEV_CAT_TELEPHONE,
WLP_DEV_CAT_OTHER = 65535,
};
/**
* WLP WSS selection method
* WLP Draft 0.99 [6.6.1.6 Table 10]
*/
enum wlp_wss_sel_mthd {
WLP_WSS_ENRL_SELECT = 1, /* Enrollee selects */
WLP_WSS_REG_SELECT, /* Registrar selects */
};
/**
* WLP association error values
* WLP Draft 0.99 [6.6.1.5 Table 9]
*/
enum wlp_assc_error {
WLP_ASSOC_ERROR_NONE,
WLP_ASSOC_ERROR_AUTH, /* Authenticator Failure */
WLP_ASSOC_ERROR_ROGUE, /* Rogue activity suspected */
WLP_ASSOC_ERROR_BUSY, /* Device busy */
WLP_ASSOC_ERROR_LOCK, /* Setup Locked */
WLP_ASSOC_ERROR_NOT_READY, /* Registrar not ready */
WLP_ASSOC_ERROR_INV, /* Invalid WSS selection */
WLP_ASSOC_ERROR_MSG_TIME, /* Message timeout */
WLP_ASSOC_ERROR_ENR_TIME, /* Enrollment session timeout */
WLP_ASSOC_ERROR_PW, /* Device password invalid */
WLP_ASSOC_ERROR_VER, /* Unsupported version */
WLP_ASSOC_ERROR_INT, /* Internal error */
WLP_ASSOC_ERROR_UNDEF, /* Undefined error */
WLP_ASSOC_ERROR_NUM, /* Numeric comparison failure */
WLP_ASSOC_ERROR_WAIT, /* Waiting for user input */
};
/**
* WLP Parameters
* WLP 0.99 [7.7]
*/
enum wlp_parameters {
WLP_PER_MSG_TIMEOUT = 15, /* Seconds to wait for response to
association message. */
};
/**
* WLP IE
*
* The WLP IE should be included in beacons by all devices.
*
* The driver can set only a few of the fields in this information element,
* most fields are managed by the device self. When the driver needs to set
* a field it will only provide values for the fields of interest, the rest
* will be filled with zeroes. The fields of interest are:
*
* Element ID
* Length
* Capabilities (only to include WSSID Hash list length)
* WSSID Hash List fields
*
* WLP 0.99 [6.7]
*
* Only the fields that will be used are detailed in this structure, rest
* are not detailed or marked as "notused".
*/
struct wlp_ie {
struct uwb_ie_hdr hdr;
__le16 capabilities;
__le16 cycle_param;
__le16 acw_anchor_addr;
u8 wssid_hash_list[];
} __attribute__((packed));
static inline int wlp_ie_hash_length(struct wlp_ie *ie)
{
return (le16_to_cpu(ie->capabilities) >> 12) & 0xf;
}
static inline void wlp_ie_set_hash_length(struct wlp_ie *ie, int hash_length)
{
u16 caps = le16_to_cpu(ie->capabilities);
caps = (caps & ~(0xf << 12)) | (hash_length << 12);
ie->capabilities = cpu_to_le16(caps);
}
/**
* WLP nonce
* WLP Draft 0.99 [6.6.1 Table 6]
*
* A 128-bit random number often used (E-SNonce1, E-SNonce2, Enrollee
* Nonce, Registrar Nonce, R-SNonce1, R-SNonce2). It is passed to HW so
* it is packed.
*/
struct wlp_nonce {
u8 data[16];
} __attribute__((packed));
/**
* WLP UUID
* WLP Draft 0.99 [6.6.1 Table 6]
*
* Universally Unique Identifier (UUID) encoded as an octet string in the
* order the octets are shown in string representation in RFC4122. A UUID
* is often used (UUID-E, UUID-R, WSSID). It is passed to HW so it is packed.
*/
struct wlp_uuid {
u8 data[16];
} __attribute__((packed));
/**
* Primary and secondary device type attributes
* WLP Draft 0.99 [6.6.1.8]
*/
struct wlp_dev_type {
enum wlp_dev_category_id category:16;
u8 OUI[3];
u8 OUIsubdiv;
__le16 subID;
} __attribute__((packed));
/**
* WLP frame header
* WLP Draft 0.99 [6.2]
*/
struct wlp_frame_hdr {
__le16 mux_hdr; /* WLP_PROTOCOL_ID */
enum wlp_frame_type type:8;
} __attribute__((packed));
/**
* WLP attribute field header
* WLP Draft 0.99 [6.6.1]
*
* Header of each attribute found in an association frame
*/
struct wlp_attr_hdr {
__le16 type;
__le16 length;
} __attribute__((packed));
/**
* Device information commonly used together
*
* Each of these device information elements has a specified range in which it
* should fit (WLP 0.99 [Table 6]). This range provided in the spec does not
* include the termination null '\0' character (when used in the
* association protocol the attribute fields are accompanied
* with a "length" field so the full range from the spec can be used for
* the value). We thus allocate an extra byte to be able to store a string
* of max length with a terminating '\0'.
*/
struct wlp_device_info {
char name[33];
char model_name[33];
char manufacturer[65];
char model_nr[33];
char serial[33];
struct wlp_dev_type prim_dev_type;
};
/**
* Macros for the WLP attributes
*
* There are quite a few attributes (total is 43). The attribute layout can be
* in one of three categories: one value, an array, an enum forced to 8 bits.
* These macros help with their definitions.
*/
#define wlp_attr(type, name) \
struct wlp_attr_##name { \
struct wlp_attr_hdr hdr; \
type name; \
} __attribute__((packed));
#define wlp_attr_array(type, name) \
struct wlp_attr_##name { \
struct wlp_attr_hdr hdr; \
type name[]; \
} __attribute__((packed));
/**
* WLP association attribute fields
* WLP Draft 0.99 [6.6.1 Table 6]
*
* Attributes appear in same order as the Table in the spec
* FIXME Does not define all attributes yet
*/
/* Device name: Friendly name of sending device */
wlp_attr_array(u8, dev_name)
/* Enrollee Nonce: Random number generated by enrollee for an enrollment
* session */
wlp_attr(struct wlp_nonce, enonce)
/* Manufacturer name: Name of manufacturer of the sending device */
wlp_attr_array(u8, manufacturer)
/* WLP Message Type */
wlp_attr(u8, msg_type)
/* WLP Model name: Model name of sending device */
wlp_attr_array(u8, model_name)
/* WLP Model number: Model number of sending device */
wlp_attr_array(u8, model_nr)
/* Registrar Nonce: Random number generated by registrar for an enrollment
* session */
wlp_attr(struct wlp_nonce, rnonce)
/* Serial number of device */
wlp_attr_array(u8, serial)
/* UUID of enrollee */
wlp_attr(struct wlp_uuid, uuid_e)
/* UUID of registrar */
wlp_attr(struct wlp_uuid, uuid_r)
/* WLP Primary device type */
wlp_attr(struct wlp_dev_type, prim_dev_type)
/* WLP Secondary device type */
wlp_attr(struct wlp_dev_type, sec_dev_type)
/* WLP protocol version */
wlp_attr(u8, version)
/* WLP service set identifier */
wlp_attr(struct wlp_uuid, wssid)
/* WLP WSS name */
wlp_attr_array(u8, wss_name)
/* WLP WSS Secure Status */
wlp_attr(u8, wss_sec_status)
/* WSS Broadcast Address */
wlp_attr(struct uwb_mac_addr, wss_bcast)
/* WLP Accepting Enrollment */
wlp_attr(u8, accept_enrl)
/**
* WSS information attributes
* WLP Draft 0.99 [6.6.3 Table 15]
*/
struct wlp_wss_info {
struct wlp_attr_wssid wssid;
struct wlp_attr_wss_name name;
struct wlp_attr_accept_enrl accept;
struct wlp_attr_wss_sec_status sec_stat;
struct wlp_attr_wss_bcast bcast;
} __attribute__((packed));
/* WLP WSS Information */
wlp_attr_array(struct wlp_wss_info, wss_info)
/* WLP WSS Selection method */
wlp_attr(u8, wss_sel_mthd)
/* WLP WSS tag */
wlp_attr(u8, wss_tag)
/* WSS Virtual Address */
wlp_attr(struct uwb_mac_addr, wss_virt)
/* WLP association error */
wlp_attr(u8, wlp_assc_err)
/**
* WLP standard and abbreviated frames
*
* WLP Draft 0.99 [6.3] and [6.4]
*
* The difference between the WLP standard frame and the WLP
* abbreviated frame is that the standard frame includes the src
* and dest addresses from the Ethernet header, the abbreviated frame does
* not.
* The src/dest (as well as the type/length and client data) are already
* defined as part of the Ethernet header, we do not do this here.
* From this perspective the standard and abbreviated frames appear the
* same - they will be treated differently though.
*
* The size of this header is also captured in WLP_DATA_HLEN to enable
* interfaces to prepare their headroom.
*/
struct wlp_frame_std_abbrv_hdr {
struct wlp_frame_hdr hdr;
u8 tag;
} __attribute__((packed));
/**
* WLP association frames
*
* WLP Draft 0.99 [6.6]
*/
struct wlp_frame_assoc {
struct wlp_frame_hdr hdr;
enum wlp_assoc_type type:8;
struct wlp_attr_version version;
struct wlp_attr_msg_type msg_type;
u8 attr[];
} __attribute__((packed));
/* Ethernet to dev address mapping */
struct wlp_eda {
spinlock_t lock;
struct list_head cache; /* Eth<->Dev Addr cache */
};
/**
* WSS information temporary storage
*
* This information is only stored temporarily during discovery. It should
* not be stored unless the device is enrolled in the advertised WSS. This
* is done mainly because we follow the letter of the spec in this regard.
* See WLP 0.99 [7.2.3].
* When the device does become enrolled in a WSS the WSS information will
* be stored as part of the more comprehensive struct wlp_wss.
*/
struct wlp_wss_tmp_info {
char name[WLP_WSS_NAME_SIZE];
u8 accept_enroll;
u8 sec_status;
struct uwb_mac_addr bcast;
};
struct wlp_wssid_e {
struct list_head node;
struct wlp_uuid wssid;
struct wlp_wss_tmp_info *info;
};
/**
* A cache entry of WLP neighborhood
*
* @node: head of list is wlp->neighbors
* @wssid: list of wssids of this neighbor, element is wlp_wssid_e
* @info: temporary storage for information learned during discovery. This
* storage is used together with the wssid_e temporary storage
* during discovery.
*/
struct wlp_neighbor_e {
struct list_head node;
struct wlp_uuid uuid;
struct uwb_dev *uwb_dev;
struct list_head wssid; /* Elements are wlp_wssid_e */
struct wlp_device_info *info;
};
struct wlp;
/**
* Information for an association session in progress.
*
* @exp_message: The type of the expected message. Both this message and a
* F0 message (which can be sent in response to any
* association frame) will be accepted as a valid message for
* this session.
* @cb: The function that will be called upon receipt of this
* message.
* @cb_priv: Private data of callback
* @data: Data used in association process (always a sk_buff?)
* @neighbor: Address of neighbor with which association session is in
* progress.
*/
struct wlp_session {
enum wlp_assoc_type exp_message;
void (*cb)(struct wlp *);
void *cb_priv;
void *data;
struct uwb_dev_addr neighbor_addr;
};
/**
* WLP Service Set
*
* @mutex: used to protect entire WSS structure.
*
* @name: The WSS name is set to 65 bytes, 1 byte larger than the maximum
* allowed by the WLP spec. This is to have a null terminated string
* for display to the user. A maximum of 64 bytes will still be used
* when placing the WSS name field in association frames.
*
* @accept_enroll: Accepting enrollment: Set to one if registrar is
* accepting enrollment in WSS, or zero otherwise.
*
* Global and local information for each WSS in which we are enrolled.
* WLP 0.99 Section 7.2.1 and Section 7.2.2
*/
struct wlp_wss {
struct mutex mutex;
struct kobject kobj;
/* Global properties. */
struct wlp_uuid wssid;
u8 hash;
char name[WLP_WSS_NAME_SIZE];
struct uwb_mac_addr bcast;
u8 secure_status:1;
u8 master_key[16];
/* Local properties. */
u8 tag;
struct uwb_mac_addr virtual_addr;
/* Extra */
u8 accept_enroll:1;
enum wlp_wss_state state;
};
/**
* WLP main structure
* @mutex: protect changes to WLP structure. We only allow changes to the
* uuid, so currently this mutex only protects this field.
*/
struct wlp {
struct mutex mutex;
struct uwb_rc *rc; /* UWB radio controller */
struct uwb_pal pal;
struct wlp_eda eda;
struct wlp_uuid uuid;
struct wlp_session *session;
struct wlp_wss wss;
struct mutex nbmutex; /* Neighbor mutex protects neighbors list */
struct list_head neighbors; /* Elements are wlp_neighbor_e */
struct uwb_notifs_handler uwb_notifs_handler;
struct wlp_device_info *dev_info;
void (*fill_device_info)(struct wlp *wlp, struct wlp_device_info *info);
int (*xmit_frame)(struct wlp *, struct sk_buff *,
struct uwb_dev_addr *);
void (*stop_queue)(struct wlp *);
void (*start_queue)(struct wlp *);
};
/* sysfs */
struct wlp_wss_attribute {
struct attribute attr;
ssize_t (*show)(struct wlp_wss *wss, char *buf);
ssize_t (*store)(struct wlp_wss *wss, const char *buf, size_t count);
};
#define WSS_ATTR(_name, _mode, _show, _store) \
static struct wlp_wss_attribute wss_attr_##_name = __ATTR(_name, _mode, \
_show, _store)
extern int wlp_setup(struct wlp *, struct uwb_rc *);
extern void wlp_remove(struct wlp *);
extern ssize_t wlp_neighborhood_show(struct wlp *, char *);
extern int wlp_wss_setup(struct net_device *, struct wlp_wss *);
extern void wlp_wss_remove(struct wlp_wss *);
extern ssize_t wlp_wss_activate_show(struct wlp_wss *, char *);
extern ssize_t wlp_wss_activate_store(struct wlp_wss *, const char *, size_t);
extern ssize_t wlp_eda_show(struct wlp *, char *);
extern ssize_t wlp_eda_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_uuid_show(struct wlp *, char *);
extern ssize_t wlp_uuid_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_name_show(struct wlp *, char *);
extern ssize_t wlp_dev_name_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_manufacturer_show(struct wlp *, char *);
extern ssize_t wlp_dev_manufacturer_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_model_name_show(struct wlp *, char *);
extern ssize_t wlp_dev_model_name_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_model_nr_show(struct wlp *, char *);
extern ssize_t wlp_dev_model_nr_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_serial_show(struct wlp *, char *);
extern ssize_t wlp_dev_serial_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_prim_category_show(struct wlp *, char *);
extern ssize_t wlp_dev_prim_category_store(struct wlp *, const char *,
size_t);
extern ssize_t wlp_dev_prim_OUI_show(struct wlp *, char *);
extern ssize_t wlp_dev_prim_OUI_store(struct wlp *, const char *, size_t);
extern ssize_t wlp_dev_prim_OUI_sub_show(struct wlp *, char *);
extern ssize_t wlp_dev_prim_OUI_sub_store(struct wlp *, const char *,
size_t);
extern ssize_t wlp_dev_prim_subcat_show(struct wlp *, char *);
extern ssize_t wlp_dev_prim_subcat_store(struct wlp *, const char *,
size_t);
extern int wlp_receive_frame(struct device *, struct wlp *, struct sk_buff *,
struct uwb_dev_addr *);
extern int wlp_prepare_tx_frame(struct device *, struct wlp *,
struct sk_buff *, struct uwb_dev_addr *);
void wlp_reset_all(struct wlp *wlp);
/**
* Initialize WSS
*/
static inline
void wlp_wss_init(struct wlp_wss *wss)
{
mutex_init(&wss->mutex);
}
static inline
void wlp_init(struct wlp *wlp)
{
INIT_LIST_HEAD(&wlp->neighbors);
mutex_init(&wlp->mutex);
mutex_init(&wlp->nbmutex);
wlp_wss_init(&wlp->wss);
}
#endif /* #ifndef __LINUX__WLP_H_ */