1 /* 2 * linux/drivers/spi/spi-loopback-test.c 3 * 4 * (c) Martin Sperl <kernel@martin.sperl.org> 5 * 6 * Loopback test driver to test several typical spi_message conditions 7 * that a spi_master driver may encounter 8 * this can also get used for regression testing 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 */ 20 21 #include <linux/delay.h> 22 #include <linux/kernel.h> 23 #include <linux/ktime.h> 24 #include <linux/list.h> 25 #include <linux/list_sort.h> 26 #include <linux/module.h> 27 #include <linux/of_device.h> 28 #include <linux/printk.h> 29 #include <linux/vmalloc.h> 30 #include <linux/spi/spi.h> 31 32 #include "spi-test.h" 33 34 /* flag to only simulate transfers */ 35 int simulate_only; 36 module_param(simulate_only, int, 0); 37 MODULE_PARM_DESC(simulate_only, "if not 0 do not execute the spi message"); 38 39 /* dump spi messages */ 40 int dump_messages; 41 module_param(dump_messages, int, 0); 42 MODULE_PARM_DESC(dump_messages, 43 "=1 dump the basic spi_message_structure, " \ 44 "=2 dump the spi_message_structure including data, " \ 45 "=3 dump the spi_message structure before and after execution"); 46 /* the device is jumpered for loopback - enabling some rx_buf tests */ 47 int loopback; 48 module_param(loopback, int, 0); 49 MODULE_PARM_DESC(loopback, 50 "if set enable loopback mode, where the rx_buf " \ 51 "is checked to match tx_buf after the spi_message " \ 52 "is executed"); 53 54 /* run only a specific test */ 55 int run_only_test = -1; 56 module_param(run_only_test, int, 0); 57 MODULE_PARM_DESC(run_only_test, 58 "only run the test with this number (0-based !)"); 59 60 /* use vmalloc'ed buffers */ 61 int use_vmalloc; 62 module_param(use_vmalloc, int, 0644); 63 MODULE_PARM_DESC(use_vmalloc, 64 "use vmalloc'ed buffers instead of kmalloc'ed"); 65 66 /* check rx ranges */ 67 int check_ranges = 1; 68 module_param(check_ranges, int, 0644); 69 MODULE_PARM_DESC(check_ranges, 70 "checks rx_buffer pattern are valid"); 71 72 /* the actual tests to execute */ 73 static struct spi_test spi_tests[] = { 74 { 75 .description = "tx/rx-transfer - start of page", 76 .fill_option = FILL_COUNT_8, 77 .iterate_len = { ITERATE_MAX_LEN }, 78 .iterate_tx_align = ITERATE_ALIGN, 79 .iterate_rx_align = ITERATE_ALIGN, 80 .transfer_count = 1, 81 .transfers = { 82 { 83 .tx_buf = TX(0), 84 .rx_buf = RX(0), 85 }, 86 }, 87 }, 88 { 89 .description = "tx/rx-transfer - crossing PAGE_SIZE", 90 .fill_option = FILL_COUNT_8, 91 .iterate_len = { ITERATE_MAX_LEN }, 92 .iterate_tx_align = ITERATE_ALIGN, 93 .iterate_rx_align = ITERATE_ALIGN, 94 .transfer_count = 1, 95 .transfers = { 96 { 97 .tx_buf = TX(PAGE_SIZE - 4), 98 .rx_buf = RX(PAGE_SIZE - 4), 99 }, 100 }, 101 }, 102 { 103 .description = "tx-transfer - only", 104 .fill_option = FILL_COUNT_8, 105 .iterate_len = { ITERATE_MAX_LEN }, 106 .iterate_tx_align = ITERATE_ALIGN, 107 .transfer_count = 1, 108 .transfers = { 109 { 110 .tx_buf = TX(0), 111 }, 112 }, 113 }, 114 { 115 .description = "rx-transfer - only", 116 .fill_option = FILL_COUNT_8, 117 .iterate_len = { ITERATE_MAX_LEN }, 118 .iterate_rx_align = ITERATE_ALIGN, 119 .transfer_count = 1, 120 .transfers = { 121 { 122 .rx_buf = RX(0), 123 }, 124 }, 125 }, 126 { 127 .description = "two tx-transfers - alter both", 128 .fill_option = FILL_COUNT_8, 129 .iterate_len = { ITERATE_LEN }, 130 .iterate_tx_align = ITERATE_ALIGN, 131 .iterate_transfer_mask = BIT(0) | BIT(1), 132 .transfer_count = 2, 133 .transfers = { 134 { 135 .tx_buf = TX(0), 136 }, 137 { 138 /* this is why we cant use ITERATE_MAX_LEN */ 139 .tx_buf = TX(SPI_TEST_MAX_SIZE_HALF), 140 }, 141 }, 142 }, 143 { 144 .description = "two tx-transfers - alter first", 145 .fill_option = FILL_COUNT_8, 146 .iterate_len = { ITERATE_MAX_LEN }, 147 .iterate_tx_align = ITERATE_ALIGN, 148 .iterate_transfer_mask = BIT(0), 149 .transfer_count = 2, 150 .transfers = { 151 { 152 .tx_buf = TX(64), 153 }, 154 { 155 .len = 1, 156 .tx_buf = TX(0), 157 }, 158 }, 159 }, 160 { 161 .description = "two tx-transfers - alter second", 162 .fill_option = FILL_COUNT_8, 163 .iterate_len = { ITERATE_MAX_LEN }, 164 .iterate_tx_align = ITERATE_ALIGN, 165 .iterate_transfer_mask = BIT(1), 166 .transfer_count = 2, 167 .transfers = { 168 { 169 .len = 16, 170 .tx_buf = TX(0), 171 }, 172 { 173 .tx_buf = TX(64), 174 }, 175 }, 176 }, 177 { 178 .description = "two transfers tx then rx - alter both", 179 .fill_option = FILL_COUNT_8, 180 .iterate_len = { ITERATE_MAX_LEN }, 181 .iterate_tx_align = ITERATE_ALIGN, 182 .iterate_transfer_mask = BIT(0) | BIT(1), 183 .transfer_count = 2, 184 .transfers = { 185 { 186 .tx_buf = TX(0), 187 }, 188 { 189 .rx_buf = RX(0), 190 }, 191 }, 192 }, 193 { 194 .description = "two transfers tx then rx - alter tx", 195 .fill_option = FILL_COUNT_8, 196 .iterate_len = { ITERATE_MAX_LEN }, 197 .iterate_tx_align = ITERATE_ALIGN, 198 .iterate_transfer_mask = BIT(0), 199 .transfer_count = 2, 200 .transfers = { 201 { 202 .tx_buf = TX(0), 203 }, 204 { 205 .len = 1, 206 .rx_buf = RX(0), 207 }, 208 }, 209 }, 210 { 211 .description = "two transfers tx then rx - alter rx", 212 .fill_option = FILL_COUNT_8, 213 .iterate_len = { ITERATE_MAX_LEN }, 214 .iterate_tx_align = ITERATE_ALIGN, 215 .iterate_transfer_mask = BIT(1), 216 .transfer_count = 2, 217 .transfers = { 218 { 219 .len = 1, 220 .tx_buf = TX(0), 221 }, 222 { 223 .rx_buf = RX(0), 224 }, 225 }, 226 }, 227 { 228 .description = "two tx+rx transfers - alter both", 229 .fill_option = FILL_COUNT_8, 230 .iterate_len = { ITERATE_LEN }, 231 .iterate_tx_align = ITERATE_ALIGN, 232 .iterate_transfer_mask = BIT(0) | BIT(1), 233 .transfer_count = 2, 234 .transfers = { 235 { 236 .tx_buf = TX(0), 237 .rx_buf = RX(0), 238 }, 239 { 240 /* making sure we align without overwrite 241 * the reason we can not use ITERATE_MAX_LEN 242 */ 243 .tx_buf = TX(SPI_TEST_MAX_SIZE_HALF), 244 .rx_buf = RX(SPI_TEST_MAX_SIZE_HALF), 245 }, 246 }, 247 }, 248 { 249 .description = "two tx+rx transfers - alter first", 250 .fill_option = FILL_COUNT_8, 251 .iterate_len = { ITERATE_MAX_LEN }, 252 .iterate_tx_align = ITERATE_ALIGN, 253 .iterate_transfer_mask = BIT(0), 254 .transfer_count = 2, 255 .transfers = { 256 { 257 /* making sure we align without overwrite */ 258 .tx_buf = TX(1024), 259 .rx_buf = RX(1024), 260 }, 261 { 262 .len = 1, 263 /* making sure we align without overwrite */ 264 .tx_buf = TX(0), 265 .rx_buf = RX(0), 266 }, 267 }, 268 }, 269 { 270 .description = "two tx+rx transfers - alter second", 271 .fill_option = FILL_COUNT_8, 272 .iterate_len = { ITERATE_MAX_LEN }, 273 .iterate_tx_align = ITERATE_ALIGN, 274 .iterate_transfer_mask = BIT(1), 275 .transfer_count = 2, 276 .transfers = { 277 { 278 .len = 1, 279 .tx_buf = TX(0), 280 .rx_buf = RX(0), 281 }, 282 { 283 /* making sure we align without overwrite */ 284 .tx_buf = TX(1024), 285 .rx_buf = RX(1024), 286 }, 287 }, 288 }, 289 { 290 .description = "two tx+rx transfers - delay after transfer", 291 .fill_option = FILL_COUNT_8, 292 .iterate_len = { ITERATE_MAX_LEN }, 293 .iterate_transfer_mask = BIT(0) | BIT(1), 294 .transfer_count = 2, 295 .transfers = { 296 { 297 .tx_buf = TX(0), 298 .rx_buf = RX(0), 299 .delay_usecs = 1000, 300 }, 301 { 302 .tx_buf = TX(0), 303 .rx_buf = RX(0), 304 .delay_usecs = 1000, 305 }, 306 }, 307 }, 308 309 { /* end of tests sequence */ } 310 }; 311 312 static int spi_loopback_test_probe(struct spi_device *spi) 313 { 314 int ret; 315 316 dev_info(&spi->dev, "Executing spi-loopback-tests\n"); 317 318 ret = spi_test_run_tests(spi, spi_tests); 319 320 dev_info(&spi->dev, "Finished spi-loopback-tests with return: %i\n", 321 ret); 322 323 return ret; 324 } 325 326 /* non const match table to permit to change via a module parameter */ 327 static struct of_device_id spi_loopback_test_of_match[] = { 328 { .compatible = "linux,spi-loopback-test", }, 329 { } 330 }; 331 332 /* allow to override the compatible string via a module_parameter */ 333 module_param_string(compatible, spi_loopback_test_of_match[0].compatible, 334 sizeof(spi_loopback_test_of_match[0].compatible), 335 0000); 336 337 MODULE_DEVICE_TABLE(of, spi_loopback_test_of_match); 338 339 static struct spi_driver spi_loopback_test_driver = { 340 .driver = { 341 .name = "spi-loopback-test", 342 .owner = THIS_MODULE, 343 .of_match_table = spi_loopback_test_of_match, 344 }, 345 .probe = spi_loopback_test_probe, 346 }; 347 348 module_spi_driver(spi_loopback_test_driver); 349 350 MODULE_AUTHOR("Martin Sperl <kernel@martin.sperl.org>"); 351 MODULE_DESCRIPTION("test spi_driver to check core functionality"); 352 MODULE_LICENSE("GPL"); 353 354 /*-------------------------------------------------------------------------*/ 355 356 /* spi_test implementation */ 357 358 #define RANGE_CHECK(ptr, plen, start, slen) \ 359 ((ptr >= start) && (ptr + plen <= start + slen)) 360 361 /* we allocate one page more, to allow for offsets */ 362 #define SPI_TEST_MAX_SIZE_PLUS (SPI_TEST_MAX_SIZE + PAGE_SIZE) 363 364 static void spi_test_print_hex_dump(char *pre, const void *ptr, size_t len) 365 { 366 /* limit the hex_dump */ 367 if (len < 1024) { 368 print_hex_dump(KERN_INFO, pre, 369 DUMP_PREFIX_OFFSET, 16, 1, 370 ptr, len, 0); 371 return; 372 } 373 /* print head */ 374 print_hex_dump(KERN_INFO, pre, 375 DUMP_PREFIX_OFFSET, 16, 1, 376 ptr, 512, 0); 377 /* print tail */ 378 pr_info("%s truncated - continuing at offset %04zx\n", 379 pre, len - 512); 380 print_hex_dump(KERN_INFO, pre, 381 DUMP_PREFIX_OFFSET, 16, 1, 382 ptr + (len - 512), 512, 0); 383 } 384 385 static void spi_test_dump_message(struct spi_device *spi, 386 struct spi_message *msg, 387 bool dump_data) 388 { 389 struct spi_transfer *xfer; 390 int i; 391 u8 b; 392 393 dev_info(&spi->dev, " spi_msg@%pK\n", msg); 394 if (msg->status) 395 dev_info(&spi->dev, " status: %i\n", 396 msg->status); 397 dev_info(&spi->dev, " frame_length: %i\n", 398 msg->frame_length); 399 dev_info(&spi->dev, " actual_length: %i\n", 400 msg->actual_length); 401 402 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 403 dev_info(&spi->dev, " spi_transfer@%pK\n", xfer); 404 dev_info(&spi->dev, " len: %i\n", xfer->len); 405 dev_info(&spi->dev, " tx_buf: %pK\n", xfer->tx_buf); 406 if (dump_data && xfer->tx_buf) 407 spi_test_print_hex_dump(" TX: ", 408 xfer->tx_buf, 409 xfer->len); 410 411 dev_info(&spi->dev, " rx_buf: %pK\n", xfer->rx_buf); 412 if (dump_data && xfer->rx_buf) 413 spi_test_print_hex_dump(" RX: ", 414 xfer->rx_buf, 415 xfer->len); 416 /* check for unwritten test pattern on rx_buf */ 417 if (xfer->rx_buf) { 418 for (i = 0 ; i < xfer->len ; i++) { 419 b = ((u8 *)xfer->rx_buf)[xfer->len - 1 - i]; 420 if (b != SPI_TEST_PATTERN_UNWRITTEN) 421 break; 422 } 423 if (i) 424 dev_info(&spi->dev, 425 " rx_buf filled with %02x starts at offset: %i\n", 426 SPI_TEST_PATTERN_UNWRITTEN, 427 xfer->len - i); 428 } 429 } 430 } 431 432 struct rx_ranges { 433 struct list_head list; 434 u8 *start; 435 u8 *end; 436 }; 437 438 static int rx_ranges_cmp(void *priv, struct list_head *a, struct list_head *b) 439 { 440 struct rx_ranges *rx_a = list_entry(a, struct rx_ranges, list); 441 struct rx_ranges *rx_b = list_entry(b, struct rx_ranges, list); 442 443 if (rx_a->start > rx_b->start) 444 return 1; 445 if (rx_a->start < rx_b->start) 446 return -1; 447 return 0; 448 } 449 450 static int spi_check_rx_ranges(struct spi_device *spi, 451 struct spi_message *msg, 452 void *rx) 453 { 454 struct spi_transfer *xfer; 455 struct rx_ranges ranges[SPI_TEST_MAX_TRANSFERS], *r; 456 int i = 0; 457 LIST_HEAD(ranges_list); 458 u8 *addr; 459 int ret = 0; 460 461 /* loop over all transfers to fill in the rx_ranges */ 462 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 463 /* if there is no rx, then no check is needed */ 464 if (!xfer->rx_buf) 465 continue; 466 /* fill in the rx_range */ 467 if (RANGE_CHECK(xfer->rx_buf, xfer->len, 468 rx, SPI_TEST_MAX_SIZE_PLUS)) { 469 ranges[i].start = xfer->rx_buf; 470 ranges[i].end = xfer->rx_buf + xfer->len; 471 list_add(&ranges[i].list, &ranges_list); 472 i++; 473 } 474 } 475 476 /* if no ranges, then we can return and avoid the checks...*/ 477 if (!i) 478 return 0; 479 480 /* sort the list */ 481 list_sort(NULL, &ranges_list, rx_ranges_cmp); 482 483 /* and iterate over all the rx addresses */ 484 for (addr = rx; addr < (u8 *)rx + SPI_TEST_MAX_SIZE_PLUS; addr++) { 485 /* if we are the DO not write pattern, 486 * then continue with the loop... 487 */ 488 if (*addr == SPI_TEST_PATTERN_DO_NOT_WRITE) 489 continue; 490 491 /* check if we are inside a range */ 492 list_for_each_entry(r, &ranges_list, list) { 493 /* if so then set to end... */ 494 if ((addr >= r->start) && (addr < r->end)) 495 addr = r->end; 496 } 497 /* second test after a (hopefull) translation */ 498 if (*addr == SPI_TEST_PATTERN_DO_NOT_WRITE) 499 continue; 500 501 /* if still not found then something has modified too much */ 502 /* we could list the "closest" transfer here... */ 503 dev_err(&spi->dev, 504 "loopback strangeness - rx changed outside of allowed range at: %pK\n", 505 addr); 506 /* do not return, only set ret, 507 * so that we list all addresses 508 */ 509 ret = -ERANGE; 510 } 511 512 return ret; 513 } 514 515 static int spi_test_check_elapsed_time(struct spi_device *spi, 516 struct spi_test *test) 517 { 518 int i; 519 unsigned long long estimated_time = 0; 520 unsigned long long delay_usecs = 0; 521 522 for (i = 0; i < test->transfer_count; i++) { 523 struct spi_transfer *xfer = test->transfers + i; 524 unsigned long long nbits = (unsigned long long)BITS_PER_BYTE * 525 xfer->len; 526 527 delay_usecs += xfer->delay_usecs; 528 if (!xfer->speed_hz) 529 continue; 530 estimated_time += div_u64(nbits * NSEC_PER_SEC, xfer->speed_hz); 531 } 532 533 estimated_time += delay_usecs * NSEC_PER_USEC; 534 if (test->elapsed_time < estimated_time) { 535 dev_err(&spi->dev, 536 "elapsed time %lld ns is shorter than minimum estimated time %lld ns\n", 537 test->elapsed_time, estimated_time); 538 539 return -EINVAL; 540 } 541 542 return 0; 543 } 544 545 static int spi_test_check_loopback_result(struct spi_device *spi, 546 struct spi_message *msg, 547 void *tx, void *rx) 548 { 549 struct spi_transfer *xfer; 550 u8 rxb, txb; 551 size_t i; 552 int ret; 553 554 /* checks rx_buffer pattern are valid with loopback or without */ 555 if (check_ranges) { 556 ret = spi_check_rx_ranges(spi, msg, rx); 557 if (ret) 558 return ret; 559 } 560 561 /* if we run without loopback, then return now */ 562 if (!loopback) 563 return 0; 564 565 /* if applicable to transfer check that rx_buf is equal to tx_buf */ 566 list_for_each_entry(xfer, &msg->transfers, transfer_list) { 567 /* if there is no rx, then no check is needed */ 568 if (!xfer->len || !xfer->rx_buf) 569 continue; 570 /* so depending on tx_buf we need to handle things */ 571 if (xfer->tx_buf) { 572 for (i = 0; i < xfer->len; i++) { 573 txb = ((u8 *)xfer->tx_buf)[i]; 574 rxb = ((u8 *)xfer->rx_buf)[i]; 575 if (txb != rxb) 576 goto mismatch_error; 577 } 578 } else { 579 /* first byte received */ 580 txb = ((u8 *)xfer->rx_buf)[0]; 581 /* first byte may be 0 or xff */ 582 if (!((txb == 0) || (txb == 0xff))) { 583 dev_err(&spi->dev, 584 "loopback strangeness - we expect 0x00 or 0xff, but not 0x%02x\n", 585 txb); 586 return -EINVAL; 587 } 588 /* check that all bytes are identical */ 589 for (i = 1; i < xfer->len; i++) { 590 rxb = ((u8 *)xfer->rx_buf)[i]; 591 if (rxb != txb) 592 goto mismatch_error; 593 } 594 } 595 } 596 597 return 0; 598 599 mismatch_error: 600 dev_err(&spi->dev, 601 "loopback strangeness - transfer mismatch on byte %04zx - expected 0x%02x, but got 0x%02x\n", 602 i, txb, rxb); 603 604 return -EINVAL; 605 } 606 607 static int spi_test_translate(struct spi_device *spi, 608 void **ptr, size_t len, 609 void *tx, void *rx) 610 { 611 size_t off; 612 613 /* return on null */ 614 if (!*ptr) 615 return 0; 616 617 /* in the MAX_SIZE_HALF case modify the pointer */ 618 if (((size_t)*ptr) & SPI_TEST_MAX_SIZE_HALF) 619 /* move the pointer to the correct range */ 620 *ptr += (SPI_TEST_MAX_SIZE_PLUS / 2) - 621 SPI_TEST_MAX_SIZE_HALF; 622 623 /* RX range 624 * - we check against MAX_SIZE_PLUS to allow for automated alignment 625 */ 626 if (RANGE_CHECK(*ptr, len, RX(0), SPI_TEST_MAX_SIZE_PLUS)) { 627 off = *ptr - RX(0); 628 *ptr = rx + off; 629 630 return 0; 631 } 632 633 /* TX range */ 634 if (RANGE_CHECK(*ptr, len, TX(0), SPI_TEST_MAX_SIZE_PLUS)) { 635 off = *ptr - TX(0); 636 *ptr = tx + off; 637 638 return 0; 639 } 640 641 dev_err(&spi->dev, 642 "PointerRange [%pK:%pK[ not in range [%pK:%pK[ or [%pK:%pK[\n", 643 *ptr, *ptr + len, 644 RX(0), RX(SPI_TEST_MAX_SIZE), 645 TX(0), TX(SPI_TEST_MAX_SIZE)); 646 647 return -EINVAL; 648 } 649 650 static int spi_test_fill_pattern(struct spi_device *spi, 651 struct spi_test *test) 652 { 653 struct spi_transfer *xfers = test->transfers; 654 u8 *tx_buf; 655 size_t count = 0; 656 int i, j; 657 658 #ifdef __BIG_ENDIAN 659 #define GET_VALUE_BYTE(value, index, bytes) \ 660 (value >> (8 * (bytes - 1 - count % bytes))) 661 #else 662 #define GET_VALUE_BYTE(value, index, bytes) \ 663 (value >> (8 * (count % bytes))) 664 #endif 665 666 /* fill all transfers with the pattern requested */ 667 for (i = 0; i < test->transfer_count; i++) { 668 /* fill rx_buf with SPI_TEST_PATTERN_UNWRITTEN */ 669 if (xfers[i].rx_buf) 670 memset(xfers[i].rx_buf, SPI_TEST_PATTERN_UNWRITTEN, 671 xfers[i].len); 672 /* if tx_buf is NULL then skip */ 673 tx_buf = (u8 *)xfers[i].tx_buf; 674 if (!tx_buf) 675 continue; 676 /* modify all the transfers */ 677 for (j = 0; j < xfers[i].len; j++, tx_buf++, count++) { 678 /* fill tx */ 679 switch (test->fill_option) { 680 case FILL_MEMSET_8: 681 *tx_buf = test->fill_pattern; 682 break; 683 case FILL_MEMSET_16: 684 *tx_buf = GET_VALUE_BYTE(test->fill_pattern, 685 count, 2); 686 break; 687 case FILL_MEMSET_24: 688 *tx_buf = GET_VALUE_BYTE(test->fill_pattern, 689 count, 3); 690 break; 691 case FILL_MEMSET_32: 692 *tx_buf = GET_VALUE_BYTE(test->fill_pattern, 693 count, 4); 694 break; 695 case FILL_COUNT_8: 696 *tx_buf = count; 697 break; 698 case FILL_COUNT_16: 699 *tx_buf = GET_VALUE_BYTE(count, count, 2); 700 break; 701 case FILL_COUNT_24: 702 *tx_buf = GET_VALUE_BYTE(count, count, 3); 703 break; 704 case FILL_COUNT_32: 705 *tx_buf = GET_VALUE_BYTE(count, count, 4); 706 break; 707 case FILL_TRANSFER_BYTE_8: 708 *tx_buf = j; 709 break; 710 case FILL_TRANSFER_BYTE_16: 711 *tx_buf = GET_VALUE_BYTE(j, j, 2); 712 break; 713 case FILL_TRANSFER_BYTE_24: 714 *tx_buf = GET_VALUE_BYTE(j, j, 3); 715 break; 716 case FILL_TRANSFER_BYTE_32: 717 *tx_buf = GET_VALUE_BYTE(j, j, 4); 718 break; 719 case FILL_TRANSFER_NUM: 720 *tx_buf = i; 721 break; 722 default: 723 dev_err(&spi->dev, 724 "unsupported fill_option: %i\n", 725 test->fill_option); 726 return -EINVAL; 727 } 728 } 729 } 730 731 return 0; 732 } 733 734 static int _spi_test_run_iter(struct spi_device *spi, 735 struct spi_test *test, 736 void *tx, void *rx) 737 { 738 struct spi_message *msg = &test->msg; 739 struct spi_transfer *x; 740 int i, ret; 741 742 /* initialize message - zero-filled via static initialization */ 743 spi_message_init_no_memset(msg); 744 745 /* fill rx with the DO_NOT_WRITE pattern */ 746 memset(rx, SPI_TEST_PATTERN_DO_NOT_WRITE, SPI_TEST_MAX_SIZE_PLUS); 747 748 /* add the individual transfers */ 749 for (i = 0; i < test->transfer_count; i++) { 750 x = &test->transfers[i]; 751 752 /* patch the values of tx_buf */ 753 ret = spi_test_translate(spi, (void **)&x->tx_buf, x->len, 754 (void *)tx, rx); 755 if (ret) 756 return ret; 757 758 /* patch the values of rx_buf */ 759 ret = spi_test_translate(spi, &x->rx_buf, x->len, 760 (void *)tx, rx); 761 if (ret) 762 return ret; 763 764 /* and add it to the list */ 765 spi_message_add_tail(x, msg); 766 } 767 768 /* fill in the transfer buffers with pattern */ 769 ret = spi_test_fill_pattern(spi, test); 770 if (ret) 771 return ret; 772 773 /* and execute */ 774 if (test->execute_msg) 775 ret = test->execute_msg(spi, test, tx, rx); 776 else 777 ret = spi_test_execute_msg(spi, test, tx, rx); 778 779 /* handle result */ 780 if (ret == test->expected_return) 781 return 0; 782 783 dev_err(&spi->dev, 784 "test failed - test returned %i, but we expect %i\n", 785 ret, test->expected_return); 786 787 if (ret) 788 return ret; 789 790 /* if it is 0, as we expected something else, 791 * then return something special 792 */ 793 return -EFAULT; 794 } 795 796 static int spi_test_run_iter(struct spi_device *spi, 797 const struct spi_test *testtemplate, 798 void *tx, void *rx, 799 size_t len, 800 size_t tx_off, 801 size_t rx_off 802 ) 803 { 804 struct spi_test test; 805 int i, tx_count, rx_count; 806 807 /* copy the test template to test */ 808 memcpy(&test, testtemplate, sizeof(test)); 809 810 /* if iterate_transfer_mask is not set, 811 * then set it to first transfer only 812 */ 813 if (!(test.iterate_transfer_mask & (BIT(test.transfer_count) - 1))) 814 test.iterate_transfer_mask = 1; 815 816 /* count number of transfers with tx/rx_buf != NULL */ 817 rx_count = tx_count = 0; 818 for (i = 0; i < test.transfer_count; i++) { 819 if (test.transfers[i].tx_buf) 820 tx_count++; 821 if (test.transfers[i].rx_buf) 822 rx_count++; 823 } 824 825 /* in some iteration cases warn and exit early, 826 * as there is nothing to do, that has not been tested already... 827 */ 828 if (tx_off && (!tx_count)) { 829 dev_warn_once(&spi->dev, 830 "%s: iterate_tx_off configured with tx_buf==NULL - ignoring\n", 831 test.description); 832 return 0; 833 } 834 if (rx_off && (!rx_count)) { 835 dev_warn_once(&spi->dev, 836 "%s: iterate_rx_off configured with rx_buf==NULL - ignoring\n", 837 test.description); 838 return 0; 839 } 840 841 /* write out info */ 842 if (!(len || tx_off || rx_off)) { 843 dev_info(&spi->dev, "Running test %s\n", test.description); 844 } else { 845 dev_info(&spi->dev, 846 " with iteration values: len = %zu, tx_off = %zu, rx_off = %zu\n", 847 len, tx_off, rx_off); 848 } 849 850 /* update in the values from iteration values */ 851 for (i = 0; i < test.transfer_count; i++) { 852 /* only when bit in transfer mask is set */ 853 if (!(test.iterate_transfer_mask & BIT(i))) 854 continue; 855 test.transfers[i].len = len; 856 if (test.transfers[i].tx_buf) 857 test.transfers[i].tx_buf += tx_off; 858 if (test.transfers[i].tx_buf) 859 test.transfers[i].rx_buf += rx_off; 860 } 861 862 /* and execute */ 863 return _spi_test_run_iter(spi, &test, tx, rx); 864 } 865 866 /** 867 * spi_test_execute_msg - default implementation to run a test 868 * 869 * spi: @spi_device on which to run the @spi_message 870 * test: the test to execute, which already contains @msg 871 * tx: the tx buffer allocated for the test sequence 872 * rx: the rx buffer allocated for the test sequence 873 * 874 * Returns: error code of spi_sync as well as basic error checking 875 */ 876 int spi_test_execute_msg(struct spi_device *spi, struct spi_test *test, 877 void *tx, void *rx) 878 { 879 struct spi_message *msg = &test->msg; 880 int ret = 0; 881 int i; 882 883 /* only if we do not simulate */ 884 if (!simulate_only) { 885 ktime_t start; 886 887 /* dump the complete message before and after the transfer */ 888 if (dump_messages == 3) 889 spi_test_dump_message(spi, msg, true); 890 891 start = ktime_get(); 892 /* run spi message */ 893 ret = spi_sync(spi, msg); 894 test->elapsed_time = ktime_to_ns(ktime_sub(ktime_get(), start)); 895 if (ret == -ETIMEDOUT) { 896 dev_info(&spi->dev, 897 "spi-message timed out - rerunning...\n"); 898 /* rerun after a few explicit schedules */ 899 for (i = 0; i < 16; i++) 900 schedule(); 901 ret = spi_sync(spi, msg); 902 } 903 if (ret) { 904 dev_err(&spi->dev, 905 "Failed to execute spi_message: %i\n", 906 ret); 907 goto exit; 908 } 909 910 /* do some extra error checks */ 911 if (msg->frame_length != msg->actual_length) { 912 dev_err(&spi->dev, 913 "actual length differs from expected\n"); 914 ret = -EIO; 915 goto exit; 916 } 917 918 /* run rx-buffer tests */ 919 ret = spi_test_check_loopback_result(spi, msg, tx, rx); 920 if (ret) 921 goto exit; 922 923 ret = spi_test_check_elapsed_time(spi, test); 924 } 925 926 /* if requested or on error dump message (including data) */ 927 exit: 928 if (dump_messages || ret) 929 spi_test_dump_message(spi, msg, 930 (dump_messages >= 2) || (ret)); 931 932 return ret; 933 } 934 EXPORT_SYMBOL_GPL(spi_test_execute_msg); 935 936 /** 937 * spi_test_run_test - run an individual spi_test 938 * including all the relevant iterations on: 939 * length and buffer alignment 940 * 941 * spi: the spi_device to send the messages to 942 * test: the test which we need to execute 943 * tx: the tx buffer allocated for the test sequence 944 * rx: the rx buffer allocated for the test sequence 945 * 946 * Returns: status code of spi_sync or other failures 947 */ 948 949 int spi_test_run_test(struct spi_device *spi, const struct spi_test *test, 950 void *tx, void *rx) 951 { 952 int idx_len; 953 size_t len; 954 size_t tx_align, rx_align; 955 int ret; 956 957 /* test for transfer limits */ 958 if (test->transfer_count >= SPI_TEST_MAX_TRANSFERS) { 959 dev_err(&spi->dev, 960 "%s: Exceeded max number of transfers with %i\n", 961 test->description, test->transfer_count); 962 return -E2BIG; 963 } 964 965 /* setting up some values in spi_message 966 * based on some settings in spi_master 967 * some of this can also get done in the run() method 968 */ 969 970 /* iterate over all the iterable values using macros 971 * (to make it a bit more readable... 972 */ 973 #define FOR_EACH_ALIGNMENT(var) \ 974 for (var = 0; \ 975 var < (test->iterate_##var ? \ 976 (spi->master->dma_alignment ? \ 977 spi->master->dma_alignment : \ 978 test->iterate_##var) : \ 979 1); \ 980 var++) 981 982 for (idx_len = 0; idx_len < SPI_TEST_MAX_ITERATE && 983 (len = test->iterate_len[idx_len]) != -1; idx_len++) { 984 FOR_EACH_ALIGNMENT(tx_align) { 985 FOR_EACH_ALIGNMENT(rx_align) { 986 /* and run the iteration */ 987 ret = spi_test_run_iter(spi, test, 988 tx, rx, 989 len, 990 tx_align, 991 rx_align); 992 if (ret) 993 return ret; 994 } 995 } 996 } 997 998 return 0; 999 } 1000 EXPORT_SYMBOL_GPL(spi_test_run_test); 1001 1002 /** 1003 * spi_test_run_tests - run an array of spi_messages tests 1004 * @spi: the spi device on which to run the tests 1005 * @tests: NULL-terminated array of @spi_test 1006 * 1007 * Returns: status errors as per @spi_test_run_test() 1008 */ 1009 1010 int spi_test_run_tests(struct spi_device *spi, 1011 struct spi_test *tests) 1012 { 1013 char *rx = NULL, *tx = NULL; 1014 int ret = 0, count = 0; 1015 struct spi_test *test; 1016 1017 /* allocate rx/tx buffers of 128kB size without devm 1018 * in the hope that is on a page boundary 1019 */ 1020 if (use_vmalloc) 1021 rx = vmalloc(SPI_TEST_MAX_SIZE_PLUS); 1022 else 1023 rx = kzalloc(SPI_TEST_MAX_SIZE_PLUS, GFP_KERNEL); 1024 if (!rx) 1025 return -ENOMEM; 1026 1027 1028 if (use_vmalloc) 1029 tx = vmalloc(SPI_TEST_MAX_SIZE_PLUS); 1030 else 1031 tx = kzalloc(SPI_TEST_MAX_SIZE_PLUS, GFP_KERNEL); 1032 if (!tx) { 1033 ret = -ENOMEM; 1034 goto err_tx; 1035 } 1036 1037 /* now run the individual tests in the table */ 1038 for (test = tests, count = 0; test->description[0]; 1039 test++, count++) { 1040 /* only run test if requested */ 1041 if ((run_only_test > -1) && (count != run_only_test)) 1042 continue; 1043 /* run custom implementation */ 1044 if (test->run_test) 1045 ret = test->run_test(spi, test, tx, rx); 1046 else 1047 ret = spi_test_run_test(spi, test, tx, rx); 1048 if (ret) 1049 goto out; 1050 /* add some delays so that we can easily 1051 * detect the individual tests when using a logic analyzer 1052 * we also add scheduling to avoid potential spi_timeouts... 1053 */ 1054 mdelay(100); 1055 schedule(); 1056 } 1057 1058 out: 1059 kvfree(tx); 1060 err_tx: 1061 kvfree(rx); 1062 return ret; 1063 } 1064 EXPORT_SYMBOL_GPL(spi_test_run_tests); 1065