linux-imx

// SPDX-License-Identifier: GPL-2.0

#include <linux/kernel.h>

#include <linux/types.h>

#include <linux/init.h>

#include <linux/memblock.h>

​

static u64 patterns[] __initdata = {

    /* 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 __init 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",

        cpu_to_be64(pattern), &start_bad, &end_bad);

    memblock_reserve(start_bad, end_bad - start_bad);

}

​

static void __init 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 = __va(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);