]> Git Repo - qemu.git/blame - hw/input/ps2.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
hw: Fix qemu_allocate_irqs() leaks
[qemu.git] / hw / input / ps2.c
CommitLineData
0e43e99c
FB		 1/*
2 * QEMU PS/2 keyboard/mouse emulation
5fafdf24 3 *
0e43e99c 4 * Copyright (c) 2003 Fabrice Bellard
5fafdf24 5 *
0e43e99c
FB		 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 */
83c9f4ca 24#include "hw/hw.h"
0d09e41a 25#include "hw/input/ps2.h"
28ecbaee 26#include "ui/console.h"
66e6536e 27#include "ui/input.h"
9c17d615 28#include "sysemu/sysemu.h"
0e43e99c
FB		 29
30/* debug PC keyboard */
31//#define DEBUG_KBD
32
33/* debug PC keyboard : only mouse */
34//#define DEBUG_MOUSE
35
36/* Keyboard Commands */
37#define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
38#define KBD_CMD_ECHO 0xEE
e7d93956 39#define KBD_CMD_SCANCODE 0xF0 /* Get/set scancode set */
0e43e99c
FB		 40#define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
41#define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
42#define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
43#define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
44#define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
45#define KBD_CMD_RESET 0xFF /* Reset */
46
47/* Keyboard Replies */
48#define KBD_REPLY_POR 0xAA /* Power on reset */
35c4d671 49#define KBD_REPLY_ID 0xAB /* Keyboard ID */
0e43e99c
FB		 50#define KBD_REPLY_ACK 0xFA /* Command ACK */
51#define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
52
53/* Mouse Commands */
54#define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
55#define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
56#define AUX_SET_RES 0xE8 /* Set resolution */
57#define AUX_GET_SCALE 0xE9 /* Get scaling factor */
58#define AUX_SET_STREAM 0xEA /* Set stream mode */
59#define AUX_POLL 0xEB /* Poll */
60#define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
61#define AUX_SET_WRAP 0xEE /* Set wrap mode */
62#define AUX_SET_REMOTE 0xF0 /* Set remote mode */
63#define AUX_GET_TYPE 0xF2 /* Get type */
64#define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
65#define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
66#define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
67#define AUX_SET_DEFAULT 0xF6
68#define AUX_RESET 0xFF /* Reset aux device */
69#define AUX_ACK 0xFA /* Command byte ACK. */
70
71#define MOUSE_STATUS_REMOTE 0x40
72#define MOUSE_STATUS_ENABLED 0x20
73#define MOUSE_STATUS_SCALE21 0x10
74
2858ab09 75#define PS2_QUEUE_SIZE 16 /* Buffer size required by PS/2 protocol */
0e43e99c
FB		 76
77typedef struct {
2858ab09
GA		 78 /* Keep the data array 256 bytes long, which compatibility
79 with older qemu versions. */
80 uint8_t data[256];
0e43e99c
FB		 81 int rptr, wptr, count;
82} PS2Queue;
83
84typedef struct {
85 PS2Queue queue;
86 int32_t write_cmd;
87 void (*update_irq)(void *, int);
88 void *update_arg;
89} PS2State;
90
91typedef struct {
92 PS2State common;
93 int scan_enabled;
5cbdb3a3 94 /* QEMU uses translated PC scancodes internally. To avoid multiple
f94f5d71
PB		 95 conversions we do the translation (if any) in the PS/2 emulation
96 not the keyboard controller. */
97 int translate;
e7d93956 98 int scancode_set; /* 1=XT, 2=AT, 3=PS/2 */
7f540ab5 99 int ledstate;
0e43e99c
FB		 100} PS2KbdState;
101
102typedef struct {
103 PS2State common;
104 uint8_t mouse_status;
105 uint8_t mouse_resolution;
106 uint8_t mouse_sample_rate;
107 uint8_t mouse_wrap;
108 uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
109 uint8_t mouse_detect_state;
110 int mouse_dx; /* current values, needed for 'poll' mode */
111 int mouse_dy;
112 int mouse_dz;
113 uint8_t mouse_buttons;
114} PS2MouseState;
115
f94f5d71
PB		 116/* Table to convert from PC scancodes to raw scancodes. */
117static const unsigned char ps2_raw_keycode[128] = {
7096a96d
RT		 118 0, 118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
119 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
120 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
121 50, 49, 58, 65, 73, 74, 89, 124, 17, 41, 88, 5, 6, 4, 12, 3,
122 11, 2, 10, 1, 9, 119, 126, 108, 117, 125, 123, 107, 115, 116, 121, 105,
123114, 122, 112, 113, 127, 96, 97, 120, 7, 15, 23, 31, 39, 47, 55, 63,
124 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
125 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
126};
127static const unsigned char ps2_raw_keycode_set3[128] = {
128 0, 8, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85, 102, 13,
129 21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 17, 28, 27,
130 35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 92, 26, 34, 33, 42,
131 50, 49, 58, 65, 73, 74, 89, 126, 25, 41, 20, 7, 15, 23, 31, 39,
132 47, 2, 63, 71, 79, 118, 95, 108, 117, 125, 132, 107, 115, 116, 124, 105,
133114, 122, 112, 113, 127, 96, 97, 86, 94, 15, 23, 31, 39, 47, 55, 63,
134 71, 79, 86, 94, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87, 111,
135 19, 25, 57, 81, 83, 92, 95, 98, 99, 100, 101, 103, 104, 106, 109, 110
f94f5d71
PB		 136};
137
0e43e99c
FB		 138void ps2_queue(void *opaque, int b)
139{
140 PS2State *s = (PS2State *)opaque;
141 PS2Queue *q = &s->queue;
142
2858ab09 143 if (q->count >= PS2_QUEUE_SIZE - 1)
0e43e99c
FB		 144 return;
145 q->data[q->wptr] = b;
146 if (++q->wptr == PS2_QUEUE_SIZE)
147 q->wptr = 0;
148 q->count++;
149 s->update_irq(s->update_arg, 1);
150}
151
35c4d671
AJ		 152/*
153 keycode is expressed as follow:
154 bit 7 - 0 key pressed, 1 = key released
155 bits 6-0 - translated scancode set 2
156 */
0e43e99c
FB		 157static void ps2_put_keycode(void *opaque, int keycode)
158{
f94f5d71 159 PS2KbdState *s = opaque;
e7d93956 160
fd214d18 161 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
7096a96d
RT		 162 /* XXX: add support for scancode set 1 */
163 if (!s->translate && keycode < 0xe0 && s->scancode_set > 1) {
164 if (keycode & 0x80) {
f94f5d71 165 ps2_queue(&s->common, 0xf0);
7096a96d
RT		 166 }
167 if (s->scancode_set == 2) {
168 keycode = ps2_raw_keycode[keycode & 0x7f];
169 } else if (s->scancode_set == 3) {
170 keycode = ps2_raw_keycode_set3[keycode & 0x7f];
171 }
f94f5d71 172 }
0e43e99c
FB		 173 ps2_queue(&s->common, keycode);
174}
175
66e6536e
GH		 176static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
177 InputEvent *evt)
178{
179 PS2KbdState *s = (PS2KbdState *)dev;
180 int scancodes[3], i, count;
181
182 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
183 count = qemu_input_key_value_to_scancode(evt->key->key,
184 evt->key->down,
185 scancodes);
186 for (i = 0; i < count; i++) {
187 ps2_put_keycode(s, scancodes[i]);
188 }
189}
190
0e43e99c
FB		 191uint32_t ps2_read_data(void *opaque)
192{
193 PS2State *s = (PS2State *)opaque;
194 PS2Queue *q;
195 int val, index;
3b46e624 196
0e43e99c
FB		 197 q = &s->queue;
198 if (q->count == 0) {
199 /* NOTE: if no data left, we return the last keyboard one
200 (needed for EMM386) */
201 /* XXX: need a timer to do things correctly */
202 index = q->rptr - 1;
203 if (index < 0)
204 index = PS2_QUEUE_SIZE - 1;
205 val = q->data[index];
206 } else {
207 val = q->data[q->rptr];
208 if (++q->rptr == PS2_QUEUE_SIZE)
209 q->rptr = 0;
210 q->count--;
211 /* reading deasserts IRQ */
212 s->update_irq(s->update_arg, 0);
213 /* reassert IRQs if data left */
214 s->update_irq(s->update_arg, q->count != 0);
215 }
216 return val;
217}
218
7f540ab5
CF		 219static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
220{
221 s->ledstate = ledstate;
222 kbd_put_ledstate(ledstate);
223}
224
0e43e99c
FB		 225static void ps2_reset_keyboard(PS2KbdState *s)
226{
227 s->scan_enabled = 1;
e7d93956 228 s->scancode_set = 2;
7f540ab5 229 ps2_set_ledstate(s, 0);
0e43e99c
FB		 230}
231
232void ps2_write_keyboard(void *opaque, int val)
233{
234 PS2KbdState *s = (PS2KbdState *)opaque;
235
236 switch(s->common.write_cmd) {
237 default:
238 case -1:
239 switch(val) {
240 case 0x00:
241 ps2_queue(&s->common, KBD_REPLY_ACK);
242 break;
243 case 0x05:
244 ps2_queue(&s->common, KBD_REPLY_RESEND);
245 break;
246 case KBD_CMD_GET_ID:
247 ps2_queue(&s->common, KBD_REPLY_ACK);
e7d93956 248 /* We emulate a MF2 AT keyboard here */
35c4d671
AJ		 249 ps2_queue(&s->common, KBD_REPLY_ID);
250 if (s->translate)
251 ps2_queue(&s->common, 0x41);
252 else
253 ps2_queue(&s->common, 0x83);
0e43e99c
FB		 254 break;
255 case KBD_CMD_ECHO:
256 ps2_queue(&s->common, KBD_CMD_ECHO);
257 break;
258 case KBD_CMD_ENABLE:
259 s->scan_enabled = 1;
260 ps2_queue(&s->common, KBD_REPLY_ACK);
261 break;
e7d93956 262 case KBD_CMD_SCANCODE:
0e43e99c
FB		 263 case KBD_CMD_SET_LEDS:
264 case KBD_CMD_SET_RATE:
265 s->common.write_cmd = val;
266 ps2_queue(&s->common, KBD_REPLY_ACK);
267 break;
268 case KBD_CMD_RESET_DISABLE:
269 ps2_reset_keyboard(s);
270 s->scan_enabled = 0;
271 ps2_queue(&s->common, KBD_REPLY_ACK);
272 break;
273 case KBD_CMD_RESET_ENABLE:
274 ps2_reset_keyboard(s);
275 s->scan_enabled = 1;
276 ps2_queue(&s->common, KBD_REPLY_ACK);
277 break;
278 case KBD_CMD_RESET:
279 ps2_reset_keyboard(s);
280 ps2_queue(&s->common, KBD_REPLY_ACK);
281 ps2_queue(&s->common, KBD_REPLY_POR);
282 break;
283 default:
284 ps2_queue(&s->common, KBD_REPLY_ACK);
285 break;
286 }
287 break;
e7d93956
AJ		 288 case KBD_CMD_SCANCODE:
289 if (val == 0) {
290 if (s->scancode_set == 1)
291 ps2_put_keycode(s, 0x43);
292 else if (s->scancode_set == 2)
293 ps2_put_keycode(s, 0x41);
294 else if (s->scancode_set == 3)
295 ps2_put_keycode(s, 0x3f);
296 } else {
297 if (val >= 1 && val <= 3)
298 s->scancode_set = val;
299 ps2_queue(&s->common, KBD_REPLY_ACK);
300 }
301 s->common.write_cmd = -1;
302 break;
0e43e99c 303 case KBD_CMD_SET_LEDS:
7f540ab5 304 ps2_set_ledstate(s, val);
0e43e99c
FB		 305 ps2_queue(&s->common, KBD_REPLY_ACK);
306 s->common.write_cmd = -1;
307 break;
308 case KBD_CMD_SET_RATE:
309 ps2_queue(&s->common, KBD_REPLY_ACK);
310 s->common.write_cmd = -1;
311 break;
312 }
313}
314
f94f5d71
PB		 315/* Set the scancode translation mode.
316 0 = raw scancodes.
317 1 = translated scancodes (used by qemu internally). */
318
319void ps2_keyboard_set_translation(void *opaque, int mode)
320{
321 PS2KbdState *s = (PS2KbdState *)opaque;
322 s->translate = mode;
323}
324
0e43e99c
FB		 325static void ps2_mouse_send_packet(PS2MouseState *s)
326{
327 unsigned int b;
328 int dx1, dy1, dz1;
329
330 dx1 = s->mouse_dx;
331 dy1 = s->mouse_dy;
332 dz1 = s->mouse_dz;
333 /* XXX: increase range to 8 bits ? */
334 if (dx1 > 127)
335 dx1 = 127;
336 else if (dx1 < -127)
337 dx1 = -127;
338 if (dy1 > 127)
339 dy1 = 127;
340 else if (dy1 < -127)
341 dy1 = -127;
342 b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
343 ps2_queue(&s->common, b);
344 ps2_queue(&s->common, dx1 & 0xff);
345 ps2_queue(&s->common, dy1 & 0xff);
346 /* extra byte for IMPS/2 or IMEX */
347 switch(s->mouse_type) {
348 default:
349 break;
350 case 3:
351 if (dz1 > 127)
352 dz1 = 127;
353 else if (dz1 < -127)
354 dz1 = -127;
355 ps2_queue(&s->common, dz1 & 0xff);
356 break;
357 case 4:
358 if (dz1 > 7)
359 dz1 = 7;
360 else if (dz1 < -7)
361 dz1 = -7;
362 b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
363 ps2_queue(&s->common, b);
364 break;
365 }
366
367 /* update deltas */
368 s->mouse_dx -= dx1;
369 s->mouse_dy -= dy1;
370 s->mouse_dz -= dz1;
371}
372
2a766d29
GH		 373static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
374 InputEvent *evt)
0e43e99c 375{
2a766d29
GH		 376 static const int bmap[INPUT_BUTTON_MAX] = {
377 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
378 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
379 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
380 };
381 PS2MouseState *s = (PS2MouseState *)dev;
0e43e99c
FB		 382
383 /* check if deltas are recorded when disabled */
384 if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
385 return;
386
2a766d29
GH		 387 switch (evt->kind) {
388 case INPUT_EVENT_KIND_REL:
389 if (evt->rel->axis == INPUT_AXIS_X) {
390 s->mouse_dx += evt->rel->value;
391 } else if (evt->rel->axis == INPUT_AXIS_Y) {
392 s->mouse_dy -= evt->rel->value;
393 }
394 break;
3b46e624 395
2a766d29
GH		 396 case INPUT_EVENT_KIND_BTN:
397 if (evt->btn->down) {
398 s->mouse_buttons |= bmap[evt->btn->button];
399 if (evt->btn->button == INPUT_BUTTON_WHEEL_UP) {
400 s->mouse_dz--;
401 } else if (evt->btn->button == INPUT_BUTTON_WHEEL_DOWN) {
402 s->mouse_dz++;
403 }
404 } else {
405 s->mouse_buttons &= ~bmap[evt->btn->button];
406 }
407 break;
408
409 default:
410 /* keep gcc happy */
411 break;
fd214d18 412 }
2a766d29 413}
fd214d18 414
2a766d29
GH		 415static void ps2_mouse_sync(DeviceState *dev)
416{
417 PS2MouseState *s = (PS2MouseState *)dev;
418
419 if (s->mouse_buttons) {
420 qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
421 }
2858ab09
GA		 422 if (!(s->mouse_status & MOUSE_STATUS_REMOTE)) {
423 while (s->common.queue.count < PS2_QUEUE_SIZE - 4) {
0e43e99c
FB		 424 /* if not remote, send event. Multiple events are sent if
425 too big deltas */
426 ps2_mouse_send_packet(s);
427 if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
428 break;
429 }
430 }
431}
432
548df2ac
TS		 433void ps2_mouse_fake_event(void *opaque)
434{
2a766d29
GH		 435 PS2MouseState *s = opaque;
436 s->mouse_dx++;
437 ps2_mouse_sync(opaque);
548df2ac
TS		 438}
439
0e43e99c
FB		 440void ps2_write_mouse(void *opaque, int val)
441{
442 PS2MouseState *s = (PS2MouseState *)opaque;
443#ifdef DEBUG_MOUSE
444 printf("kbd: write mouse 0x%02x\n", val);
445#endif
446 switch(s->common.write_cmd) {
447 default:
448 case -1:
449 /* mouse command */
450 if (s->mouse_wrap) {
451 if (val == AUX_RESET_WRAP) {
452 s->mouse_wrap = 0;
453 ps2_queue(&s->common, AUX_ACK);
454 return;
455 } else if (val != AUX_RESET) {
456 ps2_queue(&s->common, val);
457 return;
458 }
459 }
460 switch(val) {
461 case AUX_SET_SCALE11:
462 s->mouse_status &= ~MOUSE_STATUS_SCALE21;
463 ps2_queue(&s->common, AUX_ACK);
464 break;
465 case AUX_SET_SCALE21:
466 s->mouse_status |= MOUSE_STATUS_SCALE21;
467 ps2_queue(&s->common, AUX_ACK);
468 break;
469 case AUX_SET_STREAM:
470 s->mouse_status &= ~MOUSE_STATUS_REMOTE;
471 ps2_queue(&s->common, AUX_ACK);
472 break;
473 case AUX_SET_WRAP:
474 s->mouse_wrap = 1;
475 ps2_queue(&s->common, AUX_ACK);
476 break;
477 case AUX_SET_REMOTE:
478 s->mouse_status |= MOUSE_STATUS_REMOTE;
479 ps2_queue(&s->common, AUX_ACK);
480 break;
481 case AUX_GET_TYPE:
482 ps2_queue(&s->common, AUX_ACK);
483 ps2_queue(&s->common, s->mouse_type);
484 break;
485 case AUX_SET_RES:
486 case AUX_SET_SAMPLE:
487 s->common.write_cmd = val;
488 ps2_queue(&s->common, AUX_ACK);
489 break;
490 case AUX_GET_SCALE:
491 ps2_queue(&s->common, AUX_ACK);
492 ps2_queue(&s->common, s->mouse_status);
493 ps2_queue(&s->common, s->mouse_resolution);
494 ps2_queue(&s->common, s->mouse_sample_rate);
495 break;
496 case AUX_POLL:
497 ps2_queue(&s->common, AUX_ACK);
498 ps2_mouse_send_packet(s);
499 break;
500 case AUX_ENABLE_DEV:
501 s->mouse_status |= MOUSE_STATUS_ENABLED;
502 ps2_queue(&s->common, AUX_ACK);
503 break;
504 case AUX_DISABLE_DEV:
505 s->mouse_status &= ~MOUSE_STATUS_ENABLED;
506 ps2_queue(&s->common, AUX_ACK);
507 break;
508 case AUX_SET_DEFAULT:
509 s->mouse_sample_rate = 100;
510 s->mouse_resolution = 2;
511 s->mouse_status = 0;
512 ps2_queue(&s->common, AUX_ACK);
513 break;
514 case AUX_RESET:
515 s->mouse_sample_rate = 100;
516 s->mouse_resolution = 2;
517 s->mouse_status = 0;
518 s->mouse_type = 0;
519 ps2_queue(&s->common, AUX_ACK);
520 ps2_queue(&s->common, 0xaa);
521 ps2_queue(&s->common, s->mouse_type);
522 break;
523 default:
524 break;
525 }
526 break;
527 case AUX_SET_SAMPLE:
528 s->mouse_sample_rate = val;
529 /* detect IMPS/2 or IMEX */
530 switch(s->mouse_detect_state) {
531 default:
532 case 0:
533 if (val == 200)
534 s->mouse_detect_state = 1;
535 break;
536 case 1:
537 if (val == 100)
538 s->mouse_detect_state = 2;
539 else if (val == 200)
540 s->mouse_detect_state = 3;
541 else
542 s->mouse_detect_state = 0;
543 break;
544 case 2:
5fafdf24 545 if (val == 80)
0e43e99c
FB		 546 s->mouse_type = 3; /* IMPS/2 */
547 s->mouse_detect_state = 0;
548 break;
549 case 3:
5fafdf24 550 if (val == 80)
0e43e99c
FB		 551 s->mouse_type = 4; /* IMEX */
552 s->mouse_detect_state = 0;
553 break;
554 }
555 ps2_queue(&s->common, AUX_ACK);
556 s->common.write_cmd = -1;
557 break;
558 case AUX_SET_RES:
559 s->mouse_resolution = val;
560 ps2_queue(&s->common, AUX_ACK);
561 s->common.write_cmd = -1;
562 break;
563 }
564}
565
ef74679a 566static void ps2_common_reset(PS2State *s)
0e43e99c 567{
0e43e99c
FB		 568 PS2Queue *q;
569 s->write_cmd = -1;
570 q = &s->queue;
571 q->rptr = 0;
572 q->wptr = 0;
573 q->count = 0;
deeccef3 574 s->update_irq(s->update_arg, 0);
0e43e99c
FB		 575}
576
2858ab09
GA		 577static void ps2_common_post_load(PS2State *s)
578{
579 PS2Queue *q = &s->queue;
580 int size;
581 int i;
582 int tmp_data[PS2_QUEUE_SIZE];
583
584 /* set the useful data buffer queue size, < PS2_QUEUE_SIZE */
585 size = q->count > PS2_QUEUE_SIZE ? 0 : q->count;
586
587 /* move the queue elements to the start of data array */
588 if (size > 0) {
589 for (i = 0; i < size; i++) {
590 /* move the queue elements to the temporary buffer */
591 tmp_data[i] = q->data[q->rptr];
592 if (++q->rptr == 256) {
593 q->rptr = 0;
594 }
595 }
596 memcpy(q->data, tmp_data, size);
597 }
598 /* reset rptr/wptr/count */
599 q->rptr = 0;
600 q->wptr = size;
601 q->count = size;
602 s->update_irq(s->update_arg, q->count != 0);
603}
604
ef74679a
DS		 605static void ps2_kbd_reset(void *opaque)
606{
607 PS2KbdState *s = (PS2KbdState *) opaque;
608
609 ps2_common_reset(&s->common);
610 s->scan_enabled = 0;
611 s->translate = 0;
612 s->scancode_set = 0;
613}
614
615static void ps2_mouse_reset(void *opaque)
616{
617 PS2MouseState *s = (PS2MouseState *) opaque;
618
619 ps2_common_reset(&s->common);
620 s->mouse_status = 0;
621 s->mouse_resolution = 0;
622 s->mouse_sample_rate = 0;
623 s->mouse_wrap = 0;
624 s->mouse_type = 0;
625 s->mouse_detect_state = 0;
626 s->mouse_dx = 0;
627 s->mouse_dy = 0;
628 s->mouse_dz = 0;
629 s->mouse_buttons = 0;
630}
631
b31442c3
JQ		 632static const VMStateDescription vmstate_ps2_common = {
633 .name = "PS2 Common State",
634 .version_id = 3,
635 .minimum_version_id = 2,
d49805ae 636 .fields = (VMStateField[]) {
b31442c3
JQ		 637 VMSTATE_INT32(write_cmd, PS2State),
638 VMSTATE_INT32(queue.rptr, PS2State),
639 VMSTATE_INT32(queue.wptr, PS2State),
640 VMSTATE_INT32(queue.count, PS2State),
641 VMSTATE_BUFFER(queue.data, PS2State),
642 VMSTATE_END_OF_LIST()
643 }
644};
0e43e99c 645
7f540ab5
CF		 646static bool ps2_keyboard_ledstate_needed(void *opaque)
647{
648 PS2KbdState *s = opaque;
649
650 return s->ledstate != 0; /* 0 is default state */
651}
652
653static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
654{
655 PS2KbdState *s = opaque;
656
657 kbd_put_ledstate(s->ledstate);
658 return 0;
659}
660
661static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
662 .name = "ps2kbd/ledstate",
663 .version_id = 3,
664 .minimum_version_id = 2,
7f540ab5 665 .post_load = ps2_kbd_ledstate_post_load,
d49805ae 666 .fields = (VMStateField[]) {
7f540ab5
CF		 667 VMSTATE_INT32(ledstate, PS2KbdState),
668 VMSTATE_END_OF_LIST()
669 }
670};
671
db596c53 672static int ps2_kbd_post_load(void* opaque, int version_id)
0e43e99c
FB		 673{
674 PS2KbdState *s = (PS2KbdState*)opaque;
2858ab09 675 PS2State *ps2 = &s->common;
7783e9f0 676
db596c53 677 if (version_id == 2)
e7d93956 678 s->scancode_set=2;
2858ab09
GA		 679
680 ps2_common_post_load(ps2);
681
0e43e99c
FB		 682 return 0;
683}
684
2858ab09
GA		 685static void ps2_kbd_pre_save(void *opaque)
686{
687 PS2KbdState *s = (PS2KbdState *)opaque;
688 PS2State *ps2 = &s->common;
689
690 ps2_common_post_load(ps2);
691}
692
b31442c3
JQ		 693static const VMStateDescription vmstate_ps2_keyboard = {
694 .name = "ps2kbd",
695 .version_id = 3,
db596c53 696 .minimum_version_id = 2,
db596c53 697 .post_load = ps2_kbd_post_load,
2858ab09 698 .pre_save = ps2_kbd_pre_save,
d49805ae 699 .fields = (VMStateField[]) {
b31442c3
JQ		 700 VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
701 VMSTATE_INT32(scan_enabled, PS2KbdState),
702 VMSTATE_INT32(translate, PS2KbdState),
703 VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
704 VMSTATE_END_OF_LIST()
7f540ab5
CF		 705 },
706 .subsections = (VMStateSubsection []) {
707 {
708 .vmsd = &vmstate_ps2_keyboard_ledstate,
709 .needed = ps2_keyboard_ledstate_needed,
710 }, {
711 /* empty */
712 }
b31442c3
JQ		 713 }
714};
7783e9f0 715
2858ab09
GA		 716static int ps2_mouse_post_load(void *opaque, int version_id)
717{
718 PS2MouseState *s = (PS2MouseState *)opaque;
719 PS2State *ps2 = &s->common;
720
721 ps2_common_post_load(ps2);
722
723 return 0;
724}
725
726static void ps2_mouse_pre_save(void *opaque)
727{
728 PS2MouseState *s = (PS2MouseState *)opaque;
729 PS2State *ps2 = &s->common;
730
731 ps2_common_post_load(ps2);
732}
733
b31442c3
JQ		 734static const VMStateDescription vmstate_ps2_mouse = {
735 .name = "ps2mouse",
736 .version_id = 2,
737 .minimum_version_id = 2,
2858ab09
GA		 738 .post_load = ps2_mouse_post_load,
739 .pre_save = ps2_mouse_pre_save,
d49805ae 740 .fields = (VMStateField[]) {
b31442c3
JQ		 741 VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
742 VMSTATE_UINT8(mouse_status, PS2MouseState),
743 VMSTATE_UINT8(mouse_resolution, PS2MouseState),
744 VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
745 VMSTATE_UINT8(mouse_wrap, PS2MouseState),
746 VMSTATE_UINT8(mouse_type, PS2MouseState),
747 VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
748 VMSTATE_INT32(mouse_dx, PS2MouseState),
749 VMSTATE_INT32(mouse_dy, PS2MouseState),
750 VMSTATE_INT32(mouse_dz, PS2MouseState),
751 VMSTATE_UINT8(mouse_buttons, PS2MouseState),
752 VMSTATE_END_OF_LIST()
753 }
754};
0e43e99c 755
66e6536e
GH		 756static QemuInputHandler ps2_keyboard_handler = {
757 .name = "QEMU PS/2 Keyboard",
758 .mask = INPUT_EVENT_MASK_KEY,
759 .event = ps2_keyboard_event,
760};
761
0e43e99c
FB		 762void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
763{
7267c094 764 PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));
0e43e99c
FB		 765
766 s->common.update_irq = update_irq;
767 s->common.update_arg = update_arg;
e7d93956 768 s->scancode_set = 2;
0be71e32 769 vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
66e6536e
GH		 770 qemu_input_handler_register((DeviceState *)s,
771 &ps2_keyboard_handler);
ef74679a 772 qemu_register_reset(ps2_kbd_reset, s);
0e43e99c
FB		 773 return s;
774}
775
2a766d29
GH		 776static QemuInputHandler ps2_mouse_handler = {
777 .name = "QEMU PS/2 Mouse",
778 .mask = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
779 .event = ps2_mouse_event,
780 .sync = ps2_mouse_sync,
781};
782
0e43e99c
FB		 783void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
784{
7267c094 785 PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));
0e43e99c
FB		 786
787 s->common.update_irq = update_irq;
788 s->common.update_arg = update_arg;
0be71e32 789 vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
2a766d29
GH		 790 qemu_input_handler_register((DeviceState *)s,
791 &ps2_mouse_handler);
ef74679a 792 qemu_register_reset(ps2_mouse_reset, s);
0e43e99c
FB		 793 return s;
794}
Empty description
This page took 0.865857 seconds and 4 git commands to generate.