frontend: make analogs configurable

[pcsx_rearmed.git] / frontend / linux / in_evdev.c

diff --git a/frontend/linux/in_evdev.c b/frontend/linux/in_evdev.c
index 0b73302..23d2e2a 100644 (file)
--- a/frontend/linux/in_evdev.c
+++ b/frontend/linux/in_evdev.c
@@ -22,10 +22,12 @@
 #include "../common/input.h"
 #include "in_evdev.h"
 
 #include "../common/input.h"
 #include "in_evdev.h"
 

+#define MAX_ABS_DEVS 8
+

 typedef struct {
        int fd;
        int *kbits;
 typedef struct {
        int fd;
        int *kbits;

-       int abs_min_x;
+       int abs_min_x; /* abs->digital mapping */

        int abs_max_x;
        int abs_min_y;
        int abs_max_y;
        int abs_max_x;
        int abs_min_y;
        int abs_max_y;


@@ -34,6 +36,10 @@ typedef struct {
        int abs_lasty;
        int kc_first;
        int kc_last;
        int abs_lasty;
        int kc_first;
        int kc_last;

+       unsigned int abs_count;
+       int abs_mult[MAX_ABS_DEVS]; /* 16.16 multiplier to IN_ABS_RANGE */
+       int abs_adj[MAX_ABS_DEVS];  /* adjust for centering */
+       unsigned int abs_to_digital:1;

 } in_evdev_t;
 
 #ifndef KEY_CNT
 } in_evdev_t;
 
 #ifndef KEY_CNT


@@ -49,7 +55,10 @@ typedef struct {
 #define KEYBITS_BIT_CLEAR(x) (keybits[(x)/sizeof(keybits[0])/8] &= \
        ~(1 << ((x) & (sizeof(keybits[0])*8-1))))
 
 #define KEYBITS_BIT_CLEAR(x) (keybits[(x)/sizeof(keybits[0])/8] &= \
        ~(1 << ((x) & (sizeof(keybits[0])*8-1))))
 

-static const char * const in_evdev_prefix = "evdev:";
+int in_evdev_allow_abs_only;
+
+#define IN_EVDEV_PREFIX "evdev:"
+

 static const char * const in_evdev_keys[KEY_CNT] = {
        [0 ... KEY_MAX] = NULL,
        [KEY_RESERVED] = "Reserved",            [KEY_ESC] = "Esc",
 static const char * const in_evdev_keys[KEY_CNT] = {
        [0 ... KEY_MAX] = NULL,
        [KEY_RESERVED] = "Reserved",            [KEY_ESC] = "Esc",


@@ -151,7 +160,7 @@ static void in_evdev_probe(void)
        for (i = 0;; i++)
        {
                int support = 0, count = 0;
        for (i = 0;; i++)
        {
                int support = 0, count = 0;

-               int u, ret, fd, kc_first, kc_last;
+               int u, ret, fd, kc_first = KEY_MAX, kc_last = 0, have_abs = 0;

                in_evdev_t *dev;
                char name[64];
 
                in_evdev_t *dev;
                char name[64];
 


@@ -170,32 +179,28 @@ static void in_evdev_probe(void)
                        goto skip;
                }
 
                        goto skip;
                }
 

-               if (!(support & (1 << EV_KEY)))
-                       goto skip;
-
-               ret = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
-               if (ret == -1) {
-                       printf("in_evdev: ioctl failed on %s\n", name);
-                       goto skip;
-               }
+               if (support & (1 << EV_KEY)) {
+                       ret = ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
+                       if (ret == -1) {
+                               printf("in_evdev: ioctl failed on %s\n", name);
+                               goto skip;
+                       }

 
 

-               /* check for interesting keys */
-               kc_first = KEY_MAX;
-               kc_last = 0;
-               for (u = 0; u < KEY_CNT; u++) {
-                       if (KEYBITS_BIT(u)) {
-                               if (u < kc_first)
-                                       kc_first = u;
-                               if (u > kc_last)
-                                       kc_last = u;
-                               if (u != KEY_POWER && u != KEY_SLEEP && u != BTN_TOUCH)
-                                       count++;
+                       /* check for interesting keys */
+                       for (u = 0; u < KEY_CNT; u++) {
+                               if (KEYBITS_BIT(u)) {
+                                       if (u < kc_first)
+                                               kc_first = u;
+                                       if (u > kc_last)
+                                               kc_last = u;
+                                       if (u != KEY_POWER && u != KEY_SLEEP && u != BTN_TOUCH)
+                                               count++;
+                                       if (u == BTN_TOUCH) /* we can't deal with ts currently */
+                                               goto skip;
+                               }

                        }
                }
 
                        }
                }
 

-               if (count == 0)
-                       goto skip;
-

                dev = calloc(1, sizeof(*dev));
                if (dev == NULL)
                        goto skip;
                dev = calloc(1, sizeof(*dev));
                if (dev == NULL)
                        goto skip;


@@ -234,17 +239,35 @@ static void in_evdev_probe(void)
                                dev->abs_min_y = ainfo.minimum;
                                dev->abs_max_y = ainfo.maximum;
                        }
                                dev->abs_min_y = ainfo.minimum;
                                dev->abs_max_y = ainfo.maximum;
                        }

+                       for (u = 0; u < MAX_ABS_DEVS; u++) {
+                               ret = ioctl(fd, EVIOCGABS(u), &ainfo);
+                               if (ret == -1)
+                                       break;
+                               dist = ainfo.maximum - ainfo.minimum;
+                               if (dist != 0)
+                                       dev->abs_mult[u] = IN_ABS_RANGE * 2 * 65536 / dist;
+                               dev->abs_adj[u] = -(ainfo.maximum + ainfo.minimum + 1) / 2;
+                               have_abs = 1;
+                       }
+                       dev->abs_count = u;

                }
 
 no_abs:
                }
 
 no_abs:

+               if (count == 0 && !have_abs) {
+                       free(dev);
+                       goto skip;
+               }
+

                dev->fd = fd;
                dev->kc_first = kc_first;
                dev->kc_last = kc_last;
                dev->fd = fd;
                dev->kc_first = kc_first;
                dev->kc_last = kc_last;

-               strcpy(name, in_evdev_prefix);
+               if (count > 0 || in_evdev_allow_abs_only)
+                       dev->abs_to_digital = 1;
+               strcpy(name, IN_EVDEV_PREFIX);

                ioctl(fd, EVIOCGNAME(sizeof(name)-6), name+6);
                printf("in_evdev: found \"%s\" with %d events (type %08x)\n",
                        name+6, count, support);
                ioctl(fd, EVIOCGNAME(sizeof(name)-6), name+6);
                printf("in_evdev: found \"%s\" with %d events (type %08x)\n",
                        name+6, count, support);

-               in_register(name, IN_DRVID_EVDEV, fd, dev, KEY_CNT, in_evdev_keys, 0);
+               in_register(name, fd, dev, KEY_CNT, in_evdev_keys, 0);

                continue;
 
 skip:
                continue;
 
 skip:


@@ -261,9 +284,11 @@ static void in_evdev_free(void *drv_data)
        free(dev);
 }
 
        free(dev);
 }
 

-static int in_evdev_get_bind_count(void)
+static const char * const *
+in_evdev_get_key_names(int *count)

 {
 {

-       return KEY_CNT;
+       *count = KEY_CNT;
+       return in_evdev_keys;

 }
 
 static void or_binds(const int *binds, int key, int *result)
 }
 
 static void or_binds(const int *binds, int key, int *result)


@@ -275,7 +300,7 @@ static void or_binds(const int *binds, int key, int *result)
 
 /* ORs result with binds of pressed buttons
  * XXX: should measure performance hit of this func, might need to optimize */
 
 /* ORs result with binds of pressed buttons
  * XXX: should measure performance hit of this func, might need to optimize */

-int in_evdev_update(void *drv_data, const int *binds, int *result)
+static int in_evdev_update(void *drv_data, const int *binds, int *result)

 {
        struct input_event ev[16];
        struct input_absinfo ainfo;
 {
        struct input_event ev[16];
        struct input_absinfo ainfo;


@@ -318,14 +343,12 @@ int in_evdev_update(void *drv_data, const int *binds, int *result)
 
        /* map X and Y absolute to UDLR */
        lzone = dev->abs_lzone;
 
        /* map X and Y absolute to UDLR */
        lzone = dev->abs_lzone;

-       if (lzone != 0) {
+       if (dev->abs_to_digital && lzone != 0) {

                ret = ioctl(dev->fd, EVIOCGABS(ABS_X), &ainfo);
                if (ret != -1) {
                        if (ainfo.value < dev->abs_min_x + lzone) or_binds(binds, KEY_LEFT, result);
                        if (ainfo.value > dev->abs_max_x - lzone) or_binds(binds, KEY_RIGHT, result);
                }
                ret = ioctl(dev->fd, EVIOCGABS(ABS_X), &ainfo);
                if (ret != -1) {
                        if (ainfo.value < dev->abs_min_x + lzone) or_binds(binds, KEY_LEFT, result);
                        if (ainfo.value > dev->abs_max_x - lzone) or_binds(binds, KEY_RIGHT, result);
                }

-       }
-       if (lzone != 0) {

                ret = ioctl(dev->fd, EVIOCGABS(ABS_Y), &ainfo);
                if (ret != -1) {
                        if (ainfo.value < dev->abs_min_y + lzone) or_binds(binds, KEY_UP, result);
                ret = ioctl(dev->fd, EVIOCGABS(ABS_Y), &ainfo);
                if (ret != -1) {
                        if (ainfo.value < dev->abs_min_y + lzone) or_binds(binds, KEY_UP, result);


@@ -336,6 +359,24 @@ int in_evdev_update(void *drv_data, const int *binds, int *result)
        return 0;
 }
 
        return 0;
 }
 

+static int in_evdev_update_analog(void *drv_data, int axis_id, int *result)
+{
+       struct input_absinfo ainfo;
+       in_evdev_t *dev = drv_data;
+       int ret;
+
+       if ((unsigned int)axis_id >= MAX_ABS_DEVS)
+               return -1;
+
+       ret = ioctl(dev->fd, EVIOCGABS(axis_id), &ainfo);
+       if (ret != 0)
+               return ret;
+
+       *result = (ainfo.value + dev->abs_adj[axis_id]) * dev->abs_mult[axis_id];
+       *result >>= 16;
+       return 0;
+}
+

 static int in_evdev_set_blocking(in_evdev_t *dev, int y)
 {
        long flags;
 static int in_evdev_set_blocking(in_evdev_t *dev, int y)
 {
        long flags;


@@ -369,6 +410,21 @@ static int in_evdev_set_blocking(in_evdev_t *dev, int y)
        return 0;
 }
 
        return 0;
 }
 

+static int in_evdev_get_config(void *drv_data, int what, int *val)
+{
+       in_evdev_t *dev = drv_data;
+
+       switch (what) {
+       case IN_CFG_ABS_AXIS_COUNT:
+               *val = dev->abs_count;
+               break;
+       default:
+               return -1;
+       }
+
+       return 0;
+}
+

 static int in_evdev_set_config(void *drv_data, int what, int val)
 {
        in_evdev_t *dev = drv_data;
 static int in_evdev_set_config(void *drv_data, int what, int val)
 {
        in_evdev_t *dev = drv_data;


@@ -402,60 +458,60 @@ static int in_evdev_update_keycode(void *data, int *is_down)
        struct input_event ev;
        int rd;
 
        struct input_event ev;
        int rd;
 

-       while (1)
-       {
-               rd = read(dev->fd, &ev, sizeof(ev));
-               if (rd < (int) sizeof(ev)) {
-                       if (errno != EAGAIN) {
-                               perror("in_evdev: error reading");
-                               sleep(1);
-                       }
-                       goto out;
+       /* do single event, the caller sometimes wants
+        * to do select() in blocking mode */
+       rd = read(dev->fd, &ev, sizeof(ev));
+       if (rd < (int) sizeof(ev)) {
+               if (errno != EAGAIN) {
+                       perror("in_evdev: error reading");
+                       //sleep(1);
+                       ret_kc = -2;

                }
                }

+               goto out;
+       }

 
 

-               if (ev.type == EV_KEY) {
-                       if (ev.value < 0 || ev.value > 1)
-                               continue;
-                       ret_kc = ev.code;
-                       ret_down = ev.value;
+       if (ev.type == EV_KEY) {
+               if (ev.value < 0 || ev.value > 1)

                        goto out;
                        goto out;

+               ret_kc = ev.code;
+               ret_down = ev.value;
+               goto out;
+       }
+       else if (ev.type == EV_ABS && dev->abs_to_digital)
+       {
+               int lzone = dev->abs_lzone, down = 0, *last;
+
+               // map absolute to up/down/left/right
+               if (lzone != 0 && ev.code == ABS_X) {
+                       if (ev.value < dev->abs_min_x + lzone)
+                               down = KEY_LEFT;
+                       else if (ev.value > dev->abs_max_x - lzone)
+                               down = KEY_RIGHT;
+                       last = &dev->abs_lastx;

                }
                }

-               else if (ev.type == EV_ABS)
-               {
-                       int lzone = dev->abs_lzone, down = 0, *last;
-
-                       // map absolute to up/down/left/right
-                       if (lzone != 0 && ev.code == ABS_X) {
-                               if (ev.value < dev->abs_min_x + lzone)
-                                       down = KEY_LEFT;
-                               else if (ev.value > dev->abs_max_x - lzone)
-                                       down = KEY_RIGHT;
-                               last = &dev->abs_lastx;
-                       }
-                       else if (lzone != 0 && ev.code == ABS_Y) {
-                               if (ev.value < dev->abs_min_y + lzone)
-                                       down = KEY_UP;
-                               else if (ev.value > dev->abs_max_y - lzone)
-                                       down = KEY_DOWN;
-                               last = &dev->abs_lasty;
-                       }
-                       else
-                               continue;
-
-                       if (down == *last)
-                               continue;
-
-                       if (down == 0 || *last != 0) {
-                               /* key up or direction change, return up event for old key */
-                               ret_kc = *last;
-                               ret_down = 0;
-                               *last = 0;
-                               goto out;
-                       }
-                       ret_kc = *last = down;
-                       ret_down = 1;
+               else if (lzone != 0 && ev.code == ABS_Y) {
+                       if (ev.value < dev->abs_min_y + lzone)
+                               down = KEY_UP;
+                       else if (ev.value > dev->abs_max_y - lzone)
+                               down = KEY_DOWN;
+                       last = &dev->abs_lasty;
+               }
+               else
+                       goto out;
+
+               if (down == *last)
+                       goto out;
+
+               if (down == 0 || *last != 0) {
+                       /* key up or direction change, return up event for old key */
+                       ret_kc = *last;
+                       ret_down = 0;
+                       *last = 0;

                        goto out;
                }
                        goto out;
                }

+               ret_kc = *last = down;
+               ret_down = 1;
+               goto out;

        }
 
 out:
        }
 
 out:


@@ -530,48 +586,13 @@ static int in_evdev_menu_translate(void *drv_data, int keycode)
        return 0;
 }
 
        return 0;
 }
 

-/* FIXME: move to plat */
-#if 0
-static const struct {
-       short code;
-       char btype;
-       char bit;
-} in_evdev_def_binds[] =
-{
-       /* MXYZ SACB RLDU */
-       { KEY_UP,       IN_BINDTYPE_PLAYER12, 0 },
-       { KEY_DOWN,     IN_BINDTYPE_PLAYER12, 1 },
-       { KEY_LEFT,     IN_BINDTYPE_PLAYER12, 2 },
-       { KEY_RIGHT,    IN_BINDTYPE_PLAYER12, 3 },
-       { KEY_S,        IN_BINDTYPE_PLAYER12, 4 },      /* B */
-       { KEY_D,        IN_BINDTYPE_PLAYER12, 5 },      /* C */
-       { KEY_A,        IN_BINDTYPE_PLAYER12, 6 },      /* A */
-       { KEY_ENTER,    IN_BINDTYPE_PLAYER12, 7 },
-       { KEY_BACKSLASH, IN_BINDTYPE_EMU, PEVB_MENU },
-       /* Pandora */
-       { KEY_PAGEDOWN, IN_BINDTYPE_PLAYER12, 4 },
-       { KEY_END,      IN_BINDTYPE_PLAYER12, 5 },
-       { KEY_HOME,     IN_BINDTYPE_PLAYER12, 6 },
-       { KEY_LEFTALT,  IN_BINDTYPE_PLAYER12, 7 },
-       { KEY_RIGHTSHIFT,IN_BINDTYPE_EMU, PEVB_STATE_SAVE },
-       { KEY_RIGHTCTRL, IN_BINDTYPE_EMU, PEVB_STATE_LOAD },
-       { KEY_LEFTCTRL,  IN_BINDTYPE_EMU, PEVB_MENU },
-       /* Caanoo */
-       { BTN_THUMB,    IN_BINDTYPE_PLAYER12, 4 },      /* B */
-       { BTN_THUMB2,   IN_BINDTYPE_PLAYER12, 5 },      /* C */
-       { BTN_TRIGGER,  IN_BINDTYPE_PLAYER12, 6 },      /* A */
-       { BTN_BASE3,    IN_BINDTYPE_PLAYER12, 7 },
-       { BTN_TOP2,     IN_BINDTYPE_EMU, PEVB_STATE_SAVE },
-       { BTN_PINKIE,   IN_BINDTYPE_EMU, PEVB_STATE_LOAD },
-       { BTN_BASE,     IN_BINDTYPE_EMU, PEVB_MENU },
-};
-#endif
-

 static void in_evdev_get_def_binds(int *binds)
 {
        int i;
 
 static void in_evdev_get_def_binds(int *binds)
 {
        int i;
 

-       for (i = 0; in_evdev_defbinds[i].bit != 0; i++) {
+       for (i = 0; ; i++) {
+               if (in_evdev_defbinds[i].bit == 0 && in_evdev_defbinds[i].code == 0)
+                       break;

                binds[IN_BIND_OFFS(in_evdev_defbinds[i].code, in_evdev_defbinds[i].btype)] =
                        1 << in_evdev_defbinds[i].bit;
        }
                binds[IN_BIND_OFFS(in_evdev_defbinds[i].code, in_evdev_defbinds[i].btype)] =
                        1 << in_evdev_defbinds[i].bit;
        }


@@ -584,17 +605,16 @@ static int in_evdev_clean_binds(void *drv_data, int *binds, int *def_binds)
        in_evdev_t *dev = drv_data;
        int i, t, ret, offs, count = 0;
 
        in_evdev_t *dev = drv_data;
        int i, t, ret, offs, count = 0;
 

+       memset(keybits, 0, sizeof(keybits));

        ret = ioctl(dev->fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
        if (ret == -1) {
                perror("in_evdev: ioctl failed");
        ret = ioctl(dev->fd, EVIOCGBIT(EV_KEY, sizeof(keybits)), keybits);
        if (ret == -1) {
                perror("in_evdev: ioctl failed");

-               memset(keybits, 0xff, sizeof(keybits)); /* mark all as good */
+               // memset(keybits, 0xff, sizeof(keybits)); /* mark all as good */

        }
 
        }
 

-       if (dev->abs_lzone != 0) {
+       if (dev->abs_to_digital && dev->abs_lzone != 0) {

                KEYBITS_BIT_SET(KEY_LEFT);
                KEYBITS_BIT_SET(KEY_RIGHT);
                KEYBITS_BIT_SET(KEY_LEFT);
                KEYBITS_BIT_SET(KEY_RIGHT);

-       }
-       if (dev->abs_lzone != 0) {

                KEYBITS_BIT_SET(KEY_UP);
                KEYBITS_BIT_SET(KEY_DOWN);
        }
                KEYBITS_BIT_SET(KEY_UP);
                KEYBITS_BIT_SET(KEY_DOWN);
        }


@@ -612,18 +632,23 @@ static int in_evdev_clean_binds(void *drv_data, int *binds, int *def_binds)
        return count;
 }
 
        return count;
 }
 

-void in_evdev_init(void *vdrv)
+static const in_drv_t in_evdev_drv = {
+       .prefix         = IN_EVDEV_PREFIX,
+       .probe          = in_evdev_probe,
+       .free           = in_evdev_free,
+       .get_key_names  = in_evdev_get_key_names,
+       .get_def_binds  = in_evdev_get_def_binds,
+       .clean_binds    = in_evdev_clean_binds,
+       .get_config     = in_evdev_get_config,
+       .set_config     = in_evdev_set_config,
+       .update         = in_evdev_update,
+       .update_analog  = in_evdev_update_analog,
+       .update_keycode = in_evdev_update_keycode,
+       .menu_translate = in_evdev_menu_translate,
+};
+
+void in_evdev_init(void)

 {
 {

-       in_drv_t *drv = vdrv;
-
-       drv->prefix = in_evdev_prefix;
-       drv->probe = in_evdev_probe;
-       drv->free = in_evdev_free;
-       drv->get_bind_count = in_evdev_get_bind_count;
-       drv->get_def_binds = in_evdev_get_def_binds;
-       drv->clean_binds = in_evdev_clean_binds;
-       drv->set_config = in_evdev_set_config;
-       drv->update_keycode = in_evdev_update_keycode;
-       drv->menu_translate = in_evdev_menu_translate;
+       in_register_driver(&in_evdev_drv);

 }
 
 }