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
);
201 * Wait for status to update until timeout expires, USB driver
202 * interrupt handler may set the status when the USB operation has
206 if (!((volatile unsigned long)dev
->status
& USB_ST_NOT_PROC
))
217 /*-------------------------------------------------------------------
218 * submits bulk message, and waits for completion. returns 0 if Ok or
220 * synchronous behavior
222 int usb_bulk_msg(struct usb_device
*dev
, unsigned int pipe
,
223 void *data
, int len
, int *actual_length
, int timeout
)
227 dev
->status
= USB_ST_NOT_PROC
; /*not yet processed */
228 submit_bulk_msg(dev
, pipe
, data
, len
);
230 if (!((volatile unsigned long)dev
->status
& USB_ST_NOT_PROC
))
234 *actual_length
= dev
->act_len
;
235 if (dev
->status
== 0)
242 /*-------------------------------------------------------------------
247 * returns the max packet size, depending on the pipe direction and
248 * the configurations values
250 int usb_maxpacket(struct usb_device
*dev
, unsigned long pipe
)
252 /* direction is out -> use emaxpacket out */
253 if ((pipe
& USB_DIR_IN
) == 0)
254 return dev
->epmaxpacketout
[((pipe
>>15) & 0xf)];
256 return dev
->epmaxpacketin
[((pipe
>>15) & 0xf)];
259 /* The routine usb_set_maxpacket_ep() is extracted from the loop of routine
260 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine
261 * when it is inlined in 1 single routine. What happens is that the register r3
262 * is used as loop-count 'i', but gets overwritten later on.
263 * This is clearly a compiler bug, but it is easier to workaround it here than
264 * to update the compiler (Occurs with at least several GCC 4.{1,2},x
265 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM)
267 static void __attribute__((noinline
))
268 usb_set_maxpacket_ep(struct usb_device
*dev
, struct usb_endpoint_descriptor
*ep
)
272 b
= ep
->bEndpointAddress
& USB_ENDPOINT_NUMBER_MASK
;
274 if ((ep
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) ==
275 USB_ENDPOINT_XFER_CONTROL
) {
276 /* Control => bidirectional */
277 dev
->epmaxpacketout
[b
] = ep
->wMaxPacketSize
;
278 dev
->epmaxpacketin
[b
] = ep
->wMaxPacketSize
;
279 USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",
280 b
, dev
->epmaxpacketin
[b
]);
282 if ((ep
->bEndpointAddress
& 0x80) == 0) {
284 if (ep
->wMaxPacketSize
> dev
->epmaxpacketout
[b
]) {
285 dev
->epmaxpacketout
[b
] = ep
->wMaxPacketSize
;
286 USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",
287 b
, dev
->epmaxpacketout
[b
]);
291 if (ep
->wMaxPacketSize
> dev
->epmaxpacketin
[b
]) {
292 dev
->epmaxpacketin
[b
] = ep
->wMaxPacketSize
;
293 USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",
294 b
, dev
->epmaxpacketin
[b
]);
301 * set the max packed value of all endpoints in the given configuration
303 int usb_set_maxpacket(struct usb_device
*dev
)
307 for (i
= 0; i
< dev
->config
.desc
.bNumInterfaces
; i
++)
308 for (ii
= 0; ii
< dev
->config
.if_desc
[i
].desc
.bNumEndpoints
; ii
++)
309 usb_set_maxpacket_ep(dev
,
310 &dev
->config
.if_desc
[i
].ep_desc
[ii
]);
315 /*******************************************************************************
316 * Parse the config, located in buffer, and fills the dev->config structure.
317 * Note that all little/big endian swapping are done automatically.
319 int usb_parse_config(struct usb_device
*dev
, unsigned char *buffer
, int cfgno
)
321 struct usb_descriptor_header
*head
;
322 int index
, ifno
, epno
, curr_if_num
;
330 dev
->configno
= cfgno
;
331 head
= (struct usb_descriptor_header
*) &buffer
[0];
332 if (head
->bDescriptorType
!= USB_DT_CONFIG
) {
333 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
334 head
->bDescriptorType
);
337 memcpy(&dev
->config
, buffer
, buffer
[0]);
338 le16_to_cpus(&(dev
->config
.desc
.wTotalLength
));
339 dev
->config
.no_of_if
= 0;
341 index
= dev
->config
.desc
.bLength
;
342 /* Ok the first entry must be a configuration entry,
343 * now process the others */
344 head
= (struct usb_descriptor_header
*) &buffer
[index
];
345 while (index
+ 1 < dev
->config
.desc
.wTotalLength
) {
346 switch (head
->bDescriptorType
) {
347 case USB_DT_INTERFACE
:
348 if (((struct usb_interface_descriptor
*) \
349 &buffer
[index
])->bInterfaceNumber
!= curr_if_num
) {
350 /* this is a new interface, copy new desc */
351 ifno
= dev
->config
.no_of_if
;
352 dev
->config
.no_of_if
++;
353 memcpy(&dev
->config
.if_desc
[ifno
],
354 &buffer
[index
], buffer
[index
]);
355 dev
->config
.if_desc
[ifno
].no_of_ep
= 0;
356 dev
->config
.if_desc
[ifno
].num_altsetting
= 1;
358 dev
->config
.if_desc
[ifno
].desc
.bInterfaceNumber
;
360 /* found alternate setting for the interface */
361 dev
->config
.if_desc
[ifno
].num_altsetting
++;
364 case USB_DT_ENDPOINT
:
365 epno
= dev
->config
.if_desc
[ifno
].no_of_ep
;
366 /* found an endpoint */
367 dev
->config
.if_desc
[ifno
].no_of_ep
++;
368 memcpy(&dev
->config
.if_desc
[ifno
].ep_desc
[epno
],
369 &buffer
[index
], buffer
[index
]);
370 le16_to_cpus(&(dev
->config
.if_desc
[ifno
].ep_desc
[epno
].\
372 USB_PRINTF("if %d, ep %d\n", ifno
, epno
);
375 if (head
->bLength
== 0)
378 USB_PRINTF("unknown Description Type : %x\n",
379 head
->bDescriptorType
);
382 ch
= (unsigned char *)head
;
383 for (i
= 0; i
< head
->bLength
; i
++)
384 USB_PRINTF("%02X ", *ch
++);
385 USB_PRINTF("\n\n\n");
389 index
+= head
->bLength
;
390 head
= (struct usb_descriptor_header
*)&buffer
[index
];
395 /***********************************************************************
397 * endp: endpoint number in bits 0-3;
398 * direction flag in bit 7 (1 = IN, 0 = OUT)
400 int usb_clear_halt(struct usb_device
*dev
, int pipe
)
403 int endp
= usb_pipeendpoint(pipe
)|(usb_pipein(pipe
)<<7);
405 result
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
406 USB_REQ_CLEAR_FEATURE
, USB_RECIP_ENDPOINT
, 0,
407 endp
, NULL
, 0, USB_CNTL_TIMEOUT
* 3);
409 /* don't clear if failed */
414 * NOTE: we do not get status and verify reset was successful
415 * as some devices are reported to lock up upon this check..
418 usb_endpoint_running(dev
, usb_pipeendpoint(pipe
), usb_pipeout(pipe
));
420 /* toggle is reset on clear */
421 usb_settoggle(dev
, usb_pipeendpoint(pipe
), usb_pipeout(pipe
), 0);
426 /**********************************************************************
427 * get_descriptor type
429 int usb_get_descriptor(struct usb_device
*dev
, unsigned char type
,
430 unsigned char index
, void *buf
, int size
)
433 res
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
434 USB_REQ_GET_DESCRIPTOR
, USB_DIR_IN
,
435 (type
<< 8) + index
, 0,
436 buf
, size
, USB_CNTL_TIMEOUT
);
440 /**********************************************************************
441 * gets configuration cfgno and store it in the buffer
443 int usb_get_configuration_no(struct usb_device
*dev
,
444 unsigned char *buffer
, int cfgno
)
448 struct usb_configuration_descriptor
*config
;
450 config
= (struct usb_configuration_descriptor
*)&buffer
[0];
451 result
= usb_get_descriptor(dev
, USB_DT_CONFIG
, cfgno
, buffer
, 9);
454 printf("unable to get descriptor, error %lX\n",
457 printf("config descriptor too short " \
458 "(expected %i, got %i)\n", 9, result
);
461 tmp
= le16_to_cpu(config
->wTotalLength
);
463 if (tmp
> USB_BUFSIZ
) {
464 USB_PRINTF("usb_get_configuration_no: failed to get " \
465 "descriptor - too long: %d\n", tmp
);
469 result
= usb_get_descriptor(dev
, USB_DT_CONFIG
, cfgno
, buffer
, tmp
);
470 USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",
475 /********************************************************************
476 * set address of a device to the value in dev->devnum.
477 * This can only be done by addressing the device via the default address (0)
479 int usb_set_address(struct usb_device
*dev
)
483 USB_PRINTF("set address %d\n", dev
->devnum
);
484 res
= usb_control_msg(dev
, usb_snddefctrl(dev
),
485 USB_REQ_SET_ADDRESS
, 0,
487 NULL
, 0, USB_CNTL_TIMEOUT
);
491 /********************************************************************
492 * set interface number to interface
494 int usb_set_interface(struct usb_device
*dev
, int interface
, int alternate
)
496 struct usb_interface
*if_face
= NULL
;
499 for (i
= 0; i
< dev
->config
.desc
.bNumInterfaces
; i
++) {
500 if (dev
->config
.if_desc
[i
].desc
.bInterfaceNumber
== interface
) {
501 if_face
= &dev
->config
.if_desc
[i
];
506 printf("selecting invalid interface %d", interface
);
510 * We should return now for devices with only one alternate setting.
511 * According to 9.4.10 of the Universal Serial Bus Specification
512 * Revision 2.0 such devices can return with a STALL. This results in
513 * some USB sticks timeouting during initialization and then being
514 * unusable in U-Boot.
516 if (if_face
->num_altsetting
== 1)
519 ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
520 USB_REQ_SET_INTERFACE
, USB_RECIP_INTERFACE
,
521 alternate
, interface
, NULL
, 0,
522 USB_CNTL_TIMEOUT
* 5);
529 /********************************************************************
530 * set configuration number to configuration
532 int usb_set_configuration(struct usb_device
*dev
, int configuration
)
535 USB_PRINTF("set configuration %d\n", configuration
);
536 /* set setup command */
537 res
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
538 USB_REQ_SET_CONFIGURATION
, 0,
540 NULL
, 0, USB_CNTL_TIMEOUT
);
549 /********************************************************************
550 * set protocol to protocol
552 int usb_set_protocol(struct usb_device
*dev
, int ifnum
, int protocol
)
554 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
555 USB_REQ_SET_PROTOCOL
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
556 protocol
, ifnum
, NULL
, 0, USB_CNTL_TIMEOUT
);
559 /********************************************************************
562 int usb_set_idle(struct usb_device
*dev
, int ifnum
, int duration
, int report_id
)
564 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
565 USB_REQ_SET_IDLE
, USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
566 (duration
<< 8) | report_id
, ifnum
, NULL
, 0, USB_CNTL_TIMEOUT
);
569 /********************************************************************
572 int usb_get_report(struct usb_device
*dev
, int ifnum
, unsigned char type
,
573 unsigned char id
, void *buf
, int size
)
575 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
577 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
578 (type
<< 8) + id
, ifnum
, buf
, size
, USB_CNTL_TIMEOUT
);
581 /********************************************************************
582 * get class descriptor
584 int usb_get_class_descriptor(struct usb_device
*dev
, int ifnum
,
585 unsigned char type
, unsigned char id
, void *buf
, int size
)
587 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
588 USB_REQ_GET_DESCRIPTOR
, USB_RECIP_INTERFACE
| USB_DIR_IN
,
589 (type
<< 8) + id
, ifnum
, buf
, size
, USB_CNTL_TIMEOUT
);
592 /********************************************************************
593 * get string index in buffer
595 int usb_get_string(struct usb_device
*dev
, unsigned short langid
,
596 unsigned char index
, void *buf
, int size
)
601 for (i
= 0; i
< 3; ++i
) {
602 /* some devices are flaky */
603 result
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
604 USB_REQ_GET_DESCRIPTOR
, USB_DIR_IN
,
605 (USB_DT_STRING
<< 8) + index
, langid
, buf
, size
,
616 static void usb_try_string_workarounds(unsigned char *buf
, int *length
)
618 int newlength
, oldlength
= *length
;
620 for (newlength
= 2; newlength
+ 1 < oldlength
; newlength
+= 2)
621 if (!isprint(buf
[newlength
]) || buf
[newlength
+ 1])
631 static int usb_string_sub(struct usb_device
*dev
, unsigned int langid
,
632 unsigned int index
, unsigned char *buf
)
636 /* Try to read the string descriptor by asking for the maximum
637 * possible number of bytes */
638 rc
= usb_get_string(dev
, langid
, index
, buf
, 255);
640 /* If that failed try to read the descriptor length, then
641 * ask for just that many bytes */
643 rc
= usb_get_string(dev
, langid
, index
, buf
, 2);
645 rc
= usb_get_string(dev
, langid
, index
, buf
, buf
[0]);
649 if (!buf
[0] && !buf
[1])
650 usb_try_string_workarounds(buf
, &rc
);
652 /* There might be extra junk at the end of the descriptor */
656 rc
= rc
- (rc
& 1); /* force a multiple of two */
666 /********************************************************************
668 * Get string index and translate it to ascii.
669 * returns string length (> 0) or error (< 0)
671 int usb_string(struct usb_device
*dev
, int index
, char *buf
, size_t size
)
673 unsigned char mybuf
[USB_BUFSIZ
];
678 if (size
<= 0 || !buf
|| !index
)
683 /* get langid for strings if it's not yet known */
684 if (!dev
->have_langid
) {
685 err
= usb_string_sub(dev
, 0, 0, tbuf
);
687 USB_PRINTF("error getting string descriptor 0 " \
688 "(error=%lx)\n", dev
->status
);
690 } else if (tbuf
[0] < 4) {
691 USB_PRINTF("string descriptor 0 too short\n");
694 dev
->have_langid
= -1;
695 dev
->string_langid
= tbuf
[2] | (tbuf
[3] << 8);
696 /* always use the first langid listed */
697 USB_PRINTF("USB device number %d default " \
698 "language ID 0x%x\n",
699 dev
->devnum
, dev
->string_langid
);
703 err
= usb_string_sub(dev
, dev
->string_langid
, index
, tbuf
);
707 size
--; /* leave room for trailing NULL char in output buffer */
708 for (idx
= 0, u
= 2; u
< err
; u
+= 2) {
711 if (tbuf
[u
+1]) /* high byte */
712 buf
[idx
++] = '?'; /* non-ASCII character */
714 buf
[idx
++] = tbuf
[u
];
722 /********************************************************************
723 * USB device handling:
724 * the USB device are static allocated [USB_MAX_DEVICE].
728 /* returns a pointer to the device with the index [index].
729 * if the device is not assigned (dev->devnum==-1) returns NULL
731 struct usb_device
*usb_get_dev_index(int index
)
733 if (usb_dev
[index
].devnum
== -1)
736 return &usb_dev
[index
];
740 /* returns a pointer of a new device structure or NULL, if
741 * no device struct is available
743 struct usb_device
*usb_alloc_new_device(void)
746 USB_PRINTF("New Device %d\n", dev_index
);
747 if (dev_index
== USB_MAX_DEVICE
) {
748 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE
);
751 /* default Address is 0, real addresses start with 1 */
752 usb_dev
[dev_index
].devnum
= dev_index
+ 1;
753 usb_dev
[dev_index
].maxchild
= 0;
754 for (i
= 0; i
< USB_MAXCHILDREN
; i
++)
755 usb_dev
[dev_index
].children
[i
] = NULL
;
756 usb_dev
[dev_index
].parent
= NULL
;
758 return &usb_dev
[dev_index
- 1];
763 * By the time we get here, the device has gotten a new device ID
764 * and is in the default state. We need to identify the thing and
765 * get the ball rolling..
767 * Returns 0 for success, != 0 for error.
769 int usb_new_device(struct usb_device
*dev
)
773 unsigned char tmpbuf
[USB_BUFSIZ
];
775 /* We still haven't set the Address yet */
779 #ifdef CONFIG_LEGACY_USB_INIT_SEQ
780 /* this is the old and known way of initializing devices, it is
781 * different than what Windows and Linux are doing. Windows and Linux
782 * both retrieve 64 bytes while reading the device descriptor
783 * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an
784 * invalid header while reading 8 bytes as device descriptor. */
785 dev
->descriptor
.bMaxPacketSize0
= 8; /* Start off at 8 bytes */
786 dev
->maxpacketsize
= PACKET_SIZE_8
;
787 dev
->epmaxpacketin
[0] = 8;
788 dev
->epmaxpacketout
[0] = 8;
790 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0, &dev
->descriptor
, 8);
792 printf("\n USB device not responding, " \
793 "giving up (status=%lX)\n", dev
->status
);
797 /* This is a Windows scheme of initialization sequence, with double
798 * reset of the device (Linux uses the same sequence)
799 * Some equipment is said to work only with such init sequence; this
800 * patch is based on the work by Alan Stern:
801 * http://sourceforge.net/mailarchive/forum.php?
802 * thread_id=5729457&forum_id=5398
804 struct usb_device_descriptor
*desc
;
806 struct usb_device
*parent
= dev
->parent
;
807 unsigned short portstatus
;
809 /* send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is
810 * only 18 bytes long, this will terminate with a short packet. But if
811 * the maxpacket size is 8 or 16 the device may be waiting to transmit
812 * some more, or keeps on retransmitting the 8 byte header. */
814 desc
= (struct usb_device_descriptor
*)tmpbuf
;
815 dev
->descriptor
.bMaxPacketSize0
= 64; /* Start off at 64 bytes */
816 /* Default to 64 byte max packet size */
817 dev
->maxpacketsize
= PACKET_SIZE_64
;
818 dev
->epmaxpacketin
[0] = 64;
819 dev
->epmaxpacketout
[0] = 64;
821 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0, desc
, 64);
823 USB_PRINTF("usb_new_device: usb_get_descriptor() failed\n");
827 dev
->descriptor
.bMaxPacketSize0
= desc
->bMaxPacketSize0
;
829 /* find the port number we're at */
833 for (j
= 0; j
< parent
->maxchild
; j
++) {
834 if (parent
->children
[j
] == dev
) {
840 printf("usb_new_device:cannot locate device's port.\n");
844 /* reset the port for the second time */
845 err
= hub_port_reset(dev
->parent
, port
, &portstatus
);
847 printf("\n Couldn't reset port %i\n", port
);
853 dev
->epmaxpacketin
[0] = dev
->descriptor
.bMaxPacketSize0
;
854 dev
->epmaxpacketout
[0] = dev
->descriptor
.bMaxPacketSize0
;
855 switch (dev
->descriptor
.bMaxPacketSize0
) {
857 dev
->maxpacketsize
= PACKET_SIZE_8
;
860 dev
->maxpacketsize
= PACKET_SIZE_16
;
863 dev
->maxpacketsize
= PACKET_SIZE_32
;
866 dev
->maxpacketsize
= PACKET_SIZE_64
;
871 err
= usb_set_address(dev
); /* set address */
874 printf("\n USB device not accepting new address " \
875 "(error=%lX)\n", dev
->status
);
879 wait_ms(10); /* Let the SET_ADDRESS settle */
881 tmp
= sizeof(dev
->descriptor
);
883 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0,
884 &dev
->descriptor
, sizeof(dev
->descriptor
));
887 printf("unable to get device descriptor (error=%d)\n",
890 printf("USB device descriptor short read " \
891 "(expected %i, got %i)\n", tmp
, err
);
894 /* correct le values */
895 le16_to_cpus(&dev
->descriptor
.bcdUSB
);
896 le16_to_cpus(&dev
->descriptor
.idVendor
);
897 le16_to_cpus(&dev
->descriptor
.idProduct
);
898 le16_to_cpus(&dev
->descriptor
.bcdDevice
);
899 /* only support for one config for now */
900 usb_get_configuration_no(dev
, &tmpbuf
[0], 0);
901 usb_parse_config(dev
, &tmpbuf
[0], 0);
902 usb_set_maxpacket(dev
);
903 /* we set the default configuration here */
904 if (usb_set_configuration(dev
, dev
->config
.desc
.bConfigurationValue
)) {
905 printf("failed to set default configuration " \
906 "len %d, status %lX\n", dev
->act_len
, dev
->status
);
909 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
910 dev
->descriptor
.iManufacturer
, dev
->descriptor
.iProduct
,
911 dev
->descriptor
.iSerialNumber
);
912 memset(dev
->mf
, 0, sizeof(dev
->mf
));
913 memset(dev
->prod
, 0, sizeof(dev
->prod
));
914 memset(dev
->serial
, 0, sizeof(dev
->serial
));
915 if (dev
->descriptor
.iManufacturer
)
916 usb_string(dev
, dev
->descriptor
.iManufacturer
,
917 dev
->mf
, sizeof(dev
->mf
));
918 if (dev
->descriptor
.iProduct
)
919 usb_string(dev
, dev
->descriptor
.iProduct
,
920 dev
->prod
, sizeof(dev
->prod
));
921 if (dev
->descriptor
.iSerialNumber
)
922 usb_string(dev
, dev
->descriptor
.iSerialNumber
,
923 dev
->serial
, sizeof(dev
->serial
));
924 USB_PRINTF("Manufacturer %s\n", dev
->mf
);
925 USB_PRINTF("Product %s\n", dev
->prod
);
926 USB_PRINTF("SerialNumber %s\n", dev
->serial
);
927 /* now prode if the device is a hub */
928 usb_hub_probe(dev
, 0);
932 /* build device Tree */
933 void usb_scan_devices(void)
936 struct usb_device
*dev
;
938 /* first make all devices unknown */
939 for (i
= 0; i
< USB_MAX_DEVICE
; i
++) {
940 memset(&usb_dev
[i
], 0, sizeof(struct usb_device
));
941 usb_dev
[i
].devnum
= -1;
944 /* device 0 is always present (root hub, so let it analyze) */
945 dev
= usb_alloc_new_device();
946 if (usb_new_device(dev
))
947 printf("No USB Device found\n");
949 printf("%d USB Device(s) found\n", dev_index
);
950 /* insert "driver" if possible */
951 #ifdef CONFIG_USB_KEYBOARD
953 USB_PRINTF("scan end\n");
958 /****************************************************************************
960 * Probes device for being a hub and configurate it
966 #define USB_HUB_PRINTF(fmt, args...) printf(fmt , ##args)
968 #define USB_HUB_PRINTF(fmt, args...)
972 static struct usb_hub_device hub_dev
[USB_MAX_HUB
];
973 static int usb_hub_index
;
976 int usb_get_hub_descriptor(struct usb_device
*dev
, void *data
, int size
)
978 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
979 USB_REQ_GET_DESCRIPTOR
, USB_DIR_IN
| USB_RT_HUB
,
980 USB_DT_HUB
<< 8, 0, data
, size
, USB_CNTL_TIMEOUT
);
983 int usb_clear_hub_feature(struct usb_device
*dev
, int feature
)
985 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
986 USB_REQ_CLEAR_FEATURE
, USB_RT_HUB
, feature
,
987 0, NULL
, 0, USB_CNTL_TIMEOUT
);
990 int usb_clear_port_feature(struct usb_device
*dev
, int port
, int feature
)
992 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
993 USB_REQ_CLEAR_FEATURE
, USB_RT_PORT
, feature
,
994 port
, NULL
, 0, USB_CNTL_TIMEOUT
);
997 int usb_set_port_feature(struct usb_device
*dev
, int port
, int feature
)
999 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
1000 USB_REQ_SET_FEATURE
, USB_RT_PORT
, feature
,
1001 port
, NULL
, 0, USB_CNTL_TIMEOUT
);
1004 int usb_get_hub_status(struct usb_device
*dev
, void *data
)
1006 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
1007 USB_REQ_GET_STATUS
, USB_DIR_IN
| USB_RT_HUB
, 0, 0,
1008 data
, sizeof(struct usb_hub_status
), USB_CNTL_TIMEOUT
);
1011 int usb_get_port_status(struct usb_device
*dev
, int port
, void *data
)
1013 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
1014 USB_REQ_GET_STATUS
, USB_DIR_IN
| USB_RT_PORT
, 0, port
,
1015 data
, sizeof(struct usb_hub_status
), USB_CNTL_TIMEOUT
);
1019 static void usb_hub_power_on(struct usb_hub_device
*hub
)
1022 struct usb_device
*dev
;
1024 dev
= hub
->pusb_dev
;
1025 /* Enable power to the ports */
1026 USB_HUB_PRINTF("enabling power on all ports\n");
1027 for (i
= 0; i
< dev
->maxchild
; i
++) {
1028 usb_set_port_feature(dev
, i
+ 1, USB_PORT_FEAT_POWER
);
1029 USB_HUB_PRINTF("port %d returns %lX\n", i
+ 1, dev
->status
);
1030 wait_ms(hub
->desc
.bPwrOn2PwrGood
* 2);
1034 void usb_hub_reset(void)
1039 struct usb_hub_device
*usb_hub_allocate(void)
1041 if (usb_hub_index
< USB_MAX_HUB
)
1042 return &hub_dev
[usb_hub_index
++];
1044 printf("ERROR: USB_MAX_HUB (%d) reached\n", USB_MAX_HUB
);
1050 static inline char *portspeed(int portstatus
)
1052 if (portstatus
& (1 << USB_PORT_FEAT_HIGHSPEED
))
1054 else if (portstatus
& (1 << USB_PORT_FEAT_LOWSPEED
))
1060 static int hub_port_reset(struct usb_device
*dev
, int port
,
1061 unsigned short *portstat
)
1064 struct usb_port_status portsts
;
1065 unsigned short portstatus
, portchange
;
1067 USB_HUB_PRINTF("hub_port_reset: resetting port %d...\n", port
);
1068 for (tries
= 0; tries
< MAX_TRIES
; tries
++) {
1070 usb_set_port_feature(dev
, port
+ 1, USB_PORT_FEAT_RESET
);
1073 if (usb_get_port_status(dev
, port
+ 1, &portsts
) < 0) {
1074 USB_HUB_PRINTF("get_port_status failed status %lX\n",
1078 portstatus
= le16_to_cpu(portsts
.wPortStatus
);
1079 portchange
= le16_to_cpu(portsts
.wPortChange
);
1081 USB_HUB_PRINTF("portstatus %x, change %x, %s\n",
1082 portstatus
, portchange
,
1083 portspeed(portstatus
));
1085 USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d" \
1086 " USB_PORT_STAT_ENABLE %d\n",
1087 (portchange
& USB_PORT_STAT_C_CONNECTION
) ? 1 : 0,
1088 (portstatus
& USB_PORT_STAT_CONNECTION
) ? 1 : 0,
1089 (portstatus
& USB_PORT_STAT_ENABLE
) ? 1 : 0);
1091 if ((portchange
& USB_PORT_STAT_C_CONNECTION
) ||
1092 !(portstatus
& USB_PORT_STAT_CONNECTION
))
1095 if (portstatus
& USB_PORT_STAT_ENABLE
)
1101 if (tries
== MAX_TRIES
) {
1102 USB_HUB_PRINTF("Cannot enable port %i after %i retries, " \
1103 "disabling port.\n", port
+ 1, MAX_TRIES
);
1104 USB_HUB_PRINTF("Maybe the USB cable is bad?\n");
1108 usb_clear_port_feature(dev
, port
+ 1, USB_PORT_FEAT_C_RESET
);
1109 *portstat
= portstatus
;
1114 void usb_hub_port_connect_change(struct usb_device
*dev
, int port
)
1116 struct usb_device
*usb
;
1117 struct usb_port_status portsts
;
1118 unsigned short portstatus
, portchange
;
1121 if (usb_get_port_status(dev
, port
+ 1, &portsts
) < 0) {
1122 USB_HUB_PRINTF("get_port_status failed\n");
1126 portstatus
= le16_to_cpu(portsts
.wPortStatus
);
1127 portchange
= le16_to_cpu(portsts
.wPortChange
);
1128 USB_HUB_PRINTF("portstatus %x, change %x, %s\n",
1129 portstatus
, portchange
, portspeed(portstatus
));
1131 /* Clear the connection change status */
1132 usb_clear_port_feature(dev
, port
+ 1, USB_PORT_FEAT_C_CONNECTION
);
1134 /* Disconnect any existing devices under this port */
1135 if (((!(portstatus
& USB_PORT_STAT_CONNECTION
)) &&
1136 (!(portstatus
& USB_PORT_STAT_ENABLE
))) || (dev
->children
[port
])) {
1137 USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n");
1138 /* Return now if nothing is connected */
1139 if (!(portstatus
& USB_PORT_STAT_CONNECTION
))
1144 /* Reset the port */
1145 if (hub_port_reset(dev
, port
, &portstatus
) < 0) {
1146 printf("cannot reset port %i!?\n", port
+ 1);
1152 /* Allocate a new device struct for it */
1153 usb
= usb_alloc_new_device();
1155 if (portstatus
& USB_PORT_STAT_HIGH_SPEED
)
1156 usb
->speed
= USB_SPEED_HIGH
;
1157 else if (portstatus
& USB_PORT_STAT_LOW_SPEED
)
1158 usb
->speed
= USB_SPEED_LOW
;
1160 usb
->speed
= USB_SPEED_FULL
;
1162 dev
->children
[port
] = usb
;
1164 /* Run it through the hoops (find a driver, etc) */
1165 if (usb_new_device(usb
)) {
1166 /* Woops, disable the port */
1167 USB_HUB_PRINTF("hub: disabling port %d\n", port
+ 1);
1168 usb_clear_port_feature(dev
, port
+ 1, USB_PORT_FEAT_ENABLE
);
1173 int usb_hub_configure(struct usb_device
*dev
)
1175 unsigned char buffer
[USB_BUFSIZ
], *bitmap
;
1176 struct usb_hub_descriptor
*descriptor
;
1177 struct usb_hub_status
*hubsts
;
1179 struct usb_hub_device
*hub
;
1181 /* "allocate" Hub device */
1182 hub
= usb_hub_allocate();
1185 hub
->pusb_dev
= dev
;
1186 /* Get the the hub descriptor */
1187 if (usb_get_hub_descriptor(dev
, buffer
, 4) < 0) {
1188 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1189 "descriptor, giving up %lX\n", dev
->status
);
1192 descriptor
= (struct usb_hub_descriptor
*)buffer
;
1194 /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */
1195 i
= descriptor
->bLength
;
1196 if (i
> USB_BUFSIZ
) {
1197 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1198 "descriptor - too long: %d\n",
1199 descriptor
->bLength
);
1203 if (usb_get_hub_descriptor(dev
, buffer
, descriptor
->bLength
) < 0) {
1204 USB_HUB_PRINTF("usb_hub_configure: failed to get hub " \
1205 "descriptor 2nd giving up %lX\n", dev
->status
);
1208 memcpy((unsigned char *)&hub
->desc
, buffer
, descriptor
->bLength
);
1209 /* adjust 16bit values */
1210 hub
->desc
.wHubCharacteristics
=
1211 le16_to_cpu(descriptor
->wHubCharacteristics
);
1212 /* set the bitmap */
1213 bitmap
= (unsigned char *)&hub
->desc
.DeviceRemovable
[0];
1214 /* devices not removable by default */
1215 memset(bitmap
, 0xff, (USB_MAXCHILDREN
+1+7)/8);
1216 bitmap
= (unsigned char *)&hub
->desc
.PortPowerCtrlMask
[0];
1217 memset(bitmap
, 0xff, (USB_MAXCHILDREN
+1+7)/8); /* PowerMask = 1B */
1219 for (i
= 0; i
< ((hub
->desc
.bNbrPorts
+ 1 + 7)/8); i
++)
1220 hub
->desc
.DeviceRemovable
[i
] = descriptor
->DeviceRemovable
[i
];
1222 for (i
= 0; i
< ((hub
->desc
.bNbrPorts
+ 1 + 7)/8); i
++)
1223 hub
->desc
.DeviceRemovable
[i
] = descriptor
->PortPowerCtrlMask
[i
];
1225 dev
->maxchild
= descriptor
->bNbrPorts
;
1226 USB_HUB_PRINTF("%d ports detected\n", dev
->maxchild
);
1228 switch (hub
->desc
.wHubCharacteristics
& HUB_CHAR_LPSM
) {
1230 USB_HUB_PRINTF("ganged power switching\n");
1233 USB_HUB_PRINTF("individual port power switching\n");
1237 USB_HUB_PRINTF("unknown reserved power switching mode\n");
1241 if (hub
->desc
.wHubCharacteristics
& HUB_CHAR_COMPOUND
)
1242 USB_HUB_PRINTF("part of a compound device\n");
1244 USB_HUB_PRINTF("standalone hub\n");
1246 switch (hub
->desc
.wHubCharacteristics
& HUB_CHAR_OCPM
) {
1248 USB_HUB_PRINTF("global over-current protection\n");
1251 USB_HUB_PRINTF("individual port over-current protection\n");
1255 USB_HUB_PRINTF("no over-current protection\n");
1259 USB_HUB_PRINTF("power on to power good time: %dms\n",
1260 descriptor
->bPwrOn2PwrGood
* 2);
1261 USB_HUB_PRINTF("hub controller current requirement: %dmA\n",
1262 descriptor
->bHubContrCurrent
);
1264 for (i
= 0; i
< dev
->maxchild
; i
++)
1265 USB_HUB_PRINTF("port %d is%s removable\n", i
+ 1,
1266 hub
->desc
.DeviceRemovable
[(i
+ 1) / 8] & \
1267 (1 << ((i
+ 1) % 8)) ? " not" : "");
1269 if (sizeof(struct usb_hub_status
) > USB_BUFSIZ
) {
1270 USB_HUB_PRINTF("usb_hub_configure: failed to get Status - " \
1271 "too long: %d\n", descriptor
->bLength
);
1275 if (usb_get_hub_status(dev
, buffer
) < 0) {
1276 USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",
1281 hubsts
= (struct usb_hub_status
*)buffer
;
1282 USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n",
1283 le16_to_cpu(hubsts
->wHubStatus
),
1284 le16_to_cpu(hubsts
->wHubChange
));
1285 USB_HUB_PRINTF("local power source is %s\n",
1286 (le16_to_cpu(hubsts
->wHubStatus
) & HUB_STATUS_LOCAL_POWER
) ? \
1287 "lost (inactive)" : "good");
1288 USB_HUB_PRINTF("%sover-current condition exists\n",
1289 (le16_to_cpu(hubsts
->wHubStatus
) & HUB_STATUS_OVERCURRENT
) ? \
1291 usb_hub_power_on(hub
);
1293 for (i
= 0; i
< dev
->maxchild
; i
++) {
1294 struct usb_port_status portsts
;
1295 unsigned short portstatus
, portchange
;
1297 if (usb_get_port_status(dev
, i
+ 1, &portsts
) < 0) {
1298 USB_HUB_PRINTF("get_port_status failed\n");
1302 portstatus
= le16_to_cpu(portsts
.wPortStatus
);
1303 portchange
= le16_to_cpu(portsts
.wPortChange
);
1304 USB_HUB_PRINTF("Port %d Status %X Change %X\n",
1305 i
+ 1, portstatus
, portchange
);
1307 if (portchange
& USB_PORT_STAT_C_CONNECTION
) {
1308 USB_HUB_PRINTF("port %d connection change\n", i
+ 1);
1309 usb_hub_port_connect_change(dev
, i
);
1311 if (portchange
& USB_PORT_STAT_C_ENABLE
) {
1312 USB_HUB_PRINTF("port %d enable change, status %x\n",
1314 usb_clear_port_feature(dev
, i
+ 1,
1315 USB_PORT_FEAT_C_ENABLE
);
1317 /* EM interference sometimes causes bad shielded USB
1318 * devices to be shutdown by the hub, this hack enables
1319 * them again. Works at least with mouse driver */
1320 if (!(portstatus
& USB_PORT_STAT_ENABLE
) &&
1321 (portstatus
& USB_PORT_STAT_CONNECTION
) &&
1322 ((dev
->children
[i
]))) {
1323 USB_HUB_PRINTF("already running port %i " \
1324 "disabled by hub (EMI?), " \
1325 "re-enabling...\n", i
+ 1);
1326 usb_hub_port_connect_change(dev
, i
);
1329 if (portstatus
& USB_PORT_STAT_SUSPEND
) {
1330 USB_HUB_PRINTF("port %d suspend change\n", i
+ 1);
1331 usb_clear_port_feature(dev
, i
+ 1,
1332 USB_PORT_FEAT_SUSPEND
);
1335 if (portchange
& USB_PORT_STAT_C_OVERCURRENT
) {
1336 USB_HUB_PRINTF("port %d over-current change\n", i
+ 1);
1337 usb_clear_port_feature(dev
, i
+ 1,
1338 USB_PORT_FEAT_C_OVER_CURRENT
);
1339 usb_hub_power_on(hub
);
1342 if (portchange
& USB_PORT_STAT_C_RESET
) {
1343 USB_HUB_PRINTF("port %d reset change\n", i
+ 1);
1344 usb_clear_port_feature(dev
, i
+ 1,
1345 USB_PORT_FEAT_C_RESET
);
1347 } /* end for i all ports */
1352 int usb_hub_probe(struct usb_device
*dev
, int ifnum
)
1354 struct usb_interface
*iface
;
1355 struct usb_endpoint_descriptor
*ep
;
1358 iface
= &dev
->config
.if_desc
[ifnum
];
1360 if (iface
->desc
.bInterfaceClass
!= USB_CLASS_HUB
)
1362 /* Some hubs have a subclass of 1, which AFAICT according to the */
1363 /* specs is not defined, but it works */
1364 if ((iface
->desc
.bInterfaceSubClass
!= 0) &&
1365 (iface
->desc
.bInterfaceSubClass
!= 1))
1367 /* Multiple endpoints? What kind of mutant ninja-hub is this? */
1368 if (iface
->desc
.bNumEndpoints
!= 1)
1370 ep
= &iface
->ep_desc
[0];
1371 /* Output endpoint? Curiousier and curiousier.. */
1372 if (!(ep
->bEndpointAddress
& USB_DIR_IN
))
1374 /* If it's not an interrupt endpoint, we'd better punt! */
1375 if ((ep
->bmAttributes
& 3) != 3)
1377 /* We found a hub */
1378 USB_HUB_PRINTF("USB hub found\n");
1379 ret
= usb_hub_configure(dev
);