← Back to branch summary

~ahs3/+junk/cq-qemu

« back to all changes in this revision

Viewing changes to hw/hid.c

  • Committer: Al Stone
  • Date: 2012-02-09 01:17:20 UTC
  • Revision ID: albert.stone@canonical.com-20120209011720-tztl7ik3qayz80p4
first commit to bzr for qemu

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/hid.c
 
1
/*
 
2
 * QEMU HID devices
 
3
 *
 
4
 * Copyright (c) 2005 Fabrice Bellard
 
5
 * Copyright (c) 2007 OpenMoko, Inc.  (andrew@openedhand.com)
 
6
 *
 
7
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
8
 * of this software and associated documentation files (the "Software"), to deal
 
9
 * in the Software without restriction, including without limitation the rights
 
10
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
11
 * copies of the Software, and to permit persons to whom the Software is
 
12
 * furnished to do so, subject to the following conditions:
 
13
 *
 
14
 * The above copyright notice and this permission notice shall be included in
 
15
 * all copies or substantial portions of the Software.
 
16
 *
 
17
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
18
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
19
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
20
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
21
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
22
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
23
 * THE SOFTWARE.
 
24
 */
 
25
#include "hw.h"
 
26
#include "console.h"
 
27
#include "qemu-timer.h"
 
28
#include "hid.h"
 
29
 
 
30
#define HID_USAGE_ERROR_ROLLOVER        0x01
 
31
#define HID_USAGE_POSTFAIL              0x02
 
32
#define HID_USAGE_ERROR_UNDEFINED       0x03
 
33
 
 
34
/* Indices are QEMU keycodes, values are from HID Usage Table.  Indices
 
35
 * above 0x80 are for keys that come after 0xe0 or 0xe1+0x1d or 0xe1+0x9d.  */
 
36
static const uint8_t hid_usage_keys[0x100] = {
 
37
    0x00, 0x29, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
 
38
    0x24, 0x25, 0x26, 0x27, 0x2d, 0x2e, 0x2a, 0x2b,
 
39
    0x14, 0x1a, 0x08, 0x15, 0x17, 0x1c, 0x18, 0x0c,
 
40
    0x12, 0x13, 0x2f, 0x30, 0x28, 0xe0, 0x04, 0x16,
 
41
    0x07, 0x09, 0x0a, 0x0b, 0x0d, 0x0e, 0x0f, 0x33,
 
42
    0x34, 0x35, 0xe1, 0x31, 0x1d, 0x1b, 0x06, 0x19,
 
43
    0x05, 0x11, 0x10, 0x36, 0x37, 0x38, 0xe5, 0x55,
 
44
    0xe2, 0x2c, 0x32, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
 
45
    0x3f, 0x40, 0x41, 0x42, 0x43, 0x53, 0x47, 0x5f,
 
46
    0x60, 0x61, 0x56, 0x5c, 0x5d, 0x5e, 0x57, 0x59,
 
47
    0x5a, 0x5b, 0x62, 0x63, 0x00, 0x00, 0x00, 0x44,
 
48
    0x45, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e,
 
49
    0xe8, 0xe9, 0x71, 0x72, 0x73, 0x00, 0x00, 0x00,
 
50
    0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00,
 
51
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
52
    0x00, 0x00, 0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65,
 
53
 
 
54
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
55
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
56
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
57
    0x00, 0x00, 0x00, 0x00, 0x58, 0xe4, 0x00, 0x00,
 
58
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
59
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
60
    0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x00, 0x46,
 
61
    0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
62
    0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4a,
 
63
    0x52, 0x4b, 0x00, 0x50, 0x00, 0x4f, 0x00, 0x4d,
 
64
    0x51, 0x4e, 0x49, 0x4c, 0x00, 0x00, 0x00, 0x00,
 
65
    0x00, 0x00, 0x00, 0xe3, 0xe7, 0x65, 0x00, 0x00,
 
66
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
67
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
68
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
69
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
70
};
 
71
 
 
72
bool hid_has_events(HIDState *hs)
 
73
{
 
74
    return hs->n > 0;
 
75
}
 
76
 
 
77
void hid_set_next_idle(HIDState *hs, int64_t curtime)
 
78
{
 
79
    hs->next_idle_clock = curtime + (get_ticks_per_sec() * hs->idle * 4) / 1000;
 
80
}
 
81
 
 
82
static void hid_pointer_event_clear(HIDPointerEvent *e, int buttons)
 
83
{
 
84
    e->xdx = e->ydy = e->dz = 0;
 
85
    e->buttons_state = buttons;
 
86
}
 
87
 
 
88
static void hid_pointer_event_combine(HIDPointerEvent *e, int xyrel,
 
89
                                      int x1, int y1, int z1) {
 
90
    if (xyrel) {
 
91
        e->xdx += x1;
 
92
        e->ydy += y1;
 
93
    } else {
 
94
        e->xdx = x1;
 
95
        e->ydy = y1;
 
96
        /* Windows drivers do not like the 0/0 position and ignore such
 
97
         * events. */
 
98
        if (!(x1 | y1)) {
 
99
            e->xdx = 1;
 
100
        }
 
101
    }
 
102
    e->dz += z1;
 
103
}
 
104
 
 
105
static void hid_pointer_event(void *opaque,
 
106
                              int x1, int y1, int z1, int buttons_state)
 
107
{
 
108
    HIDState *hs = opaque;
 
109
    unsigned use_slot = (hs->head + hs->n - 1) & QUEUE_MASK;
 
110
    unsigned previous_slot = (use_slot - 1) & QUEUE_MASK;
 
111
 
 
112
    /* We combine events where feasible to keep the queue small.  We shouldn't
 
113
     * combine anything with the first event of a particular button state, as
 
114
     * that would change the location of the button state change.  When the
 
115
     * queue is empty, a second event is needed because we don't know if
 
116
     * the first event changed the button state.  */
 
117
    if (hs->n == QUEUE_LENGTH) {
 
118
        /* Queue full.  Discard old button state, combine motion normally.  */
 
119
        hs->ptr.queue[use_slot].buttons_state = buttons_state;
 
120
    } else if (hs->n < 2 ||
 
121
               hs->ptr.queue[use_slot].buttons_state != buttons_state ||
 
122
               hs->ptr.queue[previous_slot].buttons_state !=
 
123
               hs->ptr.queue[use_slot].buttons_state) {
 
124
        /* Cannot or should not combine, so add an empty item to the queue.  */
 
125
        QUEUE_INCR(use_slot);
 
126
        hs->n++;
 
127
        hid_pointer_event_clear(&hs->ptr.queue[use_slot], buttons_state);
 
128
    }
 
129
    hid_pointer_event_combine(&hs->ptr.queue[use_slot],
 
130
                              hs->kind == HID_MOUSE,
 
131
                              x1, y1, z1);
 
132
    hs->event(hs);
 
133
}
 
134
 
 
135
static void hid_keyboard_event(void *opaque, int keycode)
 
136
{
 
137
    HIDState *hs = opaque;
 
138
    int slot;
 
139
 
 
140
    if (hs->n == QUEUE_LENGTH) {
 
141
        fprintf(stderr, "usb-kbd: warning: key event queue full\n");
 
142
        return;
 
143
    }
 
144
    slot = (hs->head + hs->n) & QUEUE_MASK; hs->n++;
 
145
    hs->kbd.keycodes[slot] = keycode;
 
146
    hs->event(hs);
 
147
}
 
148
 
 
149
static void hid_keyboard_process_keycode(HIDState *hs)
 
150
{
 
151
    uint8_t hid_code, key;
 
152
    int i, keycode, slot;
 
153
 
 
154
    if (hs->n == 0) {
 
155
        return;
 
156
    }
 
157
    slot = hs->head & QUEUE_MASK; QUEUE_INCR(hs->head); hs->n--;
 
158
    keycode = hs->kbd.keycodes[slot];
 
159
 
 
160
    key = keycode & 0x7f;
 
161
    hid_code = hid_usage_keys[key | ((hs->kbd.modifiers >> 1) & (1 << 7))];
 
162
    hs->kbd.modifiers &= ~(1 << 8);
 
163
 
 
164
    switch (hid_code) {
 
165
    case 0x00:
 
166
        return;
 
167
 
 
168
    case 0xe0:
 
169
        if (hs->kbd.modifiers & (1 << 9)) {
 
170
            hs->kbd.modifiers ^= 3 << 8;
 
171
            return;
 
172
        }
 
173
    case 0xe1 ... 0xe7:
 
174
        if (keycode & (1 << 7)) {
 
175
            hs->kbd.modifiers &= ~(1 << (hid_code & 0x0f));
 
176
            return;
 
177
        }
 
178
    case 0xe8 ... 0xef:
 
179
        hs->kbd.modifiers |= 1 << (hid_code & 0x0f);
 
180
        return;
 
181
    }
 
182
 
 
183
    if (keycode & (1 << 7)) {
 
184
        for (i = hs->kbd.keys - 1; i >= 0; i--) {
 
185
            if (hs->kbd.key[i] == hid_code) {
 
186
                hs->kbd.key[i] = hs->kbd.key[-- hs->kbd.keys];
 
187
                hs->kbd.key[hs->kbd.keys] = 0x00;
 
188
                break;
 
189
            }
 
190
        }
 
191
        if (i < 0) {
 
192
            return;
 
193
        }
 
194
    } else {
 
195
        for (i = hs->kbd.keys - 1; i >= 0; i--) {
 
196
            if (hs->kbd.key[i] == hid_code) {
 
197
                break;
 
198
            }
 
199
        }
 
200
        if (i < 0) {
 
201
            if (hs->kbd.keys < sizeof(hs->kbd.key)) {
 
202
                hs->kbd.key[hs->kbd.keys++] = hid_code;
 
203
            }
 
204
        } else {
 
205
            return;
 
206
        }
 
207
    }
 
208
}
 
209
 
 
210
static inline int int_clamp(int val, int vmin, int vmax)
 
211
{
 
212
    if (val < vmin) {
 
213
        return vmin;
 
214
    } else if (val > vmax) {
 
215
        return vmax;
 
216
    } else {
 
217
        return val;
 
218
    }
 
219
}
 
220
 
 
221
void hid_pointer_activate(HIDState *hs)
 
222
{
 
223
    if (!hs->ptr.mouse_grabbed) {
 
224
        qemu_activate_mouse_event_handler(hs->ptr.eh_entry);
 
225
        hs->ptr.mouse_grabbed = 1;
 
226
    }
 
227
}
 
228
 
 
229
int hid_pointer_poll(HIDState *hs, uint8_t *buf, int len)
 
230
{
 
231
    int dx, dy, dz, b, l;
 
232
    int index;
 
233
    HIDPointerEvent *e;
 
234
 
 
235
    hid_pointer_activate(hs);
 
236
 
 
237
    /* When the buffer is empty, return the last event.  Relative
 
238
       movements will all be zero.  */
 
239
    index = (hs->n ? hs->head : hs->head - 1);
 
240
    e = &hs->ptr.queue[index & QUEUE_MASK];
 
241
 
 
242
    if (hs->kind == HID_MOUSE) {
 
243
        dx = int_clamp(e->xdx, -127, 127);
 
244
        dy = int_clamp(e->ydy, -127, 127);
 
245
        e->xdx -= dx;
 
246
        e->ydy -= dy;
 
247
    } else {
 
248
        dx = e->xdx;
 
249
        dy = e->ydy;
 
250
    }
 
251
    dz = int_clamp(e->dz, -127, 127);
 
252
    e->dz -= dz;
 
253
 
 
254
    b = 0;
 
255
    if (e->buttons_state & MOUSE_EVENT_LBUTTON) {
 
256
        b |= 0x01;
 
257
    }
 
258
    if (e->buttons_state & MOUSE_EVENT_RBUTTON) {
 
259
        b |= 0x02;
 
260
    }
 
261
    if (e->buttons_state & MOUSE_EVENT_MBUTTON) {
 
262
        b |= 0x04;
 
263
    }
 
264
 
 
265
    if (hs->n &&
 
266
        !e->dz &&
 
267
        (hs->kind == HID_TABLET || (!e->xdx && !e->ydy))) {
 
268
        /* that deals with this event */
 
269
        QUEUE_INCR(hs->head);
 
270
        hs->n--;
 
271
    }
 
272
 
 
273
    /* Appears we have to invert the wheel direction */
 
274
    dz = 0 - dz;
 
275
    l = 0;
 
276
    switch (hs->kind) {
 
277
    case HID_MOUSE:
 
278
        if (len > l) {
 
279
            buf[l++] = b;
 
280
        }
 
281
        if (len > l) {
 
282
            buf[l++] = dx;
 
283
        }
 
284
        if (len > l) {
 
285
            buf[l++] = dy;
 
286
        }
 
287
        if (len > l) {
 
288
            buf[l++] = dz;
 
289
        }
 
290
        break;
 
291
 
 
292
    case HID_TABLET:
 
293
        if (len > l) {
 
294
            buf[l++] = b;
 
295
        }
 
296
        if (len > l) {
 
297
            buf[l++] = dx & 0xff;
 
298
        }
 
299
        if (len > l) {
 
300
            buf[l++] = dx >> 8;
 
301
        }
 
302
        if (len > l) {
 
303
            buf[l++] = dy & 0xff;
 
304
        }
 
305
        if (len > l) {
 
306
            buf[l++] = dy >> 8;
 
307
        }
 
308
        if (len > l) {
 
309
            buf[l++] = dz;
 
310
        }
 
311
        break;
 
312
 
 
313
    default:
 
314
        abort();
 
315
    }
 
316
 
 
317
    return l;
 
318
}
 
319
 
 
320
int hid_keyboard_poll(HIDState *hs, uint8_t *buf, int len)
 
321
{
 
322
    if (len < 2) {
 
323
        return 0;
 
324
    }
 
325
 
 
326
    hid_keyboard_process_keycode(hs);
 
327
 
 
328
    buf[0] = hs->kbd.modifiers & 0xff;
 
329
    buf[1] = 0;
 
330
    if (hs->kbd.keys > 6) {
 
331
        memset(buf + 2, HID_USAGE_ERROR_ROLLOVER, MIN(8, len) - 2);
 
332
    } else {
 
333
        memcpy(buf + 2, hs->kbd.key, MIN(8, len) - 2);
 
334
    }
 
335
 
 
336
    return MIN(8, len);
 
337
}
 
338
 
 
339
int hid_keyboard_write(HIDState *hs, uint8_t *buf, int len)
 
340
{
 
341
    if (len > 0) {
 
342
        int ledstate = 0;
 
343
        /* 0x01: Num Lock LED
 
344
         * 0x02: Caps Lock LED
 
345
         * 0x04: Scroll Lock LED
 
346
         * 0x08: Compose LED
 
347
         * 0x10: Kana LED */
 
348
        hs->kbd.leds = buf[0];
 
349
        if (hs->kbd.leds & 0x04) {
 
350
            ledstate |= QEMU_SCROLL_LOCK_LED;
 
351
        }
 
352
        if (hs->kbd.leds & 0x01) {
 
353
            ledstate |= QEMU_NUM_LOCK_LED;
 
354
        }
 
355
        if (hs->kbd.leds & 0x02) {
 
356
            ledstate |= QEMU_CAPS_LOCK_LED;
 
357
        }
 
358
        kbd_put_ledstate(ledstate);
 
359
    }
 
360
    return 0;
 
361
}
 
362
 
 
363
void hid_reset(HIDState *hs)
 
364
{
 
365
    switch (hs->kind) {
 
366
    case HID_KEYBOARD:
 
367
        memset(hs->kbd.keycodes, 0, sizeof(hs->kbd.keycodes));
 
368
        memset(hs->kbd.key, 0, sizeof(hs->kbd.key));
 
369
        hs->kbd.keys = 0;
 
370
        break;
 
371
    case HID_MOUSE:
 
372
    case HID_TABLET:
 
373
        memset(hs->ptr.queue, 0, sizeof(hs->ptr.queue));
 
374
        break;
 
375
    }
 
376
    hs->head = 0;
 
377
    hs->n = 0;
 
378
    hs->protocol = 1;
 
379
    hs->idle = 0;
 
380
}
 
381
 
 
382
void hid_free(HIDState *hs)
 
383
{
 
384
    switch (hs->kind) {
 
385
    case HID_KEYBOARD:
 
386
        qemu_remove_kbd_event_handler();
 
387
        break;
 
388
    case HID_MOUSE:
 
389
    case HID_TABLET:
 
390
        qemu_remove_mouse_event_handler(hs->ptr.eh_entry);
 
391
        break;
 
392
    }
 
393
}
 
394
 
 
395
void hid_init(HIDState *hs, int kind, HIDEventFunc event)
 
396
{
 
397
    hs->kind = kind;
 
398
    hs->event = event;
 
399
 
 
400
    if (hs->kind == HID_KEYBOARD) {
 
401
        qemu_add_kbd_event_handler(hid_keyboard_event, hs);
 
402
    } else if (hs->kind == HID_MOUSE) {
 
403
        hs->ptr.eh_entry = qemu_add_mouse_event_handler(hid_pointer_event, hs,
 
404
                                                        0, "QEMU HID Mouse");
 
405
    } else if (hs->kind == HID_TABLET) {
 
406
        hs->ptr.eh_entry = qemu_add_mouse_event_handler(hid_pointer_event, hs,
 
407
                                                        1, "QEMU HID Tablet");
 
408
    }
 
409
}
 
410
 
 
411
static int hid_post_load(void *opaque, int version_id)
 
412
{
 
413
    HIDState *s = opaque;
 
414
 
 
415
    if (s->idle) {
 
416
        hid_set_next_idle(s, qemu_get_clock_ns(vm_clock));
 
417
    }
 
418
    return 0;
 
419
}
 
420
 
 
421
static const VMStateDescription vmstate_hid_ptr_queue = {
 
422
    .name = "HIDPointerEventQueue",
 
423
    .version_id = 1,
 
424
    .minimum_version_id = 1,
 
425
    .fields = (VMStateField[]) {
 
426
        VMSTATE_INT32(xdx, HIDPointerEvent),
 
427
        VMSTATE_INT32(ydy, HIDPointerEvent),
 
428
        VMSTATE_INT32(dz, HIDPointerEvent),
 
429
        VMSTATE_INT32(buttons_state, HIDPointerEvent),
 
430
        VMSTATE_END_OF_LIST()
 
431
    }
 
432
};
 
433
 
 
434
const VMStateDescription vmstate_hid_ptr_device = {
 
435
    .name = "HIDPointerDevice",
 
436
    .version_id = 1,
 
437
    .minimum_version_id = 1,
 
438
    .post_load = hid_post_load,
 
439
    .fields = (VMStateField[]) {
 
440
        VMSTATE_STRUCT_ARRAY(ptr.queue, HIDState, QUEUE_LENGTH, 0,
 
441
                             vmstate_hid_ptr_queue, HIDPointerEvent),
 
442
        VMSTATE_UINT32(head, HIDState),
 
443
        VMSTATE_UINT32(n, HIDState),
 
444
        VMSTATE_INT32(protocol, HIDState),
 
445
        VMSTATE_UINT8(idle, HIDState),
 
446
        VMSTATE_END_OF_LIST(),
 
447
    }
 
448
};
 
449
 
 
450
const VMStateDescription vmstate_hid_keyboard_device = {
 
451
    .name = "HIDKeyboardDevice",
 
452
    .version_id = 1,
 
453
    .minimum_version_id = 1,
 
454
    .post_load = hid_post_load,
 
455
    .fields = (VMStateField[]) {
 
456
        VMSTATE_UINT32_ARRAY(kbd.keycodes, HIDState, QUEUE_LENGTH),
 
457
        VMSTATE_UINT32(head, HIDState),
 
458
        VMSTATE_UINT32(n, HIDState),
 
459
        VMSTATE_UINT16(kbd.modifiers, HIDState),
 
460
        VMSTATE_UINT8(kbd.leds, HIDState),
 
461
        VMSTATE_UINT8_ARRAY(kbd.key, HIDState, 16),
 
462
        VMSTATE_INT32(kbd.keys, HIDState),
 
463
        VMSTATE_INT32(protocol, HIDState),
 
464
        VMSTATE_UINT8(idle, HIDState),
 
465
        VMSTATE_END_OF_LIST(),
 
466
    }
 
467
};