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