common/usb_hub.c

   1 /*
   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  *
  17  * SPDX-License-Identifier:     GPL-2.0+
  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 <dm.h>
  28 #include <errno.h>
  29 #include <memalign.h>
  30 #include <asm/processor.h>
  31 #include <asm/unaligned.h>
  32 #include <linux/ctype.h>
  33 #include <linux/list.h>
  34 #include <asm/byteorder.h>
  35 #ifdef CONFIG_SANDBOX
  36 #include <asm/state.h>
  37 #endif
  38 #include <asm/unaligned.h>
  39
  40 DECLARE_GLOBAL_DATA_PTR;
  41
  42 #include <usb.h>
  43
  44 #define USB_BUFSIZ      512
  45
  46 #define HUB_SHORT_RESET_TIME    20
  47 #define HUB_LONG_RESET_TIME     200
  48
  49 #define PORT_OVERCURRENT_MAX_SCAN_COUNT         3
  50
  51 struct usb_device_scan {
  52         struct usb_device *dev;         /* USB hub device to scan */
  53         struct usb_hub_device *hub;     /* USB hub struct */
  54         int port;                       /* USB port to scan */
  55         struct list_head list;
  56 };
  57
  58 static LIST_HEAD(usb_scan_list);
  59
  60 __weak void usb_hub_reset_devices(int port)
  61 {
  62         return;
  63 }
  64
  65 static inline bool usb_hub_is_superspeed(struct usb_device *hdev)
  66 {
  67         return hdev->descriptor.bDeviceProtocol == 3;
  68 }
  69
  70 #ifdef CONFIG_DM_USB
  71 bool usb_hub_is_root_hub(struct udevice *hub)
  72 {
  73         if (device_get_uclass_id(hub->parent) != UCLASS_USB_HUB)
  74                 return true;
  75
  76         return false;
  77 }
  78 #endif
  79
  80 static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
  81 {
  82         unsigned short dtype = USB_DT_HUB;
  83
  84         if (usb_hub_is_superspeed(dev))
  85                 dtype = USB_DT_SS_HUB;
  86
  87         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
  88                 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
  89                 dtype << 8, 0, data, size, USB_CNTL_TIMEOUT);
  90 }
  91
  92 static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
  93 {
  94         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
  95                                 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature,
  96                                 port, NULL, 0, USB_CNTL_TIMEOUT);
  97 }
  98
  99 static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
 100 {
 101         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 102                                 USB_REQ_SET_FEATURE, USB_RT_PORT, feature,
 103                                 port, NULL, 0, USB_CNTL_TIMEOUT);
 104 }
 105
 106 static int usb_get_hub_status(struct usb_device *dev, void *data)
 107 {
 108         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 109                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
 110                         data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
 111 }
 112
 113 int usb_get_port_status(struct usb_device *dev, int port, void *data)
 114 {
 115         int ret;
 116
 117         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 118                         USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
 119                         data, sizeof(struct usb_port_status), USB_CNTL_TIMEOUT);
 120
 121 #ifdef CONFIG_DM_USB
 122         if (ret < 0)
 123                 return ret;
 124
 125         /*
 126          * Translate the USB 3.0 hub port status field into the old version
 127          * that U-Boot understands. Do this only when the hub is not root hub.
 128          * For root hub, the port status field has already been translated
 129          * in the host controller driver (see xhci_submit_root() in xhci.c).
 130          *
 131          * Note: this only supports driver model.
 132          */
 133
 134         if (!usb_hub_is_root_hub(dev->dev) && usb_hub_is_superspeed(dev)) {
 135                 struct usb_port_status *status = (struct usb_port_status *)data;
 136                 u16 tmp = (status->wPortStatus) & USB_SS_PORT_STAT_MASK;
 137
 138                 if (status->wPortStatus & USB_SS_PORT_STAT_POWER)
 139                         tmp |= USB_PORT_STAT_POWER;
 140                 if ((status->wPortStatus & USB_SS_PORT_STAT_SPEED) ==
 141                     USB_SS_PORT_STAT_SPEED_5GBPS)
 142                         tmp |= USB_PORT_STAT_SUPER_SPEED;
 143
 144                 status->wPortStatus = tmp;
 145         }
 146 #endif
 147
 148         return ret;
 149 }
 150
 151
 152 static void usb_hub_power_on(struct usb_hub_device *hub)
 153 {
 154         int i;
 155         struct usb_device *dev;
 156         unsigned pgood_delay = hub->desc.bPwrOn2PwrGood * 2;
 157         const char *env;
 158
 159         dev = hub->pusb_dev;
 160
 161         debug("enabling power on all ports\n");
 162         for (i = 0; i < dev->maxchild; i++) {
 163                 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
 164                 debug("port %d returns %lX\n", i + 1, dev->status);
 165         }
 166
 167 #ifdef CONFIG_SANDBOX
 168         /*
 169          * Don't set timeout / delay values here. This results
 170          * in these values still being reset to 0.
 171          */
 172         if (state_get_skip_delays())
 173                 return;
 174 #endif
 175
 176         /*
 177          * Wait for power to become stable,
 178          * plus spec-defined max time for device to connect
 179          * but allow this time to be increased via env variable as some
 180          * devices break the spec and require longer warm-up times
 181          */
 182         env = getenv("usb_pgood_delay");
 183         if (env)
 184                 pgood_delay = max(pgood_delay,
 185                                   (unsigned)simple_strtol(env, NULL, 0));
 186         debug("pgood_delay=%dms\n", pgood_delay);
 187
 188         /*
 189          * Do a minimum delay of the larger value of 100ms or pgood_delay
 190          * so that the power can stablize before the devices are queried
 191          */
 192         hub->query_delay = get_timer(0) + max(100, (int)pgood_delay);
 193
 194         /*
 195          * Record the power-on timeout here. The max. delay (timeout)
 196          * will be done based on this value in the USB port loop in
 197          * usb_hub_configure() later.
 198          */
 199         hub->connect_timeout = hub->query_delay + 1000;
 200         debug("devnum=%d poweron: query_delay=%d connect_timeout=%d\n",
 201               dev->devnum, max(100, (int)pgood_delay),
 202               max(100, (int)pgood_delay) + 1000);
 203 }
 204
 205 #ifndef CONFIG_DM_USB
 206 static struct usb_hub_device hub_dev[USB_MAX_HUB];
 207 static int usb_hub_index;
 208
 209 void usb_hub_reset(void)
 210 {
 211         usb_hub_index = 0;
 212
 213         /* Zero out global hub_dev in case its re-used again */
 214         memset(hub_dev, 0, sizeof(hub_dev));
 215 }
 216
 217 static struct usb_hub_device *usb_hub_allocate(void)
 218 {
 219         if (usb_hub_index < USB_MAX_HUB)
 220                 return &hub_dev[usb_hub_index++];
 221
 222         printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB);
 223         return NULL;
 224 }
 225 #endif
 226
 227 #define MAX_TRIES 5
 228
 229 static inline char *portspeed(int portstatus)
 230 {
 231         char *speed_str;
 232
 233         switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
 234         case USB_PORT_STAT_SUPER_SPEED:
 235                 speed_str = "5 Gb/s";
 236                 break;
 237         case USB_PORT_STAT_HIGH_SPEED:
 238                 speed_str = "480 Mb/s";
 239                 break;
 240         case USB_PORT_STAT_LOW_SPEED:
 241                 speed_str = "1.5 Mb/s";
 242                 break;
 243         default:
 244                 speed_str = "12 Mb/s";
 245                 break;
 246         }
 247
 248         return speed_str;
 249 }
 250
 251 /**
 252  * usb_hub_port_reset() - reset a port given its usb_device pointer
 253  *
 254  * Reset a hub port and see if a device is present on that port, providing
 255  * sufficient time for it to show itself. The port status is returned.
 256  *
 257  * @dev:        USB device to reset
 258  * @port:       Port number to reset (note ports are numbered from 0 here)
 259  * @portstat:   Returns port status
 260  */
 261 static int usb_hub_port_reset(struct usb_device *dev, int port,
 262                               unsigned short *portstat)
 263 {
 264         int err, tries;
 265         ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
 266         unsigned short portstatus, portchange;
 267         int delay = HUB_SHORT_RESET_TIME; /* start with short reset delay */
 268
 269 #ifdef CONFIG_DM_USB
 270         debug("%s: resetting '%s' port %d...\n", __func__, dev->dev->name,
 271               port + 1);
 272 #else
 273         debug("%s: resetting port %d...\n", __func__, port + 1);
 274 #endif
 275         for (tries = 0; tries < MAX_TRIES; tries++) {
 276                 err = usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
 277                 if (err < 0)
 278                         return err;
 279
 280                 mdelay(delay);
 281
 282                 if (usb_get_port_status(dev, port + 1, portsts) < 0) {
 283                         debug("get_port_status failed status %lX\n",
 284                               dev->status);
 285                         return -1;
 286                 }
 287                 portstatus = le16_to_cpu(portsts->wPortStatus);
 288                 portchange = le16_to_cpu(portsts->wPortChange);
 289
 290                 debug("portstatus %x, change %x, %s\n", portstatus, portchange,
 291                                                         portspeed(portstatus));
 292
 293                 debug("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
 294                       "  USB_PORT_STAT_ENABLE %d\n",
 295                       (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
 296                       (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
 297                       (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);
 298
 299                 /*
 300                  * Perhaps we should check for the following here:
 301                  * - C_CONNECTION hasn't been set.
 302                  * - CONNECTION is still set.
 303                  *
 304                  * Doing so would ensure that the device is still connected
 305                  * to the bus, and hasn't been unplugged or replaced while the
 306                  * USB bus reset was going on.
 307                  *
 308                  * However, if we do that, then (at least) a San Disk Ultra
 309                  * USB 3.0 16GB device fails to reset on (at least) an NVIDIA
 310                  * Tegra Jetson TK1 board. For some reason, the device appears
 311                  * to briefly drop off the bus when this second bus reset is
 312                  * executed, yet if we retry this loop, it'll eventually come
 313                  * back after another reset or two.
 314                  */
 315
 316                 if (portstatus & USB_PORT_STAT_ENABLE)
 317                         break;
 318
 319                 /* Switch to long reset delay for the next round */
 320                 delay = HUB_LONG_RESET_TIME;
 321         }
 322
 323         if (tries == MAX_TRIES) {
 324                 debug("Cannot enable port %i after %i retries, " \
 325                       "disabling port.\n", port + 1, MAX_TRIES);
 326                 debug("Maybe the USB cable is bad?\n");
 327                 return -1;
 328         }
 329
 330         usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
 331         *portstat = portstatus;
 332         return 0;
 333 }
 334
 335 int usb_hub_port_connect_change(struct usb_device *dev, int port)
 336 {
 337         ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
 338         unsigned short portstatus;
 339         int ret, speed;
 340
 341         /* Check status */
 342         ret = usb_get_port_status(dev, port + 1, portsts);
 343         if (ret < 0) {
 344                 debug("get_port_status failed\n");
 345                 return ret;
 346         }
 347
 348         portstatus = le16_to_cpu(portsts->wPortStatus);
 349         debug("portstatus %x, change %x, %s\n",
 350               portstatus,
 351               le16_to_cpu(portsts->wPortChange),
 352               portspeed(portstatus));
 353
 354         /* Clear the connection change status */
 355         usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);
 356
 357         /* Disconnect any existing devices under this port */
 358         if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
 359              (!(portstatus & USB_PORT_STAT_ENABLE))) ||
 360             usb_device_has_child_on_port(dev, port)) {
 361                 debug("usb_disconnect(&hub->children[port]);\n");
 362                 /* Return now if nothing is connected */
 363                 if (!(portstatus & USB_PORT_STAT_CONNECTION))
 364                         return -ENOTCONN;
 365         }
 366
 367         /* Reset the port */
 368         ret = usb_hub_port_reset(dev, port, &portstatus);
 369         if (ret < 0) {
 370                 if (ret != -ENXIO)
 371                         printf("cannot reset port %i!?\n", port + 1);
 372                 return ret;
 373         }
 374
 375         switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
 376         case USB_PORT_STAT_SUPER_SPEED:
 377                 speed = USB_SPEED_SUPER;
 378                 break;
 379         case USB_PORT_STAT_HIGH_SPEED:
 380                 speed = USB_SPEED_HIGH;
 381                 break;
 382         case USB_PORT_STAT_LOW_SPEED:
 383                 speed = USB_SPEED_LOW;
 384                 break;
 385         default:
 386                 speed = USB_SPEED_FULL;
 387                 break;
 388         }
 389
 390 #ifdef CONFIG_DM_USB
 391         struct udevice *child;
 392
 393         ret = usb_scan_device(dev->dev, port + 1, speed, &child);
 394 #else
 395         struct usb_device *usb;
 396
 397         ret = usb_alloc_new_device(dev->controller, &usb);
 398         if (ret) {
 399                 printf("cannot create new device: ret=%d", ret);
 400                 return ret;
 401         }
 402
 403         dev->children[port] = usb;
 404         usb->speed = speed;
 405         usb->parent = dev;
 406         usb->portnr = port + 1;
 407         /* Run it through the hoops (find a driver, etc) */
 408         ret = usb_new_device(usb);
 409         if (ret < 0) {
 410                 /* Woops, disable the port */
 411                 usb_free_device(dev->controller);
 412                 dev->children[port] = NULL;
 413         }
 414 #endif
 415         if (ret < 0) {
 416                 debug("hub: disabling port %d\n", port + 1);
 417                 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
 418         }
 419
 420         return ret;
 421 }
 422
 423 static int usb_scan_port(struct usb_device_scan *usb_scan)
 424 {
 425         ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
 426         unsigned short portstatus;
 427         unsigned short portchange;
 428         struct usb_device *dev;
 429         struct usb_hub_device *hub;
 430         int ret = 0;
 431         int i;
 432
 433         dev = usb_scan->dev;
 434         hub = usb_scan->hub;
 435         i = usb_scan->port;
 436
 437         /*
 438          * Don't talk to the device before the query delay is expired.
 439          * This is needed for voltages to stabalize.
 440          */
 441         if (get_timer(0) < hub->query_delay)
 442                 return 0;
 443
 444         ret = usb_get_port_status(dev, i + 1, portsts);
 445         if (ret < 0) {
 446                 debug("get_port_status failed\n");
 447                 if (get_timer(0) >= hub->connect_timeout) {
 448                         debug("devnum=%d port=%d: timeout\n",
 449                               dev->devnum, i + 1);
 450                         /* Remove this device from scanning list */
 451                         list_del(&usb_scan->list);
 452                         free(usb_scan);
 453                         return 0;
 454                 }
 455                 return 0;
 456         }
 457
 458         portstatus = le16_to_cpu(portsts->wPortStatus);
 459         portchange = le16_to_cpu(portsts->wPortChange);
 460         debug("Port %d Status %X Change %X\n", i + 1, portstatus, portchange);
 461
 462         /*
 463          * No connection change happened, wait a bit more.
 464          *
 465          * For some situation, the hub reports no connection change but a
 466          * device is connected to the port (eg: CCS bit is set but CSC is not
 467          * in the PORTSC register of a root hub), ignore such case.
 468          */
 469         if (!(portchange & USB_PORT_STAT_C_CONNECTION) &&
 470             !(portstatus & USB_PORT_STAT_CONNECTION)) {
 471                 if (get_timer(0) >= hub->connect_timeout) {
 472                         debug("devnum=%d port=%d: timeout\n",
 473                               dev->devnum, i + 1);
 474                         /* Remove this device from scanning list */
 475                         list_del(&usb_scan->list);
 476                         free(usb_scan);
 477                         return 0;
 478                 }
 479                 return 0;
 480         }
 481
 482         /* A new USB device is ready at this point */
 483         debug("devnum=%d port=%d: USB dev found\n", dev->devnum, i + 1);
 484
 485         usb_hub_port_connect_change(dev, i);
 486
 487         if (portchange & USB_PORT_STAT_C_ENABLE) {
 488                 debug("port %d enable change, status %x\n", i + 1, portstatus);
 489                 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
 490                 /*
 491                  * The following hack causes a ghost device problem
 492                  * to Faraday EHCI
 493                  */
 494 #ifndef CONFIG_USB_EHCI_FARADAY
 495                 /*
 496                  * EM interference sometimes causes bad shielded USB
 497                  * devices to be shutdown by the hub, this hack enables
 498                  * them again. Works at least with mouse driver
 499                  */
 500                 if (!(portstatus & USB_PORT_STAT_ENABLE) &&
 501                     (portstatus & USB_PORT_STAT_CONNECTION) &&
 502                     usb_device_has_child_on_port(dev, i)) {
 503                         debug("already running port %i disabled by hub (EMI?), re-enabling...\n",
 504                               i + 1);
 505                         usb_hub_port_connect_change(dev, i);
 506                 }
 507 #endif
 508         }
 509
 510         if (portstatus & USB_PORT_STAT_SUSPEND) {
 511                 debug("port %d suspend change\n", i + 1);
 512                 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_SUSPEND);
 513         }
 514
 515         if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
 516                 debug("port %d over-current change\n", i + 1);
 517                 usb_clear_port_feature(dev, i + 1,
 518                                        USB_PORT_FEAT_C_OVER_CURRENT);
 519                 /* Only power-on this one port */
 520                 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
 521                 hub->overcurrent_count[i]++;
 522
 523                 /*
 524                  * If the max-scan-count is not reached, return without removing
 525                  * the device from scan-list. This will re-issue a new scan.
 526                  */
 527                 if (hub->overcurrent_count[i] <=
 528                     PORT_OVERCURRENT_MAX_SCAN_COUNT)
 529                         return 0;
 530
 531                 /* Otherwise the device will get removed */
 532                 printf("Port %d over-current occurred %d times\n", i + 1,
 533                        hub->overcurrent_count[i]);
 534         }
 535
 536         if (portchange & USB_PORT_STAT_C_RESET) {
 537                 debug("port %d reset change\n", i + 1);
 538                 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
 539         }
 540
 541         /*
 542          * We're done with this device, so let's remove this device from
 543          * scanning list
 544          */
 545         list_del(&usb_scan->list);
 546         free(usb_scan);
 547
 548         return 0;
 549 }
 550
 551 static int usb_device_list_scan(void)
 552 {
 553         struct usb_device_scan *usb_scan;
 554         struct usb_device_scan *tmp;
 555         static int running;
 556         int ret = 0;
 557
 558         /* Only run this loop once for each controller */
 559         if (running)
 560                 return 0;
 561
 562         running = 1;
 563
 564         while (1) {
 565                 /* We're done, once the list is empty again */
 566                 if (list_empty(&usb_scan_list))
 567                         goto out;
 568
 569                 list_for_each_entry_safe(usb_scan, tmp, &usb_scan_list, list) {
 570                         int ret;
 571
 572                         /* Scan this port */
 573                         ret = usb_scan_port(usb_scan);
 574                         if (ret)
 575                                 goto out;
 576                 }
 577         }
 578
 579 out:
 580         /*
 581          * This USB controller has finished scanning all its connected
 582          * USB devices. Set "running" back to 0, so that other USB controllers
 583          * will scan their devices too.
 584          */
 585         running = 0;
 586
 587         return ret;
 588 }
 589
 590 static struct usb_hub_device *usb_get_hub_device(struct usb_device *dev)
 591 {
 592         struct usb_hub_device *hub;
 593
 594 #ifndef CONFIG_DM_USB
 595         /* "allocate" Hub device */
 596         hub = usb_hub_allocate();
 597 #else
 598         hub = dev_get_uclass_priv(dev->dev);
 599 #endif
 600
 601         return hub;
 602 }
 603
 604 static int usb_hub_configure(struct usb_device *dev)
 605 {
 606         int i, length;
 607         ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, USB_BUFSIZ);
 608         unsigned char *bitmap;
 609         short hubCharacteristics;
 610         struct usb_hub_descriptor *descriptor;
 611         struct usb_hub_device *hub;
 612         __maybe_unused struct usb_hub_status *hubsts;
 613         int ret;
 614
 615         hub = usb_get_hub_device(dev);
 616         if (hub == NULL)
 617                 return -ENOMEM;
 618         hub->pusb_dev = dev;
 619
 620         /* Get the the hub descriptor */
 621         ret = usb_get_hub_descriptor(dev, buffer, 4);
 622         if (ret < 0) {
 623                 debug("usb_hub_configure: failed to get hub " \
 624                       "descriptor, giving up %lX\n", dev->status);
 625                 return ret;
 626         }
 627         descriptor = (struct usb_hub_descriptor *)buffer;
 628
 629         length = min_t(int, descriptor->bLength,
 630                        sizeof(struct usb_hub_descriptor));
 631
 632         ret = usb_get_hub_descriptor(dev, buffer, length);
 633         if (ret < 0) {
 634                 debug("usb_hub_configure: failed to get hub " \
 635                       "descriptor 2nd giving up %lX\n", dev->status);
 636                 return ret;
 637         }
 638         memcpy((unsigned char *)&hub->desc, buffer, length);
 639         /* adjust 16bit values */
 640         put_unaligned(le16_to_cpu(get_unaligned(
 641                         &descriptor->wHubCharacteristics)),
 642                         &hub->desc.wHubCharacteristics);
 643         /* set the bitmap */
 644         bitmap = (unsigned char *)&hub->desc.u.hs.DeviceRemovable[0];
 645         /* devices not removable by default */
 646         memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8);
 647         bitmap = (unsigned char *)&hub->desc.u.hs.PortPowerCtrlMask[0];
 648         memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */
 649
 650         for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
 651                 hub->desc.u.hs.DeviceRemovable[i] =
 652                         descriptor->u.hs.DeviceRemovable[i];
 653
 654         for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
 655                 hub->desc.u.hs.PortPowerCtrlMask[i] =
 656                         descriptor->u.hs.PortPowerCtrlMask[i];
 657
 658         dev->maxchild = descriptor->bNbrPorts;
 659         debug("%d ports detected\n", dev->maxchild);
 660
 661         hubCharacteristics = get_unaligned(&hub->desc.wHubCharacteristics);
 662         switch (hubCharacteristics & HUB_CHAR_LPSM) {
 663         case 0x00:
 664                 debug("ganged power switching\n");
 665                 break;
 666         case 0x01:
 667                 debug("individual port power switching\n");
 668                 break;
 669         case 0x02:
 670         case 0x03:
 671                 debug("unknown reserved power switching mode\n");
 672                 break;
 673         }
 674
 675         if (hubCharacteristics & HUB_CHAR_COMPOUND)
 676                 debug("part of a compound device\n");
 677         else
 678                 debug("standalone hub\n");
 679
 680         switch (hubCharacteristics & HUB_CHAR_OCPM) {
 681         case 0x00:
 682                 debug("global over-current protection\n");
 683                 break;
 684         case 0x08:
 685                 debug("individual port over-current protection\n");
 686                 break;
 687         case 0x10:
 688         case 0x18:
 689                 debug("no over-current protection\n");
 690                 break;
 691         }
 692
 693         debug("power on to power good time: %dms\n",
 694               descriptor->bPwrOn2PwrGood * 2);
 695         debug("hub controller current requirement: %dmA\n",
 696               descriptor->bHubContrCurrent);
 697
 698         for (i = 0; i < dev->maxchild; i++)
 699                 debug("port %d is%s removable\n", i + 1,
 700                       hub->desc.u.hs.DeviceRemovable[(i + 1) / 8] & \
 701                       (1 << ((i + 1) % 8)) ? " not" : "");
 702
 703         if (sizeof(struct usb_hub_status) > USB_BUFSIZ) {
 704                 debug("usb_hub_configure: failed to get Status - " \
 705                       "too long: %d\n", descriptor->bLength);
 706                 return -EFBIG;
 707         }
 708
 709         ret = usb_get_hub_status(dev, buffer);
 710         if (ret < 0) {
 711                 debug("usb_hub_configure: failed to get Status %lX\n",
 712                       dev->status);
 713                 return ret;
 714         }
 715
 716 #ifdef DEBUG
 717         hubsts = (struct usb_hub_status *)buffer;
 718 #endif
 719
 720         debug("get_hub_status returned status %X, change %X\n",
 721               le16_to_cpu(hubsts->wHubStatus),
 722               le16_to_cpu(hubsts->wHubChange));
 723         debug("local power source is %s\n",
 724               (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \
 725               "lost (inactive)" : "good");
 726         debug("%sover-current condition exists\n",
 727               (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \
 728               "" : "no ");
 729         usb_hub_power_on(hub);
 730
 731         /*
 732          * Reset any devices that may be in a bad state when applying
 733          * the power.  This is a __weak function.  Resetting of the devices
 734          * should occur in the board file of the device.
 735          */
 736         for (i = 0; i < dev->maxchild; i++)
 737                 usb_hub_reset_devices(i + 1);
 738
 739         /*
 740          * Only add the connected USB devices, including potential hubs,
 741          * to a scanning list. This list will get scanned and devices that
 742          * are detected (either via port connected or via port timeout)
 743          * will get removed from this list. Scanning of the devices on this
 744          * list will continue until all devices are removed.
 745          */
 746         for (i = 0; i < dev->maxchild; i++) {
 747                 struct usb_device_scan *usb_scan;
 748
 749                 usb_scan = calloc(1, sizeof(*usb_scan));
 750                 if (!usb_scan) {
 751                         printf("Can't allocate memory for USB device!\n");
 752                         return -ENOMEM;
 753                 }
 754                 usb_scan->dev = dev;
 755                 usb_scan->hub = hub;
 756                 usb_scan->port = i;
 757                 list_add_tail(&usb_scan->list, &usb_scan_list);
 758         }
 759
 760         /*
 761          * And now call the scanning code which loops over the generated list
 762          */
 763         ret = usb_device_list_scan();
 764
 765         return ret;
 766 }
 767
 768 static int usb_hub_check(struct usb_device *dev, int ifnum)
 769 {
 770         struct usb_interface *iface;
 771         struct usb_endpoint_descriptor *ep = NULL;
 772
 773         iface = &dev->config.if_desc[ifnum];
 774         /* Is it a hub? */
 775         if (iface->desc.bInterfaceClass != USB_CLASS_HUB)
 776                 goto err;
 777         /* Some hubs have a subclass of 1, which AFAICT according to the */
 778         /*  specs is not defined, but it works */
 779         if ((iface->desc.bInterfaceSubClass != 0) &&
 780             (iface->desc.bInterfaceSubClass != 1))
 781                 goto err;
 782         /* Multiple endpoints? What kind of mutant ninja-hub is this? */
 783         if (iface->desc.bNumEndpoints != 1)
 784                 goto err;
 785         ep = &iface->ep_desc[0];
 786         /* Output endpoint? Curiousier and curiousier.. */
 787         if (!(ep->bEndpointAddress & USB_DIR_IN))
 788                 goto err;
 789         /* If it's not an interrupt endpoint, we'd better punt! */
 790         if ((ep->bmAttributes & 3) != 3)
 791                 goto err;
 792         /* We found a hub */
 793         debug("USB hub found\n");
 794         return 0;
 795
 796 err:
 797         debug("USB hub not found: bInterfaceClass=%d, bInterfaceSubClass=%d, bNumEndpoints=%d\n",
 798               iface->desc.bInterfaceClass, iface->desc.bInterfaceSubClass,
 799               iface->desc.bNumEndpoints);
 800         if (ep) {
 801                 debug("   bEndpointAddress=%#x, bmAttributes=%d",
 802                       ep->bEndpointAddress, ep->bmAttributes);
 803         }
 804
 805         return -ENOENT;
 806 }
 807
 808 int usb_hub_probe(struct usb_device *dev, int ifnum)
 809 {
 810         int ret;
 811
 812         ret = usb_hub_check(dev, ifnum);
 813         if (ret)
 814                 return 0;
 815         ret = usb_hub_configure(dev);
 816         return ret;
 817 }
 818
 819 #ifdef CONFIG_DM_USB
 820 int usb_hub_scan(struct udevice *hub)
 821 {
 822         struct usb_device *udev = dev_get_parent_priv(hub);
 823
 824         return usb_hub_configure(udev);
 825 }
 826
 827 static int usb_hub_post_probe(struct udevice *dev)
 828 {
 829         debug("%s\n", __func__);
 830         return usb_hub_scan(dev);
 831 }
 832
 833 static const struct udevice_id usb_hub_ids[] = {
 834         { .compatible = "usb-hub" },
 835         { }
 836 };
 837
 838 U_BOOT_DRIVER(usb_generic_hub) = {
 839         .name   = "usb_hub",
 840         .id     = UCLASS_USB_HUB,
 841         .of_match = usb_hub_ids,
 842         .flags  = DM_FLAG_ALLOC_PRIV_DMA,
 843 };
 844
 845 UCLASS_DRIVER(usb_hub) = {
 846         .id             = UCLASS_USB_HUB,
 847         .name           = "usb_hub",
 848         .post_bind      = dm_scan_fdt_dev,
 849         .post_probe     = usb_hub_post_probe,
 850         .child_pre_probe        = usb_child_pre_probe,
 851         .per_child_auto_alloc_size = sizeof(struct usb_device),
 852         .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
 853         .per_device_auto_alloc_size = sizeof(struct usb_hub_device),
 854 };
 855
 856 static const struct usb_device_id hub_id_table[] = {
 857         {
 858                 .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
 859                 .bDeviceClass = USB_CLASS_HUB
 860         },
 861         { }     /* Terminating entry */
 862 };
 863
 864 U_BOOT_USB_DEVICE(usb_generic_hub, hub_id_table);
 865
 866 #endif