/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>

  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_internal.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 Linux implementation of 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_assert.h"

#include "SDL_joystick.h"

#include "SDL_endian.h"

#include "../SDL_sysjoystick.h"

#include "../SDL_joystick_c.h"

#include "SDL_sysjoystick_c.h"

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

#ifndef SYN_DROPPED

#define SYN_DROPPED 3

#endif

#include "../../core/linux/SDL_udev.h"

static int MaybeAddDevice(const char *path);

#if SDL_USE_LIBUDEV

static int MaybeRemoveDevice(const char *path);

void joystick_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath);

#endif /* SDL_USE_LIBUDEV */

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

    SDL_JoystickGUID guid;

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

    (((1UL << ((nr) % (sizeof(long) * 8))) & ((addr)[(nr) / (sizeof(long) * 8)])) != 0)

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

static int

IsJoystick(int fd, char *namebuf, const size_t namebuflen, SDL_JoystickGUID *guid)

{

    struct input_id inpid;

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

#if !SDL_USE_LIBUDEV

    /* When udev is enabled we only get joystick devices here, so there's no need to test them */

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

        return 0;

    }

#endif

    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;

}

#if SDL_USE_LIBUDEV

void joystick_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath)

{

    if (devpath == NULL) {

        return;

    }

    switch (udev_type) {

        case SDL_UDEV_DEVICEADDED:

            if (!(udev_class & SDL_UDEV_DEVICE_JOYSTICK)) {

                return;

            }

            MaybeAddDevice(devpath);

            break;

        case SDL_UDEV_DEVICEREMOVED:

            MaybeRemoveDevice(devpath);

            break;

        default:

            break;

    }

}

#endif /* SDL_USE_LIBUDEV */

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

    SDL_JoystickGUID guid;

    SDL_joylist_item *item;

    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;

    }

    /* Need to increment the joystick count before we post the event */

    ++numjoysticks;

    return numjoysticks;

}

#if SDL_USE_LIBUDEV

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

                item->hwdata->item = NULL;

            }

            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;

            }

            /* Need to decrement the joystick count before we post the event */

            --numjoysticks;

            SDL_free(item->path);

            SDL_free(item->name);

            SDL_free(item);

            return retval;

        }

        prev = item;

    }

    return -1;

}

#endif

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)

{

    if (SDL_UDEV_Init() < 0) {

        return SDL_SetError("Could not initialize UDEV");

    }

    /* Set up the udev callback */

    if (SDL_UDEV_AddCallback(joystick_udev_callback) < 0) {

        SDL_UDEV_Quit();

        return SDL_SetError("Could not set up joystick <-> udev callback");

    }

    /* Force a scan to build the initial device list */

    SDL_UDEV_Scan();

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

            }

            MaybeAddDevice(envpath);

            envpath = delim;

        }

        SDL_free(envcopy);

    }

#if SDL_USE_LIBUDEV

    return JoystickInitWithUdev();

#endif

    return JoystickInitWithoutUdev();

}

int SDL_SYS_NumJoysticks()

{

    return numjoysticks;

}

void SDL_SYS_JoystickDetect()

{

#if SDL_USE_LIBUDEV

    SDL_UDEV_Poll();

#endif

}

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 *

SDL_SYS_JoystickNameForDeviceIndex(int device_index)

{

    return JoystickByDevIndex(device_index)->name;

}

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

SDL_JoystickID SDL_SYS_GetInstanceIdOfDeviceIndex(int device_index)

{

    return JoystickByDevIndex(device_index)->device_instance;

}

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_MAX; ++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: 0x%.2x\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] =