]>
Commit | Line | Data |
---|---|---|
e887afc9 WD |
1 | /* |
2 | * (C) Copyright 2001 | |
3 | * Denis Peter, MPL AG Switzerland | |
4 | * | |
5 | * Most of this source has been derived from the Linux USB | |
6 | * project. | |
7 | * | |
8 | * See file CREDITS for list of people who contributed to this | |
9 | * project. | |
10 | * | |
11 | * This program is free software; you can redistribute it and/or | |
12 | * modify it under the terms of the GNU General Public License as | |
13 | * published by the Free Software Foundation; either version 2 of | |
14 | * the License, or (at your option) any later version. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | * GNU General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, write to the Free Software | |
23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
24 | * MA 02111-1307 USA | |
25 | * | |
26 | */ | |
27 | ||
28 | #include <common.h> | |
29 | #include <command.h> | |
414eec35 | 30 | #include <asm/byteorder.h> |
b2fb47f1 | 31 | #include <asm/unaligned.h> |
735dd97b | 32 | #include <part.h> |
e887afc9 | 33 | #include <usb.h> |
e887afc9 | 34 | |
1968e615 | 35 | #ifdef CONFIG_USB_STORAGE |
d0ff51ba | 36 | static int usb_stor_curr_dev = -1; /* current device */ |
1968e615 | 37 | #endif |
89d48367 SG |
38 | #ifdef CONFIG_USB_HOST_ETHER |
39 | static int usb_ether_curr_dev = -1; /* current ethernet device */ | |
40 | #endif | |
e887afc9 | 41 | |
a2663ea4 | 42 | /* some display routines (info command) */ |
de39f8c1 | 43 | char *usb_get_class_desc(unsigned char dclass) |
e887afc9 | 44 | { |
de39f8c1 MT |
45 | switch (dclass) { |
46 | case USB_CLASS_PER_INTERFACE: | |
47 | return "See Interface"; | |
48 | case USB_CLASS_AUDIO: | |
49 | return "Audio"; | |
50 | case USB_CLASS_COMM: | |
51 | return "Communication"; | |
52 | case USB_CLASS_HID: | |
53 | return "Human Interface"; | |
54 | case USB_CLASS_PRINTER: | |
55 | return "Printer"; | |
56 | case USB_CLASS_MASS_STORAGE: | |
57 | return "Mass Storage"; | |
58 | case USB_CLASS_HUB: | |
59 | return "Hub"; | |
60 | case USB_CLASS_DATA: | |
61 | return "CDC Data"; | |
62 | case USB_CLASS_VENDOR_SPEC: | |
63 | return "Vendor specific"; | |
64 | default: | |
65 | return ""; | |
e887afc9 WD |
66 | } |
67 | } | |
68 | ||
de39f8c1 MT |
69 | void usb_display_class_sub(unsigned char dclass, unsigned char subclass, |
70 | unsigned char proto) | |
e887afc9 | 71 | { |
de39f8c1 MT |
72 | switch (dclass) { |
73 | case USB_CLASS_PER_INTERFACE: | |
74 | printf("See Interface"); | |
75 | break; | |
76 | case USB_CLASS_HID: | |
77 | printf("Human Interface, Subclass: "); | |
78 | switch (subclass) { | |
79 | case USB_SUB_HID_NONE: | |
80 | printf("None"); | |
e887afc9 | 81 | break; |
de39f8c1 MT |
82 | case USB_SUB_HID_BOOT: |
83 | printf("Boot "); | |
84 | switch (proto) { | |
85 | case USB_PROT_HID_NONE: | |
86 | printf("None"); | |
87 | break; | |
88 | case USB_PROT_HID_KEYBOARD: | |
89 | printf("Keyboard"); | |
90 | break; | |
91 | case USB_PROT_HID_MOUSE: | |
92 | printf("Mouse"); | |
93 | break; | |
94 | default: | |
95 | printf("reserved"); | |
96 | break; | |
e887afc9 WD |
97 | } |
98 | break; | |
de39f8c1 MT |
99 | default: |
100 | printf("reserved"); | |
101 | break; | |
102 | } | |
103 | break; | |
104 | case USB_CLASS_MASS_STORAGE: | |
105 | printf("Mass Storage, "); | |
106 | switch (subclass) { | |
107 | case US_SC_RBC: | |
108 | printf("RBC "); | |
109 | break; | |
110 | case US_SC_8020: | |
111 | printf("SFF-8020i (ATAPI)"); | |
112 | break; | |
113 | case US_SC_QIC: | |
114 | printf("QIC-157 (Tape)"); | |
115 | break; | |
116 | case US_SC_UFI: | |
117 | printf("UFI"); | |
118 | break; | |
119 | case US_SC_8070: | |
120 | printf("SFF-8070"); | |
121 | break; | |
122 | case US_SC_SCSI: | |
123 | printf("Transp. SCSI"); | |
124 | break; | |
125 | default: | |
126 | printf("reserved"); | |
127 | break; | |
128 | } | |
129 | printf(", "); | |
130 | switch (proto) { | |
131 | case US_PR_CB: | |
132 | printf("Command/Bulk"); | |
133 | break; | |
134 | case US_PR_CBI: | |
135 | printf("Command/Bulk/Int"); | |
136 | break; | |
137 | case US_PR_BULK: | |
138 | printf("Bulk only"); | |
e887afc9 WD |
139 | break; |
140 | default: | |
de39f8c1 MT |
141 | printf("reserved"); |
142 | break; | |
143 | } | |
144 | break; | |
145 | default: | |
146 | printf("%s", usb_get_class_desc(dclass)); | |
147 | break; | |
e887afc9 WD |
148 | } |
149 | } | |
150 | ||
de39f8c1 | 151 | void usb_display_string(struct usb_device *dev, int index) |
e887afc9 WD |
152 | { |
153 | char buffer[256]; | |
de39f8c1 MT |
154 | if (index != 0) { |
155 | if (usb_string(dev, index, &buffer[0], 256) > 0) | |
156 | printf("String: \"%s\"", buffer); | |
e887afc9 WD |
157 | } |
158 | } | |
159 | ||
160 | void usb_display_desc(struct usb_device *dev) | |
161 | { | |
de39f8c1 MT |
162 | if (dev->descriptor.bDescriptorType == USB_DT_DEVICE) { |
163 | printf("%d: %s, USB Revision %x.%x\n", dev->devnum, | |
8f8bd565 | 164 | usb_get_class_desc(dev->config.if_desc[0].desc.bInterfaceClass), |
de39f8c1 MT |
165 | (dev->descriptor.bcdUSB>>8) & 0xff, |
166 | dev->descriptor.bcdUSB & 0xff); | |
167 | ||
168 | if (strlen(dev->mf) || strlen(dev->prod) || | |
169 | strlen(dev->serial)) | |
170 | printf(" - %s %s %s\n", dev->mf, dev->prod, | |
171 | dev->serial); | |
e887afc9 WD |
172 | if (dev->descriptor.bDeviceClass) { |
173 | printf(" - Class: "); | |
de39f8c1 MT |
174 | usb_display_class_sub(dev->descriptor.bDeviceClass, |
175 | dev->descriptor.bDeviceSubClass, | |
176 | dev->descriptor.bDeviceProtocol); | |
e887afc9 | 177 | printf("\n"); |
de39f8c1 MT |
178 | } else { |
179 | printf(" - Class: (from Interface) %s\n", | |
180 | usb_get_class_desc( | |
8f8bd565 | 181 | dev->config.if_desc[0].desc.bInterfaceClass)); |
e887afc9 | 182 | } |
de39f8c1 MT |
183 | printf(" - PacketSize: %d Configurations: %d\n", |
184 | dev->descriptor.bMaxPacketSize0, | |
185 | dev->descriptor.bNumConfigurations); | |
186 | printf(" - Vendor: 0x%04x Product 0x%04x Version %d.%d\n", | |
187 | dev->descriptor.idVendor, dev->descriptor.idProduct, | |
188 | (dev->descriptor.bcdDevice>>8) & 0xff, | |
189 | dev->descriptor.bcdDevice & 0xff); | |
e887afc9 WD |
190 | } |
191 | ||
192 | } | |
193 | ||
8f8bd565 | 194 | void usb_display_conf_desc(struct usb_configuration_descriptor *config, |
de39f8c1 | 195 | struct usb_device *dev) |
e887afc9 | 196 | { |
de39f8c1 MT |
197 | printf(" Configuration: %d\n", config->bConfigurationValue); |
198 | printf(" - Interfaces: %d %s%s%dmA\n", config->bNumInterfaces, | |
199 | (config->bmAttributes & 0x40) ? "Self Powered " : "Bus Powered ", | |
200 | (config->bmAttributes & 0x20) ? "Remote Wakeup " : "", | |
8f8bd565 | 201 | config->bMaxPower*2); |
e887afc9 WD |
202 | if (config->iConfiguration) { |
203 | printf(" - "); | |
de39f8c1 | 204 | usb_display_string(dev, config->iConfiguration); |
e887afc9 WD |
205 | printf("\n"); |
206 | } | |
207 | } | |
208 | ||
de39f8c1 MT |
209 | void usb_display_if_desc(struct usb_interface_descriptor *ifdesc, |
210 | struct usb_device *dev) | |
e887afc9 | 211 | { |
de39f8c1 MT |
212 | printf(" Interface: %d\n", ifdesc->bInterfaceNumber); |
213 | printf(" - Alternate Setting %d, Endpoints: %d\n", | |
214 | ifdesc->bAlternateSetting, ifdesc->bNumEndpoints); | |
e887afc9 | 215 | printf(" - Class "); |
de39f8c1 MT |
216 | usb_display_class_sub(ifdesc->bInterfaceClass, |
217 | ifdesc->bInterfaceSubClass, ifdesc->bInterfaceProtocol); | |
e887afc9 WD |
218 | printf("\n"); |
219 | if (ifdesc->iInterface) { | |
220 | printf(" - "); | |
de39f8c1 | 221 | usb_display_string(dev, ifdesc->iInterface); |
e887afc9 WD |
222 | printf("\n"); |
223 | } | |
224 | } | |
225 | ||
226 | void usb_display_ep_desc(struct usb_endpoint_descriptor *epdesc) | |
227 | { | |
de39f8c1 MT |
228 | printf(" - Endpoint %d %s ", epdesc->bEndpointAddress & 0xf, |
229 | (epdesc->bEndpointAddress & 0x80) ? "In" : "Out"); | |
230 | switch ((epdesc->bmAttributes & 0x03)) { | |
231 | case 0: | |
232 | printf("Control"); | |
233 | break; | |
234 | case 1: | |
235 | printf("Isochronous"); | |
236 | break; | |
237 | case 2: | |
238 | printf("Bulk"); | |
239 | break; | |
240 | case 3: | |
241 | printf("Interrupt"); | |
242 | break; | |
e887afc9 | 243 | } |
b2fb47f1 | 244 | printf(" MaxPacket %d", get_unaligned(&epdesc->wMaxPacketSize)); |
de39f8c1 MT |
245 | if ((epdesc->bmAttributes & 0x03) == 0x3) |
246 | printf(" Interval %dms", epdesc->bInterval); | |
e887afc9 WD |
247 | printf("\n"); |
248 | } | |
249 | ||
250 | /* main routine to diasplay the configs, interfaces and endpoints */ | |
251 | void usb_display_config(struct usb_device *dev) | |
252 | { | |
8f8bd565 TR |
253 | struct usb_config *config; |
254 | struct usb_interface *ifdesc; | |
e887afc9 | 255 | struct usb_endpoint_descriptor *epdesc; |
de39f8c1 MT |
256 | int i, ii; |
257 | ||
258 | config = &dev->config; | |
8f8bd565 | 259 | usb_display_conf_desc(&config->desc, dev); |
de39f8c1 MT |
260 | for (i = 0; i < config->no_of_if; i++) { |
261 | ifdesc = &config->if_desc[i]; | |
8f8bd565 | 262 | usb_display_if_desc(&ifdesc->desc, dev); |
de39f8c1 MT |
263 | for (ii = 0; ii < ifdesc->no_of_ep; ii++) { |
264 | epdesc = &ifdesc->ep_desc[ii]; | |
e887afc9 WD |
265 | usb_display_ep_desc(epdesc); |
266 | } | |
267 | } | |
268 | printf("\n"); | |
269 | } | |
270 | ||
f1c1f540 SR |
271 | static inline char *portspeed(int speed) |
272 | { | |
273 | if (speed == USB_SPEED_HIGH) | |
274 | return "480 Mb/s"; | |
275 | else if (speed == USB_SPEED_LOW) | |
276 | return "1.5 Mb/s"; | |
277 | else | |
278 | return "12 Mb/s"; | |
279 | } | |
280 | ||
e887afc9 | 281 | /* shows the device tree recursively */ |
de39f8c1 | 282 | void usb_show_tree_graph(struct usb_device *dev, char *pre) |
e887afc9 | 283 | { |
de39f8c1 | 284 | int i, index; |
10f4dd78 | 285 | int has_child, last_child; |
e887afc9 | 286 | |
de39f8c1 MT |
287 | index = strlen(pre); |
288 | printf(" %s", pre); | |
e887afc9 | 289 | /* check if the device has connected children */ |
de39f8c1 MT |
290 | has_child = 0; |
291 | for (i = 0; i < dev->maxchild; i++) { | |
292 | if (dev->children[i] != NULL) | |
293 | has_child = 1; | |
e887afc9 WD |
294 | } |
295 | /* check if we are the last one */ | |
de39f8c1 MT |
296 | last_child = 1; |
297 | if (dev->parent != NULL) { | |
298 | for (i = 0; i < dev->parent->maxchild; i++) { | |
e887afc9 | 299 | /* search for children */ |
de39f8c1 MT |
300 | if (dev->parent->children[i] == dev) { |
301 | /* found our pointer, see if we have a | |
302 | * little sister | |
303 | */ | |
de39f8c1 MT |
304 | while (i++ < dev->parent->maxchild) { |
305 | if (dev->parent->children[i] != NULL) { | |
e887afc9 | 306 | /* found a sister */ |
de39f8c1 | 307 | last_child = 0; |
e887afc9 WD |
308 | break; |
309 | } /* if */ | |
310 | } /* while */ | |
311 | } /* device found */ | |
312 | } /* for all children of the parent */ | |
313 | printf("\b+-"); | |
314 | /* correct last child */ | |
de39f8c1 MT |
315 | if (last_child) |
316 | pre[index-1] = ' '; | |
e887afc9 WD |
317 | } /* if not root hub */ |
318 | else | |
319 | printf(" "); | |
de39f8c1 MT |
320 | printf("%d ", dev->devnum); |
321 | pre[index++] = ' '; | |
322 | pre[index++] = has_child ? '|' : ' '; | |
323 | pre[index] = 0; | |
324 | printf(" %s (%s, %dmA)\n", usb_get_class_desc( | |
8f8bd565 | 325 | dev->config.if_desc[0].desc.bInterfaceClass), |
f1c1f540 | 326 | portspeed(dev->speed), |
8f8bd565 | 327 | dev->config.desc.bMaxPower * 2); |
de39f8c1 MT |
328 | if (strlen(dev->mf) || strlen(dev->prod) || strlen(dev->serial)) |
329 | printf(" %s %s %s %s\n", pre, dev->mf, dev->prod, dev->serial); | |
330 | printf(" %s\n", pre); | |
331 | if (dev->maxchild > 0) { | |
332 | for (i = 0; i < dev->maxchild; i++) { | |
333 | if (dev->children[i] != NULL) { | |
334 | usb_show_tree_graph(dev->children[i], pre); | |
335 | pre[index] = 0; | |
e887afc9 WD |
336 | } |
337 | } | |
338 | } | |
339 | } | |
340 | ||
341 | /* main routine for the tree command */ | |
342 | void usb_show_tree(struct usb_device *dev) | |
343 | { | |
344 | char preamble[32]; | |
345 | ||
de39f8c1 MT |
346 | memset(preamble, 0, 32); |
347 | usb_show_tree_graph(dev, &preamble[0]); | |
e887afc9 WD |
348 | } |
349 | ||
350 | ||
e887afc9 WD |
351 | /****************************************************************************** |
352 | * usb boot command intepreter. Derived from diskboot | |
353 | */ | |
354 | #ifdef CONFIG_USB_STORAGE | |
54841ab5 | 355 | int do_usbboot(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 WD |
356 | { |
357 | char *boot_device = NULL; | |
358 | char *ep; | |
67d668bf | 359 | int dev, part = 1; |
b97a2a0a | 360 | ulong addr, cnt; |
e887afc9 WD |
361 | disk_partition_t info; |
362 | image_header_t *hdr; | |
363 | block_dev_desc_t *stor_dev; | |
09475f75 | 364 | #if defined(CONFIG_FIT) |
3bab76a2 | 365 | const void *fit_hdr = NULL; |
09475f75 | 366 | #endif |
e887afc9 WD |
367 | |
368 | switch (argc) { | |
369 | case 1: | |
6d0f6bcf | 370 | addr = CONFIG_SYS_LOAD_ADDR; |
de39f8c1 | 371 | boot_device = getenv("bootdevice"); |
e887afc9 WD |
372 | break; |
373 | case 2: | |
374 | addr = simple_strtoul(argv[1], NULL, 16); | |
de39f8c1 | 375 | boot_device = getenv("bootdevice"); |
e887afc9 WD |
376 | break; |
377 | case 3: | |
378 | addr = simple_strtoul(argv[1], NULL, 16); | |
379 | boot_device = argv[2]; | |
380 | break; | |
381 | default: | |
47e26b1b | 382 | return cmd_usage(cmdtp); |
e887afc9 WD |
383 | } |
384 | ||
385 | if (!boot_device) { | |
de39f8c1 | 386 | puts("\n** No boot device **\n"); |
e887afc9 WD |
387 | return 1; |
388 | } | |
389 | ||
390 | dev = simple_strtoul(boot_device, &ep, 16); | |
de39f8c1 | 391 | stor_dev = usb_stor_get_dev(dev); |
aaad108b | 392 | if (stor_dev == NULL || stor_dev->type == DEV_TYPE_UNKNOWN) { |
de39f8c1 | 393 | printf("\n** Device %d not available\n", dev); |
e887afc9 WD |
394 | return 1; |
395 | } | |
de39f8c1 | 396 | if (stor_dev->block_read == NULL) { |
e887afc9 WD |
397 | printf("storage device not initialized. Use usb scan\n"); |
398 | return 1; | |
399 | } | |
400 | if (*ep) { | |
401 | if (*ep != ':') { | |
de39f8c1 | 402 | puts("\n** Invalid boot device, use `dev[:part]' **\n"); |
e887afc9 WD |
403 | return 1; |
404 | } | |
405 | part = simple_strtoul(++ep, NULL, 16); | |
406 | } | |
407 | ||
de39f8c1 | 408 | if (get_partition_info(stor_dev, part, &info)) { |
e887afc9 | 409 | /* try to boot raw .... */ |
de39f8c1 MT |
410 | strncpy((char *)&info.type[0], BOOT_PART_TYPE, |
411 | sizeof(BOOT_PART_TYPE)); | |
77ddac94 | 412 | strncpy((char *)&info.name[0], "Raw", 4); |
de39f8c1 MT |
413 | info.start = 0; |
414 | info.blksz = 0x200; | |
415 | info.size = 2880; | |
e887afc9 WD |
416 | printf("error reading partinfo...try to boot raw\n"); |
417 | } | |
de39f8c1 MT |
418 | if ((strncmp((char *)info.type, BOOT_PART_TYPE, |
419 | sizeof(info.type)) != 0) && | |
420 | (strncmp((char *)info.type, BOOT_PART_COMP, | |
421 | sizeof(info.type)) != 0)) { | |
422 | printf("\n** Invalid partition type \"%.32s\"" | |
e887afc9 WD |
423 | " (expect \"" BOOT_PART_TYPE "\")\n", |
424 | info.type); | |
425 | return 1; | |
426 | } | |
de39f8c1 | 427 | printf("\nLoading from USB device %d, partition %d: " |
e887afc9 WD |
428 | "Name: %.32s Type: %.32s\n", |
429 | dev, part, info.name, info.type); | |
430 | ||
de39f8c1 | 431 | debug("First Block: %ld, # of blocks: %ld, Block Size: %ld\n", |
e887afc9 WD |
432 | info.start, info.size, info.blksz); |
433 | ||
434 | if (stor_dev->block_read(dev, info.start, 1, (ulong *)addr) != 1) { | |
de39f8c1 | 435 | printf("** Read error on %d:%d\n", dev, part); |
e887afc9 WD |
436 | return 1; |
437 | } | |
438 | ||
de39f8c1 | 439 | switch (genimg_get_format((void *)addr)) { |
d5934ad7 MB |
440 | case IMAGE_FORMAT_LEGACY: |
441 | hdr = (image_header_t *)addr; | |
e887afc9 | 442 | |
de39f8c1 MT |
443 | if (!image_check_hcrc(hdr)) { |
444 | puts("\n** Bad Header Checksum **\n"); | |
d5934ad7 MB |
445 | return 1; |
446 | } | |
e887afc9 | 447 | |
de39f8c1 | 448 | image_print_contents(hdr); |
1a344f29 | 449 | |
de39f8c1 | 450 | cnt = image_get_image_size(hdr); |
d5934ad7 MB |
451 | break; |
452 | #if defined(CONFIG_FIT) | |
453 | case IMAGE_FORMAT_FIT: | |
09475f75 | 454 | fit_hdr = (const void *)addr; |
de39f8c1 | 455 | puts("Fit image detected...\n"); |
09475f75 | 456 | |
de39f8c1 | 457 | cnt = fit_get_size(fit_hdr); |
09475f75 | 458 | break; |
d5934ad7 MB |
459 | #endif |
460 | default: | |
de39f8c1 | 461 | puts("** Unknown image type\n"); |
1a344f29 WD |
462 | return 1; |
463 | } | |
464 | ||
1a344f29 WD |
465 | cnt += info.blksz - 1; |
466 | cnt /= info.blksz; | |
467 | cnt -= 1; | |
468 | ||
de39f8c1 | 469 | if (stor_dev->block_read(dev, info.start+1, cnt, |
e887afc9 | 470 | (ulong *)(addr+info.blksz)) != cnt) { |
de39f8c1 | 471 | printf("\n** Read error on %d:%d\n", dev, part); |
e887afc9 WD |
472 | return 1; |
473 | } | |
09475f75 MB |
474 | |
475 | #if defined(CONFIG_FIT) | |
de39f8c1 MT |
476 | /* This cannot be done earlier, we need complete FIT image in RAM |
477 | * first | |
478 | */ | |
479 | if (genimg_get_format((void *)addr) == IMAGE_FORMAT_FIT) { | |
480 | if (!fit_check_format(fit_hdr)) { | |
481 | puts("** Bad FIT image format\n"); | |
3bab76a2 MB |
482 | return 1; |
483 | } | |
de39f8c1 | 484 | fit_print_contents(fit_hdr); |
3bab76a2 | 485 | } |
09475f75 MB |
486 | #endif |
487 | ||
e887afc9 WD |
488 | /* Loading ok, update default load address */ |
489 | load_addr = addr; | |
490 | ||
de39f8c1 | 491 | flush_cache(addr, (cnt+1)*info.blksz); |
e887afc9 | 492 | |
67d668bf | 493 | return bootm_maybe_autostart(cmdtp, argv[0]); |
e887afc9 WD |
494 | } |
495 | #endif /* CONFIG_USB_STORAGE */ | |
496 | ||
497 | ||
de39f8c1 | 498 | /****************************************************************************** |
e887afc9 WD |
499 | * usb command intepreter |
500 | */ | |
54841ab5 | 501 | int do_usb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
e887afc9 WD |
502 | { |
503 | ||
504 | int i; | |
505 | struct usb_device *dev = NULL; | |
e51aae38 | 506 | extern char usb_started; |
1968e615 | 507 | #ifdef CONFIG_USB_STORAGE |
e887afc9 | 508 | block_dev_desc_t *stor_dev; |
1968e615 | 509 | #endif |
e887afc9 | 510 | |
47e26b1b WD |
511 | if (argc < 2) |
512 | return cmd_usage(cmdtp); | |
65d34254 | 513 | |
9c998aa8 | 514 | if ((strncmp(argv[1], "reset", 5) == 0) || |
de39f8c1 | 515 | (strncmp(argv[1], "start", 5) == 0)) { |
e887afc9 WD |
516 | usb_stop(); |
517 | printf("(Re)start USB...\n"); | |
9c998aa8 | 518 | i = usb_init(); |
89d48367 | 519 | if (i >= 0) { |
9c998aa8 | 520 | #ifdef CONFIG_USB_STORAGE |
89d48367 | 521 | /* try to recognize storage devices immediately */ |
53677ef1 | 522 | usb_stor_curr_dev = usb_stor_scan(1); |
9c998aa8 | 523 | #endif |
89d48367 SG |
524 | #ifdef CONFIG_USB_HOST_ETHER |
525 | /* try to recognize ethernet devices immediately */ | |
526 | usb_ether_curr_dev = usb_host_eth_scan(1); | |
527 | #endif | |
528 | } | |
e887afc9 WD |
529 | return 0; |
530 | } | |
de39f8c1 | 531 | if (strncmp(argv[1], "stop", 4) == 0) { |
e887afc9 | 532 | #ifdef CONFIG_USB_KEYBOARD |
de39f8c1 MT |
533 | if (argc == 2) { |
534 | if (usb_kbd_deregister() != 0) { | |
535 | printf("USB not stopped: usbkbd still" | |
536 | " using USB\n"); | |
e887afc9 WD |
537 | return 1; |
538 | } | |
de39f8c1 MT |
539 | } else { |
540 | /* forced stop, switch console in to serial */ | |
541 | console_assign(stdin, "serial"); | |
e887afc9 WD |
542 | usb_kbd_deregister(); |
543 | } | |
544 | #endif | |
545 | printf("stopping USB..\n"); | |
546 | usb_stop(); | |
547 | return 0; | |
548 | } | |
e51aae38 BS |
549 | if (!usb_started) { |
550 | printf("USB is stopped. Please issue 'usb start' first.\n"); | |
551 | return 1; | |
552 | } | |
de39f8c1 | 553 | if (strncmp(argv[1], "tree", 4) == 0) { |
e887afc9 WD |
554 | printf("\nDevice Tree:\n"); |
555 | usb_show_tree(usb_get_dev_index(0)); | |
556 | return 0; | |
557 | } | |
de39f8c1 | 558 | if (strncmp(argv[1], "inf", 3) == 0) { |
e887afc9 | 559 | int d; |
de39f8c1 MT |
560 | if (argc == 2) { |
561 | for (d = 0; d < USB_MAX_DEVICE; d++) { | |
562 | dev = usb_get_dev_index(d); | |
563 | if (dev == NULL) | |
e887afc9 WD |
564 | break; |
565 | usb_display_desc(dev); | |
566 | usb_display_config(dev); | |
567 | } | |
568 | return 0; | |
de39f8c1 | 569 | } else { |
e887afc9 WD |
570 | int d; |
571 | ||
de39f8c1 MT |
572 | i = simple_strtoul(argv[2], NULL, 16); |
573 | printf("config for device %d\n", i); | |
574 | for (d = 0; d < USB_MAX_DEVICE; d++) { | |
575 | dev = usb_get_dev_index(d); | |
576 | if (dev == NULL) | |
e887afc9 | 577 | break; |
de39f8c1 | 578 | if (dev->devnum == i) |
e887afc9 WD |
579 | break; |
580 | } | |
de39f8c1 | 581 | if (dev == NULL) { |
6052cbab | 582 | printf("*** No device available ***\n"); |
e887afc9 | 583 | return 0; |
de39f8c1 | 584 | } else { |
e887afc9 WD |
585 | usb_display_desc(dev); |
586 | usb_display_config(dev); | |
587 | } | |
588 | } | |
589 | return 0; | |
590 | } | |
591 | #ifdef CONFIG_USB_STORAGE | |
de39f8c1 | 592 | if (strncmp(argv[1], "stor", 4) == 0) |
f6b44e0e | 593 | return usb_stor_info(); |
9c998aa8 | 594 | |
de39f8c1 | 595 | if (strncmp(argv[1], "part", 4) == 0) { |
d4b5f3fa | 596 | int devno, ok = 0; |
de39f8c1 | 597 | if (argc == 2) { |
aaad108b | 598 | for (devno = 0; ; ++devno) { |
de39f8c1 | 599 | stor_dev = usb_stor_get_dev(devno); |
aaad108b KH |
600 | if (stor_dev == NULL) |
601 | break; | |
de39f8c1 | 602 | if (stor_dev->type != DEV_TYPE_UNKNOWN) { |
d4b5f3fa CE |
603 | ok++; |
604 | if (devno) | |
605 | printf("\n"); | |
060f2853 | 606 | debug("print_part of %x\n", devno); |
d4b5f3fa CE |
607 | print_part(stor_dev); |
608 | } | |
609 | } | |
de39f8c1 MT |
610 | } else { |
611 | devno = simple_strtoul(argv[2], NULL, 16); | |
612 | stor_dev = usb_stor_get_dev(devno); | |
aaad108b KH |
613 | if (stor_dev != NULL && |
614 | stor_dev->type != DEV_TYPE_UNKNOWN) { | |
e887afc9 | 615 | ok++; |
060f2853 | 616 | debug("print_part of %x\n", devno); |
e887afc9 WD |
617 | print_part(stor_dev); |
618 | } | |
619 | } | |
620 | if (!ok) { | |
621 | printf("\nno USB devices available\n"); | |
622 | return 1; | |
623 | } | |
624 | return 0; | |
625 | } | |
de39f8c1 MT |
626 | if (strcmp(argv[1], "read") == 0) { |
627 | if (usb_stor_curr_dev < 0) { | |
e887afc9 WD |
628 | printf("no current device selected\n"); |
629 | return 1; | |
630 | } | |
de39f8c1 | 631 | if (argc == 5) { |
e887afc9 WD |
632 | unsigned long addr = simple_strtoul(argv[2], NULL, 16); |
633 | unsigned long blk = simple_strtoul(argv[3], NULL, 16); | |
634 | unsigned long cnt = simple_strtoul(argv[4], NULL, 16); | |
635 | unsigned long n; | |
de39f8c1 MT |
636 | printf("\nUSB read: device %d block # %ld, count %ld" |
637 | " ... ", usb_stor_curr_dev, blk, cnt); | |
638 | stor_dev = usb_stor_get_dev(usb_stor_curr_dev); | |
639 | n = stor_dev->block_read(usb_stor_curr_dev, blk, cnt, | |
640 | (ulong *)addr); | |
641 | printf("%ld blocks read: %s\n", n, | |
642 | (n == cnt) ? "OK" : "ERROR"); | |
643 | if (n == cnt) | |
e887afc9 WD |
644 | return 0; |
645 | return 1; | |
646 | } | |
647 | } | |
127e1084 MJ |
648 | if (strcmp(argv[1], "write") == 0) { |
649 | if (usb_stor_curr_dev < 0) { | |
650 | printf("no current device selected\n"); | |
651 | return 1; | |
652 | } | |
653 | if (argc == 5) { | |
654 | unsigned long addr = simple_strtoul(argv[2], NULL, 16); | |
655 | unsigned long blk = simple_strtoul(argv[3], NULL, 16); | |
656 | unsigned long cnt = simple_strtoul(argv[4], NULL, 16); | |
657 | unsigned long n; | |
658 | printf("\nUSB write: device %d block # %ld, count %ld" | |
659 | " ... ", usb_stor_curr_dev, blk, cnt); | |
660 | stor_dev = usb_stor_get_dev(usb_stor_curr_dev); | |
661 | n = stor_dev->block_write(usb_stor_curr_dev, blk, cnt, | |
662 | (ulong *)addr); | |
663 | printf("%ld blocks write: %s\n", n, | |
664 | (n == cnt) ? "OK" : "ERROR"); | |
665 | if (n == cnt) | |
666 | return 0; | |
667 | return 1; | |
668 | } | |
669 | } | |
9c998aa8 WD |
670 | if (strncmp(argv[1], "dev", 3) == 0) { |
671 | if (argc == 3) { | |
e887afc9 | 672 | int dev = (int)simple_strtoul(argv[2], NULL, 10); |
de39f8c1 | 673 | printf("\nUSB device %d: ", dev); |
aaad108b KH |
674 | stor_dev = usb_stor_get_dev(dev); |
675 | if (stor_dev == NULL) { | |
e887afc9 WD |
676 | printf("unknown device\n"); |
677 | return 1; | |
678 | } | |
de39f8c1 | 679 | printf("\n Device %d: ", dev); |
e887afc9 | 680 | dev_print(stor_dev); |
de39f8c1 | 681 | if (stor_dev->type == DEV_TYPE_UNKNOWN) |
e887afc9 | 682 | return 1; |
e887afc9 WD |
683 | usb_stor_curr_dev = dev; |
684 | printf("... is now current device\n"); | |
685 | return 0; | |
de39f8c1 MT |
686 | } else { |
687 | printf("\nUSB device %d: ", usb_stor_curr_dev); | |
688 | stor_dev = usb_stor_get_dev(usb_stor_curr_dev); | |
e887afc9 | 689 | dev_print(stor_dev); |
de39f8c1 | 690 | if (stor_dev->type == DEV_TYPE_UNKNOWN) |
e887afc9 | 691 | return 1; |
e887afc9 WD |
692 | return 0; |
693 | } | |
694 | return 0; | |
695 | } | |
696 | #endif /* CONFIG_USB_STORAGE */ | |
47e26b1b | 697 | return cmd_usage(cmdtp); |
e887afc9 WD |
698 | } |
699 | ||
8bde7f77 | 700 | #ifdef CONFIG_USB_STORAGE |
0d498393 WD |
701 | U_BOOT_CMD( |
702 | usb, 5, 1, do_usb, | |
2fb2604d | 703 | "USB sub-system", |
1af9f963 VPP |
704 | "start - start (scan) USB controller\n" |
705 | "usb reset - reset (rescan) USB controller\n" | |
b3813a22 VPP |
706 | "usb stop [f] - stop USB [f]=force stop\n" |
707 | "usb tree - show USB device tree\n" | |
5cf91d6b | 708 | "usb info [dev] - show available USB devices\n" |
b3813a22 | 709 | "usb storage - show details of USB storage devices\n" |
342717f7 | 710 | "usb dev [dev] - show or set current USB storage device\n" |
de39f8c1 MT |
711 | "usb part [dev] - print partition table of one or all USB storage" |
712 | " devices\n" | |
5cf91d6b | 713 | "usb read addr blk# cnt - read `cnt' blocks starting at block `blk#'\n" |
842404ea | 714 | " to memory address `addr'\n" |
127e1084 MJ |
715 | "usb write addr blk# cnt - write `cnt' blocks starting at block `blk#'\n" |
716 | " from memory address `addr'" | |
8bde7f77 WD |
717 | ); |
718 | ||
719 | ||
0d498393 WD |
720 | U_BOOT_CMD( |
721 | usbboot, 3, 1, do_usbboot, | |
2fb2604d | 722 | "boot from USB device", |
a89c33db | 723 | "loadAddr dev:part" |
8bde7f77 WD |
724 | ); |
725 | ||
726 | #else | |
0d498393 WD |
727 | U_BOOT_CMD( |
728 | usb, 5, 1, do_usb, | |
2fb2604d | 729 | "USB sub-system", |
1af9f963 VPP |
730 | "start - start (scan) USB controller\n" |
731 | "usb reset - reset (rescan) USB controller\n" | |
b3813a22 VPP |
732 | "usb tree - show USB device tree\n" |
733 | "usb info [dev] - show available USB devices" | |
8bde7f77 WD |
734 | ); |
735 | #endif |