diff options
author | 2016-02-27 16:28:05 +0100 | |
---|---|---|
committer | 2016-02-27 16:53:49 +0100 | |
commit | cf6dc7d370407914020f3e623719f09c8668c692 (patch) | |
tree | 46b3416d091b4c09b50fba7ffcbd310aed032cc8 /3rdparty/SDL2/src/haptic/linux/SDL_syshaptic.c | |
parent | 64135e73f973d9b95beb0c60b65feb34fbfec64a (diff) |
Placed SDL2 source since we need it on some platforms (nw)
Diffstat (limited to '3rdparty/SDL2/src/haptic/linux/SDL_syshaptic.c')
-rw-r--r-- | 3rdparty/SDL2/src/haptic/linux/SDL_syshaptic.c | 1162 |
1 files changed, 1162 insertions, 0 deletions
diff --git a/3rdparty/SDL2/src/haptic/linux/SDL_syshaptic.c b/3rdparty/SDL2/src/haptic/linux/SDL_syshaptic.c new file mode 100644 index 00000000000..e8d78553541 --- /dev/null +++ b/3rdparty/SDL2/src/haptic/linux/SDL_syshaptic.c @@ -0,0 +1,1162 @@ +/* + 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_HAPTIC_LINUX + +#include "SDL_assert.h" +#include "SDL_haptic.h" +#include "../SDL_syshaptic.h" +#include "SDL_joystick.h" +#include "../../joystick/SDL_sysjoystick.h" /* For the real SDL_Joystick */ +#include "../../joystick/linux/SDL_sysjoystick_c.h" /* For joystick hwdata */ +#include "../../core/linux/SDL_udev.h" + +#include <unistd.h> /* close */ +#include <linux/input.h> /* Force feedback linux stuff. */ +#include <fcntl.h> /* O_RDWR */ +#include <limits.h> /* INT_MAX */ +#include <errno.h> /* errno, strerror */ +#include <math.h> /* atan2 */ +#include <sys/stat.h> /* stat */ + +/* Just in case. */ +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + + +#define MAX_HAPTICS 32 /* It's doubtful someone has more then 32 evdev */ + +static int MaybeAddDevice(const char *path); +#if SDL_USE_LIBUDEV +static int MaybeRemoveDevice(const char *path); +void haptic_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath); +#endif /* SDL_USE_LIBUDEV */ + +/* + * List of available haptic devices. + */ +typedef struct SDL_hapticlist_item +{ + char *fname; /* Dev path name (like /dev/input/event1) */ + SDL_Haptic *haptic; /* Associated haptic. */ + dev_t dev_num; + struct SDL_hapticlist_item *next; +} SDL_hapticlist_item; + + +/* + * Haptic system hardware data. + */ +struct haptic_hwdata +{ + int fd; /* File descriptor of the device. */ + char *fname; /* Points to the name in SDL_hapticlist. */ +}; + + +/* + * Haptic system effect data. + */ +struct haptic_hweffect +{ + struct ff_effect effect; /* The linux kernel effect structure. */ +}; + +static SDL_hapticlist_item *SDL_hapticlist = NULL; +static SDL_hapticlist_item *SDL_hapticlist_tail = NULL; +static int numhaptics = 0; + +#define test_bit(nr, addr) \ + (((1UL << ((nr) & 31)) & (((const unsigned int *) addr)[(nr) >> 5])) != 0) +#define EV_TEST(ev,f) \ + if (test_bit((ev), features)) ret |= (f); +/* + * Test whether a device has haptic properties. + * Returns available properties or 0 if there are none. + */ +static int +EV_IsHaptic(int fd) +{ + unsigned int ret; + unsigned long features[1 + FF_MAX / sizeof(unsigned long)]; + + /* Ask device for what it has. */ + ret = 0; + if (ioctl(fd, EVIOCGBIT(EV_FF, sizeof(features)), features) < 0) { + return SDL_SetError("Haptic: Unable to get device's features: %s", + strerror(errno)); + } + + /* Convert supported features to SDL_HAPTIC platform-neutral features. */ + EV_TEST(FF_CONSTANT, SDL_HAPTIC_CONSTANT); + EV_TEST(FF_SINE, SDL_HAPTIC_SINE); + /* !!! FIXME: put this back when we have more bits in 2.1 */ + /* EV_TEST(FF_SQUARE, SDL_HAPTIC_SQUARE); */ + EV_TEST(FF_TRIANGLE, SDL_HAPTIC_TRIANGLE); + EV_TEST(FF_SAW_UP, SDL_HAPTIC_SAWTOOTHUP); + EV_TEST(FF_SAW_DOWN, SDL_HAPTIC_SAWTOOTHDOWN); + EV_TEST(FF_RAMP, SDL_HAPTIC_RAMP); + EV_TEST(FF_SPRING, SDL_HAPTIC_SPRING); + EV_TEST(FF_FRICTION, SDL_HAPTIC_FRICTION); + EV_TEST(FF_DAMPER, SDL_HAPTIC_DAMPER); + EV_TEST(FF_INERTIA, SDL_HAPTIC_INERTIA); + EV_TEST(FF_CUSTOM, SDL_HAPTIC_CUSTOM); + EV_TEST(FF_GAIN, SDL_HAPTIC_GAIN); + EV_TEST(FF_AUTOCENTER, SDL_HAPTIC_AUTOCENTER); + EV_TEST(FF_RUMBLE, SDL_HAPTIC_LEFTRIGHT); + + /* Return what it supports. */ + return ret; +} + + +/* + * Tests whether a device is a mouse or not. + */ +static int +EV_IsMouse(int fd) +{ + unsigned long argp[40]; + + /* Ask for supported features. */ + if (ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(argp)), argp) < 0) { + return -1; + } + + /* Currently we only test for BTN_MOUSE which can give fake positives. */ + if (test_bit(BTN_MOUSE, argp) != 0) { + return 1; + } + + return 0; +} + +/* + * Initializes the haptic subsystem by finding available devices. + */ +int +SDL_SYS_HapticInit(void) +{ + const char joydev_pattern[] = "/dev/input/event%d"; + char path[PATH_MAX]; + int i, j; + + /* + * Limit amount of checks to MAX_HAPTICS since we may or may not have + * permission to some or all devices. + */ + i = 0; + for (j = 0; j < MAX_HAPTICS; ++j) { + + snprintf(path, PATH_MAX, joydev_pattern, i++); + MaybeAddDevice(path); + } + +#if SDL_USE_LIBUDEV + if (SDL_UDEV_Init() < 0) { + return SDL_SetError("Could not initialize UDEV"); + } + + if ( SDL_UDEV_AddCallback(haptic_udev_callback) < 0) { + SDL_UDEV_Quit(); + return SDL_SetError("Could not setup haptic <-> udev callback"); + } +#endif /* SDL_USE_LIBUDEV */ + + return numhaptics; +} + +int +SDL_SYS_NumHaptics() +{ + return numhaptics; +} + +static SDL_hapticlist_item * +HapticByDevIndex(int device_index) +{ + SDL_hapticlist_item *item = SDL_hapticlist; + + if ((device_index < 0) || (device_index >= numhaptics)) { + return NULL; + } + + while (device_index > 0) { + SDL_assert(item != NULL); + --device_index; + item = item->next; + } + + return item; +} + +#if SDL_USE_LIBUDEV +void haptic_udev_callback(SDL_UDEV_deviceevent udev_type, int udev_class, const char *devpath) +{ + if (devpath == NULL || !(udev_class & SDL_UDEV_DEVICE_JOYSTICK)) { + return; + } + + switch( udev_type ) + { + case SDL_UDEV_DEVICEADDED: + MaybeAddDevice(devpath); + break; + + case SDL_UDEV_DEVICEREMOVED: + MaybeRemoveDevice(devpath); + break; + + default: + break; + } + +} +#endif /* SDL_USE_LIBUDEV */ + +static int +MaybeAddDevice(const char *path) +{ + struct stat sb; + int fd; + int success; + SDL_hapticlist_item *item; + + if (path == NULL) { + return -1; + } + + /* check to see if file exists */ + if (stat(path, &sb) != 0) { + return -1; + } + + /* check for duplicates */ + for (item = SDL_hapticlist; item != NULL; item = item->next) { + if (item->dev_num == sb.st_rdev) { + return -1; /* duplicate. */ + } + } + + /* try to open */ + fd = open(path, O_RDWR, 0); + if (fd < 0) { + return -1; + } + +#ifdef DEBUG_INPUT_EVENTS + printf("Checking %s\n", path); +#endif + + /* see if it works */ + success = EV_IsHaptic(fd); + close(fd); + if (success <= 0) { + return -1; + } + + item = (SDL_hapticlist_item *) SDL_calloc(1, sizeof (SDL_hapticlist_item)); + if (item == NULL) { + return -1; + } + + item->fname = SDL_strdup(path); + if (item->fname == NULL) { + SDL_free(item); + return -1; + } + + item->dev_num = sb.st_rdev; + + /* TODO: should we add instance IDs? */ + if (SDL_hapticlist_tail == NULL) { + SDL_hapticlist = SDL_hapticlist_tail = item; + } else { + SDL_hapticlist_tail->next = item; + SDL_hapticlist_tail = item; + } + + ++numhaptics; + + /* !!! TODO: Send a haptic add event? */ + + return numhaptics; +} + +#if SDL_USE_LIBUDEV +static int +MaybeRemoveDevice(const char* path) +{ + SDL_hapticlist_item *item; + SDL_hapticlist_item *prev = NULL; + + if (path == NULL) { + return -1; + } + + for (item = SDL_hapticlist; item != NULL; item = item->next) { + /* found it, remove it. */ + if (SDL_strcmp(path, item->fname) == 0) { + const int retval = item->haptic ? item->haptic->index : -1; + + if (prev != NULL) { + prev->next = item->next; + } else { + SDL_assert(SDL_hapticlist == item); + SDL_hapticlist = item->next; + } + if (item == SDL_hapticlist_tail) { + SDL_hapticlist_tail = prev; + } + + /* Need to decrement the haptic count */ + --numhaptics; + /* !!! TODO: Send a haptic remove event? */ + + SDL_free(item->fname); + SDL_free(item); + return retval; + } + prev = item; + } + + return -1; +} +#endif /* SDL_USE_LIBUDEV */ + +/* + * Gets the name from a file descriptor. + */ +static const char * +SDL_SYS_HapticNameFromFD(int fd) +{ + static char namebuf[128]; + + /* We use the evdev name ioctl. */ + if (ioctl(fd, EVIOCGNAME(sizeof(namebuf)), namebuf) <= 0) { + return NULL; + } + + return namebuf; +} + + +/* + * Return the name of a haptic device, does not need to be opened. + */ +const char * +SDL_SYS_HapticName(int index) +{ + SDL_hapticlist_item *item; + int fd; + const char *name; + + item = HapticByDevIndex(index); + /* Open the haptic device. */ + name = NULL; + fd = open(item->fname, O_RDONLY, 0); + + if (fd >= 0) { + + name = SDL_SYS_HapticNameFromFD(fd); + if (name == NULL) { + /* No name found, return device character device */ + name = item->fname; + } + close(fd); + } + + return name; +} + + +/* + * Opens the haptic device from the file descriptor. + */ +static int +SDL_SYS_HapticOpenFromFD(SDL_Haptic * haptic, int fd) +{ + /* Allocate the hwdata */ + haptic->hwdata = (struct haptic_hwdata *) + SDL_malloc(sizeof(*haptic->hwdata)); + if (haptic->hwdata == NULL) { + SDL_OutOfMemory(); + goto open_err; + } + SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata)); + + /* Set the data. */ + haptic->hwdata->fd = fd; + haptic->supported = EV_IsHaptic(fd); + haptic->naxes = 2; /* Hardcoded for now, not sure if it's possible to find out. */ + + /* Set the effects */ + if (ioctl(fd, EVIOCGEFFECTS, &haptic->neffects) < 0) { + SDL_SetError("Haptic: Unable to query device memory: %s", + strerror(errno)); + goto open_err; + } + haptic->nplaying = haptic->neffects; /* Linux makes no distinction. */ + haptic->effects = (struct haptic_effect *) + SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects); + if (haptic->effects == NULL) { + SDL_OutOfMemory(); + goto open_err; + } + /* Clear the memory */ + SDL_memset(haptic->effects, 0, + sizeof(struct haptic_effect) * haptic->neffects); + + return 0; + + /* Error handling */ + open_err: + close(fd); + if (haptic->hwdata != NULL) { + SDL_free(haptic->hwdata); + haptic->hwdata = NULL; + } + return -1; +} + + +/* + * Opens a haptic device for usage. + */ +int +SDL_SYS_HapticOpen(SDL_Haptic * haptic) +{ + int fd; + int ret; + SDL_hapticlist_item *item; + + item = HapticByDevIndex(haptic->index); + /* Open the character device */ + fd = open(item->fname, O_RDWR, 0); + if (fd < 0) { + return SDL_SetError("Haptic: Unable to open %s: %s", + item->fname, strerror(errno)); + } + + /* Try to create the haptic. */ + ret = SDL_SYS_HapticOpenFromFD(haptic, fd); /* Already closes on error. */ + if (ret < 0) { + return -1; + } + + /* Set the fname. */ + haptic->hwdata->fname = SDL_strdup( item->fname ); + return 0; +} + + +/* + * Opens a haptic device from first mouse it finds for usage. + */ +int +SDL_SYS_HapticMouse(void) +{ + int fd; + int device_index = 0; + SDL_hapticlist_item *item; + + for (item = SDL_hapticlist; item; item = item->next) { + /* Open the device. */ + fd = open(item->fname, O_RDWR, 0); + if (fd < 0) { + return SDL_SetError("Haptic: Unable to open %s: %s", + item->fname, strerror(errno)); + } + + /* Is it a mouse? */ + if (EV_IsMouse(fd)) { + close(fd); + return device_index; + } + + close(fd); + + ++device_index; + } + + return -1; +} + + +/* + * Checks to see if a joystick has haptic features. + */ +int +SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick) +{ + return EV_IsHaptic(joystick->hwdata->fd); +} + + +/* + * Checks to see if the haptic device and joystick are in reality the same. + */ +int +SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick) +{ + /* We are assuming Linux is using evdev which should trump the old + * joystick methods. */ + if (SDL_strcmp(joystick->hwdata->fname, haptic->hwdata->fname) == 0) { + return 1; + } + return 0; +} + + +/* + * Opens a SDL_Haptic from a SDL_Joystick. + */ +int +SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick) +{ + int device_index = 0; + int fd; + int ret; + SDL_hapticlist_item *item; + + /* Find the joystick in the haptic list. */ + for (item = SDL_hapticlist; item; item = item->next) { + if (SDL_strcmp(item->fname, joystick->hwdata->fname) == 0) { + break; + } + ++device_index; + } + haptic->index = device_index; + + if (device_index >= MAX_HAPTICS) { + return SDL_SetError("Haptic: Joystick doesn't have Haptic capabilities"); + } + + fd = open(joystick->hwdata->fname, O_RDWR, 0); + if (fd < 0) { + return SDL_SetError("Haptic: Unable to open %s: %s", + joystick->hwdata->fname, strerror(errno)); + } + ret = SDL_SYS_HapticOpenFromFD(haptic, fd); /* Already closes on error. */ + if (ret < 0) { + return -1; + } + + haptic->hwdata->fname = SDL_strdup( joystick->hwdata->fname ); + + return 0; +} + + +/* + * Closes the haptic device. + */ +void +SDL_SYS_HapticClose(SDL_Haptic * haptic) +{ + if (haptic->hwdata) { + + /* Free effects. */ + SDL_free(haptic->effects); + haptic->effects = NULL; + haptic->neffects = 0; + + /* Clean up */ + close(haptic->hwdata->fd); + + /* Free */ + SDL_free(haptic->hwdata->fname); + SDL_free(haptic->hwdata); + haptic->hwdata = NULL; + } + + /* Clear the rest. */ + SDL_memset(haptic, 0, sizeof(SDL_Haptic)); +} + + +/* + * Clean up after system specific haptic stuff + */ +void +SDL_SYS_HapticQuit(void) +{ + SDL_hapticlist_item *item = NULL; + SDL_hapticlist_item *next = NULL; + + for (item = SDL_hapticlist; item; item = next) { + next = item->next; + /* Opened and not closed haptics are leaked, this is on purpose. + * Close your haptic devices after usage. */ + SDL_free(item->fname); + item->fname = NULL; + } + +#if SDL_USE_LIBUDEV + SDL_UDEV_DelCallback(haptic_udev_callback); + SDL_UDEV_Quit(); +#endif /* SDL_USE_LIBUDEV */ + + numhaptics = 0; + SDL_hapticlist = NULL; + SDL_hapticlist_tail = NULL; +} + + +/* + * Converts an SDL button to a ff_trigger button. + */ +static Uint16 +SDL_SYS_ToButton(Uint16 button) +{ + Uint16 ff_button; + + ff_button = 0; + + /* + * Not sure what the proper syntax is because this actually isn't implemented + * in the current kernel from what I've seen (2.6.26). + */ + if (button != 0) { + ff_button = BTN_GAMEPAD + button - 1; + } + + return ff_button; +} + + +/* + * Initializes the ff_effect usable direction from a SDL_HapticDirection. + */ +static int +SDL_SYS_ToDirection(Uint16 *dest, SDL_HapticDirection * src) +{ + Uint32 tmp; + + switch (src->type) { + case SDL_HAPTIC_POLAR: + /* Linux directions start from south. + (and range from 0 to 0xFFFF) + Quoting include/linux/input.h, line 926: + Direction of the effect is encoded as follows: + 0 deg -> 0x0000 (down) + 90 deg -> 0x4000 (left) + 180 deg -> 0x8000 (up) + 270 deg -> 0xC000 (right) + The force pulls into the direction specified by Linux directions, + i.e. the opposite convention of SDL directions. + */ + tmp = ((src->dir[0] % 36000) * 0x8000) / 18000; /* convert to range [0,0xFFFF] */ + *dest = (Uint16) tmp; + break; + + case SDL_HAPTIC_SPHERICAL: + /* + We convert to polar, because that's the only supported direction on Linux. + The first value of a spherical direction is practically the same as a + Polar direction, except that we have to add 90 degrees. It is the angle + from EAST {1,0} towards SOUTH {0,1}. + --> add 9000 + --> finally convert to [0,0xFFFF] as in case SDL_HAPTIC_POLAR. + */ + tmp = ((src->dir[0]) + 9000) % 36000; /* Convert to polars */ + tmp = (tmp * 0x8000) / 18000; /* convert to range [0,0xFFFF] */ + *dest = (Uint16) tmp; + break; + + case SDL_HAPTIC_CARTESIAN: + if (!src->dir[1]) + *dest = (src->dir[0] >= 0 ? 0x4000 : 0xC000); + else if (!src->dir[0]) + *dest = (src->dir[1] >= 0 ? 0x8000 : 0); + else { + float f = atan2(src->dir[1], src->dir[0]); /* Ideally we'd use fixed point math instead of floats... */ + /* + atan2 takes the parameters: Y-axis-value and X-axis-value (in that order) + - Y-axis-value is the second coordinate (from center to SOUTH) + - X-axis-value is the first coordinate (from center to EAST) + We add 36000, because atan2 also returns negative values. Then we practically + have the first spherical value. Therefore we proceed as in case + SDL_HAPTIC_SPHERICAL and add another 9000 to get the polar value. + --> add 45000 in total + --> finally convert to [0,0xFFFF] as in case SDL_HAPTIC_POLAR. + */ + tmp = (((Sint32) (f * 18000. / M_PI)) + 45000) % 36000; + tmp = (tmp * 0x8000) / 18000; /* convert to range [0,0xFFFF] */ + *dest = (Uint16) tmp; + } + break; + + default: + return SDL_SetError("Haptic: Unsupported direction type."); + } + + return 0; +} + + +#define CLAMP(x) (((x) > 32767) ? 32767 : x) +/* + * Initializes the Linux effect struct from a haptic_effect. + * Values above 32767 (for unsigned) are unspecified so we must clamp. + */ +static int +SDL_SYS_ToFFEffect(struct ff_effect *dest, SDL_HapticEffect * src) +{ + SDL_HapticConstant *constant; + SDL_HapticPeriodic *periodic; + SDL_HapticCondition *condition; + SDL_HapticRamp *ramp; + SDL_HapticLeftRight *leftright; + + /* Clear up */ + SDL_memset(dest, 0, sizeof(struct ff_effect)); + + switch (src->type) { + case SDL_HAPTIC_CONSTANT: + constant = &src->constant; + + /* Header */ + dest->type = FF_CONSTANT; + if (SDL_SYS_ToDirection(&dest->direction, &constant->direction) == -1) + return -1; + + /* Replay */ + dest->replay.length = (constant->length == SDL_HAPTIC_INFINITY) ? + 0 : CLAMP(constant->length); + dest->replay.delay = CLAMP(constant->delay); + + /* Trigger */ + dest->trigger.button = SDL_SYS_ToButton(constant->button); + dest->trigger.interval = CLAMP(constant->interval); + + /* Constant */ + dest->u.constant.level = constant->level; + + /* Envelope */ + dest->u.constant.envelope.attack_length = + CLAMP(constant->attack_length); + dest->u.constant.envelope.attack_level = + CLAMP(constant->attack_level); + dest->u.constant.envelope.fade_length = CLAMP(constant->fade_length); + dest->u.constant.envelope.fade_level = CLAMP(constant->fade_level); + + break; + + case SDL_HAPTIC_SINE: + /* !!! FIXME: put this back when we have more bits in 2.1 */ + /* case SDL_HAPTIC_SQUARE: */ + case SDL_HAPTIC_TRIANGLE: + case SDL_HAPTIC_SAWTOOTHUP: + case SDL_HAPTIC_SAWTOOTHDOWN: + periodic = &src->periodic; + + /* Header */ + dest->type = FF_PERIODIC; + if (SDL_SYS_ToDirection(&dest->direction, &periodic->direction) == -1) + return -1; + + /* Replay */ + dest->replay.length = (periodic->length == SDL_HAPTIC_INFINITY) ? + 0 : CLAMP(periodic->length); + dest->replay.delay = CLAMP(periodic->delay); + + /* Trigger */ + dest->trigger.button = SDL_SYS_ToButton(periodic->button); + dest->trigger.interval = CLAMP(periodic->interval); + + /* Periodic */ + if (periodic->type == SDL_HAPTIC_SINE) + dest->u.periodic.waveform = FF_SINE; + /* !!! FIXME: put this back when we have more bits in 2.1 */ + /* else if (periodic->type == SDL_HAPTIC_SQUARE) + dest->u.periodic.waveform = FF_SQUARE; */ + else if (periodic->type == SDL_HAPTIC_TRIANGLE) + dest->u.periodic.waveform = FF_TRIANGLE; + else if (periodic->type == SDL_HAPTIC_SAWTOOTHUP) + dest->u.periodic.waveform = FF_SAW_UP; + else if (periodic->type == SDL_HAPTIC_SAWTOOTHDOWN) + dest->u.periodic.waveform = FF_SAW_DOWN; + dest->u.periodic.period = CLAMP(periodic->period); + dest->u.periodic.magnitude = periodic->magnitude; + dest->u.periodic.offset = periodic->offset; + /* Linux phase is defined in interval "[0x0000, 0x10000[", corresponds with "[0deg, 360deg[" phase shift. */ + dest->u.periodic.phase = ((Uint32)periodic->phase * 0x10000U) / 36000; + + /* Envelope */ + dest->u.periodic.envelope.attack_length = + CLAMP(periodic->attack_length); + dest->u.periodic.envelope.attack_level = + CLAMP(periodic->attack_level); + dest->u.periodic.envelope.fade_length = CLAMP(periodic->fade_length); + dest->u.periodic.envelope.fade_level = CLAMP(periodic->fade_level); + + break; + + case SDL_HAPTIC_SPRING: + case SDL_HAPTIC_DAMPER: + case SDL_HAPTIC_INERTIA: + case SDL_HAPTIC_FRICTION: + condition = &src->condition; + + /* Header */ + if (condition->type == SDL_HAPTIC_SPRING) + dest->type = FF_SPRING; + else if (condition->type == SDL_HAPTIC_DAMPER) + dest->type = FF_DAMPER; + else if (condition->type == SDL_HAPTIC_INERTIA) + dest->type = FF_INERTIA; + else if (condition->type == SDL_HAPTIC_FRICTION) + dest->type = FF_FRICTION; + dest->direction = 0; /* Handled by the condition-specifics. */ + + /* Replay */ + dest->replay.length = (condition->length == SDL_HAPTIC_INFINITY) ? + 0 : CLAMP(condition->length); + dest->replay.delay = CLAMP(condition->delay); + + /* Trigger */ + dest->trigger.button = SDL_SYS_ToButton(condition->button); + dest->trigger.interval = CLAMP(condition->interval); + + /* Condition */ + /* X axis */ + dest->u.condition[0].right_saturation = condition->right_sat[0]; + dest->u.condition[0].left_saturation = condition->left_sat[0]; + dest->u.condition[0].right_coeff = condition->right_coeff[0]; + dest->u.condition[0].left_coeff = condition->left_coeff[0]; + dest->u.condition[0].deadband = condition->deadband[0]; + dest->u.condition[0].center = condition->center[0]; + /* Y axis */ + dest->u.condition[1].right_saturation = condition->right_sat[1]; + dest->u.condition[1].left_saturation = condition->left_sat[1]; + dest->u.condition[1].right_coeff = condition->right_coeff[1]; + dest->u.condition[1].left_coeff = condition->left_coeff[1]; + dest->u.condition[1].deadband = condition->deadband[1]; + dest->u.condition[1].center = condition->center[1]; + + /* + * There is no envelope in the linux force feedback api for conditions. + */ + + break; + + case SDL_HAPTIC_RAMP: + ramp = &src->ramp; + + /* Header */ + dest->type = FF_RAMP; + if (SDL_SYS_ToDirection(&dest->direction, &ramp->direction) == -1) + return -1; + + /* Replay */ + dest->replay.length = (ramp->length == SDL_HAPTIC_INFINITY) ? + 0 : CLAMP(ramp->length); + dest->replay.delay = CLAMP(ramp->delay); + + /* Trigger */ + dest->trigger.button = SDL_SYS_ToButton(ramp->button); + dest->trigger.interval = CLAMP(ramp->interval); + + /* Ramp */ + dest->u.ramp.start_level = ramp->start; + dest->u.ramp.end_level = ramp->end; + + /* Envelope */ + dest->u.ramp.envelope.attack_length = CLAMP(ramp->attack_length); + dest->u.ramp.envelope.attack_level = CLAMP(ramp->attack_level); + dest->u.ramp.envelope.fade_length = CLAMP(ramp->fade_length); + dest->u.ramp.envelope.fade_level = CLAMP(ramp->fade_level); + + break; + + case SDL_HAPTIC_LEFTRIGHT: + leftright = &src->leftright; + + /* Header */ + dest->type = FF_RUMBLE; + dest->direction = 0; + + /* Replay */ + dest->replay.length = (leftright->length == SDL_HAPTIC_INFINITY) ? + 0 : CLAMP(leftright->length); + + /* Trigger */ + dest->trigger.button = 0; + dest->trigger.interval = 0; + + /* Rumble */ + dest->u.rumble.strong_magnitude = leftright->large_magnitude; + dest->u.rumble.weak_magnitude = leftright->small_magnitude; + + break; + + + default: + return SDL_SetError("Haptic: Unknown effect type."); + } + + return 0; +} + + +/* + * Creates a new haptic effect. + */ +int +SDL_SYS_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect, + SDL_HapticEffect * base) +{ + struct ff_effect *linux_effect; + + /* Allocate the hardware effect */ + effect->hweffect = (struct haptic_hweffect *) + SDL_malloc(sizeof(struct haptic_hweffect)); + if (effect->hweffect == NULL) { + return SDL_OutOfMemory(); + } + + /* Prepare the ff_effect */ + linux_effect = &effect->hweffect->effect; + if (SDL_SYS_ToFFEffect(linux_effect, base) != 0) { + goto new_effect_err; + } + linux_effect->id = -1; /* Have the kernel give it an id */ + + /* Upload the effect */ + if (ioctl(haptic->hwdata->fd, EVIOCSFF, linux_effect) < 0) { + SDL_SetError("Haptic: Error uploading effect to the device: %s", + strerror(errno)); + goto new_effect_err; + } + + return 0; + + new_effect_err: + SDL_free(effect->hweffect); + effect->hweffect = NULL; + return -1; +} + + +/* + * Updates an effect. + * + * Note: Dynamically updating the direction can in some cases force + * the effect to restart and run once. + */ +int +SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic, + struct haptic_effect *effect, + SDL_HapticEffect * data) +{ + struct ff_effect linux_effect; + + /* Create the new effect */ + if (SDL_SYS_ToFFEffect(&linux_effect, data) != 0) { + return -1; + } + linux_effect.id = effect->hweffect->effect.id; + + /* See if it can be uploaded. */ + if (ioctl(haptic->hwdata->fd, EVIOCSFF, &linux_effect) < 0) { + return SDL_SetError("Haptic: Error updating the effect: %s", + strerror(errno)); + } + + /* Copy the new effect into memory. */ + SDL_memcpy(&effect->hweffect->effect, &linux_effect, + sizeof(struct ff_effect)); + + return effect->hweffect->effect.id; +} + + +/* + * Runs an effect. + */ +int +SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect, + Uint32 iterations) +{ + struct input_event run; + + /* Prepare to run the effect */ + run.type = EV_FF; + run.code = effect->hweffect->effect.id; + /* We don't actually have infinity here, so we just do INT_MAX which is pretty damn close. */ + run.value = (iterations > INT_MAX) ? INT_MAX : iterations; + + if (write(haptic->hwdata->fd, (const void *) &run, sizeof(run)) < 0) { + return SDL_SetError("Haptic: Unable to run the effect: %s", strerror(errno)); + } + + return 0; +} + + +/* + * Stops an effect. + */ +int +SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect) +{ + struct input_event stop; + + stop.type = EV_FF; + stop.code = effect->hweffect->effect.id; + stop.value = 0; + + if (write(haptic->hwdata->fd, (const void *) &stop, sizeof(stop)) < 0) { + return SDL_SetError("Haptic: Unable to stop the effect: %s", + strerror(errno)); + } + + return 0; +} + + +/* + * Frees the effect. + */ +void +SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect) +{ + if (ioctl(haptic->hwdata->fd, EVIOCRMFF, effect->hweffect->effect.id) < 0) { + SDL_SetError("Haptic: Error removing the effect from the device: %s", + strerror(errno)); + } + SDL_free(effect->hweffect); + effect->hweffect = NULL; +} + + +/* + * Gets the status of a haptic effect. + */ +int +SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic, + struct haptic_effect *effect) +{ +#if 0 /* Not supported atm. */ + struct input_event ie; + + ie.type = EV_FF; + ie.type = EV_FF_STATUS; + ie.code = effect->hweffect->effect.id; + + if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) { + return SDL_SetError("Haptic: Error getting device status."); + } + + return 0; +#endif + + return -1; +} + + +/* + * Sets the gain. + */ +int +SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain) +{ + struct input_event ie; + + ie.type = EV_FF; + ie.code = FF_GAIN; + ie.value = (0xFFFFUL * gain) / 100; + + if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) { + return SDL_SetError("Haptic: Error setting gain: %s", strerror(errno)); + } + + return 0; +} + + +/* + * Sets the autocentering. + */ +int +SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter) +{ + struct input_event ie; + + ie.type = EV_FF; + ie.code = FF_AUTOCENTER; + ie.value = (0xFFFFUL * autocenter) / 100; + + if (write(haptic->hwdata->fd, &ie, sizeof(ie)) < 0) { + return SDL_SetError("Haptic: Error setting autocenter: %s", strerror(errno)); + } + + return 0; +} + + +/* + * Pausing is not supported atm by linux. + */ +int +SDL_SYS_HapticPause(SDL_Haptic * haptic) +{ + return -1; +} + + +/* + * Unpausing is not supported atm by linux. + */ +int +SDL_SYS_HapticUnpause(SDL_Haptic * haptic) +{ + return -1; +} + + +/* + * Stops all the currently playing effects. + */ +int +SDL_SYS_HapticStopAll(SDL_Haptic * haptic) +{ + int i, ret; + + /* Linux does not support this natively so we have to loop. */ + for (i = 0; i < haptic->neffects; i++) { + if (haptic->effects[i].hweffect != NULL) { + ret = SDL_SYS_HapticStopEffect(haptic, &haptic->effects[i]); + if (ret < 0) { + return SDL_SetError + ("Haptic: Error while trying to stop all playing effects."); + } + } + } + return 0; +} + +#endif /* SDL_HAPTIC_LINUX */ + +/* vi: set ts=4 sw=4 expandtab: */ |