7 #include "../linux/in_evdev.h"
8 #include "../gp2x/in_gp2x.h"
21 static in_drv_t in_drivers[IN_DRVID_COUNT];
22 static in_dev_t in_devices[IN_MAX_DEVS];
23 static int in_dev_count = 0;
24 static int in_have_async_devs = 0;
25 static int menu_key_state = 0;
26 static int menu_last_used_dev = 0;
28 #define DRV(id) in_drivers[(unsigned)(id) < IN_DRVID_COUNT ? (id) : 0]
31 static int in_bind_count(int drv_id)
33 int count = DRV(drv_id).get_bind_count();
35 printf("input: failed to get bind count for drv %d\n", drv_id);
40 static int *in_alloc_binds(int drv_id)
44 count = in_bind_count(drv_id);
48 binds = calloc(count * 2, sizeof(binds[0]));
52 DRV(drv_id).get_def_binds(binds + count);
53 memcpy(binds, binds + count, count * sizeof(binds[0]));
58 static void in_free(in_dev_t *dev)
61 DRV(dev->drv_id).free(dev->drv_data);
70 /* to be called by drivers
71 * async devices must set drv_fd_hnd to -1 */
72 void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data, int combos)
74 int i, ret, dupe_count = 0, *binds;
75 char name[256], *name_end, *tmp;
77 strncpy(name, nname, sizeof(name));
78 name[sizeof(name)-12] = 0;
79 name_end = name + strlen(name);
81 for (i = 0; i < in_dev_count; i++)
83 if (in_devices[i].name == NULL)
85 if (strcmp(in_devices[i].name, name) == 0)
87 if (in_devices[i].probed) {
89 sprintf(name_end, " [%d]", dupe_count);
98 /* try to find unused device */
99 for (i = 0; i < IN_MAX_DEVS; i++)
100 if (!in_devices[i].probed) break;
101 if (i >= IN_MAX_DEVS) {
102 printf("input: too many devices, can't add %s\n", name);
105 in_free(&in_devices[i]);
112 binds = in_alloc_binds(drv_id);
118 in_devices[i].name = tmp;
119 in_devices[i].binds = binds;
120 if (i + 1 > in_dev_count)
121 in_dev_count = i + 1;
123 printf("input: new device #%d \"%s\"\n", i, name);
125 in_devices[i].probed = 1;
126 in_devices[i].does_combos = combos;
127 in_devices[i].drv_id = drv_id;
128 in_devices[i].drv_fd_hnd = drv_fd_hnd;
129 in_devices[i].drv_data = drv_data;
131 if (in_devices[i].binds != NULL) {
132 ret = DRV(drv_id).clean_binds(drv_data, in_devices[i].binds);
134 /* no useable binds */
135 free(in_devices[i].binds);
136 in_devices[i].binds = NULL;
141 /* key combo handling, to be called by drivers that support it */
142 void in_combos_find(int *binds, int last_key, int *combo_keys, int *combo_acts)
146 *combo_keys = *combo_acts = 0;
147 for (act = 0; act < sizeof(binds[0]) * 8; act++)
150 for (u = 0; u <= last_key; u++)
151 if (binds[u] & (1 << act))
156 // loop again and mark those keys and actions as combo
157 for (u = 0; u <= last_key; u++)
159 if (binds[u] & (1 << act)) {
160 *combo_keys |= 1 << u;
161 *combo_acts |= 1 << act;
168 int in_combos_do(int keys, int *binds, int last_key, int combo_keys, int combo_acts)
172 for (i = 0; i <= last_key; i++)
175 if (!(keys & (1 << i)))
182 if (combo_keys & (1 << i))
184 int acts_c = acts & combo_acts;
187 // let's try to find the other one
188 for (u = i + 1; u <= last_key; u++)
189 if ( (keys & (1 << u)) && (binds[u] & acts_c) ) {
190 ret |= acts_c & binds[u];
191 keys &= ~((1 << i) | (1 << u));
195 // add non-combo actions if combo ones were not found
197 ret |= acts & ~combo_acts;
209 in_have_async_devs = 0;
210 for (i = 0; i < in_dev_count; i++)
211 in_devices[i].probed = 0;
213 for (i = 1; i < IN_DRVID_COUNT; i++)
214 in_drivers[i].probe();
216 /* get rid of devs without binds and probes */
217 for (i = 0; i < in_dev_count; i++) {
218 if (!in_devices[i].probed && in_devices[i].binds == NULL) {
220 if (i < in_dev_count) {
221 free(in_devices[i].name);
222 memmove(&in_devices[i], &in_devices[i+1],
223 (in_dev_count - i) * sizeof(in_devices[0]));
229 if (in_devices[i].probed && in_devices[i].drv_fd_hnd == -1)
230 in_have_async_devs = 1;
233 if (in_have_async_devs)
234 printf("input: async-only devices detected..\n");
242 for (i = 0; i < in_dev_count; i++) {
243 in_dev_t *dev = &in_devices[i];
244 if (dev->probed && dev->binds != NULL) {
245 switch (dev->drv_id) {
248 result |= in_evdev_update(dev->drv_data, dev->binds);
253 result |= in_gp2x_update(dev->drv_data, dev->binds);
263 void in_set_blocking(int is_blocking)
267 /* have_async_devs means we will have to do all reads async anyway.. */
268 if (!in_have_async_devs) {
269 for (i = 0; i < in_dev_count; i++) {
270 if (in_devices[i].probed)
271 DRV(in_devices[i].drv_id).set_blocking(in_devices[i].drv_data, is_blocking);
279 ret = in_update_keycode(NULL, NULL, 0);
283 static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms)
285 int i, is_down, result;
288 ticks = plat_get_ticks_ms();
292 for (i = 0; i < in_dev_count; i++) {
293 in_dev_t *d = &in_devices[i];
297 result = DRV(d->drv_id).update_keycode(d->drv_data, &is_down);
304 *is_down_out = is_down;
308 if (timeout_ms >= 0 && (int)(plat_get_ticks_ms() - ticks) > timeout_ms)
318 * wait for a press, always return some keycode or -1 on timeout or error
320 int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
322 int result = -1, dev_id = 0, is_down, result_menu;
323 int fds_hnds[IN_MAX_DEVS];
324 int i, ret, count = 0;
325 in_drv_t *drv = NULL;
328 if (in_have_async_devs) {
329 result = in_update_kc_async(&dev_id, &is_down, timeout_ms);
332 drv = &DRV(in_devices[dev_id].drv_id);
336 ticks = plat_get_ticks_ms();
338 for (i = 0; i < in_dev_count; i++) {
339 if (in_devices[i].probed)
340 fds_hnds[count++] = in_devices[i].drv_fd_hnd;
344 /* don't deadlock, fail */
345 printf("input: failed to find devices to read\n");
351 ret = plat_wait_event(fds_hnds, count, timeout_ms);
355 for (i = 0; i < in_dev_count; i++) {
356 if (in_devices[i].drv_fd_hnd == ret) {
362 drv = &DRV(in_devices[dev_id].drv_id);
363 result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
365 /* update_keycode() might return -1 when some not interesting
366 * event happened, like sync event for evdev. */
370 if (timeout_ms >= 0) {
371 unsigned int ticks2 = plat_get_ticks_ms();
372 timeout_ms -= ticks2 - ticks;
382 /* keep track of menu key state, to allow mixing
383 * in_update_keycode() and in_menu_wait_any() calls */
384 result_menu = drv->menu_translate(result);
385 if (result_menu != 0) {
387 menu_key_state |= result_menu;
389 menu_key_state &= ~result_menu;
392 if (dev_id_out != NULL)
393 *dev_id_out = dev_id;
394 if (is_down_out != NULL)
395 *is_down_out = is_down;
399 /* same as above, only return bitfield of PBTN_* */
400 int in_menu_wait_any(int timeout_ms)
402 int keys_old = menu_key_state;
406 int code, is_down = 0, dev_id = 0;
408 code = in_update_keycode(&dev_id, &is_down, timeout_ms);
410 code = DRV(in_devices[dev_id].drv_id).menu_translate(code);
416 menu_last_used_dev = dev_id;
417 if (keys_old != menu_key_state)
421 return menu_key_state;
424 /* wait for menu input, do autorepeat */
425 int in_menu_wait(int interesting, int autorep_delay_ms)
427 static int inp_prev = 0;
428 static int repeats = 0;
429 int ret, release = 0, wait = 450;
432 wait = autorep_delay_ms;
434 ret = in_menu_wait_any(wait);
438 while (!(ret & interesting)) {
439 ret = in_menu_wait_any(-1);
443 if (release || ret != inp_prev)
448 /* we don't need diagonals in menus */
449 if ((ret & PBTN_UP) && (ret & PBTN_LEFT)) ret &= ~PBTN_LEFT;
450 if ((ret & PBTN_UP) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT;
451 if ((ret & PBTN_DOWN) && (ret & PBTN_LEFT)) ret &= ~PBTN_LEFT;
452 if ((ret & PBTN_DOWN) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT;
457 const int *in_get_dev_binds(int dev_id)
459 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
462 return in_devices[dev_id].binds;
465 const int *in_get_dev_def_binds(int dev_id)
469 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
472 count = in_bind_count(in_devices[dev_id].drv_id);
473 return in_devices[dev_id].binds + count;
476 int in_get_dev_info(int dev_id, int what)
478 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
482 case IN_INFO_BIND_COUNT:
483 return in_bind_count(in_devices[dev_id].drv_id);
484 case IN_INFO_DOES_COMBOS:
485 return in_devices[dev_id].does_combos;
491 const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
493 const char *name, *tmp;
495 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
498 if (must_be_active && !in_devices[dev_id].probed)
501 name = in_devices[dev_id].name;
502 if (name == NULL || !skip_pfix)
506 tmp = strchr(name, ':');
513 /* never returns NULL */
514 const char *in_get_key_name(int dev_id, int keycode)
516 static char xname[16];
519 if (dev_id < 0) /* want last used dev? */
520 dev_id = menu_last_used_dev;
522 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
525 if (keycode < 0) /* want name for menu key? */
526 keycode = DRV(in_devices[dev_id].drv_id).menu_translate(keycode);
528 name = DRV(in_devices[dev_id].drv_id).get_key_name(keycode);
532 /* assume scancode */
533 if ((keycode >= '0' && keycode <= '9') || (keycode >= 'a' && keycode <= 'z')
534 || (keycode >= 'A' && keycode <= 'Z'))
535 sprintf(xname, "%c", keycode);
537 sprintf(xname, "\\x%02X", keycode);
541 int in_bind_key(int dev_id, int keycode, int mask, int force_unbind)
546 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
548 dev = &in_devices[dev_id];
550 if (dev->binds == NULL) {
553 dev->binds = in_alloc_binds(dev->drv_id);
554 if (dev->binds == NULL)
558 count = in_bind_count(dev->drv_id);
559 if (keycode < 0 || keycode >= count)
563 dev->binds[keycode] &= ~mask;
565 dev->binds[keycode] ^= mask;
567 ret = DRV(dev->drv_id).clean_binds(dev->drv_data, dev->binds);
576 /* returns device id, or -1 on error */
577 int in_config_parse_dev(const char *name)
581 for (i = 0; i < IN_DRVID_COUNT; i++) {
582 int len = strlen(in_drivers[i].prefix);
583 if (strncmp(name, in_drivers[i].prefix, len) == 0) {
590 printf("input: missing driver for %s\n", name);
594 for (i = 0; i < in_dev_count; i++)
596 if (in_devices[i].name == NULL)
598 if (strcmp(in_devices[i].name, name) == 0)
602 if (i >= IN_MAX_DEVS)
604 /* try to find unused device */
605 for (i = 0; i < IN_MAX_DEVS; i++)
606 if (in_devices[i].name == NULL) break;
607 if (i >= IN_MAX_DEVS) {
608 printf("input: too many devices, can't add %s\n", name);
613 memset(&in_devices[i], 0, sizeof(in_devices[i]));
615 in_devices[i].name = strdup(name);
616 if (in_devices[i].name == NULL)
619 if (i + 1 > in_dev_count)
620 in_dev_count = i + 1;
621 in_devices[i].drv_id = drv_id;
627 * To reduce size of game specific configs, default binds are not saved.
628 * So we mark default binds in in_config_start(), override them in in_config_bind_key(),
629 * and restore whatever default binds are left in in_config_end().
631 void in_config_start(void)
635 /* mark all default binds, so they get overwritten by func below */
636 for (i = 0; i < IN_MAX_DEVS; i++) {
637 int n, count, *binds, *def_binds;
639 binds = in_devices[i].binds;
643 count = in_bind_count(in_devices[i].drv_id);
644 def_binds = binds + count;
646 for (n = 0; n < count; n++)
647 if (binds[n] == def_binds[n])
652 int in_config_bind_key(int dev_id, const char *key, int binds)
657 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
659 dev = &in_devices[dev_id];
661 count = in_bind_count(dev->drv_id);
663 /* maybe a raw code? */
664 if (key[0] == '\\' && key[1] == 'x') {
666 kc = (int)strtoul(key + 2, &p, 16);
667 if (p == NULL || *p != 0)
671 /* device specific key name */
672 if (dev->binds == NULL) {
673 dev->binds = in_alloc_binds(dev->drv_id);
674 if (dev->binds == NULL)
679 kc = DRV(dev->drv_id).get_key_code(key);
680 if (kc < 0 && strlen(key) == 1) {
681 /* assume scancode */
686 if (kc < 0 || kc >= count) {
687 printf("input: bad key: %s\n", key);
691 if (dev->binds[kc] == -1)
693 dev->binds[kc] |= binds;
698 void in_config_end(void)
702 for (i = 0; i < IN_MAX_DEVS; i++) {
703 int n, ret, count, *binds, *def_binds;
704 in_dev_t *dev = &in_devices[i];
706 if (dev->binds == NULL)
709 count = in_bind_count(dev->drv_id);
711 def_binds = binds + count;
713 for (n = 0; n < count; n++)
715 binds[n] = def_binds[n];
717 if (dev->drv_data == NULL)
720 ret = DRV(dev->drv_id).clean_binds(dev->drv_data, binds);
722 /* no useable binds */
729 void in_debug_dump(void)
733 printf("# drv probed binds name\n");
734 for (i = 0; i < IN_MAX_DEVS; i++) {
735 in_dev_t *d = &in_devices[i];
736 if (!d->probed && d->name == NULL && d->binds == NULL)
738 printf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n',
739 d->binds ? 'y' : 'n', d->name);
743 /* handlers for unknown/not_preset drivers */
745 static void in_def_probe(void) {}
746 static void in_def_free(void *drv_data) {}
747 static int in_def_get_bind_count(void) { return 0; }
748 static void in_def_get_def_binds(int *binds) {}
749 static int in_def_clean_binds(void *drv_data, int *binds) { return 0; }
750 static void in_def_set_blocking(void *data, int y) {}
751 static int in_def_update_keycode(void *drv_data, int *is_down) { return 0; }
752 static int in_def_menu_translate(int keycode) { return keycode; }
753 static int in_def_get_key_code(const char *key_name) { return 0; }
754 static const char *in_def_get_key_name(int keycode) { return NULL; }
760 memset(in_drivers, 0, sizeof(in_drivers));
761 memset(in_devices, 0, sizeof(in_devices));
764 for (i = 0; i < IN_DRVID_COUNT; i++) {
765 in_drivers[i].prefix = "none:";
766 in_drivers[i].probe = in_def_probe;
767 in_drivers[i].free = in_def_free;
768 in_drivers[i].get_bind_count = in_def_get_bind_count;
769 in_drivers[i].get_def_binds = in_def_get_def_binds;
770 in_drivers[i].clean_binds = in_def_clean_binds;
771 in_drivers[i].set_blocking = in_def_set_blocking;
772 in_drivers[i].update_keycode = in_def_update_keycode;
773 in_drivers[i].menu_translate = in_def_menu_translate;
774 in_drivers[i].get_key_code = in_def_get_key_code;
775 in_drivers[i].get_key_name = in_def_get_key_name;
779 in_gp2x_init(&in_drivers[IN_DRVID_GP2X]);
782 in_evdev_init(&in_drivers[IN_DRVID_EVDEV]);
799 ret = in_update_keycode(&dev, &down);
800 printf("#%i: %i %i (%s)\n", dev, down, ret, in_get_key_name(dev, ret));
804 ret = in_menu_wait_any();
805 printf("%08x\n", ret);