xref: /openbmc/u-boot/common/usb.c (revision 459f1da8)
1 /*
2  * Most of this source has been derived from the Linux USB
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
16  *
17  * SPDX-License-Identifier:	GPL-2.0+
18  */
19 
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>
31 #include <asm/processor.h>
32 #include <linux/compiler.h>
33 #include <linux/ctype.h>
34 #include <asm/byteorder.h>
35 #include <asm/unaligned.h>
36 
37 #include <usb.h>
38 #ifdef CONFIG_4xx
39 #include <asm/4xx_pci.h>
40 #endif
41 
42 #define USB_BUFSIZ	512
43 
44 static struct usb_device usb_dev[USB_MAX_DEVICE];
45 static int dev_index;
46 static int asynch_allowed;
47 
48 char usb_started; /* flag for the started/stopped USB status */
49 
50 #ifndef CONFIG_USB_MAX_CONTROLLER_COUNT
51 #define CONFIG_USB_MAX_CONTROLLER_COUNT 1
52 #endif
53 
54 /***************************************************************************
55  * Init USB Device
56  */
57 int usb_init(void)
58 {
59 	void *ctrl;
60 	struct usb_device *dev;
61 	int i, start_index = 0;
62 
63 	dev_index = 0;
64 	asynch_allowed = 1;
65 	usb_hub_reset();
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 
73 	/* init low_level USB */
74 	for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
75 		/* init low_level USB */
76 		printf("USB%d:   ", i);
77 		if (usb_lowlevel_init(i, &ctrl)) {
78 			puts("lowlevel init failed\n");
79 			continue;
80 		}
81 		/*
82 		 * lowlevel init is OK, now scan the bus for devices
83 		 * i.e. search HUBs and configure them
84 		 */
85 		start_index = dev_index;
86 		printf("scanning bus %d for devices... ", i);
87 		dev = usb_alloc_new_device(ctrl);
88 		/*
89 		 * device 0 is always present
90 		 * (root hub, so let it analyze)
91 		 */
92 		if (dev)
93 			usb_new_device(dev);
94 
95 		if (start_index == dev_index)
96 			puts("No USB Device found\n");
97 		else
98 			printf("%d USB Device(s) found\n",
99 				dev_index - start_index);
100 
101 		usb_started = 1;
102 	}
103 
104 	debug("scan end\n");
105 	/* if we were not able to find at least one working bus, bail out */
106 	if (!usb_started) {
107 		puts("USB error: all controllers failed lowlevel init\n");
108 		return -1;
109 	}
110 
111 	return 0;
112 }
113 
114 /******************************************************************************
115  * Stop USB this stops the LowLevel Part and deregisters USB devices.
116  */
117 int usb_stop(void)
118 {
119 	int i;
120 
121 	if (usb_started) {
122 		asynch_allowed = 1;
123 		usb_started = 0;
124 		usb_hub_reset();
125 
126 		for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) {
127 			if (usb_lowlevel_stop(i))
128 				printf("failed to stop USB controller %d\n", i);
129 		}
130 	}
131 
132 	return 0;
133 }
134 
135 /*
136  * disables the asynch behaviour of the control message. This is used for data
137  * transfers that uses the exclusiv access to the control and bulk messages.
138  * Returns the old value so it can be restored later.
139  */
140 int usb_disable_asynch(int disable)
141 {
142 	int old_value = asynch_allowed;
143 
144 	asynch_allowed = !disable;
145 	return old_value;
146 }
147 
148 
149 /*-------------------------------------------------------------------
150  * Message wrappers.
151  *
152  */
153 
154 /*
155  * submits an Interrupt Message
156  */
157 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
158 			void *buffer, int transfer_len, int interval)
159 {
160 	return submit_int_msg(dev, pipe, buffer, transfer_len, interval);
161 }
162 
163 /*
164  * submits a control message and waits for comletion (at least timeout * 1ms)
165  * If timeout is 0, we don't wait for completion (used as example to set and
166  * clear keyboards LEDs). For data transfers, (storage transfers) we don't
167  * allow control messages with 0 timeout, by previousely resetting the flag
168  * asynch_allowed (usb_disable_asynch(1)).
169  * returns the transfered length if OK or -1 if error. The transfered length
170  * and the current status are stored in the dev->act_len and dev->status.
171  */
172 int usb_control_msg(struct usb_device *dev, unsigned int pipe,
173 			unsigned char request, unsigned char requesttype,
174 			unsigned short value, unsigned short index,
175 			void *data, unsigned short size, int timeout)
176 {
177 	ALLOC_CACHE_ALIGN_BUFFER(struct devrequest, setup_packet, 1);
178 
179 	if ((timeout == 0) && (!asynch_allowed)) {
180 		/* request for a asynch control pipe is not allowed */
181 		return -1;
182 	}
183 
184 	/* set setup command */
185 	setup_packet->requesttype = requesttype;
186 	setup_packet->request = request;
187 	setup_packet->value = cpu_to_le16(value);
188 	setup_packet->index = cpu_to_le16(index);
189 	setup_packet->length = cpu_to_le16(size);
190 	debug("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \
191 	      "value 0x%X index 0x%X length 0x%X\n",
192 	      request, requesttype, value, index, size);
193 	dev->status = USB_ST_NOT_PROC; /*not yet processed */
194 
195 	if (submit_control_msg(dev, pipe, data, size, setup_packet) < 0)
196 		return -1;
197 	if (timeout == 0)
198 		return (int)size;
199 
200 	/*
201 	 * Wait for status to update until timeout expires, USB driver
202 	 * interrupt handler may set the status when the USB operation has
203 	 * been completed.
204 	 */
205 	while (timeout--) {
206 		if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
207 			break;
208 		mdelay(1);
209 	}
210 	if (dev->status)
211 		return -1;
212 
213 	return dev->act_len;
214 
215 }
216 
217 /*-------------------------------------------------------------------
218  * submits bulk message, and waits for completion. returns 0 if Ok or
219  * -1 if Error.
220  * synchronous behavior
221  */
222 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
223 			void *data, int len, int *actual_length, int timeout)
224 {
225 	if (len < 0)
226 		return -1;
227 	dev->status = USB_ST_NOT_PROC; /*not yet processed */
228 	if (submit_bulk_msg(dev, pipe, data, len) < 0)
229 		return -1;
230 	while (timeout--) {
231 		if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
232 			break;
233 		mdelay(1);
234 	}
235 	*actual_length = dev->act_len;
236 	if (dev->status == 0)
237 		return 0;
238 	else
239 		return -1;
240 }
241 
242 
243 /*-------------------------------------------------------------------
244  * Max Packet stuff
245  */
246 
247 /*
248  * returns the max packet size, depending on the pipe direction and
249  * the configurations values
250  */
251 int usb_maxpacket(struct usb_device *dev, unsigned long pipe)
252 {
253 	/* direction is out -> use emaxpacket out */
254 	if ((pipe & USB_DIR_IN) == 0)
255 		return dev->epmaxpacketout[((pipe>>15) & 0xf)];
256 	else
257 		return dev->epmaxpacketin[((pipe>>15) & 0xf)];
258 }
259 
260 /*
261  * The routine usb_set_maxpacket_ep() is extracted from the loop of routine
262  * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine
263  * when it is inlined in 1 single routine. What happens is that the register r3
264  * is used as loop-count 'i', but gets overwritten later on.
265  * This is clearly a compiler bug, but it is easier to workaround it here than
266  * to update the compiler (Occurs with at least several GCC 4.{1,2},x
267  * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM)
268  *
269  * NOTE: Similar behaviour was observed with GCC4.6 on ARMv5.
270  */
271 static void noinline
272 usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx)
273 {
274 	int b;
275 	struct usb_endpoint_descriptor *ep;
276 	u16 ep_wMaxPacketSize;
277 
278 	ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx];
279 
280 	b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
281 	ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize);
282 
283 	if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
284 						USB_ENDPOINT_XFER_CONTROL) {
285 		/* Control => bidirectional */
286 		dev->epmaxpacketout[b] = ep_wMaxPacketSize;
287 		dev->epmaxpacketin[b] = ep_wMaxPacketSize;
288 		debug("##Control EP epmaxpacketout/in[%d] = %d\n",
289 		      b, dev->epmaxpacketin[b]);
290 	} else {
291 		if ((ep->bEndpointAddress & 0x80) == 0) {
292 			/* OUT Endpoint */
293 			if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) {
294 				dev->epmaxpacketout[b] = ep_wMaxPacketSize;
295 				debug("##EP epmaxpacketout[%d] = %d\n",
296 				      b, dev->epmaxpacketout[b]);
297 			}
298 		} else {
299 			/* IN Endpoint */
300 			if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) {
301 				dev->epmaxpacketin[b] = ep_wMaxPacketSize;
302 				debug("##EP epmaxpacketin[%d] = %d\n",
303 				      b, dev->epmaxpacketin[b]);
304 			}
305 		} /* if out */
306 	} /* if control */
307 }
308 
309 /*
310  * set the max packed value of all endpoints in the given configuration
311  */
312 static int usb_set_maxpacket(struct usb_device *dev)
313 {
314 	int i, ii;
315 
316 	for (i = 0; i < dev->config.desc.bNumInterfaces; i++)
317 		for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++)
318 			usb_set_maxpacket_ep(dev, i, ii);
319 
320 	return 0;
321 }
322 
323 /*******************************************************************************
324  * Parse the config, located in buffer, and fills the dev->config structure.
325  * Note that all little/big endian swapping are done automatically.
326  * (wTotalLength has already been swapped and sanitized when it was read.)
327  */
328 static int usb_parse_config(struct usb_device *dev,
329 			unsigned char *buffer, int cfgno)
330 {
331 	struct usb_descriptor_header *head;
332 	int index, ifno, epno, curr_if_num;
333 	u16 ep_wMaxPacketSize;
334 	struct usb_interface *if_desc = NULL;
335 
336 	ifno = -1;
337 	epno = -1;
338 	curr_if_num = -1;
339 
340 	dev->configno = cfgno;
341 	head = (struct usb_descriptor_header *) &buffer[0];
342 	if (head->bDescriptorType != USB_DT_CONFIG) {
343 		printf(" ERROR: NOT USB_CONFIG_DESC %x\n",
344 			head->bDescriptorType);
345 		return -1;
346 	}
347 	if (head->bLength != USB_DT_CONFIG_SIZE) {
348 		printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength);
349 		return -1;
350 	}
351 	memcpy(&dev->config, head, USB_DT_CONFIG_SIZE);
352 	dev->config.no_of_if = 0;
353 
354 	index = dev->config.desc.bLength;
355 	/* Ok the first entry must be a configuration entry,
356 	 * now process the others */
357 	head = (struct usb_descriptor_header *) &buffer[index];
358 	while (index + 1 < dev->config.desc.wTotalLength && head->bLength) {
359 		switch (head->bDescriptorType) {
360 		case USB_DT_INTERFACE:
361 			if (head->bLength != USB_DT_INTERFACE_SIZE) {
362 				printf("ERROR: Invalid USB IF length (%d)\n",
363 					head->bLength);
364 				break;
365 			}
366 			if (index + USB_DT_INTERFACE_SIZE >
367 			    dev->config.desc.wTotalLength) {
368 				puts("USB IF descriptor overflowed buffer!\n");
369 				break;
370 			}
371 			if (((struct usb_interface_descriptor *) \
372 			     head)->bInterfaceNumber != curr_if_num) {
373 				/* this is a new interface, copy new desc */
374 				ifno = dev->config.no_of_if;
375 				if (ifno >= USB_MAXINTERFACES) {
376 					puts("Too many USB interfaces!\n");
377 					/* try to go on with what we have */
378 					return 1;
379 				}
380 				if_desc = &dev->config.if_desc[ifno];
381 				dev->config.no_of_if++;
382 				memcpy(if_desc, head,
383 					USB_DT_INTERFACE_SIZE);
384 				if_desc->no_of_ep = 0;
385 				if_desc->num_altsetting = 1;
386 				curr_if_num =
387 				     if_desc->desc.bInterfaceNumber;
388 			} else {
389 				/* found alternate setting for the interface */
390 				if (ifno >= 0) {
391 					if_desc = &dev->config.if_desc[ifno];
392 					if_desc->num_altsetting++;
393 				}
394 			}
395 			break;
396 		case USB_DT_ENDPOINT:
397 			if (head->bLength != USB_DT_ENDPOINT_SIZE) {
398 				printf("ERROR: Invalid USB EP length (%d)\n",
399 					head->bLength);
400 				break;
401 			}
402 			if (index + USB_DT_ENDPOINT_SIZE >
403 			    dev->config.desc.wTotalLength) {
404 				puts("USB EP descriptor overflowed buffer!\n");
405 				break;
406 			}
407 			if (ifno < 0) {
408 				puts("Endpoint descriptor out of order!\n");
409 				break;
410 			}
411 			epno = dev->config.if_desc[ifno].no_of_ep;
412 			if_desc = &dev->config.if_desc[ifno];
413 			if (epno > USB_MAXENDPOINTS) {
414 				printf("Interface %d has too many endpoints!\n",
415 					if_desc->desc.bInterfaceNumber);
416 				return 1;
417 			}
418 			/* found an endpoint */
419 			if_desc->no_of_ep++;
420 			memcpy(&if_desc->ep_desc[epno], head,
421 				USB_DT_ENDPOINT_SIZE);
422 			ep_wMaxPacketSize = get_unaligned(&dev->config.\
423 							if_desc[ifno].\
424 							ep_desc[epno].\
425 							wMaxPacketSize);
426 			put_unaligned(le16_to_cpu(ep_wMaxPacketSize),
427 					&dev->config.\
428 					if_desc[ifno].\
429 					ep_desc[epno].\
430 					wMaxPacketSize);
431 			debug("if %d, ep %d\n", ifno, epno);
432 			break;
433 		case USB_DT_SS_ENDPOINT_COMP:
434 			if (head->bLength != USB_DT_SS_EP_COMP_SIZE) {
435 				printf("ERROR: Invalid USB EPC length (%d)\n",
436 					head->bLength);
437 				break;
438 			}
439 			if (index + USB_DT_SS_EP_COMP_SIZE >
440 			    dev->config.desc.wTotalLength) {
441 				puts("USB EPC descriptor overflowed buffer!\n");
442 				break;
443 			}
444 			if (ifno < 0 || epno < 0) {
445 				puts("EPC descriptor out of order!\n");
446 				break;
447 			}
448 			if_desc = &dev->config.if_desc[ifno];
449 			memcpy(&if_desc->ss_ep_comp_desc[epno], head,
450 				USB_DT_SS_EP_COMP_SIZE);
451 			break;
452 		default:
453 			if (head->bLength == 0)
454 				return 1;
455 
456 			debug("unknown Description Type : %x\n",
457 			      head->bDescriptorType);
458 
459 #ifdef DEBUG
460 			{
461 				unsigned char *ch = (unsigned char *)head;
462 				int i;
463 
464 				for (i = 0; i < head->bLength; i++)
465 					debug("%02X ", *ch++);
466 				debug("\n\n\n");
467 			}
468 #endif
469 			break;
470 		}
471 		index += head->bLength;
472 		head = (struct usb_descriptor_header *)&buffer[index];
473 	}
474 	return 1;
475 }
476 
477 /***********************************************************************
478  * Clears an endpoint
479  * endp: endpoint number in bits 0-3;
480  * direction flag in bit 7 (1 = IN, 0 = OUT)
481  */
482 int usb_clear_halt(struct usb_device *dev, int pipe)
483 {
484 	int result;
485 	int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
486 
487 	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
488 				 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0,
489 				 endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
490 
491 	/* don't clear if failed */
492 	if (result < 0)
493 		return result;
494 
495 	/*
496 	 * NOTE: we do not get status and verify reset was successful
497 	 * as some devices are reported to lock up upon this check..
498 	 */
499 
500 	usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
501 
502 	/* toggle is reset on clear */
503 	usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
504 	return 0;
505 }
506 
507 
508 /**********************************************************************
509  * get_descriptor type
510  */
511 static int usb_get_descriptor(struct usb_device *dev, unsigned char type,
512 			unsigned char index, void *buf, int size)
513 {
514 	int res;
515 	res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
516 			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
517 			(type << 8) + index, 0,
518 			buf, size, USB_CNTL_TIMEOUT);
519 	return res;
520 }
521 
522 /**********************************************************************
523  * gets configuration cfgno and store it in the buffer
524  */
525 int usb_get_configuration_no(struct usb_device *dev,
526 			     unsigned char *buffer, int cfgno)
527 {
528 	int result;
529 	unsigned int length;
530 	struct usb_config_descriptor *config;
531 
532 	config = (struct usb_config_descriptor *)&buffer[0];
533 	result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9);
534 	if (result < 9) {
535 		if (result < 0)
536 			printf("unable to get descriptor, error %lX\n",
537 				dev->status);
538 		else
539 			printf("config descriptor too short " \
540 				"(expected %i, got %i)\n", 9, result);
541 		return -1;
542 	}
543 	length = le16_to_cpu(config->wTotalLength);
544 
545 	if (length > USB_BUFSIZ) {
546 		printf("%s: failed to get descriptor - too long: %d\n",
547 			__func__, length);
548 		return -1;
549 	}
550 
551 	result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length);
552 	debug("get_conf_no %d Result %d, wLength %d\n", cfgno, result, length);
553 	config->wTotalLength = length; /* validated, with CPU byte order */
554 
555 	return result;
556 }
557 
558 /********************************************************************
559  * set address of a device to the value in dev->devnum.
560  * This can only be done by addressing the device via the default address (0)
561  */
562 static int usb_set_address(struct usb_device *dev)
563 {
564 	int res;
565 
566 	debug("set address %d\n", dev->devnum);
567 	res = usb_control_msg(dev, usb_snddefctrl(dev),
568 				USB_REQ_SET_ADDRESS, 0,
569 				(dev->devnum), 0,
570 				NULL, 0, USB_CNTL_TIMEOUT);
571 	return res;
572 }
573 
574 /********************************************************************
575  * set interface number to interface
576  */
577 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
578 {
579 	struct usb_interface *if_face = NULL;
580 	int ret, i;
581 
582 	for (i = 0; i < dev->config.desc.bNumInterfaces; i++) {
583 		if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) {
584 			if_face = &dev->config.if_desc[i];
585 			break;
586 		}
587 	}
588 	if (!if_face) {
589 		printf("selecting invalid interface %d", interface);
590 		return -1;
591 	}
592 	/*
593 	 * We should return now for devices with only one alternate setting.
594 	 * According to 9.4.10 of the Universal Serial Bus Specification
595 	 * Revision 2.0 such devices can return with a STALL. This results in
596 	 * some USB sticks timeouting during initialization and then being
597 	 * unusable in U-Boot.
598 	 */
599 	if (if_face->num_altsetting == 1)
600 		return 0;
601 
602 	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
603 				USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,
604 				alternate, interface, NULL, 0,
605 				USB_CNTL_TIMEOUT * 5);
606 	if (ret < 0)
607 		return ret;
608 
609 	return 0;
610 }
611 
612 /********************************************************************
613  * set configuration number to configuration
614  */
615 static int usb_set_configuration(struct usb_device *dev, int configuration)
616 {
617 	int res;
618 	debug("set configuration %d\n", configuration);
619 	/* set setup command */
620 	res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
621 				USB_REQ_SET_CONFIGURATION, 0,
622 				configuration, 0,
623 				NULL, 0, USB_CNTL_TIMEOUT);
624 	if (res == 0) {
625 		dev->toggle[0] = 0;
626 		dev->toggle[1] = 0;
627 		return 0;
628 	} else
629 		return -1;
630 }
631 
632 /********************************************************************
633  * set protocol to protocol
634  */
635 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
636 {
637 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
638 		USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
639 		protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
640 }
641 
642 /********************************************************************
643  * set idle
644  */
645 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
646 {
647 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
648 		USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
649 		(duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
650 }
651 
652 /********************************************************************
653  * get report
654  */
655 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type,
656 		   unsigned char id, void *buf, int size)
657 {
658 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
659 			USB_REQ_GET_REPORT,
660 			USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
661 			(type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
662 }
663 
664 /********************************************************************
665  * get class descriptor
666  */
667 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
668 		unsigned char type, unsigned char id, void *buf, int size)
669 {
670 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
671 		USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
672 		(type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
673 }
674 
675 /********************************************************************
676  * get string index in buffer
677  */
678 static int usb_get_string(struct usb_device *dev, unsigned short langid,
679 		   unsigned char index, void *buf, int size)
680 {
681 	int i;
682 	int result;
683 
684 	for (i = 0; i < 3; ++i) {
685 		/* some devices are flaky */
686 		result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
687 			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
688 			(USB_DT_STRING << 8) + index, langid, buf, size,
689 			USB_CNTL_TIMEOUT);
690 
691 		if (result > 0)
692 			break;
693 	}
694 
695 	return result;
696 }
697 
698 
699 static void usb_try_string_workarounds(unsigned char *buf, int *length)
700 {
701 	int newlength, oldlength = *length;
702 
703 	for (newlength = 2; newlength + 1 < oldlength; newlength += 2)
704 		if (!isprint(buf[newlength]) || buf[newlength + 1])
705 			break;
706 
707 	if (newlength > 2) {
708 		buf[0] = newlength;
709 		*length = newlength;
710 	}
711 }
712 
713 
714 static int usb_string_sub(struct usb_device *dev, unsigned int langid,
715 		unsigned int index, unsigned char *buf)
716 {
717 	int rc;
718 
719 	/* Try to read the string descriptor by asking for the maximum
720 	 * possible number of bytes */
721 	rc = usb_get_string(dev, langid, index, buf, 255);
722 
723 	/* If that failed try to read the descriptor length, then
724 	 * ask for just that many bytes */
725 	if (rc < 2) {
726 		rc = usb_get_string(dev, langid, index, buf, 2);
727 		if (rc == 2)
728 			rc = usb_get_string(dev, langid, index, buf, buf[0]);
729 	}
730 
731 	if (rc >= 2) {
732 		if (!buf[0] && !buf[1])
733 			usb_try_string_workarounds(buf, &rc);
734 
735 		/* There might be extra junk at the end of the descriptor */
736 		if (buf[0] < rc)
737 			rc = buf[0];
738 
739 		rc = rc - (rc & 1); /* force a multiple of two */
740 	}
741 
742 	if (rc < 2)
743 		rc = -1;
744 
745 	return rc;
746 }
747 
748 
749 /********************************************************************
750  * usb_string:
751  * Get string index and translate it to ascii.
752  * returns string length (> 0) or error (< 0)
753  */
754 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
755 {
756 	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, mybuf, USB_BUFSIZ);
757 	unsigned char *tbuf;
758 	int err;
759 	unsigned int u, idx;
760 
761 	if (size <= 0 || !buf || !index)
762 		return -1;
763 	buf[0] = 0;
764 	tbuf = &mybuf[0];
765 
766 	/* get langid for strings if it's not yet known */
767 	if (!dev->have_langid) {
768 		err = usb_string_sub(dev, 0, 0, tbuf);
769 		if (err < 0) {
770 			debug("error getting string descriptor 0 " \
771 			      "(error=%lx)\n", dev->status);
772 			return -1;
773 		} else if (tbuf[0] < 4) {
774 			debug("string descriptor 0 too short\n");
775 			return -1;
776 		} else {
777 			dev->have_langid = -1;
778 			dev->string_langid = tbuf[2] | (tbuf[3] << 8);
779 				/* always use the first langid listed */
780 			debug("USB device number %d default " \
781 			      "language ID 0x%x\n",
782 			      dev->devnum, dev->string_langid);
783 		}
784 	}
785 
786 	err = usb_string_sub(dev, dev->string_langid, index, tbuf);
787 	if (err < 0)
788 		return err;
789 
790 	size--;		/* leave room for trailing NULL char in output buffer */
791 	for (idx = 0, u = 2; u < err; u += 2) {
792 		if (idx >= size)
793 			break;
794 		if (tbuf[u+1])			/* high byte */
795 			buf[idx++] = '?';  /* non-ASCII character */
796 		else
797 			buf[idx++] = tbuf[u];
798 	}
799 	buf[idx] = 0;
800 	err = idx;
801 	return err;
802 }
803 
804 
805 /********************************************************************
806  * USB device handling:
807  * the USB device are static allocated [USB_MAX_DEVICE].
808  */
809 
810 
811 /* returns a pointer to the device with the index [index].
812  * if the device is not assigned (dev->devnum==-1) returns NULL
813  */
814 struct usb_device *usb_get_dev_index(int index)
815 {
816 	if (usb_dev[index].devnum == -1)
817 		return NULL;
818 	else
819 		return &usb_dev[index];
820 }
821 
822 /* returns a pointer of a new device structure or NULL, if
823  * no device struct is available
824  */
825 struct usb_device *usb_alloc_new_device(void *controller)
826 {
827 	int i;
828 	debug("New Device %d\n", dev_index);
829 	if (dev_index == USB_MAX_DEVICE) {
830 		printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE);
831 		return NULL;
832 	}
833 	/* default Address is 0, real addresses start with 1 */
834 	usb_dev[dev_index].devnum = dev_index + 1;
835 	usb_dev[dev_index].maxchild = 0;
836 	for (i = 0; i < USB_MAXCHILDREN; i++)
837 		usb_dev[dev_index].children[i] = NULL;
838 	usb_dev[dev_index].parent = NULL;
839 	usb_dev[dev_index].controller = controller;
840 	dev_index++;
841 	return &usb_dev[dev_index - 1];
842 }
843 
844 /*
845  * Free the newly created device node.
846  * Called in error cases where configuring a newly attached
847  * device fails for some reason.
848  */
849 void usb_free_device(void)
850 {
851 	dev_index--;
852 	debug("Freeing device node: %d\n", dev_index);
853 	memset(&usb_dev[dev_index], 0, sizeof(struct usb_device));
854 	usb_dev[dev_index].devnum = -1;
855 }
856 
857 /*
858  * By the time we get here, the device has gotten a new device ID
859  * and is in the default state. We need to identify the thing and
860  * get the ball rolling..
861  *
862  * Returns 0 for success, != 0 for error.
863  */
864 int usb_new_device(struct usb_device *dev)
865 {
866 	int addr, err;
867 	int tmp;
868 	ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ);
869 
870 	/* We still haven't set the Address yet */
871 	addr = dev->devnum;
872 	dev->devnum = 0;
873 
874 #ifdef CONFIG_LEGACY_USB_INIT_SEQ
875 	/* this is the old and known way of initializing devices, it is
876 	 * different than what Windows and Linux are doing. Windows and Linux
877 	 * both retrieve 64 bytes while reading the device descriptor
878 	 * Several USB stick devices report ERR: CTL_TIMEOUT, caused by an
879 	 * invalid header while reading 8 bytes as device descriptor. */
880 	dev->descriptor.bMaxPacketSize0 = 8;	    /* Start off at 8 bytes  */
881 	dev->maxpacketsize = PACKET_SIZE_8;
882 	dev->epmaxpacketin[0] = 8;
883 	dev->epmaxpacketout[0] = 8;
884 
885 	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, tmpbuf, 8);
886 	if (err < 8) {
887 		printf("\n      USB device not responding, " \
888 		       "giving up (status=%lX)\n", dev->status);
889 		return 1;
890 	}
891 	memcpy(&dev->descriptor, tmpbuf, 8);
892 #else
893 	/* This is a Windows scheme of initialization sequence, with double
894 	 * reset of the device (Linux uses the same sequence)
895 	 * Some equipment is said to work only with such init sequence; this
896 	 * patch is based on the work by Alan Stern:
897 	 * http://sourceforge.net/mailarchive/forum.php?
898 	 * thread_id=5729457&forum_id=5398
899 	 */
900 	struct usb_device_descriptor *desc;
901 	int port = -1;
902 	struct usb_device *parent = dev->parent;
903 	unsigned short portstatus;
904 
905 	/* send 64-byte GET-DEVICE-DESCRIPTOR request.  Since the descriptor is
906 	 * only 18 bytes long, this will terminate with a short packet.  But if
907 	 * the maxpacket size is 8 or 16 the device may be waiting to transmit
908 	 * some more, or keeps on retransmitting the 8 byte header. */
909 
910 	desc = (struct usb_device_descriptor *)tmpbuf;
911 	dev->descriptor.bMaxPacketSize0 = 64;	    /* Start off at 64 bytes  */
912 	/* Default to 64 byte max packet size */
913 	dev->maxpacketsize = PACKET_SIZE_64;
914 	dev->epmaxpacketin[0] = 64;
915 	dev->epmaxpacketout[0] = 64;
916 
917 	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64);
918 	if (err < 0) {
919 		debug("usb_new_device: usb_get_descriptor() failed\n");
920 		return 1;
921 	}
922 
923 	dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0;
924 	/*
925 	 * Fetch the device class, driver can use this info
926 	 * to differentiate between HUB and DEVICE.
927 	 */
928 	dev->descriptor.bDeviceClass = desc->bDeviceClass;
929 
930 	/* find the port number we're at */
931 	if (parent) {
932 		int j;
933 
934 		for (j = 0; j < parent->maxchild; j++) {
935 			if (parent->children[j] == dev) {
936 				port = j;
937 				break;
938 			}
939 		}
940 		if (port < 0) {
941 			printf("usb_new_device:cannot locate device's port.\n");
942 			return 1;
943 		}
944 
945 		/* reset the port for the second time */
946 		err = hub_port_reset(dev->parent, port, &portstatus);
947 		if (err < 0) {
948 			printf("\n     Couldn't reset port %i\n", port);
949 			return 1;
950 		}
951 	}
952 #endif
953 
954 	dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0;
955 	dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
956 	switch (dev->descriptor.bMaxPacketSize0) {
957 	case 8:
958 		dev->maxpacketsize  = PACKET_SIZE_8;
959 		break;
960 	case 16:
961 		dev->maxpacketsize = PACKET_SIZE_16;
962 		break;
963 	case 32:
964 		dev->maxpacketsize = PACKET_SIZE_32;
965 		break;
966 	case 64:
967 		dev->maxpacketsize = PACKET_SIZE_64;
968 		break;
969 	}
970 	dev->devnum = addr;
971 
972 	err = usb_set_address(dev); /* set address */
973 
974 	if (err < 0) {
975 		printf("\n      USB device not accepting new address " \
976 			"(error=%lX)\n", dev->status);
977 		return 1;
978 	}
979 
980 	mdelay(10);	/* Let the SET_ADDRESS settle */
981 
982 	tmp = sizeof(dev->descriptor);
983 
984 	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
985 				 tmpbuf, sizeof(dev->descriptor));
986 	if (err < tmp) {
987 		if (err < 0)
988 			printf("unable to get device descriptor (error=%d)\n",
989 			       err);
990 		else
991 			printf("USB device descriptor short read " \
992 				"(expected %i, got %i)\n", tmp, err);
993 		return 1;
994 	}
995 	memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor));
996 	/* correct le values */
997 	le16_to_cpus(&dev->descriptor.bcdUSB);
998 	le16_to_cpus(&dev->descriptor.idVendor);
999 	le16_to_cpus(&dev->descriptor.idProduct);
1000 	le16_to_cpus(&dev->descriptor.bcdDevice);
1001 	/* only support for one config for now */
1002 	err = usb_get_configuration_no(dev, tmpbuf, 0);
1003 	if (err < 0) {
1004 		printf("usb_new_device: Cannot read configuration, " \
1005 		       "skipping device %04x:%04x\n",
1006 		       dev->descriptor.idVendor, dev->descriptor.idProduct);
1007 		return -1;
1008 	}
1009 	usb_parse_config(dev, tmpbuf, 0);
1010 	usb_set_maxpacket(dev);
1011 	/* we set the default configuration here */
1012 	if (usb_set_configuration(dev, dev->config.desc.bConfigurationValue)) {
1013 		printf("failed to set default configuration " \
1014 			"len %d, status %lX\n", dev->act_len, dev->status);
1015 		return -1;
1016 	}
1017 	debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
1018 	      dev->descriptor.iManufacturer, dev->descriptor.iProduct,
1019 	      dev->descriptor.iSerialNumber);
1020 	memset(dev->mf, 0, sizeof(dev->mf));
1021 	memset(dev->prod, 0, sizeof(dev->prod));
1022 	memset(dev->serial, 0, sizeof(dev->serial));
1023 	if (dev->descriptor.iManufacturer)
1024 		usb_string(dev, dev->descriptor.iManufacturer,
1025 			   dev->mf, sizeof(dev->mf));
1026 	if (dev->descriptor.iProduct)
1027 		usb_string(dev, dev->descriptor.iProduct,
1028 			   dev->prod, sizeof(dev->prod));
1029 	if (dev->descriptor.iSerialNumber)
1030 		usb_string(dev, dev->descriptor.iSerialNumber,
1031 			   dev->serial, sizeof(dev->serial));
1032 	debug("Manufacturer %s\n", dev->mf);
1033 	debug("Product      %s\n", dev->prod);
1034 	debug("SerialNumber %s\n", dev->serial);
1035 	/* now prode if the device is a hub */
1036 	usb_hub_probe(dev, 0);
1037 	return 0;
1038 }
1039 
1040 /* EOF */
1041