filter: add scroll movement type to the custom acceleration profile

Adds a dedicated scroll movement type to the custom acceleration profile.
Supported by physical mouse and touchpad.
Other profiles remain the same by using the same unaccelerated filter for the scroll filter.

Signed-off-by: Yinon Burgansky <51504-Yinon@users.noreply.gitlab.freedesktop.org>

25 files changed, 177 insertions, 45 deletions

diff --git a/doc/user/pointer-acceleration.rst b/doc/user/pointer-acceleration.rst
index 1d60702a..211bd469 100644
--- a/doc/user/pointer-acceleration.rst
+++ b/doc/user/pointer-acceleration.rst
@@ -252,6 +252,8 @@ Supported Movement types:
 +---------------+---------------------------------+----------------------+
 | Motion        | Used for pointer motion         | All devices          |
 +---------------+---------------------------------+----------------------+
+| Scroll        | Used for scroll movement        | Mouse, Touchpad      |
++---------------+---------------------------------+----------------------+
 
 If a user does not provide the fallback custom acceleration function, a
 flat acceleration function is used, i.e. no acceleration.
@@ -259,11 +261,12 @@ flat acceleration function is used, i.e. no acceleration.
 The fallback acceleration may be used for different types of movements, it is
 strongly recommended that this acceleration function is a constant function.
 
-For example, a physical mouse usually has two movement types: pointer
-movement and scroll (wheel) movement. As there is no separate movement
-type for scroll yet, scroll movement is be accelerated using the Fallback
-acceleration function. Pointer movements is accelerated using the Motion
-acceleration function. If no Motion acceleration function is set, the
+For example, a touchpad has multiple movement types: pointer
+movement, scroll movement, zoom movement (pinch), etc. As there is no separate
+movement type for zoom yet, zoom movement is accelerated using the Fallback
+acceleration function. Pointer movement is accelerated using the Motion
+acceleration function, and Scroll movement is accelerated using the Scroll
+acceleration function. If no Motion/Scroll acceleration function is set, the
 Fallback acceleration function is used.
 
 When using custom acceleration profile, any calls to set the speed have no
diff --git a/src/evdev-fallback.c b/src/evdev-fallback.c
index d591928a..ae33d45a 100644
--- a/src/evdev-fallback.c
+++ b/src/evdev-fallback.c
@@ -113,10 +113,10 @@ post_button_scroll(struct evdev_device *device,
 	case BUTTONSCROLL_SCROLLING:
 		{
 		const struct normalized_coords normalized =
-				filter_dispatch_constant(device->pointer.filter,
-						         &raw,
-							 device,
-							 time);
+				filter_dispatch_scroll(device->pointer.filter,
+						       &raw,
+						       device,
+						       time);
 		evdev_post_scroll(device, time,
 				  LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS,
 				  &normalized);
diff --git a/src/evdev-mt-touchpad-gestures.c b/src/evdev-mt-touchpad-gestures.c
index 08c93616..ad11c262 100644
--- a/src/evdev-mt-touchpad-gestures.c
+++ b/src/evdev-mt-touchpad-gestures.c
@@ -1176,8 +1176,8 @@ tp_gesture_handle_state_scroll(struct tp_dispatch *tp, uint64_t time)
 
 	raw = tp_get_average_touches_delta(tp);
 
-	/* scroll is not accelerated */
-	delta = tp_filter_motion_unaccelerated(tp, &raw, time);
+	/* scroll is not accelerated by default */
+	delta = tp_filter_scroll(tp, &raw, time);
 
 	if (normalized_is_zero(delta))
 		return;
diff --git a/src/evdev-mt-touchpad.c b/src/evdev-mt-touchpad.c
index 40c5696e..a72b9095 100644
--- a/src/evdev-mt-touchpad.c
+++ b/src/evdev-mt-touchpad.c
@@ -93,6 +93,24 @@ tp_filter_motion_unaccelerated(struct tp_dispatch *tp,
 					&raw, tp, time);
 }
 
+struct normalized_coords
+tp_filter_scroll(struct tp_dispatch *tp,
+		 const struct device_float_coords *unaccelerated,
+		 uint64_t time)
+{
+	struct device_float_coords raw;
+	const struct normalized_coords zero = { 0.0, 0.0 };
+
+	if (device_float_is_zero(*unaccelerated))
+		return zero;
+
+	/* Convert to device units with x/y in the same resolution */
+	raw = tp_scale_to_xaxis(tp, *unaccelerated);
+
+	return filter_dispatch_scroll(tp->device->pointer.filter,
+				      &raw, tp, time);
+}
+
 static inline void
 tp_calculate_motion_speed(struct tp_dispatch *tp,
 			  struct tp_touch *t,
diff --git a/src/evdev-mt-touchpad.h b/src/evdev-mt-touchpad.h
index a95bdd4c..c99b190f 100644
--- a/src/evdev-mt-touchpad.h
+++ b/src/evdev-mt-touchpad.h
@@ -607,6 +607,11 @@ tp_filter_motion_unaccelerated(struct tp_dispatch *tp,
 			       const struct device_float_coords *unaccelerated,
 			       uint64_t time);
 
+struct normalized_coords
+tp_filter_scroll(struct tp_dispatch *tp,
+		 const struct device_float_coords *unaccelerated,
+		 uint64_t time);
+
 bool
 tp_touch_active(const struct tp_dispatch *tp, const struct tp_touch *t);
 
diff --git a/src/evdev-wheel.c b/src/evdev-wheel.c
index 7276ec1a..2381cb77 100644
--- a/src/evdev-wheel.c
+++ b/src/evdev-wheel.c
@@ -196,10 +196,10 @@ wheel_flush_scroll(struct fallback_dispatch *dispatch,
 			.y = dispatch->wheel.lo_res.y * -1,
 		};
 		const struct normalized_coords normalized =
-				filter_dispatch_constant(device->pointer.filter,
-						         &raw,
-							 device,
-							 time);
+				filter_dispatch_scroll(device->pointer.filter,
+						       &raw,
+						       device,
+						       time);
 		evdev_post_scroll(device,
 				  time,
 				  LIBINPUT_POINTER_AXIS_SOURCE_CONTINUOUS,
diff --git a/src/filter-custom.c b/src/filter-custom.c
index 0172f7c0..b2eb75c8 100644
--- a/src/filter-custom.c
+++ b/src/filter-custom.c
@@ -201,6 +201,7 @@ struct custom_accelerator {
 	struct {
 		struct custom_accel_function *fallback;
 		struct custom_accel_function *motion;
+		struct custom_accel_function *scroll;
 	} funcs;
 };
 
@@ -213,6 +214,8 @@ custom_accelerator_get_custom_function(struct custom_accelerator *f,
 		return f->funcs.fallback;
 	case LIBINPUT_ACCEL_TYPE_MOTION:
 		return f->funcs.motion ? f->funcs.motion : f->funcs.fallback;
+	case LIBINPUT_ACCEL_TYPE_SCROLL:
+		return f->funcs.scroll ? f->funcs.scroll : f->funcs.fallback;
 	}
 
 	return f->funcs.fallback;
@@ -262,6 +265,7 @@ custom_accelerator_destroy(struct motion_filter *filter)
 	/* destroy all custom movement functions */
 	custom_accel_function_destroy(f->funcs.fallback);
 	custom_accel_function_destroy(f->funcs.motion);
+	custom_accel_function_destroy(f->funcs.scroll);
 	free(f);
 }
 
@@ -284,7 +288,8 @@ custom_accelerator_set_accel_config(struct motion_filter *filter,
 		(struct custom_accelerator *)filter;
 
 	struct custom_accel_function *fallback = NULL,
-				     *motion = NULL;
+				     *motion = NULL,
+				     *scroll = NULL;
 
 	if (config->custom.fallback) {
 		fallback = create_custom_accel_function(config->custom.fallback->step,
@@ -302,17 +307,28 @@ custom_accelerator_set_accel_config(struct motion_filter *filter,
 			goto out;
 	}
 
+	if (config->custom.scroll) {
+		scroll = create_custom_accel_function(config->custom.scroll->step,
+						      config->custom.scroll->points,
+						      config->custom.scroll->npoints);
+		if (!scroll)
+			goto out;
+	}
+
 	custom_accel_function_destroy(f->funcs.fallback);
 	custom_accel_function_destroy(f->funcs.motion);
+	custom_accel_function_destroy(f->funcs.scroll);
 
 	f->funcs.fallback = fallback;
 	f->funcs.motion = motion;
+	f->funcs.scroll = scroll;
 
 	return true;
 
 out:
 	custom_accel_function_destroy(fallback);
 	custom_accel_function_destroy(motion);
+	custom_accel_function_destroy(scroll);
 
 	return false;
 }
@@ -365,10 +381,34 @@ custom_accelerator_filter_motion(struct motion_filter *filter,
 					 time);
 }
 
+double
+custom_accel_profile_scroll(struct motion_filter *filter,
+			    void *data,
+			    double speed_in,
+			    uint64_t time)
+{
+	return custom_accelerator_profile(LIBINPUT_ACCEL_TYPE_SCROLL,
+					  filter,
+					  speed_in);
+}
+
+static struct normalized_coords
+custom_accelerator_filter_scroll(struct motion_filter *filter,
+				 const struct device_float_coords *unaccelerated,
+				 void *data,
+				 uint64_t time)
+{
+	return custom_accelerator_filter(LIBINPUT_ACCEL_TYPE_SCROLL,
+					 filter,
+					 unaccelerated,
+					 time);
+}
+
 struct motion_filter_interface custom_accelerator_interface = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM,
 	.filter = custom_accelerator_filter_motion,
 	.filter_constant = custom_accelerator_filter_fallback,
+	.filter_scroll = custom_accelerator_filter_scroll,
 	.restart = custom_accelerator_restart,
 	.destroy = custom_accelerator_destroy,
 	.set_speed = custom_accelerator_set_speed,
diff --git a/src/filter-flat.c b/src/filter-flat.c
index 3f5d9bd9..47814767 100644
--- a/src/filter-flat.c
+++ b/src/filter-flat.c
@@ -112,6 +112,7 @@ static const struct motion_filter_interface accelerator_interface_flat = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT,
 	.filter = accelerator_filter_flat,
 	.filter_constant = accelerator_filter_noop_flat,
+	.filter_scroll = accelerator_filter_noop_flat,
 	.restart = NULL,
 	.destroy = accelerator_destroy_flat,
 	.set_speed = accelerator_set_speed_flat,
diff --git a/src/filter-low-dpi.c b/src/filter-low-dpi.c
index 51793b5c..a52bb3ca 100644
--- a/src/filter-low-dpi.c
+++ b/src/filter-low-dpi.c
@@ -210,6 +210,7 @@ static const struct motion_filter_interface accelerator_interface_low_dpi = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
 	.filter = accelerator_filter_low_dpi,
 	.filter_constant = accelerator_filter_noop,
+	.filter_scroll = accelerator_filter_noop,
 	.restart = accelerator_restart,
 	.destroy = accelerator_destroy,
 	.set_speed = accelerator_set_speed,
diff --git a/src/filter-mouse.c b/src/filter-mouse.c
index a2284c00..f7d4d20c 100644
--- a/src/filter-mouse.c
+++ b/src/filter-mouse.c
@@ -270,6 +270,7 @@ static const struct motion_filter_interface accelerator_interface = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
 	.filter = accelerator_filter_linear,
 	.filter_constant = accelerator_filter_noop,
+	.filter_scroll = accelerator_filter_noop,
 	.restart = accelerator_restart,
 	.destroy = accelerator_destroy,
 	.set_speed = accelerator_set_speed,
diff --git a/src/filter-private.h b/src/filter-private.h
index ed969f04..e7f8dc24 100644
--- a/src/filter-private.h
+++ b/src/filter-private.h
@@ -38,6 +38,10 @@ struct motion_filter_interface {
 			   struct motion_filter *filter,
 			   const struct device_float_coords *unaccelerated,
 			   void *data, uint64_t time);
+	struct normalized_coords (*filter_scroll)(
+			   struct motion_filter *filter,
+			   const struct device_float_coords *unaccelerated,
+			   void *data, uint64_t time);
 	void (*restart)(struct motion_filter *filter,
 			void *data,
 			uint64_t time);
diff --git a/src/filter-tablet.c b/src/filter-tablet.c
index 4415b9ea..abc687d2 100644
--- a/src/filter-tablet.c
+++ b/src/filter-tablet.c
@@ -147,6 +147,7 @@ static const struct motion_filter_interface accelerator_interface_tablet = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT,
 	.filter = tablet_accelerator_filter_flat,
 	.filter_constant = NULL,
+	.filter_scroll = NULL,
 	.restart = NULL,
 	.destroy = tablet_accelerator_destroy,
 	.set_speed = tablet_accelerator_set_speed,
diff --git a/src/filter-touchpad-flat.c b/src/filter-touchpad-flat.c
index ac1a15c1..846d096b 100644
--- a/src/filter-touchpad-flat.c
+++ b/src/filter-touchpad-flat.c
@@ -110,6 +110,7 @@ static const struct motion_filter_interface accelerator_interface_touchpad_flat
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT,
 	.filter = accelerator_filter_touchpad_flat,
 	.filter_constant = accelerator_filter_noop_touchpad_flat,
+	.filter_scroll = accelerator_filter_noop_touchpad_flat,
 	.restart = NULL,
 	.destroy = accelerator_destroy_touchpad_flat,
 	.set_speed = accelerator_set_speed_touchpad_flat,
diff --git a/src/filter-touchpad-x230.c b/src/filter-touchpad-x230.c
index 90c42140..6d1fb282 100644
--- a/src/filter-touchpad-x230.c
+++ b/src/filter-touchpad-x230.c
@@ -287,6 +287,7 @@ static const struct motion_filter_interface accelerator_interface_x230 = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
 	.filter = accelerator_filter_x230,
 	.filter_constant = accelerator_filter_constant_x230,
+	.filter_scroll = accelerator_filter_constant_x230,
 	.restart = accelerator_restart_x230,
 	.destroy = accelerator_destroy_x230,
 	.set_speed = accelerator_set_speed_x230,
diff --git a/src/filter-touchpad.c b/src/filter-touchpad.c
index dcc2450d..ec6731c3 100644
--- a/src/filter-touchpad.c
+++ b/src/filter-touchpad.c
@@ -278,6 +278,7 @@ static const struct motion_filter_interface accelerator_interface_touchpad = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
 	.filter = accelerator_filter_touchpad,
 	.filter_constant = touchpad_constant_filter,
+	.filter_scroll = touchpad_constant_filter,
 	.restart = touchpad_accelerator_restart,
 	.destroy = touchpad_accelerator_destroy,
 	.set_speed = touchpad_accelerator_set_speed,
diff --git a/src/filter-trackpoint-flat.c b/src/filter-trackpoint-flat.c
index 7f63a0e3..786913ab 100644
--- a/src/filter-trackpoint-flat.c
+++ b/src/filter-trackpoint-flat.c
@@ -129,6 +129,7 @@ static struct motion_filter_interface accelerator_interface_flat = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT,
 	.filter = trackpoint_flat_filter,
 	.filter_constant = trackpoint_flat_filter_noop,
+	.filter_scroll = trackpoint_flat_filter_noop,
 	.restart = NULL,
 	.destroy = trackpoint_flat_destroy,
 	.set_speed = trackpoint_flat_set_speed,
diff --git a/src/filter-trackpoint.c b/src/filter-trackpoint.c
index 74267463..0083db3a 100644
--- a/src/filter-trackpoint.c
+++ b/src/filter-trackpoint.c
@@ -174,6 +174,7 @@ static const struct motion_filter_interface accelerator_interface_trackpoint = {
 	.type = LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE,
 	.filter = trackpoint_accelerator_filter,
 	.filter_constant = trackpoint_accelerator_filter_noop,
+	.filter_scroll = trackpoint_accelerator_filter_noop,
 	.restart = trackpoint_accelerator_restart,
 	.destroy = trackpoint_accelerator_destroy,
 	.set_speed = trackpoint_accelerator_set_speed,
diff --git a/src/filter.c b/src/filter.c
index aa60540a..4c28bd9d 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -53,6 +53,14 @@ filter_dispatch_constant(struct motion_filter *filter,
 	return filter->interface->filter_constant(filter, unaccelerated, data, time);
 }
 
+struct normalized_coords
+filter_dispatch_scroll(struct motion_filter *filter,
+		       const struct device_float_coords *unaccelerated,
+		       void *data, uint64_t time)
+{
+	return filter->interface->filter_scroll(filter, unaccelerated, data, time);
+}
+
 void
 filter_restart(struct motion_filter *filter,
 	       void *data, uint64_t time)
diff --git a/src/filter.h b/src/filter.h
index a293e5a6..f42a0c63 100644
--- a/src/filter.h
+++ b/src/filter.h
@@ -82,6 +82,28 @@ filter_dispatch_constant(struct motion_filter *filter,
 			 const struct device_float_coords *unaccelerated,
 			 void *data, uint64_t time);
 
+/**
+ * Apply a scroll filter.
+ * Depending on the device, and the acceleration profile,
+ * this filter allows the user to accelerate the scroll movement.
+ *
+ * Takes a set of unaccelerated deltas and applies the scroll filter to it.
+ *
+ * @param filter The device's motion filter
+ * @param unaccelerated The unaccelerated delta in the device's dpi
+ * resolution as specified during filter creation. If a device has uneven
+ * resolution for x and y, one axis needs to be scaled to match the
+ * originally provided resolution.
+ * @param data Custom data
+ * @param time The time of the delta
+ *
+ * @see filter_dispatch
+ */
+struct normalized_coords
+filter_dispatch_scroll(struct motion_filter *filter,
+		       const struct device_float_coords *unaccelerated,
+		       void *data, uint64_t time);
+
 void
 filter_restart(struct motion_filter *filter,
 	       void *data, uint64_t time);
@@ -180,4 +202,9 @@ custom_accel_profile_motion(struct motion_filter *filter,
 			    void *data,
 			    double speed_in,
 			    uint64_t time);
+double
+custom_accel_profile_scroll(struct motion_filter *filter,
+			    void *data,
+			    double speed_in,
+			    uint64_t time);
 #endif /* FILTER_H */
diff --git a/src/libinput-private.h b/src/libinput-private.h
index 298d5422..0a75a3c3 100644
--- a/src/libinput-private.h
+++ b/src/libinput-private.h
@@ -271,6 +271,7 @@ struct libinput_config_accel {
 	struct  {
 		struct libinput_config_accel_custom_func *fallback;
 		struct libinput_config_accel_custom_func *motion;
+		struct libinput_config_accel_custom_func *scroll;
 	} custom;
 };
 
diff --git a/src/libinput.c b/src/libinput.c
index c40266d7..f656dd9c 100644
--- a/src/libinput.c
+++ b/src/libinput.c
@@ -4218,6 +4218,7 @@ libinput_config_accel_destroy(struct libinput_config_accel *accel_config)
 {
 	libinput_config_accel_custom_func_destroy(accel_config->custom.fallback);
 	libinput_config_accel_custom_func_destroy(accel_config->custom.motion);
+	libinput_config_accel_custom_func_destroy(accel_config->custom.scroll);
 	free(accel_config);
 }
 
@@ -4256,6 +4257,7 @@ libinput_config_accel_set_points(struct libinput_config_accel *config,
 	switch (accel_type) {
 	case LIBINPUT_ACCEL_TYPE_FALLBACK:
 	case LIBINPUT_ACCEL_TYPE_MOTION:
+	case LIBINPUT_ACCEL_TYPE_SCROLL:
 		break;
 	default:
 		return LIBINPUT_CONFIG_STATUS_INVALID;
@@ -4288,6 +4290,10 @@ libinput_config_accel_set_points(struct libinput_config_accel *config,
 		libinput_config_accel_custom_func_destroy(config->custom.motion);
 		config->custom.motion = func;
 		break;
+	case LIBINPUT_ACCEL_TYPE_SCROLL:
+		libinput_config_accel_custom_func_destroy(config->custom.scroll);
+		config->custom.scroll = func;
+		break;
 	}
 
 	return LIBINPUT_CONFIG_STATUS_SUCCESS;
diff --git a/src/libinput.h b/src/libinput.h
index 1d477b68..7c0a9a75 100644
--- a/src/libinput.h
+++ b/src/libinput.h
@@ -5364,6 +5364,11 @@ enum libinput_config_accel_type {
 	 * type is always supported.
 	 */
 	LIBINPUT_ACCEL_TYPE_MOTION,
+	/**
+	 * Acceleration type for scroll movement.
+	 * This type is supported by mouse and touchpad.
+	 */
+	LIBINPUT_ACCEL_TYPE_SCROLL,
 };
 
 /**
diff --git a/test/test-pointer.c b/test/test-pointer.c
index f8eb1eff..945e490b 100644
--- a/test/test-pointer.c
+++ b/test/test-pointer.c
@@ -2283,22 +2283,24 @@ START_TEST(pointer_accel_config)
 	enum libinput_config_accel_profile profile;
 	enum libinput_config_status valid = LIBINPUT_CONFIG_STATUS_SUCCESS,
 				    invalid = LIBINPUT_CONFIG_STATUS_INVALID;
-	enum libinput_config_accel_type fallback = LIBINPUT_ACCEL_TYPE_FALLBACK,
-					motion = LIBINPUT_ACCEL_TYPE_MOTION;
+	enum libinput_config_accel_type accel_types[] = {
+		LIBINPUT_ACCEL_TYPE_FALLBACK,
+		LIBINPUT_ACCEL_TYPE_MOTION,
+		LIBINPUT_ACCEL_TYPE_SCROLL,
+	};
 	struct custom_config_test {
-		enum libinput_config_accel_type accel_type;
 		double step;
 		double points[4];
 		enum libinput_config_status expected_status;
 	} tests[] = {
-		{ fallback,  0.5, { 1.0, 2.0, 2.5, 2.6 },  valid },
-		{ motion,  0.003, { 0.1, 0.3, 0.4, 0.45 }, valid },
-		{ fallback,  2.7, { 1.0, 3.0, 4.5, 4.5 },  valid },
-		{ motion,      0, { 1.0, 2.0, 2.5, 2.6 },  invalid },
-		{ fallback,   -1, { 1.0, 2.0, 2.5, 2.6 },  invalid },
-		{ motion,   1e10, { 1.0, 2.0, 2.5, 2.6 },  invalid },
-		{ fallback,    1, { 1.0, 2.0, -2.5, 2.6 }, invalid },
-		{ motion,      1, { 1.0, 2.0, 1e10, 2.6 }, invalid },
+		{ 0.5,   { 1.0, 2.0, 2.5, 2.6 },  valid },
+		{ 0.003, { 0.1, 0.3, 0.4, 0.45 }, valid },
+		{ 2.7,   { 1.0, 3.0, 4.5, 4.5 },  valid },
+		{ 0,     { 1.0, 2.0, 2.5, 2.6 },  invalid },
+		{ -1,    { 1.0, 2.0, 2.5, 2.6 },  invalid },
+		{ 1e10,  { 1.0, 2.0, 2.5, 2.6 },  invalid },
+		{ 1,     { 1.0, 2.0, -2.5, 2.6 }, invalid },
+		{ 1,     { 1.0, 2.0, 1e10, 2.6 }, invalid },
 	};
 
 	ck_assert(libinput_device_config_accel_is_available(device));
@@ -2312,22 +2314,24 @@ START_TEST(pointer_accel_config)
 	ck_assert_ptr_nonnull(config_custom_changed);
 
 	ARRAY_FOR_EACH(tests, t) {
-		status = libinput_config_accel_set_points(config_custom_changed,
-							  t->accel_type,
-							  t->step,
-							  ARRAY_LENGTH(t->points),
-							  t->points);
-		ck_assert_int_eq(status, t->expected_status);
-
-		status = libinput_device_config_accel_apply(device, config_custom_changed);
-		ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
-		profile = libinput_device_config_accel_get_profile(device);
-		ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
-
-		status = libinput_device_config_accel_apply(device, config_custom_default);
-		ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
-		profile = libinput_device_config_accel_get_profile(device);
-		ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+		ARRAY_FOR_EACH(accel_types, accel_type) {
+			status = libinput_config_accel_set_points(config_custom_changed,
+								  *accel_type,
+								  t->step,
+								  ARRAY_LENGTH(t->points),
+								  t->points);
+			ck_assert_int_eq(status, t->expected_status);
+
+			status = libinput_device_config_accel_apply(device, config_custom_changed);
+			ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+			profile = libinput_device_config_accel_get_profile(device);
+			ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+
+			status = libinput_device_config_accel_apply(device, config_custom_default);
+			ck_assert_int_eq(status, LIBINPUT_CONFIG_STATUS_SUCCESS);
+			profile = libinput_device_config_accel_get_profile(device);
+			ck_assert_int_eq(profile, LIBINPUT_CONFIG_ACCEL_PROFILE_CUSTOM);
+		}
 	}
 
 	libinput_config_accel_destroy(config_custom_default);
diff --git a/tools/libinput-debug-events.man b/tools/libinput-debug-events.man
index 628d8716..849765d1 100644
--- a/tools/libinput-debug-events.man
+++ b/tools/libinput-debug-events.man
@@ -112,7 +112,7 @@ Sets the distance along the x-axis between each point, starting from 0.
 Defaults to 1.0.
 This only applies to the custom profile.
 .TP 8
-.B \-\-set\-custom\-type=[fallback|motion]
+.B \-\-set\-custom\-type=[fallback|motion|scroll]
 Sets the type of the custom acceleration function.
 Defaults to fallback.
 This only applies to the custom profile.
diff --git a/tools/shared.c b/tools/shared.c
index ee80eb93..7a730278 100644
--- a/tools/shared.c
+++ b/tools/shared.c
@@ -307,9 +307,11 @@ tools_parse_option(int option,
 			options->custom_type = LIBINPUT_ACCEL_TYPE_FALLBACK;
 		else if (streq(optarg, "motion"))
 			options->custom_type = LIBINPUT_ACCEL_TYPE_MOTION;
+		else if (streq(optarg, "scroll"))
+			options->custom_type = LIBINPUT_ACCEL_TYPE_SCROLL;
 		else {
 			fprintf(stderr, "Invalid --set-custom-type\n"
-			                "Valid custom types: fallback|motion\n");
+			                "Valid custom types: fallback|motion|scroll\n");
 			return 1;
 		}
 		break;