goldfish_events_device.c revision cccd28ca5064a7bd14282cd774ee5bb7126d5845 
1/* Copyright (C) 2007-2008 The Android Open Source Project
2**
3** This software is licensed under the terms of the GNU General Public
4** License version 2, as published by the Free Software Foundation, and
5** may be copied, distributed, and modified under those terms.
6**
7** This program is distributed in the hope that it will be useful,
8** but WITHOUT ANY WARRANTY; without even the implied warranty of
9** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10** GNU General Public License for more details.
11*/
12#include "qemu_file.h"
13#include "android/hw-events.h"
14#include "android/charmap.h"
15#include "android/globals.h"  /* for android_hw */
16#include "irq.h"
17#include "user-events.h"
18#include "console.h"
19
20#define MAX_EVENTS 256*4
21
22enum {
23    REG_READ        = 0x00,
24    REG_SET_PAGE    = 0x00,
25    REG_LEN         = 0x04,
26    REG_DATA        = 0x08,
27
28    PAGE_NAME       = 0x00000,
29    PAGE_EVBITS     = 0x10000,
30    PAGE_ABSDATA    = 0x20000 | EV_ABS,
31};
32
33/* These corresponds to the state of the driver.
34 * Unfortunately, we have to buffer events coming
35 * from the UI, since the kernel driver is not
36 * capable of receiving them until XXXXXX
37 */
38enum {
39    STATE_INIT = 0,  /* The device is initialized */
40    STATE_BUFFERED,  /* Events have been buffered, but no IRQ raised yet */
41    STATE_LIVE       /* Events can be sent directly to the kernel */
42};
43
44/* NOTE: The ev_bits arrays are used to indicate to the kernel
45 *       which events can be sent by the emulated hardware.
46 */
47
48typedef struct
49{
50    uint32_t base;
51    qemu_irq  irq;
52    int pending;
53    int page;
54
55    unsigned events[MAX_EVENTS];
56    unsigned first;
57    unsigned last;
58    unsigned state;
59
60    const char *name;
61
62    struct {
63        size_t   len;
64        uint8_t *bits;
65    } ev_bits[EV_MAX + 1];
66
67    int32_t *abs_info;
68    size_t abs_info_count;
69} events_state;
70
71/* modify this each time you change the events_device structure. you
72 * will also need to upadte events_state_load and events_state_save
73 */
74#define  EVENTS_STATE_SAVE_VERSION  2
75
76#undef  QFIELD_STRUCT
77#define QFIELD_STRUCT  events_state
78
79QFIELD_BEGIN(events_state_fields)
80    QFIELD_INT32(pending),
81    QFIELD_INT32(page),
82    QFIELD_BUFFER(events),
83    QFIELD_INT32(first),
84    QFIELD_INT32(last),
85    QFIELD_INT32(state),
86QFIELD_END
87
88static void  events_state_save(QEMUFile*  f, void*  opaque)
89{
90    events_state*  s = opaque;
91
92    qemu_put_struct(f, events_state_fields, s);
93}
94
95static int  events_state_load(QEMUFile*  f, void* opaque, int  version_id)
96{
97    events_state*  s = opaque;
98
99    if (version_id != EVENTS_STATE_SAVE_VERSION)
100        return -1;
101
102    return qemu_get_struct(f, events_state_fields, s);
103}
104
105extern const char*  android_skin_keycharmap;
106
107static void enqueue_event(events_state *s, unsigned int type, unsigned int code, int value)
108{
109    int  enqueued = s->last - s->first;
110
111    if (enqueued < 0)
112        enqueued += MAX_EVENTS;
113
114    if (enqueued + 3 > MAX_EVENTS) {
115        fprintf(stderr, "##KBD: Full queue, lose event\n");
116        return;
117    }
118
119    if(s->first == s->last) {
120	if (s->state == STATE_LIVE)
121	  qemu_irq_raise(s->irq);
122	else {
123	  s->state = STATE_BUFFERED;
124	}
125    }
126
127    //fprintf(stderr, "##KBD: type=%d code=%d value=%d\n", type, code, value);
128
129    s->events[s->last] = type;
130    s->last = (s->last + 1) & (MAX_EVENTS-1);
131    s->events[s->last] = code;
132    s->last = (s->last + 1) & (MAX_EVENTS-1);
133    s->events[s->last] = value;
134    s->last = (s->last + 1) & (MAX_EVENTS-1);
135}
136
137static unsigned dequeue_event(events_state *s)
138{
139    unsigned n;
140
141    if(s->first == s->last) {
142        return 0;
143    }
144
145    n = s->events[s->first];
146
147    s->first = (s->first + 1) & (MAX_EVENTS - 1);
148
149    if(s->first == s->last) {
150        qemu_irq_lower(s->irq);
151    }
152#ifdef TARGET_I386
153    /*
154     * Adding the logic to handle edge-triggered interrupts for x86
155     * because the exisiting goldfish events device basically provides
156     * level-trigger interrupts only.
157     *
158     * Logic: When an event (including the type/code/value) is fetched
159     * by the driver, if there is still another event in the event
160     * queue, the goldfish event device will re-assert the IRQ so that
161     * the driver can be notified to fetch the event again.
162     */
163    else if (((s->first + 2) & (MAX_EVENTS - 1)) < s->last ||
164               (s->first & (MAX_EVENTS - 1)) > s->last) { /* if there still is an event */
165        qemu_irq_lower(s->irq);
166        qemu_irq_raise(s->irq);
167    }
168#endif
169    return n;
170}
171
172static const char*
173get_charmap_name(events_state *s)
174{
175    if (s->name != NULL)
176        return s->name;
177
178    s->name = android_get_charmap_name();
179    return s->name;
180}
181
182
183static int get_page_len(events_state *s)
184{
185    int page = s->page;
186    if (page == PAGE_NAME) {
187        const char* name = get_charmap_name(s);
188        return strlen(name);
189    } if (page >= PAGE_EVBITS && page <= PAGE_EVBITS + EV_MAX)
190        return s->ev_bits[page - PAGE_EVBITS].len;
191    if (page == PAGE_ABSDATA)
192        return s->abs_info_count * sizeof(s->abs_info[0]);
193    return 0;
194}
195
196static int get_page_data(events_state *s, int offset)
197{
198    int page_len = get_page_len(s);
199    int page = s->page;
200    if (offset > page_len)
201        return 0;
202    if (page == PAGE_NAME) {
203        const char* name = get_charmap_name(s);
204        return name[offset];
205    } if (page >= PAGE_EVBITS && page <= PAGE_EVBITS + EV_MAX)
206        return s->ev_bits[page - PAGE_EVBITS].bits[offset];
207    if (page == PAGE_ABSDATA) {
208        return s->abs_info[offset / sizeof(s->abs_info[0])];
209    }
210    return 0;
211}
212
213static uint32_t events_read(void *x, target_phys_addr_t off)
214{
215    events_state *s = (events_state *) x;
216    int offset = off; // - s->base;
217
218    /* This gross hack below is used to ensure that we
219     * only raise the IRQ when the kernel driver is
220     * properly ready! If done before this, the driver
221     * becomes confused and ignores all input events
222     * as soon as one was buffered!
223     */
224    if (offset == REG_LEN && s->page == PAGE_ABSDATA) {
225	if (s->state == STATE_BUFFERED)
226	  qemu_irq_raise(s->irq);
227	s->state = STATE_LIVE;
228    }
229
230    if (offset == REG_READ)
231        return dequeue_event(s);
232    else if (offset == REG_LEN)
233        return get_page_len(s);
234    else if (offset >= REG_DATA)
235        return get_page_data(s, offset - REG_DATA);
236    return 0; // this shouldn't happen, if the driver does the right thing
237}
238
239static void events_write(void *x, target_phys_addr_t off, uint32_t val)
240{
241    events_state *s = (events_state *) x;
242    int offset = off; // - s->base;
243    if (offset == REG_SET_PAGE)
244        s->page = val;
245}
246
247static CPUReadMemoryFunc *events_readfn[] = {
248   events_read,
249   events_read,
250   events_read
251};
252
253static CPUWriteMemoryFunc *events_writefn[] = {
254   events_write,
255   events_write,
256   events_write
257};
258
259static void events_put_keycode(void *x, int keycode)
260{
261    events_state *s = (events_state *) x;
262
263    enqueue_event(s, EV_KEY, keycode&0x1ff, (keycode&0x200) ? 1 : 0);
264}
265
266static void events_put_mouse(void *opaque, int dx, int dy, int dz, int buttons_state)
267{
268    events_state *s = (events_state *) opaque;
269    /* in the Android emulator, we use dz == 0 for touchscreen events,
270     * and dz == 1 for trackball events. See the kbd_mouse_event calls
271     * in android/skin/trackball.c and android/skin/window.c
272     */
273    if (dz == 0) {
274        enqueue_event(s, EV_ABS, ABS_X, dx);
275        enqueue_event(s, EV_ABS, ABS_Y, dy);
276        enqueue_event(s, EV_ABS, ABS_Z, dz);
277        enqueue_event(s, EV_KEY, BTN_TOUCH, buttons_state&1);
278    } else {
279        enqueue_event(s, EV_REL, REL_X, dx);
280        enqueue_event(s, EV_REL, REL_Y, dy);
281    }
282    enqueue_event(s, EV_SYN, 0, 0);
283}
284
285static void  events_put_generic(void*  opaque, int  type, int  code, int  value)
286{
287   events_state *s = (events_state *) opaque;
288
289    enqueue_event(s, type, code, value);
290}
291
292/* set bits [bitl..bith] in the ev_bits[type] array
293 */
294static void
295events_set_bits(events_state *s, int type, int bitl, int bith)
296{
297    uint8_t *bits;
298    uint8_t maskl, maskh;
299    int il, ih;
300    il = bitl / 8;
301    ih = bith / 8;
302    if (ih >= s->ev_bits[type].len) {
303        bits = qemu_mallocz(ih + 1);
304        if (bits == NULL)
305            return;
306        memcpy(bits, s->ev_bits[type].bits, s->ev_bits[type].len);
307        qemu_free(s->ev_bits[type].bits);
308        s->ev_bits[type].bits = bits;
309        s->ev_bits[type].len = ih + 1;
310    }
311    else
312        bits = s->ev_bits[type].bits;
313    maskl = 0xffU << (bitl & 7);
314    maskh = 0xffU >> (7 - (bith & 7));
315    if (il >= ih)
316        maskh &= maskl;
317    else {
318        bits[il] |= maskl;
319        while (++il < ih)
320            bits[il] = 0xff;
321    }
322    bits[ih] |= maskh;
323}
324
325static void
326events_set_bit(events_state* s, int  type, int  bit)
327{
328    events_set_bits(s, type, bit, bit);
329}
330
331static void
332events_clr_bit(events_state* s, int type, int bit)
333{
334    int ii = bit / 8;
335    if (ii < s->ev_bits[type].len) {
336        uint8_t* bits = s->ev_bits[type].bits;
337        uint8_t  mask = 0x01U << (bit & 7);
338        bits[ii] &= ~mask;
339    }
340}
341
342void events_dev_init(uint32_t base, qemu_irq irq)
343{
344    events_state *s;
345    int iomemtype;
346    AndroidHwConfig*  config = android_hw;
347
348    s = (events_state *) qemu_mallocz(sizeof(events_state));
349
350    // charmap name will be determined on demand
351    s->name = NULL;
352
353    /* now set the events capability bits depending on hardware configuration */
354    /* apparently, the EV_SYN array is used to indicate which other
355     * event classes to consider.
356     */
357
358    /* configure EV_KEY array
359     *
360     * All Android devices must have the following keys:
361     *   KEY_HOME, KEY_BACK, KEY_SEND (Call), KEY_END (EndCall),
362     *   KEY_SOFT1 (Menu), VOLUME_UP, VOLUME_DOWN
363     *
364     *   Note that previous models also had a KEY_SOFT2,
365     *   and a KEY_POWER  which we still support here.
366     *
367     *   Newer models have a KEY_SEARCH key, which we always
368     *   enable here.
369     *
370     * A Dpad will send: KEY_DOWN / UP / LEFT / RIGHT / CENTER
371     *
372     * The KEY_CAMERA button isn't very useful if there is no camera.
373     *
374     * BTN_MOUSE is sent when the trackball is pressed
375     * BTN_TOUCH is sent when the touchscreen is pressed
376     */
377    events_set_bit (s, EV_SYN, EV_KEY );
378
379    events_set_bit(s, EV_KEY, KEY_HOME);
380    events_set_bit(s, EV_KEY, KEY_BACK);
381    events_set_bit(s, EV_KEY, KEY_SEND);
382    events_set_bit(s, EV_KEY, KEY_END);
383    events_set_bit(s, EV_KEY, KEY_SOFT1);
384    events_set_bit(s, EV_KEY, KEY_VOLUMEUP);
385    events_set_bit(s, EV_KEY, KEY_VOLUMEDOWN);
386    events_set_bit(s, EV_KEY, KEY_SOFT2);
387    events_set_bit(s, EV_KEY, KEY_POWER);
388    events_set_bit(s, EV_KEY, KEY_SEARCH);
389
390    if (config->hw_dPad) {
391        events_set_bit(s, EV_KEY, KEY_DOWN);
392        events_set_bit(s, EV_KEY, KEY_UP);
393        events_set_bit(s, EV_KEY, KEY_LEFT);
394        events_set_bit(s, EV_KEY, KEY_RIGHT);
395        events_set_bit(s, EV_KEY, KEY_CENTER);
396    }
397
398    if (config->hw_trackBall) {
399        events_set_bit(s, EV_KEY, BTN_MOUSE);
400    }
401    if (config->hw_touchScreen) {
402        events_set_bit(s, EV_KEY, BTN_TOUCH);
403    }
404
405    if (config->hw_camera) {
406        events_set_bit(s, EV_KEY, KEY_CAMERA);
407    }
408
409    if (config->hw_keyboard) {
410        /* since we want to implement Unicode reverse-mapping
411         * allow any kind of key, even those not available on
412         * the skin.
413         *
414         * the previous code did set the [1..0x1ff] range, but
415         * we don't want to enable certain bits in the middle
416         * of the range that are registered for mouse/trackball/joystick
417         * events.
418         *
419         * see "linux_keycodes.h" for the list of events codes.
420         */
421        events_set_bits(s, EV_KEY, 1, 0xff);
422        events_set_bits(s, EV_KEY, 0x160, 0x1ff);
423
424        /* If there is a keyboard, but no DPad, we need to clear the
425         * corresponding bits. Doing this is simpler than trying to exclude
426         * the DPad values from the ranges above.
427         */
428        if (!config->hw_dPad) {
429            events_clr_bit(s, EV_KEY, KEY_DOWN);
430            events_clr_bit(s, EV_KEY, KEY_UP);
431            events_clr_bit(s, EV_KEY, KEY_LEFT);
432            events_clr_bit(s, EV_KEY, KEY_RIGHT);
433            events_clr_bit(s, EV_KEY, KEY_CENTER);
434        }
435    }
436
437    /* configure EV_REL array
438     *
439     * EV_REL events are sent when the trackball is moved
440     */
441    if (config->hw_trackBall) {
442        events_set_bit (s, EV_SYN, EV_REL );
443        events_set_bits(s, EV_REL, REL_X, REL_Y);
444    }
445
446    /* configure EV_ABS array.
447     *
448     * EV_ABS events are sent when the touchscreen is pressed
449     */
450    if (config->hw_touchScreen) {
451        int32_t*  values;
452
453        events_set_bit (s, EV_SYN, EV_ABS );
454        events_set_bits(s, EV_ABS, ABS_X, ABS_Z);
455        /* Allocate the absinfo to report the min/max bounds for each
456         * absolute dimension. The array must contain 3 tuples
457         * of (min,max,fuzz,flat) 32-bit values.
458         *
459         * min and max are the bounds
460         * fuzz corresponds to the device's fuziness, we set it to 0
461         * flat corresponds to the flat position for JOEYDEV devices,
462         * we also set it to 0.
463         *
464         * There is no need to save/restore this array in a snapshot
465         * since the values only depend on the hardware configuration.
466         */
467        s->abs_info_count = 3*4;
468        s->abs_info = values = malloc(sizeof(uint32_t)*s->abs_info_count);
469
470        /* ABS_X min/max/fuzz/flat */
471        values[0] = 0;
472        values[1] = config->hw_lcd_width-1;
473        values[2] = 0;
474        values[3] = 0;
475        values   += 4;
476
477        /* ABS_Y */
478        values[0] = 0;
479        values[1] = config->hw_lcd_height-1;
480        values[2] = 0;
481        values[3] = 0;
482        values   += 4;
483
484        /* ABS_Z */
485        values[0] = 0;
486        values[1] = 1;
487        values[2] = 0;
488        values[3] = 0;
489    }
490
491    /* configure EV_SW array
492     *
493     * EW_SW events are sent to indicate that the keyboard lid
494     * was closed or opened (done when we switch layouts through
495     * KP-7 or KP-9).
496     *
497     * We only support this when hw.keyboard.lid is true.
498     */
499    if (config->hw_keyboard && config->hw_keyboard_lid) {
500        events_set_bit(s, EV_SYN, EV_SW);
501        events_set_bit(s, EV_SW, 0);
502    }
503
504    iomemtype = cpu_register_io_memory(events_readfn, events_writefn, s);
505
506    cpu_register_physical_memory(base, 0xfff, iomemtype);
507
508    qemu_add_kbd_event_handler(events_put_keycode, s);
509    qemu_add_mouse_event_handler(events_put_mouse, s, 1, "goldfish-events");
510
511    s->base = base;
512    s->irq = irq;
513
514    s->first = 0;
515    s->last = 0;
516    s->state = STATE_INIT;
517
518    /* This function migh fire buffered events to the device, so
519     * ensure that it is called after initialization is complete
520     */
521    user_event_register_generic(s, events_put_generic);
522
523    register_savevm( "events_state", 0, EVENTS_STATE_SAVE_VERSION,
524                      events_state_save, events_state_load, s );
525}
526