/*

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

  	for (i = 0; i < dev->maxchild; i++) {

  		usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
  		debug("port %d returns %lX
  ", 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
  ", 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
  ", 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
  ", 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
  ", 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...
  ", 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
  ",
  			      dev->status);

  			return -1;
  		}

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

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

  		debug("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
  		      "  USB_PORT_STAT_ENABLE %d
  ",
  		      (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.
  ", port + 1, MAX_TRIES);
  		debug("Maybe the USB cable is bad?
  ");

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

  		return;
  	}

  	portstatus = le16_to_cpu(portsts->wPortStatus);

  	debug("portstatus %x, change %x, %s
  ",
  	      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]);
  ");

  		/* 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!?
  ", 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
  ", 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
  ", 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
  ", 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
  ", dev->maxchild);

  	hubCharacteristics = get_unaligned(&hub->desc.wHubCharacteristics);
  	switch (hubCharacteristics & HUB_CHAR_LPSM) {

  	case 0x00:

  		debug("ganged power switching
  ");

  		break;
  	case 0x01:

  		debug("individual port power switching
  ");

  		break;
  	case 0x02:
  	case 0x03:

  		debug("unknown reserved power switching mode
  ");

  		break;
  	}

  	if (hubCharacteristics & HUB_CHAR_COMPOUND)

  		debug("part of a compound device
  ");

  	else

  		debug("standalone hub
  ");

  	switch (hubCharacteristics & HUB_CHAR_OCPM) {

  	case 0x00:

  		debug("global over-current protection
  ");

  		break;
  	case 0x08:

  		debug("individual port over-current protection
  ");

  		break;
  	case 0x10:
  	case 0x18:

  		debug("no over-current protection
  ");

  		break;
  	}

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

  
  	for (i = 0; i < dev->maxchild; i++)

  		debug("port %d is%s removable
  ", 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
  ", descriptor->bLength);

  		return -1;
  	}
  
  	if (usb_get_hub_status(dev, buffer) < 0) {

  		debug("usb_hub_configure: failed to get Status %lX
  ",
  		      dev->status);

  		return -1;
  	}

  #ifdef DEBUG

  	hubsts = (struct usb_hub_status *)buffer;
  #endif

  
  	debug("get_hub_status returned status %X, change %X
  ",
  	      le16_to_cpu(hubsts->wHubStatus),
  	      le16_to_cpu(hubsts->wHubChange));
  	debug("local power source is %s
  ",
  	      (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \
  	      "lost (inactive)" : "good");
  	debug("%sover-current condition exists
  ",
  	      (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
  ");

  				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
  ",
  		      i + 1, portstatus, portchange);

  
  		if (portchange & USB_PORT_STAT_C_CONNECTION) {

  			debug("port %d connection change
  ", i + 1);

  			usb_hub_port_connect_change(dev, i);
  		}
  		if (portchange & USB_PORT_STAT_C_ENABLE) {

  			debug("port %d enable change, status %x
  ",
  			      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...
  ", i + 1);
  				      usb_hub_port_connect_change(dev, i);

  			}

  #endif

  		}
  		if (portstatus & USB_PORT_STAT_SUSPEND) {

  			debug("port %d suspend change
  ", 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
  ", 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
  ", 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
  ");

  	ret = usb_hub_configure(dev);
  	return ret;
  }