![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw|
Return to ps2.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw |
1.1 root 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 "vl.h"
25:
26: /* debug PC keyboard */
27: //#define DEBUG_KBD
28:
29: /* debug PC keyboard : only mouse */
30: //#define DEBUG_MOUSE
31:
32: /* Keyboard Commands */
33: #define KBD_CMD_SET_LEDS 0xED /* Set keyboard leds */
34: #define KBD_CMD_ECHO 0xEE
35: #define KBD_CMD_GET_ID 0xF2 /* get keyboard ID */
36: #define KBD_CMD_SET_RATE 0xF3 /* Set typematic rate */
37: #define KBD_CMD_ENABLE 0xF4 /* Enable scanning */
38: #define KBD_CMD_RESET_DISABLE 0xF5 /* reset and disable scanning */
39: #define KBD_CMD_RESET_ENABLE 0xF6 /* reset and enable scanning */
40: #define KBD_CMD_RESET 0xFF /* Reset */
41:
42: /* Keyboard Replies */
43: #define KBD_REPLY_POR 0xAA /* Power on reset */
44: #define KBD_REPLY_ACK 0xFA /* Command ACK */
45: #define KBD_REPLY_RESEND 0xFE /* Command NACK, send the cmd again */
46:
47: /* Mouse Commands */
48: #define AUX_SET_SCALE11 0xE6 /* Set 1:1 scaling */
49: #define AUX_SET_SCALE21 0xE7 /* Set 2:1 scaling */
50: #define AUX_SET_RES 0xE8 /* Set resolution */
51: #define AUX_GET_SCALE 0xE9 /* Get scaling factor */
52: #define AUX_SET_STREAM 0xEA /* Set stream mode */
53: #define AUX_POLL 0xEB /* Poll */
54: #define AUX_RESET_WRAP 0xEC /* Reset wrap mode */
55: #define AUX_SET_WRAP 0xEE /* Set wrap mode */
56: #define AUX_SET_REMOTE 0xF0 /* Set remote mode */
57: #define AUX_GET_TYPE 0xF2 /* Get type */
58: #define AUX_SET_SAMPLE 0xF3 /* Set sample rate */
59: #define AUX_ENABLE_DEV 0xF4 /* Enable aux device */
60: #define AUX_DISABLE_DEV 0xF5 /* Disable aux device */
61: #define AUX_SET_DEFAULT 0xF6
62: #define AUX_RESET 0xFF /* Reset aux device */
63: #define AUX_ACK 0xFA /* Command byte ACK. */
64:
65: #define MOUSE_STATUS_REMOTE 0x40
66: #define MOUSE_STATUS_ENABLED 0x20
67: #define MOUSE_STATUS_SCALE21 0x10
68:
69: #define PS2_QUEUE_SIZE 256
70:
71: typedef struct {
72: uint8_t data[PS2_QUEUE_SIZE];
73: int rptr, wptr, count;
74: } PS2Queue;
75:
76: typedef struct {
77: PS2Queue queue;
78: int32_t write_cmd;
79: void (*update_irq)(void *, int);
80: void *update_arg;
81: } PS2State;
82:
83: typedef struct {
84: PS2State common;
85: int scan_enabled;
86: } PS2KbdState;
87:
88: typedef struct {
89: PS2State common;
90: uint8_t mouse_status;
91: uint8_t mouse_resolution;
92: uint8_t mouse_sample_rate;
93: uint8_t mouse_wrap;
94: uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
95: uint8_t mouse_detect_state;
96: int mouse_dx; /* current values, needed for 'poll' mode */
97: int mouse_dy;
98: int mouse_dz;
99: uint8_t mouse_buttons;
100: } PS2MouseState;
101:
102: void ps2_queue(void *opaque, int b)
103: {
104: PS2State *s = (PS2State *)opaque;
105: PS2Queue *q = &s->queue;
106:
107: if (q->count >= PS2_QUEUE_SIZE)
108: return;
109: q->data[q->wptr] = b;
110: if (++q->wptr == PS2_QUEUE_SIZE)
111: q->wptr = 0;
112: q->count++;
113: s->update_irq(s->update_arg, 1);
114: }
115:
116: static void ps2_put_keycode(void *opaque, int keycode)
117: {
118: PS2MouseState *s = opaque;
119: ps2_queue(&s->common, keycode);
120: }
121:
122: uint32_t ps2_read_data(void *opaque)
123: {
124: PS2State *s = (PS2State *)opaque;
125: PS2Queue *q;
126: int val, index;
127:
128: q = &s->queue;
129: if (q->count == 0) {
130: /* NOTE: if no data left, we return the last keyboard one
131: (needed for EMM386) */
132: /* XXX: need a timer to do things correctly */
133: index = q->rptr - 1;
134: if (index < 0)
135: index = PS2_QUEUE_SIZE - 1;
136: val = q->data[index];
137: } else {
138: val = q->data[q->rptr];
139: if (++q->rptr == PS2_QUEUE_SIZE)
140: q->rptr = 0;
141: q->count--;
142: /* reading deasserts IRQ */
143: s->update_irq(s->update_arg, 0);
144: /* reassert IRQs if data left */
145: s->update_irq(s->update_arg, q->count != 0);
146: }
147: return val;
148: }
149:
150: static void ps2_reset_keyboard(PS2KbdState *s)
151: {
152: s->scan_enabled = 1;
153: }
154:
155: void ps2_write_keyboard(void *opaque, int val)
156: {
157: PS2KbdState *s = (PS2KbdState *)opaque;
158:
159: switch(s->common.write_cmd) {
160: default:
161: case -1:
162: switch(val) {
163: case 0x00:
164: ps2_queue(&s->common, KBD_REPLY_ACK);
165: break;
166: case 0x05:
167: ps2_queue(&s->common, KBD_REPLY_RESEND);
168: break;
169: case KBD_CMD_GET_ID:
170: ps2_queue(&s->common, KBD_REPLY_ACK);
171: ps2_queue(&s->common, 0xab);
172: ps2_queue(&s->common, 0x83);
173: break;
174: case KBD_CMD_ECHO:
175: ps2_queue(&s->common, KBD_CMD_ECHO);
176: break;
177: case KBD_CMD_ENABLE:
178: s->scan_enabled = 1;
179: ps2_queue(&s->common, KBD_REPLY_ACK);
180: break;
181: case KBD_CMD_SET_LEDS:
182: case KBD_CMD_SET_RATE:
183: s->common.write_cmd = val;
184: ps2_queue(&s->common, KBD_REPLY_ACK);
185: break;
186: case KBD_CMD_RESET_DISABLE:
187: ps2_reset_keyboard(s);
188: s->scan_enabled = 0;
189: ps2_queue(&s->common, KBD_REPLY_ACK);
190: break;
191: case KBD_CMD_RESET_ENABLE:
192: ps2_reset_keyboard(s);
193: s->scan_enabled = 1;
194: ps2_queue(&s->common, KBD_REPLY_ACK);
195: break;
196: case KBD_CMD_RESET:
197: ps2_reset_keyboard(s);
198: ps2_queue(&s->common, KBD_REPLY_ACK);
199: ps2_queue(&s->common, KBD_REPLY_POR);
200: break;
201: default:
202: ps2_queue(&s->common, KBD_REPLY_ACK);
203: break;
204: }
205: break;
206: case KBD_CMD_SET_LEDS:
207: ps2_queue(&s->common, KBD_REPLY_ACK);
208: s->common.write_cmd = -1;
209: break;
210: case KBD_CMD_SET_RATE:
211: ps2_queue(&s->common, KBD_REPLY_ACK);
212: s->common.write_cmd = -1;
213: break;
214: }
215: }
216:
217: static void ps2_mouse_send_packet(PS2MouseState *s)
218: {
219: unsigned int b;
220: int dx1, dy1, dz1;
221:
222: dx1 = s->mouse_dx;
223: dy1 = s->mouse_dy;
224: dz1 = s->mouse_dz;
225: /* XXX: increase range to 8 bits ? */
226: if (dx1 > 127)
227: dx1 = 127;
228: else if (dx1 < -127)
229: dx1 = -127;
230: if (dy1 > 127)
231: dy1 = 127;
232: else if (dy1 < -127)
233: dy1 = -127;
234: b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
235: ps2_queue(&s->common, b);
236: ps2_queue(&s->common, dx1 & 0xff);
237: ps2_queue(&s->common, dy1 & 0xff);
238: /* extra byte for IMPS/2 or IMEX */
239: switch(s->mouse_type) {
240: default:
241: break;
242: case 3:
243: if (dz1 > 127)
244: dz1 = 127;
245: else if (dz1 < -127)
246: dz1 = -127;
247: ps2_queue(&s->common, dz1 & 0xff);
248: break;
249: case 4:
250: if (dz1 > 7)
251: dz1 = 7;
252: else if (dz1 < -7)
253: dz1 = -7;
254: b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
255: ps2_queue(&s->common, b);
256: break;
257: }
258:
259: /* update deltas */
260: s->mouse_dx -= dx1;
261: s->mouse_dy -= dy1;
262: s->mouse_dz -= dz1;
263: }
264:
265: static void ps2_mouse_event(void *opaque,
266: int dx, int dy, int dz, int buttons_state)
267: {
268: PS2MouseState *s = opaque;
269:
270: /* check if deltas are recorded when disabled */
271: if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
272: return;
273:
274: s->mouse_dx += dx;
275: s->mouse_dy -= dy;
276: s->mouse_dz += dz;
277: /* XXX: SDL sometimes generates nul events: we delete them */
278: if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
279: s->mouse_buttons == buttons_state)
280: return;
281: s->mouse_buttons = buttons_state;
282:
283: if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
284: (s->common.queue.count < (PS2_QUEUE_SIZE - 16))) {
285: for(;;) {
286: /* if not remote, send event. Multiple events are sent if
287: too big deltas */
288: ps2_mouse_send_packet(s);
289: if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
290: break;
291: }
292: }
293: }
294:
295: void ps2_write_mouse(void *opaque, int val)
296: {
297: PS2MouseState *s = (PS2MouseState *)opaque;
298: #ifdef DEBUG_MOUSE
299: printf("kbd: write mouse 0x%02x\n", val);
300: #endif
301: switch(s->common.write_cmd) {
302: default:
303: case -1:
304: /* mouse command */
305: if (s->mouse_wrap) {
306: if (val == AUX_RESET_WRAP) {
307: s->mouse_wrap = 0;
308: ps2_queue(&s->common, AUX_ACK);
309: return;
310: } else if (val != AUX_RESET) {
311: ps2_queue(&s->common, val);
312: return;
313: }
314: }
315: switch(val) {
316: case AUX_SET_SCALE11:
317: s->mouse_status &= ~MOUSE_STATUS_SCALE21;
318: ps2_queue(&s->common, AUX_ACK);
319: break;
320: case AUX_SET_SCALE21:
321: s->mouse_status |= MOUSE_STATUS_SCALE21;
322: ps2_queue(&s->common, AUX_ACK);
323: break;
324: case AUX_SET_STREAM:
325: s->mouse_status &= ~MOUSE_STATUS_REMOTE;
326: ps2_queue(&s->common, AUX_ACK);
327: break;
328: case AUX_SET_WRAP:
329: s->mouse_wrap = 1;
330: ps2_queue(&s->common, AUX_ACK);
331: break;
332: case AUX_SET_REMOTE:
333: s->mouse_status |= MOUSE_STATUS_REMOTE;
334: ps2_queue(&s->common, AUX_ACK);
335: break;
336: case AUX_GET_TYPE:
337: ps2_queue(&s->common, AUX_ACK);
338: ps2_queue(&s->common, s->mouse_type);
339: break;
340: case AUX_SET_RES:
341: case AUX_SET_SAMPLE:
342: s->common.write_cmd = val;
343: ps2_queue(&s->common, AUX_ACK);
344: break;
345: case AUX_GET_SCALE:
346: ps2_queue(&s->common, AUX_ACK);
347: ps2_queue(&s->common, s->mouse_status);
348: ps2_queue(&s->common, s->mouse_resolution);
349: ps2_queue(&s->common, s->mouse_sample_rate);
350: break;
351: case AUX_POLL:
352: ps2_queue(&s->common, AUX_ACK);
353: ps2_mouse_send_packet(s);
354: break;
355: case AUX_ENABLE_DEV:
356: s->mouse_status |= MOUSE_STATUS_ENABLED;
357: ps2_queue(&s->common, AUX_ACK);
358: break;
359: case AUX_DISABLE_DEV:
360: s->mouse_status &= ~MOUSE_STATUS_ENABLED;
361: ps2_queue(&s->common, AUX_ACK);
362: break;
363: case AUX_SET_DEFAULT:
364: s->mouse_sample_rate = 100;
365: s->mouse_resolution = 2;
366: s->mouse_status = 0;
367: ps2_queue(&s->common, AUX_ACK);
368: break;
369: case AUX_RESET:
370: s->mouse_sample_rate = 100;
371: s->mouse_resolution = 2;
372: s->mouse_status = 0;
373: s->mouse_type = 0;
374: ps2_queue(&s->common, AUX_ACK);
375: ps2_queue(&s->common, 0xaa);
376: ps2_queue(&s->common, s->mouse_type);
377: break;
378: default:
379: break;
380: }
381: break;
382: case AUX_SET_SAMPLE:
383: s->mouse_sample_rate = val;
384: /* detect IMPS/2 or IMEX */
385: switch(s->mouse_detect_state) {
386: default:
387: case 0:
388: if (val == 200)
389: s->mouse_detect_state = 1;
390: break;
391: case 1:
392: if (val == 100)
393: s->mouse_detect_state = 2;
394: else if (val == 200)
395: s->mouse_detect_state = 3;
396: else
397: s->mouse_detect_state = 0;
398: break;
399: case 2:
400: if (val == 80)
401: s->mouse_type = 3; /* IMPS/2 */
402: s->mouse_detect_state = 0;
403: break;
404: case 3:
405: if (val == 80)
406: s->mouse_type = 4; /* IMEX */
407: s->mouse_detect_state = 0;
408: break;
409: }
410: ps2_queue(&s->common, AUX_ACK);
411: s->common.write_cmd = -1;
412: break;
413: case AUX_SET_RES:
414: s->mouse_resolution = val;
415: ps2_queue(&s->common, AUX_ACK);
416: s->common.write_cmd = -1;
417: break;
418: }
419: }
420:
421: static void ps2_reset(void *opaque)
422: {
423: PS2State *s = (PS2State *)opaque;
424: PS2Queue *q;
425: s->write_cmd = -1;
426: q = &s->queue;
427: q->rptr = 0;
428: q->wptr = 0;
429: q->count = 0;
430: }
431:
432: static void ps2_kbd_save(QEMUFile* f, void* opaque)
433: {
434: PS2KbdState *s = (PS2KbdState*)opaque;
435:
436: qemu_put_be32s(f, &s->common.write_cmd);
437: qemu_put_be32s(f, &s->scan_enabled);
438: }
439:
440: static void ps2_mouse_save(QEMUFile* f, void* opaque)
441: {
442: PS2MouseState *s = (PS2MouseState*)opaque;
443:
444: qemu_put_be32s(f, &s->common.write_cmd);
445: qemu_put_8s(f, &s->mouse_status);
446: qemu_put_8s(f, &s->mouse_resolution);
447: qemu_put_8s(f, &s->mouse_sample_rate);
448: qemu_put_8s(f, &s->mouse_wrap);
449: qemu_put_8s(f, &s->mouse_type);
450: qemu_put_8s(f, &s->mouse_detect_state);
451: qemu_put_be32s(f, &s->mouse_dx);
452: qemu_put_be32s(f, &s->mouse_dy);
453: qemu_put_be32s(f, &s->mouse_dz);
454: qemu_put_8s(f, &s->mouse_buttons);
455: }
456:
457: static int ps2_kbd_load(QEMUFile* f, void* opaque, int version_id)
458: {
459: PS2KbdState *s = (PS2KbdState*)opaque;
460:
461: if (version_id != 1)
462: return -EINVAL;
463: qemu_get_be32s(f, &s->common.write_cmd);
464: qemu_get_be32s(f, &s->scan_enabled);
465: return 0;
466: }
467:
468: static int ps2_mouse_load(QEMUFile* f, void* opaque, int version_id)
469: {
470: PS2MouseState *s = (PS2MouseState*)opaque;
471:
472: if (version_id != 1)
473: return -EINVAL;
474: qemu_get_be32s(f, &s->common.write_cmd);
475: qemu_get_8s(f, &s->mouse_status);
476: qemu_get_8s(f, &s->mouse_resolution);
477: qemu_get_8s(f, &s->mouse_sample_rate);
478: qemu_get_8s(f, &s->mouse_wrap);
479: qemu_get_8s(f, &s->mouse_type);
480: qemu_get_8s(f, &s->mouse_detect_state);
481: qemu_get_be32s(f, &s->mouse_dx);
482: qemu_get_be32s(f, &s->mouse_dy);
483: qemu_get_be32s(f, &s->mouse_dz);
484: qemu_get_8s(f, &s->mouse_buttons);
485: return 0;
486: }
487:
488: void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
489: {
490: PS2KbdState *s = (PS2KbdState *)qemu_mallocz(sizeof(PS2KbdState));
491:
492: s->common.update_irq = update_irq;
493: s->common.update_arg = update_arg;
494: ps2_reset(&s->common);
495: register_savevm("ps2kbd", 0, 1, ps2_kbd_save, ps2_kbd_load, s);
496: qemu_add_kbd_event_handler(ps2_put_keycode, s);
497: qemu_register_reset(ps2_reset, &s->common);
498: return s;
499: }
500:
501: void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
502: {
503: PS2MouseState *s = (PS2MouseState *)qemu_mallocz(sizeof(PS2MouseState));
504:
505: s->common.update_irq = update_irq;
506: s->common.update_arg = update_arg;
507: ps2_reset(&s->common);
508: register_savevm("ps2mouse", 0, 1, ps2_mouse_save, ps2_mouse_load, s);
509: qemu_add_mouse_event_handler(ps2_mouse_event, s);
510: qemu_register_reset(ps2_reset, &s->common);
511: return s;
512: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.