1
2
3
4
5
6
7
8
9#define LOG_CATEGORY UCLASS_USB
10
11#include <common.h>
12#include <dm.h>
13#include <errno.h>
14#include <log.h>
15#include <memalign.h>
16#include <usb.h>
17#include <dm/device-internal.h>
18#include <dm/lists.h>
19#include <dm/uclass-internal.h>
20
21extern bool usb_started;
22static bool asynch_allowed;
23
24struct usb_uclass_priv {
25 int companion_device_count;
26};
27
28int usb_lock_async(struct usb_device *udev, int lock)
29{
30 struct udevice *bus = udev->controller_dev;
31 struct dm_usb_ops *ops = usb_get_ops(bus);
32
33 if (!ops->lock_async)
34 return -ENOSYS;
35
36 return ops->lock_async(bus, lock);
37}
38
39int usb_disable_asynch(int disable)
40{
41 int old_value = asynch_allowed;
42
43 asynch_allowed = !disable;
44 return old_value;
45}
46
47int submit_int_msg(struct usb_device *udev, unsigned long pipe, void *buffer,
48 int length, int interval, bool nonblock)
49{
50 struct udevice *bus = udev->controller_dev;
51 struct dm_usb_ops *ops = usb_get_ops(bus);
52
53 if (!ops->interrupt)
54 return -ENOSYS;
55
56 return ops->interrupt(bus, udev, pipe, buffer, length, interval,
57 nonblock);
58}
59
60int submit_control_msg(struct usb_device *udev, unsigned long pipe,
61 void *buffer, int length, struct devrequest *setup)
62{
63 struct udevice *bus = udev->controller_dev;
64 struct dm_usb_ops *ops = usb_get_ops(bus);
65 struct usb_uclass_priv *uc_priv = uclass_get_priv(bus->uclass);
66 int err;
67
68 if (!ops->control)
69 return -ENOSYS;
70
71 err = ops->control(bus, udev, pipe, buffer, length, setup);
72 if (setup->request == USB_REQ_SET_FEATURE &&
73 setup->requesttype == USB_RT_PORT &&
74 setup->value == cpu_to_le16(USB_PORT_FEAT_RESET) &&
75 err == -ENXIO) {
76
77 uc_priv->companion_device_count++;
78 }
79
80 return err;
81}
82
83int submit_bulk_msg(struct usb_device *udev, unsigned long pipe, void *buffer,
84 int length)
85{
86 struct udevice *bus = udev->controller_dev;
87 struct dm_usb_ops *ops = usb_get_ops(bus);
88
89 if (!ops->bulk)
90 return -ENOSYS;
91
92 return ops->bulk(bus, udev, pipe, buffer, length);
93}
94
95struct int_queue *create_int_queue(struct usb_device *udev,
96 unsigned long pipe, int queuesize, int elementsize,
97 void *buffer, int interval)
98{
99 struct udevice *bus = udev->controller_dev;
100 struct dm_usb_ops *ops = usb_get_ops(bus);
101
102 if (!ops->create_int_queue)
103 return NULL;
104
105 return ops->create_int_queue(bus, udev, pipe, queuesize, elementsize,
106 buffer, interval);
107}
108
109void *poll_int_queue(struct usb_device *udev, struct int_queue *queue)
110{
111 struct udevice *bus = udev->controller_dev;
112 struct dm_usb_ops *ops = usb_get_ops(bus);
113
114 if (!ops->poll_int_queue)
115 return NULL;
116
117 return ops->poll_int_queue(bus, udev, queue);
118}
119
120int destroy_int_queue(struct usb_device *udev, struct int_queue *queue)
121{
122 struct udevice *bus = udev->controller_dev;
123 struct dm_usb_ops *ops = usb_get_ops(bus);
124
125 if (!ops->destroy_int_queue)
126 return -ENOSYS;
127
128 return ops->destroy_int_queue(bus, udev, queue);
129}
130
131int usb_alloc_device(struct usb_device *udev)
132{
133 struct udevice *bus = udev->controller_dev;
134 struct dm_usb_ops *ops = usb_get_ops(bus);
135
136
137 if (!ops->alloc_device)
138 return 0;
139
140 return ops->alloc_device(bus, udev);
141}
142
143int usb_reset_root_port(struct usb_device *udev)
144{
145 struct udevice *bus = udev->controller_dev;
146 struct dm_usb_ops *ops = usb_get_ops(bus);
147
148 if (!ops->reset_root_port)
149 return -ENOSYS;
150
151 return ops->reset_root_port(bus, udev);
152}
153
154int usb_update_hub_device(struct usb_device *udev)
155{
156 struct udevice *bus = udev->controller_dev;
157 struct dm_usb_ops *ops = usb_get_ops(bus);
158
159 if (!ops->update_hub_device)
160 return -ENOSYS;
161
162 return ops->update_hub_device(bus, udev);
163}
164
165int usb_get_max_xfer_size(struct usb_device *udev, size_t *size)
166{
167 struct udevice *bus = udev->controller_dev;
168 struct dm_usb_ops *ops = usb_get_ops(bus);
169
170 if (!ops->get_max_xfer_size)
171 return -ENOSYS;
172
173 return ops->get_max_xfer_size(bus, size);
174}
175
176int usb_stop(void)
177{
178 struct udevice *bus;
179 struct udevice *rh;
180 struct uclass *uc;
181 struct usb_uclass_priv *uc_priv;
182 int err = 0, ret;
183
184
185 ret = uclass_get(UCLASS_USB, &uc);
186 if (ret)
187 return ret;
188
189 uc_priv = uclass_get_priv(uc);
190
191 uclass_foreach_dev(bus, uc) {
192 ret = device_remove(bus, DM_REMOVE_NORMAL);
193 if (ret && !err)
194 err = ret;
195
196
197 device_find_first_child(bus, &rh);
198 if (rh) {
199
200
201
202
203 ret = device_unbind(rh);
204 if (ret && !err)
205 err = ret;
206 }
207 }
208
209#ifdef CONFIG_USB_STORAGE
210 usb_stor_reset();
211#endif
212 uc_priv->companion_device_count = 0;
213 usb_started = 0;
214
215 return err;
216}
217
218static void usb_scan_bus(struct udevice *bus, bool recurse)
219{
220 struct usb_bus_priv *priv;
221 struct udevice *dev;
222 int ret;
223
224 priv = dev_get_uclass_priv(bus);
225
226 assert(recurse);
227
228 printf("scanning bus %s for devices... ", bus->name);
229 debug("\n");
230 ret = usb_scan_device(bus, 0, USB_SPEED_FULL, &dev);
231 if (ret)
232 printf("failed, error %d\n", ret);
233 else if (priv->next_addr == 0)
234 printf("No USB Device found\n");
235 else
236 printf("%d USB Device(s) found\n", priv->next_addr);
237}
238
239static void remove_inactive_children(struct uclass *uc, struct udevice *bus)
240{
241 uclass_foreach_dev(bus, uc) {
242 struct udevice *dev, *next;
243
244 if (!device_active(bus))
245 continue;
246 device_foreach_child_safe(dev, next, bus) {
247 if (!device_active(dev))
248 device_unbind(dev);
249 }
250 }
251}
252
253int usb_init(void)
254{
255 int controllers_initialized = 0;
256 struct usb_uclass_priv *uc_priv;
257 struct usb_bus_priv *priv;
258 struct udevice *bus;
259 struct uclass *uc;
260 int ret;
261
262 asynch_allowed = 1;
263
264 ret = uclass_get(UCLASS_USB, &uc);
265 if (ret)
266 return ret;
267
268 uc_priv = uclass_get_priv(uc);
269
270 uclass_foreach_dev(bus, uc) {
271
272 printf("Bus %s: ", bus->name);
273
274#ifdef CONFIG_SANDBOX
275
276
277
278
279
280
281 ret = dm_scan_fdt_dev(bus);
282 if (ret) {
283 printf("Sandbox USB device scan failed (%d)\n", ret);
284 continue;
285 }
286#endif
287
288 ret = device_probe(bus);
289 if (ret == -ENODEV) {
290 puts("Port not available.\n");
291 controllers_initialized++;
292 continue;
293 }
294
295 if (ret) {
296 printf("probe failed, error %d\n", ret);
297 continue;
298 }
299 controllers_initialized++;
300 usb_started = true;
301 }
302
303
304
305
306
307 uclass_foreach_dev(bus, uc) {
308 if (!device_active(bus))
309 continue;
310
311 priv = dev_get_uclass_priv(bus);
312 if (!priv->companion)
313 usb_scan_bus(bus, true);
314 }
315
316
317
318
319
320
321 if (uc_priv->companion_device_count) {
322 uclass_foreach_dev(bus, uc) {
323 if (!device_active(bus))
324 continue;
325
326 priv = dev_get_uclass_priv(bus);
327 if (priv->companion)
328 usb_scan_bus(bus, true);
329 }
330 }
331
332 debug("scan end\n");
333
334
335 remove_inactive_children(uc, bus);
336
337 ret = uclass_get(UCLASS_USB_HUB, &uc);
338 if (ret)
339 return ret;
340 remove_inactive_children(uc, bus);
341
342
343 if (controllers_initialized == 0)
344 printf("No working controllers found\n");
345
346 return usb_started ? 0 : -1;
347}
348
349
350
351
352
353
354
355
356#if !defined(CONFIG_DM_ETH) && defined(CONFIG_USB_HOST_ETHER)
357static struct usb_device *find_child_devnum(struct udevice *parent, int devnum)
358{
359 struct usb_device *udev;
360 struct udevice *dev;
361
362 if (!device_active(parent))
363 return NULL;
364 udev = dev_get_parent_priv(parent);
365 if (udev->devnum == devnum)
366 return udev;
367
368 for (device_find_first_child(parent, &dev);
369 dev;
370 device_find_next_child(&dev)) {
371 udev = find_child_devnum(dev, devnum);
372 if (udev)
373 return udev;
374 }
375
376 return NULL;
377}
378
379struct usb_device *usb_get_dev_index(struct udevice *bus, int index)
380{
381 struct udevice *dev;
382 int devnum = index + 1;
383
384 device_find_first_child(bus, &dev);
385 if (!dev)
386 return NULL;
387
388 return find_child_devnum(dev, devnum);
389}
390#endif
391
392int usb_setup_ehci_gadget(struct ehci_ctrl **ctlrp)
393{
394 struct usb_plat *plat;
395 struct udevice *dev;
396 int ret;
397
398
399 ret = uclass_find_device_by_seq(UCLASS_USB, 0, &dev);
400 if (ret)
401 return ret;
402 ret = device_remove(dev, DM_REMOVE_NORMAL);
403 if (ret)
404 return ret;
405
406 plat = dev_get_plat(dev);
407 plat->init_type = USB_INIT_DEVICE;
408 ret = device_probe(dev);
409 if (ret)
410 return ret;
411 *ctlrp = dev_get_priv(dev);
412
413 return 0;
414}
415
416int usb_remove_ehci_gadget(struct ehci_ctrl **ctlrp)
417{
418 struct udevice *dev;
419 int ret;
420
421
422 ret = uclass_find_device_by_seq(UCLASS_USB, 0, &dev);
423 if (ret)
424 return ret;
425 ret = device_remove(dev, DM_REMOVE_NORMAL);
426 if (ret)
427 return ret;
428
429 *ctlrp = NULL;
430
431 return 0;
432}
433
434
435static int usb_match_device(const struct usb_device_descriptor *desc,
436 const struct usb_device_id *id)
437{
438 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
439 id->idVendor != desc->idVendor)
440 return 0;
441
442 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
443 id->idProduct != desc->idProduct)
444 return 0;
445
446
447
448 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
449 (id->bcdDevice_lo > desc->bcdDevice))
450 return 0;
451
452 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
453 (id->bcdDevice_hi < desc->bcdDevice))
454 return 0;
455
456 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
457 (id->bDeviceClass != desc->bDeviceClass))
458 return 0;
459
460 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
461 (id->bDeviceSubClass != desc->bDeviceSubClass))
462 return 0;
463
464 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
465 (id->bDeviceProtocol != desc->bDeviceProtocol))
466 return 0;
467
468 return 1;
469}
470
471
472static int usb_match_one_id_intf(const struct usb_device_descriptor *desc,
473 const struct usb_interface_descriptor *int_desc,
474 const struct usb_device_id *id)
475{
476
477
478
479 if (desc->bDeviceClass == USB_CLASS_VENDOR_SPEC &&
480 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
481 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
482 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
483 USB_DEVICE_ID_MATCH_INT_PROTOCOL |
484 USB_DEVICE_ID_MATCH_INT_NUMBER)))
485 return 0;
486
487 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
488 (id->bInterfaceClass != int_desc->bInterfaceClass))
489 return 0;
490
491 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
492 (id->bInterfaceSubClass != int_desc->bInterfaceSubClass))
493 return 0;
494
495 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
496 (id->bInterfaceProtocol != int_desc->bInterfaceProtocol))
497 return 0;
498
499 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
500 (id->bInterfaceNumber != int_desc->bInterfaceNumber))
501 return 0;
502
503 return 1;
504}
505
506
507static int usb_match_one_id(struct usb_device_descriptor *desc,
508 struct usb_interface_descriptor *int_desc,
509 const struct usb_device_id *id)
510{
511 if (!usb_match_device(desc, id))
512 return 0;
513
514 return usb_match_one_id_intf(desc, int_desc, id);
515}
516
517static ofnode usb_get_ofnode(struct udevice *hub, int port)
518{
519 ofnode node;
520 u32 reg;
521
522 if (!dev_has_ofnode(hub))
523 return ofnode_null();
524
525
526
527
528
529
530
531
532 if (!port)
533 return dev_ofnode(hub);
534
535 ofnode_for_each_subnode(node, dev_ofnode(hub)) {
536 if (ofnode_read_u32(node, "reg", ®))
537 continue;
538
539 if (reg == port)
540 return node;
541 }
542
543 return ofnode_null();
544}
545
546
547
548
549
550
551static int usb_find_and_bind_driver(struct udevice *parent,
552 struct usb_device_descriptor *desc,
553 struct usb_interface_descriptor *iface,
554 int bus_seq, int devnum, int port,
555 struct udevice **devp)
556{
557 struct usb_driver_entry *start, *entry;
558 int n_ents;
559 int ret;
560 char name[30], *str;
561 ofnode node = usb_get_ofnode(parent, port);
562
563 *devp = NULL;
564 debug("%s: Searching for driver\n", __func__);
565 start = ll_entry_start(struct usb_driver_entry, usb_driver_entry);
566 n_ents = ll_entry_count(struct usb_driver_entry, usb_driver_entry);
567 for (entry = start; entry != start + n_ents; entry++) {
568 const struct usb_device_id *id;
569 struct udevice *dev;
570 const struct driver *drv;
571 struct usb_dev_plat *plat;
572
573 for (id = entry->match; id->match_flags; id++) {
574 if (!usb_match_one_id(desc, iface, id))
575 continue;
576
577 drv = entry->driver;
578
579
580
581
582
583
584
585
586 ret = device_bind(parent, drv, drv->name, NULL, node,
587 &dev);
588 if (ret)
589 goto error;
590 debug("%s: Match found: %s\n", __func__, drv->name);
591 dev->driver_data = id->driver_info;
592 plat = dev_get_parent_plat(dev);
593 plat->id = *id;
594 *devp = dev;
595 return 0;
596 }
597 }
598
599
600 snprintf(name, sizeof(name), "generic_bus_%x_dev_%x", bus_seq, devnum);
601 str = strdup(name);
602 if (!str)
603 return -ENOMEM;
604 ret = device_bind_driver(parent, "usb_dev_generic_drv", str, devp);
605
606error:
607 debug("%s: No match found: %d\n", __func__, ret);
608 return ret;
609}
610
611
612
613
614
615
616static int usb_find_child(struct udevice *parent,
617 struct usb_device_descriptor *desc,
618 struct usb_interface_descriptor *iface,
619 struct udevice **devp)
620{
621 struct udevice *dev;
622
623 *devp = NULL;
624 for (device_find_first_child(parent, &dev);
625 dev;
626 device_find_next_child(&dev)) {
627 struct usb_dev_plat *plat = dev_get_parent_plat(dev);
628
629
630 if (device_active(dev))
631 continue;
632 debug(" %s: name='%s', plat=%d, desc=%d\n", __func__,
633 dev->name, plat->id.bDeviceClass, desc->bDeviceClass);
634 if (usb_match_one_id(desc, iface, &plat->id)) {
635 *devp = dev;
636 return 0;
637 }
638 }
639
640 return -ENOENT;
641}
642
643int usb_scan_device(struct udevice *parent, int port,
644 enum usb_device_speed speed, struct udevice **devp)
645{
646 struct udevice *dev;
647 bool created = false;
648 struct usb_dev_plat *plat;
649 struct usb_bus_priv *priv;
650 struct usb_device *parent_udev;
651 int ret;
652 ALLOC_CACHE_ALIGN_BUFFER(struct usb_device, udev, 1);
653 struct usb_interface_descriptor *iface = &udev->config.if_desc[0].desc;
654
655 *devp = NULL;
656 memset(udev, '\0', sizeof(*udev));
657 udev->controller_dev = usb_get_bus(parent);
658 priv = dev_get_uclass_priv(udev->controller_dev);
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688 udev->dev = parent;
689 udev->speed = speed;
690 udev->devnum = priv->next_addr + 1;
691 udev->portnr = port;
692 debug("Calling usb_setup_device(), portnr=%d\n", udev->portnr);
693 parent_udev = device_get_uclass_id(parent) == UCLASS_USB_HUB ?
694 dev_get_parent_priv(parent) : NULL;
695 ret = usb_setup_device(udev, priv->desc_before_addr, parent_udev);
696 debug("read_descriptor for '%s': ret=%d\n", parent->name, ret);
697 if (ret)
698 return ret;
699 ret = usb_find_child(parent, &udev->descriptor, iface, &dev);
700 debug("** usb_find_child returns %d\n", ret);
701 if (ret) {
702 if (ret != -ENOENT)
703 return ret;
704 ret = usb_find_and_bind_driver(parent, &udev->descriptor,
705 iface,
706 dev_seq(udev->controller_dev),
707 udev->devnum, port, &dev);
708 if (ret)
709 return ret;
710 created = true;
711 }
712 plat = dev_get_parent_plat(dev);
713 debug("%s: Probing '%s', plat=%p\n", __func__, dev->name, plat);
714 plat->devnum = udev->devnum;
715 plat->udev = udev;
716 priv->next_addr++;
717 ret = device_probe(dev);
718 if (ret) {
719 debug("%s: Device '%s' probe failed\n", __func__, dev->name);
720 priv->next_addr--;
721 if (created)
722 device_unbind(dev);
723 return ret;
724 }
725 *devp = dev;
726
727 return 0;
728}
729
730
731
732
733int usb_detect_change(void)
734{
735 struct udevice *hub;
736 struct uclass *uc;
737 int change = 0;
738 int ret;
739
740 ret = uclass_get(UCLASS_USB_HUB, &uc);
741 if (ret)
742 return ret;
743
744 uclass_foreach_dev(hub, uc) {
745 struct usb_device *udev;
746 struct udevice *dev;
747
748 if (!device_active(hub))
749 continue;
750 for (device_find_first_child(hub, &dev);
751 dev;
752 device_find_next_child(&dev)) {
753 struct usb_port_status status;
754
755 if (!device_active(dev))
756 continue;
757
758 udev = dev_get_parent_priv(dev);
759 if (usb_get_port_status(udev, udev->portnr, &status)
760 < 0)
761
762 continue;
763
764 if (le16_to_cpu(status.wPortChange) &
765 USB_PORT_STAT_C_CONNECTION)
766 change++;
767 }
768 }
769
770 return change;
771}
772
773static int usb_child_post_bind(struct udevice *dev)
774{
775 struct usb_dev_plat *plat = dev_get_parent_plat(dev);
776 int val;
777
778 if (!dev_has_ofnode(dev))
779 return 0;
780
781
782 val = dev_read_u32_default(dev, "usb,device-class", -1);
783 if (val != -1) {
784 plat->id.match_flags |= USB_DEVICE_ID_MATCH_DEV_CLASS;
785 plat->id.bDeviceClass = val;
786 }
787 val = dev_read_u32_default(dev, "usb,interface-class", -1);
788 if (val != -1) {
789 plat->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
790 plat->id.bInterfaceClass = val;
791 }
792
793 return 0;
794}
795
796struct udevice *usb_get_bus(struct udevice *dev)
797{
798 struct udevice *bus;
799
800 for (bus = dev; bus && device_get_uclass_id(bus) != UCLASS_USB; )
801 bus = bus->parent;
802 if (!bus) {
803
804 assert(bus);
805 debug("USB HUB '%s' does not have a controller\n", dev->name);
806 }
807
808 return bus;
809}
810
811int usb_child_pre_probe(struct udevice *dev)
812{
813 struct usb_device *udev = dev_get_parent_priv(dev);
814 struct usb_dev_plat *plat = dev_get_parent_plat(dev);
815 int ret;
816
817 if (plat->udev) {
818
819
820
821
822
823 *udev = *(plat->udev);
824
825 plat->udev = NULL;
826 udev->dev = dev;
827 } else {
828
829
830
831
832
833 udev->dev = dev;
834 udev->controller_dev = usb_get_bus(dev);
835 udev->devnum = plat->devnum;
836
837
838
839
840
841 ret = usb_select_config(udev);
842 if (ret)
843 return ret;
844 }
845
846 return 0;
847}
848
849UCLASS_DRIVER(usb) = {
850 .id = UCLASS_USB,
851 .name = "usb",
852 .flags = DM_UC_FLAG_SEQ_ALIAS,
853 .post_bind = dm_scan_fdt_dev,
854 .priv_auto = sizeof(struct usb_uclass_priv),
855 .per_child_auto = sizeof(struct usb_device),
856 .per_device_auto = sizeof(struct usb_bus_priv),
857 .child_post_bind = usb_child_post_bind,
858 .child_pre_probe = usb_child_pre_probe,
859 .per_child_plat_auto = sizeof(struct usb_dev_plat),
860};
861
862UCLASS_DRIVER(usb_dev_generic) = {
863 .id = UCLASS_USB_DEV_GENERIC,
864 .name = "usb_dev_generic",
865};
866
867U_BOOT_DRIVER(usb_dev_generic_drv) = {
868 .id = UCLASS_USB_DEV_GENERIC,
869 .name = "usb_dev_generic_drv",
870};
871