10 #include "../linux/in_evdev.h"
13 #include "../gp2x/in_gp2x.h"
16 #include "../win32/in_vk.h"
26 int *binds; /* total = key_count * bindtypes * 2 */
31 static in_drv_t in_drivers[IN_DRVID_COUNT];
32 static in_dev_t in_devices[IN_MAX_DEVS];
33 static int in_dev_count = 0;
34 static int in_have_async_devs = 0;
35 static int menu_key_state = 0;
36 static int menu_last_used_dev = 0;
38 #define DRV(id) in_drivers[(unsigned)(id) < IN_DRVID_COUNT ? (id) : 0]
41 static int *in_alloc_binds(int drv_id, int key_count)
45 binds = calloc(key_count * IN_BINDTYPE_COUNT * 2, sizeof(binds[0]));
49 DRV(drv_id).get_def_binds(binds + key_count * IN_BINDTYPE_COUNT);
50 memcpy(binds, binds + key_count * IN_BINDTYPE_COUNT,
51 sizeof(binds[0]) * key_count * IN_BINDTYPE_COUNT);
56 static void in_free(in_dev_t *dev)
59 DRV(dev->drv_id).free(dev->drv_data);
68 /* to be called by drivers
69 * async devices must set drv_fd_hnd to -1 */
70 void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data,
71 int key_count, int combos)
73 int i, ret, dupe_count = 0, *binds;
74 char name[256], *name_end, *tmp;
76 strncpy(name, nname, sizeof(name));
77 name[sizeof(name)-12] = 0;
78 name_end = name + strlen(name);
80 for (i = 0; i < in_dev_count; i++)
82 if (in_devices[i].name == NULL)
84 if (strcmp(in_devices[i].name, name) == 0)
86 if (in_devices[i].probed) {
88 sprintf(name_end, " [%d]", dupe_count);
97 /* try to find unused device */
98 for (i = 0; i < IN_MAX_DEVS; i++)
99 if (!in_devices[i].probed) break;
100 if (i >= IN_MAX_DEVS) {
101 lprintf("input: too many devices, can't add %s\n", name);
104 in_free(&in_devices[i]);
111 binds = in_alloc_binds(drv_id, key_count);
117 in_devices[i].name = tmp;
118 in_devices[i].binds = binds;
119 in_devices[i].key_count = key_count;
120 if (i + 1 > in_dev_count)
121 in_dev_count = i + 1;
123 lprintf("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,
133 in_devices[i].binds + key_count * IN_BINDTYPE_COUNT);
135 /* no useable binds */
136 free(in_devices[i].binds);
137 in_devices[i].binds = NULL;
142 /* key combo handling, to be called by drivers that support it.
143 * Only care about IN_BINDTYPE_EMU */
144 void in_combos_find(const int *binds, int last_key, int *combo_keys, int *combo_acts)
148 *combo_keys = *combo_acts = 0;
149 for (act = 0; act < sizeof(binds[0]) * 8; act++)
152 for (u = 0; u <= last_key; u++)
153 if (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & (1 << act))
158 // loop again and mark those keys and actions as combo
159 for (u = 0; u <= last_key; u++)
161 if (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & (1 << act)) {
162 *combo_keys |= 1 << u;
163 *combo_acts |= 1 << act;
170 int in_combos_do(int keys, const int *binds, int last_key, int combo_keys, int combo_acts)
174 for (i = 0; i <= last_key; i++)
178 if (!(keys & (1 << i)))
181 acts = binds[IN_BIND_OFFS(i, IN_BINDTYPE_EMU)];
185 if (!(combo_keys & (1 << i))) {
190 acts_c = acts & combo_acts;
193 // let's try to find the other one
194 for (u = i + 1; u <= last_key; u++)
195 if ( (keys & (1 << u)) && (binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)] & acts_c) ) {
196 ret |= acts_c & binds[IN_BIND_OFFS(u, IN_BINDTYPE_EMU)];
197 keys &= ~((1 << i) | (1 << u));
201 // add non-combo actions if combo ones were not found
203 ret |= acts & ~combo_acts;
213 in_have_async_devs = 0;
214 for (i = 0; i < in_dev_count; i++)
215 in_devices[i].probed = 0;
217 for (i = 1; i < IN_DRVID_COUNT; i++)
218 in_drivers[i].probe();
220 /* get rid of devs without binds and probes */
221 for (i = 0; i < in_dev_count; i++) {
222 if (!in_devices[i].probed && in_devices[i].binds == NULL) {
224 if (i < in_dev_count) {
225 free(in_devices[i].name);
226 memmove(&in_devices[i], &in_devices[i+1],
227 (in_dev_count - i) * sizeof(in_devices[0]));
233 if (in_devices[i].probed && in_devices[i].drv_fd_hnd == -1)
234 in_have_async_devs = 1;
237 if (in_have_async_devs)
238 lprintf("input: async-only devices detected..\n");
242 int in_update(int *result)
246 for (i = 0; i < in_dev_count; i++) {
247 in_dev_t *dev = &in_devices[i];
248 if (dev->probed && dev->binds != NULL) {
249 // FIXME: this is stupid, make it indirect
250 switch (dev->drv_id) {
253 ret |= in_evdev_update(dev->drv_data, dev->binds, result);
258 ret |= in_gp2x_update(dev->drv_data, dev->binds, result);
263 ret |= in_vk_update(dev->drv_data, dev->binds, result);
273 void in_set_blocking(int is_blocking)
277 /* have_async_devs means we will have to do all reads async anyway.. */
278 if (!in_have_async_devs) {
279 for (i = 0; i < in_dev_count; i++) {
280 if (in_devices[i].probed)
281 DRV(in_devices[i].drv_id).set_blocking(in_devices[i].drv_data, is_blocking);
289 ret = in_update_keycode(NULL, NULL, 0);
293 static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms)
295 int i, is_down, result;
298 ticks = plat_get_ticks_ms();
302 for (i = 0; i < in_dev_count; i++) {
303 in_dev_t *d = &in_devices[i];
307 result = DRV(d->drv_id).update_keycode(d->drv_data, &is_down);
314 *is_down_out = is_down;
318 if (timeout_ms >= 0 && (int)(plat_get_ticks_ms() - ticks) > timeout_ms)
328 * wait for a press, always return some keycode or -1 on timeout or error
330 int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
332 int result = -1, dev_id = 0, is_down, result_menu;
333 int fds_hnds[IN_MAX_DEVS];
334 int i, ret, count = 0;
335 in_drv_t *drv = NULL;
338 if (in_have_async_devs) {
339 result = in_update_kc_async(&dev_id, &is_down, timeout_ms);
342 drv = &DRV(in_devices[dev_id].drv_id);
346 ticks = plat_get_ticks_ms();
348 for (i = 0; i < in_dev_count; i++) {
349 if (in_devices[i].probed)
350 fds_hnds[count++] = in_devices[i].drv_fd_hnd;
354 /* don't deadlock, fail */
355 lprintf("input: failed to find devices to read\n");
361 ret = plat_wait_event(fds_hnds, count, timeout_ms);
365 for (i = 0; i < in_dev_count; i++) {
366 if (in_devices[i].drv_fd_hnd == ret) {
372 drv = &DRV(in_devices[dev_id].drv_id);
373 result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
375 /* update_keycode() might return -1 when some not interesting
376 * event happened, like sync event for evdev. */
380 if (timeout_ms >= 0) {
381 unsigned int ticks2 = plat_get_ticks_ms();
382 timeout_ms -= ticks2 - ticks;
392 /* keep track of menu key state, to allow mixing
393 * in_update_keycode() and in_menu_wait_any() calls */
394 result_menu = drv->menu_translate(result);
395 if (result_menu != 0) {
397 menu_key_state |= result_menu;
399 menu_key_state &= ~result_menu;
402 if (dev_id_out != NULL)
403 *dev_id_out = dev_id;
404 if (is_down_out != NULL)
405 *is_down_out = is_down;
409 /* same as above, only return bitfield of PBTN_* */
410 int in_menu_wait_any(int timeout_ms)
412 int keys_old = menu_key_state;
416 int code, is_down = 0, dev_id = 0;
418 code = in_update_keycode(&dev_id, &is_down, timeout_ms);
420 code = DRV(in_devices[dev_id].drv_id).menu_translate(code);
426 menu_last_used_dev = dev_id;
427 if (keys_old != menu_key_state)
431 return menu_key_state;
434 /* wait for menu input, do autorepeat */
435 int in_menu_wait(int interesting, int autorep_delay_ms)
437 static int inp_prev = 0;
438 static int repeats = 0;
439 int ret, release = 0, wait = 450;
442 wait = autorep_delay_ms;
444 ret = in_menu_wait_any(wait);
448 while (!(ret & interesting)) {
449 ret = in_menu_wait_any(-1);
453 if (release || ret != inp_prev)
458 /* we don't need diagonals in menus */
459 if ((ret & PBTN_UP) && (ret & PBTN_LEFT)) ret &= ~PBTN_LEFT;
460 if ((ret & PBTN_UP) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT;
461 if ((ret & PBTN_DOWN) && (ret & PBTN_LEFT)) ret &= ~PBTN_LEFT;
462 if ((ret & PBTN_DOWN) && (ret & PBTN_RIGHT)) ret &= ~PBTN_RIGHT;
467 const int *in_get_dev_binds(int dev_id)
469 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
472 return in_devices[dev_id].binds;
475 const int *in_get_dev_def_binds(int dev_id)
477 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
480 return in_devices[dev_id].binds + in_devices[dev_id].key_count * IN_BINDTYPE_COUNT;
483 int in_get_dev_info(int dev_id, int what)
485 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
489 case IN_INFO_BIND_COUNT:
490 return in_devices[dev_id].key_count;
491 case IN_INFO_DOES_COMBOS:
492 return in_devices[dev_id].does_combos;
498 const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
500 const char *name, *tmp;
502 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
505 if (must_be_active && !in_devices[dev_id].probed)
508 name = in_devices[dev_id].name;
509 if (name == NULL || !skip_pfix)
513 tmp = strchr(name, ':');
520 /* never returns NULL */
521 const char *in_get_key_name(int dev_id, int keycode)
523 static char xname[16];
526 if (dev_id < 0) /* want last used dev? */
527 dev_id = menu_last_used_dev;
529 if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
532 if (keycode < 0) /* want name for menu key? */
533 keycode = DRV(in_devices[dev_id].drv_id).menu_translate(keycode);
535 name = DRV(in_devices[dev_id].drv_id).get_key_name(keycode);
539 /* assume scancode */
540 if ((keycode >= '0' && keycode <= '9') || (keycode >= 'a' && keycode <= 'z')
541 || (keycode >= 'A' && keycode <= 'Z'))
542 sprintf(xname, "%c", keycode);
544 sprintf(xname, "\\x%02X", keycode);
548 int in_bind_key(int dev_id, int keycode, int mask, int bind_type, int force_unbind)
553 if (dev_id < 0 || dev_id >= IN_MAX_DEVS || bind_type >= IN_BINDTYPE_COUNT)
556 dev = &in_devices[dev_id];
557 count = dev->key_count;
559 if (dev->binds == NULL) {
562 dev->binds = in_alloc_binds(dev->drv_id, count);
563 if (dev->binds == NULL)
567 if (keycode < 0 || keycode >= count)
571 dev->binds[IN_BIND_OFFS(keycode, bind_type)] &= ~mask;
573 dev->binds[IN_BIND_OFFS(keycode, bind_type)] ^= mask;
575 ret = DRV(dev->drv_id).clean_binds(dev->drv_data, dev->binds,
576 dev->binds + count * IN_BINDTYPE_COUNT);
585 void in_unbind_all(int dev_id, int act_mask, int bind_type)
590 if (dev_id < 0 || dev_id >= IN_MAX_DEVS || bind_type >= IN_BINDTYPE_COUNT)
593 dev = &in_devices[dev_id];
594 count = dev->key_count;
596 if (dev->binds == NULL)
599 for (i = 0; i < count; i++)
600 dev->binds[IN_BIND_OFFS(i, bind_type)] &= ~act_mask;
603 /* returns device id, or -1 on error */
604 int in_config_parse_dev(const char *name)
608 for (i = 0; i < IN_DRVID_COUNT; i++) {
609 int len = strlen(in_drivers[i].prefix);
610 if (strncmp(name, in_drivers[i].prefix, len) == 0) {
617 lprintf("input: missing driver for %s\n", name);
621 for (i = 0; i < in_dev_count; i++)
623 if (in_devices[i].name == NULL)
625 if (strcmp(in_devices[i].name, name) == 0)
629 if (i >= IN_MAX_DEVS)
631 /* try to find unused device */
632 for (i = 0; i < IN_MAX_DEVS; i++)
633 if (in_devices[i].name == NULL) break;
634 if (i >= IN_MAX_DEVS) {
635 lprintf("input: too many devices, can't add %s\n", name);
640 memset(&in_devices[i], 0, sizeof(in_devices[i]));
642 in_devices[i].name = strdup(name);
643 if (in_devices[i].name == NULL)
646 in_devices[i].key_count = DRV(drv_id).get_bind_count();
647 in_devices[i].drv_id = drv_id;
649 if (i + 1 > in_dev_count)
650 in_dev_count = i + 1;
656 * To reduce size of game specific configs, default binds are not saved.
657 * So we mark default binds in in_config_start(), override them in in_config_bind_key(),
658 * and restore whatever default binds are left in in_config_end().
660 void in_config_start(void)
664 /* mark all default binds, so they get overwritten by func below */
665 for (i = 0; i < IN_MAX_DEVS; i++) {
666 int n, count, *binds, *def_binds;
668 binds = in_devices[i].binds;
672 count = in_devices[i].key_count;
673 def_binds = binds + count * IN_BINDTYPE_COUNT;
675 for (n = 0; n < count * IN_BINDTYPE_COUNT; n++)
676 if (binds[n] == def_binds[n])
681 int in_config_bind_key(int dev_id, const char *key, int acts, int bind_type)
686 if (dev_id < 0 || dev_id >= IN_MAX_DEVS || bind_type >= IN_BINDTYPE_COUNT)
688 dev = &in_devices[dev_id];
690 /* maybe a raw code? */
691 if (key[0] == '\\' && key[1] == 'x') {
693 kc = (int)strtoul(key + 2, &p, 16);
694 if (p == NULL || *p != 0)
698 /* device specific key name */
699 if (dev->binds == NULL) {
700 dev->binds = in_alloc_binds(dev->drv_id, dev->key_count);
701 if (dev->binds == NULL)
706 kc = DRV(dev->drv_id).get_key_code(key);
707 if (kc < 0 && strlen(key) == 1) {
708 /* assume scancode */
713 if (kc < 0 || kc >= dev->key_count) {
714 lprintf("input: bad key: %s\n", key);
718 if (bind_type == IN_BINDTYPE_NONE) {
719 for (i = 0; i < IN_BINDTYPE_COUNT; i++)
720 dev->binds[IN_BIND_OFFS(kc, i)] = 0;
724 offs = IN_BIND_OFFS(kc, bind_type);
725 if (dev->binds[offs] == -1)
726 dev->binds[offs] = 0;
727 dev->binds[offs] |= acts;
731 void in_config_end(void)
735 for (i = 0; i < IN_MAX_DEVS; i++) {
736 int n, t, ret, count, *binds, *def_binds;
737 in_dev_t *dev = &in_devices[i];
739 if (dev->binds == NULL)
742 count = dev->key_count;
744 def_binds = binds + count * IN_BINDTYPE_COUNT;
746 for (n = 0; n < count; n++) {
748 for (t = 0; t < IN_BINDTYPE_COUNT; t++)
749 if (binds[IN_BIND_OFFS(n, t)] == -1)
750 binds[IN_BIND_OFFS(n, t)] = 0;
755 for (t = 0; t < IN_BINDTYPE_COUNT; t++)
756 binds[IN_BIND_OFFS(n, t)] = def_binds[IN_BIND_OFFS(n, t)];
759 if (dev->drv_data == NULL)
762 ret = DRV(dev->drv_id).clean_binds(dev->drv_data, binds, def_binds);
764 /* no useable binds */
771 void in_debug_dump(void)
775 lprintf("# drv probed binds name\n");
776 for (i = 0; i < IN_MAX_DEVS; i++) {
777 in_dev_t *d = &in_devices[i];
778 if (!d->probed && d->name == NULL && d->binds == NULL)
780 lprintf("%d %3d %6c %5c %s\n", i, d->drv_id, d->probed ? 'y' : 'n',
781 d->binds ? 'y' : 'n', d->name);
785 /* handlers for unknown/not_preset drivers */
787 static void in_def_probe(void) {}
788 static void in_def_free(void *drv_data) {}
789 static int in_def_get_bind_count(void) { return 0; }
790 static void in_def_get_def_binds(int *binds) {}
791 static int in_def_clean_binds(void *drv_data, int *b, int *db) { return 0; }
792 static void in_def_set_blocking(void *data, int y) {}
793 static int in_def_update_keycode(void *drv_data, int *is_down) { return 0; }
794 static int in_def_menu_translate(int keycode) { return keycode; }
795 static int in_def_get_key_code(const char *key_name) { return 0; }
796 static const char *in_def_get_key_name(int keycode) { return NULL; }
802 memset(in_drivers, 0, sizeof(in_drivers));
803 memset(in_devices, 0, sizeof(in_devices));
806 for (i = 0; i < IN_DRVID_COUNT; i++) {
807 in_drivers[i].prefix = "none:";
808 in_drivers[i].probe = in_def_probe;
809 in_drivers[i].free = in_def_free;
810 in_drivers[i].get_bind_count = in_def_get_bind_count;
811 in_drivers[i].get_def_binds = in_def_get_def_binds;
812 in_drivers[i].clean_binds = in_def_clean_binds;
813 in_drivers[i].set_blocking = in_def_set_blocking;
814 in_drivers[i].update_keycode = in_def_update_keycode;
815 in_drivers[i].menu_translate = in_def_menu_translate;
816 in_drivers[i].get_key_code = in_def_get_key_code;
817 in_drivers[i].get_key_name = in_def_get_key_name;
821 in_gp2x_init(&in_drivers[IN_DRVID_GP2X]);
824 in_evdev_init(&in_drivers[IN_DRVID_EVDEV]);
827 in_vk_init(&in_drivers[IN_DRVID_VK]);
844 ret = in_update_keycode(&dev, &down);
845 lprintf("#%i: %i %i (%s)\n", dev, down, ret, in_get_key_name(dev, ret));
849 ret = in_menu_wait_any();
850 lprintf("%08x\n", ret);