#include "console.h"
#include "usb.h"
#include "usb-desc.h"
-#include "sysemu.h"
+#include "qemu-timer.h"
/* HID interface requests */
#define GET_REPORT 0xa101
typedef struct USBMouseState {
USBPointerEvent queue[QUEUE_LENGTH];
- uint32_t head; /* index into circular queue */
- uint32_t n;
int mouse_grabbed;
QEMUPutMouseEntry *eh_entry;
} USBMouseState;
typedef struct USBKeyboardState {
uint32_t keycodes[QUEUE_LENGTH];
- uint32_t head; /* index into circular queue */
- uint32_t n;
uint16_t modifiers;
uint8_t leds;
uint8_t key[16];
- int keys;
+ int32_t keys;
} USBKeyboardState;
typedef struct USBHIDState {
USBMouseState ptr;
USBKeyboardState kbd;
};
+ uint32_t head; /* index into circular queue */
+ uint32_t n;
int kind;
- int protocol;
+ int32_t protocol;
uint8_t idle;
int64_t next_idle_clock;
int changed;
{
USBHIDState *hs = opaque;
USBMouseState *s = &hs->ptr;
- unsigned use_slot = (s->head + s->n - 1) & QUEUE_MASK;
+ unsigned use_slot = (hs->head + hs->n - 1) & QUEUE_MASK;
unsigned previous_slot = (use_slot - 1) & QUEUE_MASK;
/* We combine events where feasible to keep the queue small. We shouldn't
* that would change the location of the button state change. When the
* queue is empty, a second event is needed because we don't know if
* the first event changed the button state. */
- if (s->n == QUEUE_LENGTH) {
+ if (hs->n == QUEUE_LENGTH) {
/* Queue full. Discard old button state, combine motion normally. */
s->queue[use_slot].buttons_state = buttons_state;
- } else if (s->n < 2 ||
+ } else if (hs->n < 2 ||
s->queue[use_slot].buttons_state != buttons_state ||
s->queue[previous_slot].buttons_state != s->queue[use_slot].buttons_state) {
/* Cannot or should not combine, so add an empty item to the queue. */
QUEUE_INCR(use_slot);
- s->n++;
+ hs->n++;
usb_pointer_event_clear(&s->queue[use_slot], buttons_state);
}
usb_pointer_event_combine(&s->queue[use_slot],
USBKeyboardState *s = &hs->kbd;
int slot;
- if (s->n == QUEUE_LENGTH) {
+ if (hs->n == QUEUE_LENGTH) {
fprintf(stderr, "usb-kbd: warning: key event queue full\n");
return;
}
- slot = (s->head + s->n) & QUEUE_MASK; s->n++;
+ slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++;
s->keycodes[slot] = keycode;
usb_hid_changed(hs);
}
-static void usb_keyboard_process_keycode(USBKeyboardState *s)
+static void usb_keyboard_process_keycode(USBHIDState *hs)
{
+ USBKeyboardState *s = &hs->kbd;
uint8_t hid_code, key;
int i, keycode, slot;
- if (s->n == 0) {
+ if (hs->n == 0) {
return;
}
- slot = s->head & QUEUE_MASK; QUEUE_INCR(s->head); s->n--;
+ slot = hs->head & QUEUE_MASK; QUEUE_INCR(hs->head); hs->n--;
keycode = s->keycodes[slot];
key = keycode & 0x7f;
/* When the buffer is empty, return the last event. Relative
movements will all be zero. */
- index = (s->n ? s->head : s->head - 1);
+ index = (hs->n ? hs->head : hs->head - 1);
e = &s->queue[index & QUEUE_MASK];
if (hs->kind == USB_MOUSE) {
if (e->buttons_state & MOUSE_EVENT_MBUTTON)
b |= 0x04;
- if (s->n &&
+ if (hs->n &&
!e->dz &&
(hs->kind == USB_TABLET || (!e->xdx && !e->ydy))) {
/* that deals with this event */
- QUEUE_INCR(s->head);
- s->n--;
+ QUEUE_INCR(hs->head);
+ hs->n--;
}
/* Appears we have to invert the wheel direction */
if (len < 2)
return 0;
- usb_keyboard_process_keycode(s);
+ usb_keyboard_process_keycode(hs);
buf[0] = s->modifiers & 0xff;
buf[1] = 0;
USBHIDState *s = (USBHIDState *)dev;
memset(s->ptr.queue, 0, sizeof (s->ptr.queue));
- s->ptr.head = 0;
- s->ptr.n = 0;
+ s->head = 0;
+ s->n = 0;
s->protocol = 1;
}
qemu_add_kbd_event_handler(usb_keyboard_event, s);
memset(s->kbd.keycodes, 0, sizeof (s->kbd.keycodes));
- s->kbd.head = 0;
- s->kbd.n = 0;
+ s->head = 0;
+ s->n = 0;
memset(s->kbd.key, 0, sizeof (s->kbd.key));
s->kbd.keys = 0;
s->protocol = 1;
break;
case SET_IDLE:
s->idle = (uint8_t) (value >> 8);
- usb_hid_set_next_idle(s, qemu_get_clock(vm_clock));
+ usb_hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
ret = 0;
break;
default:
switch(p->pid) {
case USB_TOKEN_IN:
if (p->devep == 1) {
- int64_t curtime = qemu_get_clock(vm_clock);
+ int64_t curtime = qemu_get_clock_ns(vm_clock);
if (!s->changed && (!s->idle || s->next_idle_clock - curtime > 0))
return USB_RET_NAK;
usb_hid_set_next_idle(s, curtime);
if (s->kind == USB_MOUSE || s->kind == USB_TABLET) {
ret = usb_pointer_poll(s, p->data, p->len);
- s->changed = s->ptr.n > 0;
}
else if (s->kind == USB_KEYBOARD) {
ret = usb_keyboard_poll(s, p->data, p->len);
- s->changed = s->kbd.n > 0;
}
+ s->changed = s->n > 0;
} else {
goto fail;
}
s->datain = datain;
}
+static int usb_hid_post_load(void *opaque, int version_id)
+{
+ USBHIDState *s = opaque;
+
+ if (s->idle) {
+ usb_hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
+ }
+ return 0;
+}
+
+static const VMStateDescription vmstate_usb_ptr_queue = {
+ .name = "usb-ptr-queue",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .fields = (VMStateField []) {
+ VMSTATE_INT32(xdx, USBPointerEvent),
+ VMSTATE_INT32(ydy, USBPointerEvent),
+ VMSTATE_INT32(dz, USBPointerEvent),
+ VMSTATE_INT32(buttons_state, USBPointerEvent),
+ VMSTATE_END_OF_LIST()
+ }
+};
+static const VMStateDescription vmstate_usb_ptr = {
+ .name = "usb-ptr",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .post_load = usb_hid_post_load,
+ .fields = (VMStateField []) {
+ VMSTATE_USB_DEVICE(dev, USBHIDState),
+ VMSTATE_STRUCT_ARRAY(ptr.queue, USBHIDState, QUEUE_LENGTH, 0,
+ vmstate_usb_ptr_queue, USBPointerEvent),
+ VMSTATE_UINT32(head, USBHIDState),
+ VMSTATE_UINT32(n, USBHIDState),
+ VMSTATE_INT32(protocol, USBHIDState),
+ VMSTATE_UINT8(idle, USBHIDState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static const VMStateDescription vmstate_usb_kbd = {
+ .name = "usb-kbd",
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .post_load = usb_hid_post_load,
+ .fields = (VMStateField []) {
+ VMSTATE_USB_DEVICE(dev, USBHIDState),
+ VMSTATE_UINT32_ARRAY(kbd.keycodes, USBHIDState, QUEUE_LENGTH),
+ VMSTATE_UINT32(head, USBHIDState),
+ VMSTATE_UINT32(n, USBHIDState),
+ VMSTATE_UINT16(kbd.modifiers, USBHIDState),
+ VMSTATE_UINT8(kbd.leds, USBHIDState),
+ VMSTATE_UINT8_ARRAY(kbd.key, USBHIDState, 16),
+ VMSTATE_INT32(kbd.keys, USBHIDState),
+ VMSTATE_INT32(protocol, USBHIDState),
+ VMSTATE_UINT8(idle, USBHIDState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
static struct USBDeviceInfo hid_info[] = {
{
.product_desc = "QEMU USB Tablet",
.qdev.name = "usb-tablet",
.usbdevice_name = "tablet",
.qdev.size = sizeof(USBHIDState),
+ .qdev.vmsd = &vmstate_usb_ptr,
.usb_desc = &desc_tablet,
.init = usb_tablet_initfn,
.handle_packet = usb_generic_handle_packet,
.qdev.name = "usb-mouse",
.usbdevice_name = "mouse",
.qdev.size = sizeof(USBHIDState),
+ .qdev.vmsd = &vmstate_usb_ptr,
.usb_desc = &desc_mouse,
.init = usb_mouse_initfn,
.handle_packet = usb_generic_handle_packet,
.qdev.name = "usb-kbd",
.usbdevice_name = "keyboard",
.qdev.size = sizeof(USBHIDState),
+ .qdev.vmsd = &vmstate_usb_kbd,
.usb_desc = &desc_keyboard,
.init = usb_keyboard_initfn,
.handle_packet = usb_generic_handle_packet,
projects / qemu.git / blobdiff