xref: /openbmc/qemu/hw/input/ps2.c (revision ad80e367)
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 
ps2_modifier_bit(QKeyCode key)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 
ps2_reset_queue(PS2State * s)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 
ps2_queue_empty(PS2State * s)156 int ps2_queue_empty(PS2State *s)
157 {
158     return s->queue.count == 0;
159 }
160 
ps2_queue_noirq(PS2State * s,int b)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 
ps2_raise_irq(PS2State * s)176 static void ps2_raise_irq(PS2State *s)
177 {
178     qemu_set_irq(s->irq, 1);
179 }
180 
ps2_lower_irq(PS2State * s)181 static void ps2_lower_irq(PS2State *s)
182 {
183     qemu_set_irq(s->irq, 0);
184 }
185 
ps2_queue(PS2State * s,int b)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 
ps2_queue_2(PS2State * s,int b1,int b2)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 
ps2_queue_3(PS2State * s,int b1,int b2,int b3)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 
ps2_queue_4(PS2State * s,int b1,int b2,int b3,int b4)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 
ps2_cqueue_data(PS2Queue * q,int b)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 
ps2_cqueue_1(PS2State * s,int b1)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 
ps2_cqueue_2(PS2State * s,int b1,int b2)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 
ps2_cqueue_3(PS2State * s,int b1,int b2,int b3)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 
ps2_cqueue_reset(PS2State * s)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. */
ps2_put_keycode(void * opaque,int keycode)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 
ps2_keyboard_event(DeviceState * dev,QemuConsole * src,InputEvent * evt)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 if ((qcode == Q_KEY_CODE_LANG1 || qcode == Q_KEY_CODE_LANG2)
406                    && !key->down) {
407             /* Ignore release for these keys */
408         } else {
409             if (qcode < qemu_input_map_qcode_to_atset1_len) {
410                 keycode = qemu_input_map_qcode_to_atset1[qcode];
411             }
412             if (keycode) {
413                 if (keycode & 0xff00) {
414                     ps2_put_keycode(s, keycode >> 8);
415                 }
416                 if (!key->down) {
417                     keycode |= 0x80;
418                 }
419                 ps2_put_keycode(s, keycode & 0xff);
420             } else {
421                 qemu_log_mask(LOG_UNIMP,
422                               "ps2: ignoring key with qcode %d\n", qcode);
423             }
424         }
425     } else if (s->scancode_set == 2) {
426         if (qcode == Q_KEY_CODE_PAUSE) {
427             if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
428                 if (key->down) {
429                     ps2_put_keycode(s, 0xe0);
430                     ps2_put_keycode(s, 0x7e);
431                     ps2_put_keycode(s, 0xe0);
432                     ps2_put_keycode(s, 0xf0);
433                     ps2_put_keycode(s, 0x7e);
434                 }
435             } else {
436                 if (key->down) {
437                     ps2_put_keycode(s, 0xe1);
438                     ps2_put_keycode(s, 0x14);
439                     ps2_put_keycode(s, 0x77);
440                     ps2_put_keycode(s, 0xe1);
441                     ps2_put_keycode(s, 0xf0);
442                     ps2_put_keycode(s, 0x14);
443                     ps2_put_keycode(s, 0xf0);
444                     ps2_put_keycode(s, 0x77);
445                 }
446             }
447         } else if (qcode == Q_KEY_CODE_PRINT) {
448             if (s->modifiers & MOD_ALT_L) {
449                 if (key->down) {
450                     ps2_put_keycode(s, 0xf0);
451                     ps2_put_keycode(s, 0x11);
452                     ps2_put_keycode(s, 0x11);
453                     ps2_put_keycode(s, 0x84);
454                 } else {
455                     ps2_put_keycode(s, 0xf0);
456                     ps2_put_keycode(s, 0x84);
457                     ps2_put_keycode(s, 0xf0);
458                     ps2_put_keycode(s, 0x11);
459                     ps2_put_keycode(s, 0x11);
460                 }
461             } else if (s->modifiers & MOD_ALT_R) {
462                 if (key->down) {
463                     ps2_put_keycode(s, 0xe0);
464                     ps2_put_keycode(s, 0xf0);
465                     ps2_put_keycode(s, 0x11);
466                     ps2_put_keycode(s, 0xe0);
467                     ps2_put_keycode(s, 0x11);
468                     ps2_put_keycode(s, 0x84);
469                 } else {
470                     ps2_put_keycode(s, 0xf0);
471                     ps2_put_keycode(s, 0x84);
472                     ps2_put_keycode(s, 0xe0);
473                     ps2_put_keycode(s, 0xf0);
474                     ps2_put_keycode(s, 0x11);
475                     ps2_put_keycode(s, 0xe0);
476                     ps2_put_keycode(s, 0x11);
477                 }
478             } else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
479                                        MOD_SHIFT_R | MOD_CTRL_R)) {
480                 if (key->down) {
481                     ps2_put_keycode(s, 0xe0);
482                     ps2_put_keycode(s, 0x7c);
483                 } else {
484                     ps2_put_keycode(s, 0xe0);
485                     ps2_put_keycode(s, 0xf0);
486                     ps2_put_keycode(s, 0x7c);
487                 }
488             } else {
489                 if (key->down) {
490                     ps2_put_keycode(s, 0xe0);
491                     ps2_put_keycode(s, 0x12);
492                     ps2_put_keycode(s, 0xe0);
493                     ps2_put_keycode(s, 0x7c);
494                 } else {
495                     ps2_put_keycode(s, 0xe0);
496                     ps2_put_keycode(s, 0xf0);
497                     ps2_put_keycode(s, 0x7c);
498                     ps2_put_keycode(s, 0xe0);
499                     ps2_put_keycode(s, 0xf0);
500                     ps2_put_keycode(s, 0x12);
501                 }
502             }
503         } else if ((qcode == Q_KEY_CODE_LANG1 || qcode == Q_KEY_CODE_LANG2) &&
504                    !key->down) {
505             /* Ignore release for these keys */
506         } else {
507             if (qcode < qemu_input_map_qcode_to_atset2_len) {
508                 keycode = qemu_input_map_qcode_to_atset2[qcode];
509             }
510             if (keycode) {
511                 if (keycode & 0xff00) {
512                     ps2_put_keycode(s, keycode >> 8);
513                 }
514                 if (!key->down) {
515                     ps2_put_keycode(s, 0xf0);
516                 }
517                 ps2_put_keycode(s, keycode & 0xff);
518             } else {
519                 qemu_log_mask(LOG_UNIMP,
520                               "ps2: ignoring key with qcode %d\n", qcode);
521             }
522         }
523     } else if (s->scancode_set == 3) {
524         if (qcode < qemu_input_map_qcode_to_atset3_len) {
525             keycode = qemu_input_map_qcode_to_atset3[qcode];
526         }
527         if (keycode) {
528             /* FIXME: break code should be configured on a key by key basis */
529             if (!key->down) {
530                 ps2_put_keycode(s, 0xf0);
531             }
532             ps2_put_keycode(s, keycode);
533         } else {
534             qemu_log_mask(LOG_UNIMP,
535                           "ps2: ignoring key with qcode %d\n", qcode);
536         }
537     }
538 }
539 
ps2_read_data(PS2State * s)540 uint32_t ps2_read_data(PS2State *s)
541 {
542     PS2Queue *q;
543     int val, index;
544 
545     trace_ps2_read_data(s);
546     q = &s->queue;
547     if (q->count == 0) {
548         /*
549          * NOTE: if no data left, we return the last keyboard one
550          * (needed for EMM386)
551          */
552         /* XXX: need a timer to do things correctly */
553         index = q->rptr - 1;
554         if (index < 0) {
555             index = PS2_BUFFER_SIZE - 1;
556         }
557         val = q->data[index];
558     } else {
559         val = q->data[q->rptr];
560         if (++q->rptr == PS2_BUFFER_SIZE) {
561             q->rptr = 0;
562         }
563         q->count--;
564         if (q->rptr == q->cwptr) {
565             /* command reply queue is empty */
566             q->cwptr = -1;
567         }
568         /* reading deasserts IRQ */
569         ps2_lower_irq(s);
570         /* reassert IRQs if data left */
571         if (q->count) {
572             ps2_raise_irq(s);
573         }
574     }
575     return val;
576 }
577 
ps2_set_ledstate(PS2KbdState * s,int ledstate)578 static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
579 {
580     trace_ps2_set_ledstate(s, ledstate);
581     s->ledstate = ledstate;
582     kbd_put_ledstate(ledstate);
583 }
584 
ps2_reset_keyboard(PS2KbdState * s)585 static void ps2_reset_keyboard(PS2KbdState *s)
586 {
587     PS2State *ps2 = PS2_DEVICE(s);
588 
589     trace_ps2_reset_keyboard(s);
590     s->scan_enabled = 1;
591     s->scancode_set = 2;
592     ps2_reset_queue(ps2);
593     ps2_set_ledstate(s, 0);
594 }
595 
ps2_write_keyboard(PS2KbdState * s,int val)596 void ps2_write_keyboard(PS2KbdState *s, int val)
597 {
598     PS2State *ps2 = PS2_DEVICE(s);
599 
600     trace_ps2_write_keyboard(s, val);
601     ps2_cqueue_reset(ps2);
602     switch (ps2->write_cmd) {
603     default:
604     case -1:
605         switch (val) {
606         case 0x00:
607             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
608             break;
609         case 0x05:
610             ps2_cqueue_1(ps2, KBD_REPLY_RESEND);
611             break;
612         case KBD_CMD_GET_ID:
613             /* We emulate a MF2 AT keyboard here */
614             ps2_cqueue_3(ps2, KBD_REPLY_ACK, KBD_REPLY_ID,
615                          s->translate ? 0x41 : 0x83);
616             break;
617         case KBD_CMD_ECHO:
618             ps2_cqueue_1(ps2, KBD_CMD_ECHO);
619             break;
620         case KBD_CMD_ENABLE:
621             s->scan_enabled = 1;
622             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
623             break;
624         case KBD_CMD_SCANCODE:
625         case KBD_CMD_SET_LEDS:
626         case KBD_CMD_SET_RATE:
627         case KBD_CMD_SET_MAKE_BREAK:
628             ps2->write_cmd = val;
629             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
630             break;
631         case KBD_CMD_RESET_DISABLE:
632             ps2_reset_keyboard(s);
633             s->scan_enabled = 0;
634             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
635             break;
636         case KBD_CMD_RESET_ENABLE:
637             ps2_reset_keyboard(s);
638             s->scan_enabled = 1;
639             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
640             break;
641         case KBD_CMD_RESET:
642             ps2_reset_keyboard(s);
643             ps2_cqueue_2(ps2,
644                          KBD_REPLY_ACK,
645                          KBD_REPLY_POR);
646             break;
647         case KBD_CMD_SET_TYPEMATIC:
648             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
649             break;
650         default:
651             ps2_cqueue_1(ps2, KBD_REPLY_RESEND);
652             break;
653         }
654         break;
655     case KBD_CMD_SET_MAKE_BREAK:
656         ps2_cqueue_1(ps2, KBD_REPLY_ACK);
657         ps2->write_cmd = -1;
658         break;
659     case KBD_CMD_SCANCODE:
660         if (val == 0) {
661             ps2_cqueue_2(ps2, KBD_REPLY_ACK, s->translate ?
662                 translate_table[s->scancode_set] : s->scancode_set);
663         } else if (val >= 1 && val <= 3) {
664             s->scancode_set = val;
665             ps2_cqueue_1(ps2, KBD_REPLY_ACK);
666         } else {
667             ps2_cqueue_1(ps2, KBD_REPLY_RESEND);
668         }
669         ps2->write_cmd = -1;
670         break;
671     case KBD_CMD_SET_LEDS:
672         ps2_set_ledstate(s, val);
673         ps2_cqueue_1(ps2, KBD_REPLY_ACK);
674         ps2->write_cmd = -1;
675         break;
676     case KBD_CMD_SET_RATE:
677         ps2_cqueue_1(ps2, KBD_REPLY_ACK);
678         ps2->write_cmd = -1;
679         break;
680     }
681 }
682 
683 /*
684  * Set the scancode translation mode.
685  * 0 = raw scancodes.
686  * 1 = translated scancodes (used by qemu internally).
687  */
688 
ps2_keyboard_set_translation(PS2KbdState * s,int mode)689 void ps2_keyboard_set_translation(PS2KbdState *s, int mode)
690 {
691     trace_ps2_keyboard_set_translation(s, mode);
692     s->translate = mode;
693 }
694 
ps2_mouse_send_packet(PS2MouseState * s)695 static int ps2_mouse_send_packet(PS2MouseState *s)
696 {
697     PS2State *ps2 = PS2_DEVICE(s);
698     /* IMPS/2 and IMEX send 4 bytes, PS2 sends 3 bytes */
699     const int needed = s->mouse_type ? 4 : 3;
700     unsigned int b;
701     int dx1, dy1, dz1, dw1;
702 
703     if (PS2_QUEUE_SIZE - ps2->queue.count < needed) {
704         return 0;
705     }
706 
707     dx1 = s->mouse_dx;
708     dy1 = s->mouse_dy;
709     dz1 = s->mouse_dz;
710     dw1 = s->mouse_dw;
711     /* XXX: increase range to 8 bits ? */
712     if (dx1 > 127) {
713         dx1 = 127;
714     } else if (dx1 < -127) {
715         dx1 = -127;
716     }
717     if (dy1 > 127) {
718         dy1 = 127;
719     } else if (dy1 < -127) {
720         dy1 = -127;
721     }
722     b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
723     ps2_queue_noirq(ps2, b);
724     ps2_queue_noirq(ps2, dx1 & 0xff);
725     ps2_queue_noirq(ps2, dy1 & 0xff);
726     /* extra byte for IMPS/2 or IMEX */
727     switch (s->mouse_type) {
728     default:
729         /* Just ignore the wheels if not supported */
730         s->mouse_dz = 0;
731         s->mouse_dw = 0;
732         break;
733     case 3:
734         if (dz1 > 127) {
735             dz1 = 127;
736         } else if (dz1 < -127) {
737             dz1 = -127;
738         }
739         ps2_queue_noirq(ps2, dz1 & 0xff);
740         s->mouse_dz -= dz1;
741         s->mouse_dw = 0;
742         break;
743     case 4:
744         /*
745          * This matches what the Linux kernel expects for exps/2 in
746          * drivers/input/mouse/psmouse-base.c. Note, if you happen to
747          * press/release the 4th or 5th buttons at the same moment as a
748          * horizontal wheel scroll, those button presses will get lost. I'm not
749          * sure what to do about that, since by this point we don't know
750          * whether those buttons actually changed state.
751          */
752         if (dw1 != 0) {
753             if (dw1 > 31) {
754                 dw1 = 31;
755             } else if (dw1 < -31) {
756                 dw1 = -31;
757             }
758 
759             /*
760              * linux kernel expects first 6 bits to represent the value
761              * for horizontal scroll
762              */
763             b = (dw1 & 0x3f) | 0x40;
764             s->mouse_dw -= dw1;
765         } else {
766             if (dz1 > 7) {
767                 dz1 = 7;
768             } else if (dz1 < -7) {
769                 dz1 = -7;
770             }
771 
772             b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
773             s->mouse_dz -= dz1;
774         }
775         ps2_queue_noirq(ps2, b);
776         break;
777     }
778 
779     ps2_raise_irq(ps2);
780 
781     trace_ps2_mouse_send_packet(s, dx1, dy1, dz1, b);
782     /* update deltas */
783     s->mouse_dx -= dx1;
784     s->mouse_dy -= dy1;
785 
786     return 1;
787 }
788 
ps2_mouse_event(DeviceState * dev,QemuConsole * src,InputEvent * evt)789 static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
790                             InputEvent *evt)
791 {
792     static const int bmap[INPUT_BUTTON__MAX] = {
793         [INPUT_BUTTON_LEFT]   = PS2_MOUSE_BUTTON_LEFT,
794         [INPUT_BUTTON_MIDDLE] = PS2_MOUSE_BUTTON_MIDDLE,
795         [INPUT_BUTTON_RIGHT]  = PS2_MOUSE_BUTTON_RIGHT,
796         [INPUT_BUTTON_SIDE]   = PS2_MOUSE_BUTTON_SIDE,
797         [INPUT_BUTTON_EXTRA]  = PS2_MOUSE_BUTTON_EXTRA,
798     };
799     PS2MouseState *s = (PS2MouseState *)dev;
800     InputMoveEvent *move;
801     InputBtnEvent *btn;
802 
803     /* check if deltas are recorded when disabled */
804     if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) {
805         return;
806     }
807 
808     switch (evt->type) {
809     case INPUT_EVENT_KIND_REL:
810         move = evt->u.rel.data;
811         if (move->axis == INPUT_AXIS_X) {
812             s->mouse_dx += move->value;
813         } else if (move->axis == INPUT_AXIS_Y) {
814             s->mouse_dy -= move->value;
815         }
816         break;
817 
818     case INPUT_EVENT_KIND_BTN:
819         btn = evt->u.btn.data;
820         if (btn->down) {
821             s->mouse_buttons |= bmap[btn->button];
822             if (btn->button == INPUT_BUTTON_WHEEL_UP) {
823                 s->mouse_dz--;
824             } else if (btn->button == INPUT_BUTTON_WHEEL_DOWN) {
825                 s->mouse_dz++;
826             }
827 
828             if (btn->button == INPUT_BUTTON_WHEEL_RIGHT) {
829                 s->mouse_dw--;
830             } else if (btn->button == INPUT_BUTTON_WHEEL_LEFT) {
831                 s->mouse_dw++;
832             }
833         } else {
834             s->mouse_buttons &= ~bmap[btn->button];
835         }
836         break;
837 
838     default:
839         /* keep gcc happy */
840         break;
841     }
842 }
843 
ps2_mouse_sync(DeviceState * dev)844 static void ps2_mouse_sync(DeviceState *dev)
845 {
846     PS2MouseState *s = (PS2MouseState *)dev;
847 
848     /* do not sync while disabled to prevent stream corruption */
849     if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) {
850         return;
851     }
852 
853     if (s->mouse_buttons) {
854         qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
855     }
856     if (!(s->mouse_status & MOUSE_STATUS_REMOTE)) {
857         /*
858          * if not remote, send event. Multiple events are sent if
859          * too big deltas
860          */
861         while (ps2_mouse_send_packet(s)) {
862             if (s->mouse_dx == 0 && s->mouse_dy == 0
863                     && s->mouse_dz == 0 && s->mouse_dw == 0) {
864                 break;
865             }
866         }
867     }
868 }
869 
ps2_mouse_fake_event(PS2MouseState * s)870 void ps2_mouse_fake_event(PS2MouseState *s)
871 {
872     trace_ps2_mouse_fake_event(s);
873     s->mouse_dx++;
874     ps2_mouse_sync(DEVICE(s));
875 }
876 
ps2_write_mouse(PS2MouseState * s,int val)877 void ps2_write_mouse(PS2MouseState *s, int val)
878 {
879     PS2State *ps2 = PS2_DEVICE(s);
880 
881     trace_ps2_write_mouse(s, val);
882     switch (ps2->write_cmd) {
883     default:
884     case -1:
885         /* mouse command */
886         if (s->mouse_wrap) {
887             if (val == AUX_RESET_WRAP) {
888                 s->mouse_wrap = 0;
889                 ps2_queue(ps2, AUX_ACK);
890                 return;
891             } else if (val != AUX_RESET) {
892                 ps2_queue(ps2, val);
893                 return;
894             }
895         }
896         switch (val) {
897         case AUX_SET_SCALE11:
898             s->mouse_status &= ~MOUSE_STATUS_SCALE21;
899             ps2_queue(ps2, AUX_ACK);
900             break;
901         case AUX_SET_SCALE21:
902             s->mouse_status |= MOUSE_STATUS_SCALE21;
903             ps2_queue(ps2, AUX_ACK);
904             break;
905         case AUX_SET_STREAM:
906             s->mouse_status &= ~MOUSE_STATUS_REMOTE;
907             ps2_queue(ps2, AUX_ACK);
908             break;
909         case AUX_SET_WRAP:
910             s->mouse_wrap = 1;
911             ps2_queue(ps2, AUX_ACK);
912             break;
913         case AUX_SET_REMOTE:
914             s->mouse_status |= MOUSE_STATUS_REMOTE;
915             ps2_queue(ps2, AUX_ACK);
916             break;
917         case AUX_GET_TYPE:
918             ps2_queue_2(ps2,
919                 AUX_ACK,
920                 s->mouse_type);
921             break;
922         case AUX_SET_RES:
923         case AUX_SET_SAMPLE:
924             ps2->write_cmd = val;
925             ps2_queue(ps2, AUX_ACK);
926             break;
927         case AUX_GET_SCALE:
928             ps2_queue_4(ps2,
929                 AUX_ACK,
930                 s->mouse_status,
931                 s->mouse_resolution,
932                 s->mouse_sample_rate);
933             break;
934         case AUX_POLL:
935             ps2_queue(ps2, AUX_ACK);
936             ps2_mouse_send_packet(s);
937             break;
938         case AUX_ENABLE_DEV:
939             s->mouse_status |= MOUSE_STATUS_ENABLED;
940             ps2_queue(ps2, AUX_ACK);
941             break;
942         case AUX_DISABLE_DEV:
943             s->mouse_status &= ~MOUSE_STATUS_ENABLED;
944             ps2_queue(ps2, AUX_ACK);
945             break;
946         case AUX_SET_DEFAULT:
947             s->mouse_sample_rate = 100;
948             s->mouse_resolution = 2;
949             s->mouse_status = 0;
950             ps2_queue(ps2, AUX_ACK);
951             break;
952         case AUX_RESET:
953             s->mouse_sample_rate = 100;
954             s->mouse_resolution = 2;
955             s->mouse_status = 0;
956             s->mouse_type = 0;
957             ps2_reset_queue(ps2);
958             ps2_queue_3(ps2,
959                 AUX_ACK,
960                 0xaa,
961                 s->mouse_type);
962             break;
963         default:
964             break;
965         }
966         break;
967     case AUX_SET_SAMPLE:
968         s->mouse_sample_rate = val;
969         /* detect IMPS/2 or IMEX */
970         switch (s->mouse_detect_state) {
971         default:
972         case 0:
973             if (val == 200) {
974                 s->mouse_detect_state = 1;
975             }
976             break;
977         case 1:
978             if (val == 100) {
979                 s->mouse_detect_state = 2;
980             } else if (val == 200) {
981                 s->mouse_detect_state = 3;
982             } else {
983                 s->mouse_detect_state = 0;
984             }
985             break;
986         case 2:
987             if (val == 80) {
988                 s->mouse_type = 3; /* IMPS/2 */
989             }
990             s->mouse_detect_state = 0;
991             break;
992         case 3:
993             if (val == 80) {
994                 s->mouse_type = 4; /* IMEX */
995             }
996             s->mouse_detect_state = 0;
997             break;
998         }
999         ps2_queue(ps2, AUX_ACK);
1000         ps2->write_cmd = -1;
1001         break;
1002     case AUX_SET_RES:
1003         s->mouse_resolution = val;
1004         ps2_queue(ps2, AUX_ACK);
1005         ps2->write_cmd = -1;
1006         break;
1007     }
1008 }
1009 
ps2_reset_hold(Object * obj,ResetType type)1010 static void ps2_reset_hold(Object *obj, ResetType type)
1011 {
1012     PS2State *s = PS2_DEVICE(obj);
1013 
1014     s->write_cmd = -1;
1015     ps2_reset_queue(s);
1016 }
1017 
ps2_reset_exit(Object * obj,ResetType type)1018 static void ps2_reset_exit(Object *obj, ResetType type)
1019 {
1020     PS2State *s = PS2_DEVICE(obj);
1021 
1022     ps2_lower_irq(s);
1023 }
1024 
ps2_common_post_load(PS2State * s)1025 static void ps2_common_post_load(PS2State *s)
1026 {
1027     PS2Queue *q = &s->queue;
1028     int ccount = 0;
1029 
1030     /* limit the number of queued command replies to PS2_QUEUE_HEADROOM */
1031     if (q->cwptr != -1) {
1032         ccount = (q->cwptr - q->rptr) & (PS2_BUFFER_SIZE - 1);
1033         if (ccount > PS2_QUEUE_HEADROOM) {
1034             ccount = PS2_QUEUE_HEADROOM;
1035         }
1036     }
1037 
1038     /* limit the scancode queue size to PS2_QUEUE_SIZE */
1039     if (q->count < ccount) {
1040         q->count = ccount;
1041     } else if (q->count > ccount + PS2_QUEUE_SIZE) {
1042         q->count = ccount + PS2_QUEUE_SIZE;
1043     }
1044 
1045     /* sanitize rptr and recalculate wptr and cwptr */
1046     q->rptr = q->rptr & (PS2_BUFFER_SIZE - 1);
1047     q->wptr = (q->rptr + q->count) & (PS2_BUFFER_SIZE - 1);
1048     q->cwptr = ccount ? (q->rptr + ccount) & (PS2_BUFFER_SIZE - 1) : -1;
1049 }
1050 
ps2_kbd_reset_hold(Object * obj,ResetType type)1051 static void ps2_kbd_reset_hold(Object *obj, ResetType type)
1052 {
1053     PS2DeviceClass *ps2dc = PS2_DEVICE_GET_CLASS(obj);
1054     PS2KbdState *s = PS2_KBD_DEVICE(obj);
1055 
1056     trace_ps2_kbd_reset(s);
1057 
1058     if (ps2dc->parent_phases.hold) {
1059         ps2dc->parent_phases.hold(obj, type);
1060     }
1061 
1062     s->scan_enabled = 1;
1063     s->translate = 0;
1064     s->scancode_set = 2;
1065     s->modifiers = 0;
1066 }
1067 
ps2_mouse_reset_hold(Object * obj,ResetType type)1068 static void ps2_mouse_reset_hold(Object *obj, ResetType type)
1069 {
1070     PS2DeviceClass *ps2dc = PS2_DEVICE_GET_CLASS(obj);
1071     PS2MouseState *s = PS2_MOUSE_DEVICE(obj);
1072 
1073     trace_ps2_mouse_reset(s);
1074 
1075     if (ps2dc->parent_phases.hold) {
1076         ps2dc->parent_phases.hold(obj, type);
1077     }
1078 
1079     s->mouse_status = 0;
1080     s->mouse_resolution = 0;
1081     s->mouse_sample_rate = 0;
1082     s->mouse_wrap = 0;
1083     s->mouse_type = 0;
1084     s->mouse_detect_state = 0;
1085     s->mouse_dx = 0;
1086     s->mouse_dy = 0;
1087     s->mouse_dz = 0;
1088     s->mouse_dw = 0;
1089     s->mouse_buttons = 0;
1090 }
1091 
1092 static const VMStateDescription vmstate_ps2_common = {
1093     .name = "PS2 Common State",
1094     .version_id = 3,
1095     .minimum_version_id = 2,
1096     .fields = (const VMStateField[]) {
1097         VMSTATE_INT32(write_cmd, PS2State),
1098         VMSTATE_INT32(queue.rptr, PS2State),
1099         VMSTATE_INT32(queue.wptr, PS2State),
1100         VMSTATE_INT32(queue.count, PS2State),
1101         VMSTATE_BUFFER(queue.data, PS2State),
1102         VMSTATE_END_OF_LIST()
1103     }
1104 };
1105 
ps2_keyboard_ledstate_needed(void * opaque)1106 static bool ps2_keyboard_ledstate_needed(void *opaque)
1107 {
1108     PS2KbdState *s = opaque;
1109 
1110     return s->ledstate != 0; /* 0 is default state */
1111 }
1112 
ps2_kbd_ledstate_post_load(void * opaque,int version_id)1113 static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
1114 {
1115     PS2KbdState *s = opaque;
1116 
1117     kbd_put_ledstate(s->ledstate);
1118     return 0;
1119 }
1120 
1121 static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
1122     .name = "ps2kbd/ledstate",
1123     .version_id = 3,
1124     .minimum_version_id = 2,
1125     .post_load = ps2_kbd_ledstate_post_load,
1126     .needed = ps2_keyboard_ledstate_needed,
1127     .fields = (const VMStateField[]) {
1128         VMSTATE_INT32(ledstate, PS2KbdState),
1129         VMSTATE_END_OF_LIST()
1130     }
1131 };
1132 
ps2_keyboard_need_high_bit_needed(void * opaque)1133 static bool ps2_keyboard_need_high_bit_needed(void *opaque)
1134 {
1135     PS2KbdState *s = opaque;
1136     return s->need_high_bit != 0; /* 0 is the usual state */
1137 }
1138 
1139 static const VMStateDescription vmstate_ps2_keyboard_need_high_bit = {
1140     .name = "ps2kbd/need_high_bit",
1141     .version_id = 1,
1142     .minimum_version_id = 1,
1143     .needed = ps2_keyboard_need_high_bit_needed,
1144     .fields = (const VMStateField[]) {
1145         VMSTATE_BOOL(need_high_bit, PS2KbdState),
1146         VMSTATE_END_OF_LIST()
1147     }
1148 };
1149 
ps2_keyboard_cqueue_needed(void * opaque)1150 static bool ps2_keyboard_cqueue_needed(void *opaque)
1151 {
1152     PS2KbdState *s = opaque;
1153     PS2State *ps2 = PS2_DEVICE(s);
1154 
1155     return ps2->queue.cwptr != -1; /* the queue is mostly empty */
1156 }
1157 
1158 static const VMStateDescription vmstate_ps2_keyboard_cqueue = {
1159     .name = "ps2kbd/command_reply_queue",
1160     .needed = ps2_keyboard_cqueue_needed,
1161     .fields = (const VMStateField[]) {
1162         VMSTATE_INT32(parent_obj.queue.cwptr, PS2KbdState),
1163         VMSTATE_END_OF_LIST()
1164     }
1165 };
1166 
ps2_kbd_post_load(void * opaque,int version_id)1167 static int ps2_kbd_post_load(void *opaque, int version_id)
1168 {
1169     PS2KbdState *s = (PS2KbdState *)opaque;
1170     PS2State *ps2 = PS2_DEVICE(s);
1171 
1172     if (version_id == 2) {
1173         s->scancode_set = 2;
1174     }
1175 
1176     ps2_common_post_load(ps2);
1177 
1178     return 0;
1179 }
1180 
1181 static const VMStateDescription vmstate_ps2_keyboard = {
1182     .name = "ps2kbd",
1183     .version_id = 3,
1184     .minimum_version_id = 2,
1185     .post_load = ps2_kbd_post_load,
1186     .fields = (const VMStateField[]) {
1187         VMSTATE_STRUCT(parent_obj, PS2KbdState, 0, vmstate_ps2_common,
1188                        PS2State),
1189         VMSTATE_INT32(scan_enabled, PS2KbdState),
1190         VMSTATE_INT32(translate, PS2KbdState),
1191         VMSTATE_INT32_V(scancode_set, PS2KbdState, 3),
1192         VMSTATE_END_OF_LIST()
1193     },
1194     .subsections = (const VMStateDescription * const []) {
1195         &vmstate_ps2_keyboard_ledstate,
1196         &vmstate_ps2_keyboard_need_high_bit,
1197         &vmstate_ps2_keyboard_cqueue,
1198         NULL
1199     }
1200 };
1201 
ps2_mouse_post_load(void * opaque,int version_id)1202 static int ps2_mouse_post_load(void *opaque, int version_id)
1203 {
1204     PS2MouseState *s = (PS2MouseState *)opaque;
1205     PS2State *ps2 = PS2_DEVICE(s);
1206 
1207     ps2_common_post_load(ps2);
1208 
1209     return 0;
1210 }
1211 
1212 static const VMStateDescription vmstate_ps2_mouse = {
1213     .name = "ps2mouse",
1214     .version_id = 2,
1215     .minimum_version_id = 2,
1216     .post_load = ps2_mouse_post_load,
1217     .fields = (const VMStateField[]) {
1218         VMSTATE_STRUCT(parent_obj, PS2MouseState, 0, vmstate_ps2_common,
1219                        PS2State),
1220         VMSTATE_UINT8(mouse_status, PS2MouseState),
1221         VMSTATE_UINT8(mouse_resolution, PS2MouseState),
1222         VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
1223         VMSTATE_UINT8(mouse_wrap, PS2MouseState),
1224         VMSTATE_UINT8(mouse_type, PS2MouseState),
1225         VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
1226         VMSTATE_INT32(mouse_dx, PS2MouseState),
1227         VMSTATE_INT32(mouse_dy, PS2MouseState),
1228         VMSTATE_INT32(mouse_dz, PS2MouseState),
1229         VMSTATE_UINT8(mouse_buttons, PS2MouseState),
1230         VMSTATE_END_OF_LIST()
1231     }
1232 };
1233 
1234 static const QemuInputHandler ps2_keyboard_handler = {
1235     .name  = "QEMU PS/2 Keyboard",
1236     .mask  = INPUT_EVENT_MASK_KEY,
1237     .event = ps2_keyboard_event,
1238 };
1239 
ps2_kbd_realize(DeviceState * dev,Error ** errp)1240 static void ps2_kbd_realize(DeviceState *dev, Error **errp)
1241 {
1242     qemu_input_handler_register(dev, &ps2_keyboard_handler);
1243 }
1244 
1245 static const QemuInputHandler ps2_mouse_handler = {
1246     .name  = "QEMU PS/2 Mouse",
1247     .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
1248     .event = ps2_mouse_event,
1249     .sync  = ps2_mouse_sync,
1250 };
1251 
ps2_mouse_realize(DeviceState * dev,Error ** errp)1252 static void ps2_mouse_realize(DeviceState *dev, Error **errp)
1253 {
1254     qemu_input_handler_register(dev, &ps2_mouse_handler);
1255 }
1256 
ps2_kbd_class_init(ObjectClass * klass,void * data)1257 static void ps2_kbd_class_init(ObjectClass *klass, void *data)
1258 {
1259     DeviceClass *dc = DEVICE_CLASS(klass);
1260     ResettableClass *rc = RESETTABLE_CLASS(klass);
1261     PS2DeviceClass *ps2dc = PS2_DEVICE_CLASS(klass);
1262 
1263     dc->realize = ps2_kbd_realize;
1264     resettable_class_set_parent_phases(rc, NULL, ps2_kbd_reset_hold, NULL,
1265                                        &ps2dc->parent_phases);
1266     dc->vmsd = &vmstate_ps2_keyboard;
1267 }
1268 
1269 static const TypeInfo ps2_kbd_info = {
1270     .name          = TYPE_PS2_KBD_DEVICE,
1271     .parent        = TYPE_PS2_DEVICE,
1272     .instance_size = sizeof(PS2KbdState),
1273     .class_init    = ps2_kbd_class_init
1274 };
1275 
ps2_mouse_class_init(ObjectClass * klass,void * data)1276 static void ps2_mouse_class_init(ObjectClass *klass, void *data)
1277 {
1278     DeviceClass *dc = DEVICE_CLASS(klass);
1279     ResettableClass *rc = RESETTABLE_CLASS(klass);
1280     PS2DeviceClass *ps2dc = PS2_DEVICE_CLASS(klass);
1281 
1282     dc->realize = ps2_mouse_realize;
1283     resettable_class_set_parent_phases(rc, NULL, ps2_mouse_reset_hold, NULL,
1284                                        &ps2dc->parent_phases);
1285     dc->vmsd = &vmstate_ps2_mouse;
1286 }
1287 
1288 static const TypeInfo ps2_mouse_info = {
1289     .name          = TYPE_PS2_MOUSE_DEVICE,
1290     .parent        = TYPE_PS2_DEVICE,
1291     .instance_size = sizeof(PS2MouseState),
1292     .class_init    = ps2_mouse_class_init
1293 };
1294 
ps2_init(Object * obj)1295 static void ps2_init(Object *obj)
1296 {
1297     PS2State *s = PS2_DEVICE(obj);
1298 
1299     qdev_init_gpio_out(DEVICE(obj), &s->irq, 1);
1300 }
1301 
ps2_class_init(ObjectClass * klass,void * data)1302 static void ps2_class_init(ObjectClass *klass, void *data)
1303 {
1304     DeviceClass *dc = DEVICE_CLASS(klass);
1305     ResettableClass *rc = RESETTABLE_CLASS(klass);
1306 
1307     rc->phases.hold = ps2_reset_hold;
1308     rc->phases.exit = ps2_reset_exit;
1309     set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
1310 }
1311 
1312 static const TypeInfo ps2_info = {
1313     .name          = TYPE_PS2_DEVICE,
1314     .parent        = TYPE_SYS_BUS_DEVICE,
1315     .instance_init = ps2_init,
1316     .instance_size = sizeof(PS2State),
1317     .class_init    = ps2_class_init,
1318     .class_size    = sizeof(PS2DeviceClass),
1319     .abstract      = true
1320 };
1321 
ps2_register_types(void)1322 static void ps2_register_types(void)
1323 {
1324     type_register_static(&ps2_info);
1325     type_register_static(&ps2_kbd_info);
1326     type_register_static(&ps2_mouse_info);
1327 }
1328 
1329 type_init(ps2_register_types)
1330