1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // kselftest for the ALSA mixer API 4 // 5 // Original author: Mark Brown <broonie@kernel.org> 6 // Copyright (c) 2021-2 Arm Limited 7 8 // This test will iterate over all cards detected in the system, exercising 9 // every mixer control 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 <limits.h> 17 #include <string.h> 18 #include <getopt.h> 19 #include <stdarg.h> 20 #include <ctype.h> 21 #include <math.h> 22 #include <errno.h> 23 #include <assert.h> 24 #include <alsa/asoundlib.h> 25 #include <poll.h> 26 #include <stdint.h> 27 28 #include "../kselftest.h" 29 #include "alsa-local.h" 30 31 #define TESTS_PER_CONTROL 7 32 33 struct card_data { 34 snd_ctl_t *handle; 35 int card; 36 struct pollfd pollfd; 37 int num_ctls; 38 snd_ctl_elem_list_t *ctls; 39 struct card_data *next; 40 }; 41 42 struct ctl_data { 43 const char *name; 44 snd_ctl_elem_id_t *id; 45 snd_ctl_elem_info_t *info; 46 snd_ctl_elem_value_t *def_val; 47 int elem; 48 int event_missing; 49 int event_spurious; 50 struct card_data *card; 51 struct ctl_data *next; 52 }; 53 54 int num_cards = 0; 55 int num_controls = 0; 56 struct card_data *card_list = NULL; 57 struct ctl_data *ctl_list = NULL; 58 59 static void find_controls(void) 60 { 61 char name[32]; 62 int card, ctl, err; 63 struct card_data *card_data; 64 struct ctl_data *ctl_data; 65 snd_config_t *config; 66 char *card_name, *card_longname; 67 68 card = -1; 69 if (snd_card_next(&card) < 0 || card < 0) 70 return; 71 72 config = get_alsalib_config(); 73 74 while (card >= 0) { 75 sprintf(name, "hw:%d", card); 76 77 card_data = malloc(sizeof(*card_data)); 78 if (!card_data) 79 ksft_exit_fail_msg("Out of memory\n"); 80 81 err = snd_ctl_open_lconf(&card_data->handle, name, 0, config); 82 if (err < 0) { 83 ksft_print_msg("Failed to get hctl for card %d: %s\n", 84 card, snd_strerror(err)); 85 goto next_card; 86 } 87 88 err = snd_card_get_name(card, &card_name); 89 if (err != 0) 90 card_name = "Unknown"; 91 err = snd_card_get_longname(card, &card_longname); 92 if (err != 0) 93 card_longname = "Unknown"; 94 ksft_print_msg("Card %d - %s (%s)\n", card, 95 card_name, card_longname); 96 97 /* Count controls */ 98 snd_ctl_elem_list_malloc(&card_data->ctls); 99 snd_ctl_elem_list(card_data->handle, card_data->ctls); 100 card_data->num_ctls = snd_ctl_elem_list_get_count(card_data->ctls); 101 102 /* Enumerate control information */ 103 snd_ctl_elem_list_alloc_space(card_data->ctls, card_data->num_ctls); 104 snd_ctl_elem_list(card_data->handle, card_data->ctls); 105 106 card_data->card = num_cards++; 107 card_data->next = card_list; 108 card_list = card_data; 109 110 num_controls += card_data->num_ctls; 111 112 for (ctl = 0; ctl < card_data->num_ctls; ctl++) { 113 ctl_data = malloc(sizeof(*ctl_data)); 114 if (!ctl_data) 115 ksft_exit_fail_msg("Out of memory\n"); 116 117 memset(ctl_data, 0, sizeof(*ctl_data)); 118 ctl_data->card = card_data; 119 ctl_data->elem = ctl; 120 ctl_data->name = snd_ctl_elem_list_get_name(card_data->ctls, 121 ctl); 122 123 err = snd_ctl_elem_id_malloc(&ctl_data->id); 124 if (err < 0) 125 ksft_exit_fail_msg("Out of memory\n"); 126 127 err = snd_ctl_elem_info_malloc(&ctl_data->info); 128 if (err < 0) 129 ksft_exit_fail_msg("Out of memory\n"); 130 131 err = snd_ctl_elem_value_malloc(&ctl_data->def_val); 132 if (err < 0) 133 ksft_exit_fail_msg("Out of memory\n"); 134 135 snd_ctl_elem_list_get_id(card_data->ctls, ctl, 136 ctl_data->id); 137 snd_ctl_elem_info_set_id(ctl_data->info, ctl_data->id); 138 err = snd_ctl_elem_info(card_data->handle, 139 ctl_data->info); 140 if (err < 0) { 141 ksft_print_msg("%s getting info for %d\n", 142 snd_strerror(err), 143 ctl_data->name); 144 } 145 146 snd_ctl_elem_value_set_id(ctl_data->def_val, 147 ctl_data->id); 148 149 ctl_data->next = ctl_list; 150 ctl_list = ctl_data; 151 } 152 153 /* Set up for events */ 154 err = snd_ctl_subscribe_events(card_data->handle, true); 155 if (err < 0) { 156 ksft_exit_fail_msg("snd_ctl_subscribe_events() failed for card %d: %d\n", 157 card, err); 158 } 159 160 err = snd_ctl_poll_descriptors_count(card_data->handle); 161 if (err != 1) { 162 ksft_exit_fail_msg("Unexpected descriptor count %d for card %d\n", 163 err, card); 164 } 165 166 err = snd_ctl_poll_descriptors(card_data->handle, 167 &card_data->pollfd, 1); 168 if (err != 1) { 169 ksft_exit_fail_msg("snd_ctl_poll_descriptors() failed for %d\n", 170 card, err); 171 } 172 173 next_card: 174 if (snd_card_next(&card) < 0) { 175 ksft_print_msg("snd_card_next"); 176 break; 177 } 178 } 179 180 snd_config_delete(config); 181 } 182 183 /* 184 * Block for up to timeout ms for an event, returns a negative value 185 * on error, 0 for no event and 1 for an event. 186 */ 187 static int wait_for_event(struct ctl_data *ctl, int timeout) 188 { 189 unsigned short revents; 190 snd_ctl_event_t *event; 191 int count, err; 192 unsigned int mask = 0; 193 unsigned int ev_id; 194 195 snd_ctl_event_alloca(&event); 196 197 do { 198 err = poll(&(ctl->card->pollfd), 1, timeout); 199 if (err < 0) { 200 ksft_print_msg("poll() failed for %s: %s (%d)\n", 201 ctl->name, strerror(errno), errno); 202 return -1; 203 } 204 /* Timeout */ 205 if (err == 0) 206 return 0; 207 208 err = snd_ctl_poll_descriptors_revents(ctl->card->handle, 209 &(ctl->card->pollfd), 210 1, &revents); 211 if (err < 0) { 212 ksft_print_msg("snd_ctl_poll_descriptors_revents() failed for %s: %d\n", 213 ctl->name, err); 214 return err; 215 } 216 if (revents & POLLERR) { 217 ksft_print_msg("snd_ctl_poll_descriptors_revents() reported POLLERR for %s\n", 218 ctl->name); 219 return -1; 220 } 221 /* No read events */ 222 if (!(revents & POLLIN)) { 223 ksft_print_msg("No POLLIN\n"); 224 continue; 225 } 226 227 err = snd_ctl_read(ctl->card->handle, event); 228 if (err < 0) { 229 ksft_print_msg("snd_ctl_read() failed for %s: %d\n", 230 ctl->name, err); 231 return err; 232 } 233 234 if (snd_ctl_event_get_type(event) != SND_CTL_EVENT_ELEM) 235 continue; 236 237 /* The ID returned from the event is 1 less than numid */ 238 mask = snd_ctl_event_elem_get_mask(event); 239 ev_id = snd_ctl_event_elem_get_numid(event); 240 if (ev_id != snd_ctl_elem_info_get_numid(ctl->info)) { 241 ksft_print_msg("Event for unexpected ctl %s\n", 242 snd_ctl_event_elem_get_name(event)); 243 continue; 244 } 245 246 if ((mask & SND_CTL_EVENT_MASK_REMOVE) == SND_CTL_EVENT_MASK_REMOVE) { 247 ksft_print_msg("Removal event for %s\n", 248 ctl->name); 249 return -1; 250 } 251 } while ((mask & SND_CTL_EVENT_MASK_VALUE) != SND_CTL_EVENT_MASK_VALUE); 252 253 return 1; 254 } 255 256 static bool ctl_value_index_valid(struct ctl_data *ctl, 257 snd_ctl_elem_value_t *val, 258 int index) 259 { 260 long int_val; 261 long long int64_val; 262 263 switch (snd_ctl_elem_info_get_type(ctl->info)) { 264 case SND_CTL_ELEM_TYPE_NONE: 265 ksft_print_msg("%s.%d Invalid control type NONE\n", 266 ctl->name, index); 267 return false; 268 269 case SND_CTL_ELEM_TYPE_BOOLEAN: 270 int_val = snd_ctl_elem_value_get_boolean(val, index); 271 switch (int_val) { 272 case 0: 273 case 1: 274 break; 275 default: 276 ksft_print_msg("%s.%d Invalid boolean value %ld\n", 277 ctl->name, index, int_val); 278 return false; 279 } 280 break; 281 282 case SND_CTL_ELEM_TYPE_INTEGER: 283 int_val = snd_ctl_elem_value_get_integer(val, index); 284 285 if (int_val < snd_ctl_elem_info_get_min(ctl->info)) { 286 ksft_print_msg("%s.%d value %ld less than minimum %ld\n", 287 ctl->name, index, int_val, 288 snd_ctl_elem_info_get_min(ctl->info)); 289 return false; 290 } 291 292 if (int_val > snd_ctl_elem_info_get_max(ctl->info)) { 293 ksft_print_msg("%s.%d value %ld more than maximum %ld\n", 294 ctl->name, index, int_val, 295 snd_ctl_elem_info_get_max(ctl->info)); 296 return false; 297 } 298 299 /* Only check step size if there is one and we're in bounds */ 300 if (snd_ctl_elem_info_get_step(ctl->info) && 301 (int_val - snd_ctl_elem_info_get_min(ctl->info) % 302 snd_ctl_elem_info_get_step(ctl->info))) { 303 ksft_print_msg("%s.%d value %ld invalid for step %ld minimum %ld\n", 304 ctl->name, index, int_val, 305 snd_ctl_elem_info_get_step(ctl->info), 306 snd_ctl_elem_info_get_min(ctl->info)); 307 return false; 308 } 309 break; 310 311 case SND_CTL_ELEM_TYPE_INTEGER64: 312 int64_val = snd_ctl_elem_value_get_integer64(val, index); 313 314 if (int64_val < snd_ctl_elem_info_get_min64(ctl->info)) { 315 ksft_print_msg("%s.%d value %lld less than minimum %lld\n", 316 ctl->name, index, int64_val, 317 snd_ctl_elem_info_get_min64(ctl->info)); 318 return false; 319 } 320 321 if (int64_val > snd_ctl_elem_info_get_max64(ctl->info)) { 322 ksft_print_msg("%s.%d value %lld more than maximum %lld\n", 323 ctl->name, index, int64_val, 324 snd_ctl_elem_info_get_max(ctl->info)); 325 return false; 326 } 327 328 /* Only check step size if there is one and we're in bounds */ 329 if (snd_ctl_elem_info_get_step64(ctl->info) && 330 (int64_val - snd_ctl_elem_info_get_min64(ctl->info)) % 331 snd_ctl_elem_info_get_step64(ctl->info)) { 332 ksft_print_msg("%s.%d value %lld invalid for step %lld minimum %lld\n", 333 ctl->name, index, int64_val, 334 snd_ctl_elem_info_get_step64(ctl->info), 335 snd_ctl_elem_info_get_min64(ctl->info)); 336 return false; 337 } 338 break; 339 340 case SND_CTL_ELEM_TYPE_ENUMERATED: 341 int_val = snd_ctl_elem_value_get_enumerated(val, index); 342 343 if (int_val < 0) { 344 ksft_print_msg("%s.%d negative value %ld for enumeration\n", 345 ctl->name, index, int_val); 346 return false; 347 } 348 349 if (int_val >= snd_ctl_elem_info_get_items(ctl->info)) { 350 ksft_print_msg("%s.%d value %ld more than item count %ld\n", 351 ctl->name, index, int_val, 352 snd_ctl_elem_info_get_items(ctl->info)); 353 return false; 354 } 355 break; 356 357 default: 358 /* No tests for other types */ 359 break; 360 } 361 362 return true; 363 } 364 365 /* 366 * Check that the provided value meets the constraints for the 367 * provided control. 368 */ 369 static bool ctl_value_valid(struct ctl_data *ctl, snd_ctl_elem_value_t *val) 370 { 371 int i; 372 bool valid = true; 373 374 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) 375 if (!ctl_value_index_valid(ctl, val, i)) 376 valid = false; 377 378 return valid; 379 } 380 381 /* 382 * Check that we can read the default value and it is valid. Write 383 * tests use the read value to restore the default. 384 */ 385 static void test_ctl_get_value(struct ctl_data *ctl) 386 { 387 int err; 388 389 /* If the control is turned off let's be polite */ 390 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 391 ksft_print_msg("%s is inactive\n", ctl->name); 392 ksft_test_result_skip("get_value.%d.%d\n", 393 ctl->card->card, ctl->elem); 394 return; 395 } 396 397 /* Can't test reading on an unreadable control */ 398 if (!snd_ctl_elem_info_is_readable(ctl->info)) { 399 ksft_print_msg("%s is not readable\n", ctl->name); 400 ksft_test_result_skip("get_value.%d.%d\n", 401 ctl->card->card, ctl->elem); 402 return; 403 } 404 405 err = snd_ctl_elem_read(ctl->card->handle, ctl->def_val); 406 if (err < 0) { 407 ksft_print_msg("snd_ctl_elem_read() failed: %s\n", 408 snd_strerror(err)); 409 goto out; 410 } 411 412 if (!ctl_value_valid(ctl, ctl->def_val)) 413 err = -EINVAL; 414 415 out: 416 ksft_test_result(err >= 0, "get_value.%d.%d\n", 417 ctl->card->card, ctl->elem); 418 } 419 420 static bool strend(const char *haystack, const char *needle) 421 { 422 size_t haystack_len = strlen(haystack); 423 size_t needle_len = strlen(needle); 424 425 if (needle_len > haystack_len) 426 return false; 427 return strcmp(haystack + haystack_len - needle_len, needle) == 0; 428 } 429 430 static void test_ctl_name(struct ctl_data *ctl) 431 { 432 bool name_ok = true; 433 bool check; 434 435 ksft_print_msg("%d.%d %s\n", ctl->card->card, ctl->elem, 436 ctl->name); 437 438 /* Only boolean controls should end in Switch */ 439 if (strend(ctl->name, " Switch")) { 440 if (snd_ctl_elem_info_get_type(ctl->info) != SND_CTL_ELEM_TYPE_BOOLEAN) { 441 ksft_print_msg("%d.%d %s ends in Switch but is not boolean\n", 442 ctl->card->card, ctl->elem, ctl->name); 443 name_ok = false; 444 } 445 } 446 447 /* Writeable boolean controls should end in Switch */ 448 if (snd_ctl_elem_info_get_type(ctl->info) == SND_CTL_ELEM_TYPE_BOOLEAN && 449 snd_ctl_elem_info_is_writable(ctl->info)) { 450 if (!strend(ctl->name, " Switch")) { 451 ksft_print_msg("%d.%d %s is a writeable boolean but not a Switch\n", 452 ctl->card->card, ctl->elem, ctl->name); 453 name_ok = false; 454 } 455 } 456 457 ksft_test_result(name_ok, "name.%d.%d\n", 458 ctl->card->card, ctl->elem); 459 } 460 461 static void show_values(struct ctl_data *ctl, snd_ctl_elem_value_t *orig_val, 462 snd_ctl_elem_value_t *read_val) 463 { 464 long long orig_int, read_int; 465 int i; 466 467 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 468 switch (snd_ctl_elem_info_get_type(ctl->info)) { 469 case SND_CTL_ELEM_TYPE_BOOLEAN: 470 orig_int = snd_ctl_elem_value_get_boolean(orig_val, i); 471 read_int = snd_ctl_elem_value_get_boolean(read_val, i); 472 break; 473 474 case SND_CTL_ELEM_TYPE_INTEGER: 475 orig_int = snd_ctl_elem_value_get_integer(orig_val, i); 476 read_int = snd_ctl_elem_value_get_integer(read_val, i); 477 break; 478 479 case SND_CTL_ELEM_TYPE_INTEGER64: 480 orig_int = snd_ctl_elem_value_get_integer64(orig_val, 481 i); 482 read_int = snd_ctl_elem_value_get_integer64(read_val, 483 i); 484 break; 485 486 case SND_CTL_ELEM_TYPE_ENUMERATED: 487 orig_int = snd_ctl_elem_value_get_enumerated(orig_val, 488 i); 489 read_int = snd_ctl_elem_value_get_enumerated(read_val, 490 i); 491 break; 492 493 default: 494 return; 495 } 496 497 ksft_print_msg("%s.%d orig %lld read %lld, is_volatile %d\n", 498 ctl->name, i, orig_int, read_int, 499 snd_ctl_elem_info_is_volatile(ctl->info)); 500 } 501 } 502 503 static bool show_mismatch(struct ctl_data *ctl, int index, 504 snd_ctl_elem_value_t *read_val, 505 snd_ctl_elem_value_t *expected_val) 506 { 507 long long expected_int, read_int; 508 509 /* 510 * We factor out the code to compare values representable as 511 * integers, ensure that check doesn't log otherwise. 512 */ 513 expected_int = 0; 514 read_int = 0; 515 516 switch (snd_ctl_elem_info_get_type(ctl->info)) { 517 case SND_CTL_ELEM_TYPE_BOOLEAN: 518 expected_int = snd_ctl_elem_value_get_boolean(expected_val, 519 index); 520 read_int = snd_ctl_elem_value_get_boolean(read_val, index); 521 break; 522 523 case SND_CTL_ELEM_TYPE_INTEGER: 524 expected_int = snd_ctl_elem_value_get_integer(expected_val, 525 index); 526 read_int = snd_ctl_elem_value_get_integer(read_val, index); 527 break; 528 529 case SND_CTL_ELEM_TYPE_INTEGER64: 530 expected_int = snd_ctl_elem_value_get_integer64(expected_val, 531 index); 532 read_int = snd_ctl_elem_value_get_integer64(read_val, 533 index); 534 break; 535 536 case SND_CTL_ELEM_TYPE_ENUMERATED: 537 expected_int = snd_ctl_elem_value_get_enumerated(expected_val, 538 index); 539 read_int = snd_ctl_elem_value_get_enumerated(read_val, 540 index); 541 break; 542 543 default: 544 break; 545 } 546 547 if (expected_int != read_int) { 548 /* 549 * NOTE: The volatile attribute means that the hardware 550 * can voluntarily change the state of control element 551 * independent of any operation by software. 552 */ 553 bool is_volatile = snd_ctl_elem_info_is_volatile(ctl->info); 554 ksft_print_msg("%s.%d expected %lld but read %lld, is_volatile %d\n", 555 ctl->name, index, expected_int, read_int, is_volatile); 556 return !is_volatile; 557 } else { 558 return false; 559 } 560 } 561 562 /* 563 * Write a value then if possible verify that we get the expected 564 * result. An optional expected value can be provided if we expect 565 * the write to fail, for verifying that invalid writes don't corrupt 566 * anything. 567 */ 568 static int write_and_verify(struct ctl_data *ctl, 569 snd_ctl_elem_value_t *write_val, 570 snd_ctl_elem_value_t *expected_val) 571 { 572 int err, i; 573 bool error_expected, mismatch_shown; 574 snd_ctl_elem_value_t *initial_val, *read_val, *w_val; 575 snd_ctl_elem_value_alloca(&initial_val); 576 snd_ctl_elem_value_alloca(&read_val); 577 snd_ctl_elem_value_alloca(&w_val); 578 579 /* 580 * We need to copy the write value since writing can modify 581 * the value which causes surprises, and allocate an expected 582 * value if we expect to read back what we wrote. 583 */ 584 snd_ctl_elem_value_copy(w_val, write_val); 585 if (expected_val) { 586 error_expected = true; 587 } else { 588 error_expected = false; 589 snd_ctl_elem_value_alloca(&expected_val); 590 snd_ctl_elem_value_copy(expected_val, write_val); 591 } 592 593 /* Store the value before we write */ 594 if (snd_ctl_elem_info_is_readable(ctl->info)) { 595 snd_ctl_elem_value_set_id(initial_val, ctl->id); 596 597 err = snd_ctl_elem_read(ctl->card->handle, initial_val); 598 if (err < 0) { 599 ksft_print_msg("snd_ctl_elem_read() failed: %s\n", 600 snd_strerror(err)); 601 return err; 602 } 603 } 604 605 /* 606 * Do the write, if we have an expected value ignore the error 607 * and carry on to validate the expected value. 608 */ 609 err = snd_ctl_elem_write(ctl->card->handle, w_val); 610 if (err < 0 && !error_expected) { 611 ksft_print_msg("snd_ctl_elem_write() failed: %s\n", 612 snd_strerror(err)); 613 return err; 614 } 615 616 /* Can we do the verification part? */ 617 if (!snd_ctl_elem_info_is_readable(ctl->info)) 618 return err; 619 620 snd_ctl_elem_value_set_id(read_val, ctl->id); 621 622 err = snd_ctl_elem_read(ctl->card->handle, read_val); 623 if (err < 0) { 624 ksft_print_msg("snd_ctl_elem_read() failed: %s\n", 625 snd_strerror(err)); 626 return err; 627 } 628 629 /* 630 * Check for an event if the value changed, or confirm that 631 * there was none if it didn't. We rely on the kernel 632 * generating the notification before it returns from the 633 * write, this is currently true, should that ever change this 634 * will most likely break and need updating. 635 */ 636 if (!snd_ctl_elem_info_is_volatile(ctl->info)) { 637 err = wait_for_event(ctl, 0); 638 if (snd_ctl_elem_value_compare(initial_val, read_val)) { 639 if (err < 1) { 640 ksft_print_msg("No event generated for %s\n", 641 ctl->name); 642 show_values(ctl, initial_val, read_val); 643 ctl->event_missing++; 644 } 645 } else { 646 if (err != 0) { 647 ksft_print_msg("Spurious event generated for %s\n", 648 ctl->name); 649 show_values(ctl, initial_val, read_val); 650 ctl->event_spurious++; 651 } 652 } 653 } 654 655 /* 656 * Use the libray to compare values, if there's a mismatch 657 * carry on and try to provide a more useful diagnostic than 658 * just "mismatch". 659 */ 660 if (!snd_ctl_elem_value_compare(expected_val, read_val)) 661 return 0; 662 663 mismatch_shown = false; 664 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) 665 if (show_mismatch(ctl, i, read_val, expected_val)) 666 mismatch_shown = true; 667 668 if (!mismatch_shown) 669 ksft_print_msg("%s read and written values differ\n", 670 ctl->name); 671 672 return -1; 673 } 674 675 /* 676 * Make sure we can write the default value back to the control, this 677 * should validate that at least some write works. 678 */ 679 static void test_ctl_write_default(struct ctl_data *ctl) 680 { 681 int err; 682 683 /* If the control is turned off let's be polite */ 684 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 685 ksft_print_msg("%s is inactive\n", ctl->name); 686 ksft_test_result_skip("write_default.%d.%d\n", 687 ctl->card->card, ctl->elem); 688 return; 689 } 690 691 if (!snd_ctl_elem_info_is_writable(ctl->info)) { 692 ksft_print_msg("%s is not writeable\n", ctl->name); 693 ksft_test_result_skip("write_default.%d.%d\n", 694 ctl->card->card, ctl->elem); 695 return; 696 } 697 698 /* No idea what the default was for unreadable controls */ 699 if (!snd_ctl_elem_info_is_readable(ctl->info)) { 700 ksft_print_msg("%s couldn't read default\n", ctl->name); 701 ksft_test_result_skip("write_default.%d.%d\n", 702 ctl->card->card, ctl->elem); 703 return; 704 } 705 706 err = write_and_verify(ctl, ctl->def_val, NULL); 707 708 ksft_test_result(err >= 0, "write_default.%d.%d\n", 709 ctl->card->card, ctl->elem); 710 } 711 712 static bool test_ctl_write_valid_boolean(struct ctl_data *ctl) 713 { 714 int err, i, j; 715 bool fail = false; 716 snd_ctl_elem_value_t *val; 717 snd_ctl_elem_value_alloca(&val); 718 719 snd_ctl_elem_value_set_id(val, ctl->id); 720 721 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 722 for (j = 0; j < 2; j++) { 723 snd_ctl_elem_value_set_boolean(val, i, j); 724 err = write_and_verify(ctl, val, NULL); 725 if (err != 0) 726 fail = true; 727 } 728 } 729 730 return !fail; 731 } 732 733 static bool test_ctl_write_valid_integer(struct ctl_data *ctl) 734 { 735 int err; 736 int i; 737 long j, step; 738 bool fail = false; 739 snd_ctl_elem_value_t *val; 740 snd_ctl_elem_value_alloca(&val); 741 742 snd_ctl_elem_value_set_id(val, ctl->id); 743 744 step = snd_ctl_elem_info_get_step(ctl->info); 745 if (!step) 746 step = 1; 747 748 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 749 for (j = snd_ctl_elem_info_get_min(ctl->info); 750 j <= snd_ctl_elem_info_get_max(ctl->info); j += step) { 751 752 snd_ctl_elem_value_set_integer(val, i, j); 753 err = write_and_verify(ctl, val, NULL); 754 if (err != 0) 755 fail = true; 756 } 757 } 758 759 760 return !fail; 761 } 762 763 static bool test_ctl_write_valid_integer64(struct ctl_data *ctl) 764 { 765 int err, i; 766 long long j, step; 767 bool fail = false; 768 snd_ctl_elem_value_t *val; 769 snd_ctl_elem_value_alloca(&val); 770 771 snd_ctl_elem_value_set_id(val, ctl->id); 772 773 step = snd_ctl_elem_info_get_step64(ctl->info); 774 if (!step) 775 step = 1; 776 777 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 778 for (j = snd_ctl_elem_info_get_min64(ctl->info); 779 j <= snd_ctl_elem_info_get_max64(ctl->info); j += step) { 780 781 snd_ctl_elem_value_set_integer64(val, i, j); 782 err = write_and_verify(ctl, val, NULL); 783 if (err != 0) 784 fail = true; 785 } 786 } 787 788 return !fail; 789 } 790 791 static bool test_ctl_write_valid_enumerated(struct ctl_data *ctl) 792 { 793 int err, i, j; 794 bool fail = false; 795 snd_ctl_elem_value_t *val; 796 snd_ctl_elem_value_alloca(&val); 797 798 snd_ctl_elem_value_set_id(val, ctl->id); 799 800 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 801 for (j = 0; j < snd_ctl_elem_info_get_items(ctl->info); j++) { 802 snd_ctl_elem_value_set_enumerated(val, i, j); 803 err = write_and_verify(ctl, val, NULL); 804 if (err != 0) 805 fail = true; 806 } 807 } 808 809 return !fail; 810 } 811 812 static void test_ctl_write_valid(struct ctl_data *ctl) 813 { 814 bool pass; 815 816 /* If the control is turned off let's be polite */ 817 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 818 ksft_print_msg("%s is inactive\n", ctl->name); 819 ksft_test_result_skip("write_valid.%d.%d\n", 820 ctl->card->card, ctl->elem); 821 return; 822 } 823 824 if (!snd_ctl_elem_info_is_writable(ctl->info)) { 825 ksft_print_msg("%s is not writeable\n", ctl->name); 826 ksft_test_result_skip("write_valid.%d.%d\n", 827 ctl->card->card, ctl->elem); 828 return; 829 } 830 831 switch (snd_ctl_elem_info_get_type(ctl->info)) { 832 case SND_CTL_ELEM_TYPE_BOOLEAN: 833 pass = test_ctl_write_valid_boolean(ctl); 834 break; 835 836 case SND_CTL_ELEM_TYPE_INTEGER: 837 pass = test_ctl_write_valid_integer(ctl); 838 break; 839 840 case SND_CTL_ELEM_TYPE_INTEGER64: 841 pass = test_ctl_write_valid_integer64(ctl); 842 break; 843 844 case SND_CTL_ELEM_TYPE_ENUMERATED: 845 pass = test_ctl_write_valid_enumerated(ctl); 846 break; 847 848 default: 849 /* No tests for this yet */ 850 ksft_test_result_skip("write_valid.%d.%d\n", 851 ctl->card->card, ctl->elem); 852 return; 853 } 854 855 /* Restore the default value to minimise disruption */ 856 write_and_verify(ctl, ctl->def_val, NULL); 857 858 ksft_test_result(pass, "write_valid.%d.%d\n", 859 ctl->card->card, ctl->elem); 860 } 861 862 static bool test_ctl_write_invalid_value(struct ctl_data *ctl, 863 snd_ctl_elem_value_t *val) 864 { 865 int err; 866 long val_read; 867 868 /* Ideally this will fail... */ 869 err = snd_ctl_elem_write(ctl->card->handle, val); 870 if (err < 0) 871 return false; 872 873 /* ...but some devices will clamp to an in range value */ 874 err = snd_ctl_elem_read(ctl->card->handle, val); 875 if (err < 0) { 876 ksft_print_msg("%s failed to read: %s\n", 877 ctl->name, snd_strerror(err)); 878 return true; 879 } 880 881 return !ctl_value_valid(ctl, val); 882 } 883 884 static bool test_ctl_write_invalid_boolean(struct ctl_data *ctl) 885 { 886 int err, i; 887 long val_read; 888 bool fail = false; 889 snd_ctl_elem_value_t *val; 890 snd_ctl_elem_value_alloca(&val); 891 892 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 893 snd_ctl_elem_value_copy(val, ctl->def_val); 894 snd_ctl_elem_value_set_boolean(val, i, 2); 895 896 if (test_ctl_write_invalid_value(ctl, val)) 897 fail = true; 898 } 899 900 return !fail; 901 } 902 903 static bool test_ctl_write_invalid_integer(struct ctl_data *ctl) 904 { 905 int i; 906 bool fail = false; 907 snd_ctl_elem_value_t *val; 908 snd_ctl_elem_value_alloca(&val); 909 910 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 911 if (snd_ctl_elem_info_get_min(ctl->info) != LONG_MIN) { 912 /* Just under range */ 913 snd_ctl_elem_value_copy(val, ctl->def_val); 914 snd_ctl_elem_value_set_integer(val, i, 915 snd_ctl_elem_info_get_min(ctl->info) - 1); 916 917 if (test_ctl_write_invalid_value(ctl, val)) 918 fail = true; 919 920 /* Minimum representable value */ 921 snd_ctl_elem_value_copy(val, ctl->def_val); 922 snd_ctl_elem_value_set_integer(val, i, LONG_MIN); 923 924 if (test_ctl_write_invalid_value(ctl, val)) 925 fail = true; 926 } 927 928 if (snd_ctl_elem_info_get_max(ctl->info) != LONG_MAX) { 929 /* Just over range */ 930 snd_ctl_elem_value_copy(val, ctl->def_val); 931 snd_ctl_elem_value_set_integer(val, i, 932 snd_ctl_elem_info_get_max(ctl->info) + 1); 933 934 if (test_ctl_write_invalid_value(ctl, val)) 935 fail = true; 936 937 /* Maximum representable value */ 938 snd_ctl_elem_value_copy(val, ctl->def_val); 939 snd_ctl_elem_value_set_integer(val, i, LONG_MAX); 940 941 if (test_ctl_write_invalid_value(ctl, val)) 942 fail = true; 943 } 944 } 945 946 return !fail; 947 } 948 949 static bool test_ctl_write_invalid_integer64(struct ctl_data *ctl) 950 { 951 int i; 952 bool fail = false; 953 snd_ctl_elem_value_t *val; 954 snd_ctl_elem_value_alloca(&val); 955 956 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 957 if (snd_ctl_elem_info_get_min64(ctl->info) != LLONG_MIN) { 958 /* Just under range */ 959 snd_ctl_elem_value_copy(val, ctl->def_val); 960 snd_ctl_elem_value_set_integer64(val, i, 961 snd_ctl_elem_info_get_min64(ctl->info) - 1); 962 963 if (test_ctl_write_invalid_value(ctl, val)) 964 fail = true; 965 966 /* Minimum representable value */ 967 snd_ctl_elem_value_copy(val, ctl->def_val); 968 snd_ctl_elem_value_set_integer64(val, i, LLONG_MIN); 969 970 if (test_ctl_write_invalid_value(ctl, val)) 971 fail = true; 972 } 973 974 if (snd_ctl_elem_info_get_max64(ctl->info) != LLONG_MAX) { 975 /* Just over range */ 976 snd_ctl_elem_value_copy(val, ctl->def_val); 977 snd_ctl_elem_value_set_integer64(val, i, 978 snd_ctl_elem_info_get_max64(ctl->info) + 1); 979 980 if (test_ctl_write_invalid_value(ctl, val)) 981 fail = true; 982 983 /* Maximum representable value */ 984 snd_ctl_elem_value_copy(val, ctl->def_val); 985 snd_ctl_elem_value_set_integer64(val, i, LLONG_MAX); 986 987 if (test_ctl_write_invalid_value(ctl, val)) 988 fail = true; 989 } 990 } 991 992 return !fail; 993 } 994 995 static bool test_ctl_write_invalid_enumerated(struct ctl_data *ctl) 996 { 997 int err, i; 998 unsigned int val_read; 999 bool fail = false; 1000 snd_ctl_elem_value_t *val; 1001 snd_ctl_elem_value_alloca(&val); 1002 1003 snd_ctl_elem_value_set_id(val, ctl->id); 1004 1005 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 1006 /* One beyond maximum */ 1007 snd_ctl_elem_value_copy(val, ctl->def_val); 1008 snd_ctl_elem_value_set_enumerated(val, i, 1009 snd_ctl_elem_info_get_items(ctl->info)); 1010 1011 if (test_ctl_write_invalid_value(ctl, val)) 1012 fail = true; 1013 1014 /* Maximum representable value */ 1015 snd_ctl_elem_value_copy(val, ctl->def_val); 1016 snd_ctl_elem_value_set_enumerated(val, i, UINT_MAX); 1017 1018 if (test_ctl_write_invalid_value(ctl, val)) 1019 fail = true; 1020 1021 } 1022 1023 return !fail; 1024 } 1025 1026 1027 static void test_ctl_write_invalid(struct ctl_data *ctl) 1028 { 1029 bool pass; 1030 int err; 1031 1032 /* If the control is turned off let's be polite */ 1033 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 1034 ksft_print_msg("%s is inactive\n", ctl->name); 1035 ksft_test_result_skip("write_invalid.%d.%d\n", 1036 ctl->card->card, ctl->elem); 1037 return; 1038 } 1039 1040 if (!snd_ctl_elem_info_is_writable(ctl->info)) { 1041 ksft_print_msg("%s is not writeable\n", ctl->name); 1042 ksft_test_result_skip("write_invalid.%d.%d\n", 1043 ctl->card->card, ctl->elem); 1044 return; 1045 } 1046 1047 switch (snd_ctl_elem_info_get_type(ctl->info)) { 1048 case SND_CTL_ELEM_TYPE_BOOLEAN: 1049 pass = test_ctl_write_invalid_boolean(ctl); 1050 break; 1051 1052 case SND_CTL_ELEM_TYPE_INTEGER: 1053 pass = test_ctl_write_invalid_integer(ctl); 1054 break; 1055 1056 case SND_CTL_ELEM_TYPE_INTEGER64: 1057 pass = test_ctl_write_invalid_integer64(ctl); 1058 break; 1059 1060 case SND_CTL_ELEM_TYPE_ENUMERATED: 1061 pass = test_ctl_write_invalid_enumerated(ctl); 1062 break; 1063 1064 default: 1065 /* No tests for this yet */ 1066 ksft_test_result_skip("write_invalid.%d.%d\n", 1067 ctl->card->card, ctl->elem); 1068 return; 1069 } 1070 1071 /* Restore the default value to minimise disruption */ 1072 write_and_verify(ctl, ctl->def_val, NULL); 1073 1074 ksft_test_result(pass, "write_invalid.%d.%d\n", 1075 ctl->card->card, ctl->elem); 1076 } 1077 1078 static void test_ctl_event_missing(struct ctl_data *ctl) 1079 { 1080 ksft_test_result(!ctl->event_missing, "event_missing.%d.%d\n", 1081 ctl->card->card, ctl->elem); 1082 } 1083 1084 static void test_ctl_event_spurious(struct ctl_data *ctl) 1085 { 1086 ksft_test_result(!ctl->event_spurious, "event_spurious.%d.%d\n", 1087 ctl->card->card, ctl->elem); 1088 } 1089 1090 int main(void) 1091 { 1092 struct ctl_data *ctl; 1093 1094 ksft_print_header(); 1095 1096 find_controls(); 1097 1098 ksft_set_plan(num_controls * TESTS_PER_CONTROL); 1099 1100 for (ctl = ctl_list; ctl != NULL; ctl = ctl->next) { 1101 /* 1102 * Must test get_value() before we write anything, the 1103 * test stores the default value for later cleanup. 1104 */ 1105 test_ctl_get_value(ctl); 1106 test_ctl_name(ctl); 1107 test_ctl_write_default(ctl); 1108 test_ctl_write_valid(ctl); 1109 test_ctl_write_invalid(ctl); 1110 test_ctl_event_missing(ctl); 1111 test_ctl_event_spurious(ctl); 1112 } 1113 1114 ksft_exit_pass(); 1115 1116 return 0; 1117 } 1118