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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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