1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * This is the test which covers PCM middle layer data transferring using
4  * the virtual pcm test driver (snd-pcmtest).
5  *
6  * Copyright 2023 Ivan Orlov <ivan.orlov0322@gmail.com>
7  */
8 #include <string.h>
9 #include <alsa/asoundlib.h>
10 #include "../kselftest_harness.h"
11 
12 #define CH_NUM 4
13 
14 struct pattern_buf {
15 	char buf[1024];
16 	int len;
17 };
18 
19 struct pattern_buf patterns[CH_NUM];
20 
21 struct pcmtest_test_params {
22 	unsigned long buffer_size;
23 	unsigned long period_size;
24 	unsigned long channels;
25 	unsigned int rate;
26 	snd_pcm_access_t access;
27 	size_t sec_buf_len;
28 	size_t sample_size;
29 	int time;
30 	snd_pcm_format_t format;
31 };
32 
33 static int read_patterns(void)
34 {
35 	FILE *fp, *fpl;
36 	int i;
37 	char pf[64];
38 	char plf[64];
39 
40 	for (i = 0; i < CH_NUM; i++) {
41 		sprintf(plf, "/sys/kernel/debug/pcmtest/fill_pattern%d_len", i);
42 		fpl = fopen(plf, "r");
43 		if (!fpl)
44 			return -1;
45 		fscanf(fpl, "%u", &patterns[i].len);
46 		fclose(fpl);
47 
48 		sprintf(pf, "/sys/kernel/debug/pcmtest/fill_pattern%d", i);
49 		fp = fopen(pf, "r");
50 		if (!fp)
51 			return -1;
52 		fread(patterns[i].buf, 1, patterns[i].len, fp);
53 		fclose(fp);
54 	}
55 
56 	return 0;
57 }
58 
59 static int get_test_results(char *debug_name)
60 {
61 	int result;
62 	FILE *f;
63 	char fname[128];
64 
65 	sprintf(fname, "/sys/kernel/debug/pcmtest/%s", debug_name);
66 
67 	f = fopen(fname, "r");
68 	if (!f) {
69 		printf("Failed to open file\n");
70 		return -1;
71 	}
72 	fscanf(f, "%d", &result);
73 	fclose(f);
74 
75 	return result;
76 }
77 
78 static size_t get_sec_buf_len(unsigned int rate, unsigned long channels, snd_pcm_format_t format)
79 {
80 	return rate * channels * snd_pcm_format_physical_width(format) / 8;
81 }
82 
83 static int setup_handle(snd_pcm_t **handle, snd_pcm_sw_params_t *swparams,
84 			snd_pcm_hw_params_t *hwparams, struct pcmtest_test_params *params,
85 			int card, snd_pcm_stream_t stream)
86 {
87 	char pcm_name[32];
88 	int err;
89 
90 	sprintf(pcm_name, "hw:%d,0,0", card);
91 	err = snd_pcm_open(handle, pcm_name, stream, 0);
92 	if (err < 0)
93 		return err;
94 	snd_pcm_hw_params_any(*handle, hwparams);
95 	snd_pcm_hw_params_set_rate_resample(*handle, hwparams, 0);
96 	snd_pcm_hw_params_set_access(*handle, hwparams, params->access);
97 	snd_pcm_hw_params_set_format(*handle, hwparams, params->format);
98 	snd_pcm_hw_params_set_channels(*handle, hwparams, params->channels);
99 	snd_pcm_hw_params_set_rate_near(*handle, hwparams, &params->rate, 0);
100 	snd_pcm_hw_params_set_period_size_near(*handle, hwparams, &params->period_size, 0);
101 	snd_pcm_hw_params_set_buffer_size_near(*handle, hwparams, &params->buffer_size);
102 	snd_pcm_hw_params(*handle, hwparams);
103 	snd_pcm_sw_params_current(*handle, swparams);
104 
105 	snd_pcm_hw_params_set_rate_resample(*handle, hwparams, 0);
106 	snd_pcm_sw_params_set_avail_min(*handle, swparams, params->period_size);
107 	snd_pcm_hw_params_set_buffer_size_near(*handle, hwparams, &params->buffer_size);
108 	snd_pcm_hw_params_set_period_size_near(*handle, hwparams, &params->period_size, 0);
109 	snd_pcm_sw_params(*handle, swparams);
110 	snd_pcm_hw_params(*handle, hwparams);
111 
112 	return 0;
113 }
114 
115 FIXTURE(pcmtest) {
116 	int card;
117 	snd_pcm_sw_params_t *swparams;
118 	snd_pcm_hw_params_t *hwparams;
119 	struct pcmtest_test_params params;
120 };
121 
122 FIXTURE_TEARDOWN(pcmtest) {
123 }
124 
125 FIXTURE_SETUP(pcmtest) {
126 	char *card_name;
127 	int err;
128 
129 	if (geteuid())
130 		SKIP(exit(-1), "This test needs root to run!");
131 
132 	err = read_patterns();
133 	if (err)
134 		SKIP(exit(-1), "Can't read patterns. Probably, module isn't loaded");
135 
136 	card_name = malloc(127);
137 	ASSERT_NE(card_name, NULL);
138 	self->params.buffer_size = 16384;
139 	self->params.period_size = 4096;
140 	self->params.channels = CH_NUM;
141 	self->params.rate = 8000;
142 	self->params.access = SND_PCM_ACCESS_RW_INTERLEAVED;
143 	self->params.format = SND_PCM_FORMAT_S16_LE;
144 	self->card = -1;
145 	self->params.sample_size = snd_pcm_format_physical_width(self->params.format) / 8;
146 
147 	self->params.sec_buf_len = get_sec_buf_len(self->params.rate, self->params.channels,
148 						   self->params.format);
149 	self->params.time = 4;
150 
151 	while (snd_card_next(&self->card) >= 0) {
152 		if (self->card == -1)
153 			break;
154 		snd_card_get_name(self->card, &card_name);
155 		if (!strcmp(card_name, "PCM-Test"))
156 			break;
157 	}
158 	free(card_name);
159 	ASSERT_NE(self->card, -1);
160 }
161 
162 /*
163  * Here we are trying to send the looped monotonically increasing sequence of bytes to the driver.
164  * If our data isn't corrupted, the driver will set the content of 'pc_test' debugfs file to '1'
165  */
166 TEST_F(pcmtest, playback) {
167 	snd_pcm_t *handle;
168 	unsigned char *it;
169 	size_t write_res;
170 	int test_results;
171 	int i, cur_ch, pos_in_ch;
172 	void *samples;
173 	struct pcmtest_test_params *params = &self->params;
174 
175 	samples = calloc(self->params.sec_buf_len * self->params.time, 1);
176 	ASSERT_NE(samples, NULL);
177 
178 	snd_pcm_sw_params_alloca(&self->swparams);
179 	snd_pcm_hw_params_alloca(&self->hwparams);
180 
181 	ASSERT_EQ(setup_handle(&handle, self->swparams, self->hwparams, params,
182 			       self->card, SND_PCM_STREAM_PLAYBACK), 0);
183 	snd_pcm_format_set_silence(params->format, samples,
184 				   params->rate * params->channels * params->time);
185 	it = samples;
186 	for (i = 0; i < self->params.sec_buf_len * params->time; i++) {
187 		cur_ch = (i / params->sample_size) % CH_NUM;
188 		pos_in_ch = i / params->sample_size / CH_NUM * params->sample_size
189 			    + (i % params->sample_size);
190 		it[i] = patterns[cur_ch].buf[pos_in_ch % patterns[cur_ch].len];
191 	}
192 	write_res = snd_pcm_writei(handle, samples, params->rate * params->time);
193 	ASSERT_GE(write_res, 0);
194 
195 	snd_pcm_close(handle);
196 	free(samples);
197 	test_results = get_test_results("pc_test");
198 	ASSERT_EQ(test_results, 1);
199 }
200 
201 /*
202  * Here we test that the virtual alsa driver returns looped and monotonically increasing sequence
203  * of bytes. In the interleaved mode the buffer will contain samples in the following order:
204  * C0, C1, C2, C3, C0, C1, ...
205  */
206 TEST_F(pcmtest, capture) {
207 	snd_pcm_t *handle;
208 	unsigned char *it;
209 	size_t read_res;
210 	int i, cur_ch, pos_in_ch;
211 	void *samples;
212 	struct pcmtest_test_params *params = &self->params;
213 
214 	samples = calloc(self->params.sec_buf_len * self->params.time, 1);
215 	ASSERT_NE(samples, NULL);
216 
217 	snd_pcm_sw_params_alloca(&self->swparams);
218 	snd_pcm_hw_params_alloca(&self->hwparams);
219 
220 	ASSERT_EQ(setup_handle(&handle, self->swparams, self->hwparams,
221 			       params, self->card, SND_PCM_STREAM_CAPTURE), 0);
222 	snd_pcm_format_set_silence(params->format, samples,
223 				   params->rate * params->channels * params->time);
224 	read_res = snd_pcm_readi(handle, samples, params->rate * params->time);
225 	ASSERT_GE(read_res, 0);
226 	snd_pcm_close(handle);
227 	it = (unsigned char *)samples;
228 	for (i = 0; i < self->params.sec_buf_len * self->params.time; i++) {
229 		cur_ch = (i / params->sample_size) % CH_NUM;
230 		pos_in_ch = i / params->sample_size / CH_NUM * params->sample_size
231 			    + (i % params->sample_size);
232 		ASSERT_EQ(it[i], patterns[cur_ch].buf[pos_in_ch % patterns[cur_ch].len]);
233 	}
234 	free(samples);
235 }
236 
237 // Test capture in the non-interleaved access mode. The are buffers for each recorded channel
238 TEST_F(pcmtest, ni_capture) {
239 	snd_pcm_t *handle;
240 	struct pcmtest_test_params params = self->params;
241 	char **chan_samples;
242 	size_t i, j, read_res;
243 
244 	chan_samples = calloc(CH_NUM, sizeof(*chan_samples));
245 	ASSERT_NE(chan_samples, NULL);
246 
247 	snd_pcm_sw_params_alloca(&self->swparams);
248 	snd_pcm_hw_params_alloca(&self->hwparams);
249 
250 	params.access = SND_PCM_ACCESS_RW_NONINTERLEAVED;
251 
252 	ASSERT_EQ(setup_handle(&handle, self->swparams, self->hwparams,
253 			       &params, self->card, SND_PCM_STREAM_CAPTURE), 0);
254 
255 	for (i = 0; i < CH_NUM; i++)
256 		chan_samples[i] = calloc(params.sec_buf_len * params.time, 1);
257 
258 	for (i = 0; i < 1; i++) {
259 		read_res = snd_pcm_readn(handle, (void **)chan_samples, params.rate * params.time);
260 		ASSERT_GE(read_res, 0);
261 	}
262 	snd_pcm_close(handle);
263 
264 	for (i = 0; i < CH_NUM; i++) {
265 		for (j = 0; j < params.rate * params.time; j++)
266 			ASSERT_EQ(chan_samples[i][j], patterns[i].buf[j % patterns[i].len]);
267 		free(chan_samples[i]);
268 	}
269 	free(chan_samples);
270 }
271 
272 TEST_F(pcmtest, ni_playback) {
273 	snd_pcm_t *handle;
274 	struct pcmtest_test_params params = self->params;
275 	char **chan_samples;
276 	size_t i, j, read_res;
277 	int test_res;
278 
279 	chan_samples = calloc(CH_NUM, sizeof(*chan_samples));
280 	ASSERT_NE(chan_samples, NULL);
281 
282 	snd_pcm_sw_params_alloca(&self->swparams);
283 	snd_pcm_hw_params_alloca(&self->hwparams);
284 
285 	params.access = SND_PCM_ACCESS_RW_NONINTERLEAVED;
286 
287 	ASSERT_EQ(setup_handle(&handle, self->swparams, self->hwparams,
288 			       &params, self->card, SND_PCM_STREAM_PLAYBACK), 0);
289 
290 	for (i = 0; i < CH_NUM; i++) {
291 		chan_samples[i] = calloc(params.sec_buf_len * params.time, 1);
292 		for (j = 0; j < params.sec_buf_len * params.time; j++)
293 			chan_samples[i][j] = patterns[i].buf[j % patterns[i].len];
294 	}
295 
296 	for (i = 0; i < 1; i++) {
297 		read_res = snd_pcm_writen(handle, (void **)chan_samples, params.rate * params.time);
298 		ASSERT_GE(read_res, 0);
299 	}
300 
301 	snd_pcm_close(handle);
302 	test_res = get_test_results("pc_test");
303 	ASSERT_EQ(test_res, 1);
304 
305 	for (i = 0; i < CH_NUM; i++)
306 		free(chan_samples[i]);
307 	free(chan_samples);
308 }
309 
310 /*
311  * Here we are testing the custom ioctl definition inside the virtual driver. If it triggers
312  * successfully, the driver sets the content of 'ioctl_test' debugfs file to '1'.
313  */
314 TEST_F(pcmtest, reset_ioctl) {
315 	snd_pcm_t *handle;
316 	unsigned char *it;
317 	int test_res;
318 	struct pcmtest_test_params *params = &self->params;
319 
320 	snd_pcm_sw_params_alloca(&self->swparams);
321 	snd_pcm_hw_params_alloca(&self->hwparams);
322 
323 	ASSERT_EQ(setup_handle(&handle, self->swparams, self->hwparams, params,
324 			       self->card, SND_PCM_STREAM_CAPTURE), 0);
325 	snd_pcm_reset(handle);
326 	test_res = get_test_results("ioctl_test");
327 	ASSERT_EQ(test_res, 1);
328 	snd_pcm_close(handle);
329 }
330 
331 TEST_HARNESS_MAIN
332