1// SPDX-License-Identifier: GPL-2.0+ 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 19/* 20 * How it works: 21 * 22 * Since this is a bootloader, the devices will not be automatic 23 * (re)configured on hotplug, but after a restart of the USB the 24 * device should work. 25 * 26 * For each transfer (except "Interrupt") we wait for completion. 27 */ 28#include <common.h> 29#include <command.h> 30#include <dm.h> 31#include <dm/device_compat.h> 32#include <log.h> 33#include <malloc.h> 34#include <memalign.h> 35#include <asm/processor.h> 36#include <linux/compiler.h> 37#include <linux/ctype.h> 38#include <asm/byteorder.h> 39#include <asm/unaligned.h> 40#include <errno.h> 41#include <usb.h> 42#include <linux/delay.h> 43 44#define USB_BUFSIZ 512 45 46static int asynch_allowed; 47bool usb_started; /* flag for the started/stopped USB status */ 48 49#if !CONFIG_IS_ENABLED(DM_USB) 50static struct usb_device usb_dev[USB_MAX_DEVICE]; 51static int dev_index; 52 53/*************************************************************************** 54 * Init USB Device 55 */ 56int usb_init(void) 57{ 58 void *ctrl; 59 struct usb_device *dev; 60 int i, start_index = 0; 61 int controllers_initialized = 0; 62 int ret; 63 64 dev_index = 0; 65 asynch_allowed = 1; 66 usb_hub_reset(); 67 68 /* first make all devices unknown */ 69 for (i = 0; i < USB_MAX_DEVICE; i++) { 70 memset(&usb_dev[i], 0, sizeof(struct usb_device)); 71 usb_dev[i].devnum = -1; 72 } 73 74 /* init low_level USB */ 75 for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) { 76 /* init low_level USB */ 77 printf("USB%d: ", i); 78 ret = usb_lowlevel_init(i, USB_INIT_HOST, &ctrl); 79 if (ret == -ENODEV) { /* No such device. */ 80 puts("Port not available.\n"); 81 controllers_initialized++; 82 continue; 83 } 84 85 if (ret) { /* Other error. */ 86 puts("lowlevel init failed\n"); 87 continue; 88 } 89 /* 90 * lowlevel init is OK, now scan the bus for devices 91 * i.e. search HUBs and configure them 92 */ 93 controllers_initialized++; 94 start_index = dev_index; 95 printf("scanning bus %d for devices... ", i); 96 ret = usb_alloc_new_device(ctrl, &dev); 97 if (ret) 98 break; 99 100 /* 101 * device 0 is always present 102 * (root hub, so let it analyze) 103 */ 104 ret = usb_new_device(dev); 105 if (ret) 106 usb_free_device(dev->controller); 107 108 if (start_index == dev_index) { 109 puts("No USB Device found\n"); 110 continue; 111 } else { 112 printf("%d USB Device(s) found\n", 113 dev_index - start_index); 114 } 115 116 usb_started = 1; 117 } 118 119 debug("scan end\n"); 120 /* if we were not able to find at least one working bus, bail out */ 121 if (controllers_initialized == 0) 122 puts("USB error: all controllers failed lowlevel init\n"); 123 124 return usb_started ? 0 : -ENODEV; 125} 126 127/****************************************************************************** 128 * Stop USB this stops the LowLevel Part and deregisters USB devices. 129 */ 130int usb_stop(void) 131{ 132 int i; 133 134 if (usb_started) { 135 asynch_allowed = 1; 136 usb_started = 0; 137 usb_hub_reset(); 138 139 for (i = 0; i < CONFIG_USB_MAX_CONTROLLER_COUNT; i++) { 140 if (usb_lowlevel_stop(i)) 141 printf("failed to stop USB controller %d\n", i); 142 } 143 } 144 145 return 0; 146} 147 148/****************************************************************************** 149 * Detect if a USB device has been plugged or unplugged. 150 */ 151int usb_detect_change(void) 152{ 153 int i, j; 154 int change = 0; 155 156 for (j = 0; j < USB_MAX_DEVICE; j++) { 157 for (i = 0; i < usb_dev[j].maxchild; i++) { 158 struct usb_port_status status; 159 160 if (usb_get_port_status(&usb_dev[j], i + 1, 161 &status) < 0) 162 /* USB request failed */ 163 continue; 164 165 if (le16_to_cpu(status.wPortChange) & 166 USB_PORT_STAT_C_CONNECTION) 167 change++; 168 } 169 } 170 171 return change; 172} 173 174/* Lock or unlock async schedule on the controller */ 175__weak int usb_lock_async(struct usb_device *dev, int lock) 176{ 177 return 0; 178} 179 180/* 181 * disables the asynch behaviour of the control message. This is used for data 182 * transfers that uses the exclusiv access to the control and bulk messages. 183 * Returns the old value so it can be restored later. 184 */ 185int usb_disable_asynch(int disable) 186{ 187 int old_value = asynch_allowed; 188 189 asynch_allowed = !disable; 190 return old_value; 191} 192#endif /* !CONFIG_IS_ENABLED(DM_USB) */ 193 194 195/*------------------------------------------------------------------- 196 * Message wrappers. 197 * 198 */ 199 200/* 201 * submits an Interrupt Message. Some drivers may implement non-blocking 202 * polling: when non-block is true and the device is not responding return 203 * -EAGAIN instead of waiting for device to respond. 204 */ 205int usb_int_msg(struct usb_device *dev, unsigned long pipe, 206 void *buffer, int transfer_len, int interval, bool nonblock) 207{ 208 return submit_int_msg(dev, pipe, buffer, transfer_len, interval, 209 nonblock); 210} 211 212/* 213 * submits a control message and waits for comletion (at least timeout * 1ms) 214 * If timeout is 0, we don't wait for completion (used as example to set and 215 * clear keyboards LEDs). For data transfers, (storage transfers) we don't 216 * allow control messages with 0 timeout, by previousely resetting the flag 217 * asynch_allowed (usb_disable_asynch(1)). 218 * returns the transferred length if OK or -1 if error. The transferred length 219 * and the current status are stored in the dev->act_len and dev->status. 220 */ 221int usb_control_msg(struct usb_device *dev, unsigned int pipe, 222 unsigned char request, unsigned char requesttype, 223 unsigned short value, unsigned short index, 224 void *data, unsigned short size, int timeout) 225{ 226 ALLOC_CACHE_ALIGN_BUFFER(struct devrequest, setup_packet, 1); 227 int err; 228 229 if ((timeout == 0) && (!asynch_allowed)) { 230 /* request for a asynch control pipe is not allowed */ 231 return -EINVAL; 232 } 233 234 /* set setup command */ 235 setup_packet->requesttype = requesttype; 236 setup_packet->request = request; 237 setup_packet->value = cpu_to_le16(value); 238 setup_packet->index = cpu_to_le16(index); 239 setup_packet->length = cpu_to_le16(size); 240 debug("usb_control_msg: request: 0x%X, requesttype: 0x%X, " \ 241 "value 0x%X index 0x%X length 0x%X\n", 242 request, requesttype, value, index, size); 243 dev->status = USB_ST_NOT_PROC; /*not yet processed */ 244 245 err = submit_control_msg(dev, pipe, data, size, setup_packet); 246 if (err < 0) 247 return err; 248 if (timeout == 0) 249 return (int)size; 250 251 /* 252 * Wait for status to update until timeout expires, USB driver 253 * interrupt handler may set the status when the USB operation has 254 * been completed. 255 */ 256 while (timeout--) { 257 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) 258 break; 259 mdelay(1); 260 } 261 if (dev->status) 262 return -1; 263 264 return dev->act_len; 265 266} 267 268/*------------------------------------------------------------------- 269 * submits bulk message, and waits for completion. returns 0 if Ok or 270 * negative if Error. 271 * synchronous behavior 272 */ 273int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, 274 void *data, int len, int *actual_length, int timeout) 275{ 276 if (len < 0) 277 return -EINVAL; 278 dev->status = USB_ST_NOT_PROC; /*not yet processed */ 279 if (submit_bulk_msg(dev, pipe, data, len) < 0) 280 return -EIO; 281 while (timeout--) { 282 if (!((volatile unsigned long)dev->status & USB_ST_NOT_PROC)) 283 break; 284 mdelay(1); 285 } 286 *actual_length = dev->act_len; 287 if (dev->status == 0) 288 return 0; 289 else 290 return -EIO; 291} 292 293 294/*------------------------------------------------------------------- 295 * Max Packet stuff 296 */ 297 298/* 299 * returns the max packet size, depending on the pipe direction and 300 * the configurations values 301 */ 302int usb_maxpacket(struct usb_device *dev, unsigned long pipe) 303{ 304 /* direction is out -> use emaxpacket out */ 305 if ((pipe & USB_DIR_IN) == 0) 306 return dev->epmaxpacketout[((pipe>>15) & 0xf)]; 307 else 308 return dev->epmaxpacketin[((pipe>>15) & 0xf)]; 309} 310 311/* 312 * The routine usb_set_maxpacket_ep() is extracted from the loop of routine 313 * usb_set_maxpacket(), because the optimizer of GCC 4.x chokes on this routine 314 * when it is inlined in 1 single routine. What happens is that the register r3 315 * is used as loop-count 'i', but gets overwritten later on. 316 * This is clearly a compiler bug, but it is easier to workaround it here than 317 * to update the compiler (Occurs with at least several GCC 4.{1,2},x 318 * CodeSourcery compilers like e.g. 2007q3, 2008q1, 2008q3 lite editions on ARM) 319 * 320 * NOTE: Similar behaviour was observed with GCC4.6 on ARMv5. 321 */ 322static void noinline 323usb_set_maxpacket_ep(struct usb_device *dev, int if_idx, int ep_idx) 324{ 325 int b; 326 struct usb_endpoint_descriptor *ep; 327 u16 ep_wMaxPacketSize; 328 329 ep = &dev->config.if_desc[if_idx].ep_desc[ep_idx]; 330 331 b = ep->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK; 332 ep_wMaxPacketSize = get_unaligned(&ep->wMaxPacketSize); 333 334 if ((ep->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == 335 USB_ENDPOINT_XFER_CONTROL) { 336 /* Control => bidirectional */ 337 dev->epmaxpacketout[b] = ep_wMaxPacketSize; 338 dev->epmaxpacketin[b] = ep_wMaxPacketSize; 339 debug("##Control EP epmaxpacketout/in[%d] = %d\n", 340 b, dev->epmaxpacketin[b]); 341 } else { 342 if ((ep->bEndpointAddress & 0x80) == 0) { 343 /* OUT Endpoint */ 344 if (ep_wMaxPacketSize > dev->epmaxpacketout[b]) { 345 dev->epmaxpacketout[b] = ep_wMaxPacketSize; 346 debug("##EP epmaxpacketout[%d] = %d\n", 347 b, dev->epmaxpacketout[b]); 348 } 349 } else { 350 /* IN Endpoint */ 351 if (ep_wMaxPacketSize > dev->epmaxpacketin[b]) { 352 dev->epmaxpacketin[b] = ep_wMaxPacketSize; 353 debug("##EP epmaxpacketin[%d] = %d\n", 354 b, dev->epmaxpacketin[b]); 355 } 356 } /* if out */ 357 } /* if control */ 358} 359 360/* 361 * set the max packed value of all endpoints in the given configuration 362 */ 363static int usb_set_maxpacket(struct usb_device *dev) 364{ 365 int i, ii; 366 367 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) 368 for (ii = 0; ii < dev->config.if_desc[i].desc.bNumEndpoints; ii++) 369 usb_set_maxpacket_ep(dev, i, ii); 370 371 return 0; 372} 373 374/******************************************************************************* 375 * Parse the config, located in buffer, and fills the dev->config structure. 376 * Note that all little/big endian swapping are done automatically. 377 * (wTotalLength has already been swapped and sanitized when it was read.) 378 */ 379static int usb_parse_config(struct usb_device *dev, 380 unsigned char *buffer, int cfgno) 381{ 382 struct usb_descriptor_header *head; 383 int index, ifno, epno, curr_if_num; 384 u16 ep_wMaxPacketSize; 385 struct usb_interface *if_desc = NULL; 386 387 ifno = -1; 388 epno = -1; 389 curr_if_num = -1; 390 391 dev->configno = cfgno; 392 head = (struct usb_descriptor_header *) &buffer[0]; 393 if (head->bDescriptorType != USB_DT_CONFIG) { 394 printf(" ERROR: NOT USB_CONFIG_DESC %x\n", 395 head->bDescriptorType); 396 return -EINVAL; 397 } 398 if (head->bLength != USB_DT_CONFIG_SIZE) { 399 printf("ERROR: Invalid USB CFG length (%d)\n", head->bLength); 400 return -EINVAL; 401 } 402 memcpy(&dev->config, head, USB_DT_CONFIG_SIZE); 403 dev->config.no_of_if = 0; 404 405 index = dev->config.desc.bLength; 406 /* Ok the first entry must be a configuration entry, 407 * now process the others */ 408 head = (struct usb_descriptor_header *) &buffer[index]; 409 while (index + 1 < dev->config.desc.wTotalLength && head->bLength) { 410 switch (head->bDescriptorType) { 411 case USB_DT_INTERFACE: 412 if (head->bLength != USB_DT_INTERFACE_SIZE) { 413 printf("ERROR: Invalid USB IF length (%d)\n", 414 head->bLength); 415 break; 416 } 417 if (index + USB_DT_INTERFACE_SIZE > 418 dev->config.desc.wTotalLength) { 419 puts("USB IF descriptor overflowed buffer!\n"); 420 break; 421 } 422 if (((struct usb_interface_descriptor *) \ 423 head)->bInterfaceNumber != curr_if_num) { 424 /* this is a new interface, copy new desc */ 425 ifno = dev->config.no_of_if; 426 if (ifno >= USB_MAXINTERFACES) { 427 puts("Too many USB interfaces!\n"); 428 /* try to go on with what we have */ 429 return -EINVAL; 430 } 431 if_desc = &dev->config.if_desc[ifno]; 432 dev->config.no_of_if++; 433 memcpy(if_desc, head, 434 USB_DT_INTERFACE_SIZE); 435 if_desc->no_of_ep = 0; 436 if_desc->num_altsetting = 1; 437 curr_if_num = 438 if_desc->desc.bInterfaceNumber; 439 } else { 440 /* found alternate setting for the interface */ 441 if (ifno >= 0) { 442 if_desc = &dev->config.if_desc[ifno]; 443 if_desc->num_altsetting++; 444 } 445 } 446 break; 447 case USB_DT_ENDPOINT: 448 if (head->bLength != USB_DT_ENDPOINT_SIZE && 449 head->bLength != USB_DT_ENDPOINT_AUDIO_SIZE) { 450 printf("ERROR: Invalid USB EP length (%d)\n", 451 head->bLength); 452 break; 453 } 454 if (index + head->bLength > 455 dev->config.desc.wTotalLength) { 456 puts("USB EP descriptor overflowed buffer!\n"); 457 break; 458 } 459 if (ifno < 0) { 460 puts("Endpoint descriptor out of order!\n"); 461 break; 462 } 463 epno = dev->config.if_desc[ifno].no_of_ep; 464 if_desc = &dev->config.if_desc[ifno]; 465 if (epno >= USB_MAXENDPOINTS) { 466 printf("Interface %d has too many endpoints!\n", 467 if_desc->desc.bInterfaceNumber); 468 return -EINVAL; 469 } 470 /* found an endpoint */ 471 if_desc->no_of_ep++; 472 memcpy(&if_desc->ep_desc[epno], head, 473 USB_DT_ENDPOINT_SIZE); 474 ep_wMaxPacketSize = get_unaligned(&dev->config.\ 475 if_desc[ifno].\ 476 ep_desc[epno].\ 477 wMaxPacketSize); 478 put_unaligned(le16_to_cpu(ep_wMaxPacketSize), 479 &dev->config.\ 480 if_desc[ifno].\ 481 ep_desc[epno].\ 482 wMaxPacketSize); 483 debug("if %d, ep %d\n", ifno, epno); 484 break; 485 case USB_DT_SS_ENDPOINT_COMP: 486 if (head->bLength != USB_DT_SS_EP_COMP_SIZE) { 487 printf("ERROR: Invalid USB EPC length (%d)\n", 488 head->bLength); 489 break; 490 } 491 if (index + USB_DT_SS_EP_COMP_SIZE > 492 dev->config.desc.wTotalLength) { 493 puts("USB EPC descriptor overflowed buffer!\n"); 494 break; 495 } 496 if (ifno < 0 || epno < 0) { 497 puts("EPC descriptor out of order!\n"); 498 break; 499 } 500 if_desc = &dev->config.if_desc[ifno]; 501 memcpy(&if_desc->ss_ep_comp_desc[epno], head, 502 USB_DT_SS_EP_COMP_SIZE); 503 break; 504 default: 505 if (head->bLength == 0) 506 return -EINVAL; 507 508 debug("unknown Description Type : %x\n", 509 head->bDescriptorType); 510 511#ifdef DEBUG 512 { 513 unsigned char *ch = (unsigned char *)head; 514 int i; 515 516 for (i = 0; i < head->bLength; i++) 517 debug("%02X ", *ch++); 518 debug("\n\n\n"); 519 } 520#endif 521 break; 522 } 523 index += head->bLength; 524 head = (struct usb_descriptor_header *)&buffer[index]; 525 } 526 return 0; 527} 528 529/*********************************************************************** 530 * Clears an endpoint 531 * endp: endpoint number in bits 0-3; 532 * direction flag in bit 7 (1 = IN, 0 = OUT) 533 */ 534int usb_clear_halt(struct usb_device *dev, int pipe) 535{ 536 int result; 537 int endp = usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7); 538 539 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 540 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, 541 endp, NULL, 0, USB_CNTL_TIMEOUT * 3); 542 543 /* don't clear if failed */ 544 if (result < 0) 545 return result; 546 547 /* 548 * NOTE: we do not get status and verify reset was successful 549 * as some devices are reported to lock up upon this check.. 550 */ 551 552 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)); 553 554 /* toggle is reset on clear */ 555 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0); 556 return 0; 557} 558 559 560/********************************************************************** 561 * get_descriptor type 562 */ 563static int usb_get_descriptor(struct usb_device *dev, unsigned char type, 564 unsigned char index, void *buf, int size) 565{ 566 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 567 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 568 (type << 8) + index, 0, buf, size, 569 USB_CNTL_TIMEOUT); 570} 571 572/********************************************************************** 573 * gets len of configuration cfgno 574 */ 575int usb_get_configuration_len(struct usb_device *dev, int cfgno) 576{ 577 int result; 578 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, buffer, 9); 579 struct usb_config_descriptor *config; 580 581 config = (struct usb_config_descriptor *)&buffer[0]; 582 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 9); 583 if (result < 9) { 584 if (result < 0) 585 printf("unable to get descriptor, error %lX\n", 586 dev->status); 587 else 588 printf("config descriptor too short " \ 589 "(expected %i, got %i)\n", 9, result); 590 return -EIO; 591 } 592 return le16_to_cpu(config->wTotalLength); 593} 594 595/********************************************************************** 596 * gets configuration cfgno and store it in the buffer 597 */ 598int usb_get_configuration_no(struct usb_device *dev, int cfgno, 599 unsigned char *buffer, int length) 600{ 601 int result; 602 struct usb_config_descriptor *config; 603 604 config = (struct usb_config_descriptor *)&buffer[0]; 605 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, length); 606 debug("get_conf_no %d Result %d, wLength %d\n", cfgno, result, 607 le16_to_cpu(config->wTotalLength)); 608 config->wTotalLength = result; /* validated, with CPU byte order */ 609 610 return result; 611} 612 613/******************************************************************** 614 * set address of a device to the value in dev->devnum. 615 * This can only be done by addressing the device via the default address (0) 616 */ 617static int usb_set_address(struct usb_device *dev) 618{ 619 debug("set address %d\n", dev->devnum); 620 621 return usb_control_msg(dev, usb_snddefctrl(dev), USB_REQ_SET_ADDRESS, 622 0, (dev->devnum), 0, NULL, 0, USB_CNTL_TIMEOUT); 623} 624 625/******************************************************************** 626 * set interface number to interface 627 */ 628int usb_set_interface(struct usb_device *dev, int interface, int alternate) 629{ 630 struct usb_interface *if_face = NULL; 631 int ret, i; 632 633 for (i = 0; i < dev->config.desc.bNumInterfaces; i++) { 634 if (dev->config.if_desc[i].desc.bInterfaceNumber == interface) { 635 if_face = &dev->config.if_desc[i]; 636 break; 637 } 638 } 639 if (!if_face) { 640 printf("selecting invalid interface %d", interface); 641 return -EINVAL; 642 } 643 /* 644 * We should return now for devices with only one alternate setting. 645 * According to 9.4.10 of the Universal Serial Bus Specification 646 * Revision 2.0 such devices can return with a STALL. This results in 647 * some USB sticks timeouting during initialization and then being 648 * unusable in U-Boot. 649 */ 650 if (if_face->num_altsetting == 1) 651 return 0; 652 653 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 654 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, 655 alternate, interface, NULL, 0, 656 USB_CNTL_TIMEOUT * 5); 657 if (ret < 0) 658 return ret; 659 660 return 0; 661} 662 663/******************************************************************** 664 * set configuration number to configuration 665 */ 666static int usb_set_configuration(struct usb_device *dev, int configuration) 667{ 668 int res; 669 debug("set configuration %d\n", configuration); 670 /* set setup command */ 671 res = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 672 USB_REQ_SET_CONFIGURATION, 0, 673 configuration, 0, 674 NULL, 0, USB_CNTL_TIMEOUT); 675 if (res == 0) { 676 dev->toggle[0] = 0; 677 dev->toggle[1] = 0; 678 return 0; 679 } else 680 return -EIO; 681} 682 683/******************************************************************** 684 * set protocol to protocol 685 */ 686int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol) 687{ 688 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 689 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 690 protocol, ifnum, NULL, 0, USB_CNTL_TIMEOUT); 691} 692 693/******************************************************************** 694 * set idle 695 */ 696int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id) 697{ 698 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 699 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE, 700 (duration << 8) | report_id, ifnum, NULL, 0, USB_CNTL_TIMEOUT); 701} 702 703/******************************************************************** 704 * get report 705 */ 706int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, 707 unsigned char id, void *buf, int size) 708{ 709 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 710 USB_REQ_GET_REPORT, 711 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 712 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); 713} 714 715/******************************************************************** 716 * get class descriptor 717 */ 718int usb_get_class_descriptor(struct usb_device *dev, int ifnum, 719 unsigned char type, unsigned char id, void *buf, int size) 720{ 721 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 722 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN, 723 (type << 8) + id, ifnum, buf, size, USB_CNTL_TIMEOUT); 724} 725 726/******************************************************************** 727 * get string index in buffer 728 */ 729static int usb_get_string(struct usb_device *dev, unsigned short langid, 730 unsigned char index, void *buf, int size) 731{ 732 int i; 733 int result; 734 735 for (i = 0; i < 3; ++i) { 736 /* some devices are flaky */ 737 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 738 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN, 739 (USB_DT_STRING << 8) + index, langid, buf, size, 740 USB_CNTL_TIMEOUT); 741 742 if (result > 0) 743 break; 744 } 745 746 return result; 747} 748 749 750static void usb_try_string_workarounds(unsigned char *buf, int *length) 751{ 752 int newlength, oldlength = *length; 753 754 for (newlength = 2; newlength + 1 < oldlength; newlength += 2) 755 if (!isprint(buf[newlength]) || buf[newlength + 1]) 756 break; 757 758 if (newlength > 2) { 759 buf[0] = newlength; 760 *length = newlength; 761 } 762} 763 764 765static int usb_string_sub(struct usb_device *dev, unsigned int langid, 766 unsigned int index, unsigned char *buf) 767{ 768 int rc; 769 770 /* Try to read the string descriptor by asking for the maximum 771 * possible number of bytes */ 772 rc = usb_get_string(dev, langid, index, buf, 255); 773 774 /* If that failed try to read the descriptor length, then 775 * ask for just that many bytes */ 776 if (rc < 2) { 777 rc = usb_get_string(dev, langid, index, buf, 2); 778 if (rc == 2) 779 rc = usb_get_string(dev, langid, index, buf, buf[0]); 780 } 781 782 if (rc >= 2) { 783 if (!buf[0] && !buf[1]) 784 usb_try_string_workarounds(buf, &rc); 785 786 /* There might be extra junk at the end of the descriptor */ 787 if (buf[0] < rc) 788 rc = buf[0]; 789 790 rc = rc - (rc & 1); /* force a multiple of two */ 791 } 792 793 if (rc < 2) 794 rc = -EINVAL; 795 796 return rc; 797} 798 799 800/******************************************************************** 801 * usb_string: 802 * Get string index and translate it to ascii. 803 * returns string length (> 0) or error (< 0) 804 */ 805int usb_string(struct usb_device *dev, int index, char *buf, size_t size) 806{ 807 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, mybuf, USB_BUFSIZ); 808 unsigned char *tbuf; 809 int err; 810 unsigned int u, idx; 811 812 if (size <= 0 || !buf || !index) 813 return -EINVAL; 814 buf[0] = 0; 815 tbuf = &mybuf[0]; 816 817 /* get langid for strings if it's not yet known */ 818 if (!dev->have_langid) { 819 err = usb_string_sub(dev, 0, 0, tbuf); 820 if (err < 0) { 821 debug("error getting string descriptor 0 " \ 822 "(error=%lx)\n", dev->status); 823 return -EIO; 824 } else if (tbuf[0] < 4) { 825 debug("string descriptor 0 too short\n"); 826 return -EIO; 827 } else { 828 dev->have_langid = -1; 829 dev->string_langid = tbuf[2] | (tbuf[3] << 8); 830 /* always use the first langid listed */ 831 debug("USB device number %d default " \ 832 "language ID 0x%x\n", 833 dev->devnum, dev->string_langid); 834 } 835 } 836 837 err = usb_string_sub(dev, dev->string_langid, index, tbuf); 838 if (err < 0) 839 return err; 840 841 size--; /* leave room for trailing NULL char in output buffer */ 842 for (idx = 0, u = 2; u < err; u += 2) { 843 if (idx >= size) 844 break; 845 if (tbuf[u+1]) /* high byte */ 846 buf[idx++] = '?'; /* non-ASCII character */ 847 else 848 buf[idx++] = tbuf[u]; 849 } 850 buf[idx] = 0; 851 err = idx; 852 return err; 853} 854 855 856/******************************************************************** 857 * USB device handling: 858 * the USB device are static allocated [USB_MAX_DEVICE]. 859 */ 860 861#if !CONFIG_IS_ENABLED(DM_USB) 862 863/* returns a pointer to the device with the index [index]. 864 * if the device is not assigned (dev->devnum==-1) returns NULL 865 */ 866struct usb_device *usb_get_dev_index(int index) 867{ 868 if (usb_dev[index].devnum == -1) 869 return NULL; 870 else 871 return &usb_dev[index]; 872} 873 874int usb_alloc_new_device(struct udevice *controller, struct usb_device **devp) 875{ 876 int i; 877 debug("New Device %d\n", dev_index); 878 if (dev_index == USB_MAX_DEVICE) { 879 printf("ERROR, too many USB Devices, max=%d\n", USB_MAX_DEVICE); 880 return -ENOSPC; 881 } 882 /* default Address is 0, real addresses start with 1 */ 883 usb_dev[dev_index].devnum = dev_index + 1; 884 usb_dev[dev_index].maxchild = 0; 885 for (i = 0; i < USB_MAXCHILDREN; i++) 886 usb_dev[dev_index].children[i] = NULL; 887 usb_dev[dev_index].parent = NULL; 888 usb_dev[dev_index].controller = controller; 889 dev_index++; 890 *devp = &usb_dev[dev_index - 1]; 891 892 return 0; 893} 894 895/* 896 * Free the newly created device node. 897 * Called in error cases where configuring a newly attached 898 * device fails for some reason. 899 */ 900void usb_free_device(struct udevice *controller) 901{ 902 dev_index--; 903 debug("Freeing device node: %d\n", dev_index); 904 memset(&usb_dev[dev_index], 0, sizeof(struct usb_device)); 905 usb_dev[dev_index].devnum = -1; 906} 907 908/* 909 * XHCI issues Enable Slot command and thereafter 910 * allocates device contexts. Provide a weak alias 911 * function for the purpose, so that XHCI overrides it 912 * and EHCI/OHCI just work out of the box. 913 */ 914__weak int usb_alloc_device(struct usb_device *udev) 915{ 916 return 0; 917} 918#endif /* !CONFIG_IS_ENABLED(DM_USB) */ 919 920static int usb_hub_port_reset(struct usb_device *dev, struct usb_device *hub) 921{ 922 if (!hub) 923 usb_reset_root_port(dev); 924 925 return 0; 926} 927 928static int get_descriptor_len(struct usb_device *dev, int len, int expect_len) 929{ 930 __maybe_unused struct usb_device_descriptor *desc; 931 ALLOC_CACHE_ALIGN_BUFFER(unsigned char, tmpbuf, USB_BUFSIZ); 932 int err; 933 934 desc = (struct usb_device_descriptor *)tmpbuf; 935 936 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, desc, len); 937 if (err < expect_len) { 938 if (err < 0) { 939 printf("unable to get device descriptor (error=%d)\n", 940 err); 941 return err; 942 } else { 943 printf("USB device descriptor short read (expected %i, got %i)\n", 944 expect_len, err); 945 return -EIO; 946 } 947 } 948 memcpy(&dev->descriptor, tmpbuf, sizeof(dev->descriptor)); 949 950 return 0; 951} 952 953static int usb_setup_descriptor(struct usb_device *dev, bool do_read) 954{ 955 /* 956 * This is a Windows scheme of initialization sequence, with double 957 * reset of the device (Linux uses the same sequence) 958 * Some equipment is said to work only with such init sequence; this 959 * patch is based on the work by Alan Stern: 960 * http://sourceforge.net/mailarchive/forum.php? 961 * thread_id=5729457&forum_id=5398 962 */ 963 964 /* 965 * send 64-byte GET-DEVICE-DESCRIPTOR request. Since the descriptor is 966 * only 18 bytes long, this will terminate with a short packet. But if 967 * the maxpacket size is 8 or 16 the device may be waiting to transmit 968 * some more, or keeps on retransmitting the 8 byte header. 969 */ 970 971 if (dev->speed == USB_SPEED_LOW) { 972 dev->descriptor.bMaxPacketSize0 = 8; 973 dev->maxpacketsize = PACKET_SIZE_8; 974 } else { 975 dev->descriptor.bMaxPacketSize0 = 64; 976 dev->maxpacketsize = PACKET_SIZE_64; 977 } 978 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0; 979 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; 980 981 if (do_read && dev->speed == USB_SPEED_FULL) { 982 int err; 983 984 /* 985 * Validate we've received only at least 8 bytes, not that 986 * we've received the entire descriptor. The reasoning is: 987 * - The code only uses fields in the first 8 bytes, so 988 * that's all we need to have fetched at this stage. 989 * - The smallest maxpacket size is 8 bytes. Before we know 990 * the actual maxpacket the device uses, the USB controller 991 * may only accept a single packet. Consequently we are only 992 * guaranteed to receive 1 packet (at least 8 bytes) even in 993 * a non-error case. 994 * 995 * At least the DWC2 controller needs to be programmed with 996 * the number of packets in addition to the number of bytes. 997 * A request for 64 bytes of data with the maxpacket guessed 998 * as 64 (above) yields a request for 1 packet. 999 */ 1000 err = get_descriptor_len(dev, 64, 8); 1001 if (err) 1002 return err; 1003 1004 /* 1005 * Logitech Unifying Receiver 046d:c52b bcdDevice 12.10 seems 1006 * sensitive about the first Get Descriptor request. If there 1007 * are any other requests in the same microframe, the device 1008 * reports bogus data, first of the descriptor parts is not 1009 * sent to the host. Wait over one microframe duration here 1010 * (1mS for USB 1.x , 125uS for USB 2.0) to avoid triggering 1011 * the issue. 1012 */ 1013 mdelay(1); 1014 } 1015 1016 dev->epmaxpacketin[0] = dev->descriptor.bMaxPacketSize0; 1017 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0; 1018 switch (dev->descriptor.bMaxPacketSize0) { 1019 case 8: 1020 dev->maxpacketsize = PACKET_SIZE_8; 1021 break; 1022 case 16: 1023 dev->maxpacketsize = PACKET_SIZE_16; 1024 break; 1025 case 32: 1026 dev->maxpacketsize = PACKET_SIZE_32; 1027 break; 1028 case 64: 1029 dev->maxpacketsize = PACKET_SIZE_64; 1030 break; 1031 default: 1032 printf("%s: invalid max packet size\n", __func__); 1033 return -EIO; 1034 } 1035 1036 return 0; 1037} 1038 1039static int usb_prepare_device(struct usb_device *dev, int addr, bool do_read, 1040 struct usb_device *parent) 1041{ 1042 int err; 1043 1044 /* 1045 * Allocate usb 3.0 device context. 1046 * USB 3.0 (xHCI) protocol tries to allocate device slot 1047 * and related data structures first. This call does that. 1048 * Refer to sec 4.3.2 in xHCI spec rev1.0 1049 */ 1050 err = usb_alloc_device(dev); 1051 if (err) { 1052 printf("Cannot allocate device context to get SLOT_ID\n"); 1053 return err; 1054 } 1055 err = usb_setup_descriptor(dev, do_read); 1056 if (err) 1057 return err; 1058 err = usb_hub_port_reset(dev, parent); 1059 if (err) 1060 return err; 1061 1062 dev->devnum = addr; 1063 1064 err = usb_set_address(dev); /* set address */ 1065 1066 if (err < 0) { 1067 printf("\n USB device not accepting new address " \ 1068 "(error=%lX)\n", dev->status); 1069 return err; 1070 } 1071 1072 mdelay(10); /* Let the SET_ADDRESS settle */ 1073 1074 /* 1075 * If we haven't read device descriptor before, read it here 1076 * after device is assigned an address. This is only applicable 1077 * to xHCI so far. 1078 */ 1079 if (!do_read) { 1080 err = usb_setup_descriptor(dev, true); 1081 if (err) 1082 return err; 1083 } 1084 1085 return 0; 1086} 1087 1088static int usb_device_is_ignored(u16 id_vendor, u16 id_product) 1089{ 1090 ulong vid, pid; 1091 char *end; 1092 const char *cur = NULL; 1093 1094 /* ignore list depends on env support */ 1095 if (!CONFIG_IS_ENABLED(ENV_SUPPORT)) 1096 return 0; 1097 1098 cur = env_get("usb_ignorelist"); 1099 1100 /* parse "usb_ignorelist" strictly */ 1101 while (cur && cur[0] != '\0') { 1102 vid = simple_strtoul(cur, &end, 0); 1103 /* 1104 * If strtoul did not parse a single digit or the next char is 1105 * not ':' the ignore list is malformed. 1106 */ 1107 if (cur == end || end[0] != ':') 1108 return -EINVAL; 1109 1110 cur = end + 1; 1111 pid = simple_strtoul(cur, &end, 0); 1112 /* Consider '*' as wildcard for the product ID */ 1113 if (cur == end && end[0] == '*') { 1114 pid = U16_MAX + 1; 1115 end++; 1116 } 1117 /* 1118 * The ignore list is malformed if no product ID / wildcard was 1119 * parsed or entries are not separated by ',' or terminated with 1120 * '\0'. 1121 */ 1122 if (cur == end || (end[0] != ',' && end[0] != '\0')) 1123 return -EINVAL; 1124 1125 if (id_vendor == vid && (pid > U16_MAX || id_product == pid)) 1126 return -ENODEV; 1127 1128 if (end[0] == '\0') 1129 break; 1130 cur = end + 1; 1131 } 1132 1133 return 0; 1134} 1135 1136int usb_select_config(struct usb_device *dev) 1137{ 1138 unsigned char *tmpbuf = NULL; 1139 int err; 1140 1141 err = get_descriptor_len(dev, USB_DT_DEVICE_SIZE, USB_DT_DEVICE_SIZE); 1142 if (err) 1143 return err; 1144 1145 /* correct le values */ 1146 le16_to_cpus(&dev->descriptor.bcdUSB); 1147 le16_to_cpus(&dev->descriptor.idVendor); 1148 le16_to_cpus(&dev->descriptor.idProduct); 1149 le16_to_cpus(&dev->descriptor.bcdDevice); 1150 1151 /* ignore devices from usb_ignorelist */ 1152 err = usb_device_is_ignored(dev->descriptor.idVendor, 1153 dev->descriptor.idProduct); 1154 if (err == -ENODEV) { 1155 debug("Ignoring USB device 0x%x:0x%x\n", 1156 dev->descriptor.idVendor, dev->descriptor.idProduct); 1157 return err; 1158 } else if (err == -EINVAL) { 1159 /* 1160 * Continue on "usb_ignorelist" parsing errors. The list is 1161 * parsed for each device returning the error would result in 1162 * ignoring all USB devices. 1163 * Since the parsing error is independent of the probed device 1164 * report errors with printf instead of dev_err. 1165 */ 1166 printf("usb_ignorelist parse error in \"%s\"\n", 1167 env_get("usb_ignorelist")); 1168 } else if (err < 0) { 1169 return err; 1170 } 1171 1172 /* 1173 * Kingston DT Ultimate 32GB USB 3.0 seems to be extremely sensitive 1174 * about this first Get Descriptor request. If there are any other 1175 * requests in the first microframe, the stick crashes. Wait about 1176 * one microframe duration here (1mS for USB 1.x , 125uS for USB 2.0). 1177 */ 1178 mdelay(1); 1179 1180 /* only support for one config for now */ 1181 err = usb_get_configuration_len(dev, 0); 1182 if (err >= 0) { 1183 tmpbuf = (unsigned char *)malloc_cache_aligned(err); 1184 if (!tmpbuf) 1185 err = -ENOMEM; 1186 else 1187 err = usb_get_configuration_no(dev, 0, tmpbuf, err); 1188 } 1189 if (err < 0) { 1190 printf("usb_new_device: Cannot read configuration, " \ 1191 "skipping device %04x:%04x\n", 1192 dev->descriptor.idVendor, dev->descriptor.idProduct); 1193 free(tmpbuf); 1194 return err; 1195 } 1196 usb_parse_config(dev, tmpbuf, 0); 1197 free(tmpbuf); 1198 usb_set_maxpacket(dev); 1199 /* 1200 * we set the default configuration here 1201 * This seems premature. If the driver wants a different configuration 1202 * it will need to select itself. 1203 */ 1204 err = usb_set_configuration(dev, dev->config.desc.bConfigurationValue); 1205 if (err < 0) { 1206 printf("failed to set default configuration " \ 1207 "len %d, status %lX\n", dev->act_len, dev->status); 1208 return err; 1209 } 1210 1211 /* 1212 * Wait until the Set Configuration request gets processed by the 1213 * device. This is required by at least SanDisk Cruzer Pop USB 2.0 1214 * and Kingston DT Ultimate 32GB USB 3.0 on DWC2 OTG controller. 1215 */ 1216 mdelay(10); 1217 1218 debug("new device strings: Mfr=%d, Product=%d, SerialNumber=%d\n", 1219 dev->descriptor.iManufacturer, dev->descriptor.iProduct, 1220 dev->descriptor.iSerialNumber); 1221 memset(dev->mf, 0, sizeof(dev->mf)); 1222 memset(dev->prod, 0, sizeof(dev->prod)); 1223 memset(dev->serial, 0, sizeof(dev->serial)); 1224 if (dev->descriptor.iManufacturer) 1225 usb_string(dev, dev->descriptor.iManufacturer, 1226 dev->mf, sizeof(dev->mf)); 1227 if (dev->descriptor.iProduct) 1228 usb_string(dev, dev->descriptor.iProduct, 1229 dev->prod, sizeof(dev->prod)); 1230 if (dev->descriptor.iSerialNumber) 1231 usb_string(dev, dev->descriptor.iSerialNumber, 1232 dev->serial, sizeof(dev->serial)); 1233 debug("Manufacturer %s\n", dev->mf); 1234 debug("Product %s\n", dev->prod); 1235 debug("SerialNumber %s\n", dev->serial); 1236 1237 return 0; 1238} 1239 1240int usb_setup_device(struct usb_device *dev, bool do_read, 1241 struct usb_device *parent) 1242{ 1243 int addr; 1244 int ret; 1245 1246 /* We still haven't set the Address yet */ 1247 addr = dev->devnum; 1248 dev->devnum = 0; 1249 1250 ret = usb_prepare_device(dev, addr, do_read, parent); 1251 if (ret) 1252 return ret; 1253 ret = usb_select_config(dev); 1254 1255 return ret; 1256} 1257 1258#if !CONFIG_IS_ENABLED(DM_USB) 1259/* 1260 * By the time we get here, the device has gotten a new device ID 1261 * and is in the default state. We need to identify the thing and 1262 * get the ball rolling.. 1263 * 1264 * Returns 0 for success, != 0 for error. 1265 */ 1266int usb_new_device(struct usb_device *dev) 1267{ 1268 bool do_read = true; 1269 int err; 1270 1271 /* 1272 * XHCI needs to issue a Address device command to setup 1273 * proper device context structures, before it can interact 1274 * with the device. So a get_descriptor will fail before any 1275 * of that is done for XHCI unlike EHCI. 1276 */ 1277#ifdef CONFIG_USB_XHCI_HCD 1278 do_read = false; 1279#endif 1280 err = usb_setup_device(dev, do_read, dev->parent); 1281 if (err) 1282 return err; 1283 1284 /* Now probe if the device is a hub */ 1285 err = usb_hub_probe(dev, 0); 1286 if (err < 0) 1287 return err; 1288 1289 return 0; 1290} 1291#endif 1292 1293__weak 1294int board_usb_init(int index, enum usb_init_type init) 1295{ 1296 return 0; 1297} 1298 1299__weak 1300int board_usb_cleanup(int index, enum usb_init_type init) 1301{ 1302 return 0; 1303} 1304 1305bool usb_device_has_child_on_port(struct usb_device *parent, int port) 1306{ 1307#if CONFIG_IS_ENABLED(DM_USB) 1308 return false; 1309#else 1310 return parent->children[port] != NULL; 1311#endif 1312} 1313 1314#if CONFIG_IS_ENABLED(DM_USB) 1315void usb_find_usb2_hub_address_port(struct usb_device *udev, 1316 uint8_t *hub_address, uint8_t *hub_port) 1317{ 1318 struct udevice *parent; 1319 struct usb_device *uparent, *ttdev; 1320 1321 /* 1322 * When called from usb-uclass.c: usb_scan_device() udev->dev points 1323 * to the parent udevice, not the actual udevice belonging to the 1324 * udev as the device is not instantiated yet. So when searching 1325 * for the first usb-2 parent start with udev->dev not 1326 * udev->dev->parent . 1327 */ 1328 ttdev = udev; 1329 parent = udev->dev; 1330 uparent = dev_get_parent_priv(parent); 1331 1332 while (uparent->speed != USB_SPEED_HIGH) { 1333 struct udevice *dev = parent; 1334 1335 if (device_get_uclass_id(dev->parent) != UCLASS_USB_HUB) { 1336 printf("Error: Cannot find high speed parent of usb-1 device\n"); 1337 *hub_address = 0; 1338 *hub_port = 0; 1339 return; 1340 } 1341 1342 ttdev = dev_get_parent_priv(dev); 1343 parent = dev->parent; 1344 uparent = dev_get_parent_priv(parent); 1345 } 1346 *hub_address = uparent->devnum; 1347 *hub_port = ttdev->portnr; 1348} 1349#else 1350void usb_find_usb2_hub_address_port(struct usb_device *udev, 1351 uint8_t *hub_address, uint8_t *hub_port) 1352{ 1353 /* Find out the nearest parent which is high speed */ 1354 while (udev->parent->parent != NULL) 1355 if (udev->parent->speed != USB_SPEED_HIGH) { 1356 udev = udev->parent; 1357 } else { 1358 *hub_address = udev->parent->devnum; 1359 *hub_port = udev->portnr; 1360 return; 1361 } 1362 1363 printf("Error: Cannot find high speed parent of usb-1 device\n"); 1364 *hub_address = 0; 1365 *hub_port = 0; 1366} 1367#endif 1368 1369 1370/* EOF */ 1371