[PATCH 2/2] selftests/alsa: Add a test for snd-aloop notify mode

[Henrik Enquist via B4 Relay <devnull+henrik.enquist.gmail.com@kernel.org>]

From: Henrik Enquist <henrik.enquist@gmail.com>

Add a test for the hw constraints between the playback and capture
devices of an snd-aloop cable, and for the "PCM Slave" controls that
report the playback side's parameters to the capture application.

With notify disabled, a playback opened while a capture is set up must
be pinned to the capture's parameters. With notify enabled, it may pick
others. Starting it stops the running capture, and the "PCM Slave
Format", "Rate", "Channels" and "Access Mode" controls report the new
parameters, each with a value event. A capture opened second is pinned
to the playback either way.

The tests only check hw_refine results, stream states and control
values, so they don't depend on timing. They skip if snd-aloop isn't
loaded or the devices are in use.

Without "ALSA: aloop: Don't constrain playback params in notify mode",
the two notify mode tests fail.

Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Henrik Enquist <henrik.enquist@gmail.com>
---
 tools/testing/selftests/alsa/.gitignore   |   1 +
 tools/testing/selftests/alsa/Makefile     |   2 +-
 tools/testing/selftests/alsa/aloop-test.c | 345 ++++++++++++++++++++++++++++++
 3 files changed, 347 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/alsa/.gitignore b/tools/testing/selftests/alsa/.gitignore
index 3dd8e1176b..7b0e1e9ebf 100644
--- a/tools/testing/selftests/alsa/.gitignore
+++ b/tools/testing/selftests/alsa/.gitignore
@@ -1,3 +1,4 @@
+aloop-test
 global-timer
 mixer-test
 pcm-test
diff --git a/tools/testing/selftests/alsa/Makefile b/tools/testing/selftests/alsa/Makefile
index 8dab90ad22..afd64a679d 100644
--- a/tools/testing/selftests/alsa/Makefile
+++ b/tools/testing/selftests/alsa/Makefile
@@ -16,7 +16,7 @@ LDLIBS+=-lpthread
 
 OVERRIDE_TARGETS = 1
 
-TEST_GEN_PROGS := mixer-test pcm-test test-pcmtest-driver utimer-test
+TEST_GEN_PROGS := aloop-test mixer-test pcm-test test-pcmtest-driver utimer-test
 
 TEST_GEN_PROGS_EXTENDED := libatest.so global-timer
 
diff --git a/tools/testing/selftests/alsa/aloop-test.c b/tools/testing/selftests/alsa/aloop-test.c
new file mode 100644
index 0000000000..a58b9fdbdc
--- /dev/null
+++ b/tools/testing/selftests/alsa/aloop-test.c
@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Tests for the hw constraints between the two ends of an snd-aloop cable,
+ * with and without the "PCM Notify" control, and for the "PCM Slave"
+ * controls that report the playback side's parameters.
+ *
+ * Needs snd-aloop loaded with the default card id "Loopback". The tests use
+ * the cable between hw:Loopback,0,0 (playback) and hw:Loopback,1,0 (capture).
+ */
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+#include <alsa/asoundlib.h>
+#include "kselftest_harness.h"
+
+#define FRAMES		1024
+#define MAX_CHANNELS	4
+
+struct stream_params {
+	snd_pcm_access_t access;
+	snd_pcm_format_t format;
+	unsigned int channels;
+	unsigned int rate;
+};
+
+/* The playback params differ from the capture params in every field. */
+static const struct stream_params capture_params = {
+	SND_PCM_ACCESS_RW_INTERLEAVED, SND_PCM_FORMAT_S16_LE, 2, 44100
+};
+
+static const struct stream_params playback_params = {
+	SND_PCM_ACCESS_RW_NONINTERLEAVED, SND_PCM_FORMAT_S32_LE, 4, 96000
+};
+
+struct probe_result {
+	unsigned int rate_min, rate_max;
+	unsigned int channels_min, channels_max;
+	bool format_ok;
+};
+
+/* Value events seen on the cable's controls */
+enum {
+	EV_ACTIVE	= 1 << 0,
+	EV_FORMAT	= 1 << 1,
+	EV_RATE		= 1 << 2,
+	EV_CHANNELS	= 1 << 3,
+	EV_ACCESS	= 1 << 4,
+};
+
+FIXTURE(aloop) {
+	char play_name[32];
+	char capt_name[32];
+	snd_ctl_t *ctl;
+	bool saved_notify;
+	bool notify_saved;
+};
+
+/* The cable's controls are on the capture side device. */
+static void cable_ctl_id(snd_ctl_elem_value_t *value, const char *name)
+{
+	snd_ctl_elem_value_set_interface(value, SND_CTL_ELEM_IFACE_PCM);
+	snd_ctl_elem_value_set_name(value, name);
+	snd_ctl_elem_value_set_device(value, 1);
+	snd_ctl_elem_value_set_subdevice(value, 0);
+}
+
+static long cable_ctl_get(snd_ctl_t *ctl, const char *name)
+{
+	snd_ctl_elem_value_t *value;
+
+	snd_ctl_elem_value_alloca(&value);
+	cable_ctl_id(value, name);
+	if (snd_ctl_elem_read(ctl, value) < 0)
+		return -1;
+	if (!strcmp(name, "PCM Slave Access Mode"))
+		return snd_ctl_elem_value_get_enumerated(value, 0);
+	return snd_ctl_elem_value_get_integer(value, 0);
+}
+
+static int set_notify(snd_ctl_t *ctl, bool on)
+{
+	snd_ctl_elem_value_t *value;
+
+	snd_ctl_elem_value_alloca(&value);
+	cable_ctl_id(value, "PCM Notify");
+	snd_ctl_elem_value_set_boolean(value, 0, on);
+	return snd_ctl_elem_write(ctl, value);
+}
+
+/* Read all pending control events and return the EV_* bits for the cable's controls. */
+static unsigned int read_events(snd_ctl_t *ctl)
+{
+	static const struct {
+		const char *name;
+		unsigned int bit;
+	} names[] = {
+		{ "PCM Slave Active", EV_ACTIVE },
+		{ "PCM Slave Format", EV_FORMAT },
+		{ "PCM Slave Rate", EV_RATE },
+		{ "PCM Slave Channels", EV_CHANNELS },
+		{ "PCM Slave Access Mode", EV_ACCESS },
+	};
+	snd_ctl_event_t *event;
+	unsigned int seen = 0;
+	int i;
+
+	snd_ctl_event_alloca(&event);
+	while (snd_ctl_read(ctl, event) > 0) {
+		if (snd_ctl_event_get_type(event) != SND_CTL_EVENT_ELEM ||
+		    !(snd_ctl_event_elem_get_mask(event) & SND_CTL_EVENT_MASK_VALUE) ||
+		    snd_ctl_event_elem_get_device(event) != 1 ||
+		    snd_ctl_event_elem_get_subdevice(event) != 0)
+			continue;
+		for (i = 0; i < ARRAY_SIZE(names); i++)
+			if (!strcmp(snd_ctl_event_elem_get_name(event), names[i].name))
+				seen |= names[i].bit;
+	}
+	return seen;
+}
+
+/* Open and configure a stream. snd_pcm_hw_params() also prepares it. */
+static int open_pcm(snd_pcm_t **pcm, const char *name, snd_pcm_stream_t stream,
+		    const struct stream_params *p)
+{
+	unsigned int buffer_time = 100000;
+	snd_pcm_hw_params_t *hw;
+	int err;
+
+	snd_pcm_hw_params_alloca(&hw);
+	err = snd_pcm_open(pcm, name, stream, 0);
+	if (err < 0)
+		return err;
+	err = snd_pcm_hw_params_any(*pcm, hw);
+	if (err >= 0)
+		err = snd_pcm_hw_params_set_access(*pcm, hw, p->access);
+	if (err >= 0)
+		err = snd_pcm_hw_params_set_format(*pcm, hw, p->format);
+	if (err >= 0)
+		err = snd_pcm_hw_params_set_channels(*pcm, hw, p->channels);
+	if (err >= 0)
+		err = snd_pcm_hw_params_set_rate(*pcm, hw, p->rate, 0);
+	if (err >= 0)
+		err = snd_pcm_hw_params_set_buffer_time_near(*pcm, hw, &buffer_time, NULL);
+	if (err >= 0)
+		err = snd_pcm_hw_params(*pcm, hw);
+	if (err < 0) {
+		snd_pcm_close(*pcm);
+		*pcm = NULL;
+	}
+	return err;
+}
+
+/* What a client probing the device sees, and whether it may use the given format */
+static int probe_pcm(const char *name, snd_pcm_stream_t stream, snd_pcm_format_t format,
+		     struct probe_result *res)
+{
+	snd_pcm_hw_params_t *hw;
+	snd_pcm_t *pcm;
+	int err;
+
+	snd_pcm_hw_params_alloca(&hw);
+	err = snd_pcm_open(&pcm, name, stream, 0);
+	if (err < 0)
+		return err;
+	err = snd_pcm_hw_params_any(pcm, hw);
+	if (err >= 0)
+		err = snd_pcm_hw_params_get_rate_min(hw, &res->rate_min, NULL);
+	if (err >= 0)
+		err = snd_pcm_hw_params_get_rate_max(hw, &res->rate_max, NULL);
+	if (err >= 0)
+		err = snd_pcm_hw_params_get_channels_min(hw, &res->channels_min);
+	if (err >= 0)
+		err = snd_pcm_hw_params_get_channels_max(hw, &res->channels_max);
+	if (err >= 0)
+		res->format_ok = !snd_pcm_hw_params_test_format(pcm, hw, format);
+	snd_pcm_close(pcm);
+	return err;
+}
+
+static int start_playback(snd_pcm_t *pcm, const struct stream_params *p)
+{
+	static char silence[FRAMES * MAX_CHANNELS * 4];
+	void *bufs[MAX_CHANNELS];
+	snd_pcm_sframes_t written;
+	unsigned int i;
+
+	if (p->access == SND_PCM_ACCESS_RW_NONINTERLEAVED) {
+		for (i = 0; i < p->channels; i++)
+			bufs[i] = silence + i * FRAMES * 4;
+		written = snd_pcm_writen(pcm, bufs, FRAMES);
+	} else {
+		written = snd_pcm_writei(pcm, silence, FRAMES);
+	}
+	if (written < 0)
+		return written;
+	if (snd_pcm_state(pcm) == SND_PCM_STATE_PREPARED)
+		return snd_pcm_start(pcm);
+	return 0;
+}
+
+FIXTURE_SETUP(aloop) {
+	char ctl_name[32];
+	snd_pcm_t *pcm;
+	int card, err;
+
+	card = snd_card_get_index("Loopback");
+	if (card < 0)
+		SKIP(return, "No Loopback card, snd-aloop is probably not loaded");
+
+	sprintf(ctl_name, "hw:%d", card);
+	sprintf(self->play_name, "hw:%d,0,0", card);
+	sprintf(self->capt_name, "hw:%d,1,0", card);
+
+	err = snd_pcm_open(&pcm, self->capt_name, SND_PCM_STREAM_CAPTURE, SND_PCM_NONBLOCK);
+	if (err == -EBUSY)
+		SKIP(return, "%s is in use", self->capt_name);
+	ASSERT_EQ(err, 0);
+	snd_pcm_close(pcm);
+	err = snd_pcm_open(&pcm, self->play_name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
+	if (err == -EBUSY)
+		SKIP(return, "%s is in use", self->play_name);
+	ASSERT_EQ(err, 0);
+	snd_pcm_close(pcm);
+
+	ASSERT_EQ(snd_ctl_open(&self->ctl, ctl_name, SND_CTL_NONBLOCK), 0);
+	ASSERT_EQ(snd_ctl_subscribe_events(self->ctl, 1), 0);
+	self->saved_notify = cable_ctl_get(self->ctl, "PCM Notify");
+	self->notify_saved = true;
+}
+
+FIXTURE_TEARDOWN(aloop) {
+	if (self->notify_saved)
+		set_notify(self->ctl, self->saved_notify);
+	if (self->ctl)
+		snd_ctl_close(self->ctl);
+}
+
+/* Without notify, a playback opened while a capture is set up is pinned to its parameters. */
+TEST_F(aloop, playback_constrained_without_notify) {
+	struct probe_result res;
+	snd_pcm_t *capt;
+
+	ASSERT_EQ(set_notify(self->ctl, false), 0);
+	ASSERT_EQ(open_pcm(&capt, self->capt_name, SND_PCM_STREAM_CAPTURE, &capture_params), 0);
+
+	ASSERT_EQ(probe_pcm(self->play_name, SND_PCM_STREAM_PLAYBACK, playback_params.format,
+			    &res), 0);
+	EXPECT_EQ(res.rate_min, capture_params.rate);
+	EXPECT_EQ(res.rate_max, capture_params.rate);
+	EXPECT_EQ(res.channels_min, capture_params.channels);
+	EXPECT_EQ(res.channels_max, capture_params.channels);
+	EXPECT_FALSE(res.format_ok);
+
+	snd_pcm_close(capt);
+}
+
+/* With notify, the playback side is free to pick other parameters. */
+TEST_F(aloop, playback_unconstrained_with_notify) {
+	struct probe_result res;
+	snd_pcm_t *capt;
+
+	ASSERT_EQ(set_notify(self->ctl, true), 0);
+	ASSERT_EQ(open_pcm(&capt, self->capt_name, SND_PCM_STREAM_CAPTURE, &capture_params), 0);
+
+	ASSERT_EQ(probe_pcm(self->play_name, SND_PCM_STREAM_PLAYBACK, playback_params.format,
+			    &res), 0);
+	EXPECT_LE(res.rate_min, capture_params.rate);
+	EXPECT_GE(res.rate_max, playback_params.rate);
+	EXPECT_LE(res.channels_min, capture_params.channels);
+	EXPECT_GE(res.channels_max, playback_params.channels);
+	EXPECT_TRUE(res.format_ok);
+
+	snd_pcm_close(capt);
+}
+
+/*
+ * With notify, starting a playback with different parameters stops the
+ * running capture, and the "PCM Slave" controls report the new parameters
+ * with a value event for each one that changed.
+ */
+TEST_F(aloop, params_change_stops_capture_with_notify) {
+	snd_pcm_t *capt, *play;
+	unsigned int events;
+
+	/*
+	 * The controls keep the last playback's parameters, and only notify on
+	 * a change. Start a playback with the capture's parameters while no
+	 * capture is open, so that every control changes below.
+	 */
+	ASSERT_EQ(open_pcm(&play, self->play_name, SND_PCM_STREAM_PLAYBACK, &capture_params), 0);
+	ASSERT_EQ(start_playback(play, &capture_params), 0);
+	snd_pcm_close(play);
+
+	ASSERT_EQ(set_notify(self->ctl, true), 0);
+	ASSERT_EQ(open_pcm(&capt, self->capt_name, SND_PCM_STREAM_CAPTURE, &capture_params), 0);
+	ASSERT_EQ(snd_pcm_start(capt), 0);
+	ASSERT_EQ(snd_pcm_state(capt), SND_PCM_STATE_RUNNING);
+	EXPECT_EQ(cable_ctl_get(self->ctl, "PCM Slave Active"), 0);
+	read_events(self->ctl);
+
+	ASSERT_EQ(open_pcm(&play, self->play_name, SND_PCM_STREAM_PLAYBACK, &playback_params), 0)
+		TH_LOG("Playback refused other parameters while the capture is running");
+	ASSERT_EQ(start_playback(play, &playback_params), 0);
+
+	/* loopback_check_format() stops the capture from the playback's start trigger. */
+	EXPECT_NE(snd_pcm_state(capt), SND_PCM_STATE_RUNNING);
+
+	EXPECT_EQ(cable_ctl_get(self->ctl, "PCM Slave Active"), 1);
+	EXPECT_EQ(cable_ctl_get(self->ctl, "PCM Slave Format"), playback_params.format);
+	EXPECT_EQ(cable_ctl_get(self->ctl, "PCM Slave Rate"), playback_params.rate);
+	EXPECT_EQ(cable_ctl_get(self->ctl, "PCM Slave Channels"), playback_params.channels);
+	EXPECT_EQ(cable_ctl_get(self->ctl, "PCM Slave Access Mode"), 1);
+
+	events = read_events(self->ctl);
+	EXPECT_TRUE(events & EV_ACTIVE);
+	EXPECT_TRUE(events & EV_FORMAT);
+	EXPECT_TRUE(events & EV_RATE);
+	EXPECT_TRUE(events & EV_CHANNELS);
+	EXPECT_TRUE(events & EV_ACCESS);
+
+	snd_pcm_close(play);
+	snd_pcm_close(capt);
+}
+
+/* With notify, a capture opened second is still pinned to the playback's parameters. */
+TEST_F(aloop, capture_constrained_with_notify) {
+	struct probe_result res;
+	snd_pcm_t *play;
+
+	ASSERT_EQ(set_notify(self->ctl, true), 0);
+	ASSERT_EQ(open_pcm(&play, self->play_name, SND_PCM_STREAM_PLAYBACK, &playback_params), 0);
+
+	ASSERT_EQ(probe_pcm(self->capt_name, SND_PCM_STREAM_CAPTURE, capture_params.format,
+			    &res), 0);
+	EXPECT_EQ(res.rate_min, playback_params.rate);
+	EXPECT_EQ(res.rate_max, playback_params.rate);
+	EXPECT_EQ(res.channels_min, playback_params.channels);
+	EXPECT_EQ(res.channels_max, playback_params.channels);
+	EXPECT_FALSE(res.format_ok);
+
+	snd_pcm_close(play);
+}
+
+TEST_HARNESS_MAIN

-- 
2.53.0