mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-29 22:20:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'udev'

Browse Source
This commit is contained in:
Themaister 2013-09-26 11:24:10 +02:00
commit aa882c3515
20 changed files with 803 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Makefile
View File

@ -182,6 +182,7 @@ endif
ifeq ($(HAVE_SDL), 1)
OBJ += gfx/sdl_gfx.o input/sdl_input.o input/sdl_joypad.o audio/sdl_audio.o
JOYCONFIG_OBJ += input/sdl_joypad.o
JOYCONFIG_LIBS += $(SDL_LIBS)
DEFINES += $(SDL_CFLAGS) $(BSD_LOCAL_INC)
LIBS += $(SDL_LIBS)
endif
@ -316,11 +317,19 @@ ifeq ($(HAVE_PYTHON), 1)
OBJ += gfx/py_state/py_state.o
endif
ifeq ($(HAVE_UDEV), 1)
DEFINES += $(UDEV_CFLAGS)
LIBS += $(UDEV_LIBS)
JOYCONFIG_LIBS += $(UDEV_LIBS)
OBJ += input/udev_joypad.o
JOYCONFIG_OBJ += tools/udev_joypad.o
endif
ifeq ($(HAVE_NEON),1)
OBJ += audio/sinc_neon.o
OBJ += audio/sinc_neon.o
# When compiled without this, tries to attempt to compile sinc lerp,
# which will error out
DEFINES += -DSINC_LOWER_QUALITY -DHAVE_NEON
DEFINES += -DSINC_LOWER_QUALITY -DHAVE_NEON
endif
OBJ += audio/utils.o
@ -376,9 +385,9 @@ retroarch: $(OBJ)
tools/retroarch-joyconfig: $(JOYCONFIG_OBJ)
@$(if $(Q), $(shell echo echo LD $@),)
ifeq ($(CXX_BUILD), 1)
$(Q)$(CXX) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
$(Q)$(CXX) -o $@ $(JOYCONFIG_OBJ) $(JOYCONFIG_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
else
$(Q)$(CC) -o $@ $(JOYCONFIG_OBJ) $(SDL_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
$(Q)$(CC) -o $@ $(JOYCONFIG_OBJ) $(JOYCONFIG_LIBS) $(LDFLAGS) $(LIBRARY_DIRS)
endif
tools/retrolaunch/retrolaunch: $(RETROLAUNCH_OBJ)
@ -393,6 +402,10 @@ tools/linuxraw_joypad.o: input/linuxraw_joypad.c
@$(if $(Q), $(shell echo echo CC $<),)
$(Q)$(CC) $(CFLAGS) $(DEFINES) -DIS_JOYCONFIG -c -o $@ $<
tools/udev_joypad.o: input/udev_joypad.c
@$(if $(Q), $(shell echo echo CC $<),)
$(Q)$(CC) $(CFLAGS) $(DEFINES) -DIS_JOYCONFIG -c -o $@ $<
tools/input_common_launch.o: input/input_common.c
@$(if $(Q), $(shell echo echo CC $<),)
$(Q)$(CC) $(CFLAGS) $(DEFINES) -DIS_RETROLAUNCH -c -o $@ $<

1
apple/common/apple_joypad.c
View File

@ -92,6 +92,7 @@ const rarch_joypad_driver_t apple_joypad = {
apple_joypad_button,
apple_joypad_axis,
apple_joypad_poll,
NULL,
apple_joypad_name,
"apple"
};

8
driver.c
View File

@ -309,6 +309,14 @@ void driver_set_nonblock_state(bool nonblock)
g_extern.audio_data.nonblock_chunk_size : g_extern.audio_data.block_chunk_size;
}
bool driver_set_rumble_state(unsigned port, enum retro_rumble_effect effect, bool enable)
{
if (driver.input && driver.input_data && driver.input->set_rumble)
return driver.input->set_rumble(driver.input_data, port, effect, enable);
else
return false;
}
uintptr_t driver_get_current_framebuffer(void)
{
#ifdef HAVE_FBO

4
driver.h
View File

@ -335,6 +335,7 @@ typedef struct input_driver
const char *ident;
void (*grab_mouse)(void *data, bool state);
bool (*set_rumble)(void *data, unsigned port, enum retro_rumble_effect effect, bool state);
} input_driver_t;
struct rarch_viewport;
@ -495,6 +496,9 @@ void driver_set_nonblock_state(bool nonblock);
uintptr_t driver_get_current_framebuffer(void);
retro_proc_address_t driver_get_proc_address(const char *sym);
// Used by RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE
bool driver_set_rumble_state(unsigned port, enum retro_rumble_effect effect, bool enable);
extern driver_t driver;
//////////////////////////////////////////////// Backends

9
dynamic.c
View File

@ -756,6 +756,15 @@ bool rarch_environment_cb(unsigned cmd, void *data)
break;
}
case RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE:
{
RARCH_LOG("Environ GET_RUMBLE_INTERFACE.\n");
struct retro_rumble_interface *iface = (struct retro_rumble_interface*)data;
iface->set_rumble_state = driver_set_rumble_state;
break;
}
// Private extensions for internal use, not part of libretro API.
case RETRO_ENVIRONMENT_SET_LIBRETRO_PATH:
RARCH_LOG("Environ (Private) SET_LIBRETRO_PATH.\n");

1
general.h
View File

@ -712,6 +712,7 @@ void rarch_set_fullscreen(bool fullscreen);
void rarch_disk_control_set_eject(bool state, bool log);
void rarch_disk_control_set_index(unsigned index);
void rarch_disk_control_append_image(const char *path);
bool rarch_set_rumble_state(unsigned port, enum retro_rumble_effect effect, bool enable);
void rarch_init_autosave(void);
void rarch_deinit_autosave(void);
void rarch_take_screenshot(void);

8
input/dinput.c
View File

@ -334,6 +334,12 @@ static void dinput_grab_mouse(void *data, bool state)
IDirectInputDevice8_Acquire(di->mouse);
}
static bool dinput_set_rumble(void *data, unsigned port, enum retro_rumble_effect effect, bool state)
{
struct dinput_input *di = (struct dinput_input*)data;
return input_joypad_set_rumble(di->joypad, port, effect, state);
}
const input_driver_t input_dinput = {
dinput_init,
dinput_poll,
@ -344,6 +350,7 @@ const input_driver_t input_dinput = {
"dinput",
dinput_grab_mouse,
dinput_set_rumble,
};
// Keep track of which pad indexes are 360 controllers
@ -651,6 +658,7 @@ const rarch_joypad_driver_t dinput_joypad = {
dinput_joypad_button,
dinput_joypad_axis,
dinput_joypad_poll,
NULL,
dinput_joypad_name,
"dinput",
};

16
input/input_common.c
View File

@ -51,6 +51,9 @@ static const rarch_joypad_driver_t *joypad_drivers[] = {
#if defined(__linux) && !defined(ANDROID)
&linuxraw_joypad,
#endif
#ifdef HAVE_UDEV
&udev_joypad,
#endif
#ifdef HAVE_SDL
&sdl_joypad,
#endif
@ -103,6 +106,19 @@ const char *input_joypad_name(const rarch_joypad_driver_t *driver, unsigned joyp
return driver->name(joypad);
}
bool input_joypad_set_rumble(const rarch_joypad_driver_t *driver,
unsigned port, enum retro_rumble_effect effect, bool state)
{
if (!driver || !driver->set_rumble)
return false;
int joy_index = g_settings.input.joypad_map[port];
if (joy_index < 0 || joy_index >= MAX_PLAYERS)
return false;
return driver->set_rumble(joy_index, effect, state);
}
bool input_joypad_pressed(const rarch_joypad_driver_t *driver,
unsigned port, const struct retro_keybind *binds, unsigned key)
{

5
input/input_common.h
View File

@ -66,6 +66,7 @@ typedef struct rarch_joypad_driver
bool (*button)(unsigned, uint16_t);
int16_t (*axis)(unsigned, uint32_t);
void (*poll)(void);
bool (*set_rumble)(unsigned, enum retro_rumble_effect, bool); // Optional
const char *(*name)(unsigned);
const char *ident;
@ -81,6 +82,9 @@ bool input_joypad_pressed(const rarch_joypad_driver_t *driver,
int16_t input_joypad_analog(const rarch_joypad_driver_t *driver,
unsigned port, unsigned index, unsigned id, const struct retro_keybind *binds);
bool input_joypad_set_rumble(const rarch_joypad_driver_t *driver,
unsigned port, enum retro_rumble_effect effect, bool state);
int16_t input_joypad_axis_raw(const rarch_joypad_driver_t *driver,
unsigned joypad, unsigned axis);
bool input_joypad_button_raw(const rarch_joypad_driver_t *driver,
@ -93,6 +97,7 @@ const char *input_joypad_name(const rarch_joypad_driver_t *driver, unsigned joyp
extern const rarch_joypad_driver_t dinput_joypad;
extern const rarch_joypad_driver_t linuxraw_joypad;
extern const rarch_joypad_driver_t udev_joypad;
extern const rarch_joypad_driver_t winxinput_joypad; // Named as such to avoid confusion with xb1/360 port code
extern const rarch_joypad_driver_t sdl_joypad;

10
input/linuxraw_input.c
View File

@ -285,6 +285,12 @@ static void linuxraw_input_free(void *data)
free(data);
}
static bool linuxraw_set_rumble(void *data, unsigned port, enum retro_rumble_effect effect, bool state)
{
linuxraw_input_t *linuxraw = (linuxraw_input_t*)data;
return input_joypad_set_rumble(linuxraw->joypad, port, effect, state);
}
static void linuxraw_input_poll(void *data)
{
linuxraw_input_t *linuxraw = (linuxraw_input_t*)data;
@ -316,5 +322,7 @@ const input_driver_t input_linuxraw = {
linuxraw_bind_button_pressed,
linuxraw_input_free,
NULL,
"linuxraw"
"linuxraw",
NULL,
linuxraw_set_rumble,
};

9
input/linuxraw_joypad.c
View File

@ -84,14 +84,14 @@ static bool linuxraw_joypad_init_pad(const char *path, struct linuxraw_joypad *p
{
RARCH_LOG("[Joypad]: Found pad: %s on %s.\n", pad->ident, path);
#ifndef IS_JOYCONFIG
if (g_hotplug)
{
char msg[512];
snprintf(msg, sizeof(msg), "Joypad #%u (%s) connected.", (unsigned)(pad - g_pads), pad->ident);
#ifndef IS_JOYCONFIG
msg_queue_push(g_extern.msg_queue, msg, 0, 60);
#endif
}
#endif
}
else
@ -137,14 +137,14 @@ static void handle_plugged_pad(void)
{
if (g_pads[index].fd >= 0)
{
#ifndef IS_JOYCONFIG
if (g_hotplug)
{
char msg[512];
snprintf(msg, sizeof(msg), "Joypad #%u (%s) disconnected.", index, g_pads[index].ident);
#ifndef IS_JOYCONFIG
msg_queue_push(g_extern.msg_queue, msg, 0, 60);
#endif
}
#endif
RARCH_LOG("[Joypad]: Joypad %s disconnected.\n", g_pads[index].ident);
close(g_pads[index].fd);
@ -312,6 +312,7 @@ const rarch_joypad_driver_t linuxraw_joypad = {
linuxraw_joypad_button,
linuxraw_joypad_axis,
linuxraw_joypad_poll,
NULL,
linuxraw_joypad_name,
"linuxraw",
};

8
input/sdl_input.c
View File

@ -214,6 +214,12 @@ static void sdl_input_free(void *data)
free(data);
}
static bool sdl_set_rumble(void *data, unsigned port, enum retro_rumble_effect effect, bool state)
{
sdl_input_t *sdl = (sdl_input_t*)data;
return input_joypad_set_rumble(sdl->joypad, port, effect, state);
}
static void sdl_poll_mouse(sdl_input_t *sdl)
{
Uint8 btn = SDL_GetRelativeMouseState(&sdl->mouse_x, &sdl->mouse_y);
@ -240,5 +246,7 @@ const input_driver_t input_sdl = {
sdl_input_free,
NULL,
"sdl",
NULL,
sdl_set_rumble,
};

1
input/sdl_joypad.c
View File

@ -170,6 +170,7 @@ const rarch_joypad_driver_t sdl_joypad = {
sdl_joypad_button,
sdl_joypad_axis,
sdl_joypad_poll,
NULL,
sdl_joypad_name,
"sdl",
};

645
input/udev_joypad.c Normal file
View File

@ -0,0 +1,645 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2013 - Hans-Kristian Arntzen
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "input_common.h"
#include "../general.h"
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <limits.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/poll.h>
#include <fcntl.h>
#include <libudev.h>
#include <linux/types.h>
#include <linux/input.h>
// Udev/evdev Linux joypad driver.
// More complex and extremely low level,
// but only Linux driver which can support joypad rumble.
// Uses udev for device detection + hotplug.
//
// Code adapted from SDL 2.0's implementation.
#define NUM_BUTTONS 32
#define NUM_AXES 32
#define NUM_HATS 4
struct udev_joypad
{
int fd;
dev_t device;
// Input state polled
bool buttons[NUM_BUTTONS];
int16_t axes[NUM_AXES];
int8_t hats[NUM_HATS][2];
// Maps keycodes -> button/axes
uint8_t button_bind[KEY_MAX];
uint8_t axes_bind[ABS_MAX];
struct input_absinfo absinfo[NUM_AXES];
int num_effects;
int effects[2]; // [0] - strong, [1] - weak
bool has_set_ff[2];
char *ident;
char *path;
};
static struct udev *g_udev;
static struct udev_monitor *g_udev_mon;
static struct udev_joypad g_pads[MAX_PLAYERS];
static inline int16_t compute_axis(const struct input_absinfo *info, int value)
{
int range = info->maximum - info->minimum;
int axis = (value - info->minimum) * 0xffffll / range - 0x7fffll;
if (axis > 0x7fff)
return 0x7fff;
else if (axis < -0x7fff)
return -0x7fff;
else
return axis;
}
static void poll_pad(unsigned i)
{
struct udev_joypad *pad = &g_pads[i];
if (pad->fd < 0)
return;
int len;
struct input_event events[32];
while ((len = read(pad->fd, events, sizeof(events))) > 0)
{
len /= sizeof(*events);
for (int i = 0; i < len; i++)
{
int code = events[i].code;
switch (events[i].type)
{
case EV_KEY:
if (code >= BTN_MISC)
pad->buttons[pad->button_bind[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;
pad->hats[code >> 1][code & 1] = events[i].value;
break;
}
default:
{
unsigned axis = pad->axes_bind[code];
pad->axes[axis] = compute_axis(&pad->absinfo[axis], events[i].value);
break;
}
}
break;
default:
break;
}
}
}
}
static bool hotplug_available(void)
{
if (!g_udev_mon)
return false;
struct pollfd fds = {0};
fds.fd = udev_monitor_get_fd(g_udev_mon);
fds.events = POLLIN;
return (poll(&fds, 1, 0) == 1) && (fds.revents & POLLIN);
}
static void check_device(const char *path, bool hotplugged);
static void remove_device(const char *path);
static void handle_hotplug(void)
{
struct udev_device *dev = udev_monitor_receive_device(g_udev_mon);
if (!dev)
return;
const char *val = udev_device_get_property_value(dev, "ID_INPUT_JOYSTICK");
const char *action = udev_device_get_action(dev);
const char *devnode = udev_device_get_devnode(dev);
if (!val || strcmp(val, "1") || !devnode)
goto end;
if (!strcmp(action, "add"))
{
RARCH_LOG("[udev]: Hotplug add: %s.\n", devnode);
check_device(devnode, true);
}
else if (!strcmp(action, "remove"))
{
RARCH_LOG("[udev]: Hotplug remove: %s.\n", devnode);
remove_device(devnode);
}
end:
udev_device_unref(dev);
}
static bool udev_set_rumble(unsigned i, enum retro_rumble_effect effect, bool state)
{
struct udev_joypad *pad = &g_pads[i];
if (pad->fd < 0)
return false;
if (pad->num_effects < 2)
return false;
// Have to defer the force feedback settings to here.
// For some reason, effects are getting dropped when they're set at init.
// Setting at init seems to work for pads which are hotplugged ...
//
// This approach might be cleaner in the end if we end up supporting configurable force feedback.
if (!pad->has_set_ff[effect])
{
struct ff_effect e;
memset(&e, 0, sizeof(e));
e.type = FF_RUMBLE;
e.id = -1;
switch (effect)
{
case RETRO_RUMBLE_STRONG: e.u.rumble.strong_magnitude = 0xc000; break;
case RETRO_RUMBLE_WEAK: e.u.rumble.weak_magnitude = 0xc000; break;
default: return false;
}
if (ioctl(pad->fd, EVIOCSFF, &e) < 0)
{
RARCH_ERR("Failed to set rumble effect on pad #%u.\n", i);
return false;
}
pad->has_set_ff[effect] = true;
pad->effects[effect] = e.id;
}
struct input_event play;
memset(&play, 0, sizeof(play));
play.type = EV_FF;
play.code = pad->effects[effect];
play.value = state;
if (write(pad->fd, &play, sizeof(play)) < (ssize_t)sizeof(play))
{
RARCH_ERR("[udev]: Failed to set rumble effect %u on pad %u.\n",
effect, i);
return false;
}
return true;
}
static void udev_joypad_poll(void)
{
while (hotplug_available())
handle_hotplug();
for (unsigned i = 0; i < MAX_PLAYERS; i++)
poll_pad(i);
}
#define test_bit(nr, addr) \
(((1UL << ((nr) % (sizeof(long) * CHAR_BIT))) & ((addr)[(nr) / (sizeof(long) * CHAR_BIT)])) != 0)
#define NBITS(x) ((((x) - 1) / (sizeof(long) * CHAR_BIT)) + 1)
#if 0
static void test_initial_rumble(int fd, const char *path)
{
// Check for rumble features.
unsigned long ffbit[NBITS(FF_MAX)] = {0};
if (ioctl(fd, EVIOCGBIT(EV_FF, sizeof(ffbit)), ffbit) >= 0)
{
if (test_bit(FF_RUMBLE, ffbit))
RARCH_LOG("[udev]: Pad (%s) supports force feedback.\n",
path);
int effects;
if (ioctl(fd, EVIOCGEFFECTS, &effects) >= 0)
RARCH_LOG("[udev]: Pad (%s) supports %d force feedback effects.\n", path, effects);
if (effects >= 2)
{
struct ff_effect effect;
bool support_ff[2];
int effects[2] = {-1, -1};
// Strong rumble.
memset(&effect, 0, sizeof(effect));
effect.type = FF_RUMBLE;
effect.id = -1;
effect.u.rumble.strong_magnitude = 0x8000;
effect.u.rumble.weak_magnitude = 0;
support_ff[0] = ioctl(fd, EVIOCSFF, &effect) == 0;
if (support_ff[0])
{
RARCH_LOG("[udev]: (%s) supports \"strong\" rumble effect (id %d).\n",
path, effect.id);
effects[RETRO_RUMBLE_STRONG] = effect.id; // Gets updated by ioctl().
}
// Weak rumble.
memset(&effect, 0, sizeof(effect));
effect.type = FF_RUMBLE;
effect.id = -1;
effect.u.rumble.strong_magnitude = 0;
effect.u.rumble.weak_magnitude = 0xc000;
support_ff[1] = ioctl(fd, EVIOCSFF, &effect) == 0;
if (support_ff[1])
{
RARCH_LOG("[udev]: Pad (%s) supports \"weak\" rumble effect (id %d).\n",
path, effect.id);
effects[RETRO_RUMBLE_WEAK] = effect.id;
}
struct input_event play;
memset(&play, 0, sizeof(play));
play.type = EV_FF;
play.code = effects[0];
play.value = true;
write(fd, &play, sizeof(play));
rarch_sleep(500);
play.value = false;
write(fd, &play, sizeof(play));
rarch_sleep(500);
play.code = effects[1];
play.value = true;
write(fd, &play, sizeof(play));
rarch_sleep(500);
play.value = false;
write(fd, &play, sizeof(play));
}
}
}
#endif
static int open_joystick(const char *path)
{
int fd = open(path, O_RDWR | O_NONBLOCK);
if (fd < 0)
return 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))
goto error;
// Has to at least support EV_KEY interface.
if (!test_bit(EV_KEY, evbit))
goto error;
return fd;
error:
close(fd);
return -1;
}
static int find_vacant_pad(void)
{
for (unsigned i = 0; i < MAX_PLAYERS; i++)
if (g_pads[i].fd < 0)
return i;
return -1;
}
static void free_pad(unsigned pad)
{
if (g_pads[pad].fd >= 0)
close(g_pads[pad].fd);
free(g_pads[pad].path);
if (g_pads[pad].ident)
*g_pads[pad].ident = '\0';
memset(&g_pads[pad], 0, sizeof(g_pads[pad]));
g_pads[pad].fd = -1;
g_pads[pad].ident = g_settings.input.device_names[pad];
input_config_autoconfigure_joypad(pad, NULL, NULL);
}
static bool add_pad(unsigned i, int fd, const char *path)
{
struct udev_joypad *pad = &g_pads[i];
if (ioctl(fd, EVIOCGNAME(sizeof(g_settings.input.device_names[0])), pad->ident) < 0)
{
RARCH_LOG("[udev]: Failed to get pad name.\n");
return false;
}
RARCH_LOG("[udev]: Plugged pad: %s on port #%u.\n", pad->ident, i);
struct stat st;
if (fstat(fd, &st) < 0)
return false;
unsigned long keybit[NBITS(KEY_MAX)] = {0};
unsigned long absbit[NBITS(ABS_MAX)] = {0};
if ((ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keybit)), keybit) < 0) ||
(ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absbit)), absbit) < 0))
return false;
// Go through all possible keycodes, check if they are used,
// and map them to button/axes/hat indices.
unsigned buttons = 0;
unsigned axes = 0;
for (int i = BTN_JOYSTICK; i < KEY_MAX && buttons < NUM_BUTTONS; i++)
if (test_bit(i, keybit))
pad->button_bind[i] = buttons++;
for (int i = BTN_MISC; i < BTN_JOYSTICK; i++)
if (test_bit(i, keybit))
pad->button_bind[i] = buttons++;
for (int i = 0; i < ABS_MISC && axes < NUM_AXES; i++)
{
// Skip hats for now.
if (i == ABS_HAT0X)
{
i = ABS_HAT3Y;
continue;
}
if (test_bit(i, absbit))
{
struct input_absinfo *abs = &pad->absinfo[axes];
if (ioctl(fd, EVIOCGABS(i), abs) < 0)
continue;
if (abs->maximum > abs->minimum)
{
pad->axes[axes] = compute_axis(abs, abs->value);
pad->axes_bind[i] = axes++;
}
}
}
pad->device = st.st_rdev;
pad->fd = fd;
pad->path = strdup(path);
if (*pad->ident)
input_config_autoconfigure_joypad(i, pad->ident, "udev");
// Check for rumble features.
unsigned long ffbit[NBITS(FF_MAX)] = {0};
if (ioctl(fd, EVIOCGBIT(EV_FF, sizeof(ffbit)), ffbit) >= 0)
{
if (test_bit(FF_RUMBLE, ffbit))
RARCH_LOG("[udev]: Pad #%u (%s) supports force feedback.\n",
i, path);
if (ioctl(fd, EVIOCGEFFECTS, &pad->num_effects) >= 0)
RARCH_LOG("[udev]: Pad #%u (%s) supports %d force feedback effects.\n", i, path, pad->num_effects);
}
return true;
}
static void check_device(const char *path, bool hotplugged)
{
struct stat st;
if (stat(path, &st) < 0)
return;
for (unsigned i = 0; i < MAX_PLAYERS; i++)
{
if (st.st_rdev == g_pads[i].device)
{
RARCH_LOG("[udev]: Device ID %u is already plugged.\n", (unsigned)st.st_rdev);
return;
}
}
int pad = find_vacant_pad();
if (pad < 0)
return;
int fd = open_joystick(path);
if (fd < 0)
return;
if (add_pad(pad, fd, path))
{
#ifndef IS_JOYCONFIG
if (hotplugged)
{
char msg[512];
snprintf(msg, sizeof(msg), "Joypad #%u (%s) connected.", pad, path);
msg_queue_push(g_extern.msg_queue, msg, 0, 60);
RARCH_LOG("[udev]: %s\n", msg);
}
#else
(void)hotplugged;
#endif
#if 0
test_initial_rumble(fd, path);
#endif
}
else
{
RARCH_ERR("[udev]: Failed to add pad: %s.\n", path);
close(fd);
}
}
static void remove_device(const char *path)
{
for (unsigned i = 0; i < MAX_PLAYERS; i++)
{
if (g_pads[i].path && !strcmp(g_pads[i].path, path))
{
#ifndef IS_JOYCONFIG
char msg[512];
snprintf(msg, sizeof(msg), "Joypad #%u (%s) disconnected.", i, g_pads[i].ident);
msg_queue_push(g_extern.msg_queue, msg, 0, 60);
RARCH_LOG("[udev]: %s\n", msg);
#endif
free_pad(i);
break;
}
}
}
static void udev_joypad_destroy(void)
{
for (unsigned i = 0; i < MAX_PLAYERS; i++)
free_pad(i);
if (g_udev_mon)
udev_monitor_unref(g_udev_mon);
g_udev_mon = NULL;
if (g_udev)
udev_unref(g_udev);
g_udev = NULL;
}
static bool udev_joypad_init(void)
{
for (unsigned i = 0; i < MAX_PLAYERS; i++)
{
g_pads[i].fd = -1;
g_pads[i].ident = g_settings.input.device_names[i];
}
struct udev_list_entry *devs = NULL;
struct udev_list_entry *item = NULL;
g_udev = udev_new();
if (!g_udev)
return false;
g_udev_mon = udev_monitor_new_from_netlink(g_udev, "udev");
if (g_udev_mon)
{
udev_monitor_filter_add_match_subsystem_devtype(g_udev_mon, "input", NULL);
udev_monitor_enable_receiving(g_udev_mon);
}
struct udev_enumerate *enumerate = udev_enumerate_new(g_udev);
if (!enumerate)
goto error;
udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1");
udev_enumerate_scan_devices(enumerate);
devs = udev_enumerate_get_list_entry(enumerate);
for (struct udev_list_entry *item = devs; item; item = udev_list_entry_get_next(item))
{
const char *name = udev_list_entry_get_name(item);
struct udev_device *dev = udev_device_new_from_syspath(g_udev, name);
const char *devnode = udev_device_get_devnode(dev);
if (devnode)
check_device(devnode, false);
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
return true;
error:
if (enumerate)
udev_enumerate_unref(enumerate);
udev_joypad_destroy();
return false;
}
static bool udev_joypad_hat(const struct udev_joypad *pad, uint16_t hat)
{
unsigned h = GET_HAT(hat);
if (h >= NUM_HATS)
return false;
switch (GET_HAT_DIR(hat))
{
case HAT_LEFT_MASK: return pad->hats[h][0] < 0;
case HAT_RIGHT_MASK: return pad->hats[h][0] > 0;
case HAT_UP_MASK: return pad->hats[h][1] < 0;
case HAT_DOWN_MASK: return pad->hats[h][1] > 0;
default: return 0;
}
}
static bool udev_joypad_button(unsigned port, uint16_t joykey)
{
const struct udev_joypad *pad = &g_pads[port];
if (GET_HAT_DIR(joykey))
return udev_joypad_hat(pad, joykey);
else
return joykey < NUM_BUTTONS && pad->buttons[joykey];
}
static int16_t udev_joypad_axis(unsigned port, uint32_t joyaxis)
{
if (joyaxis == AXIS_NONE)
return 0;
const struct udev_joypad *pad = &g_pads[port];
int16_t val = 0;
if (AXIS_NEG_GET(joyaxis) < NUM_AXES)
{
val = pad->axes[AXIS_NEG_GET(joyaxis)];
if (val > 0)
val = 0;
}
else if (AXIS_POS_GET(joyaxis) < NUM_AXES)
{
val = pad->axes[AXIS_POS_GET(joyaxis)];
if (val < 0)
val = 0;
}
return val;
}
static bool udev_joypad_query_pad(unsigned pad)
{
return pad < MAX_PLAYERS && g_pads[pad].fd >= 0;
}
static const char *udev_joypad_name(unsigned pad)
{
if (pad >= MAX_PLAYERS)
return NULL;
return *g_pads[pad].ident ? g_pads[pad].ident : NULL;
}
const rarch_joypad_driver_t udev_joypad = {
udev_joypad_init,
udev_joypad_query_pad,
udev_joypad_destroy,
udev_joypad_button,
udev_joypad_axis,
udev_joypad_poll,
udev_set_rumble,
udev_joypad_name,
"udev",
};

1
input/winxinput_joypad.c
View File

@ -371,6 +371,7 @@ const rarch_joypad_driver_t winxinput_joypad = {
winxinput_joypad_button,
winxinput_joypad_axis,
winxinput_joypad_poll,
NULL, // FIXME: Add rumble.
winxinput_joypad_name,
"winxinput",
};

7
input/x11_input.c
View File

@ -269,6 +269,12 @@ static void x_grab_mouse(void *data, bool state)
x11->grab_mouse = state;
}
static bool x_set_rumble(void *data, unsigned port, enum retro_rumble_effect effect, bool state)
{
x11_input_t *x11 = (x11_input_t*)data;
return input_joypad_set_rumble(x11->joypad, port, effect, state);
}
const input_driver_t input_x = {
x_input_init,
x_input_poll,
@ -278,5 +284,6 @@ const input_driver_t input_x = {
NULL,
"x",
x_grab_mouse,
x_set_rumble,
};

30
libretro-test/libretro-test.c
View File

@ -61,6 +61,8 @@ static retro_environment_t environ_cb;
static retro_input_poll_t input_poll_cb;
static retro_input_state_t input_state_cb;
static struct retro_rumble_interface rumble;
void retro_set_environment(retro_environment_t cb)
{
environ_cb = cb;
@ -173,6 +175,30 @@ static void update_input(void)
x_coord = (x_coord + dir_x) & 31;
y_coord = (y_coord + dir_y) & 31;
if (rumble.set_rumble_state)
{
static bool old_start;
static bool old_select;
bool start = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START);
bool select = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_SELECT);
if (old_start != start)
{
fprintf(stderr, "Strong rumble: %s.\n", start ? "ON": "OFF");
if (!rumble.set_rumble_state(0, RETRO_RUMBLE_STRONG, start))
fprintf(stderr, "Strong rumble; failed to set state.\n");
}
if (old_select != select)
{
fprintf(stderr, "Weak rumble: %s.\n", select ? "ON": "OFF");
if (!rumble.set_rumble_state(0, RETRO_RUMBLE_WEAK, select))
fprintf(stderr, "Weak rumble; failed to set state.\n");
}
old_start = start;
old_select = select;
}
}
static void render_checkered(void)
@ -262,6 +288,10 @@ bool retro_load_game(const struct retro_game_info *info)
struct retro_keyboard_callback cb = { keyboard_cb };
environ_cb(RETRO_ENVIRONMENT_SET_KEYBOARD_CALLBACK, &cb);
if (environ_cb(RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE, &rumble))
fprintf(stderr, "Rumble environment supported.\n");
else
fprintf(stderr, "Rumble environment not supported.\n");
check_variables();

24
libretro.h
View File

@ -514,8 +514,32 @@ enum retro_mod
// Lets the core know how much time has passed since last invocation of retro_run().
// The frontend can tamper with the timing to fake fast-forward, slow-motion, frame stepping, etc.
// In this case the delta time will use the reference value in frame_time_callback..
//
#define RETRO_ENVIRONMENT_GET_RUMBLE_INTERFACE (23 | RETRO_ENVIRONMENT_EXPERIMENTAL)
// struct retro_rumble_interface * --
// Gets an interface which is used by a libretro core to set state of rumble motors in controllers.
// A strong and weak motor is supported, and they can be controlled indepedently.
enum retro_rumble_effect
{
RETRO_RUMBLE_STRONG = 0,
RETRO_RUMBLE_WEAK = 1,
RETRO_RUMBLE_DUMMY = INT_MAX
};
// Sets rumble state for joypad plugged in port 'port'. Rumble effects are controlled independently,
// and setting e.g. strong rumble does not override weak rumble.
// Should only be called when rumble state changes.
//
// Returns true if rumble state request was honored. Calling this before first retro_run() is likely to return false.
typedef bool (*retro_set_rumble_state_t)(unsigned port, enum retro_rumble_effect effect, bool enable);
struct retro_rumble_interface
{
retro_set_rumble_state_t set_rumble_state;
};
// Notifies libretro that audio data should be written.
typedef void (*retro_audio_callback_t)(void);

4
qb/config.libs.sh
View File

@ -245,6 +245,8 @@ else
HAVE_XVIDEO='no'
fi
check_pkgconf UDEV libudev
check_lib STRL -lc strlcpy
check_pkgconf PYTHON python3
@ -255,6 +257,6 @@ add_define_make OS "$OS"
# Creates config.mk and config.h.
add_define_make GLOBAL_CONFIG_DIR "$GLOBAL_CONFIG_DIR"
VARS="RGUI ALSA OSS OSS_BSD OSS_LIB AL RSOUND ROAR JACK COREAUDIO PULSE SDL OPENGL GLES VG EGL KMS GBM DRM DYLIB GETOPT_LONG THREADS CG LIBXML2 SDL_IMAGE ZLIB DYNAMIC FFMPEG AVCODEC AVFORMAT AVUTIL SWSCALE FREETYPE XVIDEO X11 XEXT XF86VM XINERAMA NETPLAY NETWORK_CMD STDIN_CMD COMMAND SOCKET_LEGACY FBO STRL PYTHON FFMPEG_ALLOC_CONTEXT3 FFMPEG_AVCODEC_OPEN2 FFMPEG_AVIO_OPEN FFMPEG_AVFORMAT_WRITE_HEADER FFMPEG_AVFORMAT_NEW_STREAM FFMPEG_AVCODEC_ENCODE_AUDIO2 FFMPEG_AVCODEC_ENCODE_VIDEO2 BSV_MOVIE VIDEOCORE NEON FLOATHARD FLOATSOFTFP"
VARS="RGUI ALSA OSS OSS_BSD OSS_LIB AL RSOUND ROAR JACK COREAUDIO PULSE SDL OPENGL GLES VG EGL KMS GBM DRM DYLIB GETOPT_LONG THREADS CG LIBXML2 SDL_IMAGE ZLIB DYNAMIC FFMPEG AVCODEC AVFORMAT AVUTIL SWSCALE FREETYPE XVIDEO X11 XEXT XF86VM XINERAMA NETPLAY NETWORK_CMD STDIN_CMD COMMAND SOCKET_LEGACY FBO STRL PYTHON FFMPEG_ALLOC_CONTEXT3 FFMPEG_AVCODEC_OPEN2 FFMPEG_AVIO_OPEN FFMPEG_AVFORMAT_WRITE_HEADER FFMPEG_AVFORMAT_NEW_STREAM FFMPEG_AVCODEC_ENCODE_AUDIO2 FFMPEG_AVCODEC_ENCODE_VIDEO2 BSV_MOVIE VIDEOCORE NEON FLOATHARD FLOATSOFTFP UDEV"
create_config_make config.mk $VARS
create_config_header config.h $VARS

1
qb/config.params.sh
View File

@ -1,6 +1,7 @@
HAVE_RGUI=yes # Disable RGUI
HAVE_DYNAMIC=yes # Disable dynamic loading of libretro library
HAVE_SDL=auto # SDL support
HAVE_UDEV=auto # Udev/Evdev gamepad support
HAVE_LIBRETRO= # libretro library used
HAVE_MAN_DIR= # Manpage install directory
HAVE_THREADS=auto # Threading support