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 return result; 527 } 528 529 530 static void usb_try_string_workarounds(unsigned char *buf, int *length) 531 { 532 int newlength, oldlength = *length; 533 534 for (newlength = 2; newlength + 1 < oldlength; newlength += 2) 535 if (!isprint(buf[newlength]) || buf[newlength + 1]) 536 break; 537 538 if (newlength > 2) { 539 buf[0] = newlength; 540 *length = newlength; 541 } 542 } 543 544 545 static int usb_string_sub(struct usb_device *dev, unsigned int langid, 546 unsigned int index, unsigned char *buf) 547 { 548 int rc; 549 550 /* Try to read the string descriptor by asking for the maximum 551 * possible number of bytes */ 552 rc = usb_get_string(dev, langid, index, buf, 255); 553 554 /* If that failed try to read the descriptor length, then 555 * ask for just that many bytes */ 556 if (rc < 2) { 557 rc = usb_get_string(dev, langid, index, buf, 2); 558 if (rc == 2) 559 rc = usb_get_string(dev, langid, index, buf, buf[0]); 560 } 561 562 if (rc >= 2) { 563 if (!buf[0] && !buf[1]) 564 usb_try_string_workarounds(buf, &rc); 565 566 /* There might be extra junk at the end of the descriptor */ 567 if (buf[0] < rc) 568 rc = buf[0]; 569 570 rc = rc - (rc & 1); /* force a multiple of two */ 571 } 572 573 if (rc < 2) 574 rc = -1; 575 576 return rc; 577 } 578 579 580 /******************************************************************** 581 * usb_string: 582 * Get string index and translate it to ascii. 583 * returns string length (> 0) or error (< 0) 584 */ 585 int usb_string(struct usb_device *dev, int index, char *buf, size_t size) 586 { 587 unsigned char mybuf[USB_BUFSIZ]; 588 unsigned char *tbuf; 589 int err; 590 unsigned int u, idx; 591 592 if (size <= 0 || !buf || !index) 593 return -1; 594 buf[0] = 0; 595 tbuf=&mybuf[0]; 596 597 /* get langid for strings if it's not yet known */ 598 if (!dev->have_langid) { 599 err = usb_string_sub(dev, 0, 0, tbuf); 600 if (err < 0) { 601 USB_PRINTF("error getting string descriptor 0 (error=%x)\n",dev->status); 602 return -1; 603 } else if (tbuf[0] < 4) { 604 USB_PRINTF("string descriptor 0 too short\n"); 605 return -1; 606 } else { 607 dev->have_langid = -1; 608 dev->string_langid = tbuf[2] | (tbuf[3]<< 8); 609 /* always use the first langid listed */ 610 USB_PRINTF("USB device number %d default language ID 0x%x\n", 611 dev->devnum, dev->string_langid); 612 } 613 } 614 615 err = usb_string_sub(dev, dev->string_langid, index, tbuf); 616 if (err < 0) 617 return err; 618 619 size--; /* leave room for trailing NULL char in output buffer */ 620 for (idx = 0, u = 2; u < err; u += 2) { 621 if (idx >= size) 622 break; 623 if (tbuf[u+1]) /* high byte */ 624 buf[idx++] = '?'; /* non-ASCII character */ 625 else 626 buf[idx++] = tbuf[u]; 627 } 628 buf[idx] = 0; 629 err = idx; 630 return err; 631 } 632 633 634 /******************************************************************** 635 * USB device handling: 636 * the USB device are static allocated [USB_MAX_DEVICE]. 637 */ 638 639 640 /* returns a pointer to the device with the index [index]. 641 * if the device is not assigned (dev->devnum==-1) returns NULL 642 */ 643 struct usb_device * usb_get_dev_index(int index) 644 { 645 if(usb_dev[index].devnum==-1) 646 return NULL; 647 else 648 return &usb_dev[index]; 649 } 650 651 652 /* returns a pointer of a new device structure or NULL, if 653 * no device struct is available 654 */ 655 struct usb_device * usb_alloc_new_device(void) 656 { 657 int i; 658 USB_PRINTF("New Device %d\n",dev_index); 659 if(dev_index==USB_MAX_DEVICE) { 660 printf("ERROR, too many USB Devices, max=%d\n",USB_MAX_DEVICE); 661 return NULL; 662 } 663 usb_dev[dev_index].devnum=dev_index+1; /* default Address is 0, real addresses start with 1 */ 664 usb_dev[dev_index].maxchild=0; 665 for(i=0;i<USB_MAXCHILDREN;i++) 666 usb_dev[dev_index].children[i]=NULL; 667 usb_dev[dev_index].parent=NULL; 668 dev_index++; 669 return &usb_dev[dev_index-1]; 670 } 671 672 673 /* 674 * By the time we get here, the device has gotten a new device ID 675 * and is in the default state. We need to identify the thing and 676 * get the ball rolling.. 677 * 678 * Returns 0 for success, != 0 for error. 679 */ 680 int usb_new_device(struct usb_device *dev) 681 { 682 int addr, err; 683 int tmp; 684 unsigned char tmpbuf[USB_BUFSIZ]; 685 686 dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */ 687 dev->maxpacketsize = 0; /* Default to 8 byte max packet size */ 688 dev->epmaxpacketin [0] = 8; 689 dev->epmaxpacketout[0] = 8; 690 691 /* We still haven't set the Address yet */ 692 addr = dev->devnum; 693 dev->devnum = 0; 694 695 #undef NEW_INIT_SEQ 696 #ifdef NEW_INIT_SEQ 697 /* this is a Windows scheme of initialization sequence, with double 698 * reset of the device. Some equipment is said to work only with such 699 * init sequence; this patch is based on the work by Alan Stern: 700 * http://sourceforge.net/mailarchive/forum.php?thread_id=5729457&forum_id=5398 701 */ 702 int j; 703 struct usb_device_descriptor *desc; 704 int port = -1; 705 struct usb_device *parent = dev->parent; 706 unsigned short portstatus; 707 708 /* send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is 709 * only 18 bytes long, this will terminate with a short packet. But if 710 * the maxpacket size is 8 or 16 the device may be waiting to transmit 711 * some more. */ 712 713 desc = (struct usb_device_descriptor *)tmpbuf; 714 desc->bMaxPacketSize0 = 0; 715 for (j = 0; j < 3; ++j) { 716 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, 64); 717 if (err < 0) { 718 USB_PRINTF("usb_new_device: 64 byte descr\n"); 719 break; 720 } 721 } 722 dev->descriptor.bMaxPacketSize0 = desc->bMaxPacketSize0; 723 724 /* find the port number we're at */ 725 if (parent) { 726 for (j = 0; j < parent->maxchild; j++) { 727 if (parent->children[j] == dev) { 728 port = j; 729 break; 730 } 731 } 732 if (port < 0) { 733 printf("usb_new_device: cannot locate device's port..\n"); 734 return 1; 735 } 736 737 /* reset the port for the second time */ 738 err = hub_port_reset(dev->parent, port, &portstatus); 739 if (err < 0) { 740 printf("\n Couldn't reset port %i\n", port); 741 return 1; 742 } 743 } 744 #else 745 /* and this is the old and known way of initializing devices */ 746 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8); 747 if (err < 8) { 748 printf("\n USB device not responding, giving up (status=%lX)\n",dev->status); 749 return 1; 750 } 751 #endif 752 753 dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0; 754 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; 755 switch (dev->descriptor.bMaxPacketSize0) { 756 case 8: dev->maxpacketsize = 0; break; 757 case 16: dev->maxpacketsize = 1; break; 758 case 32: dev->maxpacketsize = 2; break; 759 case 64: dev->maxpacketsize = 3; break; 760 } 761 dev->devnum = addr; 762 763 err = usb_set_address(dev); /* set address */ 764 765 if (err < 0) { 766 printf("\n USB device not accepting new address (error=%lX)\n", dev->status); 767 return 1; 768 } 769 770 wait_ms(10); /* Let the SET_ADDRESS settle */ 771 772 tmp = sizeof(dev->descriptor); 773 774 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, sizeof(dev->descriptor)); 775 if (err < tmp) { 776 if (err < 0) 777 printf("unable to get device descriptor (error=%d)\n",err); 778 else 779 printf("USB device descriptor short read (expected %i, got %i)\n",tmp,err); 780 return 1; 781 } 782 /* correct le values */ 783 dev->descriptor.bcdUSB=swap_16(dev->descriptor.bcdUSB); 784 dev->descriptor.idVendor=swap_16(dev->descriptor.idVendor); 785 dev->descriptor.idProduct=swap_16(dev->descriptor.idProduct); 786 dev->descriptor.bcdDevice=swap_16(dev->descriptor.bcdDevice); 787 /* only support for one config for now */ 788 usb_get_configuration_no(dev,&tmpbuf[0],0); 789 usb_parse_config(dev,&tmpbuf[0],0); 790 usb_set_maxpacket(dev); 791 /* we set the default configuration here */ 792 if (usb_set_configuration(dev, dev->config.bConfigurationValue)) { 793 printf("failed to set default configuration len %d, status %lX\n",dev->act_len,dev->status); 794 return -1; 795 } 796 USB_PRINTF("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", 797 dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber); 798 memset(dev->mf, 0, sizeof(dev->mf)); 799 memset(dev->prod, 0, sizeof(dev->prod)); 800 memset(dev->serial, 0, sizeof(dev->serial)); 801 if (dev->descriptor.iManufacturer) 802 usb_string(dev, dev->descriptor.iManufacturer, dev->mf, sizeof(dev->mf)); 803 if (dev->descriptor.iProduct) 804 usb_string(dev, dev->descriptor.iProduct, dev->prod, sizeof(dev->prod)); 805 if (dev->descriptor.iSerialNumber) 806 usb_string(dev, dev->descriptor.iSerialNumber, dev->serial, sizeof(dev->serial)); 807 USB_PRINTF("Manufacturer %s\n", dev->mf); 808 USB_PRINTF("Product %s\n", dev->prod); 809 USB_PRINTF("SerialNumber %s\n", dev->serial); 810 /* now prode if the device is a hub */ 811 usb_hub_probe(dev,0); 812 return 0; 813 } 814 815 /* build device Tree */ 816 void usb_scan_devices(void) 817 { 818 int i; 819 struct usb_device *dev; 820 821 /* first make all devices unknown */ 822 for(i=0;i<USB_MAX_DEVICE;i++) { 823 memset(&usb_dev[i],0,sizeof(struct usb_device)); 824 usb_dev[i].devnum=-1; 825 } 826 dev_index=0; 827 /* device 0 is always present (root hub, so let it analyze) */ 828 dev=usb_alloc_new_device(); 829 usb_new_device(dev); 830 printf("%d USB Device(s) found\n",dev_index); 831 /* insert "driver" if possible */ 832 #ifdef CONFIG_USB_KEYBOARD 833 drv_usb_kbd_init(); 834 USB_PRINTF("scan end\n"); 835 #endif 836 } 837 838 839 /**************************************************************************** 840 * HUB "Driver" 841 * Probes device for being a hub and configurate it 842 */ 843 844 #undef USB_HUB_DEBUG 845 846 #ifdef USB_HUB_DEBUG 847 #define USB_HUB_PRINTF(fmt,args...) printf (fmt ,##args) 848 #else 849 #define USB_HUB_PRINTF(fmt,args...) 850 #endif 851 852 853 static struct usb_hub_device hub_dev[USB_MAX_HUB]; 854 static int usb_hub_index; 855 856 857 int usb_get_hub_descriptor(struct usb_device *dev, void *data, int size) 858 { 859 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 860 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN | USB_RT_HUB, 861 USB_DT_HUB << 8, 0, data, size, USB_CNTL_TIMEOUT); 862 } 863 864 int usb_clear_hub_feature(struct usb_device *dev, int feature) 865 { 866 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 867 USB_REQ_CLEAR_FEATURE, USB_RT_HUB, feature, 0, NULL, 0, USB_CNTL_TIMEOUT); 868 } 869 870 int usb_clear_port_feature(struct usb_device *dev, int port, int feature) 871 { 872 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 873 USB_REQ_CLEAR_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT); 874 } 875 876 int usb_set_port_feature(struct usb_device *dev, int port, int feature) 877 { 878 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 879 USB_REQ_SET_FEATURE, USB_RT_PORT, feature, port, NULL, 0, USB_CNTL_TIMEOUT); 880 } 881 882 int usb_get_hub_status(struct usb_device *dev, void *data) 883 { 884 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 885 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_HUB, 0, 0, 886 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 887 } 888 889 int usb_get_port_status(struct usb_device *dev, int port, void *data) 890 { 891 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 892 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RT_PORT, 0, port, 893 data, sizeof(struct usb_hub_status), USB_CNTL_TIMEOUT); 894 } 895 896 897 static void usb_hub_power_on(struct usb_hub_device *hub) 898 { 899 int i; 900 struct usb_device *dev; 901 902 dev=hub->pusb_dev; 903 /* Enable power to the ports */ 904 USB_HUB_PRINTF("enabling power on all ports\n"); 905 for (i = 0; i < dev->maxchild; i++) { 906 usb_set_port_feature(dev, i + 1, USB_PORT_FEAT_POWER); 907 USB_HUB_PRINTF("port %d returns %lX\n",i+1,dev->status); 908 wait_ms(hub->desc.bPwrOn2PwrGood * 2); 909 } 910 } 911 912 void usb_hub_reset(void) 913 { 914 usb_hub_index=0; 915 } 916 917 struct usb_hub_device *usb_hub_allocate(void) 918 { 919 if(usb_hub_index<USB_MAX_HUB) { 920 return &hub_dev[usb_hub_index++]; 921 } 922 printf("ERROR: USB_MAX_HUB (%d) reached\n",USB_MAX_HUB); 923 return NULL; 924 } 925 926 #define MAX_TRIES 5 927 928 static int hub_port_reset(struct usb_device *dev, int port, 929 unsigned short *portstat) 930 { 931 int tries; 932 struct usb_port_status portsts; 933 unsigned short portstatus, portchange; 934 935 936 USB_HUB_PRINTF("hub_port_reset: resetting port %d...\n", port); 937 for(tries=0;tries<MAX_TRIES;tries++) { 938 939 usb_set_port_feature(dev, port + 1, USB_PORT_FEAT_RESET); 940 wait_ms(200); 941 942 if (usb_get_port_status(dev, port + 1, &portsts)<0) { 943 USB_HUB_PRINTF("get_port_status failed status %lX\n",dev->status); 944 return -1; 945 } 946 portstatus = swap_16(portsts.wPortStatus); 947 portchange = swap_16(portsts.wPortChange); 948 USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus ,portchange, 949 portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed"); 950 USB_HUB_PRINTF("STAT_C_CONNECTION = %d STAT_CONNECTION = %d USB_PORT_STAT_ENABLE %d\n", 951 (portchange & USB_PORT_STAT_C_CONNECTION) ? 1 : 0, 952 (portstatus & USB_PORT_STAT_CONNECTION) ? 1 : 0, 953 (portstatus & USB_PORT_STAT_ENABLE) ? 1 : 0); 954 if ((portchange & USB_PORT_STAT_C_CONNECTION) || 955 !(portstatus & USB_PORT_STAT_CONNECTION)) 956 return -1; 957 958 if (portstatus & USB_PORT_STAT_ENABLE) { 959 break; 960 } 961 962 wait_ms(200); 963 } 964 965 if (tries==MAX_TRIES) { 966 USB_HUB_PRINTF("Cannot enable port %i after %i retries, disabling port.\n", port+1, MAX_TRIES); 967 USB_HUB_PRINTF("Maybe the USB cable is bad?\n"); 968 return -1; 969 } 970 971 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_RESET); 972 *portstat = portstatus; 973 return 0; 974 975 } 976 977 978 void usb_hub_port_connect_change(struct usb_device *dev, int port) 979 { 980 struct usb_device *usb; 981 struct usb_port_status portsts; 982 unsigned short portstatus, portchange; 983 984 /* Check status */ 985 if (usb_get_port_status(dev, port + 1, &portsts)<0) { 986 USB_HUB_PRINTF("get_port_status failed\n"); 987 return; 988 } 989 990 portstatus = swap_16(portsts.wPortStatus); 991 portchange = swap_16(portsts.wPortChange); 992 USB_HUB_PRINTF("portstatus %x, change %x, %s\n", portstatus, portchange, 993 portstatus&(1<<USB_PORT_FEAT_LOWSPEED) ? "Low Speed" : "High Speed"); 994 995 /* Clear the connection change status */ 996 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_C_CONNECTION); 997 998 /* Disconnect any existing devices under this port */ 999 if (((!(portstatus & USB_PORT_STAT_CONNECTION)) && 1000 (!(portstatus & USB_PORT_STAT_ENABLE)))|| (dev->children[port])) { 1001 USB_HUB_PRINTF("usb_disconnect(&hub->children[port]);\n"); 1002 /* Return now if nothing is connected */ 1003 if (!(portstatus & USB_PORT_STAT_CONNECTION)) 1004 return; 1005 } 1006 wait_ms(200); 1007 1008 /* Reset the port */ 1009 if (hub_port_reset(dev, port, &portstatus) < 0) { 1010 printf("cannot reset port %i!?\n", port + 1); 1011 return; 1012 } 1013 1014 wait_ms(200); 1015 1016 /* Allocate a new device struct for it */ 1017 usb=usb_alloc_new_device(); 1018 usb->slow = (portstatus & USB_PORT_STAT_LOW_SPEED) ? 1 : 0; 1019 1020 dev->children[port] = usb; 1021 usb->parent=dev; 1022 /* Run it through the hoops (find a driver, etc) */ 1023 if (usb_new_device(usb)) { 1024 /* Woops, disable the port */ 1025 USB_HUB_PRINTF("hub: disabling port %d\n", port + 1); 1026 usb_clear_port_feature(dev, port + 1, USB_PORT_FEAT_ENABLE); 1027 } 1028 } 1029 1030 1031 int usb_hub_configure(struct usb_device *dev) 1032 { 1033 unsigned char buffer[USB_BUFSIZ], *bitmap; 1034 struct usb_hub_descriptor *descriptor; 1035 struct usb_hub_status *hubsts; 1036 int i; 1037 struct usb_hub_device *hub; 1038 1039 /* "allocate" Hub device */ 1040 hub=usb_hub_allocate(); 1041 if(hub==NULL) 1042 return -1; 1043 hub->pusb_dev=dev; 1044 /* Get the the hub descriptor */ 1045 if (usb_get_hub_descriptor(dev, buffer, 4) < 0) { 1046 USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor, giving up %lX\n",dev->status); 1047 return -1; 1048 } 1049 descriptor = (struct usb_hub_descriptor *)buffer; 1050 1051 /* silence compiler warning if USB_BUFSIZ is > 256 [= sizeof(char)] */ 1052 i = descriptor->bLength; 1053 if (i > USB_BUFSIZ) { 1054 USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor - too long: %d\N", 1055 descriptor->bLength); 1056 return -1; 1057 } 1058 1059 if (usb_get_hub_descriptor(dev, buffer, descriptor->bLength) < 0) { 1060 USB_HUB_PRINTF("usb_hub_configure: failed to get hub descriptor 2nd giving up %lX\n",dev->status); 1061 return -1; 1062 } 1063 memcpy((unsigned char *)&hub->desc,buffer,descriptor->bLength); 1064 /* adjust 16bit values */ 1065 hub->desc.wHubCharacteristics=swap_16(descriptor->wHubCharacteristics); 1066 /* set the bitmap */ 1067 bitmap=(unsigned char *)&hub->desc.DeviceRemovable[0]; 1068 memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* devices not removable by default */ 1069 bitmap=(unsigned char *)&hub->desc.PortPowerCtrlMask[0]; 1070 memset(bitmap,0xff,(USB_MAXCHILDREN+1+7)/8); /* PowerMask = 1B */ 1071 for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) { 1072 hub->desc.DeviceRemovable[i]=descriptor->DeviceRemovable[i]; 1073 } 1074 for(i=0;i<((hub->desc.bNbrPorts + 1 + 7)/8);i++) { 1075 hub->desc.DeviceRemovable[i]=descriptor->PortPowerCtrlMask[i]; 1076 } 1077 dev->maxchild = descriptor->bNbrPorts; 1078 USB_HUB_PRINTF("%d ports detected\n", dev->maxchild); 1079 1080 switch (hub->desc.wHubCharacteristics & HUB_CHAR_LPSM) { 1081 case 0x00: 1082 USB_HUB_PRINTF("ganged power switching\n"); 1083 break; 1084 case 0x01: 1085 USB_HUB_PRINTF("individual port power switching\n"); 1086 break; 1087 case 0x02: 1088 case 0x03: 1089 USB_HUB_PRINTF("unknown reserved power switching mode\n"); 1090 break; 1091 } 1092 1093 if (hub->desc.wHubCharacteristics & HUB_CHAR_COMPOUND) 1094 USB_HUB_PRINTF("part of a compound device\n"); 1095 else 1096 USB_HUB_PRINTF("standalone hub\n"); 1097 1098 switch (hub->desc.wHubCharacteristics & HUB_CHAR_OCPM) { 1099 case 0x00: 1100 USB_HUB_PRINTF("global over-current protection\n"); 1101 break; 1102 case 0x08: 1103 USB_HUB_PRINTF("individual port over-current protection\n"); 1104 break; 1105 case 0x10: 1106 case 0x18: 1107 USB_HUB_PRINTF("no over-current protection\n"); 1108 break; 1109 } 1110 USB_HUB_PRINTF("power on to power good time: %dms\n", descriptor->bPwrOn2PwrGood * 2); 1111 USB_HUB_PRINTF("hub controller current requirement: %dmA\n", descriptor->bHubContrCurrent); 1112 for (i = 0; i < dev->maxchild; i++) 1113 USB_HUB_PRINTF("port %d is%s removable\n", i + 1, 1114 hub->desc.DeviceRemovable[(i + 1)/8] & (1 << ((i + 1)%8)) ? " not" : ""); 1115 if (sizeof(struct usb_hub_status) > USB_BUFSIZ) { 1116 USB_HUB_PRINTF("usb_hub_configure: failed to get Status - too long: %d\n", 1117 descriptor->bLength); 1118 return -1; 1119 } 1120 1121 if (usb_get_hub_status(dev, buffer) < 0) { 1122 USB_HUB_PRINTF("usb_hub_configure: failed to get Status %lX\n",dev->status); 1123 return -1; 1124 } 1125 hubsts = (struct usb_hub_status *)buffer; 1126 USB_HUB_PRINTF("get_hub_status returned status %X, change %X\n", 1127 swap_16(hubsts->wHubStatus),swap_16(hubsts->wHubChange)); 1128 USB_HUB_PRINTF("local power source is %s\n", 1129 (swap_16(hubsts->wHubStatus) & HUB_STATUS_LOCAL_POWER) ? "lost (inactive)" : "good"); 1130 USB_HUB_PRINTF("%sover-current condition exists\n", 1131 (swap_16(hubsts->wHubStatus) & HUB_STATUS_OVERCURRENT) ? "" : "no "); 1132 usb_hub_power_on(hub); 1133 for (i = 0; i < dev->maxchild; i++) { 1134 struct usb_port_status portsts; 1135 unsigned short portstatus, portchange; 1136 1137 if (usb_get_port_status(dev, i + 1, &portsts) < 0) { 1138 USB_HUB_PRINTF("get_port_status failed\n"); 1139 continue; 1140 } 1141 portstatus = swap_16(portsts.wPortStatus); 1142 portchange = swap_16(portsts.wPortChange); 1143 USB_HUB_PRINTF("Port %d Status %X Change %X\n",i+1,portstatus,portchange); 1144 if (portchange & USB_PORT_STAT_C_CONNECTION) { 1145 USB_HUB_PRINTF("port %d connection change\n", i + 1); 1146 usb_hub_port_connect_change(dev, i); 1147 } 1148 if (portchange & USB_PORT_STAT_C_ENABLE) { 1149 USB_HUB_PRINTF("port %d enable change, status %x\n", i + 1, portstatus); 1150 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_ENABLE); 1151 1152 /* EM interference sometimes causes bad shielded USB devices to 1153 * be shutdown by the hub, this hack enables them again. 1154 * Works at least with mouse driver */ 1155 if (!(portstatus & USB_PORT_STAT_ENABLE) && 1156 (portstatus & USB_PORT_STAT_CONNECTION) && (dev->children[i])) { 1157 USB_HUB_PRINTF("already running port %i disabled by hub (EMI?), re-enabling...\n", 1158 i + 1); 1159 usb_hub_port_connect_change(dev, i); 1160 } 1161 } 1162 if (portstatus & USB_PORT_STAT_SUSPEND) { 1163 USB_HUB_PRINTF("port %d suspend change\n", i + 1); 1164 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_SUSPEND); 1165 } 1166 1167 if (portchange & USB_PORT_STAT_C_OVERCURRENT) { 1168 USB_HUB_PRINTF("port %d over-current change\n", i + 1); 1169 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_OVER_CURRENT); 1170 usb_hub_power_on(hub); 1171 } 1172 1173 if (portchange & USB_PORT_STAT_C_RESET) { 1174 USB_HUB_PRINTF("port %d reset change\n", i + 1); 1175 usb_clear_port_feature(dev, i + 1, USB_PORT_FEAT_C_RESET); 1176 } 1177 } /* end for i all ports */ 1178 1179 return 0; 1180 } 1181 1182 int usb_hub_probe(struct usb_device *dev, int ifnum) 1183 { 1184 struct usb_interface_descriptor *iface; 1185 struct usb_endpoint_descriptor *ep; 1186 int ret; 1187 1188 iface = &dev->config.if_desc[ifnum]; 1189 /* Is it a hub? */ 1190 if (iface->bInterfaceClass != USB_CLASS_HUB) 1191 return 0; 1192 /* Some hubs have a subclass of 1, which AFAICT according to the */ 1193 /* specs is not defined, but it works */ 1194 if ((iface->bInterfaceSubClass != 0) && 1195 (iface->bInterfaceSubClass != 1)) 1196 return 0; 1197 /* Multiple endpoints? What kind of mutant ninja-hub is this? */ 1198 if (iface->bNumEndpoints != 1) 1199 return 0; 1200 ep = &iface->ep_desc[0]; 1201 /* Output endpoint? Curiousier and curiousier.. */ 1202 if (!(ep->bEndpointAddress & USB_DIR_IN)) 1203 return 0; 1204 /* If it's not an interrupt endpoint, we'd better punt! */ 1205 if ((ep->bmAttributes & 3) != 3) 1206 return 0; 1207 /* We found a hub */ 1208 USB_HUB_PRINTF("USB hub found\n"); 1209 ret=usb_hub_configure(dev); 1210 return ret; 1211 } 1212 1213 #endif /* (CONFIG_COMMANDS & CFG_CMD_USB) */ 1214 1215 /* EOF */ 1216