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