Verilog实现eDP数据加解扰

eDP数据加解扰Verilog实现

原创于 2025-11-23 20:45:35 发布 · 985 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#fpga开发 #开发语言 #Verilog #Xilinx #DP #eDP #LFSR

DP 专栏收录该内容

5 篇文章

订阅专栏

基于eDP规范的LFSR多项式，提供一个完整的Verilog实现，包括加扰器和解扰器。

1. 基本加扰器模块

module edp_scrambler (
    input wire clk,          // 时钟
    input wire reset_n,      // 异步复位（低有效）
    input wire enable,       // 加扰使能
    input wire [7:0] data_in, // 输入数据（8位）
    input wire sync_reset,   // 同步复位（在每个Video Data Period开始）
    output wire [7:0] data_out // 加扰后输出数据
);

// LFSR状态寄存器
reg [15:0] lfsr;
wire [7:0] scramble_bits;

// 生成8个加扰比特
assign scramble_bits[0] = lfsr[15];
assign scramble_bits[1] = lfsr[14];
assign scramble_bits[2] = lfsr[13];
assign scramble_bits[3] = lfsr[12];
assign scramble_bits[4] = lfsr[11];
assign scramble_bits[5] = lfsr[10];
assign scramble_bits[6] = lfsr[9];
assign scramble_bits[7] = lfsr[8];

// 加扰输出：输入数据与LFSR序列异或
assign data_out = enable ? (data_in ^ scramble_bits) : data_in;

// LFSR反馈计算（根据多项式 X^16 + X^15 + X^13 + X^4 + 1）
wire feedback_bit;
assign feedback_bit = lfsr[15] ^ lfsr[14] ^ lfsr[12] ^ lfsr[3];

// LFSR更新逻辑
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        // 异步复位到非全零初始状态
        lfsr <= 16'hFFFF;  // eDP规范定义的初始值
    end else if (sync_reset) begin
        // 同步复位到初始状态
        lfsr <= 16'hFFFF;
    end else if (enable) begin
        // 正常操作：每次移位8位
        lfsr <= {lfsr[7:0], lfsr[15:8]};  // 循环移位8次的效果
        lfsr[15:8] <= lfsr[7:0] ^ {8{feedback_bit}};
    end
end

endmodule

2. 更精确的逐位加扰实现

module edp_scrambler_serial (
    input wire clk,
    input wire reset_n,
    input wire enable,
    input wire data_in_valid, // 输入数据有效
    input wire [7:0] data_in, // 输入数据
    input wire sync_reset,    // 同步复位
    output wire data_out_valid, // 输出数据有效
    output wire [7:0] data_out  // 加扰输出
);

reg [15:0] lfsr;
reg [7:0] input_buffer;
reg [7:0] output_buffer;
reg [2:0] bit_counter;
reg processing;

// 状态控制
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        processing <= 1'b0;
        bit_counter <= 3'b0;
        input_buffer <= 8'b0;
        output_buffer <= 8'b0;
    end else if (sync_reset) begin
        processing <= 1'b0;
        bit_counter <= 3'b0;
    end else begin
        if (data_in_valid && !processing) begin
            // 开始处理新的字节
            processing <= 1'b1;
            input_buffer <= data_in;
            bit_counter <= 3'b0;
        end else if (processing) begin
            // 处理当前字节的每一位
            if (bit_counter == 3'b111) begin
                processing <= 1'b0;
            end
            bit_counter <= bit_counter + 1'b1;
        end
    end
end

// LFSR反馈
wire feedback_bit;
assign feedback_bit = lfsr[15] ^ lfsr[14] ^ lfsr[12] ^ lfsr[3];

// LFSR更新和加扰
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        lfsr <= 16'hFFFF;
    end else if (sync_reset) begin
        lfsr <= 16'hFFFF;
    end else if (enable && processing) begin
        // 逐位更新LFSR并加扰
        lfsr <= {lfsr[14:0], feedback_bit};
        output_buffer[bit_counter] <= input_buffer[bit_counter] ^ lfsr[15];
    end
end

assign data_out_valid = (bit_counter == 3'b111) && processing;
assign data_out = output_buffer;

endmodule

3. 自同步解扰器

module edp_descrambler (
    input wire clk,
    input wire reset_n,
    input wire enable,
    input wire [7:0] scrambled_data, // 加扰后的输入数据
    output wire [7:0] descrambled_data // 解扰后数据
);

reg [15:0] lfsr;
wire [7:0] scramble_bits;

// 生成解扰序列
assign scramble_bits[0] = lfsr[15];
assign scramble_bits[1] = lfsr[14];
assign scramble_bits[2] = lfsr[13];
assign scramble_bits[3] = lfsr[12];
assign scramble_bits[4] = lfsr[11];
assign scramble_bits[5] = lfsr[10];
assign scramble_bits[6] = lfsr[9];
assign scramble_bits[7] = lfsr[8];

// 解扰：加扰数据再次与LFSR序列异或
assign descrambled_data = enable ? (scrambled_data ^ scramble_bits) : scrambled_data;

// LFSR更新 - 使用接收到的数据来同步
wire [7:0] received_bits;
assign received_bits = scrambled_data;

// 自同步LFSR更新
always @(posedge clk or negedge reset_n) begin
    if (!reset_n) begin
        lfsr <= 16'hFFFF;
    end else if (enable) begin
        // 使用接收到的数据更新LFSR
        // 注意：这是简化的8位并行更新，实际需要根据规范精确实现
        lfsr <= {lfsr[7:0], received_bits};
    end
end

endmodule

4. 完整的eDP加扰/解扰系统

module edp_scrambler_system (
    input wire clk,
    input wire reset_n,
    
    // 发送端接口
    input wire tx_valid,
    input wire [7:0] tx_data,
    input wire tx_sync_reset,
    output wire [7:0] tx_scrambled_data,
    
    // 接收端接口
    input wire rx_valid,
    input wire [7:0] rx_scrambled_data,
    output wire [7:0] rx_descrambled_data
);

// 发送端加扰器
edp_scrambler tx_scrambler (
    .clk(clk),
    .reset_n(reset_n),
    .enable(tx_valid),
    .data_in(tx_data),
    .sync_reset(tx_sync_reset),
    .data_out(tx_scrambled_data)
);

// 接收端解扰器
edp_descrambler rx_descrambler (
    .clk(clk),
    .reset_n(reset_n),
    .enable(rx_valid),
    .scrambled_data(rx_scrambled_data),
    .descrambled_data(rx_descrambled_data)
);

endmodule

5. 测试平台

module tb_edp_scrambler;

reg clk;
reg reset_n;
reg enable;
reg [7:0] data_in;
reg sync_reset;
wire [7:0] data_out;

// 实例化加扰器
edp_scrambler uut (
    .clk(clk),
    .reset_n(reset_n),
    .enable(enable),
    .data_in(data_in),
    .sync_reset(sync_reset),
    .data_out(data_out)
);

// 时钟生成
always #5 clk = ~clk;

// 测试序列
initial begin
    // 初始化
    clk = 0;
    reset_n = 0;
    enable = 0;
    data_in = 8'h00;
    sync_reset = 0;
    
    // 复位
    #20 reset_n = 1;
    
    // 测试1: 同步复位
    #10 sync_reset = 1;
    #10 sync_reset = 0;
    
    // 测试2: 加扰使能
    enable = 1;
    data_in = 8'hAA;
    #10;
    data_in = 8'h55;
    #10;
    data_in = 8'hFF;
    #10;
    data_in = 8'h00;
    #10;
    
    // 测试3: 禁用加扰
    enable = 0;
    data_in = 8'hAA;
    #10;
    
    $finish;
end

// 波形输出
initial begin
    $dumpfile("edp_scrambler.vcd");
    $dumpvars(0, tb_edp_scrambler);
end

endmodule