#include "common.h"
#include "input.h"
+#include "plat.h"
#include "../linux/in_evdev.h"
+#include "../gp2x/in_gp2x.h"
typedef struct
{
static in_drv_t in_drivers[IN_DRVID_COUNT];
static in_dev_t in_devices[IN_MAX_DEVS];
static int in_dev_count = 0;
+static int in_have_async_devs = 0;
#define DRV(id) in_drivers[(unsigned)(id) < IN_DRVID_COUNT ? (id) : 0]
+
static int in_bind_count(int drv_id)
{
int count = DRV(drv_id).get_bind_count();
dev->binds = NULL;
}
-/* to be called by drivers */
+/* to be called by drivers
+ * async devices must set drv_fd_hnd to -1 */
void in_register(const char *nname, int drv_id, int drv_fd_hnd, void *drv_data)
{
int i, ret, dupe_count = 0, *binds;
void in_probe(void)
{
int i;
+
+ in_have_async_devs = 0;
for (i = 0; i < in_dev_count; i++)
in_devices[i].probed = 0;
memmove(&in_devices[i], &in_devices[i+1],
(in_dev_count - i) * sizeof(in_devices[0]));
}
+
+ continue;
}
+
+ if (in_devices[i].probed && in_devices[i].drv_fd_hnd == -1)
+ in_have_async_devs = 1;
}
+
+ if (in_have_async_devs)
+ printf("input: async-only devices detected..\n");
}
/* async update */
case IN_DRVID_EVDEV:
result |= in_evdev_update(dev->drv_data, dev->binds);
break;
+#endif
+#ifdef IN_GP2X
+ case IN_DRVID_GP2X:
+ result |= in_gp2x_update(dev->drv_data, dev->binds);
+ break;
#endif
}
}
void in_set_blocking(int is_blocking)
{
- int i;
+ int i, ret;
- for (i = 0; i < in_dev_count; i++) {
- if (in_devices[i].probed)
- DRV(in_devices[i].drv_id).set_blocking(in_devices[i].drv_data, is_blocking);
+ /* have_async_devs means we will have to do all reads async anyway.. */
+ if (!in_have_async_devs) {
+ for (i = 0; i < in_dev_count; i++) {
+ if (in_devices[i].probed)
+ DRV(in_devices[i].drv_id).set_blocking(in_devices[i].drv_data, is_blocking);
+ }
}
menu_key_state = 0;
+
/* flush events */
- in_update_keycode(NULL, NULL, 0);
+ do {
+ ret = in_update_keycode(NULL, NULL, 0);
+ } while (ret >= 0);
}
-/* TODO: move.. */
-#include <unistd.h>
+static int in_update_kc_async(int *dev_id_out, int *is_down_out, int timeout_ms)
+{
+ int i, is_down, result;
+ unsigned int ticks;
+
+ ticks = plat_get_ticks_ms();
+
+ while (1)
+ {
+ for (i = 0; i < in_dev_count; i++) {
+ in_dev_t *d = &in_devices[i];
+ if (!d->probed)
+ continue;
+
+ result = DRV(d->drv_id).update_keycode(d->drv_data, &is_down);
+ if (result == -1)
+ continue;
+
+ if (dev_id_out)
+ *dev_id_out = i;
+ if (is_down_out)
+ *is_down_out = is_down;
+ return result;
+ }
+
+ if (timeout_ms >= 0 && (int)(plat_get_ticks_ms() - ticks) > timeout_ms)
+ break;
+
+ plat_sleep_ms(10);
+ }
+
+ return -1;
+}
/*
- * update with wait for a press, always return some keycode
+ * wait for a press, always return some keycode or -1 on timeout or error
*/
int in_update_keycode(int *dev_id_out, int *is_down_out, int timeout_ms)
{
- int result = 0, dev_id = 0, is_down, result_menu;
+ int result = -1, dev_id = 0, is_down, result_menu;
int fds_hnds[IN_MAX_DEVS];
int i, ret, count = 0;
+ unsigned int ticks;
in_drv_t *drv;
+ if (in_have_async_devs) {
+ result = in_update_kc_async(&dev_id, &is_down, timeout_ms);
+ if (result == -1)
+ return -1;
+ drv = &DRV(in_devices[dev_id].drv_id);
+ goto finish;
+ }
+
+ ticks = plat_get_ticks_ms();
+
for (i = 0; i < in_dev_count; i++) {
if (in_devices[i].probed)
fds_hnds[count++] = in_devices[i].drv_fd_hnd;
exit(1);
}
-again:
- /* TODO: move this block to platform/linux */
+ while (1)
{
- struct timeval tv, *timeout = NULL;
- int fdmax = -1;
- fd_set fdset;
-
- if (timeout_ms >= 0) {
- tv.tv_sec = timeout_ms / 1000;
- tv.tv_usec = (timeout_ms % 1000) * 1000;
- timeout = &tv;
- }
-
- FD_ZERO(&fdset);
- for (i = 0; i < count; i++) {
- if (fds_hnds[i] > fdmax) fdmax = fds_hnds[i];
- FD_SET(fds_hnds[i], &fdset);
- }
+ ret = plat_wait_event(fds_hnds, count, timeout_ms);
+ if (ret < 0)
+ break;
- ret = select(fdmax + 1, &fdset, NULL, NULL, timeout);
- if (ret == -1)
- {
- perror("input: select failed");
- sleep(1);
- return 0;
+ for (i = 0; i < in_dev_count; i++) {
+ if (in_devices[i].drv_fd_hnd == ret) {
+ dev_id = i;
+ break;
+ }
}
- if (ret == 0)
- return 0; /* timeout */
+ drv = &DRV(in_devices[dev_id].drv_id);
+ result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
- for (i = 0; i < count; i++)
- if (FD_ISSET(fds_hnds[i], &fdset))
- ret = fds_hnds[i];
- }
-
- for (i = 0; i < in_dev_count; i++) {
- if (in_devices[i].drv_fd_hnd == ret) {
- dev_id = i;
+ /* update_keycode() might return -1 when some not interesting
+ * event happened, like sync event for evdev. */
+ if (result >= 0)
break;
+
+ if (timeout_ms >= 0) {
+ unsigned int ticks2 = plat_get_ticks_ms();
+ timeout_ms -= ticks2 - ticks;
+ ticks = ticks2;
+ if (timeout_ms <= 0)
+ break;
}
}
- drv = &DRV(in_devices[dev_id].drv_id);
- result = drv->update_keycode(in_devices[dev_id].drv_data, &is_down);
-
- /* update_keycode() might return 0 when some not interesting
- * event happened, like sync event for evdev.
- * XXX: timeout restarts.. */
- if (result == 0)
- goto again;
-
+ if (result == -1)
+ return -1;
+finish:
/* keep track of menu key state, to allow mixing
* in_update_keycode() and in_menu_wait_any() calls */
result_menu = drv->menu_translate(result);
int code, is_down = 0, dev_id = 0;
code = in_update_keycode(&dev_id, &is_down, timeout_ms);
- code = DRV(in_devices[dev_id].drv_id).menu_translate(code);
+ if (code >= 0)
+ code = DRV(in_devices[dev_id].drv_id).menu_translate(code);
if (timeout_ms >= 0)
break;
- if (code == 0)
+ if (code < 0)
continue;
if (keys_old != menu_key_state)
break;
}
/* wait for menu input, do autorepeat */
-int in_menu_wait(int interesting)
+int in_menu_wait(int interesting, int autorep_delay_ms)
{
static int inp_prev = 0;
static int repeats = 0;
int ret, release = 0, wait = 666;
if (repeats)
- wait = 33;
+ wait = autorep_delay_ms;
ret = in_menu_wait_any(wait);
if (ret == inp_prev)
return in_bind_count(in_devices[dev_id].drv_id);
}
-const char *in_get_dev_name(int dev_id, int must_be_active)
+const char *in_get_dev_name(int dev_id, int must_be_active, int skip_pfix)
{
+ const char *name, *tmp;
+
if (dev_id < 0 || dev_id >= IN_MAX_DEVS)
return NULL;
if (must_be_active && !in_devices[dev_id].probed)
return NULL;
- return in_devices[dev_id].name;
+
+ name = in_devices[dev_id].name;
+ if (name == NULL)
+ return NULL;
+
+ tmp = strchr(name, ':');
+ if (tmp != NULL)
+ name = tmp + 1;
+
+ return name;
}
/* never returns NULL */
in_drivers[i].get_key_name = in_def_get_key_name;
}
+#ifdef IN_GP2X
+ in_gp2x_init(&in_drivers[IN_DRVID_GP2X]);
+#endif
#ifdef IN_EVDEV
in_evdev_init(&in_drivers[IN_DRVID_EVDEV]);
#endif
notaz.gp2x.de / libpicofe.git / blobdiff