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