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; 75*b58deb34SPaolo 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 { 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; 111*b58deb34SPaolo Bonzini QTAILQ_HEAD(, usbback_req) req_free_q; 112*b58deb34SPaolo Bonzini QSIMPLEQ_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 } 17658560f2aSPaul Durrant usbback_req->buffer = 17758560f2aSPaul Durrant xen_be_map_grant_refs(xendev, ref, usbback_req->nr_buffer_segs, 17858560f2aSPaul Durrant prot); 179816ac92eSJuergen Gross 180816ac92eSJuergen Gross if (!usbback_req->buffer) { 181816ac92eSJuergen Gross return -ENOMEM; 182816ac92eSJuergen Gross } 183816ac92eSJuergen Gross 184816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_buffer_segs; i++) { 185816ac92eSJuergen Gross seg = usbback_req->req.seg + i; 186c6d25aa6SStefano Stabellini addr = usbback_req->buffer + i * XC_PAGE_SIZE + seg->offset; 187816ac92eSJuergen Gross qemu_iovec_add(&usbback_req->packet.iov, addr, seg->length); 188816ac92eSJuergen Gross } 189816ac92eSJuergen Gross } 190816ac92eSJuergen Gross 191816ac92eSJuergen Gross if (!usbif_pipeisoc(usbback_req->req.pipe)) { 192816ac92eSJuergen Gross return 0; 193816ac92eSJuergen Gross } 194816ac92eSJuergen Gross 195816ac92eSJuergen Gross /* 196816ac92eSJuergen Gross * Right now isoc requests are not supported. 197816ac92eSJuergen Gross * Prepare supporting those by doing the work needed on the guest 198816ac92eSJuergen Gross * interface side. 199816ac92eSJuergen Gross */ 200816ac92eSJuergen Gross 201816ac92eSJuergen Gross if (!usbback_req->nr_extra_segs) { 20296c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "iso request without descriptor segments\n"); 203816ac92eSJuergen Gross return -EINVAL; 204816ac92eSJuergen Gross } 205816ac92eSJuergen Gross 206816ac92eSJuergen Gross prot = PROT_READ | PROT_WRITE; 207816ac92eSJuergen Gross for (i = 0; i < usbback_req->nr_extra_segs; i++) { 208816ac92eSJuergen Gross ref[i] = usbback_req->req.seg[i + usbback_req->req.nr_buffer_segs].gref; 209816ac92eSJuergen Gross } 21058560f2aSPaul Durrant usbback_req->isoc_buffer = 21158560f2aSPaul Durrant xen_be_map_grant_refs(xendev, ref, usbback_req->nr_extra_segs, 21258560f2aSPaul Durrant prot); 213816ac92eSJuergen Gross 214816ac92eSJuergen Gross if (!usbback_req->isoc_buffer) { 215816ac92eSJuergen Gross return -ENOMEM; 216816ac92eSJuergen Gross } 217816ac92eSJuergen Gross 218816ac92eSJuergen Gross return 0; 219816ac92eSJuergen Gross } 220816ac92eSJuergen Gross 221816ac92eSJuergen Gross static int usbback_init_packet(struct usbback_req *usbback_req) 222816ac92eSJuergen Gross { 223816ac92eSJuergen Gross struct XenDevice *xendev = &usbback_req->usbif->xendev; 224816ac92eSJuergen Gross USBPacket *packet = &usbback_req->packet; 225816ac92eSJuergen Gross USBDevice *dev = usbback_req->stub->dev; 226816ac92eSJuergen Gross USBEndpoint *ep; 227816ac92eSJuergen Gross unsigned int pid, ep_nr; 228816ac92eSJuergen Gross bool sok; 229816ac92eSJuergen Gross int ret = 0; 230816ac92eSJuergen Gross 231816ac92eSJuergen Gross qemu_iovec_init(&packet->iov, USBIF_MAX_SEGMENTS_PER_REQUEST); 232816ac92eSJuergen Gross pid = usbif_pipein(usbback_req->req.pipe) ? USB_TOKEN_IN : USB_TOKEN_OUT; 233816ac92eSJuergen Gross ep_nr = usbif_pipeendpoint(usbback_req->req.pipe); 234816ac92eSJuergen Gross sok = !!(usbback_req->req.transfer_flags & USBIF_SHORT_NOT_OK); 235816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 236816ac92eSJuergen Gross ep_nr = 0; 237816ac92eSJuergen Gross sok = false; 238816ac92eSJuergen Gross } 239816ac92eSJuergen Gross ep = usb_ep_get(dev, pid, ep_nr); 240816ac92eSJuergen Gross usb_packet_setup(packet, pid, ep, 0, 1, sok, true); 241816ac92eSJuergen Gross 242816ac92eSJuergen Gross switch (usbif_pipetype(usbback_req->req.pipe)) { 243816ac92eSJuergen Gross case USBIF_PIPE_TYPE_ISOC: 244816ac92eSJuergen Gross TR_REQ(xendev, "iso transfer %s: buflen: %x, %d frames\n", 245816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 246816ac92eSJuergen Gross usbback_req->req.buffer_length, 247816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs); 248816ac92eSJuergen Gross ret = -EINVAL; /* isoc not implemented yet */ 249816ac92eSJuergen Gross break; 250816ac92eSJuergen Gross 251816ac92eSJuergen Gross case USBIF_PIPE_TYPE_INT: 252816ac92eSJuergen Gross TR_REQ(xendev, "int transfer %s: buflen: %x\n", 253816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 254816ac92eSJuergen Gross usbback_req->req.buffer_length); 255816ac92eSJuergen Gross break; 256816ac92eSJuergen Gross 257816ac92eSJuergen Gross case USBIF_PIPE_TYPE_CTRL: 258816ac92eSJuergen Gross packet->parameter = *(uint64_t *)usbback_req->req.u.ctrl; 259042ec47eSAnthony PERARD TR_REQ(xendev, "ctrl parameter: %"PRIx64", buflen: %x\n", 260042ec47eSAnthony PERARD packet->parameter, 261816ac92eSJuergen Gross usbback_req->req.buffer_length); 262816ac92eSJuergen Gross break; 263816ac92eSJuergen Gross 264816ac92eSJuergen Gross case USBIF_PIPE_TYPE_BULK: 265816ac92eSJuergen Gross TR_REQ(xendev, "bulk transfer %s: buflen: %x\n", 266816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 267816ac92eSJuergen Gross usbback_req->req.buffer_length); 268816ac92eSJuergen Gross break; 269816ac92eSJuergen Gross default: 270816ac92eSJuergen Gross ret = -EINVAL; 271816ac92eSJuergen Gross break; 272816ac92eSJuergen Gross } 273816ac92eSJuergen Gross 274816ac92eSJuergen Gross return ret; 275816ac92eSJuergen Gross } 276816ac92eSJuergen Gross 277816ac92eSJuergen Gross static void usbback_do_response(struct usbback_req *usbback_req, int32_t status, 278816ac92eSJuergen Gross int32_t actual_length, int32_t error_count) 279816ac92eSJuergen Gross { 280816ac92eSJuergen Gross struct usbback_info *usbif; 281816ac92eSJuergen Gross struct usbif_urb_response *res; 282816ac92eSJuergen Gross struct XenDevice *xendev; 283816ac92eSJuergen Gross unsigned int notify; 284816ac92eSJuergen Gross 285816ac92eSJuergen Gross usbif = usbback_req->usbif; 286816ac92eSJuergen Gross xendev = &usbif->xendev; 287816ac92eSJuergen Gross 288816ac92eSJuergen Gross TR_REQ(xendev, "id %d, status %d, length %d, errcnt %d\n", 289816ac92eSJuergen Gross usbback_req->req.id, status, actual_length, error_count); 290816ac92eSJuergen Gross 291816ac92eSJuergen Gross if (usbback_req->packet.iov.iov) { 292816ac92eSJuergen Gross qemu_iovec_destroy(&usbback_req->packet.iov); 293816ac92eSJuergen Gross } 294816ac92eSJuergen Gross 295816ac92eSJuergen Gross if (usbback_req->buffer) { 29658560f2aSPaul Durrant xen_be_unmap_grant_refs(xendev, usbback_req->buffer, 297816ac92eSJuergen Gross usbback_req->nr_buffer_segs); 298816ac92eSJuergen Gross usbback_req->buffer = NULL; 299816ac92eSJuergen Gross } 300816ac92eSJuergen Gross 301816ac92eSJuergen Gross if (usbback_req->isoc_buffer) { 30258560f2aSPaul Durrant xen_be_unmap_grant_refs(xendev, usbback_req->isoc_buffer, 303816ac92eSJuergen Gross usbback_req->nr_extra_segs); 304816ac92eSJuergen Gross usbback_req->isoc_buffer = NULL; 305816ac92eSJuergen Gross } 306816ac92eSJuergen Gross 30780440ea0SJuergen Gross if (usbif->urb_sring) { 308816ac92eSJuergen Gross res = RING_GET_RESPONSE(&usbif->urb_ring, usbif->urb_ring.rsp_prod_pvt); 309816ac92eSJuergen Gross res->id = usbback_req->req.id; 310816ac92eSJuergen Gross res->status = status; 311816ac92eSJuergen Gross res->actual_length = actual_length; 312816ac92eSJuergen Gross res->error_count = error_count; 313816ac92eSJuergen Gross res->start_frame = 0; 314816ac92eSJuergen Gross usbif->urb_ring.rsp_prod_pvt++; 315816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&usbif->urb_ring, notify); 316816ac92eSJuergen Gross 317816ac92eSJuergen Gross if (notify) { 318ba18fa2aSEmil Condrea xen_pv_send_notify(xendev); 319816ac92eSJuergen Gross } 32080440ea0SJuergen Gross } 321816ac92eSJuergen Gross 32280440ea0SJuergen Gross if (!usbback_req->cancelled) 323816ac92eSJuergen Gross usbback_put_req(usbback_req); 324816ac92eSJuergen Gross } 325816ac92eSJuergen Gross 326816ac92eSJuergen Gross static void usbback_do_response_ret(struct usbback_req *usbback_req, 327816ac92eSJuergen Gross int32_t status) 328816ac92eSJuergen Gross { 329816ac92eSJuergen Gross usbback_do_response(usbback_req, status, 0, 0); 330816ac92eSJuergen Gross } 331816ac92eSJuergen Gross 332816ac92eSJuergen Gross static int32_t usbback_xlat_status(int status) 333816ac92eSJuergen Gross { 334816ac92eSJuergen Gross switch (status) { 335816ac92eSJuergen Gross case USB_RET_SUCCESS: 336816ac92eSJuergen Gross return 0; 337816ac92eSJuergen Gross case USB_RET_NODEV: 338816ac92eSJuergen Gross return -ENODEV; 339816ac92eSJuergen Gross case USB_RET_STALL: 340816ac92eSJuergen Gross return -EPIPE; 341816ac92eSJuergen Gross case USB_RET_BABBLE: 342816ac92eSJuergen Gross return -EOVERFLOW; 343816ac92eSJuergen Gross case USB_RET_IOERROR: 344816ac92eSJuergen Gross return -EPROTO; 345816ac92eSJuergen Gross } 346816ac92eSJuergen Gross 347816ac92eSJuergen Gross return -ESHUTDOWN; 348816ac92eSJuergen Gross } 349816ac92eSJuergen Gross 350816ac92eSJuergen Gross static void usbback_packet_complete(USBPacket *packet) 351816ac92eSJuergen Gross { 352816ac92eSJuergen Gross struct usbback_req *usbback_req; 353816ac92eSJuergen Gross int32_t status; 354816ac92eSJuergen Gross 355816ac92eSJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 356816ac92eSJuergen Gross 357816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 358816ac92eSJuergen Gross 359816ac92eSJuergen Gross status = usbback_xlat_status(packet->status); 360816ac92eSJuergen Gross usbback_do_response(usbback_req, status, packet->actual_length, 0); 361816ac92eSJuergen Gross } 362816ac92eSJuergen Gross 363816ac92eSJuergen Gross static void usbback_set_address(struct usbback_info *usbif, 364816ac92eSJuergen Gross struct usbback_stub *stub, 365816ac92eSJuergen Gross unsigned int cur_addr, unsigned int new_addr) 366816ac92eSJuergen Gross { 367816ac92eSJuergen Gross if (cur_addr) { 368816ac92eSJuergen Gross usbif->addr_table[cur_addr] = NULL; 369816ac92eSJuergen Gross } 370816ac92eSJuergen Gross if (new_addr) { 371816ac92eSJuergen Gross usbif->addr_table[new_addr] = stub; 372816ac92eSJuergen Gross } 373816ac92eSJuergen Gross } 374816ac92eSJuergen Gross 37580440ea0SJuergen Gross static void usbback_cancel_req(struct usbback_req *usbback_req) 376816ac92eSJuergen Gross { 377816ac92eSJuergen Gross if (usb_packet_is_inflight(&usbback_req->packet)) { 378816ac92eSJuergen Gross usb_cancel_packet(&usbback_req->packet); 37980440ea0SJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 38080440ea0SJuergen Gross usbback_req->cancelled = true; 38180440ea0SJuergen Gross usbback_do_response_ret(usbback_req, -EPROTO); 382816ac92eSJuergen Gross } 383816ac92eSJuergen Gross } 384816ac92eSJuergen Gross 385816ac92eSJuergen Gross static void usbback_process_unlink_req(struct usbback_req *usbback_req) 386816ac92eSJuergen Gross { 387816ac92eSJuergen Gross struct usbback_info *usbif; 388816ac92eSJuergen Gross struct usbback_req *unlink_req; 389816ac92eSJuergen Gross unsigned int id, devnum; 390816ac92eSJuergen Gross int ret; 391816ac92eSJuergen Gross 392816ac92eSJuergen Gross usbif = usbback_req->usbif; 393816ac92eSJuergen Gross ret = 0; 394816ac92eSJuergen Gross id = usbback_req->req.u.unlink.unlink_id; 395816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "unlink id %d\n", id); 396816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 397816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 398816ac92eSJuergen Gross usbback_req->stub = usbif->ports + 39980440ea0SJuergen Gross usbif_pipeportnum(usbback_req->req.pipe) - 1; 400816ac92eSJuergen Gross if (unlikely(!usbback_req->stub)) { 401816ac92eSJuergen Gross ret = -ENODEV; 402816ac92eSJuergen Gross goto fail_response; 403816ac92eSJuergen Gross } 404816ac92eSJuergen Gross } else { 405816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 406816ac92eSJuergen Gross ret = -ENODEV; 407816ac92eSJuergen Gross goto fail_response; 408816ac92eSJuergen Gross } 409816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 410816ac92eSJuergen Gross } 411816ac92eSJuergen Gross 412816ac92eSJuergen Gross QTAILQ_FOREACH(unlink_req, &usbback_req->stub->submit_q, q) { 413816ac92eSJuergen Gross if (unlink_req->req.id == id) { 41480440ea0SJuergen Gross usbback_cancel_req(unlink_req); 415816ac92eSJuergen Gross break; 416816ac92eSJuergen Gross } 417816ac92eSJuergen Gross } 418816ac92eSJuergen Gross 419816ac92eSJuergen Gross fail_response: 420816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 421816ac92eSJuergen Gross } 422816ac92eSJuergen Gross 423816ac92eSJuergen Gross /* 424816ac92eSJuergen Gross * Checks whether a request can be handled at once or should be forwarded 425816ac92eSJuergen Gross * to the usb framework. 426816ac92eSJuergen Gross * Return value is: 427816ac92eSJuergen Gross * 0 in case of usb framework is needed 428816ac92eSJuergen Gross * 1 in case of local handling (no error) 429816ac92eSJuergen Gross * The request response has been queued already if return value not 0. 430816ac92eSJuergen Gross */ 431816ac92eSJuergen Gross static int usbback_check_and_submit(struct usbback_req *usbback_req) 432816ac92eSJuergen Gross { 433816ac92eSJuergen Gross struct usbback_info *usbif; 434816ac92eSJuergen Gross unsigned int devnum; 435816ac92eSJuergen Gross struct usbback_stub *stub; 436816ac92eSJuergen Gross struct usbif_ctrlrequest *ctrl; 437816ac92eSJuergen Gross int ret; 438816ac92eSJuergen Gross uint16_t wValue; 439816ac92eSJuergen Gross 440816ac92eSJuergen Gross usbif = usbback_req->usbif; 441816ac92eSJuergen Gross stub = NULL; 442816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 443816ac92eSJuergen Gross ctrl = (struct usbif_ctrlrequest *)usbback_req->req.u.ctrl; 444816ac92eSJuergen Gross wValue = le16_to_cpu(ctrl->wValue); 445816ac92eSJuergen Gross 446816ac92eSJuergen Gross /* 447816ac92eSJuergen Gross * When the device is first connected or resetted, USB device has no 448816ac92eSJuergen Gross * address. In this initial state, following requests are sent to device 449816ac92eSJuergen Gross * address (#0), 450816ac92eSJuergen Gross * 451816ac92eSJuergen Gross * 1. GET_DESCRIPTOR (with Descriptor Type is "DEVICE") is sent, 452816ac92eSJuergen Gross * and OS knows what device is connected to. 453816ac92eSJuergen Gross * 454816ac92eSJuergen Gross * 2. SET_ADDRESS is sent, and then device has its address. 455816ac92eSJuergen Gross * 456816ac92eSJuergen Gross * In the next step, SET_CONFIGURATION is sent to addressed device, and 457816ac92eSJuergen Gross * then the device is finally ready to use. 458816ac92eSJuergen Gross */ 459816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 460816ac92eSJuergen Gross stub = usbif->ports + usbif_pipeportnum(usbback_req->req.pipe) - 1; 461816ac92eSJuergen Gross if (!stub->dev || !stub->attached) { 462816ac92eSJuergen Gross ret = -ENODEV; 463816ac92eSJuergen Gross goto do_response; 464816ac92eSJuergen Gross } 465816ac92eSJuergen Gross 466816ac92eSJuergen Gross switch (ctrl->bRequest) { 467816ac92eSJuergen Gross case USB_REQ_GET_DESCRIPTOR: 468816ac92eSJuergen Gross /* 469816ac92eSJuergen Gross * GET_DESCRIPTOR request to device #0. 470816ac92eSJuergen Gross * through normal transfer. 471816ac92eSJuergen Gross */ 472816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 GET_DESCRIPTOR\n"); 473816ac92eSJuergen Gross usbback_req->stub = stub; 474816ac92eSJuergen Gross return 0; 475816ac92eSJuergen Gross case USB_REQ_SET_ADDRESS: 476816ac92eSJuergen Gross /* 477816ac92eSJuergen Gross * SET_ADDRESS request to device #0. 478816ac92eSJuergen Gross * add attached device to addr_table. 479816ac92eSJuergen Gross */ 480816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 SET_ADDRESS\n"); 481816ac92eSJuergen Gross usbback_set_address(usbif, stub, 0, wValue); 482816ac92eSJuergen Gross ret = 0; 483816ac92eSJuergen Gross break; 484816ac92eSJuergen Gross default: 485816ac92eSJuergen Gross ret = -EINVAL; 486816ac92eSJuergen Gross break; 487816ac92eSJuergen Gross } 488816ac92eSJuergen Gross goto do_response; 489816ac92eSJuergen Gross } 490816ac92eSJuergen Gross 491816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 492816ac92eSJuergen Gross ret = -ENODEV; 493816ac92eSJuergen Gross goto do_response; 494816ac92eSJuergen Gross } 495816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 496816ac92eSJuergen Gross 497816ac92eSJuergen Gross /* 498816ac92eSJuergen Gross * Check special request 499816ac92eSJuergen Gross */ 500816ac92eSJuergen Gross if (ctrl->bRequest != USB_REQ_SET_ADDRESS) { 501816ac92eSJuergen Gross return 0; 502816ac92eSJuergen Gross } 503816ac92eSJuergen Gross 504816ac92eSJuergen Gross /* 505816ac92eSJuergen Gross * SET_ADDRESS request to addressed device. 506816ac92eSJuergen Gross * change addr or remove from addr_table. 507816ac92eSJuergen Gross */ 508816ac92eSJuergen Gross usbback_set_address(usbif, usbback_req->stub, devnum, wValue); 509816ac92eSJuergen Gross ret = 0; 510816ac92eSJuergen Gross 511816ac92eSJuergen Gross do_response: 512816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 513816ac92eSJuergen Gross return 1; 514816ac92eSJuergen Gross } 515816ac92eSJuergen Gross 516816ac92eSJuergen Gross static void usbback_dispatch(struct usbback_req *usbback_req) 517816ac92eSJuergen Gross { 518816ac92eSJuergen Gross int ret; 519816ac92eSJuergen Gross unsigned int devnum; 520816ac92eSJuergen Gross struct usbback_info *usbif; 521816ac92eSJuergen Gross 522816ac92eSJuergen Gross usbif = usbback_req->usbif; 523816ac92eSJuergen Gross 524816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "start req_id %d pipe %08x\n", usbback_req->req.id, 525816ac92eSJuergen Gross usbback_req->req.pipe); 526816ac92eSJuergen Gross 527816ac92eSJuergen Gross /* unlink request */ 528816ac92eSJuergen Gross if (unlikely(usbif_pipeunlink(usbback_req->req.pipe))) { 529816ac92eSJuergen Gross usbback_process_unlink_req(usbback_req); 530816ac92eSJuergen Gross return; 531816ac92eSJuergen Gross } 532816ac92eSJuergen Gross 533816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 534816ac92eSJuergen Gross if (usbback_check_and_submit(usbback_req)) { 535816ac92eSJuergen Gross return; 536816ac92eSJuergen Gross } 537816ac92eSJuergen Gross } else { 538816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 539816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 540816ac92eSJuergen Gross 541816ac92eSJuergen Gross if (!usbback_req->stub || !usbback_req->stub->attached) { 542816ac92eSJuergen Gross ret = -ENODEV; 543816ac92eSJuergen Gross goto fail_response; 544816ac92eSJuergen Gross } 545816ac92eSJuergen Gross } 546816ac92eSJuergen Gross 547816ac92eSJuergen Gross QTAILQ_INSERT_TAIL(&usbback_req->stub->submit_q, usbback_req, q); 548816ac92eSJuergen Gross 549816ac92eSJuergen Gross usbback_req->nr_buffer_segs = usbback_req->req.nr_buffer_segs; 550816ac92eSJuergen Gross usbback_req->nr_extra_segs = usbif_pipeisoc(usbback_req->req.pipe) ? 551816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs : 0; 552816ac92eSJuergen Gross 553816ac92eSJuergen Gross ret = usbback_init_packet(usbback_req); 554816ac92eSJuergen Gross if (ret) { 55596c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid request\n"); 556816ac92eSJuergen Gross ret = -ESHUTDOWN; 557816ac92eSJuergen Gross goto fail_free_urb; 558816ac92eSJuergen Gross } 559816ac92eSJuergen Gross 560816ac92eSJuergen Gross ret = usbback_gnttab_map(usbback_req); 561816ac92eSJuergen Gross if (ret) { 56296c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); 563816ac92eSJuergen Gross ret = -ESHUTDOWN; 564816ac92eSJuergen Gross goto fail_free_urb; 565816ac92eSJuergen Gross } 566816ac92eSJuergen Gross 567816ac92eSJuergen Gross usb_handle_packet(usbback_req->stub->dev, &usbback_req->packet); 568816ac92eSJuergen Gross if (usbback_req->packet.status != USB_RET_ASYNC) { 569816ac92eSJuergen Gross usbback_packet_complete(&usbback_req->packet); 570816ac92eSJuergen Gross } 571816ac92eSJuergen Gross return; 572816ac92eSJuergen Gross 573816ac92eSJuergen Gross fail_free_urb: 574816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 575816ac92eSJuergen Gross 576816ac92eSJuergen Gross fail_response: 577816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 578816ac92eSJuergen Gross } 579816ac92eSJuergen Gross 580816ac92eSJuergen Gross static void usbback_hotplug_notify(struct usbback_info *usbif) 581816ac92eSJuergen Gross { 582816ac92eSJuergen Gross struct usbif_conn_back_ring *ring = &usbif->conn_ring; 583816ac92eSJuergen Gross struct usbif_conn_request req; 584816ac92eSJuergen Gross struct usbif_conn_response *res; 585816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 586816ac92eSJuergen Gross unsigned int notify; 587816ac92eSJuergen Gross 588816ac92eSJuergen Gross if (!usbif->conn_sring) { 589816ac92eSJuergen Gross return; 590816ac92eSJuergen Gross } 591816ac92eSJuergen Gross 592816ac92eSJuergen Gross /* Check for full ring. */ 593816ac92eSJuergen Gross if ((RING_SIZE(ring) - ring->rsp_prod_pvt - ring->req_cons) == 0) { 594ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 595816ac92eSJuergen Gross return; 596816ac92eSJuergen Gross } 597816ac92eSJuergen Gross 598816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 599816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 600816ac92eSJuergen Gross 601816ac92eSJuergen Gross RING_COPY_REQUEST(ring, ring->req_cons, &req); 602816ac92eSJuergen Gross ring->req_cons++; 603816ac92eSJuergen Gross ring->sring->req_event = ring->req_cons + 1; 604816ac92eSJuergen Gross 605816ac92eSJuergen Gross res = RING_GET_RESPONSE(ring, ring->rsp_prod_pvt); 606816ac92eSJuergen Gross res->id = req.id; 607816ac92eSJuergen Gross res->portnum = usb_hp->port; 608816ac92eSJuergen Gross res->speed = usbif->ports[usb_hp->port - 1].speed; 609816ac92eSJuergen Gross ring->rsp_prod_pvt++; 610816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); 611816ac92eSJuergen Gross 612816ac92eSJuergen Gross if (notify) { 613ba18fa2aSEmil Condrea xen_pv_send_notify(&usbif->xendev); 614816ac92eSJuergen Gross } 615816ac92eSJuergen Gross 616816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "hotplug port %d speed %d\n", usb_hp->port, 617816ac92eSJuergen Gross res->speed); 618816ac92eSJuergen Gross 619816ac92eSJuergen Gross g_free(usb_hp); 620816ac92eSJuergen Gross 621816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 622816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 623816ac92eSJuergen Gross } 624816ac92eSJuergen Gross } 625816ac92eSJuergen Gross 626816ac92eSJuergen Gross static void usbback_bh(void *opaque) 627816ac92eSJuergen Gross { 628816ac92eSJuergen Gross struct usbback_info *usbif; 629816ac92eSJuergen Gross struct usbif_urb_back_ring *urb_ring; 630816ac92eSJuergen Gross struct usbback_req *usbback_req; 631816ac92eSJuergen Gross RING_IDX rc, rp; 632816ac92eSJuergen Gross unsigned int more_to_do; 633816ac92eSJuergen Gross 634816ac92eSJuergen Gross usbif = opaque; 635816ac92eSJuergen Gross if (usbif->ring_error) { 636816ac92eSJuergen Gross return; 637816ac92eSJuergen Gross } 638816ac92eSJuergen Gross 639816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 640816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 641816ac92eSJuergen Gross } 642816ac92eSJuergen Gross 643816ac92eSJuergen Gross urb_ring = &usbif->urb_ring; 644816ac92eSJuergen Gross rc = urb_ring->req_cons; 645816ac92eSJuergen Gross rp = urb_ring->sring->req_prod; 646816ac92eSJuergen Gross xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ 647816ac92eSJuergen Gross 648816ac92eSJuergen Gross if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { 649816ac92eSJuergen Gross rc = urb_ring->rsp_prod_pvt; 65096c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "domU provided bogus ring requests " 651816ac92eSJuergen Gross "(%#x - %#x = %u). Halting ring processing.\n", 652816ac92eSJuergen Gross rp, rc, rp - rc); 653816ac92eSJuergen Gross usbif->ring_error = true; 654816ac92eSJuergen Gross return; 655816ac92eSJuergen Gross } 656816ac92eSJuergen Gross 657816ac92eSJuergen Gross while (rc != rp) { 658816ac92eSJuergen Gross if (RING_REQUEST_CONS_OVERFLOW(urb_ring, rc)) { 659816ac92eSJuergen Gross break; 660816ac92eSJuergen Gross } 661816ac92eSJuergen Gross usbback_req = usbback_get_req(usbif); 662816ac92eSJuergen Gross 663816ac92eSJuergen Gross RING_COPY_REQUEST(urb_ring, rc, &usbback_req->req); 664816ac92eSJuergen Gross usbback_req->usbif = usbif; 665816ac92eSJuergen Gross 666816ac92eSJuergen Gross usbback_dispatch(usbback_req); 667816ac92eSJuergen Gross 668816ac92eSJuergen Gross urb_ring->req_cons = ++rc; 669816ac92eSJuergen Gross } 670816ac92eSJuergen Gross 671816ac92eSJuergen Gross RING_FINAL_CHECK_FOR_REQUESTS(urb_ring, more_to_do); 672816ac92eSJuergen Gross if (more_to_do) { 673816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 674816ac92eSJuergen Gross } 675816ac92eSJuergen Gross } 676816ac92eSJuergen Gross 677816ac92eSJuergen Gross static void usbback_hotplug_enq(struct usbback_info *usbif, unsigned port) 678816ac92eSJuergen Gross { 679816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 680816ac92eSJuergen Gross 681816ac92eSJuergen Gross usb_hp = g_new0(struct usbback_hotplug, 1); 682816ac92eSJuergen Gross usb_hp->port = port; 683816ac92eSJuergen Gross QSIMPLEQ_INSERT_TAIL(&usbif->hotplug_q, usb_hp, q); 684816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 685816ac92eSJuergen Gross } 686816ac92eSJuergen Gross 68780440ea0SJuergen Gross static void usbback_portid_drain(struct usbback_info *usbif, unsigned port) 68880440ea0SJuergen Gross { 68980440ea0SJuergen Gross struct usbback_req *req, *tmp; 69080440ea0SJuergen Gross bool sched = false; 69180440ea0SJuergen Gross 69280440ea0SJuergen Gross QTAILQ_FOREACH_SAFE(req, &usbif->ports[port - 1].submit_q, q, tmp) { 69380440ea0SJuergen Gross usbback_cancel_req(req); 69480440ea0SJuergen Gross sched = true; 69580440ea0SJuergen Gross } 69680440ea0SJuergen Gross 69780440ea0SJuergen Gross if (sched) { 69880440ea0SJuergen Gross qemu_bh_schedule(usbif->bh); 69980440ea0SJuergen Gross } 70080440ea0SJuergen Gross } 70180440ea0SJuergen Gross 70280440ea0SJuergen Gross static void usbback_portid_detach(struct usbback_info *usbif, unsigned port) 70380440ea0SJuergen Gross { 70480440ea0SJuergen Gross if (!usbif->ports[port - 1].attached) { 70580440ea0SJuergen Gross return; 70680440ea0SJuergen Gross } 70780440ea0SJuergen Gross 70880440ea0SJuergen Gross usbif->ports[port - 1].speed = USBIF_SPEED_NONE; 70980440ea0SJuergen Gross usbif->ports[port - 1].attached = false; 71080440ea0SJuergen Gross usbback_portid_drain(usbif, port); 71180440ea0SJuergen Gross usbback_hotplug_enq(usbif, port); 71280440ea0SJuergen Gross } 71380440ea0SJuergen Gross 714816ac92eSJuergen Gross static void usbback_portid_remove(struct usbback_info *usbif, unsigned port) 715816ac92eSJuergen Gross { 716816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 717816ac92eSJuergen Gross return; 718816ac92eSJuergen Gross } 719816ac92eSJuergen Gross 720816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 721816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 72280440ea0SJuergen Gross usbback_portid_detach(usbif, port); 723816ac92eSJuergen Gross 724816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d removed\n", port); 725816ac92eSJuergen Gross } 726816ac92eSJuergen Gross 727816ac92eSJuergen Gross static void usbback_portid_add(struct usbback_info *usbif, unsigned port, 728816ac92eSJuergen Gross char *busid) 729816ac92eSJuergen Gross { 730816ac92eSJuergen Gross unsigned speed; 731816ac92eSJuergen Gross char *portname; 732816ac92eSJuergen Gross Error *local_err = NULL; 733816ac92eSJuergen Gross QDict *qdict; 734816ac92eSJuergen Gross QemuOpts *opts; 735f1784a22SJuergen Gross char *tmp; 736816ac92eSJuergen Gross 737816ac92eSJuergen Gross if (usbif->ports[port - 1].dev) { 738816ac92eSJuergen Gross return; 739816ac92eSJuergen Gross } 740816ac92eSJuergen Gross 741816ac92eSJuergen Gross portname = strchr(busid, '-'); 742816ac92eSJuergen Gross if (!portname) { 74396c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s illegal specification\n", 744816ac92eSJuergen Gross busid); 745816ac92eSJuergen Gross return; 746816ac92eSJuergen Gross } 747816ac92eSJuergen Gross portname++; 748816ac92eSJuergen Gross 749816ac92eSJuergen Gross qdict = qdict_new(); 75046f5ac20SEric Blake qdict_put_str(qdict, "driver", "usb-host"); 751f1784a22SJuergen Gross tmp = g_strdup_printf("%s.0", usbif->xendev.qdev.id); 75246f5ac20SEric Blake qdict_put_str(qdict, "bus", tmp); 753f1784a22SJuergen Gross g_free(tmp); 754f1784a22SJuergen Gross tmp = g_strdup_printf("%s-%u", usbif->xendev.qdev.id, port); 75546f5ac20SEric Blake qdict_put_str(qdict, "id", tmp); 756f1784a22SJuergen Gross g_free(tmp); 75746f5ac20SEric Blake qdict_put_int(qdict, "port", port); 75846f5ac20SEric Blake qdict_put_int(qdict, "hostbus", atoi(busid)); 75946f5ac20SEric Blake qdict_put_str(qdict, "hostport", portname); 760816ac92eSJuergen Gross opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err); 761816ac92eSJuergen Gross if (local_err) { 762816ac92eSJuergen Gross goto err; 763816ac92eSJuergen Gross } 764816ac92eSJuergen Gross usbif->ports[port - 1].dev = USB_DEVICE(qdev_device_add(opts, &local_err)); 765816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 766816ac92eSJuergen Gross goto err; 767816ac92eSJuergen Gross } 768cb3e7f08SMarc-André Lureau qobject_unref(qdict); 769816ac92eSJuergen Gross speed = usbif->ports[port - 1].dev->speed; 770816ac92eSJuergen Gross switch (speed) { 771816ac92eSJuergen Gross case USB_SPEED_LOW: 772816ac92eSJuergen Gross speed = USBIF_SPEED_LOW; 773816ac92eSJuergen Gross break; 774816ac92eSJuergen Gross case USB_SPEED_FULL: 775816ac92eSJuergen Gross speed = USBIF_SPEED_FULL; 776816ac92eSJuergen Gross break; 777816ac92eSJuergen Gross case USB_SPEED_HIGH: 778816ac92eSJuergen Gross speed = (usbif->usb_ver < USB_VER_USB20) ? 779816ac92eSJuergen Gross USBIF_SPEED_NONE : USBIF_SPEED_HIGH; 780816ac92eSJuergen Gross break; 781816ac92eSJuergen Gross default: 782816ac92eSJuergen Gross speed = USBIF_SPEED_NONE; 783816ac92eSJuergen Gross break; 784816ac92eSJuergen Gross } 785816ac92eSJuergen Gross if (speed == USBIF_SPEED_NONE) { 78696c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); 787816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 788816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 789816ac92eSJuergen Gross return; 790816ac92eSJuergen Gross } 791816ac92eSJuergen Gross usb_device_reset(usbif->ports[port - 1].dev); 792816ac92eSJuergen Gross usbif->ports[port - 1].speed = speed; 793816ac92eSJuergen Gross usbif->ports[port - 1].attached = true; 794816ac92eSJuergen Gross QTAILQ_INIT(&usbif->ports[port - 1].submit_q); 795816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port); 796816ac92eSJuergen Gross 797816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d attached\n", port); 798816ac92eSJuergen Gross return; 799816ac92eSJuergen Gross 800816ac92eSJuergen Gross err: 801cb3e7f08SMarc-André Lureau qobject_unref(qdict); 80296c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); 803816ac92eSJuergen Gross } 804816ac92eSJuergen Gross 805816ac92eSJuergen Gross static void usbback_process_port(struct usbback_info *usbif, unsigned port) 806816ac92eSJuergen Gross { 807816ac92eSJuergen Gross char node[8]; 808816ac92eSJuergen Gross char *busid; 809816ac92eSJuergen Gross 810816ac92eSJuergen Gross snprintf(node, sizeof(node), "port/%d", port); 811816ac92eSJuergen Gross busid = xenstore_read_be_str(&usbif->xendev, node); 812816ac92eSJuergen Gross if (busid == NULL) { 81396c77dbaSEmil Condrea xen_pv_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); 814816ac92eSJuergen Gross return; 815816ac92eSJuergen Gross } 816816ac92eSJuergen Gross 817816ac92eSJuergen Gross /* Remove portid, if the port is not connected. */ 818816ac92eSJuergen Gross if (strlen(busid) == 0) { 819816ac92eSJuergen Gross usbback_portid_remove(usbif, port); 820816ac92eSJuergen Gross } else { 821816ac92eSJuergen Gross usbback_portid_add(usbif, port, busid); 822816ac92eSJuergen Gross } 823816ac92eSJuergen Gross 824816ac92eSJuergen Gross g_free(busid); 825816ac92eSJuergen Gross } 826816ac92eSJuergen Gross 827816ac92eSJuergen Gross static void usbback_disconnect(struct XenDevice *xendev) 828816ac92eSJuergen Gross { 829816ac92eSJuergen Gross struct usbback_info *usbif; 830816ac92eSJuergen Gross unsigned int i; 831816ac92eSJuergen Gross 832816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 833816ac92eSJuergen Gross 834816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 835816ac92eSJuergen Gross 83665807f4bSEmil Condrea xen_pv_unbind_evtchn(xendev); 837816ac92eSJuergen Gross 838816ac92eSJuergen Gross if (usbif->urb_sring) { 83958560f2aSPaul Durrant xen_be_unmap_grant_ref(xendev, usbif->urb_sring); 840816ac92eSJuergen Gross usbif->urb_sring = NULL; 841816ac92eSJuergen Gross } 842816ac92eSJuergen Gross if (usbif->conn_sring) { 84358560f2aSPaul Durrant xen_be_unmap_grant_ref(xendev, usbif->conn_sring); 844816ac92eSJuergen Gross usbif->conn_sring = NULL; 845816ac92eSJuergen Gross } 846816ac92eSJuergen Gross 847816ac92eSJuergen Gross for (i = 0; i < usbif->num_ports; i++) { 84880440ea0SJuergen Gross if (usbif->ports[i].dev) { 84980440ea0SJuergen Gross usbback_portid_drain(usbif, i + 1); 850816ac92eSJuergen Gross } 851816ac92eSJuergen Gross } 852816ac92eSJuergen Gross 853816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 854816ac92eSJuergen Gross } 855816ac92eSJuergen Gross 856816ac92eSJuergen Gross static int usbback_connect(struct XenDevice *xendev) 857816ac92eSJuergen Gross { 858816ac92eSJuergen Gross struct usbback_info *usbif; 859816ac92eSJuergen Gross struct usbif_urb_sring *urb_sring; 860816ac92eSJuergen Gross struct usbif_conn_sring *conn_sring; 861816ac92eSJuergen Gross int urb_ring_ref; 862816ac92eSJuergen Gross int conn_ring_ref; 863f8224fb0SJuergen Gross unsigned int i, max_grants; 864816ac92eSJuergen Gross 865816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 866816ac92eSJuergen Gross 867f8224fb0SJuergen Gross /* max_grants: for each request and for the rings (request and connect). */ 868f8224fb0SJuergen Gross max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; 869f8224fb0SJuergen Gross xen_be_set_max_grant_refs(xendev, max_grants); 870f8224fb0SJuergen Gross 871816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 872816ac92eSJuergen Gross 873816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { 87496c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading urb-ring-ref\n"); 875816ac92eSJuergen Gross return -1; 876816ac92eSJuergen Gross } 877816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { 87896c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading conn-ring-ref\n"); 879816ac92eSJuergen Gross return -1; 880816ac92eSJuergen Gross } 881816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { 88296c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error reading event-channel\n"); 883816ac92eSJuergen Gross return -1; 884816ac92eSJuergen Gross } 885816ac92eSJuergen Gross 88658560f2aSPaul Durrant usbif->urb_sring = xen_be_map_grant_ref(xendev, urb_ring_ref, 887816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 88858560f2aSPaul Durrant usbif->conn_sring = xen_be_map_grant_ref(xendev, conn_ring_ref, 889816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 890816ac92eSJuergen Gross if (!usbif->urb_sring || !usbif->conn_sring) { 89196c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "error mapping rings\n"); 892816ac92eSJuergen Gross usbback_disconnect(xendev); 893816ac92eSJuergen Gross return -1; 894816ac92eSJuergen Gross } 895816ac92eSJuergen Gross 896816ac92eSJuergen Gross urb_sring = usbif->urb_sring; 897816ac92eSJuergen Gross conn_sring = usbif->conn_sring; 898816ac92eSJuergen Gross BACK_RING_INIT(&usbif->urb_ring, urb_sring, XC_PAGE_SIZE); 899816ac92eSJuergen Gross BACK_RING_INIT(&usbif->conn_ring, conn_sring, XC_PAGE_SIZE); 900816ac92eSJuergen Gross 901816ac92eSJuergen Gross xen_be_bind_evtchn(xendev); 902816ac92eSJuergen Gross 90396c77dbaSEmil Condrea xen_pv_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " 904816ac92eSJuergen Gross "remote port %d, local port %d\n", urb_ring_ref, 905816ac92eSJuergen Gross conn_ring_ref, xendev->remote_port, xendev->local_port); 906816ac92eSJuergen Gross 907816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 908816ac92eSJuergen Gross if (usbif->ports[i - 1].dev) { 909816ac92eSJuergen Gross usbback_hotplug_enq(usbif, i); 910816ac92eSJuergen Gross } 911816ac92eSJuergen Gross } 912816ac92eSJuergen Gross 913816ac92eSJuergen Gross return 0; 914816ac92eSJuergen Gross } 915816ac92eSJuergen Gross 916816ac92eSJuergen Gross static void usbback_backend_changed(struct XenDevice *xendev, const char *node) 917816ac92eSJuergen Gross { 918816ac92eSJuergen Gross struct usbback_info *usbif; 919816ac92eSJuergen Gross unsigned int i; 920816ac92eSJuergen Gross 921816ac92eSJuergen Gross TR_BUS(xendev, "path %s\n", node); 922816ac92eSJuergen Gross 923816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 924816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 925816ac92eSJuergen Gross usbback_process_port(usbif, i); 926816ac92eSJuergen Gross } 927816ac92eSJuergen Gross } 928816ac92eSJuergen Gross 929816ac92eSJuergen Gross static int usbback_init(struct XenDevice *xendev) 930816ac92eSJuergen Gross { 931816ac92eSJuergen Gross struct usbback_info *usbif; 932816ac92eSJuergen Gross 933816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 934816ac92eSJuergen Gross 935816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 936816ac92eSJuergen Gross 937816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || 938816ac92eSJuergen Gross usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { 93996c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "num-ports not readable or out of bounds\n"); 940816ac92eSJuergen Gross return -1; 941816ac92eSJuergen Gross } 942816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || 943816ac92eSJuergen Gross (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { 94496c77dbaSEmil Condrea xen_pv_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); 945816ac92eSJuergen Gross return -1; 946816ac92eSJuergen Gross } 947816ac92eSJuergen Gross 948816ac92eSJuergen Gross usbback_backend_changed(xendev, "port"); 949816ac92eSJuergen Gross 950816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 951816ac92eSJuergen Gross 952816ac92eSJuergen Gross return 0; 953816ac92eSJuergen Gross } 954816ac92eSJuergen Gross 955816ac92eSJuergen Gross static void xen_bus_attach(USBPort *port) 956816ac92eSJuergen Gross { 957816ac92eSJuergen Gross struct usbback_info *usbif; 958816ac92eSJuergen Gross 959816ac92eSJuergen Gross usbif = port->opaque; 960816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 961816ac92eSJuergen Gross usbif->ports[port->index].attached = true; 962816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port->index + 1); 963816ac92eSJuergen Gross } 964816ac92eSJuergen Gross 965816ac92eSJuergen Gross static void xen_bus_detach(USBPort *port) 966816ac92eSJuergen Gross { 967816ac92eSJuergen Gross struct usbback_info *usbif; 968816ac92eSJuergen Gross 969816ac92eSJuergen Gross usbif = port->opaque; 970816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 97180440ea0SJuergen Gross usbback_portid_detach(usbif, port->index + 1); 972816ac92eSJuergen Gross } 973816ac92eSJuergen Gross 974816ac92eSJuergen Gross static void xen_bus_child_detach(USBPort *port, USBDevice *child) 975816ac92eSJuergen Gross { 976816ac92eSJuergen Gross struct usbback_info *usbif; 977816ac92eSJuergen Gross 978816ac92eSJuergen Gross usbif = port->opaque; 979816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 980816ac92eSJuergen Gross } 981816ac92eSJuergen Gross 982816ac92eSJuergen Gross static void xen_bus_complete(USBPort *port, USBPacket *packet) 983816ac92eSJuergen Gross { 98480440ea0SJuergen Gross struct usbback_req *usbback_req; 985816ac92eSJuergen Gross struct usbback_info *usbif; 986816ac92eSJuergen Gross 98780440ea0SJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 98880440ea0SJuergen Gross if (usbback_req->cancelled) { 98980440ea0SJuergen Gross g_free(usbback_req); 99080440ea0SJuergen Gross return; 99180440ea0SJuergen Gross } 99280440ea0SJuergen Gross 99380440ea0SJuergen Gross usbif = usbback_req->usbif; 994816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "\n"); 995816ac92eSJuergen Gross usbback_packet_complete(packet); 996816ac92eSJuergen Gross } 997816ac92eSJuergen Gross 998816ac92eSJuergen Gross static USBPortOps xen_usb_port_ops = { 999816ac92eSJuergen Gross .attach = xen_bus_attach, 1000816ac92eSJuergen Gross .detach = xen_bus_detach, 1001816ac92eSJuergen Gross .child_detach = xen_bus_child_detach, 1002816ac92eSJuergen Gross .complete = xen_bus_complete, 1003816ac92eSJuergen Gross }; 1004816ac92eSJuergen Gross 1005816ac92eSJuergen Gross static USBBusOps xen_usb_bus_ops = { 1006816ac92eSJuergen Gross }; 1007816ac92eSJuergen Gross 1008816ac92eSJuergen Gross static void usbback_alloc(struct XenDevice *xendev) 1009816ac92eSJuergen Gross { 1010816ac92eSJuergen Gross struct usbback_info *usbif; 1011816ac92eSJuergen Gross USBPort *p; 1012f8224fb0SJuergen Gross unsigned int i; 1013816ac92eSJuergen Gross 1014816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1015816ac92eSJuergen Gross 1016f1784a22SJuergen Gross usb_bus_new(&usbif->bus, sizeof(usbif->bus), &xen_usb_bus_ops, 1017f1784a22SJuergen Gross DEVICE(&xendev->qdev)); 1018816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1019816ac92eSJuergen Gross p = &(usbif->ports[i].port); 1020816ac92eSJuergen Gross usb_register_port(&usbif->bus, p, usbif, i, &xen_usb_port_ops, 1021816ac92eSJuergen Gross USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL | 1022816ac92eSJuergen Gross USB_SPEED_MASK_HIGH); 1023816ac92eSJuergen Gross } 1024816ac92eSJuergen Gross 1025816ac92eSJuergen Gross QTAILQ_INIT(&usbif->req_free_q); 1026816ac92eSJuergen Gross QSIMPLEQ_INIT(&usbif->hotplug_q); 1027816ac92eSJuergen Gross usbif->bh = qemu_bh_new(usbback_bh, usbif); 1028816ac92eSJuergen Gross } 1029816ac92eSJuergen Gross 1030816ac92eSJuergen Gross static int usbback_free(struct XenDevice *xendev) 1031816ac92eSJuergen Gross { 1032816ac92eSJuergen Gross struct usbback_info *usbif; 1033816ac92eSJuergen Gross struct usbback_req *usbback_req; 1034816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 1035816ac92eSJuergen Gross unsigned int i; 1036816ac92eSJuergen Gross 1037816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 1038816ac92eSJuergen Gross 1039816ac92eSJuergen Gross usbback_disconnect(xendev); 1040816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1041816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 1042816ac92eSJuergen Gross usbback_portid_remove(usbif, i); 1043816ac92eSJuergen Gross } 1044816ac92eSJuergen Gross 1045816ac92eSJuergen Gross while (!QTAILQ_EMPTY(&usbif->req_free_q)) { 1046816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 1047816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 1048816ac92eSJuergen Gross g_free(usbback_req); 1049816ac92eSJuergen Gross } 1050816ac92eSJuergen Gross while (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 1051816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 1052816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 1053816ac92eSJuergen Gross g_free(usb_hp); 1054816ac92eSJuergen Gross } 1055816ac92eSJuergen Gross 1056816ac92eSJuergen Gross qemu_bh_delete(usbif->bh); 1057816ac92eSJuergen Gross 1058816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1059816ac92eSJuergen Gross usb_unregister_port(&usbif->bus, &(usbif->ports[i].port)); 1060816ac92eSJuergen Gross } 1061816ac92eSJuergen Gross 1062816ac92eSJuergen Gross usb_bus_release(&usbif->bus); 1063816ac92eSJuergen Gross 1064816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 1065816ac92eSJuergen Gross 1066816ac92eSJuergen Gross return 0; 1067816ac92eSJuergen Gross } 1068816ac92eSJuergen Gross 1069816ac92eSJuergen Gross static void usbback_event(struct XenDevice *xendev) 1070816ac92eSJuergen Gross { 1071816ac92eSJuergen Gross struct usbback_info *usbif; 1072816ac92eSJuergen Gross 1073816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1074816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 1075816ac92eSJuergen Gross } 1076816ac92eSJuergen Gross 1077816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1078816ac92eSJuergen Gross .size = sizeof(struct usbback_info), 1079816ac92eSJuergen Gross .flags = DEVOPS_FLAG_NEED_GNTDEV, 1080816ac92eSJuergen Gross .init = usbback_init, 1081816ac92eSJuergen Gross .alloc = usbback_alloc, 1082816ac92eSJuergen Gross .free = usbback_free, 1083816ac92eSJuergen Gross .backend_changed = usbback_backend_changed, 1084816ac92eSJuergen Gross .initialise = usbback_connect, 1085816ac92eSJuergen Gross .disconnect = usbback_disconnect, 1086816ac92eSJuergen Gross .event = usbback_event, 1087816ac92eSJuergen Gross }; 1088816ac92eSJuergen Gross 1089816ac92eSJuergen Gross #else /* USBIF_SHORT_NOT_OK */ 1090816ac92eSJuergen Gross 1091816ac92eSJuergen Gross static int usbback_not_supported(void) 1092816ac92eSJuergen Gross { 1093816ac92eSJuergen Gross return -EINVAL; 1094816ac92eSJuergen Gross } 1095816ac92eSJuergen Gross 1096816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1097816ac92eSJuergen Gross .backend_register = usbback_not_supported, 1098816ac92eSJuergen Gross }; 1099816ac92eSJuergen Gross 1100816ac92eSJuergen Gross #endif 1101