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" 27922a01a0SMarkus Armbruster #include "qemu/option.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" 32452fcdbcSMarkus Armbruster #include "qapi/qmp/qdict.h" 33816ac92eSJuergen Gross #include "qapi/qmp/qstring.h" 34816ac92eSJuergen Gross 35f65eadb6SStefano Stabellini #include "hw/xen/io/ring.h" 36816ac92eSJuergen Gross #include <xen/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; 75816ac92eSJuergen Gross QTAILQ_HEAD(submit_q_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 { 102816ac92eSJuergen Gross struct XenDevice xendev; /* must be first */ 103816ac92eSJuergen Gross USBBus bus; 104816ac92eSJuergen Gross void *urb_sring; 105816ac92eSJuergen Gross void *conn_sring; 106816ac92eSJuergen Gross struct usbif_urb_back_ring urb_ring; 107816ac92eSJuergen Gross struct usbif_conn_back_ring conn_ring; 108816ac92eSJuergen Gross int num_ports; 109816ac92eSJuergen Gross int usb_ver; 110816ac92eSJuergen Gross bool ring_error; 111816ac92eSJuergen Gross QTAILQ_HEAD(req_free_q_head, usbback_req) req_free_q; 112816ac92eSJuergen Gross QSIMPLEQ_HEAD(hotplug_q_head, usbback_hotplug) hotplug_q; 113816ac92eSJuergen Gross struct usbback_stub ports[USBBACK_MAXPORTS]; 114816ac92eSJuergen Gross struct usbback_stub *addr_table[USB_DEV_ADDR_SIZE]; 115816ac92eSJuergen Gross QEMUBH *bh; 116816ac92eSJuergen Gross }; 117816ac92eSJuergen Gross 118816ac92eSJuergen Gross static struct usbback_req *usbback_get_req(struct usbback_info *usbif) 119816ac92eSJuergen Gross { 120816ac92eSJuergen Gross struct usbback_req *usbback_req; 121816ac92eSJuergen Gross 122816ac92eSJuergen Gross if (QTAILQ_EMPTY(&usbif->req_free_q)) { 123816ac92eSJuergen Gross usbback_req = g_new0(struct usbback_req, 1); 124816ac92eSJuergen Gross } else { 125816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 126816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 127816ac92eSJuergen Gross } 128816ac92eSJuergen Gross return usbback_req; 129816ac92eSJuergen Gross } 130816ac92eSJuergen Gross 131816ac92eSJuergen Gross static void usbback_put_req(struct usbback_req *usbback_req) 132816ac92eSJuergen Gross { 133816ac92eSJuergen Gross struct usbback_info *usbif; 134816ac92eSJuergen Gross 135816ac92eSJuergen Gross usbif = usbback_req->usbif; 136816ac92eSJuergen Gross memset(usbback_req, 0, sizeof(*usbback_req)); 137816ac92eSJuergen Gross QTAILQ_INSERT_HEAD(&usbif->req_free_q, usbback_req, q); 138816ac92eSJuergen Gross } 139816ac92eSJuergen Gross 140816ac92eSJuergen Gross static int usbback_gnttab_map(struct usbback_req *usbback_req) 141816ac92eSJuergen Gross { 142816ac92eSJuergen Gross unsigned int nr_segs, i, prot; 143816ac92eSJuergen Gross uint32_t ref[USBIF_MAX_SEGMENTS_PER_REQUEST]; 144816ac92eSJuergen Gross struct usbback_info *usbif = usbback_req->usbif; 145816ac92eSJuergen Gross struct XenDevice *xendev = &usbif->xendev; 146816ac92eSJuergen Gross struct usbif_request_segment *seg; 147816ac92eSJuergen Gross void *addr; 148816ac92eSJuergen Gross 149816ac92eSJuergen Gross nr_segs = usbback_req->nr_buffer_segs + usbback_req->nr_extra_segs; 150816ac92eSJuergen Gross if (!nr_segs) { 151816ac92eSJuergen Gross return 0; 152816ac92eSJuergen Gross } 153816ac92eSJuergen Gross 154816ac92eSJuergen Gross if (nr_segs > USBIF_MAX_SEGMENTS_PER_REQUEST) { 15596c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "bad number of segments in request (%d)\n", 156816ac92eSJuergen Gross nr_segs); 157816ac92eSJuergen Gross return -EINVAL; 158816ac92eSJuergen Gross } 159816ac92eSJuergen Gross 160816ac92eSJuergen Gross for (i = 0; i < nr_segs; i++) { 161816ac92eSJuergen Gross if ((unsigned)usbback_req->req.seg[i].offset + 162c6d25aa6SStefano Stabellini (unsigned)usbback_req->req.seg[i].length > XC_PAGE_SIZE) { 16396c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "segment crosses page boundary\n"); 164816ac92eSJuergen Gross return -EINVAL; 165816ac92eSJuergen Gross } 166816ac92eSJuergen Gross } 167816ac92eSJuergen Gross 168816ac92eSJuergen Gross if (usbback_req->nr_buffer_segs) { 169816ac92eSJuergen Gross prot = PROT_READ; 170816ac92eSJuergen Gross if (usbif_pipein(usbback_req->req.pipe)) { 171816ac92eSJuergen Gross prot |= PROT_WRITE; 172816ac92eSJuergen Gross } 173816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 174816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i].gref; 175816ac92eSJuergen Gross } 176816ac92eSJuergen Gross usbback_req->buffer = xengnttab_map_domain_grant_refs(xendev->gnttabdev, 177816ac92eSJuergen Gross usbback_req->nr_buffer_segs, xendev->dom, ref, prot); 178816ac92eSJuergen Gross 179816ac92eSJuergen Gross if (!usbback_req->buffer) { 180816ac92eSJuergen Gross return -ENOMEM; 181816ac92eSJuergen Gross } 182816ac92eSJuergen Gross 183816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 184816ac92eSJuergen Gross seg = usbback_req->req.seg + i; 185c6d25aa6SStefano Stabellini addr = usbback_req->buffer + i * XC_PAGE_SIZE + seg->offset; 186816ac92eSJuergen Gross qemu_iovec_add(&usbback_req->packet.iov, addr, seg->length); 187816ac92eSJuergen Gross } 188816ac92eSJuergen Gross } 189816ac92eSJuergen Gross 190816ac92eSJuergen Gross if (!usbif_pipeisoc(usbback_req->req.pipe)) { 191816ac92eSJuergen Gross return 0; 192816ac92eSJuergen Gross } 193816ac92eSJuergen Gross 194816ac92eSJuergen Gross /* 195816ac92eSJuergen Gross * Right now isoc requests are not supported. 196816ac92eSJuergen Gross * Prepare supporting those by doing the work needed on the guest 197816ac92eSJuergen Gross * interface side. 198816ac92eSJuergen Gross */ 199816ac92eSJuergen Gross 200816ac92eSJuergen Gross if (!usbback_req->nr_extra_segs) { 20196c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "iso request without descriptor segments\n"); 202816ac92eSJuergen Gross return -EINVAL; 203816ac92eSJuergen Gross } 204816ac92eSJuergen Gross 205816ac92eSJuergen Gross prot = PROT_READ | PROT_WRITE; 206816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_extra_segs; i++) { 207816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i + usbback_req->req.nr_buffer_segs].gref; 208816ac92eSJuergen Gross } 209816ac92eSJuergen Gross usbback_req->isoc_buffer = xengnttab_map_domain_grant_refs( 210816ac92eSJuergen Gross xendev->gnttabdev, usbback_req->nr_extra_segs, xendev->dom, ref, prot); 211816ac92eSJuergen Gross 212816ac92eSJuergen Gross if (!usbback_req->isoc_buffer) { 213816ac92eSJuergen Gross return -ENOMEM; 214816ac92eSJuergen Gross } 215816ac92eSJuergen Gross 216816ac92eSJuergen Gross return 0; 217816ac92eSJuergen Gross } 218816ac92eSJuergen Gross 219816ac92eSJuergen Gross static int usbback_init_packet(struct usbback_req *usbback_req) 220816ac92eSJuergen Gross { 221816ac92eSJuergen Gross struct XenDevice *xendev = &usbback_req->usbif->xendev; 222816ac92eSJuergen Gross USBPacket *packet = &usbback_req->packet; 223816ac92eSJuergen Gross USBDevice *dev = usbback_req->stub->dev; 224816ac92eSJuergen Gross USBEndpoint *ep; 225816ac92eSJuergen Gross unsigned int pid, ep_nr; 226816ac92eSJuergen Gross bool sok; 227816ac92eSJuergen Gross int ret = 0; 228816ac92eSJuergen Gross 229816ac92eSJuergen Gross qemu_iovec_init(&packet->iov, USBIF_MAX_SEGMENTS_PER_REQUEST); 230816ac92eSJuergen Gross pid = usbif_pipein(usbback_req->req.pipe) ? USB_TOKEN_IN : USB_TOKEN_OUT; 231816ac92eSJuergen Gross ep_nr = usbif_pipeendpoint(usbback_req->req.pipe); 232816ac92eSJuergen Gross sok = !!(usbback_req->req.transfer_flags & USBIF_SHORT_NOT_OK); 233816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 234816ac92eSJuergen Gross ep_nr = 0; 235816ac92eSJuergen Gross sok = false; 236816ac92eSJuergen Gross } 237816ac92eSJuergen Gross ep = usb_ep_get(dev, pid, ep_nr); 238816ac92eSJuergen Gross usb_packet_setup(packet, pid, ep, 0, 1, sok, true); 239816ac92eSJuergen Gross 240816ac92eSJuergen Gross switch (usbif_pipetype(usbback_req->req.pipe)) { 241816ac92eSJuergen Gross case USBIF_PIPE_TYPE_ISOC: 242816ac92eSJuergen Gross TR_REQ(xendev, "iso transfer %s: buflen: %x, %d frames\n", 243816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 244816ac92eSJuergen Gross usbback_req->req.buffer_length, 245816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs); 246816ac92eSJuergen Gross ret = -EINVAL; /* isoc not implemented yet */ 247816ac92eSJuergen Gross break; 248816ac92eSJuergen Gross 249816ac92eSJuergen Gross case USBIF_PIPE_TYPE_INT: 250816ac92eSJuergen Gross TR_REQ(xendev, "int transfer %s: buflen: %x\n", 251816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 252816ac92eSJuergen Gross usbback_req->req.buffer_length); 253816ac92eSJuergen Gross break; 254816ac92eSJuergen Gross 255816ac92eSJuergen Gross case USBIF_PIPE_TYPE_CTRL: 256816ac92eSJuergen Gross packet->parameter = *(uint64_t *)usbback_req->req.u.ctrl; 257042ec47eSAnthony PERARD TR_REQ(xendev, "ctrl parameter: %"PRIx64", buflen: %x\n", 258042ec47eSAnthony PERARD packet->parameter, 259816ac92eSJuergen Gross usbback_req->req.buffer_length); 260816ac92eSJuergen Gross break; 261816ac92eSJuergen Gross 262816ac92eSJuergen Gross case USBIF_PIPE_TYPE_BULK: 263816ac92eSJuergen Gross TR_REQ(xendev, "bulk transfer %s: buflen: %x\n", 264816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 265816ac92eSJuergen Gross usbback_req->req.buffer_length); 266816ac92eSJuergen Gross break; 267816ac92eSJuergen Gross default: 268816ac92eSJuergen Gross ret = -EINVAL; 269816ac92eSJuergen Gross break; 270816ac92eSJuergen Gross } 271816ac92eSJuergen Gross 272816ac92eSJuergen Gross return ret; 273816ac92eSJuergen Gross } 274816ac92eSJuergen Gross 275816ac92eSJuergen Gross static void usbback_do_response(struct usbback_req *usbback_req, int32_t status, 276816ac92eSJuergen Gross int32_t actual_length, int32_t error_count) 277816ac92eSJuergen Gross { 278816ac92eSJuergen Gross struct usbback_info *usbif; 279816ac92eSJuergen Gross struct usbif_urb_response *res; 280816ac92eSJuergen Gross struct XenDevice *xendev; 281816ac92eSJuergen Gross unsigned int notify; 282816ac92eSJuergen Gross 283816ac92eSJuergen Gross usbif = usbback_req->usbif; 284816ac92eSJuergen Gross xendev = &usbif->xendev; 285816ac92eSJuergen Gross 286816ac92eSJuergen Gross TR_REQ(xendev, "id %d, status %d, length %d, errcnt %d\n", 287816ac92eSJuergen Gross usbback_req->req.id, status, actual_length, error_count); 288816ac92eSJuergen Gross 289816ac92eSJuergen Gross if (usbback_req->packet.iov.iov) { 290816ac92eSJuergen Gross qemu_iovec_destroy(&usbback_req->packet.iov); 291816ac92eSJuergen Gross } 292816ac92eSJuergen Gross 293816ac92eSJuergen Gross if (usbback_req->buffer) { 294816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbback_req->buffer, 295816ac92eSJuergen Gross usbback_req->nr_buffer_segs); 296816ac92eSJuergen Gross usbback_req->buffer = NULL; 297816ac92eSJuergen Gross } 298816ac92eSJuergen Gross 299816ac92eSJuergen Gross if (usbback_req->isoc_buffer) { 300816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbback_req->isoc_buffer, 301816ac92eSJuergen Gross usbback_req->nr_extra_segs); 302816ac92eSJuergen Gross usbback_req->isoc_buffer = NULL; 303816ac92eSJuergen Gross } 304816ac92eSJuergen Gross 30580440ea0SJuergen Gross if (usbif->urb_sring) { 306816ac92eSJuergen Gross res = RING_GET_RESPONSE(&usbif->urb_ring, usbif->urb_ring.rsp_prod_pvt); 307816ac92eSJuergen Gross res->id = usbback_req->req.id; 308816ac92eSJuergen Gross res->status = status; 309816ac92eSJuergen Gross res->actual_length = actual_length; 310816ac92eSJuergen Gross res->error_count = error_count; 311816ac92eSJuergen Gross res->start_frame = 0; 312816ac92eSJuergen Gross usbif->urb_ring.rsp_prod_pvt++; 313816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&usbif->urb_ring, notify); 314816ac92eSJuergen Gross 315816ac92eSJuergen Gross if (notify) { 316ba18fa2aSEmil Condrea xen_pv_send_notify(xendev); 317816ac92eSJuergen Gross } 31880440ea0SJuergen Gross } 319816ac92eSJuergen Gross 32080440ea0SJuergen Gross if (!usbback_req->cancelled) 321816ac92eSJuergen Gross usbback_put_req(usbback_req); 322816ac92eSJuergen Gross } 323816ac92eSJuergen Gross 324816ac92eSJuergen Gross static void usbback_do_response_ret(struct usbback_req *usbback_req, 325816ac92eSJuergen Gross int32_t status) 326816ac92eSJuergen Gross { 327816ac92eSJuergen Gross usbback_do_response(usbback_req, status, 0, 0); 328816ac92eSJuergen Gross } 329816ac92eSJuergen Gross 330816ac92eSJuergen Gross static int32_t usbback_xlat_status(int status) 331816ac92eSJuergen Gross { 332816ac92eSJuergen Gross switch (status) { 333816ac92eSJuergen Gross case USB_RET_SUCCESS: 334816ac92eSJuergen Gross return 0; 335816ac92eSJuergen Gross case USB_RET_NODEV: 336816ac92eSJuergen Gross return -ENODEV; 337816ac92eSJuergen Gross case USB_RET_STALL: 338816ac92eSJuergen Gross return -EPIPE; 339816ac92eSJuergen Gross case USB_RET_BABBLE: 340816ac92eSJuergen Gross return -EOVERFLOW; 341816ac92eSJuergen Gross case USB_RET_IOERROR: 342816ac92eSJuergen Gross return -EPROTO; 343816ac92eSJuergen Gross } 344816ac92eSJuergen Gross 345816ac92eSJuergen Gross return -ESHUTDOWN; 346816ac92eSJuergen Gross } 347816ac92eSJuergen Gross 348816ac92eSJuergen Gross static void usbback_packet_complete(USBPacket *packet) 349816ac92eSJuergen Gross { 350816ac92eSJuergen Gross struct usbback_req *usbback_req; 351816ac92eSJuergen Gross int32_t status; 352816ac92eSJuergen Gross 353816ac92eSJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 354816ac92eSJuergen Gross 355816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 356816ac92eSJuergen Gross 357816ac92eSJuergen Gross status = usbback_xlat_status(packet->status); 358816ac92eSJuergen Gross usbback_do_response(usbback_req, status, packet->actual_length, 0); 359816ac92eSJuergen Gross } 360816ac92eSJuergen Gross 361816ac92eSJuergen Gross static void usbback_set_address(struct usbback_info *usbif, 362816ac92eSJuergen Gross struct usbback_stub *stub, 363816ac92eSJuergen Gross unsigned int cur_addr, unsigned int new_addr) 364816ac92eSJuergen Gross { 365816ac92eSJuergen Gross if (cur_addr) { 366816ac92eSJuergen Gross usbif->addr_table[cur_addr] = NULL; 367816ac92eSJuergen Gross } 368816ac92eSJuergen Gross if (new_addr) { 369816ac92eSJuergen Gross usbif->addr_table[new_addr] = stub; 370816ac92eSJuergen Gross } 371816ac92eSJuergen Gross } 372816ac92eSJuergen Gross 37380440ea0SJuergen Gross static void usbback_cancel_req(struct usbback_req *usbback_req) 374816ac92eSJuergen Gross { 375816ac92eSJuergen Gross if (usb_packet_is_inflight(&usbback_req->packet)) { 376816ac92eSJuergen Gross usb_cancel_packet(&usbback_req->packet); 37780440ea0SJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 37880440ea0SJuergen Gross usbback_req->cancelled = true; 37980440ea0SJuergen Gross usbback_do_response_ret(usbback_req, -EPROTO); 380816ac92eSJuergen Gross } 381816ac92eSJuergen Gross } 382816ac92eSJuergen Gross 383816ac92eSJuergen Gross static void usbback_process_unlink_req(struct usbback_req *usbback_req) 384816ac92eSJuergen Gross { 385816ac92eSJuergen Gross struct usbback_info *usbif; 386816ac92eSJuergen Gross struct usbback_req *unlink_req; 387816ac92eSJuergen Gross unsigned int id, devnum; 388816ac92eSJuergen Gross int ret; 389816ac92eSJuergen Gross 390816ac92eSJuergen Gross usbif = usbback_req->usbif; 391816ac92eSJuergen Gross ret = 0; 392816ac92eSJuergen Gross id = usbback_req->req.u.unlink.unlink_id; 393816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "unlink id %d\n", id); 394816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 395816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 396816ac92eSJuergen Gross usbback_req->stub = usbif->ports + 39780440ea0SJuergen Gross usbif_pipeportnum(usbback_req->req.pipe) - 1; 398816ac92eSJuergen Gross if (unlikely(!usbback_req->stub)) { 399816ac92eSJuergen Gross ret = -ENODEV; 400816ac92eSJuergen Gross goto fail_response; 401816ac92eSJuergen Gross } 402816ac92eSJuergen Gross } else { 403816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 404816ac92eSJuergen Gross ret = -ENODEV; 405816ac92eSJuergen Gross goto fail_response; 406816ac92eSJuergen Gross } 407816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 408816ac92eSJuergen Gross } 409816ac92eSJuergen Gross 410816ac92eSJuergen Gross QTAILQ_FOREACH(unlink_req, &usbback_req->stub->submit_q, q) { 411816ac92eSJuergen Gross if (unlink_req->req.id == id) { 41280440ea0SJuergen Gross usbback_cancel_req(unlink_req); 413816ac92eSJuergen Gross break; 414816ac92eSJuergen Gross } 415816ac92eSJuergen Gross } 416816ac92eSJuergen Gross 417816ac92eSJuergen Gross fail_response: 418816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 419816ac92eSJuergen Gross } 420816ac92eSJuergen Gross 421816ac92eSJuergen Gross /* 422816ac92eSJuergen Gross * Checks whether a request can be handled at once or should be forwarded 423816ac92eSJuergen Gross * to the usb framework. 424816ac92eSJuergen Gross * Return value is: 425816ac92eSJuergen Gross * 0 in case of usb framework is needed 426816ac92eSJuergen Gross * 1 in case of local handling (no error) 427816ac92eSJuergen Gross * The request response has been queued already if return value not 0. 428816ac92eSJuergen Gross */ 429816ac92eSJuergen Gross static int usbback_check_and_submit(struct usbback_req *usbback_req) 430816ac92eSJuergen Gross { 431816ac92eSJuergen Gross struct usbback_info *usbif; 432816ac92eSJuergen Gross unsigned int devnum; 433816ac92eSJuergen Gross struct usbback_stub *stub; 434816ac92eSJuergen Gross struct usbif_ctrlrequest *ctrl; 435816ac92eSJuergen Gross int ret; 436816ac92eSJuergen Gross uint16_t wValue; 437816ac92eSJuergen Gross 438816ac92eSJuergen Gross usbif = usbback_req->usbif; 439816ac92eSJuergen Gross stub = NULL; 440816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 441816ac92eSJuergen Gross ctrl = (struct usbif_ctrlrequest *)usbback_req->req.u.ctrl; 442816ac92eSJuergen Gross wValue = le16_to_cpu(ctrl->wValue); 443816ac92eSJuergen Gross 444816ac92eSJuergen Gross /* 445816ac92eSJuergen Gross * When the device is first connected or resetted, USB device has no 446816ac92eSJuergen Gross * address. In this initial state, following requests are sent to device 447816ac92eSJuergen Gross * address (#0), 448816ac92eSJuergen Gross * 449816ac92eSJuergen Gross * 1. GET_DESCRIPTOR (with Descriptor Type is "DEVICE") is sent, 450816ac92eSJuergen Gross * and OS knows what device is connected to. 451816ac92eSJuergen Gross * 452816ac92eSJuergen Gross * 2. SET_ADDRESS is sent, and then device has its address. 453816ac92eSJuergen Gross * 454816ac92eSJuergen Gross * In the next step, SET_CONFIGURATION is sent to addressed device, and 455816ac92eSJuergen Gross * then the device is finally ready to use. 456816ac92eSJuergen Gross */ 457816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 458816ac92eSJuergen Gross stub = usbif->ports + usbif_pipeportnum(usbback_req->req.pipe) - 1; 459816ac92eSJuergen Gross if (!stub->dev || !stub->attached) { 460816ac92eSJuergen Gross ret = -ENODEV; 461816ac92eSJuergen Gross goto do_response; 462816ac92eSJuergen Gross } 463816ac92eSJuergen Gross 464816ac92eSJuergen Gross switch (ctrl->bRequest) { 465816ac92eSJuergen Gross case USB_REQ_GET_DESCRIPTOR: 466816ac92eSJuergen Gross /* 467816ac92eSJuergen Gross * GET_DESCRIPTOR request to device #0. 468816ac92eSJuergen Gross * through normal transfer. 469816ac92eSJuergen Gross */ 470816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 GET_DESCRIPTOR\n"); 471816ac92eSJuergen Gross usbback_req->stub = stub; 472816ac92eSJuergen Gross return 0; 473816ac92eSJuergen Gross case USB_REQ_SET_ADDRESS: 474816ac92eSJuergen Gross /* 475816ac92eSJuergen Gross * SET_ADDRESS request to device #0. 476816ac92eSJuergen Gross * add attached device to addr_table. 477816ac92eSJuergen Gross */ 478816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 SET_ADDRESS\n"); 479816ac92eSJuergen Gross usbback_set_address(usbif, stub, 0, wValue); 480816ac92eSJuergen Gross ret = 0; 481816ac92eSJuergen Gross break; 482816ac92eSJuergen Gross default: 483816ac92eSJuergen Gross ret = -EINVAL; 484816ac92eSJuergen Gross break; 485816ac92eSJuergen Gross } 486816ac92eSJuergen Gross goto do_response; 487816ac92eSJuergen Gross } 488816ac92eSJuergen Gross 489816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 490816ac92eSJuergen Gross ret = -ENODEV; 491816ac92eSJuergen Gross goto do_response; 492816ac92eSJuergen Gross } 493816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 494816ac92eSJuergen Gross 495816ac92eSJuergen Gross /* 496816ac92eSJuergen Gross * Check special request 497816ac92eSJuergen Gross */ 498816ac92eSJuergen Gross if (ctrl->bRequest != USB_REQ_SET_ADDRESS) { 499816ac92eSJuergen Gross return 0; 500816ac92eSJuergen Gross } 501816ac92eSJuergen Gross 502816ac92eSJuergen Gross /* 503816ac92eSJuergen Gross * SET_ADDRESS request to addressed device. 504816ac92eSJuergen Gross * change addr or remove from addr_table. 505816ac92eSJuergen Gross */ 506816ac92eSJuergen Gross usbback_set_address(usbif, usbback_req->stub, devnum, wValue); 507816ac92eSJuergen Gross ret = 0; 508816ac92eSJuergen Gross 509816ac92eSJuergen Gross do_response: 510816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 511816ac92eSJuergen Gross return 1; 512816ac92eSJuergen Gross } 513816ac92eSJuergen Gross 514816ac92eSJuergen Gross static void usbback_dispatch(struct usbback_req *usbback_req) 515816ac92eSJuergen Gross { 516816ac92eSJuergen Gross int ret; 517816ac92eSJuergen Gross unsigned int devnum; 518816ac92eSJuergen Gross struct usbback_info *usbif; 519816ac92eSJuergen Gross 520816ac92eSJuergen Gross usbif = usbback_req->usbif; 521816ac92eSJuergen Gross 522816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "start req_id %d pipe %08x\n", usbback_req->req.id, 523816ac92eSJuergen Gross usbback_req->req.pipe); 524816ac92eSJuergen Gross 525816ac92eSJuergen Gross /* unlink request */ 526816ac92eSJuergen Gross if (unlikely(usbif_pipeunlink(usbback_req->req.pipe))) { 527816ac92eSJuergen Gross usbback_process_unlink_req(usbback_req); 528816ac92eSJuergen Gross return; 529816ac92eSJuergen Gross } 530816ac92eSJuergen Gross 531816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 532816ac92eSJuergen Gross if (usbback_check_and_submit(usbback_req)) { 533816ac92eSJuergen Gross return; 534816ac92eSJuergen Gross } 535816ac92eSJuergen Gross } else { 536816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 537816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 538816ac92eSJuergen Gross 539816ac92eSJuergen Gross if (!usbback_req->stub || !usbback_req->stub->attached) { 540816ac92eSJuergen Gross ret = -ENODEV; 541816ac92eSJuergen Gross goto fail_response; 542816ac92eSJuergen Gross } 543816ac92eSJuergen Gross } 544816ac92eSJuergen Gross 545816ac92eSJuergen Gross QTAILQ_INSERT_TAIL(&usbback_req->stub->submit_q, usbback_req, q); 546816ac92eSJuergen Gross 547816ac92eSJuergen Gross usbback_req->nr_buffer_segs = usbback_req->req.nr_buffer_segs; 548816ac92eSJuergen Gross usbback_req->nr_extra_segs = usbif_pipeisoc(usbback_req->req.pipe) ? 549816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs : 0; 550816ac92eSJuergen Gross 551816ac92eSJuergen Gross ret = usbback_init_packet(usbback_req); 552816ac92eSJuergen Gross if (ret) { 55396c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid request\n"); 554816ac92eSJuergen Gross ret = -ESHUTDOWN; 555816ac92eSJuergen Gross goto fail_free_urb; 556816ac92eSJuergen Gross } 557816ac92eSJuergen Gross 558816ac92eSJuergen Gross ret = usbback_gnttab_map(usbback_req); 559816ac92eSJuergen Gross if (ret) { 56096c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); 561816ac92eSJuergen Gross ret = -ESHUTDOWN; 562816ac92eSJuergen Gross goto fail_free_urb; 563816ac92eSJuergen Gross } 564816ac92eSJuergen Gross 565816ac92eSJuergen Gross usb_handle_packet(usbback_req->stub->dev, &usbback_req->packet); 566816ac92eSJuergen Gross if (usbback_req->packet.status != USB_RET_ASYNC) { 567816ac92eSJuergen Gross usbback_packet_complete(&usbback_req->packet); 568816ac92eSJuergen Gross } 569816ac92eSJuergen Gross return; 570816ac92eSJuergen Gross 571816ac92eSJuergen Gross fail_free_urb: 572816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 573816ac92eSJuergen Gross 574816ac92eSJuergen Gross fail_response: 575816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 576816ac92eSJuergen Gross } 577816ac92eSJuergen Gross 578816ac92eSJuergen Gross static void usbback_hotplug_notify(struct usbback_info *usbif) 579816ac92eSJuergen Gross { 580816ac92eSJuergen Gross struct usbif_conn_back_ring *ring = &usbif->conn_ring; 581816ac92eSJuergen Gross struct usbif_conn_request req; 582816ac92eSJuergen Gross struct usbif_conn_response *res; 583816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 584816ac92eSJuergen Gross unsigned int notify; 585816ac92eSJuergen Gross 586816ac92eSJuergen Gross if (!usbif->conn_sring) { 587816ac92eSJuergen Gross return; 588816ac92eSJuergen Gross } 589816ac92eSJuergen Gross 590816ac92eSJuergen Gross /* Check for full ring. */ 591816ac92eSJuergen Gross if ((RING_SIZE(ring) - ring->rsp_prod_pvt - ring->req_cons) == 0) { 592ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 593816ac92eSJuergen Gross return; 594816ac92eSJuergen Gross } 595816ac92eSJuergen Gross 596816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 597816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 598816ac92eSJuergen Gross 599816ac92eSJuergen Gross RING_COPY_REQUEST(ring, ring->req_cons, &req); 600816ac92eSJuergen Gross ring->req_cons++; 601816ac92eSJuergen Gross ring->sring->req_event = ring->req_cons + 1; 602816ac92eSJuergen Gross 603816ac92eSJuergen Gross res = RING_GET_RESPONSE(ring, ring->rsp_prod_pvt); 604816ac92eSJuergen Gross res->id = req.id; 605816ac92eSJuergen Gross res->portnum = usb_hp->port; 606816ac92eSJuergen Gross res->speed = usbif->ports[usb_hp->port - 1].speed; 607816ac92eSJuergen Gross ring->rsp_prod_pvt++; 608816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); 609816ac92eSJuergen Gross 610816ac92eSJuergen Gross if (notify) { 611ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 612816ac92eSJuergen Gross } 613816ac92eSJuergen Gross 614816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "hotplug port %d speed %d\n", usb_hp->port, 615816ac92eSJuergen Gross res->speed); 616816ac92eSJuergen Gross 617816ac92eSJuergen Gross g_free(usb_hp); 618816ac92eSJuergen Gross 619816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 620816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 621816ac92eSJuergen Gross } 622816ac92eSJuergen Gross } 623816ac92eSJuergen Gross 624816ac92eSJuergen Gross static void usbback_bh(void *opaque) 625816ac92eSJuergen Gross { 626816ac92eSJuergen Gross struct usbback_info *usbif; 627816ac92eSJuergen Gross struct usbif_urb_back_ring *urb_ring; 628816ac92eSJuergen Gross struct usbback_req *usbback_req; 629816ac92eSJuergen Gross RING_IDX rc, rp; 630816ac92eSJuergen Gross unsigned int more_to_do; 631816ac92eSJuergen Gross 632816ac92eSJuergen Gross usbif = opaque; 633816ac92eSJuergen Gross if (usbif->ring_error) { 634816ac92eSJuergen Gross return; 635816ac92eSJuergen Gross } 636816ac92eSJuergen Gross 637816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 638816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 639816ac92eSJuergen Gross } 640816ac92eSJuergen Gross 641816ac92eSJuergen Gross urb_ring = &usbif->urb_ring; 642816ac92eSJuergen Gross rc = urb_ring->req_cons; 643816ac92eSJuergen Gross rp = urb_ring->sring->req_prod; 644816ac92eSJuergen Gross xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ 645816ac92eSJuergen Gross 646816ac92eSJuergen Gross if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { 647816ac92eSJuergen Gross rc = urb_ring->rsp_prod_pvt; 64896c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests " 649816ac92eSJuergen Gross "(%#x - %#x = %u). Halting ring processing.\n", 650816ac92eSJuergen Gross rp, rc, rp - rc); 651816ac92eSJuergen Gross usbif->ring_error = true; 652816ac92eSJuergen Gross return; 653816ac92eSJuergen Gross } 654816ac92eSJuergen Gross 655816ac92eSJuergen Gross while (rc != rp) { 656816ac92eSJuergen Gross if (RING_REQUEST_CONS_OVERFLOW(urb_ring, rc)) { 657816ac92eSJuergen Gross break; 658816ac92eSJuergen Gross } 659816ac92eSJuergen Gross usbback_req = usbback_get_req(usbif); 660816ac92eSJuergen Gross 661816ac92eSJuergen Gross RING_COPY_REQUEST(urb_ring, rc, &usbback_req->req); 662816ac92eSJuergen Gross usbback_req->usbif = usbif; 663816ac92eSJuergen Gross 664816ac92eSJuergen Gross usbback_dispatch(usbback_req); 665816ac92eSJuergen Gross 666816ac92eSJuergen Gross urb_ring->req_cons = ++rc; 667816ac92eSJuergen Gross } 668816ac92eSJuergen Gross 669816ac92eSJuergen Gross RING_FINAL_CHECK_FOR_REQUESTS(urb_ring, more_to_do); 670816ac92eSJuergen Gross if (more_to_do) { 671816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 672816ac92eSJuergen Gross } 673816ac92eSJuergen Gross } 674816ac92eSJuergen Gross 675816ac92eSJuergen Gross static void usbback_hotplug_enq(struct usbback_info *usbif, unsigned port) 676816ac92eSJuergen Gross { 677816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 678816ac92eSJuergen Gross 679816ac92eSJuergen Gross usb_hp = g_new0(struct usbback_hotplug, 1); 680816ac92eSJuergen Gross usb_hp->port = port; 681816ac92eSJuergen Gross QSIMPLEQ_INSERT_TAIL(&usbif->hotplug_q, usb_hp, q); 682816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 683816ac92eSJuergen Gross } 684816ac92eSJuergen Gross 68580440ea0SJuergen Gross static void usbback_portid_drain(struct usbback_info *usbif, unsigned port) 68680440ea0SJuergen Gross { 68780440ea0SJuergen Gross struct usbback_req *req, *tmp; 68880440ea0SJuergen Gross bool sched = false; 68980440ea0SJuergen Gross 69080440ea0SJuergen Gross QTAILQ_FOREACH_SAFE(req, &usbif->ports[port - 1].submit_q, q, tmp) { 69180440ea0SJuergen Gross usbback_cancel_req(req); 69280440ea0SJuergen Gross sched = true; 69380440ea0SJuergen Gross } 69480440ea0SJuergen Gross 69580440ea0SJuergen Gross if (sched) { 69680440ea0SJuergen Gross qemu_bh_schedule(usbif->bh); 69780440ea0SJuergen Gross } 69880440ea0SJuergen Gross } 69980440ea0SJuergen Gross 70080440ea0SJuergen Gross static void usbback_portid_detach(struct usbback_info *usbif, unsigned port) 70180440ea0SJuergen Gross { 70280440ea0SJuergen Gross if (!usbif->ports[port - 1].attached) { 70380440ea0SJuergen Gross return; 70480440ea0SJuergen Gross } 70580440ea0SJuergen Gross 70680440ea0SJuergen Gross usbif->ports[port - 1].speed = USBIF_SPEED_NONE; 70780440ea0SJuergen Gross usbif->ports[port - 1].attached = false; 70880440ea0SJuergen Gross usbback_portid_drain(usbif, port); 70980440ea0SJuergen Gross usbback_hotplug_enq(usbif, port); 71080440ea0SJuergen Gross } 71180440ea0SJuergen Gross 712816ac92eSJuergen Gross static void usbback_portid_remove(struct usbback_info *usbif, unsigned port) 713816ac92eSJuergen Gross { 714816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 715816ac92eSJuergen Gross return; 716816ac92eSJuergen Gross } 717816ac92eSJuergen Gross 718816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 719816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 72080440ea0SJuergen Gross usbback_portid_detach(usbif, port); 721816ac92eSJuergen Gross 722816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d removed\n", port); 723816ac92eSJuergen Gross } 724816ac92eSJuergen Gross 725816ac92eSJuergen Gross static void usbback_portid_add(struct usbback_info *usbif, unsigned port, 726816ac92eSJuergen Gross char *busid) 727816ac92eSJuergen Gross { 728816ac92eSJuergen Gross unsigned speed; 729816ac92eSJuergen Gross char *portname; 730816ac92eSJuergen Gross Error *local_err = NULL; 731816ac92eSJuergen Gross QDict *qdict; 732816ac92eSJuergen Gross QemuOpts *opts; 733f1784a22SJuergen Gross char *tmp; 734816ac92eSJuergen Gross 735816ac92eSJuergen Gross if (usbif->ports[port - 1].dev) { 736816ac92eSJuergen Gross return; 737816ac92eSJuergen Gross } 738816ac92eSJuergen Gross 739816ac92eSJuergen Gross portname = strchr(busid, '-'); 740816ac92eSJuergen Gross if (!portname) { 74196c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n", 742816ac92eSJuergen Gross busid); 743816ac92eSJuergen Gross return; 744816ac92eSJuergen Gross } 745816ac92eSJuergen Gross portname++; 746816ac92eSJuergen Gross 747816ac92eSJuergen Gross qdict = qdict_new(); 74846f5ac20SEric Blake qdict_put_str(qdict, "driver", "usb-host"); 749f1784a22SJuergen Gross tmp = g_strdup_printf("%s.0", usbif->xendev.qdev.id); 75046f5ac20SEric Blake qdict_put_str(qdict, "bus", tmp); 751f1784a22SJuergen Gross g_free(tmp); 752f1784a22SJuergen Gross tmp = g_strdup_printf("%s-%u", usbif->xendev.qdev.id, port); 75346f5ac20SEric Blake qdict_put_str(qdict, "id", tmp); 754f1784a22SJuergen Gross g_free(tmp); 75546f5ac20SEric Blake qdict_put_int(qdict, "port", port); 75646f5ac20SEric Blake qdict_put_int(qdict, "hostbus", atoi(busid)); 75746f5ac20SEric Blake qdict_put_str(qdict, "hostport", portname); 758816ac92eSJuergen Gross opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err); 759816ac92eSJuergen Gross if (local_err) { 760816ac92eSJuergen Gross goto err; 761816ac92eSJuergen Gross } 762816ac92eSJuergen Gross usbif->ports[port - 1].dev = USB_DEVICE(qdev_device_add(opts, &local_err)); 763816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 764816ac92eSJuergen Gross goto err; 765816ac92eSJuergen Gross } 766*cb3e7f08SMarc-André Lureau qobject_unref(qdict); 767816ac92eSJuergen Gross speed = usbif->ports[port - 1].dev->speed; 768816ac92eSJuergen Gross switch (speed) { 769816ac92eSJuergen Gross case USB_SPEED_LOW: 770816ac92eSJuergen Gross speed = USBIF_SPEED_LOW; 771816ac92eSJuergen Gross break; 772816ac92eSJuergen Gross case USB_SPEED_FULL: 773816ac92eSJuergen Gross speed = USBIF_SPEED_FULL; 774816ac92eSJuergen Gross break; 775816ac92eSJuergen Gross case USB_SPEED_HIGH: 776816ac92eSJuergen Gross speed = (usbif->usb_ver < USB_VER_USB20) ? 777816ac92eSJuergen Gross USBIF_SPEED_NONE : USBIF_SPEED_HIGH; 778816ac92eSJuergen Gross break; 779816ac92eSJuergen Gross default: 780816ac92eSJuergen Gross speed = USBIF_SPEED_NONE; 781816ac92eSJuergen Gross break; 782816ac92eSJuergen Gross } 783816ac92eSJuergen Gross if (speed == USBIF_SPEED_NONE) { 78496c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); 785816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 786816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 787816ac92eSJuergen Gross return; 788816ac92eSJuergen Gross } 789816ac92eSJuergen Gross usb_device_reset(usbif->ports[port - 1].dev); 790816ac92eSJuergen Gross usbif->ports[port - 1].speed = speed; 791816ac92eSJuergen Gross usbif->ports[port - 1].attached = true; 792816ac92eSJuergen Gross QTAILQ_INIT(&usbif->ports[port - 1].submit_q); 793816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port); 794816ac92eSJuergen Gross 795816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d attached\n", port); 796816ac92eSJuergen Gross return; 797816ac92eSJuergen Gross 798816ac92eSJuergen Gross err: 799*cb3e7f08SMarc-André Lureau qobject_unref(qdict); 80096c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); 801816ac92eSJuergen Gross } 802816ac92eSJuergen Gross 803816ac92eSJuergen Gross static void usbback_process_port(struct usbback_info *usbif, unsigned port) 804816ac92eSJuergen Gross { 805816ac92eSJuergen Gross char node[8]; 806816ac92eSJuergen Gross char *busid; 807816ac92eSJuergen Gross 808816ac92eSJuergen Gross snprintf(node, sizeof(node), "port/%d", port); 809816ac92eSJuergen Gross busid = xenstore_read_be_str(&usbif->xendev, node); 810816ac92eSJuergen Gross if (busid == NULL) { 81196c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); 812816ac92eSJuergen Gross return; 813816ac92eSJuergen Gross } 814816ac92eSJuergen Gross 815816ac92eSJuergen Gross /* Remove portid, if the port is not connected. */ 816816ac92eSJuergen Gross if (strlen(busid) == 0) { 817816ac92eSJuergen Gross usbback_portid_remove(usbif, port); 818816ac92eSJuergen Gross } else { 819816ac92eSJuergen Gross usbback_portid_add(usbif, port, busid); 820816ac92eSJuergen Gross } 821816ac92eSJuergen Gross 822816ac92eSJuergen Gross g_free(busid); 823816ac92eSJuergen Gross } 824816ac92eSJuergen Gross 825816ac92eSJuergen Gross static void usbback_disconnect(struct XenDevice *xendev) 826816ac92eSJuergen Gross { 827816ac92eSJuergen Gross struct usbback_info *usbif; 828816ac92eSJuergen Gross unsigned int i; 829816ac92eSJuergen Gross 830816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 831816ac92eSJuergen Gross 832816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 833816ac92eSJuergen Gross 83465807f4bSEmil Condrea xen_pv_unbind_evtchn(xendev); 835816ac92eSJuergen Gross 836816ac92eSJuergen Gross if (usbif->urb_sring) { 837816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbif->urb_sring, 1); 838816ac92eSJuergen Gross usbif->urb_sring = NULL; 839816ac92eSJuergen Gross } 840816ac92eSJuergen Gross if (usbif->conn_sring) { 841816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbif->conn_sring, 1); 842816ac92eSJuergen Gross usbif->conn_sring = NULL; 843816ac92eSJuergen Gross } 844816ac92eSJuergen Gross 845816ac92eSJuergen Gross for (i = 0; i < usbif->num_ports; i++) { 84680440ea0SJuergen Gross if (usbif->ports[i].dev) { 84780440ea0SJuergen Gross usbback_portid_drain(usbif, i + 1); 848816ac92eSJuergen Gross } 849816ac92eSJuergen Gross } 850816ac92eSJuergen Gross 851816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 852816ac92eSJuergen Gross } 853816ac92eSJuergen Gross 854816ac92eSJuergen Gross static int usbback_connect(struct XenDevice *xendev) 855816ac92eSJuergen Gross { 856816ac92eSJuergen Gross struct usbback_info *usbif; 857816ac92eSJuergen Gross struct usbif_urb_sring *urb_sring; 858816ac92eSJuergen Gross struct usbif_conn_sring *conn_sring; 859816ac92eSJuergen Gross int urb_ring_ref; 860816ac92eSJuergen Gross int conn_ring_ref; 861816ac92eSJuergen Gross unsigned int i; 862816ac92eSJuergen Gross 863816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 864816ac92eSJuergen Gross 865816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 866816ac92eSJuergen Gross 867816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { 86896c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n"); 869816ac92eSJuergen Gross return -1; 870816ac92eSJuergen Gross } 871816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { 87296c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n"); 873816ac92eSJuergen Gross return -1; 874816ac92eSJuergen Gross } 875816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { 87696c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading event-channel\n"); 877816ac92eSJuergen Gross return -1; 878816ac92eSJuergen Gross } 879816ac92eSJuergen Gross 880816ac92eSJuergen Gross usbif->urb_sring = xengnttab_map_grant_ref(xendev->gnttabdev, xendev->dom, 881816ac92eSJuergen Gross urb_ring_ref, 882816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 883816ac92eSJuergen Gross usbif->conn_sring = xengnttab_map_grant_ref(xendev->gnttabdev, xendev->dom, 884816ac92eSJuergen Gross conn_ring_ref, 885816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 886816ac92eSJuergen Gross if (!usbif->urb_sring || !usbif->conn_sring) { 88796c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error mapping rings\n"); 888816ac92eSJuergen Gross usbback_disconnect(xendev); 889816ac92eSJuergen Gross return -1; 890816ac92eSJuergen Gross } 891816ac92eSJuergen Gross 892816ac92eSJuergen Gross urb_sring = usbif->urb_sring; 893816ac92eSJuergen Gross conn_sring = usbif->conn_sring; 894816ac92eSJuergen Gross BACK_RING_INIT(&usbif->urb_ring, urb_sring, XC_PAGE_SIZE); 895816ac92eSJuergen Gross BACK_RING_INIT(&usbif->conn_ring, conn_sring, XC_PAGE_SIZE); 896816ac92eSJuergen Gross 897816ac92eSJuergen Gross xen_be_bind_evtchn(xendev); 898816ac92eSJuergen Gross 89996c77dbaSEmil Condrea xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " 900816ac92eSJuergen Gross "remote port %d, local port %d\n", urb_ring_ref, 901816ac92eSJuergen Gross conn_ring_ref, xendev->remote_port, xendev->local_port); 902816ac92eSJuergen Gross 903816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 904816ac92eSJuergen Gross if (usbif->ports[i - 1].dev) { 905816ac92eSJuergen Gross usbback_hotplug_enq(usbif, i); 906816ac92eSJuergen Gross } 907816ac92eSJuergen Gross } 908816ac92eSJuergen Gross 909816ac92eSJuergen Gross return 0; 910816ac92eSJuergen Gross } 911816ac92eSJuergen Gross 912816ac92eSJuergen Gross static void usbback_backend_changed(struct XenDevice *xendev, const char *node) 913816ac92eSJuergen Gross { 914816ac92eSJuergen Gross struct usbback_info *usbif; 915816ac92eSJuergen Gross unsigned int i; 916816ac92eSJuergen Gross 917816ac92eSJuergen Gross TR_BUS(xendev, "path %s\n", node); 918816ac92eSJuergen Gross 919816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 920816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 921816ac92eSJuergen Gross usbback_process_port(usbif, i); 922816ac92eSJuergen Gross } 923816ac92eSJuergen Gross } 924816ac92eSJuergen Gross 925816ac92eSJuergen Gross static int usbback_init(struct XenDevice *xendev) 926816ac92eSJuergen Gross { 927816ac92eSJuergen Gross struct usbback_info *usbif; 928816ac92eSJuergen Gross 929816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 930816ac92eSJuergen Gross 931816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 932816ac92eSJuergen Gross 933816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || 934816ac92eSJuergen Gross usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { 93596c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n"); 936816ac92eSJuergen Gross return -1; 937816ac92eSJuergen Gross } 938816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || 939816ac92eSJuergen Gross (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { 94096c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); 941816ac92eSJuergen Gross return -1; 942816ac92eSJuergen Gross } 943816ac92eSJuergen Gross 944816ac92eSJuergen Gross usbback_backend_changed(xendev, "port"); 945816ac92eSJuergen Gross 946816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 947816ac92eSJuergen Gross 948816ac92eSJuergen Gross return 0; 949816ac92eSJuergen Gross } 950816ac92eSJuergen Gross 951816ac92eSJuergen Gross static void xen_bus_attach(USBPort *port) 952816ac92eSJuergen Gross { 953816ac92eSJuergen Gross struct usbback_info *usbif; 954816ac92eSJuergen Gross 955816ac92eSJuergen Gross usbif = port->opaque; 956816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 957816ac92eSJuergen Gross usbif->ports[port->index].attached = true; 958816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port->index + 1); 959816ac92eSJuergen Gross } 960816ac92eSJuergen Gross 961816ac92eSJuergen Gross static void xen_bus_detach(USBPort *port) 962816ac92eSJuergen Gross { 963816ac92eSJuergen Gross struct usbback_info *usbif; 964816ac92eSJuergen Gross 965816ac92eSJuergen Gross usbif = port->opaque; 966816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 96780440ea0SJuergen Gross usbback_portid_detach(usbif, port->index + 1); 968816ac92eSJuergen Gross } 969816ac92eSJuergen Gross 970816ac92eSJuergen Gross static void xen_bus_child_detach(USBPort *port, USBDevice *child) 971816ac92eSJuergen Gross { 972816ac92eSJuergen Gross struct usbback_info *usbif; 973816ac92eSJuergen Gross 974816ac92eSJuergen Gross usbif = port->opaque; 975816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 976816ac92eSJuergen Gross } 977816ac92eSJuergen Gross 978816ac92eSJuergen Gross static void xen_bus_complete(USBPort *port, USBPacket *packet) 979816ac92eSJuergen Gross { 98080440ea0SJuergen Gross struct usbback_req *usbback_req; 981816ac92eSJuergen Gross struct usbback_info *usbif; 982816ac92eSJuergen Gross 98380440ea0SJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 98480440ea0SJuergen Gross if (usbback_req->cancelled) { 98580440ea0SJuergen Gross g_free(usbback_req); 98680440ea0SJuergen Gross return; 98780440ea0SJuergen Gross } 98880440ea0SJuergen Gross 98980440ea0SJuergen Gross usbif = usbback_req->usbif; 990816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "\n"); 991816ac92eSJuergen Gross usbback_packet_complete(packet); 992816ac92eSJuergen Gross } 993816ac92eSJuergen Gross 994816ac92eSJuergen Gross static USBPortOps xen_usb_port_ops = { 995816ac92eSJuergen Gross .attach = xen_bus_attach, 996816ac92eSJuergen Gross .detach = xen_bus_detach, 997816ac92eSJuergen Gross .child_detach = xen_bus_child_detach, 998816ac92eSJuergen Gross .complete = xen_bus_complete, 999816ac92eSJuergen Gross }; 1000816ac92eSJuergen Gross 1001816ac92eSJuergen Gross static USBBusOps xen_usb_bus_ops = { 1002816ac92eSJuergen Gross }; 1003816ac92eSJuergen Gross 1004816ac92eSJuergen Gross static void usbback_alloc(struct XenDevice *xendev) 1005816ac92eSJuergen Gross { 1006816ac92eSJuergen Gross struct usbback_info *usbif; 1007816ac92eSJuergen Gross USBPort *p; 1008816ac92eSJuergen Gross unsigned int i, max_grants; 1009816ac92eSJuergen Gross 1010816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1011816ac92eSJuergen Gross 1012f1784a22SJuergen Gross usb_bus_new(&usbif->bus, sizeof(usbif->bus), &xen_usb_bus_ops, 1013f1784a22SJuergen Gross DEVICE(&xendev->qdev)); 1014816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1015816ac92eSJuergen Gross p = &(usbif->ports[i].port); 1016816ac92eSJuergen Gross usb_register_port(&usbif->bus, p, usbif, i, &xen_usb_port_ops, 1017816ac92eSJuergen Gross USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL | 1018816ac92eSJuergen Gross USB_SPEED_MASK_HIGH); 1019816ac92eSJuergen Gross } 1020816ac92eSJuergen Gross 1021816ac92eSJuergen Gross QTAILQ_INIT(&usbif->req_free_q); 1022816ac92eSJuergen Gross QSIMPLEQ_INIT(&usbif->hotplug_q); 1023816ac92eSJuergen Gross usbif->bh = qemu_bh_new(usbback_bh, usbif); 1024816ac92eSJuergen Gross 1025816ac92eSJuergen Gross /* max_grants: for each request and for the rings (request and connect). */ 1026816ac92eSJuergen Gross max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; 1027816ac92eSJuergen Gross if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) { 102896c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", 1029816ac92eSJuergen Gross strerror(errno)); 1030816ac92eSJuergen Gross } 1031816ac92eSJuergen Gross } 1032816ac92eSJuergen Gross 1033816ac92eSJuergen Gross static int usbback_free(struct XenDevice *xendev) 1034816ac92eSJuergen Gross { 1035816ac92eSJuergen Gross struct usbback_info *usbif; 1036816ac92eSJuergen Gross struct usbback_req *usbback_req; 1037816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 1038816ac92eSJuergen Gross unsigned int i; 1039816ac92eSJuergen Gross 1040816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 1041816ac92eSJuergen Gross 1042816ac92eSJuergen Gross usbback_disconnect(xendev); 1043816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1044816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 1045816ac92eSJuergen Gross usbback_portid_remove(usbif, i); 1046816ac92eSJuergen Gross } 1047816ac92eSJuergen Gross 1048816ac92eSJuergen Gross while (!QTAILQ_EMPTY(&usbif->req_free_q)) { 1049816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 1050816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 1051816ac92eSJuergen Gross g_free(usbback_req); 1052816ac92eSJuergen Gross } 1053816ac92eSJuergen Gross while (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 1054816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 1055816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 1056816ac92eSJuergen Gross g_free(usb_hp); 1057816ac92eSJuergen Gross } 1058816ac92eSJuergen Gross 1059816ac92eSJuergen Gross qemu_bh_delete(usbif->bh); 1060816ac92eSJuergen Gross 1061816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1062816ac92eSJuergen Gross usb_unregister_port(&usbif->bus, &(usbif->ports[i].port)); 1063816ac92eSJuergen Gross } 1064816ac92eSJuergen Gross 1065816ac92eSJuergen Gross usb_bus_release(&usbif->bus); 1066816ac92eSJuergen Gross 1067816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 1068816ac92eSJuergen Gross 1069816ac92eSJuergen Gross return 0; 1070816ac92eSJuergen Gross } 1071816ac92eSJuergen Gross 1072816ac92eSJuergen Gross static void usbback_event(struct XenDevice *xendev) 1073816ac92eSJuergen Gross { 1074816ac92eSJuergen Gross struct usbback_info *usbif; 1075816ac92eSJuergen Gross 1076816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1077816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 1078816ac92eSJuergen Gross } 1079816ac92eSJuergen Gross 1080816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1081816ac92eSJuergen Gross .size = sizeof(struct usbback_info), 1082816ac92eSJuergen Gross .flags = DEVOPS_FLAG_NEED_GNTDEV, 1083816ac92eSJuergen Gross .init = usbback_init, 1084816ac92eSJuergen Gross .alloc = usbback_alloc, 1085816ac92eSJuergen Gross .free = usbback_free, 1086816ac92eSJuergen Gross .backend_changed = usbback_backend_changed, 1087816ac92eSJuergen Gross .initialise = usbback_connect, 1088816ac92eSJuergen Gross .disconnect = usbback_disconnect, 1089816ac92eSJuergen Gross .event = usbback_event, 1090816ac92eSJuergen Gross }; 1091816ac92eSJuergen Gross 1092816ac92eSJuergen Gross #else /* USBIF_SHORT_NOT_OK */ 1093816ac92eSJuergen Gross 1094816ac92eSJuergen Gross static int usbback_not_supported(void) 1095816ac92eSJuergen Gross { 1096816ac92eSJuergen Gross return -EINVAL; 1097816ac92eSJuergen Gross } 1098816ac92eSJuergen Gross 1099816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1100816ac92eSJuergen Gross .backend_register = usbback_not_supported, 1101816ac92eSJuergen Gross }; 1102816ac92eSJuergen Gross 1103816ac92eSJuergen Gross #endif 1104