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 %s\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 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 434 ksft_print_msg("%d.%d %s\n", ctl->card->card, ctl->elem, 435 ctl->name); 436 437 /* Only boolean controls should end in Switch */ 438 if (strend(ctl->name, " Switch")) { 439 if (snd_ctl_elem_info_get_type(ctl->info) != SND_CTL_ELEM_TYPE_BOOLEAN) { 440 ksft_print_msg("%d.%d %s ends in Switch but is not boolean\n", 441 ctl->card->card, ctl->elem, ctl->name); 442 name_ok = false; 443 } 444 } 445 446 /* Writeable boolean controls should end in Switch */ 447 if (snd_ctl_elem_info_get_type(ctl->info) == SND_CTL_ELEM_TYPE_BOOLEAN && 448 snd_ctl_elem_info_is_writable(ctl->info)) { 449 if (!strend(ctl->name, " Switch")) { 450 ksft_print_msg("%d.%d %s is a writeable boolean but not a Switch\n", 451 ctl->card->card, ctl->elem, ctl->name); 452 name_ok = false; 453 } 454 } 455 456 ksft_test_result(name_ok, "name.%d.%d\n", 457 ctl->card->card, ctl->elem); 458 } 459 460 static void show_values(struct ctl_data *ctl, snd_ctl_elem_value_t *orig_val, 461 snd_ctl_elem_value_t *read_val) 462 { 463 long long orig_int, read_int; 464 int i; 465 466 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 467 switch (snd_ctl_elem_info_get_type(ctl->info)) { 468 case SND_CTL_ELEM_TYPE_BOOLEAN: 469 orig_int = snd_ctl_elem_value_get_boolean(orig_val, i); 470 read_int = snd_ctl_elem_value_get_boolean(read_val, i); 471 break; 472 473 case SND_CTL_ELEM_TYPE_INTEGER: 474 orig_int = snd_ctl_elem_value_get_integer(orig_val, i); 475 read_int = snd_ctl_elem_value_get_integer(read_val, i); 476 break; 477 478 case SND_CTL_ELEM_TYPE_INTEGER64: 479 orig_int = snd_ctl_elem_value_get_integer64(orig_val, 480 i); 481 read_int = snd_ctl_elem_value_get_integer64(read_val, 482 i); 483 break; 484 485 case SND_CTL_ELEM_TYPE_ENUMERATED: 486 orig_int = snd_ctl_elem_value_get_enumerated(orig_val, 487 i); 488 read_int = snd_ctl_elem_value_get_enumerated(read_val, 489 i); 490 break; 491 492 default: 493 return; 494 } 495 496 ksft_print_msg("%s.%d orig %lld read %lld, is_volatile %d\n", 497 ctl->name, i, orig_int, read_int, 498 snd_ctl_elem_info_is_volatile(ctl->info)); 499 } 500 } 501 502 static bool show_mismatch(struct ctl_data *ctl, int index, 503 snd_ctl_elem_value_t *read_val, 504 snd_ctl_elem_value_t *expected_val) 505 { 506 long long expected_int, read_int; 507 508 /* 509 * We factor out the code to compare values representable as 510 * integers, ensure that check doesn't log otherwise. 511 */ 512 expected_int = 0; 513 read_int = 0; 514 515 switch (snd_ctl_elem_info_get_type(ctl->info)) { 516 case SND_CTL_ELEM_TYPE_BOOLEAN: 517 expected_int = snd_ctl_elem_value_get_boolean(expected_val, 518 index); 519 read_int = snd_ctl_elem_value_get_boolean(read_val, index); 520 break; 521 522 case SND_CTL_ELEM_TYPE_INTEGER: 523 expected_int = snd_ctl_elem_value_get_integer(expected_val, 524 index); 525 read_int = snd_ctl_elem_value_get_integer(read_val, index); 526 break; 527 528 case SND_CTL_ELEM_TYPE_INTEGER64: 529 expected_int = snd_ctl_elem_value_get_integer64(expected_val, 530 index); 531 read_int = snd_ctl_elem_value_get_integer64(read_val, 532 index); 533 break; 534 535 case SND_CTL_ELEM_TYPE_ENUMERATED: 536 expected_int = snd_ctl_elem_value_get_enumerated(expected_val, 537 index); 538 read_int = snd_ctl_elem_value_get_enumerated(read_val, 539 index); 540 break; 541 542 default: 543 break; 544 } 545 546 if (expected_int != read_int) { 547 /* 548 * NOTE: The volatile attribute means that the hardware 549 * can voluntarily change the state of control element 550 * independent of any operation by software. 551 */ 552 bool is_volatile = snd_ctl_elem_info_is_volatile(ctl->info); 553 ksft_print_msg("%s.%d expected %lld but read %lld, is_volatile %d\n", 554 ctl->name, index, expected_int, read_int, is_volatile); 555 return !is_volatile; 556 } else { 557 return false; 558 } 559 } 560 561 /* 562 * Write a value then if possible verify that we get the expected 563 * result. An optional expected value can be provided if we expect 564 * the write to fail, for verifying that invalid writes don't corrupt 565 * anything. 566 */ 567 static int write_and_verify(struct ctl_data *ctl, 568 snd_ctl_elem_value_t *write_val, 569 snd_ctl_elem_value_t *expected_val) 570 { 571 int err, i; 572 bool error_expected, mismatch_shown; 573 snd_ctl_elem_value_t *initial_val, *read_val, *w_val; 574 snd_ctl_elem_value_alloca(&initial_val); 575 snd_ctl_elem_value_alloca(&read_val); 576 snd_ctl_elem_value_alloca(&w_val); 577 578 /* 579 * We need to copy the write value since writing can modify 580 * the value which causes surprises, and allocate an expected 581 * value if we expect to read back what we wrote. 582 */ 583 snd_ctl_elem_value_copy(w_val, write_val); 584 if (expected_val) { 585 error_expected = true; 586 } else { 587 error_expected = false; 588 snd_ctl_elem_value_alloca(&expected_val); 589 snd_ctl_elem_value_copy(expected_val, write_val); 590 } 591 592 /* Store the value before we write */ 593 if (snd_ctl_elem_info_is_readable(ctl->info)) { 594 snd_ctl_elem_value_set_id(initial_val, ctl->id); 595 596 err = snd_ctl_elem_read(ctl->card->handle, initial_val); 597 if (err < 0) { 598 ksft_print_msg("snd_ctl_elem_read() failed: %s\n", 599 snd_strerror(err)); 600 return err; 601 } 602 } 603 604 /* 605 * Do the write, if we have an expected value ignore the error 606 * and carry on to validate the expected value. 607 */ 608 err = snd_ctl_elem_write(ctl->card->handle, w_val); 609 if (err < 0 && !error_expected) { 610 ksft_print_msg("snd_ctl_elem_write() failed: %s\n", 611 snd_strerror(err)); 612 return err; 613 } 614 615 /* Can we do the verification part? */ 616 if (!snd_ctl_elem_info_is_readable(ctl->info)) 617 return err; 618 619 snd_ctl_elem_value_set_id(read_val, ctl->id); 620 621 err = snd_ctl_elem_read(ctl->card->handle, read_val); 622 if (err < 0) { 623 ksft_print_msg("snd_ctl_elem_read() failed: %s\n", 624 snd_strerror(err)); 625 return err; 626 } 627 628 /* 629 * Check for an event if the value changed, or confirm that 630 * there was none if it didn't. We rely on the kernel 631 * generating the notification before it returns from the 632 * write, this is currently true, should that ever change this 633 * will most likely break and need updating. 634 */ 635 if (!snd_ctl_elem_info_is_volatile(ctl->info)) { 636 err = wait_for_event(ctl, 0); 637 if (snd_ctl_elem_value_compare(initial_val, read_val)) { 638 if (err < 1) { 639 ksft_print_msg("No event generated for %s\n", 640 ctl->name); 641 show_values(ctl, initial_val, read_val); 642 ctl->event_missing++; 643 } 644 } else { 645 if (err != 0) { 646 ksft_print_msg("Spurious event generated for %s\n", 647 ctl->name); 648 show_values(ctl, initial_val, read_val); 649 ctl->event_spurious++; 650 } 651 } 652 } 653 654 /* 655 * Use the libray to compare values, if there's a mismatch 656 * carry on and try to provide a more useful diagnostic than 657 * just "mismatch". 658 */ 659 if (!snd_ctl_elem_value_compare(expected_val, read_val)) 660 return 0; 661 662 mismatch_shown = false; 663 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) 664 if (show_mismatch(ctl, i, read_val, expected_val)) 665 mismatch_shown = true; 666 667 if (!mismatch_shown) 668 ksft_print_msg("%s read and written values differ\n", 669 ctl->name); 670 671 return -1; 672 } 673 674 /* 675 * Make sure we can write the default value back to the control, this 676 * should validate that at least some write works. 677 */ 678 static void test_ctl_write_default(struct ctl_data *ctl) 679 { 680 int err; 681 682 /* If the control is turned off let's be polite */ 683 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 684 ksft_print_msg("%s is inactive\n", ctl->name); 685 ksft_test_result_skip("write_default.%d.%d\n", 686 ctl->card->card, ctl->elem); 687 return; 688 } 689 690 if (!snd_ctl_elem_info_is_writable(ctl->info)) { 691 ksft_print_msg("%s is not writeable\n", ctl->name); 692 ksft_test_result_skip("write_default.%d.%d\n", 693 ctl->card->card, ctl->elem); 694 return; 695 } 696 697 /* No idea what the default was for unreadable controls */ 698 if (!snd_ctl_elem_info_is_readable(ctl->info)) { 699 ksft_print_msg("%s couldn't read default\n", ctl->name); 700 ksft_test_result_skip("write_default.%d.%d\n", 701 ctl->card->card, ctl->elem); 702 return; 703 } 704 705 err = write_and_verify(ctl, ctl->def_val, NULL); 706 707 ksft_test_result(err >= 0, "write_default.%d.%d\n", 708 ctl->card->card, ctl->elem); 709 } 710 711 static bool test_ctl_write_valid_boolean(struct ctl_data *ctl) 712 { 713 int err, i, j; 714 bool fail = false; 715 snd_ctl_elem_value_t *val; 716 snd_ctl_elem_value_alloca(&val); 717 718 snd_ctl_elem_value_set_id(val, ctl->id); 719 720 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 721 for (j = 0; j < 2; j++) { 722 snd_ctl_elem_value_set_boolean(val, i, j); 723 err = write_and_verify(ctl, val, NULL); 724 if (err != 0) 725 fail = true; 726 } 727 } 728 729 return !fail; 730 } 731 732 static bool test_ctl_write_valid_integer(struct ctl_data *ctl) 733 { 734 int err; 735 int i; 736 long j, step; 737 bool fail = false; 738 snd_ctl_elem_value_t *val; 739 snd_ctl_elem_value_alloca(&val); 740 741 snd_ctl_elem_value_set_id(val, ctl->id); 742 743 step = snd_ctl_elem_info_get_step(ctl->info); 744 if (!step) 745 step = 1; 746 747 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 748 for (j = snd_ctl_elem_info_get_min(ctl->info); 749 j <= snd_ctl_elem_info_get_max(ctl->info); j += step) { 750 751 snd_ctl_elem_value_set_integer(val, i, j); 752 err = write_and_verify(ctl, val, NULL); 753 if (err != 0) 754 fail = true; 755 } 756 } 757 758 759 return !fail; 760 } 761 762 static bool test_ctl_write_valid_integer64(struct ctl_data *ctl) 763 { 764 int err, i; 765 long long j, step; 766 bool fail = false; 767 snd_ctl_elem_value_t *val; 768 snd_ctl_elem_value_alloca(&val); 769 770 snd_ctl_elem_value_set_id(val, ctl->id); 771 772 step = snd_ctl_elem_info_get_step64(ctl->info); 773 if (!step) 774 step = 1; 775 776 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 777 for (j = snd_ctl_elem_info_get_min64(ctl->info); 778 j <= snd_ctl_elem_info_get_max64(ctl->info); j += step) { 779 780 snd_ctl_elem_value_set_integer64(val, i, j); 781 err = write_and_verify(ctl, val, NULL); 782 if (err != 0) 783 fail = true; 784 } 785 } 786 787 return !fail; 788 } 789 790 static bool test_ctl_write_valid_enumerated(struct ctl_data *ctl) 791 { 792 int err, i, j; 793 bool fail = false; 794 snd_ctl_elem_value_t *val; 795 snd_ctl_elem_value_alloca(&val); 796 797 snd_ctl_elem_value_set_id(val, ctl->id); 798 799 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 800 for (j = 0; j < snd_ctl_elem_info_get_items(ctl->info); j++) { 801 snd_ctl_elem_value_set_enumerated(val, i, j); 802 err = write_and_verify(ctl, val, NULL); 803 if (err != 0) 804 fail = true; 805 } 806 } 807 808 return !fail; 809 } 810 811 static void test_ctl_write_valid(struct ctl_data *ctl) 812 { 813 bool pass; 814 815 /* If the control is turned off let's be polite */ 816 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 817 ksft_print_msg("%s is inactive\n", ctl->name); 818 ksft_test_result_skip("write_valid.%d.%d\n", 819 ctl->card->card, ctl->elem); 820 return; 821 } 822 823 if (!snd_ctl_elem_info_is_writable(ctl->info)) { 824 ksft_print_msg("%s is not writeable\n", ctl->name); 825 ksft_test_result_skip("write_valid.%d.%d\n", 826 ctl->card->card, ctl->elem); 827 return; 828 } 829 830 switch (snd_ctl_elem_info_get_type(ctl->info)) { 831 case SND_CTL_ELEM_TYPE_BOOLEAN: 832 pass = test_ctl_write_valid_boolean(ctl); 833 break; 834 835 case SND_CTL_ELEM_TYPE_INTEGER: 836 pass = test_ctl_write_valid_integer(ctl); 837 break; 838 839 case SND_CTL_ELEM_TYPE_INTEGER64: 840 pass = test_ctl_write_valid_integer64(ctl); 841 break; 842 843 case SND_CTL_ELEM_TYPE_ENUMERATED: 844 pass = test_ctl_write_valid_enumerated(ctl); 845 break; 846 847 default: 848 /* No tests for this yet */ 849 ksft_test_result_skip("write_valid.%d.%d\n", 850 ctl->card->card, ctl->elem); 851 return; 852 } 853 854 /* Restore the default value to minimise disruption */ 855 write_and_verify(ctl, ctl->def_val, NULL); 856 857 ksft_test_result(pass, "write_valid.%d.%d\n", 858 ctl->card->card, ctl->elem); 859 } 860 861 static bool test_ctl_write_invalid_value(struct ctl_data *ctl, 862 snd_ctl_elem_value_t *val) 863 { 864 int err; 865 866 /* Ideally this will fail... */ 867 err = snd_ctl_elem_write(ctl->card->handle, val); 868 if (err < 0) 869 return false; 870 871 /* ...but some devices will clamp to an in range value */ 872 err = snd_ctl_elem_read(ctl->card->handle, val); 873 if (err < 0) { 874 ksft_print_msg("%s failed to read: %s\n", 875 ctl->name, snd_strerror(err)); 876 return true; 877 } 878 879 return !ctl_value_valid(ctl, val); 880 } 881 882 static bool test_ctl_write_invalid_boolean(struct ctl_data *ctl) 883 { 884 int i; 885 bool fail = false; 886 snd_ctl_elem_value_t *val; 887 snd_ctl_elem_value_alloca(&val); 888 889 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 890 snd_ctl_elem_value_copy(val, ctl->def_val); 891 snd_ctl_elem_value_set_boolean(val, i, 2); 892 893 if (test_ctl_write_invalid_value(ctl, val)) 894 fail = true; 895 } 896 897 return !fail; 898 } 899 900 static bool test_ctl_write_invalid_integer(struct ctl_data *ctl) 901 { 902 int i; 903 bool fail = false; 904 snd_ctl_elem_value_t *val; 905 snd_ctl_elem_value_alloca(&val); 906 907 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 908 if (snd_ctl_elem_info_get_min(ctl->info) != LONG_MIN) { 909 /* Just under range */ 910 snd_ctl_elem_value_copy(val, ctl->def_val); 911 snd_ctl_elem_value_set_integer(val, i, 912 snd_ctl_elem_info_get_min(ctl->info) - 1); 913 914 if (test_ctl_write_invalid_value(ctl, val)) 915 fail = true; 916 917 /* Minimum representable value */ 918 snd_ctl_elem_value_copy(val, ctl->def_val); 919 snd_ctl_elem_value_set_integer(val, i, LONG_MIN); 920 921 if (test_ctl_write_invalid_value(ctl, val)) 922 fail = true; 923 } 924 925 if (snd_ctl_elem_info_get_max(ctl->info) != LONG_MAX) { 926 /* Just over range */ 927 snd_ctl_elem_value_copy(val, ctl->def_val); 928 snd_ctl_elem_value_set_integer(val, i, 929 snd_ctl_elem_info_get_max(ctl->info) + 1); 930 931 if (test_ctl_write_invalid_value(ctl, val)) 932 fail = true; 933 934 /* Maximum representable value */ 935 snd_ctl_elem_value_copy(val, ctl->def_val); 936 snd_ctl_elem_value_set_integer(val, i, LONG_MAX); 937 938 if (test_ctl_write_invalid_value(ctl, val)) 939 fail = true; 940 } 941 } 942 943 return !fail; 944 } 945 946 static bool test_ctl_write_invalid_integer64(struct ctl_data *ctl) 947 { 948 int i; 949 bool fail = false; 950 snd_ctl_elem_value_t *val; 951 snd_ctl_elem_value_alloca(&val); 952 953 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 954 if (snd_ctl_elem_info_get_min64(ctl->info) != LLONG_MIN) { 955 /* Just under range */ 956 snd_ctl_elem_value_copy(val, ctl->def_val); 957 snd_ctl_elem_value_set_integer64(val, i, 958 snd_ctl_elem_info_get_min64(ctl->info) - 1); 959 960 if (test_ctl_write_invalid_value(ctl, val)) 961 fail = true; 962 963 /* Minimum representable value */ 964 snd_ctl_elem_value_copy(val, ctl->def_val); 965 snd_ctl_elem_value_set_integer64(val, i, LLONG_MIN); 966 967 if (test_ctl_write_invalid_value(ctl, val)) 968 fail = true; 969 } 970 971 if (snd_ctl_elem_info_get_max64(ctl->info) != LLONG_MAX) { 972 /* Just over range */ 973 snd_ctl_elem_value_copy(val, ctl->def_val); 974 snd_ctl_elem_value_set_integer64(val, i, 975 snd_ctl_elem_info_get_max64(ctl->info) + 1); 976 977 if (test_ctl_write_invalid_value(ctl, val)) 978 fail = true; 979 980 /* Maximum representable value */ 981 snd_ctl_elem_value_copy(val, ctl->def_val); 982 snd_ctl_elem_value_set_integer64(val, i, LLONG_MAX); 983 984 if (test_ctl_write_invalid_value(ctl, val)) 985 fail = true; 986 } 987 } 988 989 return !fail; 990 } 991 992 static bool test_ctl_write_invalid_enumerated(struct ctl_data *ctl) 993 { 994 int i; 995 bool fail = false; 996 snd_ctl_elem_value_t *val; 997 snd_ctl_elem_value_alloca(&val); 998 999 snd_ctl_elem_value_set_id(val, ctl->id); 1000 1001 for (i = 0; i < snd_ctl_elem_info_get_count(ctl->info); i++) { 1002 /* One beyond maximum */ 1003 snd_ctl_elem_value_copy(val, ctl->def_val); 1004 snd_ctl_elem_value_set_enumerated(val, i, 1005 snd_ctl_elem_info_get_items(ctl->info)); 1006 1007 if (test_ctl_write_invalid_value(ctl, val)) 1008 fail = true; 1009 1010 /* Maximum representable value */ 1011 snd_ctl_elem_value_copy(val, ctl->def_val); 1012 snd_ctl_elem_value_set_enumerated(val, i, UINT_MAX); 1013 1014 if (test_ctl_write_invalid_value(ctl, val)) 1015 fail = true; 1016 1017 } 1018 1019 return !fail; 1020 } 1021 1022 1023 static void test_ctl_write_invalid(struct ctl_data *ctl) 1024 { 1025 bool pass; 1026 1027 /* If the control is turned off let's be polite */ 1028 if (snd_ctl_elem_info_is_inactive(ctl->info)) { 1029 ksft_print_msg("%s is inactive\n", ctl->name); 1030 ksft_test_result_skip("write_invalid.%d.%d\n", 1031 ctl->card->card, ctl->elem); 1032 return; 1033 } 1034 1035 if (!snd_ctl_elem_info_is_writable(ctl->info)) { 1036 ksft_print_msg("%s is not writeable\n", ctl->name); 1037 ksft_test_result_skip("write_invalid.%d.%d\n", 1038 ctl->card->card, ctl->elem); 1039 return; 1040 } 1041 1042 switch (snd_ctl_elem_info_get_type(ctl->info)) { 1043 case SND_CTL_ELEM_TYPE_BOOLEAN: 1044 pass = test_ctl_write_invalid_boolean(ctl); 1045 break; 1046 1047 case SND_CTL_ELEM_TYPE_INTEGER: 1048 pass = test_ctl_write_invalid_integer(ctl); 1049 break; 1050 1051 case SND_CTL_ELEM_TYPE_INTEGER64: 1052 pass = test_ctl_write_invalid_integer64(ctl); 1053 break; 1054 1055 case SND_CTL_ELEM_TYPE_ENUMERATED: 1056 pass = test_ctl_write_invalid_enumerated(ctl); 1057 break; 1058 1059 default: 1060 /* No tests for this yet */ 1061 ksft_test_result_skip("write_invalid.%d.%d\n", 1062 ctl->card->card, ctl->elem); 1063 return; 1064 } 1065 1066 /* Restore the default value to minimise disruption */ 1067 write_and_verify(ctl, ctl->def_val, NULL); 1068 1069 ksft_test_result(pass, "write_invalid.%d.%d\n", 1070 ctl->card->card, ctl->elem); 1071 } 1072 1073 static void test_ctl_event_missing(struct ctl_data *ctl) 1074 { 1075 ksft_test_result(!ctl->event_missing, "event_missing.%d.%d\n", 1076 ctl->card->card, ctl->elem); 1077 } 1078 1079 static void test_ctl_event_spurious(struct ctl_data *ctl) 1080 { 1081 ksft_test_result(!ctl->event_spurious, "event_spurious.%d.%d\n", 1082 ctl->card->card, ctl->elem); 1083 } 1084 1085 int main(void) 1086 { 1087 struct ctl_data *ctl; 1088 1089 ksft_print_header(); 1090 1091 find_controls(); 1092 1093 ksft_set_plan(num_controls * TESTS_PER_CONTROL); 1094 1095 for (ctl = ctl_list; ctl != NULL; ctl = ctl->next) { 1096 /* 1097 * Must test get_value() before we write anything, the 1098 * test stores the default value for later cleanup. 1099 */ 1100 test_ctl_get_value(ctl); 1101 test_ctl_name(ctl); 1102 test_ctl_write_default(ctl); 1103 test_ctl_write_valid(ctl); 1104 test_ctl_write_invalid(ctl); 1105 test_ctl_event_missing(ctl); 1106 test_ctl_event_spurious(ctl); 1107 } 1108 1109 ksft_exit_pass(); 1110 1111 return 0; 1112 } 1113