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