PPC: e500mc: add missing IVORs to bitmap
[qemu.git] / hw / 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 #include "hw.h"
25 #include "ps2.h"
26 #include "console.h"
27
28 /* debug PC keyboard */
29 //#define DEBUG_KBD
30
31 /* debug PC keyboard : only mouse */
32 //#define DEBUG_MOUSE
33
34 /* Keyboard Commands */
35 #define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
36 #define KBD_CMD_ECHO 0xEE
37 #define KBD_CMD_SCANCODE 0xF0 /* Get/set scancode set */
38 #define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
39 #define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
40 #define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
41 #define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
42 #define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
43 #define KBD_CMD_RESET 0xFF /* Reset */
44
45 /* Keyboard Replies */
46 #define KBD_REPLY_POR 0xAA /* Power on reset */
47 #define KBD_REPLY_ID 0xAB /* Keyboard ID */
48 #define KBD_REPLY_ACK 0xFA /* Command ACK */
49 #define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
50
51 /* Mouse Commands */
52 #define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
53 #define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
54 #define AUX_SET_RES 0xE8 /* Set resolution */
55 #define AUX_GET_SCALE 0xE9 /* Get scaling factor */
56 #define AUX_SET_STREAM 0xEA /* Set stream mode */
57 #define AUX_POLL 0xEB /* Poll */
58 #define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
59 #define AUX_SET_WRAP 0xEE /* Set wrap mode */
60 #define AUX_SET_REMOTE 0xF0 /* Set remote mode */
61 #define AUX_GET_TYPE 0xF2 /* Get type */
62 #define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
63 #define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
64 #define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
65 #define AUX_SET_DEFAULT 0xF6
66 #define AUX_RESET 0xFF /* Reset aux device */
67 #define AUX_ACK 0xFA /* Command byte ACK. */
68
69 #define MOUSE_STATUS_REMOTE 0x40
70 #define MOUSE_STATUS_ENABLED 0x20
71 #define MOUSE_STATUS_SCALE21 0x10
72
73 #define PS2_QUEUE_SIZE 256
74
75 typedef struct {
76 uint8_t data[PS2_QUEUE_SIZE];
77 int rptr, wptr, count;
78 } PS2Queue;
79
80 typedef struct {
81 PS2Queue queue;
82 int32_t write_cmd;
83 void (*update_irq)(void *, int);
84 void *update_arg;
85 } PS2State;
86
87 typedef struct {
88 PS2State common;
89 int scan_enabled;
90 /* Qemu uses translated PC scancodes internally. To avoid multiple
91 conversions we do the translation (if any) in the PS/2 emulation
92 not the keyboard controller. */
93 int translate;
94 int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
95 int ledstate;
96 } PS2KbdState;
97
98 typedef struct {
99 PS2State common;
100 uint8_t mouse_status;
101 uint8_t mouse_resolution;
102 uint8_t mouse_sample_rate;
103 uint8_t mouse_wrap;
104 uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
105 uint8_t mouse_detect_state;
106 int mouse_dx; /* current values, needed for 'poll' mode */
107 int mouse_dy;
108 int mouse_dz;
109 uint8_t mouse_buttons;
110 } PS2MouseState;
111
112 /* Table to convert from PC scancodes to raw scancodes. */
113 static const unsigned char ps2_raw_keycode[128] = {
114 0, 118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
115 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
116 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
117 50, 49, 58, 65, 73, 74, 89, 124, 17, 41, 88, 5, 6, 4, 12, 3,
118 11, 2, 10, 1, 9, 119, 126, 108, 117, 125, 123, 107, 115, 116, 121, 105,
119 114, 122, 112, 113, 127, 96, 97, 120, 7, 15, 23, 31, 39, 47, 55, 63,
120 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
121 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
122 };
123 static const unsigned char ps2_raw_keycode_set3[128] = {
124 0, 8, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
125 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 17, 28, 27,
126 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 92, 26, 34, 33, 42,
127 50, 49, 58, 65, 73, 74, 89, 126, 25, 41, 20, 7, 15, 23, 31, 39,
128 47, 2, 63, 71, 79, 118, 95, 108, 117, 125, 132, 107, 115, 116, 124, 105,
129 114, 122, 112, 113, 127, 96, 97, 86, 94, 15, 23, 31, 39, 47, 55, 63,
130 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
131 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
132 };
133
134 void ps2_queue(void *opaque, int b)
135 {
136 PS2State *s = (PS2State *)opaque;
137 PS2Queue *q = &s->queue;
138
139 if (q->count >= PS2_QUEUE_SIZE)
140 return;
141 q->data[q->wptr] = b;
142 if (++q->wptr == PS2_QUEUE_SIZE)
143 q->wptr = 0;
144 q->count++;
145 s->update_irq(s->update_arg, 1);
146 }
147
148 /*
149 keycode is expressed as follow:
150 bit 7 - 0 key pressed, 1 = key released
151 bits 6-0 - translated scancode set 2
152 */
153 static void ps2_put_keycode(void *opaque, int keycode)
154 {
155 PS2KbdState *s = opaque;
156
157 /* XXX: add support for scancode set 1 */
158 if (!s->translate && keycode < 0xe0 && s->scancode_set > 1) {
159 if (keycode & 0x80) {
160 ps2_queue(&s->common, 0xf0);
161 }
162 if (s->scancode_set == 2) {
163 keycode = ps2_raw_keycode[keycode & 0x7f];
164 } else if (s->scancode_set == 3) {
165 keycode = ps2_raw_keycode_set3[keycode & 0x7f];
166 }
167 }
168 ps2_queue(&s->common, keycode);
169 }
170
171 uint32_t ps2_read_data(void *opaque)
172 {
173 PS2State *s = (PS2State *)opaque;
174 PS2Queue *q;
175 int val, index;
176
177 q = &s->queue;
178 if (q->count == 0) {
179 /* NOTE: if no data left, we return the last keyboard one
180 (needed for EMM386) */
181 /* XXX: need a timer to do things correctly */
182 index = q->rptr - 1;
183 if (index < 0)
184 index = PS2_QUEUE_SIZE - 1;
185 val = q->data[index];
186 } else {
187 val = q->data[q->rptr];
188 if (++q->rptr == PS2_QUEUE_SIZE)
189 q->rptr = 0;
190 q->count--;
191 /* reading deasserts IRQ */
192 s->update_irq(s->update_arg, 0);
193 /* reassert IRQs if data left */
194 s->update_irq(s->update_arg, q->count != 0);
195 }
196 return val;
197 }
198
199 static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
200 {
201 s->ledstate = ledstate;
202 kbd_put_ledstate(ledstate);
203 }
204
205 static void ps2_reset_keyboard(PS2KbdState *s)
206 {
207 s->scan_enabled = 1;
208 s->scancode_set = 2;
209 ps2_set_ledstate(s, 0);
210 }
211
212 void ps2_write_keyboard(void *opaque, int val)
213 {
214 PS2KbdState *s = (PS2KbdState *)opaque;
215
216 switch(s->common.write_cmd) {
217 default:
218 case -1:
219 switch(val) {
220 case 0x00:
221 ps2_queue(&s->common, KBD_REPLY_ACK);
222 break;
223 case 0x05:
224 ps2_queue(&s->common, KBD_REPLY_RESEND);
225 break;
226 case KBD_CMD_GET_ID:
227 ps2_queue(&s->common, KBD_REPLY_ACK);
228 /* We emulate a MF2 AT keyboard here */
229 ps2_queue(&s->common, KBD_REPLY_ID);
230 if (s->translate)
231 ps2_queue(&s->common, 0x41);
232 else
233 ps2_queue(&s->common, 0x83);
234 break;
235 case KBD_CMD_ECHO:
236 ps2_queue(&s->common, KBD_CMD_ECHO);
237 break;
238 case KBD_CMD_ENABLE:
239 s->scan_enabled = 1;
240 ps2_queue(&s->common, KBD_REPLY_ACK);
241 break;
242 case KBD_CMD_SCANCODE:
243 case KBD_CMD_SET_LEDS:
244 case KBD_CMD_SET_RATE:
245 s->common.write_cmd = val;
246 ps2_queue(&s->common, KBD_REPLY_ACK);
247 break;
248 case KBD_CMD_RESET_DISABLE:
249 ps2_reset_keyboard(s);
250 s->scan_enabled = 0;
251 ps2_queue(&s->common, KBD_REPLY_ACK);
252 break;
253 case KBD_CMD_RESET_ENABLE:
254 ps2_reset_keyboard(s);
255 s->scan_enabled = 1;
256 ps2_queue(&s->common, KBD_REPLY_ACK);
257 break;
258 case KBD_CMD_RESET:
259 ps2_reset_keyboard(s);
260 ps2_queue(&s->common, KBD_REPLY_ACK);
261 ps2_queue(&s->common, KBD_REPLY_POR);
262 break;
263 default:
264 ps2_queue(&s->common, KBD_REPLY_ACK);
265 break;
266 }
267 break;
268 case KBD_CMD_SCANCODE:
269 if (val == 0) {
270 if (s->scancode_set == 1)
271 ps2_put_keycode(s, 0x43);
272 else if (s->scancode_set == 2)
273 ps2_put_keycode(s, 0x41);
274 else if (s->scancode_set == 3)
275 ps2_put_keycode(s, 0x3f);
276 } else {
277 if (val >= 1 && val <= 3)
278 s->scancode_set = val;
279 ps2_queue(&s->common, KBD_REPLY_ACK);
280 }
281 s->common.write_cmd = -1;
282 break;
283 case KBD_CMD_SET_LEDS:
284 ps2_set_ledstate(s, val);
285 ps2_queue(&s->common, KBD_REPLY_ACK);
286 s->common.write_cmd = -1;
287 break;
288 case KBD_CMD_SET_RATE:
289 ps2_queue(&s->common, KBD_REPLY_ACK);
290 s->common.write_cmd = -1;
291 break;
292 }
293 }
294
295 /* Set the scancode translation mode.
296 0 = raw scancodes.
297 1 = translated scancodes (used by qemu internally). */
298
299 void ps2_keyboard_set_translation(void *opaque, int mode)
300 {
301 PS2KbdState *s = (PS2KbdState *)opaque;
302 s->translate = mode;
303 }
304
305 static void ps2_mouse_send_packet(PS2MouseState *s)
306 {
307 unsigned int b;
308 int dx1, dy1, dz1;
309
310 dx1 = s->mouse_dx;
311 dy1 = s->mouse_dy;
312 dz1 = s->mouse_dz;
313 /* XXX: increase range to 8 bits ? */
314 if (dx1 > 127)
315 dx1 = 127;
316 else if (dx1 < -127)
317 dx1 = -127;
318 if (dy1 > 127)
319 dy1 = 127;
320 else if (dy1 < -127)
321 dy1 = -127;
322 b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
323 ps2_queue(&s->common, b);
324 ps2_queue(&s->common, dx1 & 0xff);
325 ps2_queue(&s->common, dy1 & 0xff);
326 /* extra byte for IMPS/2 or IMEX */
327 switch(s->mouse_type) {
328 default:
329 break;
330 case 3:
331 if (dz1 > 127)
332 dz1 = 127;
333 else if (dz1 < -127)
334 dz1 = -127;
335 ps2_queue(&s->common, dz1 & 0xff);
336 break;
337 case 4:
338 if (dz1 > 7)
339 dz1 = 7;
340 else if (dz1 < -7)
341 dz1 = -7;
342 b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
343 ps2_queue(&s->common, b);
344 break;
345 }
346
347 /* update deltas */
348 s->mouse_dx -= dx1;
349 s->mouse_dy -= dy1;
350 s->mouse_dz -= dz1;
351 }
352
353 static void ps2_mouse_event(void *opaque,
354 int dx, int dy, int dz, int buttons_state)
355 {
356 PS2MouseState *s = opaque;
357
358 /* check if deltas are recorded when disabled */
359 if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
360 return;
361
362 s->mouse_dx += dx;
363 s->mouse_dy -= dy;
364 s->mouse_dz += dz;
365 /* XXX: SDL sometimes generates nul events: we delete them */
366 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
367 s->mouse_buttons == buttons_state)
368 return;
369 s->mouse_buttons = buttons_state;
370
371 if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
372 (s->common.queue.count < (PS2_QUEUE_SIZE - 16))) {
373 for(;;) {
374 /* if not remote, send event. Multiple events are sent if
375 too big deltas */
376 ps2_mouse_send_packet(s);
377 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
378 break;
379 }
380 }
381 }
382
383 void ps2_mouse_fake_event(void *opaque)
384 {
385 ps2_mouse_event(opaque, 1, 0, 0, 0);
386 }
387
388 void ps2_write_mouse(void *opaque, int val)
389 {
390 PS2MouseState *s = (PS2MouseState *)opaque;
391 #ifdef DEBUG_MOUSE
392 printf("kbd: write mouse 0x%02x\n", val);
393 #endif
394 switch(s->common.write_cmd) {
395 default:
396 case -1:
397 /* mouse command */
398 if (s->mouse_wrap) {
399 if (val == AUX_RESET_WRAP) {
400 s->mouse_wrap = 0;
401 ps2_queue(&s->common, AUX_ACK);
402 return;
403 } else if (val != AUX_RESET) {
404 ps2_queue(&s->common, val);
405 return;
406 }
407 }
408 switch(val) {
409 case AUX_SET_SCALE11:
410 s->mouse_status &= ~MOUSE_STATUS_SCALE21;
411 ps2_queue(&s->common, AUX_ACK);
412 break;
413 case AUX_SET_SCALE21:
414 s->mouse_status |= MOUSE_STATUS_SCALE21;
415 ps2_queue(&s->common, AUX_ACK);
416 break;
417 case AUX_SET_STREAM:
418 s->mouse_status &= ~MOUSE_STATUS_REMOTE;
419 ps2_queue(&s->common, AUX_ACK);
420 break;
421 case AUX_SET_WRAP:
422 s->mouse_wrap = 1;
423 ps2_queue(&s->common, AUX_ACK);
424 break;
425 case AUX_SET_REMOTE:
426 s->mouse_status |= MOUSE_STATUS_REMOTE;
427 ps2_queue(&s->common, AUX_ACK);
428 break;
429 case AUX_GET_TYPE:
430 ps2_queue(&s->common, AUX_ACK);
431 ps2_queue(&s->common, s->mouse_type);
432 break;
433 case AUX_SET_RES:
434 case AUX_SET_SAMPLE:
435 s->common.write_cmd = val;
436 ps2_queue(&s->common, AUX_ACK);
437 break;
438 case AUX_GET_SCALE:
439 ps2_queue(&s->common, AUX_ACK);
440 ps2_queue(&s->common, s->mouse_status);
441 ps2_queue(&s->common, s->mouse_resolution);
442 ps2_queue(&s->common, s->mouse_sample_rate);
443 break;
444 case AUX_POLL:
445 ps2_queue(&s->common, AUX_ACK);
446 ps2_mouse_send_packet(s);
447 break;
448 case AUX_ENABLE_DEV:
449 s->mouse_status |= MOUSE_STATUS_ENABLED;
450 ps2_queue(&s->common, AUX_ACK);
451 break;
452 case AUX_DISABLE_DEV:
453 s->mouse_status &= ~MOUSE_STATUS_ENABLED;
454 ps2_queue(&s->common, AUX_ACK);
455 break;
456 case AUX_SET_DEFAULT:
457 s->mouse_sample_rate = 100;
458 s->mouse_resolution = 2;
459 s->mouse_status = 0;
460 ps2_queue(&s->common, AUX_ACK);
461 break;
462 case AUX_RESET:
463 s->mouse_sample_rate = 100;
464 s->mouse_resolution = 2;
465 s->mouse_status = 0;
466 s->mouse_type = 0;
467 ps2_queue(&s->common, AUX_ACK);
468 ps2_queue(&s->common, 0xaa);
469 ps2_queue(&s->common, s->mouse_type);
470 break;
471 default:
472 break;
473 }
474 break;
475 case AUX_SET_SAMPLE:
476 s->mouse_sample_rate = val;
477 /* detect IMPS/2 or IMEX */
478 switch(s->mouse_detect_state) {
479 default:
480 case 0:
481 if (val == 200)
482 s->mouse_detect_state = 1;
483 break;
484 case 1:
485 if (val == 100)
486 s->mouse_detect_state = 2;
487 else if (val == 200)
488 s->mouse_detect_state = 3;
489 else
490 s->mouse_detect_state = 0;
491 break;
492 case 2:
493 if (val == 80)
494 s->mouse_type = 3; /* IMPS/2 */
495 s->mouse_detect_state = 0;
496 break;
497 case 3:
498 if (val == 80)
499 s->mouse_type = 4; /* IMEX */
500 s->mouse_detect_state = 0;
501 break;
502 }
503 ps2_queue(&s->common, AUX_ACK);
504 s->common.write_cmd = -1;
505 break;
506 case AUX_SET_RES:
507 s->mouse_resolution = val;
508 ps2_queue(&s->common, AUX_ACK);
509 s->common.write_cmd = -1;
510 break;
511 }
512 }
513
514 static void ps2_common_reset(PS2State *s)
515 {
516 PS2Queue *q;
517 s->write_cmd = -1;
518 q = &s->queue;
519 q->rptr = 0;
520 q->wptr = 0;
521 q->count = 0;
522 s->update_irq(s->update_arg, 0);
523 }
524
525 static void ps2_kbd_reset(void *opaque)
526 {
527 PS2KbdState *s = (PS2KbdState *) opaque;
528
529 ps2_common_reset(&s->common);
530 s->scan_enabled = 0;
531 s->translate = 0;
532 s->scancode_set = 0;
533 }
534
535 static void ps2_mouse_reset(void *opaque)
536 {
537 PS2MouseState *s = (PS2MouseState *) opaque;
538
539 ps2_common_reset(&s->common);
540 s->mouse_status = 0;
541 s->mouse_resolution = 0;
542 s->mouse_sample_rate = 0;
543 s->mouse_wrap = 0;
544 s->mouse_type = 0;
545 s->mouse_detect_state = 0;
546 s->mouse_dx = 0;
547 s->mouse_dy = 0;
548 s->mouse_dz = 0;
549 s->mouse_buttons = 0;
550 }
551
552 static const VMStateDescription vmstate_ps2_common = {
553 .name = "PS2 Common State",
554 .version_id = 3,
555 .minimum_version_id = 2,
556 .minimum_version_id_old = 2,
557 .fields = (VMStateField []) {
558 VMSTATE_INT32(write_cmd, PS2State),
559 VMSTATE_INT32(queue.rptr, PS2State),
560 VMSTATE_INT32(queue.wptr, PS2State),
561 VMSTATE_INT32(queue.count, PS2State),
562 VMSTATE_BUFFER(queue.data, PS2State),
563 VMSTATE_END_OF_LIST()
564 }
565 };
566
567 static bool ps2_keyboard_ledstate_needed(void *opaque)
568 {
569 PS2KbdState *s = opaque;
570
571 return s->ledstate != 0; /* 0 is default state */
572 }
573
574 static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
575 {
576 PS2KbdState *s = opaque;
577
578 kbd_put_ledstate(s->ledstate);
579 return 0;
580 }
581
582 static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
583 .name = "ps2kbd/ledstate",
584 .version_id = 3,
585 .minimum_version_id = 2,
586 .minimum_version_id_old = 2,
587 .post_load = ps2_kbd_ledstate_post_load,
588 .fields = (VMStateField []) {
589 VMSTATE_INT32(ledstate, PS2KbdState),
590 VMSTATE_END_OF_LIST()
591 }
592 };
593
594 static int ps2_kbd_post_load(void* opaque, int version_id)
595 {
596 PS2KbdState *s = (PS2KbdState*)opaque;
597
598 if (version_id == 2)
599 s->scancode_set=2;
600 return 0;
601 }
602
603 static const VMStateDescription vmstate_ps2_keyboard = {
604 .name = "ps2kbd",
605 .version_id = 3,
606 .minimum_version_id = 2,
607 .minimum_version_id_old = 2,
608 .post_load = ps2_kbd_post_load,
609 .fields = (VMStateField []) {
610 VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
611 VMSTATE_INT32(scan_enabled, PS2KbdState),
612 VMSTATE_INT32(translate, PS2KbdState),
613 VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
614 VMSTATE_END_OF_LIST()
615 },
616 .subsections = (VMStateSubsection []) {
617 {
618 .vmsd = &vmstate_ps2_keyboard_ledstate,
619 .needed = ps2_keyboard_ledstate_needed,
620 }, {
621 /* empty */
622 }
623 }
624 };
625
626 static const VMStateDescription vmstate_ps2_mouse = {
627 .name = "ps2mouse",
628 .version_id = 2,
629 .minimum_version_id = 2,
630 .minimum_version_id_old = 2,
631 .fields = (VMStateField []) {
632 VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
633 VMSTATE_UINT8(mouse_status, PS2MouseState),
634 VMSTATE_UINT8(mouse_resolution, PS2MouseState),
635 VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
636 VMSTATE_UINT8(mouse_wrap, PS2MouseState),
637 VMSTATE_UINT8(mouse_type, PS2MouseState),
638 VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
639 VMSTATE_INT32(mouse_dx, PS2MouseState),
640 VMSTATE_INT32(mouse_dy, PS2MouseState),
641 VMSTATE_INT32(mouse_dz, PS2MouseState),
642 VMSTATE_UINT8(mouse_buttons, PS2MouseState),
643 VMSTATE_END_OF_LIST()
644 }
645 };
646
647 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
648 {
649 PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));
650
651 s->common.update_irq = update_irq;
652 s->common.update_arg = update_arg;
653 s->scancode_set = 2;
654 vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
655 qemu_add_kbd_event_handler(ps2_put_keycode, s);
656 qemu_register_reset(ps2_kbd_reset, s);
657 return s;
658 }
659
660 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
661 {
662 PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));
663
664 s->common.update_irq = update_irq;
665 s->common.update_arg = update_arg;
666 vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
667 qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse");
668 qemu_register_reset(ps2_mouse_reset, s);
669 return s;
670 }