xref: /openbmc/u-boot/common/usb.c (revision 8bde7f77)
1 /*
2  * (C) Copyright 2001
3  * Denis Peter, MPL AG Switzerland
4  *
5  * Most of this source has been derived from the Linux USB
6  * project.
7  *
8  * See file CREDITS for list of people who contributed to this
9  * project.
10  *
11  * This program is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU General Public License as
13  * published by the Free Software Foundation; either version 2 of
14  * the License, or (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24  * MA 02111-1307 USA
25  *
26  */
27 
28 
29 /*
30  * How it works:
31  *
32  * Since this is a bootloader, the devices will not be automatic
33  * (re)configured on hotplug, but after a restart of the USB the
34  * device should work.
35  *
36  * For each transfer (except "Interrupt") we wait for completion.
37  */
38 #include <common.h>
39 #include <command.h>
40 #include <asm/processor.h>
41 
42 #if (CONFIG_COMMANDS & CFG_CMD_USB)
43 
44 #include <usb.h>
45 #ifdef CONFIG_4xx
46 #include <405gp_pci.h>
47 #endif
48 
49 
50 #undef USB_DEBUG
51 
52 #ifdef	USB_DEBUG
53 #define	USB_PRINTF(fmt,args...)	printf (fmt ,##args)
54 #else
55 #define USB_PRINTF(fmt,args...)
56 #endif
57 
58 static struct usb_device usb_dev[USB_MAX_DEVICE];
59 static int dev_index;
60 static int running;
61 static int asynch_allowed;
62 static struct devrequest setup_packet;
63 
64 /**********************************************************************
65  * some forward declerations...
66  */
67 void usb_scan_devices(void);
68 
69 int usb_hub_probe(struct usb_device *dev, int ifnum);
70 void usb_hub_reset(void);
71 
72 /***********************************************************************
73  * wait_ms
74  */
75 
76 void __inline__ wait_ms(unsigned long ms)
77 {
78 	while(ms-->0)
79 		udelay(1000);
80 }
81 /***************************************************************************
82  * Init USB Device
83  */
84 
85 int usb_init(void)
86 {
87 	int result;
88 
89 	running=0;
90 	dev_index=0;
91 	asynch_allowed=1;
92 	usb_hub_reset();
93 	/* init low_level USB */
94 	printf("USB:   ");
95 	result = usb_lowlevel_init();
96 	/* if lowlevel init is OK, scan the bus for devices i.e. search HUBs and configure them */
97 	if(result==0) {
98 		printf("scanning bus for devices... ");
99 		running=1;
100 		usb_scan_devices();
101 		return 0;
102 	}
103 	else {
104 		printf("Error, couldn't init Lowlevel part\n");
105 		return -1;
106 	}
107 }
108 
109 /******************************************************************************
110  * Stop USB this stops the LowLevel Part and deregisters USB devices.
111  */
112 int usb_stop(void)
113 {
114 	asynch_allowed=1;
115 	usb_hub_reset();
116 	return usb_lowlevel_stop();
117 }
118 
119 /*
120  * disables the asynch behaviour of the control message. This is used for data
121  * transfers that uses the exclusiv access to the control and bulk messages.
122  */
123 void usb_disable_asynch(int disable)
124 {
125 	asynch_allowed=!disable;
126 }
127 
128 
129 /*-------------------------------------------------------------------
130  * Message wrappers.
131  *
132  */
133 
134 /*
135  * submits an Interrupt Message
136  */
137 int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe,
138 			void *buffer,int transfer_len, int interval)
139 {
140 	return submit_int_msg(dev,pipe,buffer,transfer_len,interval);
141 }
142 
143 /*
144  * submits a control message and waits for comletion (at least timeout * 1ms)
145  * If timeout is 0, we don't wait for completion (used as example to set and
146  * clear keyboards LEDs). For data transfers, (storage transfers) we don't
147  * allow control messages with 0 timeout, by previousely resetting the flag
148  * asynch_allowed (usb_disable_asynch(1)).
149  * returns the transfered length if OK or -1 if error. The transfered length
150  * and the current status are stored in the dev->act_len and dev->status.
151  */
152 int usb_control_msg(struct usb_device *dev, unsigned int pipe,
153 			unsigned char request, unsigned char requesttype,
154 			unsigned short value, unsigned short index,
155 			void *data, unsigned short size, int timeout)
156 {
157 	if((timeout==0)&&(!asynch_allowed)) /* request for a asynch control pipe is not allowed */
158 		return -1;
159 	/* set setup command */
160 	setup_packet.requesttype = requesttype;
161 	setup_packet.request = request;
162 	setup_packet.value = swap_16(value);
163 	setup_packet.index = swap_16(index);
164 	setup_packet.length = swap_16(size);
165  	USB_PRINTF("usb_control_msg: request: 0x%X, requesttype: 0x%X\nvalue 0x%X index 0x%X length 0x%X\n",
166 		request,requesttype,value,index,size);
167 	dev->status=USB_ST_NOT_PROC; /*not yet processed */
168 
169 	submit_control_msg(dev,pipe,data,size,&setup_packet);
170 	if(timeout==0) {
171 		return (int)size;
172 	}
173 	while(timeout--) {
174 		if(!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
175 			break;
176 		wait_ms(1);
177 	}
178 	if(dev->status==0)
179 		return dev->act_len;
180 	else {
181 		return -1;
182 	}
183 }
184 
185 /*-------------------------------------------------------------------
186  * submits bulk message, and waits for completion. returns 0 if Ok or
187  * -1 if Error.
188  * synchronous behavior
189  */
190 int usb_bulk_msg(struct usb_device *dev, unsigned int pipe,
191 			void *data, int len, int *actual_length, int timeout)
192 {
193 	if (len < 0)
194 		return -1;
195 	dev->status=USB_ST_NOT_PROC; /*not yet processed */
196 	submit_bulk_msg(dev,pipe,data,len);
197 	while(timeout--) {
198 		if(!((volatile unsigned long)dev->status & USB_ST_NOT_PROC))
199 			break;
200 		wait_ms(1);
201 	}
202 	*actual_length=dev->act_len;
203 	if(dev->status==0)
204 		return 0;
205 	else
206 		return -1;
207 }
208 
209 
210 /*-------------------------------------------------------------------
211  * Max Packet stuff
212  */
213 
214 /*
215  * returns the max packet size, depending on the pipe direction and
216  * the configurations values
217  */
218 int usb_maxpacket(struct usb_device *dev,unsigned long pipe)
219 {
220 	if((pipe & USB_DIR_IN)==0) /* direction is out -> use emaxpacket out */
221 		return(dev->epmaxpacketout[((pipe>>15) & 0xf)]);
222 	else
223 		return(dev->epmaxpacketin[((pipe>>15) & 0xf)]);
224 }
225 
226 /*
227  * set the max packed value of all endpoints in the given configuration
228  */
229 int usb_set_maxpacket(struct usb_device *dev)
230 {
231 	int i,ii,b;
232 	struct usb_endpoint_descriptor *ep;
233 
234 	for(i=0; i<dev->config.bNumInterfaces;i++) {
235 		for(ii=0; ii<dev->config.if_desc[i].bNumEndpoints; ii++) {
236 			ep=&dev->config.if_desc[i].ep_desc[ii];
237 			b=ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
238 
239 			if((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)==USB_ENDPOINT_XFER_CONTROL) {	/* Control => bidirectional */
240 				dev->epmaxpacketout[b] = ep->wMaxPacketSize;
241 				dev->epmaxpacketin [b] = ep->wMaxPacketSize;
242 				USB_PRINTF("##Control EP epmaxpacketout/in[%d] = %d\n",b,dev->epmaxpacketin[b]);
243 			}
244 			else {
245 				if ((ep->bEndpointAddress & 0x80)==0) { /* OUT Endpoint */
246 					if(ep->wMaxPacketSize > dev->epmaxpacketout[b]) {
247 						dev->epmaxpacketout[b] = ep->wMaxPacketSize;
248 						USB_PRINTF("##EP epmaxpacketout[%d] = %d\n",b,dev->epmaxpacketout[b]);
249 					}
250 				}
251 				else  { /* IN Endpoint */
252 					if(ep->wMaxPacketSize > dev->epmaxpacketin[b]) {
253 						dev->epmaxpacketin[b] = ep->wMaxPacketSize;
254 						USB_PRINTF("##EP epmaxpacketin[%d] = %d\n",b,dev->epmaxpacketin[b]);
255 					}
256 				} /* if out */
257 			} /* if control */
258 		} /* for each endpoint */
259 	}
260 	return 0;
261 }
262 
263 /*******************************************************************************
264  * Parse the config, located in buffer, and fills the dev->config structure.
265  * Note that all little/big endian swapping are done automatically.
266  */
267 int usb_parse_config(struct usb_device *dev, unsigned char *buffer, int cfgno)
268 {
269 	struct usb_descriptor_header *head;
270 	int index,ifno,epno;
271 	ifno=-1;
272 	epno=-1;
273 
274 	dev->configno=cfgno;
275 	head =(struct usb_descriptor_header *)&buffer[0];
276 	if(head->bDescriptorType!=USB_DT_CONFIG) {
277 		printf(" ERROR: NOT USB_CONFIG_DESC %x\n",head->bDescriptorType);
278 		return -1;
279 	}
280 	memcpy(&dev->config,buffer,buffer[0]);
281 	dev->config.wTotalLength=swap_16(dev->config.wTotalLength);
282 	dev->config.no_of_if=0;
283 
284 	index=dev->config.bLength;
285 	/* Ok the first entry must be a configuration entry, now process the others */
286 	head=(struct usb_descriptor_header *)&buffer[index];
287 	while(index+1 < dev->config.wTotalLength) {
288 		switch(head->bDescriptorType) {
289 			case USB_DT_INTERFACE:
290 				ifno=dev->config.no_of_if;
291 				dev->config.no_of_if++; /* found an interface desc, increase numbers */
292 				memcpy(&dev->config.if_desc[ifno],&buffer[index],buffer[index]); /* copy new desc */
293 				dev->config.if_desc[ifno].no_of_ep=0;
294 
295 				break;
296 			case USB_DT_ENDPOINT:
297 				epno=dev->config.if_desc[ifno].no_of_ep;
298 				dev->config.if_desc[ifno].no_of_ep++; /* found an endpoint */
299 				memcpy(&dev->config.if_desc[ifno].ep_desc[epno],&buffer[index],buffer[index]);
300 				dev->config.if_desc[ifno].ep_desc[epno].wMaxPacketSize
301 					=swap_16(dev->config.if_desc[ifno].ep_desc[epno].wMaxPacketSize);
302 				USB_PRINTF("if %d, ep %d\n",ifno,epno);
303 				break;
304 			default:
305 				if(head->bLength==0)
306 					return 1;
307 				USB_PRINTF("unknown Description Type : %x\n",head->bDescriptorType);
308 				{
309 					int i;
310 					unsigned char *ch;
311 					ch=(unsigned char *)head;
312 					for(i=0;i<head->bLength; i++)
313 						USB_PRINTF("%02X ",*ch++);
314 					USB_PRINTF("\n\n\n");
315 				}
316 				break;
317 		}
318 		index+=head->bLength;
319 		head=(struct usb_descriptor_header *)&buffer[index];
320 	}
321 	return 1;
322 }
323 
324 /***********************************************************************
325  * Clears an endpoint
326  * endp: endpoint number in bits 0-3;
327  * direction flag in bit 7 (1 = IN, 0 = OUT)
328  */
329 int usb_clear_halt(struct usb_device *dev, int pipe)
330 {
331 	int result;
332 	unsigned short status;
333 	int endp=usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
334 
335 	result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
336 		USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, endp, NULL, 0, USB_CNTL_TIMEOUT * 3);
337 
338 	/* don't clear if failed */
339 	if (result < 0)
340 		return result;
341 	result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
342 		USB_REQ_GET_STATUS, USB_DIR_IN | USB_RECIP_ENDPOINT, 0, endp,
343 		&status, sizeof(status), USB_CNTL_TIMEOUT * 3);
344 	if (result < 0)
345 		return result;
346 	USB_PRINTF("usb_clear_halt: status 0x%x\n",status);
347 	if (status & 1)
348 		return -1;		/* still halted */
349 	usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
350 	/* toggle is reset on clear */
351 	usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
352 	return 0;
353 }
354 
355 
356 /**********************************************************************
357  * get_descriptor type
358  */
359 int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size)
360 {
361 	int res;
362  	res = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
363 			USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
364 			(type << 8) + index, 0,
365 			buf, size, USB_CNTL_TIMEOUT);
366 	return res;
367 }
368 
369 /**********************************************************************
370  * gets configuration cfgno and store it in the buffer
371  */
372 int usb_get_configuration_no(struct usb_device *dev,unsigned char *buffer,int cfgno)
373 {
374  	int result;
375 	unsigned int tmp;
376 	struct usb_config_descriptor *config;
377 
378 
379 	config=(struct usb_config_descriptor *)&buffer[0];
380 	result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8);
381 	if (result < 8) {
382 		if (result < 0)
383 			printf("unable to get descriptor, error %lX\n",dev->status);
384 		else
385 			printf("config descriptor too short (expected %i, got %i)\n",8,result);
386 		return -1;
387 	}
388 	tmp=swap_16(config->wTotalLength);
389 
390 	result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, tmp);
391 	USB_PRINTF("get_conf_no %d Result %d, wLength %d\n",cfgno,result,tmp);
392 	return result;
393 }
394 
395 /********************************************************************
396  * set address of a device to the value in dev->devnum.
397  * This can only be done by addressing the device via the default address (0)
398  */
399 int usb_set_address(struct usb_device *dev)
400 {
401 	int res;
402 
403 	USB_PRINTF("set address %d\n",dev->devnum);
404 	res=usb_control_msg(dev, usb_snddefctrl(dev),
405 		USB_REQ_SET_ADDRESS, 0,
406 		(dev->devnum),0,
407 		NULL,0, USB_CNTL_TIMEOUT);
408 	return res;
409 }
410 
411 /********************************************************************
412  * set interface number to interface
413  */
414 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
415 {
416 	struct usb_interface_descriptor *if_face = NULL;
417 	int ret, i;
418 
419 	for (i=0; i<dev->config.bNumInterfaces; i++) {
420 		if (dev->config.if_desc[i].bInterfaceNumber == interface) {
421 			if_face = &dev->config.if_desc[i];
422 			break;
423 		}
424 	}
425 	if (!if_face) {
426 		printf("selecting invalid interface %d", interface);
427 		return -1;
428 	}
429 
430 	if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
431 	    USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, alternate,
432 	    interface, NULL, 0, USB_CNTL_TIMEOUT * 5)) < 0)
433 		return ret;
434 
435 	if_face->act_altsetting = (unsigned char)alternate;
436 	usb_set_maxpacket(dev);
437 	return 0;
438 }
439 
440 /********************************************************************
441  * set configuration number to configuration
442  */
443 int usb_set_configuration(struct usb_device *dev, int configuration)
444 {
445 	int res;
446 	USB_PRINTF("set configuration %d\n",configuration);
447 	/* set setup command */
448 	res=usb_control_msg(dev, usb_sndctrlpipe(dev,0),
449 		USB_REQ_SET_CONFIGURATION, 0,
450 		configuration,0,
451 		NULL,0, USB_CNTL_TIMEOUT);
452 	if(res==0) {
453 		dev->toggle[0] = 0;
454 		dev->toggle[1] = 0;
455 		return 0;
456 	}
457 	else
458 		return -1;
459 }
460 
461 /********************************************************************
462  * set protocol to protocol
463  */
464 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
465 {
466 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
467 		USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
468 		protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
469 }
470 
471 /********************************************************************
472  * set idle
473  */
474 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
475 {
476 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
477 		USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
478 		(duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT);
479 }
480 
481 /********************************************************************
482  * get report
483  */
484 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size)
485 {
486 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
487 		USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
488 		(type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
489 }
490 
491 /********************************************************************
492  * get class descriptor
493  */
494 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
495 		unsigned char type, unsigned char id, void *buf, int size)
496 {
497 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
498 		USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
499 		(type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT);
500 }
501 
502 /********************************************************************
503  * get string index in buffer
504  */
505 int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size)
506 {
507 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
508 		USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
509 		(USB_DT_STRING << 8) + index, langid, buf, size, USB_CNTL_TIMEOUT);
510 }
511 
512 /********************************************************************
513  * usb_string:
514  * Get string index and translate it to ascii.
515  * returns string length (> 0) or error (< 0)
516  */
517 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
518 {
519 
520 	unsigned char mybuf[256];
521 	unsigned char *tbuf;
522 	int err;
523 	unsigned int u, idx;
524 
525 	if (size <= 0 || !buf || !index)
526 		return -1;
527 	buf[0] = 0;
528 	tbuf=&mybuf[0];
529 
530 	/* get langid for strings if it's not yet known */
531 	if (!dev->have_langid) {
532 		err = usb_get_string(dev, 0, 0, tbuf, 4);
533 		if (err < 0) {
534 			USB_PRINTF("error getting string descriptor 0 (error=%x)\n",dev->status);
535 			return -1;
536 		} else if (tbuf[0] < 4) {
537 			USB_PRINTF("string descriptor 0 too short\n");
538 			return -1;
539 		} else {
540 			dev->have_langid = -1;
541 			dev->string_langid = tbuf[2] | (tbuf[3]<< 8);
542 				/* always use the first langid listed */
543 			USB_PRINTF("USB device number %d default language ID 0x%x\n",
544 				dev->devnum, dev->string_langid);
545 		}
546 	}
547 	/* Just ask for a maximum length string and then take the length
548 	 * that was returned. */
549 	err = usb_get_string(dev, dev->string_langid, index, tbuf, 4);
550 	if (err < 0)
551 		return err;
552 	u=tbuf[0];
553 	USB_PRINTF("Strn Len %d, index %d\n",u,index);
554 	err = usb_get_string(dev, dev->string_langid, index, tbuf, u);
555 	if (err < 0)
556 		return err;
557 	size--;		/* leave room for trailing NULL char in output buffer */
558 	for (idx = 0, u = 2; u < err; u += 2) {
559 		if (idx >= size)
560 			break;
561 		if (tbuf[u+1])			/* high byte */
562 			buf[idx++] = '?';  /* non-ASCII character */
563 		else
564 			buf[idx++] = tbuf[u];
565 	}
566 	buf[idx] = 0;
567 	err = idx;
568 	return err;
569 }
570 
571 
572 /********************************************************************
573  * USB device handling:
574  * the USB device are static allocated [USB_MAX_DEVICE].
575  */
576 
577 
578 /* returns a pointer to the device with the index [index].
579  * if the device is not assigned (dev->devnum==-1) returns NULL
580  */
581 struct usb_device * usb_get_dev_index(int index)
582 {
583 	if(usb_dev[index].devnum==-1)
584 		return NULL;
585 	else
586 		return &usb_dev[index];
587 }
588 
589 
590 /* returns a pointer of a new device structure or NULL, if
591  * no device struct is available
592  */
593 struct usb_device * usb_alloc_new_device(void)
594 {
595 	int i;
596 	USB_PRINTF("New Device %d\n",dev_index);
597 	if(dev_index==USB_MAX_DEVICE) {
598 		printf("ERROR, to many USB Devices max=%d\n",USB_MAX_DEVICE);
599 		return NULL;
600 	}
601 	usb_dev[dev_index].devnum=dev_index+1; /* default Address is 0, real addresses start with 1 */
602 	usb_dev[dev_index].maxchild=0;
603 	for(i=0;i<USB_MAXCHILDREN;i++)
604 		usb_dev[dev_index].children[i]=NULL;
605 	usb_dev[dev_index].parent=NULL;
606 	dev_index++;
607 	return &usb_dev[dev_index-1];
608 }
609 
610 
611 /*
612  * By the time we get here, the device has gotten a new device ID
613  * and is in the default state. We need to identify the thing and
614  * get the ball rolling..
615  *
616  * Returns 0 for success, != 0 for error.
617  */
618 int usb_new_device(struct usb_device *dev)
619 {
620 	int addr, err;
621 	int tmp;
622 	unsigned char tmpbuf[256];
623 
624 	dev->descriptor.bMaxPacketSize0 = 8;  /* Start off at 8 bytes  */
625 	dev->maxpacketsize = 0;		/* Default to 8 byte max packet size */
626 	dev->epmaxpacketin [0] = 8;
627 	dev->epmaxpacketout[0] = 8;
628 
629 	/* We still haven't set the Address yet */
630 	addr = dev->devnum;
631 	dev->devnum = 0;
632 	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
633 	if (err < 8) {
634 		printf("\n      USB device not responding, giving up (status=%lX)\n",dev->status);
635 		return 1;
636 	}
637 	dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0;
638 	dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
639 	switch (dev->descriptor.bMaxPacketSize0) {
640 		case 8: dev->maxpacketsize = 0; break;
641 		case 16: dev->maxpacketsize = 1; break;
642 		case 32: dev->maxpacketsize = 2; break;
643 		case 64: dev->maxpacketsize = 3; break;
644 	}
645 	dev->devnum = addr;
646 
647 	err = usb_set_address(dev); /* set address */
648 
649 	if (err < 0) {
650 		printf("\n      USB device not accepting new address (error=%lX)\n", dev->status);
651 		return 1;
652 	}
653 
654 	wait_ms(10);	/* Let the SET_ADDRESS settle */
655 
656 	tmp = sizeof(dev->descriptor);
657 
658 	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor));
659 	if (err < tmp) {
660 		if (err < 0)
661 			printf("unable to get device descriptor (error=%d)\n",err);
662 		else
663 			printf("USB device descriptor short read (expected %i, got %i)\n",tmp,err);
664 		return 1;
665 	}
666 	/* correct le values */
667 	dev->descriptor.bcdUSB=swap_16(dev->descriptor.bcdUSB);
668 	dev->descriptor.idVendor=swap_16(dev->descriptor.idVendor);
669 	dev->descriptor.idProduct=swap_16(dev->descriptor.idProduct);
670 	dev->descriptor.bcdDevice=swap_16(dev->descriptor.bcdDevice);
671 	/* only support for one config for now */
672 	usb_get_configuration_no(dev,&tmpbuf[0],0);
673 	usb_parse_config(dev,&tmpbuf[0],0);
674 	usb_set_maxpacket(dev);
675 	/* we set the default configuration here */
676 	if (usb_set_configuration(dev, dev->config.bConfigurationValue)) {
677 		printf("failed to set default configuration len %d, status %lX\n",dev->act_len,dev->status);
678 		return -1;
679 	}
680 	USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n",
681 		dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber);
682 	memset(dev->mf, 0, sizeof(dev->mf));
683 	memset(dev->prod, 0, sizeof(dev->prod));
684 	memset(dev->serial, 0, sizeof(dev->serial));
685 	if (dev->descriptor.iManufacturer)
686 		usb_string(dev, dev->descriptor.iManufacturer, dev->mf, sizeof(dev->mf));
687 	if (dev->descriptor.iProduct)
688 		usb_string(dev, dev->descriptor.iProduct, dev->prod, sizeof(dev->prod));
689 	if (dev->descriptor.iSerialNumber)
690 		usb_string(dev, dev->descriptor.iSerialNumber, dev->serial, sizeof(dev->serial));
691 	USB_PRINTF("Manufacturer %s\n", dev->mf);
692 	USB_PRINTF("Product      %s\n", dev->prod);
693 	USB_PRINTF("SerialNumber %s\n", dev->serial);
694 	/* now prode if the device is a hub */
695 	usb_hub_probe(dev,0);
696 	return 0;
697 }
698 
699 /* build device Tree  */
700 void usb_scan_devices(void)
701 {
702 	int i;
703 	struct usb_device *dev;
704 
705 	/* first make all devices unknown */
706 	for(i=0;i<USB_MAX_DEVICE;i++) {
707 		memset(&usb_dev[i],0,sizeof(struct usb_device));
708 		usb_dev[i].devnum=-1;
709 	}
710 	dev_index=0;
711 	/* device 0 is always present (root hub, so let it analyze) */
712 	dev=usb_alloc_new_device();
713 	usb_new_device(dev);
714 	printf("%d USB Devices found\n",dev_index);
715 	/* insert "driver" if possible */
716 #ifdef CONFIG_USB_KEYBOARD
717 	drv_usb_kbd_init();
718 	USB_PRINTF("scan end\n");
719 #endif
720 }
721 
722 
723 /****************************************************************************
724  * HUB "Driver"
725  * Probes device for being a hub and configurate it
726  */
727 
728 #undef	USB_HUB_DEBUG
729 
730 #ifdef	USB_HUB_DEBUG
731 #define	USB_HUB_PRINTF(fmt,args...)	printf (fmt ,##args)
732 #else
733 #define USB_HUB_PRINTF(fmt,args...)
734 #endif
735 
736 
737 static struct usb_hub_device hub_dev[USB_MAX_HUB];
738 static int usb_hub_index;
739 
740 
741 int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size)
742 {
743 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
744 		USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB,
745 		USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT);
746 }
747 
748 int usb_clear_hub_feature(struct usb_device *dev, int feature)
749 {
750 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
751 		USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, USB_CNTL_TIMEOUT);
752 }
753 
754 int usb_clear_port_feature(struct usb_device *dev, int port, int feature)
755 {
756 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
757 		USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT);
758 }
759 
760 int usb_set_port_feature(struct usb_device *dev, int port, int feature)
761 {
762 	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
763 		USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT);
764 }
765 
766 int usb_get_hub_status(struct usb_device *dev, void *data)
767 {
768 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
769 			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0,
770 			data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
771 }
772 
773 int usb_get_port_status(struct usb_device *dev, int port, void *data)
774 {
775 	return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
776 			USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port,
777 			data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT);
778 }
779 
780 
781 static void usb_hub_power_on(struct usb_hub_device *hub)
782 {
783 	int i;
784 	struct usb_device *dev;
785 
786 	dev=hub->pusb_dev;
787 	/* Enable power to the ports */
788 	USB_HUB_PRINTF("enabling power on all ports\n");
789 	for (i = 0; i < dev->maxchild; i++) {
790 		usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER);
791 		USB_HUB_PRINTF("port %d returns %lX\n",i+1,dev->status);
792 		wait_ms(hub->desc.bPwrOn2PwrGood * 2);
793 	}
794 }
795 
796 void usb_hub_reset(void)
797 {
798 	usb_hub_index=0;
799 }
800 
801 struct usb_hub_device *usb_hub_allocate(void)
802 {
803 	if(usb_hub_index<USB_MAX_HUB) {
804 		return &hub_dev[usb_hub_index++];
805 	}
806 	printf("ERROR: USB_MAX_HUB (%d) reached\n",USB_MAX_HUB);
807 	return NULL;
808 }
809 
810 #define MAX_TRIES 5
811 
812 void usb_hub_port_connect_change(struct usb_device *dev, int port)
813 {
814 	struct usb_device *usb;
815 	struct usb_port_status portsts;
816 	unsigned short portstatus, portchange;
817 	int tries;
818 
819 	/* Check status */
820 	if (usb_get_port_status(dev, port + 1, &portsts)<0) {
821 		USB_HUB_PRINTF("get_port_status failed\n");
822 		return;
823 	}
824 
825 	portstatus = swap_16(portsts.wPortStatus);
826 	portchange = swap_16(portsts.wPortChange);
827 	USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus, portchange,
828 		portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed");
829 
830 	/* Clear the connection change status */
831 	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION);
832 
833 	/* Disconnect any existing devices under this port */
834 	if (((!(portstatus & USB_PORT_STAT_CONNECTION)) &&
835 	     (!(portstatus & USB_PORT_STAT_ENABLE)))|| (dev->children[port])) {
836 		USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n");
837 		/* Return now if nothing is connected */
838 		if (!(portstatus & USB_PORT_STAT_CONNECTION))
839 			return;
840 	}
841 	wait_ms(200);
842 
843 	/* Reset the port */
844 
845 	for(tries=0;tries<MAX_TRIES;tries++) {
846 
847 		usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET);
848 		wait_ms(200);
849 
850 		if (usb_get_port_status(dev, port + 1, &portsts)<0) {
851 			USB_HUB_PRINTF("get_port_status failed status %lX\n",dev->status);
852 			return;
853 		}
854 		portstatus = swap_16(portsts.wPortStatus);
855 		portchange = swap_16(portsts.wPortChange);
856 		USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus ,portchange,
857 			portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed");
858 		USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d  USB_PORT_STAT_ENABLE %d\n",
859 			(portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0,
860 			(portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0,
861 			(portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0);
862 		if ((portchange & USB_PORT_STAT_C_CONNECTION) ||
863 		    !(portstatus & USB_PORT_STAT_CONNECTION))
864 			return;
865 
866 		if (portstatus & USB_PORT_STAT_ENABLE)
867 			break;
868 
869 		wait_ms(200);
870 	}
871 
872 	if (tries==MAX_TRIES) {
873 		USB_HUB_PRINTF("Cannot enable port %i after %i retries, disabling port.\n", port+1, MAX_TRIES);
874 		USB_HUB_PRINTF("Maybe the USB cable is bad?\n");
875 		return;
876 	}
877 
878 	usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET);
879 	wait_ms(200);
880 
881 	/* Allocate a new device struct for it */
882 	usb=usb_alloc_new_device();
883 	usb->slow = (portstatus & USB_PORT_STAT_LOW_SPEED) ? 1 : 0;
884 
885 	dev->children[port] = usb;
886 	usb->parent=dev;
887 	/* Run it through the hoops (find a driver, etc) */
888 	if (usb_new_device(usb)) {
889 		/* Woops, disable the port */
890 		USB_HUB_PRINTF("hub: disabling port %d\n", port + 1);
891 		usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE);
892 	}
893 }
894 
895 
896 int usb_hub_configure(struct usb_device *dev)
897 {
898 	unsigned char buffer[256], *bitmap;
899 	struct usb_hub_descriptor *descriptor;
900 	struct usb_hub_status *hubsts;
901 	int i;
902 	struct usb_hub_device *hub;
903 
904 	/* "allocate" Hub device */
905 	hub=usb_hub_allocate();
906 	if(hub==NULL)
907 		return -1;
908 	hub->pusb_dev=dev;
909 	/* Get the the hub descriptor */
910 	if (usb_get_hub_descriptor(dev, buffer, 4) < 0) {
911 		USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor, giving up %lX\n",dev->status);
912 		return -1;
913 	}
914 	descriptor = (struct usb_hub_descriptor *)buffer;
915 	if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 0) {
916 		USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor 2nd giving up %lX\n",dev->status);
917 		return -1;
918 	}
919 	memcpy((unsigned char *)&hub->desc,buffer,descriptor->bLength);
920 	/* adjust 16bit values */
921 	hub->desc.wHubCharacteristics=swap_16(descriptor->wHubCharacteristics);
922 	/* set the bitmap */
923 	bitmap=(unsigned char *)&hub->desc.DeviceRemovable[0];
924 	memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* devices not removable by default */
925 	bitmap=(unsigned char *)&hub->desc.PortPowerCtrlMask[0];
926 	memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */
927 	for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) {
928 		hub->desc.DeviceRemovable[i]=descriptor->DeviceRemovable[i];
929 	}
930 	for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) {
931 		hub->desc.DeviceRemovable[i]=descriptor->PortPowerCtrlMask[i];
932 	}
933 	dev->maxchild = descriptor->bNbrPorts;
934 	USB_HUB_PRINTF("%d ports detected\n", dev->maxchild);
935 
936 	switch (hub->desc.wHubCharacteristics & HUB_CHAR_LPSM) {
937 		case 0x00:
938 			USB_HUB_PRINTF("ganged power switching\n");
939 			break;
940 		case 0x01:
941 			USB_HUB_PRINTF("individual port power switching\n");
942 			break;
943 		case 0x02:
944 		case 0x03:
945 			USB_HUB_PRINTF("unknown reserved power switching mode\n");
946 			break;
947 	}
948 
949 	if (hub->desc.wHubCharacteristics & HUB_CHAR_COMPOUND)
950 		USB_HUB_PRINTF("part of a compound device\n");
951 	else
952 		USB_HUB_PRINTF("standalone hub\n");
953 
954 	switch (hub->desc.wHubCharacteristics & HUB_CHAR_OCPM) {
955 		case 0x00:
956 			USB_HUB_PRINTF("global over-current protection\n");
957 			break;
958 		case 0x08:
959 			USB_HUB_PRINTF("individual port over-current protection\n");
960 			break;
961 		case 0x10:
962 		case 0x18:
963 			USB_HUB_PRINTF("no over-current protection\n");
964       break;
965 	}
966 	USB_HUB_PRINTF("power on to power good time: %dms\n", descriptor->bPwrOn2PwrGood * 2);
967 	USB_HUB_PRINTF("hub controller current requirement: %dmA\n", descriptor->bHubContrCurrent);
968 	for (i = 0; i < dev->maxchild; i++)
969 		USB_HUB_PRINTF("port %d is%s removable\n", i + 1,
970 			hub->desc.DeviceRemovable[(i + 1)/8] & (1 << ((i + 1)%8)) ? " not" : "");
971 	if (usb_get_hub_status(dev, buffer) < 0) {
972 		USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",dev->status);
973 		return -1;
974 	}
975 	hubsts = (struct usb_hub_status *)buffer;
976 	USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n",
977 		swap_16(hubsts->wHubStatus),swap_16(hubsts->wHubChange));
978 	USB_HUB_PRINTF("local power source is %s\n",
979 		(swap_16(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good");
980 	USB_HUB_PRINTF("%sover-current condition exists\n",
981 		(swap_16(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? "" : "no ");
982 	usb_hub_power_on(hub);
983 	for (i = 0; i < dev->maxchild; i++) {
984 		struct usb_port_status portsts;
985 		unsigned short portstatus, portchange;
986 
987 		if (usb_get_port_status(dev, i + 1, &portsts) < 0) {
988 			USB_HUB_PRINTF("get_port_status failed\n");
989 			continue;
990 		}
991 		portstatus = swap_16(portsts.wPortStatus);
992 		portchange = swap_16(portsts.wPortChange);
993 		USB_HUB_PRINTF("Port %d Status %X Change %X\n",i+1,portstatus,portchange);
994 		if (portchange & USB_PORT_STAT_C_CONNECTION) {
995 			USB_HUB_PRINTF("port %d connection change\n", i + 1);
996 			usb_hub_port_connect_change(dev, i);
997 		}
998 		if (portchange & USB_PORT_STAT_C_ENABLE) {
999 			USB_HUB_PRINTF("port %d enable change, status %x\n", i + 1, portstatus);
1000 			usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE);
1001 
1002 			/* EM interference sometimes causes bad shielded USB devices to
1003 			 * be shutdown by the hub, this hack enables them again.
1004 			 * Works at least with mouse driver */
1005 			if (!(portstatus & USB_PORT_STAT_ENABLE) &&
1006 				(portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) {
1007 				USB_HUB_PRINTF("already running port %i disabled by hub (EMI?), re-enabling...\n",
1008 					i + 1);
1009 					usb_hub_port_connect_change(dev, i);
1010 			}
1011 		}
1012 		if (portstatus & USB_PORT_STAT_SUSPEND) {
1013 			USB_HUB_PRINTF("port %d suspend change\n", i + 1);
1014 			usb_clear_port_feature(dev, i + 1,  USB_PORT_FEAT_SUSPEND);
1015 		}
1016 
1017 		if (portchange & USB_PORT_STAT_C_OVERCURRENT) {
1018 			USB_HUB_PRINTF("port %d over-current change\n", i + 1);
1019 			usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT);
1020 			usb_hub_power_on(hub);
1021 		}
1022 
1023 		if (portchange & USB_PORT_STAT_C_RESET) {
1024 			USB_HUB_PRINTF("port %d reset change\n", i + 1);
1025 			usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET);
1026 		}
1027 	} /* end for i all ports */
1028 
1029 	return 0;
1030 }
1031 
1032 int usb_hub_probe(struct usb_device *dev, int ifnum)
1033 {
1034 	struct usb_interface_descriptor *iface;
1035 	struct usb_endpoint_descriptor *ep;
1036 	int ret;
1037 
1038 	iface = &dev->config.if_desc[ifnum];
1039 	/* Is it a hub? */
1040 	if (iface->bInterfaceClass != USB_CLASS_HUB)
1041 		return 0;
1042 	/* Some hubs have a subclass of 1, which AFAICT according to the */
1043 	/*  specs is not defined, but it works */
1044 	if ((iface->bInterfaceSubClass != 0) &&
1045 	    (iface->bInterfaceSubClass != 1))
1046 		return 0;
1047 	/* Multiple endpoints? What kind of mutant ninja-hub is this? */
1048 	if (iface->bNumEndpoints != 1)
1049 		return 0;
1050 	ep = &iface->ep_desc[0];
1051 	/* Output endpoint? Curiousier and curiousier.. */
1052 	if (!(ep->bEndpointAddress & USB_DIR_IN))
1053 		return 0;
1054 	/* If it's not an interrupt endpoint, we'd better punt! */
1055 	if ((ep->bmAttributes & 3) != 3)
1056 		return 0;
1057 	/* We found a hub */
1058 	USB_HUB_PRINTF("USB hub found\n");
1059 	ret=usb_hub_configure(dev);
1060 	return ret;
1061 }
1062 
1063 #endif /* (CONFIG_COMMANDS & CFG_CMD_USB) */
1064 
1065 /* EOF */
1066