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