From b528ebd33741511b054926e6076b23ab0637f6da Mon Sep 17 00:00:00 2001

From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>

Date: Tue, 19 Mar 2013 23:06:44 +0100

Subject: [PATCH 215/482] 	Initialize USB ports in parallel to speed-up

 boot.

---

 ChangeLog                  |   4 +

 grub-core/bus/usb/usb.c    |  38 ------

 grub-core/bus/usb/usbhub.c | 320 +++++++++++++++++++++++++++++----------------

 include/grub/usb.h         |  16 +++

 4 files changed, 228 insertions(+), 150 deletions(-)

diff --git a/ChangeLog b/ChangeLog

index 725fbe2..dd9c97a 100644

--- a/ChangeLog

+++ b/ChangeLog

@@ -1,5 +1,9 @@

 2013-03-19  Vladimir Serbinenko  <phcoder@gmail.com>

+	Initialize USB ports in parallel to speed-up boot.

+

+2013-03-19  Vladimir Serbinenko  <phcoder@gmail.com>

+

 	Fix USB devices not being detected when requested

 	due to delayed attach.

diff --git a/grub-core/bus/usb/usb.c b/grub-core/bus/usb/usb.c

index 108c69b..024190e 100644

--- a/grub-core/bus/usb/usb.c

+++ b/grub-core/bus/usb/usb.c

@@ -26,46 +26,8 @@

 GRUB_MOD_LICENSE ("GPLv3+");

-static grub_usb_controller_dev_t grub_usb_list;

 static struct grub_usb_attach_desc *attach_hooks;

-/* Iterate over all controllers found by the driver.  */

-static int

-grub_usb_controller_dev_register_iter (grub_usb_controller_t dev, void *data)

-{

-  grub_usb_controller_dev_t usb = data;

-

-  dev->dev = usb;

-

-  /* Enable the ports of the USB Root Hub.  */

-  grub_usb_root_hub (dev);

-

-  return 0;

-}

-

-void

-grub_usb_controller_dev_register (grub_usb_controller_dev_t usb)

-{

-  usb->next = grub_usb_list;

-  grub_usb_list = usb;

-

-  if (usb->iterate)

-    usb->iterate (grub_usb_controller_dev_register_iter, usb);

-}

-

-void

-grub_usb_controller_dev_unregister (grub_usb_controller_dev_t usb)

-{

-  grub_usb_controller_dev_t *p, q;

-

-  for (p = &grub_usb_list, q = *p; q; p = &(q->next), q = q->next)

-    if (q == usb)

-      {

-	*p = q->next;

-	break;

-      }

-}

-

 #if 0

 /* Context for grub_usb_controller_iterate.  */

 struct grub_usb_controller_iterate_ctx

diff --git a/grub-core/bus/usb/usbhub.c b/grub-core/bus/usb/usbhub.c

index 253e49f..d0be80d 100644

--- a/grub-core/bus/usb/usbhub.c

+++ b/grub-core/bus/usb/usbhub.c

@@ -41,6 +41,7 @@ struct grub_usb_hub

 };

 static struct grub_usb_hub *hubs;

+static grub_usb_controller_dev_t grub_usb_list;

 /* Add a device that currently has device number 0 and resides on

    CONTROLLER, the Hub reported that the device speed is SPEED.  */

@@ -146,10 +147,15 @@ grub_usb_add_hub (grub_usb_device_t dev)

   grub_dprintf ("usb", "Hub set configuration\n");

   grub_usb_set_configuration (dev, 1);

-  dev->children = grub_zalloc (hubdesc.portcnt * sizeof (dev->children[0]));

-  if (!dev->children)

-    return GRUB_USB_ERR_INTERNAL;

   dev->nports = hubdesc.portcnt;

+  dev->children = grub_zalloc (hubdesc.portcnt * sizeof (dev->children[0]));

+  dev->ports = grub_zalloc (dev->nports * sizeof (dev->ports[0]));

+  if (!dev->children || !dev->ports)

+    {

+      grub_free (dev->children);

+      grub_free (dev->ports);

+      return GRUB_USB_ERR_INTERNAL;

+    }

   /* Power on all Hub ports.  */

   for (i = 1; i <= hubdesc.portcnt; i++)

@@ -197,46 +203,6 @@ attach_root_port (struct grub_usb_hub *hub, int portno,

 {

   grub_usb_device_t dev;

   grub_err_t err;

-  int total, i;

-  grub_usb_speed_t current_speed = GRUB_USB_SPEED_NONE;

-  int changed=0;

-

-  grub_boot_time ("detect_dev USB root portno=%d\n", portno);

-

-#if 0

-/* Specification does not say about disabling of port when device

- * connected. If disabling is really necessary for some devices,

- * delete this #if 0 and related #endif */

-  /* Disable the port. XXX: Why? */

-  err = hub->controller->dev->portstatus (hub->controller, portno, 0);

-  if (err)

-    return;

-#endif

-

-  grub_boot_time ("Before the stable power wait portno=%d", portno);

-

-  /* Wait for completion of insertion and stable power (USB spec.)

-   * Should be at least 100ms, some devices requires more...

-   * There is also another thing - some devices have worse contacts

-   * and connected signal is unstable for some time - we should handle

-   * it - but prevent deadlock in case when device is too faulty... */

-  for (total = i = 0; (i < 250) && (total < 2000); i++, total++)

-    {

-      grub_millisleep (1);

-      current_speed = hub->controller->dev->detect_dev

-                        (hub->controller, portno, &changed);

-      if (current_speed == GRUB_USB_SPEED_NONE)

-        i = 0;

-    }

-

-  grub_boot_time ("After the stable power wait portno=%d", portno);

-

-  grub_dprintf ("usb", "total=%d\n", total);

-  if (total >= 2000)

-    {

-      grub_boot_time ("Root port timeout");

-      return;

-    }

   grub_boot_time ("After detect_dev");

@@ -267,12 +233,14 @@ attach_root_port (struct grub_usb_hub *hub, int portno,

   grub_boot_time ("Attached root port");

 }

-grub_usb_err_t

-grub_usb_root_hub (grub_usb_controller_t controller)

+/* Iterate over all controllers found by the driver.  */

+static int

+grub_usb_controller_dev_register_iter (grub_usb_controller_t controller, void *data)

 {

-  int i;

+  grub_usb_controller_dev_t usb = data;

   struct grub_usb_hub *hub;

-  int changed=0;

+

+  controller->dev = usb;

   grub_boot_time ("Registering USB root hub");

@@ -295,29 +263,118 @@ grub_usb_root_hub (grub_usb_controller_t controller)

   /* Query the number of ports the root Hub has.  */

   hub->nports = controller->dev->hubports (controller);

   hub->devices = grub_zalloc (sizeof (hub->devices[0]) * hub->nports);

-  if (!hub->devices)

+  usb->ports = grub_zalloc (sizeof (usb->ports[0]) * hub->nports);

+  if (!hub->devices || !usb->ports)

     {

+      grub_free (hub->devices);

+      grub_free (usb->ports);

       grub_free (hub->controller);

       grub_free (hub);

-      return GRUB_USB_ERR_INTERNAL;

+      grub_print_error ();

+      return 0;

     }

-  for (i = 0; i < hub->nports; i++)

+  return 0;

+}

+

+void

+grub_usb_controller_dev_unregister (grub_usb_controller_dev_t usb)

+{

+  grub_usb_controller_dev_t *p, q;

+

+  for (p = &grub_usb_list, q = *p; q; p = &(q->next), q = q->next)

+    if (q == usb)

+      {

+	*p = q->next;

+	break;

+      }

+}

+

+void

+grub_usb_controller_dev_register (grub_usb_controller_dev_t usb)

+{

+  int portno;

+  int continue_waiting = 0;

+  struct grub_usb_hub *hub;

+

+  usb->next = grub_usb_list;

+  grub_usb_list = usb;

+

+  if (usb->iterate)

+    usb->iterate (grub_usb_controller_dev_register_iter, usb);

+

+  grub_boot_time ("waiting for stable power on USB root\n");

+

+  while (1)

     {

-      grub_usb_speed_t speed;

-      if (!controller->dev->pending_reset)

-        {

-          speed = controller->dev->detect_dev (hub->controller, i,

-					       &changed);

-

-          if (speed != GRUB_USB_SPEED_NONE)

-	    attach_root_port (hub, i, speed);

-        }

+      for (hub = hubs; hub; hub = hub->next)

+	if (hub->controller->dev == usb)

+	  {

+	    /* Wait for completion of insertion and stable power (USB spec.)

+	     * Should be at least 100ms, some devices requires more...

+	     * There is also another thing - some devices have worse contacts

+	     * and connected signal is unstable for some time - we should handle

+	     * it - but prevent deadlock in case when device is too faulty... */

+	    for (portno = 0; portno < hub->nports; portno++)

+	      {

+		grub_usb_speed_t speed;

+		int changed = 0;

+

+		speed = hub->controller->dev->detect_dev (hub->controller, portno,

+							  &changed);

+      

+		if (usb->ports[portno].state == PORT_STATE_NORMAL

+		    && speed != GRUB_USB_SPEED_NONE)

+		  {

+		    usb->ports[portno].soft_limit_time = grub_get_time_ms () + 250;

+		    usb->ports[portno].hard_limit_time = usb->ports[portno].soft_limit_time + 1750;

+		    usb->ports[portno].state = PORT_STATE_WAITING_FOR_STABLE_POWER;

+		    continue_waiting++;

+		    continue;

+		  }

+

+		if (usb->ports[portno].state == PORT_STATE_WAITING_FOR_STABLE_POWER

+		    && speed == GRUB_USB_SPEED_NONE)

+		  {

+		    usb->ports[portno].soft_limit_time = grub_get_time_ms () + 250;

+		    continue;

+		  }

+		if (usb->ports[portno].state == PORT_STATE_WAITING_FOR_STABLE_POWER

+		    && grub_get_time_ms () > usb->ports[portno].soft_limit_time)

+		  {

+		    usb->ports[portno].state = PORT_STATE_STABLE_POWER;

+		    continue_waiting--;

+		    continue;

+		  }

+		if (usb->ports[portno].state == PORT_STATE_WAITING_FOR_STABLE_POWER

+		    && grub_get_time_ms () > usb->ports[portno].hard_limit_time)

+		  {

+		    usb->ports[portno].state = PORT_STATE_FAILED_DEVICE;

+		    continue_waiting--;

+		    continue;

+		  }

+	      }

+	  }

+      if (!continue_waiting)

+	break;

+      grub_millisleep (1);

     }

-  grub_boot_time ("USB root hub registered");

+  grub_boot_time ("After the stable power wait on USB root");

-  return GRUB_USB_ERR_NONE;

+  for (hub = hubs; hub; hub = hub->next)

+    if (hub->controller->dev == usb)

+      for (portno = 0; portno < hub->nports; portno++)

+	if (usb->ports[portno].state == PORT_STATE_STABLE_POWER)

+	  {

+	    grub_usb_speed_t speed;

+	    int changed = 0;

+	    usb->ports[portno].state = PORT_STATE_NORMAL;

+	    speed = hub->controller->dev->detect_dev (hub->controller, portno, &changed);

+	    attach_root_port (hub, portno, speed);

+	  }

+

+  grub_boot_time ("USB root hub registered");

 }

 static void detach_device (grub_usb_device_t dev);

@@ -349,6 +406,71 @@ detach_device (grub_usb_device_t dev)

   grub_usb_devs[dev->addr] = 0;

 }

+static int

+wait_power_nonroot_hub (grub_usb_device_t dev)

+{

+  grub_usb_err_t err;

+  int continue_waiting = 0;

+  unsigned i;

+  

+  for (i = 1; i <= dev->nports; i++)

+    if (dev->ports[i - 1].state == PORT_STATE_WAITING_FOR_STABLE_POWER)

+      {

+	grub_uint64_t tm;

+	grub_uint32_t current_status = 0;

+

+	/* Get the port status.  */

+	err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_IN

+					  | GRUB_USB_REQTYPE_CLASS

+					  | GRUB_USB_REQTYPE_TARGET_OTHER),

+				    GRUB_USB_REQ_GET_STATUS,

+				    0, i,

+				    sizeof (current_status),

+				    (char *) &current_status);

+	if (err)

+	  {

+	    dev->ports[i - 1].state = PORT_STATE_FAILED_DEVICE;

+	    continue;

+	  }

+	tm = grub_get_time_ms ();

+	if (!(current_status & GRUB_USB_HUB_STATUS_PORT_CONNECTED))

+	  dev->ports[i - 1].soft_limit_time = tm + 250;

+	if (tm >= dev->ports[i - 1].soft_limit_time)

+	  {

+	    if (dev->controller.dev->pending_reset)

+	      continue;

+	    /* Now do reset of port. */

+	    grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT

+					| GRUB_USB_REQTYPE_CLASS

+					| GRUB_USB_REQTYPE_TARGET_OTHER),

+				  GRUB_USB_REQ_SET_FEATURE,

+				  GRUB_USB_HUB_FEATURE_PORT_RESET,

+				  i, 0, 0);

+	    dev->ports[i - 1].state = PORT_STATE_NORMAL;

+	    grub_boot_time ("Resetting port %d", i);

+

+	    rescan = 1;

+	    /* We cannot reset more than one device at the same time !

+	     * Resetting more devices together results in very bad

+	     * situation: more than one device has default address 0

+	     * at the same time !!!

+	     * Additionaly, we cannot perform another reset

+	     * anywhere on the same OHCI controller until

+	     * we will finish addressing of reseted device ! */

+	    dev->controller.dev->pending_reset = grub_get_time_ms () + 5000;

+	    npending++;

+	    continue;

+	  }

+	if (tm >= dev->ports[i - 1].hard_limit_time)

+	  {

+	    dev->ports[i - 1].state = PORT_STATE_FAILED_DEVICE;

+	    continue;

+	  }

+	continue_waiting = 1;

+      }

+  return continue_waiting && dev->controller.dev->pending_reset == 0;

+}

+

 static void

 poll_nonroot_hub (grub_usb_device_t dev)

 {

@@ -356,7 +478,6 @@ poll_nonroot_hub (grub_usb_device_t dev)

   unsigned i;

   grub_uint8_t changed;

   grub_size_t actual, len;

-  int j, total;

   if (!dev->hub_transfer)

     return;

@@ -382,9 +503,9 @@ poll_nonroot_hub (grub_usb_device_t dev)

   for (i = 1; i <= dev->nports; i++)

     {

       grub_uint32_t status;

-      grub_uint32_t current_status = 0;

-      if (!(changed & (1 << i)))

+      if (!(changed & (1 << i))

+	  || dev->ports[i - 1].state == PORT_STATE_WAITING_FOR_STABLE_POWER)

 	continue;

       /* Get the port status.  */

@@ -444,52 +565,10 @@ poll_nonroot_hub (grub_usb_device_t dev)

 	       * There is also another thing - some devices have worse contacts

 	       * and connected signal is unstable for some time - we should handle

 	       * it - but prevent deadlock in case when device is too faulty... */

-              for (total = j = 0; (j < 250) && (total < 2000); j++, total++)

-                {

-                  grub_millisleep (1);

-                  /* Get the port status.  */

-                  err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_IN

-					       | GRUB_USB_REQTYPE_CLASS

-					       | GRUB_USB_REQTYPE_TARGET_OTHER),

-				              GRUB_USB_REQ_GET_STATUS,

-				              0, i,

-				              sizeof (current_status),

-				              (char *) &current_status);

-                  if (err)

-                    {

-                      total = 2000;

-	              break;

-                    }

-                  if (!(current_status & GRUB_USB_HUB_STATUS_PORT_CONNECTED))

-                    j = 0;

-                }

-

-	      grub_boot_time ("After the stable power wait portno=%d", i);

-

-              grub_dprintf ("usb", "(non-root) total=%d\n", total);

-              if (total >= 2000)

-                continue;

-

-              /* Now do reset of port. */

-	      grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT

-					  | GRUB_USB_REQTYPE_CLASS

-					  | GRUB_USB_REQTYPE_TARGET_OTHER),

-				    GRUB_USB_REQ_SET_FEATURE,

-				    GRUB_USB_HUB_FEATURE_PORT_RESET,

-				    i, 0, 0);

-	      grub_boot_time ("Resetting port %d", i);

-

-	      rescan = 1;

-	      /* We cannot reset more than one device at the same time !

-	       * Resetting more devices together results in very bad

-	       * situation: more than one device has default address 0

-	       * at the same time !!!

-	       * Additionaly, we cannot perform another reset

-	       * anywhere on the same OHCI controller until

-	       * we will finish addressing of reseted device ! */

-              dev->controller.dev->pending_reset = grub_get_time_ms () + 5000;

-	      npending++;

-              return;

+	      dev->ports[i - 1].soft_limit_time = grub_get_time_ms () + 250;

+	      dev->ports[i - 1].hard_limit_time = dev->ports[i - 1].soft_limit_time + 1750;

+	      dev->ports[i - 1].state = PORT_STATE_WAITING_FOR_STABLE_POWER;

+	      continue;

 	    }

 	}

@@ -580,6 +659,8 @@ grub_usb_poll_devices (int wait_for_completion)

 	}

     }

+  grub_boot_time ("Probing USB device driver");

+

   while (1)

     {

       rescan = 0;

@@ -592,11 +673,26 @@ grub_usb_poll_devices (int wait_for_completion)

 	  if (dev && dev->descdev.class == 0x09)

 	    poll_nonroot_hub (dev);

 	}

+

+      while (1)

+	{

+	  int continue_waiting = 0;

+	  for (i = 0; i < GRUB_USBHUB_MAX_DEVICES; i++)

+	    {

+	      grub_usb_device_t dev = grub_usb_devs[i];

+	    

+	      if (dev && dev->descdev.class == 0x09)

+		continue_waiting = continue_waiting || wait_power_nonroot_hub (dev);

+	    }

+	  if (!continue_waiting)

+	    break;

+	  grub_millisleep (1);

+	}

+

       if (!(rescan || (npending && wait_for_completion)))

 	break;

-      grub_millisleep (50);

+      grub_millisleep (25);

     }

-

 }

 int

diff --git a/include/grub/usb.h b/include/grub/usb.h

index 7164dd5..12a456b 100644

--- a/include/grub/usb.h

+++ b/include/grub/usb.h

@@ -121,6 +121,8 @@ struct grub_usb_controller_dev

   grub_usb_speed_t (*detect_dev) (grub_usb_controller_t dev, int port, int *changed);

+  struct grub_usb_hub_port *ports;

+

   /* Per controller flag - port reset pending, don't do another reset */

   grub_uint64_t pending_reset;

@@ -170,6 +172,18 @@ struct grub_usb_configuration

   struct grub_usb_interface interf[32];

 };

+struct grub_usb_hub_port

+{

+  grub_uint64_t soft_limit_time;

+  grub_uint64_t hard_limit_time;

+  enum { 

+    PORT_STATE_NORMAL = 0,

+    PORT_STATE_WAITING_FOR_STABLE_POWER = 1,

+    PORT_STATE_FAILED_DEVICE = 2,

+    PORT_STATE_STABLE_POWER = 3,

+  } state;

+};

+

 struct grub_usb_device

 {

   /* The device descriptor of this device.  */

@@ -204,6 +218,8 @@ struct grub_usb_device

   /* Number of hub ports.  */

   unsigned nports;

+  struct grub_usb_hub_port *ports;

+

   grub_usb_transfer_t hub_transfer;

   grub_uint32_t statuschange;

-- 

1.8.2.1