[linux-2.6-block.git] / drivers / staging / wusbcore / wusbhc.h

// SPDX-License-Identifier: GPL-2.0
/*
 * Wireless USB Host Controller
 * Common infrastructure for WHCI and HWA WUSB-HC drivers
 *
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 *
 * This driver implements parts common to all Wireless USB Host
 * Controllers (struct wusbhc, embedding a struct usb_hcd) and is used
 * by:
 *
 *   - hwahc: HWA, USB-dongle that implements a Wireless USB host
 *     controller, (Wireless USB 1.0 Host-Wire-Adapter specification).
 *
 *   - whci: WHCI, a PCI card with a wireless host controller
 *     (Wireless Host Controller Interface 1.0 specification).
 *
 * Check out the Design-overview.txt file in the source documentation
 * for other details on the implementation.
 *
 * Main blocks:
 *
 *  rh         Root Hub emulation (part of the HCD glue)
 *
 *  devconnect Handle all the issues related to device connection,
 *             authentication, disconnection, timeout, reseting,
 *             keepalives, etc.
 *
 *  mmc        MMC IE broadcasting handling
 *
 * A host controller driver just initializes its stuff and as part of
 * that, creates a 'struct wusbhc' instance that handles all the
 * common WUSB mechanisms. Links in the function ops that are specific
 * to it and then registers the host controller. Ready to run.
 */

#ifndef __WUSBHC_H__
#define __WUSBHC_H__

#include <linux/usb.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/kref.h>
#include <linux/workqueue.h>
#include <linux/usb/hcd.h>
#include "../uwb/uwb.h"
#include "include/wusb.h"

/*
 * Time from a WUSB channel stop request to the last transmitted MMC.
 *
 * This needs to be > 4.096 ms in case no MMCs can be transmitted in
 * zone 0.
 */
#define WUSB_CHANNEL_STOP_DELAY_MS 8
#define WUSB_RETRY_COUNT_MAX 15
#define WUSB_RETRY_COUNT_INFINITE 0

/**
 * Wireless USB device
 *
 * Describe a WUSB device connected to the cluster. This struct
 * belongs to the 'struct wusb_port' it is attached to and it is
 * responsible for putting and clearing the pointer to it.
 *
 * Note this "complements" the 'struct usb_device' that the usb_hcd
 * keeps for each connected USB device. However, it extends some
 * information that is not available (there is no hcpriv ptr in it!)
 * *and* most importantly, it's life cycle is different. It is created
 * as soon as we get a DN_Connect (connect request notification) from
 * the device through the WUSB host controller; the USB stack doesn't
 * create the device until we authenticate it. FIXME: this will
 * change.
 *
 * @bos:    This is allocated when the BOS descriptors are read from
 *          the device and freed upon the wusb_dev struct dying.
 * @wusb_cap_descr: points into @bos, and has been verified to be size
 *                  safe.
 */
struct wusb_dev {
	struct kref refcnt;
	struct wusbhc *wusbhc;
	struct list_head cack_node;	/* Connect-Ack list */
	struct list_head rekey_node;	/* GTK rekey list */
	u8 port_idx;
	u8 addr;
	u8 beacon_type:4;
	struct usb_encryption_descriptor ccm1_etd;
	struct wusb_ckhdid cdid;
	unsigned long entry_ts;
	struct usb_bos_descriptor *bos;
	struct usb_wireless_cap_descriptor *wusb_cap_descr;
	struct uwb_mas_bm availability;
	struct work_struct devconnect_acked_work;
	struct usb_device *usb_dev;
};

#define WUSB_DEV_ADDR_UNAUTH 0x80

static inline void wusb_dev_init(struct wusb_dev *wusb_dev)
{
	kref_init(&wusb_dev->refcnt);
	/* no need to init the cack_node */
}

extern void wusb_dev_destroy(struct kref *_wusb_dev);

static inline struct wusb_dev *wusb_dev_get(struct wusb_dev *wusb_dev)
{
	kref_get(&wusb_dev->refcnt);
	return wusb_dev;
}

static inline void wusb_dev_put(struct wusb_dev *wusb_dev)
{
	kref_put(&wusb_dev->refcnt, wusb_dev_destroy);
}

/**
 * Wireless USB Host Controller root hub "fake" ports
 * (state and device information)
 *
 * Wireless USB is wireless, so there are no ports; but we
 * fake'em. Each RC can connect a max of devices at the same time
 * (given in the Wireless Adapter descriptor, bNumPorts or WHCI's
 * caps), referred to in wusbhc->ports_max.
 *
 * See rh.c for more information.
 *
 * The @status and @change use the same bits as in USB2.0[11.24.2.7],
 * so we don't have to do much when getting the port's status.
 *
 * WUSB1.0[7.1], USB2.0[11.24.2.7.1,fig 11-10],
 * include/linux/usb_ch9.h (#define USB_PORT_STAT_*)
 */
struct wusb_port {
	u16 status;
	u16 change;
	struct wusb_dev *wusb_dev;	/* connected device's info */
	u32 ptk_tkid;
};

/**
 * WUSB Host Controller specifics
 *
 * All fields that are common to all Wireless USB controller types
 * (HWA and WHCI) are grouped here. Host Controller
 * functions/operations that only deal with general Wireless USB HC
 * issues use this data type to refer to the host.
 *
 * @usb_hcd	   Instantiation of a USB host controller
 *                 (initialized by upper layer [HWA=HC or WHCI].
 *
 * @dev		   Device that implements this; initialized by the
 *                 upper layer (HWA-HC, WHCI...); this device should
 *                 have a refcount.
 *
 * @trust_timeout  After this time without hearing for device
 *                 activity, we consider the device gone and we have to
 *                 re-authenticate.
 *
 *                 Can be accessed w/o locking--however, read to a
 *                 local variable then use.
 *
 * @chid           WUSB Cluster Host ID: this is supposed to be a
 *                 unique value that doesn't change across reboots (so
 *                 that your devices do not require re-association).
 *
 *                 Read/Write protected by @mutex
 *
 * @dev_info       This array has ports_max elements. It is used to
 *                 give the HC information about the WUSB devices (see
 *                 'struct wusb_dev_info').
 *
 *	           For HWA we need to allocate it in heap; for WHCI it
 *                 needs to be permanently mapped, so we keep it for
 *                 both and make it easy. Call wusbhc->dev_info_set()
 *                 to update an entry.
 *
 * @ports_max	   Number of simultaneous device connections (fake
 *                 ports) this HC will take. Read-only.
 *
 * @port	   Array of port status for each fake root port. Guaranteed to
 *                 always be the same length during device existence
 *                 [this allows for some unlocked but referenced reading].
 *
 * @mmcies_max	   Max number of Information Elements this HC can send
 *                 in its MMC. Read-only.
 *
 * @start          Start the WUSB channel.
 *
 * @stop           Stop the WUSB channel after the specified number of
 *                 milliseconds.  Channel Stop IEs should be transmitted
 *                 as required by [WUSB] 4.16.2.1.
 *
 * @mmcie_add	   HC specific operation (WHCI or HWA) for adding an
 *                 MMCIE.
 *
 * @mmcie_rm	   HC specific operation (WHCI or HWA) for removing an
 *                 MMCIE.
 *
 * @set_ptk:       Set the PTK and enable encryption for a device. Or, if
 *                 the supplied key is NULL, disable encryption for that
 *                 device.
 *
 * @set_gtk:       Set the GTK to be used for all future broadcast packets
 *                 (i.e., MMCs).  With some hardware, setting the GTK may start
 *                 MMC transmission.
 *
 * NOTE:
 *
 *  - If wusb_dev->usb_dev is not NULL, then usb_dev is valid
 *    (wusb_dev has a refcount on it). Likewise, if usb_dev->wusb_dev
 *    is not NULL, usb_dev->wusb_dev is valid (usb_dev keeps a
 *    refcount on it).
 *
 *    Most of the times when you need to use it, it will be non-NULL,
 *    so there is no real need to check for it (wusb_dev will
 *    disappear before usb_dev).
 *
 *  - The following fields need to be filled out before calling
 *    wusbhc_create(): ports_max, mmcies_max, mmcie_{add,rm}.
 *
 *  - there is no wusbhc_init() method, we do everything in
 *    wusbhc_create().
 *
 *  - Creation is done in two phases, wusbhc_create() and
 *    wusbhc_create_b(); b are the parts that need to be called after
 *    calling usb_hcd_add(&wusbhc->usb_hcd).
 */
struct wusbhc {
	struct usb_hcd usb_hcd;		/* HAS TO BE 1st */
	struct device *dev;
	struct uwb_rc *uwb_rc;
	struct uwb_pal pal;

	unsigned trust_timeout;			/* in jiffies */
	struct wusb_ckhdid chid;
	uint8_t phy_rate;
	uint8_t dnts_num_slots;
	uint8_t dnts_interval;
	uint8_t retry_count;
	struct wuie_host_info *wuie_host_info;

	struct mutex mutex;			/* locks everything else */
	u16 cluster_id;				/* Wireless USB Cluster ID */
	struct wusb_port *port;			/* Fake port status handling */
	struct wusb_dev_info *dev_info;		/* for Set Device Info mgmt */
	u8 ports_max;
	unsigned active:1;			/* currently xmit'ing MMCs */
	struct wuie_keep_alive keep_alive_ie;	/* protected by mutex */
	struct delayed_work keep_alive_timer;
	struct list_head cack_list;		/* Connect acknowledging */
	size_t cack_count;			/* protected by 'mutex' */
	struct wuie_connect_ack cack_ie;
	struct uwb_rsv *rsv;		/* cluster bandwidth reservation */

	struct mutex mmcie_mutex;		/* MMC WUIE handling */
	struct wuie_hdr **mmcie;		/* WUIE array */
	u8 mmcies_max;
	/* FIXME: make wusbhc_ops? */
	int (*start)(struct wusbhc *wusbhc);
	void (*stop)(struct wusbhc *wusbhc, int delay);
	int (*mmcie_add)(struct wusbhc *wusbhc, u8 interval, u8 repeat_cnt,
			 u8 handle, struct wuie_hdr *wuie);
	int (*mmcie_rm)(struct wusbhc *wusbhc, u8 handle);
	int (*dev_info_set)(struct wusbhc *, struct wusb_dev *wusb_dev);
	int (*bwa_set)(struct wusbhc *wusbhc, s8 stream_index,
		       const struct uwb_mas_bm *);
	int (*set_ptk)(struct wusbhc *wusbhc, u8 port_idx,
		       u32 tkid, const void *key, size_t key_size);
	int (*set_gtk)(struct wusbhc *wusbhc,
		       u32 tkid, const void *key, size_t key_size);
	int (*set_num_dnts)(struct wusbhc *wusbhc, u8 interval, u8 slots);

	struct {
		struct usb_key_descriptor descr;
		u8 data[16];				/* GTK key data */
	} __attribute__((packed)) gtk;
	u8 gtk_index;
	u32 gtk_tkid;

	/* workqueue for WUSB security related tasks. */
	struct workqueue_struct *wq_security;
	struct work_struct gtk_rekey_work;

	struct usb_encryption_descriptor *ccm1_etd;
};

#define usb_hcd_to_wusbhc(u) container_of((u), struct wusbhc, usb_hcd)


extern int wusbhc_create(struct wusbhc *);
extern int wusbhc_b_create(struct wusbhc *);
extern void wusbhc_b_destroy(struct wusbhc *);
extern void wusbhc_destroy(struct wusbhc *);
extern int wusb_dev_sysfs_add(struct wusbhc *, struct usb_device *,
			      struct wusb_dev *);
extern void wusb_dev_sysfs_rm(struct wusb_dev *);
extern int wusbhc_sec_create(struct wusbhc *);
extern int wusbhc_sec_start(struct wusbhc *);
extern void wusbhc_sec_stop(struct wusbhc *);
extern void wusbhc_sec_destroy(struct wusbhc *);
extern void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb,
				int status);
void wusbhc_reset_all(struct wusbhc *wusbhc);

int wusbhc_pal_register(struct wusbhc *wusbhc);
void wusbhc_pal_unregister(struct wusbhc *wusbhc);

/*
 * Return @usb_dev's @usb_hcd (properly referenced) or NULL if gone
 *
 * @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr)
 *
 * This is a safe assumption as @usb_dev->bus is referenced all the
 * time during the @usb_dev life cycle.
 */
static inline
struct usb_hcd *usb_hcd_get_by_usb_dev(struct usb_device *usb_dev)
{
	struct usb_hcd *usb_hcd;
	usb_hcd = bus_to_hcd(usb_dev->bus);
	return usb_get_hcd(usb_hcd);
}

/*
 * Increment the reference count on a wusbhc.
 *
 * @wusbhc's life cycle is identical to that of the underlying usb_hcd.
 */
static inline struct wusbhc *wusbhc_get(struct wusbhc *wusbhc)
{
	return usb_get_hcd(&wusbhc->usb_hcd) ? wusbhc : NULL;
}

/*
 * Return the wusbhc associated to a @usb_dev
 *
 * @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr)
 *
 * @returns: wusbhc for @usb_dev; NULL if the @usb_dev is being torn down.
 *           WARNING: referenced at the usb_hcd level, unlocked
 *
 * FIXME: move offline
 */
static inline struct wusbhc *wusbhc_get_by_usb_dev(struct usb_device *usb_dev)
{
	struct wusbhc *wusbhc = NULL;
	struct usb_hcd *usb_hcd;
	if (usb_dev->devnum > 1 && !usb_dev->wusb) {
		/* but root hubs */
		dev_err(&usb_dev->dev, "devnum %d wusb %d\n", usb_dev->devnum,
			usb_dev->wusb);
		BUG_ON(usb_dev->devnum > 1 && !usb_dev->wusb);
	}
	usb_hcd = usb_hcd_get_by_usb_dev(usb_dev);
	if (usb_hcd == NULL)
		return NULL;
	BUG_ON(usb_hcd->wireless == 0);
	return wusbhc = usb_hcd_to_wusbhc(usb_hcd);
}


static inline void wusbhc_put(struct wusbhc *wusbhc)
{
	usb_put_hcd(&wusbhc->usb_hcd);
}

int wusbhc_start(struct wusbhc *wusbhc);
void wusbhc_stop(struct wusbhc *wusbhc);
extern int wusbhc_chid_set(struct wusbhc *, const struct wusb_ckhdid *);

/* Device connect handling */
extern int wusbhc_devconnect_create(struct wusbhc *);
extern void wusbhc_devconnect_destroy(struct wusbhc *);
extern int wusbhc_devconnect_start(struct wusbhc *wusbhc);
extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc);
extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr,
			     struct wusb_dn_hdr *dn_hdr, size_t size);
extern void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port);
extern int wusb_usb_ncb(struct notifier_block *nb, unsigned long val,
			void *priv);
extern int wusb_set_dev_addr(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
			     u8 addr);

/* Wireless USB fake Root Hub methods */
extern int wusbhc_rh_create(struct wusbhc *);
extern void wusbhc_rh_destroy(struct wusbhc *);

extern int wusbhc_rh_status_data(struct usb_hcd *, char *);
extern int wusbhc_rh_control(struct usb_hcd *, u16, u16, u16, char *, u16);
extern int wusbhc_rh_start_port_reset(struct usb_hcd *, unsigned);

/* MMC handling */
extern int wusbhc_mmcie_create(struct wusbhc *);
extern void wusbhc_mmcie_destroy(struct wusbhc *);
extern int wusbhc_mmcie_set(struct wusbhc *, u8 interval, u8 repeat_cnt,
			    struct wuie_hdr *);
extern void wusbhc_mmcie_rm(struct wusbhc *, struct wuie_hdr *);

/* Bandwidth reservation */
int wusbhc_rsv_establish(struct wusbhc *wusbhc);
void wusbhc_rsv_terminate(struct wusbhc *wusbhc);

/*
 * I've always said
 * I wanted a wedding in a church...
 *
 * but lately I've been thinking about
 * the Botanical Gardens.
 *
 * We could do it by the tulips.
 * It'll be beautiful
 *
 * --Security!
 */
extern int wusb_dev_sec_add(struct wusbhc *, struct usb_device *,
				struct wusb_dev *);
extern void wusb_dev_sec_rm(struct wusb_dev *) ;
extern int wusb_dev_4way_handshake(struct wusbhc *, struct wusb_dev *,
				   struct wusb_ckhdid *ck);
void wusbhc_gtk_rekey(struct wusbhc *wusbhc);
int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev);


/* WUSB Cluster ID handling */
extern u8 wusb_cluster_id_get(void);
extern void wusb_cluster_id_put(u8);

/*
 * wusb_port_by_idx - return the port associated to a zero-based port index
 *
 * NOTE: valid without locking as long as wusbhc is referenced (as the
 *       number of ports doesn't change). The data pointed to has to
 *       be verified though :)
 */
static inline struct wusb_port *wusb_port_by_idx(struct wusbhc *wusbhc,
						 u8 port_idx)
{
	return &wusbhc->port[port_idx];
}

/*
 * wusb_port_no_to_idx - Convert port number (per usb_dev->portnum) to
 * a port_idx.
 *
 * USB stack USB ports are 1 based!!
 *
 * NOTE: only valid for WUSB devices!!!
 */
static inline u8 wusb_port_no_to_idx(u8 port_no)
{
	return port_no - 1;
}

extern struct wusb_dev *__wusb_dev_get_by_usb_dev(struct wusbhc *,
						  struct usb_device *);

/*
 * Return a referenced wusb_dev given a @usb_dev
 *
 * Returns NULL if the usb_dev is being torn down.
 *
 * FIXME: move offline
 */
static inline
struct wusb_dev *wusb_dev_get_by_usb_dev(struct usb_device *usb_dev)
{
	struct wusbhc *wusbhc;
	struct wusb_dev *wusb_dev;
	wusbhc = wusbhc_get_by_usb_dev(usb_dev);
	if (wusbhc == NULL)
		return NULL;
	mutex_lock(&wusbhc->mutex);
	wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev);
	mutex_unlock(&wusbhc->mutex);
	wusbhc_put(wusbhc);
	return wusb_dev;
}

/* Misc */

extern struct workqueue_struct *wusbd;
#endif /* #ifndef __WUSBHC_H__ */
Commit	Line	Data
5fd54ace	1	// SPDX-License-Identifier: GPL-2.0
90ff96f2 IPG	2	/*
	3	* Wireless USB Host Controller
	4	* Common infrastructure for WHCI and HWA WUSB-HC drivers
	5	*
	6	*
	7	* Copyright (C) 2005-2006 Intel Corporation
	8	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	9	*
90ff96f2 IPG	10	* This driver implements parts common to all Wireless USB Host
	11	* Controllers (struct wusbhc, embedding a struct usb_hcd) and is used
	12	* by:
	13	*
	14	* - hwahc: HWA, USB-dongle that implements a Wireless USB host
	15	* controller, (Wireless USB 1.0 Host-Wire-Adapter specification).
	16	*
	17	* - whci: WHCI, a PCI card with a wireless host controller
	18	* (Wireless Host Controller Interface 1.0 specification).
	19	*
	20	* Check out the Design-overview.txt file in the source documentation
	21	* for other details on the implementation.
	22	*
	23	* Main blocks:
	24	*
	25	* rh Root Hub emulation (part of the HCD glue)
	26	*
	27	* devconnect Handle all the issues related to device connection,
	28	* authentication, disconnection, timeout, reseting,
	29	* keepalives, etc.
	30	*
	31	* mmc MMC IE broadcasting handling
	32	*
	33	* A host controller driver just initializes its stuff and as part of
	34	* that, creates a 'struct wusbhc' instance that handles all the
	35	* common WUSB mechanisms. Links in the function ops that are specific
	36	* to it and then registers the host controller. Ready to run.
	37	*/
	38
	39	#ifndef __WUSBHC_H__
	40	#define __WUSBHC_H__
	41
	42	#include <linux/usb.h>
	43	#include <linux/list.h>
	44	#include <linux/mutex.h>
	45	#include <linux/kref.h>
	46	#include <linux/workqueue.h>
27729aad	47	#include <linux/usb/hcd.h>
71ed79b0 GKH	48	#include "../uwb/uwb.h"
71ed79b0 GKH	49	#include "include/wusb.h"
90ff96f2	50
4d2bea4c DV	51	/*
	52	* Time from a WUSB channel stop request to the last transmitted MMC.
	53	*
	54	* This needs to be > 4.096 ms in case no MMCs can be transmitted in
	55	* zone 0.
	56	*/
	57	#define WUSB_CHANNEL_STOP_DELAY_MS 8
f265d4d3 TP	58	#define WUSB_RETRY_COUNT_MAX 15
f265d4d3 TP	59	#define WUSB_RETRY_COUNT_INFINITE 0
90ff96f2 IPG	60
	61	/**
	62	* Wireless USB device
	63	*
	64	* Describe a WUSB device connected to the cluster. This struct
	65	* belongs to the 'struct wusb_port' it is attached to and it is
	66	* responsible for putting and clearing the pointer to it.
	67	*
	68	* Note this "complements" the 'struct usb_device' that the usb_hcd
	69	* keeps for each connected USB device. However, it extends some
	70	* information that is not available (there is no hcpriv ptr in it!)
	71	* and most importantly, it's life cycle is different. It is created
	72	* as soon as we get a DN_Connect (connect request notification) from
	73	* the device through the WUSB host controller; the USB stack doesn't
	74	* create the device until we authenticate it. FIXME: this will
	75	* change.
	76	*
	77	* @bos: This is allocated when the BOS descriptors are read from
	78	* the device and freed upon the wusb_dev struct dying.
	79	* @wusb_cap_descr: points into @bos, and has been verified to be size
	80	* safe.
	81	*/
	82	struct wusb_dev {
	83	struct kref refcnt;
	84	struct wusbhc *wusbhc;
	85	struct list_head cack_node; /* Connect-Ack list */
471e42ad	86	struct list_head rekey_node; /* GTK rekey list */
90ff96f2 IPG	87	u8 port_idx;
	88	u8 addr;
	89	u8 beacon_type:4;
	90	struct usb_encryption_descriptor ccm1_etd;
	91	struct wusb_ckhdid cdid;
	92	unsigned long entry_ts;
	93	struct usb_bos_descriptor *bos;
	94	struct usb_wireless_cap_descriptor *wusb_cap_descr;
	95	struct uwb_mas_bm availability;
	96	struct work_struct devconnect_acked_work;
90ff96f2 IPG	97	struct usb_device *usb_dev;
	98	};
	99
	100	#define WUSB_DEV_ADDR_UNAUTH 0x80
	101
	102	static inline void wusb_dev_init(struct wusb_dev *wusb_dev)
	103	{
	104	kref_init(&wusb_dev->refcnt);
	105	/* no need to init the cack_node */
	106	}
	107
	108	extern void wusb_dev_destroy(struct kref *_wusb_dev);
	109
	110	static inline struct wusb_dev wusb_dev_get(struct wusb_dev wusb_dev)
	111	{
	112	kref_get(&wusb_dev->refcnt);
	113	return wusb_dev;
	114	}
	115
	116	static inline void wusb_dev_put(struct wusb_dev *wusb_dev)
	117	{
	118	kref_put(&wusb_dev->refcnt, wusb_dev_destroy);
	119	}
	120
	121	/**
7aed9dfe	122	* Wireless USB Host Controller root hub "fake" ports
90ff96f2 IPG	123	* (state and device information)
	124	*
	125	* Wireless USB is wireless, so there are no ports; but we
	126	* fake'em. Each RC can connect a max of devices at the same time
	127	* (given in the Wireless Adapter descriptor, bNumPorts or WHCI's
	128	* caps), referred to in wusbhc->ports_max.
	129	*
	130	* See rh.c for more information.
	131	*
	132	* The @status and @change use the same bits as in USB2.0[11.24.2.7],
	133	* so we don't have to do much when getting the port's status.
	134	*
	135	* WUSB1.0[7.1], USB2.0[11.24.2.7.1,fig 11-10],
	136	* include/linux/usb_ch9.h (#define USB_PORT_STAT_*)
	137	*/
	138	struct wusb_port {
	139	u16 status;
	140	u16 change;
	141	struct wusb_dev wusb_dev; / connected device's info */
90ff96f2 IPG	142	u32 ptk_tkid;
	143	};
	144
	145	/**
	146	* WUSB Host Controller specifics
	147	*
	148	* All fields that are common to all Wireless USB controller types
	149	* (HWA and WHCI) are grouped here. Host Controller
	150	* functions/operations that only deal with general Wireless USB HC
	151	* issues use this data type to refer to the host.
	152	*
a7737e34	153	* @usb_hcd Instantiation of a USB host controller
90ff96f2 IPG	154	* (initialized by upper layer [HWA=HC or WHCI].
	155	*
	156	* @dev Device that implements this; initialized by the
	157	* upper layer (HWA-HC, WHCI...); this device should
	158	* have a refcount.
	159	*
	160	* @trust_timeout After this time without hearing for device
	161	* activity, we consider the device gone and we have to
	162	* re-authenticate.
	163	*
	164	* Can be accessed w/o locking--however, read to a
	165	* local variable then use.
	166	*
	167	* @chid WUSB Cluster Host ID: this is supposed to be a
	168	* unique value that doesn't change across reboots (so
	169	* that your devices do not require re-association).
	170	*
	171	* Read/Write protected by @mutex
	172	*
	173	* @dev_info This array has ports_max elements. It is used to
	174	* give the HC information about the WUSB devices (see
	175	* 'struct wusb_dev_info').
	176	*
	177	* For HWA we need to allocate it in heap; for WHCI it
	178	* needs to be permanently mapped, so we keep it for
	179	* both and make it easy. Call wusbhc->dev_info_set()
	180	* to update an entry.
	181	*
	182	* @ports_max Number of simultaneous device connections (fake
	183	* ports) this HC will take. Read-only.
	184	*
a7737e34	185	* @port Array of port status for each fake root port. Guaranteed to
1537a363	186	* always be the same length during device existence
90ff96f2 IPG	187	* [this allows for some unlocked but referenced reading].
	188	*
	189	* @mmcies_max Max number of Information Elements this HC can send
	190	* in its MMC. Read-only.
	191	*
4d2bea4c DV	192	* @start Start the WUSB channel.
	193	*
	194	* @stop Stop the WUSB channel after the specified number of
	195	* milliseconds. Channel Stop IEs should be transmitted
	196	* as required by [WUSB] 4.16.2.1.
	197	*
90ff96f2 IPG	198	* @mmcie_add HC specific operation (WHCI or HWA) for adding an
	199	* MMCIE.
	200	*
	201	* @mmcie_rm HC specific operation (WHCI or HWA) for removing an
	202	* MMCIE.
	203	*
90ff96f2 IPG	204	* @set_ptk: Set the PTK and enable encryption for a device. Or, if
	205	* the supplied key is NULL, disable encryption for that
	206	* device.
	207	*
	208	* @set_gtk: Set the GTK to be used for all future broadcast packets
	209	* (i.e., MMCs). With some hardware, setting the GTK may start
	210	* MMC transmission.
	211	*
	212	* NOTE:
	213	*
	214	* - If wusb_dev->usb_dev is not NULL, then usb_dev is valid
	215	* (wusb_dev has a refcount on it). Likewise, if usb_dev->wusb_dev
	216	* is not NULL, usb_dev->wusb_dev is valid (usb_dev keeps a
	217	* refcount on it).
	218	*
	219	* Most of the times when you need to use it, it will be non-NULL,
	220	* so there is no real need to check for it (wusb_dev will
25985edc	221	* disappear before usb_dev).
90ff96f2 IPG	222	*
	223	* - The following fields need to be filled out before calling
	224	* wusbhc_create(): ports_max, mmcies_max, mmcie_{add,rm}.
	225	*
	226	* - there is no wusbhc_init() method, we do everything in
	227	* wusbhc_create().
	228	*
	229	* - Creation is done in two phases, wusbhc_create() and
	230	* wusbhc_create_b(); b are the parts that need to be called after
	231	* calling usb_hcd_add(&wusbhc->usb_hcd).
	232	*/
	233	struct wusbhc {
	234	struct usb_hcd usb_hcd; /* HAS TO BE 1st */
	235	struct device *dev;
	236	struct uwb_rc *uwb_rc;
	237	struct uwb_pal pal;
	238
	239	unsigned trust_timeout; /* in jiffies */
6fae35f9	240	struct wusb_ckhdid chid;
c3f22d92	241	uint8_t phy_rate;
8bf1d071 TP	242	uint8_t dnts_num_slots;
8bf1d071 TP	243	uint8_t dnts_interval;
f265d4d3	244	uint8_t retry_count;
6fae35f9	245	struct wuie_host_info *wuie_host_info;
90ff96f2 IPG	246
	247	struct mutex mutex; /* locks everything else */
	248	u16 cluster_id; /* Wireless USB Cluster ID */
	249	struct wusb_port port; / Fake port status handling */
	250	struct wusb_dev_info dev_info; / for Set Device Info mgmt */
	251	u8 ports_max;
	252	unsigned active:1; /* currently xmit'ing MMCs */
	253	struct wuie_keep_alive keep_alive_ie; /* protected by mutex */
	254	struct delayed_work keep_alive_timer;
	255	struct list_head cack_list; /* Connect acknowledging */
	256	size_t cack_count; /* protected by 'mutex' */
	257	struct wuie_connect_ack cack_ie;
	258	struct uwb_rsv rsv; / cluster bandwidth reservation */
	259
	260	struct mutex mmcie_mutex; /* MMC WUIE handling */
	261	struct wuie_hdr *mmcie; / WUIE array */
	262	u8 mmcies_max;
	263	/* FIXME: make wusbhc_ops? */
	264	int (start)(struct wusbhc wusbhc);
4d2bea4c	265	void (stop)(struct wusbhc wusbhc, int delay);
90ff96f2 IPG	266	int (mmcie_add)(struct wusbhc wusbhc, u8 interval, u8 repeat_cnt,
	267	u8 handle, struct wuie_hdr *wuie);
	268	int (mmcie_rm)(struct wusbhc wusbhc, u8 handle);
	269	int (dev_info_set)(struct wusbhc , struct wusb_dev *wusb_dev);
	270	int (bwa_set)(struct wusbhc wusbhc, s8 stream_index,
	271	const struct uwb_mas_bm *);
	272	int (set_ptk)(struct wusbhc wusbhc, u8 port_idx,
	273	u32 tkid, const void *key, size_t key_size);
	274	int (set_gtk)(struct wusbhc wusbhc,
	275	u32 tkid, const void *key, size_t key_size);
	276	int (set_num_dnts)(struct wusbhc wusbhc, u8 interval, u8 slots);
	277
	278	struct {
	279	struct usb_key_descriptor descr;
	280	u8 data[16]; /* GTK key data */
	281	} __attribute__((packed)) gtk;
	282	u8 gtk_index;
	283	u32 gtk_tkid;
275e517c TP	284
	285	/* workqueue for WUSB security related tasks. */
	286	struct workqueue_struct *wq_security;
471e42ad	287	struct work_struct gtk_rekey_work;
90ff96f2 IPG	288
	289	struct usb_encryption_descriptor *ccm1_etd;
	290	};
	291
	292	#define usb_hcd_to_wusbhc(u) container_of((u), struct wusbhc, usb_hcd)
	293
	294
	295	extern int wusbhc_create(struct wusbhc *);
	296	extern int wusbhc_b_create(struct wusbhc *);
	297	extern void wusbhc_b_destroy(struct wusbhc *);
	298	extern void wusbhc_destroy(struct wusbhc *);
	299	extern int wusb_dev_sysfs_add(struct wusbhc , struct usb_device ,
	300	struct wusb_dev *);
	301	extern void wusb_dev_sysfs_rm(struct wusb_dev *);
	302	extern int wusbhc_sec_create(struct wusbhc *);
	303	extern int wusbhc_sec_start(struct wusbhc *);
	304	extern void wusbhc_sec_stop(struct wusbhc *);
	305	extern void wusbhc_sec_destroy(struct wusbhc *);
	306	extern void wusbhc_giveback_urb(struct wusbhc wusbhc, struct urb urb,
	307	int status);
	308	void wusbhc_reset_all(struct wusbhc *wusbhc);
	309
	310	int wusbhc_pal_register(struct wusbhc *wusbhc);
	311	void wusbhc_pal_unregister(struct wusbhc *wusbhc);
	312
	313	/*
	314	* Return @usb_dev's @usb_hcd (properly referenced) or NULL if gone
	315	*
	316	* @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr)
	317	*
	318	* This is a safe assumption as @usb_dev->bus is referenced all the
	319	* time during the @usb_dev life cycle.
	320	*/
a7737e34 RB	321	static inline
a7737e34 RB	322	struct usb_hcd usb_hcd_get_by_usb_dev(struct usb_device usb_dev)
90ff96f2 IPG	323	{
90ff96f2 IPG	324	struct usb_hcd *usb_hcd;
6ae706ae	325	usb_hcd = bus_to_hcd(usb_dev->bus);
90ff96f2 IPG	326	return usb_get_hcd(usb_hcd);
	327	}
	328
	329	/*
	330	* Increment the reference count on a wusbhc.
	331	*
	332	* @wusbhc's life cycle is identical to that of the underlying usb_hcd.
	333	*/
	334	static inline struct wusbhc wusbhc_get(struct wusbhc wusbhc)
	335	{
	336	return usb_get_hcd(&wusbhc->usb_hcd) ? wusbhc : NULL;
	337	}
	338
	339	/*
	340	* Return the wusbhc associated to a @usb_dev
	341	*
	342	* @usb_dev: USB device, UNLOCKED and referenced (or otherwise, safe ptr)
	343	*
	344	* @returns: wusbhc for @usb_dev; NULL if the @usb_dev is being torn down.
	345	* WARNING: referenced at the usb_hcd level, unlocked
	346	*
	347	* FIXME: move offline
	348	*/
	349	static inline struct wusbhc wusbhc_get_by_usb_dev(struct usb_device usb_dev)
	350	{
	351	struct wusbhc *wusbhc = NULL;
	352	struct usb_hcd *usb_hcd;
	353	if (usb_dev->devnum > 1 && !usb_dev->wusb) {
	354	/* but root hubs */
	355	dev_err(&usb_dev->dev, "devnum %d wusb %d\n", usb_dev->devnum,
	356	usb_dev->wusb);
	357	BUG_ON(usb_dev->devnum > 1 && !usb_dev->wusb);
	358	}
	359	usb_hcd = usb_hcd_get_by_usb_dev(usb_dev);
	360	if (usb_hcd == NULL)
	361	return NULL;
	362	BUG_ON(usb_hcd->wireless == 0);
	363	return wusbhc = usb_hcd_to_wusbhc(usb_hcd);
	364	}
	365
	366
	367	static inline void wusbhc_put(struct wusbhc *wusbhc)
	368	{
	369	usb_put_hcd(&wusbhc->usb_hcd);
	370	}
	371
6fae35f9	372	int wusbhc_start(struct wusbhc *wusbhc);
90ff96f2 IPG	373	void wusbhc_stop(struct wusbhc *wusbhc);
	374	extern int wusbhc_chid_set(struct wusbhc , const struct wusb_ckhdid );
	375
	376	/* Device connect handling */
	377	extern int wusbhc_devconnect_create(struct wusbhc *);
	378	extern void wusbhc_devconnect_destroy(struct wusbhc *);
6fae35f9	379	extern int wusbhc_devconnect_start(struct wusbhc *wusbhc);
90ff96f2	380	extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc);
90ff96f2 IPG	381	extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr,
90ff96f2 IPG	382	struct wusb_dn_hdr *dn_hdr, size_t size);
90ff96f2 IPG	383	extern void __wusbhc_dev_disable(struct wusbhc *wusbhc, u8 port);
	384	extern int wusb_usb_ncb(struct notifier_block *nb, unsigned long val,
	385	void *priv);
	386	extern int wusb_set_dev_addr(struct wusbhc wusbhc, struct wusb_dev wusb_dev,
	387	u8 addr);
	388
	389	/* Wireless USB fake Root Hub methods */
	390	extern int wusbhc_rh_create(struct wusbhc *);
	391	extern void wusbhc_rh_destroy(struct wusbhc *);
	392
	393	extern int wusbhc_rh_status_data(struct usb_hcd , char );
	394	extern int wusbhc_rh_control(struct usb_hcd , u16, u16, u16, char , u16);
90ff96f2 IPG	395	extern int wusbhc_rh_start_port_reset(struct usb_hcd *, unsigned);
	396
	397	/* MMC handling */
	398	extern int wusbhc_mmcie_create(struct wusbhc *);
	399	extern void wusbhc_mmcie_destroy(struct wusbhc *);
	400	extern int wusbhc_mmcie_set(struct wusbhc *, u8 interval, u8 repeat_cnt,
	401	struct wuie_hdr *);
	402	extern void wusbhc_mmcie_rm(struct wusbhc , struct wuie_hdr );
	403
	404	/* Bandwidth reservation */
	405	int wusbhc_rsv_establish(struct wusbhc *wusbhc);
	406	void wusbhc_rsv_terminate(struct wusbhc *wusbhc);
	407
	408	/*
	409	* I've always said
	410	* I wanted a wedding in a church...
	411	*
	412	* but lately I've been thinking about
	413	* the Botanical Gardens.
	414	*
	415	* We could do it by the tulips.
	416	* It'll be beautiful
	417	*
	418	* --Security!
	419	*/
	420	extern int wusb_dev_sec_add(struct wusbhc , struct usb_device ,
	421	struct wusb_dev *);
	422	extern void wusb_dev_sec_rm(struct wusb_dev *) ;
	423	extern int wusb_dev_4way_handshake(struct wusbhc , struct wusb_dev ,
	424	struct wusb_ckhdid *ck);
	425	void wusbhc_gtk_rekey(struct wusbhc *wusbhc);
4656d5de	426	int wusb_dev_update_address(struct wusbhc wusbhc, struct wusb_dev wusb_dev);
90ff96f2 IPG	427
	428
	429	/* WUSB Cluster ID handling */
	430	extern u8 wusb_cluster_id_get(void);
	431	extern void wusb_cluster_id_put(u8);
	432
	433	/*
	434	* wusb_port_by_idx - return the port associated to a zero-based port index
	435	*
	436	* NOTE: valid without locking as long as wusbhc is referenced (as the
	437	* number of ports doesn't change). The data pointed to has to
	438	* be verified though :)
	439	*/
	440	static inline struct wusb_port wusb_port_by_idx(struct wusbhc wusbhc,
	441	u8 port_idx)
	442	{
	443	return &wusbhc->port[port_idx];
	444	}
	445
	446	/*
	447	* wusb_port_no_to_idx - Convert port number (per usb_dev->portnum) to
	448	* a port_idx.
	449	*
	450	* USB stack USB ports are 1 based!!
	451	*
	452	* NOTE: only valid for WUSB devices!!!
	453	*/
	454	static inline u8 wusb_port_no_to_idx(u8 port_no)
	455	{
	456	return port_no - 1;
	457	}
	458
	459	extern struct wusb_dev __wusb_dev_get_by_usb_dev(struct wusbhc ,
	460	struct usb_device *);
	461
	462	/*
	463	* Return a referenced wusb_dev given a @usb_dev
	464	*
	465	* Returns NULL if the usb_dev is being torn down.
	466	*
	467	* FIXME: move offline
	468	*/
	469	static inline
	470	struct wusb_dev wusb_dev_get_by_usb_dev(struct usb_device usb_dev)
	471	{
	472	struct wusbhc *wusbhc;
	473	struct wusb_dev *wusb_dev;
	474	wusbhc = wusbhc_get_by_usb_dev(usb_dev);
	475	if (wusbhc == NULL)
	476	return NULL;
	477	mutex_lock(&wusbhc->mutex);
	478	wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, usb_dev);
	479	mutex_unlock(&wusbhc->mutex);
	480	wusbhc_put(wusbhc);
	481	return wusb_dev;
	482	}
	483
	484	/* Misc */
	485
	486	extern struct workqueue_struct *wusbd;
	487	#endif /* #ifndef __WUSBHC_H__ */