m + add force feedback support

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 493 insertions, 49 deletions

diff --git a/libgamepad.h b/libgamepad.h
index 627589a..665e012 100644
--- a/libgamepad.h
+++ b/libgamepad.h
@@ -2,11 +2,15 @@
 #ifndef LIBGAMEPAD_H
 #define LIBGAMEPAD_H
 
+#include <linux/input.h>
+#include <sys/ioctl.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdint.h>
 #include <stddef.h>
+#include <string.h>
 #include <time.h>
+#include <unistd.h>
 
 #include <libevdev/libevdev.h>
 
@@ -255,6 +259,21 @@ struct libgamepad_device {
 	size_t nrelative_axes;
 
 	/**
+	 * Map from button/key indices to button/key codes
+	 */
+	uint16_t *buttons;
+
+	/**
+	 * Map from absolute axis indices to absolute axis codes
+	 */
+	uint16_t *absolute_axes;
+
+	/**
+	 * Map from relative axis indices to relative axis codes
+	 */
+	uint16_t *relative_axes;
+
+	/**
 	 * Maps from button/key codes to button indices,
 	 * non-present buttons/keys map to -1, other
 	 * values are in [0, `.nbuttons`[.
@@ -276,20 +295,14 @@ struct libgamepad_device {
 	int16_t relative_axis_map[REL_CNT];
 
 	/**
-	 * Map from button/key indices to button/key codes
+	 * Bitmap of supported force feedback effects
 	 */
-	uint16_t *buttons;
+	uint8_t force_feedback_support[(FF_CNT + 7) / 8];
+};
 
-	/**
-	 * Map from absolute axis indices to absolute axis codes
-	 */
-	uint16_t *absolute_axes;
 
-	/**
-	 * Map from relative axis indices to relative axis codes
-	 */
-	uint16_t *relative_axes;
-};
+/* FOR INTERNAL USE */
+void libgamepad_construct_force_feedback_effect__(struct ff_effect *, const struct ff_effect *, double, uint16_t, uint16_t);
 
 
 /**
@@ -422,7 +435,7 @@ void libgamepad_close_device(struct libgamepad_device *);
  * libevdev_next_event(3), including:
  * -  EAGAIN  no more data currently available (non-blocking mode)
  * -  EINTR   system call was interrupted, try again
- * -  ENODEV  device has been unplugged
+ * -  ENODEV  device has been unplugged or access has been revoked
  */
 int libgamepad_next_event(struct libgamepad_device *, struct libgamepad_input_event *);
 
@@ -434,9 +447,9 @@ int libgamepad_next_event(struct libgamepad_device *, struct libgamepad_input_ev
  * @return        The button/key's name
  */
 inline const char *
-libgamepad_get_button_name(unsigned int code)
+libgamepad_get_button_name(uint16_t code)
 {
-	return libevdev_event_code_get_name(EV_KEY, code);
+	return libevdev_event_code_get_name(EV_KEY, (unsigned int)code);
 }
 
 /**
@@ -446,9 +459,9 @@ libgamepad_get_button_name(unsigned int code)
  * @return        The axis' name
  */
 inline const char *
-libgamepad_get_absolute_axis_name(unsigned int code)
+libgamepad_get_absolute_axis_name(uint16_t code)
 {
-	return libevdev_event_code_get_name(EV_ABS, code);
+	return libevdev_event_code_get_name(EV_ABS, (unsigned int)code);
 }
 
 /**
@@ -458,9 +471,9 @@ libgamepad_get_absolute_axis_name(unsigned int code)
  * @return        The axis' name
  */
 inline const char *
-libgamepad_get_relative_axis_name(unsigned int code)
+libgamepad_get_relative_axis_name(uint16_t code)
 {
-	return libevdev_event_code_get_name(EV_REL, code);
+	return libevdev_event_code_get_name(EV_REL, (unsigned int)code);
 }
 
 /**
@@ -472,9 +485,9 @@ libgamepad_get_relative_axis_name(unsigned int code)
  *                  0 otherwise
  */
 inline int
-libgamepad_get_button_is_pressed(struct libgamepad_device *device, unsigned int code)
+libgamepad_get_button_is_pressed(struct libgamepad_device *device, uint16_t code)
 {
-	return libevdev_get_event_value(device->dev, EV_KEY, code);
+	return libevdev_get_event_value(device->dev, EV_KEY, (unsigned int)code);
 }
 
 /**
@@ -485,9 +498,9 @@ libgamepad_get_button_is_pressed(struct libgamepad_device *device, unsigned int
  * @return          Information about the axis
  */
 inline const struct input_absinfo * /* `struct input_absinfo` is defined in <linux/input.h> */
-libgamepad_get_absolute_axis_info(struct libgamepad_device *device, unsigned int code)
+libgamepad_get_absolute_axis_info(struct libgamepad_device *device, uint16_t code)
 {
-	return libevdev_get_abs_info(device->dev, code);
+	return libevdev_get_abs_info(device->dev, (unsigned int)code);
 }
 
 
@@ -502,23 +515,15 @@ libgamepad_get_absolute_axis_info(struct libgamepad_device *device, unsigned int
  * @param   device  The device to grab
  * @return          0 on success, -1 on failure
  * 
- * May fail for any reason specified for libevdev_grab(3)
- * with LIBEVDEV_GRAB applied
- * 
  * In the event that the device is already grabbed by
- * via another file descriptor (duplicates do not share
+ * via another open file descriptor (duplicates share
  * grab), this function will return -1 and set `errno`
  * to `EBUSY`
  */
 inline int
 libgamepad_grab(struct libgamepad_device *device)
 {
-	int err = libevdev_grab(device->dev, LIBEVDEV_GRAB);
-	if (err < 0) {
-		errno = -err;
-		return -1;
-	}
-	return 0;
+	return ioctl(device->fd, EVIOCGRAB, (void *)1);
 }
 
 /**
@@ -526,19 +531,11 @@ libgamepad_grab(struct libgamepad_device *device)
  * 
  * @param   device  The device to ungrab
  * @return          0 on success, -1 on failure
- * 
- * May fail for any reason specified for libevdev_grab(3)
- * with LIBEVDEV_UNGRAB applied
  */
 inline int
 libgamepad_ungrab(struct libgamepad_device *device)
 {
-	int err = libevdev_grab(device->dev, LIBEVDEV_UNGRAB);
-	if (err < 0) {
-		errno = -err;
-		return -1;
-	}
-	return 0;
+	return ioctl(device->fd, EVIOCGRAB, (void *)0);
 }
 
 
@@ -548,18 +545,465 @@ libgamepad_ungrab(struct libgamepad_device *device)
  * @param   device   The device to configure
  * @param   clockid  The clock to use on event timestamps
  * @return           0 on success, -1 on failure
- * 
- * May fail for any reason specified for libevdev_set_clock_id(3)
  */
 inline int
 libgamepad_set_clock(struct libgamepad_device *device, clockid_t clockid)
 {
-	int err = libevdev_set_clock_id(device->dev, clockid);
-	if (err < 0) {
-		errno = -err;
-		return -1;
-	}
-	return 0;
+	return ioctl(device->fd, EVIOCSCLOCKID, &clockid);
+}
+
+
+/**
+ * Install a force feedback effect that can be played back later
+ * 
+ * @param   device  The device to configure
+ * @param   effect  The effect to install; will be edited, specifically the ID
+ *                  will be set (need not be set before calling this function)
+ * @return          0 on success, -1 on failure
+ */
+inline int /* `struct ff_effect` is defined in <linux/input.h> */
+libgamepad_install_force_feedback_effect(struct libgamepad_device *device, struct ff_effect *effect)
+{
+	effect->id = -1;
+	return ioctl(device->fd, EVIOCSFF, effect);
+}
+
+/**
+ * Reconfigure an already installed force feedback effect
+ * 
+ * @param   device  The device to configure
+ * @param   effect  The effect to update, the ID must be set to the ID of a
+ *                  previously installed effect
+ * @return          0 on success, -1 on failure
+ */
+inline int
+libgamepad_update_force_feedback_effect(struct libgamepad_device *device, struct ff_effect *effect)
+{
+	return ioctl(device->fd, EVIOCSFF, effect);
+}
+
+/**
+ * Uninstall an installed force feedback effect
+ * 
+ * @param   device  The device to configure
+ * @param   effect  The effect to remove, the ID must be set to the ID of a
+ *                  previously installed effect and will be reset
+ * @return          0 on success, -1 on failure
+ */
+inline int
+libgamepad_uninstall_force_feedback_effect(struct libgamepad_device *device, struct ff_effect *effect)
+{
+	int ret = ioctl(device->fd, EVIOCRMFF, effect);
+	effect->id = -1;
+	return ret;
+}
+
+/**
+ * Get the number of force feedback effects that can be played concurrently
+ * 
+ * @param   device  The device to configure
+ * @return          The number of maximum number concurrent effects, -1 on failure
+ */
+inline int
+libgamepad_get_force_feedback_max_concurrency(struct libgamepad_device *device)
+{
+	int num;
+	return ioctl(device->fd, EVIOCGEFFECTS, &num) ? -1 : num;
+}
+
+/**
+ * Play a force feedback effect
+ * 
+ * @param   device  The device to play the force feedback effect on
+ * @param   effect  The force feedback effect to play, must already be installed
+ *                  with `libgamepad_install_force_feedback_effect`
+ * @return          0 on success, -1 on failure
+ */
+inline int
+libgamepad_play_force_feedback_effect(struct libgamepad_device *device, const struct ff_effect *effect)
+{
+	struct input_event message;
+	message.type = EV_FF;
+	message.code = (uint16_t)effect->id;
+	message.value = 1;
+	return write(device->fd, &message, sizeof(message)) < 0 ? -1 : 0;
+}
+
+/**
+ * Stop playing a force feedback effect
+ * 
+ * @param   device  The device playing the force feedback effect on
+ * @param   effect  The force feedback effect to play, must already be installed
+ *                  with `libgamepad_install_force_feedback_effect`
+ * @return          0 on success, -1 on failure
+ */
+inline int
+libgamepad_stop_force_feedback_effect(struct libgamepad_device *device, const struct ff_effect *effect)
+{
+	struct input_event message;
+	message.type = EV_FF;
+	message.code = (uint16_t)effect->id;
+	message.value = 0;
+	return write(device->fd, &message, sizeof(message)) < 0 ? -1 : 0;
+}
+
+/**
+ * Check if a force feedback effect or waveform is supported
+ *
+ * @param   device  The device to check force feedback support on
+ * @param   effect  The force feedback effect or waveform
+ * @return          1 if the effect/waveform is supported, 0 otherwise
+ */
+inline int
+libgamepad_is_force_feedback_effect_supported(struct libgamepad_device *device, uint16_t effect)
+{
+	return effect < sizeof(device->force_feedback_support) * 8 &&
+	       ((device->force_feedback_support[effect / 8] >> (effect % 8)) & 1);
+}
+
+/**
+ * Set the force feedback master gain on a device
+ * 
+ * Requires support for `FF_GAIN` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * @param   device  The device to configure
+ * @param   gain    The master gain, shall be a value in [0, 0xFFFF]
+ * @return          0 on success, -1 on failure
+ */
+inline int
+libgamepad_set_force_feedback_master_gain(struct libgamepad_device *device, uint16_t gain)
+{
+	struct input_event message;
+	message.type = EV_FF;
+	message.code = FF_GAIN;
+	message.value = (int16_t)gain;
+	return write(device->fd, &message, sizeof(message)) < 0 ? -1 : 0;
+}
+
+/**
+ * Set the autocenter force feedback on a device
+ * 
+ * Requires support for `FF_AUTOCENTER` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * @param   device      The device to configure
+ * @param   autocenter  Autocenter strength, shall be a value in [0, 0xFFFF], select 0 to
+ *                      disable (you can also use `libgamepad_disable_force_feedback_autocenter`)
+ * @return              0 on success, -1 on failure
+ */
+inline int
+libgamepad_set_force_feedback_autocenter(struct libgamepad_device *device, uint16_t autocenter)
+{
+	struct input_event message;
+	message.type = EV_FF;
+	message.code = FF_AUTOCENTER;
+	message.value = (int16_t)autocenter;
+	return write(device->fd, &message, sizeof(message)) < 0 ? -1 : 0;
+}
+
+/**
+ * Disable the autocenter force feedback on a device
+ * 
+ * Requires support for `FF_AUTOCENTER` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * @param   device  device to configure
+ * @return          0 on success, -1 on failure
+ */
+inline int
+libgamepad_disable_force_feedback_autocenter(struct libgamepad_device *device)
+{
+	struct input_event message;
+	message.type = EV_FF;
+	message.code = FF_AUTOCENTER;
+	message.value = 0;
+	return write(device->fd, &message, sizeof(message)) < 0 ? -1 : 0;
+}
+
+/**
+ * Construct a rumble force-feedback effect
+ * 
+ * Requires support for `FF_RUMBLE` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details:
+ *                    - .strong_magnitude  Heavy motor strength, unsigned 16-bit integer
+ *                    - .weak_magnitude    Light motor strength, unsigned 16-bit integer
+ */
+inline void
+libgamepad_construct_rumble_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                  double direction, uint16_t length, const struct ff_rumble_effect *effect)
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_RUMBLE);
+	memcpy(&effectp->u.rumble, effect, sizeof(effectp->u.rumble));
+}
+
+/**
+ * Construct a constant force-feedback effect
+ * 
+ * Requires support for `FF_CONSTANT` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details:
+ *                    - .level                     Strength, signed 16-bit integer
+ *                    - .envelope.attack_strength  Strength at beginning, unsigned 16-bit integer
+ *                    - .envelope.fade_strength    Strength at end, unsigned 16-bit integer
+ *                    - .envelope.attack_length    The number of milliseconds the strength shall
+ *                                                 transition from `.envelope.attack_strength`
+ *                                                 to `.level`, unsigned 16-bit integer
+ *                    - .envelope.fade_length      The number of milliseconds the strength shall
+ *                                                 transition to `.envelope.fade_strength`
+ *                                                 from `.level`, unsigned 16-bit integer
+ */
+inline void
+libgamepad_construct_constant_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                    double direction, uint16_t length, const struct ff_constant_effect *effect)
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_CONSTANT);
+	memcpy(&effectp->u.constant, effect, sizeof(effectp->u.constant));
+}
+
+/**
+ * Construct a ramp force-feedback effect
+ * 
+ * Requires support for `FF_RAMP` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details:
+ *                    - .start_level               Strength at beginning, signed 16-bit integer
+ *                    - .end_level                 Strength at end, signed 16-bit integer
+ *                    - .envelope.attack_strength  Strength at beginning, unsigned 16-bit integer
+ *                    - .envelope.fade_strength    Strength at end, unsigned 16-bit integer
+ *                    - .envelope.attack_length    The number of milliseconds the strength shall
+ *                                                 transition from `.envelope.attack_strength`,
+ *                                                 unsigned 16-bit integer
+ *                    - .envelope.fade_length      The number of milliseconds the strength shall
+ *                                                 transition to `.envelope.fade_strength`,
+ *                                                 unsigned 16-bit integer
+ */
+inline void
+libgamepad_construct_ramp_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                double direction, uint16_t length, const struct ff_ramp_effect *effect)
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_RUMBLE);
+	memcpy(&effectp->u.ramp, effect, sizeof(effectp->u.ramp));
+}
+
+/**
+ * Construct a periodic force-feedback effect
+ * 
+ * Requires support for `FF_PERIODIC` and the selected waveform
+ * (check with `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details:
+ *                    - .waveform                  `FF_SQUARE`, `FF_TRIANGLE`, `FF_SINE`, `FF_SAW_UP`,
+ *                                                 `FF_SAW_DOWN`, or `FF_CUSTOM`
+ *                    - .period                    The period of the wave, in milliseconds (unsigned 16-bit integer)
+ *                    - .magnitude                 The peak value, signed 16-bit integer
+ *                    - .offset                    The rough mean value, signed 16-bit integer
+ *                    - .phase                     Horiztonal wave-shift, in milliseconds (unsigned 16-bit integer)
+ *                    - .envelope.attack_strength  Strength at beginning, unsigned 16-bit integer
+ *                    - .envelope.fade_strength    Strength at end, unsigned 16-bit integer
+ *                    - .envelope.attack_length    The number of milliseconds the strength shall
+ *                                                 transition from `.envelope.attack_strength`,
+ *                                                 unsigned 16-bit integer
+ *                    - .envelope.fade_length      The number of milliseconds the strength shall
+ *                                                 transition to `.envelope.fade_strength`,
+ *                                                 unsigned 16-bit integer
+ *                    - .custom_len                Set to zero unless you are using (`FF_CUSTOM`)
+ *                    - .custom_data               Set to `NULL` unless you are using (`FF_CUSTOM`)
+ */
+inline void
+libgamepad_construct_periodic_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                   double direction, uint16_t length, const struct ff_periodic_effect *effect)
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_PERIODIC);
+	memcpy(&effectp->u.periodic, effect, sizeof(effectp->u.periodic));
+}
+
+/**
+ * Construct a spring force-feedback effect
+ * 
+ * Requires support for `FF_SPRING` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details (one of each axis):
+ *                    - .right_saturation  Maximum level at end of axis, unsigned 16-bit integer
+ *                    - .left_saturation   Maximum level at beginning of axis, unsigned 16-bit integer
+ *                    - .right_coeff       Growth coefficient after the dead zone, signed 16-bit integer
+ *                    - .left_coeff        Growth coefficient before the dead zone, signed 16-bit integer
+ *                    - .deadband          Size of the dead zone
+ *                    - .center            The position of the center of the dead zone
+ */
+inline void
+libgamepad_construct_spring_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                  double direction, uint16_t length, const struct ff_condition_effect effect[2])
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_SPRING);
+	memcpy(effectp->u.condition, effect, sizeof(effectp->u.condition));
+}
+
+/**
+ * Construct a friction force-feedback effect
+ * 
+ * Requires support for `FF_FRICTION` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details (one of each axis):
+ *                    - .right_saturation  Maximum level at end of axis, unsigned 16-bit integer
+ *                    - .left_saturation   Maximum level at beginning of axis, unsigned 16-bit integer
+ *                    - .right_coeff       Growth coefficient after the dead zone, signed 16-bit integer
+ *                    - .left_coeff        Growth coefficient before the dead zone, signed 16-bit integer
+ *                    - .deadband          Size of the dead zone
+ *                    - .center            The position of the center of the dead zone
+ */
+inline void
+libgamepad_construct_friction_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                    double direction, uint16_t length, const struct ff_condition_effect effect[2])
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_FRICTION);
+	memcpy(effectp->u.condition, effect, sizeof(effectp->u.condition));
+}
+
+/**
+ * Construct a damper force-feedback effect
+ * 
+ * Requires support for `FF_DAMPER` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details (one of each axis):
+ *                    - .right_saturation  Maximum level at end of axis, unsigned 16-bit integer
+ *                    - .left_saturation   Maximum level at beginning of axis, unsigned 16-bit integer
+ *                    - .right_coeff       Growth coefficient after the dead zone, signed 16-bit integer
+ *                    - .left_coeff        Growth coefficient before the dead zone, signed 16-bit integer
+ *                    - .deadband          Size of the dead zone
+ *                    - .center            The position of the center of the dead zone
+ */
+inline void
+libgamepad_construct_damper_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                  double direction, uint16_t length, const struct ff_condition_effect effect[2])
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_DAMPER);
+	memcpy(effectp->u.condition, effect, sizeof(effectp->u.condition));
+}
+
+/**
+ * Construct a inertia force-feedback effect
+ * 
+ * Requires support for `FF_INERTIA` (check with
+ * `libgamepad_is_force_feedback_effect_supported`)
+ * 
+ * This function will set the following values to
+ * zero if `from` is `NULL`, see <linux/input.h>
+ * for more details:
+ * -  effectp->trigger.button
+ * -  effectp->trigger.interval
+ * -  effectp->replay.delay
+ * 
+ * @param  effectp    Output parameter for the effect
+ * @param  from       Effect to reconfigure, `NULL` to create a new effect
+ * @param  direction  The direction of the force feedback (if directional), where
+ *                    values are measure clockwise and both 0 and 1 are upwards
+ * @param  length     The number of milliseconds the effect is played
+ * @param  effect     Effect specific details (one of each axis):
+ *                    - .right_saturation  Maximum level at end of axis, unsigned 16-bit integer
+ *                    - .left_saturation   Maximum level at beginning of axis, unsigned 16-bit integer
+ *                    - .right_coeff       Growth coefficient after the dead zone, signed 16-bit integer
+ *                    - .left_coeff        Growth coefficient before the dead zone, signed 16-bit integer
+ *                    - .deadband          Size of the dead zone
+ *                    - .center            The position of the center of the dead zone
+ */
+inline void
+libgamepad_construct_inertia_force_feedback_effect(struct ff_effect *effectp, const struct ff_effect *from,
+                                                   double direction, uint16_t length, const struct ff_condition_effect effect[2])
+{
+	libgamepad_construct_force_feedback_effect__(effectp, from, direction, length, FF_INERTIA);
+	memcpy(effectp->u.condition, effect, sizeof(effectp->u.condition));
 }