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