blob: 1ec30bc058f708ea46b612aff8d3f3340b5dca68 [file] [log] [blame]
wdenkaffae2b2002-08-17 09:36:01 +00001/*
wdenkaffae2b2002-08-17 09:36:01 +00002 *
3 * Most of this source has been derived from the Linux USB
Wolfgang Denk460c3222005-08-04 01:14:12 +02004 * project:
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)
14 *
15 * Adapted for U-Boot:
16 * (C) Copyright 2001 Denis Peter, MPL AG Switzerland
wdenkaffae2b2002-08-17 09:36:01 +000017 *
18 * See file CREDITS for list of people who contributed to this
19 * project.
20 *
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.
25 *
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.
30 *
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,
34 * MA 02111-1307 USA
35 *
36 */
37
wdenkaffae2b2002-08-17 09:36:01 +000038/*
39 * How it works:
40 *
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
43 * device should work.
44 *
45 * For each transfer (except "Interrupt") we wait for completion.
46 */
47#include <common.h>
48#include <command.h>
49#include <asm/processor.h>
Wolfgang Denk9c998aa2005-07-21 11:57:57 +020050#include <linux/ctype.h>
Christian Eggersc9182612008-05-21 22:12:00 +020051#include <asm/byteorder.h>
Tom Rinib2fb47f2011-12-15 08:40:51 -070052#include <asm/unaligned.h>
wdenkaffae2b2002-08-17 09:36:01 +000053
wdenkaffae2b2002-08-17 09:36:01 +000054#include <usb.h>
55#ifdef CONFIG_4xx
Stefan Roese3048bcb2007-10-03 15:01:02 +020056#include <asm/4xx_pci.h>
wdenkaffae2b2002-08-17 09:36:01 +000057#endif
58
Alexander Hollerce297a82011-01-28 12:42:13 +010059#ifdef DEBUG
Marek Vasut88ec8c12011-10-25 11:39:14 +020060#define USB_DEBUG 1
61#define USB_HUB_DEBUG 1
62#else
63#define USB_DEBUG 0
64#define USB_HUB_DEBUG 0
Alexander Hollerce297a82011-01-28 12:42:13 +010065#endif
wdenkaffae2b2002-08-17 09:36:01 +000066
Marek Vasut88ec8c12011-10-25 11:39:14 +020067#define USB_PRINTF(fmt, args...) debug_cond(USB_DEBUG, fmt, ##args)
68#define USB_HUB_PRINTF(fmt, args...) debug_cond(USB_HUB_DEBUG, fmt, ##args)
wdenkaffae2b2002-08-17 09:36:01 +000069
wdenkcd0a9de2004-02-23 20:48:38 +000070#define USB_BUFSIZ 512
71
wdenkaffae2b2002-08-17 09:36:01 +000072static struct usb_device usb_dev[USB_MAX_DEVICE];
73static int dev_index;
74static int running;
75static int asynch_allowed;
wdenkaffae2b2002-08-17 09:36:01 +000076
Bartlomiej Siekae51aae32006-08-03 23:20:13 +020077char usb_started; /* flag for the started/stopped USB status */
78
wdenkaffae2b2002-08-17 09:36:01 +000079/**********************************************************************
80 * some forward declerations...
81 */
Marek Vasutc08b1b22012-02-13 18:58:16 +000082static void usb_scan_devices(void);
wdenkaffae2b2002-08-17 09:36:01 +000083
wdenkaffae2b2002-08-17 09:36:01 +000084/***************************************************************************
85 * Init USB Device
86 */
87
88int usb_init(void)
89{
90 int result;
91
Remy Bohmer6f5794a2008-09-16 14:55:43 +020092 running = 0;
93 dev_index = 0;
94 asynch_allowed = 1;
wdenkaffae2b2002-08-17 09:36:01 +000095 usb_hub_reset();
96 /* init low_level USB */
97 printf("USB: ");
98 result = usb_lowlevel_init();
Remy Bohmer6f5794a2008-09-16 14:55:43 +020099 /* if lowlevel init is OK, scan the bus for devices
100 * i.e. search HUBs and configure them */
101 if (result == 0) {
wdenkaffae2b2002-08-17 09:36:01 +0000102 printf("scanning bus for devices... ");
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200103 running = 1;
wdenkaffae2b2002-08-17 09:36:01 +0000104 usb_scan_devices();
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200105 usb_started = 1;
wdenkaffae2b2002-08-17 09:36:01 +0000106 return 0;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200107 } else {
wdenkaffae2b2002-08-17 09:36:01 +0000108 printf("Error, couldn't init Lowlevel part\n");
Bartlomiej Siekae51aae32006-08-03 23:20:13 +0200109 usb_started = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000110 return -1;
111 }
112}
113
114/******************************************************************************
115 * Stop USB this stops the LowLevel Part and deregisters USB devices.
116 */
117int usb_stop(void)
118{
Remy Bohmereba1f2f2008-08-20 11:22:02 +0200119 int res = 0;
120
121 if (usb_started) {
122 asynch_allowed = 1;
123 usb_started = 0;
124 usb_hub_reset();
125 res = usb_lowlevel_stop();
126 }
127 return res;
wdenkaffae2b2002-08-17 09:36:01 +0000128}
129
130/*
131 * disables the asynch behaviour of the control message. This is used for data
132 * transfers that uses the exclusiv access to the control and bulk messages.
Simon Glass89d48362011-02-16 11:14:33 -0800133 * Returns the old value so it can be restored later.
wdenkaffae2b2002-08-17 09:36:01 +0000134 */
Simon Glass89d48362011-02-16 11:14:33 -0800135int usb_disable_asynch(int disable)
wdenkaffae2b2002-08-17 09:36:01 +0000136{
Simon Glass89d48362011-02-16 11:14:33 -0800137 int old_value = asynch_allowed;
138
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200139 asynch_allowed = !disable;
Simon Glass89d48362011-02-16 11:14:33 -0800140 return old_value;
wdenkaffae2b2002-08-17 09:36:01 +0000141}
142
143
144/*-------------------------------------------------------------------
145 * Message wrappers.
146 *
147 */
148
149/*
150 * submits an Interrupt Message
151 */
152int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200153 void *buffer, int transfer_len, int interval)
wdenkaffae2b2002-08-17 09:36:01 +0000154{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200155 return submit_int_msg(dev, pipe, buffer, transfer_len, interval);
wdenkaffae2b2002-08-17 09:36:01 +0000156}
157
158/*
159 * submits a control message and waits for comletion (at least timeout * 1ms)
160 * If timeout is 0, we don't wait for completion (used as example to set and
161 * clear keyboards LEDs). For data transfers, (storage transfers) we don't
162 * allow control messages with 0 timeout, by previousely resetting the flag
163 * asynch_allowed (usb_disable_asynch(1)).
164 * returns the transfered length if OK or -1 if error. The transfered length
165 * and the current status are stored in the dev->act_len and dev->status.
166 */
167int usb_control_msg(struct usb_device *dev, unsigned int pipe,
168 unsigned char request, unsigned char requesttype,
169 unsigned short value, unsigned short index,
170 void *data, unsigned short size, int timeout)
171{
Marek Vasute159e482012-02-13 18:58:18 +0000172 struct devrequest setup_packet;
173
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200174 if ((timeout == 0) && (!asynch_allowed)) {
175 /* request for a asynch control pipe is not allowed */
wdenkaffae2b2002-08-17 09:36:01 +0000176 return -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200177 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200178
wdenkaffae2b2002-08-17 09:36:01 +0000179 /* set setup command */
180 setup_packet.requesttype = requesttype;
181 setup_packet.request = request;
Christian Eggersc9182612008-05-21 22:12:00 +0200182 setup_packet.value = cpu_to_le16(value);
183 setup_packet.index = cpu_to_le16(index);
184 setup_packet.length = cpu_to_le16(size);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200185 USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
186 "value 0x%X index 0x%X length 0x%X\n",
187 request, requesttype, value, index, size);
188 dev->status = USB_ST_NOT_PROC; /*not yet processed */
wdenkaffae2b2002-08-17 09:36:01 +0000189
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200190 submit_control_msg(dev, pipe, data, size, &setup_packet);
191 if (timeout == 0)
wdenkaffae2b2002-08-17 09:36:01 +0000192 return (int)size;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200193
Remy Bohmer84d36b32010-02-01 19:40:47 +0100194 /*
195 * Wait for status to update until timeout expires, USB driver
196 * interrupt handler may set the status when the USB operation has
197 * been completed.
198 */
199 while (timeout--) {
200 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
201 break;
Mike Frysinger5b84dd62012-03-05 13:47:00 +0000202 mdelay(1);
Remy Bohmer48867202008-10-10 10:23:21 +0200203 }
Remy Bohmer84d36b32010-02-01 19:40:47 +0100204 if (dev->status)
205 return -1;
Remy Bohmer48867202008-10-10 10:23:21 +0200206
207 return dev->act_len;
Remy Bohmer84d36b32010-02-01 19:40:47 +0100208
wdenkaffae2b2002-08-17 09:36:01 +0000209}
210
211/*-------------------------------------------------------------------
212 * submits bulk message, and waits for completion. returns 0 if Ok or
213 * -1 if Error.
214 * synchronous behavior
215 */
216int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
217 void *data, int len, int *actual_length, int timeout)
218{
219 if (len < 0)
220 return -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200221 dev->status = USB_ST_NOT_PROC; /*not yet processed */
222 submit_bulk_msg(dev, pipe, data, len);
223 while (timeout--) {
224 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
wdenkaffae2b2002-08-17 09:36:01 +0000225 break;
Mike Frysinger5b84dd62012-03-05 13:47:00 +0000226 mdelay(1);
wdenkaffae2b2002-08-17 09:36:01 +0000227 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200228 *actual_length = dev->act_len;
229 if (dev->status == 0)
wdenkaffae2b2002-08-17 09:36:01 +0000230 return 0;
231 else
232 return -1;
233}
234
235
236/*-------------------------------------------------------------------
237 * Max Packet stuff
238 */
239
240/*
241 * returns the max packet size, depending on the pipe direction and
242 * the configurations values
243 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200244int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
wdenkaffae2b2002-08-17 09:36:01 +0000245{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200246 /* direction is out -> use emaxpacket out */
247 if ((pipe & USB_DIR_IN) == 0)
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100248 return dev->epmaxpacketout[((pipe>>15) & 0xf)];
wdenkaffae2b2002-08-17 09:36:01 +0000249 else
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100250 return dev->epmaxpacketin[((pipe>>15) & 0xf)];
wdenkaffae2b2002-08-17 09:36:01 +0000251}
252
Marek Vasut5e8baf82011-11-05 23:35:12 +0100253/*
254 * The routine usb_set_maxpacket_ep() is extracted from the loop of routine
Remy Bohmerbe19d322008-09-16 14:55:42 +0200255 * 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)
Marek Vasut5e8baf82011-11-05 23:35:12 +0100261 *
262 * NOTE: Similar behaviour was observed with GCC4.6 on ARMv5.
Remy Bohmerbe19d322008-09-16 14:55:42 +0200263 */
264static void __attribute__((noinline))
Marek Vasut5e8baf82011-11-05 23:35:12 +0100265usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx)
Remy Bohmerbe19d322008-09-16 14:55:42 +0200266{
267 int b;
Marek Vasut5e8baf82011-11-05 23:35:12 +0100268 struct usb_endpoint_descriptor *ep;
Tom Rinib2fb47f2011-12-15 08:40:51 -0700269 u16 ep_wMaxPacketSize;
Marek Vasut5e8baf82011-11-05 23:35:12 +0100270
271 ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx];
Remy Bohmerbe19d322008-09-16 14:55:42 +0200272
273 b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
Tom Rinib2fb47f2011-12-15 08:40:51 -0700274 ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize);
Remy Bohmerbe19d322008-09-16 14:55:42 +0200275
276 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
277 USB_ENDPOINT_XFER_CONTROL) {
278 /* Control => bidirectional */
Tom Rinib2fb47f2011-12-15 08:40:51 -0700279 dev->epmaxpacketout[b] = ep_wMaxPacketSize;
280 dev->epmaxpacketin[b] = ep_wMaxPacketSize;
Remy Bohmerbe19d322008-09-16 14:55:42 +0200281 USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",
282 b, dev->epmaxpacketin[b]);
283 } else {
284 if ((ep->bEndpointAddress & 0x80) == 0) {
285 /* OUT Endpoint */
Tom Rinib2fb47f2011-12-15 08:40:51 -0700286 if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) {
287 dev->epmaxpacketout[b] = ep_wMaxPacketSize;
Remy Bohmerbe19d322008-09-16 14:55:42 +0200288 USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",
289 b, dev->epmaxpacketout[b]);
290 }
291 } else {
292 /* IN Endpoint */
Tom Rinib2fb47f2011-12-15 08:40:51 -0700293 if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) {
294 dev->epmaxpacketin[b] = ep_wMaxPacketSize;
Remy Bohmerbe19d322008-09-16 14:55:42 +0200295 USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",
296 b, dev->epmaxpacketin[b]);
297 }
298 } /* if out */
299 } /* if control */
300}
301
wdenkaffae2b2002-08-17 09:36:01 +0000302/*
303 * set the max packed value of all endpoints in the given configuration
304 */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000305static int usb_set_maxpacket(struct usb_device *dev)
wdenkaffae2b2002-08-17 09:36:01 +0000306{
Remy Bohmerbe19d322008-09-16 14:55:42 +0200307 int i, ii;
wdenkaffae2b2002-08-17 09:36:01 +0000308
Tom Rix8f8bd562009-10-31 12:37:38 -0500309 for (i = 0; i < dev->config.desc.bNumInterfaces; i++)
310 for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++)
Marek Vasut5e8baf82011-11-05 23:35:12 +0100311 usb_set_maxpacket_ep(dev, i, ii);
wdenkaffae2b2002-08-17 09:36:01 +0000312
wdenkaffae2b2002-08-17 09:36:01 +0000313 return 0;
314}
315
316/*******************************************************************************
317 * Parse the config, located in buffer, and fills the dev->config structure.
318 * Note that all little/big endian swapping are done automatically.
319 */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000320static int usb_parse_config(struct usb_device *dev,
321 unsigned char *buffer, int cfgno)
wdenkaffae2b2002-08-17 09:36:01 +0000322{
323 struct usb_descriptor_header *head;
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200324 int index, ifno, epno, curr_if_num;
325 int i;
Tom Rinib2fb47f2011-12-15 08:40:51 -0700326 u16 ep_wMaxPacketSize;
wdenkaffae2b2002-08-17 09:36:01 +0000327
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200328 ifno = -1;
329 epno = -1;
330 curr_if_num = -1;
331
332 dev->configno = cfgno;
333 head = (struct usb_descriptor_header *) &buffer[0];
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200334 if (head->bDescriptorType != USB_DT_CONFIG) {
335 printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
336 head->bDescriptorType);
wdenkaffae2b2002-08-17 09:36:01 +0000337 return -1;
338 }
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200339 memcpy(&dev->config, buffer, buffer[0]);
Tom Rix8f8bd562009-10-31 12:37:38 -0500340 le16_to_cpus(&(dev->config.desc.wTotalLength));
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200341 dev->config.no_of_if = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000342
Tom Rix8f8bd562009-10-31 12:37:38 -0500343 index = dev->config.desc.bLength;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200344 /* Ok the first entry must be a configuration entry,
345 * now process the others */
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200346 head = (struct usb_descriptor_header *) &buffer[index];
Tom Rix8f8bd562009-10-31 12:37:38 -0500347 while (index + 1 < dev->config.desc.wTotalLength) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200348 switch (head->bDescriptorType) {
349 case USB_DT_INTERFACE:
350 if (((struct usb_interface_descriptor *) \
351 &buffer[index])->bInterfaceNumber != curr_if_num) {
352 /* this is a new interface, copy new desc */
353 ifno = dev->config.no_of_if;
354 dev->config.no_of_if++;
355 memcpy(&dev->config.if_desc[ifno],
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200356 &buffer[index], buffer[index]);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200357 dev->config.if_desc[ifno].no_of_ep = 0;
358 dev->config.if_desc[ifno].num_altsetting = 1;
359 curr_if_num =
Tom Rix8f8bd562009-10-31 12:37:38 -0500360 dev->config.if_desc[ifno].desc.bInterfaceNumber;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200361 } else {
362 /* found alternate setting for the interface */
363 dev->config.if_desc[ifno].num_altsetting++;
364 }
365 break;
366 case USB_DT_ENDPOINT:
367 epno = dev->config.if_desc[ifno].no_of_ep;
368 /* found an endpoint */
369 dev->config.if_desc[ifno].no_of_ep++;
370 memcpy(&dev->config.if_desc[ifno].ep_desc[epno],
371 &buffer[index], buffer[index]);
Tom Rinib2fb47f2011-12-15 08:40:51 -0700372 ep_wMaxPacketSize = get_unaligned(&dev->config.\
373 if_desc[ifno].\
374 ep_desc[epno].\
375 wMaxPacketSize);
376 put_unaligned(le16_to_cpu(ep_wMaxPacketSize),
377 &dev->config.\
378 if_desc[ifno].\
379 ep_desc[epno].\
380 wMaxPacketSize);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200381 USB_PRINTF("if %d, ep %d\n", ifno, epno);
382 break;
383 default:
384 if (head->bLength == 0)
385 return 1;
386
387 USB_PRINTF("unknown Description Type : %x\n",
388 head->bDescriptorType);
389
390 {
Wolfgang Denkfad2e1b2011-10-05 23:11:19 +0200391#ifdef USB_DEBUG
392 unsigned char *ch = (unsigned char *)head;
393#endif
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200394 for (i = 0; i < head->bLength; i++)
395 USB_PRINTF("%02X ", *ch++);
396 USB_PRINTF("\n\n\n");
397 }
398 break;
wdenkaffae2b2002-08-17 09:36:01 +0000399 }
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200400 index += head->bLength;
401 head = (struct usb_descriptor_header *)&buffer[index];
wdenkaffae2b2002-08-17 09:36:01 +0000402 }
403 return 1;
404}
405
406/***********************************************************************
407 * Clears an endpoint
408 * endp: endpoint number in bits 0-3;
409 * direction flag in bit 7 (1 = IN, 0 = OUT)
410 */
411int usb_clear_halt(struct usb_device *dev, int pipe)
412{
413 int result;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200414 int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
wdenkaffae2b2002-08-17 09:36:01 +0000415
416 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200417 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
418 endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
wdenkaffae2b2002-08-17 09:36:01 +0000419
420 /* don't clear if failed */
421 if (result < 0)
422 return result;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200423
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200424 /*
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200425 * NOTE: we do not get status and verify reset was successful
426 * as some devices are reported to lock up upon this check..
427 */
428
wdenkaffae2b2002-08-17 09:36:01 +0000429 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200430
wdenkaffae2b2002-08-17 09:36:01 +0000431 /* toggle is reset on clear */
432 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
433 return 0;
434}
435
436
437/**********************************************************************
438 * get_descriptor type
439 */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000440static int usb_get_descriptor(struct usb_device *dev, unsigned char type,
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200441 unsigned char index, void *buf, int size)
wdenkaffae2b2002-08-17 09:36:01 +0000442{
443 int res;
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200444 res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
wdenkaffae2b2002-08-17 09:36:01 +0000445 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
446 (type << 8) + index, 0,
447 buf, size, USB_CNTL_TIMEOUT);
448 return res;
449}
450
451/**********************************************************************
452 * gets configuration cfgno and store it in the buffer
453 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200454int usb_get_configuration_no(struct usb_device *dev,
455 unsigned char *buffer, int cfgno)
wdenkaffae2b2002-08-17 09:36:01 +0000456{
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200457 int result;
wdenkaffae2b2002-08-17 09:36:01 +0000458 unsigned int tmp;
Tom Rix8f8bd562009-10-31 12:37:38 -0500459 struct usb_configuration_descriptor *config;
wdenkaffae2b2002-08-17 09:36:01 +0000460
Tom Rix8f8bd562009-10-31 12:37:38 -0500461 config = (struct usb_configuration_descriptor *)&buffer[0];
Remy Bohmer48867202008-10-10 10:23:21 +0200462 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9);
463 if (result < 9) {
wdenkaffae2b2002-08-17 09:36:01 +0000464 if (result < 0)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200465 printf("unable to get descriptor, error %lX\n",
466 dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000467 else
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200468 printf("config descriptor too short " \
Remy Bohmer48867202008-10-10 10:23:21 +0200469 "(expected %i, got %i)\n", 9, result);
wdenkaffae2b2002-08-17 09:36:01 +0000470 return -1;
471 }
Christian Eggersc9182612008-05-21 22:12:00 +0200472 tmp = le16_to_cpu(config->wTotalLength);
wdenkaffae2b2002-08-17 09:36:01 +0000473
wdenkcd0a9de2004-02-23 20:48:38 +0000474 if (tmp > USB_BUFSIZ) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200475 USB_PRINTF("usb_get_configuration_no: failed to get " \
476 "descriptor - too long: %d\n", tmp);
wdenkcd0a9de2004-02-23 20:48:38 +0000477 return -1;
478 }
479
wdenkaffae2b2002-08-17 09:36:01 +0000480 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, tmp);
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200481 USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",
482 cfgno, result, tmp);
wdenkaffae2b2002-08-17 09:36:01 +0000483 return result;
484}
485
486/********************************************************************
487 * set address of a device to the value in dev->devnum.
488 * This can only be done by addressing the device via the default address (0)
489 */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000490static int usb_set_address(struct usb_device *dev)
wdenkaffae2b2002-08-17 09:36:01 +0000491{
492 int res;
493
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200494 USB_PRINTF("set address %d\n", dev->devnum);
495 res = usb_control_msg(dev, usb_snddefctrl(dev),
496 USB_REQ_SET_ADDRESS, 0,
497 (dev->devnum), 0,
498 NULL, 0, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +0000499 return res;
500}
501
502/********************************************************************
503 * set interface number to interface
504 */
505int usb_set_interface(struct usb_device *dev, int interface, int alternate)
506{
Tom Rix8f8bd562009-10-31 12:37:38 -0500507 struct usb_interface *if_face = NULL;
wdenkaffae2b2002-08-17 09:36:01 +0000508 int ret, i;
509
Tom Rix8f8bd562009-10-31 12:37:38 -0500510 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) {
511 if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) {
wdenkaffae2b2002-08-17 09:36:01 +0000512 if_face = &dev->config.if_desc[i];
513 break;
514 }
515 }
516 if (!if_face) {
517 printf("selecting invalid interface %d", interface);
518 return -1;
519 }
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200520 /*
521 * We should return now for devices with only one alternate setting.
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200522 * According to 9.4.10 of the Universal Serial Bus Specification
523 * Revision 2.0 such devices can return with a STALL. This results in
524 * some USB sticks timeouting during initialization and then being
525 * unusable in U-Boot.
Bartlomiej Sieka7455af42006-08-02 00:54:18 +0200526 */
527 if (if_face->num_altsetting == 1)
528 return 0;
wdenkaffae2b2002-08-17 09:36:01 +0000529
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200530 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
531 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
532 alternate, interface, NULL, 0,
533 USB_CNTL_TIMEOUT * 5);
534 if (ret < 0)
wdenkaffae2b2002-08-17 09:36:01 +0000535 return ret;
536
wdenkaffae2b2002-08-17 09:36:01 +0000537 return 0;
538}
539
540/********************************************************************
541 * set configuration number to configuration
542 */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000543static int usb_set_configuration(struct usb_device *dev, int configuration)
wdenkaffae2b2002-08-17 09:36:01 +0000544{
545 int res;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200546 USB_PRINTF("set configuration %d\n", configuration);
wdenkaffae2b2002-08-17 09:36:01 +0000547 /* set setup command */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200548 res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
549 USB_REQ_SET_CONFIGURATION, 0,
550 configuration, 0,
551 NULL, 0, USB_CNTL_TIMEOUT);
552 if (res == 0) {
wdenkaffae2b2002-08-17 09:36:01 +0000553 dev->toggle[0] = 0;
554 dev->toggle[1] = 0;
555 return 0;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200556 } else
wdenkaffae2b2002-08-17 09:36:01 +0000557 return -1;
558}
559
560/********************************************************************
561 * set protocol to protocol
562 */
563int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
564{
565 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
566 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
567 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
568}
569
570/********************************************************************
571 * set idle
572 */
573int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
574{
575 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
576 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
577 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
578}
579
580/********************************************************************
581 * get report
582 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200583int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
584 unsigned char id, void *buf, int size)
wdenkaffae2b2002-08-17 09:36:01 +0000585{
586 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200587 USB_REQ_GET_REPORT,
588 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
589 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
wdenkaffae2b2002-08-17 09:36:01 +0000590}
591
592/********************************************************************
593 * get class descriptor
594 */
595int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
596 unsigned char type, unsigned char id, void *buf, int size)
597{
598 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
599 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
600 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
601}
602
603/********************************************************************
604 * get string index in buffer
605 */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000606static int usb_get_string(struct usb_device *dev, unsigned short langid,
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200607 unsigned char index, void *buf, int size)
wdenkaffae2b2002-08-17 09:36:01 +0000608{
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200609 int i;
610 int result;
611
612 for (i = 0; i < 3; ++i) {
613 /* some devices are flaky */
614 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
615 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200616 (USB_DT_STRING << 8) + index, langid, buf, size,
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200617 USB_CNTL_TIMEOUT);
618
619 if (result > 0)
620 break;
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200621 }
622
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200623 return result;
wdenkaffae2b2002-08-17 09:36:01 +0000624}
625
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200626
627static void usb_try_string_workarounds(unsigned char *buf, int *length)
628{
629 int newlength, oldlength = *length;
630
631 for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
632 if (!isprint(buf[newlength]) || buf[newlength + 1])
633 break;
634
635 if (newlength > 2) {
636 buf[0] = newlength;
637 *length = newlength;
638 }
639}
640
641
642static int usb_string_sub(struct usb_device *dev, unsigned int langid,
643 unsigned int index, unsigned char *buf)
644{
645 int rc;
646
647 /* Try to read the string descriptor by asking for the maximum
648 * possible number of bytes */
649 rc = usb_get_string(dev, langid, index, buf, 255);
650
651 /* If that failed try to read the descriptor length, then
652 * ask for just that many bytes */
653 if (rc < 2) {
654 rc = usb_get_string(dev, langid, index, buf, 2);
655 if (rc == 2)
656 rc = usb_get_string(dev, langid, index, buf, buf[0]);
657 }
658
659 if (rc >= 2) {
660 if (!buf[0] && !buf[1])
661 usb_try_string_workarounds(buf, &rc);
662
663 /* There might be extra junk at the end of the descriptor */
664 if (buf[0] < rc)
665 rc = buf[0];
666
667 rc = rc - (rc & 1); /* force a multiple of two */
668 }
669
670 if (rc < 2)
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200671 rc = -1;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200672
673 return rc;
674}
675
676
wdenkaffae2b2002-08-17 09:36:01 +0000677/********************************************************************
678 * usb_string:
679 * Get string index and translate it to ascii.
680 * returns string length (> 0) or error (< 0)
681 */
682int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
683{
wdenkcd0a9de2004-02-23 20:48:38 +0000684 unsigned char mybuf[USB_BUFSIZ];
wdenkaffae2b2002-08-17 09:36:01 +0000685 unsigned char *tbuf;
686 int err;
687 unsigned int u, idx;
688
689 if (size <= 0 || !buf || !index)
690 return -1;
691 buf[0] = 0;
Wolfgang Denkd0ff51b2008-07-14 15:19:07 +0200692 tbuf = &mybuf[0];
wdenkaffae2b2002-08-17 09:36:01 +0000693
694 /* get langid for strings if it's not yet known */
695 if (!dev->have_langid) {
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200696 err = usb_string_sub(dev, 0, 0, tbuf);
wdenkaffae2b2002-08-17 09:36:01 +0000697 if (err < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200698 USB_PRINTF("error getting string descriptor 0 " \
Stefan Roesef1c1f542009-01-22 10:11:21 +0100699 "(error=%lx)\n", dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000700 return -1;
701 } else if (tbuf[0] < 4) {
702 USB_PRINTF("string descriptor 0 too short\n");
703 return -1;
704 } else {
705 dev->have_langid = -1;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200706 dev->string_langid = tbuf[2] | (tbuf[3] << 8);
wdenkaffae2b2002-08-17 09:36:01 +0000707 /* always use the first langid listed */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200708 USB_PRINTF("USB device number %d default " \
709 "language ID 0x%x\n",
710 dev->devnum, dev->string_langid);
wdenkaffae2b2002-08-17 09:36:01 +0000711 }
712 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200713
714 err = usb_string_sub(dev, dev->string_langid, index, tbuf);
wdenkaffae2b2002-08-17 09:36:01 +0000715 if (err < 0)
716 return err;
wdenkcd0a9de2004-02-23 20:48:38 +0000717
wdenkaffae2b2002-08-17 09:36:01 +0000718 size--; /* leave room for trailing NULL char in output buffer */
719 for (idx = 0, u = 2; u < err; u += 2) {
720 if (idx >= size)
721 break;
722 if (tbuf[u+1]) /* high byte */
723 buf[idx++] = '?'; /* non-ASCII character */
724 else
725 buf[idx++] = tbuf[u];
726 }
727 buf[idx] = 0;
728 err = idx;
729 return err;
730}
731
732
733/********************************************************************
734 * USB device handling:
735 * the USB device are static allocated [USB_MAX_DEVICE].
736 */
737
738
739/* returns a pointer to the device with the index [index].
740 * if the device is not assigned (dev->devnum==-1) returns NULL
741 */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200742struct usb_device *usb_get_dev_index(int index)
wdenkaffae2b2002-08-17 09:36:01 +0000743{
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200744 if (usb_dev[index].devnum == -1)
wdenkaffae2b2002-08-17 09:36:01 +0000745 return NULL;
746 else
747 return &usb_dev[index];
748}
749
750
751/* returns a pointer of a new device structure or NULL, if
752 * no device struct is available
753 */
Marek Vasut23faf2b2012-02-13 18:58:17 +0000754struct usb_device *usb_alloc_new_device(void)
wdenkaffae2b2002-08-17 09:36:01 +0000755{
756 int i;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200757 USB_PRINTF("New Device %d\n", dev_index);
758 if (dev_index == USB_MAX_DEVICE) {
759 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE);
wdenkaffae2b2002-08-17 09:36:01 +0000760 return NULL;
761 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200762 /* default Address is 0, real addresses start with 1 */
763 usb_dev[dev_index].devnum = dev_index + 1;
764 usb_dev[dev_index].maxchild = 0;
765 for (i = 0; i < USB_MAXCHILDREN; i++)
766 usb_dev[dev_index].children[i] = NULL;
767 usb_dev[dev_index].parent = NULL;
wdenkaffae2b2002-08-17 09:36:01 +0000768 dev_index++;
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200769 return &usb_dev[dev_index - 1];
wdenkaffae2b2002-08-17 09:36:01 +0000770}
771
772
773/*
774 * By the time we get here, the device has gotten a new device ID
775 * and is in the default state. We need to identify the thing and
776 * get the ball rolling..
777 *
778 * Returns 0 for success, != 0 for error.
779 */
Marek Vasut23faf2b2012-02-13 18:58:17 +0000780int usb_new_device(struct usb_device *dev)
wdenkaffae2b2002-08-17 09:36:01 +0000781{
782 int addr, err;
783 int tmp;
wdenkcd0a9de2004-02-23 20:48:38 +0000784 unsigned char tmpbuf[USB_BUFSIZ];
wdenkaffae2b2002-08-17 09:36:01 +0000785
wdenkaffae2b2002-08-17 09:36:01 +0000786 /* We still haven't set the Address yet */
787 addr = dev->devnum;
788 dev->devnum = 0;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200789
Remy Bohmerc9e84362008-09-16 14:55:44 +0200790#ifdef CONFIG_LEGACY_USB_INIT_SEQ
791 /* this is the old and known way of initializing devices, it is
792 * different than what Windows and Linux are doing. Windows and Linux
793 * both retrieve 64 bytes while reading the device descriptor
794 * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an
795 * invalid header while reading 8 bytes as device descriptor. */
796 dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */
Remy Bohmer48867202008-10-10 10:23:21 +0200797 dev->maxpacketsize = PACKET_SIZE_8;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100798 dev->epmaxpacketin[0] = 8;
Remy Bohmerc9e84362008-09-16 14:55:44 +0200799 dev->epmaxpacketout[0] = 8;
800
801 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
802 if (err < 8) {
803 printf("\n USB device not responding, " \
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100804 "giving up (status=%lX)\n", dev->status);
Remy Bohmerc9e84362008-09-16 14:55:44 +0200805 return 1;
806 }
807#else
Remy Bohmer48867202008-10-10 10:23:21 +0200808 /* This is a Windows scheme of initialization sequence, with double
809 * reset of the device (Linux uses the same sequence)
Remy Bohmerc9e84362008-09-16 14:55:44 +0200810 * Some equipment is said to work only with such init sequence; this
811 * patch is based on the work by Alan Stern:
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100812 * http://sourceforge.net/mailarchive/forum.php?
813 * thread_id=5729457&forum_id=5398
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200814 */
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200815 struct usb_device_descriptor *desc;
816 int port = -1;
817 struct usb_device *parent = dev->parent;
818 unsigned short portstatus;
819
820 /* send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is
821 * only 18 bytes long, this will terminate with a short packet. But if
822 * the maxpacket size is 8 or 16 the device may be waiting to transmit
Remy Bohmerc9e84362008-09-16 14:55:44 +0200823 * some more, or keeps on retransmitting the 8 byte header. */
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200824
825 desc = (struct usb_device_descriptor *)tmpbuf;
Remy Bohmerc9e84362008-09-16 14:55:44 +0200826 dev->descriptor.bMaxPacketSize0 = 64; /* Start off at 64 bytes */
Remy Bohmer48867202008-10-10 10:23:21 +0200827 /* Default to 64 byte max packet size */
828 dev->maxpacketsize = PACKET_SIZE_64;
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100829 dev->epmaxpacketin[0] = 64;
Remy Bohmerc9e84362008-09-16 14:55:44 +0200830 dev->epmaxpacketout[0] = 64;
Remy Bohmer48867202008-10-10 10:23:21 +0200831
832 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
833 if (err < 0) {
834 USB_PRINTF("usb_new_device: usb_get_descriptor() failed\n");
835 return 1;
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200836 }
Remy Bohmer48867202008-10-10 10:23:21 +0200837
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200838 dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0;
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200839
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200840 /* find the port number we're at */
841 if (parent) {
Remy Bohmer48867202008-10-10 10:23:21 +0200842 int j;
Wolfgang Denk095b8a32005-08-02 17:06:17 +0200843
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200844 for (j = 0; j < parent->maxchild; j++) {
845 if (parent->children[j] == dev) {
846 port = j;
847 break;
848 }
849 }
850 if (port < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200851 printf("usb_new_device:cannot locate device's port.\n");
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200852 return 1;
853 }
854
855 /* reset the port for the second time */
856 err = hub_port_reset(dev->parent, port, &portstatus);
857 if (err < 0) {
858 printf("\n Couldn't reset port %i\n", port);
859 return 1;
860 }
861 }
Wolfgang Denk9c998aa2005-07-21 11:57:57 +0200862#endif
863
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100864 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
wdenkaffae2b2002-08-17 09:36:01 +0000865 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
866 switch (dev->descriptor.bMaxPacketSize0) {
Michael Trimarchide39f8c2008-11-26 17:41:34 +0100867 case 8:
868 dev->maxpacketsize = PACKET_SIZE_8;
869 break;
870 case 16:
871 dev->maxpacketsize = PACKET_SIZE_16;
872 break;
873 case 32:
874 dev->maxpacketsize = PACKET_SIZE_32;
875 break;
876 case 64:
877 dev->maxpacketsize = PACKET_SIZE_64;
878 break;
wdenkaffae2b2002-08-17 09:36:01 +0000879 }
880 dev->devnum = addr;
881
882 err = usb_set_address(dev); /* set address */
883
884 if (err < 0) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200885 printf("\n USB device not accepting new address " \
886 "(error=%lX)\n", dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000887 return 1;
888 }
889
Mike Frysinger5b84dd62012-03-05 13:47:00 +0000890 mdelay(10); /* Let the SET_ADDRESS settle */
wdenkaffae2b2002-08-17 09:36:01 +0000891
892 tmp = sizeof(dev->descriptor);
893
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200894 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
895 &dev->descriptor, sizeof(dev->descriptor));
wdenkaffae2b2002-08-17 09:36:01 +0000896 if (err < tmp) {
897 if (err < 0)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200898 printf("unable to get device descriptor (error=%d)\n",
899 err);
wdenkaffae2b2002-08-17 09:36:01 +0000900 else
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200901 printf("USB device descriptor short read " \
902 "(expected %i, got %i)\n", tmp, err);
wdenkaffae2b2002-08-17 09:36:01 +0000903 return 1;
904 }
905 /* correct le values */
Christian Eggersc9182612008-05-21 22:12:00 +0200906 le16_to_cpus(&dev->descriptor.bcdUSB);
907 le16_to_cpus(&dev->descriptor.idVendor);
908 le16_to_cpus(&dev->descriptor.idProduct);
909 le16_to_cpus(&dev->descriptor.bcdDevice);
wdenkaffae2b2002-08-17 09:36:01 +0000910 /* only support for one config for now */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200911 usb_get_configuration_no(dev, &tmpbuf[0], 0);
912 usb_parse_config(dev, &tmpbuf[0], 0);
wdenkaffae2b2002-08-17 09:36:01 +0000913 usb_set_maxpacket(dev);
914 /* we set the default configuration here */
Tom Rix8f8bd562009-10-31 12:37:38 -0500915 if (usb_set_configuration(dev, dev->config.desc.bConfigurationValue)) {
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200916 printf("failed to set default configuration " \
917 "len %d, status %lX\n", dev->act_len, dev->status);
wdenkaffae2b2002-08-17 09:36:01 +0000918 return -1;
919 }
920 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200921 dev->descriptor.iManufacturer, dev->descriptor.iProduct,
922 dev->descriptor.iSerialNumber);
wdenkaffae2b2002-08-17 09:36:01 +0000923 memset(dev->mf, 0, sizeof(dev->mf));
924 memset(dev->prod, 0, sizeof(dev->prod));
925 memset(dev->serial, 0, sizeof(dev->serial));
926 if (dev->descriptor.iManufacturer)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200927 usb_string(dev, dev->descriptor.iManufacturer,
928 dev->mf, sizeof(dev->mf));
wdenkaffae2b2002-08-17 09:36:01 +0000929 if (dev->descriptor.iProduct)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200930 usb_string(dev, dev->descriptor.iProduct,
931 dev->prod, sizeof(dev->prod));
wdenkaffae2b2002-08-17 09:36:01 +0000932 if (dev->descriptor.iSerialNumber)
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200933 usb_string(dev, dev->descriptor.iSerialNumber,
934 dev->serial, sizeof(dev->serial));
wdenkaffae2b2002-08-17 09:36:01 +0000935 USB_PRINTF("Manufacturer %s\n", dev->mf);
936 USB_PRINTF("Product %s\n", dev->prod);
937 USB_PRINTF("SerialNumber %s\n", dev->serial);
938 /* now prode if the device is a hub */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200939 usb_hub_probe(dev, 0);
wdenkaffae2b2002-08-17 09:36:01 +0000940 return 0;
941}
942
943/* build device Tree */
Marek Vasutc08b1b22012-02-13 18:58:16 +0000944static void usb_scan_devices(void)
wdenkaffae2b2002-08-17 09:36:01 +0000945{
946 int i;
947 struct usb_device *dev;
948
949 /* first make all devices unknown */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200950 for (i = 0; i < USB_MAX_DEVICE; i++) {
951 memset(&usb_dev[i], 0, sizeof(struct usb_device));
Wolfgang Denkd0ff51b2008-07-14 15:19:07 +0200952 usb_dev[i].devnum = -1;
wdenkaffae2b2002-08-17 09:36:01 +0000953 }
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200954 dev_index = 0;
wdenkaffae2b2002-08-17 09:36:01 +0000955 /* device 0 is always present (root hub, so let it analyze) */
Remy Bohmer6f5794a2008-09-16 14:55:43 +0200956 dev = usb_alloc_new_device();
Bryan Wu1a448db2009-01-18 23:04:27 -0500957 if (usb_new_device(dev))
958 printf("No USB Device found\n");
959 else
960 printf("%d USB Device(s) found\n", dev_index);
wdenkaffae2b2002-08-17 09:36:01 +0000961 /* insert "driver" if possible */
962#ifdef CONFIG_USB_KEYBOARD
963 drv_usb_kbd_init();
wdenkaffae2b2002-08-17 09:36:01 +0000964#endif
Marek Vasut2a94dda2011-07-12 02:16:46 +0200965 USB_PRINTF("scan end\n");
wdenkaffae2b2002-08-17 09:36:01 +0000966}
967
wdenkaffae2b2002-08-17 09:36:01 +0000968/* EOF */