?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
linux-user: brk() debugging
[qemu/opensuse.git] / usb-linux.c
blobe7fc9ecd5c3a73bc4add03b775e2c9c18f1fd06f
1 /*
2 * Linux host USB redirector
3 *
4 * Copyright (c) 2005 Fabrice Bellard
5 *
6 * Copyright (c) 2008 Max Krasnyansky
7 * Support for host device auto connect & disconnect
8 * Major rewrite to support fully async operation
9 *
10 * Copyright 2008 TJ <linux@tjworld.net>
11 * Added flexible support for /dev/bus/usb /sys/bus/usb/devices in addition
12 * to the legacy /proc/bus/usb USB device discovery and handling
13 *
14 * Permission is hereby granted, free of charge, to any person obtaining a copy
15 * of this software and associated documentation files (the "Software"), to deal
16 * in the Software without restriction, including without limitation the rights
17 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18 * copies of the Software, and to permit persons to whom the Software is
19 * furnished to do so, subject to the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
30 * THE SOFTWARE.
31 */
32
33 #include "qemu-common.h"
34 #include "qemu-timer.h"
35 #include "monitor.h"
36 #include "sysemu.h"
37 #include "trace.h"
38
39 #include <dirent.h>
40 #include <sys/ioctl.h>
41
42 #include <linux/usbdevice_fs.h>
43 #include <linux/version.h>
44 #include "hw/usb.h"
45
46 /* We redefine it to avoid version problems */
47 struct usb_ctrltransfer {
48 uint8_t bRequestType;
49 uint8_t bRequest;
50 uint16_t wValue;
51 uint16_t wIndex;
52 uint16_t wLength;
53 uint32_t timeout;
54 void *data;
55 };
56
57 typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port,
58 int class_id, int vendor_id, int product_id,
59 const char *product_name, int speed);
60
61 //#define DEBUG
62
63 #ifdef DEBUG
64 #define DPRINTF printf
65 #else
66 #define DPRINTF(...)
67 #endif
68
69 #define PRODUCT_NAME_SZ 32
70 #define MAX_PORTLEN 16
71
72 /* endpoint association data */
73 #define ISO_FRAME_DESC_PER_URB 32
74
75 /* devio.c limits single requests to 16k */
76 #define MAX_USBFS_BUFFER_SIZE 16384
77
78 typedef struct AsyncURB AsyncURB;
79
80 struct endp_data {
81 uint8_t halted;
82 uint8_t iso_started;
83 AsyncURB *iso_urb;
84 int iso_urb_idx;
85 int iso_buffer_used;
86 int inflight;
87 };
88
89 struct USBAutoFilter {
90 uint32_t bus_num;
91 uint32_t addr;
92 char *port;
93 uint32_t vendor_id;
94 uint32_t product_id;
95 };
96
97 typedef struct USBHostDevice {
98 USBDevice dev;
99 int fd;
100 int hub_fd;
101 int hub_port;
102
103 uint8_t descr[8192];
104 int descr_len;
105 int closing;
106 uint32_t iso_urb_count;
107 Notifier exit;
108
109 struct endp_data ep_in[USB_MAX_ENDPOINTS];
110 struct endp_data ep_out[USB_MAX_ENDPOINTS];
111 QLIST_HEAD(, AsyncURB) aurbs;
112
113 /* Host side address */
114 int bus_num;
115 int addr;
116 char port[MAX_PORTLEN];
117 struct USBAutoFilter match;
118 int seen, errcount;
119
120 QTAILQ_ENTRY(USBHostDevice) next;
121 } USBHostDevice;
122
123 static QTAILQ_HEAD(, USBHostDevice) hostdevs = QTAILQ_HEAD_INITIALIZER(hostdevs);
124
125 static int usb_host_close(USBHostDevice *dev);
126 static int parse_filter(const char *spec, struct USBAutoFilter *f);
127 static void usb_host_auto_check(void *unused);
128 static int usb_host_read_file(char *line, size_t line_size,
129 const char *device_file, const char *device_name);
130 static int usb_linux_update_endp_table(USBHostDevice *s);
131
132 static int usb_host_usbfs_type(USBHostDevice *s, USBPacket *p)
133 {
134 static const int usbfs[] = {
135 [USB_ENDPOINT_XFER_CONTROL] = USBDEVFS_URB_TYPE_CONTROL,
136 [USB_ENDPOINT_XFER_ISOC] = USBDEVFS_URB_TYPE_ISO,
137 [USB_ENDPOINT_XFER_BULK] = USBDEVFS_URB_TYPE_BULK,
138 [USB_ENDPOINT_XFER_INT] = USBDEVFS_URB_TYPE_INTERRUPT,
139 };
140 uint8_t type = usb_ep_get_type(&s->dev, p->pid, p->devep);
141 assert(type < ARRAY_SIZE(usbfs));
142 return usbfs[type];
143 }
144
145 static int usb_host_do_reset(USBHostDevice *dev)
146 {
147 struct timeval s, e;
148 uint32_t usecs;
149 int ret;
150
151 gettimeofday(&s, NULL);
152 ret = ioctl(dev->fd, USBDEVFS_RESET);
153 gettimeofday(&e, NULL);
154 usecs = (e.tv_sec - s.tv_sec) * 1000000;
155 usecs += e.tv_usec - s.tv_usec;
156 if (usecs > 1000000) {
157 /* more than a second, something is fishy, broken usb device? */
158 fprintf(stderr, "husb: device %d:%d reset took %d.%06d seconds\n",
159 dev->bus_num, dev->addr, usecs / 1000000, usecs % 1000000);
160 }
161 return ret;
162 }
163
164 static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep)
165 {
166 struct endp_data *eps = pid == USB_TOKEN_IN ? s->ep_in : s->ep_out;
167 assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT);
168 assert(ep > 0 && ep <= USB_MAX_ENDPOINTS);
169 return eps + ep - 1;
170 }
171
172 static int is_isoc(USBHostDevice *s, int pid, int ep)
173 {
174 return usb_ep_get_type(&s->dev, pid, ep) == USB_ENDPOINT_XFER_ISOC;
175 }
176
177 static int is_valid(USBHostDevice *s, int pid, int ep)
178 {
179 return usb_ep_get_type(&s->dev, pid, ep) != USB_ENDPOINT_XFER_INVALID;
180 }
181
182 static int is_halted(USBHostDevice *s, int pid, int ep)
183 {
184 return get_endp(s, pid, ep)->halted;
185 }
186
187 static void clear_halt(USBHostDevice *s, int pid, int ep)
188 {
189 trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep);
190 get_endp(s, pid, ep)->halted = 0;
191 }
192
193 static void set_halt(USBHostDevice *s, int pid, int ep)
194 {
195 if (ep != 0) {
196 trace_usb_host_ep_set_halt(s->bus_num, s->addr, ep);
197 get_endp(s, pid, ep)->halted = 1;
198 }
199 }
200
201 static int is_iso_started(USBHostDevice *s, int pid, int ep)
202 {
203 return get_endp(s, pid, ep)->iso_started;
204 }
205
206 static void clear_iso_started(USBHostDevice *s, int pid, int ep)
207 {
208 trace_usb_host_ep_stop_iso(s->bus_num, s->addr, ep);
209 get_endp(s, pid, ep)->iso_started = 0;
210 }
211
212 static void set_iso_started(USBHostDevice *s, int pid, int ep)
213 {
214 struct endp_data *e = get_endp(s, pid, ep);
215
216 trace_usb_host_ep_start_iso(s->bus_num, s->addr, ep);
217 if (!e->iso_started) {
218 e->iso_started = 1;
219 e->inflight = 0;
220 }
221 }
222
223 static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value)
224 {
225 struct endp_data *e = get_endp(s, pid, ep);
226
227 e->inflight += value;
228 return e->inflight;
229 }
230
231 static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb)
232 {
233 get_endp(s, pid, ep)->iso_urb = iso_urb;
234 }
235
236 static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep)
237 {
238 return get_endp(s, pid, ep)->iso_urb;
239 }
240
241 static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i)
242 {
243 get_endp(s, pid, ep)->iso_urb_idx = i;
244 }
245
246 static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep)
247 {
248 return get_endp(s, pid, ep)->iso_urb_idx;
249 }
250
251 static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i)
252 {
253 get_endp(s, pid, ep)->iso_buffer_used = i;
254 }
255
256 static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep)
257 {
258 return get_endp(s, pid, ep)->iso_buffer_used;
259 }
260
261 /*
262 * Async URB state.
263 * We always allocate iso packet descriptors even for bulk transfers
264 * to simplify allocation and casts.
265 */
266 struct AsyncURB
267 {
268 struct usbdevfs_urb urb;
269 struct usbdevfs_iso_packet_desc isocpd[ISO_FRAME_DESC_PER_URB];
270 USBHostDevice *hdev;
271 QLIST_ENTRY(AsyncURB) next;
272
273 /* For regular async urbs */
274 USBPacket *packet;
275 int more; /* large transfer, more urbs follow */
276
277 /* For buffered iso handling */
278 int iso_frame_idx; /* -1 means in flight */
279 };
280
281 static AsyncURB *async_alloc(USBHostDevice *s)
282 {
283 AsyncURB *aurb = g_malloc0(sizeof(AsyncURB));
284 aurb->hdev = s;
285 QLIST_INSERT_HEAD(&s->aurbs, aurb, next);
286 return aurb;
287 }
288
289 static void async_free(AsyncURB *aurb)
290 {
291 QLIST_REMOVE(aurb, next);
292 g_free(aurb);
293 }
294
295 static void do_disconnect(USBHostDevice *s)
296 {
297 usb_host_close(s);
298 usb_host_auto_check(NULL);
299 }
300
301 static void async_complete(void *opaque)
302 {
303 USBHostDevice *s = opaque;
304 AsyncURB *aurb;
305 int urbs = 0;
306
307 while (1) {
308 USBPacket *p;
309
310 int r = ioctl(s->fd, USBDEVFS_REAPURBNDELAY, &aurb);
311 if (r < 0) {
312 if (errno == EAGAIN) {
313 if (urbs > 2) {
314 fprintf(stderr, "husb: %d iso urbs finished at once\n", urbs);
315 }
316 return;
317 }
318 if (errno == ENODEV) {
319 if (!s->closing) {
320 trace_usb_host_disconnect(s->bus_num, s->addr);
321 do_disconnect(s);
322 }
323 return;
324 }
325
326 perror("USBDEVFS_REAPURBNDELAY");
327 return;
328 }
329
330 DPRINTF("husb: async completed. aurb %p status %d alen %d\n",
331 aurb, aurb->urb.status, aurb->urb.actual_length);
332
333 /* If this is a buffered iso urb mark it as complete and don't do
334 anything else (it is handled further in usb_host_handle_iso_data) */
335 if (aurb->iso_frame_idx == -1) {
336 int inflight;
337 int pid = (aurb->urb.endpoint & USB_DIR_IN) ?
338 USB_TOKEN_IN : USB_TOKEN_OUT;
339 int ep = aurb->urb.endpoint & 0xf;
340 if (aurb->urb.status == -EPIPE) {
341 set_halt(s, pid, ep);
342 }
343 aurb->iso_frame_idx = 0;
344 urbs++;
345 inflight = change_iso_inflight(s, pid, ep, -1);
346 if (inflight == 0 && is_iso_started(s, pid, ep)) {
347 fprintf(stderr, "husb: out of buffers for iso stream\n");
348 }
349 continue;
350 }
351
352 p = aurb->packet;
353 trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status,
354 aurb->urb.actual_length, aurb->more);
355
356 if (p) {
357 switch (aurb->urb.status) {
358 case 0:
359 p->result += aurb->urb.actual_length;
360 break;
361
362 case -EPIPE:
363 set_halt(s, p->pid, p->devep);
364 p->result = USB_RET_STALL;
365 break;
366
367 default:
368 p->result = USB_RET_NAK;
369 break;
370 }
371
372 if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) {
373 trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
374 usb_generic_async_ctrl_complete(&s->dev, p);
375 } else if (!aurb->more) {
376 trace_usb_host_req_complete(s->bus_num, s->addr, p->result);
377 usb_packet_complete(&s->dev, p);
378 }
379 }
380
381 async_free(aurb);
382 }
383 }
384
385 static void usb_host_async_cancel(USBDevice *dev, USBPacket *p)
386 {
387 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
388 AsyncURB *aurb;
389
390 QLIST_FOREACH(aurb, &s->aurbs, next) {
391 if (p != aurb->packet) {
392 continue;
393 }
394
395 DPRINTF("husb: async cancel: packet %p, aurb %p\n", p, aurb);
396
397 /* Mark it as dead (see async_complete above) */
398 aurb->packet = NULL;
399
400 int r = ioctl(s->fd, USBDEVFS_DISCARDURB, aurb);
401 if (r < 0) {
402 DPRINTF("husb: async. discard urb failed errno %d\n", errno);
403 }
404 }
405 }
406
407 static int usb_host_open_device(int bus, int addr)
408 {
409 const char *usbfs = NULL;
410 char filename[32];
411 struct stat st;
412 int fd, rc;
413
414 rc = stat("/dev/bus/usb", &st);
415 if (rc == 0 && S_ISDIR(st.st_mode)) {
416 /* udev-created device nodes available */
417 usbfs = "/dev/bus/usb";
418 } else {
419 /* fallback: usbfs mounted below /proc */
420 usbfs = "/proc/bus/usb";
421 }
422
423 snprintf(filename, sizeof(filename), "%s/%03d/%03d",
424 usbfs, bus, addr);
425 fd = open(filename, O_RDWR | O_NONBLOCK);
426 if (fd < 0) {
427 fprintf(stderr, "husb: open %s: %s\n", filename, strerror(errno));
428 }
429 return fd;
430 }
431
432 static int usb_host_claim_port(USBHostDevice *s)
433 {
434 #ifdef USBDEVFS_CLAIM_PORT
435 char *h, hub_name[64], line[1024];
436 int hub_addr, ret;
437
438 snprintf(hub_name, sizeof(hub_name), "%d-%s",
439 s->match.bus_num, s->match.port);
440
441 /* try strip off last ".$portnr" to get hub */
442 h = strrchr(hub_name, '.');
443 if (h != NULL) {
444 s->hub_port = atoi(h+1);
445 *h = '\0';
446 } else {
447 /* no dot in there -> it is the root hub */
448 snprintf(hub_name, sizeof(hub_name), "usb%d",
449 s->match.bus_num);
450 s->hub_port = atoi(s->match.port);
451 }
452
453 if (!usb_host_read_file(line, sizeof(line), "devnum",
454 hub_name)) {
455 return -1;
456 }
457 if (sscanf(line, "%d", &hub_addr) != 1) {
458 return -1;
459 }
460
461 s->hub_fd = usb_host_open_device(s->match.bus_num, hub_addr);
462 if (s->hub_fd < 0) {
463 return -1;
464 }
465
466 ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &s->hub_port);
467 if (ret < 0) {
468 close(s->hub_fd);
469 s->hub_fd = -1;
470 return -1;
471 }
472
473 trace_usb_host_claim_port(s->match.bus_num, hub_addr, s->hub_port);
474 return 0;
475 #else
476 return -1;
477 #endif
478 }
479
480 static void usb_host_release_port(USBHostDevice *s)
481 {
482 if (s->hub_fd == -1) {
483 return;
484 }
485 #ifdef USBDEVFS_RELEASE_PORT
486 ioctl(s->hub_fd, USBDEVFS_RELEASE_PORT, &s->hub_port);
487 #endif
488 close(s->hub_fd);
489 s->hub_fd = -1;
490 }
491
492 static int usb_host_disconnect_ifaces(USBHostDevice *dev, int nb_interfaces)
493 {
494 /* earlier Linux 2.4 do not support that */
495 #ifdef USBDEVFS_DISCONNECT
496 struct usbdevfs_ioctl ctrl;
497 int ret, interface;
498
499 for (interface = 0; interface < nb_interfaces; interface++) {
500 ctrl.ioctl_code = USBDEVFS_DISCONNECT;
501 ctrl.ifno = interface;
502 ctrl.data = 0;
503 ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
504 if (ret < 0 && errno != ENODATA) {
505 perror("USBDEVFS_DISCONNECT");
506 return -1;
507 }
508 }
509 #endif
510 return 0;
511 }
512
513 static int usb_linux_get_num_interfaces(USBHostDevice *s)
514 {
515 char device_name[64], line[1024];
516 int num_interfaces = 0;
517
518 sprintf(device_name, "%d-%s", s->bus_num, s->port);
519 if (!usb_host_read_file(line, sizeof(line), "bNumInterfaces",
520 device_name)) {
521 return -1;
522 }
523 if (sscanf(line, "%d", &num_interfaces) != 1) {
524 return -1;
525 }
526 return num_interfaces;
527 }
528
529 static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration)
530 {
531 const char *op = NULL;
532 int dev_descr_len, config_descr_len;
533 int interface, nb_interfaces;
534 int ret, i;
535
536 for (i = 0; i < USB_MAX_INTERFACES; i++) {
537 dev->dev.altsetting[i] = 0;
538 }
539
540 if (configuration == 0) { /* address state - ignore */
541 dev->dev.ninterfaces = 0;
542 dev->dev.configuration = 0;
543 return 1;
544 }
545
546 DPRINTF("husb: claiming interfaces. config %d\n", configuration);
547
548 i = 0;
549 dev_descr_len = dev->descr[0];
550 if (dev_descr_len > dev->descr_len) {
551 fprintf(stderr, "husb: update iface failed. descr too short\n");
552 return 0;
553 }
554
555 i += dev_descr_len;
556 while (i < dev->descr_len) {
557 DPRINTF("husb: i is %d, descr_len is %d, dl %d, dt %d\n",
558 i, dev->descr_len,
559 dev->descr[i], dev->descr[i+1]);
560
561 if (dev->descr[i+1] != USB_DT_CONFIG) {
562 i += dev->descr[i];
563 continue;
564 }
565 config_descr_len = dev->descr[i];
566
567 DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration);
568
569 if (configuration == dev->descr[i + 5]) {
570 configuration = dev->descr[i + 5];
571 break;
572 }
573
574 i += config_descr_len;
575 }
576
577 if (i >= dev->descr_len) {
578 fprintf(stderr,
579 "husb: update iface failed. no matching configuration\n");
580 return 0;
581 }
582 nb_interfaces = dev->descr[i + 4];
583
584 if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) {
585 goto fail;
586 }
587
588 /* XXX: only grab if all interfaces are free */
589 for (interface = 0; interface < nb_interfaces; interface++) {
590 op = "USBDEVFS_CLAIMINTERFACE";
591 ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
592 if (ret < 0) {
593 goto fail;
594 }
595 }
596
597 trace_usb_host_claim_interfaces(dev->bus_num, dev->addr,
598 nb_interfaces, configuration);
599
600 dev->dev.ninterfaces = nb_interfaces;
601 dev->dev.configuration = configuration;
602 return 1;
603
604 fail:
605 if (errno == ENODEV) {
606 do_disconnect(dev);
607 }
608 perror(op);
609 return 0;
610 }
611
612 static int usb_host_release_interfaces(USBHostDevice *s)
613 {
614 int ret, i;
615
616 trace_usb_host_release_interfaces(s->bus_num, s->addr);
617
618 for (i = 0; i < s->dev.ninterfaces; i++) {
619 ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i);
620 if (ret < 0) {
621 perror("USBDEVFS_RELEASEINTERFACE");
622 return 0;
623 }
624 }
625 return 1;
626 }
627
628 static void usb_host_handle_reset(USBDevice *dev)
629 {
630 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
631
632 trace_usb_host_reset(s->bus_num, s->addr);
633
634 usb_host_do_reset(s);;
635
636 usb_host_claim_interfaces(s, 0);
637 usb_linux_update_endp_table(s);
638 }
639
640 static void usb_host_handle_destroy(USBDevice *dev)
641 {
642 USBHostDevice *s = (USBHostDevice *)dev;
643
644 usb_host_release_port(s);
645 usb_host_close(s);
646 QTAILQ_REMOVE(&hostdevs, s, next);
647 qemu_remove_exit_notifier(&s->exit);
648 }
649
650 /* iso data is special, we need to keep enough urbs in flight to make sure
651 that the controller never runs out of them, otherwise the device will
652 likely suffer a buffer underrun / overrun. */
653 static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep)
654 {
655 AsyncURB *aurb;
656 int i, j, len = usb_ep_get_max_packet_size(&s->dev, pid, ep);
657
658 aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb));
659 for (i = 0; i < s->iso_urb_count; i++) {
660 aurb[i].urb.endpoint = ep;
661 aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len;
662 aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length);
663 aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO;
664 aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP;
665 aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB;
666 for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++)
667 aurb[i].urb.iso_frame_desc[j].length = len;
668 if (pid == USB_TOKEN_IN) {
669 aurb[i].urb.endpoint |= 0x80;
670 /* Mark as fully consumed (idle) */
671 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB;
672 }
673 }
674 set_iso_urb(s, pid, ep, aurb);
675
676 return aurb;
677 }
678
679 static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep)
680 {
681 AsyncURB *aurb;
682 int i, ret, killed = 0, free = 1;
683
684 aurb = get_iso_urb(s, pid, ep);
685 if (!aurb) {
686 return;
687 }
688
689 for (i = 0; i < s->iso_urb_count; i++) {
690 /* in flight? */
691 if (aurb[i].iso_frame_idx == -1) {
692 ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]);
693 if (ret < 0) {
694 perror("USBDEVFS_DISCARDURB");
695 free = 0;
696 continue;
697 }
698 killed++;
699 }
700 }
701
702 /* Make sure any urbs we've killed are reaped before we free them */
703 if (killed) {
704 async_complete(s);
705 }
706
707 for (i = 0; i < s->iso_urb_count; i++) {
708 g_free(aurb[i].urb.buffer);
709 }
710
711 if (free)
712 g_free(aurb);
713 else
714 printf("husb: leaking iso urbs because of discard failure\n");
715 set_iso_urb(s, pid, ep, NULL);
716 set_iso_urb_idx(s, pid, ep, 0);
717 clear_iso_started(s, pid, ep);
718 }
719
720 static int urb_status_to_usb_ret(int status)
721 {
722 switch (status) {
723 case -EPIPE:
724 return USB_RET_STALL;
725 default:
726 return USB_RET_NAK;
727 }
728 }
729
730 static int usb_host_handle_iso_data(USBHostDevice *s, USBPacket *p, int in)
731 {
732 AsyncURB *aurb;
733 int i, j, ret, max_packet_size, offset, len = 0;
734 uint8_t *buf;
735
736 max_packet_size = usb_ep_get_max_packet_size(&s->dev, p->pid, p->devep);
737 if (max_packet_size == 0)
738 return USB_RET_NAK;
739
740 aurb = get_iso_urb(s, p->pid, p->devep);
741 if (!aurb) {
742 aurb = usb_host_alloc_iso(s, p->pid, p->devep);
743 }
744
745 i = get_iso_urb_idx(s, p->pid, p->devep);
746 j = aurb[i].iso_frame_idx;
747 if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) {
748 if (in) {
749 /* Check urb status */
750 if (aurb[i].urb.status) {
751 len = urb_status_to_usb_ret(aurb[i].urb.status);
752 /* Move to the next urb */
753 aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB - 1;
754 /* Check frame status */
755 } else if (aurb[i].urb.iso_frame_desc[j].status) {
756 len = urb_status_to_usb_ret(
757 aurb[i].urb.iso_frame_desc[j].status);
758 /* Check the frame fits */
759 } else if (aurb[i].urb.iso_frame_desc[j].actual_length
760 > p->iov.size) {
761 printf("husb: received iso data is larger then packet\n");
762 len = USB_RET_NAK;
763 /* All good copy data over */
764 } else {
765 len = aurb[i].urb.iso_frame_desc[j].actual_length;
766 buf = aurb[i].urb.buffer +
767 j * aurb[i].urb.iso_frame_desc[0].length;
768 usb_packet_copy(p, buf, len);
769 }
770 } else {
771 len = p->iov.size;
772 offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep);
773
774 /* Check the frame fits */
775 if (len > max_packet_size) {
776 printf("husb: send iso data is larger then max packet size\n");
777 return USB_RET_NAK;
778 }
779
780 /* All good copy data over */
781 usb_packet_copy(p, aurb[i].urb.buffer + offset, len);
782 aurb[i].urb.iso_frame_desc[j].length = len;
783 offset += len;
784 set_iso_buffer_used(s, p->pid, p->devep, offset);
785
786 /* Start the stream once we have buffered enough data */
787 if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) {
788 set_iso_started(s, p->pid, p->devep);
789 }
790 }
791 aurb[i].iso_frame_idx++;
792 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
793 i = (i + 1) % s->iso_urb_count;
794 set_iso_urb_idx(s, p->pid, p->devep, i);
795 }
796 } else {
797 if (in) {
798 set_iso_started(s, p->pid, p->devep);
799 } else {
800 DPRINTF("hubs: iso out error no free buffer, dropping packet\n");
801 }
802 }
803
804 if (is_iso_started(s, p->pid, p->devep)) {
805 /* (Re)-submit all fully consumed / filled urbs */
806 for (i = 0; i < s->iso_urb_count; i++) {
807 if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) {
808 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]);
809 if (ret < 0) {
810 perror("USBDEVFS_SUBMITURB");
811 if (!in || len == 0) {
812 switch(errno) {
813 case ETIMEDOUT:
814 len = USB_RET_NAK;
815 break;
816 case EPIPE:
817 default:
818 len = USB_RET_STALL;
819 }
820 }
821 break;
822 }
823 aurb[i].iso_frame_idx = -1;
824 change_iso_inflight(s, p->pid, p->devep, 1);
825 }
826 }
827 }
828
829 return len;
830 }
831
832 static int usb_host_handle_data(USBDevice *dev, USBPacket *p)
833 {
834 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
835 struct usbdevfs_urb *urb;
836 AsyncURB *aurb;
837 int ret, rem, prem, v;
838 uint8_t *pbuf;
839 uint8_t ep;
840
841 trace_usb_host_req_data(s->bus_num, s->addr,
842 p->pid == USB_TOKEN_IN,
843 p->devep, p->iov.size);
844
845 if (!is_valid(s, p->pid, p->devep)) {
846 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
847 return USB_RET_NAK;
848 }
849
850 if (p->pid == USB_TOKEN_IN) {
851 ep = p->devep | 0x80;
852 } else {
853 ep = p->devep;
854 }
855
856 if (is_halted(s, p->pid, p->devep)) {
857 unsigned int arg = ep;
858 ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg);
859 if (ret < 0) {
860 perror("USBDEVFS_CLEAR_HALT");
861 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
862 return USB_RET_NAK;
863 }
864 clear_halt(s, p->pid, p->devep);
865 }
866
867 if (is_isoc(s, p->pid, p->devep)) {
868 return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN);
869 }
870
871 v = 0;
872 prem = p->iov.iov[v].iov_len;
873 pbuf = p->iov.iov[v].iov_base;
874 rem = p->iov.size;
875 while (rem) {
876 if (prem == 0) {
877 v++;
878 assert(v < p->iov.niov);
879 prem = p->iov.iov[v].iov_len;
880 pbuf = p->iov.iov[v].iov_base;
881 assert(prem <= rem);
882 }
883 aurb = async_alloc(s);
884 aurb->packet = p;
885
886 urb = &aurb->urb;
887 urb->endpoint = ep;
888 urb->type = usb_host_usbfs_type(s, p);
889 urb->usercontext = s;
890 urb->buffer = pbuf;
891 urb->buffer_length = prem;
892
893 if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) {
894 urb->buffer_length = MAX_USBFS_BUFFER_SIZE;
895 }
896 pbuf += urb->buffer_length;
897 prem -= urb->buffer_length;
898 rem -= urb->buffer_length;
899 if (rem) {
900 aurb->more = 1;
901 }
902
903 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
904 urb->buffer_length, aurb->more);
905 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
906
907 DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n",
908 urb->endpoint, urb->buffer_length, aurb->more, p, aurb);
909
910 if (ret < 0) {
911 perror("USBDEVFS_SUBMITURB");
912 async_free(aurb);
913
914 switch(errno) {
915 case ETIMEDOUT:
916 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK);
917 return USB_RET_NAK;
918 case EPIPE:
919 default:
920 trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL);
921 return USB_RET_STALL;
922 }
923 }
924 }
925
926 return USB_RET_ASYNC;
927 }
928
929 static int ctrl_error(void)
930 {
931 if (errno == ETIMEDOUT) {
932 return USB_RET_NAK;
933 } else {
934 return USB_RET_STALL;
935 }
936 }
937
938 static int usb_host_set_address(USBHostDevice *s, int addr)
939 {
940 trace_usb_host_set_address(s->bus_num, s->addr, addr);
941 s->dev.addr = addr;
942 return 0;
943 }
944
945 static int usb_host_set_config(USBHostDevice *s, int config)
946 {
947 int ret, first = 1;
948
949 trace_usb_host_set_config(s->bus_num, s->addr, config);
950
951 usb_host_release_interfaces(s);
952
953 again:
954 ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config);
955
956 DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno);
957
958 if (ret < 0 && errno == EBUSY && first) {
959 /* happens if usb device is in use by host drivers */
960 int count = usb_linux_get_num_interfaces(s);
961 if (count > 0) {
962 DPRINTF("husb: busy -> disconnecting %d interfaces\n", count);
963 usb_host_disconnect_ifaces(s, count);
964 first = 0;
965 goto again;
966 }
967 }
968
969 if (ret < 0) {
970 return ctrl_error();
971 }
972 usb_host_claim_interfaces(s, config);
973 usb_linux_update_endp_table(s);
974 return 0;
975 }
976
977 static int usb_host_set_interface(USBHostDevice *s, int iface, int alt)
978 {
979 struct usbdevfs_setinterface si;
980 int i, ret;
981
982 trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt);
983
984 for (i = 1; i <= USB_MAX_ENDPOINTS; i++) {
985 if (is_isoc(s, USB_TOKEN_IN, i)) {
986 usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i);
987 }
988 if (is_isoc(s, USB_TOKEN_OUT, i)) {
989 usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i);
990 }
991 }
992
993 if (iface >= USB_MAX_INTERFACES) {
994 return USB_RET_STALL;
995 }
996
997 si.interface = iface;
998 si.altsetting = alt;
999 ret = ioctl(s->fd, USBDEVFS_SETINTERFACE, &si);
1000
1001 DPRINTF("husb: ctrl set iface %d altset %d ret %d errno %d\n",
1002 iface, alt, ret, errno);
1003
1004 if (ret < 0) {
1005 return ctrl_error();
1006 }
1007
1008 s->dev.altsetting[iface] = alt;
1009 usb_linux_update_endp_table(s);
1010 return 0;
1011 }
1012
1013 static int usb_host_handle_control(USBDevice *dev, USBPacket *p,
1014 int request, int value, int index, int length, uint8_t *data)
1015 {
1016 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1017 struct usbdevfs_urb *urb;
1018 AsyncURB *aurb;
1019 int ret;
1020
1021 /*
1022 * Process certain standard device requests.
1023 * These are infrequent and are processed synchronously.
1024 */
1025
1026 /* Note request is (bRequestType << 8) | bRequest */
1027 trace_usb_host_req_control(s->bus_num, s->addr, request, value, index);
1028
1029 switch (request) {
1030 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
1031 return usb_host_set_address(s, value);
1032
1033 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
1034 return usb_host_set_config(s, value & 0xff);
1035
1036 case InterfaceOutRequest | USB_REQ_SET_INTERFACE:
1037 return usb_host_set_interface(s, index, value);
1038 }
1039
1040 /* The rest are asynchronous */
1041
1042 if (length > sizeof(dev->data_buf)) {
1043 fprintf(stderr, "husb: ctrl buffer too small (%d > %zu)\n",
1044 length, sizeof(dev->data_buf));
1045 return USB_RET_STALL;
1046 }
1047
1048 aurb = async_alloc(s);
1049 aurb->packet = p;
1050
1051 /*
1052 * Setup ctrl transfer.
1053 *
1054 * s->ctrl is laid out such that data buffer immediately follows
1055 * 'req' struct which is exactly what usbdevfs expects.
1056 */
1057 urb = &aurb->urb;
1058
1059 urb->type = USBDEVFS_URB_TYPE_CONTROL;
1060 urb->endpoint = p->devep;
1061
1062 urb->buffer = &dev->setup_buf;
1063 urb->buffer_length = length + 8;
1064
1065 urb->usercontext = s;
1066
1067 trace_usb_host_urb_submit(s->bus_num, s->addr, aurb,
1068 urb->buffer_length, aurb->more);
1069 ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb);
1070
1071 DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb);
1072
1073 if (ret < 0) {
1074 DPRINTF("husb: submit failed. errno %d\n", errno);
1075 async_free(aurb);
1076
1077 switch(errno) {
1078 case ETIMEDOUT:
1079 return USB_RET_NAK;
1080 case EPIPE:
1081 default:
1082 return USB_RET_STALL;
1083 }
1084 }
1085
1086 return USB_RET_ASYNC;
1087 }
1088
1089 static uint8_t usb_linux_get_alt_setting(USBHostDevice *s,
1090 uint8_t configuration, uint8_t interface)
1091 {
1092 char device_name[64], line[1024];
1093 int alt_setting;
1094
1095 sprintf(device_name, "%d-%s:%d.%d", s->bus_num, s->port,
1096 (int)configuration, (int)interface);
1097
1098 if (!usb_host_read_file(line, sizeof(line), "bAlternateSetting",
1099 device_name)) {
1100 /* Assume alt 0 on error */
1101 return 0;
1102 }
1103 if (sscanf(line, "%d", &alt_setting) != 1) {
1104 /* Assume alt 0 on error */
1105 return 0;
1106 }
1107 return alt_setting;
1108 }
1109
1110 /* returns 1 on problem encountered or 0 for success */
1111 static int usb_linux_update_endp_table(USBHostDevice *s)
1112 {
1113 uint8_t *descriptors;
1114 uint8_t devep, type, alt_interface;
1115 uint16_t raw;
1116 int interface, length, i, ep, pid;
1117 struct endp_data *epd;
1118
1119 usb_ep_init(&s->dev);
1120
1121 if (s->dev.configuration == 0) {
1122 /* not configured yet -- leave all endpoints disabled */
1123 return 0;
1124 }
1125
1126 /* get the desired configuration, interface, and endpoint descriptors
1127 * from device description */
1128 descriptors = &s->descr[18];
1129 length = s->descr_len - 18;
1130 i = 0;
1131
1132 while (i < length) {
1133 if (descriptors[i + 1] != USB_DT_CONFIG) {
1134 fprintf(stderr, "invalid descriptor data\n");
1135 return 1;
1136 } else if (descriptors[i + 5] != s->dev.configuration) {
1137 DPRINTF("not requested configuration %d\n", s->dev.configuration);
1138 i += (descriptors[i + 3] << 8) + descriptors[i + 2];
1139 continue;
1140 }
1141 i += descriptors[i];
1142
1143 if (descriptors[i + 1] != USB_DT_INTERFACE ||
1144 (descriptors[i + 1] == USB_DT_INTERFACE &&
1145 descriptors[i + 4] == 0)) {
1146 i += descriptors[i];
1147 continue;
1148 }
1149
1150 interface = descriptors[i + 2];
1151 alt_interface = usb_linux_get_alt_setting(s, s->dev.configuration,
1152 interface);
1153
1154 /* the current interface descriptor is the active interface
1155 * and has endpoints */
1156 if (descriptors[i + 3] != alt_interface) {
1157 i += descriptors[i];
1158 continue;
1159 }
1160
1161 /* advance to the endpoints */
1162 while (i < length && descriptors[i +1] != USB_DT_ENDPOINT) {
1163 i += descriptors[i];
1164 }
1165
1166 if (i >= length)
1167 break;
1168
1169 while (i < length) {
1170 if (descriptors[i + 1] != USB_DT_ENDPOINT) {
1171 break;
1172 }
1173
1174 devep = descriptors[i + 2];
1175 pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT;
1176 ep = devep & 0xf;
1177 if (ep == 0) {
1178 fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n");
1179 return 1;
1180 }
1181
1182 type = descriptors[i + 3] & 0x3;
1183 raw = descriptors[i + 4] + (descriptors[i + 5] << 8);
1184 usb_ep_set_max_packet_size(&s->dev, pid, ep, raw);
1185 assert(usb_ep_get_type(&s->dev, pid, ep) ==
1186 USB_ENDPOINT_XFER_INVALID);
1187 usb_ep_set_type(&s->dev, pid, ep, type);
1188 usb_ep_set_ifnum(&s->dev, pid, ep, interface);
1189
1190 epd = get_endp(s, pid, ep);
1191 epd->halted = 0;
1192
1193 i += descriptors[i];
1194 }
1195 }
1196 #ifdef DEBUG
1197 usb_ep_dump(&s->dev);
1198 #endif
1199 return 0;
1200 }
1201
1202 /*
1203 * Check if we can safely redirect a usb2 device to a usb1 virtual controller,
1204 * this function assumes this is safe, if:
1205 * 1) There are no isoc endpoints
1206 * 2) There are no interrupt endpoints with a max_packet_size > 64
1207 * Note bulk endpoints with a max_packet_size > 64 in theory also are not
1208 * usb1 compatible, but in practice this seems to work fine.
1209 */
1210 static int usb_linux_full_speed_compat(USBHostDevice *dev)
1211 {
1212 int i, packet_size;
1213
1214 /*
1215 * usb_linux_update_endp_table only registers info about ep in the current
1216 * interface altsettings, so we need to parse the descriptors again.
1217 */
1218 for (i = 0; (i + 5) < dev->descr_len; i += dev->descr[i]) {
1219 if (dev->descr[i + 1] == USB_DT_ENDPOINT) {
1220 switch (dev->descr[i + 3] & 0x3) {
1221 case 0x00: /* CONTROL */
1222 break;
1223 case 0x01: /* ISO */
1224 return 0;
1225 case 0x02: /* BULK */
1226 break;
1227 case 0x03: /* INTERRUPT */
1228 packet_size = dev->descr[i + 4] + (dev->descr[i + 5] << 8);
1229 if (packet_size > 64)
1230 return 0;
1231 break;
1232 }
1233 }
1234 }
1235 return 1;
1236 }
1237
1238 static int usb_host_open(USBHostDevice *dev, int bus_num,
1239 int addr, const char *port,
1240 const char *prod_name, int speed)
1241 {
1242 int fd = -1, ret;
1243
1244 trace_usb_host_open_started(bus_num, addr);
1245
1246 if (dev->fd != -1) {
1247 goto fail;
1248 }
1249
1250 fd = usb_host_open_device(bus_num, addr);
1251 if (fd < 0) {
1252 goto fail;
1253 }
1254 DPRINTF("husb: opened %s\n", buf);
1255
1256 dev->bus_num = bus_num;
1257 dev->addr = addr;
1258 strcpy(dev->port, port);
1259 dev->fd = fd;
1260
1261 /* read the device description */
1262 dev->descr_len = read(fd, dev->descr, sizeof(dev->descr));
1263 if (dev->descr_len <= 0) {
1264 perror("husb: reading device data failed");
1265 goto fail;
1266 }
1267
1268 #ifdef DEBUG
1269 {
1270 int x;
1271 printf("=== begin dumping device descriptor data ===\n");
1272 for (x = 0; x < dev->descr_len; x++) {
1273 printf("%02x ", dev->descr[x]);
1274 }
1275 printf("\n=== end dumping device descriptor data ===\n");
1276 }
1277 #endif
1278
1279
1280 /* start unconfigured -- we'll wait for the guest to set a configuration */
1281 if (!usb_host_claim_interfaces(dev, 0)) {
1282 goto fail;
1283 }
1284
1285 ret = usb_linux_update_endp_table(dev);
1286 if (ret) {
1287 goto fail;
1288 }
1289
1290 if (speed == -1) {
1291 struct usbdevfs_connectinfo ci;
1292
1293 ret = ioctl(fd, USBDEVFS_CONNECTINFO, &ci);
1294 if (ret < 0) {
1295 perror("usb_host_device_open: USBDEVFS_CONNECTINFO");
1296 goto fail;
1297 }
1298
1299 if (ci.slow) {
1300 speed = USB_SPEED_LOW;
1301 } else {
1302 speed = USB_SPEED_HIGH;
1303 }
1304 }
1305 dev->dev.speed = speed;
1306 dev->dev.speedmask = (1 << speed);
1307 if (dev->dev.speed == USB_SPEED_HIGH && usb_linux_full_speed_compat(dev)) {
1308 dev->dev.speedmask |= USB_SPEED_MASK_FULL;
1309 }
1310
1311 trace_usb_host_open_success(bus_num, addr);
1312
1313 if (!prod_name || prod_name[0] == '\0') {
1314 snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1315 "host:%d.%d", bus_num, addr);
1316 } else {
1317 pstrcpy(dev->dev.product_desc, sizeof(dev->dev.product_desc),
1318 prod_name);
1319 }
1320
1321 ret = usb_device_attach(&dev->dev);
1322 if (ret) {
1323 goto fail;
1324 }
1325
1326 /* USB devio uses 'write' flag to check for async completions */
1327 qemu_set_fd_handler(dev->fd, NULL, async_complete, dev);
1328
1329 return 0;
1330
1331 fail:
1332 trace_usb_host_open_failure(bus_num, addr);
1333 if (dev->fd != -1) {
1334 close(dev->fd);
1335 dev->fd = -1;
1336 }
1337 return -1;
1338 }
1339
1340 static int usb_host_close(USBHostDevice *dev)
1341 {
1342 int i;
1343
1344 if (dev->fd == -1) {
1345 return -1;
1346 }
1347
1348 trace_usb_host_close(dev->bus_num, dev->addr);
1349
1350 qemu_set_fd_handler(dev->fd, NULL, NULL, NULL);
1351 dev->closing = 1;
1352 for (i = 1; i <= USB_MAX_ENDPOINTS; i++) {
1353 if (is_isoc(dev, USB_TOKEN_IN, i)) {
1354 usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i);
1355 }
1356 if (is_isoc(dev, USB_TOKEN_OUT, i)) {
1357 usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i);
1358 }
1359 }
1360 async_complete(dev);
1361 dev->closing = 0;
1362 if (dev->dev.attached) {
1363 usb_device_detach(&dev->dev);
1364 }
1365 usb_host_do_reset(dev);
1366 close(dev->fd);
1367 dev->fd = -1;
1368 return 0;
1369 }
1370
1371 static void usb_host_exit_notifier(struct Notifier *n, void *data)
1372 {
1373 USBHostDevice *s = container_of(n, USBHostDevice, exit);
1374
1375 usb_host_release_port(s);
1376 if (s->fd != -1) {
1377 usb_host_do_reset(s);;
1378 }
1379 }
1380
1381 static int usb_host_initfn(USBDevice *dev)
1382 {
1383 USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev);
1384
1385 dev->auto_attach = 0;
1386 s->fd = -1;
1387 s->hub_fd = -1;
1388
1389 QTAILQ_INSERT_TAIL(&hostdevs, s, next);
1390 s->exit.notify = usb_host_exit_notifier;
1391 qemu_add_exit_notifier(&s->exit);
1392 usb_host_auto_check(NULL);
1393
1394 if (s->match.bus_num != 0 && s->match.port != NULL) {
1395 usb_host_claim_port(s);
1396 }
1397 return 0;
1398 }
1399
1400 static const VMStateDescription vmstate_usb_host = {
1401 .name = "usb-host",
1402 .unmigratable = 1,
1403 };
1404
1405 static Property usb_host_dev_properties[] = {
1406 DEFINE_PROP_UINT32("hostbus", USBHostDevice, match.bus_num, 0),
1407 DEFINE_PROP_UINT32("hostaddr", USBHostDevice, match.addr, 0),
1408 DEFINE_PROP_STRING("hostport", USBHostDevice, match.port),
1409 DEFINE_PROP_HEX32("vendorid", USBHostDevice, match.vendor_id, 0),
1410 DEFINE_PROP_HEX32("productid", USBHostDevice, match.product_id, 0),
1411 DEFINE_PROP_UINT32("isobufs", USBHostDevice, iso_urb_count, 4),
1412 DEFINE_PROP_END_OF_LIST(),
1413 };
1414
1415 static void usb_host_class_initfn(ObjectClass *klass, void *data)
1416 {
1417 DeviceClass *dc = DEVICE_CLASS(klass);
1418 USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
1419
1420 uc->init = usb_host_initfn;
1421 uc->product_desc = "USB Host Device";
1422 uc->handle_packet = usb_generic_handle_packet;
1423 uc->cancel_packet = usb_host_async_cancel;
1424 uc->handle_data = usb_host_handle_data;
1425 uc->handle_control = usb_host_handle_control;
1426 uc->handle_reset = usb_host_handle_reset;
1427 uc->handle_destroy = usb_host_handle_destroy;
1428 dc->vmsd = &vmstate_usb_host;
1429 dc->props = usb_host_dev_properties;
1430 }
1431
1432 static TypeInfo usb_host_dev_info = {
1433 .name = "usb-host",
1434 .parent = TYPE_USB_DEVICE,
1435 .instance_size = sizeof(USBHostDevice),
1436 .class_init = usb_host_class_initfn,
1437 };
1438
1439 static void usb_host_register_devices(void)
1440 {
1441 type_register_static(&usb_host_dev_info);
1442 usb_legacy_register("usb-host", "host", usb_host_device_open);
1443 }
1444 device_init(usb_host_register_devices)
1445
1446 USBDevice *usb_host_device_open(const char *devname)
1447 {
1448 struct USBAutoFilter filter;
1449 USBDevice *dev;
1450 char *p;
1451
1452 dev = usb_create(NULL /* FIXME */, "usb-host");
1453
1454 if (strstr(devname, "auto:")) {
1455 if (parse_filter(devname, &filter) < 0) {
1456 goto fail;
1457 }
1458 } else {
1459 if ((p = strchr(devname, '.'))) {
1460 filter.bus_num = strtoul(devname, NULL, 0);
1461 filter.addr = strtoul(p + 1, NULL, 0);
1462 filter.vendor_id = 0;
1463 filter.product_id = 0;
1464 } else if ((p = strchr(devname, ':'))) {
1465 filter.bus_num = 0;
1466 filter.addr = 0;
1467 filter.vendor_id = strtoul(devname, NULL, 16);
1468 filter.product_id = strtoul(p + 1, NULL, 16);
1469 } else {
1470 goto fail;
1471 }
1472 }
1473
1474 qdev_prop_set_uint32(&dev->qdev, "hostbus", filter.bus_num);
1475 qdev_prop_set_uint32(&dev->qdev, "hostaddr", filter.addr);
1476 qdev_prop_set_uint32(&dev->qdev, "vendorid", filter.vendor_id);
1477 qdev_prop_set_uint32(&dev->qdev, "productid", filter.product_id);
1478 qdev_init_nofail(&dev->qdev);
1479 return dev;
1480
1481 fail:
1482 qdev_free(&dev->qdev);
1483 return NULL;
1484 }
1485
1486 int usb_host_device_close(const char *devname)
1487 {
1488 #if 0
1489 char product_name[PRODUCT_NAME_SZ];
1490 int bus_num, addr;
1491 USBHostDevice *s;
1492
1493 if (strstr(devname, "auto:")) {
1494 return usb_host_auto_del(devname);
1495 }
1496 if (usb_host_find_device(&bus_num, &addr, product_name,
1497 sizeof(product_name), devname) < 0) {
1498 return -1;
1499 }
1500 s = hostdev_find(bus_num, addr);
1501 if (s) {
1502 usb_device_delete_addr(s->bus_num, s->dev.addr);
1503 return 0;
1504 }
1505 #endif
1506
1507 return -1;
1508 }
1509
1510 /*
1511 * Read sys file-system device file
1512 *
1513 * @line address of buffer to put file contents in
1514 * @line_size size of line
1515 * @device_file path to device file (printf format string)
1516 * @device_name device being opened (inserted into device_file)
1517 *
1518 * @return 0 failed, 1 succeeded ('line' contains data)
1519 */
1520 static int usb_host_read_file(char *line, size_t line_size,
1521 const char *device_file, const char *device_name)
1522 {
1523 FILE *f;
1524 int ret = 0;
1525 char filename[PATH_MAX];
1526
1527 snprintf(filename, PATH_MAX, "/sys/bus/usb/devices/%s/%s", device_name,
1528 device_file);
1529 f = fopen(filename, "r");
1530 if (f) {
1531 ret = fgets(line, line_size, f) != NULL;
1532 fclose(f);
1533 }
1534
1535 return ret;
1536 }
1537
1538 /*
1539 * Use /sys/bus/usb/devices/ directory to determine host's USB
1540 * devices.
1541 *
1542 * This code is based on Robert Schiele's original patches posted to
1543 * the Novell bug-tracker https://bugzilla.novell.com/show_bug.cgi?id=241950
1544 */
1545 static int usb_host_scan(void *opaque, USBScanFunc *func)
1546 {
1547 DIR *dir = NULL;
1548 char line[1024];
1549 int bus_num, addr, speed, class_id, product_id, vendor_id;
1550 int ret = 0;
1551 char port[MAX_PORTLEN];
1552 char product_name[512];
1553 struct dirent *de;
1554
1555 dir = opendir("/sys/bus/usb/devices");
1556 if (!dir) {
1557 perror("husb: opendir /sys/bus/usb/devices");
1558 fprintf(stderr, "husb: please make sure sysfs is mounted at /sys\n");
1559 goto the_end;
1560 }
1561
1562 while ((de = readdir(dir))) {
1563 if (de->d_name[0] != '.' && !strchr(de->d_name, ':')) {
1564 if (sscanf(de->d_name, "%d-%7[0-9.]", &bus_num, port) < 2) {
1565 continue;
1566 }
1567
1568 if (!usb_host_read_file(line, sizeof(line), "devnum", de->d_name)) {
1569 goto the_end;
1570 }
1571 if (sscanf(line, "%d", &addr) != 1) {
1572 goto the_end;
1573 }
1574 if (!usb_host_read_file(line, sizeof(line), "bDeviceClass",
1575 de->d_name)) {
1576 goto the_end;
1577 }
1578 if (sscanf(line, "%x", &class_id) != 1) {
1579 goto the_end;
1580 }
1581
1582 if (!usb_host_read_file(line, sizeof(line), "idVendor",
1583 de->d_name)) {
1584 goto the_end;
1585 }
1586 if (sscanf(line, "%x", &vendor_id) != 1) {
1587 goto the_end;
1588 }
1589 if (!usb_host_read_file(line, sizeof(line), "idProduct",
1590 de->d_name)) {
1591 goto the_end;
1592 }
1593 if (sscanf(line, "%x", &product_id) != 1) {
1594 goto the_end;
1595 }
1596 if (!usb_host_read_file(line, sizeof(line), "product",
1597 de->d_name)) {
1598 *product_name = 0;
1599 } else {
1600 if (strlen(line) > 0) {
1601 line[strlen(line) - 1] = '\0';
1602 }
1603 pstrcpy(product_name, sizeof(product_name), line);
1604 }
1605
1606 if (!usb_host_read_file(line, sizeof(line), "speed", de->d_name)) {
1607 goto the_end;
1608 }
1609 if (!strcmp(line, "5000\n")) {
1610 speed = USB_SPEED_SUPER;
1611 } else if (!strcmp(line, "480\n")) {
1612 speed = USB_SPEED_HIGH;
1613 } else if (!strcmp(line, "1.5\n")) {
1614 speed = USB_SPEED_LOW;
1615 } else {
1616 speed = USB_SPEED_FULL;
1617 }
1618
1619 ret = func(opaque, bus_num, addr, port, class_id, vendor_id,
1620 product_id, product_name, speed);
1621 if (ret) {
1622 goto the_end;
1623 }
1624 }
1625 }
1626 the_end:
1627 if (dir) {
1628 closedir(dir);
1629 }
1630 return ret;
1631 }
1632
1633 static QEMUTimer *usb_auto_timer;
1634
1635 static int usb_host_auto_scan(void *opaque, int bus_num,
1636 int addr, const char *port,
1637 int class_id, int vendor_id, int product_id,
1638 const char *product_name, int speed)
1639 {
1640 struct USBAutoFilter *f;
1641 struct USBHostDevice *s;
1642
1643 /* Ignore hubs */
1644 if (class_id == 9)
1645 return 0;
1646
1647 QTAILQ_FOREACH(s, &hostdevs, next) {
1648 f = &s->match;
1649
1650 if (f->bus_num > 0 && f->bus_num != bus_num) {
1651 continue;
1652 }
1653 if (f->addr > 0 && f->addr != addr) {
1654 continue;
1655 }
1656 if (f->port != NULL && (port == NULL || strcmp(f->port, port) != 0)) {
1657 continue;
1658 }
1659
1660 if (f->vendor_id > 0 && f->vendor_id != vendor_id) {
1661 continue;
1662 }
1663
1664 if (f->product_id > 0 && f->product_id != product_id) {
1665 continue;
1666 }
1667 /* We got a match */
1668 s->seen++;
1669 if (s->errcount >= 3) {
1670 return 0;
1671 }
1672
1673 /* Already attached ? */
1674 if (s->fd != -1) {
1675 return 0;
1676 }
1677 DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr);
1678
1679 if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) {
1680 s->errcount++;
1681 }
1682 break;
1683 }
1684
1685 return 0;
1686 }
1687
1688 static void usb_host_auto_check(void *unused)
1689 {
1690 struct USBHostDevice *s;
1691 int unconnected = 0;
1692
1693 usb_host_scan(NULL, usb_host_auto_scan);
1694
1695 QTAILQ_FOREACH(s, &hostdevs, next) {
1696 if (s->fd == -1) {
1697 unconnected++;
1698 }
1699 if (s->seen == 0) {
1700 s->errcount = 0;
1701 }
1702 s->seen = 0;
1703 }
1704
1705 if (unconnected == 0) {
1706 /* nothing to watch */
1707 if (usb_auto_timer) {
1708 qemu_del_timer(usb_auto_timer);
1709 trace_usb_host_auto_scan_disabled();
1710 }
1711 return;
1712 }
1713
1714 if (!usb_auto_timer) {
1715 usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
1716 if (!usb_auto_timer) {
1717 return;
1718 }
1719 trace_usb_host_auto_scan_enabled();
1720 }
1721 qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
1722 }
1723
1724 /*
1725 * Autoconnect filter
1726 * Format:
1727 * auto:bus:dev[:vid:pid]
1728 * auto:bus.dev[:vid:pid]
1729 *
1730 * bus - bus number (dec, * means any)
1731 * dev - device number (dec, * means any)
1732 * vid - vendor id (hex, * means any)
1733 * pid - product id (hex, * means any)
1734 *
1735 * See 'lsusb' output.
1736 */
1737 static int parse_filter(const char *spec, struct USBAutoFilter *f)
1738 {
1739 enum { BUS, DEV, VID, PID, DONE };
1740 const char *p = spec;
1741 int i;
1742
1743 f->bus_num = 0;
1744 f->addr = 0;
1745 f->vendor_id = 0;
1746 f->product_id = 0;
1747
1748 for (i = BUS; i < DONE; i++) {
1749 p = strpbrk(p, ":.");
1750 if (!p) {
1751 break;
1752 }
1753 p++;
1754
1755 if (*p == '*') {
1756 continue;
1757 }
1758 switch(i) {
1759 case BUS: f->bus_num = strtol(p, NULL, 10); break;
1760 case DEV: f->addr = strtol(p, NULL, 10); break;
1761 case VID: f->vendor_id = strtol(p, NULL, 16); break;
1762 case PID: f->product_id = strtol(p, NULL, 16); break;
1763 }
1764 }
1765
1766 if (i < DEV) {
1767 fprintf(stderr, "husb: invalid auto filter spec %s\n", spec);
1768 return -1;
1769 }
1770
1771 return 0;
1772 }
1773
1774 /**********************/
1775 /* USB host device info */
1776
1777 struct usb_class_info {
1778 int class;
1779 const char *class_name;
1780 };
1781
1782 static const struct usb_class_info usb_class_info[] = {
1783 { USB_CLASS_AUDIO, "Audio"},
1784 { USB_CLASS_COMM, "Communication"},
1785 { USB_CLASS_HID, "HID"},
1786 { USB_CLASS_HUB, "Hub" },
1787 { USB_CLASS_PHYSICAL, "Physical" },
1788 { USB_CLASS_PRINTER, "Printer" },
1789 { USB_CLASS_MASS_STORAGE, "Storage" },
1790 { USB_CLASS_CDC_DATA, "Data" },
1791 { USB_CLASS_APP_SPEC, "Application Specific" },
1792 { USB_CLASS_VENDOR_SPEC, "Vendor Specific" },
1793 { USB_CLASS_STILL_IMAGE, "Still Image" },
1794 { USB_CLASS_CSCID, "Smart Card" },
1795 { USB_CLASS_CONTENT_SEC, "Content Security" },
1796 { -1, NULL }
1797 };
1798
1799 static const char *usb_class_str(uint8_t class)
1800 {
1801 const struct usb_class_info *p;
1802 for(p = usb_class_info; p->class != -1; p++) {
1803 if (p->class == class) {
1804 break;
1805 }
1806 }
1807 return p->class_name;
1808 }
1809
1810 static void usb_info_device(Monitor *mon, int bus_num,
1811 int addr, const char *port,
1812 int class_id, int vendor_id, int product_id,
1813 const char *product_name,
1814 int speed)
1815 {
1816 const char *class_str, *speed_str;
1817
1818 switch(speed) {
1819 case USB_SPEED_LOW:
1820 speed_str = "1.5";
1821 break;
1822 case USB_SPEED_FULL:
1823 speed_str = "12";
1824 break;
1825 case USB_SPEED_HIGH:
1826 speed_str = "480";
1827 break;
1828 case USB_SPEED_SUPER:
1829 speed_str = "5000";
1830 break;
1831 default:
1832 speed_str = "?";
1833 break;
1834 }
1835
1836 monitor_printf(mon, " Bus %d, Addr %d, Port %s, Speed %s Mb/s\n",
1837 bus_num, addr, port, speed_str);
1838 class_str = usb_class_str(class_id);
1839 if (class_str) {
1840 monitor_printf(mon, " %s:", class_str);
1841 } else {
1842 monitor_printf(mon, " Class %02x:", class_id);
1843 }
1844 monitor_printf(mon, " USB device %04x:%04x", vendor_id, product_id);
1845 if (product_name[0] != '\0') {
1846 monitor_printf(mon, ", %s", product_name);
1847 }
1848 monitor_printf(mon, "\n");
1849 }
1850
1851 static int usb_host_info_device(void *opaque, int bus_num, int addr,
1852 const char *path, int class_id,
1853 int vendor_id, int product_id,
1854 const char *product_name,
1855 int speed)
1856 {
1857 Monitor *mon = opaque;
1858
1859 usb_info_device(mon, bus_num, addr, path, class_id, vendor_id, product_id,
1860 product_name, speed);
1861 return 0;
1862 }
1863
1864 static void dec2str(int val, char *str, size_t size)
1865 {
1866 if (val == 0) {
1867 snprintf(str, size, "*");
1868 } else {
1869 snprintf(str, size, "%d", val);
1870 }
1871 }
1872
1873 static void hex2str(int val, char *str, size_t size)
1874 {
1875 if (val == 0) {
1876 snprintf(str, size, "*");
1877 } else {
1878 snprintf(str, size, "%04x", val);
1879 }
1880 }
1881
1882 void usb_host_info(Monitor *mon)
1883 {
1884 struct USBAutoFilter *f;
1885 struct USBHostDevice *s;
1886
1887 usb_host_scan(mon, usb_host_info_device);
1888
1889 if (QTAILQ_EMPTY(&hostdevs)) {
1890 return;
1891 }
1892
1893 monitor_printf(mon, " Auto filters:\n");
1894 QTAILQ_FOREACH(s, &hostdevs, next) {
1895 char bus[10], addr[10], vid[10], pid[10];
1896 f = &s->match;
1897 dec2str(f->bus_num, bus, sizeof(bus));
1898 dec2str(f->addr, addr, sizeof(addr));
1899 hex2str(f->vendor_id, vid, sizeof(vid));
1900 hex2str(f->product_id, pid, sizeof(pid));
1901 monitor_printf(mon, " Bus %s, Addr %s, Port %s, ID %s:%s\n",
1902 bus, addr, f->port ? f->port : "*", vid, pid);
1903 }
1904 }
Patch queue for openSUSE QEMU