uwb: add the uwb include files

Signed-off-by: David Vrabel <david.vrabel@csr.com>

5 files changed, 2362 insertions, 0 deletions

diff --git a/include/linux/uwb.h b/include/linux/uwb.h
new file mode 100644
index 000000000000..0cd35937e120
--- /dev/null
+++ b/include/linux/uwb.h
@@ -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__ */
diff --git a/include/linux/uwb/debug-cmd.h b/include/linux/uwb/debug-cmd.h
new file mode 100644
index 000000000000..1141f41bab5c
--- /dev/null
+++ b/include/linux/uwb/debug-cmd.h
@@ -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__ */
diff --git a/include/linux/uwb/debug.h b/include/linux/uwb/debug.h
new file mode 100644
index 000000000000..a86a73fe303f
--- /dev/null
+++ b/include/linux/uwb/debug.h
@@ -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))
diff --git a/include/linux/uwb/spec.h b/include/linux/uwb/spec.h
new file mode 100644
index 000000000000..198c15f8e251
--- /dev/null
+++ b/include/linux/uwb/spec.h
@@ -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__ */
diff --git a/include/linux/wlp.h b/include/linux/wlp.h
new file mode 100644
index 000000000000..033545e145c7
--- /dev/null
+++ b/include/linux/wlp.h
@@ -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_ */