memtest

#include “rtdef.h”
#include <rtthread.h>

#define u64 uint64_t
#define pr_info rt_kprintf
#define phys_addr_t uint32_t

#define UINT_MAX ((uint32_t)-1)

#define ARRAY_SIZE(arr) sizeof(arr)/sizeof((arr)[0])

#undef ALIGN
#define ALIGN(size, align) RT_ALIGN(size, align)
static uint64_t patterns[] = {
/* The first entry has to be 0 to leave memtest with zeroed memory /
0,
0xffffffffffffffffULL,
0x5555555555555555ULL,
0xaaaaaaaaaaaaaaaaULL,
0x1111111111111111ULL,
0x2222222222222222ULL,
0x4444444444444444ULL,
0x8888888888888888ULL,
0x3333333333333333ULL,
0x6666666666666666ULL,
0x9999999999999999ULL,
0xccccccccccccccccULL,
0x7777777777777777ULL,
0xbbbbbbbbbbbbbbbbULL,
0xddddddddddddddddULL,
0xeeeeeeeeeeeeeeeeULL,
0x7a6c7258554e494cULL, / yeah 😉 */
};

static void reserve_bad_mem(u64 pattern, phys_addr_t start_bad, phys_addr_t end_bad)
{
pr_info(" %016llx bad mem addr %pa - %pa reserved\n",
pattern, &start_bad, &end_bad);
}

static void memtest(u64 pattern, phys_addr_t start_phys, phys_addr_t size)
{
u64 *p, *start, *end;
phys_addr_t start_bad, last_bad;
phys_addr_t start_phys_aligned;
const size_t incr = sizeof(pattern);

start_phys_aligned = ALIGN(start_phys, incr);
start = (u64 *)start_phys_aligned;
end = start + (size - (start_phys_aligned - start_phys)) / incr;
start_bad = 0;
last_bad = 0;

for (p = start; p < end; p++)
	*p = pattern;

for (p = start; p < end; p++, start_phys_aligned += incr) {
	if (*p == pattern)
		continue;
	if (start_phys_aligned == last_bad + incr) {
		last_bad += incr;
		continue;
	}
	if (start_bad)
		reserve_bad_mem(pattern, start_bad, last_bad + incr);
	start_bad = last_bad = start_phys_aligned;
}
if (start_bad)
	reserve_bad_mem(pattern, start_bad, last_bad + incr);

}

/* default is disabled */
static unsigned int memtest_pattern = ARRAY_SIZE(patterns);

void early_memtest(phys_addr_t start, phys_addr_t end)
{
unsigned int i;
unsigned int idx = 0;

if (!memtest_pattern)
	return;

pr_info("early_memtest: # of tests: %u\n", memtest_pattern);
for (i = memtest_pattern-1; i < UINT_MAX; --i) {
	//idx = i % ARRAY_SIZE(patterns);
	memtest(patterns[i], start, end);
}

}

還要進行交叉讀寫，比如 16 位讀取後 32 位寫入