2 * USB UHCI controller emulation
4 * Copyright (c) 2005 Fabrice Bellard
6 * Copyright (c) 2008 Max Krasnyansky
7 * Magor rewrite of the UHCI data structures parser and frame processor
8 * Support for fully async operation and multiple outstanding transactions
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
28 #include "qemu/osdep.h"
31 #include "hw/usb/uhci-regs.h"
32 #include "hw/pci/pci.h"
33 #include "qapi/error.h"
34 #include "qemu/timer.h"
36 #include "sysemu/dma.h"
38 #include "qemu/main-loop.h"
40 #define FRAME_TIMER_FREQ 1000
42 #define FRAME_MAX_LOOPS 256
44 /* Must be large enough to handle 10 frame delay for initial isoc requests */
47 #define MAX_FRAMES_PER_TICK (QH_VALID / 2)
52 TD_RESULT_STOP_FRAME
= 10,
55 TD_RESULT_ASYNC_START
,
59 typedef struct UHCIState UHCIState
;
60 typedef struct UHCIAsync UHCIAsync
;
61 typedef struct UHCIQueue UHCIQueue
;
62 typedef struct UHCIInfo UHCIInfo
;
63 typedef struct UHCIPCIDeviceClass UHCIPCIDeviceClass
;
71 void (*realize
)(PCIDevice
*dev
, Error
**errp
);
75 struct UHCIPCIDeviceClass
{
76 PCIDeviceClass parent_class
;
81 * Pending async transaction.
82 * 'packet' must be the first field because completion
83 * handler does "(UHCIAsync *) pkt" cast.
88 uint8_t static_buf
[64]; /* 64 bytes is enough, except for isoc packets */
91 QTAILQ_ENTRY(UHCIAsync
) next
;
101 QTAILQ_ENTRY(UHCIQueue
) next
;
102 QTAILQ_HEAD(, UHCIAsync
) asyncs
;
106 typedef struct UHCIPort
{
114 USBBus bus
; /* Note unused when we're a companion controller */
115 uint16_t cmd
; /* cmd register */
117 uint16_t intr
; /* interrupt enable register */
118 uint16_t frnum
; /* frame number */
119 uint32_t fl_base_addr
; /* frame list base address */
121 uint8_t status2
; /* bit 0 and 1 are used to generate UHCI_STS_USBINT */
123 QEMUTimer
*frame_timer
;
125 uint32_t frame_bytes
;
126 uint32_t frame_bandwidth
;
127 bool completions_only
;
128 UHCIPort ports
[NB_PORTS
];
130 /* Interrupts that should be raised at the end of the current frame. */
131 uint32_t pending_int_mask
;
134 QTAILQ_HEAD(, UHCIQueue
) queues
;
135 uint8_t num_ports_vmstate
;
143 typedef struct UHCI_TD
{
145 uint32_t ctrl
; /* see TD_CTRL_xxx */
150 typedef struct UHCI_QH
{
155 static void uhci_async_cancel(UHCIAsync
*async
);
156 static void uhci_queue_fill(UHCIQueue
*q
, UHCI_TD
*td
);
157 static void uhci_resume(void *opaque
);
159 #define TYPE_UHCI "pci-uhci-usb"
160 #define UHCI(obj) OBJECT_CHECK(UHCIState, (obj), TYPE_UHCI)
162 static inline int32_t uhci_queue_token(UHCI_TD
*td
)
164 if ((td
->token
& (0xf << 15)) == 0) {
165 /* ctrl ep, cover ep and dev, not pid! */
166 return td
->token
& 0x7ff00;
168 /* covers ep, dev, pid -> identifies the endpoint */
169 return td
->token
& 0x7ffff;
173 static UHCIQueue
*uhci_queue_new(UHCIState
*s
, uint32_t qh_addr
, UHCI_TD
*td
,
178 queue
= g_new0(UHCIQueue
, 1);
180 queue
->qh_addr
= qh_addr
;
181 queue
->token
= uhci_queue_token(td
);
183 QTAILQ_INIT(&queue
->asyncs
);
184 QTAILQ_INSERT_HEAD(&s
->queues
, queue
, next
);
185 queue
->valid
= QH_VALID
;
186 trace_usb_uhci_queue_add(queue
->token
);
190 static void uhci_queue_free(UHCIQueue
*queue
, const char *reason
)
192 UHCIState
*s
= queue
->uhci
;
195 while (!QTAILQ_EMPTY(&queue
->asyncs
)) {
196 async
= QTAILQ_FIRST(&queue
->asyncs
);
197 uhci_async_cancel(async
);
199 usb_device_ep_stopped(queue
->ep
->dev
, queue
->ep
);
201 trace_usb_uhci_queue_del(queue
->token
, reason
);
202 QTAILQ_REMOVE(&s
->queues
, queue
, next
);
206 static UHCIQueue
*uhci_queue_find(UHCIState
*s
, UHCI_TD
*td
)
208 uint32_t token
= uhci_queue_token(td
);
211 QTAILQ_FOREACH(queue
, &s
->queues
, next
) {
212 if (queue
->token
== token
) {
219 static bool uhci_queue_verify(UHCIQueue
*queue
, uint32_t qh_addr
, UHCI_TD
*td
,
220 uint32_t td_addr
, bool queuing
)
222 UHCIAsync
*first
= QTAILQ_FIRST(&queue
->asyncs
);
223 uint32_t queue_token_addr
= (queue
->token
>> 8) & 0x7f;
225 return queue
->qh_addr
== qh_addr
&&
226 queue
->token
== uhci_queue_token(td
) &&
227 queue_token_addr
== queue
->ep
->dev
->addr
&&
228 (queuing
|| !(td
->ctrl
& TD_CTRL_ACTIVE
) || first
== NULL
||
229 first
->td_addr
== td_addr
);
232 static UHCIAsync
*uhci_async_alloc(UHCIQueue
*queue
, uint32_t td_addr
)
234 UHCIAsync
*async
= g_new0(UHCIAsync
, 1);
236 async
->queue
= queue
;
237 async
->td_addr
= td_addr
;
238 usb_packet_init(&async
->packet
);
239 trace_usb_uhci_packet_add(async
->queue
->token
, async
->td_addr
);
244 static void uhci_async_free(UHCIAsync
*async
)
246 trace_usb_uhci_packet_del(async
->queue
->token
, async
->td_addr
);
247 usb_packet_cleanup(&async
->packet
);
248 if (async
->buf
!= async
->static_buf
) {
254 static void uhci_async_link(UHCIAsync
*async
)
256 UHCIQueue
*queue
= async
->queue
;
257 QTAILQ_INSERT_TAIL(&queue
->asyncs
, async
, next
);
258 trace_usb_uhci_packet_link_async(async
->queue
->token
, async
->td_addr
);
261 static void uhci_async_unlink(UHCIAsync
*async
)
263 UHCIQueue
*queue
= async
->queue
;
264 QTAILQ_REMOVE(&queue
->asyncs
, async
, next
);
265 trace_usb_uhci_packet_unlink_async(async
->queue
->token
, async
->td_addr
);
268 static void uhci_async_cancel(UHCIAsync
*async
)
270 uhci_async_unlink(async
);
271 trace_usb_uhci_packet_cancel(async
->queue
->token
, async
->td_addr
,
274 usb_cancel_packet(&async
->packet
);
275 uhci_async_free(async
);
279 * Mark all outstanding async packets as invalid.
280 * This is used for canceling them when TDs are removed by the HCD.
282 static void uhci_async_validate_begin(UHCIState
*s
)
286 QTAILQ_FOREACH(queue
, &s
->queues
, next
) {
292 * Cancel async packets that are no longer valid
294 static void uhci_async_validate_end(UHCIState
*s
)
296 UHCIQueue
*queue
, *n
;
298 QTAILQ_FOREACH_SAFE(queue
, &s
->queues
, next
, n
) {
300 uhci_queue_free(queue
, "validate-end");
305 static void uhci_async_cancel_device(UHCIState
*s
, USBDevice
*dev
)
307 UHCIQueue
*queue
, *n
;
309 QTAILQ_FOREACH_SAFE(queue
, &s
->queues
, next
, n
) {
310 if (queue
->ep
->dev
== dev
) {
311 uhci_queue_free(queue
, "cancel-device");
316 static void uhci_async_cancel_all(UHCIState
*s
)
318 UHCIQueue
*queue
, *nq
;
320 QTAILQ_FOREACH_SAFE(queue
, &s
->queues
, next
, nq
) {
321 uhci_queue_free(queue
, "cancel-all");
325 static UHCIAsync
*uhci_async_find_td(UHCIState
*s
, uint32_t td_addr
)
330 QTAILQ_FOREACH(queue
, &s
->queues
, next
) {
331 QTAILQ_FOREACH(async
, &queue
->asyncs
, next
) {
332 if (async
->td_addr
== td_addr
) {
340 static void uhci_update_irq(UHCIState
*s
)
343 if (((s
->status2
& 1) && (s
->intr
& (1 << 2))) ||
344 ((s
->status2
& 2) && (s
->intr
& (1 << 3))) ||
345 ((s
->status
& UHCI_STS_USBERR
) && (s
->intr
& (1 << 0))) ||
346 ((s
->status
& UHCI_STS_RD
) && (s
->intr
& (1 << 1))) ||
347 (s
->status
& UHCI_STS_HSERR
) ||
348 (s
->status
& UHCI_STS_HCPERR
)) {
353 pci_set_irq(&s
->dev
, level
);
356 static void uhci_reset(DeviceState
*dev
)
358 PCIDevice
*d
= PCI_DEVICE(dev
);
359 UHCIState
*s
= UHCI(d
);
364 trace_usb_uhci_reset();
366 pci_conf
= s
->dev
.config
;
368 pci_conf
[0x6a] = 0x01; /* usb clock */
369 pci_conf
[0x6b] = 0x00;
371 s
->status
= UHCI_STS_HCHALTED
;
377 for(i
= 0; i
< NB_PORTS
; i
++) {
380 if (port
->port
.dev
&& port
->port
.dev
->attached
) {
381 usb_port_reset(&port
->port
);
385 uhci_async_cancel_all(s
);
386 qemu_bh_cancel(s
->bh
);
390 static const VMStateDescription vmstate_uhci_port
= {
393 .minimum_version_id
= 1,
394 .fields
= (VMStateField
[]) {
395 VMSTATE_UINT16(ctrl
, UHCIPort
),
396 VMSTATE_END_OF_LIST()
400 static int uhci_post_load(void *opaque
, int version_id
)
402 UHCIState
*s
= opaque
;
404 if (version_id
< 2) {
405 s
->expire_time
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
406 (NANOSECONDS_PER_SECOND
/ FRAME_TIMER_FREQ
);
411 static const VMStateDescription vmstate_uhci
= {
414 .minimum_version_id
= 1,
415 .post_load
= uhci_post_load
,
416 .fields
= (VMStateField
[]) {
417 VMSTATE_PCI_DEVICE(dev
, UHCIState
),
418 VMSTATE_UINT8_EQUAL(num_ports_vmstate
, UHCIState
, NULL
),
419 VMSTATE_STRUCT_ARRAY(ports
, UHCIState
, NB_PORTS
, 1,
420 vmstate_uhci_port
, UHCIPort
),
421 VMSTATE_UINT16(cmd
, UHCIState
),
422 VMSTATE_UINT16(status
, UHCIState
),
423 VMSTATE_UINT16(intr
, UHCIState
),
424 VMSTATE_UINT16(frnum
, UHCIState
),
425 VMSTATE_UINT32(fl_base_addr
, UHCIState
),
426 VMSTATE_UINT8(sof_timing
, UHCIState
),
427 VMSTATE_UINT8(status2
, UHCIState
),
428 VMSTATE_TIMER_PTR(frame_timer
, UHCIState
),
429 VMSTATE_INT64_V(expire_time
, UHCIState
, 2),
430 VMSTATE_UINT32_V(pending_int_mask
, UHCIState
, 3),
431 VMSTATE_END_OF_LIST()
435 static void uhci_port_write(void *opaque
, hwaddr addr
,
436 uint64_t val
, unsigned size
)
438 UHCIState
*s
= opaque
;
440 trace_usb_uhci_mmio_writew(addr
, val
);
444 if ((val
& UHCI_CMD_RS
) && !(s
->cmd
& UHCI_CMD_RS
)) {
445 /* start frame processing */
446 trace_usb_uhci_schedule_start();
447 s
->expire_time
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) +
448 (NANOSECONDS_PER_SECOND
/ FRAME_TIMER_FREQ
);
449 timer_mod(s
->frame_timer
, s
->expire_time
);
450 s
->status
&= ~UHCI_STS_HCHALTED
;
451 } else if (!(val
& UHCI_CMD_RS
)) {
452 s
->status
|= UHCI_STS_HCHALTED
;
454 if (val
& UHCI_CMD_GRESET
) {
458 /* send reset on the USB bus */
459 for(i
= 0; i
< NB_PORTS
; i
++) {
461 usb_device_reset(port
->port
.dev
);
463 uhci_reset(DEVICE(s
));
466 if (val
& UHCI_CMD_HCRESET
) {
467 uhci_reset(DEVICE(s
));
471 if (val
& UHCI_CMD_EGSM
) {
472 if ((s
->ports
[0].ctrl
& UHCI_PORT_RD
) ||
473 (s
->ports
[1].ctrl
& UHCI_PORT_RD
)) {
480 /* XXX: the chip spec is not coherent, so we add a hidden
481 register to distinguish between IOC and SPD */
482 if (val
& UHCI_STS_USBINT
)
491 if (s
->status
& UHCI_STS_HCHALTED
)
492 s
->frnum
= val
& 0x7ff;
495 s
->fl_base_addr
&= 0xffff0000;
496 s
->fl_base_addr
|= val
& ~0xfff;
499 s
->fl_base_addr
&= 0x0000ffff;
500 s
->fl_base_addr
|= (val
<< 16);
503 s
->sof_timing
= val
& 0xff;
515 dev
= port
->port
.dev
;
516 if (dev
&& dev
->attached
) {
518 if ( (val
& UHCI_PORT_RESET
) &&
519 !(port
->ctrl
& UHCI_PORT_RESET
) ) {
520 usb_device_reset(dev
);
523 port
->ctrl
&= UHCI_PORT_READ_ONLY
;
524 /* enabled may only be set if a device is connected */
525 if (!(port
->ctrl
& UHCI_PORT_CCS
)) {
526 val
&= ~UHCI_PORT_EN
;
528 port
->ctrl
|= (val
& ~UHCI_PORT_READ_ONLY
);
529 /* some bits are reset when a '1' is written to them */
530 port
->ctrl
&= ~(val
& UHCI_PORT_WRITE_CLEAR
);
536 static uint64_t uhci_port_read(void *opaque
, hwaddr addr
, unsigned size
)
538 UHCIState
*s
= opaque
;
555 val
= s
->fl_base_addr
& 0xffff;
558 val
= (s
->fl_base_addr
>> 16) & 0xffff;
576 val
= 0xff7f; /* disabled port */
580 trace_usb_uhci_mmio_readw(addr
, val
);
585 /* signal resume if controller suspended */
586 static void uhci_resume (void *opaque
)
588 UHCIState
*s
= (UHCIState
*)opaque
;
593 if (s
->cmd
& UHCI_CMD_EGSM
) {
594 s
->cmd
|= UHCI_CMD_FGR
;
595 s
->status
|= UHCI_STS_RD
;
600 static void uhci_attach(USBPort
*port1
)
602 UHCIState
*s
= port1
->opaque
;
603 UHCIPort
*port
= &s
->ports
[port1
->index
];
605 /* set connect status */
606 port
->ctrl
|= UHCI_PORT_CCS
| UHCI_PORT_CSC
;
609 if (port
->port
.dev
->speed
== USB_SPEED_LOW
) {
610 port
->ctrl
|= UHCI_PORT_LSDA
;
612 port
->ctrl
&= ~UHCI_PORT_LSDA
;
618 static void uhci_detach(USBPort
*port1
)
620 UHCIState
*s
= port1
->opaque
;
621 UHCIPort
*port
= &s
->ports
[port1
->index
];
623 uhci_async_cancel_device(s
, port1
->dev
);
625 /* set connect status */
626 if (port
->ctrl
& UHCI_PORT_CCS
) {
627 port
->ctrl
&= ~UHCI_PORT_CCS
;
628 port
->ctrl
|= UHCI_PORT_CSC
;
631 if (port
->ctrl
& UHCI_PORT_EN
) {
632 port
->ctrl
&= ~UHCI_PORT_EN
;
633 port
->ctrl
|= UHCI_PORT_ENC
;
639 static void uhci_child_detach(USBPort
*port1
, USBDevice
*child
)
641 UHCIState
*s
= port1
->opaque
;
643 uhci_async_cancel_device(s
, child
);
646 static void uhci_wakeup(USBPort
*port1
)
648 UHCIState
*s
= port1
->opaque
;
649 UHCIPort
*port
= &s
->ports
[port1
->index
];
651 if (port
->ctrl
& UHCI_PORT_SUSPEND
&& !(port
->ctrl
& UHCI_PORT_RD
)) {
652 port
->ctrl
|= UHCI_PORT_RD
;
657 static USBDevice
*uhci_find_device(UHCIState
*s
, uint8_t addr
)
662 for (i
= 0; i
< NB_PORTS
; i
++) {
663 UHCIPort
*port
= &s
->ports
[i
];
664 if (!(port
->ctrl
& UHCI_PORT_EN
)) {
667 dev
= usb_find_device(&port
->port
, addr
);
675 static void uhci_read_td(UHCIState
*s
, UHCI_TD
*td
, uint32_t link
)
677 pci_dma_read(&s
->dev
, link
& ~0xf, td
, sizeof(*td
));
678 le32_to_cpus(&td
->link
);
679 le32_to_cpus(&td
->ctrl
);
680 le32_to_cpus(&td
->token
);
681 le32_to_cpus(&td
->buffer
);
684 static int uhci_handle_td_error(UHCIState
*s
, UHCI_TD
*td
, uint32_t td_addr
,
685 int status
, uint32_t *int_mask
)
687 uint32_t queue_token
= uhci_queue_token(td
);
692 td
->ctrl
|= TD_CTRL_NAK
;
693 return TD_RESULT_NEXT_QH
;
696 td
->ctrl
|= TD_CTRL_STALL
;
697 trace_usb_uhci_packet_complete_stall(queue_token
, td_addr
);
698 ret
= TD_RESULT_NEXT_QH
;
702 td
->ctrl
|= TD_CTRL_BABBLE
| TD_CTRL_STALL
;
703 /* frame interrupted */
704 trace_usb_uhci_packet_complete_babble(queue_token
, td_addr
);
705 ret
= TD_RESULT_STOP_FRAME
;
708 case USB_RET_IOERROR
:
711 td
->ctrl
|= TD_CTRL_TIMEOUT
;
712 td
->ctrl
&= ~(3 << TD_CTRL_ERROR_SHIFT
);
713 trace_usb_uhci_packet_complete_error(queue_token
, td_addr
);
714 ret
= TD_RESULT_NEXT_QH
;
718 td
->ctrl
&= ~TD_CTRL_ACTIVE
;
719 s
->status
|= UHCI_STS_USBERR
;
720 if (td
->ctrl
& TD_CTRL_IOC
) {
727 static int uhci_complete_td(UHCIState
*s
, UHCI_TD
*td
, UHCIAsync
*async
, uint32_t *int_mask
)
729 int len
= 0, max_len
;
732 max_len
= ((td
->token
>> 21) + 1) & 0x7ff;
733 pid
= td
->token
& 0xff;
735 if (td
->ctrl
& TD_CTRL_IOS
)
736 td
->ctrl
&= ~TD_CTRL_ACTIVE
;
738 if (async
->packet
.status
!= USB_RET_SUCCESS
) {
739 return uhci_handle_td_error(s
, td
, async
->td_addr
,
740 async
->packet
.status
, int_mask
);
743 len
= async
->packet
.actual_length
;
744 td
->ctrl
= (td
->ctrl
& ~0x7ff) | ((len
- 1) & 0x7ff);
746 /* The NAK bit may have been set by a previous frame, so clear it
747 here. The docs are somewhat unclear, but win2k relies on this
749 td
->ctrl
&= ~(TD_CTRL_ACTIVE
| TD_CTRL_NAK
);
750 if (td
->ctrl
& TD_CTRL_IOC
)
753 if (pid
== USB_TOKEN_IN
) {
754 pci_dma_write(&s
->dev
, td
->buffer
, async
->buf
, len
);
755 if ((td
->ctrl
& TD_CTRL_SPD
) && len
< max_len
) {
757 /* short packet: do not update QH */
758 trace_usb_uhci_packet_complete_shortxfer(async
->queue
->token
,
760 return TD_RESULT_NEXT_QH
;
765 trace_usb_uhci_packet_complete_success(async
->queue
->token
,
767 return TD_RESULT_COMPLETE
;
770 static int uhci_handle_td(UHCIState
*s
, UHCIQueue
*q
, uint32_t qh_addr
,
771 UHCI_TD
*td
, uint32_t td_addr
, uint32_t *int_mask
)
775 bool queuing
= (q
!= NULL
);
776 uint8_t pid
= td
->token
& 0xff;
779 async
= uhci_async_find_td(s
, td_addr
);
781 if (uhci_queue_verify(async
->queue
, qh_addr
, td
, td_addr
, queuing
)) {
782 assert(q
== NULL
|| q
== async
->queue
);
785 uhci_queue_free(async
->queue
, "guest re-used pending td");
791 q
= uhci_queue_find(s
, td
);
792 if (q
&& !uhci_queue_verify(q
, qh_addr
, td
, td_addr
, queuing
)) {
793 uhci_queue_free(q
, "guest re-used qh");
803 if (!(td
->ctrl
& TD_CTRL_ACTIVE
)) {
805 /* Guest marked a pending td non-active, cancel the queue */
806 uhci_queue_free(async
->queue
, "pending td non-active");
809 * ehci11d spec page 22: "Even if the Active bit in the TD is already
810 * cleared when the TD is fetched ... an IOC interrupt is generated"
812 if (td
->ctrl
& TD_CTRL_IOC
) {
815 return TD_RESULT_NEXT_QH
;
820 case USB_TOKEN_SETUP
:
824 /* invalid pid : frame interrupted */
825 s
->status
|= UHCI_STS_HCPERR
;
826 s
->cmd
&= ~UHCI_CMD_RS
;
828 return TD_RESULT_STOP_FRAME
;
833 /* we are busy filling the queue, we are not prepared
834 to consume completed packages then, just leave them
836 return TD_RESULT_ASYNC_CONT
;
840 UHCIAsync
*last
= QTAILQ_LAST(&async
->queue
->asyncs
);
842 * While we are waiting for the current td to complete, the guest
843 * may have added more tds to the queue. Note we re-read the td
844 * rather then caching it, as we want to see guest made changes!
846 uhci_read_td(s
, &last_td
, last
->td_addr
);
847 uhci_queue_fill(async
->queue
, &last_td
);
849 return TD_RESULT_ASYNC_CONT
;
851 uhci_async_unlink(async
);
855 if (s
->completions_only
) {
856 return TD_RESULT_ASYNC_CONT
;
859 /* Allocate new packet */
864 dev
= uhci_find_device(s
, (td
->token
>> 8) & 0x7f);
866 return uhci_handle_td_error(s
, td
, td_addr
, USB_RET_NODEV
,
869 ep
= usb_ep_get(dev
, pid
, (td
->token
>> 15) & 0xf);
870 q
= uhci_queue_new(s
, qh_addr
, td
, ep
);
872 async
= uhci_async_alloc(q
, td_addr
);
874 max_len
= ((td
->token
>> 21) + 1) & 0x7ff;
875 spd
= (pid
== USB_TOKEN_IN
&& (td
->ctrl
& TD_CTRL_SPD
) != 0);
876 usb_packet_setup(&async
->packet
, pid
, q
->ep
, 0, td_addr
, spd
,
877 (td
->ctrl
& TD_CTRL_IOC
) != 0);
878 if (max_len
<= sizeof(async
->static_buf
)) {
879 async
->buf
= async
->static_buf
;
881 async
->buf
= g_malloc(max_len
);
883 usb_packet_addbuf(&async
->packet
, async
->buf
, max_len
);
887 case USB_TOKEN_SETUP
:
888 pci_dma_read(&s
->dev
, td
->buffer
, async
->buf
, max_len
);
889 usb_handle_packet(q
->ep
->dev
, &async
->packet
);
890 if (async
->packet
.status
== USB_RET_SUCCESS
) {
891 async
->packet
.actual_length
= max_len
;
896 usb_handle_packet(q
->ep
->dev
, &async
->packet
);
900 abort(); /* Never to execute */
903 if (async
->packet
.status
== USB_RET_ASYNC
) {
904 uhci_async_link(async
);
906 uhci_queue_fill(q
, td
);
908 return TD_RESULT_ASYNC_START
;
912 ret
= uhci_complete_td(s
, td
, async
, int_mask
);
913 uhci_async_free(async
);
917 static void uhci_async_complete(USBPort
*port
, USBPacket
*packet
)
919 UHCIAsync
*async
= container_of(packet
, UHCIAsync
, packet
);
920 UHCIState
*s
= async
->queue
->uhci
;
922 if (packet
->status
== USB_RET_REMOVE_FROM_QUEUE
) {
923 uhci_async_cancel(async
);
928 /* Force processing of this packet *now*, needed for migration */
929 s
->completions_only
= true;
930 qemu_bh_schedule(s
->bh
);
933 static int is_valid(uint32_t link
)
935 return (link
& 1) == 0;
938 static int is_qh(uint32_t link
)
940 return (link
& 2) != 0;
943 static int depth_first(uint32_t link
)
945 return (link
& 4) != 0;
948 /* QH DB used for detecting QH loops */
949 #define UHCI_MAX_QUEUES 128
951 uint32_t addr
[UHCI_MAX_QUEUES
];
955 static void qhdb_reset(QhDb
*db
)
960 /* Add QH to DB. Returns 1 if already present or DB is full. */
961 static int qhdb_insert(QhDb
*db
, uint32_t addr
)
964 for (i
= 0; i
< db
->count
; i
++)
965 if (db
->addr
[i
] == addr
)
968 if (db
->count
>= UHCI_MAX_QUEUES
)
971 db
->addr
[db
->count
++] = addr
;
975 static void uhci_queue_fill(UHCIQueue
*q
, UHCI_TD
*td
)
977 uint32_t int_mask
= 0;
978 uint32_t plink
= td
->link
;
982 while (is_valid(plink
)) {
983 uhci_read_td(q
->uhci
, &ptd
, plink
);
984 if (!(ptd
.ctrl
& TD_CTRL_ACTIVE
)) {
987 if (uhci_queue_token(&ptd
) != q
->token
) {
990 trace_usb_uhci_td_queue(plink
& ~0xf, ptd
.ctrl
, ptd
.token
);
991 ret
= uhci_handle_td(q
->uhci
, q
, q
->qh_addr
, &ptd
, plink
, &int_mask
);
992 if (ret
== TD_RESULT_ASYNC_CONT
) {
995 assert(ret
== TD_RESULT_ASYNC_START
);
996 assert(int_mask
== 0);
999 usb_device_flush_ep_queue(q
->ep
->dev
, q
->ep
);
1002 static void uhci_process_frame(UHCIState
*s
)
1004 uint32_t frame_addr
, link
, old_td_ctrl
, val
, int_mask
;
1005 uint32_t curr_qh
, td_count
= 0;
1011 frame_addr
= s
->fl_base_addr
+ ((s
->frnum
& 0x3ff) << 2);
1013 pci_dma_read(&s
->dev
, frame_addr
, &link
, 4);
1014 le32_to_cpus(&link
);
1021 for (cnt
= FRAME_MAX_LOOPS
; is_valid(link
) && cnt
; cnt
--) {
1022 if (!s
->completions_only
&& s
->frame_bytes
>= s
->frame_bandwidth
) {
1023 /* We've reached the usb 1.1 bandwidth, which is
1024 1280 bytes/frame, stop processing */
1025 trace_usb_uhci_frame_stop_bandwidth();
1030 trace_usb_uhci_qh_load(link
& ~0xf);
1032 if (qhdb_insert(&qhdb
, link
)) {
1034 * We're going in circles. Which is not a bug because
1035 * HCD is allowed to do that as part of the BW management.
1037 * Stop processing here if no transaction has been done
1038 * since we've been here last time.
1040 if (td_count
== 0) {
1041 trace_usb_uhci_frame_loop_stop_idle();
1044 trace_usb_uhci_frame_loop_continue();
1047 qhdb_insert(&qhdb
, link
);
1051 pci_dma_read(&s
->dev
, link
& ~0xf, &qh
, sizeof(qh
));
1052 le32_to_cpus(&qh
.link
);
1053 le32_to_cpus(&qh
.el_link
);
1055 if (!is_valid(qh
.el_link
)) {
1056 /* QH w/o elements */
1060 /* QH with elements */
1068 uhci_read_td(s
, &td
, link
);
1069 trace_usb_uhci_td_load(curr_qh
& ~0xf, link
& ~0xf, td
.ctrl
, td
.token
);
1071 old_td_ctrl
= td
.ctrl
;
1072 ret
= uhci_handle_td(s
, NULL
, curr_qh
, &td
, link
, &int_mask
);
1073 if (old_td_ctrl
!= td
.ctrl
) {
1074 /* update the status bits of the TD */
1075 val
= cpu_to_le32(td
.ctrl
);
1076 pci_dma_write(&s
->dev
, (link
& ~0xf) + 4, &val
, sizeof(val
));
1080 case TD_RESULT_STOP_FRAME
: /* interrupted frame */
1083 case TD_RESULT_NEXT_QH
:
1084 case TD_RESULT_ASYNC_CONT
:
1085 trace_usb_uhci_td_nextqh(curr_qh
& ~0xf, link
& ~0xf);
1086 link
= curr_qh
? qh
.link
: td
.link
;
1089 case TD_RESULT_ASYNC_START
:
1090 trace_usb_uhci_td_async(curr_qh
& ~0xf, link
& ~0xf);
1091 link
= curr_qh
? qh
.link
: td
.link
;
1094 case TD_RESULT_COMPLETE
:
1095 trace_usb_uhci_td_complete(curr_qh
& ~0xf, link
& ~0xf);
1098 s
->frame_bytes
+= (td
.ctrl
& 0x7ff) + 1;
1101 /* update QH element link */
1103 val
= cpu_to_le32(qh
.el_link
);
1104 pci_dma_write(&s
->dev
, (curr_qh
& ~0xf) + 4, &val
, sizeof(val
));
1106 if (!depth_first(link
)) {
1107 /* done with this QH */
1115 assert(!"unknown return code");
1118 /* go to the next entry */
1122 s
->pending_int_mask
|= int_mask
;
1125 static void uhci_bh(void *opaque
)
1127 UHCIState
*s
= opaque
;
1128 uhci_process_frame(s
);
1131 static void uhci_frame_timer(void *opaque
)
1133 UHCIState
*s
= opaque
;
1134 uint64_t t_now
, t_last_run
;
1136 const uint64_t frame_t
= NANOSECONDS_PER_SECOND
/ FRAME_TIMER_FREQ
;
1138 s
->completions_only
= false;
1139 qemu_bh_cancel(s
->bh
);
1141 if (!(s
->cmd
& UHCI_CMD_RS
)) {
1143 trace_usb_uhci_schedule_stop();
1144 timer_del(s
->frame_timer
);
1145 uhci_async_cancel_all(s
);
1146 /* set hchalted bit in status - UHCI11D 2.1.2 */
1147 s
->status
|= UHCI_STS_HCHALTED
;
1151 /* We still store expire_time in our state, for migration */
1152 t_last_run
= s
->expire_time
- frame_t
;
1153 t_now
= qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
1155 /* Process up to MAX_FRAMES_PER_TICK frames */
1156 frames
= (t_now
- t_last_run
) / frame_t
;
1157 if (frames
> s
->maxframes
) {
1158 int skipped
= frames
- s
->maxframes
;
1159 s
->expire_time
+= skipped
* frame_t
;
1160 s
->frnum
= (s
->frnum
+ skipped
) & 0x7ff;
1163 if (frames
> MAX_FRAMES_PER_TICK
) {
1164 frames
= MAX_FRAMES_PER_TICK
;
1167 for (i
= 0; i
< frames
; i
++) {
1169 trace_usb_uhci_frame_start(s
->frnum
);
1170 uhci_async_validate_begin(s
);
1171 uhci_process_frame(s
);
1172 uhci_async_validate_end(s
);
1173 /* The spec says frnum is the frame currently being processed, and
1174 * the guest must look at frnum - 1 on interrupt, so inc frnum now */
1175 s
->frnum
= (s
->frnum
+ 1) & 0x7ff;
1176 s
->expire_time
+= frame_t
;
1179 /* Complete the previous frame(s) */
1180 if (s
->pending_int_mask
) {
1181 s
->status2
|= s
->pending_int_mask
;
1182 s
->status
|= UHCI_STS_USBINT
;
1185 s
->pending_int_mask
= 0;
1187 timer_mod(s
->frame_timer
, t_now
+ frame_t
);
1190 static const MemoryRegionOps uhci_ioport_ops
= {
1191 .read
= uhci_port_read
,
1192 .write
= uhci_port_write
,
1193 .valid
.min_access_size
= 1,
1194 .valid
.max_access_size
= 4,
1195 .impl
.min_access_size
= 2,
1196 .impl
.max_access_size
= 2,
1197 .endianness
= DEVICE_LITTLE_ENDIAN
,
1200 static USBPortOps uhci_port_ops
= {
1201 .attach
= uhci_attach
,
1202 .detach
= uhci_detach
,
1203 .child_detach
= uhci_child_detach
,
1204 .wakeup
= uhci_wakeup
,
1205 .complete
= uhci_async_complete
,
1208 static USBBusOps uhci_bus_ops
= {
1211 static void usb_uhci_common_realize(PCIDevice
*dev
, Error
**errp
)
1214 PCIDeviceClass
*pc
= PCI_DEVICE_GET_CLASS(dev
);
1215 UHCIPCIDeviceClass
*u
= container_of(pc
, UHCIPCIDeviceClass
, parent_class
);
1216 UHCIState
*s
= UHCI(dev
);
1217 uint8_t *pci_conf
= s
->dev
.config
;
1220 pci_conf
[PCI_CLASS_PROG
] = 0x00;
1221 /* TODO: reset value should be 0. */
1222 pci_conf
[USB_SBRN
] = USB_RELEASE_1
; // release number
1224 pci_config_set_interrupt_pin(pci_conf
, u
->info
.irq_pin
+ 1);
1227 USBPort
*ports
[NB_PORTS
];
1228 for(i
= 0; i
< NB_PORTS
; i
++) {
1229 ports
[i
] = &s
->ports
[i
].port
;
1231 usb_register_companion(s
->masterbus
, ports
, NB_PORTS
,
1232 s
->firstport
, s
, &uhci_port_ops
,
1233 USB_SPEED_MASK_LOW
| USB_SPEED_MASK_FULL
,
1236 error_propagate(errp
, err
);
1240 usb_bus_new(&s
->bus
, sizeof(s
->bus
), &uhci_bus_ops
, DEVICE(dev
));
1241 for (i
= 0; i
< NB_PORTS
; i
++) {
1242 usb_register_port(&s
->bus
, &s
->ports
[i
].port
, s
, i
, &uhci_port_ops
,
1243 USB_SPEED_MASK_LOW
| USB_SPEED_MASK_FULL
);
1246 s
->bh
= qemu_bh_new(uhci_bh
, s
);
1247 s
->frame_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, uhci_frame_timer
, s
);
1248 s
->num_ports_vmstate
= NB_PORTS
;
1249 QTAILQ_INIT(&s
->queues
);
1251 memory_region_init_io(&s
->io_bar
, OBJECT(s
), &uhci_ioport_ops
, s
,
1254 /* Use region 4 for consistency with real hardware. BSD guests seem
1256 pci_register_bar(&s
->dev
, 4, PCI_BASE_ADDRESS_SPACE_IO
, &s
->io_bar
);
1259 static void usb_uhci_vt82c686b_realize(PCIDevice
*dev
, Error
**errp
)
1261 UHCIState
*s
= UHCI(dev
);
1262 uint8_t *pci_conf
= s
->dev
.config
;
1264 /* USB misc control 1/2 */
1265 pci_set_long(pci_conf
+ 0x40,0x00001000);
1267 pci_set_long(pci_conf
+ 0x80,0x00020001);
1268 /* USB legacy support */
1269 pci_set_long(pci_conf
+ 0xc0,0x00002000);
1271 usb_uhci_common_realize(dev
, errp
);
1274 static void usb_uhci_exit(PCIDevice
*dev
)
1276 UHCIState
*s
= UHCI(dev
);
1278 trace_usb_uhci_exit();
1280 if (s
->frame_timer
) {
1281 timer_del(s
->frame_timer
);
1282 timer_free(s
->frame_timer
);
1283 s
->frame_timer
= NULL
;
1287 qemu_bh_delete(s
->bh
);
1290 uhci_async_cancel_all(s
);
1292 if (!s
->masterbus
) {
1293 usb_bus_release(&s
->bus
);
1297 static Property uhci_properties_companion
[] = {
1298 DEFINE_PROP_STRING("masterbus", UHCIState
, masterbus
),
1299 DEFINE_PROP_UINT32("firstport", UHCIState
, firstport
, 0),
1300 DEFINE_PROP_UINT32("bandwidth", UHCIState
, frame_bandwidth
, 1280),
1301 DEFINE_PROP_UINT32("maxframes", UHCIState
, maxframes
, 128),
1302 DEFINE_PROP_END_OF_LIST(),
1304 static Property uhci_properties_standalone
[] = {
1305 DEFINE_PROP_UINT32("bandwidth", UHCIState
, frame_bandwidth
, 1280),
1306 DEFINE_PROP_UINT32("maxframes", UHCIState
, maxframes
, 128),
1307 DEFINE_PROP_END_OF_LIST(),
1310 static void uhci_class_init(ObjectClass
*klass
, void *data
)
1312 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1313 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1315 k
->class_id
= PCI_CLASS_SERIAL_USB
;
1316 dc
->vmsd
= &vmstate_uhci
;
1317 dc
->reset
= uhci_reset
;
1318 set_bit(DEVICE_CATEGORY_USB
, dc
->categories
);
1321 static const TypeInfo uhci_pci_type_info
= {
1323 .parent
= TYPE_PCI_DEVICE
,
1324 .instance_size
= sizeof(UHCIState
),
1325 .class_size
= sizeof(UHCIPCIDeviceClass
),
1327 .class_init
= uhci_class_init
,
1328 .interfaces
= (InterfaceInfo
[]) {
1329 { INTERFACE_CONVENTIONAL_PCI_DEVICE
},
1334 static void uhci_data_class_init(ObjectClass
*klass
, void *data
)
1336 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1337 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1338 UHCIPCIDeviceClass
*u
= container_of(k
, UHCIPCIDeviceClass
, parent_class
);
1339 UHCIInfo
*info
= data
;
1341 k
->realize
= info
->realize
? info
->realize
: usb_uhci_common_realize
;
1342 k
->exit
= info
->unplug
? usb_uhci_exit
: NULL
;
1343 k
->vendor_id
= info
->vendor_id
;
1344 k
->device_id
= info
->device_id
;
1345 k
->revision
= info
->revision
;
1346 if (!info
->unplug
) {
1347 /* uhci controllers in companion setups can't be hotplugged */
1348 dc
->hotpluggable
= false;
1349 dc
->props
= uhci_properties_companion
;
1351 dc
->props
= uhci_properties_standalone
;
1356 static UHCIInfo uhci_info
[] = {
1358 .name
= "piix3-usb-uhci",
1359 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1360 .device_id
= PCI_DEVICE_ID_INTEL_82371SB_2
,
1365 .name
= "piix4-usb-uhci",
1366 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1367 .device_id
= PCI_DEVICE_ID_INTEL_82371AB_2
,
1372 .name
= "vt82c686b-usb-uhci",
1373 .vendor_id
= PCI_VENDOR_ID_VIA
,
1374 .device_id
= PCI_DEVICE_ID_VIA_UHCI
,
1377 .realize
= usb_uhci_vt82c686b_realize
,
1380 .name
= "ich9-usb-uhci1", /* 00:1d.0 */
1381 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1382 .device_id
= PCI_DEVICE_ID_INTEL_82801I_UHCI1
,
1387 .name
= "ich9-usb-uhci2", /* 00:1d.1 */
1388 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1389 .device_id
= PCI_DEVICE_ID_INTEL_82801I_UHCI2
,
1394 .name
= "ich9-usb-uhci3", /* 00:1d.2 */
1395 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1396 .device_id
= PCI_DEVICE_ID_INTEL_82801I_UHCI3
,
1401 .name
= "ich9-usb-uhci4", /* 00:1a.0 */
1402 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1403 .device_id
= PCI_DEVICE_ID_INTEL_82801I_UHCI4
,
1408 .name
= "ich9-usb-uhci5", /* 00:1a.1 */
1409 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1410 .device_id
= PCI_DEVICE_ID_INTEL_82801I_UHCI5
,
1415 .name
= "ich9-usb-uhci6", /* 00:1a.2 */
1416 .vendor_id
= PCI_VENDOR_ID_INTEL
,
1417 .device_id
= PCI_DEVICE_ID_INTEL_82801I_UHCI6
,
1424 static void uhci_register_types(void)
1426 TypeInfo uhci_type_info
= {
1427 .parent
= TYPE_UHCI
,
1428 .class_init
= uhci_data_class_init
,
1432 type_register_static(&uhci_pci_type_info
);
1434 for (i
= 0; i
< ARRAY_SIZE(uhci_info
); i
++) {
1435 uhci_type_info
.name
= uhci_info
[i
].name
;
1436 uhci_type_info
.class_data
= uhci_info
+ i
;
1437 type_register(&uhci_type_info
);
1441 type_init(uhci_register_types
)