识别DDR故障的“数据总线测试算法”

要通过软件精准定位具体是哪一根数据线（DQ）或哪一个字节通道（Byte Lane / DQS）存在物理故障，核心思想是"注入特定测试图案 (Test Patterns) -> 读回 -> 异或运算 (XOR) 提取错误掩码"。

在嵌入式裸机（Bootloader/U-Boot阶段）或关闭了 MMU/Cache 的内核模块中，可以编写专门的"数据总线测试算法"。

1. 核心工具：异或错误掩码 (XOR Error Mask)

无论你写入什么数据，通过将"期望读到的值"与"实际读到的值"进行按位异或（^），得出的结果就是故障物理位置的直接映射。

2. 识别 Byte Lane 故障的掩码特征

在 32 位 DDR 系统中，数据总线由 32 根 DQ 线组成，分为 4 个 Byte Lane，每个 Lane 由 8 根 DQ 和 1 根 DQS（数据选通时钟）控制。通过观察 error_mask 中 1 出现的位置，可以直接定损：

Lane 0 故障 (DQ0-DQ7, 对应 DQS0): error_mask 总是形如 0x000000XX（低 8 位出错）。
Lane 1 故障 (DQ8-DQ15, 对应 DQS1): error_mask 总是形如 0x0000XX00。
Lane 2 故障 (DQ16-DQ23, 对应 DQS2): error_mask 总是形如 0x00XX0000。（这正是你提到的第 16-23 位）
Lane 3 故障 (DQ24-DQ31, 对应 DQS3): error_mask 总是形如 0xXX000000。

如果整个 Lane 报错（比如掩码是 0x00FF0000 或随机乱码但被限制在中间两个字节），通常说明是该 Lane 的 DQS 信号线（时钟偏差） 或 VREF 供电/阻抗匹配 存在严重问题。

3. 针对不同硬件缺陷的测试图案 (Test Patterns)

为了逼迫硬件暴露特定类型的物理缺陷，你需要轮询发送以下三种经典图案：

A. Walking 1s / Walking 0s（走1 / 走0测试）

图案： 0x00000001, 0x00000002, 0x00000004 ... 直到 0x80000000。
探测目标： 专门检测 单一 DQ 针脚短路/断路 ，或者相邻数据线之间的物理粘连（Short）。
现象： 如果你写 0x00010000（第16位置1），读回来却是 0x00030000（第16和17位都是1），说明 PCB 板上 DQ16 和 DQ17 的走线短路了。

B. Checkerboard（棋盘格/交替翻转）

图案： 连续写入 0xAAAAAAAA (101010...)，再覆盖写入 0x55555555 (010101...)。
探测目标： 专门检测相邻信号线的高频串扰 (Crosstalk) 和寄生电容问题。
现象： 当总线上 0 和 1 交替密布时，电磁干扰最大。如果这种图案下某个特定的 Byte Lane 出现极高的误码率，说明该区域的 PCB 走线间距过窄或地线屏蔽没做好。

C. SSO Noise Test（同步开关输出噪声测试）

图案： 全 0 (0x00000000) 瞬间切换到全 1 (0xFFFFFFFF)。
探测目标： 供电稳定性 (地弹 Ground Bounce 和电源压降 VDD Drop)。
现象： 当 32 根数据线同时从 0 翻转到 1 时，瞬间电流抽取极大。如果某个 Byte Lane 附近的去耦电容（Decoupling Capacitor）失效或虚焊，电压跌落会导致该 Lane 的 DQS 采样失败，从而读出大量随机乱码。

cpp 复制代码

#include <linux/module.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/delay.h>
#include <linux/moduleparam.h>
#include <linux/kthread.h>
#include <linux/sched.h>

/* * ========================================================================
 * 模块参数 (可通过 insmod 动态传参)
 * ======================================================================== */
static unsigned long long phys_addr = 0x16600000;
module_param(phys_addr, ullong, 0644);

static unsigned long test_size = 0x1000000; // 默认 16MB
module_param(test_size, ulong, 0644);

static int mode = 0x1F;
module_param(mode, int, 0644);

static int loop_count = 100;
module_param(loop_count, int, 0644);

static int loop_delay_ms = 10;
module_param(loop_delay_ms, int, 0644);

// 【新增】物理数据总线宽度 (16, 32, 64)。决定了物理引脚的折叠映射方式
static int bus_width = 32;
module_param(bus_width, int, 0644);
MODULE_PARM_DESC(bus_width, "Physical DDR data bus width: 16, 32, or 64 (default: 32)");

static void __iomem *ddr_base;
static struct task_struct *test_thread;

/* * ========================================================================
 * 模块 1: 数据总线异或压测 (兼容 16/32/64-bit 物理映射)
 * ======================================================================== */
static int do_xor_test(const char *test_name, u64 pattern, int current_loop)
{
    u32 pat_l, pat_h, act_l, act_h;
    u64 error_mask;
    int error_count = 0;
    u32 i;
    u32 words_to_test = test_size / 4;
    
    // 根据物理总线宽度，格式化测试图案以对齐物理针脚
    if (bus_width == 16) {
        u32 p32 = ((pattern & 0xFFFF) << 16) | (pattern & 0xFFFF);
        pat_l = p32; pat_h = p32;
    } else if (bus_width == 32) {
        pat_l = pattern & 0xFFFFFFFF; pat_h = pattern & 0xFFFFFFFF;
    } else { // 64-bit
        pat_l = pattern & 0xFFFFFFFF; pat_h = (pattern >> 32) & 0xFFFFFFFF;
    }

    // 1. 块写入
    for (i = 0; i < words_to_test; i += 2) {
        __raw_writel(pat_l, ddr_base + (i * 4));
        if (i + 1 < words_to_test)
            __raw_writel(pat_h, ddr_base + ((i + 1) * 4));
        if (i % 1024 == 0) cond_resched();
    }
    wmb(); 
    
    // 2. 块读取与比对
    for (i = 0; i < words_to_test; i += 2) {
        act_l = __raw_readl(ddr_base + (i * 4));
        act_h = (i + 1 < words_to_test) ? __raw_readl(ddr_base + ((i + 1) * 4)) : pat_h;
        rmb();
        
        if (act_l != pat_l || act_h != pat_h) {
            error_count++;
            
            if (error_count <= 5) {
                u32 err_l = act_l ^ pat_l;
                u32 err_h = act_h ^ pat_h;
                
                // 将逻辑错误折叠为物理引脚错误掩码
                if (bus_width == 64) {
                    error_mask = ((u64)err_h << 32) | err_l;
                } else if (bus_width == 32) {
                    error_mask = err_l | err_h;
                } else {
                    error_mask = (err_l & 0xFFFF) | (err_l >> 16) | (err_h & 0xFFFF) | (err_h >> 16);
                }

                pr_err("[DDR_LOOP %d] %s FAILED! Addr: 0x%llx\n", current_loop, test_name, phys_addr + (i * 4));
                
                // Byte Lane 诊断 (支持最高 64-bit 的 8 Lane 诊断)
                if (error_mask & 0x00000000000000FFULL) pr_err(" -> DIAGNOSIS: Byte Lane 0 (DQ0-7) Error\n");
                if (error_mask & 0x000000000000FF00ULL) pr_err(" -> DIAGNOSIS: Byte Lane 1 (DQ8-15) Error\n");
                if (bus_width >= 32) {
                    if (error_mask & 0x0000000000FF0000ULL) pr_err(" -> DIAGNOSIS: Byte Lane 2 (DQ16-23) Error\n");
                    if (error_mask & 0x00000000FF000000ULL) pr_err(" -> DIAGNOSIS: Byte Lane 3 (DQ24-31) Error\n");
                }
                if (bus_width == 64) {
                    if (error_mask & 0x000000FF00000000ULL) pr_err(" -> DIAGNOSIS: Byte Lane 4 (DQ32-39) Error\n");
                    if (error_mask & 0x0000FF0000000000ULL) pr_err(" -> DIAGNOSIS: Byte Lane 5 (DQ40-47) Error\n");
                    if (error_mask & 0x00FF000000000000ULL) pr_err(" -> DIAGNOSIS: Byte Lane 6 (DQ48-55) Error\n");
                    if (error_mask & 0xFF00000000000000ULL) pr_err(" -> DIAGNOSIS: Byte Lane 7 (DQ56-63) Error\n");
                }
            }
        }
        if (i % 1024 == 0) cond_resched();
    }
    return error_count;
}

/* * ========================================================================
 * 模块 2: 地址总线 (ADDR) 折叠探测
 * ======================================================================== */
static int do_address_bus_test(int current_loop)
{
    u32 pattern = 0xAAAAAAAA;
    u32 anti_pattern = 0x55555555;
    u32 offset, actual;
    int error_count = 0;
    
    __raw_writel(pattern, ddr_base);
    wmb();

    for (offset = 4; offset < test_size; offset <<= 1) {
        __raw_writel(anti_pattern, ddr_base + offset);
        wmb();
    }

    actual = __raw_readl(ddr_base);
    rmb();
    if (actual != pattern) {
        pr_err("[DDR_LOOP %d] CRITICAL: Address Bus (ADDR) Short/Tie-down!\n", current_loop);
        pr_err(" -> DIAGNOSIS: Base address overwritten. Exp: 0x%08x, Act: 0x%08x\n", pattern, actual);
        return 1; 
    }

    for (offset = 4; offset < test_size; offset <<= 1) {
        actual = __raw_readl(ddr_base + offset);
        rmb();
        if (actual != anti_pattern) {
            error_count++;
            if (error_count <= 5) {
                pr_err("[DDR_LOOP %d] ADDR Pin FAILED at offset 0x%08x! Act: 0x%08x\n", current_loop, offset, actual);
            }
        }
    }
    return error_count;
}

/* * ========================================================================
 * 模块 3: Anti-DBI SSO 供电测试 (兼容 DDR4 的数据总线反转特性)
 * ======================================================================== */
static int do_sso_test(int current_loop)
{
    u32 actual, i;
    u32 words_to_test = test_size / 4;
    u32 sso_pat1 = 0xAAAAAAAA; // 50% 占空比，绕过 DDR4 DBI 机制
    u32 sso_pat2 = 0x55555555;
    int error_count = 0;

    // 第一阶段：蓄力 (铺满 0xAA)
    for (i = 0; i < words_to_test; i++) __raw_writel(sso_pat1, ddr_base + (i*4));
    mb(); 
    
    // 第二阶段：全总线瞬间释放电流 (强制翻转所有物理引脚到 0x55)
    for (i = 0; i < words_to_test; i++) __raw_writel(sso_pat2, ddr_base + (i*4));
    mb(); 
    
    // 校验
    for (i = 0; i < words_to_test; i++) {
        actual = __raw_readl(ddr_base + (i*4));
        rmb();
        if (actual != sso_pat2) {
            error_count++;
            if (error_count == 1) { // 只报一次
                pr_err("[DDR_LOOP %d] Anti-DBI SSO Test FAILED!\n", current_loop);
                pr_err(" -> DIAGNOSIS: Vref/VDDQ Power PDN Collapse (Ground Bounce)\n");
            }
        }
    }
    return error_count;
}

/* * ========================================================================
 * 后台温箱老化线程 (Kthread)
 * ======================================================================== */
static int ddr_test_thread_fn(void *data)
{
    int current_loop = 0;
    int total_errors = 0;
    int err_this_loop;
    int i;

    pr_info("[DDR_TEST] Background aging thread started (Bus Width: %d-bit).\n", bus_width);

    while (!kthread_should_stop()) {
        current_loop++;
        err_this_loop = 0;

        if (mode & 0x01) {
            err_this_loop += do_xor_test("Checkerboard_A", 0xAAAAAAAAAAAAAAAAULL, current_loop);
            err_this_loop += do_xor_test("Checkerboard_5", 0x5555555555555555ULL, current_loop);
        }
        
        if (mode & 0x02) {
            // 根据物理总线宽度决定 Walking 1s 的深度 (跑16、32还是64根引脚)
            for (i = 0; i < bus_width; i++) 
                err_this_loop += do_xor_test("Walking_1s", 1ULL << i, current_loop);
        }
        
        if (mode & 0x04) {
            for (i = 0; i < bus_width; i++) 
                err_this_loop += do_xor_test("Walking_0s", ~(1ULL << i), current_loop);
        }

        if (mode & 0x08) {
            err_this_loop += do_address_bus_test(current_loop);
        }

        if (mode & 0x10) {
            err_this_loop += do_sso_test(current_loop);
        }

        total_errors += err_this_loop;

        pr_info("[DDR_TEST] Heartbeat: Loop %d completed. Accumulated Errors: %d\n", current_loop, total_errors);

        if (loop_count != 0 && current_loop >= loop_count) {
            pr_info("[DDR_TEST] Reached target loop count: %d\n", loop_count);
            break;
        }

        if (loop_delay_ms > 0) msleep(loop_delay_ms);
    }

    pr_info("[DDR_TEST] Thread Exit. Total loops: %d, Total errors: %d\n", current_loop, total_errors);
    return 0;
}

/* * ========================================================================
 * 驱动初始化与卸载
 * ======================================================================== */
static int __init ddr_test_init(void)
{
    // 参数有效性校验
    if (bus_width != 16 && bus_width != 32 && bus_width != 64) {
        pr_err("[DDR_TEST] Invalid bus_width: %d. Must be 16, 32, or 64.\n", bus_width);
        return -EINVAL;
    }

    pr_info("[DDR_TEST] Target PA: 0x%llx, Size: %lu Bytes, Width: %d-bit\n", phys_addr, test_size, bus_width);

    ddr_base = ioremap((phys_addr_t)phys_addr, test_size);
    if (!ddr_base) {
        pr_err("[DDR_TEST] Failed to map physical address!\n");
        return -ENOMEM;
    }

    test_thread = kthread_run(ddr_test_thread_fn, NULL, "ddr_aging_test");
    if (IS_ERR(test_thread)) {
        pr_err("[DDR_TEST] Failed to spawn kthread!\n");
        iounmap(ddr_base);
        return PTR_ERR(test_thread);
    }

    return 0; 
}

static void __exit ddr_test_exit(void)
{
    if (test_thread) kthread_stop(test_thread);
    if (ddr_base) iounmap(ddr_base);
    pr_info("[DDR_TEST] Module Unloaded safely.\n");
}

module_init(ddr_test_init);
module_exit(ddr_test_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Driver Engineer");
MODULE_DESCRIPTION("Universal DDR3/DDR4/LPDDR4 Physical Pin Diagnosis Tool");

bash 复制代码

# 替换为你的目标内核源码树路径
KERNEL_DIR ?= /path/to/your/linux-kernel-source
# 替换为你的交叉编译器前缀 (比如 aarch64-linux-gnu- 或 arm-linux-gnueabihf-)
CROSS_COMPILE ?= aarch64-linux-gnu-
# 指定目标架构 (arm64 或 arm)
ARCH ?= arm64

obj-m := ddr_lane_test.o

all:
	$(MAKE) -C $(KERNEL_DIR) M=$(PWD) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules

clean:
	$(MAKE) -C $(KERNEL_DIR) M=$(PWD) clean

参数名	含义与作用	默认值	推荐配置 / 取值范围
`phys_addr`	测试基地址：你要压测的 DDR 物理首地址	`0x16600000`	必须是一块空闲的连续物理内存段。
`test_size`	测试大小 (字节)：决定覆盖范围和地址线深度	`16777216` (16MB)	至少填 `16777216` 才能测满 A0~A23 地址线。
`bus_width`	物理总线宽度：决定数据线折叠与诊断逻辑	`32`	IPC填 `16` 或 `32`；NVR/服务器填 `64`。
`loop_count`	循环次数：后台跑几轮	`100`	`0` 表示无限循环（温箱专用），普通压测填 `1000`。
`loop_delay_ms`	循环间隙休息：防止纯死循环导致 CPU 热宕机	`10`	推荐 `10`~`50` 毫秒。
`mode`	测试项位掩码：自由开启或关闭特定测试	`31` (0x1F)	见下方详解

关于 mode 参数的位掩码算法（你想跑哪个，就把对应的值加起来）：

1 = 跑 Checkerboard (测串扰)
2 = 跑 Walking 1s (测引脚短路/断路)
4 = 跑 Walking 0s (测引脚对电源短路)
8 = 跑 Address Bus (测地址线重叠覆盖)
16 = 跑 SSO (测瞬间大电流供电稳不稳)
总和 = 1+2+4+8+16 = 31。传 mode=31 就是全测。只想测 SSO 和走1测试，就传 mode=18 (16+2)。

以下是你在实际硬件联调时，最常用的四种配置命令：

场景 1：默认快速体检 (日常开发排错)

什么参数都不加，直接加载。它会自动以 32-bit 位宽，测试 0x16600000 开始的 16MB 空间，跑 100 轮全项测试。

复制代码

insmod ddr_lane_test.ko

场景 2：温箱极限拷机 (通宵抗老化测试) ⭐️最常用

把板子丢进温箱，设置为 无限循环 (loop_count=0)，每轮休息 50ms。这会榨干 DDR 的电气性能。

复制代码

insmod ddr_lane_test.ko phys_addr=0x16600000 test_size=16777216 loop_count=0 loop_delay_ms=50 bus_width=32 mode=31

提示：跑起来后你可以放心地退出终端，它会在后台内核线程里一直跑。

场景 3：高端 64-bit DDR4 主板压测

如果你换了一块带 DDR4 的高级板子（比如带 4 颗 16-bit 颗粒拼接成 64-bit），一定要修改总线宽度，否则物理引脚诊断会错乱。

复制代码

insmod ddr_lane_test.ko bus_width=64 test_size=33554432

(这里顺便把 test_size 提到了 32MB，测得更深)

场景 4：针对性死磕"供电问题" (抓拍瞬态宕机)

如果示波器看到 VDDQ 电压有毛刺，怀疑是供电电容虚焊。关掉其他耗时的测试，专门疯狂循环跑 SSO (mode=16) 瞬间拉高电流。

复制代码

insmod ddr_lane_test.ko mode=16 loop_count=5000 loop_delay_ms=1

怎么看结果和停止测试？

1. 实时查看进度与报错： 由于是后台运行，请使用 dmesg 查看：

复制代码

# 实时滚动查看内核打印日志
dmesg -w | grep DDR_TEST

2. 停止测试： 当你从温箱拿出来，或者想强行中断测试时，直接卸载驱动，它会自动安全地杀掉后台线程：

复制代码

rmmod ddr_lane_test