drivers/ram/stm32mp1/stm32mp1_tests.c

   1 // SPDX-License-Identifier: GPL-2.0+ OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2019, STMicroelectronics - All Rights Reserved
   4  */
   5 #include <common.h>
   6 #include <console.h>
   7 #include <init.h>
   8 #include <rand.h>
   9 #include <watchdog.h>
  10 #include <asm/io.h>
  11 #include <linux/log2.h>
  12 #include "stm32mp1_tests.h"
  13
  14 #define ADDR_INVALID    0xFFFFFFFF
  15
  16 DECLARE_GLOBAL_DATA_PTR;
  17
  18 static int get_bufsize(char *string, int argc, char *argv[], int arg_nb,
  19                        size_t *bufsize, size_t default_size)
  20 {
  21         unsigned long value;
  22
  23         if (argc > arg_nb) {
  24                 if (strict_strtoul(argv[arg_nb], 0, &value) < 0) {
  25                         sprintf(string, "invalid %d parameter %s",
  26                                 arg_nb, argv[arg_nb]);
  27                         return -1;
  28                 }
  29                 if (value > STM32_DDR_SIZE || value == 0) {
  30                         sprintf(string, "invalid size %s", argv[arg_nb]);
  31                         return -1;
  32                 }
  33                 if (value & 0x3) {
  34                         sprintf(string, "unaligned size %s",
  35                                 argv[arg_nb]);
  36                         return -1;
  37                 }
  38                 *bufsize = value;
  39         } else {
  40                 if (default_size != STM32_DDR_SIZE)
  41                         *bufsize = default_size;
  42                 else
  43                         *bufsize = get_ram_size((long *)STM32_DDR_BASE,
  44                                                 STM32_DDR_SIZE);
  45         }
  46         return 0;
  47 }
  48
  49 static int get_nb_loop(char *string, int argc, char *argv[], int arg_nb,
  50                        u32 *nb_loop, u32 default_nb_loop)
  51 {
  52         unsigned long value;
  53
  54         if (argc > arg_nb) {
  55                 if (strict_strtoul(argv[arg_nb], 0, &value) < 0) {
  56                         sprintf(string, "invalid %d parameter %s",
  57                                 arg_nb, argv[arg_nb]);
  58                         return -1;
  59                 }
  60                 if (value == 0)
  61                         printf("WARNING: infinite loop requested\n");
  62                 *nb_loop = value;
  63         } else {
  64                 *nb_loop = default_nb_loop;
  65         }
  66
  67         return 0;
  68 }
  69
  70 static int get_addr(char *string, int argc, char *argv[], int arg_nb,
  71                     u32 *addr)
  72 {
  73         unsigned long value;
  74
  75         if (argc > arg_nb) {
  76                 if (strict_strtoul(argv[arg_nb], 16, &value) < 0) {
  77                         sprintf(string, "invalid %d parameter %s",
  78                                 arg_nb, argv[arg_nb]);
  79                         return -1;
  80                 }
  81                 if (value < STM32_DDR_BASE) {
  82                         sprintf(string, "too low address %s", argv[arg_nb]);
  83                         return -1;
  84                 }
  85                 if (value & 0x3 && value != ADDR_INVALID) {
  86                         sprintf(string, "unaligned address %s",
  87                                 argv[arg_nb]);
  88                         return -1;
  89                 }
  90                 *addr = value;
  91         } else {
  92                 *addr = STM32_DDR_BASE;
  93         }
  94
  95         return 0;
  96 }
  97
  98 static int get_pattern(char *string, int argc, char *argv[], int arg_nb,
  99                        u32 *pattern, u32 default_pattern)
 100 {
 101         unsigned long value;
 102
 103         if (argc > arg_nb) {
 104                 if (strict_strtoul(argv[arg_nb], 16, &value) < 0) {
 105                         sprintf(string, "invalid %d parameter %s",
 106                                 arg_nb, argv[arg_nb]);
 107                         return -1;
 108                 }
 109                 *pattern = value;
 110         } else {
 111                 *pattern = default_pattern;
 112         }
 113
 114         return 0;
 115 }
 116
 117 static u32 check_addr(u32 addr, u32 value)
 118 {
 119         u32 data = readl(addr);
 120
 121         if (value !=  data) {
 122                 printf("0x%08x: 0x%08x <=> 0x%08x", addr, data, value);
 123                 data = readl(addr);
 124                 printf("(2nd read: 0x%08x)", data);
 125                 if (value == data)
 126                         printf("- read error");
 127                 else
 128                         printf("- write error");
 129                 printf("\n");
 130                 return -1;
 131         }
 132         return 0;
 133 }
 134
 135 static int progress(u32 offset)
 136 {
 137         if (!(offset & 0xFFFFFF)) {
 138                 putc('.');
 139                 if (ctrlc()) {
 140                         printf("\ntest interrupted!\n");
 141                         return 1;
 142                 }
 143         }
 144         return 0;
 145 }
 146
 147 static int test_loop_end(u32 *loop, u32 nb_loop, u32 progress)
 148 {
 149         (*loop)++;
 150         if (nb_loop && *loop >= nb_loop)
 151                 return 1;
 152         if ((*loop) % progress)
 153                 return 0;
 154         /* allow to interrupt the test only for progress step */
 155         if (ctrlc()) {
 156                 printf("test interrupted!\n");
 157                 return 1;
 158         }
 159         printf("loop #%d\n", *loop);
 160         WATCHDOG_RESET();
 161
 162         return 0;
 163 }
 164
 165 /**********************************************************************
 166  *
 167  * Function:    memTestDataBus()
 168  *
 169  * Description: Test the data bus wiring in a memory region by
 170  *              performing a walking 1's test at a fixed address
 171  *              within that region.  The address is selected
 172  *              by the caller.
 173  *
 174  * Notes:
 175  *
 176  * Returns:     0 if the test succeeds.
 177  *              A non-zero result is the first pattern that failed.
 178  *
 179  **********************************************************************/
 180 static u32 databus(u32 *address)
 181 {
 182         u32 pattern;
 183         u32 read_value;
 184
 185         /* Perform a walking 1's test at the given address. */
 186         for (pattern = 1; pattern != 0; pattern <<= 1) {
 187                 /* Write the test pattern. */
 188                 writel(pattern, address);
 189
 190                 /* Read it back (immediately is okay for this test). */
 191                 read_value = readl(address);
 192                 debug("%x: %x <=> %x\n",
 193                       (u32)address, read_value, pattern);
 194
 195                 if (read_value != pattern)
 196                         return pattern;
 197         }
 198
 199         return 0;
 200 }
 201
 202 /**********************************************************************
 203  *
 204  * Function:    memTestAddressBus()
 205  *
 206  * Description: Test the address bus wiring in a memory region by
 207  *              performing a walking 1's test on the relevant bits
 208  *              of the address and checking for aliasing. This test
 209  *              will find single-bit address failures such as stuck
 210  *              -high, stuck-low, and shorted pins.  The base address
 211  *              and size of the region are selected by the caller.
 212  *
 213  * Notes:       For best results, the selected base address should
 214  *              have enough LSB 0's to guarantee single address bit
 215  *              changes.  For example, to test a 64-Kbyte region,
 216  *              select a base address on a 64-Kbyte boundary.  Also,
 217  *              select the region size as a power-of-two--if at all
 218  *              possible.
 219  *
 220  * Returns:     NULL if the test succeeds.
 221  *              A non-zero result is the first address at which an
 222  *              aliasing problem was uncovered.  By examining the
 223  *              contents of memory, it may be possible to gather
 224  *              additional information about the problem.
 225  *
 226  **********************************************************************/
 227 static u32 *addressbus(u32 *address, u32 nb_bytes)
 228 {
 229         u32 mask = (nb_bytes / sizeof(u32) - 1);
 230         u32 offset;
 231         u32 test_offset;
 232         u32 read_value;
 233
 234         u32 pattern     = 0xAAAAAAAA;
 235         u32 antipattern = 0x55555555;
 236
 237         /* Write the default pattern at each of the power-of-two offsets. */
 238         for (offset = 1; (offset & mask) != 0; offset <<= 1)
 239                 writel(pattern, &address[offset]);
 240
 241         /* Check for address bits stuck high. */
 242         test_offset = 0;
 243         writel(antipattern, &address[test_offset]);
 244
 245         for (offset = 1; (offset & mask) != 0; offset <<= 1) {
 246                 read_value = readl(&address[offset]);
 247                 debug("%x: %x <=> %x\n",
 248                       (u32)&address[offset], read_value, pattern);
 249                 if (read_value != pattern)
 250                         return &address[offset];
 251         }
 252
 253         writel(pattern, &address[test_offset]);
 254
 255         /* Check for address bits stuck low or shorted. */
 256         for (test_offset = 1; (test_offset & mask) != 0; test_offset <<= 1) {
 257                 writel(antipattern, &address[test_offset]);
 258                 if (readl(&address[0]) != pattern)
 259                         return &address[test_offset];
 260
 261                 for (offset = 1; (offset & mask) != 0; offset <<= 1) {
 262                         if (readl(&address[offset]) != pattern &&
 263                             offset != test_offset)
 264                                 return &address[test_offset];
 265                 }
 266                 writel(pattern, &address[test_offset]);
 267         }
 268
 269         return NULL;
 270 }
 271
 272 /**********************************************************************
 273  *
 274  * Function:    memTestDevice()
 275  *
 276  * Description: Test the integrity of a physical memory device by
 277  *              performing an increment/decrement test over the
 278  *              entire region.  In the process every storage bit
 279  *              in the device is tested as a zero and a one.  The
 280  *              base address and the size of the region are
 281  *              selected by the caller.
 282  *
 283  * Notes:
 284  *
 285  * Returns:     NULL if the test succeeds.
 286  *
 287  *              A non-zero result is the first address at which an
 288  *              incorrect value was read back.  By examining the
 289  *              contents of memory, it may be possible to gather
 290  *              additional information about the problem.
 291  *
 292  **********************************************************************/
 293 static u32 *memdevice(u32 *address, u32 nb_bytes)
 294 {
 295         u32 offset;
 296         u32 nb_words = nb_bytes / sizeof(u32);
 297
 298         u32 pattern;
 299         u32 antipattern;
 300
 301         puts("Fill with pattern");
 302         /* Fill memory with a known pattern. */
 303         for (pattern = 1, offset = 0; offset < nb_words; pattern++, offset++) {
 304                 writel(pattern, &address[offset]);
 305                 if (progress(offset))
 306                         return NULL;
 307         }
 308
 309         puts("\nCheck and invert pattern");
 310         /* Check each location and invert it for the second pass. */
 311         for (pattern = 1, offset = 0; offset < nb_words; pattern++, offset++) {
 312                 if (readl(&address[offset]) != pattern)
 313                         return &address[offset];
 314
 315                 antipattern = ~pattern;
 316                 writel(antipattern, &address[offset]);
 317                 if (progress(offset))
 318                         return NULL;
 319         }
 320
 321         puts("\nCheck inverted pattern");
 322         /* Check each location for the inverted pattern and zero it. */
 323         for (pattern = 1, offset = 0; offset < nb_words; pattern++, offset++) {
 324                 antipattern = ~pattern;
 325                 if (readl(&address[offset]) != antipattern)
 326                         return &address[offset];
 327                 if (progress(offset))
 328                         return NULL;
 329         }
 330         printf("\n");
 331
 332         return NULL;
 333 }
 334
 335 static enum test_result databuswalk0(struct stm32mp1_ddrctl *ctl,
 336                                      struct stm32mp1_ddrphy *phy,
 337                                      char *string, int argc, char *argv[])
 338 {
 339         int i;
 340         u32 loop = 0, nb_loop;
 341         u32 addr;
 342         u32 error = 0;
 343         u32 data;
 344
 345         if (get_nb_loop(string, argc, argv, 0, &nb_loop, 100))
 346                 return TEST_ERROR;
 347         if (get_addr(string, argc, argv, 1, &addr))
 348                 return TEST_ERROR;
 349
 350         printf("running %d loops at 0x%x\n", nb_loop, addr);
 351         while (!error) {
 352                 for (i = 0; i < 32; i++)
 353                         writel(~(1 << i), addr + 4 * i);
 354                 for (i = 0; i < 32; i++) {
 355                         data = readl(addr + 4 * i);
 356                         if (~(1 << i) !=  data) {
 357                                 error |= 1 << i;
 358                                 debug("%x: error %x expected %x => error:%x\n",
 359                                       addr + 4 * i, data, ~(1 << i), error);
 360                         }
 361                 }
 362                 if (test_loop_end(&loop, nb_loop, 1000))
 363                         break;
 364                 for (i = 0; i < 32; i++)
 365                         writel(0, addr + 4 * i);
 366         }
 367         if (error) {
 368                 sprintf(string, "loop %d: error for bits 0x%x",
 369                         loop, error);
 370                 return TEST_FAILED;
 371         }
 372         sprintf(string, "no error for %d loops", loop);
 373         return TEST_PASSED;
 374 }
 375
 376 static enum test_result databuswalk1(struct stm32mp1_ddrctl *ctl,
 377                                      struct stm32mp1_ddrphy *phy,
 378                                      char *string, int argc, char *argv[])
 379 {
 380         int i;
 381         u32 loop = 0, nb_loop;
 382         u32 addr;
 383         u32 error = 0;
 384         u32 data;
 385
 386         if (get_nb_loop(string, argc, argv, 0, &nb_loop, 100))
 387                 return TEST_ERROR;
 388         if (get_addr(string, argc, argv, 1, &addr))
 389                 return TEST_ERROR;
 390         printf("running %d loops at 0x%x\n", nb_loop, addr);
 391         while (!error) {
 392                 for (i = 0; i < 32; i++)
 393                         writel(1 << i, addr + 4 * i);
 394                 for (i = 0; i < 32; i++) {
 395                         data = readl(addr + 4 * i);
 396                         if ((1 << i) !=  data) {
 397                                 error |= 1 << i;
 398                                 debug("%x: error %x expected %x => error:%x\n",
 399                                       addr + 4 * i, data, (1 << i), error);
 400                         }
 401                 }
 402                 if (test_loop_end(&loop, nb_loop, 1000))
 403                         break;
 404                 for (i = 0; i < 32; i++)
 405                         writel(0, addr + 4 * i);
 406         }
 407         if (error) {
 408                 sprintf(string, "loop %d: error for bits 0x%x",
 409                         loop, error);
 410                 return TEST_FAILED;
 411         }
 412         sprintf(string, "no error for %d loops", loop);
 413         return TEST_PASSED;
 414 }
 415
 416 static enum test_result test_databus(struct stm32mp1_ddrctl *ctl,
 417                                      struct stm32mp1_ddrphy *phy,
 418                                      char *string, int argc, char *argv[])
 419 {
 420         u32 addr;
 421         u32 error;
 422
 423         if (get_addr(string, argc, argv, 0, &addr))
 424                 return TEST_ERROR;
 425         error = databus((u32 *)addr);
 426         if (error) {
 427                 sprintf(string, "0x%x: error for bits 0x%x",
 428                         addr, error);
 429                 return TEST_FAILED;
 430         }
 431         sprintf(string, "address 0x%x", addr);
 432         return TEST_PASSED;
 433 }
 434
 435 static enum test_result test_addressbus(struct stm32mp1_ddrctl *ctl,
 436                                         struct stm32mp1_ddrphy *phy,
 437                                         char *string, int argc, char *argv[])
 438 {
 439         u32 addr;
 440         u32 bufsize;
 441         u32 error;
 442
 443         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
 444                 return TEST_ERROR;
 445         if (!is_power_of_2(bufsize)) {
 446                 sprintf(string, "size 0x%x is not a power of 2",
 447                         (u32)bufsize);
 448                 return TEST_ERROR;
 449         }
 450         if (get_addr(string, argc, argv, 1, &addr))
 451                 return TEST_ERROR;
 452
 453         error = (u32)addressbus((u32 *)addr, bufsize);
 454         if (error) {
 455                 sprintf(string, "0x%x: error for address 0x%x",
 456                         addr, error);
 457                 return TEST_FAILED;
 458         }
 459         sprintf(string, "address 0x%x, size 0x%x",
 460                 addr, bufsize);
 461         return TEST_PASSED;
 462 }
 463
 464 static enum test_result test_memdevice(struct stm32mp1_ddrctl *ctl,
 465                                        struct stm32mp1_ddrphy *phy,
 466                                        char *string, int argc, char *argv[])
 467 {
 468         u32 addr;
 469         size_t bufsize;
 470         u32 error;
 471
 472         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
 473                 return TEST_ERROR;
 474         if (get_addr(string, argc, argv, 1, &addr))
 475                 return TEST_ERROR;
 476         error = (u32)memdevice((u32 *)addr, (unsigned long)bufsize);
 477         if (error) {
 478                 sprintf(string, "0x%x: error for address 0x%x",
 479                         addr, error);
 480                 return TEST_FAILED;
 481         }
 482         sprintf(string, "address 0x%x, size 0x%x",
 483                 addr, bufsize);
 484         return TEST_PASSED;
 485 }
 486
 487 /**********************************************************************
 488  *
 489  * Function:    sso
 490  *
 491  * Description: Test the Simultaneous Switching Output.
 492  *              Verifies succes sive reads and writes to the same memory word,
 493  *              holding one bit constant while toggling all other data bits
 494  *              simultaneously
 495  *              => stress the data bus over an address range
 496  *
 497  *              The CPU writes to each address in the given range.
 498  *              For each bit, first the CPU holds the bit at 1 while
 499  *              toggling the other bits, and then the CPU holds the bit at 0
 500  *              while toggling the other bits.
 501  *              After each write, the CPU reads the address that was written
 502  *              to verify that it contains the correct data
 503  *
 504  **********************************************************************/
 505 static enum test_result test_sso(struct stm32mp1_ddrctl *ctl,
 506                                  struct stm32mp1_ddrphy *phy,
 507                                  char *string, int argc, char *argv[])
 508 {
 509         int i, j;
 510         u32 addr, bufsize, remaining, offset;
 511         u32 error = 0;
 512         u32 data;
 513
 514         if (get_bufsize(string, argc, argv, 0, &bufsize, 4))
 515                 return TEST_ERROR;
 516         if (get_addr(string, argc, argv, 1, &addr))
 517                 return TEST_ERROR;
 518
 519         printf("running sso at 0x%x length 0x%x", addr, bufsize);
 520         offset = addr;
 521         remaining = bufsize;
 522         while (remaining) {
 523                 for (i = 0; i < 32; i++) {
 524                         /* write pattern. */
 525                         for (j = 0; j < 6; j++) {
 526                                 switch (j) {
 527                                 case 0:
 528                                 case 2:
 529                                         data = 1 << i;
 530                                         break;
 531                                 case 3:
 532                                 case 5:
 533                                         data = ~(1 << i);
 534                                         break;
 535                                 case 1:
 536                                         data = ~0x0;
 537                                         break;
 538                                 case 4:
 539                                         data = 0x0;
 540                                         break;
 541                                 }
 542
 543                                 writel(data, offset);
 544                                 error = check_addr(offset, data);
 545                                 if (error)
 546                                         goto end;
 547                         }
 548                 }
 549                 offset += 4;
 550                 remaining -= 4;
 551                 if (progress(offset << 7))
 552                         goto end;
 553         }
 554         puts("\n");
 555
 556 end:
 557         if (error) {
 558                 sprintf(string, "error for pattern 0x%x @0x%x",
 559                         data, offset);
 560                 return TEST_FAILED;
 561         }
 562         sprintf(string, "no error for sso at 0x%x length 0x%x", addr, bufsize);
 563         return TEST_PASSED;
 564 }
 565
 566 /**********************************************************************
 567  *
 568  * Function:    Random
 569  *
 570  * Description: Verifies r/w with pseudo-ramdom value on one region
 571  *              + write the region (individual access)
 572  *              + memcopy to the 2nd region (try to use burst)
 573  *              + verify the 2 regions
 574  *
 575  **********************************************************************/
 576 static enum test_result test_random(struct stm32mp1_ddrctl *ctl,
 577                                     struct stm32mp1_ddrphy *phy,
 578                                     char *string, int argc, char *argv[])
 579 {
 580         u32 addr, offset, value = 0;
 581         size_t bufsize;
 582         u32 loop = 0, nb_loop;
 583         u32 error = 0;
 584         unsigned int seed;
 585
 586         if (get_bufsize(string, argc, argv, 0, &bufsize, 8 * 1024))
 587                 return TEST_ERROR;
 588         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
 589                 return TEST_ERROR;
 590         if (get_addr(string, argc, argv, 2, &addr))
 591                 return TEST_ERROR;
 592
 593         bufsize /= 2;
 594         printf("running %d loops copy from 0x%x to 0x%x (buffer size=0x%x)\n",
 595                nb_loop, addr, addr + bufsize, bufsize);
 596         while (!error) {
 597                 seed = rand();
 598                 for (offset = 0; offset < bufsize; offset += 4)
 599                         writel(rand(), addr + offset);
 600
 601                 memcpy((void *)addr + bufsize, (void *)addr, bufsize);
 602
 603                 srand(seed);
 604                 for (offset = 0; offset < 2 * bufsize; offset += 4) {
 605                         if (offset == bufsize)
 606                                 srand(seed);
 607                         value = rand();
 608                         error = check_addr(addr + offset, value);
 609                         if (error)
 610                                 break;
 611                         if (progress(offset))
 612                                 return TEST_FAILED;
 613                 }
 614                 if (test_loop_end(&loop, nb_loop, 100))
 615                         break;
 616         }
 617         putc('\n');
 618
 619         if (error) {
 620                 sprintf(string,
 621                         "loop %d: error for address 0x%x: 0x%x expected 0x%x",
 622                         loop, offset, readl(offset), value);
 623                 return TEST_FAILED;
 624         }
 625         sprintf(string, "no error for %d loops, size 0x%x",
 626                 loop, bufsize);
 627         return TEST_PASSED;
 628 }
 629
 630 /**********************************************************************
 631  *
 632  * Function:    noise
 633  *
 634  * Description: Verifies r/w while forcing switching of all data bus lines.
 635  *              optimised 4 iteration write/read/write/read cycles...
 636  *              for pattern and inversed pattern
 637  *
 638  **********************************************************************/
 639 void do_noise(u32 addr, u32 pattern, u32 *result)
 640 {
 641         __asm__("push {R0-R11}");
 642         __asm__("mov r0, %0" : : "r" (addr));
 643         __asm__("mov r1, %0" : : "r" (pattern));
 644         __asm__("mov r11, %0" : : "r" (result));
 645
 646         __asm__("mvn r2, r1");
 647
 648         __asm__("str r1, [r0]");
 649         __asm__("ldr r3, [r0]");
 650         __asm__("str r2, [r0]");
 651         __asm__("ldr r4, [r0]");
 652
 653         __asm__("str r1, [r0]");
 654         __asm__("ldr r5, [r0]");
 655         __asm__("str r2, [r0]");
 656         __asm__("ldr r6, [r0]");
 657
 658         __asm__("str r1, [r0]");
 659         __asm__("ldr r7, [r0]");
 660         __asm__("str r2, [r0]");
 661         __asm__("ldr r8, [r0]");
 662
 663         __asm__("str r1, [r0]");
 664         __asm__("ldr r9, [r0]");
 665         __asm__("str r2, [r0]");
 666         __asm__("ldr r10, [r0]");
 667
 668         __asm__("stmia R11!, {R3-R10}");
 669
 670         __asm__("pop {R0-R11}");
 671 }
 672
 673 static enum test_result test_noise(struct stm32mp1_ddrctl *ctl,
 674                                    struct stm32mp1_ddrphy *phy,
 675                                    char *string, int argc, char *argv[])
 676 {
 677         u32 addr, pattern;
 678         u32 result[8];
 679         int i;
 680         enum test_result res = TEST_PASSED;
 681
 682         if (get_pattern(string, argc, argv, 0, &pattern, 0xFFFFFFFF))
 683                 return TEST_ERROR;
 684         if (get_addr(string, argc, argv, 1, &addr))
 685                 return TEST_ERROR;
 686
 687         printf("running noise for 0x%x at 0x%x\n", pattern, addr);
 688
 689         do_noise(addr, pattern, result);
 690
 691         for (i = 0; i < 0x8;) {
 692                 if (check_addr((u32)&result[i++], pattern))
 693                         res = TEST_FAILED;
 694                 if (check_addr((u32)&result[i++], ~pattern))
 695                         res = TEST_FAILED;
 696         }
 697
 698         return res;
 699 }
 700
 701 /**********************************************************************
 702  *
 703  * Function:    noise_burst
 704  *
 705  * Description: Verifies r/w while forcing switching of all data bus lines.
 706  *              optimised write loop witrh store multiple to use burst
 707  *              for pattern and inversed pattern
 708  *
 709  **********************************************************************/
 710 void do_noise_burst(u32 addr, u32 pattern, size_t bufsize)
 711 {
 712         __asm__("push {R0-R9}");
 713         __asm__("mov r0, %0" : : "r" (addr));
 714         __asm__("mov r1, %0" : : "r" (pattern));
 715         __asm__("mov r9, %0" : : "r" (bufsize));
 716
 717         __asm__("mvn r2, r1");
 718         __asm__("mov r3, r1");
 719         __asm__("mov r4, r2");
 720         __asm__("mov r5, r1");
 721         __asm__("mov r6, r2");
 722         __asm__("mov r7, r1");
 723         __asm__("mov r8, r2");
 724
 725         __asm__("loop1:");
 726         __asm__("stmia R0!, {R1-R8}");
 727         __asm__("stmia R0!, {R1-R8}");
 728         __asm__("stmia R0!, {R1-R8}");
 729         __asm__("stmia R0!, {R1-R8}");
 730         __asm__("subs r9, r9, #128");
 731         __asm__("bge loop1");
 732         __asm__("pop {R0-R9}");
 733 }
 734
 735 /* chunk size enough to allow interruption with Ctrl-C*/
 736 #define CHUNK_SIZE      0x8000000
 737 static enum test_result test_noise_burst(struct stm32mp1_ddrctl *ctl,
 738                                          struct stm32mp1_ddrphy *phy,
 739                                          char *string, int argc, char *argv[])
 740 {
 741         u32 addr, offset, pattern;
 742         size_t bufsize, remaining, size;
 743         int i;
 744         enum test_result res = TEST_PASSED;
 745
 746         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
 747                 return TEST_ERROR;
 748         if (get_pattern(string, argc, argv, 1, &pattern, 0xFFFFFFFF))
 749                 return TEST_ERROR;
 750         if (get_addr(string, argc, argv, 2, &addr))
 751                 return TEST_ERROR;
 752
 753         printf("running noise burst for 0x%x at 0x%x + 0x%x",
 754                pattern, addr, bufsize);
 755
 756         offset = addr;
 757         remaining = bufsize;
 758         size = CHUNK_SIZE;
 759         while (remaining) {
 760                 if (remaining < size)
 761                         size = remaining;
 762                 do_noise_burst(offset, pattern, size);
 763                 remaining -= size;
 764                 offset += size;
 765                 if (progress(offset)) {
 766                         res = TEST_FAILED;
 767                         goto end;
 768                 }
 769         }
 770         puts("\ncheck buffer");
 771         for (i = 0; i < bufsize;) {
 772                 if (check_addr(addr + i, pattern))
 773                         res = TEST_FAILED;
 774                 i += 4;
 775                 if (check_addr(addr + i, ~pattern))
 776                         res = TEST_FAILED;
 777                 i += 4;
 778                 if (progress(i)) {
 779                         res = TEST_FAILED;
 780                         goto end;
 781                 }
 782         }
 783 end:
 784         puts("\n");
 785         return res;
 786 }
 787
 788 /**********************************************************************
 789  *
 790  * Function:    pattern test
 791  *
 792  * Description: optimized loop for read/write pattern (array of 8 u32)
 793  *
 794  **********************************************************************/
 795 #define PATTERN_SIZE    8
 796 static enum test_result test_loop(const u32 *pattern, u32 *address,
 797                                   const u32 bufsize)
 798 {
 799         int i;
 800         int j;
 801         enum test_result res = TEST_PASSED;
 802         u32 offset, testsize, remaining;
 803
 804         offset = (u32)address;
 805         remaining = bufsize;
 806         while (remaining) {
 807                 testsize = bufsize > 0x1000000 ? 0x1000000 : bufsize;
 808
 809                 __asm__("push {R0-R10}");
 810                 __asm__("mov r0, %0" : : "r" (pattern));
 811                 __asm__("mov r1, %0" : : "r" (offset));
 812                 __asm__("mov r2, %0" : : "r" (testsize));
 813                 __asm__("ldmia r0!, {R3-R10}");
 814
 815                 __asm__("loop2:");
 816                 __asm__("stmia r1!, {R3-R10}");
 817                 __asm__("stmia r1!, {R3-R10}");
 818                 __asm__("stmia r1!, {R3-R10}");
 819                 __asm__("stmia r1!, {R3-R10}");
 820                 __asm__("subs r2, r2, #128");
 821                 __asm__("bge loop2");
 822                 __asm__("pop {R0-R10}");
 823
 824                 offset += testsize;
 825                 remaining -= testsize;
 826                 if (progress((u32)offset)) {
 827                         res = TEST_FAILED;
 828                         goto end;
 829                 }
 830         }
 831
 832         puts("\ncheck buffer");
 833         for (i = 0; i < bufsize; i += PATTERN_SIZE * 4) {
 834                 for (j = 0; j < PATTERN_SIZE; j++, address++)
 835                         if (check_addr((u32)address, pattern[j])) {
 836                                 res = TEST_FAILED;
 837                                 goto end;
 838                         }
 839                 if (progress(i)) {
 840                         res = TEST_FAILED;
 841                         goto end;
 842                 }
 843         }
 844
 845 end:
 846         puts("\n");
 847         return res;
 848 }
 849
 850 const u32 pattern_div1_x16[PATTERN_SIZE] = {
 851         0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF,
 852         0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF
 853 };
 854
 855 const u32 pattern_div2_x16[PATTERN_SIZE] = {
 856         0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0x00000000,
 857         0xFFFFFFFF, 0x00000000, 0xFFFFFFFF, 0x00000000
 858 };
 859
 860 const u32 pattern_div4_x16[PATTERN_SIZE] = {
 861         0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000,
 862         0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000
 863 };
 864
 865 const u32 pattern_div4_x32[PATTERN_SIZE] = {
 866         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 867         0x00000000, 0x00000000, 0x00000000, 0x00000000
 868 };
 869
 870 const u32 pattern_mostly_zero_x16[PATTERN_SIZE] = {
 871         0x00000000, 0x00000000, 0x00000000, 0x0000FFFF,
 872         0x00000000, 0x00000000, 0x00000000, 0x00000000
 873 };
 874
 875 const u32 pattern_mostly_zero_x32[PATTERN_SIZE] = {
 876         0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF,
 877         0x00000000, 0x00000000, 0x00000000, 0x00000000
 878 };
 879
 880 const u32 pattern_mostly_one_x16[PATTERN_SIZE] = {
 881         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000FFFF,
 882         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
 883 };
 884
 885 const u32 pattern_mostly_one_x32[PATTERN_SIZE] = {
 886         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000,
 887         0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
 888 };
 889
 890 #define NB_PATTERN      5
 891 static enum test_result test_freq_pattern(struct stm32mp1_ddrctl *ctl,
 892                                           struct stm32mp1_ddrphy *phy,
 893                                           char *string, int argc, char *argv[])
 894 {
 895         const u32 * const patterns_x16[NB_PATTERN] = {
 896                 pattern_div1_x16,
 897                 pattern_div2_x16,
 898                 pattern_div4_x16,
 899                 pattern_mostly_zero_x16,
 900                 pattern_mostly_one_x16,
 901         };
 902         const u32 * const patterns_x32[NB_PATTERN] = {
 903                 pattern_div2_x16,
 904                 pattern_div4_x16,
 905                 pattern_div4_x32,
 906                 pattern_mostly_zero_x32,
 907                 pattern_mostly_one_x32
 908         };
 909         const char *patterns_comments[NB_PATTERN] = {
 910                 "switching at frequency F/1",
 911                 "switching at frequency F/2",
 912                 "switching at frequency F/4",
 913                 "mostly zero",
 914                 "mostly one"
 915         };
 916
 917         enum test_result res = TEST_PASSED, pattern_res;
 918         int i, bus_width;
 919         const u32 **patterns;
 920         u32 bufsize;
 921
 922         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
 923                 return TEST_ERROR;
 924
 925         switch (readl(&ctl->mstr) & DDRCTRL_MSTR_DATA_BUS_WIDTH_MASK) {
 926         case DDRCTRL_MSTR_DATA_BUS_WIDTH_HALF:
 927         case DDRCTRL_MSTR_DATA_BUS_WIDTH_QUARTER:
 928                 bus_width = 16;
 929                 break;
 930         default:
 931                 bus_width = 32;
 932                 break;
 933         }
 934
 935         printf("running test pattern at 0x%08x length 0x%x width = %d\n",
 936                STM32_DDR_BASE, bufsize, bus_width);
 937
 938         patterns =
 939                 (const u32 **)(bus_width == 16 ? patterns_x16 : patterns_x32);
 940
 941         for (i = 0; i < NB_PATTERN; i++) {
 942                 printf("test data pattern %s:", patterns_comments[i]);
 943                 pattern_res = test_loop(patterns[i], (u32 *)STM32_DDR_BASE,
 944                                         bufsize);
 945                 if (pattern_res != TEST_PASSED) {
 946                         printf("Failed\n");
 947                         return pattern_res;
 948                 }
 949                 printf("Passed\n");
 950         }
 951
 952         return res;
 953 }
 954
 955 /**********************************************************************
 956  *
 957  * Function:    pattern test with size
 958  *
 959  * Description: loop for write pattern
 960  *
 961  **********************************************************************/
 962
 963 static enum test_result test_loop_size(const u32 *pattern, u32 size,
 964                                        u32 *address,
 965                                        const u32 bufsize)
 966 {
 967         int i, j;
 968         enum test_result res = TEST_PASSED;
 969         u32 *p = address;
 970
 971         for (i = 0; i < bufsize; i += size * 4) {
 972                 for (j = 0; j < size ; j++, p++)
 973                         *p = pattern[j];
 974                 if (progress(i)) {
 975                         res = TEST_FAILED;
 976                         goto end;
 977                 }
 978         }
 979
 980         puts("\ncheck buffer");
 981         p = address;
 982         for (i = 0; i < bufsize; i += size * 4) {
 983                 for (j = 0; j < size; j++, p++)
 984                         if (check_addr((u32)p, pattern[j])) {
 985                                 res = TEST_FAILED;
 986                                 goto end;
 987                         }
 988                 if (progress(i)) {
 989                         res = TEST_FAILED;
 990                         goto end;
 991                 }
 992         }
 993
 994 end:
 995         puts("\n");
 996         return res;
 997 }
 998
 999 static enum test_result test_checkboard(struct stm32mp1_ddrctl *ctl,
1000                                         struct stm32mp1_ddrphy *phy,
1001                                         char *string, int argc, char *argv[])
1002 {
1003         enum test_result res = TEST_PASSED;
1004         u32 bufsize, nb_loop, loop = 0, addr;
1005         int i;
1006
1007         u32 checkboard[2] = {0x55555555, 0xAAAAAAAA};
1008
1009         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1010                 return TEST_ERROR;
1011         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1012                 return TEST_ERROR;
1013         if (get_addr(string, argc, argv, 2, &addr))
1014                 return TEST_ERROR;
1015
1016         printf("running %d loops at 0x%08x length 0x%x\n",
1017                nb_loop, addr, bufsize);
1018         while (1) {
1019                 for (i = 0; i < 2; i++) {
1020                         res = test_loop_size(checkboard, 2, (u32 *)addr,
1021                                              bufsize);
1022                         if (res)
1023                                 return res;
1024                         checkboard[0] = ~checkboard[0];
1025                         checkboard[1] = ~checkboard[1];
1026                 }
1027                 if (test_loop_end(&loop, nb_loop, 1))
1028                         break;
1029         }
1030         sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1031                 loop, addr, bufsize);
1032
1033         return res;
1034 }
1035
1036 static enum test_result test_blockseq(struct stm32mp1_ddrctl *ctl,
1037                                       struct stm32mp1_ddrphy *phy,
1038                                       char *string, int argc, char *argv[])
1039 {
1040         enum test_result res = TEST_PASSED;
1041         u32 bufsize, nb_loop, loop = 0, addr, value;
1042         int i;
1043
1044         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1045                 return TEST_ERROR;
1046         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1047                 return TEST_ERROR;
1048         if (get_addr(string, argc, argv, 2, &addr))
1049                 return TEST_ERROR;
1050
1051         printf("running %d loops at 0x%08x length 0x%x\n",
1052                nb_loop, addr, bufsize);
1053         while (1) {
1054                 for (i = 0; i < 256; i++) {
1055                         value = i | i << 8 | i << 16 | i << 24;
1056                         printf("pattern = %08x", value);
1057                         res = test_loop_size(&value, 1, (u32 *)addr, bufsize);
1058                         if (res != TEST_PASSED)
1059                                 return res;
1060                 }
1061                 if (test_loop_end(&loop, nb_loop, 1))
1062                         break;
1063         }
1064         sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1065                 loop, addr, bufsize);
1066
1067         return res;
1068 }
1069
1070 static enum test_result test_walkbit0(struct stm32mp1_ddrctl *ctl,
1071                                       struct stm32mp1_ddrphy *phy,
1072                                       char *string, int argc, char *argv[])
1073 {
1074         enum test_result res = TEST_PASSED;
1075         u32 bufsize, nb_loop, loop = 0, addr, value;
1076         int i;
1077
1078         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1079                 return TEST_ERROR;
1080         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1081                 return TEST_ERROR;
1082         if (get_addr(string, argc, argv, 2, &addr))
1083                 return TEST_ERROR;
1084
1085         printf("running %d loops at 0x%08x length 0x%x\n",
1086                nb_loop, addr, bufsize);
1087         while (1) {
1088                 for (i = 0; i < 64; i++) {
1089                         if (i < 32)
1090                                 value = 1 << i;
1091                         else
1092                                 value = 1 << (63 - i);
1093
1094                         printf("pattern = %08x", value);
1095                         res = test_loop_size(&value, 1, (u32 *)addr, bufsize);
1096                         if (res != TEST_PASSED)
1097                                 return res;
1098                 }
1099                 if (test_loop_end(&loop, nb_loop, 1))
1100                         break;
1101         }
1102         sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1103                 loop, addr, bufsize);
1104
1105         return res;
1106 }
1107
1108 static enum test_result test_walkbit1(struct stm32mp1_ddrctl *ctl,
1109                                       struct stm32mp1_ddrphy *phy,
1110                                       char *string, int argc, char *argv[])
1111 {
1112         enum test_result res = TEST_PASSED;
1113         u32 bufsize, nb_loop, loop = 0, addr, value;
1114         int i;
1115
1116         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1117                 return TEST_ERROR;
1118         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1119                 return TEST_ERROR;
1120         if (get_addr(string, argc, argv, 2, &addr))
1121                 return TEST_ERROR;
1122
1123         printf("running %d loops at 0x%08x length 0x%x\n",
1124                nb_loop, addr, bufsize);
1125         while (1) {
1126                 for (i = 0; i < 64; i++) {
1127                         if (i < 32)
1128                                 value = ~(1 << i);
1129                         else
1130                                 value = ~(1 << (63 - i));
1131
1132                         printf("pattern = %08x", value);
1133                         res = test_loop_size(&value, 1, (u32 *)addr, bufsize);
1134                         if (res != TEST_PASSED)
1135                                 return res;
1136                 }
1137                 if (test_loop_end(&loop, nb_loop, 1))
1138                         break;
1139         }
1140         sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1141                 loop, addr, bufsize);
1142
1143         return res;
1144 }
1145
1146 /*
1147  * try to catch bad bits which are dependent on the current values of
1148  * surrounding bits in either the same word32
1149  */
1150 static enum test_result test_bitspread(struct stm32mp1_ddrctl *ctl,
1151                                        struct stm32mp1_ddrphy *phy,
1152                                        char *string, int argc, char *argv[])
1153 {
1154         enum test_result res = TEST_PASSED;
1155         u32 bufsize, nb_loop, loop = 0, addr, bitspread[4];
1156         int i, j;
1157
1158         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1159                 return TEST_ERROR;
1160         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1161                 return TEST_ERROR;
1162         if (get_addr(string, argc, argv, 2, &addr))
1163                 return TEST_ERROR;
1164
1165         printf("running %d loops at 0x%08x length 0x%x\n",
1166                nb_loop, addr, bufsize);
1167         while (1) {
1168                 for (i = 1; i < 32; i++) {
1169                         for (j = 0; j < i; j++) {
1170                                 if (i < 32)
1171                                         bitspread[0] = (1 << i) | (1 << j);
1172                                 else
1173                                         bitspread[0] = (1 << (63 - i)) |
1174                                                        (1 << (63 - j));
1175                                 bitspread[1] = bitspread[0];
1176                                 bitspread[2] = ~bitspread[0];
1177                                 bitspread[3] = ~bitspread[0];
1178                                 printf("pattern = %08x", bitspread[0]);
1179
1180                                 res = test_loop_size(bitspread, 4, (u32 *)addr,
1181                                                      bufsize);
1182                                 if (res != TEST_PASSED)
1183                                         return res;
1184                         }
1185                 }
1186                 if (test_loop_end(&loop, nb_loop, 1))
1187                         break;
1188         }
1189         sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1190                 loop, addr, bufsize);
1191
1192         return res;
1193 }
1194
1195 static enum test_result test_bitflip(struct stm32mp1_ddrctl *ctl,
1196                                      struct stm32mp1_ddrphy *phy,
1197                                      char *string, int argc, char *argv[])
1198 {
1199         enum test_result res = TEST_PASSED;
1200         u32 bufsize, nb_loop, loop = 0, addr;
1201         int i;
1202
1203         u32 bitflip[4];
1204
1205         if (get_bufsize(string, argc, argv, 0, &bufsize, 4 * 1024))
1206                 return TEST_ERROR;
1207         if (get_nb_loop(string, argc, argv, 1, &nb_loop, 1))
1208                 return TEST_ERROR;
1209         if (get_addr(string, argc, argv, 2, &addr))
1210                 return TEST_ERROR;
1211
1212         printf("running %d loops at 0x%08x length 0x%x\n",
1213                nb_loop, addr, bufsize);
1214         while (1) {
1215                 for (i = 0; i < 32; i++) {
1216                         bitflip[0] = 1 << i;
1217                         bitflip[1] = bitflip[0];
1218                         bitflip[2] = ~bitflip[0];
1219                         bitflip[3] = bitflip[2];
1220                         printf("pattern = %08x", bitflip[0]);
1221
1222                         res = test_loop_size(bitflip, 4, (u32 *)addr, bufsize);
1223                         if (res != TEST_PASSED)
1224                                 return res;
1225                 }
1226                 if (test_loop_end(&loop, nb_loop, 1))
1227                         break;
1228         }
1229         sprintf(string, "no error for %d loops at 0x%08x length 0x%x",
1230                 loop, addr, bufsize);
1231
1232         return res;
1233 }
1234
1235 /**********************************************************************
1236  *
1237  * Function: infinite read access to DDR
1238  *
1239  * Description: continuous read the same pattern at the same address
1240  *
1241  **********************************************************************/
1242 static enum test_result test_read(struct stm32mp1_ddrctl *ctl,
1243                                   struct stm32mp1_ddrphy *phy,
1244                                   char *string, int argc, char *argv[])
1245 {
1246         u32 *addr;
1247         u32 data;
1248         u32 loop = 0;
1249         int i, size = 1024 * 1024;
1250         bool random = false;
1251
1252         if (get_addr(string, argc, argv, 0, (u32 *)&addr))
1253                 return TEST_ERROR;
1254
1255         if (get_pattern(string, argc, argv, 1, &data, 0xA5A5AA55))
1256                 return TEST_ERROR;
1257
1258         if ((u32)addr == ADDR_INVALID) {
1259                 printf("running random\n");
1260                 random = true;
1261         } else {
1262                 printf("running at 0x%08x with pattern=0x%08x\n",
1263                        (u32)addr, data);
1264                 writel(data, addr);
1265         }
1266
1267         while (1) {
1268                 for (i = 0; i < size; i++) {
1269                         if (random)
1270                                 addr = (u32 *)(STM32_DDR_BASE +
1271                                        (rand() & (STM32_DDR_SIZE - 1) & ~0x3));
1272                         data = readl(addr);
1273                 }
1274                 if (test_loop_end(&loop, 0, 1))
1275                         break;
1276         }
1277         if (random)
1278                 sprintf(string, "%d loops random", loop);
1279         else
1280                 sprintf(string, "%d loops at 0x%x: %x", loop, (u32)addr, data);
1281
1282         return TEST_PASSED;
1283 }
1284
1285 /**********************************************************************
1286  *
1287  * Function: infinite write access to DDR
1288  *
1289  * Description: continuous write the same pattern at the same address
1290  *
1291  **********************************************************************/
1292 static enum test_result test_write(struct stm32mp1_ddrctl *ctl,
1293                                    struct stm32mp1_ddrphy *phy,
1294                                    char *string, int argc, char *argv[])
1295 {
1296         u32 *addr;
1297         u32 data;
1298         u32 loop = 0;
1299         int i, size = 1024 * 1024;
1300         bool random = false;
1301
1302         if (get_addr(string, argc, argv, 0, (u32 *)&addr))
1303                 return TEST_ERROR;
1304
1305         if (get_pattern(string, argc, argv, 1, &data, 0xA5A5AA55))
1306                 return TEST_ERROR;
1307
1308         if ((u32)addr == ADDR_INVALID) {
1309                 printf("running random\n");
1310                 random = true;
1311         } else {
1312                 printf("running at 0x%08x with pattern 0x%08x\n",
1313                        (u32)addr, data);
1314         }
1315
1316         while (1) {
1317                 for (i = 0; i < size; i++) {
1318                         if (random) {
1319                                 addr = (u32 *)(STM32_DDR_BASE +
1320                                        (rand() & (STM32_DDR_SIZE - 1) & ~0x3));
1321                                 data = rand();
1322                         }
1323                         writel(data, addr);
1324                 }
1325                 if (test_loop_end(&loop, 0, 1))
1326                         break;
1327         }
1328         if (random)
1329                 sprintf(string, "%d loops random", loop);
1330         else
1331                 sprintf(string, "%d loops at 0x%x: %x", loop, (u32)addr, data);
1332
1333         return TEST_PASSED;
1334 }
1335
1336 #define NB_TEST_INFINITE 2
1337 static enum test_result test_all(struct stm32mp1_ddrctl *ctl,
1338                                  struct stm32mp1_ddrphy *phy,
1339                                  char *string, int argc, char *argv[])
1340 {
1341         enum test_result res = TEST_PASSED, result;
1342         int i, nb_error = 0;
1343         u32 loop = 0, nb_loop;
1344
1345         if (get_nb_loop(string, argc, argv, 0, &nb_loop, 1))
1346                 return TEST_ERROR;
1347
1348         while (!nb_error) {
1349                 /* execute all the test except the lasts which are infinite */
1350                 for (i = 1; i < test_nb - NB_TEST_INFINITE; i++) {
1351                         printf("execute %d:%s\n", (int)i, test[i].name);
1352                         result = test[i].fct(ctl, phy, string, 0, NULL);
1353                         printf("result %d:%s = ", (int)i, test[i].name);
1354                         if (result != TEST_PASSED) {
1355                                 nb_error++;
1356                                 res = TEST_FAILED;
1357                                 puts("Failed");
1358                         } else {
1359                                 puts("Passed");
1360                         }
1361                         puts("\n\n");
1362                 }
1363                 printf("loop %d: %d/%d test failed\n\n\n",
1364                        loop + 1, nb_error, test_nb - NB_TEST_INFINITE);
1365                 if (test_loop_end(&loop, nb_loop, 1))
1366                         break;
1367         }
1368         if (res != TEST_PASSED) {
1369                 sprintf(string, "loop %d: %d/%d test failed", loop, nb_error,
1370                         test_nb - NB_TEST_INFINITE);
1371         } else {
1372                 sprintf(string, "loop %d: %d tests passed", loop,
1373                         test_nb - NB_TEST_INFINITE);
1374         }
1375         return res;
1376 }
1377
1378 /****************************************************************
1379  * TEST Description
1380  ****************************************************************/
1381
1382 const struct test_desc test[] = {
1383         {test_all, "All", "[loop]", "Execute all tests", 1 },
1384         {test_databus, "Simple DataBus", "[addr]",
1385          "Verifies each data line by walking 1 on fixed address",
1386          1
1387          },
1388         {databuswalk0, "DataBusWalking0", "[loop] [addr]",
1389          "Verifies each data bus signal can be driven low (32 word burst)",
1390          2
1391         },
1392         {databuswalk1, "DataBusWalking1", "[loop] [addr]",
1393          "Verifies each data bus signal can be driven high (32 word burst)",
1394          2
1395         },
1396         {test_addressbus, "AddressBus", "[size] [addr]",
1397          "Verifies each relevant bits of the address and checking for aliasing",
1398          2
1399          },
1400         {test_memdevice, "MemDevice", "[size] [addr]",
1401          "Test the integrity of a physical memory (test every storage bit in the region)",
1402          2
1403          },
1404         {test_sso, "SimultaneousSwitchingOutput", "[size] [addr] ",
1405          "Stress the data bus over an address range",
1406          2
1407         },
1408         {test_noise, "Noise", "[pattern] [addr]",
1409          "Verifies r/w while forcing switching of all data bus lines.",
1410          3
1411         },
1412         {test_noise_burst, "NoiseBurst", "[size] [pattern] [addr]",
1413          "burst transfers while forcing switching of the data bus lines",
1414          3
1415         },
1416         {test_random, "Random", "[size] [loop] [addr]",
1417          "Verifies r/w and memcopy(burst for pseudo random value.",
1418          3
1419         },
1420         {test_freq_pattern, "FrequencySelectivePattern", "[size]",
1421          "write & test patterns: Mostly Zero, Mostly One and F/n",
1422          1
1423         },
1424         {test_blockseq, "BlockSequential", "[size] [loop] [addr]",
1425          "test incremental pattern",
1426          3
1427         },
1428         {test_checkboard, "Checkerboard", "[size] [loop] [addr]",
1429          "test checker pattern",
1430          3
1431         },
1432         {test_bitspread, "BitSpread", "[size] [loop] [addr]",
1433          "test Bit Spread pattern",
1434          3
1435         },
1436         {test_bitflip, "BitFlip", "[size] [loop] [addr]",
1437          "test Bit Flip pattern",
1438          3
1439         },
1440         {test_walkbit0, "WalkingOnes", "[size] [loop] [addr]",
1441          "test Walking Ones pattern",
1442          3
1443         },
1444         {test_walkbit1, "WalkingZeroes", "[size] [loop] [addr]",
1445          "test Walking Zeroes pattern",
1446          3
1447         },
1448         /* need to the the 2 last one (infinite) : skipped for test all */
1449         {test_read, "infinite read", "[addr] [pattern]",
1450          "basic test : infinite read access (random: addr=0xFFFFFFFF)", 2},
1451         {test_write, "infinite write", "[addr] [pattern]",
1452          "basic test : infinite write access (random: addr=0xFFFFFFFF)", 2},
1453 };
1454
1455 const int test_nb = ARRAY_SIZE(test);