1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
3 * Copyright (C) 2019, STMicroelectronics - All Rights Reserved
8 #include <linux/log2.h>
9 #include "stm32mp1_tests.h"
11 #define ADDR_INVALID 0xFFFFFFFF
13 DECLARE_GLOBAL_DATA_PTR;
15 static int get_bufsize(char *string, int argc, char *argv[], int arg_nb,
16 size_t *bufsize, size_t default_size)
21 if (strict_strtoul(argv[arg_nb], 0, &value) < 0) {
22 sprintf(string, "invalid %d parameter %s",
23 arg_nb, argv[arg_nb]);
26 if (value > STM32_DDR_SIZE || value == 0) {
27 sprintf(string, "invalid size %s", argv[arg_nb]);
31 sprintf(string, "unaligned size %s",
37 if (default_size != STM32_DDR_SIZE)
38 *bufsize = default_size;
40 *bufsize = get_ram_size((long *)STM32_DDR_BASE,
46 static int get_nb_loop(char *string, int argc, char *argv[], int arg_nb,
47 u32 *nb_loop, u32 default_nb_loop)
52 if (strict_strtoul(argv[arg_nb], 0, &value) < 0) {
53 sprintf(string, "invalid %d parameter %s",
54 arg_nb, argv[arg_nb]);
58 printf("WARNING: infinite loop requested\n");
61 *nb_loop = default_nb_loop;
67 static int get_addr(char *string, int argc, char *argv[], int arg_nb,
73 if (strict_strtoul(argv[arg_nb], 16, &value) < 0) {
74 sprintf(string, "invalid %d parameter %s",
75 arg_nb, argv[arg_nb]);
78 if (value < STM32_DDR_BASE) {
79 sprintf(string, "too low address %s", argv[arg_nb]);
82 if (value & 0x3 && value != ADDR_INVALID) {
83 sprintf(string, "unaligned address %s",
89 *addr = STM32_DDR_BASE;
95 static int get_pattern(char *string, int argc, char *argv[], int arg_nb,
96 u32 *pattern, u32 default_pattern)
101 if (strict_strtoul(argv[arg_nb], 16, &value) < 0) {
102 sprintf(string, "invalid %d parameter %s",
103 arg_nb, argv[arg_nb]);
108 *pattern = default_pattern;
114 static u32 check_addr(u32 addr, u32 value)
116 u32 data = readl(addr);
119 printf("0x%08x: 0x%08x <=> 0x%08x", addr, data, value);
121 printf("(2nd read: 0x%08x)", data);
123 printf("- read error");
125 printf("- write error");
132 static int progress(u32 offset)
134 if (!(offset & 0xFFFFFF)) {
137 printf("\ntest interrupted!\n");
144 static int test_loop_end(u32 *loop, u32 nb_loop, u32 progress)
147 if (nb_loop && *loop >= nb_loop)
149 if ((*loop) % progress)
151 /* allow to interrupt the test only for progress step */
153 printf("test interrupted!\n");
156 printf("loop #%d\n", *loop);
160 /**********************************************************************
162 * Function: memTestDataBus()
164 * Description: Test the data bus wiring in a memory region by
165 * performing a walking 1's test at a fixed address
166 * within that region. The address is selected
171 * Returns: 0 if the test succeeds.
172 * A non-zero result is the first pattern that failed.
174 **********************************************************************/
175 static u32 databus(u32 *address)
180 /* Perform a walking 1's test at the given address. */
181 for (pattern = 1; pattern != 0; pattern <<= 1) {
182 /* Write the test pattern. */
183 writel(pattern, address);
185 /* Read it back (immediately is okay for this test). */
186 read_value = readl(address);
187 debug("%x: %x <=> %x\n",
188 (u32)address, read_value, pattern);
190 if (read_value != pattern)
197 /**********************************************************************
199 * Function: memTestAddressBus()
201 * Description: Test the address bus wiring in a memory region by
202 * performing a walking 1's test on the relevant bits
203 * of the address and checking for aliasing. This test
204 * will find single-bit address failures such as stuck
205 * -high, stuck-low, and shorted pins. The base address
206 * and size of the region are selected by the caller.
208 * Notes: For best results, the selected base address should
209 * have enough LSB 0's to guarantee single address bit
210 * changes. For example, to test a 64-Kbyte region,
211 * select a base address on a 64-Kbyte boundary. Also,
212 * select the region size as a power-of-two--if at all
215 * Returns: NULL if the test succeeds.
216 * A non-zero result is the first address at which an
217 * aliasing problem was uncovered. By examining the
218 * contents of memory, it may be possible to gather
219 * additional information about the problem.
221 **********************************************************************/
222 static u32 *addressbus(u32 *address, u32 nb_bytes)
224 u32 mask = (nb_bytes / sizeof(u32) - 1);
229 u32 pattern = 0xAAAAAAAA;
230 u32 antipattern = 0x55555555;
232 /* Write the default pattern at each of the power-of-two offsets. */
233 for (offset = 1; (offset & mask) != 0; offset <<= 1)
234 writel(pattern, &address[offset]);
236 /* Check for address bits stuck high. */
238 writel(antipattern, &address[test_offset]);
240 for (offset = 1; (offset & mask) != 0; offset <<= 1) {
241 read_value = readl(&address[offset]);
242 debug("%x: %x <=> %x\n",
243 (u32)&address[offset], read_value, pattern);
244 if (read_value != pattern)
245 return &address[offset];
248 writel(pattern, &address[test_offset]);
250 /* Check for address bits stuck low or shorted. */
251 for (test_offset = 1; (test_offset & mask) != 0; test_offset <<= 1) {
252 writel(antipattern, &address[test_offset]);
253 if (readl(&address[0]) != pattern)
254 return &address[test_offset];
256 for (offset = 1; (offset & mask) != 0; offset <<= 1) {
257 if (readl(&address[offset]) != pattern &&
258 offset != test_offset)
259 return &address[test_offset];
261 writel(pattern, &address[test_offset]);
267 /**********************************************************************
269 * Function: memTestDevice()
271 * Description: Test the integrity of a physical memory device by
272 * performing an increment/decrement test over the
273 * entire region. In the process every storage bit
274 * in the device is tested as a zero and a one. The
275 * base address and the size of the region are
276 * selected by the caller.
280 * Returns: NULL if the test succeeds.
282 * A non-zero result is the first address at which an
283 * incorrect value was read back. By examining the
284 * contents of memory, it may be possible to gather
285 * additional information about the problem.
287 **********************************************************************/
288 static u32 *memdevice(u32 *address, u32 nb_bytes)
291 u32 nb_words = nb_bytes / sizeof(u32);
296 puts("Fill with pattern");
297 /* Fill memory with a known pattern. */
298 for (pattern = 1, offset = 0; offset < nb_words; pattern++, offset++) {
299 writel(pattern, &address[offset]);
300 if (progress(offset))
304 puts("\nCheck and invert pattern");
305 /* Check each location and invert it for the second pass. */
306 for (pattern = 1, offset = 0; offset < nb_words; pattern++, offset++) {
307 if (readl(&address[offset]) != pattern)
308 return &address[offset];
310 antipattern = ~pattern;
311 writel(antipattern, &address[offset]);
312 if (progress(offset))
316 puts("\nCheck inverted pattern");
317 /* Check each location for the inverted pattern and zero it. */
318 for (pattern = 1, offset = 0; offset < nb_words; pattern++, offset++) {
319 antipattern = ~pattern;
320 if (readl(&address[offset]) != antipattern)
321 return &address[offset];
322 if (progress(offset))
330 static enum test_result databuswalk0(struct stm32mp1_ddrctl *ctl,
331 struct stm32mp1_ddrphy *phy,
332 char *string, int argc, char *argv[])
335 u32 loop = 0, nb_loop;
340 if (get_nb_loop(string, argc, argv, 0, &nb_loop, 100))
342 if (get_addr(string, argc, argv, 1, &addr))
345 printf("running %d loops at 0x%x\n", nb_loop, addr);
347 for (i = 0; i < 32; i++)
348 writel(~(1 << i), addr + 4 * i);
349 for (i = 0; i < 32; i++) {
350 data = readl(addr + 4 * i);
351 if (~(1 << i) != data) {
353 debug("%x: error %x expected %x => error:%x\n",
354 addr + 4 * i, data, ~(1 << i), error);
357 if (test_loop_end(&loop, nb_loop, 1000))
359 for (i = 0; i < 32; i++)
360 writel(0, addr + 4 * i);
363 sprintf(string, "loop %d: error for bits 0x%x",
367 sprintf(string, "no error for %d loops", loop);
371 static enum test_result databuswalk1(struct stm32mp1_ddrctl *ctl,
372 struct stm32mp1_ddrphy *phy,
373 char *string, int argc, char *argv[])
376 u32 loop = 0, nb_loop;
381 if (get_nb_loop(string, argc, argv, 0, &nb_loop, 100))
383 if (get_addr(string, argc, argv, 1, &addr))
385 printf("running %d loops at 0x%x\n", nb_loop, addr);
387 for (i = 0; i < 32; i++)
388 writel(1 << i, addr + 4 * i);
389 for (i = 0; i < 32; i++) {
390 data = readl(addr + 4 * i);
391 if ((1 << i) != data) {
393 debug("%x: error %x expected %x => error:%x\n",
394 addr + 4 * i, data, (1 << i), error);
397 if (test_loop_end(&loop, nb_loop, 1000))
399 for (i = 0; i < 32; i++)
400 writel(0, addr + 4 * i);
403 sprintf(string, "loop %d: error for bits 0x%x",
407 sprintf(string, "no error for %d loops", loop);
411 static enum test_result test_databus(struct stm32mp1_ddrctl *ctl,
412 struct stm32mp1_ddrphy *phy,
413 char *string, int argc, char *argv[])
418 if (get_addr(string, argc, argv, 0, &addr))
420 error = databus((u32 *)addr);
422 sprintf(string, "0x%x: error for bits 0x%x",
426 sprintf(string, "address 0x%x", addr);
430 static enum test_result test_addressbus(struct stm32mp1_ddrctl *ctl,
431 struct stm32mp1_ddrphy *phy,
432 char *string, int argc, char *argv[])
438 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
440 if (!is_power_of_2(bufsize)) {
441 sprintf(string, "size 0x%x is not a power of 2",
445 if (get_addr(string, argc, argv, 1, &addr))
448 error = (u32)addressbus((u32 *)addr, bufsize);
450 sprintf(string, "0x%x: error for address 0x%x",
454 sprintf(string, "address 0x%x, size 0x%x",
459 static enum test_result test_memdevice(struct stm32mp1_ddrctl *ctl,
460 struct stm32mp1_ddrphy *phy,
461 char *string, int argc, char *argv[])
467 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
469 if (get_addr(string, argc, argv, 1, &addr))
471 error = (u32)memdevice((u32 *)addr, (unsigned long)bufsize);
473 sprintf(string, "0x%x: error for address 0x%x",
477 sprintf(string, "address 0x%x, size 0x%x",
482 /**********************************************************************
486 * Description: Test the Simultaneous Switching Output.
487 * Verifies succes sive reads and writes to the same memory word,
488 * holding one bit constant while toggling all other data bits
490 * => stress the data bus over an address range
492 * The CPU writes to each address in the given range.
493 * For each bit, first the CPU holds the bit at 1 while
494 * toggling the other bits, and then the CPU holds the bit at 0
495 * while toggling the other bits.
496 * After each write, the CPU reads the address that was written
497 * to verify that it contains the correct data
499 **********************************************************************/
500 static enum test_result test_sso(struct stm32mp1_ddrctl *ctl,
501 struct stm32mp1_ddrphy *phy,
502 char *string, int argc, char *argv[])
505 u32 addr, bufsize, remaining, offset;
509 if (get_bufsize(string, argc, argv, 0, &bufsize, 4))
511 if (get_addr(string, argc, argv, 1, &addr))
514 printf("running sso at 0x%x length 0x%x", addr, bufsize);
518 for (i = 0; i < 32; i++) {
520 for (j = 0; j < 6; j++) {
538 writel(data, offset);
539 error = check_addr(offset, data);
546 if (progress(offset << 7))
553 sprintf(string, "error for pattern 0x%x @0x%x",
557 sprintf(string, "no error for sso at 0x%x length 0x%x", addr, bufsize);
561 /**********************************************************************
565 * Description: Verifies r/w with pseudo-ramdom value on one region
566 * + write the region (individual access)
567 * + memcopy to the 2nd region (try to use burst)
568 * + verify the 2 regions
570 **********************************************************************/
571 static enum test_result test_random(struct stm32mp1_ddrctl *ctl,
572 struct stm32mp1_ddrphy *phy,
573 char *string, int argc, char *argv[])
575 u32 addr, offset, value = 0;
577 u32 loop = 0, nb_loop;
581 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
583 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
585 if (get_addr(string, argc, argv, 2, &addr))
588 printf("running %d loops at 0x%x\n", nb_loop, addr);
591 for (offset = addr; offset < addr + bufsize; offset += 4)
592 writel(rand(), offset);
594 memcpy((void *)addr + bufsize, (void *)addr, bufsize);
597 for (offset = addr; offset < addr + 2 * bufsize; offset += 4) {
598 if (offset == (addr + bufsize))
601 error = check_addr(offset, value);
604 if (progress(offset))
607 if (test_loop_end(&loop, nb_loop, 100))
613 "loop %d: error for address 0x%x: 0x%x expected 0x%x",
614 loop, offset, readl(offset), value);
617 sprintf(string, "no error for %d loops, size 0x%x",
622 /**********************************************************************
626 * Description: Verifies r/w while forcing switching of all data bus lines.
627 * optimised 4 iteration write/read/write/read cycles...
628 * for pattern and inversed pattern
630 **********************************************************************/
631 void do_noise(u32 addr, u32 pattern, u32 *result)
633 __asm__("push {R0-R11}");
634 __asm__("mov r0, %0" : : "r" (addr));
635 __asm__("mov r1, %0" : : "r" (pattern));
636 __asm__("mov r11, %0" : : "r" (result));
638 __asm__("mvn r2, r1");
640 __asm__("str r1, [r0]");
641 __asm__("ldr r3, [r0]");
642 __asm__("str r2, [r0]");
643 __asm__("ldr r4, [r0]");
645 __asm__("str r1, [r0]");
646 __asm__("ldr r5, [r0]");
647 __asm__("str r2, [r0]");
648 __asm__("ldr r6, [r0]");
650 __asm__("str r1, [r0]");
651 __asm__("ldr r7, [r0]");
652 __asm__("str r2, [r0]");
653 __asm__("ldr r8, [r0]");
655 __asm__("str r1, [r0]");
656 __asm__("ldr r9, [r0]");
657 __asm__("str r2, [r0]");
658 __asm__("ldr r10, [r0]");
660 __asm__("stmia R11!, {R3-R10}");
662 __asm__("pop {R0-R11}");
665 static enum test_result test_noise(struct stm32mp1_ddrctl *ctl,
666 struct stm32mp1_ddrphy *phy,
667 char *string, int argc, char *argv[])
672 enum test_result res = TEST_PASSED;
674 if (get_pattern(string, argc, argv, 0, &pattern, 0xFFFFFFFF))
676 if (get_addr(string, argc, argv, 1, &addr))
679 printf("running noise for 0x%x at 0x%x\n", pattern, addr);
681 do_noise(addr, pattern, result);
683 for (i = 0; i < 0x8;) {
684 if (check_addr((u32)&result[i++], pattern))
686 if (check_addr((u32)&result[i++], ~pattern))
693 /**********************************************************************
695 * Function: noise_burst
697 * Description: Verifies r/w while forcing switching of all data bus lines.
698 * optimised write loop witrh store multiple to use burst
699 * for pattern and inversed pattern
701 **********************************************************************/
702 void do_noise_burst(u32 addr, u32 pattern, size_t bufsize)
704 __asm__("push {R0-R9}");
705 __asm__("mov r0, %0" : : "r" (addr));
706 __asm__("mov r1, %0" : : "r" (pattern));
707 __asm__("mov r9, %0" : : "r" (bufsize));
709 __asm__("mvn r2, r1");
710 __asm__("mov r3, r1");
711 __asm__("mov r4, r2");
712 __asm__("mov r5, r1");
713 __asm__("mov r6, r2");
714 __asm__("mov r7, r1");
715 __asm__("mov r8, r2");
718 __asm__("stmia R0!, {R1-R8}");
719 __asm__("stmia R0!, {R1-R8}");
720 __asm__("stmia R0!, {R1-R8}");
721 __asm__("stmia R0!, {R1-R8}");
722 __asm__("subs r9, r9, #128");
723 __asm__("bge loop1");
724 __asm__("pop {R0-R9}");
727 /* chunk size enough to allow interruption with Ctrl-C*/
728 #define CHUNK_SIZE 0x8000000
729 static enum test_result test_noise_burst(struct stm32mp1_ddrctl *ctl,
730 struct stm32mp1_ddrphy *phy,
731 char *string, int argc, char *argv[])
733 u32 addr, offset, pattern;
734 size_t bufsize, remaining, size;
736 enum test_result res = TEST_PASSED;
738 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
740 if (get_pattern(string, argc, argv, 1, &pattern, 0xFFFFFFFF))
742 if (get_addr(string, argc, argv, 2, &addr))
745 printf("running noise burst for 0x%x at 0x%x + 0x%x",
746 pattern, addr, bufsize);
752 if (remaining < size)
754 do_noise_burst(offset, pattern, size);
757 if (progress(offset)) {
762 puts("\ncheck buffer");
763 for (i = 0; i < bufsize;) {
764 if (check_addr(addr + i, pattern))
767 if (check_addr(addr + i, ~pattern))
780 /**********************************************************************
782 * Function: pattern test
784 * Description: optimized loop for read/write pattern (array of 8 u32)
786 **********************************************************************/
787 #define PATTERN_SIZE 8
788 static enum test_result test_loop(const u32 *pattern, u32 *address,
793 enum test_result res = TEST_PASSED;
794 u32 *offset, testsize, remaining;
799 testsize = bufsize > 0x1000000 ? 0x1000000 : bufsize;
801 __asm__("push {R0-R10}");
802 __asm__("mov r0, %0" : : "r" (pattern));
803 __asm__("mov r1, %0" : : "r" (offset));
804 __asm__("mov r2, %0" : : "r" (testsize));
805 __asm__("ldmia r0!, {R3-R10}");
808 __asm__("stmia r1!, {R3-R10}");
809 __asm__("stmia r1!, {R3-R10}");
810 __asm__("stmia r1!, {R3-R10}");
811 __asm__("stmia r1!, {R3-R10}");
812 __asm__("subs r2, r2, #8");
813 __asm__("bge loop2");
814 __asm__("pop {R0-R10}");
817 remaining -= testsize;
818 if (progress((u32)offset)) {
824 puts("\ncheck buffer");
825 for (i = 0; i < bufsize; i += PATTERN_SIZE * 4) {
826 for (j = 0; j < PATTERN_SIZE; j++, address++)
827 if (check_addr((u32)address, pattern[j])) {
842 const u32 pattern_div1_x16[PATTERN_SIZE] = {
843 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF,
844 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF
847 const u32 pattern_div2_x16[PATTERN_SIZE] = {
848 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0x00000000,
849 0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0x00000000
852 const u32 pattern_div4_x16[PATTERN_SIZE] = {
853 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000,
854 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000
857 const u32 pattern_div4_x32[PATTERN_SIZE] = {
858 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
859 0x00000000, 0x00000000, 0x00000000, 0x00000000
862 const u32 pattern_mostly_zero_x16[PATTERN_SIZE] = {
863 0x00000000, 0x00000000, 0x00000000, 0x0000FFFF,
864 0x00000000, 0x00000000, 0x00000000, 0x00000000
867 const u32 pattern_mostly_zero_x32[PATTERN_SIZE] = {
868 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF,
869 0x00000000, 0x00000000, 0x00000000, 0x00000000
872 const u32 pattern_mostly_one_x16[PATTERN_SIZE] = {
873 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000FFFF,
874 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
877 const u32 pattern_mostly_one_x32[PATTERN_SIZE] = {
878 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000,
879 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
883 static enum test_result test_freq_pattern(struct stm32mp1_ddrctl *ctl,
884 struct stm32mp1_ddrphy *phy,
885 char *string, int argc, char *argv[])
887 const u32 * const patterns_x16[NB_PATTERN] = {
891 pattern_mostly_zero_x16,
892 pattern_mostly_one_x16,
894 const u32 * const patterns_x32[NB_PATTERN] = {
898 pattern_mostly_zero_x32,
899 pattern_mostly_one_x32
901 const char *patterns_comments[NB_PATTERN] = {
902 "switching at frequency F/1",
903 "switching at frequency F/2",
904 "switching at frequency F/4",
909 enum test_result res = TEST_PASSED, pattern_res;
911 const u32 **patterns;
914 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
917 switch (readl(&ctl->mstr) & DDRCTRL_MSTR_DATA_BUS_WIDTH_MASK) {
918 case DDRCTRL_MSTR_DATA_BUS_WIDTH_HALF:
919 case DDRCTRL_MSTR_DATA_BUS_WIDTH_QUARTER:
927 printf("running test pattern at 0x%08x length 0x%x width = %d\n",
928 STM32_DDR_BASE, bufsize, bus_width);
931 (const u32 **)(bus_width == 16 ? patterns_x16 : patterns_x32);
933 for (i = 0; i < NB_PATTERN; i++) {
934 printf("test data pattern %s:", patterns_comments[i]);
935 pattern_res = test_loop(patterns[i], (u32 *)STM32_DDR_BASE,
937 if (pattern_res != TEST_PASSED) {
947 /**********************************************************************
949 * Function: pattern test with size
951 * Description: loop for write pattern
953 **********************************************************************/
955 static enum test_result test_loop_size(const u32 *pattern, u32 size,
960 enum test_result res = TEST_PASSED;
963 for (i = 0; i < bufsize; i += size * 4) {
964 for (j = 0; j < size ; j++, p++)
972 puts("\ncheck buffer");
974 for (i = 0; i < bufsize; i += size * 4) {
975 for (j = 0; j < size; j++, p++)
976 if (check_addr((u32)p, pattern[j])) {
991 static enum test_result test_checkboard(struct stm32mp1_ddrctl *ctl,
992 struct stm32mp1_ddrphy *phy,
993 char *string, int argc, char *argv[])
995 enum test_result res = TEST_PASSED;
996 u32 bufsize, nb_loop, loop = 0, addr;
999 u32 checkboard[2] = {0x55555555, 0xAAAAAAAA};
1001 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1003 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1005 if (get_addr(string, argc, argv, 2, &addr))
1008 printf("running %d loops at 0x%08x length 0x%x\n",
1009 nb_loop, addr, bufsize);
1011 for (i = 0; i < 2; i++) {
1012 res = test_loop_size(checkboard, 2, (u32 *)addr,
1016 checkboard[0] = ~checkboard[0];
1017 checkboard[1] = ~checkboard[1];
1019 if (test_loop_end(&loop, nb_loop, 1))
1022 sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1023 loop, addr, bufsize);
1028 static enum test_result test_blockseq(struct stm32mp1_ddrctl *ctl,
1029 struct stm32mp1_ddrphy *phy,
1030 char *string, int argc, char *argv[])
1032 enum test_result res = TEST_PASSED;
1033 u32 bufsize, nb_loop, loop = 0, addr, value;
1036 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1038 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1040 if (get_addr(string, argc, argv, 2, &addr))
1043 printf("running %d loops at 0x%08x length 0x%x\n",
1044 nb_loop, addr, bufsize);
1046 for (i = 0; i < 256; i++) {
1047 value = i | i << 8 | i << 16 | i << 24;
1048 printf("pattern = %08x", value);
1049 res = test_loop_size(&value, 1, (u32 *)addr, bufsize);
1050 if (res != TEST_PASSED)
1053 if (test_loop_end(&loop, nb_loop, 1))
1056 sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1057 loop, addr, bufsize);
1062 static enum test_result test_walkbit0(struct stm32mp1_ddrctl *ctl,
1063 struct stm32mp1_ddrphy *phy,
1064 char *string, int argc, char *argv[])
1066 enum test_result res = TEST_PASSED;
1067 u32 bufsize, nb_loop, loop = 0, addr, value;
1070 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1072 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1074 if (get_addr(string, argc, argv, 2, &addr))
1077 printf("running %d loops at 0x%08x length 0x%x\n",
1078 nb_loop, addr, bufsize);
1080 for (i = 0; i < 64; i++) {
1084 value = 1 << (63 - i);
1086 printf("pattern = %08x", value);
1087 res = test_loop_size(&value, 1, (u32 *)addr, bufsize);
1088 if (res != TEST_PASSED)
1091 if (test_loop_end(&loop, nb_loop, 1))
1094 sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1095 loop, addr, bufsize);
1100 static enum test_result test_walkbit1(struct stm32mp1_ddrctl *ctl,
1101 struct stm32mp1_ddrphy *phy,
1102 char *string, int argc, char *argv[])
1104 enum test_result res = TEST_PASSED;
1105 u32 bufsize, nb_loop, loop = 0, addr, value;
1108 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1110 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1112 if (get_addr(string, argc, argv, 2, &addr))
1115 printf("running %d loops at 0x%08x length 0x%x\n",
1116 nb_loop, addr, bufsize);
1118 for (i = 0; i < 64; i++) {
1122 value = ~(1 << (63 - i));
1124 printf("pattern = %08x", value);
1125 res = test_loop_size(&value, 1, (u32 *)addr, bufsize);
1126 if (res != TEST_PASSED)
1129 if (test_loop_end(&loop, nb_loop, 1))
1132 sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1133 loop, addr, bufsize);
1139 * try to catch bad bits which are dependent on the current values of
1140 * surrounding bits in either the same word32
1142 static enum test_result test_bitspread(struct stm32mp1_ddrctl *ctl,
1143 struct stm32mp1_ddrphy *phy,
1144 char *string, int argc, char *argv[])
1146 enum test_result res = TEST_PASSED;
1147 u32 bufsize, nb_loop, loop = 0, addr, bitspread[4];
1150 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1152 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1154 if (get_addr(string, argc, argv, 2, &addr))
1157 printf("running %d loops at 0x%08x length 0x%x\n",
1158 nb_loop, addr, bufsize);
1160 for (i = 1; i < 32; i++) {
1161 for (j = 0; j < i; j++) {
1163 bitspread[0] = (1 << i) | (1 << j);
1165 bitspread[0] = (1 << (63 - i)) |
1167 bitspread[1] = bitspread[0];
1168 bitspread[2] = ~bitspread[0];
1169 bitspread[3] = ~bitspread[0];
1170 printf("pattern = %08x", bitspread[0]);
1172 res = test_loop_size(bitspread, 4, (u32 *)addr,
1174 if (res != TEST_PASSED)
1178 if (test_loop_end(&loop, nb_loop, 1))
1181 sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1182 loop, addr, bufsize);
1187 static enum test_result test_bitflip(struct stm32mp1_ddrctl *ctl,
1188 struct stm32mp1_ddrphy *phy,
1189 char *string, int argc, char *argv[])
1191 enum test_result res = TEST_PASSED;
1192 u32 bufsize, nb_loop, loop = 0, addr;
1197 if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1199 if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1201 if (get_addr(string, argc, argv, 2, &addr))
1204 printf("running %d loops at 0x%08x length 0x%x\n",
1205 nb_loop, addr, bufsize);
1207 for (i = 0; i < 32; i++) {
1208 bitflip[0] = 1 << i;
1209 bitflip[1] = bitflip[0];
1210 bitflip[2] = ~bitflip[0];
1211 bitflip[3] = bitflip[2];
1212 printf("pattern = %08x", bitflip[0]);
1214 res = test_loop_size(bitflip, 4, (u32 *)addr, bufsize);
1215 if (res != TEST_PASSED)
1218 if (test_loop_end(&loop, nb_loop, 1))
1221 sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1222 loop, addr, bufsize);
1227 /**********************************************************************
1229 * Function: infinite read access to DDR
1231 * Description: continuous read the same pattern at the same address
1233 **********************************************************************/
1234 static enum test_result test_read(struct stm32mp1_ddrctl *ctl,
1235 struct stm32mp1_ddrphy *phy,
1236 char *string, int argc, char *argv[])
1241 bool random = false;
1243 if (get_addr(string, argc, argv, 0, (u32 *)&addr))
1246 if ((u32)addr == ADDR_INVALID) {
1251 printf("running at 0x%08x\n", (u32)addr);
1255 addr = (u32 *)(STM32_DDR_BASE +
1256 (rand() & (STM32_DDR_SIZE - 1) & ~0x3));
1258 if (test_loop_end(&loop, 0, 1000))
1261 sprintf(string, "0x%x: %x", (u32)addr, data);
1266 /**********************************************************************
1268 * Function: infinite write access to DDR
1270 * Description: continuous write the same pattern at the same address
1272 **********************************************************************/
1273 static enum test_result test_write(struct stm32mp1_ddrctl *ctl,
1274 struct stm32mp1_ddrphy *phy,
1275 char *string, int argc, char *argv[])
1278 u32 data = 0xA5A5AA55;
1280 bool random = false;
1282 if (get_addr(string, argc, argv, 0, (u32 *)&addr))
1285 if ((u32)addr == ADDR_INVALID) {
1290 printf("running at 0x%08x\n", (u32)addr);
1294 addr = (u32 *)(STM32_DDR_BASE +
1295 (rand() & (STM32_DDR_SIZE - 1) & ~0x3));
1299 if (test_loop_end(&loop, 0, 1000))
1302 sprintf(string, "0x%x: %x", (u32)addr, data);
1307 #define NB_TEST_INFINITE 2
1308 static enum test_result test_all(struct stm32mp1_ddrctl *ctl,
1309 struct stm32mp1_ddrphy *phy,
1310 char *string, int argc, char *argv[])
1312 enum test_result res = TEST_PASSED, result;
1313 int i, nb_error = 0;
1314 u32 loop = 0, nb_loop;
1316 if (get_nb_loop(string, argc, argv, 0, &nb_loop, 1))
1320 /* execute all the test except the lasts which are infinite */
1321 for (i = 1; i < test_nb - NB_TEST_INFINITE; i++) {
1322 printf("execute %d:%s\n", (int)i, test[i].name);
1323 result = test[i].fct(ctl, phy, string, 0, NULL);
1324 printf("result %d:%s = ", (int)i, test[i].name);
1325 if (result != TEST_PASSED) {
1334 printf("loop %d: %d/%d test failed\n\n\n",
1335 loop + 1, nb_error, test_nb - NB_TEST_INFINITE);
1336 if (test_loop_end(&loop, nb_loop, 1))
1339 if (res != TEST_PASSED) {
1340 sprintf(string, "loop %d: %d/%d test failed", loop, nb_error,
1341 test_nb - NB_TEST_INFINITE);
1343 sprintf(string, "loop %d: %d tests passed", loop,
1344 test_nb - NB_TEST_INFINITE);
1349 /****************************************************************
1351 ****************************************************************/
1353 const struct test_desc test[] = {
1354 {test_all, "All", "[loop]", "Execute all tests", 1 },
1355 {test_databus, "Simple DataBus", "[addr]",
1356 "Verifies each data line by walking 1 on fixed address",
1359 {databuswalk0, "DataBusWalking0", "[loop] [addr]",
1360 "Verifies each data bus signal can be driven low (32 word burst)",
1363 {databuswalk1, "DataBusWalking1", "[loop] [addr]",
1364 "Verifies each data bus signal can be driven high (32 word burst)",
1367 {test_addressbus, "AddressBus", "[size] [addr]",
1368 "Verifies each relevant bits of the address and checking for aliasing",
1371 {test_memdevice, "MemDevice", "[size] [addr]",
1372 "Test the integrity of a physical memory (test every storage bit in the region)",
1375 {test_sso, "SimultaneousSwitchingOutput", "[size] [addr] ",
1376 "Stress the data bus over an address range",
1379 {test_noise, "Noise", "[pattern] [addr]",
1380 "Verifies r/w while forcing switching of all data bus lines.",
1383 {test_noise_burst, "NoiseBurst", "[size] [pattern] [addr]",
1384 "burst transfers while forcing switching of the data bus lines",
1387 {test_random, "Random", "[size] [loop] [addr]",
1388 "Verifies r/w and memcopy(burst for pseudo random value.",
1391 {test_freq_pattern, "FrequencySelectivePattern ", "[size]",
1392 "write & test patterns: Mostly Zero, Mostly One and F/n",
1395 {test_blockseq, "BlockSequential", "[size] [loop] [addr]",
1396 "test incremental pattern",
1399 {test_checkboard, "Checkerboard", "[size] [loop] [addr]",
1400 "test checker pattern",
1403 {test_bitspread, "BitSpread", "[size] [loop] [addr]",
1404 "test Bit Spread pattern",
1407 {test_bitflip, "BitFlip", "[size] [loop] [addr]",
1408 "test Bit Flip pattern",
1411 {test_walkbit0, "WalkingOnes", "[size] [loop] [addr]",
1412 "test Walking Ones pattern",
1415 {test_walkbit1, "WalkingZeroes", "[size] [loop] [addr]",
1416 "test Walking Zeroes pattern",
1419 /* need to the the 2 last one (infinite) : skipped for test all */
1420 {test_read, "infinite read", "[addr]",
1421 "basic test : infinite read access", 1},
1422 {test_write, "infinite write", "[addr]",
1423 "basic test : infinite write access", 1},
1426 const int test_nb = ARRAY_SIZE(test);