1 /* 2 * (C) Copyright 2001 3 * Denis Peter, MPL AG Switzerland 4 * 5 * Adapted for U-Boot driver model 6 * (C) Copyright 2015 Google, Inc 7 * 8 * Most of this source has been derived from the Linux USB 9 * project. 10 * 11 * SPDX-License-Identifier: GPL-2.0+ 12 */ 13 14 #include <common.h> 15 #include <command.h> 16 #include <console.h> 17 #include <dm.h> 18 #include <dm/uclass-internal.h> 19 #include <memalign.h> 20 #include <asm/byteorder.h> 21 #include <asm/unaligned.h> 22 #include <part.h> 23 #include <usb.h> 24 25 #ifdef CONFIG_USB_STORAGE 26 static int usb_stor_curr_dev = -1; /* current device */ 27 #endif 28 #if defined(CONFIG_USB_HOST_ETHER) && !defined(CONFIG_DM_ETH) 29 static int __maybe_unused usb_ether_curr_dev = -1; /* current ethernet device */ 30 #endif 31 32 /* some display routines (info command) */ 33 static char *usb_get_class_desc(unsigned char dclass) 34 { 35 switch (dclass) { 36 case USB_CLASS_PER_INTERFACE: 37 return "See Interface"; 38 case USB_CLASS_AUDIO: 39 return "Audio"; 40 case USB_CLASS_COMM: 41 return "Communication"; 42 case USB_CLASS_HID: 43 return "Human Interface"; 44 case USB_CLASS_PRINTER: 45 return "Printer"; 46 case USB_CLASS_MASS_STORAGE: 47 return "Mass Storage"; 48 case USB_CLASS_HUB: 49 return "Hub"; 50 case USB_CLASS_DATA: 51 return "CDC Data"; 52 case USB_CLASS_VENDOR_SPEC: 53 return "Vendor specific"; 54 default: 55 return ""; 56 } 57 } 58 59 static void usb_display_class_sub(unsigned char dclass, unsigned char subclass, 60 unsigned char proto) 61 { 62 switch (dclass) { 63 case USB_CLASS_PER_INTERFACE: 64 printf("See Interface"); 65 break; 66 case USB_CLASS_HID: 67 printf("Human Interface, Subclass: "); 68 switch (subclass) { 69 case USB_SUB_HID_NONE: 70 printf("None"); 71 break; 72 case USB_SUB_HID_BOOT: 73 printf("Boot "); 74 switch (proto) { 75 case USB_PROT_HID_NONE: 76 printf("None"); 77 break; 78 case USB_PROT_HID_KEYBOARD: 79 printf("Keyboard"); 80 break; 81 case USB_PROT_HID_MOUSE: 82 printf("Mouse"); 83 break; 84 default: 85 printf("reserved"); 86 break; 87 } 88 break; 89 default: 90 printf("reserved"); 91 break; 92 } 93 break; 94 case USB_CLASS_MASS_STORAGE: 95 printf("Mass Storage, "); 96 switch (subclass) { 97 case US_SC_RBC: 98 printf("RBC "); 99 break; 100 case US_SC_8020: 101 printf("SFF-8020i (ATAPI)"); 102 break; 103 case US_SC_QIC: 104 printf("QIC-157 (Tape)"); 105 break; 106 case US_SC_UFI: 107 printf("UFI"); 108 break; 109 case US_SC_8070: 110 printf("SFF-8070"); 111 break; 112 case US_SC_SCSI: 113 printf("Transp. SCSI"); 114 break; 115 default: 116 printf("reserved"); 117 break; 118 } 119 printf(", "); 120 switch (proto) { 121 case US_PR_CB: 122 printf("Command/Bulk"); 123 break; 124 case US_PR_CBI: 125 printf("Command/Bulk/Int"); 126 break; 127 case US_PR_BULK: 128 printf("Bulk only"); 129 break; 130 default: 131 printf("reserved"); 132 break; 133 } 134 break; 135 default: 136 printf("%s", usb_get_class_desc(dclass)); 137 break; 138 } 139 } 140 141 static void usb_display_string(struct usb_device *dev, int index) 142 { 143 ALLOC_CACHE_ALIGN_BUFFER(char, buffer, 256); 144 145 if (index != 0) { 146 if (usb_string(dev, index, &buffer[0], 256) > 0) 147 printf("String: \"%s\"", buffer); 148 } 149 } 150 151 static void usb_display_desc(struct usb_device *dev) 152 { 153 if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) { 154 printf("%d: %s, USB Revision %x.%x\n", dev->devnum, 155 usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass), 156 (dev->descriptor.bcdUSB>>8) & 0xff, 157 dev->descriptor.bcdUSB & 0xff); 158 159 if (strlen(dev->mf) || strlen(dev->prod) || 160 strlen(dev->serial)) 161 printf(" - %s %s %s\n", dev->mf, dev->prod, 162 dev->serial); 163 if (dev->descriptor.bDeviceClass) { 164 printf(" - Class: "); 165 usb_display_class_sub(dev->descriptor.bDeviceClass, 166 dev->descriptor.bDeviceSubClass, 167 dev->descriptor.bDeviceProtocol); 168 printf("\n"); 169 } else { 170 printf(" - Class: (from Interface) %s\n", 171 usb_get_class_desc( 172 dev->config.if_desc[0].desc.bInterfaceClass)); 173 } 174 printf(" - PacketSize: %d Configurations: %d\n", 175 dev->descriptor.bMaxPacketSize0, 176 dev->descriptor.bNumConfigurations); 177 printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n", 178 dev->descriptor.idVendor, dev->descriptor.idProduct, 179 (dev->descriptor.bcdDevice>>8) & 0xff, 180 dev->descriptor.bcdDevice & 0xff); 181 } 182 183 } 184 185 static void usb_display_conf_desc(struct usb_config_descriptor *config, 186 struct usb_device *dev) 187 { 188 printf(" Configuration: %d\n", config->bConfigurationValue); 189 printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces, 190 (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ", 191 (config->bmAttributes & 0x20) ? "Remote Wakeup " : "", 192 config->bMaxPower*2); 193 if (config->iConfiguration) { 194 printf(" - "); 195 usb_display_string(dev, config->iConfiguration); 196 printf("\n"); 197 } 198 } 199 200 static void usb_display_if_desc(struct usb_interface_descriptor *ifdesc, 201 struct usb_device *dev) 202 { 203 printf(" Interface: %d\n", ifdesc->bInterfaceNumber); 204 printf(" - Alternate Setting %d, Endpoints: %d\n", 205 ifdesc->bAlternateSetting, ifdesc->bNumEndpoints); 206 printf(" - Class "); 207 usb_display_class_sub(ifdesc->bInterfaceClass, 208 ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol); 209 printf("\n"); 210 if (ifdesc->iInterface) { 211 printf(" - "); 212 usb_display_string(dev, ifdesc->iInterface); 213 printf("\n"); 214 } 215 } 216 217 static void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc) 218 { 219 printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf, 220 (epdesc->bEndpointAddress & 0x80) ? "In" : "Out"); 221 switch ((epdesc->bmAttributes & 0x03)) { 222 case 0: 223 printf("Control"); 224 break; 225 case 1: 226 printf("Isochronous"); 227 break; 228 case 2: 229 printf("Bulk"); 230 break; 231 case 3: 232 printf("Interrupt"); 233 break; 234 } 235 printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize)); 236 if ((epdesc->bmAttributes & 0x03) == 0x3) 237 printf(" Interval %dms", epdesc->bInterval); 238 printf("\n"); 239 } 240 241 /* main routine to diasplay the configs, interfaces and endpoints */ 242 static void usb_display_config(struct usb_device *dev) 243 { 244 struct usb_config *config; 245 struct usb_interface *ifdesc; 246 struct usb_endpoint_descriptor *epdesc; 247 int i, ii; 248 249 config = &dev->config; 250 usb_display_conf_desc(&config->desc, dev); 251 for (i = 0; i < config->no_of_if; i++) { 252 ifdesc = &config->if_desc[i]; 253 usb_display_if_desc(&ifdesc->desc, dev); 254 for (ii = 0; ii < ifdesc->no_of_ep; ii++) { 255 epdesc = &ifdesc->ep_desc[ii]; 256 usb_display_ep_desc(epdesc); 257 } 258 } 259 printf("\n"); 260 } 261 262 /* 263 * With driver model this isn't right since we can have multiple controllers 264 * and the device numbering starts at 1 on each bus. 265 * TODO(sjg@chromium.org): Add a way to specify the controller/bus. 266 */ 267 static struct usb_device *usb_find_device(int devnum) 268 { 269 #ifdef CONFIG_DM_USB 270 struct usb_device *udev; 271 struct udevice *hub; 272 struct uclass *uc; 273 int ret; 274 275 /* Device addresses start at 1 */ 276 devnum++; 277 ret = uclass_get(UCLASS_USB_HUB, &uc); 278 if (ret) 279 return NULL; 280 281 uclass_foreach_dev(hub, uc) { 282 struct udevice *dev; 283 284 if (!device_active(hub)) 285 continue; 286 udev = dev_get_parent_priv(hub); 287 if (udev->devnum == devnum) 288 return udev; 289 290 for (device_find_first_child(hub, &dev); 291 dev; 292 device_find_next_child(&dev)) { 293 if (!device_active(hub)) 294 continue; 295 296 udev = dev_get_parent_priv(dev); 297 if (udev->devnum == devnum) 298 return udev; 299 } 300 } 301 #else 302 struct usb_device *udev; 303 int d; 304 305 for (d = 0; d < USB_MAX_DEVICE; d++) { 306 udev = usb_get_dev_index(d); 307 if (udev == NULL) 308 return NULL; 309 if (udev->devnum == devnum) 310 return udev; 311 } 312 #endif 313 314 return NULL; 315 } 316 317 static inline char *portspeed(int speed) 318 { 319 char *speed_str; 320 321 switch (speed) { 322 case USB_SPEED_SUPER: 323 speed_str = "5 Gb/s"; 324 break; 325 case USB_SPEED_HIGH: 326 speed_str = "480 Mb/s"; 327 break; 328 case USB_SPEED_LOW: 329 speed_str = "1.5 Mb/s"; 330 break; 331 default: 332 speed_str = "12 Mb/s"; 333 break; 334 } 335 336 return speed_str; 337 } 338 339 /* shows the device tree recursively */ 340 static void usb_show_tree_graph(struct usb_device *dev, char *pre) 341 { 342 int index; 343 int has_child, last_child; 344 345 index = strlen(pre); 346 printf(" %s", pre); 347 #ifdef CONFIG_DM_USB 348 has_child = device_has_active_children(dev->dev); 349 #else 350 /* check if the device has connected children */ 351 int i; 352 353 has_child = 0; 354 for (i = 0; i < dev->maxchild; i++) { 355 if (dev->children[i] != NULL) 356 has_child = 1; 357 } 358 #endif 359 /* check if we are the last one */ 360 #ifdef CONFIG_DM_USB 361 /* Not the root of the usb tree? */ 362 if (device_get_uclass_id(dev->dev->parent) != UCLASS_USB) { 363 last_child = device_is_last_sibling(dev->dev); 364 #else 365 if (dev->parent != NULL) { /* not root? */ 366 last_child = 1; 367 for (i = 0; i < dev->parent->maxchild; i++) { 368 /* search for children */ 369 if (dev->parent->children[i] == dev) { 370 /* found our pointer, see if we have a 371 * little sister 372 */ 373 while (i++ < dev->parent->maxchild) { 374 if (dev->parent->children[i] != NULL) { 375 /* found a sister */ 376 last_child = 0; 377 break; 378 } /* if */ 379 } /* while */ 380 } /* device found */ 381 } /* for all children of the parent */ 382 #endif 383 printf("\b+-"); 384 /* correct last child */ 385 if (last_child && index) 386 pre[index-1] = ' '; 387 } /* if not root hub */ 388 else 389 printf(" "); 390 printf("%d ", dev->devnum); 391 pre[index++] = ' '; 392 pre[index++] = has_child ? '|' : ' '; 393 pre[index] = 0; 394 printf(" %s (%s, %dmA)\n", usb_get_class_desc( 395 dev->config.if_desc[0].desc.bInterfaceClass), 396 portspeed(dev->speed), 397 dev->config.desc.bMaxPower * 2); 398 if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial)) 399 printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial); 400 printf(" %s\n", pre); 401 #ifdef CONFIG_DM_USB 402 struct udevice *child; 403 404 for (device_find_first_child(dev->dev, &child); 405 child; 406 device_find_next_child(&child)) { 407 struct usb_device *udev; 408 409 if (!device_active(child)) 410 continue; 411 412 udev = dev_get_parent_priv(child); 413 414 /* Ignore emulators, we only want real devices */ 415 if (device_get_uclass_id(child) != UCLASS_USB_EMUL) { 416 usb_show_tree_graph(udev, pre); 417 pre[index] = 0; 418 } 419 } 420 #else 421 if (dev->maxchild > 0) { 422 for (i = 0; i < dev->maxchild; i++) { 423 if (dev->children[i] != NULL) { 424 usb_show_tree_graph(dev->children[i], pre); 425 pre[index] = 0; 426 } 427 } 428 } 429 #endif 430 } 431 432 /* main routine for the tree command */ 433 static void usb_show_subtree(struct usb_device *dev) 434 { 435 char preamble[32]; 436 437 memset(preamble, '\0', sizeof(preamble)); 438 usb_show_tree_graph(dev, &preamble[0]); 439 } 440 441 void usb_show_tree(void) 442 { 443 #ifdef CONFIG_DM_USB 444 struct udevice *bus; 445 446 for (uclass_find_first_device(UCLASS_USB, &bus); 447 bus; 448 uclass_find_next_device(&bus)) { 449 struct usb_device *udev; 450 struct udevice *dev; 451 452 if (!device_active(bus)) 453 continue; 454 455 device_find_first_child(bus, &dev); 456 if (dev && device_active(dev)) { 457 udev = dev_get_parent_priv(dev); 458 usb_show_subtree(udev); 459 } 460 } 461 #else 462 struct usb_device *udev; 463 int i; 464 465 for (i = 0; i < USB_MAX_DEVICE; i++) { 466 udev = usb_get_dev_index(i); 467 if (udev == NULL) 468 break; 469 if (udev->parent == NULL) 470 usb_show_subtree(udev); 471 } 472 #endif 473 } 474 475 static int usb_test(struct usb_device *dev, int port, char* arg) 476 { 477 int mode; 478 479 if (port > dev->maxchild) { 480 printf("Device is no hub or does not have %d ports.\n", port); 481 return 1; 482 } 483 484 switch (arg[0]) { 485 case 'J': 486 case 'j': 487 printf("Setting Test_J mode"); 488 mode = USB_TEST_MODE_J; 489 break; 490 case 'K': 491 case 'k': 492 printf("Setting Test_K mode"); 493 mode = USB_TEST_MODE_K; 494 break; 495 case 'S': 496 case 's': 497 printf("Setting Test_SE0_NAK mode"); 498 mode = USB_TEST_MODE_SE0_NAK; 499 break; 500 case 'P': 501 case 'p': 502 printf("Setting Test_Packet mode"); 503 mode = USB_TEST_MODE_PACKET; 504 break; 505 case 'F': 506 case 'f': 507 printf("Setting Test_Force_Enable mode"); 508 mode = USB_TEST_MODE_FORCE_ENABLE; 509 break; 510 default: 511 printf("Unrecognized test mode: %s\nAvailable modes: " 512 "J, K, S[E0_NAK], P[acket], F[orce_Enable]\n", arg); 513 return 1; 514 } 515 516 if (port) 517 printf(" on downstream facing port %d...\n", port); 518 else 519 printf(" on upstream facing port...\n"); 520 521 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_FEATURE, 522 port ? USB_RT_PORT : USB_RECIP_DEVICE, 523 port ? USB_PORT_FEAT_TEST : USB_FEAT_TEST, 524 (mode << 8) | port, 525 NULL, 0, USB_CNTL_TIMEOUT) == -1) { 526 printf("Error during SET_FEATURE.\n"); 527 return 1; 528 } else { 529 printf("Test mode successfully set. Use 'usb start' " 530 "to return to normal operation.\n"); 531 return 0; 532 } 533 } 534 535 536 /****************************************************************************** 537 * usb boot command intepreter. Derived from diskboot 538 */ 539 #ifdef CONFIG_USB_STORAGE 540 static int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 541 { 542 return common_diskboot(cmdtp, "usb", argc, argv); 543 } 544 #endif /* CONFIG_USB_STORAGE */ 545 546 static int do_usb_stop_keyboard(int force) 547 { 548 #if !defined CONFIG_DM_USB && defined CONFIG_USB_KEYBOARD 549 if (usb_kbd_deregister(force) != 0) { 550 printf("USB not stopped: usbkbd still using USB\n"); 551 return 1; 552 } 553 #endif 554 return 0; 555 } 556 557 static void do_usb_start(void) 558 { 559 bootstage_mark_name(BOOTSTAGE_ID_USB_START, "usb_start"); 560 561 if (usb_init() < 0) 562 return; 563 564 /* Driver model will probe the devices as they are found */ 565 #ifndef CONFIG_DM_USB 566 # ifdef CONFIG_USB_STORAGE 567 /* try to recognize storage devices immediately */ 568 usb_stor_curr_dev = usb_stor_scan(1); 569 # endif 570 # ifdef CONFIG_USB_KEYBOARD 571 drv_usb_kbd_init(); 572 # endif 573 #endif /* !CONFIG_DM_USB */ 574 #ifdef CONFIG_USB_HOST_ETHER 575 # ifdef CONFIG_DM_ETH 576 # ifndef CONFIG_DM_USB 577 # error "You must use CONFIG_DM_USB if you want to use CONFIG_USB_HOST_ETHER with CONFIG_DM_ETH" 578 # endif 579 # else 580 /* try to recognize ethernet devices immediately */ 581 usb_ether_curr_dev = usb_host_eth_scan(1); 582 # endif 583 #endif 584 } 585 586 #ifdef CONFIG_DM_USB 587 static void show_info(struct udevice *dev) 588 { 589 struct udevice *child; 590 struct usb_device *udev; 591 592 udev = dev_get_parent_priv(dev); 593 usb_display_desc(udev); 594 usb_display_config(udev); 595 for (device_find_first_child(dev, &child); 596 child; 597 device_find_next_child(&child)) { 598 if (device_active(child)) 599 show_info(child); 600 } 601 } 602 603 static int usb_device_info(void) 604 { 605 struct udevice *bus; 606 607 for (uclass_first_device(UCLASS_USB, &bus); 608 bus; 609 uclass_next_device(&bus)) { 610 struct udevice *hub; 611 612 device_find_first_child(bus, &hub); 613 if (device_get_uclass_id(hub) == UCLASS_USB_HUB && 614 device_active(hub)) { 615 show_info(hub); 616 } 617 } 618 619 return 0; 620 } 621 #endif 622 623 /****************************************************************************** 624 * usb command intepreter 625 */ 626 static int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) 627 { 628 struct usb_device *udev = NULL; 629 int i; 630 extern char usb_started; 631 #ifdef CONFIG_USB_STORAGE 632 struct blk_desc *stor_dev; 633 #endif 634 635 if (argc < 2) 636 return CMD_RET_USAGE; 637 638 if (strncmp(argv[1], "start", 5) == 0) { 639 if (usb_started) 640 return 0; /* Already started */ 641 printf("starting USB...\n"); 642 do_usb_start(); 643 return 0; 644 } 645 646 if (strncmp(argv[1], "reset", 5) == 0) { 647 printf("resetting USB...\n"); 648 if (do_usb_stop_keyboard(1) != 0) 649 return 1; 650 usb_stop(); 651 do_usb_start(); 652 return 0; 653 } 654 if (strncmp(argv[1], "stop", 4) == 0) { 655 if (argc != 2) 656 console_assign(stdin, "serial"); 657 if (do_usb_stop_keyboard(0) != 0) 658 return 1; 659 printf("stopping USB..\n"); 660 usb_stop(); 661 return 0; 662 } 663 if (!usb_started) { 664 printf("USB is stopped. Please issue 'usb start' first.\n"); 665 return 1; 666 } 667 if (strncmp(argv[1], "tree", 4) == 0) { 668 puts("USB device tree:\n"); 669 usb_show_tree(); 670 return 0; 671 } 672 if (strncmp(argv[1], "inf", 3) == 0) { 673 if (argc == 2) { 674 #ifdef CONFIG_DM_USB 675 usb_device_info(); 676 #else 677 int d; 678 for (d = 0; d < USB_MAX_DEVICE; d++) { 679 udev = usb_get_dev_index(d); 680 if (udev == NULL) 681 break; 682 usb_display_desc(udev); 683 usb_display_config(udev); 684 } 685 #endif 686 return 0; 687 } else { 688 /* 689 * With driver model this isn't right since we can 690 * have multiple controllers and the device numbering 691 * starts at 1 on each bus. 692 */ 693 i = simple_strtoul(argv[2], NULL, 10); 694 printf("config for device %d\n", i); 695 udev = usb_find_device(i); 696 if (udev == NULL) { 697 printf("*** No device available ***\n"); 698 return 0; 699 } else { 700 usb_display_desc(udev); 701 usb_display_config(udev); 702 } 703 } 704 return 0; 705 } 706 if (strncmp(argv[1], "test", 4) == 0) { 707 if (argc < 5) 708 return CMD_RET_USAGE; 709 i = simple_strtoul(argv[2], NULL, 10); 710 udev = usb_find_device(i); 711 if (udev == NULL) { 712 printf("Device %d does not exist.\n", i); 713 return 1; 714 } 715 i = simple_strtoul(argv[3], NULL, 10); 716 return usb_test(udev, i, argv[4]); 717 } 718 #ifdef CONFIG_USB_STORAGE 719 if (strncmp(argv[1], "stor", 4) == 0) 720 return usb_stor_info(); 721 722 if (strncmp(argv[1], "part", 4) == 0) { 723 int devno, ok = 0; 724 if (argc == 2) { 725 for (devno = 0; ; ++devno) { 726 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, 727 devno); 728 if (stor_dev == NULL) 729 break; 730 if (stor_dev->type != DEV_TYPE_UNKNOWN) { 731 ok++; 732 if (devno) 733 printf("\n"); 734 debug("print_part of %x\n", devno); 735 part_print(stor_dev); 736 } 737 } 738 } else { 739 devno = simple_strtoul(argv[2], NULL, 16); 740 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, devno); 741 if (stor_dev != NULL && 742 stor_dev->type != DEV_TYPE_UNKNOWN) { 743 ok++; 744 debug("print_part of %x\n", devno); 745 part_print(stor_dev); 746 } 747 } 748 if (!ok) { 749 printf("\nno USB devices available\n"); 750 return 1; 751 } 752 return 0; 753 } 754 if (strcmp(argv[1], "read") == 0) { 755 if (usb_stor_curr_dev < 0) { 756 printf("no current device selected\n"); 757 return 1; 758 } 759 if (argc == 5) { 760 unsigned long addr = simple_strtoul(argv[2], NULL, 16); 761 unsigned long blk = simple_strtoul(argv[3], NULL, 16); 762 unsigned long cnt = simple_strtoul(argv[4], NULL, 16); 763 unsigned long n; 764 printf("\nUSB read: device %d block # %ld, count %ld" 765 " ... ", usb_stor_curr_dev, blk, cnt); 766 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, 767 usb_stor_curr_dev); 768 n = blk_dread(stor_dev, blk, cnt, (ulong *)addr); 769 printf("%ld blocks read: %s\n", n, 770 (n == cnt) ? "OK" : "ERROR"); 771 if (n == cnt) 772 return 0; 773 return 1; 774 } 775 } 776 if (strcmp(argv[1], "write") == 0) { 777 if (usb_stor_curr_dev < 0) { 778 printf("no current device selected\n"); 779 return 1; 780 } 781 if (argc == 5) { 782 unsigned long addr = simple_strtoul(argv[2], NULL, 16); 783 unsigned long blk = simple_strtoul(argv[3], NULL, 16); 784 unsigned long cnt = simple_strtoul(argv[4], NULL, 16); 785 unsigned long n; 786 printf("\nUSB write: device %d block # %ld, count %ld" 787 " ... ", usb_stor_curr_dev, blk, cnt); 788 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, 789 usb_stor_curr_dev); 790 n = blk_dwrite(stor_dev, blk, cnt, (ulong *)addr); 791 printf("%ld blocks write: %s\n", n, 792 (n == cnt) ? "OK" : "ERROR"); 793 if (n == cnt) 794 return 0; 795 return 1; 796 } 797 } 798 if (strncmp(argv[1], "dev", 3) == 0) { 799 if (argc == 3) { 800 int dev = (int)simple_strtoul(argv[2], NULL, 10); 801 printf("\nUSB device %d: ", dev); 802 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, dev); 803 if (stor_dev == NULL) { 804 printf("unknown device\n"); 805 return 1; 806 } 807 printf("\n Device %d: ", dev); 808 dev_print(stor_dev); 809 if (stor_dev->type == DEV_TYPE_UNKNOWN) 810 return 1; 811 usb_stor_curr_dev = dev; 812 printf("... is now current device\n"); 813 return 0; 814 } else { 815 printf("\nUSB device %d: ", usb_stor_curr_dev); 816 stor_dev = blk_get_devnum_by_type(IF_TYPE_USB, 817 usb_stor_curr_dev); 818 dev_print(stor_dev); 819 if (stor_dev->type == DEV_TYPE_UNKNOWN) 820 return 1; 821 return 0; 822 } 823 return 0; 824 } 825 #endif /* CONFIG_USB_STORAGE */ 826 return CMD_RET_USAGE; 827 } 828 829 U_BOOT_CMD( 830 usb, 5, 1, do_usb, 831 "USB sub-system", 832 "start - start (scan) USB controller\n" 833 "usb reset - reset (rescan) USB controller\n" 834 "usb stop [f] - stop USB [f]=force stop\n" 835 "usb tree - show USB device tree\n" 836 "usb info [dev] - show available USB devices\n" 837 "usb test [dev] [port] [mode] - set USB 2.0 test mode\n" 838 " (specify port 0 to indicate the device's upstream port)\n" 839 " Available modes: J, K, S[E0_NAK], P[acket], F[orce_Enable]\n" 840 #ifdef CONFIG_USB_STORAGE 841 "usb storage - show details of USB storage devices\n" 842 "usb dev [dev] - show or set current USB storage device\n" 843 "usb part [dev] - print partition table of one or all USB storage" 844 " devices\n" 845 "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n" 846 " to memory address `addr'\n" 847 "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n" 848 " from memory address `addr'" 849 #endif /* CONFIG_USB_STORAGE */ 850 ); 851 852 853 #ifdef CONFIG_USB_STORAGE 854 U_BOOT_CMD( 855 usbboot, 3, 1, do_usbboot, 856 "boot from USB device", 857 "loadAddr dev:part" 858 ); 859 #endif /* CONFIG_USB_STORAGE */ 860