[PATCH] selftests/alsa: Add a test for the sequencer UMP conversion of RPN/NRPN

[PATCH] selftests/alsa: Add a test for the sequencer UMP conversion of RPN/NRPN

[HyeongJun An]

The sequencer converts MIDI 1.0 CC and CONTROL14 events to UMP for
UMP clients. Add a test that sends such events from a legacy client to
a UMP MIDI 2.0 client and checks the RPN/NRPN packets it receives, and
one that checks that a UMP MIDI 1.0 client gets the CCs as they are.

The cases cover switching between RPN and NRPN, Data Entry sent with
nothing selected, repeated Data Entry, Null RPN and NRPN, and the
CONTROL14 path. Some of them come from the KUnit test in Alyandra
Zahran Nadhir's patch.

The test skips when /dev/snd/seq can't be opened or the kernel has no
UMP support in the sequencer.

Link: https://lore.kernel.org/all/20261107111056.667-1-alyandra5b@gmail.com/
Signed-off-by: HyeongJun An <sammiee5311@gmail.com>
---
This depends on the RPN/NRPN series [1]. Without it, 11 of the 22
tests fail.

[1] https://lore.kernel.org/all/cover.1794141913.git.sammiee5311@gmail.com/

Prepared with Claude Code (Claude Opus 5.5). Tested on x86_64 under
qemu: 22/22 pass with the series applied.

 tools/testing/selftests/alsa/.gitignore     |   1 +
 tools/testing/selftests/alsa/Makefile       |   3 +-
 tools/testing/selftests/alsa/seq-ump-test.c | 452 ++++++++++++++++++++
 3 files changed, 455 insertions(+), 1 deletion(-)
 create mode 100644 tools/testing/selftests/alsa/seq-ump-test.c

diff --git a/tools/testing/selftests/alsa/.gitignore b/tools/testing/selftests/alsa/.gitignore
index 7b0e1e9ebf1b..a0762c3c52e6 100644
--- a/tools/testing/selftests/alsa/.gitignore
+++ b/tools/testing/selftests/alsa/.gitignore
@@ -2,5 +2,6 @@ aloop-test
 global-timer
 mixer-test
 pcm-test
+seq-ump-test
 test-pcmtest-driver
 utimer-test
diff --git a/tools/testing/selftests/alsa/Makefile b/tools/testing/selftests/alsa/Makefile
index afd64a679dc1..92de58287e77 100644
--- a/tools/testing/selftests/alsa/Makefile
+++ b/tools/testing/selftests/alsa/Makefile
@@ -16,7 +16,8 @@ LDLIBS+=-lpthread
 
 OVERRIDE_TARGETS = 1
 
-TEST_GEN_PROGS := aloop-test mixer-test pcm-test test-pcmtest-driver utimer-test
+TEST_GEN_PROGS := aloop-test mixer-test pcm-test seq-ump-test test-pcmtest-driver \
+		  utimer-test
 
 TEST_GEN_PROGS_EXTENDED := libatest.so global-timer
 
diff --git a/tools/testing/selftests/alsa/seq-ump-test.c b/tools/testing/selftests/alsa/seq-ump-test.c
new file mode 100644
index 000000000000..d1eca920cfc8
--- /dev/null
+++ b/tools/testing/selftests/alsa/seq-ump-test.c
@@ -0,0 +1,452 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Test the conversion of MIDI 1.0 sequencer events to UMP.
+ *
+ * A legacy client sends CC and CONTROL14 events to a UMP client, and the
+ * test checks the packets that the UMP client receives. The converter keeps
+ * its RPN/NRPN state per destination port and channel, so each test uses
+ * new clients.
+ */
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <sound/asequencer.h>
+
+#include "kselftest_harness.h"
+
+#define MAX_PACKETS	8
+#define CAP_IN	(SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE)
+#define CAP_OUT	(SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ)
+#define READ_TIMEOUT_MS	100
+
+/* first word of a MIDI 2.0 RPN/NRPN packet on group 0 */
+#define RPN(ch, bank, index) \
+	(0x40200000u | ((ch) << 16) | ((bank) << 8) | (index))
+#define NRPN(ch, bank, index) \
+	(0x40300000u | ((ch) << 16) | ((bank) << 8) | (index))
+
+struct packet {
+	unsigned int w0;
+	unsigned int w1;
+};
+
+struct seq_client {
+	int fd;
+	int id;
+	int port;
+};
+
+/* the same scaling as the kernel's upscale_14_to_32bit() */
+static unsigned int data14(unsigned int msb, unsigned int lsb)
+{
+	unsigned int src = (msb << 7) | lsb;
+	unsigned int val = src << 18;
+	unsigned int repeat;
+
+	if (src <= 0x2000)
+		return val;
+	repeat = src & 0x1fff;
+	return val | (repeat << 5) | (repeat >> 8);
+}
+
+/* returns 0, or a negative errno with *skip set when UMP is unavailable */
+static int open_client(struct seq_client *c, int midi_version,
+		       unsigned int cap, int *skip)
+{
+	struct snd_seq_client_info info;
+	struct snd_seq_port_info port;
+	int ver = SNDRV_SEQ_VERSION;
+
+	c->fd = open("/dev/snd/seq", O_RDWR | O_NONBLOCK);
+	if (c->fd < 0) {
+		*skip = 1;
+		return -errno;
+	}
+	if (ioctl(c->fd, SNDRV_SEQ_IOCTL_CLIENT_ID, &c->id) < 0)
+		return -errno;
+
+	if (midi_version) {
+		if (ioctl(c->fd, SNDRV_SEQ_IOCTL_USER_PVERSION, &ver) < 0) {
+			*skip = 1;
+			return -errno;
+		}
+		memset(&info, 0, sizeof(info));
+		info.client = c->id;
+		if (ioctl(c->fd, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, &info) < 0)
+			return -errno;
+		info.midi_version = midi_version;
+		if (ioctl(c->fd, SNDRV_SEQ_IOCTL_SET_CLIENT_INFO, &info) < 0) {
+			*skip = 1;
+			return -errno;
+		}
+	}
+
+	memset(&port, 0, sizeof(port));
+	port.addr.client = c->id;
+	strcpy(port.name, "seq-ump-test");
+	port.capability = cap;
+	port.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
+		    SNDRV_SEQ_PORT_TYPE_APPLICATION;
+	if (ioctl(c->fd, SNDRV_SEQ_IOCTL_CREATE_PORT, &port) < 0)
+		return -errno;
+	c->port = port.addr.port;
+	return 0;
+}
+
+static void close_client(struct seq_client *c)
+{
+	if (c->fd >= 0)
+		close(c->fd);
+	c->fd = -1;
+}
+
+static int send_event(struct seq_client *src, struct seq_client *dst,
+		      int type, int ch, int param, int value)
+{
+	struct snd_seq_event ev;
+
+	memset(&ev, 0, sizeof(ev));
+	ev.type = type;
+	ev.flags = SNDRV_SEQ_TIME_STAMP_TICK | SNDRV_SEQ_EVENT_LENGTH_FIXED;
+	ev.queue = SNDRV_SEQ_QUEUE_DIRECT;
+	ev.source.client = src->id;
+	ev.source.port = src->port;
+	ev.dest.client = dst->id;
+	ev.dest.port = dst->port;
+	ev.data.control.channel = ch;
+	ev.data.control.param = param;
+	ev.data.control.value = value;
+	if (write(src->fd, &ev, sizeof(ev)) != sizeof(ev))
+		return -errno;
+	return 0;
+}
+
+/*
+ * Read what the UMP client received until it is quiet, and keep the
+ * packets of message type @mt. Returns the number of packets kept.
+ */
+static int read_packets(struct seq_client *dst, unsigned int mt,
+			struct packet *out)
+{
+	struct pollfd pfd = { .fd = dst->fd, .events = POLLIN };
+	struct snd_seq_ump_event ev;
+	int n = 0;
+
+	while (poll(&pfd, 1, READ_TIMEOUT_MS) > 0) {
+		if (read(dst->fd, &ev, sizeof(ev)) != sizeof(ev))
+			break;
+		if (!(ev.flags & SNDRV_SEQ_EVENT_UMP) || ev.ump[0] >> 28 != mt)
+			continue;
+		if (n < MAX_PACKETS) {
+			out[n].w0 = ev.ump[0];
+			out[n].w1 = ev.ump[1];
+		}
+		n++;
+	}
+	return n;
+}
+
+FIXTURE(seq_ump) {
+	struct seq_client src;
+	struct seq_client dst;
+};
+
+FIXTURE_SETUP(seq_ump)
+{
+	int skip = 0;
+	int err;
+
+	self->src.fd = -1;
+	self->dst.fd = -1;
+
+	err = open_client(&self->dst, SNDRV_SEQ_CLIENT_UMP_MIDI_2_0,
+			  CAP_IN, &skip);
+	if (skip)
+		SKIP(return, "UMP sequencer client unavailable: %s",
+		     strerror(-err));
+	ASSERT_EQ(0, err);
+
+	err = open_client(&self->src, 0, CAP_OUT, &skip);
+	ASSERT_EQ(0, err);
+}
+
+FIXTURE_TEARDOWN(seq_ump)
+{
+	close_client(&self->src);
+	close_client(&self->dst);
+}
+
+struct event {
+	int type;
+	int ch;
+	int param;
+	int value;
+};
+
+#define CC(ch, param, value) \
+	{ SNDRV_SEQ_EVENT_CONTROLLER, ch, param, value }
+#define C14(ch, param, value) \
+	{ SNDRV_SEQ_EVENT_CONTROL14, ch, param, value }
+
+static int send_events(struct seq_client *src, struct seq_client *dst,
+		       const struct event *ev, int n)
+{
+	int i, err;
+
+	for (i = 0; i < n; i++) {
+		err = send_event(src, dst, ev[i].type, ev[i].ch,
+				 ev[i].param, ev[i].value);
+		if (err)
+			return err;
+	}
+	return 0;
+}
+
+#define SEND(...) do {							\
+	const struct event ev[] = { __VA_ARGS__ };			\
+									\
+	ASSERT_EQ(0, send_events(&self->src, &self->dst, ev,		\
+				 ARRAY_SIZE(ev)));			\
+} while (0)
+
+/* compare the RPN/NRPN packets received with the expected ones */
+#define EXPECT_PACKETS(...) do {					\
+	const struct packet want[] = { __VA_ARGS__ };			\
+	struct packet got[MAX_PACKETS];					\
+	int n = read_packets(&self->dst, 4, got);			\
+	int i;								\
+									\
+	ASSERT_EQ((int)ARRAY_SIZE(want), n);				\
+	for (i = 0; i < n; i++) {					\
+		EXPECT_EQ(want[i].w0, got[i].w0);			\
+		EXPECT_EQ(want[i].w1, got[i].w1);			\
+	}								\
+} while (0)
+
+#define EXPECT_NO_PACKETS() do {					\
+	struct packet got[MAX_PACKETS];					\
+									\
+	EXPECT_EQ(0, read_packets(&self->dst, 4, got));			\
+} while (0)
+
+/* RPN 0/1 with Data Entry */
+TEST_F(seq_ump, rpn)
+{
+	SEND(CC(0, 101, 0), CC(0, 100, 1), CC(0, 6, 0x40), CC(0, 38, 0));
+	EXPECT_PACKETS({ RPN(0, 0, 1), data14(0x40, 0) });
+}
+
+/* Data Entry after a Null RPN is not sent at the next selection */
+TEST_F(seq_ump, data_after_null_rpn)
+{
+	SEND(CC(0, 101, 0x7f), CC(0, 100, 0x7f), CC(0, 6, 0x40), CC(0, 38, 0));
+	SEND(CC(0, 101, 0), CC(0, 100, 1));
+	EXPECT_NO_PACKETS();
+}
+
+/* Data Entry before any selection is not sent at the next selection */
+TEST_F(seq_ump, data_before_selection)
+{
+	SEND(CC(0, 6, 0x40), CC(0, 38, 0), CC(0, 101, 0), CC(0, 100, 1));
+	EXPECT_NO_PACKETS();
+}
+
+/* the same for an NRPN selected after a Null RPN */
+TEST_F(seq_ump, data_after_null_rpn_to_nrpn)
+{
+	SEND(CC(0, 101, 0x7f), CC(0, 100, 0x7f), CC(0, 6, 0x40), CC(0, 38, 0));
+	SEND(CC(0, 99, 0), CC(0, 98, 5));
+	EXPECT_NO_PACKETS();
+}
+
+/* a repeated Data Entry goes to the selected RPN */
+TEST_F(seq_ump, repeated_data)
+{
+	SEND(CC(0, 101, 0), CC(0, 100, 2), CC(0, 6, 0x40), CC(0, 38, 0));
+	SEND(CC(0, 6, 0x10), CC(0, 38, 0), CC(0, 101, 0), CC(0, 100, 1));
+	EXPECT_PACKETS({ RPN(0, 0, 2), data14(0x40, 0) },
+		       { RPN(0, 0, 2), data14(0x10, 0) });
+}
+
+/* two values for one RPN, then another RPN */
+TEST_F(seq_ump, two_rpns)
+{
+	SEND(CC(0, 101, 0), CC(0, 100, 0), CC(0, 6, 2), CC(0, 38, 0));
+	SEND(CC(0, 6, 12), CC(0, 38, 0));
+	SEND(CC(0, 101, 0), CC(0, 100, 1), CC(0, 6, 0x40), CC(0, 38, 0));
+	EXPECT_PACKETS({ RPN(0, 0, 0), data14(2, 0) },
+		       { RPN(0, 0, 0), data14(12, 0) },
+		       { RPN(0, 0, 1), data14(0x40, 0) });
+}
+
+/* the RPN number is held after a send, like the NRPN number */
+TEST_F(seq_ump, rpn_msb_held)
+{
+	SEND(CC(0, 101, 1), CC(0, 100, 1), CC(0, 6, 0x40), CC(0, 38, 0));
+	SEND(CC(0, 100, 2), CC(0, 6, 0x10), CC(0, 38, 0));
+	EXPECT_PACKETS({ RPN(0, 1, 1), data14(0x40, 0) },
+		       { RPN(0, 1, 2), data14(0x10, 0) });
+}
+
+/* selecting an NRPN replaces an RPN selection, and the reverse */
+TEST_F(seq_ump, selector_switch)
+{
+	SEND(CC(0, 101, 0x11), CC(0, 100, 0x12), CC(0, 99, 0x21),
+	     CC(0, 98, 0x22));
+	SEND(CC(0, 6, 0x31), CC(0, 38, 0x32));
+	SEND(CC(1, 99, 0x41), CC(1, 98, 0x42), CC(1, 101, 0x51),
+	     CC(1, 100, 0x52));
+	SEND(CC(1, 6, 0x61), CC(1, 38, 0x62));
+	EXPECT_PACKETS({ NRPN(0, 0x21, 0x22), data14(0x31, 0x32) },
+		       { RPN(1, 0x51, 0x52), data14(0x61, 0x62) });
+}
+
+/*
+ * A pending Data Entry MSB is sent for the old selection when another
+ * one is made. Other channels keep their own selection.
+ */
+TEST_F(seq_ump, pending_flush_and_channels)
+{
+	SEND(CC(2, 101, 0x09), CC(2, 100, 0x08));
+	SEND(CC(3, 99, 0x17), CC(3, 98, 0x18));
+	SEND(CC(2, 6, 0x25), CC(2, 99, 0x29));
+	SEND(CC(3, 6, 0x33), CC(3, 38, 0));
+	EXPECT_PACKETS({ RPN(2, 0x09, 0x08), data14(0x25, 0) },
+		       { NRPN(3, 0x17, 0x18), data14(0x33, 0) });
+}
+
+/* a Null NRPN deselects, and its data is not sent */
+TEST_F(seq_ump, null_nrpn)
+{
+	SEND(CC(0, 99, 0x7f), CC(0, 98, 0x7f), CC(0, 6, 0x40), CC(0, 38, 0));
+	EXPECT_NO_PACKETS();
+}
+
+/* a Null RPN also deselects an NRPN */
+TEST_F(seq_ump, null_rpn_after_nrpn)
+{
+	SEND(CC(0, 99, 1), CC(0, 98, 2), CC(0, 101, 0x7f), CC(0, 100, 0x7f));
+	SEND(CC(0, 6, 0x10), CC(0, 38, 0));
+	EXPECT_NO_PACKETS();
+}
+
+/* a Null NRPN does not touch the RPN number */
+TEST_F(seq_ump, null_nrpn_keeps_rpn_number)
+{
+	SEND(CC(0, 100, 1), CC(0, 99, 0x7f), CC(0, 98, 0x7f), CC(0, 101, 0));
+	SEND(CC(0, 6, 0x10), CC(0, 38, 0));
+	EXPECT_PACKETS({ RPN(0, 0, 1), data14(0x10, 0) });
+}
+
+/* a Null RPN sent around a Null NRPN still deselects */
+TEST_F(seq_ump, null_rpn_split_by_null_nrpn)
+{
+	SEND(CC(0, 100, 0x7f), CC(0, 99, 0x7f), CC(0, 98, 0x7f),
+	     CC(0, 101, 0x7f));
+	SEND(CC(0, 6, 0x10), CC(0, 38, 0));
+	EXPECT_NO_PACKETS();
+}
+
+/* a Null RPN after an RPN with LSB 127 does not select RPN 0/127 */
+TEST_F(seq_ump, null_rpn_after_lsb_127)
+{
+	SEND(CC(0, 101, 0), CC(0, 100, 0x7f), CC(0, 6, 0x40), CC(0, 38, 0));
+	SEND(CC(0, 101, 0x7f), CC(0, 100, 0x7f), CC(0, 6, 0x10), CC(0, 38, 0));
+	EXPECT_PACKETS({ RPN(0, 0, 0x7f), data14(0x40, 0) });
+}
+
+/* CONTROL14: RPN 0/1 with Data Entry */
+TEST_F(seq_ump, c14_rpn)
+{
+	SEND(C14(0, 101, 1), C14(0, 6, 0x40 << 7));
+	EXPECT_PACKETS({ RPN(0, 0, 1), data14(0x40, 0) });
+}
+
+/* CONTROL14: Data Entry before any selection is not sent */
+TEST_F(seq_ump, c14_data_before_selection)
+{
+	SEND(C14(0, 6, 0x40 << 7), C14(0, 101, 1), C14(0, 101, 2));
+	EXPECT_NO_PACKETS();
+}
+
+/* CONTROL14: a repeated Data Entry goes to the selected RPN */
+TEST_F(seq_ump, c14_repeated_data)
+{
+	SEND(C14(0, 101, 1), C14(0, 6, 0x40 << 7), C14(0, 6, 0x10 << 7));
+	EXPECT_PACKETS({ RPN(0, 0, 1), data14(0x40, 0) },
+		       { RPN(0, 0, 1), data14(0x10, 0) });
+}
+
+/* CONTROL14: selecting an NRPN replaces an RPN selection, and the reverse */
+TEST_F(seq_ump, c14_selector_switch)
+{
+	SEND(C14(4, 101, (1 << 7) | 2), C14(4, 99, (3 << 7) | 4));
+	SEND(C14(4, 6, (5 << 7) | 6));
+	SEND(C14(5, 99, (7 << 7) | 8), C14(5, 101, (9 << 7) | 10));
+	SEND(C14(5, 6, (11 << 7) | 12));
+	EXPECT_PACKETS({ NRPN(4, 3, 4), data14(5, 6) },
+		       { RPN(5, 9, 10), data14(11, 12) });
+}
+
+/* CONTROL14: a pending Data Entry is sent for the old selection */
+TEST_F(seq_ump, c14_pending_flush)
+{
+	SEND(C14(6, 99, (2 << 7) | 3), CC(6, 6, 0x35),
+	     C14(6, 101, (4 << 7) | 5));
+	EXPECT_PACKETS({ NRPN(6, 2, 3), data14(0x35, 0) });
+}
+
+/* CONTROL14: a Null RPN deselects an NRPN, and so does a Null NRPN */
+TEST_F(seq_ump, c14_null)
+{
+	SEND(C14(0, 99, (3 << 7) | 4), C14(0, 101, 0x3fff));
+	SEND(C14(0, 6, 0x10 << 7));
+	SEND(C14(1, 101, 1), C14(1, 99, 0x3fff), C14(1, 6, 0x10 << 7));
+	EXPECT_NO_PACKETS();
+}
+
+/* CONTROL14: a Null NRPN does not touch the RPN number */
+TEST_F(seq_ump, c14_null_nrpn_keeps_rpn_number)
+{
+	SEND(CC(0, 100, 1), C14(0, 99, 0x3fff), CC(0, 101, 0));
+	SEND(C14(0, 6, 0x10 << 7));
+	EXPECT_PACKETS({ RPN(0, 0, 1), data14(0x10, 0) });
+}
+
+/* a UMP MIDI 1.0 client gets the CCs as they are, RPN selection included */
+TEST(midi1_passthrough)
+{
+	struct seq_client src = { .fd = -1 }, dst = { .fd = -1 };
+	struct packet got[MAX_PACKETS];
+	int skip = 0;
+	int err;
+
+	err = open_client(&dst, SNDRV_SEQ_CLIENT_UMP_MIDI_1_0,
+			  CAP_IN, &skip);
+	if (skip) {
+		close_client(&dst);
+		SKIP(return, "UMP sequencer client unavailable: %s",
+		     strerror(-err));
+	}
+	ASSERT_EQ(0, err);
+	ASSERT_EQ(0, open_client(&src, 0, CAP_OUT, &skip));
+
+	ASSERT_EQ(0, send_event(&src, &dst, SNDRV_SEQ_EVENT_CONTROLLER,
+				9, 0x40, 0x22));
+	ASSERT_EQ(0, send_event(&src, &dst, SNDRV_SEQ_EVENT_CONTROLLER,
+				3, 101, 0x12));
+	ASSERT_EQ(0, send_event(&src, &dst, SNDRV_SEQ_EVENT_CONTROLLER,
+				3, 99, 0x34));
+	ASSERT_EQ(3, read_packets(&dst, 2, got));
+	EXPECT_EQ(0x20b94022u, got[0].w0);
+	EXPECT_EQ(0x20b36512u, got[1].w0);
+	EXPECT_EQ(0x20b36334u, got[2].w0);
+
+	close_client(&src);
+	close_client(&dst);
+}
+
+TEST_HARNESS_MAIN
-- 
2.43.0

Re: [PATCH] selftests/alsa: Add a test for the sequencer UMP conversion of RPN/NRPN

[Takashi Iwai]

On Tue, 10 Nov 2026 02:22:13 +0100,
HyeongJun An wrote:
> 
> The sequencer converts MIDI 1.0 CC and CONTROL14 events to UMP for
> UMP clients. Add a test that sends such events from a legacy client to
> a UMP MIDI 2.0 client and checks the RPN/NRPN packets it receives, and
> one that checks that a UMP MIDI 1.0 client gets the CCs as they are.
> 
> The cases cover switching between RPN and NRPN, Data Entry sent with
> nothing selected, repeated Data Entry, Null RPN and NRPN, and the
> CONTROL14 path. Some of them come from the KUnit test in Alyandra
> Zahran Nadhir's patch.
> 
> The test skips when /dev/snd/seq can't be opened or the kernel has no
> UMP support in the sequencer.
> 
> Link: https://lore.kernel.org/all/20261107111056.667-1-alyandra5b@gmail.com/
> Signed-off-by: HyeongJun An <sammiee5311@gmail.com>

Applied to for-next branch now.  Thanks.


Takashi