4. CRC硬件实现：从LFSR到并行计算的实战之路

聊到CRC的硬件实现，好多做软件出身的朋友第一反应是“查表”。嗯，查表在软件里确实好用，可一旦跑到FPGA或者ASIC里，你会发现LFSR——线性反馈移位寄存器，才是真正的底子。我个人习惯把LFSR看成是CRC的“原生心脏”，搞懂了它，后面并行计算那些花活，就全通了。

4.1 LFSR的工作原理——一个移位寄存器的自白

LFSR这东西，说白了就是一个带反馈的移位寄存器。每一位寄存器存一个比特，每个时钟周期，数据往右挪一位，最左边那一位则由某些特定位的异或结果来填充。

为什么会这样设计？想想看，CRC的本质是多项式除法。LFSR的反馈路径，其实就是多项式里那些系数为1的项。数据一位一位送进去，同步完成除法运算，最后留在寄存器里的余数，就是CRC校验值。

4.2 串行CRC硬件实现

先看最简单的串行实现。假设我们要实现多项式 CRC-8: x⁸ + x² + x + 1，也就是0x07（忽略最高位）。

硬件结构如下：

• 8个D触发器组成移位链，编号Q7到Q0
• 反馈抽头：Q0的输出，与输入数据异或后，反馈到Q7、Q2、Q1的输入
• 每个时钟周期，数据从低位到高位依次输入

伪代码实现：

// 串行CRC-8的Verilog描述
always @(posedge clk or negedge rst_n) begin
    if (!rst_n) begin
        lfsr <= 8'd0;
    end else begin
        // feedback = data_in ^ lfsr[0]
        // Q7 <= feedback
        // Q6 <= Q7
        // Q5 <= Q6
        // Q4 <= Q5
        // Q3 <= Q4
        // Q2 <= Q3 ^ feedback
        // Q1 <= Q2 ^ feedback
        // Q0 <= Q1
        lfsr <= {
            data_in ^ lfsr[0],  // Q7
            lfsr[7],            // Q6
            lfsr[6],            // Q5
            lfsr[5],            // Q4
            lfsr[4],            // Q3
            lfsr[3] ^ data_in ^ lfsr[0], // Q2
            lfsr[2] ^ data_in ^ lfsr[0], // Q1
            lfsr[1]             // Q0
        };
    end
end

4.3 并行CRC——把串行展开成矩阵

串行CRC的缺点是慢——每个时钟只能处理1比特。如果数据总线是8位、16位甚至32位呢？你总不能把数据拆成单比特慢慢算吧，那延迟谁都受不了。

并行CRC的核心理念：把LFSR的N个时钟周期的状态转移，合并成一个组合逻辑函数。说白了，就是一次算出N比特数据的CRC结果。

实现方法有两种：

• 矩阵法：写出LFSR的状态转移矩阵，然后做N次乘法，得到一个组合逻辑
• 推导法：手动展开每一步的异或表达式，合并同类项

以CRC-8为例，8位并行计算的推导思路：

// 串行迭代步骤（伪代码）
// step 0: crc_next = f(crc_current, data[0])
// step 1: crc_next = f(crc_next, data[1])
// ...
// step 7: crc_next = f(crc_next, data[7])

// 合并后，每个crc_next[i]都是crc_current[7:0]和data[7:0]的异或组合

实际应用中，我们通常用工具自动生成并行CRC的表达式。比如用Python的pycrc库，或者直接在网上查现成的并行CRC表。我的习惯是先用软件验证算法正确，再转成硬件描述。

参数	串行CRC	并行CRC (8-bit)
每时钟处理位数	1 bit	8 bits
逻辑资源消耗	低（约N个寄存器+几个门）	高（组合逻辑随位宽指数增长）
适用场景	低速串行接口	高速并行总线
最大频率	高（路径短）	较低（路径长）

4.4 并行CRC的设计实战

我来举个例子，展示8位输入、CRC-8的并行表达式是如何推导的。假设初始值为0，多项式为0x07。

第一步：写出单步状态转移方程。对于每个寄存器，lfsr_next[i]是当前状态和输入的函数。

第二步：将8次迭代展开。比如我们想知道8个时钟后lfsr_next[7]的值，就把每一步的表达式代进去，合并异或项。

第三步：用卡诺图或者布尔代数化简。结果会是一组异或表达式，每个表达式约3-6个输入变量。

最终的并行CRC逻辑，通常用assign语句实现：

// 8位并行CRC-8的Verilog实现片段（多项式0x07）
wire [7:0] crc_next;
assign crc_next[0] = crc[1] ^ data[7];
assign crc_next[1] = crc[2] ^ data[6];
assign crc_next[2] = crc[3] ^ crc[0] ^ data[5] ^ data[7];
assign crc_next[3] = crc[4] ^ crc[1] ^ data[4] ^ data[6];
assign crc_next[4] = crc[5] ^ crc[2] ^ data[3] ^ data[5];
assign crc_next[5] = crc[6] ^ crc[3] ^ data[2] ^ data[4];
assign crc_next[6] = crc[7] ^ crc[4] ^ data[1] ^ data[3];
assign crc_next[7] = crc[5] ^ data[0] ^ data[2];

4.5 并行CRC的工程权衡

并行CRC虽然快，但不是想扩多宽就扩多宽。我遇到过一位工程师，硬要把32位并行CRC用在1.25Gbps的链路上。结果时序收敛不了，迟延路径加起来有20多级XOR门。

常用的解决方案：

• 流水线：在组合逻辑中间插入寄存器，切断长路径
• 折叠实现：如果位宽太大，拆成两个16位并行CRC轮流算
• 查表+组合：用ROM查部分结果，再组合出最终值

我个人推荐的做法：在FPGA里，8位并行CRC基本没什么压力；16位就要小心了，看综合工具能不能推高频率；32位及以上，基本都得做流水线或者拆模块。

下面这张图展示了从串行LFSR到并行CRC的演进路径，以及设计时需要考虑的关键环节。你可以把它当成一个检核清单。

4.6 硬件实现的常见陷阱

最后，我总结几条在项目中摔过的跟头，供你参考：

• 初始值问题：CRC硬件复位后，寄存器是全0还是全1？不同协议要求不同。比如CRC-32初始值是全1，如果你忘了这茬，算出来的结果肯定不对。
• 输入数据顺序：是先送高位还是低位？这个在并行实现里容易搞混。我的经验是：先确认协议文档里写的“bit ordering”。
• 输出结果处理：有些协议要求输出结果再取反（比如以太网CRC-32）。别在最后一步漏了。
• 综合工具优化：并行CRC的组合逻辑，综合工具会自动优化。但如果你手动写了一大堆assign，工具可能会做重复运算。我建议先看综合后的网表，确认逻辑深度是不是在可接受范围内。