wusb: add the Wireless USB core

Add support for Ceritified Wireless USB 1.0 to the USB stack.

This has been split into several patches for easier review.

core (this patch):
  - host controller infrastructure
  - cluster reservation
  - UWB PAL registration
  - fake root hub

protocol:
  - MMC management (start/stop, managing IEs)
  - device connection

security:
  - device authentication and authorization

build-system:
  - Kconfig and Kbuild files

Signed-off-by: David Vrabel <david.vrabel@csr.com>
This commit is contained in:
Inaky Perez-Gonzalez 2008-09-17 16:34:23 +01:00 committed by David Vrabel
parent c7f736484f
commit 90ff96f224
6 changed files with 1685 additions and 0 deletions

View File

@ -0,0 +1,143 @@
/*
* WUSB devices
* sysfs bindings
*
* Copyright (C) 2007 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.
*
*
* Get them out of the way...
*/
#include <linux/jiffies.h>
#include <linux/ctype.h>
#include <linux/workqueue.h>
#include "wusbhc.h"
#undef D_LOCAL
#define D_LOCAL 4
#include <linux/uwb/debug.h>
static ssize_t wusb_disconnect_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct usb_device *usb_dev;
struct wusbhc *wusbhc;
unsigned command;
u8 port_idx;
if (sscanf(buf, "%u", &command) != 1)
return -EINVAL;
if (command == 0)
return size;
usb_dev = to_usb_device(dev);
wusbhc = wusbhc_get_by_usb_dev(usb_dev);
if (wusbhc == NULL)
return -ENODEV;
mutex_lock(&wusbhc->mutex);
port_idx = wusb_port_no_to_idx(usb_dev->portnum);
__wusbhc_dev_disable(wusbhc, port_idx);
mutex_unlock(&wusbhc->mutex);
wusbhc_put(wusbhc);
return size;
}
static DEVICE_ATTR(wusb_disconnect, 0200, NULL, wusb_disconnect_store);
static ssize_t wusb_cdid_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
ssize_t result;
struct wusb_dev *wusb_dev;
wusb_dev = wusb_dev_get_by_usb_dev(to_usb_device(dev));
if (wusb_dev == NULL)
return -ENODEV;
result = ckhdid_printf(buf, PAGE_SIZE, &wusb_dev->cdid);
strcat(buf, "\n");
wusb_dev_put(wusb_dev);
return result + 1;
}
static DEVICE_ATTR(wusb_cdid, 0444, wusb_cdid_show, NULL);
static ssize_t wusb_ck_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
int result;
struct usb_device *usb_dev;
struct wusbhc *wusbhc;
struct wusb_ckhdid ck;
result = sscanf(buf,
"%02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx\n",
&ck.data[0] , &ck.data[1],
&ck.data[2] , &ck.data[3],
&ck.data[4] , &ck.data[5],
&ck.data[6] , &ck.data[7],
&ck.data[8] , &ck.data[9],
&ck.data[10], &ck.data[11],
&ck.data[12], &ck.data[13],
&ck.data[14], &ck.data[15]);
if (result != 16)
return -EINVAL;
usb_dev = to_usb_device(dev);
wusbhc = wusbhc_get_by_usb_dev(usb_dev);
if (wusbhc == NULL)
return -ENODEV;
result = wusb_dev_4way_handshake(wusbhc, usb_dev->wusb_dev, &ck);
memset(&ck, 0, sizeof(ck));
wusbhc_put(wusbhc);
return result < 0 ? result : size;
}
static DEVICE_ATTR(wusb_ck, 0200, NULL, wusb_ck_store);
static struct attribute *wusb_dev_attrs[] = {
&dev_attr_wusb_disconnect.attr,
&dev_attr_wusb_cdid.attr,
&dev_attr_wusb_ck.attr,
NULL,
};
static struct attribute_group wusb_dev_attr_group = {
.name = NULL, /* we want them in the same directory */
.attrs = wusb_dev_attrs,
};
int wusb_dev_sysfs_add(struct wusbhc *wusbhc, struct usb_device *usb_dev,
struct wusb_dev *wusb_dev)
{
int result = sysfs_create_group(&usb_dev->dev.kobj,
&wusb_dev_attr_group);
struct device *dev = &usb_dev->dev;
if (result < 0)
dev_err(dev, "Cannot register WUSB-dev attributes: %d\n",
result);
return result;
}
void wusb_dev_sysfs_rm(struct wusb_dev *wusb_dev)
{
struct usb_device *usb_dev = wusb_dev->usb_dev;
if (usb_dev)
sysfs_remove_group(&usb_dev->dev.kobj, &wusb_dev_attr_group);
}

View File

@ -0,0 +1,39 @@
/*
* Wireless USB Host Controller
* UWB Protocol Adaptation Layer (PAL) glue.
*
* 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/>.
*/
#include "wusbhc.h"
/**
* wusbhc_pal_register - register the WUSB HC as a UWB PAL
* @wusbhc: the WUSB HC
*/
int wusbhc_pal_register(struct wusbhc *wusbhc)
{
uwb_pal_init(&wusbhc->pal);
return uwb_pal_register(wusbhc->uwb_rc, &wusbhc->pal);
}
/**
* wusbhc_pal_register - unregister the WUSB HC as a UWB PAL
* @wusbhc: the WUSB HC
*/
void wusbhc_pal_unregister(struct wusbhc *wusbhc)
{
uwb_pal_unregister(wusbhc->uwb_rc, &wusbhc->pal);
}

View File

@ -0,0 +1,115 @@
/*
* WUSB cluster reservation management
*
* Copyright (C) 2007 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/>.
*/
#include <linux/kernel.h>
#include <linux/uwb.h>
#include "wusbhc.h"
/*
* WUSB cluster reservations are multicast reservations with the
* broadcast cluster ID (BCID) as the target DevAddr.
*
* FIXME: consider adjusting the reservation depending on what devices
* are attached.
*/
static int wusbhc_bwa_set(struct wusbhc *wusbhc, u8 stream,
const struct uwb_mas_bm *mas)
{
if (mas == NULL)
mas = &uwb_mas_bm_zero;
return wusbhc->bwa_set(wusbhc, stream, mas);
}
/**
* wusbhc_rsv_complete_cb - WUSB HC reservation complete callback
* @rsv: the reservation
*
* Either set or clear the HC's view of the reservation.
*
* FIXME: when a reservation is denied the HC should be stopped.
*/
static void wusbhc_rsv_complete_cb(struct uwb_rsv *rsv)
{
struct wusbhc *wusbhc = rsv->pal_priv;
struct device *dev = wusbhc->dev;
char buf[72];
switch (rsv->state) {
case UWB_RSV_STATE_O_ESTABLISHED:
bitmap_scnprintf(buf, sizeof(buf), rsv->mas.bm, UWB_NUM_MAS);
dev_dbg(dev, "established reservation: %s\n", buf);
wusbhc_bwa_set(wusbhc, rsv->stream, &rsv->mas);
break;
case UWB_RSV_STATE_NONE:
dev_dbg(dev, "removed reservation\n");
wusbhc_bwa_set(wusbhc, 0, NULL);
wusbhc->rsv = NULL;
break;
default:
dev_dbg(dev, "unexpected reservation state: %d\n", rsv->state);
break;
}
}
/**
* wusbhc_rsv_establish - establish a reservation for the cluster
* @wusbhc: the WUSB HC requesting a bandwith reservation
*/
int wusbhc_rsv_establish(struct wusbhc *wusbhc)
{
struct uwb_rc *rc = wusbhc->uwb_rc;
struct uwb_rsv *rsv;
struct uwb_dev_addr bcid;
int ret;
rsv = uwb_rsv_create(rc, wusbhc_rsv_complete_cb, wusbhc);
if (rsv == NULL)
return -ENOMEM;
bcid.data[0] = wusbhc->cluster_id;
bcid.data[1] = 0;
rsv->owner = &rc->uwb_dev;
rsv->target.type = UWB_RSV_TARGET_DEVADDR;
rsv->target.devaddr = bcid;
rsv->type = UWB_DRP_TYPE_PRIVATE;
rsv->max_mas = 256;
rsv->min_mas = 16; /* one MAS per zone? */
rsv->sparsity = 16; /* at least one MAS in each zone? */
rsv->is_multicast = true;
ret = uwb_rsv_establish(rsv);
if (ret == 0)
wusbhc->rsv = rsv;
else
uwb_rsv_destroy(rsv);
return ret;
}
/**
* wusbhc_rsv_terminate - terminate any cluster reservation
* @wusbhc: the WUSB host whose reservation is to be terminated
*/
void wusbhc_rsv_terminate(struct wusbhc *wusbhc)
{
if (wusbhc->rsv)
uwb_rsv_terminate(wusbhc->rsv);
}

477
drivers/usb/wusbcore/rh.c Normal file
View File

@ -0,0 +1,477 @@
/*
* Wireless USB Host Controller
* Root Hub operations
*
*
* 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.
*
*
* We fake a root hub that has fake ports (as many as simultaneous
* devices the Wireless USB Host Controller can deal with). For each
* port we keep an state in @wusbhc->port[index] identical to the one
* specified in the USB2.0[ch11] spec and some extra device
* information that complements the one in 'struct usb_device' (as
* this lacs a hcpriv pointer).
*
* Note this is common to WHCI and HWA host controllers.
*
* Through here we enable most of the state changes that the USB stack
* will use to connect or disconnect devices. We need to do some
* forced adaptation of Wireless USB device states vs. wired:
*
* USB: WUSB:
*
* Port Powered-off port slot n/a
* Powered-on port slot available
* Disconnected port slot available
* Connected port slot assigned device
* device sent DN_Connect
* device was authenticated
* Enabled device is authenticated, transitioned
* from unauth -> auth -> default address
* -> enabled
* Reset disconnect
* Disable disconnect
*
* This maps the standard USB port states with the WUSB device states
* so we can fake ports without having to modify the USB stack.
*
* FIXME: this process will change in the future
*
*
* ENTRY POINTS
*
* Our entry points into here are, as in hcd.c, the USB stack root hub
* ops defined in the usb_hcd struct:
*
* wusbhc_rh_status_data() Provide hub and port status data bitmap
*
* wusbhc_rh_control() Execution of all the major requests
* you can do to a hub (Set|Clear
* features, get descriptors, status, etc).
*
* wusbhc_rh_[suspend|resume]() That
*
* wusbhc_rh_start_port_reset() ??? unimplemented
*/
#include "wusbhc.h"
#define D_LOCAL 0
#include <linux/uwb/debug.h>
/*
* Reset a fake port
*
* This can be called to reset a port from any other state or to reset
* it when connecting. In Wireless USB they are different; when doing
* a new connect that involves going over the authentication. When
* just reseting, its a different story.
*
* The Linux USB stack resets a port twice before it considers it
* enabled, so we have to detect and ignore that.
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*
* Supposedly we are the only thread accesing @wusbhc->port; in any
* case, maybe we should move the mutex locking from
* wusbhc_devconnect_auth() to here.
*
* @port_idx refers to the wusbhc's port index, not the USB port number
*/
static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx)
{
int result = 0;
struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx);
d_fnstart(3, wusbhc->dev, "(wusbhc %p port_idx %u)\n",
wusbhc, port_idx);
if (port->reset_count == 0) {
wusbhc_devconnect_auth(wusbhc, port_idx);
port->reset_count++;
} else if (port->reset_count == 1)
/* see header */
d_printf(2, wusbhc->dev, "Ignoring second reset on port_idx "
"%u\n", port_idx);
else
result = wusbhc_dev_reset(wusbhc, port_idx);
d_fnend(3, wusbhc->dev, "(wusbhc %p port_idx %u) = %d\n",
wusbhc, port_idx, result);
return result;
}
/*
* Return the hub change status bitmap
*
* The bits in the change status bitmap are cleared when a
* ClearPortFeature request is issued (USB2.0[11.12.3,11.12.4].
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*
* WARNING!! This gets called from atomic context; we cannot get the
* mutex--the only race condition we can find is some bit
* changing just after we copy it, which shouldn't be too
* big of a problem [and we can't make it an spinlock
* because other parts need to take it and sleep] .
*
* @usb_hcd is refcounted, so it won't dissapear under us
* and before killing a host, the polling of the root hub
* would be stopped anyway.
*/
int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf)
{
struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
size_t cnt, size;
unsigned long *buf = (unsigned long *) _buf;
d_fnstart(1, wusbhc->dev, "(wusbhc %p)\n", wusbhc);
/* WE DON'T LOCK, see comment */
size = wusbhc->ports_max + 1 /* hub bit */;
size = (size + 8 - 1) / 8; /* round to bytes */
for (cnt = 0; cnt < wusbhc->ports_max; cnt++)
if (wusb_port_by_idx(wusbhc, cnt)->change)
set_bit(cnt + 1, buf);
else
clear_bit(cnt + 1, buf);
d_fnend(1, wusbhc->dev, "(wusbhc %p) %u, buffer:\n", wusbhc, (int)size);
d_dump(1, wusbhc->dev, _buf, size);
return size;
}
EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);
/*
* Return the hub's desciptor
*
* NOTE: almost cut and paste from ehci-hub.c
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked
*/
static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
u16 wIndex,
struct usb_hub_descriptor *descr,
u16 wLength)
{
u16 temp = 1 + (wusbhc->ports_max / 8);
u8 length = 7 + 2 * temp;
if (wLength < length)
return -ENOSPC;
descr->bDescLength = 7 + 2 * temp;
descr->bDescriptorType = 0x29; /* HUB type */
descr->bNbrPorts = wusbhc->ports_max;
descr->wHubCharacteristics = cpu_to_le16(
0x00 /* All ports power at once */
| 0x00 /* not part of compound device */
| 0x10 /* No overcurrent protection */
| 0x00 /* 8 FS think time FIXME ?? */
| 0x00); /* No port indicators */
descr->bPwrOn2PwrGood = 0;
descr->bHubContrCurrent = 0;
/* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
memset(&descr->bitmap[0], 0, temp);
memset(&descr->bitmap[temp], 0xff, temp);
return 0;
}
/*
* Clear a hub feature
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*
* Nothing to do, so no locking needed ;)
*/
static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature)
{
int result;
struct device *dev = wusbhc->dev;
d_fnstart(4, dev, "(%p, feature 0x%04u)\n", wusbhc, feature);
switch (feature) {
case C_HUB_LOCAL_POWER:
/* FIXME: maybe plug bit 0 to the power input status,
* if any?
* see wusbhc_rh_get_hub_status() */
case C_HUB_OVER_CURRENT:
result = 0;
break;
default:
result = -EPIPE;
}
d_fnend(4, dev, "(%p, feature 0x%04u), %d\n", wusbhc, feature, result);
return result;
}
/*
* Return hub status (it is always zero...)
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*
* Nothing to do, so no locking needed ;)
*/
static int wusbhc_rh_get_hub_status(struct wusbhc *wusbhc, u32 *buf,
u16 wLength)
{
/* FIXME: maybe plug bit 0 to the power input status (if any)? */
*buf = 0;
return 0;
}
/*
* Set a port feature
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*/
static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature,
u8 selector, u8 port_idx)
{
int result = -EINVAL;
struct device *dev = wusbhc->dev;
d_fnstart(4, dev, "(feat 0x%04u, selector 0x%u, port_idx %d)\n",
feature, selector, port_idx);
if (port_idx > wusbhc->ports_max)
goto error;
switch (feature) {
/* According to USB2.0[11.24.2.13]p2, these features
* are not required to be implemented. */
case USB_PORT_FEAT_C_OVER_CURRENT:
case USB_PORT_FEAT_C_ENABLE:
case USB_PORT_FEAT_C_SUSPEND:
case USB_PORT_FEAT_C_CONNECTION:
case USB_PORT_FEAT_C_RESET:
result = 0;
break;
case USB_PORT_FEAT_POWER:
/* No such thing, but we fake it works */
mutex_lock(&wusbhc->mutex);
wusb_port_by_idx(wusbhc, port_idx)->status |= USB_PORT_STAT_POWER;
mutex_unlock(&wusbhc->mutex);
result = 0;
break;
case USB_PORT_FEAT_RESET:
result = wusbhc_rh_port_reset(wusbhc, port_idx);
break;
case USB_PORT_FEAT_ENABLE:
case USB_PORT_FEAT_SUSPEND:
dev_err(dev, "(port_idx %d) set feat %d/%d UNIMPLEMENTED\n",
port_idx, feature, selector);
result = -ENOSYS;
break;
default:
dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n",
port_idx, feature, selector);
result = -EPIPE;
break;
}
error:
d_fnend(4, dev, "(feat 0x%04u, selector 0x%u, port_idx %d) = %d\n",
feature, selector, port_idx, result);
return result;
}
/*
* Clear a port feature...
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*/
static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
u8 selector, u8 port_idx)
{
int result = -EINVAL;
struct device *dev = wusbhc->dev;
d_fnstart(4, dev, "(wusbhc %p feat 0x%04x selector %d port_idx %d)\n",
wusbhc, feature, selector, port_idx);
if (port_idx > wusbhc->ports_max)
goto error;
mutex_lock(&wusbhc->mutex);
result = 0;
switch (feature) {
case USB_PORT_FEAT_POWER: /* fake port always on */
/* According to USB2.0[11.24.2.7.1.4], no need to implement? */
case USB_PORT_FEAT_C_OVER_CURRENT:
break;
case USB_PORT_FEAT_C_RESET:
wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_RESET;
break;
case USB_PORT_FEAT_C_CONNECTION:
wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_CONNECTION;
break;
case USB_PORT_FEAT_ENABLE:
__wusbhc_dev_disable(wusbhc, port_idx);
break;
case USB_PORT_FEAT_C_ENABLE:
wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_ENABLE;
break;
case USB_PORT_FEAT_SUSPEND:
case USB_PORT_FEAT_C_SUSPEND:
case 0xffff: /* ??? FIXME */
dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n",
port_idx, feature, selector);
/* dump_stack(); */
result = -ENOSYS;
break;
default:
dev_err(dev, "(port_idx %d) Clear feat %d/%d UNKNOWN\n",
port_idx, feature, selector);
result = -EPIPE;
break;
}
mutex_unlock(&wusbhc->mutex);
error:
d_fnend(4, dev, "(wusbhc %p feat 0x%04x selector %d port_idx %d) = "
"%d\n", wusbhc, feature, selector, port_idx, result);
return result;
}
/*
* Return the port's status
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*/
static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx,
u32 *_buf, u16 wLength)
{
int result = -EINVAL;
u16 *buf = (u16 *) _buf;
d_fnstart(1, wusbhc->dev, "(wusbhc %p port_idx %u wLength %u)\n",
wusbhc, port_idx, wLength);
if (port_idx > wusbhc->ports_max)
goto error;
mutex_lock(&wusbhc->mutex);
buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status);
buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change);
result = 0;
mutex_unlock(&wusbhc->mutex);
error:
d_fnend(1, wusbhc->dev, "(wusbhc %p) = %d, buffer:\n", wusbhc, result);
d_dump(1, wusbhc->dev, _buf, wLength);
return result;
}
/*
* Entry point for Root Hub operations
*
* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
*/
int wusbhc_rh_control(struct usb_hcd *usb_hcd, u16 reqntype, u16 wValue,
u16 wIndex, char *buf, u16 wLength)
{
int result = -ENOSYS;
struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
switch (reqntype) {
case GetHubDescriptor:
result = wusbhc_rh_get_hub_descr(
wusbhc, wValue, wIndex,
(struct usb_hub_descriptor *) buf, wLength);
break;
case ClearHubFeature:
result = wusbhc_rh_clear_hub_feat(wusbhc, wValue);
break;
case GetHubStatus:
result = wusbhc_rh_get_hub_status(wusbhc, (u32 *)buf, wLength);
break;
case SetPortFeature:
result = wusbhc_rh_set_port_feat(wusbhc, wValue, wIndex >> 8,
(wIndex & 0xff) - 1);
break;
case ClearPortFeature:
result = wusbhc_rh_clear_port_feat(wusbhc, wValue, wIndex >> 8,
(wIndex & 0xff) - 1);
break;
case GetPortStatus:
result = wusbhc_rh_get_port_status(wusbhc, wIndex - 1,
(u32 *)buf, wLength);
break;
case SetHubFeature:
default:
dev_err(wusbhc->dev, "%s (%p [%p], %x, %x, %x, %p, %x) "
"UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, reqntype,
wValue, wIndex, buf, wLength);
/* dump_stack(); */
result = -ENOSYS;
}
return result;
}
EXPORT_SYMBOL_GPL(wusbhc_rh_control);
int wusbhc_rh_suspend(struct usb_hcd *usb_hcd)
{
struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
usb_hcd, wusbhc);
/* dump_stack(); */
return -ENOSYS;
}
EXPORT_SYMBOL_GPL(wusbhc_rh_suspend);
int wusbhc_rh_resume(struct usb_hcd *usb_hcd)
{
struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
usb_hcd, wusbhc);
/* dump_stack(); */
return -ENOSYS;
}
EXPORT_SYMBOL_GPL(wusbhc_rh_resume);
int wusbhc_rh_start_port_reset(struct usb_hcd *usb_hcd, unsigned port_idx)
{
struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
dev_err(wusbhc->dev, "%s (%p [%p], port_idx %u) UNIMPLEMENTED\n",
__func__, usb_hcd, wusbhc, port_idx);
WARN_ON(1);
return -ENOSYS;
}
EXPORT_SYMBOL_GPL(wusbhc_rh_start_port_reset);
static void wusb_port_init(struct wusb_port *port)
{
port->status |= USB_PORT_STAT_HIGH_SPEED;
}
/*
* Alloc fake port specific fields and status.
*/
int wusbhc_rh_create(struct wusbhc *wusbhc)
{
int result = -ENOMEM;
size_t port_size, itr;
port_size = wusbhc->ports_max * sizeof(wusbhc->port[0]);
wusbhc->port = kzalloc(port_size, GFP_KERNEL);
if (wusbhc->port == NULL)
goto error_port_alloc;
for (itr = 0; itr < wusbhc->ports_max; itr++)
wusb_port_init(&wusbhc->port[itr]);
result = 0;
error_port_alloc:
return result;
}
void wusbhc_rh_destroy(struct wusbhc *wusbhc)
{
kfree(wusbhc->port);
}

View File

@ -0,0 +1,416 @@
/*
* Wireless USB Host Controller
* sysfs glue, wusbcore module support and life cycle management
*
*
* 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.
*
*
* Creation/destruction of wusbhc is split in two parts; that that
* doesn't require the HCD to be added (wusbhc_{create,destroy}) and
* the one that requires (phase B, wusbhc_b_{create,destroy}).
*
* This is so because usb_add_hcd() will start the HC, and thus, all
* the HC specific stuff has to be already initialiazed (like sysfs
* thingies).
*/
#include <linux/device.h>
#include <linux/module.h>
#include "wusbhc.h"
/**
* Extract the wusbhc that corresponds to a USB Host Controller class device
*
* WARNING! Apply only if @dev is that of a
* wusbhc.usb_hcd.self->class_dev; otherwise, you loose.
*/
static struct wusbhc *usbhc_dev_to_wusbhc(struct device *dev)
{
struct usb_bus *usb_bus = dev_get_drvdata(dev);
struct usb_hcd *usb_hcd = bus_to_hcd(usb_bus);
return usb_hcd_to_wusbhc(usb_hcd);
}
/*
* Show & store the current WUSB trust timeout
*
* We don't do locking--it is an 'atomic' value.
*
* The units that we store/show are always MILLISECONDS. However, the
* value of trust_timeout is jiffies.
*/
static ssize_t wusb_trust_timeout_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
return scnprintf(buf, PAGE_SIZE, "%u\n", wusbhc->trust_timeout);
}
static ssize_t wusb_trust_timeout_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
ssize_t result = -ENOSYS;
unsigned trust_timeout;
result = sscanf(buf, "%u", &trust_timeout);
if (result != 1) {
result = -EINVAL;
goto out;
}
/* FIXME: maybe we should check for range validity? */
wusbhc->trust_timeout = trust_timeout;
cancel_delayed_work(&wusbhc->keep_alive_timer);
flush_workqueue(wusbd);
queue_delayed_work(wusbd, &wusbhc->keep_alive_timer,
(trust_timeout * CONFIG_HZ)/1000/2);
out:
return result < 0 ? result : size;
}
static DEVICE_ATTR(wusb_trust_timeout, 0644, wusb_trust_timeout_show,
wusb_trust_timeout_store);
/*
* Show & store the current WUSB CHID
*/
static ssize_t wusb_chid_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
ssize_t result = 0;
if (wusbhc->wuie_host_info != NULL)
result += ckhdid_printf(buf, PAGE_SIZE,
&wusbhc->wuie_host_info->CHID);
return result;
}
/*
* Store a new CHID
*
* This will (FIXME) trigger many changes.
*
* - Send an all zeros CHID and it will stop the controller
* - Send a non-zero CHID and it will start it
* (unless it was started, it will just change the CHID,
* diconnecting all devices first).
*
* So first we scan the MMC we are sent and then we act on it. We
* read it in the same format as we print it, an ASCII string of 16
* hex bytes.
*
* See wusbhc_chid_set() for more info.
*/
static ssize_t wusb_chid_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t size)
{
struct wusbhc *wusbhc = usbhc_dev_to_wusbhc(dev);
struct wusb_ckhdid chid;
ssize_t result;
result = sscanf(buf,
"%02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx "
"%02hhx %02hhx %02hhx %02hhx\n",
&chid.data[0] , &chid.data[1] ,
&chid.data[2] , &chid.data[3] ,
&chid.data[4] , &chid.data[5] ,
&chid.data[6] , &chid.data[7] ,
&chid.data[8] , &chid.data[9] ,
&chid.data[10], &chid.data[11],
&chid.data[12], &chid.data[13],
&chid.data[14], &chid.data[15]);
if (result != 16) {
dev_err(dev, "Unrecognized CHID (need 16 8-bit hex digits): "
"%d\n", (int)result);
return -EINVAL;
}
result = wusbhc_chid_set(wusbhc, &chid);
return result < 0 ? result : size;
}
static DEVICE_ATTR(wusb_chid, 0644, wusb_chid_show, wusb_chid_store);
/* Group all the WUSBHC attributes */
static struct attribute *wusbhc_attrs[] = {
&dev_attr_wusb_trust_timeout.attr,
&dev_attr_wusb_chid.attr,
NULL,
};
static struct attribute_group wusbhc_attr_group = {
.name = NULL, /* we want them in the same directory */
.attrs = wusbhc_attrs,
};
/*
* Create a wusbhc instance
*
* NOTEs:
*
* - assumes *wusbhc has been zeroed and wusbhc->usb_hcd has been
* initialized but not added.
*
* - fill out ports_max, mmcies_max and mmcie_{add,rm} before calling.
*
* - fill out wusbhc->uwb_rc and refcount it before calling
* - fill out the wusbhc->sec_modes array
*/
int wusbhc_create(struct wusbhc *wusbhc)
{
int result = 0;
wusbhc->trust_timeout = WUSB_TRUST_TIMEOUT_MS;
mutex_init(&wusbhc->mutex);
result = wusbhc_mmcie_create(wusbhc);
if (result < 0)
goto error_mmcie_create;
result = wusbhc_devconnect_create(wusbhc);
if (result < 0)
goto error_devconnect_create;
result = wusbhc_rh_create(wusbhc);
if (result < 0)
goto error_rh_create;
result = wusbhc_sec_create(wusbhc);
if (result < 0)
goto error_sec_create;
result = wusbhc_pal_register(wusbhc);
if (result < 0)
goto error_pal_register;
return 0;
error_pal_register:
wusbhc_sec_destroy(wusbhc);
error_sec_create:
wusbhc_rh_destroy(wusbhc);
error_rh_create:
wusbhc_devconnect_destroy(wusbhc);
error_devconnect_create:
wusbhc_mmcie_destroy(wusbhc);
error_mmcie_create:
return result;
}
EXPORT_SYMBOL_GPL(wusbhc_create);
static inline struct kobject *wusbhc_kobj(struct wusbhc *wusbhc)
{
return &wusbhc->usb_hcd.self.controller->kobj;
}
/*
* Phase B of a wusbhc instance creation
*
* Creates fields that depend on wusbhc->usb_hcd having been
* added. This is where we create the sysfs files in
* /sys/class/usb_host/usb_hostX/.
*
* NOTE: Assumes wusbhc->usb_hcd has been already added by the upper
* layer (hwahc or whci)
*/
int wusbhc_b_create(struct wusbhc *wusbhc)
{
int result = 0;
struct device *dev = wusbhc->usb_hcd.self.controller;
result = sysfs_create_group(wusbhc_kobj(wusbhc), &wusbhc_attr_group);
if (result < 0) {
dev_err(dev, "Cannot register WUSBHC attributes: %d\n", result);
goto error_create_attr_group;
}
/* Yep, I plan to add stuff here... */
error_create_attr_group:
return result;
}
EXPORT_SYMBOL_GPL(wusbhc_b_create);
void wusbhc_b_destroy(struct wusbhc *wusbhc)
{
sysfs_remove_group(wusbhc_kobj(wusbhc), &wusbhc_attr_group);
}
EXPORT_SYMBOL_GPL(wusbhc_b_destroy);
void wusbhc_destroy(struct wusbhc *wusbhc)
{
wusbhc_pal_unregister(wusbhc);
wusbhc_sec_destroy(wusbhc);
wusbhc_rh_destroy(wusbhc);
wusbhc_devconnect_destroy(wusbhc);
wusbhc_mmcie_destroy(wusbhc);
}
EXPORT_SYMBOL_GPL(wusbhc_destroy);
struct workqueue_struct *wusbd;
EXPORT_SYMBOL_GPL(wusbd);
/*
* WUSB Cluster ID allocation map
*
* Each WUSB bus in a channel is identified with a Cluster Id in the
* unauth address pace (WUSB1.0[4.3]). We take the range 0xe0 to 0xff
* (that's space for 31 WUSB controllers, as 0xff can't be taken). We
* start taking from 0xff, 0xfe, 0xfd... (hence the += or -= 0xff).
*
* For each one we taken, we pin it in the bitap
*/
#define CLUSTER_IDS 32
static DECLARE_BITMAP(wusb_cluster_id_table, CLUSTER_IDS);
static DEFINE_SPINLOCK(wusb_cluster_ids_lock);
/*
* Get a WUSB Cluster ID
*
* Need to release with wusb_cluster_id_put() when done w/ it.
*/
/* FIXME: coordinate with the choose_addres() from the USB stack */
/* we want to leave the top of the 128 range for cluster addresses and
* the bottom for device addresses (as we map them one on one with
* ports). */
u8 wusb_cluster_id_get(void)
{
u8 id;
spin_lock(&wusb_cluster_ids_lock);
id = find_first_zero_bit(wusb_cluster_id_table, CLUSTER_IDS);
if (id > CLUSTER_IDS) {
id = 0;
goto out;
}
set_bit(id, wusb_cluster_id_table);
id = (u8) 0xff - id;
out:
spin_unlock(&wusb_cluster_ids_lock);
return id;
}
EXPORT_SYMBOL_GPL(wusb_cluster_id_get);
/*
* Release a WUSB Cluster ID
*
* Obtained it with wusb_cluster_id_get()
*/
void wusb_cluster_id_put(u8 id)
{
id = 0xff - id;
BUG_ON(id >= CLUSTER_IDS);
spin_lock(&wusb_cluster_ids_lock);
WARN_ON(!test_bit(id, wusb_cluster_id_table));
clear_bit(id, wusb_cluster_id_table);
spin_unlock(&wusb_cluster_ids_lock);
}
EXPORT_SYMBOL_GPL(wusb_cluster_id_put);
/**
* wusbhc_giveback_urb - return an URB to the USB core
* @wusbhc: the host controller the URB is from.
* @urb: the URB.
* @status: the URB's status.
*
* Return an URB to the USB core doing some additional WUSB specific
* processing.
*
* - After a successful transfer, update the trust timeout timestamp
* for the WUSB device.
*
* - [WUSB] sections 4.13 and 7.5.1 specifies the stop retrasmittion
* condition for the WCONNECTACK_IE is that the host has observed
* the associated device responding to a control transfer.
*/
void wusbhc_giveback_urb(struct wusbhc *wusbhc, struct urb *urb, int status)
{
struct wusb_dev *wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, urb->dev);
if (status == 0) {
wusb_dev->entry_ts = jiffies;
/* wusbhc_devconnect_acked() can't be called from from
atomic context so defer it to a work queue. */
if (!list_empty(&wusb_dev->cack_node))
queue_work(wusbd, &wusb_dev->devconnect_acked_work);
}
usb_hcd_giveback_urb(&wusbhc->usb_hcd, urb, status);
}
EXPORT_SYMBOL_GPL(wusbhc_giveback_urb);
/**
* wusbhc_reset_all - reset the HC hardware
* @wusbhc: the host controller to reset.
*
* Request a full hardware reset of the chip. This will also reset
* the radio controller and any other PALs.
*/
void wusbhc_reset_all(struct wusbhc *wusbhc)
{
uwb_rc_reset_all(wusbhc->uwb_rc);
}
EXPORT_SYMBOL_GPL(wusbhc_reset_all);
static struct notifier_block wusb_usb_notifier = {
.notifier_call = wusb_usb_ncb,
.priority = INT_MAX /* Need to be called first of all */
};
static int __init wusbcore_init(void)
{
int result;
result = wusb_crypto_init();
if (result < 0)
goto error_crypto_init;
/* WQ is singlethread because we need to serialize notifications */
wusbd = create_singlethread_workqueue("wusbd");
if (wusbd == NULL) {
result = -ENOMEM;
printk(KERN_ERR "WUSB-core: Cannot create wusbd workqueue\n");
goto error_wusbd_create;
}
usb_register_notify(&wusb_usb_notifier);
bitmap_zero(wusb_cluster_id_table, CLUSTER_IDS);
set_bit(0, wusb_cluster_id_table); /* reserve Cluster ID 0xff */
return 0;
error_wusbd_create:
wusb_crypto_exit();
error_crypto_init:
return result;
}
module_init(wusbcore_init);
static void __exit wusbcore_exit(void)
{
clear_bit(0, wusb_cluster_id_table);
if (!bitmap_empty(wusb_cluster_id_table, CLUSTER_IDS)) {
char buf[256];
bitmap_scnprintf(buf, sizeof(buf), wusb_cluster_id_table,
CLUSTER_IDS);
printk(KERN_ERR "BUG: WUSB Cluster IDs not released "
"on exit: %s\n", buf);
WARN_ON(1);
}
usb_unregister_notify(&wusb_usb_notifier);
destroy_workqueue(wusbd);
wusb_crypto_exit();
}
module_exit(wusbcore_exit);
MODULE_AUTHOR("Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>");
MODULE_DESCRIPTION("Wireless USB core");
MODULE_LICENSE("GPL");

View File

@ -0,0 +1,495 @@
/*
* 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 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.
*
*
* 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>
/* FIXME: Yes, I know: BAD--it's not my fault the USB HC iface is not
* public */
#include <linux/../../drivers/usb/core/hcd.h>
#include <linux/uwb.h>
#include <linux/usb/wusb.h>
/**
* 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 */
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 urb *set_gtk_urb;
struct usb_ctrlrequest *set_gtk_req;
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 Controlller 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 */
unsigned reset_count;
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 lenght 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.
*
* @mmcie_add HC specific operation (WHCI or HWA) for adding an
* MMCIE.
*
* @mmcie_rm HC specific operation (WHCI or HWA) for removing an
* MMCIE.
*
* @enc_types Array which describes the encryptions methods
* supported by the host as described in WUSB1.0 --
* one entry per supported method. As of WUSB1.0 there
* is only four methods, we make space for eight just in
* case they decide to add some more (and pray they do
* it in sequential order). if 'enc_types[enc_method]
* != 0', then it is supported by the host. enc_method
* is USB_ENC_TYPE*.
*
* @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
* dissapear 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 wuie_host_info *wuie_host_info; /* Includes CHID */
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 (*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;
struct work_struct gtk_rekey_done_work;
int pending_set_gtks;
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 = container_of(usb_dev->bus, struct usb_hcd, self);
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, const struct wusb_ckhdid *chid);
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,
const struct wusb_ckhdid *chid);
extern void wusbhc_devconnect_stop(struct wusbhc *wusbhc);
extern int wusbhc_devconnect_auth(struct wusbhc *, u8);
extern void wusbhc_handle_dn(struct wusbhc *, u8 srcaddr,
struct wusb_dn_hdr *dn_hdr, size_t size);
extern int wusbhc_dev_reset(struct wusbhc *wusbhc, u8 port);
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_suspend(struct usb_hcd *);
extern int wusbhc_rh_resume(struct usb_hcd *);
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);
/* 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__ */