aboutsummaryrefslogtreecommitdiffstats
path: root/distrib/sdl-1.2.15/src/joystick/linux
diff options
context:
space:
mode:
Diffstat (limited to 'distrib/sdl-1.2.15/src/joystick/linux')
-rw-r--r--distrib/sdl-1.2.15/src/joystick/linux/SDL_sysjoystick.c1218
1 files changed, 1218 insertions, 0 deletions
diff --git a/distrib/sdl-1.2.15/src/joystick/linux/SDL_sysjoystick.c b/distrib/sdl-1.2.15/src/joystick/linux/SDL_sysjoystick.c
new file mode 100644
index 0000000..ee43974
--- /dev/null
+++ b/distrib/sdl-1.2.15/src/joystick/linux/SDL_sysjoystick.c
@@ -0,0 +1,1218 @@
+/*
+ SDL - Simple DirectMedia Layer
+ Copyright (C) 1997-2012 Sam Lantinga
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+ Sam Lantinga
+ slouken@libsdl.org
+*/
+#include "SDL_config.h"
+
+#ifdef SDL_JOYSTICK_LINUX
+
+/* This is the system specific header for the SDL joystick API */
+
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <limits.h> /* For the definition of PATH_MAX */
+#include <linux/joystick.h>
+#if SDL_INPUT_LINUXEV
+#include <linux/input.h>
+#endif
+
+#include "SDL_joystick.h"
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+
+/* Special joystick configurations */
+static struct {
+ const char *name;
+ int naxes;
+ int nhats;
+ int nballs;
+} special_joysticks[] = {
+ { "MadCatz Panther XL", 3, 2, 1 }, /* We don't handle rudder (axis 8) */
+ { "SideWinder Precision Pro", 4, 1, 0 },
+ { "SideWinder 3D Pro", 4, 1, 0 },
+ { "Microsoft SideWinder 3D Pro", 4, 1, 0 },
+ { "Microsoft SideWinder Precision Pro", 4, 1, 0 },
+ { "Microsoft SideWinder Dual Strike USB version 1.0", 2, 1, 0 },
+ { "WingMan Interceptor", 3, 3, 0 },
+ { "WingMan Extreme Digital 3D", 4, 1, 0 },
+ { "Microsoft SideWinder Precision 2 Joystick", 4, 1, 0 },
+ { "Logitech Inc. WingMan Extreme Digital 3D", 4, 1, 0 },
+ { "Saitek Saitek X45", 6, 1, 0 }
+};
+
+/* It looks like newer kernels have the logical mapping at the driver level */
+#define NO_LOGICAL_JOYSTICKS
+
+#ifndef NO_LOGICAL_JOYSTICKS
+
+/*
+ Some USB HIDs show up as a single joystick even though they actually
+ control 2 or more joysticks.
+*/
+/*
+ This code handles the MP-8800 (Quad) and MP-8866 (Dual), which can
+ be identified by their transparent blue design. It's quite trivial
+ to add other joysticks with similar quirky behavior.
+ -id
+*/
+
+struct joystick_logical_mapping {
+ int njoy;
+ int nthing;
+};
+
+/*
+ {logical joy, logical axis},
+ {logical joy, logical hat},
+ {logical joy, logical ball},
+ {logical joy, logical button}
+*/
+
+static struct joystick_logical_mapping mp88xx_1_logical_axismap[] = {
+ {0,0},{0,1},{0,2},{0,3},{0,4},{0,5}
+};
+static struct joystick_logical_mapping mp88xx_1_logical_buttonmap[] = {
+ {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11}
+};
+
+static struct joystick_logical_mapping mp88xx_2_logical_axismap[] = {
+ {0,0},{0,1},{0,2},{1,0},{1,1},{0,3},
+ {1,2},{1,3},{0,4},{0,5},{1,4},{1,5}
+};
+static struct joystick_logical_mapping mp88xx_2_logical_buttonmap[] = {
+ {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},
+ {1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}
+};
+
+static struct joystick_logical_mapping mp88xx_3_logical_axismap[] = {
+ {0,0},{0,1},{0,2},{1,0},{1,1},{0,3},
+ {1,2},{1,3},{2,0},{2,1},{2,2},{2,3},
+ {0,4},{0,5},{1,4},{1,5},{2,4},{2,5}
+};
+static struct joystick_logical_mapping mp88xx_3_logical_buttonmap[] = {
+ {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},
+ {1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11},
+ {2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}
+};
+
+static struct joystick_logical_mapping mp88xx_4_logical_axismap[] = {
+ {0,0},{0,1},{0,2},{1,0},{1,1},{0,3},
+ {1,2},{1,3},{2,0},{2,1},{2,2},{2,3},
+ {3,0},{3,1},{3,2},{3,3},{0,4},{0,5},
+ {1,4},{1,5},{2,4},{2,5},{3,4},{3,5}
+};
+static struct joystick_logical_mapping mp88xx_4_logical_buttonmap[] = {
+ {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},{0,9},{0,10},{0,11},
+ {1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11},
+ {2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11},
+ {3,0},{3,1},{3,2},{3,3},{3,4},{3,5},{3,6},{3,7},{3,8},{3,9},{3,10},{3,11}
+};
+
+struct joystick_logical_layout {
+ int naxes;
+ int nhats;
+ int nballs;
+ int nbuttons;
+};
+
+static struct joystick_logical_layout mp88xx_1_logical_layout[] = {
+ {6, 0, 0, 12}
+};
+static struct joystick_logical_layout mp88xx_2_logical_layout[] = {
+ {6, 0, 0, 12},
+ {6, 0, 0, 12}
+};
+static struct joystick_logical_layout mp88xx_3_logical_layout[] = {
+ {6, 0, 0, 12},
+ {6, 0, 0, 12},
+ {6, 0, 0, 12}
+};
+static struct joystick_logical_layout mp88xx_4_logical_layout[] = {
+ {6, 0, 0, 12},
+ {6, 0, 0, 12},
+ {6, 0, 0, 12},
+ {6, 0, 0, 12}
+};
+
+/*
+ This array sets up a means of mapping a single physical joystick to
+ multiple logical joysticks. (djm)
+
+ njoys
+ the number of logical joysticks
+
+ layouts
+ an array of layout structures, one to describe each logical joystick
+
+ axes, hats, balls, buttons
+ arrays that map a physical thingy to a logical thingy
+ */
+struct joystick_logicalmap {
+ const char *name;
+ int nbuttons;
+ int njoys;
+ struct joystick_logical_layout *layout;
+ struct joystick_logical_mapping *axismap;
+ struct joystick_logical_mapping *hatmap;
+ struct joystick_logical_mapping *ballmap;
+ struct joystick_logical_mapping *buttonmap;
+};
+
+static struct joystick_logicalmap joystick_logicalmap[] = {
+ {
+ "WiseGroup.,Ltd MP-8866 Dual USB Joypad",
+ 12,
+ 1,
+ mp88xx_1_logical_layout,
+ mp88xx_1_logical_axismap,
+ NULL,
+ NULL,
+ mp88xx_1_logical_buttonmap
+ },
+ {
+ "WiseGroup.,Ltd MP-8866 Dual USB Joypad",
+ 24,
+ 2,
+ mp88xx_2_logical_layout,
+ mp88xx_2_logical_axismap,
+ NULL,
+ NULL,
+ mp88xx_2_logical_buttonmap
+ },
+ {
+ "WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+ 12,
+ 1,
+ mp88xx_1_logical_layout,
+ mp88xx_1_logical_axismap,
+ NULL,
+ NULL,
+ mp88xx_1_logical_buttonmap
+ },
+ {
+ "WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+ 24,
+ 2,
+ mp88xx_2_logical_layout,
+ mp88xx_2_logical_axismap,
+ NULL,
+ NULL,
+ mp88xx_2_logical_buttonmap
+ },
+ {
+ "WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+ 36,
+ 3,
+ mp88xx_3_logical_layout,
+ mp88xx_3_logical_axismap,
+ NULL,
+ NULL,
+ mp88xx_3_logical_buttonmap
+ },
+ {
+ "WiseGroup.,Ltd MP-8800 Quad USB Joypad",
+ 48,
+ 4,
+ mp88xx_4_logical_layout,
+ mp88xx_4_logical_axismap,
+ NULL,
+ NULL,
+ mp88xx_4_logical_buttonmap
+ }
+};
+
+/* find the head of a linked list, given a point in it
+ */
+#define SDL_joylist_head(i, start)\
+ for(i = start; SDL_joylist[i].fname == NULL;) i = SDL_joylist[i].prev;
+
+#define SDL_logical_joydecl(d) d
+
+
+#else
+
+#define SDL_logical_joydecl(d)
+
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+/* The maximum number of joysticks we'll detect */
+#define MAX_JOYSTICKS 32
+
+/* A list of available joysticks */
+static struct
+{
+ char* fname;
+#ifndef NO_LOGICAL_JOYSTICKS
+ SDL_Joystick* joy;
+ struct joystick_logicalmap* map;
+ int prev;
+ int next;
+ int logicalno;
+#endif /* USE_LOGICAL_JOYSTICKS */
+} SDL_joylist[MAX_JOYSTICKS];
+
+
+/* The private structure used to keep track of a joystick */
+struct joystick_hwdata {
+ int fd;
+ /* The current linux joystick driver maps hats to two axes */
+ struct hwdata_hat {
+ int axis[2];
+ } *hats;
+ /* The current linux joystick driver maps balls to two axes */
+ struct hwdata_ball {
+ int axis[2];
+ } *balls;
+
+ /* Support for the Linux 2.4 unified input interface */
+#if SDL_INPUT_LINUXEV
+ SDL_bool is_hid;
+ Uint8 key_map[KEY_MAX-BTN_MISC];
+ Uint8 abs_map[ABS_MAX];
+ struct axis_correct {
+ int used;
+ int coef[3];
+ } abs_correct[ABS_MAX];
+#endif
+};
+
+
+#ifndef NO_LOGICAL_JOYSTICKS
+
+static int CountLogicalJoysticks(int max)
+{
+ register int i, j, k, ret, prev;
+ const char* name;
+ int nbuttons, fd;
+ unsigned char n;
+
+ ret = 0;
+
+ for(i = 0; i < max; i++) {
+ name = SDL_SYS_JoystickName(i);
+
+ fd = open(SDL_joylist[i].fname, O_RDONLY, 0);
+ if ( fd >= 0 ) {
+ if ( ioctl(fd, JSIOCGBUTTONS, &n) < 0 ) {
+ nbuttons = -1;
+ } else {
+ nbuttons = n;
+ }
+ close(fd);
+ }
+ else {
+ nbuttons=-1;
+ }
+
+ if (name) {
+ for(j = 0; j < SDL_arraysize(joystick_logicalmap); j++) {
+ if (!SDL_strcmp(name, joystick_logicalmap[j].name) && (nbuttons==-1 || nbuttons==joystick_logicalmap[j].nbuttons)) {
+ prev = i;
+ SDL_joylist[prev].map = &(joystick_logicalmap[j]);
+
+ for(k = 1; k < joystick_logicalmap[j].njoys; k++) {
+ SDL_joylist[prev].next = max + ret;
+ SDL_joylist[max+ret].prev = prev;
+
+ prev = max + ret;
+ SDL_joylist[prev].logicalno = k;
+ SDL_joylist[prev].map = &(joystick_logicalmap[j]);
+ ret++;
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+ return ret;
+}
+
+static void LogicalSuffix(int logicalno, char* namebuf, int len)
+{
+ register int slen;
+ const static char suffixs[] =
+ "01020304050607080910111213141516171819"
+ "20212223242526272829303132";
+ const char* suffix;
+ slen = SDL_strlen(namebuf);
+ suffix = NULL;
+
+ if (logicalno*2<sizeof(suffixs))
+ suffix = suffixs + (logicalno*2);
+
+ if (slen + 4 < len && suffix) {
+ namebuf[slen++] = ' ';
+ namebuf[slen++] = '#';
+ namebuf[slen++] = suffix[0];
+ namebuf[slen++] = suffix[1];
+ namebuf[slen++] = 0;
+ }
+}
+
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+#if SDL_INPUT_LINUXEV
+#define test_bit(nr, addr) \
+ (((1UL << ((nr) % (sizeof(long) * 8))) & ((addr)[(nr) / (sizeof(long) * 8)])) != 0)
+#define NBITS(x) ((((x)-1)/(sizeof(long) * 8))+1)
+
+static int EV_IsJoystick(int fd)
+{
+ unsigned long evbit[NBITS(EV_MAX)] = { 0 };
+ unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
+ unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
+
+ if ( (ioctl(fd, EVIOCGBIT(0, sizeof(evbit)), evbit) < 0) ||
+ (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
+ (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0) ) {
+ return(0);
+ }
+ if (!(test_bit(EV_KEY, evbit) && test_bit(EV_ABS, evbit) &&
+ test_bit(ABS_X, absbit) && test_bit(ABS_Y, absbit) &&
+ (test_bit(BTN_TRIGGER, keybit) || test_bit(BTN_A, keybit) || test_bit(BTN_1, keybit)))) return 0;
+ return(1);
+}
+
+#endif /* SDL_INPUT_LINUXEV */
+
+/* Function to scan the system for joysticks */
+int SDL_SYS_JoystickInit(void)
+{
+ /* The base path of the joystick devices */
+ const char *joydev_pattern[] = {
+#if SDL_INPUT_LINUXEV
+ "/dev/input/event%d",
+#endif
+ "/dev/input/js%d",
+ "/dev/js%d"
+ };
+ int numjoysticks;
+ int i, j;
+ int fd;
+ char path[PATH_MAX];
+ dev_t dev_nums[MAX_JOYSTICKS]; /* major/minor device numbers */
+ struct stat sb;
+ int n, duplicate;
+
+ numjoysticks = 0;
+
+ /* First see if the user specified one or more joysticks to use */
+ if ( SDL_getenv("SDL_JOYSTICK_DEVICE") != NULL ) {
+ char *envcopy, *envpath, *delim;
+ envcopy = SDL_strdup(SDL_getenv("SDL_JOYSTICK_DEVICE"));
+ envpath = envcopy;
+ while ( envpath != NULL ) {
+ delim = SDL_strchr(envpath, ':');
+ if ( delim != NULL ) {
+ *delim++ = '\0';
+ }
+ if ( stat(envpath, &sb) == 0 ) {
+ fd = open(envpath, O_RDONLY, 0);
+ if ( fd >= 0 ) {
+ /* Assume the user knows what they're doing. */
+ SDL_joylist[numjoysticks].fname = SDL_strdup(envpath);
+ if ( SDL_joylist[numjoysticks].fname ) {
+ dev_nums[numjoysticks] = sb.st_rdev;
+ ++numjoysticks;
+ }
+ close(fd);
+ }
+ }
+ envpath = delim;
+ }
+ SDL_free(envcopy);
+ }
+
+ for ( i=0; i<SDL_arraysize(joydev_pattern); ++i ) {
+ for ( j=0; j < MAX_JOYSTICKS; ++j ) {
+ SDL_snprintf(path, SDL_arraysize(path), joydev_pattern[i], j);
+
+ /* rcg06302000 replaced access(F_OK) call with stat().
+ * stat() will fail if the file doesn't exist, so it's
+ * equivalent behaviour.
+ */
+ if ( stat(path, &sb) == 0 ) {
+ /* Check to make sure it's not already in list.
+ * This happens when we see a stick via symlink.
+ */
+ duplicate = 0;
+ for (n=0; (n<numjoysticks) && !duplicate; ++n) {
+ if ( sb.st_rdev == dev_nums[n] ) {
+ duplicate = 1;
+ }
+ }
+ if (duplicate) {
+ continue;
+ }
+
+ fd = open(path, O_RDONLY, 0);
+ if ( fd < 0 ) {
+ continue;
+ }
+#if SDL_INPUT_LINUXEV
+#ifdef DEBUG_INPUT_EVENTS
+ printf("Checking %s\n", path);
+#endif
+ if ( (i == 0) && ! EV_IsJoystick(fd) ) {
+ close(fd);
+ continue;
+ }
+#endif
+ close(fd);
+
+ /* We're fine, add this joystick */
+ SDL_joylist[numjoysticks].fname = SDL_strdup(path);
+ if ( SDL_joylist[numjoysticks].fname ) {
+ dev_nums[numjoysticks] = sb.st_rdev;
+ ++numjoysticks;
+ }
+ }
+ }
+
+#if SDL_INPUT_LINUXEV
+ /* This is a special case...
+ If the event devices are valid then the joystick devices
+ will be duplicates but without extra information about their
+ hats or balls. Unfortunately, the event devices can't
+ currently be calibrated, so it's a win-lose situation.
+ So : /dev/input/eventX = /dev/input/jsY = /dev/jsY
+ */
+ if ( (i == 0) && (numjoysticks > 0) )
+ break;
+#endif
+ }
+#ifndef NO_LOGICAL_JOYSTICKS
+ numjoysticks += CountLogicalJoysticks(numjoysticks);
+#endif
+
+ return(numjoysticks);
+}
+
+/* Function to get the device-dependent name of a joystick */
+const char *SDL_SYS_JoystickName(int index)
+{
+ int fd;
+ static char namebuf[128];
+ char *name;
+ SDL_logical_joydecl(int oindex = index);
+
+#ifndef NO_LOGICAL_JOYSTICKS
+ SDL_joylist_head(index, index);
+#endif
+ name = NULL;
+ fd = open(SDL_joylist[index].fname, O_RDONLY, 0);
+ if ( fd >= 0 ) {
+ if (
+#if SDL_INPUT_LINUXEV
+ (ioctl(fd, EVIOCGNAME(sizeof(namebuf)), namebuf) <= 0) &&
+#endif
+ (ioctl(fd, JSIOCGNAME(sizeof(namebuf)), namebuf) <= 0) ) {
+ name = SDL_joylist[index].fname;
+ } else {
+ name = namebuf;
+ }
+ close(fd);
+
+
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (SDL_joylist[oindex].prev || SDL_joylist[oindex].next || index!=oindex)
+ {
+ LogicalSuffix(SDL_joylist[oindex].logicalno, namebuf, 128);
+ }
+#endif
+ }
+ return name;
+}
+
+static int allocate_hatdata(SDL_Joystick *joystick)
+{
+ int i;
+
+ joystick->hwdata->hats = (struct hwdata_hat *)SDL_malloc(
+ joystick->nhats * sizeof(struct hwdata_hat));
+ if ( joystick->hwdata->hats == NULL ) {
+ return(-1);
+ }
+ for ( i=0; i<joystick->nhats; ++i ) {
+ joystick->hwdata->hats[i].axis[0] = 1;
+ joystick->hwdata->hats[i].axis[1] = 1;
+ }
+ return(0);
+}
+
+static int allocate_balldata(SDL_Joystick *joystick)
+{
+ int i;
+
+ joystick->hwdata->balls = (struct hwdata_ball *)SDL_malloc(
+ joystick->nballs * sizeof(struct hwdata_ball));
+ if ( joystick->hwdata->balls == NULL ) {
+ return(-1);
+ }
+ for ( i=0; i<joystick->nballs; ++i ) {
+ joystick->hwdata->balls[i].axis[0] = 0;
+ joystick->hwdata->balls[i].axis[1] = 0;
+ }
+ return(0);
+}
+
+static SDL_bool JS_ConfigJoystick(SDL_Joystick *joystick, int fd)
+{
+ SDL_bool handled;
+ unsigned char n;
+ int tmp_naxes, tmp_nhats, tmp_nballs;
+ const char *name;
+ char *env, env_name[128];
+ int i;
+
+ handled = SDL_FALSE;
+
+ /* Default joystick device settings */
+ if ( ioctl(fd, JSIOCGAXES, &n) < 0 ) {
+ joystick->naxes = 2;
+ } else {
+ joystick->naxes = n;
+ }
+ if ( ioctl(fd, JSIOCGBUTTONS, &n) < 0 ) {
+ joystick->nbuttons = 2;
+ } else {
+ joystick->nbuttons = n;
+ }
+
+ name = SDL_SYS_JoystickName(joystick->index);
+
+ /* Generic analog joystick support */
+ if ( SDL_strstr(name, "Analog") == name && SDL_strstr(name, "-hat") ) {
+ if ( SDL_sscanf(name,"Analog %d-axis %*d-button %d-hat",
+ &tmp_naxes, &tmp_nhats) == 2 ) {
+
+ joystick->naxes = tmp_naxes;
+ joystick->nhats = tmp_nhats;
+
+ handled = SDL_TRUE;
+ }
+ }
+
+ /* Special joystick support */
+ for ( i=0; i < SDL_arraysize(special_joysticks); ++i ) {
+ if ( SDL_strcmp(name, special_joysticks[i].name) == 0 ) {
+
+ joystick->naxes = special_joysticks[i].naxes;
+ joystick->nhats = special_joysticks[i].nhats;
+ joystick->nballs = special_joysticks[i].nballs;
+
+ handled = SDL_TRUE;
+ break;
+ }
+ }
+
+ /* User environment joystick support */
+ if ( (env = SDL_getenv("SDL_LINUX_JOYSTICK")) ) {
+ *env_name = '\0';
+ if ( *env == '\'' && SDL_sscanf(env, "'%[^']s'", env_name) == 1 )
+ env += SDL_strlen(env_name)+2;
+ else if ( SDL_sscanf(env, "%s", env_name) == 1 )
+ env += SDL_strlen(env_name);
+
+ if ( SDL_strcmp(name, env_name) == 0 ) {
+
+ if ( SDL_sscanf(env, "%d %d %d", &tmp_naxes, &tmp_nhats,
+ &tmp_nballs) == 3 ) {
+
+ joystick->naxes = tmp_naxes;
+ joystick->nhats = tmp_nhats;
+ joystick->nballs = tmp_nballs;
+
+ handled = SDL_TRUE;
+ }
+ }
+ }
+
+ /* Remap hats and balls */
+ if (handled) {
+ if ( joystick->nhats > 0 ) {
+ if ( allocate_hatdata(joystick) < 0 ) {
+ joystick->nhats = 0;
+ }
+ }
+ if ( joystick->nballs > 0 ) {
+ if ( allocate_balldata(joystick) < 0 ) {
+ joystick->nballs = 0;
+ }
+ }
+ }
+
+ return(handled);
+}
+
+#if SDL_INPUT_LINUXEV
+
+static SDL_bool EV_ConfigJoystick(SDL_Joystick *joystick, int fd)
+{
+ int i, t;
+ unsigned long keybit[NBITS(KEY_MAX)] = { 0 };
+ unsigned long absbit[NBITS(ABS_MAX)] = { 0 };
+ unsigned long relbit[NBITS(REL_MAX)] = { 0 };
+
+ /* See if this device uses the new unified event API */
+ if ( (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) >= 0) &&
+ (ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) >= 0) &&
+ (ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relbit)), relbit) >= 0) ) {
+ joystick->hwdata->is_hid = SDL_TRUE;
+
+ /* Get the number of buttons, axes, and other thingamajigs */
+ for ( i=BTN_JOYSTICK; i < KEY_MAX; ++i ) {
+ if ( test_bit(i, keybit) ) {
+#ifdef DEBUG_INPUT_EVENTS
+ printf("Joystick has button: 0x%x\n", i);
+#endif
+ joystick->hwdata->key_map[i-BTN_MISC] =
+ joystick->nbuttons;
+ ++joystick->nbuttons;
+ }
+ }
+ for ( i=BTN_MISC; i < BTN_JOYSTICK; ++i ) {
+ if ( test_bit(i, keybit) ) {
+#ifdef DEBUG_INPUT_EVENTS
+ printf("Joystick has button: 0x%x\n", i);
+#endif
+ joystick->hwdata->key_map[i-BTN_MISC] =
+ joystick->nbuttons;
+ ++joystick->nbuttons;
+ }
+ }
+ for ( i=0; i<ABS_MISC; ++i ) {
+ /* Skip hats */
+ if ( i == ABS_HAT0X ) {
+ i = ABS_HAT3Y;
+ continue;
+ }
+ if ( test_bit(i, absbit) ) {
+ struct input_absinfo absinfo;
+
+ if ( ioctl(fd, EVIOCGABS(i), &absinfo) < 0 )
+ continue;
+#ifdef DEBUG_INPUT_EVENTS
+ printf("Joystick has absolute axis: %x\n", i);
+ printf("Values = { %d, %d, %d, %d, %d }\n",
+ absinfo.value, absinfo.minimum,
+ absinfo.maximum, absinfo.fuzz, absinfo.flat);
+#endif /* DEBUG_INPUT_EVENTS */
+ joystick->hwdata->abs_map[i] = joystick->naxes;
+ if ( absinfo.minimum == absinfo.maximum ) {
+ joystick->hwdata->abs_correct[i].used = 0;
+ } else {
+ joystick->hwdata->abs_correct[i].used = 1;
+ joystick->hwdata->abs_correct[i].coef[0] =
+ (absinfo.maximum + absinfo.minimum) / 2 - absinfo.flat;
+ joystick->hwdata->abs_correct[i].coef[1] =
+ (absinfo.maximum + absinfo.minimum) / 2 + absinfo.flat;
+ t = ((absinfo.maximum - absinfo.minimum) / 2 - 2 * absinfo.flat);
+ if ( t != 0 ) {
+ joystick->hwdata->abs_correct[i].coef[2] = (1 << 29) / t;
+ } else {
+ joystick->hwdata->abs_correct[i].coef[2] = 0;
+ }
+ }
+ ++joystick->naxes;
+ }
+ }
+ for ( i=ABS_HAT0X; i <= ABS_HAT3Y; i += 2 ) {
+ if ( test_bit(i, absbit) || test_bit(i+1, absbit) ) {
+#ifdef DEBUG_INPUT_EVENTS
+ printf("Joystick has hat %d\n",(i-ABS_HAT0X)/2);
+#endif
+ ++joystick->nhats;
+ }
+ }
+ if ( test_bit(REL_X, relbit) || test_bit(REL_Y, relbit) ) {
+ ++joystick->nballs;
+ }
+
+ /* Allocate data to keep track of these thingamajigs */
+ if ( joystick->nhats > 0 ) {
+ if ( allocate_hatdata(joystick) < 0 ) {
+ joystick->nhats = 0;
+ }
+ }
+ if ( joystick->nballs > 0 ) {
+ if ( allocate_balldata(joystick) < 0 ) {
+ joystick->nballs = 0;
+ }
+ }
+ }
+ return(joystick->hwdata->is_hid);
+}
+
+#endif /* SDL_INPUT_LINUXEV */
+
+#ifndef NO_LOGICAL_JOYSTICKS
+static void ConfigLogicalJoystick(SDL_Joystick *joystick)
+{
+ struct joystick_logical_layout* layout;
+
+ layout = SDL_joylist[joystick->index].map->layout +
+ SDL_joylist[joystick->index].logicalno;
+
+ joystick->nbuttons = layout->nbuttons;
+ joystick->nhats = layout->nhats;
+ joystick->naxes = layout->naxes;
+ joystick->nballs = layout->nballs;
+}
+#endif
+
+
+/* Function to open a joystick for use.
+ The joystick to open is specified by the index field of the joystick.
+ This should fill the nbuttons and naxes fields of the joystick structure.
+ It returns 0, or -1 if there is an error.
+ */
+int SDL_SYS_JoystickOpen(SDL_Joystick *joystick)
+{
+ int fd;
+ SDL_logical_joydecl(int realindex);
+ SDL_logical_joydecl(SDL_Joystick *realjoy = NULL);
+
+ /* Open the joystick and set the joystick file descriptor */
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (SDL_joylist[joystick->index].fname == NULL) {
+ SDL_joylist_head(realindex, joystick->index);
+ realjoy = SDL_JoystickOpen(realindex);
+
+ if (realjoy == NULL)
+ return(-1);
+
+ fd = realjoy->hwdata->fd;
+
+ } else {
+ fd = open(SDL_joylist[joystick->index].fname, O_RDONLY, 0);
+ }
+ SDL_joylist[joystick->index].joy = joystick;
+#else
+ fd = open(SDL_joylist[joystick->index].fname, O_RDONLY, 0);
+#endif
+
+ if ( fd < 0 ) {
+ SDL_SetError("Unable to open %s\n",
+ SDL_joylist[joystick->index]);
+ return(-1);
+ }
+ joystick->hwdata = (struct joystick_hwdata *)
+ SDL_malloc(sizeof(*joystick->hwdata));
+ if ( joystick->hwdata == NULL ) {
+ SDL_OutOfMemory();
+ close(fd);
+ return(-1);
+ }
+ SDL_memset(joystick->hwdata, 0, sizeof(*joystick->hwdata));
+ joystick->hwdata->fd = fd;
+
+ /* Set the joystick to non-blocking read mode */
+ fcntl(fd, F_SETFL, O_NONBLOCK);
+
+ /* Get the number of buttons and axes on the joystick */
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (realjoy)
+ ConfigLogicalJoystick(joystick);
+ else
+#endif
+#if SDL_INPUT_LINUXEV
+ if ( ! EV_ConfigJoystick(joystick, fd) )
+#endif
+ JS_ConfigJoystick(joystick, fd);
+
+ return(0);
+}
+
+#ifndef NO_LOGICAL_JOYSTICKS
+
+static SDL_Joystick* FindLogicalJoystick(
+ SDL_Joystick *joystick, struct joystick_logical_mapping* v)
+{
+ SDL_Joystick *logicaljoy;
+ register int i;
+
+ i = joystick->index;
+ logicaljoy = NULL;
+
+ /* get the fake joystick that will receive the event
+ */
+ for(;;) {
+
+ if (SDL_joylist[i].logicalno == v->njoy) {
+ logicaljoy = SDL_joylist[i].joy;
+ break;
+ }
+
+ if (SDL_joylist[i].next == 0)
+ break;
+
+ i = SDL_joylist[i].next;
+
+ }
+
+ return logicaljoy;
+}
+
+static int LogicalJoystickButton(
+ SDL_Joystick *joystick, Uint8 button, Uint8 state){
+ struct joystick_logical_mapping* buttons;
+ SDL_Joystick *logicaljoy = NULL;
+
+ /* if there's no map then this is just a regular joystick
+ */
+ if (SDL_joylist[joystick->index].map == NULL)
+ return 0;
+
+ /* get the logical joystick that will receive the event
+ */
+ buttons = SDL_joylist[joystick->index].map->buttonmap+button;
+ logicaljoy = FindLogicalJoystick(joystick, buttons);
+
+ if (logicaljoy == NULL)
+ return 1;
+
+ SDL_PrivateJoystickButton(logicaljoy, buttons->nthing, state);
+
+ return 1;
+}
+
+static int LogicalJoystickAxis(
+ SDL_Joystick *joystick, Uint8 axis, Sint16 value)
+{
+ struct joystick_logical_mapping* axes;
+ SDL_Joystick *logicaljoy = NULL;
+
+ /* if there's no map then this is just a regular joystick
+ */
+ if (SDL_joylist[joystick->index].map == NULL)
+ return 0;
+
+ /* get the logical joystick that will receive the event
+ */
+ axes = SDL_joylist[joystick->index].map->axismap+axis;
+ logicaljoy = FindLogicalJoystick(joystick, axes);
+
+ if (logicaljoy == NULL)
+ return 1;
+
+ SDL_PrivateJoystickAxis(logicaljoy, axes->nthing, value);
+
+ return 1;
+}
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+static __inline__
+void HandleHat(SDL_Joystick *stick, Uint8 hat, int axis, int value)
+{
+ struct hwdata_hat *the_hat;
+ const Uint8 position_map[3][3] = {
+ { SDL_HAT_LEFTUP, SDL_HAT_UP, SDL_HAT_RIGHTUP },
+ { SDL_HAT_LEFT, SDL_HAT_CENTERED, SDL_HAT_RIGHT },
+ { SDL_HAT_LEFTDOWN, SDL_HAT_DOWN, SDL_HAT_RIGHTDOWN }
+ };
+ SDL_logical_joydecl(SDL_Joystick *logicaljoy = NULL);
+ SDL_logical_joydecl(struct joystick_logical_mapping* hats = NULL);
+
+ if (stick->nhats <= hat) {
+ return; /* whoops, that shouldn't happen! */
+ }
+
+ the_hat = &stick->hwdata->hats[hat];
+ if ( value < 0 ) {
+ value = 0;
+ } else
+ if ( value == 0 ) {
+ value = 1;
+ } else
+ if ( value > 0 ) {
+ value = 2;
+ }
+ if ( value != the_hat->axis[axis] ) {
+ the_hat->axis[axis] = value;
+
+#ifndef NO_LOGICAL_JOYSTICKS
+ /* if there's no map then this is just a regular joystick
+ */
+ if (SDL_joylist[stick->index].map != NULL) {
+
+ /* get the fake joystick that will receive the event
+ */
+ hats = SDL_joylist[stick->index].map->hatmap+hat;
+ logicaljoy = FindLogicalJoystick(stick, hats);
+ }
+
+ if (logicaljoy) {
+ stick = logicaljoy;
+ hat = hats->nthing;
+ }
+#endif /* USE_LOGICAL_JOYSTICKS */
+
+ SDL_PrivateJoystickHat(stick, hat,
+ position_map[the_hat->axis[1]][the_hat->axis[0]]);
+ }
+}
+
+static __inline__
+void HandleBall(SDL_Joystick *stick, Uint8 ball, int axis, int value)
+{
+ if ((stick->nballs <= ball) || (axis >= 2)) {
+ return; /* whoops, that shouldn't happen! */
+ }
+ stick->hwdata->balls[ball].axis[axis] += value;
+}
+
+/* Function to update the state of a joystick - called as a device poll.
+ * This function shouldn't update the joystick structure directly,
+ * but instead should call SDL_PrivateJoystick*() to deliver events
+ * and update joystick device state.
+ */
+static __inline__ void JS_HandleEvents(SDL_Joystick *joystick)
+{
+ struct js_event events[32];
+ int i, len;
+ Uint8 other_axis;
+
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (SDL_joylist[joystick->index].fname == NULL) {
+ SDL_joylist_head(i, joystick->index);
+ JS_HandleEvents(SDL_joylist[i].joy);
+ return;
+ }
+#endif
+
+ while ((len=read(joystick->hwdata->fd, events, (sizeof events))) > 0) {
+ len /= sizeof(events[0]);
+ for ( i=0; i<len; ++i ) {
+ switch (events[i].type & ~JS_EVENT_INIT) {
+ case JS_EVENT_AXIS:
+ if ( events[i].number < joystick->naxes ) {
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (!LogicalJoystickAxis(joystick,
+ events[i].number, events[i].value))
+#endif
+ SDL_PrivateJoystickAxis(joystick,
+ events[i].number, events[i].value);
+ break;
+ }
+ events[i].number -= joystick->naxes;
+ other_axis = (events[i].number / 2);
+ if ( other_axis < joystick->nhats ) {
+ HandleHat(joystick, other_axis,
+ events[i].number%2,
+ events[i].value);
+ break;
+ }
+ events[i].number -= joystick->nhats*2;
+ other_axis = (events[i].number / 2);
+ if ( other_axis < joystick->nballs ) {
+ HandleBall(joystick, other_axis,
+ events[i].number%2,
+ events[i].value);
+ break;
+ }
+ break;
+ case JS_EVENT_BUTTON:
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (!LogicalJoystickButton(joystick,
+ events[i].number, events[i].value))
+#endif
+ SDL_PrivateJoystickButton(joystick,
+ events[i].number, events[i].value);
+ break;
+ default:
+ /* ?? */
+ break;
+ }
+ }
+ }
+}
+#if SDL_INPUT_LINUXEV
+static __inline__ int EV_AxisCorrect(SDL_Joystick *joystick, int which, int value)
+{
+ struct axis_correct *correct;
+
+ correct = &joystick->hwdata->abs_correct[which];
+ if ( correct->used ) {
+ if ( value > correct->coef[0] ) {
+ if ( value < correct->coef[1] ) {
+ return 0;
+ }
+ value -= correct->coef[1];
+ } else {
+ value -= correct->coef[0];
+ }
+ value *= correct->coef[2];
+ value >>= 14;
+ }
+
+ /* Clamp and return */
+ if ( value < -32768 ) return -32768;
+ if ( value > 32767 ) return 32767;
+
+ return value;
+}
+
+static __inline__ void EV_HandleEvents(SDL_Joystick *joystick)
+{
+ struct input_event events[32];
+ int i, len;
+ int code;
+
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (SDL_joylist[joystick->index].fname == NULL) {
+ SDL_joylist_head(i, joystick->index);
+ return EV_HandleEvents(SDL_joylist[i].joy);
+ }
+#endif
+
+ while ((len=read(joystick->hwdata->fd, events, (sizeof events))) > 0) {
+ len /= sizeof(events[0]);
+ for ( i=0; i<len; ++i ) {
+ code = events[i].code;
+ switch (events[i].type) {
+ case EV_KEY:
+ if ( code >= BTN_MISC ) {
+ code -= BTN_MISC;
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (!LogicalJoystickButton(joystick,
+ joystick->hwdata->key_map[code],
+ events[i].value))
+#endif
+ SDL_PrivateJoystickButton(joystick,
+ joystick->hwdata->key_map[code],
+ events[i].value);
+ }
+ break;
+ case EV_ABS:
+ switch (code) {
+ case ABS_HAT0X:
+ case ABS_HAT0Y:
+ case ABS_HAT1X:
+ case ABS_HAT1Y:
+ case ABS_HAT2X:
+ case ABS_HAT2Y:
+ case ABS_HAT3X:
+ case ABS_HAT3Y:
+ code -= ABS_HAT0X;
+ HandleHat(joystick, code/2, code%2,
+ events[i].value);
+ break;
+ default:
+ events[i].value = EV_AxisCorrect(joystick, code, events[i].value);
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (!LogicalJoystickAxis(joystick,
+ joystick->hwdata->abs_map[code],
+ events[i].value))
+#endif
+ SDL_PrivateJoystickAxis(joystick,
+ joystick->hwdata->abs_map[code],
+ events[i].value);
+ break;
+ }
+ break;
+ case EV_REL:
+ switch (code) {
+ case REL_X:
+ case REL_Y:
+ code -= REL_X;
+ HandleBall(joystick, code/2, code%2,
+ events[i].value);
+ break;
+ default:
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+}
+#endif /* SDL_INPUT_LINUXEV */
+
+void SDL_SYS_JoystickUpdate(SDL_Joystick *joystick)
+{
+ int i;
+
+#if SDL_INPUT_LINUXEV
+ if ( joystick->hwdata->is_hid )
+ EV_HandleEvents(joystick);
+ else
+#endif
+ JS_HandleEvents(joystick);
+
+ /* Deliver ball motion updates */
+ for ( i=0; i<joystick->nballs; ++i ) {
+ int xrel, yrel;
+
+ xrel = joystick->hwdata->balls[i].axis[0];
+ yrel = joystick->hwdata->balls[i].axis[1];
+ if ( xrel || yrel ) {
+ joystick->hwdata->balls[i].axis[0] = 0;
+ joystick->hwdata->balls[i].axis[1] = 0;
+ SDL_PrivateJoystickBall(joystick, (Uint8)i, xrel, yrel);
+ }
+ }
+}
+
+/* Function to close a joystick after use */
+void SDL_SYS_JoystickClose(SDL_Joystick *joystick)
+{
+#ifndef NO_LOGICAL_JOYSTICKS
+ register int i;
+ if (SDL_joylist[joystick->index].fname == NULL) {
+ SDL_joylist_head(i, joystick->index);
+ SDL_JoystickClose(SDL_joylist[i].joy);
+ }
+#endif
+
+ if ( joystick->hwdata ) {
+#ifndef NO_LOGICAL_JOYSTICKS
+ if (SDL_joylist[joystick->index].fname != NULL)
+#endif
+ close(joystick->hwdata->fd);
+ if ( joystick->hwdata->hats ) {
+ SDL_free(joystick->hwdata->hats);
+ }
+ if ( joystick->hwdata->balls ) {
+ SDL_free(joystick->hwdata->balls);
+ }
+ SDL_free(joystick->hwdata);
+ joystick->hwdata = NULL;
+ }
+}
+
+/* Function to perform any system-specific joystick related cleanup */
+void SDL_SYS_JoystickQuit(void)
+{
+ int i;
+
+ for ( i=0; SDL_joylist[i].fname; ++i ) {
+ SDL_free(SDL_joylist[i].fname);
+ SDL_joylist[i].fname = NULL;
+ }
+}
+
+#endif /* SDL_JOYSTICK_LINUX */