]>
Commit | Line | Data |
---|---|---|
affae2bf | 1 | /* |
affae2bf | 2 | * Most of this source has been derived from the Linux USB |
460c322f WD |
3 | * project: |
4 | * (C) Copyright Linus Torvalds 1999 | |
5 | * (C) Copyright Johannes Erdfelt 1999-2001 | |
6 | * (C) Copyright Andreas Gal 1999 | |
7 | * (C) Copyright Gregory P. Smith 1999 | |
8 | * (C) Copyright Deti Fliegl 1999 (new USB architecture) | |
9 | * (C) Copyright Randy Dunlap 2000 | |
10 | * (C) Copyright David Brownell 2000 (kernel hotplug, usb_device_id) | |
11 | * (C) Copyright Yggdrasil Computing, Inc. 2000 | |
12 | * (usb_device_id matching changes by Adam J. Richter) | |
13 | * | |
14 | * Adapted for U-Boot: | |
15 | * (C) Copyright 2001 Denis Peter, MPL AG Switzerland | |
affae2bf | 16 | * |
1a459660 | 17 | * SPDX-License-Identifier: GPL-2.0+ |
affae2bf WD |
18 | */ |
19 | ||
affae2bf WD |
20 | /* |
21 | * How it works: | |
22 | * | |
23 | * Since this is a bootloader, the devices will not be automatic | |
24 | * (re)configured on hotplug, but after a restart of the USB the | |
25 | * device should work. | |
26 | * | |
27 | * For each transfer (except "Interrupt") we wait for completion. | |
28 | */ | |
29 | #include <common.h> | |
30 | #include <command.h> | |
95fbfe42 | 31 | #include <dm.h> |
affae2bf | 32 | #include <asm/processor.h> |
66cf6410 | 33 | #include <linux/compiler.h> |
9c998aa8 | 34 | #include <linux/ctype.h> |
c918261c | 35 | #include <asm/byteorder.h> |
b2fb47f1 | 36 | #include <asm/unaligned.h> |
97b9eb9e | 37 | #include <errno.h> |
affae2bf WD |
38 | #include <usb.h> |
39 | #ifdef CONFIG_4xx | |
3048bcbf | 40 | #include <asm/4xx_pci.h> |
affae2bf WD |
41 | #endif |
42 | ||
cd0a9de6 WD |
43 | #define USB_BUFSIZ 512 |
44 | ||
affae2bf | 45 | static int asynch_allowed; |
e51aae38 BS |
46 | char usb_started; /* flag for the started/stopped USB status */ |
47 | ||
95fbfe42 SG |
48 | #ifndef CONFIG_DM_USB |
49 | static struct usb_device usb_dev[USB_MAX_DEVICE]; | |
50 | static int dev_index; | |
51 | ||
93c2582f LS |
52 | #ifndef CONFIG_USB_MAX_CONTROLLER_COUNT |
53 | #define CONFIG_USB_MAX_CONTROLLER_COUNT 1 | |
54 | #endif | |
affae2bf | 55 | |
affae2bf WD |
56 | /*************************************************************************** |
57 | * Init USB Device | |
58 | */ | |
affae2bf WD |
59 | int usb_init(void) |
60 | { | |
93c2582f LS |
61 | void *ctrl; |
62 | struct usb_device *dev; | |
63 | int i, start_index = 0; | |
d906bbc2 | 64 | int controllers_initialized = 0; |
97b9eb9e | 65 | int ret; |
affae2bf | 66 | |
6f5794a6 RB |
67 | dev_index = 0; |
68 | asynch_allowed = 1; | |
affae2bf | 69 | usb_hub_reset(); |
93c2582f LS |
70 | |
71 | /* first make all devices unknown */ | |
72 | for (i = 0; i < USB_MAX_DEVICE; i++) { | |
73 | memset(&usb_dev[i], 0, sizeof(struct usb_device)); | |
74 | usb_dev[i].devnum = -1; | |
75 | } | |
76 | ||
affae2bf | 77 | /* init low_level USB */ |
93c2582f LS |
78 | for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) { |
79 | /* init low_level USB */ | |
80 | printf("USB%d: ", i); | |
97b9eb9e MV |
81 | ret = usb_lowlevel_init(i, USB_INIT_HOST, &ctrl); |
82 | if (ret == -ENODEV) { /* No such device. */ | |
83 | puts("Port not available.\n"); | |
d906bbc2 | 84 | controllers_initialized++; |
97b9eb9e MV |
85 | continue; |
86 | } | |
87 | ||
88 | if (ret) { /* Other error. */ | |
93c2582f LS |
89 | puts("lowlevel init failed\n"); |
90 | continue; | |
91 | } | |
92 | /* | |
93 | * lowlevel init is OK, now scan the bus for devices | |
94 | * i.e. search HUBs and configure them | |
95 | */ | |
d906bbc2 | 96 | controllers_initialized++; |
93c2582f LS |
97 | start_index = dev_index; |
98 | printf("scanning bus %d for devices... ", i); | |
79b58887 SG |
99 | ret = usb_alloc_new_device(ctrl, &dev); |
100 | if (ret) | |
8879be88 PK |
101 | break; |
102 | ||
93c2582f LS |
103 | /* |
104 | * device 0 is always present | |
105 | * (root hub, so let it analyze) | |
106 | */ | |
8879be88 PK |
107 | ret = usb_new_device(dev); |
108 | if (ret) | |
79b58887 | 109 | usb_free_device(dev->controller); |
93c2582f | 110 | |
8879be88 | 111 | if (start_index == dev_index) { |
93c2582f | 112 | puts("No USB Device found\n"); |
8879be88 PK |
113 | continue; |
114 | } else { | |
93c2582f LS |
115 | printf("%d USB Device(s) found\n", |
116 | dev_index - start_index); | |
8879be88 | 117 | } |
93c2582f | 118 | |
e51aae38 | 119 | usb_started = 1; |
93c2582f LS |
120 | } |
121 | ||
ceb4972a | 122 | debug("scan end\n"); |
93c2582f | 123 | /* if we were not able to find at least one working bus, bail out */ |
d906bbc2 | 124 | if (controllers_initialized == 0) |
93c2582f | 125 | puts("USB error: all controllers failed lowlevel init\n"); |
93c2582f | 126 | |
5a80b344 | 127 | return usb_started ? 0 : -ENODEV; |
affae2bf WD |
128 | } |
129 | ||
130 | /****************************************************************************** | |
131 | * Stop USB this stops the LowLevel Part and deregisters USB devices. | |
132 | */ | |
133 | int usb_stop(void) | |
134 | { | |
93c2582f | 135 | int i; |
eba1f2fc RB |
136 | |
137 | if (usb_started) { | |
138 | asynch_allowed = 1; | |
139 | usb_started = 0; | |
140 | usb_hub_reset(); | |
93c2582f LS |
141 | |
142 | for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) { | |
143 | if (usb_lowlevel_stop(i)) | |
144 | printf("failed to stop USB controller %d\n", i); | |
145 | } | |
eba1f2fc | 146 | } |
93c2582f LS |
147 | |
148 | return 0; | |
affae2bf WD |
149 | } |
150 | ||
151 | /* | |
152 | * disables the asynch behaviour of the control message. This is used for data | |
153 | * transfers that uses the exclusiv access to the control and bulk messages. | |
89d48367 | 154 | * Returns the old value so it can be restored later. |
affae2bf | 155 | */ |
89d48367 | 156 | int usb_disable_asynch(int disable) |
affae2bf | 157 | { |
89d48367 SG |
158 | int old_value = asynch_allowed; |
159 | ||
6f5794a6 | 160 | asynch_allowed = !disable; |
89d48367 | 161 | return old_value; |
affae2bf | 162 | } |
95fbfe42 | 163 | #endif /* !CONFIG_DM_USB */ |
affae2bf WD |
164 | |
165 | ||
166 | /*------------------------------------------------------------------- | |
167 | * Message wrappers. | |
168 | * | |
169 | */ | |
170 | ||
171 | /* | |
172 | * submits an Interrupt Message | |
173 | */ | |
174 | int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, | |
6f5794a6 | 175 | void *buffer, int transfer_len, int interval) |
affae2bf | 176 | { |
6f5794a6 | 177 | return submit_int_msg(dev, pipe, buffer, transfer_len, interval); |
affae2bf WD |
178 | } |
179 | ||
180 | /* | |
181 | * submits a control message and waits for comletion (at least timeout * 1ms) | |
182 | * If timeout is 0, we don't wait for completion (used as example to set and | |
183 | * clear keyboards LEDs). For data transfers, (storage transfers) we don't | |
184 | * allow control messages with 0 timeout, by previousely resetting the flag | |
185 | * asynch_allowed (usb_disable_asynch(1)). | |
186 | * returns the transfered length if OK or -1 if error. The transfered length | |
187 | * and the current status are stored in the dev->act_len and dev->status. | |
188 | */ | |
189 | int usb_control_msg(struct usb_device *dev, unsigned int pipe, | |
190 | unsigned char request, unsigned char requesttype, | |
191 | unsigned short value, unsigned short index, | |
192 | void *data, unsigned short size, int timeout) | |
193 | { | |
f5766139 | 194 | ALLOC_CACHE_ALIGN_BUFFER(struct devrequest, setup_packet, 1); |
651d95c8 | 195 | int err; |
e159e486 | 196 | |
6f5794a6 RB |
197 | if ((timeout == 0) && (!asynch_allowed)) { |
198 | /* request for a asynch control pipe is not allowed */ | |
5a80b344 | 199 | return -EINVAL; |
6f5794a6 | 200 | } |
9c998aa8 | 201 | |
affae2bf | 202 | /* set setup command */ |
f5766139 PS |
203 | setup_packet->requesttype = requesttype; |
204 | setup_packet->request = request; | |
205 | setup_packet->value = cpu_to_le16(value); | |
206 | setup_packet->index = cpu_to_le16(index); | |
207 | setup_packet->length = cpu_to_le16(size); | |
ceb4972a VG |
208 | debug("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \ |
209 | "value 0x%X index 0x%X length 0x%X\n", | |
210 | request, requesttype, value, index, size); | |
6f5794a6 | 211 | dev->status = USB_ST_NOT_PROC; /*not yet processed */ |
affae2bf | 212 | |
651d95c8 HG |
213 | err = submit_control_msg(dev, pipe, data, size, setup_packet); |
214 | if (err < 0) | |
215 | return err; | |
6f5794a6 | 216 | if (timeout == 0) |
affae2bf | 217 | return (int)size; |
6f5794a6 | 218 | |
84d36b30 RB |
219 | /* |
220 | * Wait for status to update until timeout expires, USB driver | |
221 | * interrupt handler may set the status when the USB operation has | |
222 | * been completed. | |
223 | */ | |
224 | while (timeout--) { | |
225 | if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) | |
226 | break; | |
5b84dd67 | 227 | mdelay(1); |
48867208 | 228 | } |
84d36b30 RB |
229 | if (dev->status) |
230 | return -1; | |
48867208 RB |
231 | |
232 | return dev->act_len; | |
84d36b30 | 233 | |
affae2bf WD |
234 | } |
235 | ||
236 | /*------------------------------------------------------------------- | |
237 | * submits bulk message, and waits for completion. returns 0 if Ok or | |
5a80b344 | 238 | * negative if Error. |
affae2bf WD |
239 | * synchronous behavior |
240 | */ | |
241 | int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, | |
242 | void *data, int len, int *actual_length, int timeout) | |
243 | { | |
244 | if (len < 0) | |
5a80b344 | 245 | return -EINVAL; |
6f5794a6 | 246 | dev->status = USB_ST_NOT_PROC; /*not yet processed */ |
fd06028d | 247 | if (submit_bulk_msg(dev, pipe, data, len) < 0) |
5a80b344 | 248 | return -EIO; |
6f5794a6 RB |
249 | while (timeout--) { |
250 | if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) | |
affae2bf | 251 | break; |
5b84dd67 | 252 | mdelay(1); |
affae2bf | 253 | } |
6f5794a6 RB |
254 | *actual_length = dev->act_len; |
255 | if (dev->status == 0) | |
affae2bf WD |
256 | return 0; |
257 | else | |
5a80b344 | 258 | return -EIO; |
affae2bf WD |
259 | } |
260 | ||
261 | ||
262 | /*------------------------------------------------------------------- | |
263 | * Max Packet stuff | |
264 | */ | |
265 | ||
266 | /* | |
267 | * returns the max packet size, depending on the pipe direction and | |
268 | * the configurations values | |
269 | */ | |
6f5794a6 | 270 | int usb_maxpacket(struct usb_device *dev, unsigned long pipe) |
affae2bf | 271 | { |
6f5794a6 RB |
272 | /* direction is out -> use emaxpacket out */ |
273 | if ((pipe & USB_DIR_IN) == 0) | |
de39f8c1 | 274 | return dev->epmaxpacketout[((pipe>>15) & 0xf)]; |
affae2bf | 275 | else |
de39f8c1 | 276 | return dev->epmaxpacketin[((pipe>>15) & 0xf)]; |
affae2bf WD |
277 | } |
278 | ||
5e8baf87 MV |
279 | /* |
280 | * The routine usb_set_maxpacket_ep() is extracted from the loop of routine | |
be19d324 RB |
281 | * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine |
282 | * when it is inlined in 1 single routine. What happens is that the register r3 | |
283 | * is used as loop-count 'i', but gets overwritten later on. | |
284 | * This is clearly a compiler bug, but it is easier to workaround it here than | |
285 | * to update the compiler (Occurs with at least several GCC 4.{1,2},x | |
286 | * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM) | |
5e8baf87 MV |
287 | * |
288 | * NOTE: Similar behaviour was observed with GCC4.6 on ARMv5. | |
be19d324 | 289 | */ |
66cf6410 | 290 | static void noinline |
5e8baf87 | 291 | usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx) |
be19d324 RB |
292 | { |
293 | int b; | |
5e8baf87 | 294 | struct usb_endpoint_descriptor *ep; |
b2fb47f1 | 295 | u16 ep_wMaxPacketSize; |
5e8baf87 MV |
296 | |
297 | ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx]; | |
be19d324 RB |
298 | |
299 | b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; | |
b2fb47f1 | 300 | ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize); |
be19d324 RB |
301 | |
302 | if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == | |
303 | USB_ENDPOINT_XFER_CONTROL) { | |
304 | /* Control => bidirectional */ | |
b2fb47f1 TR |
305 | dev->epmaxpacketout[b] = ep_wMaxPacketSize; |
306 | dev->epmaxpacketin[b] = ep_wMaxPacketSize; | |
ceb4972a VG |
307 | debug("##Control EP epmaxpacketout/in[%d] = %d\n", |
308 | b, dev->epmaxpacketin[b]); | |
be19d324 RB |
309 | } else { |
310 | if ((ep->bEndpointAddress & 0x80) == 0) { | |
311 | /* OUT Endpoint */ | |
b2fb47f1 TR |
312 | if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) { |
313 | dev->epmaxpacketout[b] = ep_wMaxPacketSize; | |
ceb4972a VG |
314 | debug("##EP epmaxpacketout[%d] = %d\n", |
315 | b, dev->epmaxpacketout[b]); | |
be19d324 RB |
316 | } |
317 | } else { | |
318 | /* IN Endpoint */ | |
b2fb47f1 TR |
319 | if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) { |
320 | dev->epmaxpacketin[b] = ep_wMaxPacketSize; | |
ceb4972a VG |
321 | debug("##EP epmaxpacketin[%d] = %d\n", |
322 | b, dev->epmaxpacketin[b]); | |
be19d324 RB |
323 | } |
324 | } /* if out */ | |
325 | } /* if control */ | |
326 | } | |
327 | ||
affae2bf WD |
328 | /* |
329 | * set the max packed value of all endpoints in the given configuration | |
330 | */ | |
c08b1b26 | 331 | static int usb_set_maxpacket(struct usb_device *dev) |
affae2bf | 332 | { |
be19d324 | 333 | int i, ii; |
affae2bf | 334 | |
8f8bd565 TR |
335 | for (i = 0; i < dev->config.desc.bNumInterfaces; i++) |
336 | for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++) | |
5e8baf87 | 337 | usb_set_maxpacket_ep(dev, i, ii); |
affae2bf | 338 | |
affae2bf WD |
339 | return 0; |
340 | } | |
341 | ||
342 | /******************************************************************************* | |
343 | * Parse the config, located in buffer, and fills the dev->config structure. | |
344 | * Note that all little/big endian swapping are done automatically. | |
eaf3e613 | 345 | * (wTotalLength has already been swapped and sanitized when it was read.) |
affae2bf | 346 | */ |
c08b1b26 MV |
347 | static int usb_parse_config(struct usb_device *dev, |
348 | unsigned char *buffer, int cfgno) | |
affae2bf WD |
349 | { |
350 | struct usb_descriptor_header *head; | |
7455af41 | 351 | int index, ifno, epno, curr_if_num; |
b2fb47f1 | 352 | u16 ep_wMaxPacketSize; |
605bd75a | 353 | struct usb_interface *if_desc = NULL; |
7455af41 BS |
354 | |
355 | ifno = -1; | |
356 | epno = -1; | |
357 | curr_if_num = -1; | |
358 | ||
359 | dev->configno = cfgno; | |
360 | head = (struct usb_descriptor_header *) &buffer[0]; | |
6f5794a6 RB |
361 | if (head->bDescriptorType != USB_DT_CONFIG) { |
362 | printf(" ERROR: NOT USB_CONFIG_DESC %x\n", | |
363 | head->bDescriptorType); | |
5a80b344 | 364 | return -EINVAL; |
affae2bf | 365 | } |
eaf3e613 JW |
366 | if (head->bLength != USB_DT_CONFIG_SIZE) { |
367 | printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength); | |
5a80b344 | 368 | return -EINVAL; |
eaf3e613 JW |
369 | } |
370 | memcpy(&dev->config, head, USB_DT_CONFIG_SIZE); | |
7455af41 | 371 | dev->config.no_of_if = 0; |
affae2bf | 372 | |
8f8bd565 | 373 | index = dev->config.desc.bLength; |
6f5794a6 RB |
374 | /* Ok the first entry must be a configuration entry, |
375 | * now process the others */ | |
7455af41 | 376 | head = (struct usb_descriptor_header *) &buffer[index]; |
eaf3e613 | 377 | while (index + 1 < dev->config.desc.wTotalLength && head->bLength) { |
6f5794a6 RB |
378 | switch (head->bDescriptorType) { |
379 | case USB_DT_INTERFACE: | |
eaf3e613 JW |
380 | if (head->bLength != USB_DT_INTERFACE_SIZE) { |
381 | printf("ERROR: Invalid USB IF length (%d)\n", | |
382 | head->bLength); | |
383 | break; | |
384 | } | |
385 | if (index + USB_DT_INTERFACE_SIZE > | |
386 | dev->config.desc.wTotalLength) { | |
387 | puts("USB IF descriptor overflowed buffer!\n"); | |
388 | break; | |
389 | } | |
6f5794a6 | 390 | if (((struct usb_interface_descriptor *) \ |
eaf3e613 | 391 | head)->bInterfaceNumber != curr_if_num) { |
6f5794a6 RB |
392 | /* this is a new interface, copy new desc */ |
393 | ifno = dev->config.no_of_if; | |
eaf3e613 JW |
394 | if (ifno >= USB_MAXINTERFACES) { |
395 | puts("Too many USB interfaces!\n"); | |
396 | /* try to go on with what we have */ | |
5a80b344 | 397 | return -EINVAL; |
eaf3e613 | 398 | } |
605bd75a | 399 | if_desc = &dev->config.if_desc[ifno]; |
6f5794a6 | 400 | dev->config.no_of_if++; |
eaf3e613 JW |
401 | memcpy(if_desc, head, |
402 | USB_DT_INTERFACE_SIZE); | |
605bd75a VG |
403 | if_desc->no_of_ep = 0; |
404 | if_desc->num_altsetting = 1; | |
6f5794a6 | 405 | curr_if_num = |
605bd75a | 406 | if_desc->desc.bInterfaceNumber; |
6f5794a6 RB |
407 | } else { |
408 | /* found alternate setting for the interface */ | |
605bd75a VG |
409 | if (ifno >= 0) { |
410 | if_desc = &dev->config.if_desc[ifno]; | |
411 | if_desc->num_altsetting++; | |
412 | } | |
6f5794a6 RB |
413 | } |
414 | break; | |
415 | case USB_DT_ENDPOINT: | |
eaf3e613 JW |
416 | if (head->bLength != USB_DT_ENDPOINT_SIZE) { |
417 | printf("ERROR: Invalid USB EP length (%d)\n", | |
418 | head->bLength); | |
419 | break; | |
420 | } | |
421 | if (index + USB_DT_ENDPOINT_SIZE > | |
422 | dev->config.desc.wTotalLength) { | |
423 | puts("USB EP descriptor overflowed buffer!\n"); | |
424 | break; | |
425 | } | |
426 | if (ifno < 0) { | |
427 | puts("Endpoint descriptor out of order!\n"); | |
428 | break; | |
429 | } | |
6f5794a6 | 430 | epno = dev->config.if_desc[ifno].no_of_ep; |
605bd75a | 431 | if_desc = &dev->config.if_desc[ifno]; |
eaf3e613 JW |
432 | if (epno > USB_MAXENDPOINTS) { |
433 | printf("Interface %d has too many endpoints!\n", | |
434 | if_desc->desc.bInterfaceNumber); | |
5a80b344 | 435 | return -EINVAL; |
eaf3e613 | 436 | } |
6f5794a6 | 437 | /* found an endpoint */ |
605bd75a | 438 | if_desc->no_of_ep++; |
eaf3e613 JW |
439 | memcpy(&if_desc->ep_desc[epno], head, |
440 | USB_DT_ENDPOINT_SIZE); | |
b2fb47f1 TR |
441 | ep_wMaxPacketSize = get_unaligned(&dev->config.\ |
442 | if_desc[ifno].\ | |
443 | ep_desc[epno].\ | |
444 | wMaxPacketSize); | |
445 | put_unaligned(le16_to_cpu(ep_wMaxPacketSize), | |
446 | &dev->config.\ | |
447 | if_desc[ifno].\ | |
448 | ep_desc[epno].\ | |
449 | wMaxPacketSize); | |
ceb4972a | 450 | debug("if %d, ep %d\n", ifno, epno); |
6f5794a6 | 451 | break; |
6497c667 | 452 | case USB_DT_SS_ENDPOINT_COMP: |
eaf3e613 JW |
453 | if (head->bLength != USB_DT_SS_EP_COMP_SIZE) { |
454 | printf("ERROR: Invalid USB EPC length (%d)\n", | |
455 | head->bLength); | |
456 | break; | |
457 | } | |
458 | if (index + USB_DT_SS_EP_COMP_SIZE > | |
459 | dev->config.desc.wTotalLength) { | |
460 | puts("USB EPC descriptor overflowed buffer!\n"); | |
461 | break; | |
462 | } | |
463 | if (ifno < 0 || epno < 0) { | |
464 | puts("EPC descriptor out of order!\n"); | |
465 | break; | |
466 | } | |
6497c667 | 467 | if_desc = &dev->config.if_desc[ifno]; |
eaf3e613 JW |
468 | memcpy(&if_desc->ss_ep_comp_desc[epno], head, |
469 | USB_DT_SS_EP_COMP_SIZE); | |
6497c667 | 470 | break; |
6f5794a6 RB |
471 | default: |
472 | if (head->bLength == 0) | |
5a80b344 | 473 | return -EINVAL; |
6f5794a6 | 474 | |
ceb4972a VG |
475 | debug("unknown Description Type : %x\n", |
476 | head->bDescriptorType); | |
6f5794a6 | 477 | |
ceb4972a | 478 | #ifdef DEBUG |
6f5794a6 | 479 | { |
fad2e1b0 | 480 | unsigned char *ch = (unsigned char *)head; |
ceb4972a VG |
481 | int i; |
482 | ||
6f5794a6 | 483 | for (i = 0; i < head->bLength; i++) |
ceb4972a VG |
484 | debug("%02X ", *ch++); |
485 | debug("\n\n\n"); | |
6f5794a6 | 486 | } |
ceb4972a | 487 | #endif |
6f5794a6 | 488 | break; |
affae2bf | 489 | } |
7455af41 BS |
490 | index += head->bLength; |
491 | head = (struct usb_descriptor_header *)&buffer[index]; | |
affae2bf | 492 | } |
5a80b344 | 493 | return 0; |
affae2bf WD |
494 | } |
495 | ||
496 | /*********************************************************************** | |
497 | * Clears an endpoint | |
498 | * endp: endpoint number in bits 0-3; | |
499 | * direction flag in bit 7 (1 = IN, 0 = OUT) | |
500 | */ | |
501 | int usb_clear_halt(struct usb_device *dev, int pipe) | |
502 | { | |
503 | int result; | |
9c998aa8 | 504 | int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7); |
affae2bf WD |
505 | |
506 | result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), | |
6f5794a6 RB |
507 | USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, |
508 | endp, NULL, 0, USB_CNTL_TIMEOUT * 3); | |
affae2bf WD |
509 | |
510 | /* don't clear if failed */ | |
511 | if (result < 0) | |
512 | return result; | |
9c998aa8 | 513 | |
095b8a37 | 514 | /* |
9c998aa8 WD |
515 | * NOTE: we do not get status and verify reset was successful |
516 | * as some devices are reported to lock up upon this check.. | |
517 | */ | |
518 | ||
affae2bf | 519 | usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)); |
9c998aa8 | 520 | |
affae2bf WD |
521 | /* toggle is reset on clear */ |
522 | usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0); | |
523 | return 0; | |
524 | } | |
525 | ||
526 | ||
527 | /********************************************************************** | |
528 | * get_descriptor type | |
529 | */ | |
c08b1b26 | 530 | static int usb_get_descriptor(struct usb_device *dev, unsigned char type, |
6f5794a6 | 531 | unsigned char index, void *buf, int size) |
affae2bf WD |
532 | { |
533 | int res; | |
53677ef1 | 534 | res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), |
affae2bf WD |
535 | USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, |
536 | (type << 8) + index, 0, | |
537 | buf, size, USB_CNTL_TIMEOUT); | |
538 | return res; | |
539 | } | |
540 | ||
541 | /********************************************************************** | |
542 | * gets configuration cfgno and store it in the buffer | |
543 | */ | |
6f5794a6 RB |
544 | int usb_get_configuration_no(struct usb_device *dev, |
545 | unsigned char *buffer, int cfgno) | |
affae2bf | 546 | { |
53677ef1 | 547 | int result; |
eaf3e613 | 548 | unsigned int length; |
c60795f4 | 549 | struct usb_config_descriptor *config; |
affae2bf | 550 | |
c60795f4 | 551 | config = (struct usb_config_descriptor *)&buffer[0]; |
48867208 RB |
552 | result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9); |
553 | if (result < 9) { | |
affae2bf | 554 | if (result < 0) |
6f5794a6 RB |
555 | printf("unable to get descriptor, error %lX\n", |
556 | dev->status); | |
affae2bf | 557 | else |
6f5794a6 | 558 | printf("config descriptor too short " \ |
48867208 | 559 | "(expected %i, got %i)\n", 9, result); |
5a80b344 | 560 | return -EIO; |
affae2bf | 561 | } |
eaf3e613 | 562 | length = le16_to_cpu(config->wTotalLength); |
affae2bf | 563 | |
eaf3e613 JW |
564 | if (length > USB_BUFSIZ) { |
565 | printf("%s: failed to get descriptor - too long: %d\n", | |
566 | __func__, length); | |
5a80b344 | 567 | return -EIO; |
cd0a9de6 WD |
568 | } |
569 | ||
eaf3e613 JW |
570 | result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length); |
571 | debug("get_conf_no %d Result %d, wLength %d\n", cfgno, result, length); | |
572 | config->wTotalLength = length; /* validated, with CPU byte order */ | |
573 | ||
affae2bf WD |
574 | return result; |
575 | } | |
576 | ||
577 | /******************************************************************** | |
578 | * set address of a device to the value in dev->devnum. | |
579 | * This can only be done by addressing the device via the default address (0) | |
580 | */ | |
c08b1b26 | 581 | static int usb_set_address(struct usb_device *dev) |
affae2bf WD |
582 | { |
583 | int res; | |
584 | ||
ceb4972a | 585 | debug("set address %d\n", dev->devnum); |
6f5794a6 RB |
586 | res = usb_control_msg(dev, usb_snddefctrl(dev), |
587 | USB_REQ_SET_ADDRESS, 0, | |
588 | (dev->devnum), 0, | |
589 | NULL, 0, USB_CNTL_TIMEOUT); | |
affae2bf WD |
590 | return res; |
591 | } | |
592 | ||
593 | /******************************************************************** | |
594 | * set interface number to interface | |
595 | */ | |
596 | int usb_set_interface(struct usb_device *dev, int interface, int alternate) | |
597 | { | |
8f8bd565 | 598 | struct usb_interface *if_face = NULL; |
affae2bf WD |
599 | int ret, i; |
600 | ||
8f8bd565 TR |
601 | for (i = 0; i < dev->config.desc.bNumInterfaces; i++) { |
602 | if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) { | |
affae2bf WD |
603 | if_face = &dev->config.if_desc[i]; |
604 | break; | |
605 | } | |
606 | } | |
607 | if (!if_face) { | |
608 | printf("selecting invalid interface %d", interface); | |
5a80b344 | 609 | return -EINVAL; |
affae2bf | 610 | } |
7455af41 BS |
611 | /* |
612 | * We should return now for devices with only one alternate setting. | |
6f5794a6 RB |
613 | * According to 9.4.10 of the Universal Serial Bus Specification |
614 | * Revision 2.0 such devices can return with a STALL. This results in | |
615 | * some USB sticks timeouting during initialization and then being | |
616 | * unusable in U-Boot. | |
7455af41 BS |
617 | */ |
618 | if (if_face->num_altsetting == 1) | |
619 | return 0; | |
affae2bf | 620 | |
6f5794a6 RB |
621 | ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
622 | USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, | |
623 | alternate, interface, NULL, 0, | |
624 | USB_CNTL_TIMEOUT * 5); | |
625 | if (ret < 0) | |
affae2bf WD |
626 | return ret; |
627 | ||
affae2bf WD |
628 | return 0; |
629 | } | |
630 | ||
631 | /******************************************************************** | |
632 | * set configuration number to configuration | |
633 | */ | |
c08b1b26 | 634 | static int usb_set_configuration(struct usb_device *dev, int configuration) |
affae2bf WD |
635 | { |
636 | int res; | |
ceb4972a | 637 | debug("set configuration %d\n", configuration); |
affae2bf | 638 | /* set setup command */ |
6f5794a6 RB |
639 | res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), |
640 | USB_REQ_SET_CONFIGURATION, 0, | |
641 | configuration, 0, | |
642 | NULL, 0, USB_CNTL_TIMEOUT); | |
643 | if (res == 0) { | |
affae2bf WD |
644 | dev->toggle[0] = 0; |
645 | dev->toggle[1] = 0; | |
646 | return 0; | |
6f5794a6 | 647 | } else |
5a80b344 | 648 | return -EIO; |
affae2bf WD |
649 | } |
650 | ||
651 | /******************************************************************** | |
652 | * set protocol to protocol | |
653 | */ | |
654 | int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol) | |
655 | { | |
656 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), | |
657 | USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
658 | protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT); | |
659 | } | |
660 | ||
661 | /******************************************************************** | |
662 | * set idle | |
663 | */ | |
664 | int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id) | |
665 | { | |
666 | return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), | |
667 | USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
668 | (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT); | |
669 | } | |
670 | ||
671 | /******************************************************************** | |
672 | * get report | |
673 | */ | |
6f5794a6 RB |
674 | int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, |
675 | unsigned char id, void *buf, int size) | |
affae2bf WD |
676 | { |
677 | return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), | |
6f5794a6 RB |
678 | USB_REQ_GET_REPORT, |
679 | USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, | |
680 | (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); | |
affae2bf WD |
681 | } |
682 | ||
683 | /******************************************************************** | |
684 | * get class descriptor | |
685 | */ | |
686 | int usb_get_class_descriptor(struct usb_device *dev, int ifnum, | |
687 | unsigned char type, unsigned char id, void *buf, int size) | |
688 | { | |
689 | return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), | |
690 | USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN, | |
691 | (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); | |
692 | } | |
693 | ||
694 | /******************************************************************** | |
695 | * get string index in buffer | |
696 | */ | |
c08b1b26 | 697 | static int usb_get_string(struct usb_device *dev, unsigned short langid, |
6f5794a6 | 698 | unsigned char index, void *buf, int size) |
affae2bf | 699 | { |
9c998aa8 WD |
700 | int i; |
701 | int result; | |
702 | ||
703 | for (i = 0; i < 3; ++i) { | |
704 | /* some devices are flaky */ | |
705 | result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), | |
706 | USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, | |
095b8a37 | 707 | (USB_DT_STRING << 8) + index, langid, buf, size, |
9c998aa8 WD |
708 | USB_CNTL_TIMEOUT); |
709 | ||
710 | if (result > 0) | |
711 | break; | |
095b8a37 WD |
712 | } |
713 | ||
9c998aa8 WD |
714 | return result; |
715 | } | |
716 | ||
717 | ||
718 | static void usb_try_string_workarounds(unsigned char *buf, int *length) | |
719 | { | |
720 | int newlength, oldlength = *length; | |
721 | ||
722 | for (newlength = 2; newlength + 1 < oldlength; newlength += 2) | |
723 | if (!isprint(buf[newlength]) || buf[newlength + 1]) | |
724 | break; | |
725 | ||
726 | if (newlength > 2) { | |
727 | buf[0] = newlength; | |
728 | *length = newlength; | |
729 | } | |
affae2bf WD |
730 | } |
731 | ||
9c998aa8 WD |
732 | |
733 | static int usb_string_sub(struct usb_device *dev, unsigned int langid, | |
734 | unsigned int index, unsigned char *buf) | |
735 | { | |
736 | int rc; | |
737 | ||
738 | /* Try to read the string descriptor by asking for the maximum | |
739 | * possible number of bytes */ | |
740 | rc = usb_get_string(dev, langid, index, buf, 255); | |
741 | ||
742 | /* If that failed try to read the descriptor length, then | |
743 | * ask for just that many bytes */ | |
744 | if (rc < 2) { | |
745 | rc = usb_get_string(dev, langid, index, buf, 2); | |
746 | if (rc == 2) | |
747 | rc = usb_get_string(dev, langid, index, buf, buf[0]); | |
748 | } | |
749 | ||
750 | if (rc >= 2) { | |
751 | if (!buf[0] && !buf[1]) | |
752 | usb_try_string_workarounds(buf, &rc); | |
753 | ||
754 | /* There might be extra junk at the end of the descriptor */ | |
755 | if (buf[0] < rc) | |
756 | rc = buf[0]; | |
757 | ||
758 | rc = rc - (rc & 1); /* force a multiple of two */ | |
759 | } | |
760 | ||
761 | if (rc < 2) | |
5a80b344 | 762 | rc = -EINVAL; |
9c998aa8 WD |
763 | |
764 | return rc; | |
765 | } | |
766 | ||
767 | ||
affae2bf WD |
768 | /******************************************************************** |
769 | * usb_string: | |
770 | * Get string index and translate it to ascii. | |
771 | * returns string length (> 0) or error (< 0) | |
772 | */ | |
773 | int usb_string(struct usb_device *dev, int index, char *buf, size_t size) | |
774 | { | |
f5766139 | 775 | ALLOC_CACHE_ALIGN_BUFFER(unsigned char, mybuf, USB_BUFSIZ); |
affae2bf WD |
776 | unsigned char *tbuf; |
777 | int err; | |
778 | unsigned int u, idx; | |
779 | ||
780 | if (size <= 0 || !buf || !index) | |
5a80b344 | 781 | return -EINVAL; |
affae2bf | 782 | buf[0] = 0; |
d0ff51ba | 783 | tbuf = &mybuf[0]; |
affae2bf WD |
784 | |
785 | /* get langid for strings if it's not yet known */ | |
786 | if (!dev->have_langid) { | |
9c998aa8 | 787 | err = usb_string_sub(dev, 0, 0, tbuf); |
affae2bf | 788 | if (err < 0) { |
ceb4972a VG |
789 | debug("error getting string descriptor 0 " \ |
790 | "(error=%lx)\n", dev->status); | |
5a80b344 | 791 | return -EIO; |
affae2bf | 792 | } else if (tbuf[0] < 4) { |
ceb4972a | 793 | debug("string descriptor 0 too short\n"); |
5a80b344 | 794 | return -EIO; |
affae2bf WD |
795 | } else { |
796 | dev->have_langid = -1; | |
6f5794a6 | 797 | dev->string_langid = tbuf[2] | (tbuf[3] << 8); |
affae2bf | 798 | /* always use the first langid listed */ |
ceb4972a VG |
799 | debug("USB device number %d default " \ |
800 | "language ID 0x%x\n", | |
801 | dev->devnum, dev->string_langid); | |
affae2bf WD |
802 | } |
803 | } | |
cd0a9de6 | 804 | |
9c998aa8 | 805 | err = usb_string_sub(dev, dev->string_langid, index, tbuf); |
affae2bf WD |
806 | if (err < 0) |
807 | return err; | |
9c998aa8 | 808 | |
affae2bf WD |
809 | size--; /* leave room for trailing NULL char in output buffer */ |
810 | for (idx = 0, u = 2; u < err; u += 2) { | |
811 | if (idx >= size) | |
812 | break; | |
813 | if (tbuf[u+1]) /* high byte */ | |
814 | buf[idx++] = '?'; /* non-ASCII character */ | |
815 | else | |
816 | buf[idx++] = tbuf[u]; | |
817 | } | |
818 | buf[idx] = 0; | |
819 | err = idx; | |
820 | return err; | |
821 | } | |
822 | ||
823 | ||
824 | /******************************************************************** | |
825 | * USB device handling: | |
826 | * the USB device are static allocated [USB_MAX_DEVICE]. | |
827 | */ | |
828 | ||
95fbfe42 | 829 | #ifndef CONFIG_DM_USB |
affae2bf WD |
830 | |
831 | /* returns a pointer to the device with the index [index]. | |
832 | * if the device is not assigned (dev->devnum==-1) returns NULL | |
833 | */ | |
6f5794a6 | 834 | struct usb_device *usb_get_dev_index(int index) |
affae2bf | 835 | { |
6f5794a6 | 836 | if (usb_dev[index].devnum == -1) |
affae2bf WD |
837 | return NULL; |
838 | else | |
839 | return &usb_dev[index]; | |
840 | } | |
841 | ||
79b58887 | 842 | int usb_alloc_new_device(struct udevice *controller, struct usb_device **devp) |
affae2bf WD |
843 | { |
844 | int i; | |
ceb4972a | 845 | debug("New Device %d\n", dev_index); |
6f5794a6 RB |
846 | if (dev_index == USB_MAX_DEVICE) { |
847 | printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE); | |
79b58887 | 848 | return -ENOSPC; |
affae2bf | 849 | } |
6f5794a6 RB |
850 | /* default Address is 0, real addresses start with 1 */ |
851 | usb_dev[dev_index].devnum = dev_index + 1; | |
852 | usb_dev[dev_index].maxchild = 0; | |
853 | for (i = 0; i < USB_MAXCHILDREN; i++) | |
854 | usb_dev[dev_index].children[i] = NULL; | |
855 | usb_dev[dev_index].parent = NULL; | |
c7e3b2b5 | 856 | usb_dev[dev_index].controller = controller; |
affae2bf | 857 | dev_index++; |
79b58887 SG |
858 | *devp = &usb_dev[dev_index - 1]; |
859 | ||
860 | return 0; | |
affae2bf WD |
861 | } |
862 | ||
359439d2 MC |
863 | /* |
864 | * Free the newly created device node. | |
865 | * Called in error cases where configuring a newly attached | |
866 | * device fails for some reason. | |
867 | */ | |
79b58887 | 868 | void usb_free_device(struct udevice *controller) |
359439d2 MC |
869 | { |
870 | dev_index--; | |
ceb4972a | 871 | debug("Freeing device node: %d\n", dev_index); |
359439d2 MC |
872 | memset(&usb_dev[dev_index], 0, sizeof(struct usb_device)); |
873 | usb_dev[dev_index].devnum = -1; | |
874 | } | |
affae2bf | 875 | |
5853e133 VG |
876 | /* |
877 | * XHCI issues Enable Slot command and thereafter | |
878 | * allocates device contexts. Provide a weak alias | |
879 | * function for the purpose, so that XHCI overrides it | |
880 | * and EHCI/OHCI just work out of the box. | |
881 | */ | |
882 | __weak int usb_alloc_device(struct usb_device *udev) | |
883 | { | |
884 | return 0; | |
885 | } | |
95fbfe42 | 886 | #endif /* !CONFIG_DM_USB */ |
862e75c0 | 887 | |
95fbfe42 | 888 | #ifndef CONFIG_DM_USB |
862e75c0 SG |
889 | int usb_legacy_port_reset(struct usb_device *hub, int portnr) |
890 | { | |
891 | if (hub) { | |
892 | unsigned short portstatus; | |
893 | int err; | |
894 | ||
895 | /* reset the port for the second time */ | |
896 | err = legacy_hub_port_reset(hub, portnr - 1, &portstatus); | |
897 | if (err < 0) { | |
898 | printf("\n Couldn't reset port %i\n", portnr); | |
899 | return err; | |
900 | } | |
901 | } else { | |
902 | usb_reset_root_port(); | |
903 | } | |
904 | ||
905 | return 0; | |
906 | } | |
95fbfe42 | 907 | #endif |
862e75c0 | 908 | |
0ed27905 | 909 | static int get_descriptor_len(struct usb_device *dev, int len, int expect_len) |
affae2bf | 910 | { |
128fcac0 | 911 | __maybe_unused struct usb_device_descriptor *desc; |
f5766139 | 912 | ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ); |
0ed27905 SG |
913 | int err; |
914 | ||
915 | desc = (struct usb_device_descriptor *)tmpbuf; | |
916 | ||
917 | err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, len); | |
918 | if (err < expect_len) { | |
919 | if (err < 0) { | |
920 | printf("unable to get device descriptor (error=%d)\n", | |
921 | err); | |
922 | return err; | |
923 | } else { | |
924 | printf("USB device descriptor short read (expected %i, got %i)\n", | |
925 | expect_len, err); | |
926 | return -EIO; | |
927 | } | |
928 | } | |
929 | memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor)); | |
930 | ||
931 | return 0; | |
932 | } | |
933 | ||
934 | static int usb_setup_descriptor(struct usb_device *dev, bool do_read) | |
935 | { | |
936 | __maybe_unused struct usb_device_descriptor *desc; | |
affae2bf | 937 | |
53d8aa0f SG |
938 | /* |
939 | * This is a Windows scheme of initialization sequence, with double | |
48867208 | 940 | * reset of the device (Linux uses the same sequence) |
c9e8436b RB |
941 | * Some equipment is said to work only with such init sequence; this |
942 | * patch is based on the work by Alan Stern: | |
de39f8c1 MT |
943 | * http://sourceforge.net/mailarchive/forum.php? |
944 | * thread_id=5729457&forum_id=5398 | |
9c998aa8 | 945 | */ |
9c998aa8 | 946 | |
53d8aa0f SG |
947 | /* |
948 | * send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is | |
9c998aa8 WD |
949 | * only 18 bytes long, this will terminate with a short packet. But if |
950 | * the maxpacket size is 8 or 16 the device may be waiting to transmit | |
2b338ef4 HG |
951 | * some more, or keeps on retransmitting the 8 byte header. |
952 | */ | |
9c998aa8 | 953 | |
2b338ef4 HG |
954 | if (dev->speed == USB_SPEED_LOW) { |
955 | dev->descriptor.bMaxPacketSize0 = 8; | |
956 | dev->maxpacketsize = PACKET_SIZE_8; | |
957 | } else { | |
958 | dev->descriptor.bMaxPacketSize0 = 64; | |
959 | dev->maxpacketsize = PACKET_SIZE_64; | |
960 | } | |
961 | dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0; | |
962 | dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; | |
48867208 | 963 | |
128fcac0 SG |
964 | if (do_read) { |
965 | int err; | |
862e75c0 | 966 | |
128fcac0 SG |
967 | /* |
968 | * Validate we've received only at least 8 bytes, not that we've | |
969 | * received the entire descriptor. The reasoning is: | |
970 | * - The code only uses fields in the first 8 bytes, so that's all we | |
971 | * need to have fetched at this stage. | |
972 | * - The smallest maxpacket size is 8 bytes. Before we know the actual | |
973 | * maxpacket the device uses, the USB controller may only accept a | |
974 | * single packet. Consequently we are only guaranteed to receive 1 | |
975 | * packet (at least 8 bytes) even in a non-error case. | |
976 | * | |
977 | * At least the DWC2 controller needs to be programmed with the number | |
978 | * of packets in addition to the number of bytes. A request for 64 | |
979 | * bytes of data with the maxpacket guessed as 64 (above) yields a | |
980 | * request for 1 packet. | |
981 | */ | |
0ed27905 SG |
982 | err = get_descriptor_len(dev, 64, 8); |
983 | if (err) | |
984 | return err; | |
9c998aa8 | 985 | } |
48867208 | 986 | |
de39f8c1 | 987 | dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0; |
affae2bf WD |
988 | dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; |
989 | switch (dev->descriptor.bMaxPacketSize0) { | |
de39f8c1 MT |
990 | case 8: |
991 | dev->maxpacketsize = PACKET_SIZE_8; | |
992 | break; | |
993 | case 16: | |
994 | dev->maxpacketsize = PACKET_SIZE_16; | |
995 | break; | |
996 | case 32: | |
997 | dev->maxpacketsize = PACKET_SIZE_32; | |
998 | break; | |
999 | case 64: | |
1000 | dev->maxpacketsize = PACKET_SIZE_64; | |
1001 | break; | |
04ee6ee2 PK |
1002 | default: |
1003 | printf("usb_new_device: invalid max packet size\n"); | |
1004 | return -EIO; | |
affae2bf | 1005 | } |
128fcac0 SG |
1006 | |
1007 | return 0; | |
1008 | } | |
1009 | ||
91398f98 SG |
1010 | static int usb_prepare_device(struct usb_device *dev, int addr, bool do_read, |
1011 | struct usb_device *parent, int portnr) | |
128fcac0 | 1012 | { |
91398f98 | 1013 | int err; |
128fcac0 SG |
1014 | |
1015 | /* | |
1016 | * Allocate usb 3.0 device context. | |
1017 | * USB 3.0 (xHCI) protocol tries to allocate device slot | |
1018 | * and related data structures first. This call does that. | |
1019 | * Refer to sec 4.3.2 in xHCI spec rev1.0 | |
1020 | */ | |
91398f98 SG |
1021 | err = usb_alloc_device(dev); |
1022 | if (err) { | |
128fcac0 | 1023 | printf("Cannot allocate device context to get SLOT_ID\n"); |
91398f98 | 1024 | return err; |
128fcac0 | 1025 | } |
128fcac0 SG |
1026 | err = usb_setup_descriptor(dev, do_read); |
1027 | if (err) | |
1028 | return err; | |
91398f98 | 1029 | err = usb_legacy_port_reset(parent, portnr); |
128fcac0 SG |
1030 | if (err) |
1031 | return err; | |
1032 | ||
affae2bf WD |
1033 | dev->devnum = addr; |
1034 | ||
1035 | err = usb_set_address(dev); /* set address */ | |
1036 | ||
1037 | if (err < 0) { | |
6f5794a6 RB |
1038 | printf("\n USB device not accepting new address " \ |
1039 | "(error=%lX)\n", dev->status); | |
91398f98 | 1040 | return err; |
affae2bf WD |
1041 | } |
1042 | ||
5b84dd67 | 1043 | mdelay(10); /* Let the SET_ADDRESS settle */ |
affae2bf | 1044 | |
91398f98 SG |
1045 | return 0; |
1046 | } | |
1047 | ||
95fbfe42 | 1048 | int usb_select_config(struct usb_device *dev) |
91398f98 | 1049 | { |
91398f98 | 1050 | ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ); |
0ed27905 | 1051 | int err; |
91398f98 | 1052 | |
0ed27905 SG |
1053 | err = get_descriptor_len(dev, USB_DT_DEVICE_SIZE, USB_DT_DEVICE_SIZE); |
1054 | if (err) | |
1055 | return err; | |
affae2bf | 1056 | |
affae2bf | 1057 | /* correct le values */ |
c918261c CE |
1058 | le16_to_cpus(&dev->descriptor.bcdUSB); |
1059 | le16_to_cpus(&dev->descriptor.idVendor); | |
1060 | le16_to_cpus(&dev->descriptor.idProduct); | |
1061 | le16_to_cpus(&dev->descriptor.bcdDevice); | |
0ed27905 | 1062 | |
affae2bf | 1063 | /* only support for one config for now */ |
8b8d779d VP |
1064 | err = usb_get_configuration_no(dev, tmpbuf, 0); |
1065 | if (err < 0) { | |
1066 | printf("usb_new_device: Cannot read configuration, " \ | |
1067 | "skipping device %04x:%04x\n", | |
1068 | dev->descriptor.idVendor, dev->descriptor.idProduct); | |
0ed27905 | 1069 | return err; |
8b8d779d | 1070 | } |
f5766139 | 1071 | usb_parse_config(dev, tmpbuf, 0); |
affae2bf | 1072 | usb_set_maxpacket(dev); |
0ed27905 SG |
1073 | /* |
1074 | * we set the default configuration here | |
1075 | * This seems premature. If the driver wants a different configuration | |
1076 | * it will need to select itself. | |
1077 | */ | |
1078 | err = usb_set_configuration(dev, dev->config.desc.bConfigurationValue); | |
1079 | if (err < 0) { | |
6f5794a6 RB |
1080 | printf("failed to set default configuration " \ |
1081 | "len %d, status %lX\n", dev->act_len, dev->status); | |
0ed27905 | 1082 | return err; |
affae2bf | 1083 | } |
ceb4972a VG |
1084 | debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", |
1085 | dev->descriptor.iManufacturer, dev->descriptor.iProduct, | |
1086 | dev->descriptor.iSerialNumber); | |
affae2bf WD |
1087 | memset(dev->mf, 0, sizeof(dev->mf)); |
1088 | memset(dev->prod, 0, sizeof(dev->prod)); | |
1089 | memset(dev->serial, 0, sizeof(dev->serial)); | |
1090 | if (dev->descriptor.iManufacturer) | |
6f5794a6 RB |
1091 | usb_string(dev, dev->descriptor.iManufacturer, |
1092 | dev->mf, sizeof(dev->mf)); | |
affae2bf | 1093 | if (dev->descriptor.iProduct) |
6f5794a6 RB |
1094 | usb_string(dev, dev->descriptor.iProduct, |
1095 | dev->prod, sizeof(dev->prod)); | |
affae2bf | 1096 | if (dev->descriptor.iSerialNumber) |
6f5794a6 RB |
1097 | usb_string(dev, dev->descriptor.iSerialNumber, |
1098 | dev->serial, sizeof(dev->serial)); | |
ceb4972a VG |
1099 | debug("Manufacturer %s\n", dev->mf); |
1100 | debug("Product %s\n", dev->prod); | |
1101 | debug("SerialNumber %s\n", dev->serial); | |
0ed27905 SG |
1102 | |
1103 | return 0; | |
1104 | } | |
1105 | ||
95fbfe42 SG |
1106 | int usb_setup_device(struct usb_device *dev, bool do_read, |
1107 | struct usb_device *parent, int portnr) | |
0ed27905 SG |
1108 | { |
1109 | int addr; | |
1110 | int ret; | |
1111 | ||
1112 | /* We still haven't set the Address yet */ | |
1113 | addr = dev->devnum; | |
1114 | dev->devnum = 0; | |
1115 | ||
1116 | ret = usb_prepare_device(dev, addr, do_read, parent, portnr); | |
1117 | if (ret) | |
1118 | return ret; | |
1119 | ret = usb_select_config(dev); | |
1120 | ||
1121 | return ret; | |
1122 | } | |
1123 | ||
95fbfe42 | 1124 | #ifndef CONFIG_DM_USB |
0ed27905 SG |
1125 | /* |
1126 | * By the time we get here, the device has gotten a new device ID | |
1127 | * and is in the default state. We need to identify the thing and | |
1128 | * get the ball rolling.. | |
1129 | * | |
1130 | * Returns 0 for success, != 0 for error. | |
1131 | */ | |
1132 | int usb_new_device(struct usb_device *dev) | |
1133 | { | |
1134 | bool do_read = true; | |
1135 | int err; | |
1136 | ||
1137 | /* | |
1138 | * XHCI needs to issue a Address device command to setup | |
1139 | * proper device context structures, before it can interact | |
1140 | * with the device. So a get_descriptor will fail before any | |
1141 | * of that is done for XHCI unlike EHCI. | |
1142 | */ | |
1143 | #ifdef CONFIG_USB_XHCI | |
1144 | do_read = false; | |
1145 | #endif | |
1146 | err = usb_setup_device(dev, do_read, dev->parent, dev->portnr); | |
1147 | if (err) | |
1148 | return err; | |
1149 | ||
1150 | /* Now probe if the device is a hub */ | |
1151 | err = usb_hub_probe(dev, 0); | |
1152 | if (err < 0) | |
1153 | return err; | |
1154 | ||
affae2bf WD |
1155 | return 0; |
1156 | } | |
95fbfe42 | 1157 | #endif |
affae2bf | 1158 | |
16297cfb | 1159 | __weak |
bba67914 | 1160 | int board_usb_init(int index, enum usb_init_type init) |
16297cfb MZ |
1161 | { |
1162 | return 0; | |
1163 | } | |
db378d78 KVA |
1164 | |
1165 | __weak | |
1166 | int board_usb_cleanup(int index, enum usb_init_type init) | |
1167 | { | |
1168 | return 0; | |
1169 | } | |
95fbfe42 SG |
1170 | |
1171 | bool usb_device_has_child_on_port(struct usb_device *parent, int port) | |
1172 | { | |
1173 | #ifdef CONFIG_DM_USB | |
1174 | return false; | |
1175 | #else | |
1176 | return parent->children[port] != NULL; | |
1177 | #endif | |
1178 | } | |
1179 | ||
affae2bf | 1180 | /* EOF */ |