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 } 1169