[people/ms/u-boot.git] / common / usb_hub.c

/*
 * Most of this source has been derived from the Linux USB
 * project:
 * (C) Copyright Linus Torvalds 1999
 * (C) Copyright Johannes Erdfelt 1999-2001
 * (C) Copyright Andreas Gal 1999
 * (C) Copyright Gregory P. Smith 1999
 * (C) Copyright Deti Fliegl 1999 (new USB architecture)
 * (C) Copyright Randy Dunlap 2000
 * (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id)
 * (C) Copyright Yggdrasil Computing, Inc. 2000
 *     (usb_device_id matching changes by Adam J. Richter)
 *
 * Adapted for U-Boot:
 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

/****************************************************************************
 * HUB "Driver"
 * Probes device for being a hub and configurate it
 */

#include <common.h>
#include <command.h>
#include <asm/processor.h>
#include <asm/unaligned.h>
#include <linux/ctype.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>

#include <usb.h>
#ifdef CONFIG_4xx
#include <asm/4xx_pci.h>
#endif

#define USB_BUFSIZ	512

static struct usb_hub_device hub_dev[USB_MAX_HUB];
static int usb_hub_index;

__weak void usb_hub_reset_devices(int port)
{
	return;
}

static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
{
	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
		USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
		USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
}

static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
{
	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
				USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature,
				port, NULL, 0, USB_CNTL_TIMEOUT);
}

static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
{
	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
				USB_REQ_SET_FEATURE, USB_RT_PORT, feature,
				port, NULL, 0, USB_CNTL_TIMEOUT);
}

static int usb_get_hub_status(struct usb_device *dev, void *data)
{
	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
			data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
}

static int usb_get_port_status(struct usb_device *dev, int port, void *data)
{
	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
			data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
}


static void usb_hub_power_on(struct usb_hub_device *hub)
{
	int i;
	struct usb_device *dev;
	unsigned pgood_delay = hub->desc.bPwrOn2PwrGood * 2;
	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
	unsigned short portstatus;
	int ret;

	dev = hub->pusb_dev;

	/*
	 * Enable power to the ports:
	 * Here we Power-cycle the ports: aka,
	 * turning them off and turning on again.
	 */
	debug("enabling power on all ports\n");
	for (i = 0; i < dev->maxchild; i++) {
		usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
		debug("port %d returns %lX\n", i + 1, dev->status);
	}

	/* Wait at least 2*bPwrOn2PwrGood for PP to change */
	mdelay(pgood_delay);

	for (i = 0; i < dev->maxchild; i++) {
		ret = usb_get_port_status(dev, i + 1, portsts);
		if (ret < 0) {
			debug("port %d: get_port_status failed\n", i + 1);
			continue;
		}

		/*
		 * Check to confirm the state of Port Power:
		 * xHCI says "After modifying PP, s/w shall read
		 * PP and confirm that it has reached the desired state
		 * before modifying it again, undefined behavior may occur
		 * if this procedure is not followed".
		 * EHCI doesn't say anything like this, but no harm in keeping
		 * this.
		 */
		portstatus = le16_to_cpu(portsts->wPortStatus);
		if (portstatus & (USB_PORT_STAT_POWER << 1)) {
			debug("port %d: Port power change failed\n", i + 1);
			continue;
		}
	}

	for (i = 0; i < dev->maxchild; i++) {
		usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
		debug("port %d returns %lX\n", i + 1, dev->status);
	}

	/*
	 * Wait for power to become stable,
	 * plus spec-defined max time for device to connect
	 */
	mdelay(pgood_delay + 1000);
}

void usb_hub_reset(void)
{
	usb_hub_index = 0;
}

static struct usb_hub_device *usb_hub_allocate(void)
{
	if (usb_hub_index < USB_MAX_HUB)
		return &hub_dev[usb_hub_index++];

	printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB);
	return NULL;
}

#define MAX_TRIES 5

static inline char *portspeed(int portstatus)
{
	char *speed_str;

	switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
	case USB_PORT_STAT_SUPER_SPEED:
		speed_str = "5 Gb/s";
		break;
	case USB_PORT_STAT_HIGH_SPEED:
		speed_str = "480 Mb/s";
		break;
	case USB_PORT_STAT_LOW_SPEED:
		speed_str = "1.5 Mb/s";
		break;
	default:
		speed_str = "12 Mb/s";
		break;
	}

	return speed_str;
}

int hub_port_reset(struct usb_device *dev, int port,
			unsigned short *portstat)
{
	int tries;
	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
	unsigned short portstatus, portchange;

	debug("hub_port_reset: resetting port %d...\n", port);
	for (tries = 0; tries < MAX_TRIES; tries++) {

		usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
		mdelay(200);

		if (usb_get_port_status(dev, port + 1, portsts) < 0) {
			debug("get_port_status failed status %lX\n",
			      dev->status);
			return -1;
		}
		portstatus = le16_to_cpu(portsts->wPortStatus);
		portchange = le16_to_cpu(portsts->wPortChange);

		debug("portstatus %x, change %x, %s\n", portstatus, portchange,
							portspeed(portstatus));

		debug("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
		      "  USB_PORT_STAT_ENABLE %d\n",
		      (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
		      (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
		      (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);

		if ((portchange & USB_PORT_STAT_C_CONNECTION) ||
		    !(portstatus & USB_PORT_STAT_CONNECTION))
			return -1;

		if (portstatus & USB_PORT_STAT_ENABLE)
			break;

		mdelay(200);
	}

	if (tries == MAX_TRIES) {
		debug("Cannot enable port %i after %i retries, " \
		      "disabling port.\n", port + 1, MAX_TRIES);
		debug("Maybe the USB cable is bad?\n");
		return -1;
	}

	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
	*portstat = portstatus;
	return 0;
}


void usb_hub_port_connect_change(struct usb_device *dev, int port)
{
	struct usb_device *usb;
	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
	unsigned short portstatus;

	/* Check status */
	if (usb_get_port_status(dev, port + 1, portsts) < 0) {
		debug("get_port_status failed\n");
		return;
	}

	portstatus = le16_to_cpu(portsts->wPortStatus);
	debug("portstatus %x, change %x, %s\n",
	      portstatus,
	      le16_to_cpu(portsts->wPortChange),
	      portspeed(portstatus));

	/* Clear the connection change status */
	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);

	/* Disconnect any existing devices under this port */
	if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
	     (!(portstatus & USB_PORT_STAT_ENABLE))) || (dev->children[port])) {
		debug("usb_disconnect(&hub->children[port]);\n");
		/* Return now if nothing is connected */
		if (!(portstatus & USB_PORT_STAT_CONNECTION))
			return;
	}
	mdelay(200);

	/* Reset the port */
	if (hub_port_reset(dev, port, &portstatus) < 0) {
		printf("cannot reset port %i!?\n", port + 1);
		return;
	}

	mdelay(200);

	/* Allocate a new device struct for it */
	usb = usb_alloc_new_device(dev->controller);

	switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
	case USB_PORT_STAT_SUPER_SPEED:
		usb->speed = USB_SPEED_SUPER;
		break;
	case USB_PORT_STAT_HIGH_SPEED:
		usb->speed = USB_SPEED_HIGH;
		break;
	case USB_PORT_STAT_LOW_SPEED:
		usb->speed = USB_SPEED_LOW;
		break;
	default:
		usb->speed = USB_SPEED_FULL;
		break;
	}

	dev->children[port] = usb;
	usb->parent = dev;
	usb->portnr = port + 1;
	/* Run it through the hoops (find a driver, etc) */
	if (usb_new_device(usb)) {
		/* Woops, disable the port */
		usb_free_device();
		dev->children[port] = NULL;
		debug("hub: disabling port %d\n", port + 1);
		usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
	}
}


static int usb_hub_configure(struct usb_device *dev)
{
	int i, length;
	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, USB_BUFSIZ);
	unsigned char *bitmap;
	short hubCharacteristics;
	struct usb_hub_descriptor *descriptor;
	struct usb_hub_device *hub;
	__maybe_unused struct usb_hub_status *hubsts;

	/* "allocate" Hub device */
	hub = usb_hub_allocate();
	if (hub == NULL)
		return -1;
	hub->pusb_dev = dev;
	/* Get the the hub descriptor */
	if (usb_get_hub_descriptor(dev, buffer, 4) < 0) {
		debug("usb_hub_configure: failed to get hub " \
		      "descriptor, giving up %lX\n", dev->status);
		return -1;
	}
	descriptor = (struct usb_hub_descriptor *)buffer;

	length = min(descriptor->bLength, sizeof(struct usb_hub_descriptor));

	if (usb_get_hub_descriptor(dev, buffer, length) < 0) {
		debug("usb_hub_configure: failed to get hub " \
		      "descriptor 2nd giving up %lX\n", dev->status);
		return -1;
	}
	memcpy((unsigned char *)&hub->desc, buffer, length);
	/* adjust 16bit values */
	put_unaligned(le16_to_cpu(get_unaligned(
			&descriptor->wHubCharacteristics)),
			&hub->desc.wHubCharacteristics);
	/* set the bitmap */
	bitmap = (unsigned char *)&hub->desc.DeviceRemovable[0];
	/* devices not removable by default */
	memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8);
	bitmap = (unsigned char *)&hub->desc.PortPowerCtrlMask[0];
	memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */

	for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
		hub->desc.DeviceRemovable[i] = descriptor->DeviceRemovable[i];

	for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
		hub->desc.PortPowerCtrlMask[i] = descriptor->PortPowerCtrlMask[i];

	dev->maxchild = descriptor->bNbrPorts;
	debug("%d ports detected\n", dev->maxchild);

	hubCharacteristics = get_unaligned(&hub->desc.wHubCharacteristics);
	switch (hubCharacteristics & HUB_CHAR_LPSM) {
	case 0x00:
		debug("ganged power switching\n");
		break;
	case 0x01:
		debug("individual port power switching\n");
		break;
	case 0x02:
	case 0x03:
		debug("unknown reserved power switching mode\n");
		break;
	}

	if (hubCharacteristics & HUB_CHAR_COMPOUND)
		debug("part of a compound device\n");
	else
		debug("standalone hub\n");

	switch (hubCharacteristics & HUB_CHAR_OCPM) {
	case 0x00:
		debug("global over-current protection\n");
		break;
	case 0x08:
		debug("individual port over-current protection\n");
		break;
	case 0x10:
	case 0x18:
		debug("no over-current protection\n");
		break;
	}

	debug("power on to power good time: %dms\n",
	      descriptor->bPwrOn2PwrGood * 2);
	debug("hub controller current requirement: %dmA\n",
	      descriptor->bHubContrCurrent);

	for (i = 0; i < dev->maxchild; i++)
		debug("port %d is%s removable\n", i + 1,
		      hub->desc.DeviceRemovable[(i + 1) / 8] & \
		      (1 << ((i + 1) % 8)) ? " not" : "");

	if (sizeof(struct usb_hub_status) > USB_BUFSIZ) {
		debug("usb_hub_configure: failed to get Status - " \
		      "too long: %d\n", descriptor->bLength);
		return -1;
	}

	if (usb_get_hub_status(dev, buffer) < 0) {
		debug("usb_hub_configure: failed to get Status %lX\n",
		      dev->status);
		return -1;
	}

#ifdef DEBUG
	hubsts = (struct usb_hub_status *)buffer;
#endif

	debug("get_hub_status returned status %X, change %X\n",
	      le16_to_cpu(hubsts->wHubStatus),
	      le16_to_cpu(hubsts->wHubChange));
	debug("local power source is %s\n",
	      (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \
	      "lost (inactive)" : "good");
	debug("%sover-current condition exists\n",
	      (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \
	      "" : "no ");
	usb_hub_power_on(hub);

	/*
	 * Reset any devices that may be in a bad state when applying
	 * the power.  This is a __weak function.  Resetting of the devices
	 * should occur in the board file of the device.
	 */
	for (i = 0; i < dev->maxchild; i++)
		usb_hub_reset_devices(i + 1);

	for (i = 0; i < dev->maxchild; i++) {
		ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
		unsigned short portstatus, portchange;
		int ret;
		ulong start = get_timer(0);

		/*
		 * Wait for (whichever finishes first)
		 *  - A maximum of 10 seconds
		 *    This is a purely observational value driven by connecting
		 *    a few broken pen drives and taking the max * 1.5 approach
		 *  - connection_change and connection state to report same
		 *    state
		 */
		do {
			ret = usb_get_port_status(dev, i + 1, portsts);
			if (ret < 0) {
				debug("get_port_status failed\n");
				break;
			}

			portstatus = le16_to_cpu(portsts->wPortStatus);
			portchange = le16_to_cpu(portsts->wPortChange);

			if ((portchange & USB_PORT_STAT_C_CONNECTION) ==
				(portstatus & USB_PORT_STAT_CONNECTION))
				break;

		} while (get_timer(start) < CONFIG_SYS_HZ * 10);

		if (ret < 0)
			continue;

		debug("Port %d Status %X Change %X\n",
		      i + 1, portstatus, portchange);

		if (portchange & USB_PORT_STAT_C_CONNECTION) {
			debug("port %d connection change\n", i + 1);
			usb_hub_port_connect_change(dev, i);
		}
		if (portchange & USB_PORT_STAT_C_ENABLE) {
			debug("port %d enable change, status %x\n",
			      i + 1, portstatus);
			usb_clear_port_feature(dev, i + 1,
						USB_PORT_FEAT_C_ENABLE);
			/*
			 * The following hack causes a ghost device problem
			 * to Faraday EHCI
			 */
#ifndef CONFIG_USB_EHCI_FARADAY
			/* EM interference sometimes causes bad shielded USB
			 * devices to be shutdown by the hub, this hack enables
			 * them again. Works at least with mouse driver */
			if (!(portstatus & USB_PORT_STAT_ENABLE) &&
			     (portstatus & USB_PORT_STAT_CONNECTION) &&
			     ((dev->children[i]))) {
				debug("already running port %i "  \
				      "disabled by hub (EMI?), " \
				      "re-enabling...\n", i + 1);
				      usb_hub_port_connect_change(dev, i);
			}
#endif
		}
		if (portstatus & USB_PORT_STAT_SUSPEND) {
			debug("port %d suspend change\n", i + 1);
			usb_clear_port_feature(dev, i + 1,
						USB_PORT_FEAT_SUSPEND);
		}

		if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
			debug("port %d over-current change\n", i + 1);
			usb_clear_port_feature(dev, i + 1,
						USB_PORT_FEAT_C_OVER_CURRENT);
			usb_hub_power_on(hub);
		}

		if (portchange & USB_PORT_STAT_C_RESET) {
			debug("port %d reset change\n", i + 1);
			usb_clear_port_feature(dev, i + 1,
						USB_PORT_FEAT_C_RESET);
		}
	} /* end for i all ports */

	return 0;
}

int usb_hub_probe(struct usb_device *dev, int ifnum)
{
	struct usb_interface *iface;
	struct usb_endpoint_descriptor *ep;
	int ret;

	iface = &dev->config.if_desc[ifnum];
	/* Is it a hub? */
	if (iface->desc.bInterfaceClass != USB_CLASS_HUB)
		return 0;
	/* Some hubs have a subclass of 1, which AFAICT according to the */
	/*  specs is not defined, but it works */
	if ((iface->desc.bInterfaceSubClass != 0) &&
	    (iface->desc.bInterfaceSubClass != 1))
		return 0;
	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
	if (iface->desc.bNumEndpoints != 1)
		return 0;
	ep = &iface->ep_desc[0];
	/* Output endpoint? Curiousier and curiousier.. */
	if (!(ep->bEndpointAddress & USB_DIR_IN))
		return 0;
	/* If it's not an interrupt endpoint, we'd better punt! */
	if ((ep->bmAttributes & 3) != 3)
		return 0;
	/* We found a hub */
	debug("USB hub found\n");
	ret = usb_hub_configure(dev);
	return ret;
}
Commit	Line	Data
23faf2bc	1	/*
23faf2bc MV	2	* Most of this source has been derived from the Linux USB
	3	* project:
	4	* (C) Copyright Linus Torvalds 1999
	5	* (C) Copyright Johannes Erdfelt 1999-2001
	6	* (C) Copyright Andreas Gal 1999
	7	* (C) Copyright Gregory P. Smith 1999
	8	* (C) Copyright Deti Fliegl 1999 (new USB architecture)
	9	* (C) Copyright Randy Dunlap 2000
	10	* (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id)
	11	* (C) Copyright Yggdrasil Computing, Inc. 2000
	12	* (usb_device_id matching changes by Adam J. Richter)
	13	*
	14	* Adapted for U-Boot:
	15	* (C) Copyright 2001 Denis Peter, MPL AG Switzerland
	16	*
1a459660	17	* SPDX-License-Identifier: GPL-2.0+
23faf2bc MV	18	*/
	19
	20	/****************************************************************************
	21	* HUB "Driver"
	22	* Probes device for being a hub and configurate it
	23	*/
	24
	25	#include <common.h>
	26	#include <command.h>
	27	#include <asm/processor.h>
93ad908c	28	#include <asm/unaligned.h>
23faf2bc MV	29	#include <linux/ctype.h>
	30	#include <asm/byteorder.h>
	31	#include <asm/unaligned.h>
	32
	33	#include <usb.h>
	34	#ifdef CONFIG_4xx
	35	#include <asm/4xx_pci.h>
	36	#endif
	37
23faf2bc MV	38	#define USB_BUFSIZ 512
	39
	40	static struct usb_hub_device hub_dev[USB_MAX_HUB];
	41	static int usb_hub_index;
	42
3615a996 DM	43	__weak void usb_hub_reset_devices(int port)
	44	{
	45	return;
	46	}
23faf2bc MV	47
	48	static int usb_get_hub_descriptor(struct usb_device dev, void data, int size)
	49	{
	50	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	51	USB_REQ_GET_DESCRIPTOR, USB_DIR_IN \| USB_RT_HUB,
	52	USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
	53	}
	54
	55	static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
	56	{
	57	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	58	USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature,
	59	port, NULL, 0, USB_CNTL_TIMEOUT);
	60	}
	61
	62	static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
	63	{
	64	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	65	USB_REQ_SET_FEATURE, USB_RT_PORT, feature,
	66	port, NULL, 0, USB_CNTL_TIMEOUT);
	67	}
	68
	69	static int usb_get_hub_status(struct usb_device dev, void data)
	70	{
	71	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	72	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_HUB, 0, 0,
	73	data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
	74	}
	75
	76	static int usb_get_port_status(struct usb_device dev, int port, void data)
	77	{
	78	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	79	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_PORT, 0, port,
	80	data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
	81	}
	82
	83
	84	static void usb_hub_power_on(struct usb_hub_device *hub)
	85	{
	86	int i;
	87	struct usb_device *dev;
a1a28c6e	88	unsigned pgood_delay = hub->desc.bPwrOn2PwrGood * 2;
020bbcb7 VG	89	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
	90	unsigned short portstatus;
	91	int ret;
23faf2bc MV	92
23faf2bc MV	93	dev = hub->pusb_dev;
0bf796f7 VG	94
	95	/*
	96	* Enable power to the ports:
	97	* Here we Power-cycle the ports: aka,
	98	* turning them off and turning on again.
	99	*/
ceb4972a	100	debug("enabling power on all ports\n");
23faf2bc	101	for (i = 0; i < dev->maxchild; i++) {
020bbcb7 VG	102	usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
020bbcb7 VG	103	debug("port %d returns %lX\n", i + 1, dev->status);
0bf796f7	104	}
020bbcb7	105
0bf796f7 VG	106	/* Wait at least 2bPwrOn2PwrGood for PP to change /
0bf796f7 VG	107	mdelay(pgood_delay);
020bbcb7	108
0bf796f7	109	for (i = 0; i < dev->maxchild; i++) {
020bbcb7 VG	110	ret = usb_get_port_status(dev, i + 1, portsts);
	111	if (ret < 0) {
	112	debug("port %d: get_port_status failed\n", i + 1);
0adc331b	113	continue;
020bbcb7 VG	114	}
	115
	116	/*
	117	* Check to confirm the state of Port Power:
	118	* xHCI says "After modifying PP, s/w shall read
	119	* PP and confirm that it has reached the desired state
	120	* before modifying it again, undefined behavior may occur
	121	* if this procedure is not followed".
	122	* EHCI doesn't say anything like this, but no harm in keeping
	123	* this.
	124	*/
	125	portstatus = le16_to_cpu(portsts->wPortStatus);
	126	if (portstatus & (USB_PORT_STAT_POWER << 1)) {
	127	debug("port %d: Port power change failed\n", i + 1);
0adc331b	128	continue;
020bbcb7	129	}
0bf796f7	130	}
020bbcb7	131
0bf796f7	132	for (i = 0; i < dev->maxchild; i++) {
23faf2bc	133	usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
ceb4972a	134	debug("port %d returns %lX\n", i + 1, dev->status);
23faf2bc	135	}
a1a28c6e	136
0d437bca SW	137	/*
	138	* Wait for power to become stable,
	139	* plus spec-defined max time for device to connect
	140	*/
77b83e6d	141	mdelay(pgood_delay + 1000);
23faf2bc MV	142	}
	143
	144	void usb_hub_reset(void)
	145	{
	146	usb_hub_index = 0;
	147	}
	148
	149	static struct usb_hub_device *usb_hub_allocate(void)
	150	{
	151	if (usb_hub_index < USB_MAX_HUB)
	152	return &hub_dev[usb_hub_index++];
	153
	154	printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB);
	155	return NULL;
	156	}
	157
	158	#define MAX_TRIES 5
	159
	160	static inline char *portspeed(int portstatus)
	161	{
55f4b575 VG	162	char *speed_str;
	163
	164	switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
	165	case USB_PORT_STAT_SUPER_SPEED:
	166	speed_str = "5 Gb/s";
	167	break;
	168	case USB_PORT_STAT_HIGH_SPEED:
	169	speed_str = "480 Mb/s";
	170	break;
	171	case USB_PORT_STAT_LOW_SPEED:
	172	speed_str = "1.5 Mb/s";
	173	break;
	174	default:
	175	speed_str = "12 Mb/s";
	176	break;
	177	}
	178
	179	return speed_str;
23faf2bc MV	180	}
	181
	182	int hub_port_reset(struct usb_device *dev, int port,
	183	unsigned short *portstat)
	184	{
	185	int tries;
f5766139	186	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
23faf2bc MV	187	unsigned short portstatus, portchange;
23faf2bc MV	188
ceb4972a	189	debug("hub_port_reset: resetting port %d...\n", port);
23faf2bc MV	190	for (tries = 0; tries < MAX_TRIES; tries++) {
	191
	192	usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
5b84dd67	193	mdelay(200);
23faf2bc	194
f5766139	195	if (usb_get_port_status(dev, port + 1, portsts) < 0) {
ceb4972a VG	196	debug("get_port_status failed status %lX\n",
ceb4972a VG	197	dev->status);
23faf2bc MV	198	return -1;
23faf2bc MV	199	}
f5766139 PS	200	portstatus = le16_to_cpu(portsts->wPortStatus);
f5766139 PS	201	portchange = le16_to_cpu(portsts->wPortChange);
23faf2bc	202
ceb4972a VG	203	debug("portstatus %x, change %x, %s\n", portstatus, portchange,
ceb4972a VG	204	portspeed(portstatus));
23faf2bc	205
ceb4972a VG	206	debug("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
	207	" USB_PORT_STAT_ENABLE %d\n",
	208	(portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
	209	(portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
	210	(portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);
23faf2bc MV	211
	212	if ((portchange & USB_PORT_STAT_C_CONNECTION) \|\|
	213	!(portstatus & USB_PORT_STAT_CONNECTION))
	214	return -1;
	215
	216	if (portstatus & USB_PORT_STAT_ENABLE)
	217	break;
	218
5b84dd67	219	mdelay(200);
23faf2bc MV	220	}
	221
	222	if (tries == MAX_TRIES) {
ceb4972a VG	223	debug("Cannot enable port %i after %i retries, " \
	224	"disabling port.\n", port + 1, MAX_TRIES);
	225	debug("Maybe the USB cable is bad?\n");
23faf2bc MV	226	return -1;
	227	}
	228
	229	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
	230	*portstat = portstatus;
	231	return 0;
	232	}
	233
	234
	235	void usb_hub_port_connect_change(struct usb_device *dev, int port)
	236	{
	237	struct usb_device *usb;
f5766139	238	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
23faf2bc MV	239	unsigned short portstatus;
	240
	241	/* Check status */
f5766139	242	if (usb_get_port_status(dev, port + 1, portsts) < 0) {
ceb4972a	243	debug("get_port_status failed\n");
23faf2bc MV	244	return;
	245	}
	246
f5766139	247	portstatus = le16_to_cpu(portsts->wPortStatus);
ceb4972a VG	248	debug("portstatus %x, change %x, %s\n",
	249	portstatus,
	250	le16_to_cpu(portsts->wPortChange),
	251	portspeed(portstatus));
23faf2bc MV	252
	253	/* Clear the connection change status */
	254	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);
	255
	256	/* Disconnect any existing devices under this port */
	257	if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
	258	(!(portstatus & USB_PORT_STAT_ENABLE))) \|\| (dev->children[port])) {
ceb4972a	259	debug("usb_disconnect(&hub->children[port]);\n");
23faf2bc MV	260	/* Return now if nothing is connected */
	261	if (!(portstatus & USB_PORT_STAT_CONNECTION))
	262	return;
	263	}
5b84dd67	264	mdelay(200);
23faf2bc MV	265
	266	/* Reset the port */
	267	if (hub_port_reset(dev, port, &portstatus) < 0) {
	268	printf("cannot reset port %i!?\n", port + 1);
	269	return;
	270	}
	271
5b84dd67	272	mdelay(200);
23faf2bc MV	273
23faf2bc MV	274	/* Allocate a new device struct for it */
c7e3b2b5	275	usb = usb_alloc_new_device(dev->controller);
23faf2bc	276
55f4b575 VG	277	switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
55f4b575 VG	278	case USB_PORT_STAT_SUPER_SPEED:
6497c667	279	usb->speed = USB_SPEED_SUPER;
55f4b575 VG	280	break;
55f4b575 VG	281	case USB_PORT_STAT_HIGH_SPEED:
23faf2bc	282	usb->speed = USB_SPEED_HIGH;
55f4b575 VG	283	break;
55f4b575 VG	284	case USB_PORT_STAT_LOW_SPEED:
23faf2bc	285	usb->speed = USB_SPEED_LOW;
55f4b575 VG	286	break;
55f4b575 VG	287	default:
23faf2bc	288	usb->speed = USB_SPEED_FULL;
55f4b575 VG	289	break;
55f4b575 VG	290	}
23faf2bc MV	291
	292	dev->children[port] = usb;
	293	usb->parent = dev;
	294	usb->portnr = port + 1;
	295	/* Run it through the hoops (find a driver, etc) */
	296	if (usb_new_device(usb)) {
	297	/* Woops, disable the port */
359439d2 MC	298	usb_free_device();
359439d2 MC	299	dev->children[port] = NULL;
ceb4972a	300	debug("hub: disabling port %d\n", port + 1);
23faf2bc MV	301	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
	302	}
	303	}
	304
	305
	306	static int usb_hub_configure(struct usb_device *dev)
	307	{
eaf3e613	308	int i, length;
f5766139 PS	309	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, USB_BUFSIZ);
f5766139 PS	310	unsigned char *bitmap;
93ad908c	311	short hubCharacteristics;
23faf2bc MV	312	struct usb_hub_descriptor *descriptor;
23faf2bc MV	313	struct usb_hub_device *hub;
ceb4972a	314	__maybe_unused struct usb_hub_status *hubsts;
23faf2bc MV	315
	316	/* "allocate" Hub device */
	317	hub = usb_hub_allocate();
	318	if (hub == NULL)
	319	return -1;
	320	hub->pusb_dev = dev;
	321	/* Get the the hub descriptor */
	322	if (usb_get_hub_descriptor(dev, buffer, 4) < 0) {
ceb4972a VG	323	debug("usb_hub_configure: failed to get hub " \
ceb4972a VG	324	"descriptor, giving up %lX\n", dev->status);
23faf2bc MV	325	return -1;
	326	}
	327	descriptor = (struct usb_hub_descriptor *)buffer;
	328
eaf3e613	329	length = min(descriptor->bLength, sizeof(struct usb_hub_descriptor));
23faf2bc	330
eaf3e613	331	if (usb_get_hub_descriptor(dev, buffer, length) < 0) {
ceb4972a VG	332	debug("usb_hub_configure: failed to get hub " \
ceb4972a VG	333	"descriptor 2nd giving up %lX\n", dev->status);
23faf2bc MV	334	return -1;
23faf2bc MV	335	}
eaf3e613	336	memcpy((unsigned char *)&hub->desc, buffer, length);
23faf2bc	337	/* adjust 16bit values */
93ad908c LS	338	put_unaligned(le16_to_cpu(get_unaligned(
	339	&descriptor->wHubCharacteristics)),
	340	&hub->desc.wHubCharacteristics);
23faf2bc MV	341	/* set the bitmap */
	342	bitmap = (unsigned char *)&hub->desc.DeviceRemovable[0];
	343	/* devices not removable by default */
	344	memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8);
	345	bitmap = (unsigned char *)&hub->desc.PortPowerCtrlMask[0];
	346	memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */
	347
	348	for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
	349	hub->desc.DeviceRemovable[i] = descriptor->DeviceRemovable[i];
	350
	351	for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
	352	hub->desc.PortPowerCtrlMask[i] = descriptor->PortPowerCtrlMask[i];
	353
	354	dev->maxchild = descriptor->bNbrPorts;
ceb4972a	355	debug("%d ports detected\n", dev->maxchild);
23faf2bc	356
93ad908c LS	357	hubCharacteristics = get_unaligned(&hub->desc.wHubCharacteristics);
93ad908c LS	358	switch (hubCharacteristics & HUB_CHAR_LPSM) {
23faf2bc	359	case 0x00:
ceb4972a	360	debug("ganged power switching\n");
23faf2bc MV	361	break;
23faf2bc MV	362	case 0x01:
ceb4972a	363	debug("individual port power switching\n");
23faf2bc MV	364	break;
	365	case 0x02:
	366	case 0x03:
ceb4972a	367	debug("unknown reserved power switching mode\n");
23faf2bc MV	368	break;
	369	}
	370
93ad908c	371	if (hubCharacteristics & HUB_CHAR_COMPOUND)
ceb4972a	372	debug("part of a compound device\n");
23faf2bc	373	else
ceb4972a	374	debug("standalone hub\n");
23faf2bc	375
93ad908c	376	switch (hubCharacteristics & HUB_CHAR_OCPM) {
23faf2bc	377	case 0x00:
ceb4972a	378	debug("global over-current protection\n");
23faf2bc MV	379	break;
23faf2bc MV	380	case 0x08:
ceb4972a	381	debug("individual port over-current protection\n");
23faf2bc MV	382	break;
	383	case 0x10:
	384	case 0x18:
ceb4972a	385	debug("no over-current protection\n");
23faf2bc MV	386	break;
	387	}
	388
ceb4972a VG	389	debug("power on to power good time: %dms\n",
	390	descriptor->bPwrOn2PwrGood * 2);
	391	debug("hub controller current requirement: %dmA\n",
	392	descriptor->bHubContrCurrent);
23faf2bc MV	393
23faf2bc MV	394	for (i = 0; i < dev->maxchild; i++)
ceb4972a VG	395	debug("port %d is%s removable\n", i + 1,
	396	hub->desc.DeviceRemovable[(i + 1) / 8] & \
	397	(1 << ((i + 1) % 8)) ? " not" : "");
23faf2bc MV	398
23faf2bc MV	399	if (sizeof(struct usb_hub_status) > USB_BUFSIZ) {
ceb4972a VG	400	debug("usb_hub_configure: failed to get Status - " \
ceb4972a VG	401	"too long: %d\n", descriptor->bLength);
23faf2bc MV	402	return -1;
	403	}
	404
	405	if (usb_get_hub_status(dev, buffer) < 0) {
ceb4972a VG	406	debug("usb_hub_configure: failed to get Status %lX\n",
ceb4972a VG	407	dev->status);
23faf2bc MV	408	return -1;
	409	}
	410
ceb4972a	411	#ifdef DEBUG
23faf2bc MV	412	hubsts = (struct usb_hub_status *)buffer;
23faf2bc MV	413	#endif
ceb4972a VG	414
	415	debug("get_hub_status returned status %X, change %X\n",
	416	le16_to_cpu(hubsts->wHubStatus),
	417	le16_to_cpu(hubsts->wHubChange));
	418	debug("local power source is %s\n",
	419	(le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \
	420	"lost (inactive)" : "good");
	421	debug("%sover-current condition exists\n",
	422	(le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \
	423	"" : "no ");
23faf2bc MV	424	usb_hub_power_on(hub);
23faf2bc MV	425
3615a996 DM	426	/*
	427	* Reset any devices that may be in a bad state when applying
	428	* the power. This is a __weak function. Resetting of the devices
	429	* should occur in the board file of the device.
	430	*/
	431	for (i = 0; i < dev->maxchild; i++)
	432	usb_hub_reset_devices(i + 1);
	433
23faf2bc	434	for (i = 0; i < dev->maxchild; i++) {
f5766139	435	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
23faf2bc	436	unsigned short portstatus, portchange;
b6d7852c VK	437	int ret;
	438	ulong start = get_timer(0);
	439
	440	/*
	441	* Wait for (whichever finishes first)
	442	* - A maximum of 10 seconds
	443	* This is a purely observational value driven by connecting
	444	* a few broken pen drives and taking the max * 1.5 approach
	445	* - connection_change and connection state to report same
	446	* state
	447	*/
	448	do {
	449	ret = usb_get_port_status(dev, i + 1, portsts);
	450	if (ret < 0) {
ceb4972a	451	debug("get_port_status failed\n");
b6d7852c VK	452	break;
	453	}
	454
	455	portstatus = le16_to_cpu(portsts->wPortStatus);
	456	portchange = le16_to_cpu(portsts->wPortChange);
	457
	458	if ((portchange & USB_PORT_STAT_C_CONNECTION) ==
	459	(portstatus & USB_PORT_STAT_CONNECTION))
	460	break;
	461
b6d7852c VK	462	} while (get_timer(start) < CONFIG_SYS_HZ * 10);
	463
	464	if (ret < 0)
23faf2bc	465	continue;
23faf2bc	466
ceb4972a VG	467	debug("Port %d Status %X Change %X\n",
ceb4972a VG	468	i + 1, portstatus, portchange);
23faf2bc MV	469
23faf2bc MV	470	if (portchange & USB_PORT_STAT_C_CONNECTION) {
ceb4972a	471	debug("port %d connection change\n", i + 1);
23faf2bc MV	472	usb_hub_port_connect_change(dev, i);
	473	}
	474	if (portchange & USB_PORT_STAT_C_ENABLE) {
ceb4972a VG	475	debug("port %d enable change, status %x\n",
ceb4972a VG	476	i + 1, portstatus);
23faf2bc MV	477	usb_clear_port_feature(dev, i + 1,
23faf2bc MV	478	USB_PORT_FEAT_C_ENABLE);
e82a316d KJS	479	/*
	480	* The following hack causes a ghost device problem
	481	* to Faraday EHCI
	482	*/
	483	#ifndef CONFIG_USB_EHCI_FARADAY
23faf2bc MV	484	/* EM interference sometimes causes bad shielded USB
	485	* devices to be shutdown by the hub, this hack enables
	486	* them again. Works at least with mouse driver */
	487	if (!(portstatus & USB_PORT_STAT_ENABLE) &&
	488	(portstatus & USB_PORT_STAT_CONNECTION) &&
	489	((dev->children[i]))) {
ceb4972a VG	490	debug("already running port %i " \
	491	"disabled by hub (EMI?), " \
	492	"re-enabling...\n", i + 1);
	493	usb_hub_port_connect_change(dev, i);
23faf2bc	494	}
e82a316d	495	#endif
23faf2bc MV	496	}
23faf2bc MV	497	if (portstatus & USB_PORT_STAT_SUSPEND) {
ceb4972a	498	debug("port %d suspend change\n", i + 1);
23faf2bc MV	499	usb_clear_port_feature(dev, i + 1,
	500	USB_PORT_FEAT_SUSPEND);
	501	}
	502
	503	if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
ceb4972a	504	debug("port %d over-current change\n", i + 1);
23faf2bc MV	505	usb_clear_port_feature(dev, i + 1,
	506	USB_PORT_FEAT_C_OVER_CURRENT);
	507	usb_hub_power_on(hub);
	508	}
	509
	510	if (portchange & USB_PORT_STAT_C_RESET) {
ceb4972a	511	debug("port %d reset change\n", i + 1);
23faf2bc MV	512	usb_clear_port_feature(dev, i + 1,
	513	USB_PORT_FEAT_C_RESET);
	514	}
	515	} /* end for i all ports */
	516
	517	return 0;
	518	}
	519
	520	int usb_hub_probe(struct usb_device *dev, int ifnum)
	521	{
	522	struct usb_interface *iface;
	523	struct usb_endpoint_descriptor *ep;
	524	int ret;
	525
	526	iface = &dev->config.if_desc[ifnum];
	527	/* Is it a hub? */
	528	if (iface->desc.bInterfaceClass != USB_CLASS_HUB)
	529	return 0;
	530	/* Some hubs have a subclass of 1, which AFAICT according to the */
	531	/* specs is not defined, but it works */
	532	if ((iface->desc.bInterfaceSubClass != 0) &&
	533	(iface->desc.bInterfaceSubClass != 1))
	534	return 0;
	535	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
	536	if (iface->desc.bNumEndpoints != 1)
	537	return 0;
	538	ep = &iface->ep_desc[0];
	539	/* Output endpoint? Curiousier and curiousier.. */
	540	if (!(ep->bEndpointAddress & USB_DIR_IN))
	541	return 0;
	542	/* If it's not an interrupt endpoint, we'd better punt! */
	543	if ((ep->bmAttributes & 3) != 3)
	544	return 0;
	545	/* We found a hub */
ceb4972a	546	debug("USB hub found\n");
23faf2bc MV	547	ret = usb_hub_configure(dev);
	548	return ret;
	549	}