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