Merge remote-tracking branch 'remotes/philmd-gitlab/tags/renesas-20201027' into staging
[qemu.git] / hw / input / ps2.c
1 /*
2 * QEMU PS/2 keyboard/mouse emulation
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26 #include "qemu/log.h"
27 #include "hw/input/ps2.h"
28 #include "migration/vmstate.h"
29 #include "ui/console.h"
30 #include "ui/input.h"
31 #include "sysemu/reset.h"
32 #include "sysemu/runstate.h"
33
34 #include "trace.h"
35
36 /* debug PC keyboard */
37 //#define DEBUG_KBD
38
39 /* debug PC keyboard : only mouse */
40 //#define DEBUG_MOUSE
41
42 /* Keyboard Commands */
43 #define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
44 #define KBD_CMD_ECHO 0xEE
45 #define KBD_CMD_SCANCODE 0xF0 /* Get/set scancode set */
46 #define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
47 #define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
48 #define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
49 #define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
50 #define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
51 #define KBD_CMD_RESET 0xFF /* Reset */
52 #define KBD_CMD_SET_MAKE_BREAK 0xFC /* Set Make and Break mode */
53 #define KBD_CMD_SET_TYPEMATIC 0xFA /* Set Typematic Make and Break mode */
54
55 /* Keyboard Replies */
56 #define KBD_REPLY_POR 0xAA /* Power on reset */
57 #define KBD_REPLY_ID 0xAB /* Keyboard ID */
58 #define KBD_REPLY_ACK 0xFA /* Command ACK */
59 #define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
60
61 /* Mouse Commands */
62 #define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
63 #define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
64 #define AUX_SET_RES 0xE8 /* Set resolution */
65 #define AUX_GET_SCALE 0xE9 /* Get scaling factor */
66 #define AUX_SET_STREAM 0xEA /* Set stream mode */
67 #define AUX_POLL 0xEB /* Poll */
68 #define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
69 #define AUX_SET_WRAP 0xEE /* Set wrap mode */
70 #define AUX_SET_REMOTE 0xF0 /* Set remote mode */
71 #define AUX_GET_TYPE 0xF2 /* Get type */
72 #define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
73 #define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
74 #define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
75 #define AUX_SET_DEFAULT 0xF6
76 #define AUX_RESET 0xFF /* Reset aux device */
77 #define AUX_ACK 0xFA /* Command byte ACK. */
78
79 #define MOUSE_STATUS_REMOTE 0x40
80 #define MOUSE_STATUS_ENABLED 0x20
81 #define MOUSE_STATUS_SCALE21 0x10
82
83 #define PS2_QUEUE_SIZE 16 /* Buffer size required by PS/2 protocol */
84
85 /* Bits for 'modifiers' field in PS2KbdState */
86 #define MOD_CTRL_L (1 << 0)
87 #define MOD_SHIFT_L (1 << 1)
88 #define MOD_ALT_L (1 << 2)
89 #define MOD_CTRL_R (1 << 3)
90 #define MOD_SHIFT_R (1 << 4)
91 #define MOD_ALT_R (1 << 5)
92
93 typedef struct {
94 /* Keep the data array 256 bytes long, which compatibility
95 with older qemu versions. */
96 uint8_t data[256];
97 int rptr, wptr, count;
98 } PS2Queue;
99
100 struct PS2State {
101 PS2Queue queue;
102 int32_t write_cmd;
103 void (*update_irq)(void *, int);
104 void *update_arg;
105 };
106
107 typedef struct {
108 PS2State common;
109 int scan_enabled;
110 int translate;
111 int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
112 int ledstate;
113 bool need_high_bit;
114 unsigned int modifiers; /* bitmask of MOD_* constants above */
115 } PS2KbdState;
116
117 typedef struct {
118 PS2State common;
119 uint8_t mouse_status;
120 uint8_t mouse_resolution;
121 uint8_t mouse_sample_rate;
122 uint8_t mouse_wrap;
123 uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
124 uint8_t mouse_detect_state;
125 int mouse_dx; /* current values, needed for 'poll' mode */
126 int mouse_dy;
127 int mouse_dz;
128 uint8_t mouse_buttons;
129 } PS2MouseState;
130
131 static uint8_t translate_table[256] = {
132 0xff, 0x43, 0x41, 0x3f, 0x3d, 0x3b, 0x3c, 0x58,
133 0x64, 0x44, 0x42, 0x40, 0x3e, 0x0f, 0x29, 0x59,
134 0x65, 0x38, 0x2a, 0x70, 0x1d, 0x10, 0x02, 0x5a,
135 0x66, 0x71, 0x2c, 0x1f, 0x1e, 0x11, 0x03, 0x5b,
136 0x67, 0x2e, 0x2d, 0x20, 0x12, 0x05, 0x04, 0x5c,
137 0x68, 0x39, 0x2f, 0x21, 0x14, 0x13, 0x06, 0x5d,
138 0x69, 0x31, 0x30, 0x23, 0x22, 0x15, 0x07, 0x5e,
139 0x6a, 0x72, 0x32, 0x24, 0x16, 0x08, 0x09, 0x5f,
140 0x6b, 0x33, 0x25, 0x17, 0x18, 0x0b, 0x0a, 0x60,
141 0x6c, 0x34, 0x35, 0x26, 0x27, 0x19, 0x0c, 0x61,
142 0x6d, 0x73, 0x28, 0x74, 0x1a, 0x0d, 0x62, 0x6e,
143 0x3a, 0x36, 0x1c, 0x1b, 0x75, 0x2b, 0x63, 0x76,
144 0x55, 0x56, 0x77, 0x78, 0x79, 0x7a, 0x0e, 0x7b,
145 0x7c, 0x4f, 0x7d, 0x4b, 0x47, 0x7e, 0x7f, 0x6f,
146 0x52, 0x53, 0x50, 0x4c, 0x4d, 0x48, 0x01, 0x45,
147 0x57, 0x4e, 0x51, 0x4a, 0x37, 0x49, 0x46, 0x54,
148 0x80, 0x81, 0x82, 0x41, 0x54, 0x85, 0x86, 0x87,
149 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
150 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
151 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
152 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
153 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
154 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
155 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
156 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
157 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
158 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
159 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
160 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
161 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
162 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
163 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
164 };
165
166 static unsigned int ps2_modifier_bit(QKeyCode key)
167 {
168 switch (key) {
169 case Q_KEY_CODE_CTRL:
170 return MOD_CTRL_L;
171 case Q_KEY_CODE_CTRL_R:
172 return MOD_CTRL_R;
173 case Q_KEY_CODE_SHIFT:
174 return MOD_SHIFT_L;
175 case Q_KEY_CODE_SHIFT_R:
176 return MOD_SHIFT_R;
177 case Q_KEY_CODE_ALT:
178 return MOD_ALT_L;
179 case Q_KEY_CODE_ALT_R:
180 return MOD_ALT_R;
181 default:
182 return 0;
183 }
184 }
185
186 static void ps2_reset_queue(PS2State *s)
187 {
188 PS2Queue *q = &s->queue;
189
190 q->rptr = 0;
191 q->wptr = 0;
192 q->count = 0;
193 }
194
195 int ps2_queue_empty(PS2State *s)
196 {
197 return s->queue.count == 0;
198 }
199
200 void ps2_queue_noirq(PS2State *s, int b)
201 {
202 PS2Queue *q = &s->queue;
203
204 if (q->count == PS2_QUEUE_SIZE) {
205 return;
206 }
207
208 q->data[q->wptr] = b;
209 if (++q->wptr == PS2_QUEUE_SIZE)
210 q->wptr = 0;
211 q->count++;
212 }
213
214 void ps2_raise_irq(PS2State *s)
215 {
216 s->update_irq(s->update_arg, 1);
217 }
218
219 void ps2_queue(PS2State *s, int b)
220 {
221 ps2_queue_noirq(s, b);
222 s->update_irq(s->update_arg, 1);
223 }
224
225 void ps2_queue_2(PS2State *s, int b1, int b2)
226 {
227 if (PS2_QUEUE_SIZE - s->queue.count < 2) {
228 return;
229 }
230
231 ps2_queue_noirq(s, b1);
232 ps2_queue_noirq(s, b2);
233 s->update_irq(s->update_arg, 1);
234 }
235
236 void ps2_queue_3(PS2State *s, int b1, int b2, int b3)
237 {
238 if (PS2_QUEUE_SIZE - s->queue.count < 3) {
239 return;
240 }
241
242 ps2_queue_noirq(s, b1);
243 ps2_queue_noirq(s, b2);
244 ps2_queue_noirq(s, b3);
245 s->update_irq(s->update_arg, 1);
246 }
247
248 void ps2_queue_4(PS2State *s, int b1, int b2, int b3, int b4)
249 {
250 if (PS2_QUEUE_SIZE - s->queue.count < 4) {
251 return;
252 }
253
254 ps2_queue_noirq(s, b1);
255 ps2_queue_noirq(s, b2);
256 ps2_queue_noirq(s, b3);
257 ps2_queue_noirq(s, b4);
258 s->update_irq(s->update_arg, 1);
259 }
260
261 /* keycode is the untranslated scancode in the current scancode set. */
262 static void ps2_put_keycode(void *opaque, int keycode)
263 {
264 PS2KbdState *s = opaque;
265
266 trace_ps2_put_keycode(opaque, keycode);
267 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
268
269 if (s->translate) {
270 if (keycode == 0xf0) {
271 s->need_high_bit = true;
272 } else if (s->need_high_bit) {
273 ps2_queue(&s->common, translate_table[keycode] | 0x80);
274 s->need_high_bit = false;
275 } else {
276 ps2_queue(&s->common, translate_table[keycode]);
277 }
278 } else {
279 ps2_queue(&s->common, keycode);
280 }
281 }
282
283 static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
284 InputEvent *evt)
285 {
286 PS2KbdState *s = (PS2KbdState *)dev;
287 InputKeyEvent *key = evt->u.key.data;
288 int qcode;
289 uint16_t keycode = 0;
290 int mod;
291
292 /* do not process events while disabled to prevent stream corruption */
293 if (!s->scan_enabled) {
294 return;
295 }
296
297 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
298 assert(evt->type == INPUT_EVENT_KIND_KEY);
299 qcode = qemu_input_key_value_to_qcode(key->key);
300
301 mod = ps2_modifier_bit(qcode);
302 trace_ps2_keyboard_event(s, qcode, key->down, mod, s->modifiers);
303 if (key->down) {
304 s->modifiers |= mod;
305 } else {
306 s->modifiers &= ~mod;
307 }
308
309 if (s->scancode_set == 1) {
310 if (qcode == Q_KEY_CODE_PAUSE) {
311 if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
312 if (key->down) {
313 ps2_put_keycode(s, 0xe0);
314 ps2_put_keycode(s, 0x46);
315 ps2_put_keycode(s, 0xe0);
316 ps2_put_keycode(s, 0xc6);
317 }
318 } else {
319 if (key->down) {
320 ps2_put_keycode(s, 0xe1);
321 ps2_put_keycode(s, 0x1d);
322 ps2_put_keycode(s, 0x45);
323 ps2_put_keycode(s, 0xe1);
324 ps2_put_keycode(s, 0x9d);
325 ps2_put_keycode(s, 0xc5);
326 }
327 }
328 } else if (qcode == Q_KEY_CODE_PRINT) {
329 if (s->modifiers & MOD_ALT_L) {
330 if (key->down) {
331 ps2_put_keycode(s, 0xb8);
332 ps2_put_keycode(s, 0x38);
333 ps2_put_keycode(s, 0x54);
334 } else {
335 ps2_put_keycode(s, 0xd4);
336 ps2_put_keycode(s, 0xb8);
337 ps2_put_keycode(s, 0x38);
338 }
339 } else if (s->modifiers & MOD_ALT_R) {
340 if (key->down) {
341 ps2_put_keycode(s, 0xe0);
342 ps2_put_keycode(s, 0xb8);
343 ps2_put_keycode(s, 0xe0);
344 ps2_put_keycode(s, 0x38);
345 ps2_put_keycode(s, 0x54);
346 } else {
347 ps2_put_keycode(s, 0xd4);
348 ps2_put_keycode(s, 0xe0);
349 ps2_put_keycode(s, 0xb8);
350 ps2_put_keycode(s, 0xe0);
351 ps2_put_keycode(s, 0x38);
352 }
353 } else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
354 MOD_SHIFT_R | MOD_CTRL_R)) {
355 if (key->down) {
356 ps2_put_keycode(s, 0xe0);
357 ps2_put_keycode(s, 0x37);
358 } else {
359 ps2_put_keycode(s, 0xe0);
360 ps2_put_keycode(s, 0xb7);
361 }
362 } else {
363 if (key->down) {
364 ps2_put_keycode(s, 0xe0);
365 ps2_put_keycode(s, 0x2a);
366 ps2_put_keycode(s, 0xe0);
367 ps2_put_keycode(s, 0x37);
368 } else {
369 ps2_put_keycode(s, 0xe0);
370 ps2_put_keycode(s, 0xb7);
371 ps2_put_keycode(s, 0xe0);
372 ps2_put_keycode(s, 0xaa);
373 }
374 }
375 } else {
376 if (qcode < qemu_input_map_qcode_to_atset1_len)
377 keycode = qemu_input_map_qcode_to_atset1[qcode];
378 if (keycode) {
379 if (keycode & 0xff00) {
380 ps2_put_keycode(s, keycode >> 8);
381 }
382 if (!key->down) {
383 keycode |= 0x80;
384 }
385 ps2_put_keycode(s, keycode & 0xff);
386 } else {
387 qemu_log_mask(LOG_UNIMP,
388 "ps2: ignoring key with qcode %d\n", qcode);
389 }
390 }
391 } else if (s->scancode_set == 2) {
392 if (qcode == Q_KEY_CODE_PAUSE) {
393 if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
394 if (key->down) {
395 ps2_put_keycode(s, 0xe0);
396 ps2_put_keycode(s, 0x7e);
397 ps2_put_keycode(s, 0xe0);
398 ps2_put_keycode(s, 0xf0);
399 ps2_put_keycode(s, 0x7e);
400 }
401 } else {
402 if (key->down) {
403 ps2_put_keycode(s, 0xe1);
404 ps2_put_keycode(s, 0x14);
405 ps2_put_keycode(s, 0x77);
406 ps2_put_keycode(s, 0xe1);
407 ps2_put_keycode(s, 0xf0);
408 ps2_put_keycode(s, 0x14);
409 ps2_put_keycode(s, 0xf0);
410 ps2_put_keycode(s, 0x77);
411 }
412 }
413 } else if (qcode == Q_KEY_CODE_PRINT) {
414 if (s->modifiers & MOD_ALT_L) {
415 if (key->down) {
416 ps2_put_keycode(s, 0xf0);
417 ps2_put_keycode(s, 0x11);
418 ps2_put_keycode(s, 0x11);
419 ps2_put_keycode(s, 0x84);
420 } else {
421 ps2_put_keycode(s, 0xf0);
422 ps2_put_keycode(s, 0x84);
423 ps2_put_keycode(s, 0xf0);
424 ps2_put_keycode(s, 0x11);
425 ps2_put_keycode(s, 0x11);
426 }
427 } else if (s->modifiers & MOD_ALT_R) {
428 if (key->down) {
429 ps2_put_keycode(s, 0xe0);
430 ps2_put_keycode(s, 0xf0);
431 ps2_put_keycode(s, 0x11);
432 ps2_put_keycode(s, 0xe0);
433 ps2_put_keycode(s, 0x11);
434 ps2_put_keycode(s, 0x84);
435 } else {
436 ps2_put_keycode(s, 0xf0);
437 ps2_put_keycode(s, 0x84);
438 ps2_put_keycode(s, 0xe0);
439 ps2_put_keycode(s, 0xf0);
440 ps2_put_keycode(s, 0x11);
441 ps2_put_keycode(s, 0xe0);
442 ps2_put_keycode(s, 0x11);
443 }
444 } else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
445 MOD_SHIFT_R | MOD_CTRL_R)) {
446 if (key->down) {
447 ps2_put_keycode(s, 0xe0);
448 ps2_put_keycode(s, 0x7c);
449 } else {
450 ps2_put_keycode(s, 0xe0);
451 ps2_put_keycode(s, 0xf0);
452 ps2_put_keycode(s, 0x7c);
453 }
454 } else {
455 if (key->down) {
456 ps2_put_keycode(s, 0xe0);
457 ps2_put_keycode(s, 0x12);
458 ps2_put_keycode(s, 0xe0);
459 ps2_put_keycode(s, 0x7c);
460 } else {
461 ps2_put_keycode(s, 0xe0);
462 ps2_put_keycode(s, 0xf0);
463 ps2_put_keycode(s, 0x7c);
464 ps2_put_keycode(s, 0xe0);
465 ps2_put_keycode(s, 0xf0);
466 ps2_put_keycode(s, 0x12);
467 }
468 }
469 } else {
470 if (qcode < qemu_input_map_qcode_to_atset2_len)
471 keycode = qemu_input_map_qcode_to_atset2[qcode];
472 if (keycode) {
473 if (keycode & 0xff00) {
474 ps2_put_keycode(s, keycode >> 8);
475 }
476 if (!key->down) {
477 ps2_put_keycode(s, 0xf0);
478 }
479 ps2_put_keycode(s, keycode & 0xff);
480 } else {
481 qemu_log_mask(LOG_UNIMP,
482 "ps2: ignoring key with qcode %d\n", qcode);
483 }
484 }
485 } else if (s->scancode_set == 3) {
486 if (qcode < qemu_input_map_qcode_to_atset3_len)
487 keycode = qemu_input_map_qcode_to_atset3[qcode];
488 if (keycode) {
489 /* FIXME: break code should be configured on a key by key basis */
490 if (!key->down) {
491 ps2_put_keycode(s, 0xf0);
492 }
493 ps2_put_keycode(s, keycode);
494 } else {
495 qemu_log_mask(LOG_UNIMP,
496 "ps2: ignoring key with qcode %d\n", qcode);
497 }
498 }
499 }
500
501 uint32_t ps2_read_data(PS2State *s)
502 {
503 PS2Queue *q;
504 int val, index;
505
506 trace_ps2_read_data(s);
507 q = &s->queue;
508 if (q->count == 0) {
509 /* NOTE: if no data left, we return the last keyboard one
510 (needed for EMM386) */
511 /* XXX: need a timer to do things correctly */
512 index = q->rptr - 1;
513 if (index < 0)
514 index = PS2_QUEUE_SIZE - 1;
515 val = q->data[index];
516 } else {
517 val = q->data[q->rptr];
518 if (++q->rptr == PS2_QUEUE_SIZE)
519 q->rptr = 0;
520 q->count--;
521 /* reading deasserts IRQ */
522 s->update_irq(s->update_arg, 0);
523 /* reassert IRQs if data left */
524 s->update_irq(s->update_arg, q->count != 0);
525 }
526 return val;
527 }
528
529 static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
530 {
531 trace_ps2_set_ledstate(s, ledstate);
532 s->ledstate = ledstate;
533 kbd_put_ledstate(ledstate);
534 }
535
536 static void ps2_reset_keyboard(PS2KbdState *s)
537 {
538 trace_ps2_reset_keyboard(s);
539 s->scan_enabled = 1;
540 s->scancode_set = 2;
541 ps2_reset_queue(&s->common);
542 ps2_set_ledstate(s, 0);
543 }
544
545 void ps2_write_keyboard(void *opaque, int val)
546 {
547 PS2KbdState *s = (PS2KbdState *)opaque;
548
549 trace_ps2_write_keyboard(opaque, val);
550 switch(s->common.write_cmd) {
551 default:
552 case -1:
553 switch(val) {
554 case 0x00:
555 ps2_queue(&s->common, KBD_REPLY_ACK);
556 break;
557 case 0x05:
558 ps2_queue(&s->common, KBD_REPLY_RESEND);
559 break;
560 case KBD_CMD_GET_ID:
561 /* We emulate a MF2 AT keyboard here */
562 if (s->translate)
563 ps2_queue_3(&s->common,
564 KBD_REPLY_ACK,
565 KBD_REPLY_ID,
566 0x41);
567 else
568 ps2_queue_3(&s->common,
569 KBD_REPLY_ACK,
570 KBD_REPLY_ID,
571 0x83);
572 break;
573 case KBD_CMD_ECHO:
574 ps2_queue(&s->common, KBD_CMD_ECHO);
575 break;
576 case KBD_CMD_ENABLE:
577 s->scan_enabled = 1;
578 ps2_queue(&s->common, KBD_REPLY_ACK);
579 break;
580 case KBD_CMD_SCANCODE:
581 case KBD_CMD_SET_LEDS:
582 case KBD_CMD_SET_RATE:
583 case KBD_CMD_SET_MAKE_BREAK:
584 s->common.write_cmd = val;
585 ps2_queue(&s->common, KBD_REPLY_ACK);
586 break;
587 case KBD_CMD_RESET_DISABLE:
588 ps2_reset_keyboard(s);
589 s->scan_enabled = 0;
590 ps2_queue(&s->common, KBD_REPLY_ACK);
591 break;
592 case KBD_CMD_RESET_ENABLE:
593 ps2_reset_keyboard(s);
594 s->scan_enabled = 1;
595 ps2_queue(&s->common, KBD_REPLY_ACK);
596 break;
597 case KBD_CMD_RESET:
598 ps2_reset_keyboard(s);
599 ps2_queue_2(&s->common,
600 KBD_REPLY_ACK,
601 KBD_REPLY_POR);
602 break;
603 case KBD_CMD_SET_TYPEMATIC:
604 ps2_queue(&s->common, KBD_REPLY_ACK);
605 break;
606 default:
607 ps2_queue(&s->common, KBD_REPLY_RESEND);
608 break;
609 }
610 break;
611 case KBD_CMD_SET_MAKE_BREAK:
612 ps2_queue(&s->common, KBD_REPLY_ACK);
613 s->common.write_cmd = -1;
614 break;
615 case KBD_CMD_SCANCODE:
616 if (val == 0) {
617 if (s->common.queue.count <= PS2_QUEUE_SIZE - 2) {
618 ps2_queue(&s->common, KBD_REPLY_ACK);
619 ps2_put_keycode(s, s->scancode_set);
620 }
621 } else if (val >= 1 && val <= 3) {
622 s->scancode_set = val;
623 ps2_queue(&s->common, KBD_REPLY_ACK);
624 } else {
625 ps2_queue(&s->common, KBD_REPLY_RESEND);
626 }
627 s->common.write_cmd = -1;
628 break;
629 case KBD_CMD_SET_LEDS:
630 ps2_set_ledstate(s, val);
631 ps2_queue(&s->common, KBD_REPLY_ACK);
632 s->common.write_cmd = -1;
633 break;
634 case KBD_CMD_SET_RATE:
635 ps2_queue(&s->common, KBD_REPLY_ACK);
636 s->common.write_cmd = -1;
637 break;
638 }
639 }
640
641 /* Set the scancode translation mode.
642 0 = raw scancodes.
643 1 = translated scancodes (used by qemu internally). */
644
645 void ps2_keyboard_set_translation(void *opaque, int mode)
646 {
647 PS2KbdState *s = (PS2KbdState *)opaque;
648 trace_ps2_keyboard_set_translation(opaque, mode);
649 s->translate = mode;
650 }
651
652 static int ps2_mouse_send_packet(PS2MouseState *s)
653 {
654 const int needed = 3 + (s->mouse_type - 2);
655 unsigned int b;
656 int dx1, dy1, dz1;
657
658 if (PS2_QUEUE_SIZE - s->common.queue.count < needed) {
659 return 0;
660 }
661
662 dx1 = s->mouse_dx;
663 dy1 = s->mouse_dy;
664 dz1 = s->mouse_dz;
665 /* XXX: increase range to 8 bits ? */
666 if (dx1 > 127)
667 dx1 = 127;
668 else if (dx1 < -127)
669 dx1 = -127;
670 if (dy1 > 127)
671 dy1 = 127;
672 else if (dy1 < -127)
673 dy1 = -127;
674 b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
675 ps2_queue_noirq(&s->common, b);
676 ps2_queue_noirq(&s->common, dx1 & 0xff);
677 ps2_queue_noirq(&s->common, dy1 & 0xff);
678 /* extra byte for IMPS/2 or IMEX */
679 switch(s->mouse_type) {
680 default:
681 break;
682 case 3:
683 if (dz1 > 127)
684 dz1 = 127;
685 else if (dz1 < -127)
686 dz1 = -127;
687 ps2_queue_noirq(&s->common, dz1 & 0xff);
688 break;
689 case 4:
690 if (dz1 > 7)
691 dz1 = 7;
692 else if (dz1 < -7)
693 dz1 = -7;
694 b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
695 ps2_queue_noirq(&s->common, b);
696 break;
697 }
698
699 ps2_raise_irq(&s->common);
700
701 trace_ps2_mouse_send_packet(s, dx1, dy1, dz1, b);
702 /* update deltas */
703 s->mouse_dx -= dx1;
704 s->mouse_dy -= dy1;
705 s->mouse_dz -= dz1;
706
707 return 1;
708 }
709
710 static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
711 InputEvent *evt)
712 {
713 static const int bmap[INPUT_BUTTON__MAX] = {
714 [INPUT_BUTTON_LEFT] = PS2_MOUSE_BUTTON_LEFT,
715 [INPUT_BUTTON_MIDDLE] = PS2_MOUSE_BUTTON_MIDDLE,
716 [INPUT_BUTTON_RIGHT] = PS2_MOUSE_BUTTON_RIGHT,
717 [INPUT_BUTTON_SIDE] = PS2_MOUSE_BUTTON_SIDE,
718 [INPUT_BUTTON_EXTRA] = PS2_MOUSE_BUTTON_EXTRA,
719 };
720 PS2MouseState *s = (PS2MouseState *)dev;
721 InputMoveEvent *move;
722 InputBtnEvent *btn;
723
724 /* check if deltas are recorded when disabled */
725 if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
726 return;
727
728 switch (evt->type) {
729 case INPUT_EVENT_KIND_REL:
730 move = evt->u.rel.data;
731 if (move->axis == INPUT_AXIS_X) {
732 s->mouse_dx += move->value;
733 } else if (move->axis == INPUT_AXIS_Y) {
734 s->mouse_dy -= move->value;
735 }
736 break;
737
738 case INPUT_EVENT_KIND_BTN:
739 btn = evt->u.btn.data;
740 if (btn->down) {
741 s->mouse_buttons |= bmap[btn->button];
742 if (btn->button == INPUT_BUTTON_WHEEL_UP) {
743 s->mouse_dz--;
744 } else if (btn->button == INPUT_BUTTON_WHEEL_DOWN) {
745 s->mouse_dz++;
746 }
747 } else {
748 s->mouse_buttons &= ~bmap[btn->button];
749 }
750 break;
751
752 default:
753 /* keep gcc happy */
754 break;
755 }
756 }
757
758 static void ps2_mouse_sync(DeviceState *dev)
759 {
760 PS2MouseState *s = (PS2MouseState *)dev;
761
762 /* do not sync while disabled to prevent stream corruption */
763 if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) {
764 return;
765 }
766
767 if (s->mouse_buttons) {
768 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
769 }
770 if (!(s->mouse_status & MOUSE_STATUS_REMOTE)) {
771 /* if not remote, send event. Multiple events are sent if
772 too big deltas */
773 while (ps2_mouse_send_packet(s)) {
774 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
775 break;
776 }
777 }
778 }
779
780 void ps2_mouse_fake_event(void *opaque)
781 {
782 PS2MouseState *s = opaque;
783 trace_ps2_mouse_fake_event(opaque);
784 s->mouse_dx++;
785 ps2_mouse_sync(opaque);
786 }
787
788 void ps2_write_mouse(void *opaque, int val)
789 {
790 PS2MouseState *s = (PS2MouseState *)opaque;
791
792 trace_ps2_write_mouse(opaque, val);
793 #ifdef DEBUG_MOUSE
794 printf("kbd: write mouse 0x%02x\n", val);
795 #endif
796 switch(s->common.write_cmd) {
797 default:
798 case -1:
799 /* mouse command */
800 if (s->mouse_wrap) {
801 if (val == AUX_RESET_WRAP) {
802 s->mouse_wrap = 0;
803 ps2_queue(&s->common, AUX_ACK);
804 return;
805 } else if (val != AUX_RESET) {
806 ps2_queue(&s->common, val);
807 return;
808 }
809 }
810 switch(val) {
811 case AUX_SET_SCALE11:
812 s->mouse_status &= ~MOUSE_STATUS_SCALE21;
813 ps2_queue(&s->common, AUX_ACK);
814 break;
815 case AUX_SET_SCALE21:
816 s->mouse_status |= MOUSE_STATUS_SCALE21;
817 ps2_queue(&s->common, AUX_ACK);
818 break;
819 case AUX_SET_STREAM:
820 s->mouse_status &= ~MOUSE_STATUS_REMOTE;
821 ps2_queue(&s->common, AUX_ACK);
822 break;
823 case AUX_SET_WRAP:
824 s->mouse_wrap = 1;
825 ps2_queue(&s->common, AUX_ACK);
826 break;
827 case AUX_SET_REMOTE:
828 s->mouse_status |= MOUSE_STATUS_REMOTE;
829 ps2_queue(&s->common, AUX_ACK);
830 break;
831 case AUX_GET_TYPE:
832 ps2_queue_2(&s->common,
833 AUX_ACK,
834 s->mouse_type);
835 break;
836 case AUX_SET_RES:
837 case AUX_SET_SAMPLE:
838 s->common.write_cmd = val;
839 ps2_queue(&s->common, AUX_ACK);
840 break;
841 case AUX_GET_SCALE:
842 ps2_queue_4(&s->common,
843 AUX_ACK,
844 s->mouse_status,
845 s->mouse_resolution,
846 s->mouse_sample_rate);
847 break;
848 case AUX_POLL:
849 ps2_queue(&s->common, AUX_ACK);
850 ps2_mouse_send_packet(s);
851 break;
852 case AUX_ENABLE_DEV:
853 s->mouse_status |= MOUSE_STATUS_ENABLED;
854 ps2_queue(&s->common, AUX_ACK);
855 break;
856 case AUX_DISABLE_DEV:
857 s->mouse_status &= ~MOUSE_STATUS_ENABLED;
858 ps2_queue(&s->common, AUX_ACK);
859 break;
860 case AUX_SET_DEFAULT:
861 s->mouse_sample_rate = 100;
862 s->mouse_resolution = 2;
863 s->mouse_status = 0;
864 ps2_queue(&s->common, AUX_ACK);
865 break;
866 case AUX_RESET:
867 s->mouse_sample_rate = 100;
868 s->mouse_resolution = 2;
869 s->mouse_status = 0;
870 s->mouse_type = 0;
871 ps2_reset_queue(&s->common);
872 ps2_queue_3(&s->common,
873 AUX_ACK,
874 0xaa,
875 s->mouse_type);
876 break;
877 default:
878 break;
879 }
880 break;
881 case AUX_SET_SAMPLE:
882 s->mouse_sample_rate = val;
883 /* detect IMPS/2 or IMEX */
884 switch(s->mouse_detect_state) {
885 default:
886 case 0:
887 if (val == 200)
888 s->mouse_detect_state = 1;
889 break;
890 case 1:
891 if (val == 100)
892 s->mouse_detect_state = 2;
893 else if (val == 200)
894 s->mouse_detect_state = 3;
895 else
896 s->mouse_detect_state = 0;
897 break;
898 case 2:
899 if (val == 80)
900 s->mouse_type = 3; /* IMPS/2 */
901 s->mouse_detect_state = 0;
902 break;
903 case 3:
904 if (val == 80)
905 s->mouse_type = 4; /* IMEX */
906 s->mouse_detect_state = 0;
907 break;
908 }
909 ps2_queue(&s->common, AUX_ACK);
910 s->common.write_cmd = -1;
911 break;
912 case AUX_SET_RES:
913 s->mouse_resolution = val;
914 ps2_queue(&s->common, AUX_ACK);
915 s->common.write_cmd = -1;
916 break;
917 }
918 }
919
920 static void ps2_common_reset(PS2State *s)
921 {
922 s->write_cmd = -1;
923 ps2_reset_queue(s);
924 s->update_irq(s->update_arg, 0);
925 }
926
927 static void ps2_common_post_load(PS2State *s)
928 {
929 PS2Queue *q = &s->queue;
930 uint8_t i, size;
931 uint8_t tmp_data[PS2_QUEUE_SIZE];
932
933 /* set the useful data buffer queue size, < PS2_QUEUE_SIZE */
934 size = q->count;
935 if (q->count < 0) {
936 size = 0;
937 } else if (q->count > PS2_QUEUE_SIZE) {
938 size = PS2_QUEUE_SIZE;
939 }
940
941 /* move the queue elements to the start of data array */
942 for (i = 0; i < size; i++) {
943 if (q->rptr < 0 || q->rptr >= sizeof(q->data)) {
944 q->rptr = 0;
945 }
946 tmp_data[i] = q->data[q->rptr++];
947 }
948 memcpy(q->data, tmp_data, size);
949
950 /* reset rptr/wptr/count */
951 q->rptr = 0;
952 q->wptr = (size == PS2_QUEUE_SIZE) ? 0 : size;
953 q->count = size;
954 }
955
956 static void ps2_kbd_reset(void *opaque)
957 {
958 PS2KbdState *s = (PS2KbdState *) opaque;
959
960 trace_ps2_kbd_reset(opaque);
961 ps2_common_reset(&s->common);
962 s->scan_enabled = 1;
963 s->translate = 0;
964 s->scancode_set = 2;
965 s->modifiers = 0;
966 }
967
968 static void ps2_mouse_reset(void *opaque)
969 {
970 PS2MouseState *s = (PS2MouseState *) opaque;
971
972 trace_ps2_mouse_reset(opaque);
973 ps2_common_reset(&s->common);
974 s->mouse_status = 0;
975 s->mouse_resolution = 0;
976 s->mouse_sample_rate = 0;
977 s->mouse_wrap = 0;
978 s->mouse_type = 0;
979 s->mouse_detect_state = 0;
980 s->mouse_dx = 0;
981 s->mouse_dy = 0;
982 s->mouse_dz = 0;
983 s->mouse_buttons = 0;
984 }
985
986 static const VMStateDescription vmstate_ps2_common = {
987 .name = "PS2 Common State",
988 .version_id = 3,
989 .minimum_version_id = 2,
990 .fields = (VMStateField[]) {
991 VMSTATE_INT32(write_cmd, PS2State),
992 VMSTATE_INT32(queue.rptr, PS2State),
993 VMSTATE_INT32(queue.wptr, PS2State),
994 VMSTATE_INT32(queue.count, PS2State),
995 VMSTATE_BUFFER(queue.data, PS2State),
996 VMSTATE_END_OF_LIST()
997 }
998 };
999
1000 static bool ps2_keyboard_ledstate_needed(void *opaque)
1001 {
1002 PS2KbdState *s = opaque;
1003
1004 return s->ledstate != 0; /* 0 is default state */
1005 }
1006
1007 static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
1008 {
1009 PS2KbdState *s = opaque;
1010
1011 kbd_put_ledstate(s->ledstate);
1012 return 0;
1013 }
1014
1015 static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
1016 .name = "ps2kbd/ledstate",
1017 .version_id = 3,
1018 .minimum_version_id = 2,
1019 .post_load = ps2_kbd_ledstate_post_load,
1020 .needed = ps2_keyboard_ledstate_needed,
1021 .fields = (VMStateField[]) {
1022 VMSTATE_INT32(ledstate, PS2KbdState),
1023 VMSTATE_END_OF_LIST()
1024 }
1025 };
1026
1027 static bool ps2_keyboard_need_high_bit_needed(void *opaque)
1028 {
1029 PS2KbdState *s = opaque;
1030 return s->need_high_bit != 0; /* 0 is the usual state */
1031 }
1032
1033 static const VMStateDescription vmstate_ps2_keyboard_need_high_bit = {
1034 .name = "ps2kbd/need_high_bit",
1035 .version_id = 1,
1036 .minimum_version_id = 1,
1037 .needed = ps2_keyboard_need_high_bit_needed,
1038 .fields = (VMStateField[]) {
1039 VMSTATE_BOOL(need_high_bit, PS2KbdState),
1040 VMSTATE_END_OF_LIST()
1041 }
1042 };
1043
1044 static int ps2_kbd_post_load(void* opaque, int version_id)
1045 {
1046 PS2KbdState *s = (PS2KbdState*)opaque;
1047 PS2State *ps2 = &s->common;
1048
1049 if (version_id == 2)
1050 s->scancode_set=2;
1051
1052 ps2_common_post_load(ps2);
1053
1054 return 0;
1055 }
1056
1057 static int ps2_kbd_pre_save(void *opaque)
1058 {
1059 PS2KbdState *s = (PS2KbdState *)opaque;
1060 PS2State *ps2 = &s->common;
1061
1062 ps2_common_post_load(ps2);
1063
1064 return 0;
1065 }
1066
1067 static const VMStateDescription vmstate_ps2_keyboard = {
1068 .name = "ps2kbd",
1069 .version_id = 3,
1070 .minimum_version_id = 2,
1071 .post_load = ps2_kbd_post_load,
1072 .pre_save = ps2_kbd_pre_save,
1073 .fields = (VMStateField[]) {
1074 VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
1075 VMSTATE_INT32(scan_enabled, PS2KbdState),
1076 VMSTATE_INT32(translate, PS2KbdState),
1077 VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
1078 VMSTATE_END_OF_LIST()
1079 },
1080 .subsections = (const VMStateDescription*[]) {
1081 &vmstate_ps2_keyboard_ledstate,
1082 &vmstate_ps2_keyboard_need_high_bit,
1083 NULL
1084 }
1085 };
1086
1087 static int ps2_mouse_post_load(void *opaque, int version_id)
1088 {
1089 PS2MouseState *s = (PS2MouseState *)opaque;
1090 PS2State *ps2 = &s->common;
1091
1092 ps2_common_post_load(ps2);
1093
1094 return 0;
1095 }
1096
1097 static int ps2_mouse_pre_save(void *opaque)
1098 {
1099 PS2MouseState *s = (PS2MouseState *)opaque;
1100 PS2State *ps2 = &s->common;
1101
1102 ps2_common_post_load(ps2);
1103
1104 return 0;
1105 }
1106
1107 static const VMStateDescription vmstate_ps2_mouse = {
1108 .name = "ps2mouse",
1109 .version_id = 2,
1110 .minimum_version_id = 2,
1111 .post_load = ps2_mouse_post_load,
1112 .pre_save = ps2_mouse_pre_save,
1113 .fields = (VMStateField[]) {
1114 VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
1115 VMSTATE_UINT8(mouse_status, PS2MouseState),
1116 VMSTATE_UINT8(mouse_resolution, PS2MouseState),
1117 VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
1118 VMSTATE_UINT8(mouse_wrap, PS2MouseState),
1119 VMSTATE_UINT8(mouse_type, PS2MouseState),
1120 VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
1121 VMSTATE_INT32(mouse_dx, PS2MouseState),
1122 VMSTATE_INT32(mouse_dy, PS2MouseState),
1123 VMSTATE_INT32(mouse_dz, PS2MouseState),
1124 VMSTATE_UINT8(mouse_buttons, PS2MouseState),
1125 VMSTATE_END_OF_LIST()
1126 }
1127 };
1128
1129 static QemuInputHandler ps2_keyboard_handler = {
1130 .name = "QEMU PS/2 Keyboard",
1131 .mask = INPUT_EVENT_MASK_KEY,
1132 .event = ps2_keyboard_event,
1133 };
1134
1135 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
1136 {
1137 PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));
1138
1139 trace_ps2_kbd_init(s);
1140 s->common.update_irq = update_irq;
1141 s->common.update_arg = update_arg;
1142 s->scancode_set = 2;
1143 vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
1144 qemu_input_handler_register((DeviceState *)s,
1145 &ps2_keyboard_handler);
1146 qemu_register_reset(ps2_kbd_reset, s);
1147 return s;
1148 }
1149
1150 static QemuInputHandler ps2_mouse_handler = {
1151 .name = "QEMU PS/2 Mouse",
1152 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
1153 .event = ps2_mouse_event,
1154 .sync = ps2_mouse_sync,
1155 };
1156
1157 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
1158 {
1159 PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));
1160
1161 trace_ps2_mouse_init(s);
1162 s->common.update_irq = update_irq;
1163 s->common.update_arg = update_arg;
1164 vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
1165 qemu_input_handler_register((DeviceState *)s,
1166 &ps2_mouse_handler);
1167 qemu_register_reset(ps2_mouse_reset, s);
1168 return s;
1169 }