Statistics
| Branch: | Revision:

root / hw / ps2.c @ 455204eb

History | View | Annotate | Download (16.9 kB)

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
    /* Qemu uses translated PC scancodes internally.  To avoid multiple
87
       conversions we do the translation (if any) in the PS/2 emulation
88
       not the keyboard controller.  */
89
    int translate;
90
} PS2KbdState;
91

    
92
typedef struct {
93
    PS2State common;
94
    uint8_t mouse_status;
95
    uint8_t mouse_resolution;
96
    uint8_t mouse_sample_rate;
97
    uint8_t mouse_wrap;
98
    uint8_t mouse_type; /* 0 = PS2, 3 = IMPS/2, 4 = IMEX */
99
    uint8_t mouse_detect_state;
100
    int mouse_dx; /* current values, needed for 'poll' mode */
101
    int mouse_dy;
102
    int mouse_dz;
103
    uint8_t mouse_buttons;
104
} PS2MouseState;
105

    
106
/* Table to convert from PC scancodes to raw scancodes.  */
107
static const unsigned char ps2_raw_keycode[128] = {
108
          0,118, 22, 30, 38, 37, 46, 54, 61, 62, 70, 69, 78, 85,102, 13,
109
         21, 29, 36, 45, 44, 53, 60, 67, 68, 77, 84, 91, 90, 20, 28, 27,
110
         35, 43, 52, 51, 59, 66, 75, 76, 82, 14, 18, 93, 26, 34, 33, 42,
111
         50, 49, 58, 65, 73, 74, 89,124, 17, 41, 88,  5,  6,  4, 12,  3,
112
         11,  2, 10,  1,  9,119,126,108,117,125,123,107,115,116,121,105,
113
        114,122,112,113,127, 96, 97,120,  7, 15, 23, 31, 39, 47, 55, 63,
114
         71, 79, 86, 94,  8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 87,111,
115
         19, 25, 57, 81, 83, 92, 95, 98, 99,100,101,103,104,106,109,110
116
};
117

    
118
void ps2_queue(void *opaque, int b)
119
{
120
    PS2State *s = (PS2State *)opaque;
121
    PS2Queue *q = &s->queue;
122

    
123
    if (q->count >= PS2_QUEUE_SIZE)
124
        return;
125
    q->data[q->wptr] = b;
126
    if (++q->wptr == PS2_QUEUE_SIZE)
127
        q->wptr = 0;
128
    q->count++;
129
    s->update_irq(s->update_arg, 1);
130
}
131

    
132
static void ps2_put_keycode(void *opaque, int keycode)
133
{
134
    PS2KbdState *s = opaque;
135
    if (!s->translate && keycode < 0xe0)
136
      {
137
        if (keycode & 0x80)
138
            ps2_queue(&s->common, 0xf0);
139
        keycode = ps2_raw_keycode[keycode & 0x7f];
140
      }
141
    ps2_queue(&s->common, keycode);
142
}
143

    
144
uint32_t ps2_read_data(void *opaque)
145
{
146
    PS2State *s = (PS2State *)opaque;
147
    PS2Queue *q;
148
    int val, index;
149
    
150
    q = &s->queue;
151
    if (q->count == 0) {
152
        /* NOTE: if no data left, we return the last keyboard one
153
           (needed for EMM386) */
154
        /* XXX: need a timer to do things correctly */
155
        index = q->rptr - 1;
156
        if (index < 0)
157
            index = PS2_QUEUE_SIZE - 1;
158
        val = q->data[index];
159
    } else {
160
        val = q->data[q->rptr];
161
        if (++q->rptr == PS2_QUEUE_SIZE)
162
            q->rptr = 0;
163
        q->count--;
164
        /* reading deasserts IRQ */
165
        s->update_irq(s->update_arg, 0);
166
        /* reassert IRQs if data left */
167
        s->update_irq(s->update_arg, q->count != 0);
168
    }
169
    return val;
170
}
171

    
172
static void ps2_reset_keyboard(PS2KbdState *s)
173
{
174
    s->scan_enabled = 1;
175
}
176

    
177
void ps2_write_keyboard(void *opaque, int val)
178
{
179
    PS2KbdState *s = (PS2KbdState *)opaque;
180

    
181
    switch(s->common.write_cmd) {
182
    default:
183
    case -1:
184
        switch(val) {
185
        case 0x00:
186
            ps2_queue(&s->common, KBD_REPLY_ACK);
187
            break;
188
        case 0x05:
189
            ps2_queue(&s->common, KBD_REPLY_RESEND);
190
            break;
191
        case KBD_CMD_GET_ID:
192
            ps2_queue(&s->common, KBD_REPLY_ACK);
193
            ps2_queue(&s->common, 0xab);
194
            ps2_queue(&s->common, 0x83);
195
            break;
196
        case KBD_CMD_ECHO:
197
            ps2_queue(&s->common, KBD_CMD_ECHO);
198
            break;
199
        case KBD_CMD_ENABLE:
200
            s->scan_enabled = 1;
201
            ps2_queue(&s->common, KBD_REPLY_ACK);
202
            break;
203
        case KBD_CMD_SET_LEDS:
204
        case KBD_CMD_SET_RATE:
205
            s->common.write_cmd = val;
206
            ps2_queue(&s->common, KBD_REPLY_ACK);
207
            break;
208
        case KBD_CMD_RESET_DISABLE:
209
            ps2_reset_keyboard(s);
210
            s->scan_enabled = 0;
211
            ps2_queue(&s->common, KBD_REPLY_ACK);
212
            break;
213
        case KBD_CMD_RESET_ENABLE:
214
            ps2_reset_keyboard(s);
215
            s->scan_enabled = 1;
216
            ps2_queue(&s->common, KBD_REPLY_ACK);
217
            break;
218
        case KBD_CMD_RESET:
219
            ps2_reset_keyboard(s);
220
            ps2_queue(&s->common, KBD_REPLY_ACK);
221
            ps2_queue(&s->common, KBD_REPLY_POR);
222
            break;
223
        default:
224
            ps2_queue(&s->common, KBD_REPLY_ACK);
225
            break;
226
        }
227
        break;
228
    case KBD_CMD_SET_LEDS:
229
        ps2_queue(&s->common, KBD_REPLY_ACK);
230
        s->common.write_cmd = -1;
231
        break;
232
    case KBD_CMD_SET_RATE:
233
        ps2_queue(&s->common, KBD_REPLY_ACK);
234
        s->common.write_cmd = -1;
235
        break;
236
    }
237
}
238

    
239
/* Set the scancode translation mode.
240
   0 = raw scancodes.
241
   1 = translated scancodes (used by qemu internally).  */
242

    
243
void ps2_keyboard_set_translation(void *opaque, int mode)
244
{
245
    PS2KbdState *s = (PS2KbdState *)opaque;
246
    s->translate = mode;
247
}
248

    
249
static void ps2_mouse_send_packet(PS2MouseState *s)
250
{
251
    unsigned int b;
252
    int dx1, dy1, dz1;
253

    
254
    dx1 = s->mouse_dx;
255
    dy1 = s->mouse_dy;
256
    dz1 = s->mouse_dz;
257
    /* XXX: increase range to 8 bits ? */
258
    if (dx1 > 127)
259
        dx1 = 127;
260
    else if (dx1 < -127)
261
        dx1 = -127;
262
    if (dy1 > 127)
263
        dy1 = 127;
264
    else if (dy1 < -127)
265
        dy1 = -127;
266
    b = 0x08 | ((dx1 < 0) << 4) | ((dy1 < 0) << 5) | (s->mouse_buttons & 0x07);
267
    ps2_queue(&s->common, b);
268
    ps2_queue(&s->common, dx1 & 0xff);
269
    ps2_queue(&s->common, dy1 & 0xff);
270
    /* extra byte for IMPS/2 or IMEX */
271
    switch(s->mouse_type) {
272
    default:
273
        break;
274
    case 3:
275
        if (dz1 > 127)
276
            dz1 = 127;
277
        else if (dz1 < -127)
278
                dz1 = -127;
279
        ps2_queue(&s->common, dz1 & 0xff);
280
        break;
281
    case 4:
282
        if (dz1 > 7)
283
            dz1 = 7;
284
        else if (dz1 < -7)
285
            dz1 = -7;
286
        b = (dz1 & 0x0f) | ((s->mouse_buttons & 0x18) << 1);
287
        ps2_queue(&s->common, b);
288
        break;
289
    }
290

    
291
    /* update deltas */
292
    s->mouse_dx -= dx1;
293
    s->mouse_dy -= dy1;
294
    s->mouse_dz -= dz1;
295
}
296

    
297
static void ps2_mouse_event(void *opaque, 
298
                            int dx, int dy, int dz, int buttons_state)
299
{
300
    PS2MouseState *s = opaque;
301

    
302
    /* check if deltas are recorded when disabled */
303
    if (!(s->mouse_status & MOUSE_STATUS_ENABLED))
304
        return;
305

    
306
    s->mouse_dx += dx;
307
    s->mouse_dy -= dy;
308
    s->mouse_dz += dz;
309
    /* XXX: SDL sometimes generates nul events: we delete them */
310
    if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0 &&
311
        s->mouse_buttons == buttons_state)
312
        return;
313
    s->mouse_buttons = buttons_state;
314
    
315
    if (!(s->mouse_status & MOUSE_STATUS_REMOTE) &&
316
        (s->common.queue.count < (PS2_QUEUE_SIZE - 16))) {
317
        for(;;) {
318
            /* if not remote, send event. Multiple events are sent if
319
               too big deltas */
320
            ps2_mouse_send_packet(s);
321
            if (s->mouse_dx == 0 && s->mouse_dy == 0 && s->mouse_dz == 0)
322
                break;
323
        }
324
    }
325
}
326

    
327
void ps2_write_mouse(void *opaque, int val)
328
{
329
    PS2MouseState *s = (PS2MouseState *)opaque;
330
#ifdef DEBUG_MOUSE
331
    printf("kbd: write mouse 0x%02x\n", val);
332
#endif
333
    switch(s->common.write_cmd) {
334
    default:
335
    case -1:
336
        /* mouse command */
337
        if (s->mouse_wrap) {
338
            if (val == AUX_RESET_WRAP) {
339
                s->mouse_wrap = 0;
340
                ps2_queue(&s->common, AUX_ACK);
341
                return;
342
            } else if (val != AUX_RESET) {
343
                ps2_queue(&s->common, val);
344
                return;
345
            }
346
        }
347
        switch(val) {
348
        case AUX_SET_SCALE11:
349
            s->mouse_status &= ~MOUSE_STATUS_SCALE21;
350
            ps2_queue(&s->common, AUX_ACK);
351
            break;
352
        case AUX_SET_SCALE21:
353
            s->mouse_status |= MOUSE_STATUS_SCALE21;
354
            ps2_queue(&s->common, AUX_ACK);
355
            break;
356
        case AUX_SET_STREAM:
357
            s->mouse_status &= ~MOUSE_STATUS_REMOTE;
358
            ps2_queue(&s->common, AUX_ACK);
359
            break;
360
        case AUX_SET_WRAP:
361
            s->mouse_wrap = 1;
362
            ps2_queue(&s->common, AUX_ACK);
363
            break;
364
        case AUX_SET_REMOTE:
365
            s->mouse_status |= MOUSE_STATUS_REMOTE;
366
            ps2_queue(&s->common, AUX_ACK);
367
            break;
368
        case AUX_GET_TYPE:
369
            ps2_queue(&s->common, AUX_ACK);
370
            ps2_queue(&s->common, s->mouse_type);
371
            break;
372
        case AUX_SET_RES:
373
        case AUX_SET_SAMPLE:
374
            s->common.write_cmd = val;
375
            ps2_queue(&s->common, AUX_ACK);
376
            break;
377
        case AUX_GET_SCALE:
378
            ps2_queue(&s->common, AUX_ACK);
379
            ps2_queue(&s->common, s->mouse_status);
380
            ps2_queue(&s->common, s->mouse_resolution);
381
            ps2_queue(&s->common, s->mouse_sample_rate);
382
            break;
383
        case AUX_POLL:
384
            ps2_queue(&s->common, AUX_ACK);
385
            ps2_mouse_send_packet(s);
386
            break;
387
        case AUX_ENABLE_DEV:
388
            s->mouse_status |= MOUSE_STATUS_ENABLED;
389
            ps2_queue(&s->common, AUX_ACK);
390
            break;
391
        case AUX_DISABLE_DEV:
392
            s->mouse_status &= ~MOUSE_STATUS_ENABLED;
393
            ps2_queue(&s->common, AUX_ACK);
394
            break;
395
        case AUX_SET_DEFAULT:
396
            s->mouse_sample_rate = 100;
397
            s->mouse_resolution = 2;
398
            s->mouse_status = 0;
399
            ps2_queue(&s->common, AUX_ACK);
400
            break;
401
        case AUX_RESET:
402
            s->mouse_sample_rate = 100;
403
            s->mouse_resolution = 2;
404
            s->mouse_status = 0;
405
            s->mouse_type = 0;
406
            ps2_queue(&s->common, AUX_ACK);
407
            ps2_queue(&s->common, 0xaa);
408
            ps2_queue(&s->common, s->mouse_type);
409
            break;
410
        default:
411
            break;
412
        }
413
        break;
414
    case AUX_SET_SAMPLE:
415
        s->mouse_sample_rate = val;
416
        /* detect IMPS/2 or IMEX */
417
        switch(s->mouse_detect_state) {
418
        default:
419
        case 0:
420
            if (val == 200)
421
                s->mouse_detect_state = 1;
422
            break;
423
        case 1:
424
            if (val == 100)
425
                s->mouse_detect_state = 2;
426
            else if (val == 200)
427
                s->mouse_detect_state = 3;
428
            else
429
                s->mouse_detect_state = 0;
430
            break;
431
        case 2:
432
            if (val == 80) 
433
                s->mouse_type = 3; /* IMPS/2 */
434
            s->mouse_detect_state = 0;
435
            break;
436
        case 3:
437
            if (val == 80) 
438
                s->mouse_type = 4; /* IMEX */
439
            s->mouse_detect_state = 0;
440
            break;
441
        }
442
        ps2_queue(&s->common, AUX_ACK);
443
        s->common.write_cmd = -1;
444
        break;
445
    case AUX_SET_RES:
446
        s->mouse_resolution = val;
447
        ps2_queue(&s->common, AUX_ACK);
448
        s->common.write_cmd = -1;
449
        break;
450
    }
451
}
452

    
453
static void ps2_reset(void *opaque)
454
{
455
    PS2State *s = (PS2State *)opaque;
456
    PS2Queue *q;
457
    s->write_cmd = -1;
458
    q = &s->queue;
459
    q->rptr = 0;
460
    q->wptr = 0;
461
    q->count = 0;
462
}
463

    
464
static void ps2_common_save (QEMUFile *f, PS2State *s)
465
{
466
    qemu_put_be32s (f, &s->write_cmd);
467
    qemu_put_be32s (f, &s->queue.rptr);
468
    qemu_put_be32s (f, &s->queue.wptr);
469
    qemu_put_be32s (f, &s->queue.count);
470
    qemu_put_buffer (f, s->queue.data, sizeof (s->queue.data));
471
}
472

    
473
static void ps2_common_load (QEMUFile *f, PS2State *s)
474
{
475
    qemu_get_be32s (f, &s->write_cmd);
476
    qemu_get_be32s (f, &s->queue.rptr);
477
    qemu_get_be32s (f, &s->queue.wptr);
478
    qemu_get_be32s (f, &s->queue.count);
479
    qemu_get_buffer (f, s->queue.data, sizeof (s->queue.data));
480
}
481

    
482
static void ps2_kbd_save(QEMUFile* f, void* opaque)
483
{
484
    PS2KbdState *s = (PS2KbdState*)opaque;
485

    
486
    ps2_common_save (f, &s->common);
487
    qemu_put_be32s(f, &s->scan_enabled);
488
    qemu_put_be32s(f, &s->translate);
489
}
490

    
491
static void ps2_mouse_save(QEMUFile* f, void* opaque)
492
{
493
    PS2MouseState *s = (PS2MouseState*)opaque;
494

    
495
    ps2_common_save (f, &s->common);
496
    qemu_put_8s(f, &s->mouse_status);
497
    qemu_put_8s(f, &s->mouse_resolution);
498
    qemu_put_8s(f, &s->mouse_sample_rate);
499
    qemu_put_8s(f, &s->mouse_wrap);
500
    qemu_put_8s(f, &s->mouse_type);
501
    qemu_put_8s(f, &s->mouse_detect_state);
502
    qemu_put_be32s(f, &s->mouse_dx);
503
    qemu_put_be32s(f, &s->mouse_dy);
504
    qemu_put_be32s(f, &s->mouse_dz);
505
    qemu_put_8s(f, &s->mouse_buttons);
506
}
507

    
508
static int ps2_kbd_load(QEMUFile* f, void* opaque, int version_id)
509
{
510
    PS2KbdState *s = (PS2KbdState*)opaque;
511

    
512
    if (version_id != 2)
513
        return -EINVAL;
514

    
515
    ps2_common_load (f, &s->common);
516
    qemu_get_be32s(f, &s->scan_enabled);
517
    qemu_get_be32s(f, &s->translate);
518
    return 0;
519
}
520

    
521
static int ps2_mouse_load(QEMUFile* f, void* opaque, int version_id)
522
{
523
    PS2MouseState *s = (PS2MouseState*)opaque;
524

    
525
    if (version_id != 2)
526
        return -EINVAL;
527

    
528
    ps2_common_load (f, &s->common);
529
    qemu_get_8s(f, &s->mouse_status);
530
    qemu_get_8s(f, &s->mouse_resolution);
531
    qemu_get_8s(f, &s->mouse_sample_rate);
532
    qemu_get_8s(f, &s->mouse_wrap);
533
    qemu_get_8s(f, &s->mouse_type);
534
    qemu_get_8s(f, &s->mouse_detect_state);
535
    qemu_get_be32s(f, &s->mouse_dx);
536
    qemu_get_be32s(f, &s->mouse_dy);
537
    qemu_get_be32s(f, &s->mouse_dz);
538
    qemu_get_8s(f, &s->mouse_buttons);
539
    return 0;
540
}
541

    
542
void *ps2_kbd_init(void (*update_irq)(void *, int), void *update_arg)
543
{
544
    PS2KbdState *s = (PS2KbdState *)qemu_mallocz(sizeof(PS2KbdState));
545

    
546
    s->common.update_irq = update_irq;
547
    s->common.update_arg = update_arg;
548
    ps2_reset(&s->common);
549
    register_savevm("ps2kbd", 0, 2, ps2_kbd_save, ps2_kbd_load, s);
550
    qemu_add_kbd_event_handler(ps2_put_keycode, s);
551
    qemu_register_reset(ps2_reset, &s->common);
552
    return s;
553
}
554

    
555
void *ps2_mouse_init(void (*update_irq)(void *, int), void *update_arg)
556
{
557
    PS2MouseState *s = (PS2MouseState *)qemu_mallocz(sizeof(PS2MouseState));
558

    
559
    s->common.update_irq = update_irq;
560
    s->common.update_arg = update_arg;
561
    ps2_reset(&s->common);
562
    register_savevm("ps2mouse", 0, 2, ps2_mouse_save, ps2_mouse_load, s);
563
    qemu_add_mouse_event_handler(ps2_mouse_event, s, 0, "QEMU PS/2 Mouse");
564
    qemu_register_reset(ps2_reset, &s->common);
565
    return s;
566
}