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