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