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