board/siemens/common/ddr_si_test.c - filogic/uboot - Gitiles

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright Siemens AG 2023
  *
  * DDR signal integrity test
  *   Check signals on DDR lines
  *   - signals must be as fast as possible and generate long burst
  *   - signals must be unidirectional (to DDR or from DDR only)
  *
  *   Set pattern: define 2^n 32-bit patterns (up to 4)
  *   Addresses: must be multiple of 16 to avoid checks in loops
  *   Test functions
  *   - write: write pattern to memory area for iteration times
  *   - read: write pattern once to memory area, read for iteration times
  */

 #include <command.h>
 #include <exports.h>
 #include <time.h>
 #if CONFIG_IS_ENABLED(AM33XX)
 #include <asm/arch-am33xx/hardware_am33xx.h>
 #include <asm/arch-am33xx/cpu.h>
 #include <asm/io.h>
 #endif

 /* enable some print for debugging */
 #ifdef PR_DEBUG
 	#define PDEBUG(fmt, args...) printf(fmt, ## args)
 #else
 	#define PDEBUG(fmt, args...)
 #endif

 /* define 4 32-bit patterns */
 #define MAX_PTN_SIZE (128)
 #define PTN_ARRAY_SIZE (MAX_PTN_SIZE / (8 * sizeof(u32)))

 /* define test direction */
 #define DIR_READ	0
 #define DIR_WRITE	1

 static union {
 	u64 l[2];
 	u32 s[4];
 	} test_pattern;
 static int num_ptn32;

 #if CONFIG_IS_ENABLED(AM33XX)
 static inline void wdt_disable(void)
 {
 	struct wd_timer *wdtimer = (struct wd_timer *)WDT_BASE;

 	writel(0xAAAA, &wdtimer->wdtwspr);
 	while (readl(&wdtimer->wdtwwps) != 0x0)
 		;
 	writel(0x5555, &wdtimer->wdtwspr);
 	while (readl(&wdtimer->wdtwwps) != 0x0)
 		;
 }

 static inline void wdt_enable(void)
 {
 	struct wd_timer *wdtimer = (struct wd_timer *)WDT_BASE;

 	writel(0xBBBB, &wdtimer->wdtwspr);
 	while (readl(&wdtimer->wdtwwps) != 0x0)
 		;
 	writel(0x4444, &wdtimer->wdtwspr);
 	while (readl(&wdtimer->wdtwwps) != 0x0)
 		;
 }
 #else /* ! */
 static inline void wdt_disable(void) {}

 static inline void wdt_enable(void) {}
 #endif /* CONFIG_IS_ENABLED(AM33XX) */

 static int do_ddr_set_ptn(struct cmd_tbl *cmdtp, int flag, int argc,
 			  char *const argv[])
 {
 	int i, n;

 	if (argc < 1)
 		return CMD_RET_USAGE;

 	/* number of patterns: 2 exponent */
 	n = argc - 1;
 	if (n > PTN_ARRAY_SIZE || (n & (n - 1)))
 		return CMD_RET_USAGE;
 	num_ptn32 = n;

 	/* get patterns */
 	for (i = 0; i < n; i++)
 		test_pattern.s[i] = simple_strtoul(argv[i + 1], NULL, 0);

 	printf("Test pattern set\n");

 	return CMD_RET_SUCCESS;
 }

 static int do_ddr_show_ptn(struct cmd_tbl *cmdtp, int flag, int argc,
 			   char *const argv[])
 {
 	if (!num_ptn32) {
 		printf("No pattern available\n");
 	} else {
 		u32 *buf = test_pattern.s;
 		int len = num_ptn32;
 		int i;

 		printf("Pattern: ");
 		for (i = 0 ; i < len; i++)
 			printf("0x%08X ", *buf++);

 		printf("\n");
 	}

 	return CMD_RET_SUCCESS;
 }

 static void ddr_read32(u64 start_addr, u64 n_word, unsigned long iter)
 {
 	while (iter--) {
 		register volatile u32 *addr = (u32 *)start_addr;
 		register u64 count = n_word;

 		while (count) {
 			(void)*addr++;
 			PDEBUG("Read 0x%08X from 0x%p\n", val, addr - 1);
 			count--;
 		}
 	}
 }

 static void ddr_read64(u64 start_addr, u64 n_word, unsigned long iter)
 {
 	while (iter--) {
 		register volatile u64 *addr = (u64 *)start_addr;
 		register u64 count = n_word;

 		if (num_ptn32 == 4)
 			count *= 2;

 		/*
 		 * 64 & 128 bit pattern. Increase the nummber of read
 		 * commands in the loop to generate longer burst signal
 		 */
 		while (count) {
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			(void)*addr++;
 			PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
 			/*
 			 * underflow cannot happen since n_word = end -
 			 * start, end & start addresses are checked to be
 			 * multiple of 16
 			 */
 			count -= 8;
 		}
 	}
 }

 static void ddr_write32(u64 start_addr, u64 n_word, unsigned long iter)
 {
 	while (iter--) {
 		register u32 *addr = (u32 *)start_addr;
 		register u32 ptn = *test_pattern.s;
 		register u64 count = n_word;

 		while (count) {
 			PDEBUG("Write 0x%08X to 0x%p\n", ptn, addr);
 			*addr++ = ptn;
 			count--;
 		}
 	}
 }

 static void ddr_write64(u64 start_addr, u64 n_word, unsigned long iter)
 {
 	while (iter--) {
 		register u64 *addr = (u64 *)start_addr;
 		register u64 ptnA = test_pattern.l[0];
 		register u64 ptnB = test_pattern.l[1];
 		register u64 count = n_word;

 		if (num_ptn32 == 2)
 			ptnB = ptnA;
 		else
 			count *= 2;

 		/*
 		 * 64 & 128 bit pattern. Increase the nummber of write
 		 * commands in the loop to generate longer burst signal
 		 */
 		while (count) {
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
 			*addr++ = ptnA;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
 			*addr++ = ptnB;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
 			*addr++ = ptnA;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
 			*addr++ = ptnB;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
 			*addr++ = ptnA;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
 			*addr++ = ptnB;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
 			*addr++ = ptnA;
 			PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
 			*addr++ = ptnB;
 			/*
 			 * underflow cannot happen since n_word = end -
 			 * start, end & start addresses are checked to be
 			 * multiple of 16
 			 */
 			count -= 8;
 		}
 	}
 }

 static int do_ddr_si_test(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 {
 	u64 start_addr, end_addr, n_word;
 	u64 ts_start, ts_end;
 	unsigned long iteration, wr_iter;
 	int direction, i;

 	if (argc < 3 || argc > 4)
 		return CMD_RET_USAGE;

 	/* get arguments */
 	direction = strcmp(argv[0], "read") ? DIR_WRITE : DIR_READ;
 	start_addr = simple_strtoul(argv[1], NULL, 0);
 	end_addr = simple_strtoul(argv[2], NULL, 0);
 	iteration = simple_strtoul(argv[3], NULL, 10);

 	n_word = (end_addr - start_addr) / (num_ptn32 * 4);
 	printf("\nDDR signal integrity %s test: start\n", argv[0]);
 	/* checks */
 	if (start_addr & 0xF) {
 		printf("ERROR: start_address should be 16 bytes aligned\n\n");
 		return CMD_RET_USAGE;
 	}

 	if (end_addr & 0xF) {
 		printf("ERROR: end_address should be 16 bytes aligned\n\n");
 		return CMD_RET_USAGE;
 	}

 	if (start_addr >= end_addr) {
 		printf("ERROR: end_address is not bigger than start_address\n\n");
 		return CMD_RET_USAGE;
 	}

 	if (!iteration) {
 		printf("ERROR: no iteration specified\n\n");
 		return CMD_RET_USAGE;
 	}

 	if (!num_ptn32) {
 		printf("ERROR: no test pattern specified\n\n");
 		return CMD_RET_USAGE;
 	}

 	/* print parameters */
 	printf("start_address = 0x%016llX\n", start_addr);
 	printf("end_address   = 0x%016llX\n", end_addr);
 	printf("iterations = %lu\n", iteration);

 	/* print pattern */
 	printf("test pattern 0x");
 	for (i = 0; i < num_ptn32; i++)
 		printf("%08X", test_pattern.s[i]);

 	printf("\n");

 	wdt_disable();

 	/* writing */
 	printf("Writing..\n");
 	ts_start = get_timer_us(0);

 	if (direction == DIR_READ)
 		wr_iter = 1;
 	else
 		wr_iter = iteration;

 	if (num_ptn32 == 1)
 		ddr_write32(start_addr, n_word, wr_iter);
 	else
 		ddr_write64(start_addr, n_word, wr_iter);

 	ts_end = get_timer_us(0);

 	/* reading */
 	if (direction == DIR_READ) {
 		printf("Reading..\n");
 		/* we need read time, just overwrite */
 		ts_start = get_timer_us(0);

 		if (num_ptn32 == 1)
 			ddr_read32(start_addr, n_word, iteration);
 		else
 			ddr_read64(start_addr, n_word, iteration);

 		ts_end = get_timer_us(0);
 	}

 	wdt_enable();

 	/* print stats */
 	printf("DONE.");
 	printf(" Bytes=%llu ", n_word * num_ptn32 * 4 * iteration);
 	printf(" Time=%llu us ", ts_end - ts_start);
 	printf("\nDDR signal integrity %s test: end\n", argv[0]);

 	return CMD_RET_SUCCESS;
 }

 static char ddr_si_help_text[] =
 	"- DDR signal integrity test\n\n"
 	"ddr_si setptn <pattern> [<pattern>] : set [1,2,4] 32-bit patterns\n"
 	"ddr_si showptn : show patterns\n"
 	"ddr_si read <start> <end> <iterations> : run test for reading\n"
 	"ddr_si write <start> <end> <iterations> : run test for writing\n"
 	"\nWith\n"
 	"\t<pattern>: 32-bit pattern in hex format\n"
 	"\t<start>: test start address in hex format\n"
 	"\t<end>: test end address in hex format\n"
 	"\t<iterations>: number of iterations\n";

 U_BOOT_CMD_WITH_SUBCMDS(ddr_si, "DDR si test", ddr_si_help_text,
 			U_BOOT_SUBCMD_MKENT(setptn, 5, 0, do_ddr_set_ptn),
 			U_BOOT_SUBCMD_MKENT(showptn, 1, 0, do_ddr_show_ptn),
 			U_BOOT_SUBCMD_MKENT(read, 4, 0, do_ddr_si_test),
 			U_BOOT_SUBCMD_MKENT(write, 4, 0, do_ddr_si_test));
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Copyright Siemens AG 2023
	*
	* DDR signal integrity test
	* Check signals on DDR lines
	* - signals must be as fast as possible and generate long burst
	* - signals must be unidirectional (to DDR or from DDR only)
	*
	* Set pattern: define 2^n 32-bit patterns (up to 4)
	* Addresses: must be multiple of 16 to avoid checks in loops
	* Test functions
	* - write: write pattern to memory area for iteration times
	* - read: write pattern once to memory area, read for iteration times
	*/

	#include <command.h>
	#include <exports.h>
	#include <time.h>
	#if CONFIG_IS_ENABLED(AM33XX)
	#include <asm/arch-am33xx/hardware_am33xx.h>
	#include <asm/arch-am33xx/cpu.h>
	#include <asm/io.h>
	#endif

	/* enable some print for debugging */
	#ifdef PR_DEBUG
	#define PDEBUG(fmt, args...) printf(fmt, ## args)
	#else
	#define PDEBUG(fmt, args...)
	#endif

	/* define 4 32-bit patterns */
	#define MAX_PTN_SIZE (128)
	#define PTN_ARRAY_SIZE (MAX_PTN_SIZE / (8 * sizeof(u32)))

	/* define test direction */
	#define DIR_READ 0
	#define DIR_WRITE 1

	static union {
	u64 l[2];
	u32 s[4];
	} test_pattern;
	static int num_ptn32;

	#if CONFIG_IS_ENABLED(AM33XX)
	static inline void wdt_disable(void)
	{
	struct wd_timer wdtimer = (struct wd_timer )WDT_BASE;

	writel(0xAAAA, &wdtimer->wdtwspr);
	while (readl(&wdtimer->wdtwwps) != 0x0)
	;
	writel(0x5555, &wdtimer->wdtwspr);
	while (readl(&wdtimer->wdtwwps) != 0x0)
	;
	}

	static inline void wdt_enable(void)
	{
	struct wd_timer wdtimer = (struct wd_timer )WDT_BASE;

	writel(0xBBBB, &wdtimer->wdtwspr);
	while (readl(&wdtimer->wdtwwps) != 0x0)
	;
	writel(0x4444, &wdtimer->wdtwspr);
	while (readl(&wdtimer->wdtwwps) != 0x0)
	;
	}
	#else /* ! */
	static inline void wdt_disable(void) {}

	static inline void wdt_enable(void) {}
	#endif /* CONFIG_IS_ENABLED(AM33XX) */

	static int do_ddr_set_ptn(struct cmd_tbl *cmdtp, int flag, int argc,
	char *const argv[])
	{
	int i, n;

	if (argc < 1)
	return CMD_RET_USAGE;

	/* number of patterns: 2 exponent */
	n = argc - 1;
	if (n > PTN_ARRAY_SIZE \|\| (n & (n - 1)))
	return CMD_RET_USAGE;
	num_ptn32 = n;

	/* get patterns */
	for (i = 0; i < n; i++)
	test_pattern.s[i] = simple_strtoul(argv[i + 1], NULL, 0);

	printf("Test pattern set\n");

	return CMD_RET_SUCCESS;
	}

	static int do_ddr_show_ptn(struct cmd_tbl *cmdtp, int flag, int argc,
	char *const argv[])
	{
	if (!num_ptn32) {
	printf("No pattern available\n");
	} else {
	u32 *buf = test_pattern.s;
	int len = num_ptn32;
	int i;

	printf("Pattern: ");
	for (i = 0 ; i < len; i++)
	printf("0x%08X ", *buf++);

	printf("\n");
	}

	return CMD_RET_SUCCESS;
	}

	static void ddr_read32(u64 start_addr, u64 n_word, unsigned long iter)
	{
	while (iter--) {
	register volatile u32 addr = (u32 )start_addr;
	register u64 count = n_word;

	while (count) {
	(void)*addr++;
	PDEBUG("Read 0x%08X from 0x%p\n", val, addr - 1);
	count--;
	}
	}
	}

	static void ddr_read64(u64 start_addr, u64 n_word, unsigned long iter)
	{
	while (iter--) {
	register volatile u64 addr = (u64 )start_addr;
	register u64 count = n_word;

	if (num_ptn32 == 4)
	count *= 2;

	/*
	* 64 & 128 bit pattern. Increase the nummber of read
	* commands in the loop to generate longer burst signal
	*/
	while (count) {
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	(void)*addr++;
	PDEBUG("Read 0x%016llX from 0x%p\n", val, addr - 1);
	/*
	* underflow cannot happen since n_word = end -
	* start, end & start addresses are checked to be
	* multiple of 16
	*/
	count -= 8;
	}
	}
	}

	static void ddr_write32(u64 start_addr, u64 n_word, unsigned long iter)
	{
	while (iter--) {
	register u32 addr = (u32 )start_addr;
	register u32 ptn = *test_pattern.s;
	register u64 count = n_word;

	while (count) {
	PDEBUG("Write 0x%08X to 0x%p\n", ptn, addr);
	*addr++ = ptn;
	count--;
	}
	}
	}

	static void ddr_write64(u64 start_addr, u64 n_word, unsigned long iter)
	{
	while (iter--) {
	register u64 addr = (u64 )start_addr;
	register u64 ptnA = test_pattern.l[0];
	register u64 ptnB = test_pattern.l[1];
	register u64 count = n_word;

	if (num_ptn32 == 2)
	ptnB = ptnA;
	else
	count *= 2;

	/*
	* 64 & 128 bit pattern. Increase the nummber of write
	* commands in the loop to generate longer burst signal
	*/
	while (count) {
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
	*addr++ = ptnA;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
	*addr++ = ptnB;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
	*addr++ = ptnA;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
	*addr++ = ptnB;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
	*addr++ = ptnA;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
	*addr++ = ptnB;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnA, addr);
	*addr++ = ptnA;
	PDEBUG("Write 0x%016llX to 0x%p\n", ptnB, addr);
	*addr++ = ptnB;
	/*
	* underflow cannot happen since n_word = end -
	* start, end & start addresses are checked to be
	* multiple of 16
	*/
	count -= 8;
	}
	}
	}

	static int do_ddr_si_test(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
	{
	u64 start_addr, end_addr, n_word;
	u64 ts_start, ts_end;
	unsigned long iteration, wr_iter;
	int direction, i;

	if (argc < 3 \|\| argc > 4)
	return CMD_RET_USAGE;

	/* get arguments */
	direction = strcmp(argv[0], "read") ? DIR_WRITE : DIR_READ;
	start_addr = simple_strtoul(argv[1], NULL, 0);
	end_addr = simple_strtoul(argv[2], NULL, 0);
	iteration = simple_strtoul(argv[3], NULL, 10);

	n_word = (end_addr - start_addr) / (num_ptn32 * 4);
	printf("\nDDR signal integrity %s test: start\n", argv[0]);
	/* checks */
	if (start_addr & 0xF) {
	printf("ERROR: start_address should be 16 bytes aligned\n\n");
	return CMD_RET_USAGE;
	}

	if (end_addr & 0xF) {
	printf("ERROR: end_address should be 16 bytes aligned\n\n");
	return CMD_RET_USAGE;
	}

	if (start_addr >= end_addr) {
	printf("ERROR: end_address is not bigger than start_address\n\n");
	return CMD_RET_USAGE;
	}

	if (!iteration) {
	printf("ERROR: no iteration specified\n\n");
	return CMD_RET_USAGE;
	}

	if (!num_ptn32) {
	printf("ERROR: no test pattern specified\n\n");
	return CMD_RET_USAGE;
	}

	/* print parameters */
	printf("start_address = 0x%016llX\n", start_addr);
	printf("end_address = 0x%016llX\n", end_addr);
	printf("iterations = %lu\n", iteration);

	/* print pattern */
	printf("test pattern 0x");
	for (i = 0; i < num_ptn32; i++)
	printf("%08X", test_pattern.s[i]);

	printf("\n");

	wdt_disable();

	/* writing */
	printf("Writing..\n");
	ts_start = get_timer_us(0);

	if (direction == DIR_READ)
	wr_iter = 1;
	else
	wr_iter = iteration;

	if (num_ptn32 == 1)
	ddr_write32(start_addr, n_word, wr_iter);
	else
	ddr_write64(start_addr, n_word, wr_iter);

	ts_end = get_timer_us(0);

	/* reading */
	if (direction == DIR_READ) {
	printf("Reading..\n");
	/* we need read time, just overwrite */
	ts_start = get_timer_us(0);

	if (num_ptn32 == 1)
	ddr_read32(start_addr, n_word, iteration);
	else
	ddr_read64(start_addr, n_word, iteration);

	ts_end = get_timer_us(0);
	}

	wdt_enable();

	/* print stats */
	printf("DONE.");
	printf(" Bytes=%llu ", n_word * num_ptn32 * 4 * iteration);
	printf(" Time=%llu us ", ts_end - ts_start);
	printf("\nDDR signal integrity %s test: end\n", argv[0]);

	return CMD_RET_SUCCESS;
	}

	static char ddr_si_help_text[] =
	"- DDR signal integrity test\n\n"
	"ddr_si setptn <pattern> [<pattern>] : set [1,2,4] 32-bit patterns\n"
	"ddr_si showptn : show patterns\n"
	"ddr_si read <start> <end> <iterations> : run test for reading\n"
	"ddr_si write <start> <end> <iterations> : run test for writing\n"
	"\nWith\n"
	"\t<pattern>: 32-bit pattern in hex format\n"
	"\t<start>: test start address in hex format\n"
	"\t<end>: test end address in hex format\n"
	"\t<iterations>: number of iterations\n";

	U_BOOT_CMD_WITH_SUBCMDS(ddr_si, "DDR si test", ddr_si_help_text,
	U_BOOT_SUBCMD_MKENT(setptn, 5, 0, do_ddr_set_ptn),
	U_BOOT_SUBCMD_MKENT(showptn, 1, 0, do_ddr_show_ptn),
	U_BOOT_SUBCMD_MKENT(read, 4, 0, do_ddr_si_test),
	U_BOOT_SUBCMD_MKENT(write, 4, 0, do_ddr_si_test));