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