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
18 * See file CREDITS for list of people who contributed to this
21 * This program is free software; you can redistribute it and/or
22 * modify it under the terms of the GNU General Public License as
23 * published by the Free Software Foundation; either version 2 of
24 * the License, or (at your option) any later version.
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, write to the Free Software
33 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
41 * Since this is a bootloader, the devices will not be automatic
42 * (re)configured on hotplug, but after a restart of the USB the
45 * For each transfer (except "Interrupt") we wait for completion.
49 #include <asm/processor.h>
50 #include <linux/ctype.h>
51 #include <asm/byteorder.h>
55 #include <asm/4xx_pci.h>
61 #define USB_PRINTF(fmt, args...) printf(fmt , ##args)
63 #define USB_PRINTF(fmt, args...)
66 #define USB_BUFSIZ 512
68 static struct usb_device usb_dev
[USB_MAX_DEVICE
];
71 static int asynch_allowed
;
72 static struct devrequest setup_packet
;
74 char usb_started
; /* flag for the started/stopped USB status */
76 /**********************************************************************
77 * some forward declerations...
79 void usb_scan_devices(void);
81 int usb_hub_probe(struct usb_device
*dev
, int ifnum
);
82 void usb_hub_reset(void);
83 static int hub_port_reset(struct usb_device
*dev
, int port
,
84 unsigned short *portstat
);
86 /***********************************************************************
90 inline void wait_ms(unsigned long ms
)
96 /***************************************************************************
108 /* init low_level USB */
110 result
= usb_lowlevel_init();
111 /* if lowlevel init is OK, scan the bus for devices
112 * i.e. search HUBs and configure them */
114 printf("scanning bus for devices... ");
120 printf("Error, couldn't init Lowlevel part\n");
126 /******************************************************************************
127 * Stop USB this stops the LowLevel Part and deregisters USB devices.
137 res
= usb_lowlevel_stop();
143 * disables the asynch behaviour of the control message. This is used for data
144 * transfers that uses the exclusiv access to the control and bulk messages.
146 void usb_disable_asynch(int disable
)
148 asynch_allowed
= !disable
;
152 /*-------------------------------------------------------------------
158 * submits an Interrupt Message
160 int usb_submit_int_msg(struct usb_device
*dev
, unsigned long pipe
,
161 void *buffer
, int transfer_len
, int interval
)
163 return submit_int_msg(dev
, pipe
, buffer
, transfer_len
, interval
);
167 * submits a control message and waits for comletion (at least timeout * 1ms)
168 * If timeout is 0, we don't wait for completion (used as example to set and
169 * clear keyboards LEDs). For data transfers, (storage transfers) we don't
170 * allow control messages with 0 timeout, by previousely resetting the flag
171 * asynch_allowed (usb_disable_asynch(1)).
172 * returns the transfered length if OK or -1 if error. The transfered length
173 * and the current status are stored in the dev->act_len and dev->status.
175 int usb_control_msg(struct usb_device
*dev
, unsigned int pipe
,
176 unsigned char request
, unsigned char requesttype
,
177 unsigned short value
, unsigned short index
,
178 void *data
, unsigned short size
, int timeout
)
180 if ((timeout
== 0) && (!asynch_allowed
)) {
181 /* request for a asynch control pipe is not allowed */
185 /* set setup command */
186 setup_packet
.requesttype
= requesttype
;
187 setup_packet
.request
= request
;
188 setup_packet
.value
= cpu_to_le16(value
);
189 setup_packet
.index
= cpu_to_le16(index
);
190 setup_packet
.length
= cpu_to_le16(size
);
191 USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
192 "value 0x%X index 0x%X length 0x%X\n",
193 request
, requesttype
, value
, index
, size
);
194 dev
->status
= USB_ST_NOT_PROC
; /*not yet processed */
196 submit_control_msg(dev
, pipe
, data
, size
, &setup_packet
);
200 if (dev
->status
!= 0) {
202 * Let's wait a while for the timeout to elapse.
203 * It has no real use, but it keeps the interface happy.
212 /*-------------------------------------------------------------------
213 * submits bulk message, and waits for completion. returns 0 if Ok or
215 * synchronous behavior
217 int usb_bulk_msg(struct usb_device
*dev
, unsigned int pipe
,
218 void *data
, int len
, int *actual_length
, int timeout
)
222 dev
->status
= USB_ST_NOT_PROC
; /*not yet processed */
223 submit_bulk_msg(dev
, pipe
, data
, len
);
225 if (!((volatile unsigned long)dev
->status
& USB_ST_NOT_PROC
))
229 *actual_length
= dev
->act_len
;
230 if (dev
->status
== 0)
237 /*-------------------------------------------------------------------
242 * returns the max packet size, depending on the pipe direction and
243 * the configurations values
245 int usb_maxpacket(struct usb_device
*dev
, unsigned long pipe
)
247 /* direction is out -> use emaxpacket out */
248 if ((pipe
& USB_DIR_IN
) == 0)
249 return dev
->epmaxpacketout
[((pipe
>>15) & 0xf)];
251 return dev
->epmaxpacketin
[((pipe
>>15) & 0xf)];
254 /* The routine usb_set_maxpacket_ep() is extracted from the loop of routine
255 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine
256 * when it is inlined in 1 single routine. What happens is that the register r3
257 * is used as loop-count 'i', but gets overwritten later on.
258 * This is clearly a compiler bug, but it is easier to workaround it here than
259 * to update the compiler (Occurs with at least several GCC 4.{1,2},x
260 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM)
262 static void __attribute__((noinline
))
263 usb_set_maxpacket_ep(struct usb_device
*dev
, struct usb_endpoint_descriptor
*ep
)
267 b
= ep
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
;
269 if ((ep
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
270 USB_ENDPOINT_XFER_CONTROL
) {
271 /* Control => bidirectional */
272 dev
->epmaxpacketout
[b
] = ep
->wMaxPacketSize
;
273 dev
->epmaxpacketin
[b
] = ep
->wMaxPacketSize
;
274 USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",
275 b
, dev
->epmaxpacketin
[b
]);
277 if ((ep
->bEndpointAddress
& 0x80) == 0) {
279 if (ep
->wMaxPacketSize
> dev
->epmaxpacketout
[b
]) {
280 dev
->epmaxpacketout
[b
] = ep
->wMaxPacketSize
;
281 USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",
282 b
, dev
->epmaxpacketout
[b
]);
286 if (ep
->wMaxPacketSize
> dev
->epmaxpacketin
[b
]) {
287 dev
->epmaxpacketin
[b
] = ep
->wMaxPacketSize
;
288 USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",
289 b
, dev
->epmaxpacketin
[b
]);
296 * set the max packed value of all endpoints in the given configuration
298 int usb_set_maxpacket(struct usb_device
*dev
)
302 for (i
= 0; i
< dev
->config
.bNumInterfaces
; i
++)
303 for (ii
= 0; ii
< dev
->config
.if_desc
[i
].bNumEndpoints
; ii
++)
304 usb_set_maxpacket_ep(dev
,
305 &dev
->config
.if_desc
[i
].ep_desc
[ii
]);
310 /*******************************************************************************
311 * Parse the config, located in buffer, and fills the dev->config structure.
312 * Note that all little/big endian swapping are done automatically.
314 int usb_parse_config(struct usb_device
*dev
, unsigned char *buffer
, int cfgno
)
316 struct usb_descriptor_header
*head
;
317 int index
, ifno
, epno
, curr_if_num
;
325 dev
->configno
= cfgno
;
326 head
= (struct usb_descriptor_header
*) &buffer
[0];
327 if (head
->bDescriptorType
!= USB_DT_CONFIG
) {
328 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
329 head
->bDescriptorType
);
332 memcpy(&dev
->config
, buffer
, buffer
[0]);
333 le16_to_cpus(&(dev
->config
.wTotalLength
));
334 dev
->config
.no_of_if
= 0;
336 index
= dev
->config
.bLength
;
337 /* Ok the first entry must be a configuration entry,
338 * now process the others */
339 head
= (struct usb_descriptor_header
*) &buffer
[index
];
340 while (index
+ 1 < dev
->config
.wTotalLength
) {
341 switch (head
->bDescriptorType
) {
342 case USB_DT_INTERFACE
:
343 if (((struct usb_interface_descriptor
*) \
344 &buffer
[index
])->bInterfaceNumber
!= curr_if_num
) {
345 /* this is a new interface, copy new desc */
346 ifno
= dev
->config
.no_of_if
;
347 dev
->config
.no_of_if
++;
348 memcpy(&dev
->config
.if_desc
[ifno
],
349 &buffer
[index
], buffer
[index
]);
350 dev
->config
.if_desc
[ifno
].no_of_ep
= 0;
351 dev
->config
.if_desc
[ifno
].num_altsetting
= 1;
353 dev
->config
.if_desc
[ifno
].bInterfaceNumber
;
355 /* found alternate setting for the interface */
356 dev
->config
.if_desc
[ifno
].num_altsetting
++;
359 case USB_DT_ENDPOINT
:
360 epno
= dev
->config
.if_desc
[ifno
].no_of_ep
;
361 /* found an endpoint */
362 dev
->config
.if_desc
[ifno
].no_of_ep
++;
363 memcpy(&dev
->config
.if_desc
[ifno
].ep_desc
[epno
],
364 &buffer
[index
], buffer
[index
]);
365 le16_to_cpus(&(dev
->config
.if_desc
[ifno
].ep_desc
[epno
].\
367 USB_PRINTF("if %d, ep %d\n", ifno
, epno
);
370 if (head
->bLength
== 0)
373 USB_PRINTF("unknown Description Type : %x\n",
374 head
->bDescriptorType
);
377 ch
= (unsigned char *)head
;
378 for (i
= 0; i
< head
->bLength
; i
++)
379 USB_PRINTF("%02X ", *ch
++);
380 USB_PRINTF("\n\n\n");
384 index
+= head
->bLength
;
385 head
= (struct usb_descriptor_header
*)&buffer
[index
];
390 /***********************************************************************
392 * endp: endpoint number in bits 0-3;
393 * direction flag in bit 7 (1 = IN, 0 = OUT)
395 int usb_clear_halt(struct usb_device
*dev
, int pipe
)
398 int endp
= usb_pipeendpoint(pipe
)|(usb_pipein(pipe
)<<7);
400 result
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
401 USB_REQ_CLEAR_FEATURE
, USB_RECIP_ENDPOINT
, 0,
402 endp
, NULL
, 0, USB_CNTL_TIMEOUT
* 3);
404 /* don't clear if failed */
409 * NOTE: we do not get status and verify reset was successful
410 * as some devices are reported to lock up upon this check..
413 usb_endpoint_running(dev
, usb_pipeendpoint(pipe
), usb_pipeout(pipe
));
415 /* toggle is reset on clear */
416 usb_settoggle(dev
, usb_pipeendpoint(pipe
), usb_pipeout(pipe
), 0);
421 /**********************************************************************
422 * get_descriptor type
424 int usb_get_descriptor(struct usb_device
*dev
, unsigned char type
,
425 unsigned char index
, void *buf
, int size
)
428 res
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
429 USB_REQ_GET_DESCRIPTOR
, USB_DIR_IN
,
430 (type
<< 8) + index
, 0,
431 buf
, size
, USB_CNTL_TIMEOUT
);
435 /**********************************************************************
436 * gets configuration cfgno and store it in the buffer
438 int usb_get_configuration_no(struct usb_device
*dev
,
439 unsigned char *buffer
, int cfgno
)
443 struct usb_config_descriptor
*config
;
446 config
= (struct usb_config_descriptor
*)&buffer
[0];
447 result
= usb_get_descriptor(dev
, USB_DT_CONFIG
, cfgno
, buffer
, 9);
450 printf("unable to get descriptor, error %lX\n",
453 printf("config descriptor too short " \
454 "(expected %i, got %i)\n", 9, result
);
457 tmp
= le16_to_cpu(config
->wTotalLength
);
459 if (tmp
> USB_BUFSIZ
) {
460 USB_PRINTF("usb_get_configuration_no: failed to get " \
461 "descriptor - too long: %d\n", tmp
);
465 result
= usb_get_descriptor(dev
, USB_DT_CONFIG
, cfgno
, buffer
, tmp
);
466 USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",
471 /********************************************************************
472 * set address of a device to the value in dev->devnum.
473 * This can only be done by addressing the device via the default address (0)
475 int usb_set_address(struct usb_device
*dev
)
479 USB_PRINTF("set address %d\n", dev
->devnum
);
480 res
= usb_control_msg(dev
, usb_snddefctrl(dev
),
481 USB_REQ_SET_ADDRESS
, 0,
483 NULL
, 0, USB_CNTL_TIMEOUT
);
487 /********************************************************************
488 * set interface number to interface
490 int usb_set_interface(struct usb_device
*dev
, int interface
, int alternate
)
492 struct usb_interface_descriptor
*if_face
= NULL
;
495 for (i
= 0; i
< dev
->config
.bNumInterfaces
; i
++) {
496 if (dev
->config
.if_desc
[i
].bInterfaceNumber
== interface
) {
497 if_face
= &dev
->config
.if_desc
[i
];
502 printf("selecting invalid interface %d", interface
);
506 * We should return now for devices with only one alternate setting.
507 * According to 9.4.10 of the Universal Serial Bus Specification
508 * Revision 2.0 such devices can return with a STALL. This results in
509 * some USB sticks timeouting during initialization and then being
510 * unusable in U-Boot.
512 if (if_face
->num_altsetting
== 1)
515 ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
516 USB_REQ_SET_INTERFACE
, USB_RECIP_INTERFACE
,
517 alternate
, interface
, NULL
, 0,
518 USB_CNTL_TIMEOUT
* 5);
525 /********************************************************************
526 * set configuration number to configuration
528 int usb_set_configuration(struct usb_device
*dev
, int configuration
)
531 USB_PRINTF("set configuration %d\n", configuration
);
532 /* set setup command */
533 res
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
534 USB_REQ_SET_CONFIGURATION
, 0,
536 NULL
, 0, USB_CNTL_TIMEOUT
);
545 /********************************************************************
546 * set protocol to protocol
548 int usb_set_protocol(struct usb_device
*dev
, int ifnum
, int protocol
)
550 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
551 USB_REQ_SET_PROTOCOL
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
552 protocol
, ifnum
, NULL
, 0, USB_CNTL_TIMEOUT
);
555 /********************************************************************
558 int usb_set_idle(struct usb_device
*dev
, int ifnum
, int duration
, int report_id
)
560 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
561 USB_REQ_SET_IDLE
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
562 (duration
<< 8) | report_id
, ifnum
, NULL
, 0, USB_CNTL_TIMEOUT
);
565 /********************************************************************
568 int usb_get_report(struct usb_device
*dev
, int ifnum
, unsigned char type
,
569 unsigned char id
, void *buf
, int size
)
571 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
573 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
574 (type
<< 8) + id
, ifnum
, buf
, size
, USB_CNTL_TIMEOUT
);
577 /********************************************************************
578 * get class descriptor
580 int usb_get_class_descriptor(struct usb_device
*dev
, int ifnum
,
581 unsigned char type
, unsigned char id
, void *buf
, int size
)
583 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
584 USB_REQ_GET_DESCRIPTOR
, USB_RECIP_INTERFACE
| USB_DIR_IN
,
585 (type
<< 8) + id
, ifnum
, buf
, size
, USB_CNTL_TIMEOUT
);
588 /********************************************************************
589 * get string index in buffer
591 int usb_get_string(struct usb_device
*dev
, unsigned short langid
,
592 unsigned char index
, void *buf
, int size
)
597 for (i
= 0; i
< 3; ++i
) {
598 /* some devices are flaky */
599 result
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
600 USB_REQ_GET_DESCRIPTOR
, USB_DIR_IN
,
601 (USB_DT_STRING
<< 8) + index
, langid
, buf
, size
,
612 static void usb_try_string_workarounds(unsigned char *buf
, int *length
)
614 int newlength
, oldlength
= *length
;
616 for (newlength
= 2; newlength
+ 1 < oldlength
; newlength
+= 2)
617 if (!isprint(buf
[newlength
]) || buf
[newlength
+ 1])
627 static int usb_string_sub(struct usb_device
*dev
, unsigned int langid
,
628 unsigned int index
, unsigned char *buf
)
632 /* Try to read the string descriptor by asking for the maximum
633 * possible number of bytes */
634 rc
= usb_get_string(dev
, langid
, index
, buf
, 255);
636 /* If that failed try to read the descriptor length, then
637 * ask for just that many bytes */
639 rc
= usb_get_string(dev
, langid
, index
, buf
, 2);
641 rc
= usb_get_string(dev
, langid
, index
, buf
, buf
[0]);
645 if (!buf
[0] && !buf
[1])
646 usb_try_string_workarounds(buf
, &rc
);
648 /* There might be extra junk at the end of the descriptor */
652 rc
= rc
- (rc
& 1); /* force a multiple of two */
662 /********************************************************************
664 * Get string index and translate it to ascii.
665 * returns string length (> 0) or error (< 0)
667 int usb_string(struct usb_device
*dev
, int index
, char *buf
, size_t size
)
669 unsigned char mybuf
[USB_BUFSIZ
];
674 if (size
<= 0 || !buf
|| !index
)
679 /* get langid for strings if it's not yet known */
680 if (!dev
->have_langid
) {
681 err
= usb_string_sub(dev
, 0, 0, tbuf
);
683 USB_PRINTF("error getting string descriptor 0 " \
684 "(error=%x)\n", dev
->status
);
686 } else if (tbuf
[0] < 4) {
687 USB_PRINTF("string descriptor 0 too short\n");
690 dev
->have_langid
= -1;
691 dev
->string_langid
= tbuf
[2] | (tbuf
[3] << 8);
692 /* always use the first langid listed */
693 USB_PRINTF("USB device number %d default " \
694 "language ID 0x%x\n",
695 dev
->devnum
, dev
->string_langid
);
699 err
= usb_string_sub(dev
, dev
->string_langid
, index
, tbuf
);
703 size
--; /* leave room for trailing NULL char in output buffer */
704 for (idx
= 0, u
= 2; u
< err
; u
+= 2) {
707 if (tbuf
[u
+1]) /* high byte */
708 buf
[idx
++] = '?'; /* non-ASCII character */
710 buf
[idx
++] = tbuf
[u
];
718 /********************************************************************
719 * USB device handling:
720 * the USB device are static allocated [USB_MAX_DEVICE].
724 /* returns a pointer to the device with the index [index].
725 * if the device is not assigned (dev->devnum==-1) returns NULL
727 struct usb_device
*usb_get_dev_index(int index
)
729 if (usb_dev
[index
].devnum
== -1)
732 return &usb_dev
[index
];
736 /* returns a pointer of a new device structure or NULL, if
737 * no device struct is available
739 struct usb_device
*usb_alloc_new_device(void)
742 USB_PRINTF("New Device %d\n", dev_index
);
743 if (dev_index
== USB_MAX_DEVICE
) {
744 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE
);
747 /* default Address is 0, real addresses start with 1 */
748 usb_dev
[dev_index
].devnum
= dev_index
+ 1;
749 usb_dev
[dev_index
].maxchild
= 0;
750 for (i
= 0; i
< USB_MAXCHILDREN
; i
++)
751 usb_dev
[dev_index
].children
[i
] = NULL
;
752 usb_dev
[dev_index
].parent
= NULL
;
754 return &usb_dev
[dev_index
- 1];
759 * By the time we get here, the device has gotten a new device ID
760 * and is in the default state. We need to identify the thing and
761 * get the ball rolling..
763 * Returns 0 for success, != 0 for error.
765 int usb_new_device(struct usb_device
*dev
)
769 unsigned char tmpbuf
[USB_BUFSIZ
];
771 /* We still haven't set the Address yet */
775 #ifdef CONFIG_LEGACY_USB_INIT_SEQ
776 /* this is the old and known way of initializing devices, it is
777 * different than what Windows and Linux are doing. Windows and Linux
778 * both retrieve 64 bytes while reading the device descriptor
779 * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an
780 * invalid header while reading 8 bytes as device descriptor. */
781 dev
->descriptor
.bMaxPacketSize0
= 8; /* Start off at 8 bytes */
782 dev
->maxpacketsize
= PACKET_SIZE_8
;
783 dev
->epmaxpacketin
[0] = 8;
784 dev
->epmaxpacketout
[0] = 8;
786 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0, &dev
->descriptor
, 8);
788 printf("\n USB device not responding, " \
789 "giving up (status=%lX)\n", dev
->status
);
793 /* This is a Windows scheme of initialization sequence, with double
794 * reset of the device (Linux uses the same sequence)
795 * Some equipment is said to work only with such init sequence; this
796 * patch is based on the work by Alan Stern:
797 * http://sourceforge.net/mailarchive/forum.php?
798 * thread_id=5729457&forum_id=5398
800 struct usb_device_descriptor
*desc
;
802 struct usb_device
*parent
= dev
->parent
;
803 unsigned short portstatus
;
805 /* send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is
806 * only 18 bytes long, this will terminate with a short packet. But if
807 * the maxpacket size is 8 or 16 the device may be waiting to transmit
808 * some more, or keeps on retransmitting the 8 byte header. */
810 desc
= (struct usb_device_descriptor
*)tmpbuf
;
811 dev
->descriptor
.bMaxPacketSize0
= 64; /* Start off at 64 bytes */
812 /* Default to 64 byte max packet size */
813 dev
->maxpacketsize
= PACKET_SIZE_64
;
814 dev
->epmaxpacketin
[0] = 64;
815 dev
->epmaxpacketout
[0] = 64;
817 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0, desc
, 64);
819 USB_PRINTF("usb_new_device: usb_get_descriptor() failed\n");
823 dev
->descriptor
.bMaxPacketSize0
= desc
->bMaxPacketSize0
;
825 /* find the port number we're at */
829 for (j
= 0; j
< parent
->maxchild
; j
++) {
830 if (parent
->children
[j
] == dev
) {
836 printf("usb_new_device:cannot locate device's port.\n");
840 /* reset the port for the second time */
841 err
= hub_port_reset(dev
->parent
, port
, &portstatus
);
843 printf("\n Couldn't reset port %i\n", port
);
849 dev
->epmaxpacketin
[0] = dev
->descriptor
.bMaxPacketSize0
;
850 dev
->epmaxpacketout
[0] = dev
->descriptor
.bMaxPacketSize0
;
851 switch (dev
->descriptor
.bMaxPacketSize0
) {
853 dev
->maxpacketsize
= PACKET_SIZE_8
;
856 dev
->maxpacketsize
= PACKET_SIZE_16
;
859 dev
->maxpacketsize
= PACKET_SIZE_32
;
862 dev
->maxpacketsize
= PACKET_SIZE_64
;
867 err
= usb_set_address(dev
); /* set address */
870 printf("\n USB device not accepting new address " \
871 "(error=%lX)\n", dev
->status
);
875 wait_ms(10); /* Let the SET_ADDRESS settle */
877 tmp
= sizeof(dev
->descriptor
);
879 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0,
880 &dev
->descriptor
, sizeof(dev
->descriptor
));
883 printf("unable to get device descriptor (error=%d)\n",
886 printf("USB device descriptor short read " \
887 "(expected %i, got %i)\n", tmp
, err
);
890 /* correct le values */
891 le16_to_cpus(&dev
->descriptor
.bcdUSB
);
892 le16_to_cpus(&dev
->descriptor
.idVendor
);
893 le16_to_cpus(&dev
->descriptor
.idProduct
);
894 le16_to_cpus(&dev
->descriptor
.bcdDevice
);
895 /* only support for one config for now */
896 usb_get_configuration_no(dev
, &tmpbuf
[0], 0);
897 usb_parse_config(dev
, &tmpbuf
[0], 0);
898 usb_set_maxpacket(dev
);
899 /* we set the default configuration here */
900 if (usb_set_configuration(dev
, dev
->config
.bConfigurationValue
)) {
901 printf("failed to set default configuration " \
902 "len %d, status %lX\n", dev
->act_len
, dev
->status
);
905 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
906 dev
->descriptor
.iManufacturer
, dev
->descriptor
.iProduct
,
907 dev
->descriptor
.iSerialNumber
);
908 memset(dev
->mf
, 0, sizeof(dev
->mf
));
909 memset(dev
->prod
, 0, sizeof(dev
->prod
));
910 memset(dev
->serial
, 0, sizeof(dev
->serial
));
911 if (dev
->descriptor
.iManufacturer
)
912 usb_string(dev
, dev
->descriptor
.iManufacturer
,
913 dev
->mf
, sizeof(dev
->mf
));
914 if (dev
->descriptor
.iProduct
)
915 usb_string(dev
, dev
->descriptor
.iProduct
,
916 dev
->prod
, sizeof(dev
->prod
));
917 if (dev
->descriptor
.iSerialNumber
)
918 usb_string(dev
, dev
->descriptor
.iSerialNumber
,
919 dev
->serial
, sizeof(dev
->serial
));
920 USB_PRINTF("Manufacturer %s\n", dev
->mf
);
921 USB_PRINTF("Product %s\n", dev
->prod
);
922 USB_PRINTF("SerialNumber %s\n", dev
->serial
);
923 /* now prode if the device is a hub */
924 usb_hub_probe(dev
, 0);
928 /* build device Tree */
929 void usb_scan_devices(void)
932 struct usb_device
*dev
;
934 /* first make all devices unknown */
935 for (i
= 0; i
< USB_MAX_DEVICE
; i
++) {
936 memset(&usb_dev
[i
], 0, sizeof(struct usb_device
));
937 usb_dev
[i
].devnum
= -1;
940 /* device 0 is always present (root hub, so let it analyze) */
941 dev
= usb_alloc_new_device();
943 printf("%d USB Device(s) found\n", dev_index
);
944 /* insert "driver" if possible */
945 #ifdef CONFIG_USB_KEYBOARD
947 USB_PRINTF("scan end\n");
952 /****************************************************************************
954 * Probes device for being a hub and configurate it
960 #define USB_HUB_PRINTF(fmt, args...) printf(fmt , ##args)
962 #define USB_HUB_PRINTF(fmt, args...)
966 static struct usb_hub_device hub_dev
[USB_MAX_HUB
];
967 static int usb_hub_index
;
970 int usb_get_hub_descriptor(struct usb_device
*dev
, void *data
, int size
)
972 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
973 USB_REQ_GET_DESCRIPTOR
, USB_DIR_IN
| USB_RT_HUB
,
974 USB_DT_HUB
<< 8, 0, data
, size
, USB_CNTL_TIMEOUT
);
977 int usb_clear_hub_feature(struct usb_device
*dev
, int feature
)
979 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
980 USB_REQ_CLEAR_FEATURE
, USB_RT_HUB
, feature
,
981 0, NULL
, 0, USB_CNTL_TIMEOUT
);
984 int usb_clear_port_feature(struct usb_device
*dev
, int port
, int feature
)
986 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
987 USB_REQ_CLEAR_FEATURE
, USB_RT_PORT
, feature
,
988 port
, NULL
, 0, USB_CNTL_TIMEOUT
);
991 int usb_set_port_feature(struct usb_device
*dev
, int port
, int feature
)
993 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
994 USB_REQ_SET_FEATURE
, USB_RT_PORT
, feature
,
995 port
, NULL
, 0, USB_CNTL_TIMEOUT
);
998 int usb_get_hub_status(struct usb_device
*dev
, void *data
)
1000 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
1001 USB_REQ_GET_STATUS
, USB_DIR_IN
| USB_RT_HUB
, 0, 0,
1002 data
, sizeof(struct usb_hub_status
), USB_CNTL_TIMEOUT
);
1005 int usb_get_port_status(struct usb_device
*dev
, int port
, void *data
)
1007 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
1008 USB_REQ_GET_STATUS
, USB_DIR_IN
| USB_RT_PORT
, 0, port
,
1009 data
, sizeof(struct usb_hub_status
), USB_CNTL_TIMEOUT
);
1013 static void usb_hub_power_on(struct usb_hub_device
*hub
)
1016 struct usb_device
*dev
;
1018 dev
= hub
->pusb_dev
;
1019 /* Enable power to the ports */
1020 USB_HUB_PRINTF("enabling power on all ports\n");
1021 for (i
= 0; i
< dev
->maxchild
; i
++) {
1022 usb_set_port_feature(dev
, i
+ 1, USB_PORT_FEAT_POWER
);
1023 USB_HUB_PRINTF("port %d returns %lX\n", i
+ 1, dev
->status
);
1024 wait_ms(hub
->desc
.bPwrOn2PwrGood
* 2);
1028 void usb_hub_reset(void)
1033 struct usb_hub_device
*usb_hub_allocate(void)
1035 if (usb_hub_index
< USB_MAX_HUB
)
1036 return &hub_dev
[usb_hub_index
++];
1038 printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB
);
1044 static int hub_port_reset(struct usb_device
*dev
, int port
,
1045 unsigned short *portstat
)
1048 struct usb_port_status portsts
;
1049 unsigned short portstatus
, portchange
;
1051 USB_HUB_PRINTF("hub_port_reset: resetting port %d...\n", port
);
1052 for (tries
= 0; tries
< MAX_TRIES
; tries
++) {
1054 usb_set_port_feature(dev
, port
+ 1, USB_PORT_FEAT_RESET
);
1057 if (usb_get_port_status(dev
, port
+ 1, &portsts
) < 0) {
1058 USB_HUB_PRINTF("get_port_status failed status %lX\n",
1062 portstatus
= le16_to_cpu(portsts
.wPortStatus
);
1063 portchange
= le16_to_cpu(portsts
.wPortChange
);
1064 USB_HUB_PRINTF("portstatus %x, change %x, %s\n",
1065 portstatus
, portchange
,
1066 portstatus
&(1<<USB_PORT_FEAT_LOWSPEED
) ? \
1067 "Low Speed" : "High Speed");
1068 USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
1069 " USB_PORT_STAT_ENABLE %d\n",
1070 (portchange
& USB_PORT_STAT_C_CONNECTION
) ? 1 : 0,
1071 (portstatus
& USB_PORT_STAT_CONNECTION
) ? 1 : 0,
1072 (portstatus
& USB_PORT_STAT_ENABLE
) ? 1 : 0);
1074 if ((portchange
& USB_PORT_STAT_C_CONNECTION
) ||
1075 !(portstatus
& USB_PORT_STAT_CONNECTION
))
1078 if (portstatus
& USB_PORT_STAT_ENABLE
)
1084 if (tries
== MAX_TRIES
) {
1085 USB_HUB_PRINTF("Cannot enable port %i after %i retries, " \
1086 "disabling port.\n", port
+ 1, MAX_TRIES
);
1087 USB_HUB_PRINTF("Maybe the USB cable is bad?\n");
1091 usb_clear_port_feature(dev
, port
+ 1, USB_PORT_FEAT_C_RESET
);
1092 *portstat
= portstatus
;
1097 void usb_hub_port_connect_change(struct usb_device
*dev
, int port
)
1099 struct usb_device
*usb
;
1100 struct usb_port_status portsts
;
1101 unsigned short portstatus
, portchange
;
1104 if (usb_get_port_status(dev
, port
+ 1, &portsts
) < 0) {
1105 USB_HUB_PRINTF("get_port_status failed\n");
1109 portstatus
= le16_to_cpu(portsts
.wPortStatus
);
1110 portchange
= le16_to_cpu(portsts
.wPortChange
);
1111 USB_HUB_PRINTF("portstatus %x, change %x, %s\n",
1112 portstatus
, portchange
,
1113 portstatus
&(1 << USB_PORT_FEAT_LOWSPEED
) ? \
1114 "Low Speed" : "High Speed");
1116 /* Clear the connection change status */
1117 usb_clear_port_feature(dev
, port
+ 1, USB_PORT_FEAT_C_CONNECTION
);
1119 /* Disconnect any existing devices under this port */
1120 if (((!(portstatus
& USB_PORT_STAT_CONNECTION
)) &&
1121 (!(portstatus
& USB_PORT_STAT_ENABLE
))) || (dev
->children
[port
])) {
1122 USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n");
1123 /* Return now if nothing is connected */
1124 if (!(portstatus
& USB_PORT_STAT_CONNECTION
))
1129 /* Reset the port */
1130 if (hub_port_reset(dev
, port
, &portstatus
) < 0) {
1131 printf("cannot reset port %i!?\n", port
+ 1);
1137 /* Allocate a new device struct for it */
1138 usb
= usb_alloc_new_device();
1139 usb
->slow
= (portstatus
& USB_PORT_STAT_LOW_SPEED
) ? 1 : 0;
1141 dev
->children
[port
] = usb
;
1143 /* Run it through the hoops (find a driver, etc) */
1144 if (usb_new_device(usb
)) {
1145 /* Woops, disable the port */
1146 USB_HUB_PRINTF("hub: disabling port %d\n", port
+ 1);
1147 usb_clear_port_feature(dev
, port
+ 1, USB_PORT_FEAT_ENABLE
);
1152 int usb_hub_configure(struct usb_device
*dev
)
1154 unsigned char buffer
[USB_BUFSIZ
], *bitmap
;
1155 struct usb_hub_descriptor
*descriptor
;
1156 struct usb_hub_status
*hubsts
;
1158 struct usb_hub_device
*hub
;
1160 /* "allocate" Hub device */
1161 hub
= usb_hub_allocate();
1164 hub
->pusb_dev
= dev
;
1165 /* Get the the hub descriptor */
1166 if (usb_get_hub_descriptor(dev
, buffer
, 4) < 0) {
1167 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1168 "descriptor, giving up %lX\n", dev
->status
);
1171 descriptor
= (struct usb_hub_descriptor
*)buffer
;
1173 /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
1174 i
= descriptor
->bLength
;
1175 if (i
> USB_BUFSIZ
) {
1176 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1177 "descriptor - too long: %d\n",
1178 descriptor
->bLength
);
1182 if (usb_get_hub_descriptor(dev
, buffer
, descriptor
->bLength
) < 0) {
1183 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1184 "descriptor 2nd giving up %lX\n", dev
->status
);
1187 memcpy((unsigned char *)&hub
->desc
, buffer
, descriptor
->bLength
);
1188 /* adjust 16bit values */
1189 hub
->desc
.wHubCharacteristics
=
1190 le16_to_cpu(descriptor
->wHubCharacteristics
);
1191 /* set the bitmap */
1192 bitmap
= (unsigned char *)&hub
->desc
.DeviceRemovable
[0];
1193 /* devices not removable by default */
1194 memset(bitmap
, 0xff, (USB_MAXCHILDREN
+1+7)/8);
1195 bitmap
= (unsigned char *)&hub
->desc
.PortPowerCtrlMask
[0];
1196 memset(bitmap
, 0xff, (USB_MAXCHILDREN
+1+7)/8); /* PowerMask = 1B */
1198 for (i
= 0; i
< ((hub
->desc
.bNbrPorts
+ 1 + 7)/8); i
++)
1199 hub
->desc
.DeviceRemovable
[i
] = descriptor
->DeviceRemovable
[i
];
1201 for (i
= 0; i
< ((hub
->desc
.bNbrPorts
+ 1 + 7)/8); i
++)
1202 hub
->desc
.DeviceRemovable
[i
] = descriptor
->PortPowerCtrlMask
[i
];
1204 dev
->maxchild
= descriptor
->bNbrPorts
;
1205 USB_HUB_PRINTF("%d ports detected\n", dev
->maxchild
);
1207 switch (hub
->desc
.wHubCharacteristics
& HUB_CHAR_LPSM
) {
1209 USB_HUB_PRINTF("ganged power switching\n");
1212 USB_HUB_PRINTF("individual port power switching\n");
1216 USB_HUB_PRINTF("unknown reserved power switching mode\n");
1220 if (hub
->desc
.wHubCharacteristics
& HUB_CHAR_COMPOUND
)
1221 USB_HUB_PRINTF("part of a compound device\n");
1223 USB_HUB_PRINTF("standalone hub\n");
1225 switch (hub
->desc
.wHubCharacteristics
& HUB_CHAR_OCPM
) {
1227 USB_HUB_PRINTF("global over-current protection\n");
1230 USB_HUB_PRINTF("individual port over-current protection\n");
1234 USB_HUB_PRINTF("no over-current protection\n");
1238 USB_HUB_PRINTF("power on to power good time: %dms\n",
1239 descriptor
->bPwrOn2PwrGood
* 2);
1240 USB_HUB_PRINTF("hub controller current requirement: %dmA\n",
1241 descriptor
->bHubContrCurrent
);
1243 for (i
= 0; i
< dev
->maxchild
; i
++)
1244 USB_HUB_PRINTF("port %d is%s removable\n", i
+ 1,
1245 hub
->desc
.DeviceRemovable
[(i
+ 1) / 8] & \
1246 (1 << ((i
+ 1) % 8)) ? " not" : "");
1248 if (sizeof(struct usb_hub_status
) > USB_BUFSIZ
) {
1249 USB_HUB_PRINTF("usb_hub_configure: failed to get Status - " \
1250 "too long: %d\n", descriptor
->bLength
);
1254 if (usb_get_hub_status(dev
, buffer
) < 0) {
1255 USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",
1260 hubsts
= (struct usb_hub_status
*)buffer
;
1261 USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n",
1262 le16_to_cpu(hubsts
->wHubStatus
),
1263 le16_to_cpu(hubsts
->wHubChange
));
1264 USB_HUB_PRINTF("local power source is %s\n",
1265 (le16_to_cpu(hubsts
->wHubStatus
) & HUB_STATUS_LOCAL_POWER
) ? \
1266 "lost (inactive)" : "good");
1267 USB_HUB_PRINTF("%sover-current condition exists\n",
1268 (le16_to_cpu(hubsts
->wHubStatus
) & HUB_STATUS_OVERCURRENT
) ? \
1270 usb_hub_power_on(hub
);
1272 for (i
= 0; i
< dev
->maxchild
; i
++) {
1273 struct usb_port_status portsts
;
1274 unsigned short portstatus
, portchange
;
1276 if (usb_get_port_status(dev
, i
+ 1, &portsts
) < 0) {
1277 USB_HUB_PRINTF("get_port_status failed\n");
1281 portstatus
= le16_to_cpu(portsts
.wPortStatus
);
1282 portchange
= le16_to_cpu(portsts
.wPortChange
);
1283 USB_HUB_PRINTF("Port %d Status %X Change %X\n",
1284 i
+ 1, portstatus
, portchange
);
1286 if (portchange
& USB_PORT_STAT_C_CONNECTION
) {
1287 USB_HUB_PRINTF("port %d connection change\n", i
+ 1);
1288 usb_hub_port_connect_change(dev
, i
);
1290 if (portchange
& USB_PORT_STAT_C_ENABLE
) {
1291 USB_HUB_PRINTF("port %d enable change, status %x\n",
1293 usb_clear_port_feature(dev
, i
+ 1,
1294 USB_PORT_FEAT_C_ENABLE
);
1296 /* EM interference sometimes causes bad shielded USB
1297 * devices to be shutdown by the hub, this hack enables
1298 * them again. Works at least with mouse driver */
1299 if (!(portstatus
& USB_PORT_STAT_ENABLE
) &&
1300 (portstatus
& USB_PORT_STAT_CONNECTION
) &&
1301 ((dev
->children
[i
]))) {
1302 USB_HUB_PRINTF("already running port %i " \
1303 "disabled by hub (EMI?), " \
1304 "re-enabling...\n", i
+ 1);
1305 usb_hub_port_connect_change(dev
, i
);
1308 if (portstatus
& USB_PORT_STAT_SUSPEND
) {
1309 USB_HUB_PRINTF("port %d suspend change\n", i
+ 1);
1310 usb_clear_port_feature(dev
, i
+ 1,
1311 USB_PORT_FEAT_SUSPEND
);
1314 if (portchange
& USB_PORT_STAT_C_OVERCURRENT
) {
1315 USB_HUB_PRINTF("port %d over-current change\n", i
+ 1);
1316 usb_clear_port_feature(dev
, i
+ 1,
1317 USB_PORT_FEAT_C_OVER_CURRENT
);
1318 usb_hub_power_on(hub
);
1321 if (portchange
& USB_PORT_STAT_C_RESET
) {
1322 USB_HUB_PRINTF("port %d reset change\n", i
+ 1);
1323 usb_clear_port_feature(dev
, i
+ 1,
1324 USB_PORT_FEAT_C_RESET
);
1326 } /* end for i all ports */
1331 int usb_hub_probe(struct usb_device
*dev
, int ifnum
)
1333 struct usb_interface_descriptor
*iface
;
1334 struct usb_endpoint_descriptor
*ep
;
1337 iface
= &dev
->config
.if_desc
[ifnum
];
1339 if (iface
->bInterfaceClass
!= USB_CLASS_HUB
)
1341 /* Some hubs have a subclass of 1, which AFAICT according to the */
1342 /* specs is not defined, but it works */
1343 if ((iface
->bInterfaceSubClass
!= 0) &&
1344 (iface
->bInterfaceSubClass
!= 1))
1346 /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1347 if (iface
->bNumEndpoints
!= 1)
1349 ep
= &iface
->ep_desc
[0];
1350 /* Output endpoint? Curiousier and curiousier.. */
1351 if (!(ep
->bEndpointAddress
& USB_DIR_IN
))
1353 /* If it's not an interrupt endpoint, we'd better punt! */
1354 if ((ep
->bmAttributes
& 3) != 3)
1356 /* We found a hub */
1357 USB_HUB_PRINTF("USB hub found\n");
1358 ret
= usb_hub_configure(dev
);