[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
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 *
 */

/****************************************************************************
 * 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;


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);
			return;
		}

		/*
		 * 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);
			return;
		}
	}

	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 at least 100 msec for power to become stable */
	mdelay(max(pgood_delay, (unsigned)100));
}

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)
{
	if (portstatus & (1 << USB_PORT_FEAT_SUPERSPEED))
		return "5 Gb/s";
	else if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
		return "480 Mb/s";
	else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
		return "1.5 Mb/s";
	else
		return "12 Mb/s";
}

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);

	if (portstatus & USB_PORT_STAT_SUPER_SPEED)
		usb->speed = USB_SPEED_SUPER;
	else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
		usb->speed = USB_SPEED_HIGH;
	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
		usb->speed = USB_SPEED_LOW;
	else
		usb->speed = USB_SPEED_FULL;

	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;
	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;

	/* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
	i = descriptor->bLength;
	if (i > USB_BUFSIZ) {
		debug("usb_hub_configure: failed to get hub " \
		      "descriptor - too long: %d\n", descriptor->bLength);
		return -1;
	}

	if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 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, descriptor->bLength);
	/* 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);

	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);

			/* 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);
			}
		}
		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 MV	1	/*
	2	*
	3	* Most of this source has been derived from the Linux USB
	4	* project:
	5	* (C) Copyright Linus Torvalds 1999
	6	* (C) Copyright Johannes Erdfelt 1999-2001
	7	* (C) Copyright Andreas Gal 1999
	8	* (C) Copyright Gregory P. Smith 1999
	9	* (C) Copyright Deti Fliegl 1999 (new USB architecture)
	10	* (C) Copyright Randy Dunlap 2000
	11	* (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id)
	12	* (C) Copyright Yggdrasil Computing, Inc. 2000
	13	* (usb_device_id matching changes by Adam J. Richter)
	14	*
	15	* Adapted for U-Boot:
	16	* (C) Copyright 2001 Denis Peter, MPL AG Switzerland
	17	*
	18	* See file CREDITS for list of people who contributed to this
	19	* project.
	20	*
	21	* This program is free software; you can redistribute it and/or
	22	* modify it under the terms of the GNU General Public License as
	23	* published by the Free Software Foundation; either version 2 of
	24	* the License, or (at your option) any later version.
	25	*
	26	* This program is distributed in the hope that it will be useful,
	27	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	28	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	29	* GNU General Public License for more details.
	30	*
	31	* You should have received a copy of the GNU General Public License
	32	* along with this program; if not, write to the Free Software
	33	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	34	* MA 02111-1307 USA
	35	*
	36	*/
	37
	38	/****************************************************************************
	39	* HUB "Driver"
	40	* Probes device for being a hub and configurate it
	41	*/
	42
	43	#include <common.h>
	44	#include <command.h>
	45	#include <asm/processor.h>
93ad908c	46	#include <asm/unaligned.h>
23faf2bc MV	47	#include <linux/ctype.h>
	48	#include <asm/byteorder.h>
	49	#include <asm/unaligned.h>
	50
	51	#include <usb.h>
	52	#ifdef CONFIG_4xx
	53	#include <asm/4xx_pci.h>
	54	#endif
	55
23faf2bc MV	56	#define USB_BUFSIZ 512
	57
	58	static struct usb_hub_device hub_dev[USB_MAX_HUB];
	59	static int usb_hub_index;
	60
	61
	62	static int usb_get_hub_descriptor(struct usb_device dev, void data, int size)
	63	{
	64	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	65	USB_REQ_GET_DESCRIPTOR, USB_DIR_IN \| USB_RT_HUB,
	66	USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
	67	}
	68
	69	static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
	70	{
	71	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	72	USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature,
	73	port, NULL, 0, USB_CNTL_TIMEOUT);
	74	}
	75
	76	static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
	77	{
	78	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	79	USB_REQ_SET_FEATURE, USB_RT_PORT, feature,
	80	port, NULL, 0, USB_CNTL_TIMEOUT);
	81	}
	82
	83	static int usb_get_hub_status(struct usb_device dev, void data)
	84	{
	85	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	86	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_HUB, 0, 0,
	87	data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
	88	}
	89
	90	static int usb_get_port_status(struct usb_device dev, int port, void data)
	91	{
	92	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
	93	USB_REQ_GET_STATUS, USB_DIR_IN \| USB_RT_PORT, 0, port,
	94	data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
	95	}
	96
	97
	98	static void usb_hub_power_on(struct usb_hub_device *hub)
	99	{
	100	int i;
	101	struct usb_device *dev;
a1a28c6e	102	unsigned pgood_delay = hub->desc.bPwrOn2PwrGood * 2;
020bbcb7 VG	103	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
	104	unsigned short portstatus;
	105	int ret;
23faf2bc MV	106
23faf2bc MV	107	dev = hub->pusb_dev;
0bf796f7 VG	108
	109	/*
	110	* Enable power to the ports:
	111	* Here we Power-cycle the ports: aka,
	112	* turning them off and turning on again.
	113	*/
ceb4972a	114	debug("enabling power on all ports\n");
23faf2bc	115	for (i = 0; i < dev->maxchild; i++) {
020bbcb7 VG	116	usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
020bbcb7 VG	117	debug("port %d returns %lX\n", i + 1, dev->status);
0bf796f7	118	}
020bbcb7	119
0bf796f7 VG	120	/* Wait at least 2bPwrOn2PwrGood for PP to change /
0bf796f7 VG	121	mdelay(pgood_delay);
020bbcb7	122
0bf796f7	123	for (i = 0; i < dev->maxchild; i++) {
020bbcb7 VG	124	ret = usb_get_port_status(dev, i + 1, portsts);
	125	if (ret < 0) {
	126	debug("port %d: get_port_status failed\n", i + 1);
	127	return;
	128	}
	129
	130	/*
	131	* Check to confirm the state of Port Power:
	132	* xHCI says "After modifying PP, s/w shall read
	133	* PP and confirm that it has reached the desired state
	134	* before modifying it again, undefined behavior may occur
	135	* if this procedure is not followed".
	136	* EHCI doesn't say anything like this, but no harm in keeping
	137	* this.
	138	*/
	139	portstatus = le16_to_cpu(portsts->wPortStatus);
	140	if (portstatus & (USB_PORT_STAT_POWER << 1)) {
	141	debug("port %d: Port power change failed\n", i + 1);
	142	return;
	143	}
0bf796f7	144	}
020bbcb7	145
0bf796f7	146	for (i = 0; i < dev->maxchild; i++) {
23faf2bc	147	usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
ceb4972a	148	debug("port %d returns %lX\n", i + 1, dev->status);
23faf2bc	149	}
a1a28c6e WG	150
a1a28c6e WG	151	/* Wait at least 100 msec for power to become stable */
5b84dd67	152	mdelay(max(pgood_delay, (unsigned)100));
23faf2bc MV	153	}
	154
	155	void usb_hub_reset(void)
	156	{
	157	usb_hub_index = 0;
	158	}
	159
	160	static struct usb_hub_device *usb_hub_allocate(void)
	161	{
	162	if (usb_hub_index < USB_MAX_HUB)
	163	return &hub_dev[usb_hub_index++];
	164
	165	printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB);
	166	return NULL;
	167	}
	168
	169	#define MAX_TRIES 5
	170
	171	static inline char *portspeed(int portstatus)
	172	{
6497c667 VG	173	if (portstatus & (1 << USB_PORT_FEAT_SUPERSPEED))
	174	return "5 Gb/s";
	175	else if (portstatus & (1 << USB_PORT_FEAT_HIGHSPEED))
23faf2bc MV	176	return "480 Mb/s";
	177	else if (portstatus & (1 << USB_PORT_FEAT_LOWSPEED))
	178	return "1.5 Mb/s";
	179	else
	180	return "12 Mb/s";
	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
6497c667 VG	278	if (portstatus & USB_PORT_STAT_SUPER_SPEED)
	279	usb->speed = USB_SPEED_SUPER;
	280	else if (portstatus & USB_PORT_STAT_HIGH_SPEED)
23faf2bc MV	281	usb->speed = USB_SPEED_HIGH;
	282	else if (portstatus & USB_PORT_STAT_LOW_SPEED)
	283	usb->speed = USB_SPEED_LOW;
	284	else
	285	usb->speed = USB_SPEED_FULL;
	286
	287	dev->children[port] = usb;
	288	usb->parent = dev;
	289	usb->portnr = port + 1;
	290	/* Run it through the hoops (find a driver, etc) */
	291	if (usb_new_device(usb)) {
	292	/* Woops, disable the port */
359439d2 MC	293	usb_free_device();
359439d2 MC	294	dev->children[port] = NULL;
ceb4972a	295	debug("hub: disabling port %d\n", port + 1);
23faf2bc MV	296	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
	297	}
	298	}
	299
	300
	301	static int usb_hub_configure(struct usb_device *dev)
	302	{
	303	int i;
f5766139 PS	304	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, USB_BUFSIZ);
f5766139 PS	305	unsigned char *bitmap;
93ad908c	306	short hubCharacteristics;
23faf2bc MV	307	struct usb_hub_descriptor *descriptor;
23faf2bc MV	308	struct usb_hub_device *hub;
ceb4972a	309	__maybe_unused struct usb_hub_status *hubsts;
23faf2bc MV	310
	311	/* "allocate" Hub device */
	312	hub = usb_hub_allocate();
	313	if (hub == NULL)
	314	return -1;
	315	hub->pusb_dev = dev;
	316	/* Get the the hub descriptor */
	317	if (usb_get_hub_descriptor(dev, buffer, 4) < 0) {
ceb4972a VG	318	debug("usb_hub_configure: failed to get hub " \
ceb4972a VG	319	"descriptor, giving up %lX\n", dev->status);
23faf2bc MV	320	return -1;
	321	}
	322	descriptor = (struct usb_hub_descriptor *)buffer;
	323
	324	/* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
	325	i = descriptor->bLength;
	326	if (i > USB_BUFSIZ) {
ceb4972a VG	327	debug("usb_hub_configure: failed to get hub " \
ceb4972a VG	328	"descriptor - too long: %d\n", descriptor->bLength);
23faf2bc MV	329	return -1;
	330	}
	331
	332	if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 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;
	336	}
	337	memcpy((unsigned char *)&hub->desc, buffer, descriptor->bLength);
	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);
	426
	427	for (i = 0; i < dev->maxchild; i++) {
f5766139	428	ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
23faf2bc	429	unsigned short portstatus, portchange;
b6d7852c VK	430	int ret;
	431	ulong start = get_timer(0);
	432
	433	/*
	434	* Wait for (whichever finishes first)
	435	* - A maximum of 10 seconds
	436	* This is a purely observational value driven by connecting
	437	* a few broken pen drives and taking the max * 1.5 approach
	438	* - connection_change and connection state to report same
	439	* state
	440	*/
	441	do {
	442	ret = usb_get_port_status(dev, i + 1, portsts);
	443	if (ret < 0) {
ceb4972a	444	debug("get_port_status failed\n");
b6d7852c VK	445	break;
	446	}
	447
	448	portstatus = le16_to_cpu(portsts->wPortStatus);
	449	portchange = le16_to_cpu(portsts->wPortChange);
	450
	451	if ((portchange & USB_PORT_STAT_C_CONNECTION) ==
	452	(portstatus & USB_PORT_STAT_CONNECTION))
	453	break;
	454
b6d7852c VK	455	} while (get_timer(start) < CONFIG_SYS_HZ * 10);
	456
	457	if (ret < 0)
23faf2bc	458	continue;
23faf2bc	459
ceb4972a VG	460	debug("Port %d Status %X Change %X\n",
ceb4972a VG	461	i + 1, portstatus, portchange);
23faf2bc MV	462
23faf2bc MV	463	if (portchange & USB_PORT_STAT_C_CONNECTION) {
ceb4972a	464	debug("port %d connection change\n", i + 1);
23faf2bc MV	465	usb_hub_port_connect_change(dev, i);
	466	}
	467	if (portchange & USB_PORT_STAT_C_ENABLE) {
ceb4972a VG	468	debug("port %d enable change, status %x\n",
ceb4972a VG	469	i + 1, portstatus);
23faf2bc MV	470	usb_clear_port_feature(dev, i + 1,
	471	USB_PORT_FEAT_C_ENABLE);
	472
	473	/* EM interference sometimes causes bad shielded USB
	474	* devices to be shutdown by the hub, this hack enables
	475	* them again. Works at least with mouse driver */
	476	if (!(portstatus & USB_PORT_STAT_ENABLE) &&
	477	(portstatus & USB_PORT_STAT_CONNECTION) &&
	478	((dev->children[i]))) {
ceb4972a VG	479	debug("already running port %i " \
	480	"disabled by hub (EMI?), " \
	481	"re-enabling...\n", i + 1);
	482	usb_hub_port_connect_change(dev, i);
23faf2bc MV	483	}
	484	}
	485	if (portstatus & USB_PORT_STAT_SUSPEND) {
ceb4972a	486	debug("port %d suspend change\n", i + 1);
23faf2bc MV	487	usb_clear_port_feature(dev, i + 1,
	488	USB_PORT_FEAT_SUSPEND);
	489	}
	490
	491	if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
ceb4972a	492	debug("port %d over-current change\n", i + 1);
23faf2bc MV	493	usb_clear_port_feature(dev, i + 1,
	494	USB_PORT_FEAT_C_OVER_CURRENT);
	495	usb_hub_power_on(hub);
	496	}
	497
	498	if (portchange & USB_PORT_STAT_C_RESET) {
ceb4972a	499	debug("port %d reset change\n", i + 1);
23faf2bc MV	500	usb_clear_port_feature(dev, i + 1,
	501	USB_PORT_FEAT_C_RESET);
	502	}
	503	} /* end for i all ports */
	504
	505	return 0;
	506	}
	507
	508	int usb_hub_probe(struct usb_device *dev, int ifnum)
	509	{
	510	struct usb_interface *iface;
	511	struct usb_endpoint_descriptor *ep;
	512	int ret;
	513
	514	iface = &dev->config.if_desc[ifnum];
	515	/* Is it a hub? */
	516	if (iface->desc.bInterfaceClass != USB_CLASS_HUB)
	517	return 0;
	518	/* Some hubs have a subclass of 1, which AFAICT according to the */
	519	/* specs is not defined, but it works */
	520	if ((iface->desc.bInterfaceSubClass != 0) &&
	521	(iface->desc.bInterfaceSubClass != 1))
	522	return 0;
	523	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
	524	if (iface->desc.bNumEndpoints != 1)
	525	return 0;
	526	ep = &iface->ep_desc[0];
	527	/* Output endpoint? Curiousier and curiousier.. */
	528	if (!(ep->bEndpointAddress & USB_DIR_IN))
	529	return 0;
	530	/* If it's not an interrupt endpoint, we'd better punt! */
	531	if ((ep->bmAttributes & 3) != 3)
	532	return 0;
	533	/* We found a hub */
ceb4972a	534	debug("USB hub found\n");
23faf2bc MV	535	ret = usb_hub_configure(dev);
	536	return ret;
	537	}