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