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" 23*b1b23e5bSPeter Maydell #include <libusb.h> 24*b1b23e5bSPeter Maydell #include <sys/mman.h> 25*b1b23e5bSPeter Maydell 26816ac92eSJuergen Gross #include "qemu-common.h" 27816ac92eSJuergen Gross #include "qemu/config-file.h" 28816ac92eSJuergen Gross #include "hw/sysbus.h" 29816ac92eSJuergen Gross #include "hw/usb.h" 30816ac92eSJuergen Gross #include "hw/xen/xen_backend.h" 31816ac92eSJuergen Gross #include "monitor/qdev.h" 32816ac92eSJuergen Gross #include "qapi/qmp/qbool.h" 33816ac92eSJuergen Gross #include "qapi/qmp/qint.h" 34816ac92eSJuergen Gross #include "qapi/qmp/qstring.h" 35816ac92eSJuergen Gross #include "sys/user.h" 36816ac92eSJuergen Gross 37816ac92eSJuergen Gross #include <xen/io/ring.h> 38816ac92eSJuergen Gross #include <xen/io/usbif.h> 39816ac92eSJuergen Gross 40816ac92eSJuergen Gross /* 41816ac92eSJuergen Gross * Check for required support of usbif.h: USBIF_SHORT_NOT_OK was the last 42816ac92eSJuergen Gross * macro added we rely on. 43816ac92eSJuergen Gross */ 44816ac92eSJuergen Gross #ifdef USBIF_SHORT_NOT_OK 45816ac92eSJuergen Gross 46816ac92eSJuergen Gross #define TR(xendev, lvl, fmt, args...) \ 47816ac92eSJuergen Gross { \ 48816ac92eSJuergen Gross struct timeval tv; \ 49816ac92eSJuergen Gross \ 50816ac92eSJuergen Gross gettimeofday(&tv, NULL); \ 51816ac92eSJuergen Gross xen_be_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \ 52816ac92eSJuergen Gross tv.tv_sec, tv.tv_usec, __func__, ##args); \ 53816ac92eSJuergen Gross } 54816ac92eSJuergen Gross #define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args) 55816ac92eSJuergen Gross #define TR_REQ(xendev, fmt, args...) TR(xendev, 3, fmt, ##args) 56816ac92eSJuergen Gross 57816ac92eSJuergen Gross #define USBBACK_MAXPORTS USBIF_PIPE_PORT_MASK 58816ac92eSJuergen Gross #define USB_DEV_ADDR_SIZE (USBIF_PIPE_DEV_MASK + 1) 59816ac92eSJuergen Gross 60816ac92eSJuergen Gross /* USB wire protocol: structure describing control request parameter. */ 61816ac92eSJuergen Gross struct usbif_ctrlrequest { 62816ac92eSJuergen Gross uint8_t bRequestType; 63816ac92eSJuergen Gross uint8_t bRequest; 64816ac92eSJuergen Gross uint16_t wValue; 65816ac92eSJuergen Gross uint16_t wIndex; 66816ac92eSJuergen Gross uint16_t wLength; 67816ac92eSJuergen Gross }; 68816ac92eSJuergen Gross 69816ac92eSJuergen Gross struct usbback_info; 70816ac92eSJuergen Gross struct usbback_req; 71816ac92eSJuergen Gross 72816ac92eSJuergen Gross struct usbback_stub { 73816ac92eSJuergen Gross USBDevice *dev; 74816ac92eSJuergen Gross USBPort port; 75816ac92eSJuergen Gross unsigned int speed; 76816ac92eSJuergen Gross bool attached; 77816ac92eSJuergen Gross QTAILQ_HEAD(submit_q_head, usbback_req) submit_q; 78816ac92eSJuergen Gross }; 79816ac92eSJuergen Gross 80816ac92eSJuergen Gross struct usbback_req { 81816ac92eSJuergen Gross struct usbback_info *usbif; 82816ac92eSJuergen Gross struct usbback_stub *stub; 83816ac92eSJuergen Gross struct usbif_urb_request req; 84816ac92eSJuergen Gross USBPacket packet; 85816ac92eSJuergen Gross 86816ac92eSJuergen Gross unsigned int nr_buffer_segs; /* # of transfer_buffer segments */ 87816ac92eSJuergen Gross unsigned int nr_extra_segs; /* # of iso_frame_desc segments */ 88816ac92eSJuergen Gross 89816ac92eSJuergen Gross QTAILQ_ENTRY(usbback_req) q; 90816ac92eSJuergen Gross 91816ac92eSJuergen Gross void *buffer; 92816ac92eSJuergen Gross void *isoc_buffer; 93816ac92eSJuergen Gross struct libusb_transfer *xfer; 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) { 155816ac92eSJuergen Gross xen_be_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 + 162816ac92eSJuergen Gross (unsigned)usbback_req->req.seg[i].length > PAGE_SIZE) { 163816ac92eSJuergen Gross xen_be_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; 185816ac92eSJuergen Gross addr = usbback_req->buffer + i * 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) { 201816ac92eSJuergen Gross xen_be_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; 257816ac92eSJuergen Gross TR_REQ(xendev, "ctrl parameter: %lx, buflen: %x\n", packet->parameter, 258816ac92eSJuergen Gross usbback_req->req.buffer_length); 259816ac92eSJuergen Gross break; 260816ac92eSJuergen Gross 261816ac92eSJuergen Gross case USBIF_PIPE_TYPE_BULK: 262816ac92eSJuergen Gross TR_REQ(xendev, "bulk transfer %s: buflen: %x\n", 263816ac92eSJuergen Gross (pid == USB_TOKEN_IN) ? "in" : "out", 264816ac92eSJuergen Gross usbback_req->req.buffer_length); 265816ac92eSJuergen Gross break; 266816ac92eSJuergen Gross default: 267816ac92eSJuergen Gross ret = -EINVAL; 268816ac92eSJuergen Gross break; 269816ac92eSJuergen Gross } 270816ac92eSJuergen Gross 271816ac92eSJuergen Gross return ret; 272816ac92eSJuergen Gross } 273816ac92eSJuergen Gross 274816ac92eSJuergen Gross static void usbback_do_response(struct usbback_req *usbback_req, int32_t status, 275816ac92eSJuergen Gross int32_t actual_length, int32_t error_count) 276816ac92eSJuergen Gross { 277816ac92eSJuergen Gross struct usbback_info *usbif; 278816ac92eSJuergen Gross struct usbif_urb_response *res; 279816ac92eSJuergen Gross struct XenDevice *xendev; 280816ac92eSJuergen Gross unsigned int notify; 281816ac92eSJuergen Gross 282816ac92eSJuergen Gross usbif = usbback_req->usbif; 283816ac92eSJuergen Gross xendev = &usbif->xendev; 284816ac92eSJuergen Gross 285816ac92eSJuergen Gross TR_REQ(xendev, "id %d, status %d, length %d, errcnt %d\n", 286816ac92eSJuergen Gross usbback_req->req.id, status, actual_length, error_count); 287816ac92eSJuergen Gross 288816ac92eSJuergen Gross if (usbback_req->packet.iov.iov) { 289816ac92eSJuergen Gross qemu_iovec_destroy(&usbback_req->packet.iov); 290816ac92eSJuergen Gross } 291816ac92eSJuergen Gross 292816ac92eSJuergen Gross if (usbback_req->buffer) { 293816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbback_req->buffer, 294816ac92eSJuergen Gross usbback_req->nr_buffer_segs); 295816ac92eSJuergen Gross usbback_req->buffer = NULL; 296816ac92eSJuergen Gross } 297816ac92eSJuergen Gross 298816ac92eSJuergen Gross if (usbback_req->isoc_buffer) { 299816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbback_req->isoc_buffer, 300816ac92eSJuergen Gross usbback_req->nr_extra_segs); 301816ac92eSJuergen Gross usbback_req->isoc_buffer = NULL; 302816ac92eSJuergen Gross } 303816ac92eSJuergen Gross 304816ac92eSJuergen Gross res = RING_GET_RESPONSE(&usbif->urb_ring, usbif->urb_ring.rsp_prod_pvt); 305816ac92eSJuergen Gross res->id = usbback_req->req.id; 306816ac92eSJuergen Gross res->status = status; 307816ac92eSJuergen Gross res->actual_length = actual_length; 308816ac92eSJuergen Gross res->error_count = error_count; 309816ac92eSJuergen Gross res->start_frame = 0; 310816ac92eSJuergen Gross usbif->urb_ring.rsp_prod_pvt++; 311816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&usbif->urb_ring, notify); 312816ac92eSJuergen Gross 313816ac92eSJuergen Gross if (notify) { 314816ac92eSJuergen Gross xen_be_send_notify(xendev); 315816ac92eSJuergen Gross } 316816ac92eSJuergen Gross 317816ac92eSJuergen Gross usbback_put_req(usbback_req); 318816ac92eSJuergen Gross } 319816ac92eSJuergen Gross 320816ac92eSJuergen Gross static void usbback_do_response_ret(struct usbback_req *usbback_req, 321816ac92eSJuergen Gross int32_t status) 322816ac92eSJuergen Gross { 323816ac92eSJuergen Gross usbback_do_response(usbback_req, status, 0, 0); 324816ac92eSJuergen Gross } 325816ac92eSJuergen Gross 326816ac92eSJuergen Gross static int32_t usbback_xlat_status(int status) 327816ac92eSJuergen Gross { 328816ac92eSJuergen Gross switch (status) { 329816ac92eSJuergen Gross case USB_RET_SUCCESS: 330816ac92eSJuergen Gross return 0; 331816ac92eSJuergen Gross case USB_RET_NODEV: 332816ac92eSJuergen Gross return -ENODEV; 333816ac92eSJuergen Gross case USB_RET_STALL: 334816ac92eSJuergen Gross return -EPIPE; 335816ac92eSJuergen Gross case USB_RET_BABBLE: 336816ac92eSJuergen Gross return -EOVERFLOW; 337816ac92eSJuergen Gross case USB_RET_IOERROR: 338816ac92eSJuergen Gross return -EPROTO; 339816ac92eSJuergen Gross } 340816ac92eSJuergen Gross 341816ac92eSJuergen Gross return -ESHUTDOWN; 342816ac92eSJuergen Gross } 343816ac92eSJuergen Gross 344816ac92eSJuergen Gross static void usbback_packet_complete(USBPacket *packet) 345816ac92eSJuergen Gross { 346816ac92eSJuergen Gross struct usbback_req *usbback_req; 347816ac92eSJuergen Gross int32_t status; 348816ac92eSJuergen Gross 349816ac92eSJuergen Gross usbback_req = container_of(packet, struct usbback_req, packet); 350816ac92eSJuergen Gross 351816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 352816ac92eSJuergen Gross 353816ac92eSJuergen Gross status = usbback_xlat_status(packet->status); 354816ac92eSJuergen Gross usbback_do_response(usbback_req, status, packet->actual_length, 0); 355816ac92eSJuergen Gross } 356816ac92eSJuergen Gross 357816ac92eSJuergen Gross static void usbback_set_address(struct usbback_info *usbif, 358816ac92eSJuergen Gross struct usbback_stub *stub, 359816ac92eSJuergen Gross unsigned int cur_addr, unsigned int new_addr) 360816ac92eSJuergen Gross { 361816ac92eSJuergen Gross if (cur_addr) { 362816ac92eSJuergen Gross usbif->addr_table[cur_addr] = NULL; 363816ac92eSJuergen Gross } 364816ac92eSJuergen Gross if (new_addr) { 365816ac92eSJuergen Gross usbif->addr_table[new_addr] = stub; 366816ac92eSJuergen Gross } 367816ac92eSJuergen Gross } 368816ac92eSJuergen Gross 369816ac92eSJuergen Gross static bool usbback_cancel_req(struct usbback_req *usbback_req) 370816ac92eSJuergen Gross { 371816ac92eSJuergen Gross bool ret = false; 372816ac92eSJuergen Gross 373816ac92eSJuergen Gross if (usb_packet_is_inflight(&usbback_req->packet)) { 374816ac92eSJuergen Gross usb_cancel_packet(&usbback_req->packet); 375816ac92eSJuergen Gross ret = true; 376816ac92eSJuergen Gross } 377816ac92eSJuergen Gross return ret; 378816ac92eSJuergen Gross } 379816ac92eSJuergen Gross 380816ac92eSJuergen Gross static void usbback_process_unlink_req(struct usbback_req *usbback_req) 381816ac92eSJuergen Gross { 382816ac92eSJuergen Gross struct usbback_info *usbif; 383816ac92eSJuergen Gross struct usbback_req *unlink_req; 384816ac92eSJuergen Gross unsigned int id, devnum; 385816ac92eSJuergen Gross int ret; 386816ac92eSJuergen Gross 387816ac92eSJuergen Gross usbif = usbback_req->usbif; 388816ac92eSJuergen Gross ret = 0; 389816ac92eSJuergen Gross id = usbback_req->req.u.unlink.unlink_id; 390816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "unlink id %d\n", id); 391816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 392816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 393816ac92eSJuergen Gross usbback_req->stub = usbif->ports + 394816ac92eSJuergen Gross usbif_pipeportnum(usbback_req->req.pipe); 395816ac92eSJuergen Gross if (unlikely(!usbback_req->stub)) { 396816ac92eSJuergen Gross ret = -ENODEV; 397816ac92eSJuergen Gross goto fail_response; 398816ac92eSJuergen Gross } 399816ac92eSJuergen Gross } else { 400816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 401816ac92eSJuergen Gross ret = -ENODEV; 402816ac92eSJuergen Gross goto fail_response; 403816ac92eSJuergen Gross } 404816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 405816ac92eSJuergen Gross } 406816ac92eSJuergen Gross 407816ac92eSJuergen Gross QTAILQ_FOREACH(unlink_req, &usbback_req->stub->submit_q, q) { 408816ac92eSJuergen Gross if (unlink_req->req.id == id) { 409816ac92eSJuergen Gross if (usbback_cancel_req(unlink_req)) { 410816ac92eSJuergen Gross usbback_do_response_ret(unlink_req, -EPROTO); 411816ac92eSJuergen Gross } 412816ac92eSJuergen Gross break; 413816ac92eSJuergen Gross } 414816ac92eSJuergen Gross } 415816ac92eSJuergen Gross 416816ac92eSJuergen Gross fail_response: 417816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 418816ac92eSJuergen Gross } 419816ac92eSJuergen Gross 420816ac92eSJuergen Gross /* 421816ac92eSJuergen Gross * Checks whether a request can be handled at once or should be forwarded 422816ac92eSJuergen Gross * to the usb framework. 423816ac92eSJuergen Gross * Return value is: 424816ac92eSJuergen Gross * 0 in case of usb framework is needed 425816ac92eSJuergen Gross * 1 in case of local handling (no error) 426816ac92eSJuergen Gross * The request response has been queued already if return value not 0. 427816ac92eSJuergen Gross */ 428816ac92eSJuergen Gross static int usbback_check_and_submit(struct usbback_req *usbback_req) 429816ac92eSJuergen Gross { 430816ac92eSJuergen Gross struct usbback_info *usbif; 431816ac92eSJuergen Gross unsigned int devnum; 432816ac92eSJuergen Gross struct usbback_stub *stub; 433816ac92eSJuergen Gross struct usbif_ctrlrequest *ctrl; 434816ac92eSJuergen Gross int ret; 435816ac92eSJuergen Gross uint16_t wValue; 436816ac92eSJuergen Gross 437816ac92eSJuergen Gross usbif = usbback_req->usbif; 438816ac92eSJuergen Gross stub = NULL; 439816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 440816ac92eSJuergen Gross ctrl = (struct usbif_ctrlrequest *)usbback_req->req.u.ctrl; 441816ac92eSJuergen Gross wValue = le16_to_cpu(ctrl->wValue); 442816ac92eSJuergen Gross 443816ac92eSJuergen Gross /* 444816ac92eSJuergen Gross * When the device is first connected or resetted, USB device has no 445816ac92eSJuergen Gross * address. In this initial state, following requests are sent to device 446816ac92eSJuergen Gross * address (#0), 447816ac92eSJuergen Gross * 448816ac92eSJuergen Gross * 1. GET_DESCRIPTOR (with Descriptor Type is "DEVICE") is sent, 449816ac92eSJuergen Gross * and OS knows what device is connected to. 450816ac92eSJuergen Gross * 451816ac92eSJuergen Gross * 2. SET_ADDRESS is sent, and then device has its address. 452816ac92eSJuergen Gross * 453816ac92eSJuergen Gross * In the next step, SET_CONFIGURATION is sent to addressed device, and 454816ac92eSJuergen Gross * then the device is finally ready to use. 455816ac92eSJuergen Gross */ 456816ac92eSJuergen Gross if (unlikely(devnum == 0)) { 457816ac92eSJuergen Gross stub = usbif->ports + usbif_pipeportnum(usbback_req->req.pipe) - 1; 458816ac92eSJuergen Gross if (!stub->dev || !stub->attached) { 459816ac92eSJuergen Gross ret = -ENODEV; 460816ac92eSJuergen Gross goto do_response; 461816ac92eSJuergen Gross } 462816ac92eSJuergen Gross 463816ac92eSJuergen Gross switch (ctrl->bRequest) { 464816ac92eSJuergen Gross case USB_REQ_GET_DESCRIPTOR: 465816ac92eSJuergen Gross /* 466816ac92eSJuergen Gross * GET_DESCRIPTOR request to device #0. 467816ac92eSJuergen Gross * through normal transfer. 468816ac92eSJuergen Gross */ 469816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 GET_DESCRIPTOR\n"); 470816ac92eSJuergen Gross usbback_req->stub = stub; 471816ac92eSJuergen Gross return 0; 472816ac92eSJuergen Gross case USB_REQ_SET_ADDRESS: 473816ac92eSJuergen Gross /* 474816ac92eSJuergen Gross * SET_ADDRESS request to device #0. 475816ac92eSJuergen Gross * add attached device to addr_table. 476816ac92eSJuergen Gross */ 477816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "devnum 0 SET_ADDRESS\n"); 478816ac92eSJuergen Gross usbback_set_address(usbif, stub, 0, wValue); 479816ac92eSJuergen Gross ret = 0; 480816ac92eSJuergen Gross break; 481816ac92eSJuergen Gross default: 482816ac92eSJuergen Gross ret = -EINVAL; 483816ac92eSJuergen Gross break; 484816ac92eSJuergen Gross } 485816ac92eSJuergen Gross goto do_response; 486816ac92eSJuergen Gross } 487816ac92eSJuergen Gross 488816ac92eSJuergen Gross if (unlikely(!usbif->addr_table[devnum])) { 489816ac92eSJuergen Gross ret = -ENODEV; 490816ac92eSJuergen Gross goto do_response; 491816ac92eSJuergen Gross } 492816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 493816ac92eSJuergen Gross 494816ac92eSJuergen Gross /* 495816ac92eSJuergen Gross * Check special request 496816ac92eSJuergen Gross */ 497816ac92eSJuergen Gross if (ctrl->bRequest != USB_REQ_SET_ADDRESS) { 498816ac92eSJuergen Gross return 0; 499816ac92eSJuergen Gross } 500816ac92eSJuergen Gross 501816ac92eSJuergen Gross /* 502816ac92eSJuergen Gross * SET_ADDRESS request to addressed device. 503816ac92eSJuergen Gross * change addr or remove from addr_table. 504816ac92eSJuergen Gross */ 505816ac92eSJuergen Gross usbback_set_address(usbif, usbback_req->stub, devnum, wValue); 506816ac92eSJuergen Gross ret = 0; 507816ac92eSJuergen Gross 508816ac92eSJuergen Gross do_response: 509816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 510816ac92eSJuergen Gross return 1; 511816ac92eSJuergen Gross } 512816ac92eSJuergen Gross 513816ac92eSJuergen Gross static void usbback_dispatch(struct usbback_req *usbback_req) 514816ac92eSJuergen Gross { 515816ac92eSJuergen Gross int ret; 516816ac92eSJuergen Gross unsigned int devnum; 517816ac92eSJuergen Gross struct usbback_info *usbif; 518816ac92eSJuergen Gross 519816ac92eSJuergen Gross usbif = usbback_req->usbif; 520816ac92eSJuergen Gross 521816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "start req_id %d pipe %08x\n", usbback_req->req.id, 522816ac92eSJuergen Gross usbback_req->req.pipe); 523816ac92eSJuergen Gross 524816ac92eSJuergen Gross /* unlink request */ 525816ac92eSJuergen Gross if (unlikely(usbif_pipeunlink(usbback_req->req.pipe))) { 526816ac92eSJuergen Gross usbback_process_unlink_req(usbback_req); 527816ac92eSJuergen Gross return; 528816ac92eSJuergen Gross } 529816ac92eSJuergen Gross 530816ac92eSJuergen Gross if (usbif_pipectrl(usbback_req->req.pipe)) { 531816ac92eSJuergen Gross if (usbback_check_and_submit(usbback_req)) { 532816ac92eSJuergen Gross return; 533816ac92eSJuergen Gross } 534816ac92eSJuergen Gross } else { 535816ac92eSJuergen Gross devnum = usbif_pipedevice(usbback_req->req.pipe); 536816ac92eSJuergen Gross usbback_req->stub = usbif->addr_table[devnum]; 537816ac92eSJuergen Gross 538816ac92eSJuergen Gross if (!usbback_req->stub || !usbback_req->stub->attached) { 539816ac92eSJuergen Gross ret = -ENODEV; 540816ac92eSJuergen Gross goto fail_response; 541816ac92eSJuergen Gross } 542816ac92eSJuergen Gross } 543816ac92eSJuergen Gross 544816ac92eSJuergen Gross QTAILQ_INSERT_TAIL(&usbback_req->stub->submit_q, usbback_req, q); 545816ac92eSJuergen Gross 546816ac92eSJuergen Gross usbback_req->nr_buffer_segs = usbback_req->req.nr_buffer_segs; 547816ac92eSJuergen Gross usbback_req->nr_extra_segs = usbif_pipeisoc(usbback_req->req.pipe) ? 548816ac92eSJuergen Gross usbback_req->req.u.isoc.nr_frame_desc_segs : 0; 549816ac92eSJuergen Gross 550816ac92eSJuergen Gross ret = usbback_init_packet(usbback_req); 551816ac92eSJuergen Gross if (ret) { 552816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "invalid request\n"); 553816ac92eSJuergen Gross ret = -ESHUTDOWN; 554816ac92eSJuergen Gross goto fail_free_urb; 555816ac92eSJuergen Gross } 556816ac92eSJuergen Gross 557816ac92eSJuergen Gross ret = usbback_gnttab_map(usbback_req); 558816ac92eSJuergen Gross if (ret) { 559816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "invalid buffer, ret=%d\n", ret); 560816ac92eSJuergen Gross ret = -ESHUTDOWN; 561816ac92eSJuergen Gross goto fail_free_urb; 562816ac92eSJuergen Gross } 563816ac92eSJuergen Gross 564816ac92eSJuergen Gross usb_handle_packet(usbback_req->stub->dev, &usbback_req->packet); 565816ac92eSJuergen Gross if (usbback_req->packet.status != USB_RET_ASYNC) { 566816ac92eSJuergen Gross usbback_packet_complete(&usbback_req->packet); 567816ac92eSJuergen Gross } 568816ac92eSJuergen Gross return; 569816ac92eSJuergen Gross 570816ac92eSJuergen Gross fail_free_urb: 571816ac92eSJuergen Gross QTAILQ_REMOVE(&usbback_req->stub->submit_q, usbback_req, q); 572816ac92eSJuergen Gross 573816ac92eSJuergen Gross fail_response: 574816ac92eSJuergen Gross usbback_do_response_ret(usbback_req, ret); 575816ac92eSJuergen Gross } 576816ac92eSJuergen Gross 577816ac92eSJuergen Gross static void usbback_hotplug_notify(struct usbback_info *usbif) 578816ac92eSJuergen Gross { 579816ac92eSJuergen Gross struct usbif_conn_back_ring *ring = &usbif->conn_ring; 580816ac92eSJuergen Gross struct usbif_conn_request req; 581816ac92eSJuergen Gross struct usbif_conn_response *res; 582816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 583816ac92eSJuergen Gross unsigned int notify; 584816ac92eSJuergen Gross 585816ac92eSJuergen Gross if (!usbif->conn_sring) { 586816ac92eSJuergen Gross return; 587816ac92eSJuergen Gross } 588816ac92eSJuergen Gross 589816ac92eSJuergen Gross /* Check for full ring. */ 590816ac92eSJuergen Gross if ((RING_SIZE(ring) - ring->rsp_prod_pvt - ring->req_cons) == 0) { 591816ac92eSJuergen Gross xen_be_send_notify(&usbif->xendev); 592816ac92eSJuergen Gross return; 593816ac92eSJuergen Gross } 594816ac92eSJuergen Gross 595816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 596816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 597816ac92eSJuergen Gross 598816ac92eSJuergen Gross RING_COPY_REQUEST(ring, ring->req_cons, &req); 599816ac92eSJuergen Gross ring->req_cons++; 600816ac92eSJuergen Gross ring->sring->req_event = ring->req_cons + 1; 601816ac92eSJuergen Gross 602816ac92eSJuergen Gross res = RING_GET_RESPONSE(ring, ring->rsp_prod_pvt); 603816ac92eSJuergen Gross res->id = req.id; 604816ac92eSJuergen Gross res->portnum = usb_hp->port; 605816ac92eSJuergen Gross res->speed = usbif->ports[usb_hp->port - 1].speed; 606816ac92eSJuergen Gross ring->rsp_prod_pvt++; 607816ac92eSJuergen Gross RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring, notify); 608816ac92eSJuergen Gross 609816ac92eSJuergen Gross if (notify) { 610816ac92eSJuergen Gross xen_be_send_notify(&usbif->xendev); 611816ac92eSJuergen Gross } 612816ac92eSJuergen Gross 613816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "hotplug port %d speed %d\n", usb_hp->port, 614816ac92eSJuergen Gross res->speed); 615816ac92eSJuergen Gross 616816ac92eSJuergen Gross g_free(usb_hp); 617816ac92eSJuergen Gross 618816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 619816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 620816ac92eSJuergen Gross } 621816ac92eSJuergen Gross } 622816ac92eSJuergen Gross 623816ac92eSJuergen Gross static void usbback_bh(void *opaque) 624816ac92eSJuergen Gross { 625816ac92eSJuergen Gross struct usbback_info *usbif; 626816ac92eSJuergen Gross struct usbif_urb_back_ring *urb_ring; 627816ac92eSJuergen Gross struct usbback_req *usbback_req; 628816ac92eSJuergen Gross RING_IDX rc, rp; 629816ac92eSJuergen Gross unsigned int more_to_do; 630816ac92eSJuergen Gross 631816ac92eSJuergen Gross usbif = opaque; 632816ac92eSJuergen Gross if (usbif->ring_error) { 633816ac92eSJuergen Gross return; 634816ac92eSJuergen Gross } 635816ac92eSJuergen Gross 636816ac92eSJuergen Gross if (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 637816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 638816ac92eSJuergen Gross } 639816ac92eSJuergen Gross 640816ac92eSJuergen Gross urb_ring = &usbif->urb_ring; 641816ac92eSJuergen Gross rc = urb_ring->req_cons; 642816ac92eSJuergen Gross rp = urb_ring->sring->req_prod; 643816ac92eSJuergen Gross xen_rmb(); /* Ensure we see queued requests up to 'rp'. */ 644816ac92eSJuergen Gross 645816ac92eSJuergen Gross if (RING_REQUEST_PROD_OVERFLOW(urb_ring, rp)) { 646816ac92eSJuergen Gross rc = urb_ring->rsp_prod_pvt; 647816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "domU provided bogus ring requests " 648816ac92eSJuergen Gross "(%#x - %#x = %u). Halting ring processing.\n", 649816ac92eSJuergen Gross rp, rc, rp - rc); 650816ac92eSJuergen Gross usbif->ring_error = true; 651816ac92eSJuergen Gross return; 652816ac92eSJuergen Gross } 653816ac92eSJuergen Gross 654816ac92eSJuergen Gross while (rc != rp) { 655816ac92eSJuergen Gross if (RING_REQUEST_CONS_OVERFLOW(urb_ring, rc)) { 656816ac92eSJuergen Gross break; 657816ac92eSJuergen Gross } 658816ac92eSJuergen Gross usbback_req = usbback_get_req(usbif); 659816ac92eSJuergen Gross 660816ac92eSJuergen Gross RING_COPY_REQUEST(urb_ring, rc, &usbback_req->req); 661816ac92eSJuergen Gross usbback_req->usbif = usbif; 662816ac92eSJuergen Gross 663816ac92eSJuergen Gross usbback_dispatch(usbback_req); 664816ac92eSJuergen Gross 665816ac92eSJuergen Gross urb_ring->req_cons = ++rc; 666816ac92eSJuergen Gross } 667816ac92eSJuergen Gross 668816ac92eSJuergen Gross RING_FINAL_CHECK_FOR_REQUESTS(urb_ring, more_to_do); 669816ac92eSJuergen Gross if (more_to_do) { 670816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 671816ac92eSJuergen Gross } 672816ac92eSJuergen Gross } 673816ac92eSJuergen Gross 674816ac92eSJuergen Gross static void usbback_hotplug_enq(struct usbback_info *usbif, unsigned port) 675816ac92eSJuergen Gross { 676816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 677816ac92eSJuergen Gross 678816ac92eSJuergen Gross usb_hp = g_new0(struct usbback_hotplug, 1); 679816ac92eSJuergen Gross usb_hp->port = port; 680816ac92eSJuergen Gross QSIMPLEQ_INSERT_TAIL(&usbif->hotplug_q, usb_hp, q); 681816ac92eSJuergen Gross usbback_hotplug_notify(usbif); 682816ac92eSJuergen Gross } 683816ac92eSJuergen Gross 684816ac92eSJuergen Gross static void usbback_portid_remove(struct usbback_info *usbif, unsigned port) 685816ac92eSJuergen Gross { 686816ac92eSJuergen Gross USBPort *p; 687816ac92eSJuergen Gross 688816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 689816ac92eSJuergen Gross return; 690816ac92eSJuergen Gross } 691816ac92eSJuergen Gross 692816ac92eSJuergen Gross p = &(usbif->ports[port - 1].port); 693816ac92eSJuergen Gross snprintf(p->path, sizeof(p->path), "%d", 99); 694816ac92eSJuergen Gross 695816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 696816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 697816ac92eSJuergen Gross usbif->ports[port - 1].speed = USBIF_SPEED_NONE; 698816ac92eSJuergen Gross usbif->ports[port - 1].attached = false; 699816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port); 700816ac92eSJuergen Gross 701816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d removed\n", port); 702816ac92eSJuergen Gross } 703816ac92eSJuergen Gross 704816ac92eSJuergen Gross static void usbback_portid_add(struct usbback_info *usbif, unsigned port, 705816ac92eSJuergen Gross char *busid) 706816ac92eSJuergen Gross { 707816ac92eSJuergen Gross unsigned speed; 708816ac92eSJuergen Gross char *portname; 709816ac92eSJuergen Gross USBPort *p; 710816ac92eSJuergen Gross Error *local_err = NULL; 711816ac92eSJuergen Gross QDict *qdict; 712816ac92eSJuergen Gross QemuOpts *opts; 713816ac92eSJuergen Gross 714816ac92eSJuergen Gross if (usbif->ports[port - 1].dev) { 715816ac92eSJuergen Gross return; 716816ac92eSJuergen Gross } 717816ac92eSJuergen Gross 718816ac92eSJuergen Gross portname = strchr(busid, '-'); 719816ac92eSJuergen Gross if (!portname) { 720816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "device %s illegal specification\n", 721816ac92eSJuergen Gross busid); 722816ac92eSJuergen Gross return; 723816ac92eSJuergen Gross } 724816ac92eSJuergen Gross portname++; 725816ac92eSJuergen Gross p = &(usbif->ports[port - 1].port); 726816ac92eSJuergen Gross snprintf(p->path, sizeof(p->path), "%s", portname); 727816ac92eSJuergen Gross 728816ac92eSJuergen Gross qdict = qdict_new(); 729816ac92eSJuergen Gross qdict_put(qdict, "driver", qstring_from_str("usb-host")); 730816ac92eSJuergen Gross qdict_put(qdict, "hostbus", qint_from_int(atoi(busid))); 731816ac92eSJuergen Gross qdict_put(qdict, "hostport", qstring_from_str(portname)); 732816ac92eSJuergen Gross opts = qemu_opts_from_qdict(qemu_find_opts("device"), qdict, &local_err); 733816ac92eSJuergen Gross if (local_err) { 734816ac92eSJuergen Gross goto err; 735816ac92eSJuergen Gross } 736816ac92eSJuergen Gross usbif->ports[port - 1].dev = USB_DEVICE(qdev_device_add(opts, &local_err)); 737816ac92eSJuergen Gross if (!usbif->ports[port - 1].dev) { 738816ac92eSJuergen Gross goto err; 739816ac92eSJuergen Gross } 740816ac92eSJuergen Gross QDECREF(qdict); 741816ac92eSJuergen Gross snprintf(p->path, sizeof(p->path), "%d", port); 742816ac92eSJuergen Gross speed = usbif->ports[port - 1].dev->speed; 743816ac92eSJuergen Gross switch (speed) { 744816ac92eSJuergen Gross case USB_SPEED_LOW: 745816ac92eSJuergen Gross speed = USBIF_SPEED_LOW; 746816ac92eSJuergen Gross break; 747816ac92eSJuergen Gross case USB_SPEED_FULL: 748816ac92eSJuergen Gross speed = USBIF_SPEED_FULL; 749816ac92eSJuergen Gross break; 750816ac92eSJuergen Gross case USB_SPEED_HIGH: 751816ac92eSJuergen Gross speed = (usbif->usb_ver < USB_VER_USB20) ? 752816ac92eSJuergen Gross USBIF_SPEED_NONE : USBIF_SPEED_HIGH; 753816ac92eSJuergen Gross break; 754816ac92eSJuergen Gross default: 755816ac92eSJuergen Gross speed = USBIF_SPEED_NONE; 756816ac92eSJuergen Gross break; 757816ac92eSJuergen Gross } 758816ac92eSJuergen Gross if (speed == USBIF_SPEED_NONE) { 759816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "device %s wrong speed\n", busid); 760816ac92eSJuergen Gross object_unparent(OBJECT(usbif->ports[port - 1].dev)); 761816ac92eSJuergen Gross usbif->ports[port - 1].dev = NULL; 762816ac92eSJuergen Gross return; 763816ac92eSJuergen Gross } 764816ac92eSJuergen Gross usb_device_reset(usbif->ports[port - 1].dev); 765816ac92eSJuergen Gross usbif->ports[port - 1].speed = speed; 766816ac92eSJuergen Gross usbif->ports[port - 1].attached = true; 767816ac92eSJuergen Gross QTAILQ_INIT(&usbif->ports[port - 1].submit_q); 768816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port); 769816ac92eSJuergen Gross 770816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "port %d attached\n", port); 771816ac92eSJuergen Gross return; 772816ac92eSJuergen Gross 773816ac92eSJuergen Gross err: 774816ac92eSJuergen Gross QDECREF(qdict); 775816ac92eSJuergen Gross snprintf(p->path, sizeof(p->path), "%d", 99); 776816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "device %s could not be opened\n", busid); 777816ac92eSJuergen Gross } 778816ac92eSJuergen Gross 779816ac92eSJuergen Gross static void usbback_process_port(struct usbback_info *usbif, unsigned port) 780816ac92eSJuergen Gross { 781816ac92eSJuergen Gross char node[8]; 782816ac92eSJuergen Gross char *busid; 783816ac92eSJuergen Gross 784816ac92eSJuergen Gross snprintf(node, sizeof(node), "port/%d", port); 785816ac92eSJuergen Gross busid = xenstore_read_be_str(&usbif->xendev, node); 786816ac92eSJuergen Gross if (busid == NULL) { 787816ac92eSJuergen Gross xen_be_printf(&usbif->xendev, 0, "xenstore_read %s failed\n", node); 788816ac92eSJuergen Gross return; 789816ac92eSJuergen Gross } 790816ac92eSJuergen Gross 791816ac92eSJuergen Gross /* Remove portid, if the port is not connected. */ 792816ac92eSJuergen Gross if (strlen(busid) == 0) { 793816ac92eSJuergen Gross usbback_portid_remove(usbif, port); 794816ac92eSJuergen Gross } else { 795816ac92eSJuergen Gross usbback_portid_add(usbif, port, busid); 796816ac92eSJuergen Gross } 797816ac92eSJuergen Gross 798816ac92eSJuergen Gross g_free(busid); 799816ac92eSJuergen Gross } 800816ac92eSJuergen Gross 801816ac92eSJuergen Gross static void usbback_disconnect(struct XenDevice *xendev) 802816ac92eSJuergen Gross { 803816ac92eSJuergen Gross struct usbback_info *usbif; 804816ac92eSJuergen Gross struct usbback_req *req, *tmp; 805816ac92eSJuergen Gross unsigned int i; 806816ac92eSJuergen Gross 807816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 808816ac92eSJuergen Gross 809816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 810816ac92eSJuergen Gross 811816ac92eSJuergen Gross xen_be_unbind_evtchn(xendev); 812816ac92eSJuergen Gross 813816ac92eSJuergen Gross if (usbif->urb_sring) { 814816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbif->urb_sring, 1); 815816ac92eSJuergen Gross usbif->urb_sring = NULL; 816816ac92eSJuergen Gross } 817816ac92eSJuergen Gross if (usbif->conn_sring) { 818816ac92eSJuergen Gross xengnttab_unmap(xendev->gnttabdev, usbif->conn_sring, 1); 819816ac92eSJuergen Gross usbif->conn_sring = NULL; 820816ac92eSJuergen Gross } 821816ac92eSJuergen Gross 822816ac92eSJuergen Gross for (i = 0; i < usbif->num_ports; i++) { 823816ac92eSJuergen Gross if (!usbif->ports[i].dev) { 824816ac92eSJuergen Gross continue; 825816ac92eSJuergen Gross } 826816ac92eSJuergen Gross QTAILQ_FOREACH_SAFE(req, &usbif->ports[i].submit_q, q, tmp) { 827816ac92eSJuergen Gross usbback_cancel_req(req); 828816ac92eSJuergen Gross } 829816ac92eSJuergen Gross } 830816ac92eSJuergen Gross 831816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 832816ac92eSJuergen Gross } 833816ac92eSJuergen Gross 834816ac92eSJuergen Gross static int usbback_connect(struct XenDevice *xendev) 835816ac92eSJuergen Gross { 836816ac92eSJuergen Gross struct usbback_info *usbif; 837816ac92eSJuergen Gross struct usbif_urb_sring *urb_sring; 838816ac92eSJuergen Gross struct usbif_conn_sring *conn_sring; 839816ac92eSJuergen Gross int urb_ring_ref; 840816ac92eSJuergen Gross int conn_ring_ref; 841816ac92eSJuergen Gross unsigned int i; 842816ac92eSJuergen Gross 843816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 844816ac92eSJuergen Gross 845816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 846816ac92eSJuergen Gross 847816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "urb-ring-ref", &urb_ring_ref)) { 848816ac92eSJuergen Gross xen_be_printf(xendev, 0, "error reading urb-ring-ref\n"); 849816ac92eSJuergen Gross return -1; 850816ac92eSJuergen Gross } 851816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "conn-ring-ref", &conn_ring_ref)) { 852816ac92eSJuergen Gross xen_be_printf(xendev, 0, "error reading conn-ring-ref\n"); 853816ac92eSJuergen Gross return -1; 854816ac92eSJuergen Gross } 855816ac92eSJuergen Gross if (xenstore_read_fe_int(xendev, "event-channel", &xendev->remote_port)) { 856816ac92eSJuergen Gross xen_be_printf(xendev, 0, "error reading event-channel\n"); 857816ac92eSJuergen Gross return -1; 858816ac92eSJuergen Gross } 859816ac92eSJuergen Gross 860816ac92eSJuergen Gross usbif->urb_sring = xengnttab_map_grant_ref(xendev->gnttabdev, xendev->dom, 861816ac92eSJuergen Gross urb_ring_ref, 862816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 863816ac92eSJuergen Gross usbif->conn_sring = xengnttab_map_grant_ref(xendev->gnttabdev, xendev->dom, 864816ac92eSJuergen Gross conn_ring_ref, 865816ac92eSJuergen Gross PROT_READ | PROT_WRITE); 866816ac92eSJuergen Gross if (!usbif->urb_sring || !usbif->conn_sring) { 867816ac92eSJuergen Gross xen_be_printf(xendev, 0, "error mapping rings\n"); 868816ac92eSJuergen Gross usbback_disconnect(xendev); 869816ac92eSJuergen Gross return -1; 870816ac92eSJuergen Gross } 871816ac92eSJuergen Gross 872816ac92eSJuergen Gross urb_sring = usbif->urb_sring; 873816ac92eSJuergen Gross conn_sring = usbif->conn_sring; 874816ac92eSJuergen Gross BACK_RING_INIT(&usbif->urb_ring, urb_sring, XC_PAGE_SIZE); 875816ac92eSJuergen Gross BACK_RING_INIT(&usbif->conn_ring, conn_sring, XC_PAGE_SIZE); 876816ac92eSJuergen Gross 877816ac92eSJuergen Gross xen_be_bind_evtchn(xendev); 878816ac92eSJuergen Gross 879816ac92eSJuergen Gross xen_be_printf(xendev, 1, "urb-ring-ref %d, conn-ring-ref %d, " 880816ac92eSJuergen Gross "remote port %d, local port %d\n", urb_ring_ref, 881816ac92eSJuergen Gross conn_ring_ref, xendev->remote_port, xendev->local_port); 882816ac92eSJuergen Gross 883816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 884816ac92eSJuergen Gross if (usbif->ports[i - 1].dev) { 885816ac92eSJuergen Gross usbback_hotplug_enq(usbif, i); 886816ac92eSJuergen Gross } 887816ac92eSJuergen Gross } 888816ac92eSJuergen Gross 889816ac92eSJuergen Gross return 0; 890816ac92eSJuergen Gross } 891816ac92eSJuergen Gross 892816ac92eSJuergen Gross static void usbback_backend_changed(struct XenDevice *xendev, const char *node) 893816ac92eSJuergen Gross { 894816ac92eSJuergen Gross struct usbback_info *usbif; 895816ac92eSJuergen Gross unsigned int i; 896816ac92eSJuergen Gross 897816ac92eSJuergen Gross TR_BUS(xendev, "path %s\n", node); 898816ac92eSJuergen Gross 899816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 900816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 901816ac92eSJuergen Gross usbback_process_port(usbif, i); 902816ac92eSJuergen Gross } 903816ac92eSJuergen Gross } 904816ac92eSJuergen Gross 905816ac92eSJuergen Gross static int usbback_init(struct XenDevice *xendev) 906816ac92eSJuergen Gross { 907816ac92eSJuergen Gross struct usbback_info *usbif; 908816ac92eSJuergen Gross 909816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 910816ac92eSJuergen Gross 911816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 912816ac92eSJuergen Gross 913816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "num-ports", &usbif->num_ports) || 914816ac92eSJuergen Gross usbif->num_ports < 1 || usbif->num_ports > USBBACK_MAXPORTS) { 915816ac92eSJuergen Gross xen_be_printf(xendev, 0, "num-ports not readable or out of bounds\n"); 916816ac92eSJuergen Gross return -1; 917816ac92eSJuergen Gross } 918816ac92eSJuergen Gross if (xenstore_read_be_int(xendev, "usb-ver", &usbif->usb_ver) || 919816ac92eSJuergen Gross (usbif->usb_ver != USB_VER_USB11 && usbif->usb_ver != USB_VER_USB20)) { 920816ac92eSJuergen Gross xen_be_printf(xendev, 0, "usb-ver not readable or out of bounds\n"); 921816ac92eSJuergen Gross return -1; 922816ac92eSJuergen Gross } 923816ac92eSJuergen Gross 924816ac92eSJuergen Gross usbback_backend_changed(xendev, "port"); 925816ac92eSJuergen Gross 926816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 927816ac92eSJuergen Gross 928816ac92eSJuergen Gross return 0; 929816ac92eSJuergen Gross } 930816ac92eSJuergen Gross 931816ac92eSJuergen Gross static void xen_bus_attach(USBPort *port) 932816ac92eSJuergen Gross { 933816ac92eSJuergen Gross struct usbback_info *usbif; 934816ac92eSJuergen Gross 935816ac92eSJuergen Gross usbif = port->opaque; 936816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 937816ac92eSJuergen Gross usbif->ports[port->index].attached = true; 938816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port->index + 1); 939816ac92eSJuergen Gross } 940816ac92eSJuergen Gross 941816ac92eSJuergen Gross static void xen_bus_detach(USBPort *port) 942816ac92eSJuergen Gross { 943816ac92eSJuergen Gross struct usbback_info *usbif; 944816ac92eSJuergen Gross 945816ac92eSJuergen Gross usbif = port->opaque; 946816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 947816ac92eSJuergen Gross usbif->ports[port->index].attached = false; 948816ac92eSJuergen Gross usbback_hotplug_enq(usbif, port->index + 1); 949816ac92eSJuergen Gross } 950816ac92eSJuergen Gross 951816ac92eSJuergen Gross static void xen_bus_child_detach(USBPort *port, USBDevice *child) 952816ac92eSJuergen Gross { 953816ac92eSJuergen Gross struct usbback_info *usbif; 954816ac92eSJuergen Gross 955816ac92eSJuergen Gross usbif = port->opaque; 956816ac92eSJuergen Gross TR_BUS(&usbif->xendev, "\n"); 957816ac92eSJuergen Gross } 958816ac92eSJuergen Gross 959816ac92eSJuergen Gross static void xen_bus_complete(USBPort *port, USBPacket *packet) 960816ac92eSJuergen Gross { 961816ac92eSJuergen Gross struct usbback_info *usbif; 962816ac92eSJuergen Gross 963816ac92eSJuergen Gross usbif = port->opaque; 964816ac92eSJuergen Gross TR_REQ(&usbif->xendev, "\n"); 965816ac92eSJuergen Gross usbback_packet_complete(packet); 966816ac92eSJuergen Gross } 967816ac92eSJuergen Gross 968816ac92eSJuergen Gross static USBPortOps xen_usb_port_ops = { 969816ac92eSJuergen Gross .attach = xen_bus_attach, 970816ac92eSJuergen Gross .detach = xen_bus_detach, 971816ac92eSJuergen Gross .child_detach = xen_bus_child_detach, 972816ac92eSJuergen Gross .complete = xen_bus_complete, 973816ac92eSJuergen Gross }; 974816ac92eSJuergen Gross 975816ac92eSJuergen Gross static USBBusOps xen_usb_bus_ops = { 976816ac92eSJuergen Gross }; 977816ac92eSJuergen Gross 978816ac92eSJuergen Gross static void usbback_alloc(struct XenDevice *xendev) 979816ac92eSJuergen Gross { 980816ac92eSJuergen Gross struct usbback_info *usbif; 981816ac92eSJuergen Gross USBPort *p; 982816ac92eSJuergen Gross unsigned int i, max_grants; 983816ac92eSJuergen Gross 984816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 985816ac92eSJuergen Gross 986816ac92eSJuergen Gross usb_bus_new(&usbif->bus, sizeof(usbif->bus), &xen_usb_bus_ops, xen_sysdev); 987816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 988816ac92eSJuergen Gross p = &(usbif->ports[i].port); 989816ac92eSJuergen Gross usb_register_port(&usbif->bus, p, usbif, i, &xen_usb_port_ops, 990816ac92eSJuergen Gross USB_SPEED_MASK_LOW | USB_SPEED_MASK_FULL | 991816ac92eSJuergen Gross USB_SPEED_MASK_HIGH); 992816ac92eSJuergen Gross snprintf(p->path, sizeof(p->path), "%d", 99); 993816ac92eSJuergen Gross } 994816ac92eSJuergen Gross 995816ac92eSJuergen Gross QTAILQ_INIT(&usbif->req_free_q); 996816ac92eSJuergen Gross QSIMPLEQ_INIT(&usbif->hotplug_q); 997816ac92eSJuergen Gross usbif->bh = qemu_bh_new(usbback_bh, usbif); 998816ac92eSJuergen Gross 999816ac92eSJuergen Gross /* max_grants: for each request and for the rings (request and connect). */ 1000816ac92eSJuergen Gross max_grants = USBIF_MAX_SEGMENTS_PER_REQUEST * USB_URB_RING_SIZE + 2; 1001816ac92eSJuergen Gross if (xengnttab_set_max_grants(xendev->gnttabdev, max_grants) < 0) { 1002816ac92eSJuergen Gross xen_be_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", 1003816ac92eSJuergen Gross strerror(errno)); 1004816ac92eSJuergen Gross } 1005816ac92eSJuergen Gross } 1006816ac92eSJuergen Gross 1007816ac92eSJuergen Gross static int usbback_free(struct XenDevice *xendev) 1008816ac92eSJuergen Gross { 1009816ac92eSJuergen Gross struct usbback_info *usbif; 1010816ac92eSJuergen Gross struct usbback_req *usbback_req; 1011816ac92eSJuergen Gross struct usbback_hotplug *usb_hp; 1012816ac92eSJuergen Gross unsigned int i; 1013816ac92eSJuergen Gross 1014816ac92eSJuergen Gross TR_BUS(xendev, "start\n"); 1015816ac92eSJuergen Gross 1016816ac92eSJuergen Gross usbback_disconnect(xendev); 1017816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1018816ac92eSJuergen Gross for (i = 1; i <= usbif->num_ports; i++) { 1019816ac92eSJuergen Gross usbback_portid_remove(usbif, i); 1020816ac92eSJuergen Gross } 1021816ac92eSJuergen Gross 1022816ac92eSJuergen Gross while (!QTAILQ_EMPTY(&usbif->req_free_q)) { 1023816ac92eSJuergen Gross usbback_req = QTAILQ_FIRST(&usbif->req_free_q); 1024816ac92eSJuergen Gross QTAILQ_REMOVE(&usbif->req_free_q, usbback_req, q); 1025816ac92eSJuergen Gross g_free(usbback_req); 1026816ac92eSJuergen Gross } 1027816ac92eSJuergen Gross while (!QSIMPLEQ_EMPTY(&usbif->hotplug_q)) { 1028816ac92eSJuergen Gross usb_hp = QSIMPLEQ_FIRST(&usbif->hotplug_q); 1029816ac92eSJuergen Gross QSIMPLEQ_REMOVE_HEAD(&usbif->hotplug_q, q); 1030816ac92eSJuergen Gross g_free(usb_hp); 1031816ac92eSJuergen Gross } 1032816ac92eSJuergen Gross 1033816ac92eSJuergen Gross qemu_bh_delete(usbif->bh); 1034816ac92eSJuergen Gross 1035816ac92eSJuergen Gross for (i = 0; i < USBBACK_MAXPORTS; i++) { 1036816ac92eSJuergen Gross usb_unregister_port(&usbif->bus, &(usbif->ports[i].port)); 1037816ac92eSJuergen Gross } 1038816ac92eSJuergen Gross 1039816ac92eSJuergen Gross usb_bus_release(&usbif->bus); 1040816ac92eSJuergen Gross 1041816ac92eSJuergen Gross TR_BUS(xendev, "finished\n"); 1042816ac92eSJuergen Gross 1043816ac92eSJuergen Gross return 0; 1044816ac92eSJuergen Gross } 1045816ac92eSJuergen Gross 1046816ac92eSJuergen Gross static void usbback_event(struct XenDevice *xendev) 1047816ac92eSJuergen Gross { 1048816ac92eSJuergen Gross struct usbback_info *usbif; 1049816ac92eSJuergen Gross 1050816ac92eSJuergen Gross usbif = container_of(xendev, struct usbback_info, xendev); 1051816ac92eSJuergen Gross qemu_bh_schedule(usbif->bh); 1052816ac92eSJuergen Gross } 1053816ac92eSJuergen Gross 1054816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1055816ac92eSJuergen Gross .size = sizeof(struct usbback_info), 1056816ac92eSJuergen Gross .flags = DEVOPS_FLAG_NEED_GNTDEV, 1057816ac92eSJuergen Gross .init = usbback_init, 1058816ac92eSJuergen Gross .alloc = usbback_alloc, 1059816ac92eSJuergen Gross .free = usbback_free, 1060816ac92eSJuergen Gross .backend_changed = usbback_backend_changed, 1061816ac92eSJuergen Gross .initialise = usbback_connect, 1062816ac92eSJuergen Gross .disconnect = usbback_disconnect, 1063816ac92eSJuergen Gross .event = usbback_event, 1064816ac92eSJuergen Gross }; 1065816ac92eSJuergen Gross 1066816ac92eSJuergen Gross #else /* USBIF_SHORT_NOT_OK */ 1067816ac92eSJuergen Gross 1068816ac92eSJuergen Gross static int usbback_not_supported(void) 1069816ac92eSJuergen Gross { 1070816ac92eSJuergen Gross return -EINVAL; 1071816ac92eSJuergen Gross } 1072816ac92eSJuergen Gross 1073816ac92eSJuergen Gross struct XenDevOps xen_usb_ops = { 1074816ac92eSJuergen Gross .backend_register = usbback_not_supported, 1075816ac92eSJuergen Gross }; 1076816ac92eSJuergen Gross 1077816ac92eSJuergen Gross #endif 1078