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