]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * BSD host USB redirector | |
3 | * | |
4 | * Copyright (c) 2006 Lonnie Mendez | |
5 | * Portions of code and concepts borrowed from | |
6 | * usb-linux.c and libusb's bsd.c and are copyright their respective owners. | |
7 | * | |
8 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
9 | * of this software and associated documentation files (the "Software"), to deal | |
10 | * in the Software without restriction, including without limitation the rights | |
11 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
12 | * copies of the Software, and to permit persons to whom the Software is | |
13 | * furnished to do so, subject to the following conditions: | |
14 | * | |
15 | * The above copyright notice and this permission notice shall be included in | |
16 | * all copies or substantial portions of the Software. | |
17 | * | |
18 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
19 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
20 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
21 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
22 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
23 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
24 | * THE SOFTWARE. | |
25 | */ | |
26 | ||
27 | #include "qemu-common.h" | |
28 | #include "monitor.h" | |
29 | #include "hw/usb.h" | |
30 | ||
31 | /* usb.h declares these */ | |
32 | #undef USB_SPEED_HIGH | |
33 | #undef USB_SPEED_FULL | |
34 | #undef USB_SPEED_LOW | |
35 | ||
36 | #include <sys/ioctl.h> | |
37 | #ifndef __DragonFly__ | |
38 | #include <dev/usb/usb.h> | |
39 | #else | |
40 | #include <bus/usb/usb.h> | |
41 | #endif | |
42 | ||
43 | /* This value has maximum potential at 16. | |
44 | * You should also set hw.usb.debug to gain | |
45 | * more detailed view. | |
46 | */ | |
47 | //#define DEBUG | |
48 | #define UGEN_DEBUG_LEVEL 0 | |
49 | ||
50 | ||
51 | typedef int USBScanFunc(void *opaque, int bus_num, int addr, int class_id, | |
52 | int vendor_id, int product_id, | |
53 | const char *product_name, int speed); | |
54 | static int usb_host_find_device(int *pbus_num, int *paddr, | |
55 | const char *devname); | |
56 | ||
57 | typedef struct USBHostDevice { | |
58 | USBDevice dev; | |
59 | int ep_fd[USB_MAX_ENDPOINTS]; | |
60 | int devfd; | |
61 | char devpath[32]; | |
62 | } USBHostDevice; | |
63 | ||
64 | ||
65 | #if 0 | |
66 | static int ensure_ep_open(USBHostDevice *dev, int ep, int mode) | |
67 | { | |
68 | char buf[32]; | |
69 | int fd; | |
70 | ||
71 | /* Get the address for this endpoint */ | |
72 | ep = UE_GET_ADDR(ep); | |
73 | ||
74 | if (dev->ep_fd[ep] < 0) { | |
75 | #if defined(__FreeBSD__) || defined(__DragonFly__) | |
76 | snprintf(buf, sizeof(buf) - 1, "%s.%d", dev->devpath, ep); | |
77 | #else | |
78 | snprintf(buf, sizeof(buf) - 1, "%s.%02d", dev->devpath, ep); | |
79 | #endif | |
80 | /* Try to open it O_RDWR first for those devices which have in and out | |
81 | * endpoints with the same address (eg 0x02 and 0x82) | |
82 | */ | |
83 | fd = open(buf, O_RDWR); | |
84 | if (fd < 0 && errno == ENXIO) | |
85 | fd = open(buf, mode); | |
86 | if (fd < 0) { | |
87 | #ifdef DEBUG | |
88 | printf("ensure_ep_open: failed to open device endpoint %s: %s\n", | |
89 | buf, strerror(errno)); | |
90 | #endif | |
91 | } | |
92 | dev->ep_fd[ep] = fd; | |
93 | } | |
94 | ||
95 | return dev->ep_fd[ep]; | |
96 | } | |
97 | ||
98 | static void ensure_eps_closed(USBHostDevice *dev) | |
99 | { | |
100 | int epnum = 1; | |
101 | ||
102 | if (!dev) | |
103 | return; | |
104 | ||
105 | while (epnum < USB_MAX_ENDPOINTS) { | |
106 | if (dev->ep_fd[epnum] >= 0) { | |
107 | close(dev->ep_fd[epnum]); | |
108 | dev->ep_fd[epnum] = -1; | |
109 | } | |
110 | epnum++; | |
111 | } | |
112 | } | |
113 | #endif | |
114 | ||
115 | static void usb_host_handle_reset(USBDevice *dev) | |
116 | { | |
117 | #if 0 | |
118 | USBHostDevice *s = (USBHostDevice *)dev; | |
119 | #endif | |
120 | } | |
121 | ||
122 | #if 0 | |
123 | /* XXX: | |
124 | * -check device states against transfer requests | |
125 | * and return appropriate response | |
126 | */ | |
127 | static int usb_host_handle_control(USBDevice *dev, | |
128 | USBPacket *p, | |
129 | int request, | |
130 | int value, | |
131 | int index, | |
132 | int length, | |
133 | uint8_t *data) | |
134 | { | |
135 | USBHostDevice *s = (USBHostDevice *)dev; | |
136 | struct usb_ctl_request req; | |
137 | struct usb_alt_interface aiface; | |
138 | int ret, timeout = 50; | |
139 | ||
140 | if ((request >> 8) == UT_WRITE_DEVICE && | |
141 | (request & 0xff) == UR_SET_ADDRESS) { | |
142 | ||
143 | /* specific SET_ADDRESS support */ | |
144 | dev->addr = value; | |
145 | return 0; | |
146 | } else if ((request >> 8) == UT_WRITE_DEVICE && | |
147 | (request & 0xff) == UR_SET_CONFIG) { | |
148 | ||
149 | ensure_eps_closed(s); /* can't do this without all eps closed */ | |
150 | ||
151 | ret = ioctl(s->devfd, USB_SET_CONFIG, &value); | |
152 | if (ret < 0) { | |
153 | #ifdef DEBUG | |
154 | printf("handle_control: failed to set configuration - %s\n", | |
155 | strerror(errno)); | |
156 | #endif | |
157 | return USB_RET_STALL; | |
158 | } | |
159 | ||
160 | return 0; | |
161 | } else if ((request >> 8) == UT_WRITE_INTERFACE && | |
162 | (request & 0xff) == UR_SET_INTERFACE) { | |
163 | ||
164 | aiface.uai_interface_index = index; | |
165 | aiface.uai_alt_no = value; | |
166 | ||
167 | ensure_eps_closed(s); /* can't do this without all eps closed */ | |
168 | ret = ioctl(s->devfd, USB_SET_ALTINTERFACE, &aiface); | |
169 | if (ret < 0) { | |
170 | #ifdef DEBUG | |
171 | printf("handle_control: failed to set alternate interface - %s\n", | |
172 | strerror(errno)); | |
173 | #endif | |
174 | return USB_RET_STALL; | |
175 | } | |
176 | ||
177 | return 0; | |
178 | } else { | |
179 | req.ucr_request.bmRequestType = request >> 8; | |
180 | req.ucr_request.bRequest = request & 0xff; | |
181 | USETW(req.ucr_request.wValue, value); | |
182 | USETW(req.ucr_request.wIndex, index); | |
183 | USETW(req.ucr_request.wLength, length); | |
184 | req.ucr_data = data; | |
185 | req.ucr_flags = USBD_SHORT_XFER_OK; | |
186 | ||
187 | ret = ioctl(s->devfd, USB_SET_TIMEOUT, &timeout); | |
188 | #if defined(__NetBSD__) || defined(__OpenBSD__) | |
189 | if (ret < 0 && errno != EINVAL) { | |
190 | #else | |
191 | if (ret < 0) { | |
192 | #endif | |
193 | #ifdef DEBUG | |
194 | printf("handle_control: setting timeout failed - %s\n", | |
195 | strerror(errno)); | |
196 | #endif | |
197 | } | |
198 | ||
199 | ret = ioctl(s->devfd, USB_DO_REQUEST, &req); | |
200 | /* ugen returns EIO for usbd_do_request_ no matter what | |
201 | * happens with the transfer */ | |
202 | if (ret < 0) { | |
203 | #ifdef DEBUG | |
204 | printf("handle_control: error after request - %s\n", | |
205 | strerror(errno)); | |
206 | #endif | |
207 | return USB_RET_NAK; // STALL | |
208 | } else { | |
209 | return req.ucr_actlen; | |
210 | } | |
211 | } | |
212 | } | |
213 | ||
214 | static int usb_host_handle_data(USBDevice *dev, USBPacket *p) | |
215 | { | |
216 | USBHostDevice *s = (USBHostDevice *)dev; | |
217 | int ret, fd, mode; | |
218 | int one = 1, shortpacket = 0, timeout = 50; | |
219 | sigset_t new_mask, old_mask; | |
220 | uint8_t devep = p->devep; | |
221 | ||
222 | /* protect data transfers from SIGALRM signal */ | |
223 | sigemptyset(&new_mask); | |
224 | sigaddset(&new_mask, SIGALRM); | |
225 | sigprocmask(SIG_BLOCK, &new_mask, &old_mask); | |
226 | ||
227 | if (p->pid == USB_TOKEN_IN) { | |
228 | devep |= 0x80; | |
229 | mode = O_RDONLY; | |
230 | shortpacket = 1; | |
231 | } else { | |
232 | mode = O_WRONLY; | |
233 | } | |
234 | ||
235 | fd = ensure_ep_open(s, devep, mode); | |
236 | if (fd < 0) { | |
237 | sigprocmask(SIG_SETMASK, &old_mask, NULL); | |
238 | return USB_RET_NODEV; | |
239 | } | |
240 | ||
241 | if (ioctl(fd, USB_SET_TIMEOUT, &timeout) < 0) { | |
242 | #ifdef DEBUG | |
243 | printf("handle_data: failed to set timeout - %s\n", | |
244 | strerror(errno)); | |
245 | #endif | |
246 | } | |
247 | ||
248 | if (shortpacket) { | |
249 | if (ioctl(fd, USB_SET_SHORT_XFER, &one) < 0) { | |
250 | #ifdef DEBUG | |
251 | printf("handle_data: failed to set short xfer mode - %s\n", | |
252 | strerror(errno)); | |
253 | #endif | |
254 | sigprocmask(SIG_SETMASK, &old_mask, NULL); | |
255 | } | |
256 | } | |
257 | ||
258 | if (p->pid == USB_TOKEN_IN) | |
259 | ret = read(fd, p->data, p->len); | |
260 | else | |
261 | ret = write(fd, p->data, p->len); | |
262 | ||
263 | sigprocmask(SIG_SETMASK, &old_mask, NULL); | |
264 | ||
265 | if (ret < 0) { | |
266 | #ifdef DEBUG | |
267 | printf("handle_data: error after %s data - %s\n", | |
268 | pid == USB_TOKEN_IN ? "reading" : "writing", strerror(errno)); | |
269 | #endif | |
270 | switch(errno) { | |
271 | case ETIMEDOUT: | |
272 | case EINTR: | |
273 | return USB_RET_NAK; | |
274 | default: | |
275 | return USB_RET_STALL; | |
276 | } | |
277 | } else { | |
278 | return ret; | |
279 | } | |
280 | } | |
281 | #endif | |
282 | ||
283 | static void usb_host_handle_destroy(USBDevice *opaque) | |
284 | { | |
285 | USBHostDevice *s = (USBHostDevice *)opaque; | |
286 | int i; | |
287 | ||
288 | for (i = 0; i < USB_MAX_ENDPOINTS; i++) | |
289 | if (s->ep_fd[i] >= 0) | |
290 | close(s->ep_fd[i]); | |
291 | ||
292 | if (s->devfd < 0) | |
293 | return; | |
294 | ||
295 | close(s->devfd); | |
296 | ||
297 | qemu_free(s); | |
298 | } | |
299 | ||
300 | static int usb_host_initfn(USBDevice *dev) | |
301 | { | |
302 | return 0; | |
303 | } | |
304 | ||
305 | USBDevice *usb_host_device_open(const char *devname) | |
306 | { | |
307 | struct usb_device_info bus_info, dev_info; | |
308 | USBDevice *d = NULL; | |
309 | USBHostDevice *dev, *ret = NULL; | |
310 | char ctlpath[PATH_MAX + 1]; | |
311 | char buspath[PATH_MAX + 1]; | |
312 | int bfd, dfd, bus, address, i; | |
313 | int ugendebug = UGEN_DEBUG_LEVEL; | |
314 | ||
315 | if (usb_host_find_device(&bus, &address, devname) < 0) { | |
316 | goto fail; | |
317 | } | |
318 | ||
319 | snprintf(buspath, PATH_MAX, "/dev/usb%d", bus); | |
320 | ||
321 | bfd = open(buspath, O_RDWR); | |
322 | if (bfd < 0) { | |
323 | #ifdef DEBUG | |
324 | printf("usb_host_device_open: failed to open usb bus - %s\n", | |
325 | strerror(errno)); | |
326 | #endif | |
327 | goto fail; | |
328 | } | |
329 | ||
330 | bus_info.udi_addr = address; | |
331 | if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0) { | |
332 | #ifdef DEBUG | |
333 | printf("usb_host_device_open: failed to grab bus information - %s\n", | |
334 | strerror(errno)); | |
335 | #endif | |
336 | goto fail_bfd; | |
337 | } | |
338 | ||
339 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) | |
340 | snprintf(ctlpath, PATH_MAX, "/dev/%s", bus_info.udi_devnames[0]); | |
341 | #else | |
342 | snprintf(ctlpath, PATH_MAX, "/dev/%s.00", bus_info.udi_devnames[0]); | |
343 | #endif | |
344 | ||
345 | dfd = open(ctlpath, O_RDWR); | |
346 | if (dfd < 0) { | |
347 | dfd = open(ctlpath, O_RDONLY); | |
348 | if (dfd < 0) { | |
349 | #ifdef DEBUG | |
350 | printf("usb_host_device_open: failed to open usb device %s - %s\n", | |
351 | ctlpath, strerror(errno)); | |
352 | #endif | |
353 | } | |
354 | goto fail_dfd; | |
355 | } | |
356 | ||
357 | if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0) { | |
358 | #ifdef DEBUG | |
359 | printf("usb_host_device_open: failed to grab device info - %s\n", | |
360 | strerror(errno)); | |
361 | #endif | |
362 | goto fail_dfd; | |
363 | } | |
364 | ||
365 | d = usb_create(NULL /* FIXME */, "usb-host"); | |
366 | dev = DO_UPCAST(USBHostDevice, dev, d); | |
367 | ||
368 | if (dev_info.udi_speed == 1) { | |
369 | dev->dev.speed = USB_SPEED_LOW - 1; | |
370 | } else { | |
371 | dev->dev.speed = USB_SPEED_FULL - 1; | |
372 | } | |
373 | ||
374 | if (strncmp(dev_info.udi_product, "product", 7) != 0) { | |
375 | pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc), | |
376 | dev_info.udi_product); | |
377 | } else { | |
378 | snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc), | |
379 | "host:%s", devname); | |
380 | } | |
381 | ||
382 | pstrcpy(dev->devpath, sizeof(dev->devpath), "/dev/"); | |
383 | pstrcat(dev->devpath, sizeof(dev->devpath), dev_info.udi_devnames[0]); | |
384 | ||
385 | /* Mark the endpoints as not yet open */ | |
386 | for (i = 0; i < USB_MAX_ENDPOINTS; i++) { | |
387 | dev->ep_fd[i] = -1; | |
388 | } | |
389 | ||
390 | ioctl(dfd, USB_SETDEBUG, &ugendebug); | |
391 | ||
392 | ret = (USBDevice *)dev; | |
393 | ||
394 | fail_dfd: | |
395 | close(dfd); | |
396 | fail_bfd: | |
397 | close(bfd); | |
398 | fail: | |
399 | return ret; | |
400 | } | |
401 | ||
402 | static struct USBDeviceInfo usb_host_dev_info = { | |
403 | .product_desc = "USB Host Device", | |
404 | .qdev.name = "usb-host", | |
405 | .qdev.size = sizeof(USBHostDevice), | |
406 | .init = usb_host_initfn, | |
407 | .handle_packet = usb_generic_handle_packet, | |
408 | .handle_reset = usb_host_handle_reset, | |
409 | #if 0 | |
410 | .handle_control = usb_host_handle_control, | |
411 | .handle_data = usb_host_handle_data, | |
412 | #endif | |
413 | .handle_destroy = usb_host_handle_destroy, | |
414 | }; | |
415 | ||
416 | static void usb_host_register_devices(void) | |
417 | { | |
418 | usb_qdev_register(&usb_host_dev_info); | |
419 | } | |
420 | device_init(usb_host_register_devices) | |
421 | ||
422 | static int usb_host_scan(void *opaque, USBScanFunc *func) | |
423 | { | |
424 | struct usb_device_info bus_info; | |
425 | struct usb_device_info dev_info; | |
426 | uint16_t vendor_id, product_id, class_id, speed; | |
427 | int bfd, dfd, bus, address; | |
428 | char busbuf[20], devbuf[20], product_name[256]; | |
429 | int ret = 0; | |
430 | ||
431 | for (bus = 0; bus < 10; bus++) { | |
432 | ||
433 | snprintf(busbuf, sizeof(busbuf) - 1, "/dev/usb%d", bus); | |
434 | bfd = open(busbuf, O_RDWR); | |
435 | if (bfd < 0) | |
436 | continue; | |
437 | ||
438 | for (address = 1; address < 127; address++) { | |
439 | ||
440 | bus_info.udi_addr = address; | |
441 | if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0) | |
442 | continue; | |
443 | ||
444 | /* only list devices that can be used by generic layer */ | |
445 | if (strncmp(bus_info.udi_devnames[0], "ugen", 4) != 0) | |
446 | continue; | |
447 | ||
448 | #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__) | |
449 | snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s", bus_info.udi_devnames[0]); | |
450 | #else | |
451 | snprintf(devbuf, sizeof(devbuf) - 1, "/dev/%s.00", bus_info.udi_devnames[0]); | |
452 | #endif | |
453 | ||
454 | dfd = open(devbuf, O_RDONLY); | |
455 | if (dfd < 0) { | |
456 | #ifdef DEBUG | |
457 | printf("usb_host_scan: couldn't open device %s - %s\n", devbuf, | |
458 | strerror(errno)); | |
459 | #endif | |
460 | continue; | |
461 | } | |
462 | ||
463 | if (ioctl(dfd, USB_GET_DEVICEINFO, &dev_info) < 0) | |
464 | printf("usb_host_scan: couldn't get device information for %s - %s\n", | |
465 | devbuf, strerror(errno)); | |
466 | ||
467 | /* XXX: might need to fixup endianness of word values before copying over */ | |
468 | ||
469 | vendor_id = dev_info.udi_vendorNo; | |
470 | product_id = dev_info.udi_productNo; | |
471 | class_id = dev_info.udi_class; | |
472 | speed = dev_info.udi_speed; | |
473 | ||
474 | if (strncmp(dev_info.udi_product, "product", 7) != 0) | |
475 | pstrcpy(product_name, sizeof(product_name), | |
476 | dev_info.udi_product); | |
477 | else | |
478 | product_name[0] = '\0'; | |
479 | ||
480 | ret = func(opaque, bus, address, class_id, vendor_id, | |
481 | product_id, product_name, speed); | |
482 | ||
483 | close(dfd); | |
484 | ||
485 | if (ret) | |
486 | goto the_end; | |
487 | } | |
488 | ||
489 | close(bfd); | |
490 | } | |
491 | ||
492 | the_end: | |
493 | return ret; | |
494 | } | |
495 | ||
496 | typedef struct FindDeviceState { | |
497 | int vendor_id; | |
498 | int product_id; | |
499 | int bus_num; | |
500 | int addr; | |
501 | } FindDeviceState; | |
502 | ||
503 | static int usb_host_find_device_scan(void *opaque, int bus_num, int addr, | |
504 | int class_id, | |
505 | int vendor_id, int product_id, | |
506 | const char *product_name, int speed) | |
507 | { | |
508 | FindDeviceState *s = opaque; | |
509 | if (vendor_id == s->vendor_id && | |
510 | product_id == s->product_id) { | |
511 | s->bus_num = bus_num; | |
512 | s->addr = addr; | |
513 | return 1; | |
514 | } else { | |
515 | return 0; | |
516 | } | |
517 | } | |
518 | ||
519 | ||
520 | /* the syntax is : | |
521 | 'bus.addr' (decimal numbers) or | |
522 | 'vendor_id:product_id' (hexa numbers) */ | |
523 | static int usb_host_find_device(int *pbus_num, int *paddr, | |
524 | const char *devname) | |
525 | { | |
526 | const char *p; | |
527 | int ret; | |
528 | FindDeviceState fs; | |
529 | ||
530 | p = strchr(devname, '.'); | |
531 | if (p) { | |
532 | *pbus_num = strtoul(devname, NULL, 0); | |
533 | *paddr = strtoul(p + 1, NULL, 0); | |
534 | return 0; | |
535 | } | |
536 | p = strchr(devname, ':'); | |
537 | if (p) { | |
538 | fs.vendor_id = strtoul(devname, NULL, 16); | |
539 | fs.product_id = strtoul(p + 1, NULL, 16); | |
540 | ret = usb_host_scan(&fs, usb_host_find_device_scan); | |
541 | if (ret) { | |
542 | *pbus_num = fs.bus_num; | |
543 | *paddr = fs.addr; | |
544 | return 0; | |
545 | } | |
546 | } | |
547 | return -1; | |
548 | } | |
549 | ||
550 | /**********************/ | |
551 | /* USB host device info */ | |
552 | ||
553 | struct usb_class_info { | |
554 | int class; | |
555 | const char *class_name; | |
556 | }; | |
557 | ||
558 | static const struct usb_class_info usb_class_info[] = { | |
559 | { USB_CLASS_AUDIO, "Audio"}, | |
560 | { USB_CLASS_COMM, "Communication"}, | |
561 | { USB_CLASS_HID, "HID"}, | |
562 | { USB_CLASS_HUB, "Hub" }, | |
563 | { USB_CLASS_PHYSICAL, "Physical" }, | |
564 | { USB_CLASS_PRINTER, "Printer" }, | |
565 | { USB_CLASS_MASS_STORAGE, "Storage" }, | |
566 | { USB_CLASS_CDC_DATA, "Data" }, | |
567 | { USB_CLASS_APP_SPEC, "Application Specific" }, | |
568 | { USB_CLASS_VENDOR_SPEC, "Vendor Specific" }, | |
569 | { USB_CLASS_STILL_IMAGE, "Still Image" }, | |
570 | { USB_CLASS_CSCID, "Smart Card" }, | |
571 | { USB_CLASS_CONTENT_SEC, "Content Security" }, | |
572 | { -1, NULL } | |
573 | }; | |
574 | ||
575 | static const char *usb_class_str(uint8_t class) | |
576 | { | |
577 | const struct usb_class_info *p; | |
578 | for (p = usb_class_info; p->class != -1; p++) { | |
579 | if (p->class == class) | |
580 | break; | |
581 | } | |
582 | return p->class_name; | |
583 | } | |
584 | ||
585 | static void usb_info_device(Monitor *mon, int bus_num, int addr, int class_id, | |
586 | int vendor_id, int product_id, | |
587 | const char *product_name, | |
588 | int speed) | |
589 | { | |
590 | const char *class_str, *speed_str; | |
591 | ||
592 | switch(speed) { | |
593 | case USB_SPEED_LOW: | |
594 | speed_str = "1.5"; | |
595 | break; | |
596 | case USB_SPEED_FULL: | |
597 | speed_str = "12"; | |
598 | break; | |
599 | case USB_SPEED_HIGH: | |
600 | speed_str = "480"; | |
601 | break; | |
602 | default: | |
603 | speed_str = "?"; | |
604 | break; | |
605 | } | |
606 | ||
607 | monitor_printf(mon, " Device %d.%d, speed %s Mb/s\n", | |
608 | bus_num, addr, speed_str); | |
609 | class_str = usb_class_str(class_id); | |
610 | if (class_str) | |
611 | monitor_printf(mon, " %s:", class_str); | |
612 | else | |
613 | monitor_printf(mon, " Class %02x:", class_id); | |
614 | monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id); | |
615 | if (product_name[0] != '\0') | |
616 | monitor_printf(mon, ", %s", product_name); | |
617 | monitor_printf(mon, "\n"); | |
618 | } | |
619 | ||
620 | static int usb_host_info_device(void *opaque, | |
621 | int bus_num, int addr, | |
622 | int class_id, | |
623 | int vendor_id, int product_id, | |
624 | const char *product_name, | |
625 | int speed) | |
626 | { | |
627 | Monitor *mon = opaque; | |
628 | ||
629 | usb_info_device(mon, bus_num, addr, class_id, vendor_id, product_id, | |
630 | product_name, speed); | |
631 | return 0; | |
632 | } | |
633 | ||
634 | void usb_host_info(Monitor *mon) | |
635 | { | |
636 | usb_host_scan(mon, usb_host_info_device); | |
637 | } | |
638 | ||
639 | /* XXX add this */ | |
640 | int usb_host_device_close(const char *devname) | |
641 | { | |
642 | return 0; | |
643 | } |