1 // SPDX-License-Identifier: GPL-2.0+
3 * Most of this source has been derived from the Linux USB
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)
16 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland
22 * Since this is a bootloader, the devices will not be automatic
23 * (re)configured on hotplug, but after a restart of the USB the
26 * For each transfer (except "Interrupt") we wait for completion.
34 #include <asm/processor.h>
35 #include <linux/compiler.h>
36 #include <linux/ctype.h>
37 #include <asm/byteorder.h>
38 #include <asm/unaligned.h>
42 #define USB_BUFSIZ 512
44 static int asynch_allowed;
45 char usb_started; /* flag for the started/stopped USB status */
47 #if !CONFIG_IS_ENABLED(DM_USB)
48 static struct usb_device usb_dev[USB_MAX_DEVICE];
51 #ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
52 #define CONFIG_USB_MAX_CONTROLLER_COUNT 1
55 /***************************************************************************
61 struct usb_device *dev;
62 int i, start_index = 0;
63 int controllers_initialized = 0;
70 /* first make all devices unknown */
71 for (i = 0; i < USB_MAX_DEVICE; i++) {
72 memset(&usb_dev[i], 0, sizeof(struct usb_device));
73 usb_dev[i].devnum = -1;
76 /* init low_level USB */
77 for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
78 /* init low_level USB */
80 ret = usb_lowlevel_init(i, USB_INIT_HOST, &ctrl);
81 if (ret == -ENODEV) { /* No such device. */
82 puts("Port not available.\n");
83 controllers_initialized++;
87 if (ret) { /* Other error. */
88 puts("lowlevel init failed\n");
92 * lowlevel init is OK, now scan the bus for devices
93 * i.e. search HUBs and configure them
95 controllers_initialized++;
96 start_index = dev_index;
97 printf("scanning bus %d for devices... ", i);
98 ret = usb_alloc_new_device(ctrl, &dev);
103 * device 0 is always present
104 * (root hub, so let it analyze)
106 ret = usb_new_device(dev);
108 usb_free_device(dev->controller);
110 if (start_index == dev_index) {
111 puts("No USB Device found\n");
114 printf("%d USB Device(s) found\n",
115 dev_index - start_index);
122 /* if we were not able to find at least one working bus, bail out */
123 if (controllers_initialized == 0)
124 puts("USB error: all controllers failed lowlevel init\n");
126 return usb_started ? 0 : -ENODEV;
129 /******************************************************************************
130 * Stop USB this stops the LowLevel Part and deregisters USB devices.
141 for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
142 if (usb_lowlevel_stop(i))
143 printf("failed to stop USB controller %d\n", i);
150 /******************************************************************************
151 * Detect if a USB device has been plugged or unplugged.
153 int usb_detect_change(void)
158 for (j = 0; j < USB_MAX_DEVICE; j++) {
159 for (i = 0; i < usb_dev[j].maxchild; i++) {
160 struct usb_port_status status;
162 if (usb_get_port_status(&usb_dev[j], i + 1,
164 /* USB request failed */
167 if (le16_to_cpu(status.wPortChange) &
168 USB_PORT_STAT_C_CONNECTION)
176 /* Lock or unlock async schedule on the controller */
177 __weak int usb_lock_async(struct usb_device *dev, int lock)
183 * disables the asynch behaviour of the control message. This is used for data
184 * transfers that uses the exclusiv access to the control and bulk messages.
185 * Returns the old value so it can be restored later.
187 int usb_disable_asynch(int disable)
189 int old_value = asynch_allowed;
191 asynch_allowed = !disable;
194 #endif /* !CONFIG_IS_ENABLED(DM_USB) */
197 /*-------------------------------------------------------------------
203 * submits an Interrupt Message. Some drivers may implement non-blocking
204 * polling: when non-block is true and the device is not responding return
205 * -EAGAIN instead of waiting for device to respond.
207 int usb_int_msg(struct usb_device *dev, unsigned long pipe,
208 void *buffer, int transfer_len, int interval, bool nonblock)
210 return submit_int_msg(dev, pipe, buffer, transfer_len, interval,
215 * submits a control message and waits for comletion (at least timeout * 1ms)
216 * If timeout is 0, we don't wait for completion (used as example to set and
217 * clear keyboards LEDs). For data transfers, (storage transfers) we don't
218 * allow control messages with 0 timeout, by previousely resetting the flag
219 * asynch_allowed (usb_disable_asynch(1)).
220 * returns the transferred length if OK or -1 if error. The transferred length
221 * and the current status are stored in the dev->act_len and dev->status.
223 int usb_control_msg(struct usb_device *dev, unsigned int pipe,
224 unsigned char request, unsigned char requesttype,
225 unsigned short value, unsigned short index,
226 void *data, unsigned short size, int timeout)
228 ALLOC_CACHE_ALIGN_BUFFER(struct devrequest, setup_packet, 1);
231 if ((timeout == 0) && (!asynch_allowed)) {
232 /* request for a asynch control pipe is not allowed */
236 /* set setup command */
237 setup_packet->requesttype = requesttype;
238 setup_packet->request = request;
239 setup_packet->value = cpu_to_le16(value);
240 setup_packet->index = cpu_to_le16(index);
241 setup_packet->length = cpu_to_le16(size);
242 debug("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
243 "value 0x%X index 0x%X length 0x%X\n",
244 request, requesttype, value, index, size);
245 dev->status = USB_ST_NOT_PROC; /*not yet processed */
247 err = submit_control_msg(dev, pipe, data, size, setup_packet);
254 * Wait for status to update until timeout expires, USB driver
255 * interrupt handler may set the status when the USB operation has
259 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
270 /*-------------------------------------------------------------------
271 * submits bulk message, and waits for completion. returns 0 if Ok or
273 * synchronous behavior
275 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
276 void *data, int len, int *actual_length, int timeout)
280 dev->status = USB_ST_NOT_PROC; /*not yet processed */
281 if (submit_bulk_msg(dev, pipe, data, len) < 0)
284 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
288 *actual_length = dev->act_len;
289 if (dev->status == 0)
296 /*-------------------------------------------------------------------
301 * returns the max packet size, depending on the pipe direction and
302 * the configurations values
304 int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
306 /* direction is out -> use emaxpacket out */
307 if ((pipe & USB_DIR_IN) == 0)
308 return dev->epmaxpacketout[((pipe>>15) & 0xf)];
310 return dev->epmaxpacketin[((pipe>>15) & 0xf)];
314 * The routine usb_set_maxpacket_ep() is extracted from the loop of routine
315 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine
316 * when it is inlined in 1 single routine. What happens is that the register r3
317 * is used as loop-count 'i', but gets overwritten later on.
318 * This is clearly a compiler bug, but it is easier to workaround it here than
319 * to update the compiler (Occurs with at least several GCC 4.{1,2},x
320 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM)
322 * NOTE: Similar behaviour was observed with GCC4.6 on ARMv5.
325 usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx)
328 struct usb_endpoint_descriptor *ep;
329 u16 ep_wMaxPacketSize;
331 ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx];
333 b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
334 ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize);
336 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
337 USB_ENDPOINT_XFER_CONTROL) {
338 /* Control => bidirectional */
339 dev->epmaxpacketout[b] = ep_wMaxPacketSize;
340 dev->epmaxpacketin[b] = ep_wMaxPacketSize;
341 debug("##Control EP epmaxpacketout/in[%d] = %d\n",
342 b, dev->epmaxpacketin[b]);
344 if ((ep->bEndpointAddress & 0x80) == 0) {
346 if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) {
347 dev->epmaxpacketout[b] = ep_wMaxPacketSize;
348 debug("##EP epmaxpacketout[%d] = %d\n",
349 b, dev->epmaxpacketout[b]);
353 if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) {
354 dev->epmaxpacketin[b] = ep_wMaxPacketSize;
355 debug("##EP epmaxpacketin[%d] = %d\n",
356 b, dev->epmaxpacketin[b]);
363 * set the max packed value of all endpoints in the given configuration
365 static int usb_set_maxpacket(struct usb_device *dev)
369 for (i = 0; i < dev->config.desc.bNumInterfaces; i++)
370 for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++)
371 usb_set_maxpacket_ep(dev, i, ii);
376 /*******************************************************************************
377 * Parse the config, located in buffer, and fills the dev->config structure.
378 * Note that all little/big endian swapping are done automatically.
379 * (wTotalLength has already been swapped and sanitized when it was read.)
381 static int usb_parse_config(struct usb_device *dev,
382 unsigned char *buffer, int cfgno)
384 struct usb_descriptor_header *head;
385 int index, ifno, epno, curr_if_num;
386 u16 ep_wMaxPacketSize;
387 struct usb_interface *if_desc = NULL;
393 dev->configno = cfgno;
394 head = (struct usb_descriptor_header *) &buffer[0];
395 if (head->bDescriptorType != USB_DT_CONFIG) {
396 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
397 head->bDescriptorType);
400 if (head->bLength != USB_DT_CONFIG_SIZE) {
401 printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength);
404 memcpy(&dev->config, head, USB_DT_CONFIG_SIZE);
405 dev->config.no_of_if = 0;
407 index = dev->config.desc.bLength;
408 /* Ok the first entry must be a configuration entry,
409 * now process the others */
410 head = (struct usb_descriptor_header *) &buffer[index];
411 while (index + 1 < dev->config.desc.wTotalLength && head->bLength) {
412 switch (head->bDescriptorType) {
413 case USB_DT_INTERFACE:
414 if (head->bLength != USB_DT_INTERFACE_SIZE) {
415 printf("ERROR: Invalid USB IF length (%d)\n",
419 if (index + USB_DT_INTERFACE_SIZE >
420 dev->config.desc.wTotalLength) {
421 puts("USB IF descriptor overflowed buffer!\n");
424 if (((struct usb_interface_descriptor *) \
425 head)->bInterfaceNumber != curr_if_num) {
426 /* this is a new interface, copy new desc */
427 ifno = dev->config.no_of_if;
428 if (ifno >= USB_MAXINTERFACES) {
429 puts("Too many USB interfaces!\n");
430 /* try to go on with what we have */
433 if_desc = &dev->config.if_desc[ifno];
434 dev->config.no_of_if++;
435 memcpy(if_desc, head,
436 USB_DT_INTERFACE_SIZE);
437 if_desc->no_of_ep = 0;
438 if_desc->num_altsetting = 1;
440 if_desc->desc.bInterfaceNumber;
442 /* found alternate setting for the interface */
444 if_desc = &dev->config.if_desc[ifno];
445 if_desc->num_altsetting++;
449 case USB_DT_ENDPOINT:
450 if (head->bLength != USB_DT_ENDPOINT_SIZE &&
451 head->bLength != USB_DT_ENDPOINT_AUDIO_SIZE) {
452 printf("ERROR: Invalid USB EP length (%d)\n",
456 if (index + head->bLength >
457 dev->config.desc.wTotalLength) {
458 puts("USB EP descriptor overflowed buffer!\n");
462 puts("Endpoint descriptor out of order!\n");
465 epno = dev->config.if_desc[ifno].no_of_ep;
466 if_desc = &dev->config.if_desc[ifno];
467 if (epno >= USB_MAXENDPOINTS) {
468 printf("Interface %d has too many endpoints!\n",
469 if_desc->desc.bInterfaceNumber);
472 /* found an endpoint */
474 memcpy(&if_desc->ep_desc[epno], head,
475 USB_DT_ENDPOINT_SIZE);
476 ep_wMaxPacketSize = get_unaligned(&dev->config.\
480 put_unaligned(le16_to_cpu(ep_wMaxPacketSize),
485 debug("if %d, ep %d\n", ifno, epno);
487 case USB_DT_SS_ENDPOINT_COMP:
488 if (head->bLength != USB_DT_SS_EP_COMP_SIZE) {
489 printf("ERROR: Invalid USB EPC length (%d)\n",
493 if (index + USB_DT_SS_EP_COMP_SIZE >
494 dev->config.desc.wTotalLength) {
495 puts("USB EPC descriptor overflowed buffer!\n");
498 if (ifno < 0 || epno < 0) {
499 puts("EPC descriptor out of order!\n");
502 if_desc = &dev->config.if_desc[ifno];
503 memcpy(&if_desc->ss_ep_comp_desc[epno], head,
504 USB_DT_SS_EP_COMP_SIZE);
507 if (head->bLength == 0)
510 debug("unknown Description Type : %x\n",
511 head->bDescriptorType);
515 unsigned char *ch = (unsigned char *)head;
518 for (i = 0; i < head->bLength; i++)
519 debug("%02X ", *ch++);
525 index += head->bLength;
526 head = (struct usb_descriptor_header *)&buffer[index];
531 /***********************************************************************
533 * endp: endpoint number in bits 0-3;
534 * direction flag in bit 7 (1 = IN, 0 = OUT)
536 int usb_clear_halt(struct usb_device *dev, int pipe)
539 int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
541 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
542 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
543 endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
545 /* don't clear if failed */
550 * NOTE: we do not get status and verify reset was successful
551 * as some devices are reported to lock up upon this check..
554 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
556 /* toggle is reset on clear */
557 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
562 /**********************************************************************
563 * get_descriptor type
565 static int usb_get_descriptor(struct usb_device *dev, unsigned char type,
566 unsigned char index, void *buf, int size)
568 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
569 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
570 (type << 8) + index, 0, buf, size,
574 /**********************************************************************
575 * gets len of configuration cfgno
577 int usb_get_configuration_len(struct usb_device *dev, int cfgno)
580 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, 9);
581 struct usb_config_descriptor *config;
583 config = (struct usb_config_descriptor *)&buffer[0];
584 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9);
587 printf("unable to get descriptor, error %lX\n",
590 printf("config descriptor too short " \
591 "(expected %i, got %i)\n", 9, result);
594 return le16_to_cpu(config->wTotalLength);
597 /**********************************************************************
598 * gets configuration cfgno and store it in the buffer
600 int usb_get_configuration_no(struct usb_device *dev, int cfgno,
601 unsigned char *buffer, int length)
604 struct usb_config_descriptor *config;
606 config = (struct usb_config_descriptor *)&buffer[0];
607 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length);
608 debug("get_conf_no %d Result %d, wLength %d\n", cfgno, result,
609 le16_to_cpu(config->wTotalLength));
610 config->wTotalLength = result; /* validated, with CPU byte order */
615 /********************************************************************
616 * set address of a device to the value in dev->devnum.
617 * This can only be done by addressing the device via the default address (0)
619 static int usb_set_address(struct usb_device *dev)
621 debug("set address %d\n", dev->devnum);
623 return usb_control_msg(dev, usb_snddefctrl(dev), USB_REQ_SET_ADDRESS,
624 0, (dev->devnum), 0, NULL, 0, USB_CNTL_TIMEOUT);
627 /********************************************************************
628 * set interface number to interface
630 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
632 struct usb_interface *if_face = NULL;
635 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) {
636 if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) {
637 if_face = &dev->config.if_desc[i];
642 printf("selecting invalid interface %d", interface);
646 * We should return now for devices with only one alternate setting.
647 * According to 9.4.10 of the Universal Serial Bus Specification
648 * Revision 2.0 such devices can return with a STALL. This results in
649 * some USB sticks timeouting during initialization and then being
650 * unusable in U-Boot.
652 if (if_face->num_altsetting == 1)
655 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
656 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
657 alternate, interface, NULL, 0,
658 USB_CNTL_TIMEOUT * 5);
665 /********************************************************************
666 * set configuration number to configuration
668 static int usb_set_configuration(struct usb_device *dev, int configuration)
671 debug("set configuration %d\n", configuration);
672 /* set setup command */
673 res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
674 USB_REQ_SET_CONFIGURATION, 0,
676 NULL, 0, USB_CNTL_TIMEOUT);
685 /********************************************************************
686 * set protocol to protocol
688 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
690 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
691 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
692 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
695 /********************************************************************
698 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
700 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
701 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
702 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
705 /********************************************************************
708 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
709 unsigned char id, void *buf, int size)
711 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
713 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
714 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
717 /********************************************************************
718 * get class descriptor
720 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
721 unsigned char type, unsigned char id, void *buf, int size)
723 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
724 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
725 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
728 /********************************************************************
729 * get string index in buffer
731 static int usb_get_string(struct usb_device *dev, unsigned short langid,
732 unsigned char index, void *buf, int size)
737 for (i = 0; i < 3; ++i) {
738 /* some devices are flaky */
739 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
740 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
741 (USB_DT_STRING << 8) + index, langid, buf, size,
752 static void usb_try_string_workarounds(unsigned char *buf, int *length)
754 int newlength, oldlength = *length;
756 for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
757 if (!isprint(buf[newlength]) || buf[newlength + 1])
767 static int usb_string_sub(struct usb_device *dev, unsigned int langid,
768 unsigned int index, unsigned char *buf)
772 /* Try to read the string descriptor by asking for the maximum
773 * possible number of bytes */
774 rc = usb_get_string(dev, langid, index, buf, 255);
776 /* If that failed try to read the descriptor length, then
777 * ask for just that many bytes */
779 rc = usb_get_string(dev, langid, index, buf, 2);
781 rc = usb_get_string(dev, langid, index, buf, buf[0]);
785 if (!buf[0] && !buf[1])
786 usb_try_string_workarounds(buf, &rc);
788 /* There might be extra junk at the end of the descriptor */
792 rc = rc - (rc & 1); /* force a multiple of two */
802 /********************************************************************
804 * Get string index and translate it to ascii.
805 * returns string length (> 0) or error (< 0)
807 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
809 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, mybuf, USB_BUFSIZ);
814 if (size <= 0 || !buf || !index)
819 /* get langid for strings if it's not yet known */
820 if (!dev->have_langid) {
821 err = usb_string_sub(dev, 0, 0, tbuf);
823 debug("error getting string descriptor 0 " \
824 "(error=%lx)\n", dev->status);
826 } else if (tbuf[0] < 4) {
827 debug("string descriptor 0 too short\n");
830 dev->have_langid = -1;
831 dev->string_langid = tbuf[2] | (tbuf[3] << 8);
832 /* always use the first langid listed */
833 debug("USB device number %d default " \
834 "language ID 0x%x\n",
835 dev->devnum, dev->string_langid);
839 err = usb_string_sub(dev, dev->string_langid, index, tbuf);
843 size--; /* leave room for trailing NULL char in output buffer */
844 for (idx = 0, u = 2; u < err; u += 2) {
847 if (tbuf[u+1]) /* high byte */
848 buf[idx++] = '?'; /* non-ASCII character */
850 buf[idx++] = tbuf[u];
858 /********************************************************************
859 * USB device handling:
860 * the USB device are static allocated [USB_MAX_DEVICE].
863 #if !CONFIG_IS_ENABLED(DM_USB)
865 /* returns a pointer to the device with the index [index].
866 * if the device is not assigned (dev->devnum==-1) returns NULL
868 struct usb_device *usb_get_dev_index(int index)
870 if (usb_dev[index].devnum == -1)
873 return &usb_dev[index];
876 int usb_alloc_new_device(struct udevice *controller, struct usb_device **devp)
879 debug("New Device %d\n", dev_index);
880 if (dev_index == USB_MAX_DEVICE) {
881 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE);
884 /* default Address is 0, real addresses start with 1 */
885 usb_dev[dev_index].devnum = dev_index + 1;
886 usb_dev[dev_index].maxchild = 0;
887 for (i = 0; i < USB_MAXCHILDREN; i++)
888 usb_dev[dev_index].children[i] = NULL;
889 usb_dev[dev_index].parent = NULL;
890 usb_dev[dev_index].controller = controller;
892 *devp = &usb_dev[dev_index - 1];
898 * Free the newly created device node.
899 * Called in error cases where configuring a newly attached
900 * device fails for some reason.
902 void usb_free_device(struct udevice *controller)
905 debug("Freeing device node: %d\n", dev_index);
906 memset(&usb_dev[dev_index], 0, sizeof(struct usb_device));
907 usb_dev[dev_index].devnum = -1;
911 * XHCI issues Enable Slot command and thereafter
912 * allocates device contexts. Provide a weak alias
913 * function for the purpose, so that XHCI overrides it
914 * and EHCI/OHCI just work out of the box.
916 __weak int usb_alloc_device(struct usb_device *udev)
920 #endif /* !CONFIG_IS_ENABLED(DM_USB) */
922 static int usb_hub_port_reset(struct usb_device *dev, struct usb_device *hub)
925 usb_reset_root_port(dev);
930 static int get_descriptor_len(struct usb_device *dev, int len, int expect_len)
932 __maybe_unused struct usb_device_descriptor *desc;
933 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ);
936 desc = (struct usb_device_descriptor *)tmpbuf;
938 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, len);
939 if (err < expect_len) {
941 printf("unable to get device descriptor (error=%d)\n",
945 printf("USB device descriptor short read (expected %i, got %i)\n",
950 memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor));
955 static int usb_setup_descriptor(struct usb_device *dev, bool do_read)
958 * This is a Windows scheme of initialization sequence, with double
959 * reset of the device (Linux uses the same sequence)
960 * Some equipment is said to work only with such init sequence; this
961 * patch is based on the work by Alan Stern:
962 * http://sourceforge.net/mailarchive/forum.php?
963 * thread_id=5729457&forum_id=5398
967 * send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is
968 * only 18 bytes long, this will terminate with a short packet. But if
969 * the maxpacket size is 8 or 16 the device may be waiting to transmit
970 * some more, or keeps on retransmitting the 8 byte header.
973 if (dev->speed == USB_SPEED_LOW) {
974 dev->descriptor.bMaxPacketSize0 = 8;
975 dev->maxpacketsize = PACKET_SIZE_8;
977 dev->descriptor.bMaxPacketSize0 = 64;
978 dev->maxpacketsize = PACKET_SIZE_64;
980 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
981 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
983 if (do_read && dev->speed == USB_SPEED_FULL) {
987 * Validate we've received only at least 8 bytes, not that
988 * we've received the entire descriptor. The reasoning is:
989 * - The code only uses fields in the first 8 bytes, so
990 * that's all we need to have fetched at this stage.
991 * - The smallest maxpacket size is 8 bytes. Before we know
992 * the actual maxpacket the device uses, the USB controller
993 * may only accept a single packet. Consequently we are only
994 * guaranteed to receive 1 packet (at least 8 bytes) even in
997 * At least the DWC2 controller needs to be programmed with
998 * the number of packets in addition to the number of bytes.
999 * A request for 64 bytes of data with the maxpacket guessed
1000 * as 64 (above) yields a request for 1 packet.
1002 err = get_descriptor_len(dev, 64, 8);
1007 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
1008 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
1009 switch (dev->descriptor.bMaxPacketSize0) {
1011 dev->maxpacketsize = PACKET_SIZE_8;
1014 dev->maxpacketsize = PACKET_SIZE_16;
1017 dev->maxpacketsize = PACKET_SIZE_32;
1020 dev->maxpacketsize = PACKET_SIZE_64;
1023 printf("%s: invalid max packet size\n", __func__);
1030 static int usb_prepare_device(struct usb_device *dev, int addr, bool do_read,
1031 struct usb_device *parent)
1036 * Allocate usb 3.0 device context.
1037 * USB 3.0 (xHCI) protocol tries to allocate device slot
1038 * and related data structures first. This call does that.
1039 * Refer to sec 4.3.2 in xHCI spec rev1.0
1041 err = usb_alloc_device(dev);
1043 printf("Cannot allocate device context to get SLOT_ID\n");
1046 err = usb_setup_descriptor(dev, do_read);
1049 err = usb_hub_port_reset(dev, parent);
1055 err = usb_set_address(dev); /* set address */
1058 printf("\n USB device not accepting new address " \
1059 "(error=%lX)\n", dev->status);
1063 mdelay(10); /* Let the SET_ADDRESS settle */
1066 * If we haven't read device descriptor before, read it here
1067 * after device is assigned an address. This is only applicable
1071 err = usb_setup_descriptor(dev, true);
1079 int usb_select_config(struct usb_device *dev)
1081 unsigned char *tmpbuf = NULL;
1084 err = get_descriptor_len(dev, USB_DT_DEVICE_SIZE, USB_DT_DEVICE_SIZE);
1088 /* correct le values */
1089 le16_to_cpus(&dev->descriptor.bcdUSB);
1090 le16_to_cpus(&dev->descriptor.idVendor);
1091 le16_to_cpus(&dev->descriptor.idProduct);
1092 le16_to_cpus(&dev->descriptor.bcdDevice);
1095 * Kingston DT Ultimate 32GB USB 3.0 seems to be extremely sensitive
1096 * about this first Get Descriptor request. If there are any other
1097 * requests in the first microframe, the stick crashes. Wait about
1098 * one microframe duration here (1mS for USB 1.x , 125uS for USB 2.0).
1102 /* only support for one config for now */
1103 err = usb_get_configuration_len(dev, 0);
1105 tmpbuf = (unsigned char *)malloc_cache_aligned(err);
1109 err = usb_get_configuration_no(dev, 0, tmpbuf, err);
1112 printf("usb_new_device: Cannot read configuration, " \
1113 "skipping device %04x:%04x\n",
1114 dev->descriptor.idVendor, dev->descriptor.idProduct);
1118 usb_parse_config(dev, tmpbuf, 0);
1120 usb_set_maxpacket(dev);
1122 * we set the default configuration here
1123 * This seems premature. If the driver wants a different configuration
1124 * it will need to select itself.
1126 err = usb_set_configuration(dev, dev->config.desc.bConfigurationValue);
1128 printf("failed to set default configuration " \
1129 "len %d, status %lX\n", dev->act_len, dev->status);
1134 * Wait until the Set Configuration request gets processed by the
1135 * device. This is required by at least SanDisk Cruzer Pop USB 2.0
1136 * and Kingston DT Ultimate 32GB USB 3.0 on DWC2 OTG controller.
1140 debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
1141 dev->descriptor.iManufacturer, dev->descriptor.iProduct,
1142 dev->descriptor.iSerialNumber);
1143 memset(dev->mf, 0, sizeof(dev->mf));
1144 memset(dev->prod, 0, sizeof(dev->prod));
1145 memset(dev->serial, 0, sizeof(dev->serial));
1146 if (dev->descriptor.iManufacturer)
1147 usb_string(dev, dev->descriptor.iManufacturer,
1148 dev->mf, sizeof(dev->mf));
1149 if (dev->descriptor.iProduct)
1150 usb_string(dev, dev->descriptor.iProduct,
1151 dev->prod, sizeof(dev->prod));
1152 if (dev->descriptor.iSerialNumber)
1153 usb_string(dev, dev->descriptor.iSerialNumber,
1154 dev->serial, sizeof(dev->serial));
1155 debug("Manufacturer %s\n", dev->mf);
1156 debug("Product %s\n", dev->prod);
1157 debug("SerialNumber %s\n", dev->serial);
1162 int usb_setup_device(struct usb_device *dev, bool do_read,
1163 struct usb_device *parent)
1168 /* We still haven't set the Address yet */
1172 ret = usb_prepare_device(dev, addr, do_read, parent);
1175 ret = usb_select_config(dev);
1180 #if !CONFIG_IS_ENABLED(DM_USB)
1182 * By the time we get here, the device has gotten a new device ID
1183 * and is in the default state. We need to identify the thing and
1184 * get the ball rolling..
1186 * Returns 0 for success, != 0 for error.
1188 int usb_new_device(struct usb_device *dev)
1190 bool do_read = true;
1194 * XHCI needs to issue a Address device command to setup
1195 * proper device context structures, before it can interact
1196 * with the device. So a get_descriptor will fail before any
1197 * of that is done for XHCI unlike EHCI.
1199 #ifdef CONFIG_USB_XHCI_HCD
1202 err = usb_setup_device(dev, do_read, dev->parent);
1206 /* Now probe if the device is a hub */
1207 err = usb_hub_probe(dev, 0);
1216 int board_usb_init(int index, enum usb_init_type init)
1222 int board_usb_cleanup(int index, enum usb_init_type init)
1227 bool usb_device_has_child_on_port(struct usb_device *parent, int port)
1229 #if CONFIG_IS_ENABLED(DM_USB)
1232 return parent->children[port] != NULL;
1236 #if CONFIG_IS_ENABLED(DM_USB)
1237 void usb_find_usb2_hub_address_port(struct usb_device *udev,
1238 uint8_t *hub_address, uint8_t *hub_port)
1240 struct udevice *parent;
1241 struct usb_device *uparent, *ttdev;
1244 * When called from usb-uclass.c: usb_scan_device() udev->dev points
1245 * to the parent udevice, not the actual udevice belonging to the
1246 * udev as the device is not instantiated yet. So when searching
1247 * for the first usb-2 parent start with udev->dev not
1248 * udev->dev->parent .
1252 uparent = dev_get_parent_priv(parent);
1254 while (uparent->speed != USB_SPEED_HIGH) {
1255 struct udevice *dev = parent;
1257 if (device_get_uclass_id(dev->parent) != UCLASS_USB_HUB) {
1258 printf("Error: Cannot find high speed parent of usb-1 device\n");
1264 ttdev = dev_get_parent_priv(dev);
1265 parent = dev->parent;
1266 uparent = dev_get_parent_priv(parent);
1268 *hub_address = uparent->devnum;
1269 *hub_port = ttdev->portnr;
1272 void usb_find_usb2_hub_address_port(struct usb_device *udev,
1273 uint8_t *hub_address, uint8_t *hub_port)
1275 /* Find out the nearest parent which is high speed */
1276 while (udev->parent->parent != NULL)
1277 if (udev->parent->speed != USB_SPEED_HIGH) {
1278 udev = udev->parent;
1280 *hub_address = udev->parent->devnum;
1281 *hub_port = udev->portnr;
1285 printf("Error: Cannot find high speed parent of usb-1 device\n");