2 * QEMU PS/2 keyboard/mouse emulation
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "hw/input/ps2.h"
26 #include "ui/console.h"
28 #include "sysemu/sysemu.h"
32 /* to guarantee safe serialization of input event by Munkyu Im */
33 #include "qemu/thread.h"
34 static QemuMutex mutex;
37 /* debug PC keyboard */
40 /* debug PC keyboard : only mouse */
43 /* Keyboard Commands */
44 #define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
45 #define KBD_CMD_ECHO 0xEE
46 #define KBD_CMD_SCANCODE 0xF0 /* Get/set scancode set */
47 #define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
48 #define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
49 #define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
50 #define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
51 #define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
52 #define KBD_CMD_RESET 0xFF /* Reset */
54 /* Keyboard Replies */
55 #define KBD_REPLY_POR 0xAA /* Power on reset */
56 #define KBD_REPLY_ID 0xAB /* Keyboard ID */
57 #define KBD_REPLY_ACK 0xFA /* Command ACK */
58 #define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
61 #define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
62 #define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
63 #define AUX_SET_RES 0xE8 /* Set resolution */
64 #define AUX_GET_SCALE 0xE9 /* Get scaling factor */
65 #define AUX_SET_STREAM 0xEA /* Set stream mode */
66 #define AUX_POLL 0xEB /* Poll */
67 #define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
68 #define AUX_SET_WRAP 0xEE /* Set wrap mode */
69 #define AUX_SET_REMOTE 0xF0 /* Set remote mode */
70 #define AUX_GET_TYPE 0xF2 /* Get type */
71 #define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
72 #define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
73 #define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
74 #define AUX_SET_DEFAULT 0xF6
75 #define AUX_RESET 0xFF /* Reset aux device */
76 #define AUX_ACK 0xFA /* Command byte ACK. */
78 #define MOUSE_STATUS_REMOTE 0x40
79 #define MOUSE_STATUS_ENABLED 0x20
80 #define MOUSE_STATUS_SCALE21 0x10
82 #define PS2_QUEUE_SIZE 16 /* Buffer size required by PS/2 protocol */
85 /* Keep the data array 256 bytes long, which compatibility
86 with older qemu versions. */
88 int rptr, wptr, count;
94 void (*update_irq)(void *, int);
101 /* QEMU uses translated PC scancodes internally. To avoid multiple
102 conversions we do the translation (if any) in the PS/2 emulation
103 not the keyboard controller. */
105 int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
111 uint8_t mouse_status;
112 uint8_t mouse_resolution;
113 uint8_t mouse_sample_rate;
115 uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
116 uint8_t mouse_detect_state;
117 int mouse_dx; /* current values, needed for 'poll' mode */
120 uint8_t mouse_buttons;
123 /* Table to convert from PC scancodes to raw scancodes. */
124 static const unsigned char ps2_raw_keycode[128] = {
125 0, 118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
126 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
127 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
128 50, 49, 58, 65, 73, 74, 89, 124, 17, 41, 88, 5, 6, 4, 12, 3,
129 11, 2, 10, 1, 9, 119, 126, 108, 117, 125, 123, 107, 115, 116, 121, 105,
130 114, 122, 112, 113, 127, 96, 97, 120, 7, 15, 23, 31, 39, 47, 55, 63,
131 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
132 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
134 static const unsigned char ps2_raw_keycode_set3[128] = {
135 0, 8, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
136 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 17, 28, 27,
137 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 92, 26, 34, 33, 42,
138 50, 49, 58, 65, 73, 74, 89, 126, 25, 41, 20, 7, 15, 23, 31, 39,
139 47, 2, 63, 71, 79, 118, 95, 108, 117, 125, 132, 107, 115, 116, 124, 105,
140 114, 122, 112, 113, 127, 96, 97, 86, 94, 15, 23, 31, 39, 47, 55, 63,
141 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
142 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
145 void ps2_queue(void *opaque, int b)
147 PS2State *s = (PS2State *)opaque;
148 PS2Queue *q = &s->queue;
150 if (q->count >= PS2_QUEUE_SIZE - 1)
152 q->data[q->wptr] = b;
153 if (++q->wptr == PS2_QUEUE_SIZE)
156 s->update_irq(s->update_arg, 1);
160 keycode is expressed as follow:
161 bit 7 - 0 key pressed, 1 = key released
162 bits 6-0 - translated scancode set 2
164 static void ps2_put_keycode(void *opaque, int keycode)
166 PS2KbdState *s = opaque;
168 trace_ps2_put_keycode(opaque, keycode);
169 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
170 /* XXX: add support for scancode set 1 */
171 if (!s->translate && keycode < 0xe0 && s->scancode_set > 1) {
172 if (keycode & 0x80) {
173 ps2_queue(&s->common, 0xf0);
175 if (s->scancode_set == 2) {
176 keycode = ps2_raw_keycode[keycode & 0x7f];
177 } else if (s->scancode_set == 3) {
178 keycode = ps2_raw_keycode_set3[keycode & 0x7f];
181 ps2_queue(&s->common, keycode);
184 static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
187 PS2KbdState *s = (PS2KbdState *)dev;
188 int scancodes[3], i, count;
190 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
191 count = qemu_input_key_value_to_scancode(evt->u.key->key,
194 for (i = 0; i < count; i++) {
195 ps2_put_keycode(s, scancodes[i]);
199 uint32_t ps2_read_data(void *opaque)
201 PS2State *s = (PS2State *)opaque;
205 trace_ps2_read_data(opaque);
208 /* NOTE: if no data left, we return the last keyboard one
209 (needed for EMM386) */
210 /* XXX: need a timer to do things correctly */
213 index = PS2_QUEUE_SIZE - 1;
214 val = q->data[index];
216 val = q->data[q->rptr];
217 if (++q->rptr == PS2_QUEUE_SIZE)
220 /* reading deasserts IRQ */
221 s->update_irq(s->update_arg, 0);
222 /* reassert IRQs if data left */
223 s->update_irq(s->update_arg, q->count != 0);
228 static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
230 trace_ps2_set_ledstate(s, ledstate);
231 s->ledstate = ledstate;
232 kbd_put_ledstate(ledstate);
235 static void ps2_reset_keyboard(PS2KbdState *s)
237 trace_ps2_reset_keyboard(s);
240 ps2_set_ledstate(s, 0);
243 void ps2_write_keyboard(void *opaque, int val)
245 PS2KbdState *s = (PS2KbdState *)opaque;
247 trace_ps2_write_keyboard(opaque, val);
248 switch(s->common.write_cmd) {
253 ps2_queue(&s->common, KBD_REPLY_ACK);
256 ps2_queue(&s->common, KBD_REPLY_RESEND);
259 ps2_queue(&s->common, KBD_REPLY_ACK);
260 /* We emulate a MF2 AT keyboard here */
261 ps2_queue(&s->common, KBD_REPLY_ID);
263 ps2_queue(&s->common, 0x41);
265 ps2_queue(&s->common, 0x83);
268 ps2_queue(&s->common, KBD_CMD_ECHO);
272 ps2_queue(&s->common, KBD_REPLY_ACK);
274 case KBD_CMD_SCANCODE:
275 case KBD_CMD_SET_LEDS:
276 case KBD_CMD_SET_RATE:
277 s->common.write_cmd = val;
278 ps2_queue(&s->common, KBD_REPLY_ACK);
280 case KBD_CMD_RESET_DISABLE:
281 ps2_reset_keyboard(s);
283 ps2_queue(&s->common, KBD_REPLY_ACK);
285 case KBD_CMD_RESET_ENABLE:
286 ps2_reset_keyboard(s);
288 ps2_queue(&s->common, KBD_REPLY_ACK);
291 ps2_reset_keyboard(s);
292 ps2_queue(&s->common, KBD_REPLY_ACK);
293 ps2_queue(&s->common, KBD_REPLY_POR);
296 ps2_queue(&s->common, KBD_REPLY_ACK);
300 case KBD_CMD_SCANCODE:
302 if (s->scancode_set == 1)
303 ps2_put_keycode(s, 0x43);
304 else if (s->scancode_set == 2)
305 ps2_put_keycode(s, 0x41);
306 else if (s->scancode_set == 3)
307 ps2_put_keycode(s, 0x3f);
309 if (val >= 1 && val <= 3)
310 s->scancode_set = val;
311 ps2_queue(&s->common, KBD_REPLY_ACK);
313 s->common.write_cmd = -1;
315 case KBD_CMD_SET_LEDS:
316 ps2_set_ledstate(s, val);
317 ps2_queue(&s->common, KBD_REPLY_ACK);
318 s->common.write_cmd = -1;
320 case KBD_CMD_SET_RATE:
321 ps2_queue(&s->common, KBD_REPLY_ACK);
322 s->common.write_cmd = -1;
327 /* Set the scancode translation mode.
329 1 = translated scancodes (used by qemu internally). */
331 void ps2_keyboard_set_translation(void *opaque, int mode)
333 PS2KbdState *s = (PS2KbdState *)opaque;
334 trace_ps2_keyboard_set_translation(opaque, mode);
338 static void ps2_mouse_send_packet(PS2MouseState *s)
346 /* XXX: increase range to 8 bits ? */
355 b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
356 ps2_queue(&s->common, b);
357 ps2_queue(&s->common, dx1 & 0xff);
358 ps2_queue(&s->common, dy1 & 0xff);
359 /* extra byte for IMPS/2 or IMEX */
360 switch(s->mouse_type) {
368 ps2_queue(&s->common, dz1 & 0xff);
375 b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
376 ps2_queue(&s->common, b);
380 trace_ps2_mouse_send_packet(s, dx1, dy1, dz1, b);
387 static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
390 static const int bmap[INPUT_BUTTON_MAX] = {
391 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
392 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
393 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
395 PS2MouseState *s = (PS2MouseState *)dev;
397 /* check if deltas are recorded when disabled */
398 if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
402 case INPUT_EVENT_KIND_REL:
403 if (evt->u.rel->axis == INPUT_AXIS_X) {
404 s->mouse_dx += evt->u.rel->value;
405 } else if (evt->u.rel->axis == INPUT_AXIS_Y) {
406 s->mouse_dy -= evt->u.rel->value;
410 case INPUT_EVENT_KIND_BTN:
411 if (evt->u.btn->down) {
412 s->mouse_buttons |= bmap[evt->u.btn->button];
413 if (evt->u.btn->button == INPUT_BUTTON_WHEEL_UP) {
415 } else if (evt->u.btn->button == INPUT_BUTTON_WHEEL_DOWN) {
419 s->mouse_buttons &= ~bmap[evt->u.btn->button];
429 static void ps2_mouse_sync(DeviceState *dev)
431 PS2MouseState *s = (PS2MouseState *)dev;
433 if (s->mouse_buttons) {
434 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
436 if (!(s->mouse_status & MOUSE_STATUS_REMOTE)) {
437 while (s->common.queue.count < PS2_QUEUE_SIZE - 4) {
438 /* if not remote, send event. Multiple events are sent if
441 /* to guarantee safe serialization of input event by Munkyu Im */
442 qemu_mutex_lock(&mutex);
443 ps2_mouse_send_packet(s);
444 qemu_mutex_unlock(&mutex);
446 ps2_mouse_send_packet(s);
448 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
454 void ps2_mouse_fake_event(void *opaque)
456 PS2MouseState *s = opaque;
457 trace_ps2_mouse_fake_event(opaque);
459 ps2_mouse_sync(opaque);
462 void ps2_write_mouse(void *opaque, int val)
464 PS2MouseState *s = (PS2MouseState *)opaque;
466 trace_ps2_write_mouse(opaque, val);
468 printf("kbd: write mouse 0x%02x\n", val);
470 switch(s->common.write_cmd) {
475 if (val == AUX_RESET_WRAP) {
477 ps2_queue(&s->common, AUX_ACK);
479 } else if (val != AUX_RESET) {
480 ps2_queue(&s->common, val);
485 case AUX_SET_SCALE11:
486 s->mouse_status &= ~MOUSE_STATUS_SCALE21;
487 ps2_queue(&s->common, AUX_ACK);
489 case AUX_SET_SCALE21:
490 s->mouse_status |= MOUSE_STATUS_SCALE21;
491 ps2_queue(&s->common, AUX_ACK);
494 s->mouse_status &= ~MOUSE_STATUS_REMOTE;
495 ps2_queue(&s->common, AUX_ACK);
499 ps2_queue(&s->common, AUX_ACK);
502 s->mouse_status |= MOUSE_STATUS_REMOTE;
503 ps2_queue(&s->common, AUX_ACK);
506 ps2_queue(&s->common, AUX_ACK);
507 ps2_queue(&s->common, s->mouse_type);
511 s->common.write_cmd = val;
512 ps2_queue(&s->common, AUX_ACK);
515 ps2_queue(&s->common, AUX_ACK);
516 ps2_queue(&s->common, s->mouse_status);
517 ps2_queue(&s->common, s->mouse_resolution);
518 ps2_queue(&s->common, s->mouse_sample_rate);
521 ps2_queue(&s->common, AUX_ACK);
522 ps2_mouse_send_packet(s);
525 s->mouse_status |= MOUSE_STATUS_ENABLED;
526 ps2_queue(&s->common, AUX_ACK);
528 case AUX_DISABLE_DEV:
529 s->mouse_status &= ~MOUSE_STATUS_ENABLED;
530 ps2_queue(&s->common, AUX_ACK);
532 case AUX_SET_DEFAULT:
533 s->mouse_sample_rate = 100;
534 s->mouse_resolution = 2;
536 ps2_queue(&s->common, AUX_ACK);
539 s->mouse_sample_rate = 100;
540 s->mouse_resolution = 2;
543 ps2_queue(&s->common, AUX_ACK);
544 ps2_queue(&s->common, 0xaa);
545 ps2_queue(&s->common, s->mouse_type);
552 s->mouse_sample_rate = val;
553 /* detect IMPS/2 or IMEX */
554 switch(s->mouse_detect_state) {
558 s->mouse_detect_state = 1;
562 s->mouse_detect_state = 2;
564 s->mouse_detect_state = 3;
566 s->mouse_detect_state = 0;
570 s->mouse_type = 3; /* IMPS/2 */
571 s->mouse_detect_state = 0;
575 s->mouse_type = 4; /* IMEX */
576 s->mouse_detect_state = 0;
579 ps2_queue(&s->common, AUX_ACK);
580 s->common.write_cmd = -1;
583 s->mouse_resolution = val;
584 ps2_queue(&s->common, AUX_ACK);
585 s->common.write_cmd = -1;
590 static void ps2_common_reset(PS2State *s)
598 s->update_irq(s->update_arg, 0);
601 static void ps2_common_post_load(PS2State *s)
603 PS2Queue *q = &s->queue;
606 int tmp_data[PS2_QUEUE_SIZE];
608 /* set the useful data buffer queue size, < PS2_QUEUE_SIZE */
609 size = q->count > PS2_QUEUE_SIZE ? 0 : q->count;
611 /* move the queue elements to the start of data array */
613 for (i = 0; i < size; i++) {
614 /* move the queue elements to the temporary buffer */
615 tmp_data[i] = q->data[q->rptr];
616 if (++q->rptr == 256) {
620 memcpy(q->data, tmp_data, size);
622 /* reset rptr/wptr/count */
626 s->update_irq(s->update_arg, q->count != 0);
629 static void ps2_kbd_reset(void *opaque)
631 PS2KbdState *s = (PS2KbdState *) opaque;
633 trace_ps2_kbd_reset(opaque);
634 ps2_common_reset(&s->common);
640 static void ps2_mouse_reset(void *opaque)
642 PS2MouseState *s = (PS2MouseState *) opaque;
644 trace_ps2_mouse_reset(opaque);
645 ps2_common_reset(&s->common);
647 s->mouse_resolution = 0;
648 s->mouse_sample_rate = 0;
651 s->mouse_detect_state = 0;
655 s->mouse_buttons = 0;
658 static const VMStateDescription vmstate_ps2_common = {
659 .name = "PS2 Common State",
661 .minimum_version_id = 2,
662 .fields = (VMStateField[]) {
663 VMSTATE_INT32(write_cmd, PS2State),
664 VMSTATE_INT32(queue.rptr, PS2State),
665 VMSTATE_INT32(queue.wptr, PS2State),
666 VMSTATE_INT32(queue.count, PS2State),
667 VMSTATE_BUFFER(queue.data, PS2State),
668 VMSTATE_END_OF_LIST()
672 static bool ps2_keyboard_ledstate_needed(void *opaque)
674 PS2KbdState *s = opaque;
676 return s->ledstate != 0; /* 0 is default state */
679 static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
681 PS2KbdState *s = opaque;
683 kbd_put_ledstate(s->ledstate);
687 static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
688 .name = "ps2kbd/ledstate",
690 .minimum_version_id = 2,
691 .post_load = ps2_kbd_ledstate_post_load,
692 .needed = ps2_keyboard_ledstate_needed,
693 .fields = (VMStateField[]) {
694 VMSTATE_INT32(ledstate, PS2KbdState),
695 VMSTATE_END_OF_LIST()
699 static int ps2_kbd_post_load(void* opaque, int version_id)
701 PS2KbdState *s = (PS2KbdState*)opaque;
702 PS2State *ps2 = &s->common;
707 ps2_common_post_load(ps2);
712 static void ps2_kbd_pre_save(void *opaque)
714 PS2KbdState *s = (PS2KbdState *)opaque;
715 PS2State *ps2 = &s->common;
717 ps2_common_post_load(ps2);
720 static const VMStateDescription vmstate_ps2_keyboard = {
723 .minimum_version_id = 2,
724 .post_load = ps2_kbd_post_load,
725 .pre_save = ps2_kbd_pre_save,
726 .fields = (VMStateField[]) {
727 VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
728 VMSTATE_INT32(scan_enabled, PS2KbdState),
729 VMSTATE_INT32(translate, PS2KbdState),
730 VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
731 VMSTATE_END_OF_LIST()
733 .subsections = (const VMStateDescription*[]) {
734 &vmstate_ps2_keyboard_ledstate,
739 static int ps2_mouse_post_load(void *opaque, int version_id)
741 PS2MouseState *s = (PS2MouseState *)opaque;
742 PS2State *ps2 = &s->common;
744 ps2_common_post_load(ps2);
749 static void ps2_mouse_pre_save(void *opaque)
751 PS2MouseState *s = (PS2MouseState *)opaque;
752 PS2State *ps2 = &s->common;
754 ps2_common_post_load(ps2);
757 static const VMStateDescription vmstate_ps2_mouse = {
760 .minimum_version_id = 2,
761 .post_load = ps2_mouse_post_load,
762 .pre_save = ps2_mouse_pre_save,
763 .fields = (VMStateField[]) {
764 VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
765 VMSTATE_UINT8(mouse_status, PS2MouseState),
766 VMSTATE_UINT8(mouse_resolution, PS2MouseState),
767 VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
768 VMSTATE_UINT8(mouse_wrap, PS2MouseState),
769 VMSTATE_UINT8(mouse_type, PS2MouseState),
770 VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
771 VMSTATE_INT32(mouse_dx, PS2MouseState),
772 VMSTATE_INT32(mouse_dy, PS2MouseState),
773 VMSTATE_INT32(mouse_dz, PS2MouseState),
774 VMSTATE_UINT8(mouse_buttons, PS2MouseState),
775 VMSTATE_END_OF_LIST()
779 static QemuInputHandler ps2_keyboard_handler = {
780 .name = "QEMU PS/2 Keyboard",
781 .mask = INPUT_EVENT_MASK_KEY,
782 .event = ps2_keyboard_event,
785 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
787 PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));
789 trace_ps2_kbd_init(s);
790 s->common.update_irq = update_irq;
791 s->common.update_arg = update_arg;
793 vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
794 qemu_input_handler_register((DeviceState *)s,
795 &ps2_keyboard_handler);
796 qemu_register_reset(ps2_kbd_reset, s);
800 static QemuInputHandler ps2_mouse_handler = {
801 .name = "QEMU PS/2 Mouse",
802 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
803 .event = ps2_mouse_event,
804 .sync = ps2_mouse_sync,
807 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
809 PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));
811 trace_ps2_mouse_init(s);
812 s->common.update_irq = update_irq;
813 s->common.update_arg = update_arg;
814 vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
815 qemu_input_handler_register((DeviceState *)s,
817 qemu_register_reset(ps2_mouse_reset, s);
819 /* to guarantee safe serialization of input event by Munkyu Im */
820 qemu_mutex_init(&mutex);