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