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
26
27
28
29#include <common.h>
30#include <command.h>
31#include <dm.h>
32#include <memalign.h>
33#include <asm/processor.h>
34#include <linux/compiler.h>
35#include <linux/ctype.h>
36#include <asm/byteorder.h>
37#include <asm/unaligned.h>
38#include <errno.h>
39#include <usb.h>
40
41#define USB_BUFSIZ 512
42
43static int asynch_allowed;
44char usb_started;
45
46#ifndef CONFIG_DM_USB
47static struct usb_device usb_dev[USB_MAX_DEVICE];
48static int dev_index;
49
50#ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
51#define CONFIG_USB_MAX_CONTROLLER_COUNT 1
52#endif
53
54
55
56
57int usb_init(void)
58{
59 void *ctrl;
60 struct usb_device *dev;
61 int i, start_index = 0;
62 int controllers_initialized = 0;
63 int ret;
64
65 dev_index = 0;
66 asynch_allowed = 1;
67 usb_hub_reset();
68
69
70 for (i = 0; i < USB_MAX_DEVICE; i++) {
71 memset(&usb_dev[i], 0, sizeof(struct usb_device));
72 usb_dev[i].devnum = -1;
73 }
74
75
76 for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
77
78 printf("USB%d: ", i);
79 ret = usb_lowlevel_init(i, USB_INIT_HOST, &ctrl);
80 if (ret == -ENODEV) {
81 puts("Port not available.\n");
82 controllers_initialized++;
83 continue;
84 }
85
86 if (ret) {
87 puts("lowlevel init failed\n");
88 continue;
89 }
90
91
92
93
94 controllers_initialized++;
95 start_index = dev_index;
96 printf("scanning bus %d for devices... ", i);
97 ret = usb_alloc_new_device(ctrl, &dev);
98 if (ret)
99 break;
100
101
102
103
104
105 ret = usb_new_device(dev);
106 if (ret)
107 usb_free_device(dev->controller);
108
109 if (start_index == dev_index) {
110 puts("No USB Device found\n");
111 continue;
112 } else {
113 printf("%d USB Device(s) found\n",
114 dev_index - start_index);
115 }
116
117 usb_started = 1;
118 }
119
120 debug("scan end\n");
121
122 if (controllers_initialized == 0)
123 puts("USB error: all controllers failed lowlevel init\n");
124
125 return usb_started ? 0 : -ENODEV;
126}
127
128
129
130
131int usb_stop(void)
132{
133 int i;
134
135 if (usb_started) {
136 asynch_allowed = 1;
137 usb_started = 0;
138 usb_hub_reset();
139
140 for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
141 if (usb_lowlevel_stop(i))
142 printf("failed to stop USB controller %d\n", i);
143 }
144 }
145
146 return 0;
147}
148
149
150
151
152int usb_detect_change(void)
153{
154 int i, j;
155 int change = 0;
156
157 for (j = 0; j < USB_MAX_DEVICE; j++) {
158 for (i = 0; i < usb_dev[j].maxchild; i++) {
159 struct usb_port_status status;
160
161 if (usb_get_port_status(&usb_dev[j], i + 1,
162 &status) < 0)
163
164 continue;
165
166 if (le16_to_cpu(status.wPortChange) &
167 USB_PORT_STAT_C_CONNECTION)
168 change++;
169 }
170 }
171
172 return change;
173}
174
175
176
177
178
179
180int usb_disable_asynch(int disable)
181{
182 int old_value = asynch_allowed;
183
184 asynch_allowed = !disable;
185 return old_value;
186}
187#endif
188
189
190
191
192
193
194
195
196
197
198int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
199 void *buffer, int transfer_len, int interval)
200{
201 return submit_int_msg(dev, pipe, buffer, transfer_len, interval);
202}
203
204
205
206
207
208
209
210
211
212
213int usb_control_msg(struct usb_device *dev, unsigned int pipe,
214 unsigned char request, unsigned char requesttype,
215 unsigned short value, unsigned short index,
216 void *data, unsigned short size, int timeout)
217{
218 ALLOC_CACHE_ALIGN_BUFFER(struct devrequest, setup_packet, 1);
219 int err;
220
221 if ((timeout == 0) && (!asynch_allowed)) {
222
223 return -EINVAL;
224 }
225
226
227 setup_packet->requesttype = requesttype;
228 setup_packet->request = request;
229 setup_packet->value = cpu_to_le16(value);
230 setup_packet->index = cpu_to_le16(index);
231 setup_packet->length = cpu_to_le16(size);
232 debug("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
233 "value 0x%X index 0x%X length 0x%X\n",
234 request, requesttype, value, index, size);
235 dev->status = USB_ST_NOT_PROC;
236
237 err = submit_control_msg(dev, pipe, data, size, setup_packet);
238 if (err < 0)
239 return err;
240 if (timeout == 0)
241 return (int)size;
242
243
244
245
246
247
248 while (timeout--) {
249 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
250 break;
251 mdelay(1);
252 }
253 if (dev->status)
254 return -1;
255
256 return dev->act_len;
257
258}
259
260
261
262
263
264
265int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
266 void *data, int len, int *actual_length, int timeout)
267{
268 if (len < 0)
269 return -EINVAL;
270 dev->status = USB_ST_NOT_PROC;
271 if (submit_bulk_msg(dev, pipe, data, len) < 0)
272 return -EIO;
273 while (timeout--) {
274 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
275 break;
276 mdelay(1);
277 }
278 *actual_length = dev->act_len;
279 if (dev->status == 0)
280 return 0;
281 else
282 return -EIO;
283}
284
285
286
287
288
289
290
291
292
293
294int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
295{
296
297 if ((pipe & USB_DIR_IN) == 0)
298 return dev->epmaxpacketout[((pipe>>15) & 0xf)];
299 else
300 return dev->epmaxpacketin[((pipe>>15) & 0xf)];
301}
302
303
304
305
306
307
308
309
310
311
312
313
314static void noinline
315usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx)
316{
317 int b;
318 struct usb_endpoint_descriptor *ep;
319 u16 ep_wMaxPacketSize;
320
321 ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx];
322
323 b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
324 ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize);
325
326 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
327 USB_ENDPOINT_XFER_CONTROL) {
328
329 dev->epmaxpacketout[b] = ep_wMaxPacketSize;
330 dev->epmaxpacketin[b] = ep_wMaxPacketSize;
331 debug("##Control EP epmaxpacketout/in[%d] = %d\n",
332 b, dev->epmaxpacketin[b]);
333 } else {
334 if ((ep->bEndpointAddress & 0x80) == 0) {
335
336 if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) {
337 dev->epmaxpacketout[b] = ep_wMaxPacketSize;
338 debug("##EP epmaxpacketout[%d] = %d\n",
339 b, dev->epmaxpacketout[b]);
340 }
341 } else {
342
343 if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) {
344 dev->epmaxpacketin[b] = ep_wMaxPacketSize;
345 debug("##EP epmaxpacketin[%d] = %d\n",
346 b, dev->epmaxpacketin[b]);
347 }
348 }
349 }
350}
351
352
353
354
355static int usb_set_maxpacket(struct usb_device *dev)
356{
357 int i, ii;
358
359 for (i = 0; i < dev->config.desc.bNumInterfaces; i++)
360 for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++)
361 usb_set_maxpacket_ep(dev, i, ii);
362
363 return 0;
364}
365
366
367
368
369
370
371static int usb_parse_config(struct usb_device *dev,
372 unsigned char *buffer, int cfgno)
373{
374 struct usb_descriptor_header *head;
375 int index, ifno, epno, curr_if_num;
376 u16 ep_wMaxPacketSize;
377 struct usb_interface *if_desc = NULL;
378
379 ifno = -1;
380 epno = -1;
381 curr_if_num = -1;
382
383 dev->configno = cfgno;
384 head = (struct usb_descriptor_header *) &buffer[0];
385 if (head->bDescriptorType != USB_DT_CONFIG) {
386 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
387 head->bDescriptorType);
388 return -EINVAL;
389 }
390 if (head->bLength != USB_DT_CONFIG_SIZE) {
391 printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength);
392 return -EINVAL;
393 }
394 memcpy(&dev->config, head, USB_DT_CONFIG_SIZE);
395 dev->config.no_of_if = 0;
396
397 index = dev->config.desc.bLength;
398
399
400 head = (struct usb_descriptor_header *) &buffer[index];
401 while (index + 1 < dev->config.desc.wTotalLength && head->bLength) {
402 switch (head->bDescriptorType) {
403 case USB_DT_INTERFACE:
404 if (head->bLength != USB_DT_INTERFACE_SIZE) {
405 printf("ERROR: Invalid USB IF length (%d)\n",
406 head->bLength);
407 break;
408 }
409 if (index + USB_DT_INTERFACE_SIZE >
410 dev->config.desc.wTotalLength) {
411 puts("USB IF descriptor overflowed buffer!\n");
412 break;
413 }
414 if (((struct usb_interface_descriptor *) \
415 head)->bInterfaceNumber != curr_if_num) {
416
417 ifno = dev->config.no_of_if;
418 if (ifno >= USB_MAXINTERFACES) {
419 puts("Too many USB interfaces!\n");
420
421 return -EINVAL;
422 }
423 if_desc = &dev->config.if_desc[ifno];
424 dev->config.no_of_if++;
425 memcpy(if_desc, head,
426 USB_DT_INTERFACE_SIZE);
427 if_desc->no_of_ep = 0;
428 if_desc->num_altsetting = 1;
429 curr_if_num =
430 if_desc->desc.bInterfaceNumber;
431 } else {
432
433 if (ifno >= 0) {
434 if_desc = &dev->config.if_desc[ifno];
435 if_desc->num_altsetting++;
436 }
437 }
438 break;
439 case USB_DT_ENDPOINT:
440 if (head->bLength != USB_DT_ENDPOINT_SIZE &&
441 head->bLength != USB_DT_ENDPOINT_AUDIO_SIZE) {
442 printf("ERROR: Invalid USB EP length (%d)\n",
443 head->bLength);
444 break;
445 }
446 if (index + head->bLength >
447 dev->config.desc.wTotalLength) {
448 puts("USB EP descriptor overflowed buffer!\n");
449 break;
450 }
451 if (ifno < 0) {
452 puts("Endpoint descriptor out of order!\n");
453 break;
454 }
455 epno = dev->config.if_desc[ifno].no_of_ep;
456 if_desc = &dev->config.if_desc[ifno];
457 if (epno >= USB_MAXENDPOINTS) {
458 printf("Interface %d has too many endpoints!\n",
459 if_desc->desc.bInterfaceNumber);
460 return -EINVAL;
461 }
462
463 if_desc->no_of_ep++;
464 memcpy(&if_desc->ep_desc[epno], head,
465 USB_DT_ENDPOINT_SIZE);
466 ep_wMaxPacketSize = get_unaligned(&dev->config.\
467 if_desc[ifno].\
468 ep_desc[epno].\
469 wMaxPacketSize);
470 put_unaligned(le16_to_cpu(ep_wMaxPacketSize),
471 &dev->config.\
472 if_desc[ifno].\
473 ep_desc[epno].\
474 wMaxPacketSize);
475 debug("if %d, ep %d\n", ifno, epno);
476 break;
477 case USB_DT_SS_ENDPOINT_COMP:
478 if (head->bLength != USB_DT_SS_EP_COMP_SIZE) {
479 printf("ERROR: Invalid USB EPC length (%d)\n",
480 head->bLength);
481 break;
482 }
483 if (index + USB_DT_SS_EP_COMP_SIZE >
484 dev->config.desc.wTotalLength) {
485 puts("USB EPC descriptor overflowed buffer!\n");
486 break;
487 }
488 if (ifno < 0 || epno < 0) {
489 puts("EPC descriptor out of order!\n");
490 break;
491 }
492 if_desc = &dev->config.if_desc[ifno];
493 memcpy(&if_desc->ss_ep_comp_desc[epno], head,
494 USB_DT_SS_EP_COMP_SIZE);
495 break;
496 default:
497 if (head->bLength == 0)
498 return -EINVAL;
499
500 debug("unknown Description Type : %x\n",
501 head->bDescriptorType);
502
503#ifdef DEBUG
504 {
505 unsigned char *ch = (unsigned char *)head;
506 int i;
507
508 for (i = 0; i < head->bLength; i++)
509 debug("%02X ", *ch++);
510 debug("\n\n\n");
511 }
512#endif
513 break;
514 }
515 index += head->bLength;
516 head = (struct usb_descriptor_header *)&buffer[index];
517 }
518 return 0;
519}
520
521
522
523
524
525
526int usb_clear_halt(struct usb_device *dev, int pipe)
527{
528 int result;
529 int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
530
531 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
532 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
533 endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
534
535
536 if (result < 0)
537 return result;
538
539
540
541
542
543
544 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
545
546
547 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
548 return 0;
549}
550
551
552
553
554
555static int usb_get_descriptor(struct usb_device *dev, unsigned char type,
556 unsigned char index, void *buf, int size)
557{
558 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
559 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
560 (type << 8) + index, 0, buf, size,
561 USB_CNTL_TIMEOUT);
562}
563
564
565
566
567int usb_get_configuration_len(struct usb_device *dev, int cfgno)
568{
569 int result;
570 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, 9);
571 struct usb_config_descriptor *config;
572
573 config = (struct usb_config_descriptor *)&buffer[0];
574 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9);
575 if (result < 9) {
576 if (result < 0)
577 printf("unable to get descriptor, error %lX\n",
578 dev->status);
579 else
580 printf("config descriptor too short " \
581 "(expected %i, got %i)\n", 9, result);
582 return -EIO;
583 }
584 return le16_to_cpu(config->wTotalLength);
585}
586
587
588
589
590int usb_get_configuration_no(struct usb_device *dev, int cfgno,
591 unsigned char *buffer, int length)
592{
593 int result;
594 struct usb_config_descriptor *config;
595
596 config = (struct usb_config_descriptor *)&buffer[0];
597 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length);
598 debug("get_conf_no %d Result %d, wLength %d\n", cfgno, result,
599 le16_to_cpu(config->wTotalLength));
600 config->wTotalLength = result;
601
602 return result;
603}
604
605
606
607
608
609static int usb_set_address(struct usb_device *dev)
610{
611 debug("set address %d\n", dev->devnum);
612
613 return usb_control_msg(dev, usb_snddefctrl(dev), USB_REQ_SET_ADDRESS,
614 0, (dev->devnum), 0, NULL, 0, USB_CNTL_TIMEOUT);
615}
616
617
618
619
620int usb_set_interface(struct usb_device *dev, int interface, int alternate)
621{
622 struct usb_interface *if_face = NULL;
623 int ret, i;
624
625 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) {
626 if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) {
627 if_face = &dev->config.if_desc[i];
628 break;
629 }
630 }
631 if (!if_face) {
632 printf("selecting invalid interface %d", interface);
633 return -EINVAL;
634 }
635
636
637
638
639
640
641
642 if (if_face->num_altsetting == 1)
643 return 0;
644
645 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
646 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
647 alternate, interface, NULL, 0,
648 USB_CNTL_TIMEOUT * 5);
649 if (ret < 0)
650 return ret;
651
652 return 0;
653}
654
655
656
657
658static int usb_set_configuration(struct usb_device *dev, int configuration)
659{
660 int res;
661 debug("set configuration %d\n", configuration);
662
663 res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
664 USB_REQ_SET_CONFIGURATION, 0,
665 configuration, 0,
666 NULL, 0, USB_CNTL_TIMEOUT);
667 if (res == 0) {
668 dev->toggle[0] = 0;
669 dev->toggle[1] = 0;
670 return 0;
671 } else
672 return -EIO;
673}
674
675
676
677
678int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
679{
680 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
681 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
682 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
683}
684
685
686
687
688int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
689{
690 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
691 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
692 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
693}
694
695
696
697
698int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
699 unsigned char id, void *buf, int size)
700{
701 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
702 USB_REQ_GET_REPORT,
703 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
704 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
705}
706
707
708
709
710int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
711 unsigned char type, unsigned char id, void *buf, int size)
712{
713 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
714 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
715 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
716}
717
718
719
720
721static int usb_get_string(struct usb_device *dev, unsigned short langid,
722 unsigned char index, void *buf, int size)
723{
724 int i;
725 int result;
726
727 for (i = 0; i < 3; ++i) {
728
729 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
730 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
731 (USB_DT_STRING << 8) + index, langid, buf, size,
732 USB_CNTL_TIMEOUT);
733
734 if (result > 0)
735 break;
736 }
737
738 return result;
739}
740
741
742static void usb_try_string_workarounds(unsigned char *buf, int *length)
743{
744 int newlength, oldlength = *length;
745
746 for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
747 if (!isprint(buf[newlength]) || buf[newlength + 1])
748 break;
749
750 if (newlength > 2) {
751 buf[0] = newlength;
752 *length = newlength;
753 }
754}
755
756
757static int usb_string_sub(struct usb_device *dev, unsigned int langid,
758 unsigned int index, unsigned char *buf)
759{
760 int rc;
761
762
763
764 rc = usb_get_string(dev, langid, index, buf, 255);
765
766
767
768 if (rc < 2) {
769 rc = usb_get_string(dev, langid, index, buf, 2);
770 if (rc == 2)
771 rc = usb_get_string(dev, langid, index, buf, buf[0]);
772 }
773
774 if (rc >= 2) {
775 if (!buf[0] && !buf[1])
776 usb_try_string_workarounds(buf, &rc);
777
778
779 if (buf[0] < rc)
780 rc = buf[0];
781
782 rc = rc - (rc & 1);
783 }
784
785 if (rc < 2)
786 rc = -EINVAL;
787
788 return rc;
789}
790
791
792
793
794
795
796
797int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
798{
799 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, mybuf, USB_BUFSIZ);
800 unsigned char *tbuf;
801 int err;
802 unsigned int u, idx;
803
804 if (size <= 0 || !buf || !index)
805 return -EINVAL;
806 buf[0] = 0;
807 tbuf = &mybuf[0];
808
809
810 if (!dev->have_langid) {
811 err = usb_string_sub(dev, 0, 0, tbuf);
812 if (err < 0) {
813 debug("error getting string descriptor 0 " \
814 "(error=%lx)\n", dev->status);
815 return -EIO;
816 } else if (tbuf[0] < 4) {
817 debug("string descriptor 0 too short\n");
818 return -EIO;
819 } else {
820 dev->have_langid = -1;
821 dev->string_langid = tbuf[2] | (tbuf[3] << 8);
822
823 debug("USB device number %d default " \
824 "language ID 0x%x\n",
825 dev->devnum, dev->string_langid);
826 }
827 }
828
829 err = usb_string_sub(dev, dev->string_langid, index, tbuf);
830 if (err < 0)
831 return err;
832
833 size--;
834 for (idx = 0, u = 2; u < err; u += 2) {
835 if (idx >= size)
836 break;
837 if (tbuf[u+1])
838 buf[idx++] = '?';
839 else
840 buf[idx++] = tbuf[u];
841 }
842 buf[idx] = 0;
843 err = idx;
844 return err;
845}
846
847
848
849
850
851
852
853#ifndef CONFIG_DM_USB
854
855
856
857
858struct usb_device *usb_get_dev_index(int index)
859{
860 if (usb_dev[index].devnum == -1)
861 return NULL;
862 else
863 return &usb_dev[index];
864}
865
866int usb_alloc_new_device(struct udevice *controller, struct usb_device **devp)
867{
868 int i;
869 debug("New Device %d\n", dev_index);
870 if (dev_index == USB_MAX_DEVICE) {
871 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE);
872 return -ENOSPC;
873 }
874
875 usb_dev[dev_index].devnum = dev_index + 1;
876 usb_dev[dev_index].maxchild = 0;
877 for (i = 0; i < USB_MAXCHILDREN; i++)
878 usb_dev[dev_index].children[i] = NULL;
879 usb_dev[dev_index].parent = NULL;
880 usb_dev[dev_index].controller = controller;
881 dev_index++;
882 *devp = &usb_dev[dev_index - 1];
883
884 return 0;
885}
886
887
888
889
890
891
892void usb_free_device(struct udevice *controller)
893{
894 dev_index--;
895 debug("Freeing device node: %d\n", dev_index);
896 memset(&usb_dev[dev_index], 0, sizeof(struct usb_device));
897 usb_dev[dev_index].devnum = -1;
898}
899
900
901
902
903
904
905
906__weak int usb_alloc_device(struct usb_device *udev)
907{
908 return 0;
909}
910#endif
911
912static int usb_hub_port_reset(struct usb_device *dev, struct usb_device *hub)
913{
914 if (!hub)
915 usb_reset_root_port(dev);
916
917 return 0;
918}
919
920static int get_descriptor_len(struct usb_device *dev, int len, int expect_len)
921{
922 __maybe_unused struct usb_device_descriptor *desc;
923 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ);
924 int err;
925
926 desc = (struct usb_device_descriptor *)tmpbuf;
927
928 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, len);
929 if (err < expect_len) {
930 if (err < 0) {
931 printf("unable to get device descriptor (error=%d)\n",
932 err);
933 return err;
934 } else {
935 printf("USB device descriptor short read (expected %i, got %i)\n",
936 expect_len, err);
937 return -EIO;
938 }
939 }
940 memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor));
941
942 return 0;
943}
944
945static int usb_setup_descriptor(struct usb_device *dev, bool do_read)
946{
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963 if (dev->speed == USB_SPEED_LOW) {
964 dev->descriptor.bMaxPacketSize0 = 8;
965 dev->maxpacketsize = PACKET_SIZE_8;
966 } else {
967 dev->descriptor.bMaxPacketSize0 = 64;
968 dev->maxpacketsize = PACKET_SIZE_64;
969 }
970 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
971 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
972
973 if (do_read && dev->speed == USB_SPEED_FULL) {
974 int err;
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992 err = get_descriptor_len(dev, 64, 8);
993 if (err)
994 return err;
995 }
996
997 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
998 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
999 switch (dev->descriptor.bMaxPacketSize0) {
1000 case 8:
1001 dev->maxpacketsize = PACKET_SIZE_8;
1002 break;
1003 case 16:
1004 dev->maxpacketsize = PACKET_SIZE_16;
1005 break;
1006 case 32:
1007 dev->maxpacketsize = PACKET_SIZE_32;
1008 break;
1009 case 64:
1010 dev->maxpacketsize = PACKET_SIZE_64;
1011 break;
1012 default:
1013 printf("%s: invalid max packet size\n", __func__);
1014 return -EIO;
1015 }
1016
1017 return 0;
1018}
1019
1020static int usb_prepare_device(struct usb_device *dev, int addr, bool do_read,
1021 struct usb_device *parent)
1022{
1023 int err;
1024
1025
1026
1027
1028
1029
1030
1031 err = usb_alloc_device(dev);
1032 if (err) {
1033 printf("Cannot allocate device context to get SLOT_ID\n");
1034 return err;
1035 }
1036 err = usb_setup_descriptor(dev, do_read);
1037 if (err)
1038 return err;
1039 err = usb_hub_port_reset(dev, parent);
1040 if (err)
1041 return err;
1042
1043 dev->devnum = addr;
1044
1045 err = usb_set_address(dev);
1046
1047 if (err < 0) {
1048 printf("\n USB device not accepting new address " \
1049 "(error=%lX)\n", dev->status);
1050 return err;
1051 }
1052
1053 mdelay(10);
1054
1055
1056
1057
1058
1059
1060 if (!do_read) {
1061 err = usb_setup_descriptor(dev, true);
1062 if (err)
1063 return err;
1064 }
1065
1066 return 0;
1067}
1068
1069int usb_select_config(struct usb_device *dev)
1070{
1071 unsigned char *tmpbuf = NULL;
1072 int err;
1073
1074 err = get_descriptor_len(dev, USB_DT_DEVICE_SIZE, USB_DT_DEVICE_SIZE);
1075 if (err)
1076 return err;
1077
1078
1079 le16_to_cpus(&dev->descriptor.bcdUSB);
1080 le16_to_cpus(&dev->descriptor.idVendor);
1081 le16_to_cpus(&dev->descriptor.idProduct);
1082 le16_to_cpus(&dev->descriptor.bcdDevice);
1083
1084
1085
1086
1087
1088
1089
1090 mdelay(1);
1091
1092
1093 err = usb_get_configuration_len(dev, 0);
1094 if (err >= 0) {
1095 tmpbuf = (unsigned char *)malloc_cache_aligned(err);
1096 if (!tmpbuf)
1097 err = -ENOMEM;
1098 else
1099 err = usb_get_configuration_no(dev, 0, tmpbuf, err);
1100 }
1101 if (err < 0) {
1102 printf("usb_new_device: Cannot read configuration, " \
1103 "skipping device %04x:%04x\n",
1104 dev->descriptor.idVendor, dev->descriptor.idProduct);
1105 free(tmpbuf);
1106 return err;
1107 }
1108 usb_parse_config(dev, tmpbuf, 0);
1109 free(tmpbuf);
1110 usb_set_maxpacket(dev);
1111
1112
1113
1114
1115
1116 err = usb_set_configuration(dev, dev->config.desc.bConfigurationValue);
1117 if (err < 0) {
1118 printf("failed to set default configuration " \
1119 "len %d, status %lX\n", dev->act_len, dev->status);
1120 return err;
1121 }
1122
1123
1124
1125
1126
1127
1128 mdelay(10);
1129
1130 debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
1131 dev->descriptor.iManufacturer, dev->descriptor.iProduct,
1132 dev->descriptor.iSerialNumber);
1133 memset(dev->mf, 0, sizeof(dev->mf));
1134 memset(dev->prod, 0, sizeof(dev->prod));
1135 memset(dev->serial, 0, sizeof(dev->serial));
1136 if (dev->descriptor.iManufacturer)
1137 usb_string(dev, dev->descriptor.iManufacturer,
1138 dev->mf, sizeof(dev->mf));
1139 if (dev->descriptor.iProduct)
1140 usb_string(dev, dev->descriptor.iProduct,
1141 dev->prod, sizeof(dev->prod));
1142 if (dev->descriptor.iSerialNumber)
1143 usb_string(dev, dev->descriptor.iSerialNumber,
1144 dev->serial, sizeof(dev->serial));
1145 debug("Manufacturer %s\n", dev->mf);
1146 debug("Product %s\n", dev->prod);
1147 debug("SerialNumber %s\n", dev->serial);
1148
1149 return 0;
1150}
1151
1152int usb_setup_device(struct usb_device *dev, bool do_read,
1153 struct usb_device *parent)
1154{
1155 int addr;
1156 int ret;
1157
1158
1159 addr = dev->devnum;
1160 dev->devnum = 0;
1161
1162 ret = usb_prepare_device(dev, addr, do_read, parent);
1163 if (ret)
1164 return ret;
1165 ret = usb_select_config(dev);
1166
1167 return ret;
1168}
1169
1170#ifndef CONFIG_DM_USB
1171
1172
1173
1174
1175
1176
1177
1178int usb_new_device(struct usb_device *dev)
1179{
1180 bool do_read = true;
1181 int err;
1182
1183
1184
1185
1186
1187
1188
1189#ifdef CONFIG_USB_XHCI_HCD
1190 do_read = false;
1191#endif
1192 err = usb_setup_device(dev, do_read, dev->parent);
1193 if (err)
1194 return err;
1195
1196
1197 err = usb_hub_probe(dev, 0);
1198 if (err < 0)
1199 return err;
1200
1201 return 0;
1202}
1203#endif
1204
1205__weak
1206int board_usb_init(int index, enum usb_init_type init)
1207{
1208 return 0;
1209}
1210
1211__weak
1212int board_usb_cleanup(int index, enum usb_init_type init)
1213{
1214 return 0;
1215}
1216
1217bool usb_device_has_child_on_port(struct usb_device *parent, int port)
1218{
1219#ifdef CONFIG_DM_USB
1220 return false;
1221#else
1222 return parent->children[port] != NULL;
1223#endif
1224}
1225
1226#ifdef CONFIG_DM_USB
1227void usb_find_usb2_hub_address_port(struct usb_device *udev,
1228 uint8_t *hub_address, uint8_t *hub_port)
1229{
1230 struct udevice *parent;
1231 struct usb_device *uparent, *ttdev;
1232
1233
1234
1235
1236
1237
1238
1239
1240 ttdev = udev;
1241 parent = udev->dev;
1242 uparent = dev_get_parent_priv(parent);
1243
1244 while (uparent->speed != USB_SPEED_HIGH) {
1245 struct udevice *dev = parent;
1246
1247 if (device_get_uclass_id(dev->parent) != UCLASS_USB_HUB) {
1248 printf("Error: Cannot find high speed parent of usb-1 device\n");
1249 *hub_address = 0;
1250 *hub_port = 0;
1251 return;
1252 }
1253
1254 ttdev = dev_get_parent_priv(dev);
1255 parent = dev->parent;
1256 uparent = dev_get_parent_priv(parent);
1257 }
1258 *hub_address = uparent->devnum;
1259 *hub_port = ttdev->portnr;
1260}
1261#else
1262void usb_find_usb2_hub_address_port(struct usb_device *udev,
1263 uint8_t *hub_address, uint8_t *hub_port)
1264{
1265
1266 while (udev->parent->parent != NULL)
1267 if (udev->parent->speed != USB_SPEED_HIGH) {
1268 udev = udev->parent;
1269 } else {
1270 *hub_address = udev->parent->devnum;
1271 *hub_port = udev->portnr;
1272 return;
1273 }
1274
1275 printf("Error: Cannot find high speed parent of usb-1 device\n");
1276 *hub_address = 0;
1277 *hub_port = 0;
1278}
1279#endif
1280
1281
1282
1283