/*

Simple DirectMedia Layer

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL_config.h"

#ifdef SDL_JOYSTICK_LINUX

#ifndef SDL_INPUT_LINUXEV

#error SDL now requires a Linux 2.4+ kernel with /dev/input/event support.

#endif

/* 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>

#include "../SDL_sysjoystick.h"

#include "../SDL_joystick_c.h"

#include "SDL_sysjoystick_c.h"

/* !!! FIXME: move this somewhere else. */

#if !SDL_EVENTS_DISABLED

#include "../../events/SDL_events_c.h"

#endif

/* This isn't defined in older Linux kernel headers */

#ifndef SYN_DROPPED

#define SYN_DROPPED 3

#endif

/*

* !!! FIXME: move all the udev stuff to src/core/linux, so I can reuse it

* !!! FIXME: for audio hardware disconnects.

*/

#ifdef HAVE_LIBUDEV_H

#define SDL_USE_LIBUDEV 1

#include "SDL_loadso.h"

#include <libudev.h>

#include <sys/time.h>

#include <sys/types.h>

/* we never link directly to libudev. */

/* !!! FIXME: can we generalize this? ALSA, etc, do the same things. */

static void *udev_handle = NULL;

/* !!! FIXME: this is kinda ugly. */

static SDL_bool

load_udev_sym(const char *fn, void **addr)

{

*addr = SDL_LoadFunction(udev_handle, fn);

if (*addr == NULL) {

/* Don't call SDL_SetError(): SDL_LoadFunction already did. */

return SDL_FALSE;

}

return SDL_TRUE;

}

/* libudev entry points... */

static const char *(*UDEV_udev_device_get_action)(struct udev_device *) = NULL;

static const char *(*UDEV_udev_device_get_devnode)(struct udev_device *) = NULL;

static const char *(*UDEV_udev_device_get_property_value)(struct udev_device *, const char *) = NULL;

static struct udev_device *(*UDEV_udev_device_new_from_syspath)(struct udev *, const char *) = NULL;

static void (*UDEV_udev_device_unref)(struct udev_device *) = NULL;

static int (*UDEV_udev_enumerate_add_match_property)(struct udev_enumerate *, const char *, const char *) = NULL;

static int (*UDEV_udev_enumerate_add_match_subsystem)(struct udev_enumerate *, const char *) = NULL;

static struct udev_list_entry *(*UDEV_udev_enumerate_get_list_entry)(struct udev_enumerate *) = NULL;

static struct udev_enumerate *(*UDEV_udev_enumerate_new)(struct udev *) = NULL;

static int (*UDEV_udev_enumerate_scan_devices)(struct udev_enumerate *) = NULL;

static void (*UDEV_udev_enumerate_unref)(struct udev_enumerate *) = NULL;

static const char *(*UDEV_udev_list_entry_get_name)(struct udev_list_entry *) = NULL;

static struct udev_list_entry *(*UDEV_udev_list_entry_get_next)(struct udev_list_entry *) = NULL;

static int (*UDEV_udev_monitor_enable_receiving)(struct udev_monitor *) = NULL;

static int (*UDEV_udev_monitor_filter_add_match_subsystem_devtype)(struct udev_monitor *, const char *, const char *) = NULL;

static int (*UDEV_udev_monitor_get_fd)(struct udev_monitor *) = NULL;

static struct udev_monitor *(*UDEV_udev_monitor_new_from_netlink)(struct udev *, const char *) = NULL;

static struct udev_device *(*UDEV_udev_monitor_receive_device)(struct udev_monitor *) = NULL;

static void (*UDEV_udev_monitor_unref)(struct udev_monitor *) = NULL;

static struct udev *(*UDEV_udev_new)(void) = NULL;

static void (*UDEV_udev_unref)(struct udev *) = NULL;

static int

load_udev_syms(void)

{

/* cast funcs to char* first, to please GCC's strict aliasing rules. */

#define SDL_UDEV_SYM(x) \

if (!load_udev_sym(#x, (void **) (char *) &UDEV_##x)) return -1

SDL_UDEV_SYM(udev_device_get_action);

SDL_UDEV_SYM(udev_device_get_devnode);

SDL_UDEV_SYM(udev_device_get_property_value);

SDL_UDEV_SYM(udev_device_new_from_syspath);

SDL_UDEV_SYM(udev_device_unref);

SDL_UDEV_SYM(udev_enumerate_add_match_property);

SDL_UDEV_SYM(udev_enumerate_add_match_subsystem);

SDL_UDEV_SYM(udev_enumerate_get_list_entry);

SDL_UDEV_SYM(udev_enumerate_new);

SDL_UDEV_SYM(udev_enumerate_scan_devices);

SDL_UDEV_SYM(udev_enumerate_unref);

SDL_UDEV_SYM(udev_list_entry_get_name);

SDL_UDEV_SYM(udev_list_entry_get_next);

SDL_UDEV_SYM(udev_monitor_enable_receiving);

SDL_UDEV_SYM(udev_monitor_filter_add_match_subsystem_devtype);

SDL_UDEV_SYM(udev_monitor_get_fd);

SDL_UDEV_SYM(udev_monitor_new_from_netlink);

SDL_UDEV_SYM(udev_monitor_receive_device);

SDL_UDEV_SYM(udev_monitor_unref);

SDL_UDEV_SYM(udev_new);

SDL_UDEV_SYM(udev_unref);

#undef SDL_UDEV_SYM

return 0;

}

static void

UnloadUDEVLibrary(void)

{

if (udev_handle != NULL) {

SDL_UnloadObject(udev_handle);

udev_handle = NULL;

}

}

static int

LoadUDEVLibrary(void)

{

int retval = 0;

if (udev_handle == NULL) {

udev_handle = SDL_LoadObject(udev_library);

if (udev_handle == NULL) {

retval = -1;

/* Don't call SDL_SetError(): SDL_LoadObject already did. */

} else {

retval = load_udev_syms();

if (retval < 0) {

UnloadUDEVLibrary();

}

}

}

return retval;

}

static struct udev *udev = NULL;

static struct udev_monitor *udev_mon = NULL;

#endif

/* A linked list of available joysticks */

typedef struct SDL_joylist_item

int device_instance;

char *path; /* "/dev/input/event2" or whatever */

char *name; /* "SideWinder 3D Pro" or whatever */

dev_t devnum;

struct joystick_hwdata *hwdata;

struct SDL_joylist_item *next;

} SDL_joylist_item;

static SDL_joylist_item *SDL_joylist = NULL;

static SDL_joylist_item *SDL_joylist_tail = NULL;

static int numjoysticks = 0;

static int instance_counter = 0;

#define test_bit(nr, addr) \

#define NBITS(x) ((((x)-1)/(sizeof(long) * 8))+1)

static int

{

unsigned long evbit[NBITS(EV_MAX)] = { 0 };

unsigned long keybit[NBITS(KEY_MAX)] = { 0 };

unsigned long absbit[NBITS(ABS_MAX)] = { 0 };

struct input_id inpid;

Uint16 *guid16 = (Uint16 *) ((char *) &guid->data);

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))) {

return 0;

}

if (ioctl(fd, EVIOCGNAME(namebuflen), namebuf) < 0) {

return 0;

}

if (ioctl(fd, EVIOCGID, &inpid) < 0) {

return 0;

}

#ifdef DEBUG_JOYSTICK

printf("Joystick: %s, bustype = %d, vendor = 0x%x, product = 0x%x, version = %d\n", namebuf, inpid.bustype, inpid.vendor, inpid.product, inpid.version);

#endif

SDL_memset(guid->data, 0, sizeof(guid->data));

/* We only need 16 bits for each of these; space them out to fill 128. */

/* Byteswap so devices get same GUID on little/big endian platforms. */

*(guid16++) = SDL_SwapLE16(inpid.bustype);

*(guid16++) = 0;

if (inpid.vendor && inpid.product && inpid.version) {

*(guid16++) = SDL_SwapLE16(inpid.vendor);

*(guid16++) = 0;

*(guid16++) = SDL_SwapLE16(inpid.product);

*(guid16++) = 0;

*(guid16++) = SDL_SwapLE16(inpid.version);

*(guid16++) = 0;

} else {

SDL_strlcpy((char*)guid16, namebuf, sizeof(guid->data) - 4);

}

return 1;

}

/* !!! FIXME: I would love to dump this code and use libudev instead. */

static int

MaybeAddDevice(const char *path)

{

struct stat sb;

int fd = -1;

int isstick = 0;

char namebuf[128];

if (path == NULL) {

return -1;

}

if (stat(path, &sb) == -1) {

return -1;

}

/* Check to make sure it's not already in list. */

for (item = SDL_joylist; item != NULL; item = item->next) {

if (sb.st_rdev == item->devnum) {

return -1; /* already have this one */

}

}

fd = open(path, O_RDONLY, 0);

if (fd < 0) {

return -1;

}

#ifdef DEBUG_INPUT_EVENTS

printf("Checking %s\n", path);

#endif

isstick = IsJoystick(fd, namebuf, sizeof (namebuf), &guid);

close(fd);

if (!isstick) {

return -1;

}

item = (SDL_joylist_item *) SDL_malloc(sizeof (SDL_joylist_item));

if (item == NULL) {

return -1;

}

SDL_zerop(item);

item->devnum = sb.st_rdev;

item->path = SDL_strdup(path);

item->name = SDL_strdup(namebuf);

item->guid = guid;

if ( (item->path == NULL) || (item->name == NULL) ) {

SDL_free(item->path);

SDL_free(item->name);

SDL_free(item);

return -1;

}

item->device_instance = instance_counter++;

if (SDL_joylist_tail == NULL) {

SDL_joylist = SDL_joylist_tail = item;

} else {

SDL_joylist_tail->next = item;

SDL_joylist_tail = item;

}

return numjoysticks++;

}

/* !!! FIXME: I would love to dump this code and use libudev instead. */

static int

MaybeRemoveDevice(const char *path)

SDL_joylist_item *item;

SDL_joylist_item *prev = NULL;

if (path == NULL) {

return -1;

}

for (item = SDL_joylist; item != NULL; item = item->next) {

/* found it, remove it. */

if (SDL_strcmp(path, item->path) == 0) {

const int retval = item->device_instance;

if (item->hwdata) {

}

if (prev != NULL) {

prev->next = item->next;

} else {

SDL_assert(SDL_joylist == item);

SDL_joylist = item->next;

}

if (item == SDL_joylist_tail) {

SDL_joylist_tail = prev;

}

SDL_free(item->path);

SDL_free(item->name);

SDL_free(item);

numjoysticks--;

return retval;

}

prev = item;

}

return -1;

}

static int

JoystickInitWithoutUdev(void)

{

int i;

char path[PATH_MAX];

/* !!! FIXME: only finds sticks if they're called /dev/input/event[0..31] */

/* !!! FIXME: we could at least readdir() through /dev/input...? */

/* !!! FIXME: (or delete this and rely on libudev?) */

for (i = 0; i < 32; i++) {

SDL_snprintf(path, SDL_arraysize(path), "/dev/input/event%d", i);

MaybeAddDevice(path);

}

return numjoysticks;

}

#if SDL_USE_LIBUDEV

static int

JoystickInitWithUdev(void)

{

struct udev_enumerate *enumerate = NULL;

struct udev_list_entry *devs = NULL;

struct udev_list_entry *item = NULL;

SDL_assert(udev == NULL);

udev = UDEV_udev_new();

if (udev == NULL) {

}

udev_mon = UDEV_udev_monitor_new_from_netlink(udev, "udev");

if (udev_mon != NULL) { /* okay if it's NULL, we just lose hotplugging. */

UDEV_udev_monitor_filter_add_match_subsystem_devtype(udev_mon,

"input", NULL);

UDEV_udev_monitor_enable_receiving(udev_mon);

}

enumerate = UDEV_udev_enumerate_new(udev);

if (enumerate == NULL) {

}

UDEV_udev_enumerate_add_match_subsystem(enumerate, "input");

UDEV_udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1");

UDEV_udev_enumerate_scan_devices(enumerate);

devs = UDEV_udev_enumerate_get_list_entry(enumerate);

for (item = devs; item; item = UDEV_udev_list_entry_get_next(item)) {

const char *path = UDEV_udev_list_entry_get_name(item);

struct udev_device *dev = UDEV_udev_device_new_from_syspath(udev, path);

MaybeAddDevice(UDEV_udev_device_get_devnode(dev));

UDEV_udev_device_unref(dev);

}

UDEV_udev_enumerate_unref(enumerate);

return numjoysticks;

}

#endif

int

SDL_SYS_JoystickInit(void)

{

/* 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';

}

envpath = delim;

}

SDL_free(envcopy);

}

#if SDL_USE_LIBUDEV

if (LoadUDEVLibrary() == 0) { /* okay if this fails, FOR NOW. */

return JoystickInitWithUdev();

}

int SDL_SYS_NumJoysticks()

{

return numjoysticks;

}

static SDL_bool

HotplugUpdateAvailable(void)

{

#if SDL_USE_LIBUDEV

if (udev_mon != NULL) {

const int fd = UDEV_udev_monitor_get_fd(udev_mon);

fd_set fds;

struct timeval tv;

FD_ZERO(&fds);

FD_SET(fd, &fds);

tv.tv_sec = 0;

tv.tv_usec = 0;

if ((select(fd+1, &fds, NULL, NULL, &tv) > 0) && (FD_ISSET(fd, &fds))) {

return SDL_TRUE;

}

}

#endif

return SDL_FALSE;

}

void SDL_SYS_JoystickDetect()

{

#if SDL_USE_LIBUDEV

struct udev_device *dev = NULL;

const char *devnode = NULL;

const char *action = NULL;

const char *val = NULL;

while (HotplugUpdateAvailable()) {

dev = UDEV_udev_monitor_receive_device(udev_mon);

if (dev == NULL) {

break;

}

val = UDEV_udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK");

if ((!val) || (SDL_strcmp(val, "1") != 0)) {

continue;

}

action = UDEV_udev_device_get_action(dev);

devnode = UDEV_udev_device_get_devnode(dev);

if (SDL_strcmp(action, "add") == 0) {

const int device_index = MaybeAddDevice(devnode);

if (device_index != -1) {

/* !!! FIXME: Move this to an SDL_PrivateJoyDeviceAdded() function? */

#if !SDL_EVENTS_DISABLED

SDL_Event event;

event.type = SDL_JOYDEVICEADDED;

if (SDL_GetEventState(event.type) == SDL_ENABLE) {

event.jdevice.which = device_index;

if ( (SDL_EventOK == NULL) ||

(*SDL_EventOK) (SDL_EventOKParam, &event) ) {

SDL_PushEvent(&event);

}

}

}

} else if (SDL_strcmp(action, "remove") == 0) {

const int inst = MaybeRemoveDevice(devnode);

if (inst != -1) {

/* !!! FIXME: Move this to an SDL_PrivateJoyDeviceRemoved() function? */

#if !SDL_EVENTS_DISABLED

SDL_Event event;

event.type = SDL_JOYDEVICEREMOVED;

if (SDL_GetEventState(event.type) == SDL_ENABLE) {

event.jdevice.which = inst;

if ( (SDL_EventOK == NULL) ||

(*SDL_EventOK) (SDL_EventOKParam, &event) ) {

SDL_PushEvent(&event);

}

}

}

}

UDEV_udev_device_unref(dev);

}

#endif

}

SDL_bool SDL_SYS_JoystickNeedsPolling()

{

/*

* This results in a select() call, so technically we're polling to

* decide if we should poll, but I think this function is here because

* Windows has to do an enormous amount of work to detect new sticks,

* whereas libudev just needs to see if there's more data available on

* a socket...so this should be acceptable, I hope.

*/

return HotplugUpdateAvailable();

}

static SDL_joylist_item *

JoystickByDevIndex(int device_index)

{

SDL_joylist_item *item = SDL_joylist;

if ((device_index < 0) || (device_index >= numjoysticks)) {

return NULL;

}

while (device_index > 0) {

SDL_assert(item != NULL);

device_index--;

item = item->next;

}

return item;

}

/* Function to get the device-dependent name of a joystick */

const char *

}

/* Function to perform the mapping from device index to the instance id for this index */

SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)

{

}

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 void

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)) {

/* 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;

t = ((absinfo.maximum - absinfo.minimum) - 4 * absinfo.flat);

if (t != 0) {

joystick->hwdata->abs_correct[i].coef[2] =

} 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;

}

}

}

}

/* 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_joylist_item *item = JoystickByDevIndex(device_index);

char *fname = NULL;

int fd = -1;

fname = item->path;

fd = open(fname, O_RDONLY, 0);

joystick->hwdata = (struct joystick_hwdata *)

SDL_malloc(sizeof(*joystick->hwdata));

if (joystick->hwdata == NULL) {

close(fd);

}

SDL_memset(joystick->hwdata, 0, sizeof(*joystick->hwdata));

joystick->hwdata->fname = SDL_strdup(item->path);

if (joystick->hwdata->fname == NULL) {

SDL_free(joystick->hwdata);

joystick->hwdata = NULL;

close(fd);

}

SDL_assert(item->hwdata == NULL);

item->hwdata = joystick->hwdata;

/* Set the joystick to non-blocking read mode */

fcntl(fd, F_SETFL, O_NONBLOCK);

/* Get the number of buttons and axes on the joystick */

joystick->hwdata->fresh = 1;

return (0);

}

/* Function to determine is this joystick is attached to the system right now */

SDL_bool SDL_SYS_JoystickAttached(SDL_Joystick *joystick)

{

}

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}

};

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;

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)

{

stick->hwdata->balls[ball].axis[axis] += value;

}

static __inline__ int

{

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];

}

/* Clamp and return */

if (value < -32768)

return -32768;

if (value > 32767)

return 32767;

return value;

}

static __inline__ void

PollAllValues(SDL_Joystick * joystick)

{

struct input_absinfo absinfo;

int a, b = 0;

for (a = ABS_X; b < ABS_MAX; a++) {

switch (a) {

case ABS_HAT0X:

case ABS_HAT0Y:

case ABS_HAT1X:

case ABS_HAT1Y:

case ABS_HAT2X:

case ABS_HAT2Y:

case ABS_HAT3X:

case ABS_HAT3Y:

break;

default:

if (joystick->hwdata->abs_correct[b].used) {

if (ioctl(joystick->hwdata->fd, EVIOCGABS(a), &absinfo) >= 0) {

absinfo.value = AxisCorrect(joystick, b, absinfo.value);

#ifdef DEBUG_INPUT_EVENTS

printf("Joystick : Re-read Axis %d (%d) val= %d\n",

joystick->hwdata->abs_map[b], a, absinfo.value);

#endif

SDL_PrivateJoystickAxis(joystick,

joystick->hwdata->abs_map[b],

absinfo.value);

}

}

b++;

}

}

}

{

struct input_event events[32];

int i, len;

int code;

if (joystick->hwdata->fresh) {

PollAllValues(joystick);

joystick->hwdata->fresh = 0;

}

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;

SDL_PrivateJoystickButton(joystick,

joystick->hwdata->key_map[code],

events[i].value);

}

break;

case EV_ABS:

if (code >= ABS_MISC) {

break;

}

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 =

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;

case EV_SYN:

switch (code) {

case SYN_DROPPED :

#ifdef DEBUG_INPUT_EVENTS

#endif

PollAllValues(joystick);

break;

default:

break;

}

default:

break;

}

}

}

}

void

SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)

{

int i;

/* 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)

{

if (joystick->hwdata) {

if (joystick->hwdata->item) {

joystick->hwdata->item->hwdata = NULL;

}

SDL_free(joystick->hwdata->hats);

SDL_free(joystick->hwdata->balls);

SDL_free(joystick->hwdata->fname);

SDL_free(joystick->hwdata);

joystick->hwdata = NULL;

}

}

/* Function to perform any system-specific joystick related cleanup */

void

SDL_SYS_JoystickQuit(void)

{

SDL_joylist_item *item = NULL;

SDL_joylist_item *next = NULL;