[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

#ifndef CONFIG_USB_HUB_MIN_POWER_ON_DELAY
#define CONFIG_USB_HUB_MIN_POWER_ON_DELAY	100
#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 */
	mdelay(max(pgood_delay, CONFIG_USB_HUB_MIN_POWER_ON_DELAY));
}

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