Subversion Repositories bch_configurable

///-----------------------------------------

///introduce:

///bch encoder

///author:jiml

///record:

///2015.1.31    initial

///-----------------------------------------

`timescale 1ns/100ps

module test_bch_encode

#(

parameter C_DWIDTH = 128,                //input data width

parameter C_COEF_NUM = 43,               //correct threshold

parameter C_PRIMPOLY_ORDER = 14,         //order of eigenpolynomial

parameter C_PRIM_POLY = 15'h4443         //eigenpolynomial

)

(

input                     I_clk       ,

input                     I_rst       ,

input      [C_DWIDTH-1:0] I_data      ,  //input data

input                     I_data_v    ,  //input data available

input                     I_data_sof  ,  //input data frame start

input                     I_data_eof  ,  //input data frame end

output reg [C_DWIDTH-1:0] O_data      ,  //output data

output reg                O_data_v    ,  //output data available

output reg                O_data_sof  ,  //output data frame start

output reg                O_data_eof     //output data frame end

);

///----------------------------------------

///parameter and variable

///----------------------------------------

localparam C_REG_LEN = C_COEF_NUM*C_PRIMPOLY_ORDER;

localparam C_GEN_WIDTH = F_TOTAL_NUM(0);

localparam C_ECC_PERIOD = F_DIV(C_GEN_WIDTH,C_DWIDTH);

localparam C_CNT_WIDTH = GETASIZE(C_ECC_PERIOD);

localparam C_GENPOLY = F_GEN_POLY(0);

reg [C_GEN_WIDTH-1:0] S_reg = 0;

reg [C_CNT_WIDTH-1:0] S_ecc_cnt = 0;

reg S_ecc_v = 0;

//---------------------------------------------

//function

//---------------------------------------------

//calculate length of encode polynomial

function integer F_TOTAL_NUM;

input red;

integer i,j;

integer temp;

reg [2**C_PRIMPOLY_ORDER-2:0] S_flag;

begin

        F_TOTAL_NUM = 0;

    for(i=0;i<C_COEF_NUM;i=i+1)

        begin

                S_flag = 0;

                for(j=1;j<=C_PRIMPOLY_ORDER;j=j+1)

                begin

                        temp = (2*i+1)*(2**(j-1));

                        while(temp > 2**C_PRIMPOLY_ORDER-2)

                                temp = temp - (2**C_PRIMPOLY_ORDER-1);

                    if(!S_flag[temp])

                        begin

                            S_flag[temp] = 1;

                                F_TOTAL_NUM=F_TOTAL_NUM+1;

                        end

                end

        end

end

endfunction

//integer division

function integer F_DIV;

input integer S_DIVIDEND;

input integer S_DIVIDER;

begin

    F_DIV = (S_DIVIDEND-1)/S_DIVIDER;

end

endfunction

//polynomial multiplication in Galois Field

function [C_PRIMPOLY_ORDER-1:0] F_mult;

input [C_PRIMPOLY_ORDER-1:0] S_data1;

input [C_PRIMPOLY_ORDER-1:0] S_data2;

reg [C_PRIMPOLY_ORDER*2-1:0] S_temp;

integer i;

begin

    S_temp = 0;

        F_mult = 0;

        for(i=0;i<C_PRIMPOLY_ORDER;i=i+1)

        begin

            S_temp = S_temp ^ ({(C_PRIMPOLY_ORDER*2){S_data1[i]}} & (S_data2<<i));

        end

        for(i=0;i<C_PRIMPOLY_ORDER*2;i=i+1)

        begin

                F_mult = {F_mult[C_PRIMPOLY_ORDER-2:0],S_temp[C_PRIMPOLY_ORDER*2-1-i]} ^ (C_PRIM_POLY[C_PRIMPOLY_ORDER-1:0] & {C_PRIMPOLY_ORDER{F_mult[C_PRIMPOLY_ORDER-1]}});

        end

end

endfunction

//element generation in Galois Field

function [C_PRIMPOLY_ORDER-1:0] F_gen;

input [C_PRIMPOLY_ORDER-1:0] S_init;

input integer S_times;

integer i;

begin

        F_gen = S_init;

    for(i=0;i<S_times;i=i+1)

        begin

            if(F_gen[C_PRIMPOLY_ORDER-1])

                    F_gen = (F_gen<<1) ^ C_PRIM_POLY[C_PRIMPOLY_ORDER-1:0];

                else

                    F_gen = (F_gen<<1);

        end

end

endfunction

//encode polynomial generation

function [C_GEN_WIDTH:0] F_GEN_POLY;

input red;

integer i,j,k;

integer pointer;

reg [2**C_PRIMPOLY_ORDER-2:0] S_flag;

reg [C_PRIMPOLY_ORDER-1:0] S_temp [C_GEN_WIDTH:0]; //every reg is C_PRIMPOLY_ORDER width, represent a element 

reg [C_PRIMPOLY_ORDER-1:0] S_temp2;

begin

        F_GEN_POLY = 0;

        for(i=0;i<=C_PRIMPOLY_ORDER;i=i+1)

                S_temp[i] = C_PRIM_POLY[i];                //least C_PRIMPOLY_ORDER bits are eigenpolynomial

        for(i=C_PRIMPOLY_ORDER+1;i<=C_GEN_WIDTH;i=i+1)

                S_temp[i] = 0;

        for(i=1;i<C_COEF_NUM;i=i+1)    //encode polynomial include C_COEF_NUM polynomials

        begin

                S_flag = 0;

            for(j=1;j<=C_PRIMPOLY_ORDER;j=j+1)  //each polynomial have at most C_PRIMPOLY_ORDER element

                begin

                        pointer = (2*i+1)*(2**(j-1));

                        while(pointer>(2**C_PRIMPOLY_ORDER-2))

                                pointer = pointer - (2**C_PRIMPOLY_ORDER-1);

                    if(!S_flag[pointer])            //flag is a marker to indicate element exists or not

                        begin

                            S_flag[pointer] = 1;

                                S_temp2 = F_gen(1,pointer);

                                for(k=C_GEN_WIDTH-1;k>0;k=k-1)   //each polynomial have at most C_PRIMPOLY_ORDER multiplication

                                begin

                                    S_temp[k]= F_mult(S_temp[k],S_temp2) ^ S_temp[k-1]; //all the reg need to shift in each multiplication

                                end

                                S_temp[0] = F_mult(S_temp[0],S_temp2);

                                S_temp[C_GEN_WIDTH] = S_temp[C_GEN_WIDTH-1];

                        end

                end

        end

        for(i=0;i<C_GEN_WIDTH;i=i+1)

        F_GEN_POLY[i] = (S_temp[i] == 1);     //finally the S_temp should only be 1 or 0

end

endfunction

//width calculation

function integer GETASIZE;

input integer a;

integer i;

begin

    for(i=1;(2**i)<=a;i=i+1)

      begin

      end

    GETASIZE = i;

end

endfunction

//polynomial multiplication between encode polynomial and input data

function [C_GEN_WIDTH-1:0] F_reg_update;

input [C_GEN_WIDTH-1:0] S_reg_ori;

input [C_DWIDTH-1:0] S_data;

integer i;

reg S_temp1;

begin

        F_reg_update = S_reg_ori;

        for(i=0;i<C_DWIDTH;i=i+1)

        begin

                S_temp1 = F_reg_update[C_GEN_WIDTH-1] ^ S_data[C_DWIDTH-1-i];

                F_reg_update[C_GEN_WIDTH-1:0] = {F_reg_update[C_GEN_WIDTH-2:0],1'b0} ^ ({C_GEN_WIDTH{S_temp1}} & C_GENPOLY[C_GEN_WIDTH-1:0]);

        end

end

endfunction

//-----------------------------------------------

//encode

//-----------------------------------------------

always @(posedge I_clk)

begin

        if(I_data_v)

            S_reg <= F_reg_update(S_reg,I_data);

        else if(S_ecc_v)

            S_reg <= S_reg << C_DWIDTH;

end

//output counter

always @(posedge I_clk)

begin

    if(S_ecc_v)

            S_ecc_cnt <= S_ecc_cnt + 'd1;

        else

            S_ecc_cnt <= 'd0;

end

always @(posedge I_clk)

begin

    if(I_data_eof && I_data_v)

            S_ecc_v <= 1'b1;

        else if(S_ecc_cnt == C_ECC_PERIOD && S_ecc_v)

            S_ecc_v <= 1'b0;

end

//data out

always @(posedge I_clk)

begin

    if(S_ecc_v)

            O_data <= (C_GEN_WIDTH >= C_DWIDTH) ? S_reg[C_GEN_WIDTH-1-:C_DWIDTH] : (S_reg << (C_DWIDTH-C_GEN_WIDTH));

        else

            O_data <= I_data;

        O_data_v <= I_data_v || S_ecc_v;

        O_data_sof <= I_data_sof;

        O_data_eof <= (S_ecc_cnt == C_ECC_PERIOD) && S_ecc_v;

end

endmodule