2 * xen paravirt usb device backend
4 * (c) Juergen Gross <jgross@suse.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; under version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, see <http://www.gnu.org/licenses/>.
18 * Contributions after 2012-01-13 are licensed under the terms of the
19 * GNU GPL, version 2 or (at your option) any later version.
22 #include "qemu/osdep.h"
26 #include "qemu-common.h"
27 #include "qemu/config-file.h"
28 #include "hw/sysbus.h"
30 #include "hw/xen/xen_backend.h"
31 #include "monitor/qdev.h"
32 #include "qapi/qmp/qbool.h"
33 #include "qapi/qmp/qint.h"
34 #include "qapi/qmp/qstring.h"
36 #include <xen/io/ring.h>
37 #include <xen/io/usbif.h>
40 * Check for required support of usbif.h: USBIF_SHORT_NOT_OK was the last
41 * macro added we rely on.
43 #ifdef USBIF_SHORT_NOT_OK
45 #define TR(xendev, lvl, fmt, args...) \
49 gettimeofday(&tv, NULL); \
50 xen_be_printf(xendev, lvl, "%8ld.%06ld xen-usb(%s):" fmt, \
51 tv.tv_sec, tv.tv_usec, __func__, ##args); \
53 #define TR_BUS(xendev, fmt, args...) TR(xendev, 2, fmt, ##args)
54 #define TR_REQ(xendev, fmt, args...) TR(xendev, 3, fmt, ##args)
56 #define USBBACK_MAXPORTS USBIF_PIPE_PORT_MASK
57 #define USB_DEV_ADDR_SIZE (USBIF_PIPE_DEV_MASK + 1)
59 /* USB wire protocol: structure describing control request parameter. */
60 struct usbif_ctrlrequest
{
76 QTAILQ_HEAD(submit_q_head
, usbback_req
) submit_q
;
80 struct usbback_info
*usbif
;
81 struct usbback_stub
*stub
;
82 struct usbif_urb_request req
;
85 unsigned int nr_buffer_segs
; /* # of transfer_buffer segments */
86 unsigned int nr_extra_segs
; /* # of iso_frame_desc segments */
88 QTAILQ_ENTRY(usbback_req
) q
;
92 struct libusb_transfer
*xfer
;
95 struct usbback_hotplug
{
96 QSIMPLEQ_ENTRY(usbback_hotplug
) q
;
100 struct usbback_info
{
101 struct XenDevice xendev
; /* must be first */
105 struct usbif_urb_back_ring urb_ring
;
106 struct usbif_conn_back_ring conn_ring
;
110 QTAILQ_HEAD(req_free_q_head
, usbback_req
) req_free_q
;
111 QSIMPLEQ_HEAD(hotplug_q_head
, usbback_hotplug
) hotplug_q
;
112 struct usbback_stub ports
[USBBACK_MAXPORTS
];
113 struct usbback_stub
*addr_table
[USB_DEV_ADDR_SIZE
];
117 static struct usbback_req
*usbback_get_req(struct usbback_info
*usbif
)
119 struct usbback_req
*usbback_req
;
121 if (QTAILQ_EMPTY(&usbif
->req_free_q
)) {
122 usbback_req
= g_new0(struct usbback_req
, 1);
124 usbback_req
= QTAILQ_FIRST(&usbif
->req_free_q
);
125 QTAILQ_REMOVE(&usbif
->req_free_q
, usbback_req
, q
);
130 static void usbback_put_req(struct usbback_req
*usbback_req
)
132 struct usbback_info
*usbif
;
134 usbif
= usbback_req
->usbif
;
135 memset(usbback_req
, 0, sizeof(*usbback_req
));
136 QTAILQ_INSERT_HEAD(&usbif
->req_free_q
, usbback_req
, q
);
139 static int usbback_gnttab_map(struct usbback_req
*usbback_req
)
141 unsigned int nr_segs
, i
, prot
;
142 uint32_t ref
[USBIF_MAX_SEGMENTS_PER_REQUEST
];
143 struct usbback_info
*usbif
= usbback_req
->usbif
;
144 struct XenDevice
*xendev
= &usbif
->xendev
;
145 struct usbif_request_segment
*seg
;
148 nr_segs
= usbback_req
->nr_buffer_segs
+ usbback_req
->nr_extra_segs
;
153 if (nr_segs
> USBIF_MAX_SEGMENTS_PER_REQUEST
) {
154 xen_be_printf(xendev
, 0, "bad number of segments in request (%d)\n",
159 for (i
= 0; i
< nr_segs
; i
++) {
160 if ((unsigned)usbback_req
->req
.seg
[i
].offset
+
161 (unsigned)usbback_req
->req
.seg
[i
].length
> PAGE_SIZE
) {
162 xen_be_printf(xendev
, 0, "segment crosses page boundary\n");
167 if (usbback_req
->nr_buffer_segs
) {
169 if (usbif_pipein(usbback_req
->req
.pipe
)) {
172 for (i
= 0; i
< usbback_req
->nr_buffer_segs
; i
++) {
173 ref
[i
] = usbback_req
->req
.seg
[i
].gref
;
175 usbback_req
->buffer
= xengnttab_map_domain_grant_refs(xendev
->gnttabdev
,
176 usbback_req
->nr_buffer_segs
, xendev
->dom
, ref
, prot
);
178 if (!usbback_req
->buffer
) {
182 for (i
= 0; i
< usbback_req
->nr_buffer_segs
; i
++) {
183 seg
= usbback_req
->req
.seg
+ i
;
184 addr
= usbback_req
->buffer
+ i
* PAGE_SIZE
+ seg
->offset
;
185 qemu_iovec_add(&usbback_req
->packet
.iov
, addr
, seg
->length
);
189 if (!usbif_pipeisoc(usbback_req
->req
.pipe
)) {
194 * Right now isoc requests are not supported.
195 * Prepare supporting those by doing the work needed on the guest
199 if (!usbback_req
->nr_extra_segs
) {
200 xen_be_printf(xendev
, 0, "iso request without descriptor segments\n");
204 prot
= PROT_READ
| PROT_WRITE
;
205 for (i
= 0; i
< usbback_req
->nr_extra_segs
; i
++) {
206 ref
[i
] = usbback_req
->req
.seg
[i
+ usbback_req
->req
.nr_buffer_segs
].gref
;
208 usbback_req
->isoc_buffer
= xengnttab_map_domain_grant_refs(
209 xendev
->gnttabdev
, usbback_req
->nr_extra_segs
, xendev
->dom
, ref
, prot
);
211 if (!usbback_req
->isoc_buffer
) {
218 static int usbback_init_packet(struct usbback_req
*usbback_req
)
220 struct XenDevice
*xendev
= &usbback_req
->usbif
->xendev
;
221 USBPacket
*packet
= &usbback_req
->packet
;
222 USBDevice
*dev
= usbback_req
->stub
->dev
;
224 unsigned int pid
, ep_nr
;
228 qemu_iovec_init(&packet
->iov
, USBIF_MAX_SEGMENTS_PER_REQUEST
);
229 pid
= usbif_pipein(usbback_req
->req
.pipe
) ? USB_TOKEN_IN
: USB_TOKEN_OUT
;
230 ep_nr
= usbif_pipeendpoint(usbback_req
->req
.pipe
);
231 sok
= !!(usbback_req
->req
.transfer_flags
& USBIF_SHORT_NOT_OK
);
232 if (usbif_pipectrl(usbback_req
->req
.pipe
)) {
236 ep
= usb_ep_get(dev
, pid
, ep_nr
);
237 usb_packet_setup(packet
, pid
, ep
, 0, 1, sok
, true);
239 switch (usbif_pipetype(usbback_req
->req
.pipe
)) {
240 case USBIF_PIPE_TYPE_ISOC
:
241 TR_REQ(xendev
, "iso transfer %s: buflen: %x, %d frames\n",
242 (pid
== USB_TOKEN_IN
) ? "in" : "out",
243 usbback_req
->req
.buffer_length
,
244 usbback_req
->req
.u
.isoc
.nr_frame_desc_segs
);
245 ret
= -EINVAL
; /* isoc not implemented yet */
248 case USBIF_PIPE_TYPE_INT
:
249 TR_REQ(xendev
, "int transfer %s: buflen: %x\n",
250 (pid
== USB_TOKEN_IN
) ? "in" : "out",
251 usbback_req
->req
.buffer_length
);
254 case USBIF_PIPE_TYPE_CTRL
:
255 packet
->parameter
= *(uint64_t *)usbback_req
->req
.u
.ctrl
;
256 TR_REQ(xendev
, "ctrl parameter: %"PRIx64
", buflen: %x\n",
258 usbback_req
->req
.buffer_length
);
261 case USBIF_PIPE_TYPE_BULK
:
262 TR_REQ(xendev
, "bulk transfer %s: buflen: %x\n",
263 (pid
== USB_TOKEN_IN
) ? "in" : "out",
264 usbback_req
->req
.buffer_length
);
274 static void usbback_do_response(struct usbback_req
*usbback_req
, int32_t status
,
275 int32_t actual_length
, int32_t error_count
)
277 struct usbback_info
*usbif
;
278 struct usbif_urb_response
*res
;
279 struct XenDevice
*xendev
;
282 usbif
= usbback_req
->usbif
;
283 xendev
= &usbif
->xendev
;
285 TR_REQ(xendev
, "id %d, status %d, length %d, errcnt %d\n",
286 usbback_req
->req
.id
, status
, actual_length
, error_count
);
288 if (usbback_req
->packet
.iov
.iov
) {
289 qemu_iovec_destroy(&usbback_req
->packet
.iov
);
292 if (usbback_req
->buffer
) {
293 xengnttab_unmap(xendev
->gnttabdev
, usbback_req
->buffer
,
294 usbback_req
->nr_buffer_segs
);
295 usbback_req
->buffer
= NULL
;
298 if (usbback_req
->isoc_buffer
) {
299 xengnttab_unmap(xendev
->gnttabdev
, usbback_req
->isoc_buffer
,
300 usbback_req
->nr_extra_segs
);
301 usbback_req
->isoc_buffer
= NULL
;
304 res
= RING_GET_RESPONSE(&usbif
->urb_ring
, usbif
->urb_ring
.rsp_prod_pvt
);
305 res
->id
= usbback_req
->req
.id
;
306 res
->status
= status
;
307 res
->actual_length
= actual_length
;
308 res
->error_count
= error_count
;
309 res
->start_frame
= 0;
310 usbif
->urb_ring
.rsp_prod_pvt
++;
311 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&usbif
->urb_ring
, notify
);
314 xen_be_send_notify(xendev
);
317 usbback_put_req(usbback_req
);
320 static void usbback_do_response_ret(struct usbback_req
*usbback_req
,
323 usbback_do_response(usbback_req
, status
, 0, 0);
326 static int32_t usbback_xlat_status(int status
)
329 case USB_RET_SUCCESS
:
337 case USB_RET_IOERROR
:
344 static void usbback_packet_complete(USBPacket
*packet
)
346 struct usbback_req
*usbback_req
;
349 usbback_req
= container_of(packet
, struct usbback_req
, packet
);
351 QTAILQ_REMOVE(&usbback_req
->stub
->submit_q
, usbback_req
, q
);
353 status
= usbback_xlat_status(packet
->status
);
354 usbback_do_response(usbback_req
, status
, packet
->actual_length
, 0);
357 static void usbback_set_address(struct usbback_info
*usbif
,
358 struct usbback_stub
*stub
,
359 unsigned int cur_addr
, unsigned int new_addr
)
362 usbif
->addr_table
[cur_addr
] = NULL
;
365 usbif
->addr_table
[new_addr
] = stub
;
369 static bool usbback_cancel_req(struct usbback_req
*usbback_req
)
373 if (usb_packet_is_inflight(&usbback_req
->packet
)) {
374 usb_cancel_packet(&usbback_req
->packet
);
380 static void usbback_process_unlink_req(struct usbback_req
*usbback_req
)
382 struct usbback_info
*usbif
;
383 struct usbback_req
*unlink_req
;
384 unsigned int id
, devnum
;
387 usbif
= usbback_req
->usbif
;
389 id
= usbback_req
->req
.u
.unlink
.unlink_id
;
390 TR_REQ(&usbif
->xendev
, "unlink id %d\n", id
);
391 devnum
= usbif_pipedevice(usbback_req
->req
.pipe
);
392 if (unlikely(devnum
== 0)) {
393 usbback_req
->stub
= usbif
->ports
+
394 usbif_pipeportnum(usbback_req
->req
.pipe
);
395 if (unlikely(!usbback_req
->stub
)) {
400 if (unlikely(!usbif
->addr_table
[devnum
])) {
404 usbback_req
->stub
= usbif
->addr_table
[devnum
];
407 QTAILQ_FOREACH(unlink_req
, &usbback_req
->stub
->submit_q
, q
) {
408 if (unlink_req
->req
.id
== id
) {
409 if (usbback_cancel_req(unlink_req
)) {
410 usbback_do_response_ret(unlink_req
, -EPROTO
);
417 usbback_do_response_ret(usbback_req
, ret
);
421 * Checks whether a request can be handled at once or should be forwarded
422 * to the usb framework.
424 * 0 in case of usb framework is needed
425 * 1 in case of local handling (no error)
426 * The request response has been queued already if return value not 0.
428 static int usbback_check_and_submit(struct usbback_req
*usbback_req
)
430 struct usbback_info
*usbif
;
432 struct usbback_stub
*stub
;
433 struct usbif_ctrlrequest
*ctrl
;
437 usbif
= usbback_req
->usbif
;
439 devnum
= usbif_pipedevice(usbback_req
->req
.pipe
);
440 ctrl
= (struct usbif_ctrlrequest
*)usbback_req
->req
.u
.ctrl
;
441 wValue
= le16_to_cpu(ctrl
->wValue
);
444 * When the device is first connected or resetted, USB device has no
445 * address. In this initial state, following requests are sent to device
448 * 1. GET_DESCRIPTOR (with Descriptor Type is "DEVICE") is sent,
449 * and OS knows what device is connected to.
451 * 2. SET_ADDRESS is sent, and then device has its address.
453 * In the next step, SET_CONFIGURATION is sent to addressed device, and
454 * then the device is finally ready to use.
456 if (unlikely(devnum
== 0)) {
457 stub
= usbif
->ports
+ usbif_pipeportnum(usbback_req
->req
.pipe
) - 1;
458 if (!stub
->dev
|| !stub
->attached
) {
463 switch (ctrl
->bRequest
) {
464 case USB_REQ_GET_DESCRIPTOR
:
466 * GET_DESCRIPTOR request to device #0.
467 * through normal transfer.
469 TR_REQ(&usbif
->xendev
, "devnum 0 GET_DESCRIPTOR\n");
470 usbback_req
->stub
= stub
;
472 case USB_REQ_SET_ADDRESS
:
474 * SET_ADDRESS request to device #0.
475 * add attached device to addr_table.
477 TR_REQ(&usbif
->xendev
, "devnum 0 SET_ADDRESS\n");
478 usbback_set_address(usbif
, stub
, 0, wValue
);
488 if (unlikely(!usbif
->addr_table
[devnum
])) {
492 usbback_req
->stub
= usbif
->addr_table
[devnum
];
495 * Check special request
497 if (ctrl
->bRequest
!= USB_REQ_SET_ADDRESS
) {
502 * SET_ADDRESS request to addressed device.
503 * change addr or remove from addr_table.
505 usbback_set_address(usbif
, usbback_req
->stub
, devnum
, wValue
);
509 usbback_do_response_ret(usbback_req
, ret
);
513 static void usbback_dispatch(struct usbback_req
*usbback_req
)
517 struct usbback_info
*usbif
;
519 usbif
= usbback_req
->usbif
;
521 TR_REQ(&usbif
->xendev
, "start req_id %d pipe %08x\n", usbback_req
->req
.id
,
522 usbback_req
->req
.pipe
);
525 if (unlikely(usbif_pipeunlink(usbback_req
->req
.pipe
))) {
526 usbback_process_unlink_req(usbback_req
);
530 if (usbif_pipectrl(usbback_req
->req
.pipe
)) {
531 if (usbback_check_and_submit(usbback_req
)) {
535 devnum
= usbif_pipedevice(usbback_req
->req
.pipe
);
536 usbback_req
->stub
= usbif
->addr_table
[devnum
];
538 if (!usbback_req
->stub
|| !usbback_req
->stub
->attached
) {
544 QTAILQ_INSERT_TAIL(&usbback_req
->stub
->submit_q
, usbback_req
, q
);
546 usbback_req
->nr_buffer_segs
= usbback_req
->req
.nr_buffer_segs
;
547 usbback_req
->nr_extra_segs
= usbif_pipeisoc(usbback_req
->req
.pipe
) ?
548 usbback_req
->req
.u
.isoc
.nr_frame_desc_segs
: 0;
550 ret
= usbback_init_packet(usbback_req
);
552 xen_be_printf(&usbif
->xendev
, 0, "invalid request\n");
557 ret
= usbback_gnttab_map(usbback_req
);
559 xen_be_printf(&usbif
->xendev
, 0, "invalid buffer, ret=%d\n", ret
);
564 usb_handle_packet(usbback_req
->stub
->dev
, &usbback_req
->packet
);
565 if (usbback_req
->packet
.status
!= USB_RET_ASYNC
) {
566 usbback_packet_complete(&usbback_req
->packet
);
571 QTAILQ_REMOVE(&usbback_req
->stub
->submit_q
, usbback_req
, q
);
574 usbback_do_response_ret(usbback_req
, ret
);
577 static void usbback_hotplug_notify(struct usbback_info
*usbif
)
579 struct usbif_conn_back_ring
*ring
= &usbif
->conn_ring
;
580 struct usbif_conn_request req
;
581 struct usbif_conn_response
*res
;
582 struct usbback_hotplug
*usb_hp
;
585 if (!usbif
->conn_sring
) {
589 /* Check for full ring. */
590 if ((RING_SIZE(ring
) - ring
->rsp_prod_pvt
- ring
->req_cons
) == 0) {
591 xen_be_send_notify(&usbif
->xendev
);
595 usb_hp
= QSIMPLEQ_FIRST(&usbif
->hotplug_q
);
596 QSIMPLEQ_REMOVE_HEAD(&usbif
->hotplug_q
, q
);
598 RING_COPY_REQUEST(ring
, ring
->req_cons
, &req
);
600 ring
->sring
->req_event
= ring
->req_cons
+ 1;
602 res
= RING_GET_RESPONSE(ring
, ring
->rsp_prod_pvt
);
604 res
->portnum
= usb_hp
->port
;
605 res
->speed
= usbif
->ports
[usb_hp
->port
- 1].speed
;
606 ring
->rsp_prod_pvt
++;
607 RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(ring
, notify
);
610 xen_be_send_notify(&usbif
->xendev
);
613 TR_BUS(&usbif
->xendev
, "hotplug port %d speed %d\n", usb_hp
->port
,
618 if (!QSIMPLEQ_EMPTY(&usbif
->hotplug_q
)) {
619 qemu_bh_schedule(usbif
->bh
);
623 static void usbback_bh(void *opaque
)
625 struct usbback_info
*usbif
;
626 struct usbif_urb_back_ring
*urb_ring
;
627 struct usbback_req
*usbback_req
;
629 unsigned int more_to_do
;
632 if (usbif
->ring_error
) {
636 if (!QSIMPLEQ_EMPTY(&usbif
->hotplug_q
)) {
637 usbback_hotplug_notify(usbif
);
640 urb_ring
= &usbif
->urb_ring
;
641 rc
= urb_ring
->req_cons
;
642 rp
= urb_ring
->sring
->req_prod
;
643 xen_rmb(); /* Ensure we see queued requests up to 'rp'. */
645 if (RING_REQUEST_PROD_OVERFLOW(urb_ring
, rp
)) {
646 rc
= urb_ring
->rsp_prod_pvt
;
647 xen_be_printf(&usbif
->xendev
, 0, "domU provided bogus ring requests "
648 "(%#x - %#x = %u). Halting ring processing.\n",
650 usbif
->ring_error
= true;
655 if (RING_REQUEST_CONS_OVERFLOW(urb_ring
, rc
)) {
658 usbback_req
= usbback_get_req(usbif
);
660 RING_COPY_REQUEST(urb_ring
, rc
, &usbback_req
->req
);
661 usbback_req
->usbif
= usbif
;
663 usbback_dispatch(usbback_req
);
665 urb_ring
->req_cons
= ++rc
;
668 RING_FINAL_CHECK_FOR_REQUESTS(urb_ring
, more_to_do
);
670 qemu_bh_schedule(usbif
->bh
);
674 static void usbback_hotplug_enq(struct usbback_info
*usbif
, unsigned port
)
676 struct usbback_hotplug
*usb_hp
;
678 usb_hp
= g_new0(struct usbback_hotplug
, 1);
680 QSIMPLEQ_INSERT_TAIL(&usbif
->hotplug_q
, usb_hp
, q
);
681 usbback_hotplug_notify(usbif
);
684 static void usbback_portid_remove(struct usbback_info
*usbif
, unsigned port
)
688 if (!usbif
->ports
[port
- 1].dev
) {
692 p
= &(usbif
->ports
[port
- 1].port
);
693 snprintf(p
->path
, sizeof(p
->path
), "%d", 99);
695 object_unparent(OBJECT(usbif
->ports
[port
- 1].dev
));
696 usbif
->ports
[port
- 1].dev
= NULL
;
697 usbif
->ports
[port
- 1].speed
= USBIF_SPEED_NONE
;
698 usbif
->ports
[port
- 1].attached
= false;
699 usbback_hotplug_enq(usbif
, port
);
701 TR_BUS(&usbif
->xendev
, "port %d removed\n", port
);
704 static void usbback_portid_add(struct usbback_info
*usbif
, unsigned port
,
710 Error
*local_err
= NULL
;
714 if (usbif
->ports
[port
- 1].dev
) {
718 portname
= strchr(busid
, '-');
720 xen_be_printf(&usbif
->xendev
, 0, "device %s illegal specification\n",
725 p
= &(usbif
->ports
[port
- 1].port
);
726 snprintf(p
->path
, sizeof(p
->path
), "%s", portname
);
729 qdict_put(qdict
, "driver", qstring_from_str("usb-host"));
730 qdict_put(qdict
, "hostbus", qint_from_int(atoi(busid
)));
731 qdict_put(qdict
, "hostport", qstring_from_str(portname
));
732 opts
= qemu_opts_from_qdict(qemu_find_opts("device"), qdict
, &local_err
);
736 usbif
->ports
[port
- 1].dev
= USB_DEVICE(qdev_device_add(opts
, &local_err
));
737 if (!usbif
->ports
[port
- 1].dev
) {
741 snprintf(p
->path
, sizeof(p
->path
), "%d", port
);
742 speed
= usbif
->ports
[port
- 1].dev
->speed
;
745 speed
= USBIF_SPEED_LOW
;
748 speed
= USBIF_SPEED_FULL
;
751 speed
= (usbif
->usb_ver
< USB_VER_USB20
) ?
752 USBIF_SPEED_NONE
: USBIF_SPEED_HIGH
;
755 speed
= USBIF_SPEED_NONE
;
758 if (speed
== USBIF_SPEED_NONE
) {
759 xen_be_printf(&usbif
->xendev
, 0, "device %s wrong speed\n", busid
);
760 object_unparent(OBJECT(usbif
->ports
[port
- 1].dev
));
761 usbif
->ports
[port
- 1].dev
= NULL
;
764 usb_device_reset(usbif
->ports
[port
- 1].dev
);
765 usbif
->ports
[port
- 1].speed
= speed
;
766 usbif
->ports
[port
- 1].attached
= true;
767 QTAILQ_INIT(&usbif
->ports
[port
- 1].submit_q
);
768 usbback_hotplug_enq(usbif
, port
);
770 TR_BUS(&usbif
->xendev
, "port %d attached\n", port
);
775 snprintf(p
->path
, sizeof(p
->path
), "%d", 99);
776 xen_be_printf(&usbif
->xendev
, 0, "device %s could not be opened\n", busid
);
779 static void usbback_process_port(struct usbback_info
*usbif
, unsigned port
)
784 snprintf(node
, sizeof(node
), "port/%d", port
);
785 busid
= xenstore_read_be_str(&usbif
->xendev
, node
);
787 xen_be_printf(&usbif
->xendev
, 0, "xenstore_read %s failed\n", node
);
791 /* Remove portid, if the port is not connected. */
792 if (strlen(busid
) == 0) {
793 usbback_portid_remove(usbif
, port
);
795 usbback_portid_add(usbif
, port
, busid
);
801 static void usbback_disconnect(struct XenDevice
*xendev
)
803 struct usbback_info
*usbif
;
804 struct usbback_req
*req
, *tmp
;
807 TR_BUS(xendev
, "start\n");
809 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
811 xen_be_unbind_evtchn(xendev
);
813 if (usbif
->urb_sring
) {
814 xengnttab_unmap(xendev
->gnttabdev
, usbif
->urb_sring
, 1);
815 usbif
->urb_sring
= NULL
;
817 if (usbif
->conn_sring
) {
818 xengnttab_unmap(xendev
->gnttabdev
, usbif
->conn_sring
, 1);
819 usbif
->conn_sring
= NULL
;
822 for (i
= 0; i
< usbif
->num_ports
; i
++) {
823 if (!usbif
->ports
[i
].dev
) {
826 QTAILQ_FOREACH_SAFE(req
, &usbif
->ports
[i
].submit_q
, q
, tmp
) {
827 usbback_cancel_req(req
);
831 TR_BUS(xendev
, "finished\n");
834 static int usbback_connect(struct XenDevice
*xendev
)
836 struct usbback_info
*usbif
;
837 struct usbif_urb_sring
*urb_sring
;
838 struct usbif_conn_sring
*conn_sring
;
843 TR_BUS(xendev
, "start\n");
845 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
847 if (xenstore_read_fe_int(xendev
, "urb-ring-ref", &urb_ring_ref
)) {
848 xen_be_printf(xendev
, 0, "error reading urb-ring-ref\n");
851 if (xenstore_read_fe_int(xendev
, "conn-ring-ref", &conn_ring_ref
)) {
852 xen_be_printf(xendev
, 0, "error reading conn-ring-ref\n");
855 if (xenstore_read_fe_int(xendev
, "event-channel", &xendev
->remote_port
)) {
856 xen_be_printf(xendev
, 0, "error reading event-channel\n");
860 usbif
->urb_sring
= xengnttab_map_grant_ref(xendev
->gnttabdev
, xendev
->dom
,
862 PROT_READ
| PROT_WRITE
);
863 usbif
->conn_sring
= xengnttab_map_grant_ref(xendev
->gnttabdev
, xendev
->dom
,
865 PROT_READ
| PROT_WRITE
);
866 if (!usbif
->urb_sring
|| !usbif
->conn_sring
) {
867 xen_be_printf(xendev
, 0, "error mapping rings\n");
868 usbback_disconnect(xendev
);
872 urb_sring
= usbif
->urb_sring
;
873 conn_sring
= usbif
->conn_sring
;
874 BACK_RING_INIT(&usbif
->urb_ring
, urb_sring
, XC_PAGE_SIZE
);
875 BACK_RING_INIT(&usbif
->conn_ring
, conn_sring
, XC_PAGE_SIZE
);
877 xen_be_bind_evtchn(xendev
);
879 xen_be_printf(xendev
, 1, "urb-ring-ref %d, conn-ring-ref %d, "
880 "remote port %d, local port %d\n", urb_ring_ref
,
881 conn_ring_ref
, xendev
->remote_port
, xendev
->local_port
);
883 for (i
= 1; i
<= usbif
->num_ports
; i
++) {
884 if (usbif
->ports
[i
- 1].dev
) {
885 usbback_hotplug_enq(usbif
, i
);
892 static void usbback_backend_changed(struct XenDevice
*xendev
, const char *node
)
894 struct usbback_info
*usbif
;
897 TR_BUS(xendev
, "path %s\n", node
);
899 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
900 for (i
= 1; i
<= usbif
->num_ports
; i
++) {
901 usbback_process_port(usbif
, i
);
905 static int usbback_init(struct XenDevice
*xendev
)
907 struct usbback_info
*usbif
;
909 TR_BUS(xendev
, "start\n");
911 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
913 if (xenstore_read_be_int(xendev
, "num-ports", &usbif
->num_ports
) ||
914 usbif
->num_ports
< 1 || usbif
->num_ports
> USBBACK_MAXPORTS
) {
915 xen_be_printf(xendev
, 0, "num-ports not readable or out of bounds\n");
918 if (xenstore_read_be_int(xendev
, "usb-ver", &usbif
->usb_ver
) ||
919 (usbif
->usb_ver
!= USB_VER_USB11
&& usbif
->usb_ver
!= USB_VER_USB20
)) {
920 xen_be_printf(xendev
, 0, "usb-ver not readable or out of bounds\n");
924 usbback_backend_changed(xendev
, "port");
926 TR_BUS(xendev
, "finished\n");
931 static void xen_bus_attach(USBPort
*port
)
933 struct usbback_info
*usbif
;
935 usbif
= port
->opaque
;
936 TR_BUS(&usbif
->xendev
, "\n");
937 usbif
->ports
[port
->index
].attached
= true;
938 usbback_hotplug_enq(usbif
, port
->index
+ 1);
941 static void xen_bus_detach(USBPort
*port
)
943 struct usbback_info
*usbif
;
945 usbif
= port
->opaque
;
946 TR_BUS(&usbif
->xendev
, "\n");
947 usbif
->ports
[port
->index
].attached
= false;
948 usbback_hotplug_enq(usbif
, port
->index
+ 1);
951 static void xen_bus_child_detach(USBPort
*port
, USBDevice
*child
)
953 struct usbback_info
*usbif
;
955 usbif
= port
->opaque
;
956 TR_BUS(&usbif
->xendev
, "\n");
959 static void xen_bus_complete(USBPort
*port
, USBPacket
*packet
)
961 struct usbback_info
*usbif
;
963 usbif
= port
->opaque
;
964 TR_REQ(&usbif
->xendev
, "\n");
965 usbback_packet_complete(packet
);
968 static USBPortOps xen_usb_port_ops
= {
969 .attach
= xen_bus_attach
,
970 .detach
= xen_bus_detach
,
971 .child_detach
= xen_bus_child_detach
,
972 .complete
= xen_bus_complete
,
975 static USBBusOps xen_usb_bus_ops
= {
978 static void usbback_alloc(struct XenDevice
*xendev
)
980 struct usbback_info
*usbif
;
982 unsigned int i
, max_grants
;
984 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
986 usb_bus_new(&usbif
->bus
, sizeof(usbif
->bus
), &xen_usb_bus_ops
, xen_sysdev
);
987 for (i
= 0; i
< USBBACK_MAXPORTS
; i
++) {
988 p
= &(usbif
->ports
[i
].port
);
989 usb_register_port(&usbif
->bus
, p
, usbif
, i
, &xen_usb_port_ops
,
990 USB_SPEED_MASK_LOW
| USB_SPEED_MASK_FULL
|
991 USB_SPEED_MASK_HIGH
);
992 snprintf(p
->path
, sizeof(p
->path
), "%d", 99);
995 QTAILQ_INIT(&usbif
->req_free_q
);
996 QSIMPLEQ_INIT(&usbif
->hotplug_q
);
997 usbif
->bh
= qemu_bh_new(usbback_bh
, usbif
);
999 /* max_grants: for each request and for the rings (request and connect). */
1000 max_grants
= USBIF_MAX_SEGMENTS_PER_REQUEST
* USB_URB_RING_SIZE
+ 2;
1001 if (xengnttab_set_max_grants(xendev
->gnttabdev
, max_grants
) < 0) {
1002 xen_be_printf(xendev
, 0, "xengnttab_set_max_grants failed: %s\n",
1007 static int usbback_free(struct XenDevice
*xendev
)
1009 struct usbback_info
*usbif
;
1010 struct usbback_req
*usbback_req
;
1011 struct usbback_hotplug
*usb_hp
;
1014 TR_BUS(xendev
, "start\n");
1016 usbback_disconnect(xendev
);
1017 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
1018 for (i
= 1; i
<= usbif
->num_ports
; i
++) {
1019 usbback_portid_remove(usbif
, i
);
1022 while (!QTAILQ_EMPTY(&usbif
->req_free_q
)) {
1023 usbback_req
= QTAILQ_FIRST(&usbif
->req_free_q
);
1024 QTAILQ_REMOVE(&usbif
->req_free_q
, usbback_req
, q
);
1025 g_free(usbback_req
);
1027 while (!QSIMPLEQ_EMPTY(&usbif
->hotplug_q
)) {
1028 usb_hp
= QSIMPLEQ_FIRST(&usbif
->hotplug_q
);
1029 QSIMPLEQ_REMOVE_HEAD(&usbif
->hotplug_q
, q
);
1033 qemu_bh_delete(usbif
->bh
);
1035 for (i
= 0; i
< USBBACK_MAXPORTS
; i
++) {
1036 usb_unregister_port(&usbif
->bus
, &(usbif
->ports
[i
].port
));
1039 usb_bus_release(&usbif
->bus
);
1041 TR_BUS(xendev
, "finished\n");
1046 static void usbback_event(struct XenDevice
*xendev
)
1048 struct usbback_info
*usbif
;
1050 usbif
= container_of(xendev
, struct usbback_info
, xendev
);
1051 qemu_bh_schedule(usbif
->bh
);
1054 struct XenDevOps xen_usb_ops
= {
1055 .size
= sizeof(struct usbback_info
),
1056 .flags
= DEVOPS_FLAG_NEED_GNTDEV
,
1057 .init
= usbback_init
,
1058 .alloc
= usbback_alloc
,
1059 .free
= usbback_free
,
1060 .backend_changed
= usbback_backend_changed
,
1061 .initialise
= usbback_connect
,
1062 .disconnect
= usbback_disconnect
,
1063 .event
= usbback_event
,
1066 #else /* USBIF_SHORT_NOT_OK */
1068 static int usbback_not_supported(void)
1073 struct XenDevOps xen_usb_ops
= {
1074 .backend_register
= usbback_not_supported
,