URL https://opencores.org/ocsvn/bch_configurable/bch_configurable/trunk

Subversion Repositories bch_configurable

[/] [bch_configurable/] [trunk/] [src/] [test_bch_bm.v] - Blame information for rev 2

Details | Compare with Previous | View Log


///-----------------------------------------
///introduce:
///bch error position polynomial calculate by bm algorithm
///author:jiml
///record:
///2015.1.31    initial
///2015.2.2     S_syndrome modified from parallel to serial
///-----------------------------------------
`timescale 1ns/100ps
module test_bch_bm
#(
    parameter C_PRIMPOLY_ORDER = 14,          //order of eigenpolynomial
    parameter C_COEF_NUM = 43,                //correct threshold
        parameter C_PRIMPOLY = 15'h4443           //eigenpolynomial
)
(
input                                                           I_clk        ,
input                                                           I_rst        ,
input      [C_PRIMPOLY_ORDER*C_COEF_NUM-1:0]                    I_syndrome   , //syndrome cascaded
input                                                           I_syndrome_v , //syndrome available
output reg [C_PRIMPOLY_ORDER*C_COEF_NUM-1+C_PRIMPOLY_ORDER:0]   O_err_pos    , //error position polynomial
(* MAX_FANOUT=30 *)output reg                                   O_err_pos_v    //error position polynomial available
);
 
//--------------------------------
//parameter and variable
//--------------------------------
localparam C_CYCLE = GETASIZE(C_COEF_NUM);
integer i,j,jj;
reg [C_CYCLE+1:0]                             S_syndrome_v_slr = 0;
reg                                           S_syndrome_v_all = 0;
reg [C_PRIMPOLY_ORDER-1:0]                    S_syndrome [2*C_COEF_NUM-1:0];
reg                                           S_syndrome_v = 0;
reg                                           S_syndrome_v_d = 0;
reg                                           S_syndrome_v_2d = 0;
reg                                           S_syndrome_v_3d = 0;
reg                                           S_bm_cnt2_d = 0;
reg [C_PRIMPOLY_ORDER*C_COEF_NUM-1:0]         S_syndrome_seq = 0;
reg [C_PRIMPOLY_ORDER*C_COEF_NUM-1:0]         S_syndrome_seq2 = 0;
reg [C_PRIMPOLY_ORDER-1:0]                    S_syndrome_new = 0;
reg [C_PRIMPOLY_ORDER-1:0]                    S_syndrome_seq_sel = 0;
reg [C_PRIMPOLY_ORDER-1:0]                    S_syndrome_new_d = 0;
reg [C_PRIMPOLY_ORDER*(C_COEF_NUM+1)-1:0]     S_syndrome_slr = 0;
(* MAX_FANOUT=8 *)reg [C_PRIMPOLY_ORDER-1:0]  S_poly_v [C_COEF_NUM-1+1:0];
reg [C_PRIMPOLY_ORDER-1:0]                    S_poly_deltav [C_COEF_NUM-1+1:0];
(* MAX_FANOUT=16 *)reg [C_PRIMPOLY_ORDER-1:0] S_poly_k [C_COEF_NUM-1+2:0];
(* MAX_FANOUT=50 *)reg [C_PRIMPOLY_ORDER-1:0] S_delta;
reg [C_PRIMPOLY_ORDER-1:0]                    S_d_uint [C_COEF_NUM-1+1:0];
(* MAX_FANOUT=36 *)reg [C_PRIMPOLY_ORDER-1:0] S_d;
wire [C_PRIMPOLY_ORDER-1:0]                   S_d_xor [C_COEF_NUM+1:0];
reg [C_PRIMPOLY_ORDER-1:0]                    S_mult_result [C_COEF_NUM-1:0];
reg                                           S_bm_v = 0;
reg                                           S_bm_v_d = 0;
reg                                           S_bm_v_2d = 0;
(* MAX_FANOUT=36 *)reg [1:0]                  S_bm_cnt = 0;
reg [C_CYCLE-1:0]                             S_bm_cnt2 = 0;
reg                                           S_d_nozero = 0;
reg                                           S_kdelta_v = 0;
reg [C_COEF_NUM-1:0]                          S_poly_v_exist = 0;
reg                                           S_poly_v_exist_all = 0;
reg                                           S_syndrome_ram_we = 0;
reg [C_PRIMPOLY_ORDER-1:0]                    S_syndrome_ram [2**C_CYCLE-1:0];
reg [C_CYCLE-1:0]                             S_syndrome_waddr = 0;
reg [C_CYCLE-1:0]                             S_syndrome_raddr = 0;
reg [C_PRIMPOLY_ORDER-1:0]                    S_syndrome_ram_dout = 0;
reg                                           S_k_v = 0;
 
 
///----------------------------
///function
///----------------------------
//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
 
//two elements in Galois Field multiplication
function [C_PRIMPOLY_ORDER-1:0] F_var_upgrade;
input [C_PRIMPOLY_ORDER-1:0] S_mult1;
input [C_PRIMPOLY_ORDER-1:0] S_mult2;
integer i;
reg [C_PRIMPOLY_ORDER-1:0] S_temp1;
reg [C_PRIMPOLY_ORDER-1:0] S_temp2;
begin
        F_var_upgrade = {C_PRIMPOLY_ORDER{1'b0}};
        for(i=0;i<C_PRIMPOLY_ORDER;i=i+1)
        begin
            S_temp1 = {C_PRIMPOLY_ORDER{F_var_upgrade[C_PRIMPOLY_ORDER-1]}} & C_PRIMPOLY[C_PRIMPOLY_ORDER-1:0];
                S_temp2 = {C_PRIMPOLY_ORDER{S_mult1[C_PRIMPOLY_ORDER-1-i]}} & S_mult2;
                F_var_upgrade = {F_var_upgrade[C_PRIMPOLY_ORDER-2:0],1'b0} ^ S_temp1 ^ S_temp2;
        end
end
endfunction
 
///----------------------------
///syndrome
///----------------------------
always @(posedge I_clk)
begin
    S_syndrome_v_slr <= {S_syndrome_v_slr[C_CYCLE:0],I_syndrome_v};
        S_syndrome_v_all <= |S_syndrome_v_slr;
        S_syndrome_v <= I_syndrome_v;
        S_syndrome_v_d <= S_syndrome_v;
        S_syndrome_v_2d <= S_syndrome_v_d;
        S_syndrome_v_3d <= S_syndrome_v_2d;
        S_bm_cnt2_d <= S_bm_cnt2[0];
end
 
//an odd order syndrome used to calculate even order syndrome
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_syndrome_seq <= I_syndrome;
        else if((S_bm_cnt == 'd2 && S_bm_cnt2_d) || S_syndrome_v)
            S_syndrome_seq <= S_syndrome_seq>>C_PRIMPOLY_ORDER;
end
 
//every iteration need an odd order syndrome
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_syndrome_seq2 <= I_syndrome;
        else if(S_bm_cnt == 'd1)
            S_syndrome_seq2 <= S_syndrome_seq2>>C_PRIMPOLY_ORDER;
end
 
//even order syndrome generation by multiplication, multiplier is odd order or even order 
always @(posedge I_clk)
begin
    S_syndrome_new <= F_var_upgrade(S_syndrome_seq_sel,S_syndrome_seq_sel);
end
 
//multiplier selection, S_syndrome_seq[C_PRIMPOLY_ORDER-1:0] is odd order, and S_syndrome_ram_dout is even order
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_syndrome_seq_sel <= I_syndrome[C_PRIMPOLY_ORDER-1:0];
        else if(S_syndrome_v_3d)
            S_syndrome_seq_sel <= S_syndrome_new_d;
        else if(S_bm_cnt == 'd2)
        begin
            S_syndrome_seq_sel <= (S_bm_cnt2_d) ? S_syndrome_seq[C_PRIMPOLY_ORDER-1:0] : S_syndrome_ram_dout;
        end
end
 
//every iteration need an even order syndrome
always @(posedge I_clk)
begin
    if(S_bm_cnt == 'd1 || S_syndrome_v_d)
            S_syndrome_new_d <= S_syndrome_new;
end
 
//even order syndrome are saved into ram for further even order syndrome calculation
always @(posedge I_clk)
begin
    S_syndrome_ram_we <= (S_bm_cnt == 'd1) && S_bm_v_2d;
        if(S_syndrome_ram_we)
            S_syndrome_ram[S_syndrome_waddr] <= S_syndrome_new_d;
        if(I_syndrome_v)
            S_syndrome_waddr <= 'd0;
        else if(S_syndrome_ram_we)
            S_syndrome_waddr <= S_syndrome_waddr + 'd1;
        S_syndrome_ram_dout <= S_syndrome_ram[S_syndrome_raddr];
        if(I_syndrome_v)
            S_syndrome_raddr <= 'd0;
        else if((S_bm_cnt == 'd1) && (!S_bm_cnt2_d) && S_bm_v_2d)
            S_syndrome_raddr <= S_syndrome_raddr + 'd1;
end
 
//syndrome update every iteration
always @(posedge I_clk)
begin
    if(I_syndrome_v)
        begin
            S_syndrome_slr <= 'd0;
                S_syndrome_slr[C_PRIMPOLY_ORDER-1:0] <= I_syndrome[C_PRIMPOLY_ORDER-1:0];
                S_syndrome_slr[2*C_PRIMPOLY_ORDER-1:C_PRIMPOLY_ORDER] <= 'd1;
        end
        else if(S_bm_cnt == 'd2)
        begin
            S_syndrome_slr <= S_syndrome_slr<<(C_PRIMPOLY_ORDER*2);
                S_syndrome_slr[0+:C_PRIMPOLY_ORDER*2] <= {S_syndrome_new_d,S_syndrome_seq2[C_PRIMPOLY_ORDER-1:0]};
        end
end
 
///-------------------------------
///bm
///-------------------------------
///bm algorithm
///v(0)=1,k(0)=1,delta(-2)=1
///for k=0:1:C_COEF_NUM-1
///v(2k+2)=delta(2k-2)*v(2k)+d(2k)*k(2k)*z
///k(2k+2)=z^2*k(2k)        if d(2k) == 0 or if deg v(2k)>k
///k(2k+2)=z*v(2k)          if d(2k) != 0 and if deg v(2k)<=k
///delta(2k)=delta(2k-2)    if d(2k) == 0 or if deg v(2k)>k
///delta(2k)=d(2k)          if d(2k) != 0 and if deg v(2k)<=k
 
always @(posedge I_clk)
begin
    if(S_syndrome_v)
            S_bm_v <= 'b1;
        else if(S_bm_cnt2 == C_COEF_NUM)
            S_bm_v <= 'b0;
end
 
always @(posedge I_clk)
begin
    O_err_pos_v <= (!S_bm_v) && S_bm_v_d;
end
 
always @(posedge I_clk)
begin
    if(S_bm_v)
        begin
            if(S_bm_cnt=='d2)
                    S_bm_cnt <= 'd0;
                else
                    S_bm_cnt <= S_bm_cnt + 'd1;
        end
        else
            S_bm_cnt <= 'd0;
end
 
always @(posedge I_clk)
begin
    if(S_bm_v)
        begin
            if(S_bm_cnt=='d1)
                    S_bm_cnt2 <= S_bm_cnt2 + 'd1;
        end
        else
            S_bm_cnt2 <= 'd0;
end
 
//variable d generation
always @(posedge I_clk)
begin
        if(S_bm_cnt[1:0]=='d1)
            S_d <= S_d_xor[C_COEF_NUM+1];
end
 
always @(posedge I_clk)
begin
    S_d_nozero <= (S_d != 'd0);
        S_kdelta_v <= (S_bm_cnt[1:0]=='d2);
        S_k_v <= (S_bm_cnt[1:0]=='d1);
        S_bm_v_d <= S_bm_v;
        S_bm_v_2d <= S_bm_v_d;
        if(S_bm_cnt[1:0]=='d1)
                S_poly_deltav[C_COEF_NUM] <= F_var_upgrade(S_delta,S_poly_v[C_COEF_NUM]);
end
 
assign S_d_xor[0] = 0;
 
genvar S_jj;
generate
for(S_jj=0;S_jj<=C_COEF_NUM;S_jj=S_jj+1)
begin:bm2
 
assign S_d_xor[S_jj+1] = S_d_xor[S_jj] ^ S_d_uint[S_jj];
 
always @(posedge I_clk)
begin
    if(S_bm_cnt[1:0]=='d0)
        begin
            S_d_uint[S_jj] <= F_var_upgrade(S_syndrome_slr[S_jj*C_PRIMPOLY_ORDER+:C_PRIMPOLY_ORDER],S_poly_v[S_jj]);
        end
end
end
endgenerate
 
 
genvar S_j;
generate
for(S_j=0;S_j<C_COEF_NUM;S_j=S_j+1)
begin:bm
 
always @(posedge I_clk)
begin
    if(S_bm_cnt[1:0]=='d1)
                S_poly_deltav[S_j] <= F_var_upgrade(S_delta,S_poly_v[S_j]);
end
 
//variable v generation
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_poly_v[S_j+1] <= 'd0;
        else if(S_bm_cnt[1:0]=='d2)
            S_poly_v[S_j+1] <= S_poly_deltav[S_j+1] ^ F_var_upgrade(S_poly_k[S_j],S_d);
end
 
always @(posedge I_clk)
begin
    S_poly_v_exist[S_j] <= (S_poly_v[S_j] != 'd0) && (S_j > S_bm_cnt2);
end
 
always @(posedge I_clk)
begin
    O_err_pos[C_PRIMPOLY_ORDER*S_j+C_PRIMPOLY_ORDER-1-:C_PRIMPOLY_ORDER] <= S_poly_v[S_j];
end
 
end
endgenerate
 
always @(posedge I_clk)
begin
    S_poly_v_exist_all <= |S_poly_v_exist;
        O_err_pos[C_PRIMPOLY_ORDER*C_COEF_NUM+C_PRIMPOLY_ORDER-1-:C_PRIMPOLY_ORDER] <= S_poly_v[C_COEF_NUM];
end
 
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_poly_v[0] <= 'd1;
        else if(S_bm_cnt[1:0]=='d2)
            S_poly_v[0] <= S_poly_deltav[0];
end
 
//variable k generation
genvar S_k;
generate
for(S_k=1;S_k<C_COEF_NUM;S_k=S_k+1)
begin:think
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_poly_k[S_k+1] <= 'd0;
        else if(S_k_v)
        begin
            if(!((S_d != 'd0) && !S_poly_v_exist_all))
                    S_poly_k[S_k+1] <= S_poly_k[S_k-1];
                else
                    S_poly_k[S_k+1] <= S_poly_v[S_k];
        end
end
end
endgenerate
 
always @(posedge I_clk)
begin
    if(I_syndrome_v)
        begin
            S_poly_k[0] <= 'd1;
                S_poly_k[1] <= 'd0;
                S_poly_k[C_COEF_NUM+1] <= 'd0;
        end
        else if(S_k_v)
        begin
            if(!((S_d != 'd0) && !S_poly_v_exist_all))
                begin
                    S_poly_k[0] <= 'd0;
                        S_poly_k[1] <= 'd0;
                        S_poly_k[C_COEF_NUM+1] <= S_poly_k[C_COEF_NUM-1];
                end
                else
                begin
                    S_poly_k[1] <= S_poly_v[0];
                        S_poly_k[0] <= 'd0;
                        S_poly_k[C_COEF_NUM+1] <= S_poly_v[C_COEF_NUM];
                end
        end
end
 
//variable delta generation
always @(posedge I_clk)
begin
    if(I_syndrome_v)
            S_delta <= 'd1;
        else if(S_kdelta_v && S_d_nozero && !S_poly_v_exist_all)
            S_delta <= S_d;
end
 
endmodule

Browse

Tools

Subversion Repositories bch_configurable

[/] [bch_configurable/] [trunk/] [src/] [test_bch_bm.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	Success105	`///-----------------------------------------`
2			`///introduce:`
3			`///bch error position polynomial calculate by bm algorithm`
4			`///author:jiml`
5			`///record:`
6			`///2015.1.31 initial`
7			`///2015.2.2 S_syndrome modified from parallel to serial`
8			`///-----------------------------------------`
9			`timescale 1ns/100ps
10			`module test_bch_bm`
11			`#(`
12			`parameter C_PRIMPOLY_ORDER = 14, //order of eigenpolynomial`
13			`parameter C_COEF_NUM = 43, //correct threshold`
14			`parameter C_PRIMPOLY = 15'h4443 //eigenpolynomial`
15			`)`
16			`(`
17			`input I_clk ,`
18			`input I_rst ,`
19			`input [C_PRIMPOLY_ORDER*C_COEF_NUM-1:0] I_syndrome , //syndrome cascaded`
20			`input I_syndrome_v , //syndrome available`
21			`output reg [C_PRIMPOLY_ORDER*C_COEF_NUM-1+C_PRIMPOLY_ORDER:0] O_err_pos , //error position polynomial`
22			`(* MAX_FANOUT=30 *)output reg O_err_pos_v //error position polynomial available`
23			`);`
24
25			`//--------------------------------`
26			`//parameter and variable`
27			`//--------------------------------`
28			`localparam C_CYCLE = GETASIZE(C_COEF_NUM);`
29			`integer i,j,jj;`
30			`reg [C_CYCLE+1:0] S_syndrome_v_slr = 0;`
31			`reg S_syndrome_v_all = 0;`
32			`reg [C_PRIMPOLY_ORDER-1:0] S_syndrome [2*C_COEF_NUM-1:0];`
33			`reg S_syndrome_v = 0;`
34			`reg S_syndrome_v_d = 0;`
35			`reg S_syndrome_v_2d = 0;`
36			`reg S_syndrome_v_3d = 0;`
37			`reg S_bm_cnt2_d = 0;`
38			`reg [C_PRIMPOLY_ORDER*C_COEF_NUM-1:0] S_syndrome_seq = 0;`
39			`reg [C_PRIMPOLY_ORDER*C_COEF_NUM-1:0] S_syndrome_seq2 = 0;`
40			`reg [C_PRIMPOLY_ORDER-1:0] S_syndrome_new = 0;`
41			`reg [C_PRIMPOLY_ORDER-1:0] S_syndrome_seq_sel = 0;`
42			`reg [C_PRIMPOLY_ORDER-1:0] S_syndrome_new_d = 0;`
43			`reg [C_PRIMPOLY_ORDER*(C_COEF_NUM+1)-1:0] S_syndrome_slr = 0;`
44			`(* MAX_FANOUT=8 *)reg [C_PRIMPOLY_ORDER-1:0] S_poly_v [C_COEF_NUM-1+1:0];`
45			`reg [C_PRIMPOLY_ORDER-1:0] S_poly_deltav [C_COEF_NUM-1+1:0];`
46			`(* MAX_FANOUT=16 *)reg [C_PRIMPOLY_ORDER-1:0] S_poly_k [C_COEF_NUM-1+2:0];`
47			`(* MAX_FANOUT=50 *)reg [C_PRIMPOLY_ORDER-1:0] S_delta;`
48			`reg [C_PRIMPOLY_ORDER-1:0] S_d_uint [C_COEF_NUM-1+1:0];`
49			`(* MAX_FANOUT=36 *)reg [C_PRIMPOLY_ORDER-1:0] S_d;`
50			`wire [C_PRIMPOLY_ORDER-1:0] S_d_xor [C_COEF_NUM+1:0];`
51			`reg [C_PRIMPOLY_ORDER-1:0] S_mult_result [C_COEF_NUM-1:0];`
52			`reg S_bm_v = 0;`
53			`reg S_bm_v_d = 0;`
54			`reg S_bm_v_2d = 0;`
55			`(* MAX_FANOUT=36 *)reg [1:0] S_bm_cnt = 0;`
56			`reg [C_CYCLE-1:0] S_bm_cnt2 = 0;`
57			`reg S_d_nozero = 0;`
58			`reg S_kdelta_v = 0;`
59			`reg [C_COEF_NUM-1:0] S_poly_v_exist = 0;`
60			`reg S_poly_v_exist_all = 0;`
61			`reg S_syndrome_ram_we = 0;`
62			`reg [C_PRIMPOLY_ORDER-1:0] S_syndrome_ram [2**C_CYCLE-1:0];`
63			`reg [C_CYCLE-1:0] S_syndrome_waddr = 0;`
64			`reg [C_CYCLE-1:0] S_syndrome_raddr = 0;`
65			`reg [C_PRIMPOLY_ORDER-1:0] S_syndrome_ram_dout = 0;`
66			`reg S_k_v = 0;`
67
68
69			`///----------------------------`
70			`///function`
71			`///----------------------------`
72			`//width calculation`
73			`function integer GETASIZE;`
74			`input integer a;`
75			`integer i;`
76			`begin`
77			`for(i=1;(2**i)<=a;i=i+1)`
78			`begin`
79			`end`
80			`GETASIZE = i;`
81			`end`
82			`endfunction`
83
84			`//two elements in Galois Field multiplication`
85			`function [C_PRIMPOLY_ORDER-1:0] F_var_upgrade;`
86			`input [C_PRIMPOLY_ORDER-1:0] S_mult1;`
87			`input [C_PRIMPOLY_ORDER-1:0] S_mult2;`
88			`integer i;`
89			`reg [C_PRIMPOLY_ORDER-1:0] S_temp1;`
90			`reg [C_PRIMPOLY_ORDER-1:0] S_temp2;`
91			`begin`
92			`F_var_upgrade = {C_PRIMPOLY_ORDER{1'b0}};`
93			`for(i=0;i<C_PRIMPOLY_ORDER;i=i+1)`
94			`begin`
95			`S_temp1 = {C_PRIMPOLY_ORDER{F_var_upgrade[C_PRIMPOLY_ORDER-1]}} & C_PRIMPOLY[C_PRIMPOLY_ORDER-1:0];`
96			`S_temp2 = {C_PRIMPOLY_ORDER{S_mult1[C_PRIMPOLY_ORDER-1-i]}} & S_mult2;`
97			`F_var_upgrade = {F_var_upgrade[C_PRIMPOLY_ORDER-2:0],1'b0} ^ S_temp1 ^ S_temp2;`
98			`end`
99			`end`
100			`endfunction`
101
102			`///----------------------------`
103			`///syndrome`
104			`///----------------------------`
105			`always @(posedge I_clk)`
106			`begin`
107			`S_syndrome_v_slr <= {S_syndrome_v_slr[C_CYCLE:0],I_syndrome_v};`
108			`S_syndrome_v_all <= \|S_syndrome_v_slr;`
109			`S_syndrome_v <= I_syndrome_v;`
110			`S_syndrome_v_d <= S_syndrome_v;`
111			`S_syndrome_v_2d <= S_syndrome_v_d;`
112			`S_syndrome_v_3d <= S_syndrome_v_2d;`
113			`S_bm_cnt2_d <= S_bm_cnt2[0];`
114			`end`
115
116			`//an odd order syndrome used to calculate even order syndrome`
117			`always @(posedge I_clk)`
118			`begin`
119			`if(I_syndrome_v)`
120			`S_syndrome_seq <= I_syndrome;`
121			`else if((S_bm_cnt == 'd2 && S_bm_cnt2_d) \|\| S_syndrome_v)`
122			`S_syndrome_seq <= S_syndrome_seq>>C_PRIMPOLY_ORDER;`
123			`end`
124
125			`//every iteration need an odd order syndrome`
126			`always @(posedge I_clk)`
127			`begin`
128			`if(I_syndrome_v)`
129			`S_syndrome_seq2 <= I_syndrome;`
130			`else if(S_bm_cnt == 'd1)`
131			`S_syndrome_seq2 <= S_syndrome_seq2>>C_PRIMPOLY_ORDER;`
132			`end`
133
134			`//even order syndrome generation by multiplication, multiplier is odd order or even order`
135			`always @(posedge I_clk)`
136			`begin`
137			`S_syndrome_new <= F_var_upgrade(S_syndrome_seq_sel,S_syndrome_seq_sel);`
138			`end`
139
140			`//multiplier selection, S_syndrome_seq[C_PRIMPOLY_ORDER-1:0] is odd order, and S_syndrome_ram_dout is even order`
141			`always @(posedge I_clk)`
142			`begin`
143			`if(I_syndrome_v)`
144			`S_syndrome_seq_sel <= I_syndrome[C_PRIMPOLY_ORDER-1:0];`
145			`else if(S_syndrome_v_3d)`
146			`S_syndrome_seq_sel <= S_syndrome_new_d;`
147			`else if(S_bm_cnt == 'd2)`
148			`begin`
149			`S_syndrome_seq_sel <= (S_bm_cnt2_d) ? S_syndrome_seq[C_PRIMPOLY_ORDER-1:0] : S_syndrome_ram_dout;`
150			`end`
151			`end`
152
153			`//every iteration need an even order syndrome`
154			`always @(posedge I_clk)`
155			`begin`
156			`if(S_bm_cnt == 'd1 \|\| S_syndrome_v_d)`
157			`S_syndrome_new_d <= S_syndrome_new;`
158			`end`
159
160			`//even order syndrome are saved into ram for further even order syndrome calculation`
161			`always @(posedge I_clk)`
162			`begin`
163			`S_syndrome_ram_we <= (S_bm_cnt == 'd1) && S_bm_v_2d;`
164			`if(S_syndrome_ram_we)`
165			`S_syndrome_ram[S_syndrome_waddr] <= S_syndrome_new_d;`
166			`if(I_syndrome_v)`
167			`S_syndrome_waddr <= 'd0;`
168			`else if(S_syndrome_ram_we)`
169			`S_syndrome_waddr <= S_syndrome_waddr + 'd1;`
170			`S_syndrome_ram_dout <= S_syndrome_ram[S_syndrome_raddr];`
171			`if(I_syndrome_v)`
172			`S_syndrome_raddr <= 'd0;`
173			`else if((S_bm_cnt == 'd1) && (!S_bm_cnt2_d) && S_bm_v_2d)`
174			`S_syndrome_raddr <= S_syndrome_raddr + 'd1;`
175			`end`
176
177			`//syndrome update every iteration`
178			`always @(posedge I_clk)`
179			`begin`
180			`if(I_syndrome_v)`
181			`begin`
182			`S_syndrome_slr <= 'd0;`
183			`S_syndrome_slr[C_PRIMPOLY_ORDER-1:0] <= I_syndrome[C_PRIMPOLY_ORDER-1:0];`
184			`S_syndrome_slr[2*C_PRIMPOLY_ORDER-1:C_PRIMPOLY_ORDER] <= 'd1;`
185			`end`
186			`else if(S_bm_cnt == 'd2)`
187			`begin`
188			`S_syndrome_slr <= S_syndrome_slr<<(C_PRIMPOLY_ORDER*2);`
189			`S_syndrome_slr[0+:C_PRIMPOLY_ORDER*2] <= {S_syndrome_new_d,S_syndrome_seq2[C_PRIMPOLY_ORDER-1:0]};`
190			`end`
191			`end`
192
193			`///-------------------------------`
194			`///bm`
195			`///-------------------------------`
196			`///bm algorithm`
197			`///v(0)=1,k(0)=1,delta(-2)=1`
198			`///for k=0:1:C_COEF_NUM-1`
199			`///v(2k+2)=delta(2k-2)v(2k)+d(2k)k(2k)*z`
200			`///k(2k+2)=z^2*k(2k) if d(2k) == 0 or if deg v(2k)>k`
201			`///k(2k+2)=z*v(2k) if d(2k) != 0 and if deg v(2k)<=k`
202			`///delta(2k)=delta(2k-2) if d(2k) == 0 or if deg v(2k)>k`
203			`///delta(2k)=d(2k) if d(2k) != 0 and if deg v(2k)<=k`
204
205			`always @(posedge I_clk)`
206			`begin`
207			`if(S_syndrome_v)`
208			`S_bm_v <= 'b1;`
209			`else if(S_bm_cnt2 == C_COEF_NUM)`
210			`S_bm_v <= 'b0;`
211			`end`
212
213			`always @(posedge I_clk)`
214			`begin`
215			`O_err_pos_v <= (!S_bm_v) && S_bm_v_d;`
216			`end`
217
218			`always @(posedge I_clk)`
219			`begin`
220			`if(S_bm_v)`
221			`begin`
222			`if(S_bm_cnt=='d2)`
223			`S_bm_cnt <= 'd0;`
224			`else`
225			`S_bm_cnt <= S_bm_cnt + 'd1;`
226			`end`
227			`else`
228			`S_bm_cnt <= 'd0;`
229			`end`
230
231			`always @(posedge I_clk)`
232			`begin`
233			`if(S_bm_v)`
234			`begin`
235			`if(S_bm_cnt=='d1)`
236			`S_bm_cnt2 <= S_bm_cnt2 + 'd1;`
237			`end`
238			`else`
239			`S_bm_cnt2 <= 'd0;`
240			`end`
241
242			`//variable d generation`
243			`always @(posedge I_clk)`
244			`begin`
245			`if(S_bm_cnt[1:0]=='d1)`
246			`S_d <= S_d_xor[C_COEF_NUM+1];`
247			`end`
248
249			`always @(posedge I_clk)`
250			`begin`
251			`S_d_nozero <= (S_d != 'd0);`
252			`S_kdelta_v <= (S_bm_cnt[1:0]=='d2);`
253			`S_k_v <= (S_bm_cnt[1:0]=='d1);`
254			`S_bm_v_d <= S_bm_v;`
255			`S_bm_v_2d <= S_bm_v_d;`
256			`if(S_bm_cnt[1:0]=='d1)`
257			`S_poly_deltav[C_COEF_NUM] <= F_var_upgrade(S_delta,S_poly_v[C_COEF_NUM]);`
258			`end`
259
260			`assign S_d_xor[0] = 0;`
261
262			`genvar S_jj;`
263			`generate`
264			`for(S_jj=0;S_jj<=C_COEF_NUM;S_jj=S_jj+1)`
265			`begin:bm2`
266
267			`assign S_d_xor[S_jj+1] = S_d_xor[S_jj] ^ S_d_uint[S_jj];`
268
269			`always @(posedge I_clk)`
270			`begin`
271			`if(S_bm_cnt[1:0]=='d0)`
272			`begin`
273			`S_d_uint[S_jj] <= F_var_upgrade(S_syndrome_slr[S_jj*C_PRIMPOLY_ORDER+:C_PRIMPOLY_ORDER],S_poly_v[S_jj]);`
274			`end`
275			`end`
276			`end`
277			`endgenerate`
278
279
280			`genvar S_j;`
281			`generate`
282			`for(S_j=0;S_j<C_COEF_NUM;S_j=S_j+1)`
283			`begin:bm`
284
285			`always @(posedge I_clk)`
286			`begin`
287			`if(S_bm_cnt[1:0]=='d1)`
288			`S_poly_deltav[S_j] <= F_var_upgrade(S_delta,S_poly_v[S_j]);`
289			`end`
290
291			`//variable v generation`
292			`always @(posedge I_clk)`
293			`begin`
294			`if(I_syndrome_v)`
295			`S_poly_v[S_j+1] <= 'd0;`
296			`else if(S_bm_cnt[1:0]=='d2)`
297			`S_poly_v[S_j+1] <= S_poly_deltav[S_j+1] ^ F_var_upgrade(S_poly_k[S_j],S_d);`
298			`end`
299
300			`always @(posedge I_clk)`
301			`begin`
302			`S_poly_v_exist[S_j] <= (S_poly_v[S_j] != 'd0) && (S_j > S_bm_cnt2);`
303			`end`
304
305			`always @(posedge I_clk)`
306			`begin`
307			`O_err_pos[C_PRIMPOLY_ORDER*S_j+C_PRIMPOLY_ORDER-1-:C_PRIMPOLY_ORDER] <= S_poly_v[S_j];`
308			`end`
309
310			`end`
311			`endgenerate`
312
313			`always @(posedge I_clk)`
314			`begin`
315			`S_poly_v_exist_all <= \|S_poly_v_exist;`
316			`O_err_pos[C_PRIMPOLY_ORDER*C_COEF_NUM+C_PRIMPOLY_ORDER-1-:C_PRIMPOLY_ORDER] <= S_poly_v[C_COEF_NUM];`
317			`end`
318
319			`always @(posedge I_clk)`
320			`begin`
321			`if(I_syndrome_v)`
322			`S_poly_v[0] <= 'd1;`
323			`else if(S_bm_cnt[1:0]=='d2)`
324			`S_poly_v[0] <= S_poly_deltav[0];`
325			`end`
326
327			`//variable k generation`
328			`genvar S_k;`
329			`generate`
330			`for(S_k=1;S_k<C_COEF_NUM;S_k=S_k+1)`
331			`begin:think`
332			`always @(posedge I_clk)`
333			`begin`
334			`if(I_syndrome_v)`
335			`S_poly_k[S_k+1] <= 'd0;`
336			`else if(S_k_v)`
337			`begin`
338			`if(!((S_d != 'd0) && !S_poly_v_exist_all))`
339			`S_poly_k[S_k+1] <= S_poly_k[S_k-1];`
340			`else`
341			`S_poly_k[S_k+1] <= S_poly_v[S_k];`
342			`end`
343			`end`
344			`end`
345			`endgenerate`
346
347			`always @(posedge I_clk)`
348			`begin`
349			`if(I_syndrome_v)`
350			`begin`
351			`S_poly_k[0] <= 'd1;`
352			`S_poly_k[1] <= 'd0;`
353			`S_poly_k[C_COEF_NUM+1] <= 'd0;`
354			`end`
355			`else if(S_k_v)`
356			`begin`
357			`if(!((S_d != 'd0) && !S_poly_v_exist_all))`
358			`begin`
359			`S_poly_k[0] <= 'd0;`
360			`S_poly_k[1] <= 'd0;`
361			`S_poly_k[C_COEF_NUM+1] <= S_poly_k[C_COEF_NUM-1];`
362			`end`
363			`else`
364			`begin`
365			`S_poly_k[1] <= S_poly_v[0];`
366			`S_poly_k[0] <= 'd0;`
367			`S_poly_k[C_COEF_NUM+1] <= S_poly_v[C_COEF_NUM];`
368			`end`
369			`end`
370			`end`
371
372			`//variable delta generation`
373			`always @(posedge I_clk)`
374			`begin`
375			`if(I_syndrome_v)`
376			`S_delta <= 'd1;`
377			`else if(S_kdelta_v && S_d_nozero && !S_poly_v_exist_all)`
378			`S_delta <= S_d;`
379			`end`
380
381			`endmodule`