--- qemu/usb-linux.c 2018/04/24 18:56:03 1.1.1.13 +++ qemu/usb-linux.c 2018/04/24 19:17:08 1.1.1.14 @@ -34,6 +34,7 @@ #include "qemu-timer.h" #include "monitor.h" #include "sysemu.h" +#include "trace.h" #include #include @@ -53,7 +54,7 @@ struct usb_ctrltransfer { void *data; }; -typedef int USBScanFunc(void *opaque, int bus_num, int addr, char *port, +typedef int USBScanFunc(void *opaque, int bus_num, int addr, const char *port, int class_id, int vendor_id, int product_id, const char *product_name, int speed); @@ -114,6 +115,8 @@ struct USBAutoFilter { typedef struct USBHostDevice { USBDevice dev; int fd; + int hub_fd; + int hub_port; uint8_t descr[8192]; int descr_len; @@ -123,7 +126,8 @@ typedef struct USBHostDevice { uint32_t iso_urb_count; Notifier exit; - struct endp_data endp_table[MAX_ENDPOINTS]; + struct endp_data ep_in[MAX_ENDPOINTS]; + struct endp_data ep_out[MAX_ENDPOINTS]; QLIST_HEAD(, AsyncURB) aurbs; /* Host side address */ @@ -131,6 +135,7 @@ typedef struct USBHostDevice { int addr; char port[MAX_PORTLEN]; struct USBAutoFilter match; + int seen, errcount; QTAILQ_ENTRY(USBHostDevice) next; } USBHostDevice; @@ -142,95 +147,126 @@ static int parse_filter(const char *spec static void usb_host_auto_check(void *unused); static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name); +static int usb_linux_update_endp_table(USBHostDevice *s); + +static int usb_host_do_reset(USBHostDevice *dev) +{ + struct timeval s, e; + uint32_t usecs; + int ret; + + gettimeofday(&s, NULL); + ret = ioctl(dev->fd, USBDEVFS_RESET); + gettimeofday(&e, NULL); + usecs = (e.tv_sec - s.tv_sec) * 1000000; + usecs += e.tv_usec - s.tv_usec; + if (usecs > 1000000) { + /* more than a second, something is fishy, broken usb device? */ + fprintf(stderr, "husb: device %d:%d reset took %d.%06d seconds\n", + dev->bus_num, dev->addr, usecs / 1000000, usecs % 1000000); + } + return ret; +} -static struct endp_data *get_endp(USBHostDevice *s, int ep) +static struct endp_data *get_endp(USBHostDevice *s, int pid, int ep) { - return s->endp_table + ep - 1; + struct endp_data *eps = pid == USB_TOKEN_IN ? s->ep_in : s->ep_out; + assert(pid == USB_TOKEN_IN || pid == USB_TOKEN_OUT); + assert(ep > 0 && ep <= MAX_ENDPOINTS); + return eps + ep - 1; } -static int is_isoc(USBHostDevice *s, int ep) +static int is_isoc(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->type == USBDEVFS_URB_TYPE_ISO; + return get_endp(s, pid, ep)->type == USBDEVFS_URB_TYPE_ISO; } -static int is_valid(USBHostDevice *s, int ep) +static int is_valid(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->type != INVALID_EP_TYPE; + return get_endp(s, pid, ep)->type != INVALID_EP_TYPE; } -static int is_halted(USBHostDevice *s, int ep) +static int is_halted(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->halted; + return get_endp(s, pid, ep)->halted; } -static void clear_halt(USBHostDevice *s, int ep) +static void clear_halt(USBHostDevice *s, int pid, int ep) { - get_endp(s, ep)->halted = 0; + trace_usb_host_ep_clear_halt(s->bus_num, s->addr, ep); + get_endp(s, pid, ep)->halted = 0; } -static void set_halt(USBHostDevice *s, int ep) +static void set_halt(USBHostDevice *s, int pid, int ep) { - get_endp(s, ep)->halted = 1; + if (ep != 0) { + trace_usb_host_ep_set_halt(s->bus_num, s->addr, ep); + get_endp(s, pid, ep)->halted = 1; + } } -static int is_iso_started(USBHostDevice *s, int ep) +static int is_iso_started(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->iso_started; + return get_endp(s, pid, ep)->iso_started; } -static void clear_iso_started(USBHostDevice *s, int ep) +static void clear_iso_started(USBHostDevice *s, int pid, int ep) { - get_endp(s, ep)->iso_started = 0; + trace_usb_host_ep_stop_iso(s->bus_num, s->addr, ep); + get_endp(s, pid, ep)->iso_started = 0; } -static void set_iso_started(USBHostDevice *s, int ep) +static void set_iso_started(USBHostDevice *s, int pid, int ep) { - struct endp_data *e = get_endp(s, ep); + struct endp_data *e = get_endp(s, pid, ep); + + trace_usb_host_ep_start_iso(s->bus_num, s->addr, ep); if (!e->iso_started) { e->iso_started = 1; e->inflight = 0; } } -static int change_iso_inflight(USBHostDevice *s, int ep, int value) +static int change_iso_inflight(USBHostDevice *s, int pid, int ep, int value) { - struct endp_data *e = get_endp(s, ep); + struct endp_data *e = get_endp(s, pid, ep); e->inflight += value; return e->inflight; } -static void set_iso_urb(USBHostDevice *s, int ep, AsyncURB *iso_urb) +static void set_iso_urb(USBHostDevice *s, int pid, int ep, AsyncURB *iso_urb) { - get_endp(s, ep)->iso_urb = iso_urb; + get_endp(s, pid, ep)->iso_urb = iso_urb; } -static AsyncURB *get_iso_urb(USBHostDevice *s, int ep) +static AsyncURB *get_iso_urb(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->iso_urb; + return get_endp(s, pid, ep)->iso_urb; } -static void set_iso_urb_idx(USBHostDevice *s, int ep, int i) +static void set_iso_urb_idx(USBHostDevice *s, int pid, int ep, int i) { - get_endp(s, ep)->iso_urb_idx = i; + get_endp(s, pid, ep)->iso_urb_idx = i; } -static int get_iso_urb_idx(USBHostDevice *s, int ep) +static int get_iso_urb_idx(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->iso_urb_idx; + return get_endp(s, pid, ep)->iso_urb_idx; } -static void set_iso_buffer_used(USBHostDevice *s, int ep, int i) +static void set_iso_buffer_used(USBHostDevice *s, int pid, int ep, int i) { - get_endp(s, ep)->iso_buffer_used = i; + get_endp(s, pid, ep)->iso_buffer_used = i; } -static int get_iso_buffer_used(USBHostDevice *s, int ep) +static int get_iso_buffer_used(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->iso_buffer_used; + return get_endp(s, pid, ep)->iso_buffer_used; } -static void set_max_packet_size(USBHostDevice *s, int ep, uint8_t *descriptor) +static void set_max_packet_size(USBHostDevice *s, int pid, int ep, + uint8_t *descriptor) { int raw = descriptor[4] + (descriptor[5] << 8); int size, microframes; @@ -241,12 +277,12 @@ static void set_max_packet_size(USBHostD case 2: microframes = 3; break; default: microframes = 1; break; } - get_endp(s, ep)->max_packet_size = size * microframes; + get_endp(s, pid, ep)->max_packet_size = size * microframes; } -static int get_max_packet_size(USBHostDevice *s, int ep) +static int get_max_packet_size(USBHostDevice *s, int pid, int ep) { - return get_endp(s, ep)->max_packet_size; + return get_endp(s, pid, ep)->max_packet_size; } /* @@ -271,7 +307,7 @@ struct AsyncURB static AsyncURB *async_alloc(USBHostDevice *s) { - AsyncURB *aurb = qemu_mallocz(sizeof(AsyncURB)); + AsyncURB *aurb = g_malloc0(sizeof(AsyncURB)); aurb->hdev = s; QLIST_INSERT_HEAD(&s->aurbs, aurb, next); return aurb; @@ -280,13 +316,11 @@ static AsyncURB *async_alloc(USBHostDevi static void async_free(AsyncURB *aurb) { QLIST_REMOVE(aurb, next); - qemu_free(aurb); + g_free(aurb); } static void do_disconnect(USBHostDevice *s) { - printf("husb: device %d.%d disconnected\n", - s->bus_num, s->addr); usb_host_close(s); usb_host_auto_check(NULL); } @@ -308,12 +342,15 @@ static void async_complete(void *opaque) } return; } - if (errno == ENODEV && !s->closing) { - do_disconnect(s); + if (errno == ENODEV) { + if (!s->closing) { + trace_usb_host_disconnect(s->bus_num, s->addr); + do_disconnect(s); + } return; } - DPRINTF("husb: async. reap urb failed errno %d\n", errno); + perror("USBDEVFS_REAPURBNDELAY"); return; } @@ -324,39 +361,46 @@ static void async_complete(void *opaque) anything else (it is handled further in usb_host_handle_iso_data) */ if (aurb->iso_frame_idx == -1) { int inflight; + int pid = (aurb->urb.endpoint & USB_DIR_IN) ? + USB_TOKEN_IN : USB_TOKEN_OUT; + int ep = aurb->urb.endpoint & 0xf; if (aurb->urb.status == -EPIPE) { - set_halt(s, aurb->urb.endpoint & 0xf); + set_halt(s, pid, ep); } aurb->iso_frame_idx = 0; urbs++; - inflight = change_iso_inflight(s, aurb->urb.endpoint & 0xf, -1); - if (inflight == 0 && is_iso_started(s, aurb->urb.endpoint & 0xf)) { + inflight = change_iso_inflight(s, pid, ep, -1); + if (inflight == 0 && is_iso_started(s, pid, ep)) { fprintf(stderr, "husb: out of buffers for iso stream\n"); } continue; } p = aurb->packet; + trace_usb_host_urb_complete(s->bus_num, s->addr, aurb, aurb->urb.status, + aurb->urb.actual_length, aurb->more); if (p) { switch (aurb->urb.status) { case 0: - p->len += aurb->urb.actual_length; + p->result += aurb->urb.actual_length; break; case -EPIPE: - set_halt(s, p->devep); - p->len = USB_RET_STALL; + set_halt(s, p->pid, p->devep); + p->result = USB_RET_STALL; break; default: - p->len = USB_RET_NAK; + p->result = USB_RET_NAK; break; } if (aurb->urb.type == USBDEVFS_URB_TYPE_CONTROL) { + trace_usb_host_req_complete(s->bus_num, s->addr, p->result); usb_generic_async_ctrl_complete(&s->dev, p); } else if (!aurb->more) { + trace_usb_host_req_complete(s->bus_num, s->addr, p->result); usb_packet_complete(&s->dev, p); } } @@ -387,6 +431,112 @@ static void usb_host_async_cancel(USBDev } } +static int usb_host_claim_port(USBHostDevice *s) +{ +#ifdef USBDEVFS_CLAIM_PORT + char *h, hub_name[64], line[1024]; + int hub_addr, ret; + + snprintf(hub_name, sizeof(hub_name), "%d-%s", + s->match.bus_num, s->match.port); + + /* try strip off last ".$portnr" to get hub */ + h = strrchr(hub_name, '.'); + if (h != NULL) { + s->hub_port = atoi(h+1); + *h = '\0'; + } else { + /* no dot in there -> it is the root hub */ + snprintf(hub_name, sizeof(hub_name), "usb%d", + s->match.bus_num); + s->hub_port = atoi(s->match.port); + } + + if (!usb_host_read_file(line, sizeof(line), "devnum", + hub_name)) { + return -1; + } + if (sscanf(line, "%d", &hub_addr) != 1) { + return -1; + } + + if (!usb_host_device_path) { + return -1; + } + snprintf(line, sizeof(line), "%s/%03d/%03d", + usb_host_device_path, s->match.bus_num, hub_addr); + s->hub_fd = open(line, O_RDWR | O_NONBLOCK); + if (s->hub_fd < 0) { + return -1; + } + + ret = ioctl(s->hub_fd, USBDEVFS_CLAIM_PORT, &s->hub_port); + if (ret < 0) { + close(s->hub_fd); + s->hub_fd = -1; + return -1; + } + + trace_usb_host_claim_port(s->match.bus_num, hub_addr, s->hub_port); + return 0; +#else + return -1; +#endif +} + +static void usb_host_release_port(USBHostDevice *s) +{ + if (s->hub_fd == -1) { + return; + } +#ifdef USBDEVFS_RELEASE_PORT + ioctl(s->hub_fd, USBDEVFS_RELEASE_PORT, &s->hub_port); +#endif + close(s->hub_fd); + s->hub_fd = -1; +} + +static int usb_host_disconnect_ifaces(USBHostDevice *dev, int nb_interfaces) +{ + /* earlier Linux 2.4 do not support that */ +#ifdef USBDEVFS_DISCONNECT + struct usbdevfs_ioctl ctrl; + int ret, interface; + + for (interface = 0; interface < nb_interfaces; interface++) { + ctrl.ioctl_code = USBDEVFS_DISCONNECT; + ctrl.ifno = interface; + ctrl.data = 0; + ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl); + if (ret < 0 && errno != ENODATA) { + perror("USBDEVFS_DISCONNECT"); + return -1; + } + } +#endif + return 0; +} + +static int usb_linux_get_num_interfaces(USBHostDevice *s) +{ + char device_name[64], line[1024]; + int num_interfaces = 0; + + if (usb_fs_type != USB_FS_SYS) { + return -1; + } + + sprintf(device_name, "%d-%s", s->bus_num, s->port); + if (!usb_host_read_file(line, sizeof(line), "bNumInterfaces", + device_name)) { + return -1; + } + if (sscanf(line, "%d", &num_interfaces) != 1) { + return -1; + } + return num_interfaces; +} + static int usb_host_claim_interfaces(USBHostDevice *dev, int configuration) { const char *op = NULL; @@ -394,8 +544,11 @@ static int usb_host_claim_interfaces(USB int interface, nb_interfaces; int ret, i; - if (configuration == 0) /* address state - ignore */ + if (configuration == 0) { /* address state - ignore */ + dev->ninterfaces = 0; + dev->configuration = 0; return 1; + } DPRINTF("husb: claiming interfaces. config %d\n", configuration); @@ -418,9 +571,9 @@ static int usb_host_claim_interfaces(USB } config_descr_len = dev->descr[i]; - printf("husb: config #%d need %d\n", dev->descr[i + 5], configuration); + DPRINTF("husb: config #%d need %d\n", dev->descr[i + 5], configuration); - if (configuration < 0 || configuration == dev->descr[i + 5]) { + if (configuration == dev->descr[i + 5]) { configuration = dev->descr[i + 5]; break; } @@ -435,39 +588,21 @@ static int usb_host_claim_interfaces(USB } nb_interfaces = dev->descr[i + 4]; -#ifdef USBDEVFS_DISCONNECT - /* earlier Linux 2.4 do not support that */ - { - struct usbdevfs_ioctl ctrl; - for (interface = 0; interface < nb_interfaces; interface++) { - ctrl.ioctl_code = USBDEVFS_DISCONNECT; - ctrl.ifno = interface; - ctrl.data = 0; - op = "USBDEVFS_DISCONNECT"; - ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl); - if (ret < 0 && errno != ENODATA) { - goto fail; - } - } + if (usb_host_disconnect_ifaces(dev, nb_interfaces) < 0) { + goto fail; } -#endif /* XXX: only grab if all interfaces are free */ for (interface = 0; interface < nb_interfaces; interface++) { op = "USBDEVFS_CLAIMINTERFACE"; ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface); if (ret < 0) { - if (errno == EBUSY) { - printf("husb: update iface. device already grabbed\n"); - } else { - perror("husb: failed to claim interface"); - } goto fail; } } - printf("husb: %d interfaces claimed for configuration %d\n", - nb_interfaces, configuration); + trace_usb_host_claim_interfaces(dev->bus_num, dev->addr, + nb_interfaces, configuration); dev->ninterfaces = nb_interfaces; dev->configuration = configuration; @@ -485,16 +620,15 @@ static int usb_host_release_interfaces(U { int ret, i; - DPRINTF("husb: releasing interfaces\n"); + trace_usb_host_release_interfaces(s->bus_num, s->addr); for (i = 0; i < s->ninterfaces; i++) { ret = ioctl(s->fd, USBDEVFS_RELEASEINTERFACE, &i); if (ret < 0) { - perror("husb: failed to release interface"); + perror("USBDEVFS_RELEASEINTERFACE"); return 0; } } - return 1; } @@ -502,59 +636,59 @@ static void usb_host_handle_reset(USBDev { USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); - DPRINTF("husb: reset device %u.%u\n", s->bus_num, s->addr); + trace_usb_host_reset(s->bus_num, s->addr); - ioctl(s->fd, USBDEVFS_RESET); + usb_host_do_reset(s);; - usb_host_claim_interfaces(s, s->configuration); + usb_host_claim_interfaces(s, 0); + usb_linux_update_endp_table(s); } static void usb_host_handle_destroy(USBDevice *dev) { USBHostDevice *s = (USBHostDevice *)dev; + usb_host_release_port(s); usb_host_close(s); QTAILQ_REMOVE(&hostdevs, s, next); qemu_remove_exit_notifier(&s->exit); } -static int usb_linux_update_endp_table(USBHostDevice *s); - /* iso data is special, we need to keep enough urbs in flight to make sure that the controller never runs out of them, otherwise the device will likely suffer a buffer underrun / overrun. */ -static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, uint8_t ep, int in) +static AsyncURB *usb_host_alloc_iso(USBHostDevice *s, int pid, uint8_t ep) { AsyncURB *aurb; - int i, j, len = get_max_packet_size(s, ep); + int i, j, len = get_max_packet_size(s, pid, ep); - aurb = qemu_mallocz(s->iso_urb_count * sizeof(*aurb)); + aurb = g_malloc0(s->iso_urb_count * sizeof(*aurb)); for (i = 0; i < s->iso_urb_count; i++) { aurb[i].urb.endpoint = ep; aurb[i].urb.buffer_length = ISO_FRAME_DESC_PER_URB * len; - aurb[i].urb.buffer = qemu_malloc(aurb[i].urb.buffer_length); + aurb[i].urb.buffer = g_malloc(aurb[i].urb.buffer_length); aurb[i].urb.type = USBDEVFS_URB_TYPE_ISO; aurb[i].urb.flags = USBDEVFS_URB_ISO_ASAP; aurb[i].urb.number_of_packets = ISO_FRAME_DESC_PER_URB; for (j = 0 ; j < ISO_FRAME_DESC_PER_URB; j++) aurb[i].urb.iso_frame_desc[j].length = len; - if (in) { + if (pid == USB_TOKEN_IN) { aurb[i].urb.endpoint |= 0x80; /* Mark as fully consumed (idle) */ aurb[i].iso_frame_idx = ISO_FRAME_DESC_PER_URB; } } - set_iso_urb(s, ep, aurb); + set_iso_urb(s, pid, ep, aurb); return aurb; } -static void usb_host_stop_n_free_iso(USBHostDevice *s, uint8_t ep) +static void usb_host_stop_n_free_iso(USBHostDevice *s, int pid, uint8_t ep) { AsyncURB *aurb; int i, ret, killed = 0, free = 1; - aurb = get_iso_urb(s, ep); + aurb = get_iso_urb(s, pid, ep); if (!aurb) { return; } @@ -564,7 +698,7 @@ static void usb_host_stop_n_free_iso(USB if (aurb[i].iso_frame_idx == -1) { ret = ioctl(s->fd, USBDEVFS_DISCARDURB, &aurb[i]); if (ret < 0) { - printf("husb: discard isoc in urb failed errno %d\n", errno); + perror("USBDEVFS_DISCARDURB"); free = 0; continue; } @@ -578,16 +712,16 @@ static void usb_host_stop_n_free_iso(USB } for (i = 0; i < s->iso_urb_count; i++) { - qemu_free(aurb[i].urb.buffer); + g_free(aurb[i].urb.buffer); } if (free) - qemu_free(aurb); + g_free(aurb); else printf("husb: leaking iso urbs because of discard failure\n"); - set_iso_urb(s, ep, NULL); - set_iso_urb_idx(s, ep, 0); - clear_iso_started(s, ep); + set_iso_urb(s, pid, ep, NULL); + set_iso_urb_idx(s, pid, ep, 0); + clear_iso_started(s, pid, ep); } static int urb_status_to_usb_ret(int status) @@ -604,17 +738,18 @@ static int usb_host_handle_iso_data(USBH { AsyncURB *aurb; int i, j, ret, max_packet_size, offset, len = 0; + uint8_t *buf; - max_packet_size = get_max_packet_size(s, p->devep); + max_packet_size = get_max_packet_size(s, p->pid, p->devep); if (max_packet_size == 0) return USB_RET_NAK; - aurb = get_iso_urb(s, p->devep); + aurb = get_iso_urb(s, p->pid, p->devep); if (!aurb) { - aurb = usb_host_alloc_iso(s, p->devep, in); + aurb = usb_host_alloc_iso(s, p->pid, p->devep); } - i = get_iso_urb_idx(s, p->devep); + i = get_iso_urb_idx(s, p->pid, p->devep); j = aurb[i].iso_frame_idx; if (j >= 0 && j < ISO_FRAME_DESC_PER_URB) { if (in) { @@ -628,20 +763,20 @@ static int usb_host_handle_iso_data(USBH len = urb_status_to_usb_ret( aurb[i].urb.iso_frame_desc[j].status); /* Check the frame fits */ - } else if (aurb[i].urb.iso_frame_desc[j].actual_length > p->len) { + } else if (aurb[i].urb.iso_frame_desc[j].actual_length + > p->iov.size) { printf("husb: received iso data is larger then packet\n"); len = USB_RET_NAK; /* All good copy data over */ } else { len = aurb[i].urb.iso_frame_desc[j].actual_length; - memcpy(p->data, - aurb[i].urb.buffer + - j * aurb[i].urb.iso_frame_desc[0].length, - len); + buf = aurb[i].urb.buffer + + j * aurb[i].urb.iso_frame_desc[0].length; + usb_packet_copy(p, buf, len); } } else { - len = p->len; - offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->devep); + len = p->iov.size; + offset = (j == 0) ? 0 : get_iso_buffer_used(s, p->pid, p->devep); /* Check the frame fits */ if (len > max_packet_size) { @@ -650,36 +785,36 @@ static int usb_host_handle_iso_data(USBH } /* All good copy data over */ - memcpy(aurb[i].urb.buffer + offset, p->data, len); + usb_packet_copy(p, aurb[i].urb.buffer + offset, len); aurb[i].urb.iso_frame_desc[j].length = len; offset += len; - set_iso_buffer_used(s, p->devep, offset); + set_iso_buffer_used(s, p->pid, p->devep, offset); /* Start the stream once we have buffered enough data */ - if (!is_iso_started(s, p->devep) && i == 1 && j == 8) { - set_iso_started(s, p->devep); + if (!is_iso_started(s, p->pid, p->devep) && i == 1 && j == 8) { + set_iso_started(s, p->pid, p->devep); } } aurb[i].iso_frame_idx++; if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) { i = (i + 1) % s->iso_urb_count; - set_iso_urb_idx(s, p->devep, i); + set_iso_urb_idx(s, p->pid, p->devep, i); } } else { if (in) { - set_iso_started(s, p->devep); + set_iso_started(s, p->pid, p->devep); } else { DPRINTF("hubs: iso out error no free buffer, dropping packet\n"); } } - if (is_iso_started(s, p->devep)) { + if (is_iso_started(s, p->pid, p->devep)) { /* (Re)-submit all fully consumed / filled urbs */ for (i = 0; i < s->iso_urb_count; i++) { if (aurb[i].iso_frame_idx == ISO_FRAME_DESC_PER_URB) { ret = ioctl(s->fd, USBDEVFS_SUBMITURB, &aurb[i]); if (ret < 0) { - printf("husb error submitting iso urb %d: %d\n", i, errno); + perror("USBDEVFS_SUBMITURB"); if (!in || len == 0) { switch(errno) { case ETIMEDOUT: @@ -693,7 +828,7 @@ static int usb_host_handle_iso_data(USBH break; } aurb[i].iso_frame_idx = -1; - change_iso_inflight(s, p->devep, +1); + change_iso_inflight(s, p->pid, p->devep, 1); } } } @@ -706,11 +841,16 @@ static int usb_host_handle_data(USBDevic USBHostDevice *s = DO_UPCAST(USBHostDevice, dev, dev); struct usbdevfs_urb *urb; AsyncURB *aurb; - int ret, rem; + int ret, rem, prem, v; uint8_t *pbuf; uint8_t ep; - if (!is_valid(s, p->devep)) { + trace_usb_host_req_data(s->bus_num, s->addr, + p->pid == USB_TOKEN_IN, + p->devep, p->iov.size); + + if (!is_valid(s, p->pid, p->devep)) { + trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK); return USB_RET_NAK; } @@ -720,24 +860,33 @@ static int usb_host_handle_data(USBDevic ep = p->devep; } - if (is_halted(s, p->devep)) { - ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &ep); + if (is_halted(s, p->pid, p->devep)) { + unsigned int arg = ep; + ret = ioctl(s->fd, USBDEVFS_CLEAR_HALT, &arg); if (ret < 0) { - DPRINTF("husb: failed to clear halt. ep 0x%x errno %d\n", - ep, errno); + perror("USBDEVFS_CLEAR_HALT"); + trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK); return USB_RET_NAK; } - clear_halt(s, p->devep); + clear_halt(s, p->pid, p->devep); } - if (is_isoc(s, p->devep)) { + if (is_isoc(s, p->pid, p->devep)) { return usb_host_handle_iso_data(s, p, p->pid == USB_TOKEN_IN); } - rem = p->len; - pbuf = p->data; - p->len = 0; + v = 0; + prem = p->iov.iov[v].iov_len; + pbuf = p->iov.iov[v].iov_base; + rem = p->iov.size; while (rem) { + if (prem == 0) { + v++; + assert(v < p->iov.niov); + prem = p->iov.iov[v].iov_len; + pbuf = p->iov.iov[v].iov_base; + assert(prem <= rem); + } aurb = async_alloc(s); aurb->packet = p; @@ -746,31 +895,36 @@ static int usb_host_handle_data(USBDevic urb->type = USBDEVFS_URB_TYPE_BULK; urb->usercontext = s; urb->buffer = pbuf; + urb->buffer_length = prem; - if (rem > MAX_USBFS_BUFFER_SIZE) { + if (urb->buffer_length > MAX_USBFS_BUFFER_SIZE) { urb->buffer_length = MAX_USBFS_BUFFER_SIZE; - aurb->more = 1; - } else { - urb->buffer_length = rem; - aurb->more = 0; } pbuf += urb->buffer_length; + prem -= urb->buffer_length; rem -= urb->buffer_length; + if (rem) { + aurb->more = 1; + } + trace_usb_host_urb_submit(s->bus_num, s->addr, aurb, + urb->buffer_length, aurb->more); ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb); DPRINTF("husb: data submit: ep 0x%x, len %u, more %d, packet %p, aurb %p\n", urb->endpoint, urb->buffer_length, aurb->more, p, aurb); if (ret < 0) { - DPRINTF("husb: submit failed. errno %d\n", errno); + perror("USBDEVFS_SUBMITURB"); async_free(aurb); switch(errno) { case ETIMEDOUT: + trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_NAK); return USB_RET_NAK; case EPIPE: default: + trace_usb_host_req_complete(s->bus_num, s->addr, USB_RET_STALL); return USB_RET_STALL; } } @@ -790,23 +944,40 @@ static int ctrl_error(void) static int usb_host_set_address(USBHostDevice *s, int addr) { - DPRINTF("husb: ctrl set addr %u\n", addr); + trace_usb_host_set_address(s->bus_num, s->addr, addr); s->dev.addr = addr; return 0; } static int usb_host_set_config(USBHostDevice *s, int config) { + int ret, first = 1; + + trace_usb_host_set_config(s->bus_num, s->addr, config); + usb_host_release_interfaces(s); - int ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config); +again: + ret = ioctl(s->fd, USBDEVFS_SETCONFIGURATION, &config); DPRINTF("husb: ctrl set config %d ret %d errno %d\n", config, ret, errno); + if (ret < 0 && errno == EBUSY && first) { + /* happens if usb device is in use by host drivers */ + int count = usb_linux_get_num_interfaces(s); + if (count > 0) { + DPRINTF("husb: busy -> disconnecting %d interfaces\n", count); + usb_host_disconnect_ifaces(s, count); + first = 0; + goto again; + } + } + if (ret < 0) { return ctrl_error(); } usb_host_claim_interfaces(s, config); + usb_linux_update_endp_table(s); return 0; } @@ -815,9 +986,14 @@ static int usb_host_set_interface(USBHos struct usbdevfs_setinterface si; int i, ret; + trace_usb_host_set_interface(s->bus_num, s->addr, iface, alt); + for (i = 1; i <= MAX_ENDPOINTS; i++) { - if (is_isoc(s, i)) { - usb_host_stop_n_free_iso(s, i); + if (is_isoc(s, USB_TOKEN_IN, i)) { + usb_host_stop_n_free_iso(s, USB_TOKEN_IN, i); + } + if (is_isoc(s, USB_TOKEN_OUT, i)) { + usb_host_stop_n_free_iso(s, USB_TOKEN_OUT, i); } } @@ -849,8 +1025,7 @@ static int usb_host_handle_control(USBDe */ /* Note request is (bRequestType << 8) | bRequest */ - DPRINTF("husb: ctrl type 0x%x req 0x%x val 0x%x index %u len %u\n", - request >> 8, request & 0xff, value, index, length); + trace_usb_host_req_control(s->bus_num, s->addr, request, value, index); switch (request) { case DeviceOutRequest | USB_REQ_SET_ADDRESS: @@ -890,6 +1065,8 @@ static int usb_host_handle_control(USBDe urb->usercontext = s; + trace_usb_host_urb_submit(s->bus_num, s->addr, aurb, + urb->buffer_length, aurb->more); ret = ioctl(s->fd, USBDEVFS_SUBMITURB, urb); DPRINTF("husb: submit ctrl. len %u aurb %p\n", urb->buffer_length, aurb); @@ -910,51 +1087,6 @@ static int usb_host_handle_control(USBDe return USB_RET_ASYNC; } -static int usb_linux_get_configuration(USBHostDevice *s) -{ - uint8_t configuration; - struct usb_ctrltransfer ct; - int ret; - - if (usb_fs_type == USB_FS_SYS) { - char device_name[32], line[1024]; - int configuration; - - sprintf(device_name, "%d-%s", s->bus_num, s->port); - - if (!usb_host_read_file(line, sizeof(line), "bConfigurationValue", - device_name)) { - goto usbdevfs; - } - if (sscanf(line, "%d", &configuration) != 1) { - goto usbdevfs; - } - return configuration; - } - -usbdevfs: - ct.bRequestType = USB_DIR_IN; - ct.bRequest = USB_REQ_GET_CONFIGURATION; - ct.wValue = 0; - ct.wIndex = 0; - ct.wLength = 1; - ct.data = &configuration; - ct.timeout = 50; - - ret = ioctl(s->fd, USBDEVFS_CONTROL, &ct); - if (ret < 0) { - perror("usb_linux_get_configuration"); - return -1; - } - - /* in address state */ - if (configuration == 0) { - return -1; - } - - return configuration; -} - static uint8_t usb_linux_get_alt_setting(USBHostDevice *s, uint8_t configuration, uint8_t interface) { @@ -1000,16 +1132,19 @@ usbdevfs: static int usb_linux_update_endp_table(USBHostDevice *s) { uint8_t *descriptors; - uint8_t devep, type, configuration, alt_interface; - int interface, length, i; + uint8_t devep, type, alt_interface; + int interface, length, i, ep, pid; + struct endp_data *epd; - for (i = 0; i < MAX_ENDPOINTS; i++) - s->endp_table[i].type = INVALID_EP_TYPE; + for (i = 0; i < MAX_ENDPOINTS; i++) { + s->ep_in[i].type = INVALID_EP_TYPE; + s->ep_out[i].type = INVALID_EP_TYPE; + } - i = usb_linux_get_configuration(s); - if (i < 0) - return 1; - configuration = i; + if (s->configuration == 0) { + /* not configured yet -- leave all endpoints disabled */ + return 0; + } /* get the desired configuration, interface, and endpoint descriptors * from device description */ @@ -1017,14 +1152,18 @@ static int usb_linux_update_endp_table(U length = s->descr_len - 18; i = 0; - if (descriptors[i + 1] != USB_DT_CONFIG || - descriptors[i + 5] != configuration) { - DPRINTF("invalid descriptor data - configuration\n"); - return 1; - } - i += descriptors[i]; - while (i < length) { + if (descriptors[i + 1] != USB_DT_CONFIG) { + fprintf(stderr, "invalid descriptor data\n"); + return 1; + } else if (descriptors[i + 5] != s->configuration) { + DPRINTF("not requested configuration %d\n", s->configuration); + i += (descriptors[i + 3] << 8) + descriptors[i + 2]; + continue; + } + + i += descriptors[i]; + if (descriptors[i + 1] != USB_DT_INTERFACE || (descriptors[i + 1] == USB_DT_INTERFACE && descriptors[i + 4] == 0)) { @@ -1033,7 +1172,8 @@ static int usb_linux_update_endp_table(U } interface = descriptors[i + 2]; - alt_interface = usb_linux_get_alt_setting(s, configuration, interface); + alt_interface = usb_linux_get_alt_setting(s, s->configuration, + interface); /* the current interface descriptor is the active interface * and has endpoints */ @@ -1056,7 +1196,9 @@ static int usb_linux_update_endp_table(U } devep = descriptors[i + 2]; - if ((devep & 0x0f) == 0) { + pid = (devep & USB_DIR_IN) ? USB_TOKEN_IN : USB_TOKEN_OUT; + ep = devep & 0xf; + if (ep == 0) { fprintf(stderr, "usb-linux: invalid ep descriptor, ep == 0\n"); return 1; } @@ -1067,7 +1209,7 @@ static int usb_linux_update_endp_table(U break; case 0x01: type = USBDEVFS_URB_TYPE_ISO; - set_max_packet_size(s, (devep & 0xf), descriptors + i); + set_max_packet_size(s, pid, ep, descriptors + i); break; case 0x02: type = USBDEVFS_URB_TYPE_BULK; @@ -1079,8 +1221,10 @@ static int usb_linux_update_endp_table(U DPRINTF("usb_host: malformed endpoint type\n"); type = USBDEVFS_URB_TYPE_BULK; } - s->endp_table[(devep & 0xf) - 1].type = type; - s->endp_table[(devep & 0xf) - 1].halted = 0; + epd = get_endp(s, pid, ep); + assert(epd->type == INVALID_EP_TYPE); + epd->type = type; + epd->halted = 0; i += descriptors[i]; } @@ -1125,15 +1269,17 @@ static int usb_linux_full_speed_compat(U } static int usb_host_open(USBHostDevice *dev, int bus_num, - int addr, char *port, const char *prod_name, int speed) + int addr, const char *port, + const char *prod_name, int speed) { int fd = -1, ret; char buf[1024]; + trace_usb_host_open_started(bus_num, addr); + if (dev->fd != -1) { goto fail; } - printf("husb: open device %d.%d\n", bus_num, addr); if (!usb_host_device_path) { perror("husb: USB Host Device Path not set"); @@ -1172,13 +1318,8 @@ static int usb_host_open(USBHostDevice * #endif - /* - * Initial configuration is -1 which makes us claim first - * available config. We used to start with 1, which does not - * always work. I've seen devices where first config starts - * with 2. - */ - if (!usb_host_claim_interfaces(dev, -1)) { + /* start unconfigured -- we'll wait for the guest to set a configuration */ + if (!usb_host_claim_interfaces(dev, 0)) { goto fail; } @@ -1208,7 +1349,7 @@ static int usb_host_open(USBHostDevice * dev->dev.speedmask |= USB_SPEED_MASK_FULL; } - printf("husb: grabbed usb device %d.%d\n", bus_num, addr); + trace_usb_host_open_success(bus_num, addr); if (!prod_name || prod_name[0] == '\0') { snprintf(dev->dev.product_desc, sizeof(dev->dev.product_desc), @@ -1229,6 +1370,7 @@ static int usb_host_open(USBHostDevice * return 0; fail: + trace_usb_host_open_failure(bus_num, addr); if (dev->fd != -1) { close(dev->fd); dev->fd = -1; @@ -1240,21 +1382,28 @@ static int usb_host_close(USBHostDevice { int i; - if (dev->fd == -1 || !dev->dev.attached) { + if (dev->fd == -1) { return -1; } + trace_usb_host_close(dev->bus_num, dev->addr); + qemu_set_fd_handler(dev->fd, NULL, NULL, NULL); dev->closing = 1; for (i = 1; i <= MAX_ENDPOINTS; i++) { - if (is_isoc(dev, i)) { - usb_host_stop_n_free_iso(dev, i); + if (is_isoc(dev, USB_TOKEN_IN, i)) { + usb_host_stop_n_free_iso(dev, USB_TOKEN_IN, i); + } + if (is_isoc(dev, USB_TOKEN_OUT, i)) { + usb_host_stop_n_free_iso(dev, USB_TOKEN_OUT, i); } } async_complete(dev); dev->closing = 0; - usb_device_detach(&dev->dev); - ioctl(dev->fd, USBDEVFS_RESET); + if (dev->dev.attached) { + usb_device_detach(&dev->dev); + } + usb_host_do_reset(dev); close(dev->fd); dev->fd = -1; return 0; @@ -1264,8 +1413,9 @@ static void usb_host_exit_notifier(struc { USBHostDevice *s = container_of(n, USBHostDevice, exit); + usb_host_release_port(s); if (s->fd != -1) { - ioctl(s->fd, USBDEVFS_RESET); + usb_host_do_reset(s);; } } @@ -1275,17 +1425,29 @@ static int usb_host_initfn(USBDevice *de dev->auto_attach = 0; s->fd = -1; + s->hub_fd = -1; + QTAILQ_INSERT_TAIL(&hostdevs, s, next); s->exit.notify = usb_host_exit_notifier; qemu_add_exit_notifier(&s->exit); usb_host_auto_check(NULL); + + if (s->match.bus_num != 0 && s->match.port != NULL) { + usb_host_claim_port(s); + } return 0; } +static const VMStateDescription vmstate_usb_host = { + .name = "usb-host", + .unmigratable = 1, +}; + static struct USBDeviceInfo usb_host_dev_info = { .product_desc = "USB Host Device", .qdev.name = "usb-host", .qdev.size = sizeof(USBHostDevice), + .qdev.vmsd = &vmstate_usb_host, .init = usb_host_initfn, .handle_packet = usb_generic_handle_packet, .cancel_packet = usb_host_async_cancel, @@ -1411,7 +1573,8 @@ static int usb_host_scan_dev(void *opaqu FILE *f = NULL; char line[1024]; char buf[1024]; - int bus_num, addr, speed, device_count, class_id, product_id, vendor_id; + int bus_num, addr, speed, device_count; + int class_id, product_id, vendor_id, port; char product_name[512]; int ret = 0; @@ -1427,7 +1590,7 @@ static int usb_host_scan_dev(void *opaqu } device_count = 0; - bus_num = addr = class_id = product_id = vendor_id = 0; + bus_num = addr = class_id = product_id = vendor_id = port = 0; speed = -1; /* Can't get the speed from /[proc|dev]/bus/usb/devices */ for(;;) { if (fgets(line, sizeof(line), f) == NULL) { @@ -1439,7 +1602,12 @@ static int usb_host_scan_dev(void *opaqu if (line[0] == 'T' && line[1] == ':') { if (device_count && (vendor_id || product_id)) { /* New device. Add the previously discovered device. */ - ret = func(opaque, bus_num, addr, 0, class_id, vendor_id, + if (port > 0) { + snprintf(buf, sizeof(buf), "%d", port); + } else { + snprintf(buf, sizeof(buf), "?"); + } + ret = func(opaque, bus_num, addr, buf, class_id, vendor_id, product_id, product_name, speed); if (ret) { goto the_end; @@ -1449,6 +1617,10 @@ static int usb_host_scan_dev(void *opaqu goto fail; } bus_num = atoi(buf); + if (get_tag_value(buf, sizeof(buf), line, "Port=", " ") < 0) { + goto fail; + } + port = atoi(buf); if (get_tag_value(buf, sizeof(buf), line, "Dev#=", " ") < 0) { goto fail; } @@ -1494,7 +1666,12 @@ static int usb_host_scan_dev(void *opaqu } if (device_count && (vendor_id || product_id)) { /* Add the last device. */ - ret = func(opaque, bus_num, addr, 0, class_id, vendor_id, + if (port > 0) { + snprintf(buf, sizeof(buf), "%d", port); + } else { + snprintf(buf, sizeof(buf), "?"); + } + ret = func(opaque, bus_num, addr, buf, class_id, vendor_id, product_id, product_name, speed); } the_end: @@ -1678,7 +1855,7 @@ static int usb_host_scan(void *opaque, U } /* the module setting (used later for opening devices) */ - usb_host_device_path = qemu_mallocz(strlen(devpath)+1); + usb_host_device_path = g_malloc0(strlen(devpath)+1); strcpy(usb_host_device_path, devpath); if (mon) { monitor_printf(mon, "husb: using %s file-system with %s\n", @@ -1703,7 +1880,8 @@ static int usb_host_scan(void *opaque, U static QEMUTimer *usb_auto_timer; -static int usb_host_auto_scan(void *opaque, int bus_num, int addr, char *port, +static int usb_host_auto_scan(void *opaque, int bus_num, + int addr, const char *port, int class_id, int vendor_id, int product_id, const char *product_name, int speed) { @@ -1735,6 +1913,10 @@ static int usb_host_auto_scan(void *opaq continue; } /* We got a match */ + s->seen++; + if (s->errcount >= 3) { + return 0; + } /* Already attached ? */ if (s->fd != -1) { @@ -1742,7 +1924,9 @@ static int usb_host_auto_scan(void *opaq } DPRINTF("husb: auto open: bus_num %d addr %d\n", bus_num, addr); - usb_host_open(s, bus_num, addr, port, product_name, speed); + if (usb_host_open(s, bus_num, addr, port, product_name, speed) < 0) { + s->errcount++; + } break; } @@ -1760,12 +1944,17 @@ static void usb_host_auto_check(void *un if (s->fd == -1) { unconnected++; } + if (s->seen == 0) { + s->errcount = 0; + } + s->seen = 0; } if (unconnected == 0) { /* nothing to watch */ if (usb_auto_timer) { qemu_del_timer(usb_auto_timer); + trace_usb_host_auto_scan_disabled(); } return; } @@ -1775,6 +1964,7 @@ static void usb_host_auto_check(void *un if (!usb_auto_timer) { return; } + trace_usb_host_auto_scan_enabled(); } qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000); } @@ -1865,7 +2055,8 @@ static const char *usb_class_str(uint8_t return p->class_name; } -static void usb_info_device(Monitor *mon, int bus_num, int addr, char *port, +static void usb_info_device(Monitor *mon, int bus_num, + int addr, const char *port, int class_id, int vendor_id, int product_id, const char *product_name, int speed) @@ -1906,7 +2097,7 @@ static void usb_info_device(Monitor *mon } static int usb_host_info_device(void *opaque, int bus_num, int addr, - char *path, int class_id, + const char *path, int class_id, int vendor_id, int product_id, const char *product_name, int speed)