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