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