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/config-file.h" 27db725815SMarkus Armbruster #include "qemu/main-loop.h" 28922a01a0SMarkus Armbruster #include "qemu/option.h" 29816ac92eSJuergen Gross #include "hw/usb.h" 302d0ed5e6SPaul Durrant #include "hw/xen/xen-legacy-backend.h" 31816ac92eSJuergen Gross #include "monitor/qdev.h" 3256f9dde4SMarkus Armbruster #include "qapi/error.h" 33452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h" 34816ac92eSJuergen Gross #include "qapi/qmp/qstring.h" 35816ac92eSJuergen Gross 36a3434a2dSAnthony PERARD #include "hw/xen/interface/io/usbif.h" 37816ac92eSJuergen Gross 38816ac92eSJuergen Gross /* 39816ac92eSJuergen Gross * Check for required support of usbif.h: USBIF_SHORT_NOT_OK was the last 40816ac92eSJuergen Gross * macro added we rely on. 41816ac92eSJuergen Gross */ 42816ac92eSJuergen Gross #ifdef USBIF_SHORT_NOT_OK 43816ac92eSJuergen Gross 44816ac92eSJuergen Gross #define TR(xendev, lvl, fmt, args...) \ 45816ac92eSJuergen Gross { \ 46816ac92eSJuergen Gross struct timeval tv; \ 47816ac92eSJuergen Gross \ 48816ac92eSJuergen Gross gettimeofday(&tv, NULL); \ 4996c77dbaSEmil Condrea xen_pv_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \ 50816ac92eSJuergen Gross tv.tv_sec, tv.tv_usec, __func__, ##args); \ 51816ac92eSJuergen Gross } 52816ac92eSJuergen Gross #define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args) 53816ac92eSJuergen Gross #define TR_REQ(xendev, fmt, args...) TR(xendev, 3, fmt, ##args) 54816ac92eSJuergen Gross 55816ac92eSJuergen Gross #define USBBACK_MAXPORTS USBIF_PIPE_PORT_MASK 56816ac92eSJuergen Gross #define USB_DEV_ADDR_SIZE (USBIF_PIPE_DEV_MASK + 1) 57816ac92eSJuergen Gross 58816ac92eSJuergen Gross /* USB wire protocol: structure describing control request parameter. */ 59816ac92eSJuergen Gross struct usbif_ctrlrequest { 60816ac92eSJuergen Gross uint8_t bRequestType; 61816ac92eSJuergen Gross uint8_t bRequest; 62816ac92eSJuergen Gross uint16_t wValue; 63816ac92eSJuergen Gross uint16_t wIndex; 64816ac92eSJuergen Gross uint16_t wLength; 65816ac92eSJuergen Gross }; 66816ac92eSJuergen Gross 67816ac92eSJuergen Gross struct usbback_info; 68816ac92eSJuergen Gross struct usbback_req; 69816ac92eSJuergen Gross 70816ac92eSJuergen Gross struct usbback_stub { 71816ac92eSJuergen Gross USBDevice *dev; 72816ac92eSJuergen Gross USBPort port; 73816ac92eSJuergen Gross unsigned int speed; 74816ac92eSJuergen Gross bool attached; 75b58deb34SPaolo Bonzini QTAILQ_HEAD(, usbback_req) submit_q; 76816ac92eSJuergen Gross }; 77816ac92eSJuergen Gross 78816ac92eSJuergen Gross struct usbback_req { 79816ac92eSJuergen Gross struct usbback_info *usbif; 80816ac92eSJuergen Gross struct usbback_stub *stub; 81816ac92eSJuergen Gross struct usbif_urb_request req; 82816ac92eSJuergen Gross USBPacket packet; 83816ac92eSJuergen Gross 84816ac92eSJuergen Gross unsigned int nr_buffer_segs; /* # of transfer_buffer segments */ 85816ac92eSJuergen Gross unsigned int nr_extra_segs; /* # of iso_frame_desc segments */ 86816ac92eSJuergen Gross 87816ac92eSJuergen Gross QTAILQ_ENTRY(usbback_req) q; 88816ac92eSJuergen Gross 89816ac92eSJuergen Gross void *buffer; 90816ac92eSJuergen Gross void *isoc_buffer; 91816ac92eSJuergen Gross struct libusb_transfer *xfer; 9280440ea0SJuergen Gross 9380440ea0SJuergen Gross bool cancelled; 94816ac92eSJuergen Gross }; 95816ac92eSJuergen Gross 96816ac92eSJuergen Gross struct usbback_hotplug { 97816ac92eSJuergen Gross QSIMPLEQ_ENTRY(usbback_hotplug) q; 98816ac92eSJuergen Gross unsigned port; 99816ac92eSJuergen Gross }; 100816ac92eSJuergen Gross 101816ac92eSJuergen Gross struct usbback_info { 1022d0ed5e6SPaul Durrant struct XenLegacyDevice xendev; /* must be first */ 103816ac92eSJuergen Gross USBBus bus; 104*f80fad16SDavid Woodhouse uint32_t urb_ring_ref; 105*f80fad16SDavid Woodhouse uint32_t conn_ring_ref; 106816ac92eSJuergen Gross void *urb_sring; 107816ac92eSJuergen Gross void *conn_sring; 108816ac92eSJuergen Gross struct usbif_urb_back_ring urb_ring; 109816ac92eSJuergen Gross struct usbif_conn_back_ring conn_ring; 110816ac92eSJuergen Gross int num_ports; 111816ac92eSJuergen Gross int usb_ver; 112816ac92eSJuergen Gross bool ring_error; 113b58deb34SPaolo Bonzini QTAILQ_HEAD(, usbback_req) req_free_q; 114b58deb34SPaolo Bonzini QSIMPLEQ_HEAD(, usbback_hotplug) hotplug_q; 115816ac92eSJuergen Gross struct usbback_stub ports[USBBACK_MAXPORTS]; 116816ac92eSJuergen Gross struct usbback_stub *addr_table[USB_DEV_ADDR_SIZE]; 117816ac92eSJuergen Gross QEMUBH *bh; 118816ac92eSJuergen Gross }; 119816ac92eSJuergen Gross 120816ac92eSJuergen Gross static struct usbback_req *usbback_get_req(struct usbback_info *usbif) 121816ac92eSJuergen Gross { 122816ac92eSJuergen Gross struct usbback_req *usbback_req; 123816ac92eSJuergen Gross 124816ac92eSJuergen Gross if (QTAILQ_EMPTY(&usbif->req_free_q)) { 125816ac92eSJuergen Gross usbback_req = g_new0(struct usbback_req, 1); 126816ac92eSJuergen Gross } else { 127816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 128816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 129816ac92eSJuergen Gross } 130816ac92eSJuergen Gross return usbback_req; 131816ac92eSJuergen Gross } 132816ac92eSJuergen Gross 133816ac92eSJuergen Gross static void usbback_put_req(struct usbback_req *usbback_req) 134816ac92eSJuergen Gross { 135816ac92eSJuergen Gross struct usbback_info *usbif; 136816ac92eSJuergen Gross 137816ac92eSJuergen Gross usbif = usbback_req->usbif; 138816ac92eSJuergen Gross memset(usbback_req, 0, sizeof(*usbback_req)); 139816ac92eSJuergen Gross QTAILQ_INSERT_HEAD(&usbif->req_free_q, usbback_req, q); 140816ac92eSJuergen Gross } 141816ac92eSJuergen Gross 142816ac92eSJuergen Gross static int usbback_gnttab_map(struct usbback_req *usbback_req) 143816ac92eSJuergen Gross { 144816ac92eSJuergen Gross unsigned int nr_segs, i, prot; 145816ac92eSJuergen Gross uint32_t ref[USBIF_MAX_SEGMENTS_PER_REQUEST]; 146816ac92eSJuergen Gross struct usbback_info *usbif = usbback_req->usbif; 1472d0ed5e6SPaul Durrant struct XenLegacyDevice *xendev = &usbif->xendev; 148816ac92eSJuergen Gross struct usbif_request_segment *seg; 149816ac92eSJuergen Gross void *addr; 150816ac92eSJuergen Gross 151816ac92eSJuergen Gross nr_segs = usbback_req->nr_buffer_segs + usbback_req->nr_extra_segs; 152816ac92eSJuergen Gross if (!nr_segs) { 153816ac92eSJuergen Gross return 0; 154816ac92eSJuergen Gross } 155816ac92eSJuergen Gross 156816ac92eSJuergen Gross if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) { 15796c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "bad number of segments in request (%d)\n", 158816ac92eSJuergen Gross nr_segs); 159816ac92eSJuergen Gross return -EINVAL; 160816ac92eSJuergen Gross } 161816ac92eSJuergen Gross 162816ac92eSJuergen Gross for (i = 0; i < nr_segs; i++) { 163816ac92eSJuergen Gross if ((unsigned)usbback_req->req.seg[i].offset + 164c6d25aa6SStefano Stabellini (unsigned)usbback_req->req.seg[i].length > XC_PAGE_SIZE) { 16596c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "segment crosses page boundary\n"); 166816ac92eSJuergen Gross return -EINVAL; 167816ac92eSJuergen Gross } 168816ac92eSJuergen Gross } 169816ac92eSJuergen Gross 170816ac92eSJuergen Gross if (usbback_req->nr_buffer_segs) { 171816ac92eSJuergen Gross prot = PROT_READ; 172816ac92eSJuergen Gross if (usbif_pipein(usbback_req->req.pipe)) { 173816ac92eSJuergen Gross prot |= PROT_WRITE; 174816ac92eSJuergen Gross } 175816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 176816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i].gref; 177816ac92eSJuergen Gross } 17858560f2aSPaul Durrant usbback_req->buffer = 17958560f2aSPaul Durrant xen_be_map_grant_refs(xendev, ref, usbback_req->nr_buffer_segs, 18058560f2aSPaul Durrant prot); 181816ac92eSJuergen Gross 182816ac92eSJuergen Gross if (!usbback_req->buffer) { 183816ac92eSJuergen Gross return -ENOMEM; 184816ac92eSJuergen Gross } 185816ac92eSJuergen Gross 186816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 187816ac92eSJuergen Gross seg = usbback_req->req.seg + i; 188c6d25aa6SStefano Stabellini addr = usbback_req->buffer + i * XC_PAGE_SIZE + seg->offset; 189816ac92eSJuergen Gross qemu_iovec_add(&usbback_req->packet.iov, addr, seg->length); 190816ac92eSJuergen Gross } 191816ac92eSJuergen Gross } 192816ac92eSJuergen Gross 193816ac92eSJuergen Gross if (!usbif_pipeisoc(usbback_req->req.pipe)) { 194816ac92eSJuergen Gross return 0; 195816ac92eSJuergen Gross } 196816ac92eSJuergen Gross 197816ac92eSJuergen Gross /* 198816ac92eSJuergen Gross * Right now isoc requests are not supported. 199816ac92eSJuergen Gross * Prepare supporting those by doing the work needed on the guest 200816ac92eSJuergen Gross * interface side. 201816ac92eSJuergen Gross */ 202816ac92eSJuergen Gross 203816ac92eSJuergen Gross if (!usbback_req->nr_extra_segs) { 20496c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "iso request without descriptor segments\n"); 205816ac92eSJuergen Gross return -EINVAL; 206816ac92eSJuergen Gross } 207816ac92eSJuergen Gross 208816ac92eSJuergen Gross prot = PROT_READ | PROT_WRITE; 209816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_extra_segs; i++) { 210816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i + usbback_req->req.nr_buffer_segs].gref; 211816ac92eSJuergen Gross } 21258560f2aSPaul Durrant usbback_req->isoc_buffer = 21358560f2aSPaul Durrant xen_be_map_grant_refs(xendev, ref, usbback_req->nr_extra_segs, 21458560f2aSPaul Durrant prot); 215816ac92eSJuergen Gross 216816ac92eSJuergen Gross if (!usbback_req->isoc_buffer) { 217816ac92eSJuergen Gross return -ENOMEM; 218816ac92eSJuergen Gross } 219816ac92eSJuergen Gross 220816ac92eSJuergen Gross return 0; 221816ac92eSJuergen Gross } 222816ac92eSJuergen Gross 223816ac92eSJuergen Gross static int usbback_init_packet(struct usbback_req *usbback_req) 224816ac92eSJuergen Gross { 2252d0ed5e6SPaul Durrant struct XenLegacyDevice *xendev = &usbback_req->usbif->xendev; 226816ac92eSJuergen Gross USBPacket *packet = &usbback_req->packet; 227816ac92eSJuergen Gross USBDevice *dev = usbback_req->stub->dev; 228816ac92eSJuergen Gross USBEndpoint *ep; 229816ac92eSJuergen Gross unsigned int pid, ep_nr; 230816ac92eSJuergen Gross bool sok; 231816ac92eSJuergen Gross int ret = 0; 232816ac92eSJuergen Gross 233816ac92eSJuergen Gross qemu_iovec_init(&packet->iov, USBIF_MAX_SEGMENTS_PER_REQUEST); 234816ac92eSJuergen Gross pid = usbif_pipein(usbback_req->req.pipe) ? USB_TOKEN_IN : USB_TOKEN_OUT; 235816ac92eSJuergen Gross ep_nr = usbif_pipeendpoint(usbback_req->req.pipe); 236816ac92eSJuergen Gross sok = !!(usbback_req->req.transfer_flags & USBIF_SHORT_NOT_OK); 237816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 238816ac92eSJuergen Gross ep_nr = 0; 239816ac92eSJuergen Gross sok = false; 240816ac92eSJuergen Gross } 241816ac92eSJuergen Gross ep = usb_ep_get(dev, pid, ep_nr); 242816ac92eSJuergen Gross usb_packet_setup(packet, pid, ep, 0, 1, sok, true); 243816ac92eSJuergen Gross 244816ac92eSJuergen Gross switch (usbif_pipetype(usbback_req->req.pipe)) { 245816ac92eSJuergen Gross case USBIF_PIPE_TYPE_ISOC: 246816ac92eSJuergen Gross TR_REQ(xendev, "iso transfer %s: buflen: %x, %d frames\n", 247816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 248816ac92eSJuergen Gross usbback_req->req.buffer_length, 249816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs); 250816ac92eSJuergen Gross ret = -EINVAL; /* isoc not implemented yet */ 251816ac92eSJuergen Gross break; 252816ac92eSJuergen Gross 253816ac92eSJuergen Gross case USBIF_PIPE_TYPE_INT: 254816ac92eSJuergen Gross TR_REQ(xendev, "int transfer %s: buflen: %x\n", 255816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 256816ac92eSJuergen Gross usbback_req->req.buffer_length); 257816ac92eSJuergen Gross break; 258816ac92eSJuergen Gross 259816ac92eSJuergen Gross case USBIF_PIPE_TYPE_CTRL: 260816ac92eSJuergen Gross packet->parameter = *(uint64_t *)usbback_req->req.u.ctrl; 261042ec47eSAnthony PERARD TR_REQ(xendev, "ctrl parameter: %"PRIx64", buflen: %x\n", 262042ec47eSAnthony PERARD packet->parameter, 263816ac92eSJuergen Gross usbback_req->req.buffer_length); 264816ac92eSJuergen Gross break; 265816ac92eSJuergen Gross 266816ac92eSJuergen Gross case USBIF_PIPE_TYPE_BULK: 267816ac92eSJuergen Gross TR_REQ(xendev, "bulk transfer %s: buflen: %x\n", 268816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 269816ac92eSJuergen Gross usbback_req->req.buffer_length); 270816ac92eSJuergen Gross break; 271816ac92eSJuergen Gross default: 272816ac92eSJuergen Gross ret = -EINVAL; 273816ac92eSJuergen Gross break; 274816ac92eSJuergen Gross } 275816ac92eSJuergen Gross 276816ac92eSJuergen Gross return ret; 277816ac92eSJuergen Gross } 278816ac92eSJuergen Gross 279816ac92eSJuergen Gross static void usbback_do_response(struct usbback_req *usbback_req, int32_t status, 280816ac92eSJuergen Gross int32_t actual_length, int32_t error_count) 281816ac92eSJuergen Gross { 282*f80fad16SDavid Woodhouse uint32_t ref[USBIF_MAX_SEGMENTS_PER_REQUEST]; 283816ac92eSJuergen Gross struct usbback_info *usbif; 284816ac92eSJuergen Gross struct usbif_urb_response *res; 2852d0ed5e6SPaul Durrant struct XenLegacyDevice *xendev; 286*f80fad16SDavid Woodhouse unsigned int notify, i; 287816ac92eSJuergen Gross 288816ac92eSJuergen Gross usbif = usbback_req->usbif; 289816ac92eSJuergen Gross xendev = &usbif->xendev; 290816ac92eSJuergen Gross 291816ac92eSJuergen Gross TR_REQ(xendev, "id %d, status %d, length %d, errcnt %d\n", 292816ac92eSJuergen Gross usbback_req->req.id, status, actual_length, error_count); 293816ac92eSJuergen Gross 294816ac92eSJuergen Gross if (usbback_req->packet.iov.iov) { 295816ac92eSJuergen Gross qemu_iovec_destroy(&usbback_req->packet.iov); 296816ac92eSJuergen Gross } 297816ac92eSJuergen Gross 298816ac92eSJuergen Gross if (usbback_req->buffer) { 299*f80fad16SDavid Woodhouse for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 300*f80fad16SDavid Woodhouse ref[i] = usbback_req->req.seg[i].gref; 301*f80fad16SDavid Woodhouse } 302*f80fad16SDavid Woodhouse xen_be_unmap_grant_refs(xendev, usbback_req->buffer, ref, 303816ac92eSJuergen Gross usbback_req->nr_buffer_segs); 304816ac92eSJuergen Gross usbback_req->buffer = NULL; 305816ac92eSJuergen Gross } 306816ac92eSJuergen Gross 307816ac92eSJuergen Gross if (usbback_req->isoc_buffer) { 308*f80fad16SDavid Woodhouse for (i = 0; i < usbback_req->nr_extra_segs; i++) { 309*f80fad16SDavid Woodhouse ref[i] = usbback_req->req.seg[i + usbback_req->req.nr_buffer_segs].gref; 310*f80fad16SDavid Woodhouse } 311*f80fad16SDavid Woodhouse xen_be_unmap_grant_refs(xendev, usbback_req->isoc_buffer, ref, 312816ac92eSJuergen Gross usbback_req->nr_extra_segs); 313816ac92eSJuergen Gross usbback_req->isoc_buffer = NULL; 314816ac92eSJuergen Gross } 315816ac92eSJuergen Gross 31680440ea0SJuergen Gross if (usbif->urb_sring) { 317816ac92eSJuergen Gross res = RING_GET_RESPONSE(&usbif->urb_ring, usbif->urb_ring.rsp_prod_pvt); 318816ac92eSJuergen Gross res->id = usbback_req->req.id; 319816ac92eSJuergen Gross res->status = status; 320816ac92eSJuergen Gross res->actual_length = actual_length; 321816ac92eSJuergen Gross res->error_count = error_count; 322816ac92eSJuergen Gross res->start_frame = 0; 323816ac92eSJuergen Gross usbif->urb_ring.rsp_prod_pvt++; 324816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&usbif->urb_ring, notify); 325816ac92eSJuergen Gross 326816ac92eSJuergen Gross if (notify) { 327ba18fa2aSEmil Condrea xen_pv_send_notify(xendev); 328816ac92eSJuergen Gross } 32980440ea0SJuergen Gross } 330816ac92eSJuergen Gross 33180440ea0SJuergen Gross if (!usbback_req->cancelled) 332816ac92eSJuergen Gross usbback_put_req(usbback_req); 333816ac92eSJuergen Gross } 334816ac92eSJuergen Gross 335816ac92eSJuergen Gross static void usbback_do_response_ret(struct usbback_req *usbback_req, 336816ac92eSJuergen Gross int32_t status) 337816ac92eSJuergen Gross { 338816ac92eSJuergen Gross usbback_do_response(usbback_req, status, 0, 0); 339816ac92eSJuergen Gross } 340816ac92eSJuergen Gross 341816ac92eSJuergen Gross static int32_t usbback_xlat_status(int status) 342816ac92eSJuergen Gross { 343816ac92eSJuergen Gross switch (status) { 344816ac92eSJuergen Gross case USB_RET_SUCCESS: 345816ac92eSJuergen Gross return 0; 346816ac92eSJuergen Gross case USB_RET_NODEV: 347816ac92eSJuergen Gross return -ENODEV; 348816ac92eSJuergen Gross case USB_RET_STALL: 349816ac92eSJuergen Gross return -EPIPE; 350816ac92eSJuergen Gross case USB_RET_BABBLE: 351816ac92eSJuergen Gross return -EOVERFLOW; 352816ac92eSJuergen Gross case USB_RET_IOERROR: 353816ac92eSJuergen Gross return -EPROTO; 354816ac92eSJuergen Gross } 355816ac92eSJuergen Gross 356816ac92eSJuergen Gross return -ESHUTDOWN; 357816ac92eSJuergen Gross } 358816ac92eSJuergen Gross 3591aef27c9SPeter Maydell static void usbback_packet_complete(struct usbback_req *usbback_req) 360816ac92eSJuergen Gross { 3611aef27c9SPeter Maydell USBPacket *packet = &usbback_req->packet; 362816ac92eSJuergen Gross int32_t status; 363816ac92eSJuergen Gross 364816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 365816ac92eSJuergen Gross 366816ac92eSJuergen Gross status = usbback_xlat_status(packet->status); 367816ac92eSJuergen Gross usbback_do_response(usbback_req, status, packet->actual_length, 0); 368816ac92eSJuergen Gross } 369816ac92eSJuergen Gross 370816ac92eSJuergen Gross static void usbback_set_address(struct usbback_info *usbif, 371816ac92eSJuergen Gross struct usbback_stub *stub, 372816ac92eSJuergen Gross unsigned int cur_addr, unsigned int new_addr) 373816ac92eSJuergen Gross { 374816ac92eSJuergen Gross if (cur_addr) { 375816ac92eSJuergen Gross usbif->addr_table[cur_addr] = NULL; 376816ac92eSJuergen Gross } 377816ac92eSJuergen Gross if (new_addr) { 378816ac92eSJuergen Gross usbif->addr_table[new_addr] = stub; 379816ac92eSJuergen Gross } 380816ac92eSJuergen Gross } 381816ac92eSJuergen Gross 38280440ea0SJuergen Gross static void usbback_cancel_req(struct usbback_req *usbback_req) 383816ac92eSJuergen Gross { 384816ac92eSJuergen Gross if (usb_packet_is_inflight(&usbback_req->packet)) { 385816ac92eSJuergen Gross usb_cancel_packet(&usbback_req->packet); 38680440ea0SJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 38780440ea0SJuergen Gross usbback_req->cancelled = true; 38880440ea0SJuergen Gross usbback_do_response_ret(usbback_req, -EPROTO); 389816ac92eSJuergen Gross } 390816ac92eSJuergen Gross } 391816ac92eSJuergen Gross 392816ac92eSJuergen Gross static void usbback_process_unlink_req(struct usbback_req *usbback_req) 393816ac92eSJuergen Gross { 394816ac92eSJuergen Gross struct usbback_info *usbif; 395816ac92eSJuergen Gross struct usbback_req *unlink_req; 396816ac92eSJuergen Gross unsigned int id, devnum; 397816ac92eSJuergen Gross int ret; 398816ac92eSJuergen Gross 399816ac92eSJuergen Gross usbif = usbback_req->usbif; 400816ac92eSJuergen Gross ret = 0; 401816ac92eSJuergen Gross id = usbback_req->req.u.unlink.unlink_id; 402816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "unlink id %d\n", id); 403816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 404816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 405816ac92eSJuergen Gross usbback_req->stub = usbif->ports + 40680440ea0SJuergen Gross usbif_pipeportnum(usbback_req->req.pipe) - 1; 407816ac92eSJuergen Gross if (unlikely(!usbback_req->stub)) { 408816ac92eSJuergen Gross ret = -ENODEV; 409816ac92eSJuergen Gross goto fail_response; 410816ac92eSJuergen Gross } 411816ac92eSJuergen Gross } else { 412816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 413816ac92eSJuergen Gross ret = -ENODEV; 414816ac92eSJuergen Gross goto fail_response; 415816ac92eSJuergen Gross } 416816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 417816ac92eSJuergen Gross } 418816ac92eSJuergen Gross 419816ac92eSJuergen Gross QTAILQ_FOREACH(unlink_req, &usbback_req->stub->submit_q, q) { 420816ac92eSJuergen Gross if (unlink_req->req.id == id) { 42180440ea0SJuergen Gross usbback_cancel_req(unlink_req); 422816ac92eSJuergen Gross break; 423816ac92eSJuergen Gross } 424816ac92eSJuergen Gross } 425816ac92eSJuergen Gross 426816ac92eSJuergen Gross fail_response: 427816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 428816ac92eSJuergen Gross } 429816ac92eSJuergen Gross 430816ac92eSJuergen Gross /* 431816ac92eSJuergen Gross * Checks whether a request can be handled at once or should be forwarded 432816ac92eSJuergen Gross * to the usb framework. 433816ac92eSJuergen Gross * Return value is: 434816ac92eSJuergen Gross * 0 in case of usb framework is needed 435816ac92eSJuergen Gross * 1 in case of local handling (no error) 436816ac92eSJuergen Gross * The request response has been queued already if return value not 0. 437816ac92eSJuergen Gross */ 438816ac92eSJuergen Gross static int usbback_check_and_submit(struct usbback_req *usbback_req) 439816ac92eSJuergen Gross { 440816ac92eSJuergen Gross struct usbback_info *usbif; 441816ac92eSJuergen Gross unsigned int devnum; 442816ac92eSJuergen Gross struct usbback_stub *stub; 443816ac92eSJuergen Gross struct usbif_ctrlrequest *ctrl; 444816ac92eSJuergen Gross int ret; 445816ac92eSJuergen Gross uint16_t wValue; 446816ac92eSJuergen Gross 447816ac92eSJuergen Gross usbif = usbback_req->usbif; 448816ac92eSJuergen Gross stub = NULL; 449816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 450816ac92eSJuergen Gross ctrl = (struct usbif_ctrlrequest *)usbback_req->req.u.ctrl; 451816ac92eSJuergen Gross wValue = le16_to_cpu(ctrl->wValue); 452816ac92eSJuergen Gross 453816ac92eSJuergen Gross /* 454816ac92eSJuergen Gross * When the device is first connected or resetted, USB device has no 455816ac92eSJuergen Gross * address. In this initial state, following requests are sent to device 456816ac92eSJuergen Gross * address (#0), 457816ac92eSJuergen Gross * 458816ac92eSJuergen Gross * 1. GET_DESCRIPTOR (with Descriptor Type is "DEVICE") is sent, 459816ac92eSJuergen Gross * and OS knows what device is connected to. 460816ac92eSJuergen Gross * 461816ac92eSJuergen Gross * 2. SET_ADDRESS is sent, and then device has its address. 462816ac92eSJuergen Gross * 463816ac92eSJuergen Gross * In the next step, SET_CONFIGURATION is sent to addressed device, and 464816ac92eSJuergen Gross * then the device is finally ready to use. 465816ac92eSJuergen Gross */ 466816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 467816ac92eSJuergen Gross stub = usbif->ports + usbif_pipeportnum(usbback_req->req.pipe) - 1; 468816ac92eSJuergen Gross if (!stub->dev || !stub->attached) { 469816ac92eSJuergen Gross ret = -ENODEV; 470816ac92eSJuergen Gross goto do_response; 471816ac92eSJuergen Gross } 472816ac92eSJuergen Gross 473816ac92eSJuergen Gross switch (ctrl->bRequest) { 474816ac92eSJuergen Gross case USB_REQ_GET_DESCRIPTOR: 475816ac92eSJuergen Gross /* 476816ac92eSJuergen Gross * GET_DESCRIPTOR request to device #0. 477816ac92eSJuergen Gross * through normal transfer. 478816ac92eSJuergen Gross */ 479816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 GET_DESCRIPTOR\n"); 480816ac92eSJuergen Gross usbback_req->stub = stub; 481816ac92eSJuergen Gross return 0; 482816ac92eSJuergen Gross case USB_REQ_SET_ADDRESS: 483816ac92eSJuergen Gross /* 484816ac92eSJuergen Gross * SET_ADDRESS request to device #0. 485816ac92eSJuergen Gross * add attached device to addr_table. 486816ac92eSJuergen Gross */ 487816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 SET_ADDRESS\n"); 488816ac92eSJuergen Gross usbback_set_address(usbif, stub, 0, wValue); 489816ac92eSJuergen Gross ret = 0; 490816ac92eSJuergen Gross break; 491816ac92eSJuergen Gross default: 492816ac92eSJuergen Gross ret = -EINVAL; 493816ac92eSJuergen Gross break; 494816ac92eSJuergen Gross } 495816ac92eSJuergen Gross goto do_response; 496816ac92eSJuergen Gross } 497816ac92eSJuergen Gross 498816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 499816ac92eSJuergen Gross ret = -ENODEV; 500816ac92eSJuergen Gross goto do_response; 501816ac92eSJuergen Gross } 502816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 503816ac92eSJuergen Gross 504816ac92eSJuergen Gross /* 505816ac92eSJuergen Gross * Check special request 506816ac92eSJuergen Gross */ 507816ac92eSJuergen Gross if (ctrl->bRequest != USB_REQ_SET_ADDRESS) { 508816ac92eSJuergen Gross return 0; 509816ac92eSJuergen Gross } 510816ac92eSJuergen Gross 511816ac92eSJuergen Gross /* 512816ac92eSJuergen Gross * SET_ADDRESS request to addressed device. 513816ac92eSJuergen Gross * change addr or remove from addr_table. 514816ac92eSJuergen Gross */ 515816ac92eSJuergen Gross usbback_set_address(usbif, usbback_req->stub, devnum, wValue); 516816ac92eSJuergen Gross ret = 0; 517816ac92eSJuergen Gross 518816ac92eSJuergen Gross do_response: 519816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 520816ac92eSJuergen Gross return 1; 521816ac92eSJuergen Gross } 522816ac92eSJuergen Gross 523816ac92eSJuergen Gross static void usbback_dispatch(struct usbback_req *usbback_req) 524816ac92eSJuergen Gross { 525816ac92eSJuergen Gross int ret; 526816ac92eSJuergen Gross unsigned int devnum; 527816ac92eSJuergen Gross struct usbback_info *usbif; 528816ac92eSJuergen Gross 529816ac92eSJuergen Gross usbif = usbback_req->usbif; 530816ac92eSJuergen Gross 531816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "start req_id %d pipe %08x\n", usbback_req->req.id, 532816ac92eSJuergen Gross usbback_req->req.pipe); 533816ac92eSJuergen Gross 534816ac92eSJuergen Gross /* unlink request */ 535816ac92eSJuergen Gross if (unlikely(usbif_pipeunlink(usbback_req->req.pipe))) { 536816ac92eSJuergen Gross usbback_process_unlink_req(usbback_req); 537816ac92eSJuergen Gross return; 538816ac92eSJuergen Gross } 539816ac92eSJuergen Gross 540816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 541816ac92eSJuergen Gross if (usbback_check_and_submit(usbback_req)) { 542816ac92eSJuergen Gross return; 543816ac92eSJuergen Gross } 544816ac92eSJuergen Gross } else { 545816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 546816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 547816ac92eSJuergen Gross 548816ac92eSJuergen Gross if (!usbback_req->stub || !usbback_req->stub->attached) { 549816ac92eSJuergen Gross ret = -ENODEV; 550816ac92eSJuergen Gross goto fail_response; 551816ac92eSJuergen Gross } 552816ac92eSJuergen Gross } 553816ac92eSJuergen Gross 554816ac92eSJuergen Gross QTAILQ_INSERT_TAIL(&usbback_req->stub->submit_q, usbback_req, q); 555816ac92eSJuergen Gross 556816ac92eSJuergen Gross usbback_req->nr_buffer_segs = usbback_req->req.nr_buffer_segs; 557816ac92eSJuergen Gross usbback_req->nr_extra_segs = usbif_pipeisoc(usbback_req->req.pipe) ? 558816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs : 0; 559816ac92eSJuergen Gross 560816ac92eSJuergen Gross ret = usbback_init_packet(usbback_req); 561816ac92eSJuergen Gross if (ret) { 56296c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid request\n"); 563816ac92eSJuergen Gross ret = -ESHUTDOWN; 564816ac92eSJuergen Gross goto fail_free_urb; 565816ac92eSJuergen Gross } 566816ac92eSJuergen Gross 567816ac92eSJuergen Gross ret = usbback_gnttab_map(usbback_req); 568816ac92eSJuergen Gross if (ret) { 56996c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); 570816ac92eSJuergen Gross ret = -ESHUTDOWN; 571816ac92eSJuergen Gross goto fail_free_urb; 572816ac92eSJuergen Gross } 573816ac92eSJuergen Gross 574816ac92eSJuergen Gross usb_handle_packet(usbback_req->stub->dev, &usbback_req->packet); 575816ac92eSJuergen Gross if (usbback_req->packet.status != USB_RET_ASYNC) { 5761aef27c9SPeter Maydell usbback_packet_complete(usbback_req); 577816ac92eSJuergen Gross } 578816ac92eSJuergen Gross return; 579816ac92eSJuergen Gross 580816ac92eSJuergen Gross fail_free_urb: 581816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 582816ac92eSJuergen Gross 583816ac92eSJuergen Gross fail_response: 584816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 585816ac92eSJuergen Gross } 586816ac92eSJuergen Gross 587816ac92eSJuergen Gross static void usbback_hotplug_notify(struct usbback_info *usbif) 588816ac92eSJuergen Gross { 589816ac92eSJuergen Gross struct usbif_conn_back_ring *ring = &usbif->conn_ring; 590816ac92eSJuergen Gross struct usbif_conn_request req; 591816ac92eSJuergen Gross struct usbif_conn_response *res; 592816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 593816ac92eSJuergen Gross unsigned int notify; 594816ac92eSJuergen Gross 595816ac92eSJuergen Gross if (!usbif->conn_sring) { 596816ac92eSJuergen Gross return; 597816ac92eSJuergen Gross } 598816ac92eSJuergen Gross 599816ac92eSJuergen Gross /* Check for full ring. */ 600816ac92eSJuergen Gross if ((RING_SIZE(ring) - ring->rsp_prod_pvt - ring->req_cons) == 0) { 601ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 602816ac92eSJuergen Gross return; 603816ac92eSJuergen Gross } 604816ac92eSJuergen Gross 605816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 606816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 607816ac92eSJuergen Gross 608816ac92eSJuergen Gross RING_COPY_REQUEST(ring, ring->req_cons, &req); 609816ac92eSJuergen Gross ring->req_cons++; 610816ac92eSJuergen Gross ring->sring->req_event = ring->req_cons + 1; 611816ac92eSJuergen Gross 612816ac92eSJuergen Gross res = RING_GET_RESPONSE(ring, ring->rsp_prod_pvt); 613816ac92eSJuergen Gross res->id = req.id; 614816ac92eSJuergen Gross res->portnum = usb_hp->port; 615816ac92eSJuergen Gross res->speed = usbif->ports[usb_hp->port - 1].speed; 616816ac92eSJuergen Gross ring->rsp_prod_pvt++; 617816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); 618816ac92eSJuergen Gross 619816ac92eSJuergen Gross if (notify) { 620ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 621816ac92eSJuergen Gross } 622816ac92eSJuergen Gross 623816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "hotplug port %d speed %d\n", usb_hp->port, 624816ac92eSJuergen Gross res->speed); 625816ac92eSJuergen Gross 626816ac92eSJuergen Gross g_free(usb_hp); 627816ac92eSJuergen Gross 628816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 629816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 630816ac92eSJuergen Gross } 631816ac92eSJuergen Gross } 632816ac92eSJuergen Gross 633816ac92eSJuergen Gross static void usbback_bh(void *opaque) 634816ac92eSJuergen Gross { 635816ac92eSJuergen Gross struct usbback_info *usbif; 636816ac92eSJuergen Gross struct usbif_urb_back_ring *urb_ring; 637816ac92eSJuergen Gross struct usbback_req *usbback_req; 638816ac92eSJuergen Gross RING_IDX rc, rp; 639816ac92eSJuergen Gross unsigned int more_to_do; 640816ac92eSJuergen Gross 641816ac92eSJuergen Gross usbif = opaque; 642816ac92eSJuergen Gross if (usbif->ring_error) { 643816ac92eSJuergen Gross return; 644816ac92eSJuergen Gross } 645816ac92eSJuergen Gross 646816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 647816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 648816ac92eSJuergen Gross } 649816ac92eSJuergen Gross 650816ac92eSJuergen Gross urb_ring = &usbif->urb_ring; 651816ac92eSJuergen Gross rc = urb_ring->req_cons; 652816ac92eSJuergen Gross rp = urb_ring->sring->req_prod; 653816ac92eSJuergen Gross xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ 654816ac92eSJuergen Gross 655816ac92eSJuergen Gross if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { 656816ac92eSJuergen Gross rc = urb_ring->rsp_prod_pvt; 65796c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests " 658816ac92eSJuergen Gross "(%#x - %#x = %u). Halting ring processing.\n", 659816ac92eSJuergen Gross rp, rc, rp - rc); 660816ac92eSJuergen Gross usbif->ring_error = true; 661816ac92eSJuergen Gross return; 662816ac92eSJuergen Gross } 663816ac92eSJuergen Gross 664816ac92eSJuergen Gross while (rc != rp) { 665816ac92eSJuergen Gross if (RING_REQUEST_CONS_OVERFLOW(urb_ring, rc)) { 666816ac92eSJuergen Gross break; 667816ac92eSJuergen Gross } 668816ac92eSJuergen Gross usbback_req = usbback_get_req(usbif); 669816ac92eSJuergen Gross 670816ac92eSJuergen Gross RING_COPY_REQUEST(urb_ring, rc, &usbback_req->req); 671816ac92eSJuergen Gross usbback_req->usbif = usbif; 672816ac92eSJuergen Gross 673816ac92eSJuergen Gross usbback_dispatch(usbback_req); 674816ac92eSJuergen Gross 675816ac92eSJuergen Gross urb_ring->req_cons = ++rc; 676816ac92eSJuergen Gross } 677816ac92eSJuergen Gross 678816ac92eSJuergen Gross RING_FINAL_CHECK_FOR_REQUESTS(urb_ring, more_to_do); 679816ac92eSJuergen Gross if (more_to_do) { 680816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 681816ac92eSJuergen Gross } 682816ac92eSJuergen Gross } 683816ac92eSJuergen Gross 684816ac92eSJuergen Gross static void usbback_hotplug_enq(struct usbback_info *usbif, unsigned port) 685816ac92eSJuergen Gross { 686816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 687816ac92eSJuergen Gross 688816ac92eSJuergen Gross usb_hp = g_new0(struct usbback_hotplug, 1); 689816ac92eSJuergen Gross usb_hp->port = port; 690816ac92eSJuergen Gross QSIMPLEQ_INSERT_TAIL(&usbif->hotplug_q, usb_hp, q); 691816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 692816ac92eSJuergen Gross } 693816ac92eSJuergen Gross 69480440ea0SJuergen Gross static void usbback_portid_drain(struct usbback_info *usbif, unsigned port) 69580440ea0SJuergen Gross { 69680440ea0SJuergen Gross struct usbback_req *req, *tmp; 69780440ea0SJuergen Gross bool sched = false; 69880440ea0SJuergen Gross 69980440ea0SJuergen Gross QTAILQ_FOREACH_SAFE(req, &usbif->ports[port - 1].submit_q, q, tmp) { 70080440ea0SJuergen Gross usbback_cancel_req(req); 70180440ea0SJuergen Gross sched = true; 70280440ea0SJuergen Gross } 70380440ea0SJuergen Gross 70480440ea0SJuergen Gross if (sched) { 70580440ea0SJuergen Gross qemu_bh_schedule(usbif->bh); 70680440ea0SJuergen Gross } 70780440ea0SJuergen Gross } 70880440ea0SJuergen Gross 70980440ea0SJuergen Gross static void usbback_portid_detach(struct usbback_info *usbif, unsigned port) 71080440ea0SJuergen Gross { 71180440ea0SJuergen Gross if (!usbif->ports[port - 1].attached) { 71280440ea0SJuergen Gross return; 71380440ea0SJuergen Gross } 71480440ea0SJuergen Gross 71580440ea0SJuergen Gross usbif->ports[port - 1].speed = USBIF_SPEED_NONE; 71680440ea0SJuergen Gross usbif->ports[port - 1].attached = false; 71780440ea0SJuergen Gross usbback_portid_drain(usbif, port); 71880440ea0SJuergen Gross usbback_hotplug_enq(usbif, port); 71980440ea0SJuergen Gross } 72080440ea0SJuergen Gross 721816ac92eSJuergen Gross static void usbback_portid_remove(struct usbback_info *usbif, unsigned port) 722816ac92eSJuergen Gross { 723816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 724816ac92eSJuergen Gross return; 725816ac92eSJuergen Gross } 726816ac92eSJuergen Gross 727816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 728816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 72980440ea0SJuergen Gross usbback_portid_detach(usbif, port); 730816ac92eSJuergen Gross 731816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d removed\n", port); 732816ac92eSJuergen Gross } 733816ac92eSJuergen Gross 734816ac92eSJuergen Gross static void usbback_portid_add(struct usbback_info *usbif, unsigned port, 735816ac92eSJuergen Gross char *busid) 736816ac92eSJuergen Gross { 737816ac92eSJuergen Gross unsigned speed; 738816ac92eSJuergen Gross char *portname; 739816ac92eSJuergen Gross Error *local_err = NULL; 740816ac92eSJuergen Gross QDict *qdict; 741816ac92eSJuergen Gross QemuOpts *opts; 742f1784a22SJuergen Gross char *tmp; 743816ac92eSJuergen Gross 744816ac92eSJuergen Gross if (usbif->ports[port - 1].dev) { 745816ac92eSJuergen Gross return; 746816ac92eSJuergen Gross } 747816ac92eSJuergen Gross 748816ac92eSJuergen Gross portname = strchr(busid, '-'); 749816ac92eSJuergen Gross if (!portname) { 75096c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n", 751816ac92eSJuergen Gross busid); 752816ac92eSJuergen Gross return; 753816ac92eSJuergen Gross } 754816ac92eSJuergen Gross portname++; 755816ac92eSJuergen Gross 756816ac92eSJuergen Gross qdict = qdict_new(); 75746f5ac20SEric Blake qdict_put_str(qdict, "driver", "usb-host"); 758f1784a22SJuergen Gross tmp = g_strdup_printf("%s.0", usbif->xendev.qdev.id); 75946f5ac20SEric Blake qdict_put_str(qdict, "bus", tmp); 760f1784a22SJuergen Gross g_free(tmp); 761f1784a22SJuergen Gross tmp = g_strdup_printf("%s-%u", usbif->xendev.qdev.id, port); 76246f5ac20SEric Blake qdict_put_str(qdict, "id", tmp); 763f1784a22SJuergen Gross g_free(tmp); 76446f5ac20SEric Blake qdict_put_int(qdict, "port", port); 76546f5ac20SEric Blake qdict_put_int(qdict, "hostbus", atoi(busid)); 76646f5ac20SEric Blake qdict_put_str(qdict, "hostport", portname); 76756f9dde4SMarkus Armbruster opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, 76856f9dde4SMarkus Armbruster &error_abort); 769816ac92eSJuergen Gross usbif->ports[port - 1].dev = USB_DEVICE(qdev_device_add(opts, &local_err)); 770816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 77156f9dde4SMarkus Armbruster qobject_unref(qdict); 77256f9dde4SMarkus Armbruster xen_pv_printf(&usbif->xendev, 0, 77356f9dde4SMarkus Armbruster "device %s could not be opened: %s\n", 77456f9dde4SMarkus Armbruster busid, error_get_pretty(local_err)); 77556f9dde4SMarkus Armbruster error_free(local_err); 77656f9dde4SMarkus Armbruster return; 777816ac92eSJuergen Gross } 778cb3e7f08SMarc-André Lureau qobject_unref(qdict); 779816ac92eSJuergen Gross speed = usbif->ports[port - 1].dev->speed; 780816ac92eSJuergen Gross switch (speed) { 781816ac92eSJuergen Gross case USB_SPEED_LOW: 782816ac92eSJuergen Gross speed = USBIF_SPEED_LOW; 783816ac92eSJuergen Gross break; 784816ac92eSJuergen Gross case USB_SPEED_FULL: 785816ac92eSJuergen Gross speed = USBIF_SPEED_FULL; 786816ac92eSJuergen Gross break; 787816ac92eSJuergen Gross case USB_SPEED_HIGH: 788816ac92eSJuergen Gross speed = (usbif->usb_ver < USB_VER_USB20) ? 789816ac92eSJuergen Gross USBIF_SPEED_NONE : USBIF_SPEED_HIGH; 790816ac92eSJuergen Gross break; 791816ac92eSJuergen Gross default: 792816ac92eSJuergen Gross speed = USBIF_SPEED_NONE; 793816ac92eSJuergen Gross break; 794816ac92eSJuergen Gross } 795816ac92eSJuergen Gross if (speed == USBIF_SPEED_NONE) { 79696c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); 797816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 798816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 799816ac92eSJuergen Gross return; 800816ac92eSJuergen Gross } 801816ac92eSJuergen Gross usb_device_reset(usbif->ports[port - 1].dev); 802816ac92eSJuergen Gross usbif->ports[port - 1].speed = speed; 803816ac92eSJuergen Gross usbif->ports[port - 1].attached = true; 804816ac92eSJuergen Gross QTAILQ_INIT(&usbif->ports[port - 1].submit_q); 805816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port); 806816ac92eSJuergen Gross 807816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d attached\n", port); 808816ac92eSJuergen Gross } 809816ac92eSJuergen Gross 810816ac92eSJuergen Gross static void usbback_process_port(struct usbback_info *usbif, unsigned port) 811816ac92eSJuergen Gross { 812816ac92eSJuergen Gross char node[8]; 813816ac92eSJuergen Gross char *busid; 814816ac92eSJuergen Gross 815816ac92eSJuergen Gross snprintf(node, sizeof(node), "port/%d", port); 816816ac92eSJuergen Gross busid = xenstore_read_be_str(&usbif->xendev, node); 817816ac92eSJuergen Gross if (busid == NULL) { 81896c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); 819816ac92eSJuergen Gross return; 820816ac92eSJuergen Gross } 821816ac92eSJuergen Gross 822816ac92eSJuergen Gross /* Remove portid, if the port is not connected. */ 823816ac92eSJuergen Gross if (strlen(busid) == 0) { 824816ac92eSJuergen Gross usbback_portid_remove(usbif, port); 825816ac92eSJuergen Gross } else { 826816ac92eSJuergen Gross usbback_portid_add(usbif, port, busid); 827816ac92eSJuergen Gross } 828816ac92eSJuergen Gross 829816ac92eSJuergen Gross g_free(busid); 830816ac92eSJuergen Gross } 831816ac92eSJuergen Gross 8322d0ed5e6SPaul Durrant static void usbback_disconnect(struct XenLegacyDevice *xendev) 833816ac92eSJuergen Gross { 834816ac92eSJuergen Gross struct usbback_info *usbif; 835816ac92eSJuergen Gross unsigned int i; 836816ac92eSJuergen Gross 837816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 838816ac92eSJuergen Gross 839816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 840816ac92eSJuergen Gross 84165807f4bSEmil Condrea xen_pv_unbind_evtchn(xendev); 842816ac92eSJuergen Gross 843816ac92eSJuergen Gross if (usbif->urb_sring) { 844*f80fad16SDavid Woodhouse xen_be_unmap_grant_ref(xendev, usbif->urb_sring, usbif->urb_ring_ref); 845816ac92eSJuergen Gross usbif->urb_sring = NULL; 846816ac92eSJuergen Gross } 847816ac92eSJuergen Gross if (usbif->conn_sring) { 848*f80fad16SDavid Woodhouse xen_be_unmap_grant_ref(xendev, usbif->conn_sring, usbif->conn_ring_ref); 849816ac92eSJuergen Gross usbif->conn_sring = NULL; 850816ac92eSJuergen Gross } 851816ac92eSJuergen Gross 852816ac92eSJuergen Gross for (i = 0; i < usbif->num_ports; i++) { 85380440ea0SJuergen Gross if (usbif->ports[i].dev) { 85480440ea0SJuergen Gross usbback_portid_drain(usbif, i + 1); 855816ac92eSJuergen Gross } 856816ac92eSJuergen Gross } 857816ac92eSJuergen Gross 858816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 859816ac92eSJuergen Gross } 860816ac92eSJuergen Gross 8612d0ed5e6SPaul Durrant static int usbback_connect(struct XenLegacyDevice *xendev) 862816ac92eSJuergen Gross { 863816ac92eSJuergen Gross struct usbback_info *usbif; 864816ac92eSJuergen Gross struct usbif_urb_sring *urb_sring; 865816ac92eSJuergen Gross struct usbif_conn_sring *conn_sring; 866816ac92eSJuergen Gross int urb_ring_ref; 867816ac92eSJuergen Gross int conn_ring_ref; 868f8224fb0SJuergen Gross unsigned int i, max_grants; 869816ac92eSJuergen Gross 870816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 871816ac92eSJuergen Gross 872f8224fb0SJuergen Gross /* max_grants: for each request and for the rings (request and connect). */ 873f8224fb0SJuergen Gross max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; 874f8224fb0SJuergen Gross xen_be_set_max_grant_refs(xendev, max_grants); 875f8224fb0SJuergen Gross 876816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 877816ac92eSJuergen Gross 878816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { 87996c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n"); 880816ac92eSJuergen Gross return -1; 881816ac92eSJuergen Gross } 882816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { 88396c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n"); 884816ac92eSJuergen Gross return -1; 885816ac92eSJuergen Gross } 886816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { 88796c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading event-channel\n"); 888816ac92eSJuergen Gross return -1; 889816ac92eSJuergen Gross } 890816ac92eSJuergen Gross 89158560f2aSPaul Durrant usbif->urb_sring = xen_be_map_grant_ref(xendev, urb_ring_ref, 892816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 89358560f2aSPaul Durrant usbif->conn_sring = xen_be_map_grant_ref(xendev, conn_ring_ref, 894816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 895816ac92eSJuergen Gross if (!usbif->urb_sring || !usbif->conn_sring) { 89696c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error mapping rings\n"); 897816ac92eSJuergen Gross usbback_disconnect(xendev); 898816ac92eSJuergen Gross return -1; 899816ac92eSJuergen Gross } 900816ac92eSJuergen Gross 901*f80fad16SDavid Woodhouse usbif->urb_ring_ref = urb_ring_ref; 902*f80fad16SDavid Woodhouse usbif->conn_ring_ref = conn_ring_ref; 903816ac92eSJuergen Gross urb_sring = usbif->urb_sring; 904816ac92eSJuergen Gross conn_sring = usbif->conn_sring; 905816ac92eSJuergen Gross BACK_RING_INIT(&usbif->urb_ring, urb_sring, XC_PAGE_SIZE); 906816ac92eSJuergen Gross BACK_RING_INIT(&usbif->conn_ring, conn_sring, XC_PAGE_SIZE); 907816ac92eSJuergen Gross 908816ac92eSJuergen Gross xen_be_bind_evtchn(xendev); 909816ac92eSJuergen Gross 91096c77dbaSEmil Condrea xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " 911816ac92eSJuergen Gross "remote port %d, local port %d\n", urb_ring_ref, 912816ac92eSJuergen Gross conn_ring_ref, xendev->remote_port, xendev->local_port); 913816ac92eSJuergen Gross 914816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 915816ac92eSJuergen Gross if (usbif->ports[i - 1].dev) { 916816ac92eSJuergen Gross usbback_hotplug_enq(usbif, i); 917816ac92eSJuergen Gross } 918816ac92eSJuergen Gross } 919816ac92eSJuergen Gross 920816ac92eSJuergen Gross return 0; 921816ac92eSJuergen Gross } 922816ac92eSJuergen Gross 9232d0ed5e6SPaul Durrant static void usbback_backend_changed(struct XenLegacyDevice *xendev, 9242d0ed5e6SPaul Durrant const char *node) 925816ac92eSJuergen Gross { 926816ac92eSJuergen Gross struct usbback_info *usbif; 927816ac92eSJuergen Gross unsigned int i; 928816ac92eSJuergen Gross 929816ac92eSJuergen Gross TR_BUS(xendev, "path %s\n", node); 930816ac92eSJuergen Gross 931816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 932816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 933816ac92eSJuergen Gross usbback_process_port(usbif, i); 934816ac92eSJuergen Gross } 935816ac92eSJuergen Gross } 936816ac92eSJuergen Gross 9372d0ed5e6SPaul Durrant static int usbback_init(struct XenLegacyDevice *xendev) 938816ac92eSJuergen Gross { 939816ac92eSJuergen Gross struct usbback_info *usbif; 940816ac92eSJuergen Gross 941816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 942816ac92eSJuergen Gross 943816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 944816ac92eSJuergen Gross 945816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || 946816ac92eSJuergen Gross usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { 94796c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n"); 948816ac92eSJuergen Gross return -1; 949816ac92eSJuergen Gross } 950816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || 951816ac92eSJuergen Gross (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { 95296c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); 953816ac92eSJuergen Gross return -1; 954816ac92eSJuergen Gross } 955816ac92eSJuergen Gross 956816ac92eSJuergen Gross usbback_backend_changed(xendev, "port"); 957816ac92eSJuergen Gross 958816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 959816ac92eSJuergen Gross 960816ac92eSJuergen Gross return 0; 961816ac92eSJuergen Gross } 962816ac92eSJuergen Gross 963816ac92eSJuergen Gross static void xen_bus_attach(USBPort *port) 964816ac92eSJuergen Gross { 965816ac92eSJuergen Gross struct usbback_info *usbif; 966816ac92eSJuergen Gross 967816ac92eSJuergen Gross usbif = port->opaque; 968816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 969816ac92eSJuergen Gross usbif->ports[port->index].attached = true; 970816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port->index + 1); 971816ac92eSJuergen Gross } 972816ac92eSJuergen Gross 973816ac92eSJuergen Gross static void xen_bus_detach(USBPort *port) 974816ac92eSJuergen Gross { 975816ac92eSJuergen Gross struct usbback_info *usbif; 976816ac92eSJuergen Gross 977816ac92eSJuergen Gross usbif = port->opaque; 978816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 97980440ea0SJuergen Gross usbback_portid_detach(usbif, port->index + 1); 980816ac92eSJuergen Gross } 981816ac92eSJuergen Gross 982816ac92eSJuergen Gross static void xen_bus_child_detach(USBPort *port, USBDevice *child) 983816ac92eSJuergen Gross { 984816ac92eSJuergen Gross struct usbback_info *usbif; 985816ac92eSJuergen Gross 986816ac92eSJuergen Gross usbif = port->opaque; 987816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 988816ac92eSJuergen Gross } 989816ac92eSJuergen Gross 990816ac92eSJuergen Gross static void xen_bus_complete(USBPort *port, USBPacket *packet) 991816ac92eSJuergen Gross { 99280440ea0SJuergen Gross struct usbback_req *usbback_req; 993816ac92eSJuergen Gross struct usbback_info *usbif; 994816ac92eSJuergen Gross 99580440ea0SJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 99680440ea0SJuergen Gross if (usbback_req->cancelled) { 99780440ea0SJuergen Gross g_free(usbback_req); 99880440ea0SJuergen Gross return; 99980440ea0SJuergen Gross } 100080440ea0SJuergen Gross 100180440ea0SJuergen Gross usbif = usbback_req->usbif; 1002816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "\n"); 10031aef27c9SPeter Maydell usbback_packet_complete(usbback_req); 1004816ac92eSJuergen Gross } 1005816ac92eSJuergen Gross 1006816ac92eSJuergen Gross static USBPortOps xen_usb_port_ops = { 1007816ac92eSJuergen Gross .attach = xen_bus_attach, 1008816ac92eSJuergen Gross .detach = xen_bus_detach, 1009816ac92eSJuergen Gross .child_detach = xen_bus_child_detach, 1010816ac92eSJuergen Gross .complete = xen_bus_complete, 1011816ac92eSJuergen Gross }; 1012816ac92eSJuergen Gross 1013816ac92eSJuergen Gross static USBBusOps xen_usb_bus_ops = { 1014816ac92eSJuergen Gross }; 1015816ac92eSJuergen Gross 10162d0ed5e6SPaul Durrant static void usbback_alloc(struct XenLegacyDevice *xendev) 1017816ac92eSJuergen Gross { 1018816ac92eSJuergen Gross struct usbback_info *usbif; 1019816ac92eSJuergen Gross USBPort *p; 1020f8224fb0SJuergen Gross unsigned int i; 1021816ac92eSJuergen Gross 1022816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1023816ac92eSJuergen Gross 1024f1784a22SJuergen Gross usb_bus_new(&usbif->bus, sizeof(usbif->bus), &xen_usb_bus_ops, 1025f1784a22SJuergen Gross DEVICE(&xendev->qdev)); 1026816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1027816ac92eSJuergen Gross p = &(usbif->ports[i].port); 1028816ac92eSJuergen Gross usb_register_port(&usbif->bus, p, usbif, i, &xen_usb_port_ops, 1029816ac92eSJuergen Gross USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL | 1030816ac92eSJuergen Gross USB_SPEED_MASK_HIGH); 1031816ac92eSJuergen Gross } 1032816ac92eSJuergen Gross 1033816ac92eSJuergen Gross QTAILQ_INIT(&usbif->req_free_q); 1034816ac92eSJuergen Gross QSIMPLEQ_INIT(&usbif->hotplug_q); 1035816ac92eSJuergen Gross usbif->bh = qemu_bh_new(usbback_bh, usbif); 1036816ac92eSJuergen Gross } 1037816ac92eSJuergen Gross 10382d0ed5e6SPaul Durrant static int usbback_free(struct XenLegacyDevice *xendev) 1039816ac92eSJuergen Gross { 1040816ac92eSJuergen Gross struct usbback_info *usbif; 1041816ac92eSJuergen Gross struct usbback_req *usbback_req; 1042816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 1043816ac92eSJuergen Gross unsigned int i; 1044816ac92eSJuergen Gross 1045816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 1046816ac92eSJuergen Gross 1047816ac92eSJuergen Gross usbback_disconnect(xendev); 1048816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1049816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 1050816ac92eSJuergen Gross usbback_portid_remove(usbif, i); 1051816ac92eSJuergen Gross } 1052816ac92eSJuergen Gross 1053816ac92eSJuergen Gross while (!QTAILQ_EMPTY(&usbif->req_free_q)) { 1054816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 1055816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 1056816ac92eSJuergen Gross g_free(usbback_req); 1057816ac92eSJuergen Gross } 1058816ac92eSJuergen Gross while (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 1059816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 1060816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 1061816ac92eSJuergen Gross g_free(usb_hp); 1062816ac92eSJuergen Gross } 1063816ac92eSJuergen Gross 1064816ac92eSJuergen Gross qemu_bh_delete(usbif->bh); 1065816ac92eSJuergen Gross 1066816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1067816ac92eSJuergen Gross usb_unregister_port(&usbif->bus, &(usbif->ports[i].port)); 1068816ac92eSJuergen Gross } 1069816ac92eSJuergen Gross 1070816ac92eSJuergen Gross usb_bus_release(&usbif->bus); 1071816ac92eSJuergen Gross 1072816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 1073816ac92eSJuergen Gross 1074816ac92eSJuergen Gross return 0; 1075816ac92eSJuergen Gross } 1076816ac92eSJuergen Gross 10772d0ed5e6SPaul Durrant static void usbback_event(struct XenLegacyDevice *xendev) 1078816ac92eSJuergen Gross { 1079816ac92eSJuergen Gross struct usbback_info *usbif; 1080816ac92eSJuergen Gross 1081816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1082816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 1083816ac92eSJuergen Gross } 1084816ac92eSJuergen Gross 1085816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1086816ac92eSJuergen Gross .size = sizeof(struct usbback_info), 1087816ac92eSJuergen Gross .flags = DEVOPS_FLAG_NEED_GNTDEV, 1088816ac92eSJuergen Gross .init = usbback_init, 1089816ac92eSJuergen Gross .alloc = usbback_alloc, 1090816ac92eSJuergen Gross .free = usbback_free, 1091816ac92eSJuergen Gross .backend_changed = usbback_backend_changed, 1092816ac92eSJuergen Gross .initialise = usbback_connect, 1093816ac92eSJuergen Gross .disconnect = usbback_disconnect, 1094816ac92eSJuergen Gross .event = usbback_event, 1095816ac92eSJuergen Gross }; 1096816ac92eSJuergen Gross 1097816ac92eSJuergen Gross #else /* USBIF_SHORT_NOT_OK */ 1098816ac92eSJuergen Gross 1099816ac92eSJuergen Gross static int usbback_not_supported(void) 1100816ac92eSJuergen Gross { 1101816ac92eSJuergen Gross return -EINVAL; 1102816ac92eSJuergen Gross } 1103816ac92eSJuergen Gross 1104816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1105816ac92eSJuergen Gross .backend_register = usbback_not_supported, 1106816ac92eSJuergen Gross }; 1107816ac92eSJuergen Gross 1108816ac92eSJuergen Gross #endif 1109