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 "android/multitouch-screen.h"
17 #include "irq.h"
18 #include "user-events.h"
19 #include "console.h"
20
21 #define MAX_EVENTS 256*4
22
23 enum {
24 REG_READ = 0x00,
25 REG_SET_PAGE = 0x00,
26 REG_LEN = 0x04,
27 REG_DATA = 0x08,
28
29 PAGE_NAME = 0x00000,
30 PAGE_EVBITS = 0x10000,
31 PAGE_ABSDATA = 0x20000 | EV_ABS,
32 };
33
34 /* These corresponds to the state of the driver.
35 * Unfortunately, we have to buffer events coming
36 * from the UI, since the kernel driver is not
37 * capable of receiving them until XXXXXX
38 */
39 enum {
40 STATE_INIT = 0, /* The device is initialized */
41 STATE_BUFFERED, /* Events have been buffered, but no IRQ raised yet */
42 STATE_LIVE /* Events can be sent directly to the kernel */
43 };
44
45 /* NOTE: The ev_bits arrays are used to indicate to the kernel
46 * which events can be sent by the emulated hardware.
47 */
48
49 typedef struct
50 {
51 uint32_t base;
52 qemu_irq irq;
53 int pending;
54 int page;
55
56 unsigned events[MAX_EVENTS];
57 unsigned first;
58 unsigned last;
59 unsigned state;
60
61 const char *name;
62
63 struct {
64 size_t len;
65 uint8_t *bits;
66 } ev_bits[EV_MAX + 1];
67
68 int32_t *abs_info;
69 size_t abs_info_count;
70 } events_state;
71
72 /* An entry in the array of ABS_XXX values */
73 typedef struct ABSEntry {
74 /* Minimum ABS_XXX value. */
75 uint32_t min;
76 /* Maximum ABS_XXX value. */
77 uint32_t max;
78 /* 'fuzz;, and 'flat' ABS_XXX values are always zero here. */
79 uint32_t fuzz;
80 uint32_t flat;
81 } ABSEntry;
82
83
84 /* modify this each time you change the events_device structure. you
85 * will also need to upadte events_state_load and events_state_save
86 */
87 #define EVENTS_STATE_SAVE_VERSION 2
88
89 #undef QFIELD_STRUCT
90 #define QFIELD_STRUCT events_state
91
92 QFIELD_BEGIN(events_state_fields)
QFIELD_INT32(pending)93 QFIELD_INT32(pending),
94 QFIELD_INT32(page),
95 QFIELD_BUFFER(events),
96 QFIELD_INT32(first),
97 QFIELD_INT32(last),
98 QFIELD_INT32(state),
99 QFIELD_END
100
101 static void events_state_save(QEMUFile* f, void* opaque)
102 {
103 events_state* s = opaque;
104
105 qemu_put_struct(f, events_state_fields, s);
106 }
107
events_state_load(QEMUFile * f,void * opaque,int version_id)108 static int events_state_load(QEMUFile* f, void* opaque, int version_id)
109 {
110 events_state* s = opaque;
111
112 if (version_id != EVENTS_STATE_SAVE_VERSION)
113 return -1;
114
115 return qemu_get_struct(f, events_state_fields, s);
116 }
117
enqueue_event(events_state * s,unsigned int type,unsigned int code,int value)118 static void enqueue_event(events_state *s, unsigned int type, unsigned int code, int value)
119 {
120 int enqueued = s->last - s->first;
121
122 if (enqueued < 0)
123 enqueued += MAX_EVENTS;
124
125 if (enqueued + 3 > MAX_EVENTS) {
126 fprintf(stderr, "##KBD: Full queue, lose event\n");
127 return;
128 }
129
130 if(s->first == s->last) {
131 if (s->state == STATE_LIVE)
132 qemu_irq_raise(s->irq);
133 else {
134 s->state = STATE_BUFFERED;
135 }
136 }
137
138 //fprintf(stderr, "##KBD: type=%d code=%d value=%d\n", type, code, value);
139
140 s->events[s->last] = type;
141 s->last = (s->last + 1) & (MAX_EVENTS-1);
142 s->events[s->last] = code;
143 s->last = (s->last + 1) & (MAX_EVENTS-1);
144 s->events[s->last] = value;
145 s->last = (s->last + 1) & (MAX_EVENTS-1);
146 }
147
dequeue_event(events_state * s)148 static unsigned dequeue_event(events_state *s)
149 {
150 unsigned n;
151
152 if(s->first == s->last) {
153 return 0;
154 }
155
156 n = s->events[s->first];
157
158 s->first = (s->first + 1) & (MAX_EVENTS - 1);
159
160 if(s->first == s->last) {
161 qemu_irq_lower(s->irq);
162 }
163 #ifdef TARGET_I386
164 /*
165 * Adding the logic to handle edge-triggered interrupts for x86
166 * because the exisiting goldfish events device basically provides
167 * level-trigger interrupts only.
168 *
169 * Logic: When an event (including the type/code/value) is fetched
170 * by the driver, if there is still another event in the event
171 * queue, the goldfish event device will re-assert the IRQ so that
172 * the driver can be notified to fetch the event again.
173 */
174 else if (((s->first + 2) & (MAX_EVENTS - 1)) < s->last ||
175 (s->first & (MAX_EVENTS - 1)) > s->last) { /* if there still is an event */
176 qemu_irq_lower(s->irq);
177 qemu_irq_raise(s->irq);
178 }
179 #endif
180 return n;
181 }
182
get_page_len(events_state * s)183 static int get_page_len(events_state *s)
184 {
185 int page = s->page;
186 if (page == PAGE_NAME) {
187 const char* name = s->name;
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
get_page_data(events_state * s,int offset)196 static 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 = s->name;
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
events_read(void * x,target_phys_addr_t off)213 static 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
events_write(void * x,target_phys_addr_t off,uint32_t val)239 static 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
247 static CPUReadMemoryFunc *events_readfn[] = {
248 events_read,
249 events_read,
250 events_read
251 };
252
253 static CPUWriteMemoryFunc *events_writefn[] = {
254 events_write,
255 events_write,
256 events_write
257 };
258
events_put_keycode(void * x,int keycode)259 static 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
events_put_mouse(void * opaque,int dx,int dy,int dz,int buttons_state)266 static 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 if (androidHwConfig_isScreenMultiTouch(android_hw)) {
275 /* Convert mouse event into multi-touch event */
276 multitouch_update_pointer(MTES_MOUSE, 0, dx, dy,
277 (buttons_state & 1) ? 0x81 : 0);
278 } else if (androidHwConfig_isScreenTouch(android_hw)) {
279 enqueue_event(s, EV_ABS, ABS_X, dx);
280 enqueue_event(s, EV_ABS, ABS_Y, dy);
281 enqueue_event(s, EV_ABS, ABS_Z, dz);
282 enqueue_event(s, EV_KEY, BTN_TOUCH, buttons_state&1);
283 enqueue_event(s, EV_SYN, 0, 0);
284 }
285 } else {
286 enqueue_event(s, EV_REL, REL_X, dx);
287 enqueue_event(s, EV_REL, REL_Y, dy);
288 enqueue_event(s, EV_SYN, 0, 0);
289 }
290 }
291
events_put_generic(void * opaque,int type,int code,int value)292 static void events_put_generic(void* opaque, int type, int code, int value)
293 {
294 events_state *s = (events_state *) opaque;
295
296 enqueue_event(s, type, code, value);
297 }
298
299 /* set bits [bitl..bith] in the ev_bits[type] array
300 */
301 static void
events_set_bits(events_state * s,int type,int bitl,int bith)302 events_set_bits(events_state *s, int type, int bitl, int bith)
303 {
304 uint8_t *bits;
305 uint8_t maskl, maskh;
306 int il, ih;
307 il = bitl / 8;
308 ih = bith / 8;
309 if (ih >= s->ev_bits[type].len) {
310 bits = qemu_mallocz(ih + 1);
311 if (bits == NULL)
312 return;
313 memcpy(bits, s->ev_bits[type].bits, s->ev_bits[type].len);
314 qemu_free(s->ev_bits[type].bits);
315 s->ev_bits[type].bits = bits;
316 s->ev_bits[type].len = ih + 1;
317 }
318 else
319 bits = s->ev_bits[type].bits;
320 maskl = 0xffU << (bitl & 7);
321 maskh = 0xffU >> (7 - (bith & 7));
322 if (il >= ih)
323 maskh &= maskl;
324 else {
325 bits[il] |= maskl;
326 while (++il < ih)
327 bits[il] = 0xff;
328 }
329 bits[ih] |= maskh;
330 }
331
332 static void
events_set_bit(events_state * s,int type,int bit)333 events_set_bit(events_state* s, int type, int bit)
334 {
335 events_set_bits(s, type, bit, bit);
336 }
337
338 static void
events_clr_bit(events_state * s,int type,int bit)339 events_clr_bit(events_state* s, int type, int bit)
340 {
341 int ii = bit / 8;
342 if (ii < s->ev_bits[type].len) {
343 uint8_t* bits = s->ev_bits[type].bits;
344 uint8_t mask = 0x01U << (bit & 7);
345 bits[ii] &= ~mask;
346 }
347 }
348
events_dev_init(uint32_t base,qemu_irq irq)349 void events_dev_init(uint32_t base, qemu_irq irq)
350 {
351 events_state *s;
352 int iomemtype;
353 AndroidHwConfig* config = android_hw;
354
355 s = (events_state *) qemu_mallocz(sizeof(events_state));
356
357 /* now set the events capability bits depending on hardware configuration */
358 /* apparently, the EV_SYN array is used to indicate which other
359 * event classes to consider.
360 */
361
362 /* configure EV_KEY array
363 *
364 * All Android devices must have the following keys:
365 * KEY_HOME, KEY_BACK, KEY_SEND (Call), KEY_END (EndCall),
366 * KEY_SOFT1 (Menu), VOLUME_UP, VOLUME_DOWN
367 *
368 * Note that previous models also had a KEY_SOFT2,
369 * and a KEY_POWER which we still support here.
370 *
371 * Newer models have a KEY_SEARCH key, which we always
372 * enable here.
373 *
374 * A Dpad will send: KEY_DOWN / UP / LEFT / RIGHT / CENTER
375 *
376 * The KEY_CAMERA button isn't very useful if there is no camera.
377 *
378 * BTN_MOUSE is sent when the trackball is pressed
379 * BTN_TOUCH is sent when the touchscreen is pressed
380 */
381 events_set_bit (s, EV_SYN, EV_KEY );
382
383 events_set_bit(s, EV_KEY, KEY_HOME);
384 events_set_bit(s, EV_KEY, KEY_BACK);
385 events_set_bit(s, EV_KEY, KEY_SEND);
386 events_set_bit(s, EV_KEY, KEY_END);
387 events_set_bit(s, EV_KEY, KEY_SOFT1);
388 events_set_bit(s, EV_KEY, KEY_VOLUMEUP);
389 events_set_bit(s, EV_KEY, KEY_VOLUMEDOWN);
390 events_set_bit(s, EV_KEY, KEY_SOFT2);
391 events_set_bit(s, EV_KEY, KEY_POWER);
392 events_set_bit(s, EV_KEY, KEY_SEARCH);
393
394 if (config->hw_dPad) {
395 events_set_bit(s, EV_KEY, KEY_DOWN);
396 events_set_bit(s, EV_KEY, KEY_UP);
397 events_set_bit(s, EV_KEY, KEY_LEFT);
398 events_set_bit(s, EV_KEY, KEY_RIGHT);
399 events_set_bit(s, EV_KEY, KEY_CENTER);
400 }
401
402 if (config->hw_trackBall) {
403 events_set_bit(s, EV_KEY, BTN_MOUSE);
404 }
405 if (androidHwConfig_isScreenTouch(config)) {
406 events_set_bit(s, EV_KEY, BTN_TOUCH);
407 }
408
409 if (strcmp(config->hw_camera_back, "none") ||
410 strcmp(config->hw_camera_front, "none")) {
411 /* Camera emulation is enabled. */
412 events_set_bit(s, EV_KEY, KEY_CAMERA);
413 }
414
415 if (config->hw_keyboard) {
416 /* since we want to implement Unicode reverse-mapping
417 * allow any kind of key, even those not available on
418 * the skin.
419 *
420 * the previous code did set the [1..0x1ff] range, but
421 * we don't want to enable certain bits in the middle
422 * of the range that are registered for mouse/trackball/joystick
423 * events.
424 *
425 * see "linux_keycodes.h" for the list of events codes.
426 */
427 events_set_bits(s, EV_KEY, 1, 0xff);
428 events_set_bits(s, EV_KEY, 0x160, 0x1ff);
429
430 /* If there is a keyboard, but no DPad, we need to clear the
431 * corresponding bits. Doing this is simpler than trying to exclude
432 * the DPad values from the ranges above.
433 */
434 if (!config->hw_dPad) {
435 events_clr_bit(s, EV_KEY, KEY_DOWN);
436 events_clr_bit(s, EV_KEY, KEY_UP);
437 events_clr_bit(s, EV_KEY, KEY_LEFT);
438 events_clr_bit(s, EV_KEY, KEY_RIGHT);
439 events_clr_bit(s, EV_KEY, KEY_CENTER);
440 }
441 }
442
443 /* configure EV_REL array
444 *
445 * EV_REL events are sent when the trackball is moved
446 */
447 if (config->hw_trackBall) {
448 events_set_bit (s, EV_SYN, EV_REL );
449 events_set_bits(s, EV_REL, REL_X, REL_Y);
450 }
451
452 /* configure EV_ABS array.
453 *
454 * EV_ABS events are sent when the touchscreen is pressed
455 */
456 if (!androidHwConfig_isScreenNoTouch(config)) {
457 ABSEntry* abs_values;
458
459 events_set_bit (s, EV_SYN, EV_ABS );
460 events_set_bits(s, EV_ABS, ABS_X, ABS_Z);
461 /* Allocate the absinfo to report the min/max bounds for each
462 * absolute dimension. The array must contain 3, or ABS_MAX tuples
463 * of (min,max,fuzz,flat) 32-bit values.
464 *
465 * min and max are the bounds
466 * fuzz corresponds to the device's fuziness, we set it to 0
467 * flat corresponds to the flat position for JOEYDEV devices,
468 * we also set it to 0.
469 *
470 * There is no need to save/restore this array in a snapshot
471 * since the values only depend on the hardware configuration.
472 */
473 s->abs_info_count = androidHwConfig_isScreenMultiTouch(config) ? ABS_MAX * 4 : 3 * 4;
474 const int abs_size = sizeof(uint32_t) * s->abs_info_count;
475 s->abs_info = malloc(abs_size);
476 memset(s->abs_info, 0, abs_size);
477 abs_values = (ABSEntry*)s->abs_info;
478
479 abs_values[ABS_X].max = config->hw_lcd_width-1;
480 abs_values[ABS_Y].max = config->hw_lcd_height-1;
481 abs_values[ABS_Z].max = 1;
482
483 if (androidHwConfig_isScreenMultiTouch(config)) {
484 /*
485 * Setup multitouch.
486 */
487 events_set_bit(s, EV_ABS, ABS_MT_SLOT);
488 events_set_bit(s, EV_ABS, ABS_MT_POSITION_X);
489 events_set_bit(s, EV_ABS, ABS_MT_POSITION_Y);
490 events_set_bit(s, EV_ABS, ABS_MT_TRACKING_ID);
491 events_set_bit(s, EV_ABS, ABS_MT_TOUCH_MAJOR);
492 events_set_bit(s, EV_ABS, ABS_MT_PRESSURE);
493
494 abs_values[ABS_MT_SLOT].max = multitouch_get_max_slot();
495 abs_values[ABS_MT_TRACKING_ID].max = abs_values[ABS_MT_SLOT].max + 1;
496 abs_values[ABS_MT_POSITION_X].max = abs_values[ABS_X].max;
497 abs_values[ABS_MT_POSITION_Y].max = abs_values[ABS_Y].max;
498 abs_values[ABS_MT_TOUCH_MAJOR].max = 0x7fffffff; // TODO: Make it less random
499 abs_values[ABS_MT_PRESSURE].max = 0x100; // TODO: Make it less random
500 }
501 }
502
503 /* configure EV_SW array
504 *
505 * EV_SW events are sent to indicate that the keyboard lid
506 * was closed or opened (done when we switch layouts through
507 * KP-7 or KP-9).
508 *
509 * We only support this when hw.keyboard.lid is true.
510 */
511 if (config->hw_keyboard && config->hw_keyboard_lid) {
512 events_set_bit(s, EV_SYN, EV_SW);
513 events_set_bit(s, EV_SW, 0);
514 }
515
516 iomemtype = cpu_register_io_memory(events_readfn, events_writefn, s);
517
518 cpu_register_physical_memory(base, 0xfff, iomemtype);
519
520 qemu_add_kbd_event_handler(events_put_keycode, s);
521 qemu_add_mouse_event_handler(events_put_mouse, s, 1, "goldfish-events");
522
523 s->base = base;
524 s->irq = irq;
525
526 s->first = 0;
527 s->last = 0;
528 s->state = STATE_INIT;
529 s->name = qemu_strdup(config->hw_keyboard_charmap);
530
531 /* This function migh fire buffered events to the device, so
532 * ensure that it is called after initialization is complete
533 */
534 user_event_register_generic(s, events_put_generic);
535
536 register_savevm( "events_state", 0, EVENTS_STATE_SAVE_VERSION,
537 events_state_save, events_state_load, s );
538 }
539