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