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