1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // kselftest for the ALSA PCM API
4 //
5 // Original author: Jaroslav Kysela <perex@perex.cz>
6 // Copyright (c) 2022 Red Hat Inc.
7
8 // This test will iterate over all cards detected in the system, exercising
9 // every PCM device it can find. This may conflict with other system
10 // software if there is audio activity so is best run on a system with a
11 // minimal active userspace.
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <stdbool.h>
16 #include <errno.h>
17 #include <assert.h>
18 #include <pthread.h>
19
20 #include "../kselftest.h"
21 #include "alsa-local.h"
22
23 typedef struct timespec timestamp_t;
24
25 struct card_data {
26 int card;
27 pthread_t thread;
28 struct card_data *next;
29 };
30
31 struct card_data *card_list = NULL;
32
33 struct pcm_data {
34 snd_pcm_t *handle;
35 int card;
36 int device;
37 int subdevice;
38 snd_pcm_stream_t stream;
39 snd_config_t *pcm_config;
40 struct pcm_data *next;
41 };
42
43 struct pcm_data *pcm_list = NULL;
44
45 int num_missing = 0;
46 struct pcm_data *pcm_missing = NULL;
47
48 snd_config_t *default_pcm_config;
49
50 /* Lock while reporting results since kselftest doesn't */
51 pthread_mutex_t results_lock = PTHREAD_MUTEX_INITIALIZER;
52
53 enum test_class {
54 TEST_CLASS_DEFAULT,
55 TEST_CLASS_SYSTEM,
56 };
57
timestamp_now(timestamp_t * tstamp)58 void timestamp_now(timestamp_t *tstamp)
59 {
60 if (clock_gettime(CLOCK_MONOTONIC_RAW, tstamp))
61 ksft_exit_fail_msg("clock_get_time\n");
62 }
63
timestamp_diff_ms(timestamp_t * tstamp)64 long long timestamp_diff_ms(timestamp_t *tstamp)
65 {
66 timestamp_t now, diff;
67 timestamp_now(&now);
68 if (tstamp->tv_nsec > now.tv_nsec) {
69 diff.tv_sec = now.tv_sec - tstamp->tv_sec - 1;
70 diff.tv_nsec = (now.tv_nsec + 1000000000L) - tstamp->tv_nsec;
71 } else {
72 diff.tv_sec = now.tv_sec - tstamp->tv_sec;
73 diff.tv_nsec = now.tv_nsec - tstamp->tv_nsec;
74 }
75 return (diff.tv_sec * 1000) + ((diff.tv_nsec + 500000L) / 1000000L);
76 }
77
device_from_id(snd_config_t * node)78 static long device_from_id(snd_config_t *node)
79 {
80 const char *id;
81 char *end;
82 long v;
83
84 if (snd_config_get_id(node, &id))
85 ksft_exit_fail_msg("snd_config_get_id\n");
86 errno = 0;
87 v = strtol(id, &end, 10);
88 if (errno || *end)
89 return -1;
90 return v;
91 }
92
missing_device(int card,int device,int subdevice,snd_pcm_stream_t stream)93 static void missing_device(int card, int device, int subdevice, snd_pcm_stream_t stream)
94 {
95 struct pcm_data *pcm_data;
96
97 for (pcm_data = pcm_list; pcm_data != NULL; pcm_data = pcm_data->next) {
98 if (pcm_data->card != card)
99 continue;
100 if (pcm_data->device != device)
101 continue;
102 if (pcm_data->subdevice != subdevice)
103 continue;
104 if (pcm_data->stream != stream)
105 continue;
106 return;
107 }
108 pcm_data = calloc(1, sizeof(*pcm_data));
109 if (!pcm_data)
110 ksft_exit_fail_msg("Out of memory\n");
111 pcm_data->card = card;
112 pcm_data->device = device;
113 pcm_data->subdevice = subdevice;
114 pcm_data->stream = stream;
115 pcm_data->next = pcm_missing;
116 pcm_missing = pcm_data;
117 num_missing++;
118 }
119
missing_devices(int card,snd_config_t * card_config)120 static void missing_devices(int card, snd_config_t *card_config)
121 {
122 snd_config_t *pcm_config, *node1, *node2;
123 snd_config_iterator_t i1, i2, next1, next2;
124 int device, subdevice;
125
126 pcm_config = conf_get_subtree(card_config, "pcm", NULL);
127 if (!pcm_config)
128 return;
129 snd_config_for_each(i1, next1, pcm_config) {
130 node1 = snd_config_iterator_entry(i1);
131 device = device_from_id(node1);
132 if (device < 0)
133 continue;
134 if (snd_config_get_type(node1) != SND_CONFIG_TYPE_COMPOUND)
135 continue;
136 snd_config_for_each(i2, next2, node1) {
137 node2 = snd_config_iterator_entry(i2);
138 subdevice = device_from_id(node2);
139 if (subdevice < 0)
140 continue;
141 if (conf_get_subtree(node2, "PLAYBACK", NULL))
142 missing_device(card, device, subdevice, SND_PCM_STREAM_PLAYBACK);
143 if (conf_get_subtree(node2, "CAPTURE", NULL))
144 missing_device(card, device, subdevice, SND_PCM_STREAM_CAPTURE);
145 }
146 }
147 }
148
find_pcms(void)149 static void find_pcms(void)
150 {
151 char name[32], key[64];
152 char *card_name, *card_longname;
153 int card, dev, subdev, count, direction, err;
154 snd_pcm_stream_t stream;
155 struct pcm_data *pcm_data;
156 snd_ctl_t *handle;
157 snd_pcm_info_t *pcm_info;
158 snd_config_t *config, *card_config, *pcm_config;
159 struct card_data *card_data;
160
161 snd_pcm_info_alloca(&pcm_info);
162
163 card = -1;
164 if (snd_card_next(&card) < 0 || card < 0)
165 return;
166
167 config = get_alsalib_config();
168
169 while (card >= 0) {
170 sprintf(name, "hw:%d", card);
171
172 err = snd_ctl_open_lconf(&handle, name, 0, config);
173 if (err < 0) {
174 ksft_print_msg("Failed to get hctl for card %d: %s\n",
175 card, snd_strerror(err));
176 goto next_card;
177 }
178
179 err = snd_card_get_name(card, &card_name);
180 if (err != 0)
181 card_name = "Unknown";
182 err = snd_card_get_longname(card, &card_longname);
183 if (err != 0)
184 card_longname = "Unknown";
185 ksft_print_msg("Card %d - %s (%s)\n", card,
186 card_name, card_longname);
187
188 card_config = conf_by_card(card);
189
190 card_data = calloc(1, sizeof(*card_data));
191 if (!card_data)
192 ksft_exit_fail_msg("Out of memory\n");
193 card_data->card = card;
194 card_data->next = card_list;
195 card_list = card_data;
196
197 dev = -1;
198 while (1) {
199 if (snd_ctl_pcm_next_device(handle, &dev) < 0)
200 ksft_exit_fail_msg("snd_ctl_pcm_next_device\n");
201 if (dev < 0)
202 break;
203
204 for (direction = 0; direction < 2; direction++) {
205 stream = direction ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK;
206 sprintf(key, "pcm.%d.%s", dev, snd_pcm_stream_name(stream));
207 pcm_config = conf_get_subtree(card_config, key, NULL);
208 if (conf_get_bool(card_config, key, "skip", false)) {
209 ksft_print_msg("skipping pcm %d.%d.%s\n", card, dev, snd_pcm_stream_name(stream));
210 continue;
211 }
212 snd_pcm_info_set_device(pcm_info, dev);
213 snd_pcm_info_set_subdevice(pcm_info, 0);
214 snd_pcm_info_set_stream(pcm_info, stream);
215 err = snd_ctl_pcm_info(handle, pcm_info);
216 if (err == -ENOENT)
217 continue;
218 if (err < 0)
219 ksft_exit_fail_msg("snd_ctl_pcm_info: %d:%d:%d\n",
220 dev, 0, stream);
221 count = snd_pcm_info_get_subdevices_count(pcm_info);
222 for (subdev = 0; subdev < count; subdev++) {
223 sprintf(key, "pcm.%d.%d.%s", dev, subdev, snd_pcm_stream_name(stream));
224 if (conf_get_bool(card_config, key, "skip", false)) {
225 ksft_print_msg("skipping pcm %d.%d.%d.%s\n", card, dev,
226 subdev, snd_pcm_stream_name(stream));
227 continue;
228 }
229 pcm_data = calloc(1, sizeof(*pcm_data));
230 if (!pcm_data)
231 ksft_exit_fail_msg("Out of memory\n");
232 pcm_data->card = card;
233 pcm_data->device = dev;
234 pcm_data->subdevice = subdev;
235 pcm_data->stream = stream;
236 pcm_data->pcm_config = conf_get_subtree(card_config, key, NULL);
237 pcm_data->next = pcm_list;
238 pcm_list = pcm_data;
239 }
240 }
241 }
242
243 /* check for missing devices */
244 missing_devices(card, card_config);
245
246 next_card:
247 snd_ctl_close(handle);
248 if (snd_card_next(&card) < 0) {
249 ksft_print_msg("snd_card_next");
250 break;
251 }
252 }
253
254 snd_config_delete(config);
255 }
256
test_pcm_time(struct pcm_data * data,enum test_class class,const char * test_name,snd_config_t * pcm_cfg)257 static void test_pcm_time(struct pcm_data *data, enum test_class class,
258 const char *test_name, snd_config_t *pcm_cfg)
259 {
260 char name[64], msg[256];
261 const int duration_s = 2, margin_ms = 100;
262 const int duration_ms = duration_s * 1000;
263 const char *cs;
264 int i, err;
265 snd_pcm_t *handle = NULL;
266 snd_pcm_access_t access = SND_PCM_ACCESS_RW_INTERLEAVED;
267 snd_pcm_format_t format, old_format;
268 const char *alt_formats[8];
269 unsigned char *samples = NULL;
270 snd_pcm_sframes_t frames;
271 long long ms;
272 long rate, channels, period_size, buffer_size;
273 unsigned int rrate;
274 snd_pcm_uframes_t rperiod_size, rbuffer_size, start_threshold;
275 timestamp_t tstamp;
276 bool pass = false;
277 snd_pcm_hw_params_t *hw_params;
278 snd_pcm_sw_params_t *sw_params;
279 const char *test_class_name;
280 bool skip = true;
281 const char *desc;
282
283 switch (class) {
284 case TEST_CLASS_DEFAULT:
285 test_class_name = "default";
286 break;
287 case TEST_CLASS_SYSTEM:
288 test_class_name = "system";
289 break;
290 default:
291 ksft_exit_fail_msg("Unknown test class %d\n", class);
292 break;
293 }
294
295 desc = conf_get_string(pcm_cfg, "description", NULL, NULL);
296 if (desc)
297 ksft_print_msg("%s.%s.%d.%d.%d.%s - %s\n",
298 test_class_name, test_name,
299 data->card, data->device, data->subdevice,
300 snd_pcm_stream_name(data->stream),
301 desc);
302
303
304 snd_pcm_hw_params_alloca(&hw_params);
305 snd_pcm_sw_params_alloca(&sw_params);
306
307 cs = conf_get_string(pcm_cfg, "format", NULL, "S16_LE");
308 format = snd_pcm_format_value(cs);
309 if (format == SND_PCM_FORMAT_UNKNOWN)
310 ksft_exit_fail_msg("Wrong format '%s'\n", cs);
311 conf_get_string_array(pcm_cfg, "alt_formats", NULL,
312 alt_formats, ARRAY_SIZE(alt_formats), NULL);
313 rate = conf_get_long(pcm_cfg, "rate", NULL, 48000);
314 channels = conf_get_long(pcm_cfg, "channels", NULL, 2);
315 period_size = conf_get_long(pcm_cfg, "period_size", NULL, 4096);
316 buffer_size = conf_get_long(pcm_cfg, "buffer_size", NULL, 16384);
317
318 samples = malloc((rate * channels * snd_pcm_format_physical_width(format)) / 8);
319 if (!samples)
320 ksft_exit_fail_msg("Out of memory\n");
321 snd_pcm_format_set_silence(format, samples, rate * channels);
322
323 sprintf(name, "hw:%d,%d,%d", data->card, data->device, data->subdevice);
324 err = snd_pcm_open(&handle, name, data->stream, 0);
325 if (err < 0) {
326 snprintf(msg, sizeof(msg), "Failed to get pcm handle: %s", snd_strerror(err));
327 goto __close;
328 }
329
330 err = snd_pcm_hw_params_any(handle, hw_params);
331 if (err < 0) {
332 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_any: %s", snd_strerror(err));
333 goto __close;
334 }
335 err = snd_pcm_hw_params_set_rate_resample(handle, hw_params, 0);
336 if (err < 0) {
337 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_rate_resample: %s", snd_strerror(err));
338 goto __close;
339 }
340 err = snd_pcm_hw_params_set_access(handle, hw_params, access);
341 if (err < 0) {
342 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_access %s: %s",
343 snd_pcm_access_name(access), snd_strerror(err));
344 goto __close;
345 }
346 i = -1;
347 __format:
348 err = snd_pcm_hw_params_set_format(handle, hw_params, format);
349 if (err < 0) {
350 i++;
351 if (i < ARRAY_SIZE(alt_formats) && alt_formats[i]) {
352 old_format = format;
353 format = snd_pcm_format_value(alt_formats[i]);
354 if (format != SND_PCM_FORMAT_UNKNOWN) {
355 ksft_print_msg("%s.%d.%d.%d.%s.%s format %s -> %s\n",
356 test_name,
357 data->card, data->device, data->subdevice,
358 snd_pcm_stream_name(data->stream),
359 snd_pcm_access_name(access),
360 snd_pcm_format_name(old_format),
361 snd_pcm_format_name(format));
362 samples = realloc(samples, (rate * channels *
363 snd_pcm_format_physical_width(format)) / 8);
364 if (!samples)
365 ksft_exit_fail_msg("Out of memory\n");
366 snd_pcm_format_set_silence(format, samples, rate * channels);
367 goto __format;
368 }
369 }
370 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_format %s: %s",
371 snd_pcm_format_name(format), snd_strerror(err));
372 goto __close;
373 }
374 err = snd_pcm_hw_params_set_channels(handle, hw_params, channels);
375 if (err < 0) {
376 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_channels %ld: %s", channels, snd_strerror(err));
377 goto __close;
378 }
379 rrate = rate;
380 err = snd_pcm_hw_params_set_rate_near(handle, hw_params, &rrate, 0);
381 if (err < 0) {
382 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_rate %ld: %s", rate, snd_strerror(err));
383 goto __close;
384 }
385 if (rrate != rate) {
386 snprintf(msg, sizeof(msg), "rate mismatch %ld != %d", rate, rrate);
387 goto __close;
388 }
389 rperiod_size = period_size;
390 err = snd_pcm_hw_params_set_period_size_near(handle, hw_params, &rperiod_size, 0);
391 if (err < 0) {
392 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_period_size %ld: %s", period_size, snd_strerror(err));
393 goto __close;
394 }
395 rbuffer_size = buffer_size;
396 err = snd_pcm_hw_params_set_buffer_size_near(handle, hw_params, &rbuffer_size);
397 if (err < 0) {
398 snprintf(msg, sizeof(msg), "snd_pcm_hw_params_set_buffer_size %ld: %s", buffer_size, snd_strerror(err));
399 goto __close;
400 }
401 err = snd_pcm_hw_params(handle, hw_params);
402 if (err < 0) {
403 snprintf(msg, sizeof(msg), "snd_pcm_hw_params: %s", snd_strerror(err));
404 goto __close;
405 }
406
407 err = snd_pcm_sw_params_current(handle, sw_params);
408 if (err < 0) {
409 snprintf(msg, sizeof(msg), "snd_pcm_sw_params_current: %s", snd_strerror(err));
410 goto __close;
411 }
412 if (data->stream == SND_PCM_STREAM_PLAYBACK) {
413 start_threshold = (rbuffer_size / rperiod_size) * rperiod_size;
414 } else {
415 start_threshold = rperiod_size;
416 }
417 err = snd_pcm_sw_params_set_start_threshold(handle, sw_params, start_threshold);
418 if (err < 0) {
419 snprintf(msg, sizeof(msg), "snd_pcm_sw_params_set_start_threshold %ld: %s", (long)start_threshold, snd_strerror(err));
420 goto __close;
421 }
422 err = snd_pcm_sw_params_set_avail_min(handle, sw_params, rperiod_size);
423 if (err < 0) {
424 snprintf(msg, sizeof(msg), "snd_pcm_sw_params_set_avail_min %ld: %s", (long)rperiod_size, snd_strerror(err));
425 goto __close;
426 }
427 err = snd_pcm_sw_params(handle, sw_params);
428 if (err < 0) {
429 snprintf(msg, sizeof(msg), "snd_pcm_sw_params: %s", snd_strerror(err));
430 goto __close;
431 }
432
433 ksft_print_msg("%s.%s.%d.%d.%d.%s hw_params.%s.%s.%ld.%ld.%ld.%ld sw_params.%ld\n",
434 test_class_name, test_name,
435 data->card, data->device, data->subdevice,
436 snd_pcm_stream_name(data->stream),
437 snd_pcm_access_name(access),
438 snd_pcm_format_name(format),
439 (long)rate, (long)channels,
440 (long)rperiod_size, (long)rbuffer_size,
441 (long)start_threshold);
442
443 /* Set all the params, actually run the test */
444 skip = false;
445
446 timestamp_now(&tstamp);
447 for (i = 0; i < duration_s; i++) {
448 if (data->stream == SND_PCM_STREAM_PLAYBACK) {
449 frames = snd_pcm_writei(handle, samples, rate);
450 if (frames < 0) {
451 snprintf(msg, sizeof(msg),
452 "Write failed: expected %ld, wrote %li", rate, frames);
453 goto __close;
454 }
455 if (frames < rate) {
456 snprintf(msg, sizeof(msg),
457 "expected %ld, wrote %li", rate, frames);
458 goto __close;
459 }
460 } else {
461 frames = snd_pcm_readi(handle, samples, rate);
462 if (frames < 0) {
463 snprintf(msg, sizeof(msg),
464 "expected %ld, wrote %li", rate, frames);
465 goto __close;
466 }
467 if (frames < rate) {
468 snprintf(msg, sizeof(msg),
469 "expected %ld, wrote %li", rate, frames);
470 goto __close;
471 }
472 }
473 }
474
475 snd_pcm_drain(handle);
476 ms = timestamp_diff_ms(&tstamp);
477 if (ms < duration_ms - margin_ms || ms > duration_ms + margin_ms) {
478 snprintf(msg, sizeof(msg), "time mismatch: expected %dms got %lld", duration_ms, ms);
479 goto __close;
480 }
481
482 msg[0] = '\0';
483 pass = true;
484 __close:
485 pthread_mutex_lock(&results_lock);
486
487 switch (class) {
488 case TEST_CLASS_SYSTEM:
489 test_class_name = "system";
490 /*
491 * Anything specified as specific to this system
492 * should always be supported.
493 */
494 ksft_test_result(!skip, "%s.%s.%d.%d.%d.%s.params\n",
495 test_class_name, test_name,
496 data->card, data->device, data->subdevice,
497 snd_pcm_stream_name(data->stream));
498 break;
499 default:
500 break;
501 }
502
503 if (!skip)
504 ksft_test_result(pass, "%s.%s.%d.%d.%d.%s\n",
505 test_class_name, test_name,
506 data->card, data->device, data->subdevice,
507 snd_pcm_stream_name(data->stream));
508 else
509 ksft_test_result_skip("%s.%s.%d.%d.%d.%s\n",
510 test_class_name, test_name,
511 data->card, data->device, data->subdevice,
512 snd_pcm_stream_name(data->stream));
513
514 if (msg[0])
515 ksft_print_msg("%s\n", msg);
516
517 pthread_mutex_unlock(&results_lock);
518
519 free(samples);
520 if (handle)
521 snd_pcm_close(handle);
522 }
523
run_time_tests(struct pcm_data * pcm,enum test_class class,snd_config_t * cfg)524 void run_time_tests(struct pcm_data *pcm, enum test_class class,
525 snd_config_t *cfg)
526 {
527 const char *test_name, *test_type;
528 snd_config_t *pcm_cfg;
529 snd_config_iterator_t i, next;
530
531 if (!cfg)
532 return;
533
534 cfg = conf_get_subtree(cfg, "test", NULL);
535 if (cfg == NULL)
536 return;
537
538 snd_config_for_each(i, next, cfg) {
539 pcm_cfg = snd_config_iterator_entry(i);
540 if (snd_config_get_id(pcm_cfg, &test_name) < 0)
541 ksft_exit_fail_msg("snd_config_get_id\n");
542 test_type = conf_get_string(pcm_cfg, "type", NULL, "time");
543 if (strcmp(test_type, "time") == 0)
544 test_pcm_time(pcm, class, test_name, pcm_cfg);
545 else
546 ksft_exit_fail_msg("unknown test type '%s'\n", test_type);
547 }
548 }
549
card_thread(void * data)550 void *card_thread(void *data)
551 {
552 struct card_data *card = data;
553 struct pcm_data *pcm;
554
555 for (pcm = pcm_list; pcm != NULL; pcm = pcm->next) {
556 if (pcm->card != card->card)
557 continue;
558
559 run_time_tests(pcm, TEST_CLASS_DEFAULT, default_pcm_config);
560 run_time_tests(pcm, TEST_CLASS_SYSTEM, pcm->pcm_config);
561 }
562
563 return 0;
564 }
565
main(void)566 int main(void)
567 {
568 struct card_data *card;
569 struct pcm_data *pcm;
570 snd_config_t *global_config, *cfg;
571 int num_pcm_tests = 0, num_tests, num_std_pcm_tests;
572 int ret;
573 void *thread_ret;
574
575 ksft_print_header();
576
577 global_config = conf_load_from_file("pcm-test.conf");
578 default_pcm_config = conf_get_subtree(global_config, "pcm", NULL);
579 if (default_pcm_config == NULL)
580 ksft_exit_fail_msg("default pcm test configuration (pcm compound) is missing\n");
581
582 conf_load();
583
584 find_pcms();
585
586 num_std_pcm_tests = conf_get_count(default_pcm_config, "test", NULL);
587
588 for (pcm = pcm_list; pcm != NULL; pcm = pcm->next) {
589 num_pcm_tests += num_std_pcm_tests;
590 cfg = pcm->pcm_config;
591 if (cfg == NULL)
592 continue;
593 /* Setting params is reported as a separate test */
594 num_tests = conf_get_count(cfg, "test", NULL) * 2;
595 if (num_tests > 0)
596 num_pcm_tests += num_tests;
597 }
598
599 ksft_set_plan(num_missing + num_pcm_tests);
600
601 for (pcm = pcm_missing; pcm != NULL; pcm = pcm->next) {
602 ksft_test_result(false, "test.missing.%d.%d.%d.%s\n",
603 pcm->card, pcm->device, pcm->subdevice,
604 snd_pcm_stream_name(pcm->stream));
605 }
606
607 for (card = card_list; card != NULL; card = card->next) {
608 ret = pthread_create(&card->thread, NULL, card_thread, card);
609 if (ret != 0) {
610 ksft_exit_fail_msg("Failed to create card %d thread: %d (%s)\n",
611 card->card, ret,
612 strerror(errno));
613 }
614 }
615
616 for (card = card_list; card != NULL; card = card->next) {
617 ret = pthread_join(card->thread, &thread_ret);
618 if (ret != 0) {
619 ksft_exit_fail_msg("Failed to join card %d thread: %d (%s)\n",
620 card->card, ret,
621 strerror(errno));
622 }
623 }
624
625 snd_config_delete(global_config);
626 conf_free();
627
628 ksft_exit_pass();
629
630 return 0;
631 }
632