virtio-serial-bus: bump up control vq size to 32
[qemu/cris-port.git] / usb-bsd.c
blobabcb60c6f1d63d26a5283778b1eee378fcaaa01f
1 /*
2 * BSD host USB redirector
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.
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:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
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.
27 #include "qemu-common.h"
28 #include "monitor.h"
29 #include "hw/usb.h"
31 /* usb.h declares these */
32 #undef USB_SPEED_HIGH
33 #undef USB_SPEED_FULL
34 #undef USB_SPEED_LOW
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 #include <signal.h>
44 /* This value has maximum potential at 16.
45 * You should also set hw.usb.debug to gain
46 * more detailed view.
48 //#define DEBUG
49 #define UGEN_DEBUG_LEVEL 0
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);
58 typedef struct USBHostDevice {
59 USBDevice dev;
60 int ep_fd[USB_MAX_ENDPOINTS];
61 int devfd;
62 char devpath[32];
63 } USBHostDevice;
66 #if 0
67 static int ensure_ep_open(USBHostDevice *dev, int ep, int mode)
69 char buf[32];
70 int fd;
72 /* Get the address for this endpoint */
73 ep = UE_GET_ADDR(ep);
75 if (dev->ep_fd[ep] < 0) {
76 #if defined(__FreeBSD__) || defined(__DragonFly__)
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)
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
93 dev->ep_fd[ep] = fd;
96 return dev->ep_fd[ep];
99 static void ensure_eps_closed(USBHostDevice *dev)
101 int epnum = 1;
103 if (!dev)
104 return;
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;
111 epnum++;
114 #endif
116 static void usb_host_handle_reset(USBDevice *dev)
118 #if 0
119 USBHostDevice *s = (USBHostDevice *)dev;
120 #endif
123 #if 0
124 /* XXX:
125 * -check device states against transfer requests
126 * and return appropriate response
128 static int usb_host_handle_control(USBDevice *dev,
129 int request,
130 int value,
131 int index,
132 int length,
133 uint8_t *data)
135 USBHostDevice *s = (USBHostDevice *)dev;
136 struct usb_ctl_request req;
137 struct usb_alt_interface aiface;
138 int ret, timeout = 50;
140 if ((request >> 8) == UT_WRITE_DEVICE &&
141 (request & 0xff) == UR_SET_ADDRESS) {
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) {
149 ensure_eps_closed(s); /* can't do this without all eps closed */
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;
160 return 0;
161 } else if ((request >> 8) == UT_WRITE_INTERFACE &&
162 (request & 0xff) == UR_SET_INTERFACE) {
164 aiface.uai_interface_index = index;
165 aiface.uai_alt_no = value;
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;
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;
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
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;
214 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
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;
222 /* protect data transfers from SIGALRM signal */
223 sigemptyset(&new_mask);
224 sigaddset(&new_mask, SIGALRM);
225 sigprocmask(SIG_BLOCK, &new_mask, &old_mask);
227 if (p->pid == USB_TOKEN_IN) {
228 devep |= 0x80;
229 mode = O_RDONLY;
230 shortpacket = 1;
231 } else {
232 mode = O_WRONLY;
235 fd = ensure_ep_open(s, devep, mode);
236 if (fd < 0) {
237 sigprocmask(SIG_SETMASK, &old_mask, NULL);
238 return USB_RET_NODEV;
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
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);
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);
263 sigprocmask(SIG_SETMASK, &old_mask, NULL);
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;
277 } else {
278 return ret;
281 #endif
283 static void usb_host_handle_destroy(USBDevice *opaque)
285 USBHostDevice *s = (USBHostDevice *)opaque;
286 int i;
288 for (i = 0; i < USB_MAX_ENDPOINTS; i++)
289 if (s->ep_fd[i] >= 0)
290 close(s->ep_fd[i]);
292 if (s->devfd < 0)
293 return;
295 close(s->devfd);
297 qemu_free(s);
300 static int usb_host_initfn(USBDevice *dev)
302 return 0;
305 USBDevice *usb_host_device_open(const char *devname)
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;
315 if (usb_host_find_device(&bus, &address, devname) < 0) {
316 goto fail;
319 snprintf(buspath, PATH_MAX, "/dev/usb%d", bus);
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;
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;
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
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
354 goto fail_dfd;
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;
365 d = usb_create(NULL /* FIXME */, "usb-host");
366 dev = DO_UPCAST(USBHostDevice, dev, d);
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;
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);
382 pstrcpy(dev->devpath, sizeof(dev->devpath), "/dev/");
383 pstrcat(dev->devpath, sizeof(dev->devpath), dev_info.udi_devnames[0]);
385 /* Mark the endpoints as not yet open */
386 for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
387 dev->ep_fd[i] = -1;
390 ioctl(dfd, USB_SETDEBUG, &ugendebug);
392 ret = (USBDevice *)dev;
394 fail_dfd:
395 close(dfd);
396 fail_bfd:
397 close(bfd);
398 fail:
399 return ret;
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,
416 static void usb_host_register_devices(void)
418 usb_qdev_register(&usb_host_dev_info);
420 device_init(usb_host_register_devices)
422 static int usb_host_scan(void *opaque, USBScanFunc *func)
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;
431 for (bus = 0; bus < 10; bus++) {
433 snprintf(busbuf, sizeof(busbuf) - 1, "/dev/usb%d", bus);
434 bfd = open(busbuf, O_RDWR);
435 if (bfd < 0)
436 continue;
438 for (address = 1; address < 127; address++) {
440 bus_info.udi_addr = address;
441 if (ioctl(bfd, USB_DEVICEINFO, &bus_info) < 0)
442 continue;
444 /* only list devices that can be used by generic layer */
445 if (strncmp(bus_info.udi_devnames[0], "ugen", 4) != 0)
446 continue;
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
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;
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));
467 // XXX: might need to fixup endianess of word values before copying over
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;
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';
480 ret = func(opaque, bus, address, class_id, vendor_id,
481 product_id, product_name, speed);
483 close(dfd);
485 if (ret)
486 goto the_end;
489 close(bfd);
492 the_end:
493 return ret;
496 typedef struct FindDeviceState {
497 int vendor_id;
498 int product_id;
499 int bus_num;
500 int addr;
501 } FindDeviceState;
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)
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;
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)
526 const char *p;
527 int ret;
528 FindDeviceState fs;
530 p = strchr(devname, '.');
531 if (p) {
532 *pbus_num = strtoul(devname, NULL, 0);
533 *paddr = strtoul(p + 1, NULL, 0);
534 return 0;
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;
547 return -1;
550 /**********************/
551 /* USB host device info */
553 struct usb_class_info {
554 int class;
555 const char *class_name;
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 }
575 static const char *usb_class_str(uint8_t class)
577 const struct usb_class_info *p;
578 for (p = usb_class_info; p->class != -1; p++) {
579 if (p->class == class)
580 break;
582 return p->class_name;
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)
590 const char *class_str, *speed_str;
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;
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");
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)
627 Monitor *mon = opaque;
629 usb_info_device(mon, bus_num, addr, class_id, vendor_id, product_id,
630 product_name, speed);
631 return 0;
634 void usb_host_info(Monitor *mon)
636 usb_host_scan(mon, usb_host_info_device);
639 /* XXX add this */
640 int usb_host_device_close(const char *devname)
642 return 0;