[linux-2.6-block.git] / drivers / staging / wusbcore / rh.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Wireless USB Host Controller
 * Root Hub operations
 *
 *
 * Copyright (C) 2005-2006 Intel Corporation
 * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
 *
 * 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 <linux/slab.h>
#include <linux/export.h>
#include "wusbhc.h"

/*
 * Reset a fake port
 *
 * Using a Reset Device IE is too heavyweight as it causes the device
 * to enter the UnConnected state and leave the cluster, this can mean
 * that when the device reconnects it is connected to a different fake
 * port.
 *
 * Instead, reset authenticated devices with a SetAddress(0), followed
 * by a SetAddresss(AuthAddr).
 *
 * For unauthenticated devices just pretend to reset but do nothing.
 * If the device initialization continues to fail it will eventually
 * time out after TrustTimeout and enter the UnConnected state.
 *
 * @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);
	struct wusb_dev *wusb_dev = port->wusb_dev;

	if (wusb_dev == NULL)
		return -ENOTCONN;

	port->status |= USB_PORT_STAT_RESET;
	port->change |= USB_PORT_STAT_C_RESET;

	if (wusb_dev->addr & WUSB_DEV_ADDR_UNAUTH)
		result = 0;
	else
		result = wusb_dev_update_address(wusbhc, wusb_dev);

	port->status &= ~USB_PORT_STAT_RESET;
	port->status |= USB_PORT_STAT_ENABLE;
	port->change |= USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_ENABLE;	

	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 disappear 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, bits_set = 0;

	/* WE DON'T LOCK, see comment */
	/* round up to bytes.  Hub bit is bit 0 so add 1. */
	size = DIV_ROUND_UP(wusbhc->ports_max + 1, 8);

	/* clear the output buffer. */
	memset(_buf, 0, size);
	/* set the bit for each changed port. */
	for (cnt = 0; cnt < wusbhc->ports_max; cnt++) {

		if (wusb_port_by_idx(wusbhc, cnt)->change) {
			const int bitpos = cnt+1;

			_buf[bitpos/8] |= (1 << (bitpos % 8));
			bits_set++;
		}
	}

	return bits_set ? size : 0;
}
EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);

/*
 * Return the hub's descriptor
 *
 * 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 = USB_DT_HUB; /* HUB type */
	descr->bNbrPorts = wusbhc->ports_max;
	descr->wHubCharacteristics = cpu_to_le16(
		HUB_CHAR_COMMON_LPSM	/* All ports power at once */
		| 0x00			/* not part of compound device */
		| HUB_CHAR_NO_OCPM	/* 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->u.hs.DeviceRemovable[0], 0, temp);
	memset(&descr->u.hs.DeviceRemovable[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;

	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;
	}
	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)
{
	struct device *dev = wusbhc->dev;

	if (port_idx > wusbhc->ports_max)
		return -EINVAL;

	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:
		return 0;
	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);
		return 0;
	case USB_PORT_FEAT_RESET:
		return wusbhc_rh_port_reset(wusbhc, port_idx);
	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);
		return -ENOSYS;
	default:
		dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n",
			port_idx, feature, selector);
		return -EPIPE;
	}

	return 0;
}

/*
 * 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 = 0;
	struct device *dev = wusbhc->dev;

	if (port_idx > wusbhc->ports_max)
		return -EINVAL;

	mutex_lock(&wusbhc->mutex);
	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:
		dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n",
			port_idx, feature, selector);
		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);

	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)
{
	__le16 *buf = (__le16 *)_buf;

	if (port_idx > wusbhc->ports_max)
		return -EINVAL;

	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);
	mutex_unlock(&wusbhc->mutex);

	return 0;
}

/*
 * 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_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);
}
Commit	Line	Data
5fd54ace	1	// SPDX-License-Identifier: GPL-2.0
90ff96f2 IPG	2	/*
	3	* Wireless USB Host Controller
	4	* Root Hub operations
	5	*
	6	*
	7	* Copyright (C) 2005-2006 Intel Corporation
	8	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	9	*
90ff96f2 IPG	10	* We fake a root hub that has fake ports (as many as simultaneous
	11	* devices the Wireless USB Host Controller can deal with). For each
	12	* port we keep an state in @wusbhc->port[index] identical to the one
	13	* specified in the USB2.0[ch11] spec and some extra device
	14	* information that complements the one in 'struct usb_device' (as
	15	* this lacs a hcpriv pointer).
	16	*
	17	* Note this is common to WHCI and HWA host controllers.
	18	*
	19	* Through here we enable most of the state changes that the USB stack
	20	* will use to connect or disconnect devices. We need to do some
	21	* forced adaptation of Wireless USB device states vs. wired:
	22	*
	23	* USB: WUSB:
	24	*
	25	* Port Powered-off port slot n/a
	26	* Powered-on port slot available
	27	* Disconnected port slot available
	28	* Connected port slot assigned device
	29	* device sent DN_Connect
	30	* device was authenticated
	31	* Enabled device is authenticated, transitioned
	32	* from unauth -> auth -> default address
	33	* -> enabled
	34	* Reset disconnect
	35	* Disable disconnect
	36	*
	37	* This maps the standard USB port states with the WUSB device states
	38	* so we can fake ports without having to modify the USB stack.
	39	*
	40	* FIXME: this process will change in the future
	41	*
	42	*
	43	* ENTRY POINTS
	44	*
	45	* Our entry points into here are, as in hcd.c, the USB stack root hub
	46	* ops defined in the usb_hcd struct:
	47	*
	48	* wusbhc_rh_status_data() Provide hub and port status data bitmap
	49	*
	50	* wusbhc_rh_control() Execution of all the major requests
	51	* you can do to a hub (Set\|Clear
	52	* features, get descriptors, status, etc).
	53	*
	54	* wusbhc_rh_[suspend\|resume]() That
	55	*
	56	* wusbhc_rh_start_port_reset() ??? unimplemented
	57	*/
5a0e3ad6	58	#include <linux/slab.h>
f940fcd8	59	#include <linux/export.h>
90ff96f2 IPG	60	#include "wusbhc.h"
90ff96f2 IPG	61
90ff96f2 IPG	62	/*
	63	* Reset a fake port
	64	*
4656d5de DV	65	* Using a Reset Device IE is too heavyweight as it causes the device
	66	* to enter the UnConnected state and leave the cluster, this can mean
	67	* that when the device reconnects it is connected to a different fake
	68	* port.
90ff96f2	69	*
4656d5de DV	70	* Instead, reset authenticated devices with a SetAddress(0), followed
	71	* by a SetAddresss(AuthAddr).
	72	*
	73	* For unauthenticated devices just pretend to reset but do nothing.
	74	* If the device initialization continues to fail it will eventually
	75	* time out after TrustTimeout and enter the UnConnected state.
90ff96f2 IPG	76	*
	77	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	78	*
	79	* Supposedly we are the only thread accesing @wusbhc->port; in any
	80	* case, maybe we should move the mutex locking from
	81	* wusbhc_devconnect_auth() to here.
	82	*
	83	* @port_idx refers to the wusbhc's port index, not the USB port number
	84	*/
	85	static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx)
	86	{
	87	int result = 0;
	88	struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx);
4656d5de DV	89	struct wusb_dev *wusb_dev = port->wusb_dev;
4656d5de DV	90
9a9b1d17 DV	91	if (wusb_dev == NULL)
	92	return -ENOTCONN;
	93
4656d5de DV	94	port->status \|= USB_PORT_STAT_RESET;
4656d5de DV	95	port->change \|= USB_PORT_STAT_C_RESET;
90ff96f2	96
4656d5de DV	97	if (wusb_dev->addr & WUSB_DEV_ADDR_UNAUTH)
4656d5de DV	98	result = 0;
90ff96f2	99	else
4656d5de DV	100	result = wusb_dev_update_address(wusbhc, wusb_dev);
	101
	102	port->status &= ~USB_PORT_STAT_RESET;
	103	port->status \|= USB_PORT_STAT_ENABLE;
	104	port->change \|= USB_PORT_STAT_C_RESET \| USB_PORT_STAT_C_ENABLE;
	105
90ff96f2 IPG	106	return result;
	107	}
	108
	109	/*
	110	* Return the hub change status bitmap
	111	*
	112	* The bits in the change status bitmap are cleared when a
	113	* ClearPortFeature request is issued (USB2.0[11.12.3,11.12.4].
	114	*
	115	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	116	*
	117	* WARNING!! This gets called from atomic context; we cannot get the
	118	* mutex--the only race condition we can find is some bit
	119	* changing just after we copy it, which shouldn't be too
	120	* big of a problem [and we can't make it an spinlock
	121	* because other parts need to take it and sleep] .
	122	*
25985edc	123	* @usb_hcd is refcounted, so it won't disappear under us
90ff96f2 IPG	124	* and before killing a host, the polling of the root hub
	125	* would be stopped anyway.
	126	*/
	127	int wusbhc_rh_status_data(struct usb_hcd usb_hcd, char _buf)
	128	{
	129	struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
467d296f	130	size_t cnt, size, bits_set = 0;
90ff96f2	131
90ff96f2	132	/* WE DON'T LOCK, see comment */
467d296f TP	133	/* round up to bytes. Hub bit is bit 0 so add 1. */
	134	size = DIV_ROUND_UP(wusbhc->ports_max + 1, 8);
	135
	136	/* clear the output buffer. */
	137	memset(_buf, 0, size);
	138	/* set the bit for each changed port. */
	139	for (cnt = 0; cnt < wusbhc->ports_max; cnt++) {
	140
	141	if (wusb_port_by_idx(wusbhc, cnt)->change) {
	142	const int bitpos = cnt+1;
	143
	144	_buf[bitpos/8] \|= (1 << (bitpos % 8));
	145	bits_set++;
	146	}
	147	}
	148
	149	return bits_set ? size : 0;
90ff96f2 IPG	150	}
	151	EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);
	152
	153	/*
32b801e9	154	* Return the hub's descriptor
90ff96f2 IPG	155	*
	156	* NOTE: almost cut and paste from ehci-hub.c
	157	*
	158	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked
	159	*/
	160	static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
	161	u16 wIndex,
	162	struct usb_hub_descriptor *descr,
	163	u16 wLength)
	164	{
	165	u16 temp = 1 + (wusbhc->ports_max / 8);
	166	u8 length = 7 + 2 * temp;
	167
	168	if (wLength < length)
	169	return -ENOSPC;
	170	descr->bDescLength = 7 + 2 * temp;
22299d13	171	descr->bDescriptorType = USB_DT_HUB; /* HUB type */
90ff96f2 IPG	172	descr->bNbrPorts = wusbhc->ports_max;
90ff96f2 IPG	173	descr->wHubCharacteristics = cpu_to_le16(
6d2a5663	174	HUB_CHAR_COMMON_LPSM /* All ports power at once */
90ff96f2	175	\| 0x00 /* not part of compound device */
6d2a5663	176	\| HUB_CHAR_NO_OCPM /* No overcurrent protection */
90ff96f2 IPG	177	\| 0x00 /* 8 FS think time FIXME ?? */
	178	\| 0x00); /* No port indicators */
	179	descr->bPwrOn2PwrGood = 0;
	180	descr->bHubContrCurrent = 0;
	181	/* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
dbe79bbe JY	182	memset(&descr->u.hs.DeviceRemovable[0], 0, temp);
dbe79bbe JY	183	memset(&descr->u.hs.DeviceRemovable[temp], 0xff, temp);
90ff96f2 IPG	184	return 0;
	185	}
	186
	187	/*
	188	* Clear a hub feature
	189	*
	190	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	191	*
	192	* Nothing to do, so no locking needed ;)
	193	*/
	194	static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature)
	195	{
	196	int result;
90ff96f2	197
90ff96f2 IPG	198	switch (feature) {
	199	case C_HUB_LOCAL_POWER:
	200	/* FIXME: maybe plug bit 0 to the power input status,
	201	* if any?
	202	* see wusbhc_rh_get_hub_status() */
	203	case C_HUB_OVER_CURRENT:
	204	result = 0;
	205	break;
	206	default:
	207	result = -EPIPE;
	208	}
90ff96f2 IPG	209	return result;
	210	}
	211
	212	/*
	213	* Return hub status (it is always zero...)
	214	*
	215	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	216	*
	217	* Nothing to do, so no locking needed ;)
	218	*/
	219	static int wusbhc_rh_get_hub_status(struct wusbhc wusbhc, u32 buf,
	220	u16 wLength)
	221	{
	222	/* FIXME: maybe plug bit 0 to the power input status (if any)? */
	223	*buf = 0;
	224	return 0;
	225	}
	226
	227	/*
	228	* Set a port feature
	229	*
	230	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	231	*/
	232	static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature,
	233	u8 selector, u8 port_idx)
	234	{
90ff96f2 IPG	235	struct device *dev = wusbhc->dev;
90ff96f2 IPG	236
90ff96f2	237	if (port_idx > wusbhc->ports_max)
bce83697	238	return -EINVAL;
90ff96f2 IPG	239
	240	switch (feature) {
	241	/* According to USB2.0[11.24.2.13]p2, these features
	242	* are not required to be implemented. */
	243	case USB_PORT_FEAT_C_OVER_CURRENT:
	244	case USB_PORT_FEAT_C_ENABLE:
	245	case USB_PORT_FEAT_C_SUSPEND:
	246	case USB_PORT_FEAT_C_CONNECTION:
	247	case USB_PORT_FEAT_C_RESET:
bce83697	248	return 0;
90ff96f2 IPG	249	case USB_PORT_FEAT_POWER:
	250	/* No such thing, but we fake it works */
	251	mutex_lock(&wusbhc->mutex);
	252	wusb_port_by_idx(wusbhc, port_idx)->status \|= USB_PORT_STAT_POWER;
	253	mutex_unlock(&wusbhc->mutex);
bce83697	254	return 0;
90ff96f2	255	case USB_PORT_FEAT_RESET:
bce83697	256	return wusbhc_rh_port_reset(wusbhc, port_idx);
90ff96f2 IPG	257	case USB_PORT_FEAT_ENABLE:
	258	case USB_PORT_FEAT_SUSPEND:
	259	dev_err(dev, "(port_idx %d) set feat %d/%d UNIMPLEMENTED\n",
	260	port_idx, feature, selector);
bce83697	261	return -ENOSYS;
90ff96f2 IPG	262	default:
	263	dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n",
	264	port_idx, feature, selector);
bce83697	265	return -EPIPE;
90ff96f2	266	}
bce83697 DV	267
bce83697 DV	268	return 0;
90ff96f2 IPG	269	}
	270
	271	/*
	272	* Clear a port feature...
	273	*
	274	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	275	*/
	276	static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
	277	u8 selector, u8 port_idx)
	278	{
bce83697	279	int result = 0;
90ff96f2 IPG	280	struct device *dev = wusbhc->dev;
90ff96f2 IPG	281
90ff96f2	282	if (port_idx > wusbhc->ports_max)
bce83697	283	return -EINVAL;
90ff96f2 IPG	284
90ff96f2 IPG	285	mutex_lock(&wusbhc->mutex);
90ff96f2 IPG	286	switch (feature) {
	287	case USB_PORT_FEAT_POWER: /* fake port always on */
	288	/* According to USB2.0[11.24.2.7.1.4], no need to implement? */
	289	case USB_PORT_FEAT_C_OVER_CURRENT:
	290	break;
	291	case USB_PORT_FEAT_C_RESET:
	292	wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_RESET;
	293	break;
	294	case USB_PORT_FEAT_C_CONNECTION:
	295	wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_CONNECTION;
	296	break;
	297	case USB_PORT_FEAT_ENABLE:
	298	__wusbhc_dev_disable(wusbhc, port_idx);
	299	break;
	300	case USB_PORT_FEAT_C_ENABLE:
	301	wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_ENABLE;
	302	break;
	303	case USB_PORT_FEAT_SUSPEND:
	304	case USB_PORT_FEAT_C_SUSPEND:
90ff96f2 IPG	305	dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n",
90ff96f2 IPG	306	port_idx, feature, selector);
90ff96f2 IPG	307	result = -ENOSYS;
	308	break;
	309	default:
	310	dev_err(dev, "(port_idx %d) Clear feat %d/%d UNKNOWN\n",
	311	port_idx, feature, selector);
	312	result = -EPIPE;
	313	break;
	314	}
	315	mutex_unlock(&wusbhc->mutex);
bce83697	316
90ff96f2 IPG	317	return result;
	318	}
	319
	320	/*
	321	* Return the port's status
	322	*
	323	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	324	*/
	325	static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx,
	326	u32 *_buf, u16 wLength)
	327	{
d767d888	328	__le16 buf = (__le16 )_buf;
90ff96f2	329
90ff96f2	330	if (port_idx > wusbhc->ports_max)
bce83697 DV	331	return -EINVAL;
bce83697 DV	332
90ff96f2 IPG	333	mutex_lock(&wusbhc->mutex);
	334	buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status);
	335	buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change);
90ff96f2	336	mutex_unlock(&wusbhc->mutex);
bce83697 DV	337
bce83697 DV	338	return 0;
90ff96f2 IPG	339	}
	340
	341	/*
	342	* Entry point for Root Hub operations
	343	*
	344	* @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
	345	*/
	346	int wusbhc_rh_control(struct usb_hcd *usb_hcd, u16 reqntype, u16 wValue,
	347	u16 wIndex, char *buf, u16 wLength)
	348	{
	349	int result = -ENOSYS;
	350	struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
	351
	352	switch (reqntype) {
	353	case GetHubDescriptor:
	354	result = wusbhc_rh_get_hub_descr(
	355	wusbhc, wValue, wIndex,
	356	(struct usb_hub_descriptor *) buf, wLength);
	357	break;
	358	case ClearHubFeature:
	359	result = wusbhc_rh_clear_hub_feat(wusbhc, wValue);
	360	break;
	361	case GetHubStatus:
	362	result = wusbhc_rh_get_hub_status(wusbhc, (u32 *)buf, wLength);
	363	break;
	364
	365	case SetPortFeature:
	366	result = wusbhc_rh_set_port_feat(wusbhc, wValue, wIndex >> 8,
	367	(wIndex & 0xff) - 1);
	368	break;
	369	case ClearPortFeature:
	370	result = wusbhc_rh_clear_port_feat(wusbhc, wValue, wIndex >> 8,
	371	(wIndex & 0xff) - 1);
	372	break;
	373	case GetPortStatus:
	374	result = wusbhc_rh_get_port_status(wusbhc, wIndex - 1,
	375	(u32 *)buf, wLength);
	376	break;
	377
	378	case SetHubFeature:
	379	default:
	380	dev_err(wusbhc->dev, "%s (%p [%p], %x, %x, %x, %p, %x) "
	381	"UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, reqntype,
	382	wValue, wIndex, buf, wLength);
	383	/* dump_stack(); */
	384	result = -ENOSYS;
	385	}
	386	return result;
	387	}
	388	EXPORT_SYMBOL_GPL(wusbhc_rh_control);
	389
90ff96f2 IPG	390	int wusbhc_rh_start_port_reset(struct usb_hcd *usb_hcd, unsigned port_idx)
	391	{
	392	struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
	393	dev_err(wusbhc->dev, "%s (%p [%p], port_idx %u) UNIMPLEMENTED\n",
	394	__func__, usb_hcd, wusbhc, port_idx);
	395	WARN_ON(1);
	396	return -ENOSYS;
	397	}
	398	EXPORT_SYMBOL_GPL(wusbhc_rh_start_port_reset);
	399
	400	static void wusb_port_init(struct wusb_port *port)
	401	{
	402	port->status \|= USB_PORT_STAT_HIGH_SPEED;
	403	}
	404
	405	/*
	406	* Alloc fake port specific fields and status.
	407	*/
	408	int wusbhc_rh_create(struct wusbhc *wusbhc)
	409	{
	410	int result = -ENOMEM;
	411	size_t port_size, itr;
	412	port_size = wusbhc->ports_max * sizeof(wusbhc->port[0]);
	413	wusbhc->port = kzalloc(port_size, GFP_KERNEL);
	414	if (wusbhc->port == NULL)
	415	goto error_port_alloc;
	416	for (itr = 0; itr < wusbhc->ports_max; itr++)
	417	wusb_port_init(&wusbhc->port[itr]);
	418	result = 0;
	419	error_port_alloc:
	420	return result;
	421	}
	422
	423	void wusbhc_rh_destroy(struct wusbhc *wusbhc)
	424	{
	425	kfree(wusbhc->port);
	426	}