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