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