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"
27 #include "sysemu/sysemu.h"
30 /* to guarantee safe serialization of input event by Munkyu Im */
31 #include "qemu/thread.h"
32 static QemuMutex mutex;
34 /* debug PC keyboard */
37 /* debug PC keyboard : only mouse */
40 /* Keyboard Commands */
41 #define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
42 #define KBD_CMD_ECHO 0xEE
43 #define KBD_CMD_SCANCODE 0xF0 /* Get/set scancode set */
44 #define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
45 #define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
46 #define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
47 #define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
48 #define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
49 #define KBD_CMD_RESET 0xFF /* Reset */
51 /* Keyboard Replies */
52 #define KBD_REPLY_POR 0xAA /* Power on reset */
53 #define KBD_REPLY_ID 0xAB /* Keyboard ID */
54 #define KBD_REPLY_ACK 0xFA /* Command ACK */
55 #define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
58 #define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
59 #define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
60 #define AUX_SET_RES 0xE8 /* Set resolution */
61 #define AUX_GET_SCALE 0xE9 /* Get scaling factor */
62 #define AUX_SET_STREAM 0xEA /* Set stream mode */
63 #define AUX_POLL 0xEB /* Poll */
64 #define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
65 #define AUX_SET_WRAP 0xEE /* Set wrap mode */
66 #define AUX_SET_REMOTE 0xF0 /* Set remote mode */
67 #define AUX_GET_TYPE 0xF2 /* Get type */
68 #define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
69 #define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
70 #define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
71 #define AUX_SET_DEFAULT 0xF6
72 #define AUX_RESET 0xFF /* Reset aux device */
73 #define AUX_ACK 0xFA /* Command byte ACK. */
75 #define MOUSE_STATUS_REMOTE 0x40
76 #define MOUSE_STATUS_ENABLED 0x20
77 #define MOUSE_STATUS_SCALE21 0x10
79 #define PS2_QUEUE_SIZE 256
82 uint8_t data[PS2_QUEUE_SIZE];
83 int rptr, wptr, count;
89 void (*update_irq)(void *, int);
96 /* QEMU uses translated PC scancodes internally. To avoid multiple
97 conversions we do the translation (if any) in the PS/2 emulation
98 not the keyboard controller. */
100 int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
106 uint8_t mouse_status;
107 uint8_t mouse_resolution;
108 uint8_t mouse_sample_rate;
110 uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
111 uint8_t mouse_detect_state;
112 int mouse_dx; /* current values, needed for 'poll' mode */
115 uint8_t mouse_buttons;
118 /* Table to convert from PC scancodes to raw scancodes. */
119 static const unsigned char ps2_raw_keycode[128] = {
120 0, 118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
121 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
122 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
123 50, 49, 58, 65, 73, 74, 89, 124, 17, 41, 88, 5, 6, 4, 12, 3,
124 11, 2, 10, 1, 9, 119, 126, 108, 117, 125, 123, 107, 115, 116, 121, 105,
125 114, 122, 112, 113, 127, 96, 97, 120, 7, 15, 23, 31, 39, 47, 55, 63,
126 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
127 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
129 static const unsigned char ps2_raw_keycode_set3[128] = {
130 0, 8, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
131 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 17, 28, 27,
132 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 92, 26, 34, 33, 42,
133 50, 49, 58, 65, 73, 74, 89, 126, 25, 41, 20, 7, 15, 23, 31, 39,
134 47, 2, 63, 71, 79, 118, 95, 108, 117, 125, 132, 107, 115, 116, 124, 105,
135 114, 122, 112, 113, 127, 96, 97, 86, 94, 15, 23, 31, 39, 47, 55, 63,
136 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
137 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
140 void ps2_queue(void *opaque, int b)
142 PS2State *s = (PS2State *)opaque;
143 PS2Queue *q = &s->queue;
145 if (q->count >= PS2_QUEUE_SIZE)
147 q->data[q->wptr] = b;
148 if (++q->wptr == PS2_QUEUE_SIZE)
151 s->update_irq(s->update_arg, 1);
155 keycode is expressed as follow:
156 bit 7 - 0 key pressed, 1 = key released
157 bits 6-0 - translated scancode set 2
159 static void ps2_put_keycode(void *opaque, int keycode)
161 PS2KbdState *s = opaque;
163 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
164 /* XXX: add support for scancode set 1 */
165 if (!s->translate && keycode < 0xe0 && s->scancode_set > 1) {
166 if (keycode & 0x80) {
167 ps2_queue(&s->common, 0xf0);
169 if (s->scancode_set == 2) {
170 keycode = ps2_raw_keycode[keycode & 0x7f];
171 } else if (s->scancode_set == 3) {
172 keycode = ps2_raw_keycode_set3[keycode & 0x7f];
175 ps2_queue(&s->common, keycode);
178 uint32_t ps2_read_data(void *opaque)
180 PS2State *s = (PS2State *)opaque;
186 /* NOTE: if no data left, we return the last keyboard one
187 (needed for EMM386) */
188 /* XXX: need a timer to do things correctly */
191 index = PS2_QUEUE_SIZE - 1;
192 val = q->data[index];
194 val = q->data[q->rptr];
195 if (++q->rptr == PS2_QUEUE_SIZE)
198 /* reading deasserts IRQ */
199 s->update_irq(s->update_arg, 0);
200 /* reassert IRQs if data left */
201 s->update_irq(s->update_arg, q->count != 0);
206 static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
208 s->ledstate = ledstate;
209 kbd_put_ledstate(ledstate);
212 static void ps2_reset_keyboard(PS2KbdState *s)
216 ps2_set_ledstate(s, 0);
219 void ps2_write_keyboard(void *opaque, int val)
221 PS2KbdState *s = (PS2KbdState *)opaque;
223 switch(s->common.write_cmd) {
228 ps2_queue(&s->common, KBD_REPLY_ACK);
231 ps2_queue(&s->common, KBD_REPLY_RESEND);
234 ps2_queue(&s->common, KBD_REPLY_ACK);
235 /* We emulate a MF2 AT keyboard here */
236 ps2_queue(&s->common, KBD_REPLY_ID);
238 ps2_queue(&s->common, 0x41);
240 ps2_queue(&s->common, 0x83);
243 ps2_queue(&s->common, KBD_CMD_ECHO);
247 ps2_queue(&s->common, KBD_REPLY_ACK);
249 case KBD_CMD_SCANCODE:
250 case KBD_CMD_SET_LEDS:
251 case KBD_CMD_SET_RATE:
252 s->common.write_cmd = val;
253 ps2_queue(&s->common, KBD_REPLY_ACK);
255 case KBD_CMD_RESET_DISABLE:
256 ps2_reset_keyboard(s);
258 ps2_queue(&s->common, KBD_REPLY_ACK);
260 case KBD_CMD_RESET_ENABLE:
261 ps2_reset_keyboard(s);
263 ps2_queue(&s->common, KBD_REPLY_ACK);
266 ps2_reset_keyboard(s);
267 ps2_queue(&s->common, KBD_REPLY_ACK);
268 ps2_queue(&s->common, KBD_REPLY_POR);
271 ps2_queue(&s->common, KBD_REPLY_ACK);
275 case KBD_CMD_SCANCODE:
277 if (s->scancode_set == 1)
278 ps2_put_keycode(s, 0x43);
279 else if (s->scancode_set == 2)
280 ps2_put_keycode(s, 0x41);
281 else if (s->scancode_set == 3)
282 ps2_put_keycode(s, 0x3f);
284 if (val >= 1 && val <= 3)
285 s->scancode_set = val;
286 ps2_queue(&s->common, KBD_REPLY_ACK);
288 s->common.write_cmd = -1;
290 case KBD_CMD_SET_LEDS:
291 ps2_set_ledstate(s, val);
292 ps2_queue(&s->common, KBD_REPLY_ACK);
293 s->common.write_cmd = -1;
295 case KBD_CMD_SET_RATE:
296 ps2_queue(&s->common, KBD_REPLY_ACK);
297 s->common.write_cmd = -1;
302 /* Set the scancode translation mode.
304 1 = translated scancodes (used by qemu internally). */
306 void ps2_keyboard_set_translation(void *opaque, int mode)
308 PS2KbdState *s = (PS2KbdState *)opaque;
312 static void ps2_mouse_send_packet(PS2MouseState *s)
320 /* XXX: increase range to 8 bits ? */
329 b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
330 ps2_queue(&s->common, b);
331 ps2_queue(&s->common, dx1 & 0xff);
332 ps2_queue(&s->common, dy1 & 0xff);
333 /* extra byte for IMPS/2 or IMEX */
334 switch(s->mouse_type) {
342 ps2_queue(&s->common, dz1 & 0xff);
349 b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
350 ps2_queue(&s->common, b);
360 static void ps2_mouse_event(void *opaque,
361 int dx, int dy, int dz, int buttons_state)
363 PS2MouseState *s = opaque;
365 /* check if deltas are recorded when disabled */
366 if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
372 /* XXX: SDL sometimes generates nul events: we delete them */
373 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
374 s->mouse_buttons == buttons_state)
376 s->mouse_buttons = buttons_state;
379 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
382 if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
383 (s->common.queue.count < (PS2_QUEUE_SIZE - 16))) {
385 /* if not remote, send event. Multiple events are sent if
388 /* to guarantee safe serialization of input event by Munkyu Im */
389 qemu_mutex_lock(&mutex);
390 ps2_mouse_send_packet(s);
391 qemu_mutex_unlock(&mutex);
393 ps2_mouse_send_packet(s);
395 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
401 void ps2_mouse_fake_event(void *opaque)
403 ps2_mouse_event(opaque, 1, 0, 0, 0);
406 void ps2_write_mouse(void *opaque, int val)
408 PS2MouseState *s = (PS2MouseState *)opaque;
410 printf("kbd: write mouse 0x%02x\n", val);
412 switch(s->common.write_cmd) {
417 if (val == AUX_RESET_WRAP) {
419 ps2_queue(&s->common, AUX_ACK);
421 } else if (val != AUX_RESET) {
422 ps2_queue(&s->common, val);
427 case AUX_SET_SCALE11:
428 s->mouse_status &= ~MOUSE_STATUS_SCALE21;
429 ps2_queue(&s->common, AUX_ACK);
431 case AUX_SET_SCALE21:
432 s->mouse_status |= MOUSE_STATUS_SCALE21;
433 ps2_queue(&s->common, AUX_ACK);
436 s->mouse_status &= ~MOUSE_STATUS_REMOTE;
437 ps2_queue(&s->common, AUX_ACK);
441 ps2_queue(&s->common, AUX_ACK);
444 s->mouse_status |= MOUSE_STATUS_REMOTE;
445 ps2_queue(&s->common, AUX_ACK);
448 ps2_queue(&s->common, AUX_ACK);
449 ps2_queue(&s->common, s->mouse_type);
453 s->common.write_cmd = val;
454 ps2_queue(&s->common, AUX_ACK);
457 ps2_queue(&s->common, AUX_ACK);
458 ps2_queue(&s->common, s->mouse_status);
459 ps2_queue(&s->common, s->mouse_resolution);
460 ps2_queue(&s->common, s->mouse_sample_rate);
463 ps2_queue(&s->common, AUX_ACK);
464 ps2_mouse_send_packet(s);
467 s->mouse_status |= MOUSE_STATUS_ENABLED;
468 ps2_queue(&s->common, AUX_ACK);
470 case AUX_DISABLE_DEV:
471 s->mouse_status &= ~MOUSE_STATUS_ENABLED;
472 ps2_queue(&s->common, AUX_ACK);
474 case AUX_SET_DEFAULT:
475 s->mouse_sample_rate = 100;
476 s->mouse_resolution = 2;
478 ps2_queue(&s->common, AUX_ACK);
481 s->mouse_sample_rate = 100;
482 s->mouse_resolution = 2;
485 ps2_queue(&s->common, AUX_ACK);
486 ps2_queue(&s->common, 0xaa);
487 ps2_queue(&s->common, s->mouse_type);
494 s->mouse_sample_rate = val;
495 /* detect IMPS/2 or IMEX */
496 switch(s->mouse_detect_state) {
500 s->mouse_detect_state = 1;
504 s->mouse_detect_state = 2;
506 s->mouse_detect_state = 3;
508 s->mouse_detect_state = 0;
512 s->mouse_type = 3; /* IMPS/2 */
513 s->mouse_detect_state = 0;
517 s->mouse_type = 4; /* IMEX */
518 s->mouse_detect_state = 0;
521 ps2_queue(&s->common, AUX_ACK);
522 s->common.write_cmd = -1;
525 s->mouse_resolution = val;
526 ps2_queue(&s->common, AUX_ACK);
527 s->common.write_cmd = -1;
532 static void ps2_common_reset(PS2State *s)
540 s->update_irq(s->update_arg, 0);
543 static void ps2_kbd_reset(void *opaque)
545 PS2KbdState *s = (PS2KbdState *) opaque;
547 ps2_common_reset(&s->common);
553 static void ps2_mouse_reset(void *opaque)
555 PS2MouseState *s = (PS2MouseState *) opaque;
557 ps2_common_reset(&s->common);
559 s->mouse_resolution = 0;
560 s->mouse_sample_rate = 0;
563 s->mouse_detect_state = 0;
567 s->mouse_buttons = 0;
570 static const VMStateDescription vmstate_ps2_common = {
571 .name = "PS2 Common State",
573 .minimum_version_id = 2,
574 .minimum_version_id_old = 2,
575 .fields = (VMStateField []) {
576 VMSTATE_INT32(write_cmd, PS2State),
577 VMSTATE_INT32(queue.rptr, PS2State),
578 VMSTATE_INT32(queue.wptr, PS2State),
579 VMSTATE_INT32(queue.count, PS2State),
580 VMSTATE_BUFFER(queue.data, PS2State),
581 VMSTATE_END_OF_LIST()
585 static bool ps2_keyboard_ledstate_needed(void *opaque)
587 PS2KbdState *s = opaque;
589 return s->ledstate != 0; /* 0 is default state */
592 static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
594 PS2KbdState *s = opaque;
596 kbd_put_ledstate(s->ledstate);
600 static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
601 .name = "ps2kbd/ledstate",
603 .minimum_version_id = 2,
604 .minimum_version_id_old = 2,
605 .post_load = ps2_kbd_ledstate_post_load,
606 .fields = (VMStateField []) {
607 VMSTATE_INT32(ledstate, PS2KbdState),
608 VMSTATE_END_OF_LIST()
612 static int ps2_kbd_post_load(void* opaque, int version_id)
614 PS2KbdState *s = (PS2KbdState*)opaque;
621 static const VMStateDescription vmstate_ps2_keyboard = {
624 .minimum_version_id = 2,
625 .minimum_version_id_old = 2,
626 .post_load = ps2_kbd_post_load,
627 .fields = (VMStateField []) {
628 VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
629 VMSTATE_INT32(scan_enabled, PS2KbdState),
630 VMSTATE_INT32(translate, PS2KbdState),
631 VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
632 VMSTATE_END_OF_LIST()
634 .subsections = (VMStateSubsection []) {
636 .vmsd = &vmstate_ps2_keyboard_ledstate,
637 .needed = ps2_keyboard_ledstate_needed,
644 static const VMStateDescription vmstate_ps2_mouse = {
647 .minimum_version_id = 2,
648 .minimum_version_id_old = 2,
649 .fields = (VMStateField []) {
650 VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
651 VMSTATE_UINT8(mouse_status, PS2MouseState),
652 VMSTATE_UINT8(mouse_resolution, PS2MouseState),
653 VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
654 VMSTATE_UINT8(mouse_wrap, PS2MouseState),
655 VMSTATE_UINT8(mouse_type, PS2MouseState),
656 VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
657 VMSTATE_INT32(mouse_dx, PS2MouseState),
658 VMSTATE_INT32(mouse_dy, PS2MouseState),
659 VMSTATE_INT32(mouse_dz, PS2MouseState),
660 VMSTATE_UINT8(mouse_buttons, PS2MouseState),
661 VMSTATE_END_OF_LIST()
665 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
667 PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));
669 s->common.update_irq = update_irq;
670 s->common.update_arg = update_arg;
672 vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
673 qemu_add_kbd_event_handler(ps2_put_keycode, s);
674 qemu_register_reset(ps2_kbd_reset, s);
678 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
680 PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));
682 s->common.update_irq = update_irq;
683 s->common.update_arg = update_arg;
684 vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
685 qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse");
686 qemu_register_reset(ps2_mouse_reset, s);
688 /* to guarantee safe serialization of input event by Munkyu Im */
689 qemu_mutex_init(&mutex);