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