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