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     ps2_queue_noirq(s, b);
 216     s->update_irq(s->update_arg, 1);
 217 }
 218
 219 void ps2_queue_2(PS2State *s, int b1, int b2)
 220 {
 221     if (PS2_QUEUE_SIZE - s->queue.count < 2) {
 222         return;
 223     }
 224
 225     ps2_queue_noirq(s, b1);
 226     ps2_queue_noirq(s, b2);
 227     s->update_irq(s->update_arg, 1);
 228 }
 229
 230 void ps2_queue_3(PS2State *s, int b1, int b2, int b3)
 231 {
 232     if (PS2_QUEUE_SIZE - s->queue.count < 3) {
 233         return;
 234     }
 235
 236     ps2_queue_noirq(s, b1);
 237     ps2_queue_noirq(s, b2);
 238     ps2_queue_noirq(s, b3);
 239     s->update_irq(s->update_arg, 1);
 240 }
 241
 242 void ps2_queue_4(PS2State *s, int b1, int b2, int b3, int b4)
 243 {
 244     if (PS2_QUEUE_SIZE - s->queue.count < 4) {
 245         return;
 246     }
 247
 248     ps2_queue_noirq(s, b1);
 249     ps2_queue_noirq(s, b2);
 250     ps2_queue_noirq(s, b3);
 251     ps2_queue_noirq(s, b4);
 252     s->update_irq(s->update_arg, 1);
 253 }
 254
 255 /* keycode is the untranslated scancode in the current scancode set. */
 256 static void ps2_put_keycode(void *opaque, int keycode)
 257 {
 258     PS2KbdState *s = opaque;
 259
 260     trace_ps2_put_keycode(opaque, keycode);
 261     qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
 262
 263     if (s->translate) {
 264         if (keycode == 0xf0) {
 265             s->need_high_bit = true;
 266         } else if (s->need_high_bit) {
 267             ps2_queue(&s->common, translate_table[keycode] | 0x80);
 268             s->need_high_bit = false;
 269         } else {
 270             ps2_queue(&s->common, translate_table[keycode]);
 271         }
 272     } else {
 273         ps2_queue(&s->common, keycode);
 274     }
 275 }
 276
 277 static void ps2_keyboard_event(DeviceState *dev, QemuConsole *src,
 278                                InputEvent *evt)
 279 {
 280     PS2KbdState *s = (PS2KbdState *)dev;
 281     InputKeyEvent *key = evt->u.key.data;
 282     int qcode;
 283     uint16_t keycode = 0;
 284     int mod;
 285
 286     /* do not process events while disabled to prevent stream corruption */
 287     if (!s->scan_enabled) {
 288         return;
 289     }
 290
 291     qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
 292     assert(evt->type == INPUT_EVENT_KIND_KEY);
 293     qcode = qemu_input_key_value_to_qcode(key->key);
 294
 295     mod = ps2_modifier_bit(qcode);
 296     trace_ps2_keyboard_event(s, qcode, key->down, mod, s->modifiers);
 297     if (key->down) {
 298         s->modifiers |= mod;
 299     } else {
 300         s->modifiers &= ~mod;
 301     }
 302
 303     if (s->scancode_set == 1) {
 304         if (qcode == Q_KEY_CODE_PAUSE) {
 305             if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
 306                 if (key->down) {
 307                     ps2_put_keycode(s, 0xe0);
 308                     ps2_put_keycode(s, 0x46);
 309                     ps2_put_keycode(s, 0xe0);
 310                     ps2_put_keycode(s, 0xc6);
 311                 }
 312             } else {
 313                 if (key->down) {
 314                     ps2_put_keycode(s, 0xe1);
 315                     ps2_put_keycode(s, 0x1d);
 316                     ps2_put_keycode(s, 0x45);
 317                     ps2_put_keycode(s, 0xe1);
 318                     ps2_put_keycode(s, 0x9d);
 319                     ps2_put_keycode(s, 0xc5);
 320                 }
 321             }
 322         } else if (qcode == Q_KEY_CODE_PRINT) {
 323             if (s->modifiers & MOD_ALT_L) {
 324                 if (key->down) {
 325                     ps2_put_keycode(s, 0xb8);
 326                     ps2_put_keycode(s, 0x38);
 327                     ps2_put_keycode(s, 0x54);
 328                 } else {
 329                     ps2_put_keycode(s, 0xd4);
 330                     ps2_put_keycode(s, 0xb8);
 331                     ps2_put_keycode(s, 0x38);
 332                 }
 333             } else if (s->modifiers & MOD_ALT_R) {
 334                 if (key->down) {
 335                     ps2_put_keycode(s, 0xe0);
 336                     ps2_put_keycode(s, 0xb8);
 337                     ps2_put_keycode(s, 0xe0);
 338                     ps2_put_keycode(s, 0x38);
 339                     ps2_put_keycode(s, 0x54);
 340                 } else {
 341                     ps2_put_keycode(s, 0xd4);
 342                     ps2_put_keycode(s, 0xe0);
 343                     ps2_put_keycode(s, 0xb8);
 344                     ps2_put_keycode(s, 0xe0);
 345                     ps2_put_keycode(s, 0x38);
 346                 }
 347             } else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
 348                                        MOD_SHIFT_R | MOD_CTRL_R)) {
 349                 if (key->down) {
 350                     ps2_put_keycode(s, 0xe0);
 351                     ps2_put_keycode(s, 0x37);
 352                 } else {
 353                     ps2_put_keycode(s, 0xe0);
 354                     ps2_put_keycode(s, 0xb7);
 355                 }
 356             } else {
 357                 if (key->down) {
 358                     ps2_put_keycode(s, 0xe0);
 359                     ps2_put_keycode(s, 0x2a);
 360                     ps2_put_keycode(s, 0xe0);
 361                     ps2_put_keycode(s, 0x37);
 362                 } else {
 363                     ps2_put_keycode(s, 0xe0);
 364                     ps2_put_keycode(s, 0xb7);
 365                     ps2_put_keycode(s, 0xe0);
 366                     ps2_put_keycode(s, 0xaa);
 367                 }
 368             }
 369         } else {
 370             if (qcode < qemu_input_map_qcode_to_atset1_len)
 371                 keycode = qemu_input_map_qcode_to_atset1[qcode];
 372             if (keycode) {
 373                 if (keycode & 0xff00) {
 374                     ps2_put_keycode(s, keycode >> 8);
 375                 }
 376                 if (!key->down) {
 377                     keycode |= 0x80;
 378                 }
 379                 ps2_put_keycode(s, keycode & 0xff);
 380             } else {
 381                 qemu_log_mask(LOG_UNIMP,
 382                               "ps2: ignoring key with qcode %d\n", qcode);
 383             }
 384         }
 385     } else if (s->scancode_set == 2) {
 386         if (qcode == Q_KEY_CODE_PAUSE) {
 387             if (s->modifiers & (MOD_CTRL_L | MOD_CTRL_R)) {
 388                 if (key->down) {
 389                     ps2_put_keycode(s, 0xe0);
 390                     ps2_put_keycode(s, 0x7e);
 391                     ps2_put_keycode(s, 0xe0);
 392                     ps2_put_keycode(s, 0xf0);
 393                     ps2_put_keycode(s, 0x7e);
 394                 }
 395             } else {
 396                 if (key->down) {
 397                     ps2_put_keycode(s, 0xe1);
 398                     ps2_put_keycode(s, 0x14);
 399                     ps2_put_keycode(s, 0x77);
 400                     ps2_put_keycode(s, 0xe1);
 401                     ps2_put_keycode(s, 0xf0);
 402                     ps2_put_keycode(s, 0x14);
 403                     ps2_put_keycode(s, 0xf0);
 404                     ps2_put_keycode(s, 0x77);
 405                 }
 406             }
 407         } else if (qcode == Q_KEY_CODE_PRINT) {
 408             if (s->modifiers & MOD_ALT_L) {
 409                 if (key->down) {
 410                     ps2_put_keycode(s, 0xf0);
 411                     ps2_put_keycode(s, 0x11);
 412                     ps2_put_keycode(s, 0x11);
 413                     ps2_put_keycode(s, 0x84);
 414                 } else {
 415                     ps2_put_keycode(s, 0xf0);
 416                     ps2_put_keycode(s, 0x84);
 417                     ps2_put_keycode(s, 0xf0);
 418                     ps2_put_keycode(s, 0x11);
 419                     ps2_put_keycode(s, 0x11);
 420                 }
 421             } else if (s->modifiers & MOD_ALT_R) {
 422                 if (key->down) {
 423                     ps2_put_keycode(s, 0xe0);
 424                     ps2_put_keycode(s, 0xf0);
 425                     ps2_put_keycode(s, 0x11);
 426                     ps2_put_keycode(s, 0xe0);
 427                     ps2_put_keycode(s, 0x11);
 428                     ps2_put_keycode(s, 0x84);
 429                 } else {
 430                     ps2_put_keycode(s, 0xf0);
 431                     ps2_put_keycode(s, 0x84);
 432                     ps2_put_keycode(s, 0xe0);
 433                     ps2_put_keycode(s, 0xf0);
 434                     ps2_put_keycode(s, 0x11);
 435                     ps2_put_keycode(s, 0xe0);
 436                     ps2_put_keycode(s, 0x11);
 437                 }
 438             } else if (s->modifiers & (MOD_SHIFT_L | MOD_CTRL_L |
 439                                        MOD_SHIFT_R | MOD_CTRL_R)) {
 440                 if (key->down) {
 441                     ps2_put_keycode(s, 0xe0);
 442                     ps2_put_keycode(s, 0x7c);
 443                 } else {
 444                     ps2_put_keycode(s, 0xe0);
 445                     ps2_put_keycode(s, 0xf0);
 446                     ps2_put_keycode(s, 0x7c);
 447                 }
 448             } else {
 449                 if (key->down) {
 450                     ps2_put_keycode(s, 0xe0);
 451                     ps2_put_keycode(s, 0x12);
 452                     ps2_put_keycode(s, 0xe0);
 453                     ps2_put_keycode(s, 0x7c);
 454                 } else {
 455                     ps2_put_keycode(s, 0xe0);
 456                     ps2_put_keycode(s, 0xf0);
 457                     ps2_put_keycode(s, 0x7c);
 458                     ps2_put_keycode(s, 0xe0);
 459                     ps2_put_keycode(s, 0xf0);
 460                     ps2_put_keycode(s, 0x12);
 461                 }
 462             }
 463         } else {
 464             if (qcode < qemu_input_map_qcode_to_atset2_len)
 465                 keycode = qemu_input_map_qcode_to_atset2[qcode];
 466             if (keycode) {
 467                 if (keycode & 0xff00) {
 468                     ps2_put_keycode(s, keycode >> 8);
 469                 }
 470                 if (!key->down) {
 471                     ps2_put_keycode(s, 0xf0);
 472                 }
 473                 ps2_put_keycode(s, keycode & 0xff);
 474             } else {
 475                 qemu_log_mask(LOG_UNIMP,
 476                               "ps2: ignoring key with qcode %d\n", qcode);
 477             }
 478         }
 479     } else if (s->scancode_set == 3) {
 480         if (qcode < qemu_input_map_qcode_to_atset3_len)
 481             keycode = qemu_input_map_qcode_to_atset3[qcode];
 482         if (keycode) {
 483             /* FIXME: break code should be configured on a key by key basis */
 484             if (!key->down) {
 485                 ps2_put_keycode(s, 0xf0);
 486             }
 487             ps2_put_keycode(s, keycode);
 488         } else {
 489             qemu_log_mask(LOG_UNIMP,
 490                           "ps2: ignoring key with qcode %d\n", qcode);
 491         }
 492     }
 493 }
 494
 495 uint32_t ps2_read_data(PS2State *s)
 496 {
 497     PS2Queue *q;
 498     int val, index;
 499
 500     trace_ps2_read_data(s);
 501     q = &s->queue;
 502     if (q->count == 0) {
 503         /* NOTE: if no data left, we return the last keyboard one
 504            (needed for EMM386) */
 505         /* XXX: need a timer to do things correctly */
 506         index = q->rptr - 1;
 507         if (index < 0)
 508             index = PS2_QUEUE_SIZE - 1;
 509         val = q->data[index];
 510     } else {
 511         val = q->data[q->rptr];
 512         if (++q->rptr == PS2_QUEUE_SIZE)
 513             q->rptr = 0;
 514         q->count--;
 515         /* reading deasserts IRQ */
 516         s->update_irq(s->update_arg, 0);
 517         /* reassert IRQs if data left */
 518         s->update_irq(s->update_arg, q->count != 0);
 519     }
 520     return val;
 521 }
 522
 523 static void ps2_set_ledstate(PS2KbdState *s, int ledstate)
 524 {
 525     trace_ps2_set_ledstate(s, ledstate);
 526     s->ledstate = ledstate;
 527     kbd_put_ledstate(ledstate);
 528 }
 529
 530 static void ps2_reset_keyboard(PS2KbdState *s)
 531 {
 532     trace_ps2_reset_keyboard(s);
 533     s->scan_enabled = 1;
 534     s->scancode_set = 2;
 535     ps2_reset_queue(&s->common);
 536     ps2_set_ledstate(s, 0);
 537 }
 538
 539 void ps2_write_keyboard(void *opaque, int val)
 540 {
 541     PS2KbdState *s = (PS2KbdState *)opaque;
 542
 543     trace_ps2_write_keyboard(opaque, val);
 544     switch(s->common.write_cmd) {
 545     default:
 546     case -1:
 547         switch(val) {
 548         case 0x00:
 549             ps2_queue(&s->common, KBD_REPLY_ACK);
 550             break;
 551         case 0x05:
 552             ps2_queue(&s->common, KBD_REPLY_RESEND);
 553             break;
 554         case KBD_CMD_GET_ID:
 555             /* We emulate a MF2 AT keyboard here */
 556             if (s->translate)
 557                 ps2_queue_3(&s->common,
 558                     KBD_REPLY_ACK,
 559                     KBD_REPLY_ID,
 560                     0x41);
 561             else
 562                 ps2_queue_3(&s->common,
 563                     KBD_REPLY_ACK,
 564                     KBD_REPLY_ID,
 565                     0x83);
 566             break;
 567         case KBD_CMD_ECHO:
 568             ps2_queue(&s->common, KBD_CMD_ECHO);
 569             break;
 570         case KBD_CMD_ENABLE:
 571             s->scan_enabled = 1;
 572             ps2_queue(&s->common, KBD_REPLY_ACK);
 573             break;
 574         case KBD_CMD_SCANCODE:
 575         case KBD_CMD_SET_LEDS:
 576         case KBD_CMD_SET_RATE:
 577         case KBD_CMD_SET_MAKE_BREAK:
 578             s->common.write_cmd = val;
 579             ps2_queue(&s->common, KBD_REPLY_ACK);
 580             break;
 581         case KBD_CMD_RESET_DISABLE:
 582             ps2_reset_keyboard(s);
 583             s->scan_enabled = 0;
 584             ps2_queue(&s->common, KBD_REPLY_ACK);
 585             break;
 586         case KBD_CMD_RESET_ENABLE:
 587             ps2_reset_keyboard(s);
 588             s->scan_enabled = 1;
 589             ps2_queue(&s->common, KBD_REPLY_ACK);
 590             break;
 591         case KBD_CMD_RESET:
 592             ps2_reset_keyboard(s);
 593             ps2_queue_2(&s->common,
 594                 KBD_REPLY_ACK,
 595                 KBD_REPLY_POR);
 596             break;
 597         case KBD_CMD_SET_TYPEMATIC:
 598             ps2_queue(&s->common, KBD_REPLY_ACK);
 599             break;
 600         default:
 601             ps2_queue(&s->common, KBD_REPLY_RESEND);
 602             break;
 603         }
 604         break;
 605     case KBD_CMD_SET_MAKE_BREAK:
 606         ps2_queue(&s->common, KBD_REPLY_ACK);
 607         s->common.write_cmd = -1;
 608         break;
 609     case KBD_CMD_SCANCODE:
 610         if (val == 0) {
 611             if (s->common.queue.count <= PS2_QUEUE_SIZE - 2) {
 612                 ps2_queue(&s->common, KBD_REPLY_ACK);
 613                 ps2_put_keycode(s, s->scancode_set);
 614             }
 615         } else if (val >= 1 && val <= 3) {
 616             s->scancode_set = val;
 617             ps2_queue(&s->common, KBD_REPLY_ACK);
 618         } else {
 619             ps2_queue(&s->common, KBD_REPLY_RESEND);
 620         }
 621         s->common.write_cmd = -1;
 622         break;
 623     case KBD_CMD_SET_LEDS:
 624         ps2_set_ledstate(s, val);
 625         ps2_queue(&s->common, KBD_REPLY_ACK);
 626         s->common.write_cmd = -1;
 627         break;
 628     case KBD_CMD_SET_RATE:
 629         ps2_queue(&s->common, KBD_REPLY_ACK);
 630         s->common.write_cmd = -1;
 631         break;
 632     }
 633 }
 634
 635 /* Set the scancode translation mode.
 636    0 = raw scancodes.
 637    1 = translated scancodes (used by qemu internally).  */
 638
 639 void ps2_keyboard_set_translation(void *opaque, int mode)
 640 {
 641     PS2KbdState *s = (PS2KbdState *)opaque;
 642     trace_ps2_keyboard_set_translation(opaque, mode);
 643     s->translate = mode;
 644 }
 645
 646 static int ps2_mouse_send_packet(PS2MouseState *s)
 647 {
 648     const int needed = 3 + (s->mouse_type - 2);
 649     unsigned int b;
 650     int dx1, dy1, dz1;
 651
 652     if (PS2_QUEUE_SIZE - s->common.queue.count < needed) {
 653         return 0;
 654     }
 655
 656     dx1 = s->mouse_dx;
 657     dy1 = s->mouse_dy;
 658     dz1 = s->mouse_dz;
 659     /* XXX: increase range to 8 bits ? */
 660     if (dx1 > 127)
 661         dx1 = 127;
 662     else if (dx1 < -127)
 663         dx1 = -127;
 664     if (dy1 > 127)
 665         dy1 = 127;
 666     else if (dy1 < -127)
 667         dy1 = -127;
 668     b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
 669     ps2_queue_noirq(&s->common, b);
 670     ps2_queue_noirq(&s->common, dx1 & 0xff);
 671     ps2_queue_noirq(&s->common, dy1 & 0xff);
 672     /* extra byte for IMPS/2 or IMEX */
 673     switch(s->mouse_type) {
 674     default:
 675         break;
 676     case 3:
 677         if (dz1 > 127)
 678             dz1 = 127;
 679         else if (dz1 < -127)
 680                 dz1 = -127;
 681         ps2_queue_noirq(&s->common, dz1 & 0xff);
 682         break;
 683     case 4:
 684         if (dz1 > 7)
 685             dz1 = 7;
 686         else if (dz1 < -7)
 687             dz1 = -7;
 688         b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
 689         ps2_queue_noirq(&s->common, b);
 690         break;
 691     }
 692
 693     ps2_raise_irq(&s->common);
 694
 695     trace_ps2_mouse_send_packet(s, dx1, dy1, dz1, b);
 696     /* update deltas */
 697     s->mouse_dx -= dx1;
 698     s->mouse_dy -= dy1;
 699     s->mouse_dz -= dz1;
 700
 701     return 1;
 702 }
 703
 704 static void ps2_mouse_event(DeviceState *dev, QemuConsole *src,
 705                             InputEvent *evt)
 706 {
 707     static const int bmap[INPUT_BUTTON__MAX] = {
 708         [INPUT_BUTTON_LEFT]   = PS2_MOUSE_BUTTON_LEFT,
 709         [INPUT_BUTTON_MIDDLE] = PS2_MOUSE_BUTTON_MIDDLE,
 710         [INPUT_BUTTON_RIGHT]  = PS2_MOUSE_BUTTON_RIGHT,
 711         [INPUT_BUTTON_SIDE]   = PS2_MOUSE_BUTTON_SIDE,
 712         [INPUT_BUTTON_EXTRA]  = PS2_MOUSE_BUTTON_EXTRA,
 713     };
 714     PS2MouseState *s = (PS2MouseState *)dev;
 715     InputMoveEvent *move;
 716     InputBtnEvent *btn;
 717
 718     /* check if deltas are recorded when disabled */
 719     if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
 720         return;
 721
 722     switch (evt->type) {
 723     case INPUT_EVENT_KIND_REL:
 724         move = evt->u.rel.data;
 725         if (move->axis == INPUT_AXIS_X) {
 726             s->mouse_dx += move->value;
 727         } else if (move->axis == INPUT_AXIS_Y) {
 728             s->mouse_dy -= move->value;
 729         }
 730         break;
 731
 732     case INPUT_EVENT_KIND_BTN:
 733         btn = evt->u.btn.data;
 734         if (btn->down) {
 735             s->mouse_buttons |= bmap[btn->button];
 736             if (btn->button == INPUT_BUTTON_WHEEL_UP) {
 737                 s->mouse_dz--;
 738             } else if (btn->button == INPUT_BUTTON_WHEEL_DOWN) {
 739                 s->mouse_dz++;
 740             }
 741         } else {
 742             s->mouse_buttons &= ~bmap[btn->button];
 743         }
 744         break;
 745
 746     default:
 747         /* keep gcc happy */
 748         break;
 749     }
 750 }
 751
 752 static void ps2_mouse_sync(DeviceState *dev)
 753 {
 754     PS2MouseState *s = (PS2MouseState *)dev;
 755
 756     /* do not sync while disabled to prevent stream corruption */
 757     if (!(s->mouse_status & MOUSE_STATUS_ENABLED)) {
 758         return;
 759     }
 760
 761     if (s->mouse_buttons) {
 762         qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER, NULL);
 763     }
 764     if (!(s->mouse_status & MOUSE_STATUS_REMOTE)) {
 765         /* if not remote, send event. Multiple events are sent if
 766            too big deltas */
 767         while (ps2_mouse_send_packet(s)) {
 768             if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
 769                 break;
 770         }
 771     }
 772 }
 773
 774 void ps2_mouse_fake_event(void *opaque)
 775 {
 776     PS2MouseState *s = opaque;
 777     trace_ps2_mouse_fake_event(opaque);
 778     s->mouse_dx++;
 779     ps2_mouse_sync(opaque);
 780 }
 781
 782 void ps2_write_mouse(void *opaque, int val)
 783 {
 784     PS2MouseState *s = (PS2MouseState *)opaque;
 785
 786     trace_ps2_write_mouse(opaque, val);
 787     switch(s->common.write_cmd) {
 788     default:
 789     case -1:
 790         /* mouse command */
 791         if (s->mouse_wrap) {
 792             if (val == AUX_RESET_WRAP) {
 793                 s->mouse_wrap = 0;
 794                 ps2_queue(&s->common, AUX_ACK);
 795                 return;
 796             } else if (val != AUX_RESET) {
 797                 ps2_queue(&s->common, val);
 798                 return;
 799             }
 800         }
 801         switch(val) {
 802         case AUX_SET_SCALE11:
 803             s->mouse_status &= ~MOUSE_STATUS_SCALE21;
 804             ps2_queue(&s->common, AUX_ACK);
 805             break;
 806         case AUX_SET_SCALE21:
 807             s->mouse_status |= MOUSE_STATUS_SCALE21;
 808             ps2_queue(&s->common, AUX_ACK);
 809             break;
 810         case AUX_SET_STREAM:
 811             s->mouse_status &= ~MOUSE_STATUS_REMOTE;
 812             ps2_queue(&s->common, AUX_ACK);
 813             break;
 814         case AUX_SET_WRAP:
 815             s->mouse_wrap = 1;
 816             ps2_queue(&s->common, AUX_ACK);
 817             break;
 818         case AUX_SET_REMOTE:
 819             s->mouse_status |= MOUSE_STATUS_REMOTE;
 820             ps2_queue(&s->common, AUX_ACK);
 821             break;
 822         case AUX_GET_TYPE:
 823             ps2_queue_2(&s->common,
 824                 AUX_ACK,
 825                 s->mouse_type);
 826             break;
 827         case AUX_SET_RES:
 828         case AUX_SET_SAMPLE:
 829             s->common.write_cmd = val;
 830             ps2_queue(&s->common, AUX_ACK);
 831             break;
 832         case AUX_GET_SCALE:
 833             ps2_queue_4(&s->common,
 834                 AUX_ACK,
 835                 s->mouse_status,
 836                 s->mouse_resolution,
 837                 s->mouse_sample_rate);
 838             break;
 839         case AUX_POLL:
 840             ps2_queue(&s->common, AUX_ACK);
 841             ps2_mouse_send_packet(s);
 842             break;
 843         case AUX_ENABLE_DEV:
 844             s->mouse_status |= MOUSE_STATUS_ENABLED;
 845             ps2_queue(&s->common, AUX_ACK);
 846             break;
 847         case AUX_DISABLE_DEV:
 848             s->mouse_status &= ~MOUSE_STATUS_ENABLED;
 849             ps2_queue(&s->common, AUX_ACK);
 850             break;
 851         case AUX_SET_DEFAULT:
 852             s->mouse_sample_rate = 100;
 853             s->mouse_resolution = 2;
 854             s->mouse_status = 0;
 855             ps2_queue(&s->common, AUX_ACK);
 856             break;
 857         case AUX_RESET:
 858             s->mouse_sample_rate = 100;
 859             s->mouse_resolution = 2;
 860             s->mouse_status = 0;
 861             s->mouse_type = 0;
 862             ps2_reset_queue(&s->common);
 863             ps2_queue_3(&s->common,
 864                 AUX_ACK,
 865                 0xaa,
 866                 s->mouse_type);
 867             break;
 868         default:
 869             break;
 870         }
 871         break;
 872     case AUX_SET_SAMPLE:
 873         s->mouse_sample_rate = val;
 874         /* detect IMPS/2 or IMEX */
 875         switch(s->mouse_detect_state) {
 876         default:
 877         case 0:
 878             if (val == 200)
 879                 s->mouse_detect_state = 1;
 880             break;
 881         case 1:
 882             if (val == 100)
 883                 s->mouse_detect_state = 2;
 884             else if (val == 200)
 885                 s->mouse_detect_state = 3;
 886             else
 887                 s->mouse_detect_state = 0;
 888             break;
 889         case 2:
 890             if (val == 80)
 891                 s->mouse_type = 3; /* IMPS/2 */
 892             s->mouse_detect_state = 0;
 893             break;
 894         case 3:
 895             if (val == 80)
 896                 s->mouse_type = 4; /* IMEX */
 897             s->mouse_detect_state = 0;
 898             break;
 899         }
 900         ps2_queue(&s->common, AUX_ACK);
 901         s->common.write_cmd = -1;
 902         break;
 903     case AUX_SET_RES:
 904         s->mouse_resolution = val;
 905         ps2_queue(&s->common, AUX_ACK);
 906         s->common.write_cmd = -1;
 907         break;
 908     }
 909 }
 910
 911 static void ps2_common_reset(PS2State *s)
 912 {
 913     s->write_cmd = -1;
 914     ps2_reset_queue(s);
 915     s->update_irq(s->update_arg, 0);
 916 }
 917
 918 static void ps2_common_post_load(PS2State *s)
 919 {
 920     PS2Queue *q = &s->queue;
 921     uint8_t i, size;
 922     uint8_t tmp_data[PS2_QUEUE_SIZE];
 923
 924     /* set the useful data buffer queue size, < PS2_QUEUE_SIZE */
 925     size = q->count;
 926     if (q->count < 0) {
 927         size = 0;
 928     } else if (q->count > PS2_QUEUE_SIZE) {
 929         size = PS2_QUEUE_SIZE;
 930     }
 931
 932     /* move the queue elements to the start of data array */
 933     for (i = 0; i < size; i++) {
 934         if (q->rptr < 0 || q->rptr >= sizeof(q->data)) {
 935             q->rptr = 0;
 936         }
 937         tmp_data[i] = q->data[q->rptr++];
 938     }
 939     memcpy(q->data, tmp_data, size);
 940
 941     /* reset rptr/wptr/count */
 942     q->rptr = 0;
 943     q->wptr = (size == PS2_QUEUE_SIZE) ? 0 : size;
 944     q->count = size;
 945 }
 946
 947 static void ps2_kbd_reset(void *opaque)
 948 {
 949     PS2KbdState *s = (PS2KbdState *) opaque;
 950
 951     trace_ps2_kbd_reset(opaque);
 952     ps2_common_reset(&s->common);
 953     s->scan_enabled = 1;
 954     s->translate = 0;
 955     s->scancode_set = 2;
 956     s->modifiers = 0;
 957 }
 958
 959 static void ps2_mouse_reset(void *opaque)
 960 {
 961     PS2MouseState *s = (PS2MouseState *) opaque;
 962
 963     trace_ps2_mouse_reset(opaque);
 964     ps2_common_reset(&s->common);
 965     s->mouse_status = 0;
 966     s->mouse_resolution = 0;
 967     s->mouse_sample_rate = 0;
 968     s->mouse_wrap = 0;
 969     s->mouse_type = 0;
 970     s->mouse_detect_state = 0;
 971     s->mouse_dx = 0;
 972     s->mouse_dy = 0;
 973     s->mouse_dz = 0;
 974     s->mouse_buttons = 0;
 975 }
 976
 977 static const VMStateDescription vmstate_ps2_common = {
 978     .name = "PS2 Common State",
 979     .version_id = 3,
 980     .minimum_version_id = 2,
 981     .fields = (VMStateField[]) {
 982         VMSTATE_INT32(write_cmd, PS2State),
 983         VMSTATE_INT32(queue.rptr, PS2State),
 984         VMSTATE_INT32(queue.wptr, PS2State),
 985         VMSTATE_INT32(queue.count, PS2State),
 986         VMSTATE_BUFFER(queue.data, PS2State),
 987         VMSTATE_END_OF_LIST()
 988     }
 989 };
 990
 991 static bool ps2_keyboard_ledstate_needed(void *opaque)
 992 {
 993     PS2KbdState *s = opaque;
 994
 995     return s->ledstate != 0; /* 0 is default state */
 996 }
 997
 998 static int ps2_kbd_ledstate_post_load(void *opaque, int version_id)
 999 {
1000     PS2KbdState *s = opaque;
1001
1002     kbd_put_ledstate(s->ledstate);
1003     return 0;
1004 }
1005
1006 static const VMStateDescription vmstate_ps2_keyboard_ledstate = {
1007     .name = "ps2kbd/ledstate",
1008     .version_id = 3,
1009     .minimum_version_id = 2,
1010     .post_load = ps2_kbd_ledstate_post_load,
1011     .needed = ps2_keyboard_ledstate_needed,
1012     .fields = (VMStateField[]) {
1013         VMSTATE_INT32(ledstate, PS2KbdState),
1014         VMSTATE_END_OF_LIST()
1015     }
1016 };
1017
1018 static bool ps2_keyboard_need_high_bit_needed(void *opaque)
1019 {
1020     PS2KbdState *s = opaque;
1021     return s->need_high_bit != 0; /* 0 is the usual state */
1022 }
1023
1024 static const VMStateDescription vmstate_ps2_keyboard_need_high_bit = {
1025     .name = "ps2kbd/need_high_bit",
1026     .version_id = 1,
1027     .minimum_version_id = 1,
1028     .needed = ps2_keyboard_need_high_bit_needed,
1029     .fields = (VMStateField[]) {
1030         VMSTATE_BOOL(need_high_bit, PS2KbdState),
1031         VMSTATE_END_OF_LIST()
1032     }
1033 };
1034
1035 static int ps2_kbd_post_load(void* opaque, int version_id)
1036 {
1037     PS2KbdState *s = (PS2KbdState*)opaque;
1038     PS2State *ps2 = &s->common;
1039
1040     if (version_id == 2)
1041         s->scancode_set=2;
1042
1043     ps2_common_post_load(ps2);
1044
1045     return 0;
1046 }
1047
1048 static int ps2_kbd_pre_save(void *opaque)
1049 {
1050     PS2KbdState *s = (PS2KbdState *)opaque;
1051     PS2State *ps2 = &s->common;
1052
1053     ps2_common_post_load(ps2);
1054
1055     return 0;
1056 }
1057
1058 static const VMStateDescription vmstate_ps2_keyboard = {
1059     .name = "ps2kbd",
1060     .version_id = 3,
1061     .minimum_version_id = 2,
1062     .post_load = ps2_kbd_post_load,
1063     .pre_save = ps2_kbd_pre_save,
1064     .fields = (VMStateField[]) {
1065         VMSTATE_STRUCT(common, PS2KbdState, 0, vmstate_ps2_common, PS2State),
1066         VMSTATE_INT32(scan_enabled, PS2KbdState),
1067         VMSTATE_INT32(translate, PS2KbdState),
1068         VMSTATE_INT32_V(scancode_set, PS2KbdState,3),
1069         VMSTATE_END_OF_LIST()
1070     },
1071     .subsections = (const VMStateDescription*[]) {
1072         &vmstate_ps2_keyboard_ledstate,
1073         &vmstate_ps2_keyboard_need_high_bit,
1074         NULL
1075     }
1076 };
1077
1078 static int ps2_mouse_post_load(void *opaque, int version_id)
1079 {
1080     PS2MouseState *s = (PS2MouseState *)opaque;
1081     PS2State *ps2 = &s->common;
1082
1083     ps2_common_post_load(ps2);
1084
1085     return 0;
1086 }
1087
1088 static int ps2_mouse_pre_save(void *opaque)
1089 {
1090     PS2MouseState *s = (PS2MouseState *)opaque;
1091     PS2State *ps2 = &s->common;
1092
1093     ps2_common_post_load(ps2);
1094
1095     return 0;
1096 }
1097
1098 static const VMStateDescription vmstate_ps2_mouse = {
1099     .name = "ps2mouse",
1100     .version_id = 2,
1101     .minimum_version_id = 2,
1102     .post_load = ps2_mouse_post_load,
1103     .pre_save = ps2_mouse_pre_save,
1104     .fields = (VMStateField[]) {
1105         VMSTATE_STRUCT(common, PS2MouseState, 0, vmstate_ps2_common, PS2State),
1106         VMSTATE_UINT8(mouse_status, PS2MouseState),
1107         VMSTATE_UINT8(mouse_resolution, PS2MouseState),
1108         VMSTATE_UINT8(mouse_sample_rate, PS2MouseState),
1109         VMSTATE_UINT8(mouse_wrap, PS2MouseState),
1110         VMSTATE_UINT8(mouse_type, PS2MouseState),
1111         VMSTATE_UINT8(mouse_detect_state, PS2MouseState),
1112         VMSTATE_INT32(mouse_dx, PS2MouseState),
1113         VMSTATE_INT32(mouse_dy, PS2MouseState),
1114         VMSTATE_INT32(mouse_dz, PS2MouseState),
1115         VMSTATE_UINT8(mouse_buttons, PS2MouseState),
1116         VMSTATE_END_OF_LIST()
1117     }
1118 };
1119
1120 static QemuInputHandler ps2_keyboard_handler = {
1121     .name  = "QEMU PS/2 Keyboard",
1122     .mask  = INPUT_EVENT_MASK_KEY,
1123     .event = ps2_keyboard_event,
1124 };
1125
1126 void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
1127 {
1128     PS2KbdState *s = (PS2KbdState *)g_malloc0(sizeof(PS2KbdState));
1129
1130     trace_ps2_kbd_init(s);
1131     s->common.update_irq = update_irq;
1132     s->common.update_arg = update_arg;
1133     s->scancode_set = 2;
1134     vmstate_register(NULL, 0, &vmstate_ps2_keyboard, s);
1135     qemu_input_handler_register((DeviceState *)s,
1136                                 &ps2_keyboard_handler);
1137     qemu_register_reset(ps2_kbd_reset, s);
1138     return s;
1139 }
1140
1141 static QemuInputHandler ps2_mouse_handler = {
1142     .name  = "QEMU PS/2 Mouse",
1143     .mask  = INPUT_EVENT_MASK_BTN | INPUT_EVENT_MASK_REL,
1144     .event = ps2_mouse_event,
1145     .sync  = ps2_mouse_sync,
1146 };
1147
1148 void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
1149 {
1150     PS2MouseState *s = (PS2MouseState *)g_malloc0(sizeof(PS2MouseState));
1151
1152     trace_ps2_mouse_init(s);
1153     s->common.update_irq = update_irq;
1154     s->common.update_arg = update_arg;
1155     vmstate_register(NULL, 0, &vmstate_ps2_mouse, s);
1156     qemu_input_handler_register((DeviceState *)s,
1157                                 &ps2_mouse_handler);
1158     qemu_register_reset(ps2_mouse_reset, s);
1159     return s;
1160 }