1 files changed, 345 insertions, 0 deletions

diff --git a/tools/testing/selftests/alsa/aloop-test.c b/tools/testing/selftests/alsa/aloop-test.c
new file mode 100644
index 000000000000..a58b9fdbdc17
--- /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