1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
40DECLARE_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#define HUB_SHORT_RESET_TIME 20
50#define HUB_LONG_RESET_TIME 200
51
52#define PORT_OVERCURRENT_MAX_SCAN_COUNT 3
53
54struct usb_device_scan {
55 struct usb_device *dev;
56 struct usb_hub_device *hub;
57 int port;
58 struct list_head list;
59};
60
61
62static struct usb_hub_device hub_dev[USB_MAX_HUB];
63static int usb_hub_index;
64static LIST_HEAD(usb_scan_list);
65
66__weak void usb_hub_reset_devices(int port)
67{
68 return;
69}
70
71static int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
72{
73 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
74 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
75 USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
76}
77
78static int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
79{
80 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
81 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature,
82 port, NULL, 0, USB_CNTL_TIMEOUT);
83}
84
85static int usb_set_port_feature(struct usb_device *dev, int port, int feature)
86{
87 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
88 USB_REQ_SET_FEATURE, USB_RT_PORT, feature,
89 port, NULL, 0, USB_CNTL_TIMEOUT);
90}
91
92static int usb_get_hub_status(struct usb_device *dev, void *data)
93{
94 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
95 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
96 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
97}
98
99int usb_get_port_status(struct usb_device *dev, int port, void *data)
100{
101 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
102 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
103 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
104}
105
106
107static void usb_hub_power_on(struct usb_hub_device *hub)
108{
109 int i;
110 struct usb_device *dev;
111 unsigned pgood_delay = hub->desc.bPwrOn2PwrGood * 2;
112 const char *env;
113
114 dev = hub->pusb_dev;
115
116 debug("enabling power on all ports\n");
117 for (i = 0; i < dev->maxchild; i++) {
118 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
119 debug("port %d returns %lX\n", i + 1, dev->status);
120 }
121
122#ifdef CONFIG_SANDBOX
123
124
125
126
127 if (state_get_skip_delays())
128 return;
129#endif
130
131
132
133
134
135
136
137 env = getenv("usb_pgood_delay");
138 if (env)
139 pgood_delay = max(pgood_delay,
140 (unsigned)simple_strtol(env, NULL, 0));
141 debug("pgood_delay=%dms\n", pgood_delay);
142
143
144
145
146
147 hub->query_delay = get_timer(0) + max(100, (int)pgood_delay);
148
149
150
151
152
153
154 hub->connect_timeout = hub->query_delay + 1000;
155 debug("devnum=%d poweron: query_delay=%d connect_timeout=%d\n",
156 dev->devnum, max(100, (int)pgood_delay),
157 max(100, (int)pgood_delay) + 1000);
158}
159
160void usb_hub_reset(void)
161{
162 usb_hub_index = 0;
163
164
165 memset(hub_dev, 0, sizeof(hub_dev));
166}
167
168static struct usb_hub_device *usb_hub_allocate(void)
169{
170 if (usb_hub_index < USB_MAX_HUB)
171 return &hub_dev[usb_hub_index++];
172
173 printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB);
174 return NULL;
175}
176
177#define MAX_TRIES 5
178
179static inline char *portspeed(int portstatus)
180{
181 char *speed_str;
182
183 switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
184 case USB_PORT_STAT_SUPER_SPEED:
185 speed_str = "5 Gb/s";
186 break;
187 case USB_PORT_STAT_HIGH_SPEED:
188 speed_str = "480 Mb/s";
189 break;
190 case USB_PORT_STAT_LOW_SPEED:
191 speed_str = "1.5 Mb/s";
192 break;
193 default:
194 speed_str = "12 Mb/s";
195 break;
196 }
197
198 return speed_str;
199}
200
201int legacy_hub_port_reset(struct usb_device *dev, int port,
202 unsigned short *portstat)
203{
204 int err, tries;
205 ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
206 unsigned short portstatus, portchange;
207 int delay = HUB_SHORT_RESET_TIME;
208
209#ifdef CONFIG_DM_USB
210 debug("%s: resetting '%s' port %d...\n", __func__, dev->dev->name,
211 port + 1);
212#else
213 debug("%s: resetting port %d...\n", __func__, port + 1);
214#endif
215 for (tries = 0; tries < MAX_TRIES; tries++) {
216 err = usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
217 if (err < 0)
218 return err;
219
220 mdelay(delay);
221
222 if (usb_get_port_status(dev, port + 1, portsts) < 0) {
223 debug("get_port_status failed status %lX\n",
224 dev->status);
225 return -1;
226 }
227 portstatus = le16_to_cpu(portsts->wPortStatus);
228 portchange = le16_to_cpu(portsts->wPortChange);
229
230 debug("portstatus %x, change %x, %s\n", portstatus, portchange,
231 portspeed(portstatus));
232
233 debug("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
234 " USB_PORT_STAT_ENABLE %d\n",
235 (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
236 (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
237 (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256 if (portstatus & USB_PORT_STAT_ENABLE)
257 break;
258
259
260 delay = HUB_LONG_RESET_TIME;
261 }
262
263 if (tries == MAX_TRIES) {
264 debug("Cannot enable port %i after %i retries, " \
265 "disabling port.\n", port + 1, MAX_TRIES);
266 debug("Maybe the USB cable is bad?\n");
267 return -1;
268 }
269
270 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
271 *portstat = portstatus;
272 return 0;
273}
274
275#ifdef CONFIG_DM_USB
276int hub_port_reset(struct udevice *dev, int port, unsigned short *portstat)
277{
278 struct usb_device *udev = dev_get_parent_priv(dev);
279
280 return legacy_hub_port_reset(udev, port, portstat);
281}
282#endif
283
284int usb_hub_port_connect_change(struct usb_device *dev, int port)
285{
286 ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
287 unsigned short portstatus;
288 int ret, speed;
289
290
291 ret = usb_get_port_status(dev, port + 1, portsts);
292 if (ret < 0) {
293 debug("get_port_status failed\n");
294 return ret;
295 }
296
297 portstatus = le16_to_cpu(portsts->wPortStatus);
298 debug("portstatus %x, change %x, %s\n",
299 portstatus,
300 le16_to_cpu(portsts->wPortChange),
301 portspeed(portstatus));
302
303
304 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);
305
306
307 if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
308 (!(portstatus & USB_PORT_STAT_ENABLE))) ||
309 usb_device_has_child_on_port(dev, port)) {
310 debug("usb_disconnect(&hub->children[port]);\n");
311
312 if (!(portstatus & USB_PORT_STAT_CONNECTION))
313 return -ENOTCONN;
314 }
315
316
317 ret = legacy_hub_port_reset(dev, port, &portstatus);
318 if (ret < 0) {
319 if (ret != -ENXIO)
320 printf("cannot reset port %i!?\n", port + 1);
321 return ret;
322 }
323
324 switch (portstatus & USB_PORT_STAT_SPEED_MASK) {
325 case USB_PORT_STAT_SUPER_SPEED:
326 speed = USB_SPEED_SUPER;
327 break;
328 case USB_PORT_STAT_HIGH_SPEED:
329 speed = USB_SPEED_HIGH;
330 break;
331 case USB_PORT_STAT_LOW_SPEED:
332 speed = USB_SPEED_LOW;
333 break;
334 default:
335 speed = USB_SPEED_FULL;
336 break;
337 }
338
339#ifdef CONFIG_DM_USB
340 struct udevice *child;
341
342 ret = usb_scan_device(dev->dev, port + 1, speed, &child);
343#else
344 struct usb_device *usb;
345
346 ret = usb_alloc_new_device(dev->controller, &usb);
347 if (ret) {
348 printf("cannot create new device: ret=%d", ret);
349 return ret;
350 }
351
352 dev->children[port] = usb;
353 usb->speed = speed;
354 usb->parent = dev;
355 usb->portnr = port + 1;
356
357 ret = usb_new_device(usb);
358 if (ret < 0) {
359
360 usb_free_device(dev->controller);
361 dev->children[port] = NULL;
362 }
363#endif
364 if (ret < 0) {
365 debug("hub: disabling port %d\n", port + 1);
366 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
367 }
368
369 return ret;
370}
371
372static int usb_scan_port(struct usb_device_scan *usb_scan)
373{
374 ALLOC_CACHE_ALIGN_BUFFER(struct usb_port_status, portsts, 1);
375 unsigned short portstatus;
376 unsigned short portchange;
377 struct usb_device *dev;
378 struct usb_hub_device *hub;
379 int ret = 0;
380 int i;
381
382 dev = usb_scan->dev;
383 hub = usb_scan->hub;
384 i = usb_scan->port;
385
386
387
388
389
390 if (get_timer(0) < hub->query_delay)
391 return 0;
392
393 ret = usb_get_port_status(dev, i + 1, portsts);
394 if (ret < 0) {
395 debug("get_port_status failed\n");
396 if (get_timer(0) >= hub->connect_timeout) {
397 debug("devnum=%d port=%d: timeout\n",
398 dev->devnum, i + 1);
399
400 list_del(&usb_scan->list);
401 free(usb_scan);
402 return 0;
403 }
404 return 0;
405 }
406
407 portstatus = le16_to_cpu(portsts->wPortStatus);
408 portchange = le16_to_cpu(portsts->wPortChange);
409 debug("Port %d Status %X Change %X\n", i + 1, portstatus, portchange);
410
411
412 if (!(portchange & USB_PORT_STAT_C_CONNECTION)) {
413 if (get_timer(0) >= hub->connect_timeout) {
414 debug("devnum=%d port=%d: timeout\n",
415 dev->devnum, i + 1);
416
417 list_del(&usb_scan->list);
418 free(usb_scan);
419 return 0;
420 }
421 return 0;
422 }
423
424
425 if (!(portstatus & USB_PORT_STAT_CONNECTION))
426 return 0;
427
428
429 debug("devnum=%d port=%d: USB dev found\n", dev->devnum, i + 1);
430
431 usb_hub_port_connect_change(dev, i);
432
433 if (portchange & USB_PORT_STAT_C_ENABLE) {
434 debug("port %d enable change, status %x\n", i + 1, portstatus);
435 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
436
437
438
439
440#ifndef CONFIG_USB_EHCI_FARADAY
441
442
443
444
445
446 if (!(portstatus & USB_PORT_STAT_ENABLE) &&
447 (portstatus & USB_PORT_STAT_CONNECTION) &&
448 usb_device_has_child_on_port(dev, i)) {
449 debug("already running port %i disabled by hub (EMI?), re-enabling...\n",
450 i + 1);
451 usb_hub_port_connect_change(dev, i);
452 }
453#endif
454 }
455
456 if (portstatus & USB_PORT_STAT_SUSPEND) {
457 debug("port %d suspend change\n", i + 1);
458 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_SUSPEND);
459 }
460
461 if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
462 debug("port %d over-current change\n", i + 1);
463 usb_clear_port_feature(dev, i + 1,
464 USB_PORT_FEAT_C_OVER_CURRENT);
465
466 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
467 hub->overcurrent_count[i]++;
468
469
470
471
472
473 if (hub->overcurrent_count[i] <=
474 PORT_OVERCURRENT_MAX_SCAN_COUNT)
475 return 0;
476
477
478 printf("Port %d over-current occurred %d times\n", i + 1,
479 hub->overcurrent_count[i]);
480 }
481
482 if (portchange & USB_PORT_STAT_C_RESET) {
483 debug("port %d reset change\n", i + 1);
484 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
485 }
486
487
488
489
490
491 list_del(&usb_scan->list);
492 free(usb_scan);
493
494 return 0;
495}
496
497static int usb_device_list_scan(void)
498{
499 struct usb_device_scan *usb_scan;
500 struct usb_device_scan *tmp;
501 static int running;
502 int ret = 0;
503
504
505 if (running)
506 return 0;
507
508 running = 1;
509
510 while (1) {
511
512 if (list_empty(&usb_scan_list))
513 goto out;
514
515 list_for_each_entry_safe(usb_scan, tmp, &usb_scan_list, list) {
516 int ret;
517
518
519 ret = usb_scan_port(usb_scan);
520 if (ret)
521 goto out;
522 }
523 }
524
525out:
526
527
528
529
530
531 running = 0;
532
533 return ret;
534}
535
536static int usb_hub_configure(struct usb_device *dev)
537{
538 int i, length;
539 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, USB_BUFSIZ);
540 unsigned char *bitmap;
541 short hubCharacteristics;
542 struct usb_hub_descriptor *descriptor;
543 struct usb_hub_device *hub;
544 __maybe_unused struct usb_hub_status *hubsts;
545 int ret;
546
547
548 hub = usb_hub_allocate();
549 if (hub == NULL)
550 return -ENOMEM;
551 hub->pusb_dev = dev;
552
553 ret = usb_get_hub_descriptor(dev, buffer, 4);
554 if (ret < 0) {
555 debug("usb_hub_configure: failed to get hub " \
556 "descriptor, giving up %lX\n", dev->status);
557 return ret;
558 }
559 descriptor = (struct usb_hub_descriptor *)buffer;
560
561 length = min_t(int, descriptor->bLength,
562 sizeof(struct usb_hub_descriptor));
563
564 ret = usb_get_hub_descriptor(dev, buffer, length);
565 if (ret < 0) {
566 debug("usb_hub_configure: failed to get hub " \
567 "descriptor 2nd giving up %lX\n", dev->status);
568 return ret;
569 }
570 memcpy((unsigned char *)&hub->desc, buffer, length);
571
572 put_unaligned(le16_to_cpu(get_unaligned(
573 &descriptor->wHubCharacteristics)),
574 &hub->desc.wHubCharacteristics);
575
576 bitmap = (unsigned char *)&hub->desc.DeviceRemovable[0];
577
578 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8);
579 bitmap = (unsigned char *)&hub->desc.PortPowerCtrlMask[0];
580 memset(bitmap, 0xff, (USB_MAXCHILDREN+1+7)/8);
581
582 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
583 hub->desc.DeviceRemovable[i] = descriptor->DeviceRemovable[i];
584
585 for (i = 0; i < ((hub->desc.bNbrPorts + 1 + 7)/8); i++)
586 hub->desc.PortPowerCtrlMask[i] = descriptor->PortPowerCtrlMask[i];
587
588 dev->maxchild = descriptor->bNbrPorts;
589 debug("%d ports detected\n", dev->maxchild);
590
591 hubCharacteristics = get_unaligned(&hub->desc.wHubCharacteristics);
592 switch (hubCharacteristics & HUB_CHAR_LPSM) {
593 case 0x00:
594 debug("ganged power switching\n");
595 break;
596 case 0x01:
597 debug("individual port power switching\n");
598 break;
599 case 0x02:
600 case 0x03:
601 debug("unknown reserved power switching mode\n");
602 break;
603 }
604
605 if (hubCharacteristics & HUB_CHAR_COMPOUND)
606 debug("part of a compound device\n");
607 else
608 debug("standalone hub\n");
609
610 switch (hubCharacteristics & HUB_CHAR_OCPM) {
611 case 0x00:
612 debug("global over-current protection\n");
613 break;
614 case 0x08:
615 debug("individual port over-current protection\n");
616 break;
617 case 0x10:
618 case 0x18:
619 debug("no over-current protection\n");
620 break;
621 }
622
623 debug("power on to power good time: %dms\n",
624 descriptor->bPwrOn2PwrGood * 2);
625 debug("hub controller current requirement: %dmA\n",
626 descriptor->bHubContrCurrent);
627
628 for (i = 0; i < dev->maxchild; i++)
629 debug("port %d is%s removable\n", i + 1,
630 hub->desc.DeviceRemovable[(i + 1) / 8] & \
631 (1 << ((i + 1) % 8)) ? " not" : "");
632
633 if (sizeof(struct usb_hub_status) > USB_BUFSIZ) {
634 debug("usb_hub_configure: failed to get Status - " \
635 "too long: %d\n", descriptor->bLength);
636 return -EFBIG;
637 }
638
639 ret = usb_get_hub_status(dev, buffer);
640 if (ret < 0) {
641 debug("usb_hub_configure: failed to get Status %lX\n",
642 dev->status);
643 return ret;
644 }
645
646#ifdef DEBUG
647 hubsts = (struct usb_hub_status *)buffer;
648#endif
649
650 debug("get_hub_status returned status %X, change %X\n",
651 le16_to_cpu(hubsts->wHubStatus),
652 le16_to_cpu(hubsts->wHubChange));
653 debug("local power source is %s\n",
654 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? \
655 "lost (inactive)" : "good");
656 debug("%sover-current condition exists\n",
657 (le16_to_cpu(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? \
658 "" : "no ");
659 usb_hub_power_on(hub);
660
661
662
663
664
665
666 for (i = 0; i < dev->maxchild; i++)
667 usb_hub_reset_devices(i + 1);
668
669
670
671
672
673
674
675
676 for (i = 0; i < dev->maxchild; i++) {
677 struct usb_device_scan *usb_scan;
678
679 usb_scan = calloc(1, sizeof(*usb_scan));
680 if (!usb_scan) {
681 printf("Can't allocate memory for USB device!\n");
682 return -ENOMEM;
683 }
684 usb_scan->dev = dev;
685 usb_scan->hub = hub;
686 usb_scan->port = i;
687 list_add_tail(&usb_scan->list, &usb_scan_list);
688 }
689
690
691
692
693 ret = usb_device_list_scan();
694
695 return ret;
696}
697
698static int usb_hub_check(struct usb_device *dev, int ifnum)
699{
700 struct usb_interface *iface;
701 struct usb_endpoint_descriptor *ep = NULL;
702
703 iface = &dev->config.if_desc[ifnum];
704
705 if (iface->desc.bInterfaceClass != USB_CLASS_HUB)
706 goto err;
707
708
709 if ((iface->desc.bInterfaceSubClass != 0) &&
710 (iface->desc.bInterfaceSubClass != 1))
711 goto err;
712
713 if (iface->desc.bNumEndpoints != 1)
714 goto err;
715 ep = &iface->ep_desc[0];
716
717 if (!(ep->bEndpointAddress & USB_DIR_IN))
718 goto err;
719
720 if ((ep->bmAttributes & 3) != 3)
721 goto err;
722
723 debug("USB hub found\n");
724 return 0;
725
726err:
727 debug("USB hub not found: bInterfaceClass=%d, bInterfaceSubClass=%d, bNumEndpoints=%d\n",
728 iface->desc.bInterfaceClass, iface->desc.bInterfaceSubClass,
729 iface->desc.bNumEndpoints);
730 if (ep) {
731 debug(" bEndpointAddress=%#x, bmAttributes=%d",
732 ep->bEndpointAddress, ep->bmAttributes);
733 }
734
735 return -ENOENT;
736}
737
738int usb_hub_probe(struct usb_device *dev, int ifnum)
739{
740 int ret;
741
742 ret = usb_hub_check(dev, ifnum);
743 if (ret)
744 return 0;
745 ret = usb_hub_configure(dev);
746 return ret;
747}
748
749#ifdef CONFIG_DM_USB
750int usb_hub_scan(struct udevice *hub)
751{
752 struct usb_device *udev = dev_get_parent_priv(hub);
753
754 return usb_hub_configure(udev);
755}
756
757static int usb_hub_post_probe(struct udevice *dev)
758{
759 debug("%s\n", __func__);
760 return usb_hub_scan(dev);
761}
762
763static const struct udevice_id usb_hub_ids[] = {
764 { .compatible = "usb-hub" },
765 { }
766};
767
768U_BOOT_DRIVER(usb_generic_hub) = {
769 .name = "usb_hub",
770 .id = UCLASS_USB_HUB,
771 .of_match = usb_hub_ids,
772 .flags = DM_FLAG_ALLOC_PRIV_DMA,
773};
774
775UCLASS_DRIVER(usb_hub) = {
776 .id = UCLASS_USB_HUB,
777 .name = "usb_hub",
778 .post_bind = dm_scan_fdt_dev,
779 .post_probe = usb_hub_post_probe,
780 .child_pre_probe = usb_child_pre_probe,
781 .per_child_auto_alloc_size = sizeof(struct usb_device),
782 .per_child_platdata_auto_alloc_size = sizeof(struct usb_dev_platdata),
783};
784
785static const struct usb_device_id hub_id_table[] = {
786 {
787 .match_flags = USB_DEVICE_ID_MATCH_DEV_CLASS,
788 .bDeviceClass = USB_CLASS_HUB
789 },
790 { }
791};
792
793U_BOOT_USB_DEVICE(usb_generic_hub, hub_id_table);
794
795#endif
796