1816ac92eSJuergen Gross /* 2816ac92eSJuergen Gross * xen paravirt usb device backend 3816ac92eSJuergen Gross * 4816ac92eSJuergen Gross * (c) Juergen Gross <jgross@suse.com> 5816ac92eSJuergen Gross * 6816ac92eSJuergen Gross * This program is free software; you can redistribute it and/or modify 7816ac92eSJuergen Gross * it under the terms of the GNU General Public License as published by 8816ac92eSJuergen Gross * the Free Software Foundation; under version 2 of the License. 9816ac92eSJuergen Gross * 10816ac92eSJuergen Gross * This program is distributed in the hope that it will be useful, 11816ac92eSJuergen Gross * but WITHOUT ANY WARRANTY; without even the implied warranty of 12816ac92eSJuergen Gross * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13816ac92eSJuergen Gross * GNU General Public License for more details. 14816ac92eSJuergen Gross * 15816ac92eSJuergen Gross * You should have received a copy of the GNU General Public License along 16816ac92eSJuergen Gross * with this program; if not, see <http://www.gnu.org/licenses/>. 17816ac92eSJuergen Gross * 18816ac92eSJuergen Gross * Contributions after 2012-01-13 are licensed under the terms of the 19816ac92eSJuergen Gross * GNU GPL, version 2 or (at your option) any later version. 20816ac92eSJuergen Gross */ 21816ac92eSJuergen Gross 22816ac92eSJuergen Gross #include "qemu/osdep.h" 23b1b23e5bSPeter Maydell #include <libusb.h> 24a9c94277SMarkus Armbruster #include <sys/user.h> 25b1b23e5bSPeter Maydell 26816ac92eSJuergen Gross #include "qemu-common.h" 27816ac92eSJuergen Gross #include "qemu/config-file.h" 28816ac92eSJuergen Gross #include "hw/sysbus.h" 29816ac92eSJuergen Gross #include "hw/usb.h" 30816ac92eSJuergen Gross #include "hw/xen/xen_backend.h" 31816ac92eSJuergen Gross #include "monitor/qdev.h" 32816ac92eSJuergen Gross #include "qapi/qmp/qbool.h" 33816ac92eSJuergen Gross #include "qapi/qmp/qint.h" 34816ac92eSJuergen Gross #include "qapi/qmp/qstring.h" 35816ac92eSJuergen Gross 36*f65eadb6SStefano Stabellini #include "hw/xen/io/ring.h" 37816ac92eSJuergen Gross #include <xen/io/usbif.h> 38816ac92eSJuergen Gross 39816ac92eSJuergen Gross /* 40816ac92eSJuergen Gross * Check for required support of usbif.h: USBIF_SHORT_NOT_OK was the last 41816ac92eSJuergen Gross * macro added we rely on. 42816ac92eSJuergen Gross */ 43816ac92eSJuergen Gross #ifdef USBIF_SHORT_NOT_OK 44816ac92eSJuergen Gross 45816ac92eSJuergen Gross #define TR(xendev, lvl, fmt, args...) \ 46816ac92eSJuergen Gross { \ 47816ac92eSJuergen Gross struct timeval tv; \ 48816ac92eSJuergen Gross \ 49816ac92eSJuergen Gross gettimeofday(&tv, NULL); \ 5096c77dbaSEmil Condrea xen_pv_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \ 51816ac92eSJuergen Gross tv.tv_sec, tv.tv_usec, __func__, ##args); \ 52816ac92eSJuergen Gross } 53816ac92eSJuergen Gross #define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args) 54816ac92eSJuergen Gross #define TR_REQ(xendev, fmt, args...) TR(xendev, 3, fmt, ##args) 55816ac92eSJuergen Gross 56816ac92eSJuergen Gross #define USBBACK_MAXPORTS USBIF_PIPE_PORT_MASK 57816ac92eSJuergen Gross #define USB_DEV_ADDR_SIZE (USBIF_PIPE_DEV_MASK + 1) 58816ac92eSJuergen Gross 59816ac92eSJuergen Gross /* USB wire protocol: structure describing control request parameter. */ 60816ac92eSJuergen Gross struct usbif_ctrlrequest { 61816ac92eSJuergen Gross uint8_t bRequestType; 62816ac92eSJuergen Gross uint8_t bRequest; 63816ac92eSJuergen Gross uint16_t wValue; 64816ac92eSJuergen Gross uint16_t wIndex; 65816ac92eSJuergen Gross uint16_t wLength; 66816ac92eSJuergen Gross }; 67816ac92eSJuergen Gross 68816ac92eSJuergen Gross struct usbback_info; 69816ac92eSJuergen Gross struct usbback_req; 70816ac92eSJuergen Gross 71816ac92eSJuergen Gross struct usbback_stub { 72816ac92eSJuergen Gross USBDevice *dev; 73816ac92eSJuergen Gross USBPort port; 74816ac92eSJuergen Gross unsigned int speed; 75816ac92eSJuergen Gross bool attached; 76816ac92eSJuergen Gross QTAILQ_HEAD(submit_q_head, usbback_req) submit_q; 77816ac92eSJuergen Gross }; 78816ac92eSJuergen Gross 79816ac92eSJuergen Gross struct usbback_req { 80816ac92eSJuergen Gross struct usbback_info *usbif; 81816ac92eSJuergen Gross struct usbback_stub *stub; 82816ac92eSJuergen Gross struct usbif_urb_request req; 83816ac92eSJuergen Gross USBPacket packet; 84816ac92eSJuergen Gross 85816ac92eSJuergen Gross unsigned int nr_buffer_segs; /* # of transfer_buffer segments */ 86816ac92eSJuergen Gross unsigned int nr_extra_segs; /* # of iso_frame_desc segments */ 87816ac92eSJuergen Gross 88816ac92eSJuergen Gross QTAILQ_ENTRY(usbback_req) q; 89816ac92eSJuergen Gross 90816ac92eSJuergen Gross void *buffer; 91816ac92eSJuergen Gross void *isoc_buffer; 92816ac92eSJuergen Gross struct libusb_transfer *xfer; 9380440ea0SJuergen Gross 9480440ea0SJuergen Gross bool cancelled; 95816ac92eSJuergen Gross }; 96816ac92eSJuergen Gross 97816ac92eSJuergen Gross struct usbback_hotplug { 98816ac92eSJuergen Gross QSIMPLEQ_ENTRY(usbback_hotplug) q; 99816ac92eSJuergen Gross unsigned port; 100816ac92eSJuergen Gross }; 101816ac92eSJuergen Gross 102816ac92eSJuergen Gross struct usbback_info { 103816ac92eSJuergen Gross struct XenDevice xendev; /* must be first */ 104816ac92eSJuergen Gross USBBus bus; 105816ac92eSJuergen Gross void *urb_sring; 106816ac92eSJuergen Gross void *conn_sring; 107816ac92eSJuergen Gross struct usbif_urb_back_ring urb_ring; 108816ac92eSJuergen Gross struct usbif_conn_back_ring conn_ring; 109816ac92eSJuergen Gross int num_ports; 110816ac92eSJuergen Gross int usb_ver; 111816ac92eSJuergen Gross bool ring_error; 112816ac92eSJuergen Gross QTAILQ_HEAD(req_free_q_head, usbback_req) req_free_q; 113816ac92eSJuergen Gross QSIMPLEQ_HEAD(hotplug_q_head, usbback_hotplug) hotplug_q; 114816ac92eSJuergen Gross struct usbback_stub ports[USBBACK_MAXPORTS]; 115816ac92eSJuergen Gross struct usbback_stub *addr_table[USB_DEV_ADDR_SIZE]; 116816ac92eSJuergen Gross QEMUBH *bh; 117816ac92eSJuergen Gross }; 118816ac92eSJuergen Gross 119816ac92eSJuergen Gross static struct usbback_req *usbback_get_req(struct usbback_info *usbif) 120816ac92eSJuergen Gross { 121816ac92eSJuergen Gross struct usbback_req *usbback_req; 122816ac92eSJuergen Gross 123816ac92eSJuergen Gross if (QTAILQ_EMPTY(&usbif->req_free_q)) { 124816ac92eSJuergen Gross usbback_req = g_new0(struct usbback_req, 1); 125816ac92eSJuergen Gross } else { 126816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 127816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 128816ac92eSJuergen Gross } 129816ac92eSJuergen Gross return usbback_req; 130816ac92eSJuergen Gross } 131816ac92eSJuergen Gross 132816ac92eSJuergen Gross static void usbback_put_req(struct usbback_req *usbback_req) 133816ac92eSJuergen Gross { 134816ac92eSJuergen Gross struct usbback_info *usbif; 135816ac92eSJuergen Gross 136816ac92eSJuergen Gross usbif = usbback_req->usbif; 137816ac92eSJuergen Gross memset(usbback_req, 0, sizeof(*usbback_req)); 138816ac92eSJuergen Gross QTAILQ_INSERT_HEAD(&usbif->req_free_q, usbback_req, q); 139816ac92eSJuergen Gross } 140816ac92eSJuergen Gross 141816ac92eSJuergen Gross static int usbback_gnttab_map(struct usbback_req *usbback_req) 142816ac92eSJuergen Gross { 143816ac92eSJuergen Gross unsigned int nr_segs, i, prot; 144816ac92eSJuergen Gross uint32_t ref[USBIF_MAX_SEGMENTS_PER_REQUEST]; 145816ac92eSJuergen Gross struct usbback_info *usbif = usbback_req->usbif; 146816ac92eSJuergen Gross struct XenDevice *xendev = &usbif->xendev; 147816ac92eSJuergen Gross struct usbif_request_segment *seg; 148816ac92eSJuergen Gross void *addr; 149816ac92eSJuergen Gross 150816ac92eSJuergen Gross nr_segs = usbback_req->nr_buffer_segs + usbback_req->nr_extra_segs; 151816ac92eSJuergen Gross if (!nr_segs) { 152816ac92eSJuergen Gross return 0; 153816ac92eSJuergen Gross } 154816ac92eSJuergen Gross 155816ac92eSJuergen Gross if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) { 15696c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "bad number of segments in request (%d)\n", 157816ac92eSJuergen Gross nr_segs); 158816ac92eSJuergen Gross return -EINVAL; 159816ac92eSJuergen Gross } 160816ac92eSJuergen Gross 161816ac92eSJuergen Gross for (i = 0; i < nr_segs; i++) { 162816ac92eSJuergen Gross if ((unsigned)usbback_req->req.seg[i].offset + 163c6d25aa6SStefano Stabellini (unsigned)usbback_req->req.seg[i].length > XC_PAGE_SIZE) { 16496c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "segment crosses page boundary\n"); 165816ac92eSJuergen Gross return -EINVAL; 166816ac92eSJuergen Gross } 167816ac92eSJuergen Gross } 168816ac92eSJuergen Gross 169816ac92eSJuergen Gross if (usbback_req->nr_buffer_segs) { 170816ac92eSJuergen Gross prot = PROT_READ; 171816ac92eSJuergen Gross if (usbif_pipein(usbback_req->req.pipe)) { 172816ac92eSJuergen Gross prot |= PROT_WRITE; 173816ac92eSJuergen Gross } 174816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 175816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i].gref; 176816ac92eSJuergen Gross } 177816ac92eSJuergen Gross usbback_req->buffer = xengnttab_map_domain_grant_refs(xendev->gnttabdev, 178816ac92eSJuergen Gross usbback_req->nr_buffer_segs, xendev->dom, ref, prot); 179816ac92eSJuergen Gross 180816ac92eSJuergen Gross if (!usbback_req->buffer) { 181816ac92eSJuergen Gross return -ENOMEM; 182816ac92eSJuergen Gross } 183816ac92eSJuergen Gross 184816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 185816ac92eSJuergen Gross seg = usbback_req->req.seg + i; 186c6d25aa6SStefano Stabellini addr = usbback_req->buffer + i * XC_PAGE_SIZE + seg->offset; 187816ac92eSJuergen Gross qemu_iovec_add(&usbback_req->packet.iov, addr, seg->length); 188816ac92eSJuergen Gross } 189816ac92eSJuergen Gross } 190816ac92eSJuergen Gross 191816ac92eSJuergen Gross if (!usbif_pipeisoc(usbback_req->req.pipe)) { 192816ac92eSJuergen Gross return 0; 193816ac92eSJuergen Gross } 194816ac92eSJuergen Gross 195816ac92eSJuergen Gross /* 196816ac92eSJuergen Gross * Right now isoc requests are not supported. 197816ac92eSJuergen Gross * Prepare supporting those by doing the work needed on the guest 198816ac92eSJuergen Gross * interface side. 199816ac92eSJuergen Gross */ 200816ac92eSJuergen Gross 201816ac92eSJuergen Gross if (!usbback_req->nr_extra_segs) { 20296c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "iso request without descriptor segments\n"); 203816ac92eSJuergen Gross return -EINVAL; 204816ac92eSJuergen Gross } 205816ac92eSJuergen Gross 206816ac92eSJuergen Gross prot = PROT_READ | PROT_WRITE; 207816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_extra_segs; i++) { 208816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i + usbback_req->req.nr_buffer_segs].gref; 209816ac92eSJuergen Gross } 210816ac92eSJuergen Gross usbback_req->isoc_buffer = xengnttab_map_domain_grant_refs( 211816ac92eSJuergen Gross xendev->gnttabdev, usbback_req->nr_extra_segs, xendev->dom, ref, prot); 212816ac92eSJuergen Gross 213816ac92eSJuergen Gross if (!usbback_req->isoc_buffer) { 214816ac92eSJuergen Gross return -ENOMEM; 215816ac92eSJuergen Gross } 216816ac92eSJuergen Gross 217816ac92eSJuergen Gross return 0; 218816ac92eSJuergen Gross } 219816ac92eSJuergen Gross 220816ac92eSJuergen Gross static int usbback_init_packet(struct usbback_req *usbback_req) 221816ac92eSJuergen Gross { 222816ac92eSJuergen Gross struct XenDevice *xendev = &usbback_req->usbif->xendev; 223816ac92eSJuergen Gross USBPacket *packet = &usbback_req->packet; 224816ac92eSJuergen Gross USBDevice *dev = usbback_req->stub->dev; 225816ac92eSJuergen Gross USBEndpoint *ep; 226816ac92eSJuergen Gross unsigned int pid, ep_nr; 227816ac92eSJuergen Gross bool sok; 228816ac92eSJuergen Gross int ret = 0; 229816ac92eSJuergen Gross 230816ac92eSJuergen Gross qemu_iovec_init(&packet->iov, USBIF_MAX_SEGMENTS_PER_REQUEST); 231816ac92eSJuergen Gross pid = usbif_pipein(usbback_req->req.pipe) ? USB_TOKEN_IN : USB_TOKEN_OUT; 232816ac92eSJuergen Gross ep_nr = usbif_pipeendpoint(usbback_req->req.pipe); 233816ac92eSJuergen Gross sok = !!(usbback_req->req.transfer_flags & USBIF_SHORT_NOT_OK); 234816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 235816ac92eSJuergen Gross ep_nr = 0; 236816ac92eSJuergen Gross sok = false; 237816ac92eSJuergen Gross } 238816ac92eSJuergen Gross ep = usb_ep_get(dev, pid, ep_nr); 239816ac92eSJuergen Gross usb_packet_setup(packet, pid, ep, 0, 1, sok, true); 240816ac92eSJuergen Gross 241816ac92eSJuergen Gross switch (usbif_pipetype(usbback_req->req.pipe)) { 242816ac92eSJuergen Gross case USBIF_PIPE_TYPE_ISOC: 243816ac92eSJuergen Gross TR_REQ(xendev, "iso transfer %s: buflen: %x, %d frames\n", 244816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 245816ac92eSJuergen Gross usbback_req->req.buffer_length, 246816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs); 247816ac92eSJuergen Gross ret = -EINVAL; /* isoc not implemented yet */ 248816ac92eSJuergen Gross break; 249816ac92eSJuergen Gross 250816ac92eSJuergen Gross case USBIF_PIPE_TYPE_INT: 251816ac92eSJuergen Gross TR_REQ(xendev, "int transfer %s: buflen: %x\n", 252816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 253816ac92eSJuergen Gross usbback_req->req.buffer_length); 254816ac92eSJuergen Gross break; 255816ac92eSJuergen Gross 256816ac92eSJuergen Gross case USBIF_PIPE_TYPE_CTRL: 257816ac92eSJuergen Gross packet->parameter = *(uint64_t *)usbback_req->req.u.ctrl; 258042ec47eSAnthony PERARD TR_REQ(xendev, "ctrl parameter: %"PRIx64", buflen: %x\n", 259042ec47eSAnthony PERARD packet->parameter, 260816ac92eSJuergen Gross usbback_req->req.buffer_length); 261816ac92eSJuergen Gross break; 262816ac92eSJuergen Gross 263816ac92eSJuergen Gross case USBIF_PIPE_TYPE_BULK: 264816ac92eSJuergen Gross TR_REQ(xendev, "bulk transfer %s: buflen: %x\n", 265816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 266816ac92eSJuergen Gross usbback_req->req.buffer_length); 267816ac92eSJuergen Gross break; 268816ac92eSJuergen Gross default: 269816ac92eSJuergen Gross ret = -EINVAL; 270816ac92eSJuergen Gross break; 271816ac92eSJuergen Gross } 272816ac92eSJuergen Gross 273816ac92eSJuergen Gross return ret; 274816ac92eSJuergen Gross } 275816ac92eSJuergen Gross 276816ac92eSJuergen Gross static void usbback_do_response(struct usbback_req *usbback_req, int32_t status, 277816ac92eSJuergen Gross int32_t actual_length, int32_t error_count) 278816ac92eSJuergen Gross { 279816ac92eSJuergen Gross struct usbback_info *usbif; 280816ac92eSJuergen Gross struct usbif_urb_response *res; 281816ac92eSJuergen Gross struct XenDevice *xendev; 282816ac92eSJuergen Gross unsigned int notify; 283816ac92eSJuergen Gross 284816ac92eSJuergen Gross usbif = usbback_req->usbif; 285816ac92eSJuergen Gross xendev = &usbif->xendev; 286816ac92eSJuergen Gross 287816ac92eSJuergen Gross TR_REQ(xendev, "id %d, status %d, length %d, errcnt %d\n", 288816ac92eSJuergen Gross usbback_req->req.id, status, actual_length, error_count); 289816ac92eSJuergen Gross 290816ac92eSJuergen Gross if (usbback_req->packet.iov.iov) { 291816ac92eSJuergen Gross qemu_iovec_destroy(&usbback_req->packet.iov); 292816ac92eSJuergen Gross } 293816ac92eSJuergen Gross 294816ac92eSJuergen Gross if (usbback_req->buffer) { 295816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbback_req->buffer, 296816ac92eSJuergen Gross usbback_req->nr_buffer_segs); 297816ac92eSJuergen Gross usbback_req->buffer = NULL; 298816ac92eSJuergen Gross } 299816ac92eSJuergen Gross 300816ac92eSJuergen Gross if (usbback_req->isoc_buffer) { 301816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbback_req->isoc_buffer, 302816ac92eSJuergen Gross usbback_req->nr_extra_segs); 303816ac92eSJuergen Gross usbback_req->isoc_buffer = NULL; 304816ac92eSJuergen Gross } 305816ac92eSJuergen Gross 30680440ea0SJuergen Gross if (usbif->urb_sring) { 307816ac92eSJuergen Gross res = RING_GET_RESPONSE(&usbif->urb_ring, usbif->urb_ring.rsp_prod_pvt); 308816ac92eSJuergen Gross res->id = usbback_req->req.id; 309816ac92eSJuergen Gross res->status = status; 310816ac92eSJuergen Gross res->actual_length = actual_length; 311816ac92eSJuergen Gross res->error_count = error_count; 312816ac92eSJuergen Gross res->start_frame = 0; 313816ac92eSJuergen Gross usbif->urb_ring.rsp_prod_pvt++; 314816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&usbif->urb_ring, notify); 315816ac92eSJuergen Gross 316816ac92eSJuergen Gross if (notify) { 317ba18fa2aSEmil Condrea xen_pv_send_notify(xendev); 318816ac92eSJuergen Gross } 31980440ea0SJuergen Gross } 320816ac92eSJuergen Gross 32180440ea0SJuergen Gross if (!usbback_req->cancelled) 322816ac92eSJuergen Gross usbback_put_req(usbback_req); 323816ac92eSJuergen Gross } 324816ac92eSJuergen Gross 325816ac92eSJuergen Gross static void usbback_do_response_ret(struct usbback_req *usbback_req, 326816ac92eSJuergen Gross int32_t status) 327816ac92eSJuergen Gross { 328816ac92eSJuergen Gross usbback_do_response(usbback_req, status, 0, 0); 329816ac92eSJuergen Gross } 330816ac92eSJuergen Gross 331816ac92eSJuergen Gross static int32_t usbback_xlat_status(int status) 332816ac92eSJuergen Gross { 333816ac92eSJuergen Gross switch (status) { 334816ac92eSJuergen Gross case USB_RET_SUCCESS: 335816ac92eSJuergen Gross return 0; 336816ac92eSJuergen Gross case USB_RET_NODEV: 337816ac92eSJuergen Gross return -ENODEV; 338816ac92eSJuergen Gross case USB_RET_STALL: 339816ac92eSJuergen Gross return -EPIPE; 340816ac92eSJuergen Gross case USB_RET_BABBLE: 341816ac92eSJuergen Gross return -EOVERFLOW; 342816ac92eSJuergen Gross case USB_RET_IOERROR: 343816ac92eSJuergen Gross return -EPROTO; 344816ac92eSJuergen Gross } 345816ac92eSJuergen Gross 346816ac92eSJuergen Gross return -ESHUTDOWN; 347816ac92eSJuergen Gross } 348816ac92eSJuergen Gross 349816ac92eSJuergen Gross static void usbback_packet_complete(USBPacket *packet) 350816ac92eSJuergen Gross { 351816ac92eSJuergen Gross struct usbback_req *usbback_req; 352816ac92eSJuergen Gross int32_t status; 353816ac92eSJuergen Gross 354816ac92eSJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 355816ac92eSJuergen Gross 356816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 357816ac92eSJuergen Gross 358816ac92eSJuergen Gross status = usbback_xlat_status(packet->status); 359816ac92eSJuergen Gross usbback_do_response(usbback_req, status, packet->actual_length, 0); 360816ac92eSJuergen Gross } 361816ac92eSJuergen Gross 362816ac92eSJuergen Gross static void usbback_set_address(struct usbback_info *usbif, 363816ac92eSJuergen Gross struct usbback_stub *stub, 364816ac92eSJuergen Gross unsigned int cur_addr, unsigned int new_addr) 365816ac92eSJuergen Gross { 366816ac92eSJuergen Gross if (cur_addr) { 367816ac92eSJuergen Gross usbif->addr_table[cur_addr] = NULL; 368816ac92eSJuergen Gross } 369816ac92eSJuergen Gross if (new_addr) { 370816ac92eSJuergen Gross usbif->addr_table[new_addr] = stub; 371816ac92eSJuergen Gross } 372816ac92eSJuergen Gross } 373816ac92eSJuergen Gross 37480440ea0SJuergen Gross static void usbback_cancel_req(struct usbback_req *usbback_req) 375816ac92eSJuergen Gross { 376816ac92eSJuergen Gross if (usb_packet_is_inflight(&usbback_req->packet)) { 377816ac92eSJuergen Gross usb_cancel_packet(&usbback_req->packet); 37880440ea0SJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 37980440ea0SJuergen Gross usbback_req->cancelled = true; 38080440ea0SJuergen Gross usbback_do_response_ret(usbback_req, -EPROTO); 381816ac92eSJuergen Gross } 382816ac92eSJuergen Gross } 383816ac92eSJuergen Gross 384816ac92eSJuergen Gross static void usbback_process_unlink_req(struct usbback_req *usbback_req) 385816ac92eSJuergen Gross { 386816ac92eSJuergen Gross struct usbback_info *usbif; 387816ac92eSJuergen Gross struct usbback_req *unlink_req; 388816ac92eSJuergen Gross unsigned int id, devnum; 389816ac92eSJuergen Gross int ret; 390816ac92eSJuergen Gross 391816ac92eSJuergen Gross usbif = usbback_req->usbif; 392816ac92eSJuergen Gross ret = 0; 393816ac92eSJuergen Gross id = usbback_req->req.u.unlink.unlink_id; 394816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "unlink id %d\n", id); 395816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 396816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 397816ac92eSJuergen Gross usbback_req->stub = usbif->ports + 39880440ea0SJuergen Gross usbif_pipeportnum(usbback_req->req.pipe) - 1; 399816ac92eSJuergen Gross if (unlikely(!usbback_req->stub)) { 400816ac92eSJuergen Gross ret = -ENODEV; 401816ac92eSJuergen Gross goto fail_response; 402816ac92eSJuergen Gross } 403816ac92eSJuergen Gross } else { 404816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 405816ac92eSJuergen Gross ret = -ENODEV; 406816ac92eSJuergen Gross goto fail_response; 407816ac92eSJuergen Gross } 408816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 409816ac92eSJuergen Gross } 410816ac92eSJuergen Gross 411816ac92eSJuergen Gross QTAILQ_FOREACH(unlink_req, &usbback_req->stub->submit_q, q) { 412816ac92eSJuergen Gross if (unlink_req->req.id == id) { 41380440ea0SJuergen Gross usbback_cancel_req(unlink_req); 414816ac92eSJuergen Gross break; 415816ac92eSJuergen Gross } 416816ac92eSJuergen Gross } 417816ac92eSJuergen Gross 418816ac92eSJuergen Gross fail_response: 419816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 420816ac92eSJuergen Gross } 421816ac92eSJuergen Gross 422816ac92eSJuergen Gross /* 423816ac92eSJuergen Gross * Checks whether a request can be handled at once or should be forwarded 424816ac92eSJuergen Gross * to the usb framework. 425816ac92eSJuergen Gross * Return value is: 426816ac92eSJuergen Gross * 0 in case of usb framework is needed 427816ac92eSJuergen Gross * 1 in case of local handling (no error) 428816ac92eSJuergen Gross * The request response has been queued already if return value not 0. 429816ac92eSJuergen Gross */ 430816ac92eSJuergen Gross static int usbback_check_and_submit(struct usbback_req *usbback_req) 431816ac92eSJuergen Gross { 432816ac92eSJuergen Gross struct usbback_info *usbif; 433816ac92eSJuergen Gross unsigned int devnum; 434816ac92eSJuergen Gross struct usbback_stub *stub; 435816ac92eSJuergen Gross struct usbif_ctrlrequest *ctrl; 436816ac92eSJuergen Gross int ret; 437816ac92eSJuergen Gross uint16_t wValue; 438816ac92eSJuergen Gross 439816ac92eSJuergen Gross usbif = usbback_req->usbif; 440816ac92eSJuergen Gross stub = NULL; 441816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 442816ac92eSJuergen Gross ctrl = (struct usbif_ctrlrequest *)usbback_req->req.u.ctrl; 443816ac92eSJuergen Gross wValue = le16_to_cpu(ctrl->wValue); 444816ac92eSJuergen Gross 445816ac92eSJuergen Gross /* 446816ac92eSJuergen Gross * When the device is first connected or resetted, USB device has no 447816ac92eSJuergen Gross * address. In this initial state, following requests are sent to device 448816ac92eSJuergen Gross * address (#0), 449816ac92eSJuergen Gross * 450816ac92eSJuergen Gross * 1. GET_DESCRIPTOR (with Descriptor Type is "DEVICE") is sent, 451816ac92eSJuergen Gross * and OS knows what device is connected to. 452816ac92eSJuergen Gross * 453816ac92eSJuergen Gross * 2. SET_ADDRESS is sent, and then device has its address. 454816ac92eSJuergen Gross * 455816ac92eSJuergen Gross * In the next step, SET_CONFIGURATION is sent to addressed device, and 456816ac92eSJuergen Gross * then the device is finally ready to use. 457816ac92eSJuergen Gross */ 458816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 459816ac92eSJuergen Gross stub = usbif->ports + usbif_pipeportnum(usbback_req->req.pipe) - 1; 460816ac92eSJuergen Gross if (!stub->dev || !stub->attached) { 461816ac92eSJuergen Gross ret = -ENODEV; 462816ac92eSJuergen Gross goto do_response; 463816ac92eSJuergen Gross } 464816ac92eSJuergen Gross 465816ac92eSJuergen Gross switch (ctrl->bRequest) { 466816ac92eSJuergen Gross case USB_REQ_GET_DESCRIPTOR: 467816ac92eSJuergen Gross /* 468816ac92eSJuergen Gross * GET_DESCRIPTOR request to device #0. 469816ac92eSJuergen Gross * through normal transfer. 470816ac92eSJuergen Gross */ 471816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 GET_DESCRIPTOR\n"); 472816ac92eSJuergen Gross usbback_req->stub = stub; 473816ac92eSJuergen Gross return 0; 474816ac92eSJuergen Gross case USB_REQ_SET_ADDRESS: 475816ac92eSJuergen Gross /* 476816ac92eSJuergen Gross * SET_ADDRESS request to device #0. 477816ac92eSJuergen Gross * add attached device to addr_table. 478816ac92eSJuergen Gross */ 479816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 SET_ADDRESS\n"); 480816ac92eSJuergen Gross usbback_set_address(usbif, stub, 0, wValue); 481816ac92eSJuergen Gross ret = 0; 482816ac92eSJuergen Gross break; 483816ac92eSJuergen Gross default: 484816ac92eSJuergen Gross ret = -EINVAL; 485816ac92eSJuergen Gross break; 486816ac92eSJuergen Gross } 487816ac92eSJuergen Gross goto do_response; 488816ac92eSJuergen Gross } 489816ac92eSJuergen Gross 490816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 491816ac92eSJuergen Gross ret = -ENODEV; 492816ac92eSJuergen Gross goto do_response; 493816ac92eSJuergen Gross } 494816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 495816ac92eSJuergen Gross 496816ac92eSJuergen Gross /* 497816ac92eSJuergen Gross * Check special request 498816ac92eSJuergen Gross */ 499816ac92eSJuergen Gross if (ctrl->bRequest != USB_REQ_SET_ADDRESS) { 500816ac92eSJuergen Gross return 0; 501816ac92eSJuergen Gross } 502816ac92eSJuergen Gross 503816ac92eSJuergen Gross /* 504816ac92eSJuergen Gross * SET_ADDRESS request to addressed device. 505816ac92eSJuergen Gross * change addr or remove from addr_table. 506816ac92eSJuergen Gross */ 507816ac92eSJuergen Gross usbback_set_address(usbif, usbback_req->stub, devnum, wValue); 508816ac92eSJuergen Gross ret = 0; 509816ac92eSJuergen Gross 510816ac92eSJuergen Gross do_response: 511816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 512816ac92eSJuergen Gross return 1; 513816ac92eSJuergen Gross } 514816ac92eSJuergen Gross 515816ac92eSJuergen Gross static void usbback_dispatch(struct usbback_req *usbback_req) 516816ac92eSJuergen Gross { 517816ac92eSJuergen Gross int ret; 518816ac92eSJuergen Gross unsigned int devnum; 519816ac92eSJuergen Gross struct usbback_info *usbif; 520816ac92eSJuergen Gross 521816ac92eSJuergen Gross usbif = usbback_req->usbif; 522816ac92eSJuergen Gross 523816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "start req_id %d pipe %08x\n", usbback_req->req.id, 524816ac92eSJuergen Gross usbback_req->req.pipe); 525816ac92eSJuergen Gross 526816ac92eSJuergen Gross /* unlink request */ 527816ac92eSJuergen Gross if (unlikely(usbif_pipeunlink(usbback_req->req.pipe))) { 528816ac92eSJuergen Gross usbback_process_unlink_req(usbback_req); 529816ac92eSJuergen Gross return; 530816ac92eSJuergen Gross } 531816ac92eSJuergen Gross 532816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 533816ac92eSJuergen Gross if (usbback_check_and_submit(usbback_req)) { 534816ac92eSJuergen Gross return; 535816ac92eSJuergen Gross } 536816ac92eSJuergen Gross } else { 537816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 538816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 539816ac92eSJuergen Gross 540816ac92eSJuergen Gross if (!usbback_req->stub || !usbback_req->stub->attached) { 541816ac92eSJuergen Gross ret = -ENODEV; 542816ac92eSJuergen Gross goto fail_response; 543816ac92eSJuergen Gross } 544816ac92eSJuergen Gross } 545816ac92eSJuergen Gross 546816ac92eSJuergen Gross QTAILQ_INSERT_TAIL(&usbback_req->stub->submit_q, usbback_req, q); 547816ac92eSJuergen Gross 548816ac92eSJuergen Gross usbback_req->nr_buffer_segs = usbback_req->req.nr_buffer_segs; 549816ac92eSJuergen Gross usbback_req->nr_extra_segs = usbif_pipeisoc(usbback_req->req.pipe) ? 550816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs : 0; 551816ac92eSJuergen Gross 552816ac92eSJuergen Gross ret = usbback_init_packet(usbback_req); 553816ac92eSJuergen Gross if (ret) { 55496c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid request\n"); 555816ac92eSJuergen Gross ret = -ESHUTDOWN; 556816ac92eSJuergen Gross goto fail_free_urb; 557816ac92eSJuergen Gross } 558816ac92eSJuergen Gross 559816ac92eSJuergen Gross ret = usbback_gnttab_map(usbback_req); 560816ac92eSJuergen Gross if (ret) { 56196c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); 562816ac92eSJuergen Gross ret = -ESHUTDOWN; 563816ac92eSJuergen Gross goto fail_free_urb; 564816ac92eSJuergen Gross } 565816ac92eSJuergen Gross 566816ac92eSJuergen Gross usb_handle_packet(usbback_req->stub->dev, &usbback_req->packet); 567816ac92eSJuergen Gross if (usbback_req->packet.status != USB_RET_ASYNC) { 568816ac92eSJuergen Gross usbback_packet_complete(&usbback_req->packet); 569816ac92eSJuergen Gross } 570816ac92eSJuergen Gross return; 571816ac92eSJuergen Gross 572816ac92eSJuergen Gross fail_free_urb: 573816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 574816ac92eSJuergen Gross 575816ac92eSJuergen Gross fail_response: 576816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 577816ac92eSJuergen Gross } 578816ac92eSJuergen Gross 579816ac92eSJuergen Gross static void usbback_hotplug_notify(struct usbback_info *usbif) 580816ac92eSJuergen Gross { 581816ac92eSJuergen Gross struct usbif_conn_back_ring *ring = &usbif->conn_ring; 582816ac92eSJuergen Gross struct usbif_conn_request req; 583816ac92eSJuergen Gross struct usbif_conn_response *res; 584816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 585816ac92eSJuergen Gross unsigned int notify; 586816ac92eSJuergen Gross 587816ac92eSJuergen Gross if (!usbif->conn_sring) { 588816ac92eSJuergen Gross return; 589816ac92eSJuergen Gross } 590816ac92eSJuergen Gross 591816ac92eSJuergen Gross /* Check for full ring. */ 592816ac92eSJuergen Gross if ((RING_SIZE(ring) - ring->rsp_prod_pvt - ring->req_cons) == 0) { 593ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 594816ac92eSJuergen Gross return; 595816ac92eSJuergen Gross } 596816ac92eSJuergen Gross 597816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 598816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 599816ac92eSJuergen Gross 600816ac92eSJuergen Gross RING_COPY_REQUEST(ring, ring->req_cons, &req); 601816ac92eSJuergen Gross ring->req_cons++; 602816ac92eSJuergen Gross ring->sring->req_event = ring->req_cons + 1; 603816ac92eSJuergen Gross 604816ac92eSJuergen Gross res = RING_GET_RESPONSE(ring, ring->rsp_prod_pvt); 605816ac92eSJuergen Gross res->id = req.id; 606816ac92eSJuergen Gross res->portnum = usb_hp->port; 607816ac92eSJuergen Gross res->speed = usbif->ports[usb_hp->port - 1].speed; 608816ac92eSJuergen Gross ring->rsp_prod_pvt++; 609816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); 610816ac92eSJuergen Gross 611816ac92eSJuergen Gross if (notify) { 612ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 613816ac92eSJuergen Gross } 614816ac92eSJuergen Gross 615816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "hotplug port %d speed %d\n", usb_hp->port, 616816ac92eSJuergen Gross res->speed); 617816ac92eSJuergen Gross 618816ac92eSJuergen Gross g_free(usb_hp); 619816ac92eSJuergen Gross 620816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 621816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 622816ac92eSJuergen Gross } 623816ac92eSJuergen Gross } 624816ac92eSJuergen Gross 625816ac92eSJuergen Gross static void usbback_bh(void *opaque) 626816ac92eSJuergen Gross { 627816ac92eSJuergen Gross struct usbback_info *usbif; 628816ac92eSJuergen Gross struct usbif_urb_back_ring *urb_ring; 629816ac92eSJuergen Gross struct usbback_req *usbback_req; 630816ac92eSJuergen Gross RING_IDX rc, rp; 631816ac92eSJuergen Gross unsigned int more_to_do; 632816ac92eSJuergen Gross 633816ac92eSJuergen Gross usbif = opaque; 634816ac92eSJuergen Gross if (usbif->ring_error) { 635816ac92eSJuergen Gross return; 636816ac92eSJuergen Gross } 637816ac92eSJuergen Gross 638816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 639816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 640816ac92eSJuergen Gross } 641816ac92eSJuergen Gross 642816ac92eSJuergen Gross urb_ring = &usbif->urb_ring; 643816ac92eSJuergen Gross rc = urb_ring->req_cons; 644816ac92eSJuergen Gross rp = urb_ring->sring->req_prod; 645816ac92eSJuergen Gross xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ 646816ac92eSJuergen Gross 647816ac92eSJuergen Gross if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { 648816ac92eSJuergen Gross rc = urb_ring->rsp_prod_pvt; 64996c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests " 650816ac92eSJuergen Gross "(%#x - %#x = %u). Halting ring processing.\n", 651816ac92eSJuergen Gross rp, rc, rp - rc); 652816ac92eSJuergen Gross usbif->ring_error = true; 653816ac92eSJuergen Gross return; 654816ac92eSJuergen Gross } 655816ac92eSJuergen Gross 656816ac92eSJuergen Gross while (rc != rp) { 657816ac92eSJuergen Gross if (RING_REQUEST_CONS_OVERFLOW(urb_ring, rc)) { 658816ac92eSJuergen Gross break; 659816ac92eSJuergen Gross } 660816ac92eSJuergen Gross usbback_req = usbback_get_req(usbif); 661816ac92eSJuergen Gross 662816ac92eSJuergen Gross RING_COPY_REQUEST(urb_ring, rc, &usbback_req->req); 663816ac92eSJuergen Gross usbback_req->usbif = usbif; 664816ac92eSJuergen Gross 665816ac92eSJuergen Gross usbback_dispatch(usbback_req); 666816ac92eSJuergen Gross 667816ac92eSJuergen Gross urb_ring->req_cons = ++rc; 668816ac92eSJuergen Gross } 669816ac92eSJuergen Gross 670816ac92eSJuergen Gross RING_FINAL_CHECK_FOR_REQUESTS(urb_ring, more_to_do); 671816ac92eSJuergen Gross if (more_to_do) { 672816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 673816ac92eSJuergen Gross } 674816ac92eSJuergen Gross } 675816ac92eSJuergen Gross 676816ac92eSJuergen Gross static void usbback_hotplug_enq(struct usbback_info *usbif, unsigned port) 677816ac92eSJuergen Gross { 678816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 679816ac92eSJuergen Gross 680816ac92eSJuergen Gross usb_hp = g_new0(struct usbback_hotplug, 1); 681816ac92eSJuergen Gross usb_hp->port = port; 682816ac92eSJuergen Gross QSIMPLEQ_INSERT_TAIL(&usbif->hotplug_q, usb_hp, q); 683816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 684816ac92eSJuergen Gross } 685816ac92eSJuergen Gross 68680440ea0SJuergen Gross static void usbback_portid_drain(struct usbback_info *usbif, unsigned port) 68780440ea0SJuergen Gross { 68880440ea0SJuergen Gross struct usbback_req *req, *tmp; 68980440ea0SJuergen Gross bool sched = false; 69080440ea0SJuergen Gross 69180440ea0SJuergen Gross QTAILQ_FOREACH_SAFE(req, &usbif->ports[port - 1].submit_q, q, tmp) { 69280440ea0SJuergen Gross usbback_cancel_req(req); 69380440ea0SJuergen Gross sched = true; 69480440ea0SJuergen Gross } 69580440ea0SJuergen Gross 69680440ea0SJuergen Gross if (sched) { 69780440ea0SJuergen Gross qemu_bh_schedule(usbif->bh); 69880440ea0SJuergen Gross } 69980440ea0SJuergen Gross } 70080440ea0SJuergen Gross 70180440ea0SJuergen Gross static void usbback_portid_detach(struct usbback_info *usbif, unsigned port) 70280440ea0SJuergen Gross { 70380440ea0SJuergen Gross if (!usbif->ports[port - 1].attached) { 70480440ea0SJuergen Gross return; 70580440ea0SJuergen Gross } 70680440ea0SJuergen Gross 70780440ea0SJuergen Gross usbif->ports[port - 1].speed = USBIF_SPEED_NONE; 70880440ea0SJuergen Gross usbif->ports[port - 1].attached = false; 70980440ea0SJuergen Gross usbback_portid_drain(usbif, port); 71080440ea0SJuergen Gross usbback_hotplug_enq(usbif, port); 71180440ea0SJuergen Gross } 71280440ea0SJuergen Gross 713816ac92eSJuergen Gross static void usbback_portid_remove(struct usbback_info *usbif, unsigned port) 714816ac92eSJuergen Gross { 715816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 716816ac92eSJuergen Gross return; 717816ac92eSJuergen Gross } 718816ac92eSJuergen Gross 719816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 720816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 72180440ea0SJuergen Gross usbback_portid_detach(usbif, port); 722816ac92eSJuergen Gross 723816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d removed\n", port); 724816ac92eSJuergen Gross } 725816ac92eSJuergen Gross 726816ac92eSJuergen Gross static void usbback_portid_add(struct usbback_info *usbif, unsigned port, 727816ac92eSJuergen Gross char *busid) 728816ac92eSJuergen Gross { 729816ac92eSJuergen Gross unsigned speed; 730816ac92eSJuergen Gross char *portname; 731816ac92eSJuergen Gross Error *local_err = NULL; 732816ac92eSJuergen Gross QDict *qdict; 733816ac92eSJuergen Gross QemuOpts *opts; 734f1784a22SJuergen Gross char *tmp; 735816ac92eSJuergen Gross 736816ac92eSJuergen Gross if (usbif->ports[port - 1].dev) { 737816ac92eSJuergen Gross return; 738816ac92eSJuergen Gross } 739816ac92eSJuergen Gross 740816ac92eSJuergen Gross portname = strchr(busid, '-'); 741816ac92eSJuergen Gross if (!portname) { 74296c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n", 743816ac92eSJuergen Gross busid); 744816ac92eSJuergen Gross return; 745816ac92eSJuergen Gross } 746816ac92eSJuergen Gross portname++; 747816ac92eSJuergen Gross 748816ac92eSJuergen Gross qdict = qdict_new(); 749816ac92eSJuergen Gross qdict_put(qdict, "driver", qstring_from_str("usb-host")); 750f1784a22SJuergen Gross tmp = g_strdup_printf("%s.0", usbif->xendev.qdev.id); 751f1784a22SJuergen Gross qdict_put(qdict, "bus", qstring_from_str(tmp)); 752f1784a22SJuergen Gross g_free(tmp); 753f1784a22SJuergen Gross tmp = g_strdup_printf("%s-%u", usbif->xendev.qdev.id, port); 754f1784a22SJuergen Gross qdict_put(qdict, "id", qstring_from_str(tmp)); 755f1784a22SJuergen Gross g_free(tmp); 756f1784a22SJuergen Gross qdict_put(qdict, "port", qint_from_int(port)); 757816ac92eSJuergen Gross qdict_put(qdict, "hostbus", qint_from_int(atoi(busid))); 758816ac92eSJuergen Gross qdict_put(qdict, "hostport", qstring_from_str(portname)); 759816ac92eSJuergen Gross opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err); 760816ac92eSJuergen Gross if (local_err) { 761816ac92eSJuergen Gross goto err; 762816ac92eSJuergen Gross } 763816ac92eSJuergen Gross usbif->ports[port - 1].dev = USB_DEVICE(qdev_device_add(opts, &local_err)); 764816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 765816ac92eSJuergen Gross goto err; 766816ac92eSJuergen Gross } 767816ac92eSJuergen Gross QDECREF(qdict); 768816ac92eSJuergen Gross speed = usbif->ports[port - 1].dev->speed; 769816ac92eSJuergen Gross switch (speed) { 770816ac92eSJuergen Gross case USB_SPEED_LOW: 771816ac92eSJuergen Gross speed = USBIF_SPEED_LOW; 772816ac92eSJuergen Gross break; 773816ac92eSJuergen Gross case USB_SPEED_FULL: 774816ac92eSJuergen Gross speed = USBIF_SPEED_FULL; 775816ac92eSJuergen Gross break; 776816ac92eSJuergen Gross case USB_SPEED_HIGH: 777816ac92eSJuergen Gross speed = (usbif->usb_ver < USB_VER_USB20) ? 778816ac92eSJuergen Gross USBIF_SPEED_NONE : USBIF_SPEED_HIGH; 779816ac92eSJuergen Gross break; 780816ac92eSJuergen Gross default: 781816ac92eSJuergen Gross speed = USBIF_SPEED_NONE; 782816ac92eSJuergen Gross break; 783816ac92eSJuergen Gross } 784816ac92eSJuergen Gross if (speed == USBIF_SPEED_NONE) { 78596c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); 786816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 787816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 788816ac92eSJuergen Gross return; 789816ac92eSJuergen Gross } 790816ac92eSJuergen Gross usb_device_reset(usbif->ports[port - 1].dev); 791816ac92eSJuergen Gross usbif->ports[port - 1].speed = speed; 792816ac92eSJuergen Gross usbif->ports[port - 1].attached = true; 793816ac92eSJuergen Gross QTAILQ_INIT(&usbif->ports[port - 1].submit_q); 794816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port); 795816ac92eSJuergen Gross 796816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d attached\n", port); 797816ac92eSJuergen Gross return; 798816ac92eSJuergen Gross 799816ac92eSJuergen Gross err: 800816ac92eSJuergen Gross QDECREF(qdict); 80196c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); 802816ac92eSJuergen Gross } 803816ac92eSJuergen Gross 804816ac92eSJuergen Gross static void usbback_process_port(struct usbback_info *usbif, unsigned port) 805816ac92eSJuergen Gross { 806816ac92eSJuergen Gross char node[8]; 807816ac92eSJuergen Gross char *busid; 808816ac92eSJuergen Gross 809816ac92eSJuergen Gross snprintf(node, sizeof(node), "port/%d", port); 810816ac92eSJuergen Gross busid = xenstore_read_be_str(&usbif->xendev, node); 811816ac92eSJuergen Gross if (busid == NULL) { 81296c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); 813816ac92eSJuergen Gross return; 814816ac92eSJuergen Gross } 815816ac92eSJuergen Gross 816816ac92eSJuergen Gross /* Remove portid, if the port is not connected. */ 817816ac92eSJuergen Gross if (strlen(busid) == 0) { 818816ac92eSJuergen Gross usbback_portid_remove(usbif, port); 819816ac92eSJuergen Gross } else { 820816ac92eSJuergen Gross usbback_portid_add(usbif, port, busid); 821816ac92eSJuergen Gross } 822816ac92eSJuergen Gross 823816ac92eSJuergen Gross g_free(busid); 824816ac92eSJuergen Gross } 825816ac92eSJuergen Gross 826816ac92eSJuergen Gross static void usbback_disconnect(struct XenDevice *xendev) 827816ac92eSJuergen Gross { 828816ac92eSJuergen Gross struct usbback_info *usbif; 829816ac92eSJuergen Gross unsigned int i; 830816ac92eSJuergen Gross 831816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 832816ac92eSJuergen Gross 833816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 834816ac92eSJuergen Gross 83565807f4bSEmil Condrea xen_pv_unbind_evtchn(xendev); 836816ac92eSJuergen Gross 837816ac92eSJuergen Gross if (usbif->urb_sring) { 838816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbif->urb_sring, 1); 839816ac92eSJuergen Gross usbif->urb_sring = NULL; 840816ac92eSJuergen Gross } 841816ac92eSJuergen Gross if (usbif->conn_sring) { 842816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbif->conn_sring, 1); 843816ac92eSJuergen Gross usbif->conn_sring = NULL; 844816ac92eSJuergen Gross } 845816ac92eSJuergen Gross 846816ac92eSJuergen Gross for (i = 0; i < usbif->num_ports; i++) { 84780440ea0SJuergen Gross if (usbif->ports[i].dev) { 84880440ea0SJuergen Gross usbback_portid_drain(usbif, i + 1); 849816ac92eSJuergen Gross } 850816ac92eSJuergen Gross } 851816ac92eSJuergen Gross 852816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 853816ac92eSJuergen Gross } 854816ac92eSJuergen Gross 855816ac92eSJuergen Gross static int usbback_connect(struct XenDevice *xendev) 856816ac92eSJuergen Gross { 857816ac92eSJuergen Gross struct usbback_info *usbif; 858816ac92eSJuergen Gross struct usbif_urb_sring *urb_sring; 859816ac92eSJuergen Gross struct usbif_conn_sring *conn_sring; 860816ac92eSJuergen Gross int urb_ring_ref; 861816ac92eSJuergen Gross int conn_ring_ref; 862816ac92eSJuergen Gross unsigned int i; 863816ac92eSJuergen Gross 864816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 865816ac92eSJuergen Gross 866816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 867816ac92eSJuergen Gross 868816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { 86996c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n"); 870816ac92eSJuergen Gross return -1; 871816ac92eSJuergen Gross } 872816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { 87396c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n"); 874816ac92eSJuergen Gross return -1; 875816ac92eSJuergen Gross } 876816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { 87796c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading event-channel\n"); 878816ac92eSJuergen Gross return -1; 879816ac92eSJuergen Gross } 880816ac92eSJuergen Gross 881816ac92eSJuergen Gross usbif->urb_sring = xengnttab_map_grant_ref(xendev->gnttabdev, xendev->dom, 882816ac92eSJuergen Gross urb_ring_ref, 883816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 884816ac92eSJuergen Gross usbif->conn_sring = xengnttab_map_grant_ref(xendev->gnttabdev, xendev->dom, 885816ac92eSJuergen Gross conn_ring_ref, 886816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 887816ac92eSJuergen Gross if (!usbif->urb_sring || !usbif->conn_sring) { 88896c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error mapping rings\n"); 889816ac92eSJuergen Gross usbback_disconnect(xendev); 890816ac92eSJuergen Gross return -1; 891816ac92eSJuergen Gross } 892816ac92eSJuergen Gross 893816ac92eSJuergen Gross urb_sring = usbif->urb_sring; 894816ac92eSJuergen Gross conn_sring = usbif->conn_sring; 895816ac92eSJuergen Gross BACK_RING_INIT(&usbif->urb_ring, urb_sring, XC_PAGE_SIZE); 896816ac92eSJuergen Gross BACK_RING_INIT(&usbif->conn_ring, conn_sring, XC_PAGE_SIZE); 897816ac92eSJuergen Gross 898816ac92eSJuergen Gross xen_be_bind_evtchn(xendev); 899816ac92eSJuergen Gross 90096c77dbaSEmil Condrea xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " 901816ac92eSJuergen Gross "remote port %d, local port %d\n", urb_ring_ref, 902816ac92eSJuergen Gross conn_ring_ref, xendev->remote_port, xendev->local_port); 903816ac92eSJuergen Gross 904816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 905816ac92eSJuergen Gross if (usbif->ports[i - 1].dev) { 906816ac92eSJuergen Gross usbback_hotplug_enq(usbif, i); 907816ac92eSJuergen Gross } 908816ac92eSJuergen Gross } 909816ac92eSJuergen Gross 910816ac92eSJuergen Gross return 0; 911816ac92eSJuergen Gross } 912816ac92eSJuergen Gross 913816ac92eSJuergen Gross static void usbback_backend_changed(struct XenDevice *xendev, const char *node) 914816ac92eSJuergen Gross { 915816ac92eSJuergen Gross struct usbback_info *usbif; 916816ac92eSJuergen Gross unsigned int i; 917816ac92eSJuergen Gross 918816ac92eSJuergen Gross TR_BUS(xendev, "path %s\n", node); 919816ac92eSJuergen Gross 920816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 921816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 922816ac92eSJuergen Gross usbback_process_port(usbif, i); 923816ac92eSJuergen Gross } 924816ac92eSJuergen Gross } 925816ac92eSJuergen Gross 926816ac92eSJuergen Gross static int usbback_init(struct XenDevice *xendev) 927816ac92eSJuergen Gross { 928816ac92eSJuergen Gross struct usbback_info *usbif; 929816ac92eSJuergen Gross 930816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 931816ac92eSJuergen Gross 932816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 933816ac92eSJuergen Gross 934816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || 935816ac92eSJuergen Gross usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { 93696c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n"); 937816ac92eSJuergen Gross return -1; 938816ac92eSJuergen Gross } 939816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || 940816ac92eSJuergen Gross (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { 94196c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); 942816ac92eSJuergen Gross return -1; 943816ac92eSJuergen Gross } 944816ac92eSJuergen Gross 945816ac92eSJuergen Gross usbback_backend_changed(xendev, "port"); 946816ac92eSJuergen Gross 947816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 948816ac92eSJuergen Gross 949816ac92eSJuergen Gross return 0; 950816ac92eSJuergen Gross } 951816ac92eSJuergen Gross 952816ac92eSJuergen Gross static void xen_bus_attach(USBPort *port) 953816ac92eSJuergen Gross { 954816ac92eSJuergen Gross struct usbback_info *usbif; 955816ac92eSJuergen Gross 956816ac92eSJuergen Gross usbif = port->opaque; 957816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 958816ac92eSJuergen Gross usbif->ports[port->index].attached = true; 959816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port->index + 1); 960816ac92eSJuergen Gross } 961816ac92eSJuergen Gross 962816ac92eSJuergen Gross static void xen_bus_detach(USBPort *port) 963816ac92eSJuergen Gross { 964816ac92eSJuergen Gross struct usbback_info *usbif; 965816ac92eSJuergen Gross 966816ac92eSJuergen Gross usbif = port->opaque; 967816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 96880440ea0SJuergen Gross usbback_portid_detach(usbif, port->index + 1); 969816ac92eSJuergen Gross } 970816ac92eSJuergen Gross 971816ac92eSJuergen Gross static void xen_bus_child_detach(USBPort *port, USBDevice *child) 972816ac92eSJuergen Gross { 973816ac92eSJuergen Gross struct usbback_info *usbif; 974816ac92eSJuergen Gross 975816ac92eSJuergen Gross usbif = port->opaque; 976816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 977816ac92eSJuergen Gross } 978816ac92eSJuergen Gross 979816ac92eSJuergen Gross static void xen_bus_complete(USBPort *port, USBPacket *packet) 980816ac92eSJuergen Gross { 98180440ea0SJuergen Gross struct usbback_req *usbback_req; 982816ac92eSJuergen Gross struct usbback_info *usbif; 983816ac92eSJuergen Gross 98480440ea0SJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 98580440ea0SJuergen Gross if (usbback_req->cancelled) { 98680440ea0SJuergen Gross g_free(usbback_req); 98780440ea0SJuergen Gross return; 98880440ea0SJuergen Gross } 98980440ea0SJuergen Gross 99080440ea0SJuergen Gross usbif = usbback_req->usbif; 991816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "\n"); 992816ac92eSJuergen Gross usbback_packet_complete(packet); 993816ac92eSJuergen Gross } 994816ac92eSJuergen Gross 995816ac92eSJuergen Gross static USBPortOps xen_usb_port_ops = { 996816ac92eSJuergen Gross .attach = xen_bus_attach, 997816ac92eSJuergen Gross .detach = xen_bus_detach, 998816ac92eSJuergen Gross .child_detach = xen_bus_child_detach, 999816ac92eSJuergen Gross .complete = xen_bus_complete, 1000816ac92eSJuergen Gross }; 1001816ac92eSJuergen Gross 1002816ac92eSJuergen Gross static USBBusOps xen_usb_bus_ops = { 1003816ac92eSJuergen Gross }; 1004816ac92eSJuergen Gross 1005816ac92eSJuergen Gross static void usbback_alloc(struct XenDevice *xendev) 1006816ac92eSJuergen Gross { 1007816ac92eSJuergen Gross struct usbback_info *usbif; 1008816ac92eSJuergen Gross USBPort *p; 1009816ac92eSJuergen Gross unsigned int i, max_grants; 1010816ac92eSJuergen Gross 1011816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1012816ac92eSJuergen Gross 1013f1784a22SJuergen Gross usb_bus_new(&usbif->bus, sizeof(usbif->bus), &xen_usb_bus_ops, 1014f1784a22SJuergen Gross DEVICE(&xendev->qdev)); 1015816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1016816ac92eSJuergen Gross p = &(usbif->ports[i].port); 1017816ac92eSJuergen Gross usb_register_port(&usbif->bus, p, usbif, i, &xen_usb_port_ops, 1018816ac92eSJuergen Gross USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL | 1019816ac92eSJuergen Gross USB_SPEED_MASK_HIGH); 1020816ac92eSJuergen Gross } 1021816ac92eSJuergen Gross 1022816ac92eSJuergen Gross QTAILQ_INIT(&usbif->req_free_q); 1023816ac92eSJuergen Gross QSIMPLEQ_INIT(&usbif->hotplug_q); 1024816ac92eSJuergen Gross usbif->bh = qemu_bh_new(usbback_bh, usbif); 1025816ac92eSJuergen Gross 1026816ac92eSJuergen Gross /* max_grants: for each request and for the rings (request and connect). */ 1027816ac92eSJuergen Gross max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; 1028816ac92eSJuergen Gross if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) { 102996c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", 1030816ac92eSJuergen Gross strerror(errno)); 1031816ac92eSJuergen Gross } 1032816ac92eSJuergen Gross } 1033816ac92eSJuergen Gross 1034816ac92eSJuergen Gross static int usbback_free(struct XenDevice *xendev) 1035816ac92eSJuergen Gross { 1036816ac92eSJuergen Gross struct usbback_info *usbif; 1037816ac92eSJuergen Gross struct usbback_req *usbback_req; 1038816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 1039816ac92eSJuergen Gross unsigned int i; 1040816ac92eSJuergen Gross 1041816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 1042816ac92eSJuergen Gross 1043816ac92eSJuergen Gross usbback_disconnect(xendev); 1044816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1045816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 1046816ac92eSJuergen Gross usbback_portid_remove(usbif, i); 1047816ac92eSJuergen Gross } 1048816ac92eSJuergen Gross 1049816ac92eSJuergen Gross while (!QTAILQ_EMPTY(&usbif->req_free_q)) { 1050816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 1051816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 1052816ac92eSJuergen Gross g_free(usbback_req); 1053816ac92eSJuergen Gross } 1054816ac92eSJuergen Gross while (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 1055816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 1056816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 1057816ac92eSJuergen Gross g_free(usb_hp); 1058816ac92eSJuergen Gross } 1059816ac92eSJuergen Gross 1060816ac92eSJuergen Gross qemu_bh_delete(usbif->bh); 1061816ac92eSJuergen Gross 1062816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1063816ac92eSJuergen Gross usb_unregister_port(&usbif->bus, &(usbif->ports[i].port)); 1064816ac92eSJuergen Gross } 1065816ac92eSJuergen Gross 1066816ac92eSJuergen Gross usb_bus_release(&usbif->bus); 1067816ac92eSJuergen Gross 1068816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 1069816ac92eSJuergen Gross 1070816ac92eSJuergen Gross return 0; 1071816ac92eSJuergen Gross } 1072816ac92eSJuergen Gross 1073816ac92eSJuergen Gross static void usbback_event(struct XenDevice *xendev) 1074816ac92eSJuergen Gross { 1075816ac92eSJuergen Gross struct usbback_info *usbif; 1076816ac92eSJuergen Gross 1077816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1078816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 1079816ac92eSJuergen Gross } 1080816ac92eSJuergen Gross 1081816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1082816ac92eSJuergen Gross .size = sizeof(struct usbback_info), 1083816ac92eSJuergen Gross .flags = DEVOPS_FLAG_NEED_GNTDEV, 1084816ac92eSJuergen Gross .init = usbback_init, 1085816ac92eSJuergen Gross .alloc = usbback_alloc, 1086816ac92eSJuergen Gross .free = usbback_free, 1087816ac92eSJuergen Gross .backend_changed = usbback_backend_changed, 1088816ac92eSJuergen Gross .initialise = usbback_connect, 1089816ac92eSJuergen Gross .disconnect = usbback_disconnect, 1090816ac92eSJuergen Gross .event = usbback_event, 1091816ac92eSJuergen Gross }; 1092816ac92eSJuergen Gross 1093816ac92eSJuergen Gross #else /* USBIF_SHORT_NOT_OK */ 1094816ac92eSJuergen Gross 1095816ac92eSJuergen Gross static int usbback_not_supported(void) 1096816ac92eSJuergen Gross { 1097816ac92eSJuergen Gross return -EINVAL; 1098816ac92eSJuergen Gross } 1099816ac92eSJuergen Gross 1100816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1101816ac92eSJuergen Gross .backend_register = usbback_not_supported, 1102816ac92eSJuergen Gross }; 1103816ac92eSJuergen Gross 1104816ac92eSJuergen Gross #endif 1105