?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ps2: use QEMU qcodes instead of scancodes
[qemu/kevin.git] / hw / input / ps2.c
blob98da984384f5fef2f59b0272cfc539a921d491c6
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 }
Random patches