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 <asm/byteorder.h> 34 #ifdef CONFIG_SANDBOX 35 #include <asm/state.h> 36 #endif 37 #include <asm/unaligned.h> 38 #include <dm/root.h> 39 40 DECLARE_GLOBAL_DATA_PTR; 41 42 #include <usb.h> 43 #ifdef CONFIG_4xx 44 #include <asm/4xx_pci.h> 45 #endif 46 47 #define USB_BUFSIZ 512 48 49 /* TODO(sjg@chromium.org): Remove this when CONFIG_DM_USB is defined */ 50 static struct usb_hub_device hub_dev[USB_MAX_HUB]; 51 static int usb_hub_index; 52 53 __weak void usb_hub_reset_devices(int port) 54 { 55 return; 56 } 57 58 static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size) 59 { 60 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 61 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 62 USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT); 63 } 64 65 static int usb_clear_port_feature(struct usb_device *dev, int port, int feature) 66 { 67 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 68 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, 69 port, NULL, 0, USB_CNTL_TIMEOUT); 70 } 71 72 static int usb_set_port_feature(struct usb_device *dev, int port, int feature) 73 { 74 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 75 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, 76 port, NULL, 0, USB_CNTL_TIMEOUT); 77 } 78 79 static int usb_get_hub_status(struct usb_device *dev, void *data) 80 { 81 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 82 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 83 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 84 } 85 86 int usb_get_port_status(struct usb_device *dev, int port, void *data) 87 { 88 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 89 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port, 90 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 91 } 92 93 94 static void usb_hub_power_on(struct usb_hub_device *hub) 95 { 96 int i; 97 struct usb_device *dev; 98 unsigned pgood_delay = hub->desc.bPwrOn2PwrGood * 2; 99 const char *env; 100 101 dev = hub->pusb_dev; 102 103 debug("enabling power on all ports\n"); 104 for (i = 0; i < dev->maxchild; i++) { 105 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER); 106 debug("port %d returns %lX\n", i + 1, dev->status); 107 } 108 109 /* 110 * Wait for power to become stable, 111 * plus spec-defined max time for device to connect 112 * but allow this time to be increased via env variable as some 113 * devices break the spec and require longer warm-up times 114 */ 115 env = getenv("usb_pgood_delay"); 116 if (env) 117 pgood_delay = max(pgood_delay, 118 (unsigned)simple_strtol(env, NULL, 0)); 119 debug("pgood_delay=%dms\n", pgood_delay); 120 mdelay(pgood_delay + 1000); 121 } 122 123 void usb_hub_reset(void) 124 { 125 usb_hub_index = 0; 126 } 127 128 static struct usb_hub_device *usb_hub_allocate(void) 129 { 130 if (usb_hub_index < USB_MAX_HUB) 131 return &hub_dev[usb_hub_index++]; 132 133 printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB); 134 return NULL; 135 } 136 137 #define MAX_TRIES 5 138 139 static inline char *portspeed(int portstatus) 140 { 141 char *speed_str; 142 143 switch (portstatus & USB_PORT_STAT_SPEED_MASK) { 144 case USB_PORT_STAT_SUPER_SPEED: 145 speed_str = "5 Gb/s"; 146 break; 147 case USB_PORT_STAT_HIGH_SPEED: 148 speed_str = "480 Mb/s"; 149 break; 150 case USB_PORT_STAT_LOW_SPEED: 151 speed_str = "1.5 Mb/s"; 152 break; 153 default: 154 speed_str = "12 Mb/s"; 155 break; 156 } 157 158 return speed_str; 159 } 160 161 int legacy_hub_port_reset(struct usb_device *dev, int port, 162 unsigned short *portstat) 163 { 164 int err, tries; 165 ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1); 166 unsigned short portstatus, portchange; 167 168 #ifdef CONFIG_DM_USB 169 debug("%s: resetting '%s' port %d...\n", __func__, dev->dev->name, 170 port + 1); 171 #else 172 debug("%s: resetting port %d...\n", __func__, port + 1); 173 #endif 174 for (tries = 0; tries < MAX_TRIES; tries++) { 175 err = usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET); 176 if (err < 0) 177 return err; 178 179 mdelay(200); 180 181 if (usb_get_port_status(dev, port + 1, portsts) < 0) { 182 debug("get_port_status failed status %lX\n", 183 dev->status); 184 return -1; 185 } 186 portstatus = le16_to_cpu(portsts->wPortStatus); 187 portchange = le16_to_cpu(portsts->wPortChange); 188 189 debug("portstatus %x, change %x, %s\n", portstatus, portchange, 190 portspeed(portstatus)); 191 192 debug("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \ 193 " USB_PORT_STAT_ENABLE %d\n", 194 (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0, 195 (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0, 196 (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0); 197 198 /* 199 * Perhaps we should check for the following here: 200 * - C_CONNECTION hasn't been set. 201 * - CONNECTION is still set. 202 * 203 * Doing so would ensure that the device is still connected 204 * to the bus, and hasn't been unplugged or replaced while the 205 * USB bus reset was going on. 206 * 207 * However, if we do that, then (at least) a San Disk Ultra 208 * USB 3.0 16GB device fails to reset on (at least) an NVIDIA 209 * Tegra Jetson TK1 board. For some reason, the device appears 210 * to briefly drop off the bus when this second bus reset is 211 * executed, yet if we retry this loop, it'll eventually come 212 * back after another reset or two. 213 */ 214 215 if (portstatus & USB_PORT_STAT_ENABLE) 216 break; 217 218 mdelay(200); 219 } 220 221 if (tries == MAX_TRIES) { 222 debug("Cannot enable port %i after %i retries, " \ 223 "disabling port.\n", port + 1, MAX_TRIES); 224 debug("Maybe the USB cable is bad?\n"); 225 return -1; 226 } 227 228 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET); 229 *portstat = portstatus; 230 return 0; 231 } 232 233 #ifdef CONFIG_DM_USB 234 int hub_port_reset(struct udevice *dev, int port, unsigned short *portstat) 235 { 236 struct usb_device *udev = dev_get_parent_priv(dev); 237 238 return legacy_hub_port_reset(udev, port, portstat); 239 } 240 #endif 241 242 int usb_hub_port_connect_change(struct usb_device *dev, int port) 243 { 244 ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1); 245 unsigned short portstatus; 246 int ret, speed; 247 248 /* Check status */ 249 ret = usb_get_port_status(dev, port + 1, portsts); 250 if (ret < 0) { 251 debug("get_port_status failed\n"); 252 return ret; 253 } 254 255 portstatus = le16_to_cpu(portsts->wPortStatus); 256 debug("portstatus %x, change %x, %s\n", 257 portstatus, 258 le16_to_cpu(portsts->wPortChange), 259 portspeed(portstatus)); 260 261 /* Clear the connection change status */ 262 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION); 263 264 /* Disconnect any existing devices under this port */ 265 if (((!(portstatus & USB_PORT_STAT_CONNECTION)) && 266 (!(portstatus & USB_PORT_STAT_ENABLE))) || 267 usb_device_has_child_on_port(dev, port)) { 268 debug("usb_disconnect(&hub->children[port]);\n"); 269 /* Return now if nothing is connected */ 270 if (!(portstatus & USB_PORT_STAT_CONNECTION)) 271 return -ENOTCONN; 272 } 273 mdelay(200); 274 275 /* Reset the port */ 276 ret = legacy_hub_port_reset(dev, port, &portstatus); 277 if (ret < 0) { 278 if (ret != -ENXIO) 279 printf("cannot reset port %i!?\n", port + 1); 280 return ret; 281 } 282 283 mdelay(200); 284 285 switch (portstatus & USB_PORT_STAT_SPEED_MASK) { 286 case USB_PORT_STAT_SUPER_SPEED: 287 speed = USB_SPEED_SUPER; 288 break; 289 case USB_PORT_STAT_HIGH_SPEED: 290 speed = USB_SPEED_HIGH; 291 break; 292 case USB_PORT_STAT_LOW_SPEED: 293 speed = USB_SPEED_LOW; 294 break; 295 default: 296 speed = USB_SPEED_FULL; 297 break; 298 } 299 300 #ifdef CONFIG_DM_USB 301 struct udevice *child; 302 303 ret = usb_scan_device(dev->dev, port + 1, speed, &child); 304 #else 305 struct usb_device *usb; 306 307 ret = usb_alloc_new_device(dev->controller, &usb); 308 if (ret) { 309 printf("cannot create new device: ret=%d", ret); 310 return ret; 311 } 312 313 dev->children[port] = usb; 314 usb->speed = speed; 315 usb->parent = dev; 316 usb->portnr = port + 1; 317 /* Run it through the hoops (find a driver, etc) */ 318 ret = usb_new_device(usb); 319 if (ret < 0) { 320 /* Woops, disable the port */ 321 usb_free_device(dev->controller); 322 dev->children[port] = NULL; 323 } 324 #endif 325 if (ret < 0) { 326 debug("hub: disabling port %d\n", port + 1); 327 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE); 328 } 329 330 return ret; 331 } 332 333 334 static int usb_hub_configure(struct usb_device *dev) 335 { 336 int i, length; 337 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, USB_BUFSIZ); 338 unsigned char *bitmap; 339 short hubCharacteristics; 340 struct usb_hub_descriptor *descriptor; 341 struct usb_hub_device *hub; 342 __maybe_unused struct usb_hub_status *hubsts; 343 int ret; 344 345 /* "allocate" Hub device */ 346 hub = usb_hub_allocate(); 347 if (hub == NULL) 348 return -ENOMEM; 349 hub->pusb_dev = dev; 350 /* Get the the hub descriptor */ 351 ret = usb_get_hub_descriptor(dev, buffer, 4); 352 if (ret < 0) { 353 debug("usb_hub_configure: failed to get hub " \ 354 "descriptor, giving up %lX\n", dev->status); 355 return ret; 356 } 357 descriptor = (struct usb_hub_descriptor *)buffer; 358 359 length = min_t(int, descriptor->bLength, 360 sizeof(struct usb_hub_descriptor)); 361 362 ret = usb_get_hub_descriptor(dev, buffer, length); 363 if (ret < 0) { 364 debug("usb_hub_configure: failed to get hub " \ 365 "descriptor 2nd giving up %lX\n", dev->status); 366 return ret; 367 } 368 memcpy((unsigned char *)&hub->desc, buffer, length); 369 /* adjust 16bit values */ 370 put_unaligned(le16_to_cpu(get_unaligned( 371 &descriptor->wHubCharacteristics)), 372 &hub->desc.wHubCharacteristics); 373 /* set the bitmap */ 374 bitmap = (unsigned char *)&hub->desc.DeviceRemovable[0]; 375 /* devices not removable by default */ 376 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); 377 bitmap = (unsigned char *)&hub->desc.PortPowerCtrlMask[0]; 378 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */ 379 380 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++) 381 hub->desc.DeviceRemovable[i] = descriptor->DeviceRemovable[i]; 382 383 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++) 384 hub->desc.PortPowerCtrlMask[i] = descriptor->PortPowerCtrlMask[i]; 385 386 dev->maxchild = descriptor->bNbrPorts; 387 debug("%d ports detected\n", dev->maxchild); 388 389 hubCharacteristics = get_unaligned(&hub->desc.wHubCharacteristics); 390 switch (hubCharacteristics & HUB_CHAR_LPSM) { 391 case 0x00: 392 debug("ganged power switching\n"); 393 break; 394 case 0x01: 395 debug("individual port power switching\n"); 396 break; 397 case 0x02: 398 case 0x03: 399 debug("unknown reserved power switching mode\n"); 400 break; 401 } 402 403 if (hubCharacteristics & HUB_CHAR_COMPOUND) 404 debug("part of a compound device\n"); 405 else 406 debug("standalone hub\n"); 407 408 switch (hubCharacteristics & HUB_CHAR_OCPM) { 409 case 0x00: 410 debug("global over-current protection\n"); 411 break; 412 case 0x08: 413 debug("individual port over-current protection\n"); 414 break; 415 case 0x10: 416 case 0x18: 417 debug("no over-current protection\n"); 418 break; 419 } 420 421 debug("power on to power good time: %dms\n", 422 descriptor->bPwrOn2PwrGood * 2); 423 debug("hub controller current requirement: %dmA\n", 424 descriptor->bHubContrCurrent); 425 426 for (i = 0; i < dev->maxchild; i++) 427 debug("port %d is%s removable\n", i + 1, 428 hub->desc.DeviceRemovable[(i + 1) / 8] & \ 429 (1 << ((i + 1) % 8)) ? " not" : ""); 430 431 if (sizeof(struct usb_hub_status) > USB_BUFSIZ) { 432 debug("usb_hub_configure: failed to get Status - " \ 433 "too long: %d\n", descriptor->bLength); 434 return -EFBIG; 435 } 436 437 ret = usb_get_hub_status(dev, buffer); 438 if (ret < 0) { 439 debug("usb_hub_configure: failed to get Status %lX\n", 440 dev->status); 441 return ret; 442 } 443 444 #ifdef DEBUG 445 hubsts = (struct usb_hub_status *)buffer; 446 #endif 447 448 debug("get_hub_status returned status %X, change %X\n", 449 le16_to_cpu(hubsts->wHubStatus), 450 le16_to_cpu(hubsts->wHubChange)); 451 debug("local power source is %s\n", 452 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \ 453 "lost (inactive)" : "good"); 454 debug("%sover-current condition exists\n", 455 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \ 456 "" : "no "); 457 usb_hub_power_on(hub); 458 459 /* 460 * Reset any devices that may be in a bad state when applying 461 * the power. This is a __weak function. Resetting of the devices 462 * should occur in the board file of the device. 463 */ 464 for (i = 0; i < dev->maxchild; i++) 465 usb_hub_reset_devices(i + 1); 466 467 for (i = 0; i < dev->maxchild; i++) { 468 ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1); 469 unsigned short portstatus, portchange; 470 int ret; 471 ulong start = get_timer(0); 472 uint delay = CONFIG_SYS_HZ; 473 474 #ifdef CONFIG_SANDBOX 475 if (state_get_skip_delays()) 476 delay = 0; 477 #endif 478 #ifdef CONFIG_DM_USB 479 debug("\n\nScanning '%s' port %d\n", dev->dev->name, i + 1); 480 #else 481 debug("\n\nScanning port %d\n", i + 1); 482 #endif 483 /* 484 * Wait for (whichever finishes first) 485 * - A maximum of 10 seconds 486 * This is a purely observational value driven by connecting 487 * a few broken pen drives and taking the max * 1.5 approach 488 * - connection_change and connection state to report same 489 * state 490 */ 491 do { 492 ret = usb_get_port_status(dev, i + 1, portsts); 493 if (ret < 0) { 494 debug("get_port_status failed\n"); 495 break; 496 } 497 498 portstatus = le16_to_cpu(portsts->wPortStatus); 499 portchange = le16_to_cpu(portsts->wPortChange); 500 501 /* No connection change happened, wait a bit more. */ 502 if (!(portchange & USB_PORT_STAT_C_CONNECTION)) 503 continue; 504 505 /* Test if the connection came up, and if so, exit. */ 506 if (portstatus & USB_PORT_STAT_CONNECTION) 507 break; 508 509 } while (get_timer(start) < delay); 510 511 if (ret < 0) 512 continue; 513 514 debug("Port %d Status %X Change %X\n", 515 i + 1, portstatus, portchange); 516 517 if (portchange & USB_PORT_STAT_C_CONNECTION) { 518 debug("port %d connection change\n", i + 1); 519 usb_hub_port_connect_change(dev, i); 520 } 521 if (portchange & USB_PORT_STAT_C_ENABLE) { 522 debug("port %d enable change, status %x\n", 523 i + 1, portstatus); 524 usb_clear_port_feature(dev, i + 1, 525 USB_PORT_FEAT_C_ENABLE); 526 /* 527 * The following hack causes a ghost device problem 528 * to Faraday EHCI 529 */ 530 #ifndef CONFIG_USB_EHCI_FARADAY 531 /* EM interference sometimes causes bad shielded USB 532 * devices to be shutdown by the hub, this hack enables 533 * them again. Works at least with mouse driver */ 534 if (!(portstatus & USB_PORT_STAT_ENABLE) && 535 (portstatus & USB_PORT_STAT_CONNECTION) && 536 usb_device_has_child_on_port(dev, i)) { 537 debug("already running port %i " \ 538 "disabled by hub (EMI?), " \ 539 "re-enabling...\n", i + 1); 540 usb_hub_port_connect_change(dev, i); 541 } 542 #endif 543 } 544 if (portstatus & USB_PORT_STAT_SUSPEND) { 545 debug("port %d suspend change\n", i + 1); 546 usb_clear_port_feature(dev, i + 1, 547 USB_PORT_FEAT_SUSPEND); 548 } 549 550 if (portchange & USB_PORT_STAT_C_OVERCURRENT) { 551 debug("port %d over-current change\n", i + 1); 552 usb_clear_port_feature(dev, i + 1, 553 USB_PORT_FEAT_C_OVER_CURRENT); 554 usb_hub_power_on(hub); 555 } 556 557 if (portchange & USB_PORT_STAT_C_RESET) { 558 debug("port %d reset change\n", i + 1); 559 usb_clear_port_feature(dev, i + 1, 560 USB_PORT_FEAT_C_RESET); 561 } 562 } /* end for i all ports */ 563 564 return 0; 565 } 566 567 static int usb_hub_check(struct usb_device *dev, int ifnum) 568 { 569 struct usb_interface *iface; 570 struct usb_endpoint_descriptor *ep = NULL; 571 572 iface = &dev->config.if_desc[ifnum]; 573 /* Is it a hub? */ 574 if (iface->desc.bInterfaceClass != USB_CLASS_HUB) 575 goto err; 576 /* Some hubs have a subclass of 1, which AFAICT according to the */ 577 /* specs is not defined, but it works */ 578 if ((iface->desc.bInterfaceSubClass != 0) && 579 (iface->desc.bInterfaceSubClass != 1)) 580 goto err; 581 /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 582 if (iface->desc.bNumEndpoints != 1) 583 goto err; 584 ep = &iface->ep_desc[0]; 585 /* Output endpoint? Curiousier and curiousier.. */ 586 if (!(ep->bEndpointAddress & USB_DIR_IN)) 587 goto err; 588 /* If it's not an interrupt endpoint, we'd better punt! */ 589 if ((ep->bmAttributes & 3) != 3) 590 goto err; 591 /* We found a hub */ 592 debug("USB hub found\n"); 593 return 0; 594 595 err: 596 debug("USB hub not found: bInterfaceClass=%d, bInterfaceSubClass=%d, bNumEndpoints=%d\n", 597 iface->desc.bInterfaceClass, iface->desc.bInterfaceSubClass, 598 iface->desc.bNumEndpoints); 599 if (ep) { 600 debug(" bEndpointAddress=%#x, bmAttributes=%d", 601 ep->bEndpointAddress, ep->bmAttributes); 602 } 603 604 return -ENOENT; 605 } 606 607 int usb_hub_probe(struct usb_device *dev, int ifnum) 608 { 609 int ret; 610 611 ret = usb_hub_check(dev, ifnum); 612 if (ret) 613 return 0; 614 ret = usb_hub_configure(dev); 615 return ret; 616 } 617 618 #ifdef CONFIG_DM_USB 619 int usb_hub_scan(struct udevice *hub) 620 { 621 struct usb_device *udev = dev_get_parent_priv(hub); 622 623 return usb_hub_configure(udev); 624 } 625 626 static int usb_hub_post_bind(struct udevice *dev) 627 { 628 /* Scan the bus for devices */ 629 return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false); 630 } 631 632 static int usb_hub_post_probe(struct udevice *dev) 633 { 634 debug("%s\n", __func__); 635 return usb_hub_scan(dev); 636 } 637 638 static const struct udevice_id usb_hub_ids[] = { 639 { .compatible = "usb-hub" }, 640 { } 641 }; 642 643 U_BOOT_DRIVER(usb_generic_hub) = { 644 .name = "usb_hub", 645 .id = UCLASS_USB_HUB, 646 .of_match = usb_hub_ids, 647 .flags = DM_FLAG_ALLOC_PRIV_DMA, 648 }; 649 650 UCLASS_DRIVER(usb_hub) = { 651 .id = UCLASS_USB_HUB, 652 .name = "usb_hub", 653 .post_bind = usb_hub_post_bind, 654 .post_probe = usb_hub_post_probe, 655 .child_pre_probe = usb_child_pre_probe, 656 .per_child_auto_alloc_size = sizeof(struct usb_device), 657 .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata), 658 }; 659 660 static const struct usb_device_id hub_id_table[] = { 661 { 662 .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS, 663 .bDeviceClass = USB_CLASS_HUB 664 }, 665 { } /* Terminating entry */ 666 }; 667 668 U_BOOT_USB_DEVICE(usb_generic_hub, hub_id_table); 669 670 #endif 671