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

Subversion Repositories reed_solomon_decoder

[/] [reed_solomon_decoder/] [trunk/] [rtl/] [Omega_Phy.v] - Blame information for rev 2

Details | Compare with Previous | View Log


/* This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
   Email : semiconductors@varkongroup.com
   Tel   : 1-732-447-8611
 
*/
 
 
 
module Omega_Phy
///// calculates Omega and Phy polynomials 
///    Omega = (Syndromes_16 * Lamda_8)  mod16
///    Phy = dirvetive (Lamda_8)      
(
 
input clk, // input clock planned to be 56 Mhz
input reset, // active high asynchronous reset
 
 //   active high flag for one clock to indicate that input Sm is ready
input Sm_ready,
 // input modified syndromes in decimal format 
input [7:0] Sm1,Sm2,Sm3,Sm4,Sm5,Sm6,Sm7,Sm8,
input [7:0] Sm9,Sm10,Sm11,Sm12,Sm13,Sm14,Sm15,Sm16,
 
// active high flag for one clock to indicate that lamda polynomial is ready
input L_ready,
///  lamda coeff values in decimal format 
input [7:0] L1,L2,L3,L4,L5,L6,L7,L8,
 
input [7:0] pow1,pow2,pow3,  /// output of power memories
input [7:0] dec1,                /// output of decimal memories
 
output reg [7:0] add_pow1,add_pow2,add_pow3, /// address to power memories
output  [7:0] add_dec1,                           /// address to decimal memories
 
// active high flag for one clock to indicate that Phy and Omega polynomials are ready
output reg poly_ready ,
// decimal value of first coeff of Omega polynomial
output  [7:0] O1,
/// power values of omega polynomial coeff from 2:16
output  [7:0] O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,
 
output  reg [7:0] P1,    // decimal value of first coeff of Phy polynomial
output  reg [7:0] P3,P5,P7  /// power values of phy polynomial 
 
 
);
 
 
 
parameter state1    =  19'b0000000000000000001;
parameter state2    =  19'b0000000000000000010;
parameter state10  =  19'b0000000000000000100;
parameter state11  =  19'b0000000000000001000;
parameter state12  =  19'b0000000000000010000;
parameter state13  =  19'b0000000000000100000;
parameter state14  =  19'b0000000000001000000;
parameter state15  =  19'b0000000000010000000;
parameter state16  =  19'b0000000000100000000;
parameter state17  =  19'b0000000001000000000;
parameter state18  =  19'b0000000010000000000;
parameter state19  =  19'b0000000100000000000;
parameter state20  =  19'b0000001000000000000;
parameter state21  =  19'b0000010000000000000;
parameter state22  =  19'b0000100000000000000;
parameter state23  =  19'b0001000000000000000;
parameter state24  =  19'b0010000000000000000;
parameter state25  =  19'b0100000000000000000;
parameter state26  =  19'b1000000000000000000;
 
reg [18:0] state = state1;
 
 
reg [7:0] Sp [1:15]; // syndromes power values
reg [7:0] L   [1:8]; // lamda decimal values
reg [7:0] Lp [1:8];  // lamda power values
 
reg [7:0] O [1:16]; // omega values
 
assign O1=O[1];
assign O2=O[2];
assign O3=O[3];
assign O4=O[4];
assign O5=O[5];
assign O6=O[6];
assign O7=O[7];
assign O8=O[8];
assign O9=O[9];
assign O10=O[10];
assign O11=O[11];
assign O12=O[12];
assign O13=O[13];
assign O14=O[14];
assign O15=O[15];
assign O16=O[16];
 
 
reg [3:0]  cnt;
reg [3:0]  cnt1;
reg [3:0]  cnt2;
 
 
reg [8:0] add_1;
reg F1;  // is 255 flag
 
assign add_dec1  =(F1)?  8'h00 :(&add_1[7:0])?     8'h01 : add_1[7:0]+add_1[8]+1;
 
integer k;
 
always@ (posedge clk or posedge reset)
begin
        if (reset)
                begin
                        poly_ready<=0;
                        P1<= 0;P3<= 0;P5<= 0;P7<= 0;
                        add_pow1<=0;add_pow2<=0;add_pow3<=0;
 
                        add_1<=0;
                        F1<=0;
 
                        for(k=1;k<=15;k=k+1)
                                begin
                                        Sp[k] <=0;
                                        O[k] <=0;
                                end
 
                        for(k=1;k<=8;k=k+1)
                                begin
                                        L[k]<=0;
                                        Lp[k]<=0;
                                end
 
                        O[16] <=0;
 
                        cnt<=0;
                        cnt1<=0;
                        cnt2<=0;
                        state<=state1;
                end
        else
                begin
                        case (state)
                        ////////////////////////////////////////////
                        state1:begin       ///// register inputs
 
                                if(Sm_ready)
                                        begin
                                                O[1]<=Sm1;
                                                O[2]<=Sm2;O[3]<=Sm3;O[4]<=Sm4;O[5]<=Sm5;
                                                O[6]<=Sm6;O[7]<=Sm7;O[8]<=Sm8;O[9]<=Sm9;
                                                O[10]<=Sm10;O[11]<=Sm11;O[12]<=Sm12;
                                                O[13]<=Sm13;O[14]<=Sm14;O[15]<=Sm15;O[16]<=Sm16;
                                        end
 
                                if(L_ready)
                                        begin
                                                L[1]<=L1;L[2]<=L2;L[3]<=L3;L[4]<=L4;L[5]<=L5;
                                                L[6]<=L6;L[7]<=L7;L[8]<=L8;
                                                P1<= L1;P3<= 255;P5<= 255;P7<= 255;
                                                state<=state2;
                                                end
                                cnt<=0;
                        end
                        /////////////////////////////////////////////////////////////
                        state2:begin  //// get power values of  syndromes and lamda coeff
 
                                if (cnt == 9)
                                        begin
                                                state<=state10;
                                                cnt<=0;
                                        end
                                else
                                        cnt<=cnt+1;
                                ///////////////////////////////////////
                                case(cnt)
 
                                0:begin
                                        add_pow1<= O[1];
                                        add_pow2<= O[2];
                                        add_pow3<= O[3];
                                end
 
                                1:begin
                                        add_pow1<= O[4];
                                        add_pow2<= O[5];
                                        add_pow3<= O[6];
                                end
 
                                2:begin
                                        add_pow1<= O[7];
                                        add_pow2<= O[8];
                                        add_pow3<= O[9];
 
 
                                        Sp[1] <= pow1;
                                        Sp[2] <= pow2;
                                        Sp[3] <= pow3;
                                end
 
                                3:begin
                                        add_pow1<= O[10];
                                        add_pow2<= O[11];
                                        add_pow3<= O[12];
 
                                        Sp[4] <= pow1;
                                        Sp[5] <= pow2;
                                        Sp[6] <= pow3;
                                end
 
                                4:begin
                                        add_pow1<= O[13];
                                        add_pow2<= O[14];
                                        add_pow3<= O[15];
 
                                        Sp[7] <= pow1;
                                        Sp[8] <= pow2;
                                        Sp[9] <= pow3;
                                end
 
                                5:begin
                                        add_pow1<= L[1];
                                        add_pow2<= L[2];
                                        add_pow3<= L[3];
 
                                        Sp[10] <= pow1;
                                        Sp[11] <= pow2;
                                        Sp[12] <= pow3;
                                end
 
                                6:begin
                                        add_pow1<= L[4];
                                        add_pow2<= L[5];
                                        add_pow3<= L[6];
 
                                        Sp[13] <= pow1;
                                        Sp[14] <= pow2;
                                        Sp[15] <= pow3;
                                end
 
                                7:begin
                                        add_pow1<= L[7];
                                        add_pow2<= L[8];
 
                                        Lp[1] <= pow1;
                                        Lp[2] <= pow2;
                                        Lp[3] <= pow3;
 
                                        P3<=pow3;
                                end
 
                                8:begin
                                        Lp[4] <= pow1;
                                        Lp[5] <= pow2;
                                        Lp[6] <= pow3;
 
                                        P5<=pow2;
                                end
 
                                default:begin
                                        Lp[7] <= pow1;
                                        Lp[8] <= pow2;
 
                                        P7<=pow1;
                                end
 
                                endcase
                        end
                        /////////////////////////////////////////////////////
                        /// just a name for the next state but it is state number three in sequence
                        state10:begin   //// calculate O2
                                if(cnt == 2)
                                        begin
                                                state<=state11;
                                                cnt<=0;
                                                cnt1<=1;
                                                cnt2<=2;
                                        end
                                else
                                        cnt<=cnt+1;
 
                                add_1<= Sp[1]+Lp[1];
                                F1<= (&Sp[1] || &Lp[1])? 1:0;
 
                                if(cnt == 2)
                                        O[2] <= O[2] ^ dec1;
 
                        end
                        /////////////////////////////////////////////////
                        state11:begin     /// O3 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[3]<=O[3]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=3;
                                                                cnt1<=1;
                                                                state<=state12;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        /////////////////////////////////////////////////
                        state12:begin     /// O4 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[4]<=O[4]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=4;
                                                                cnt1<=1;
                                                                state<=state13;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ///////////////////////////////////////////////////
                        state13:begin     /// O5 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[5]<=O[5]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=5;
                                                                cnt1<=1;
                                                                state<=state14;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ////////////////////////////////////////////////////
                        state14:begin     /// O6 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[6]<=O[6]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=6;
                                                                cnt1<=1;
                                                                state<=state15;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ///////////////////////////////////////////////////
                        state15:begin     /// O7 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[7]<=O[7]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=7;
                                                                cnt1<=1;
                                                                state<=state16;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ////////////////////////////////////////////////
                        state16:begin     /// O8 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[8]<=O[8]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=8;
                                                                cnt1<=1;
                                                                state<=state17;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        //////////////////////////////////////////////
                        state17:begin     /// O9 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[9]<=O[9]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 1)
                                                        begin
                                                                cnt2<=9;
                                                                cnt1<=1;
                                                                state<=state18;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        //////////////////////////////////////////////////
                        state18:begin     /// O10 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[10]<=O[10]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 2)
                                                        begin
                                                                cnt2<=10;
                                                                cnt1<=1;
                                                                state<=state19;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ///////////////////////////////////////////////////
                        state19:begin     /// O11 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[11]<=O[11]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 3)
                                                        begin
                                                                cnt2<=11;
                                                                cnt1<=1;
                                                                state<=state20;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        /////////////////////////////////////////////////
                        state20:begin     /// O12 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[12]<=O[12]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 4)
                                                        begin
                                                                cnt2<=12;
                                                                cnt1<=1;
                                                                state<=state21;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        /////////////////////////////////////////
                        state21:begin     /// O13 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[13]<=O[13]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 5)
                                                        begin
                                                                cnt2<=13;
                                                                cnt1<=1;
                                                                state<=state22;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ////////////////////////////////////////////////
                        state22:begin     /// O14 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[14]<=O[14]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 6)
                                                        begin
                                                                cnt2<=14;
                                                                cnt1<=1;
                                                                state<=state23;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        /////////////////////////////////////////////
                        state23:begin     /// O15 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[15]<=O[15]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 7)
                                                        begin
                                                                cnt2<=15;
                                                                cnt1<=1;
                                                                state<=state24;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        //////////////////////////////////////////////
                        state24:begin     /// O16 calculation
                                if(cnt == 2)
                                        begin
                                                cnt<=0;
                                                O[16]<=O[16]^dec1;
                                        end
                                else
                                        cnt<=cnt+1;
                                /////////////////////////////////////////
                                if (cnt == 2)
                                        begin
                                                if (cnt2 == 8)
                                                        begin
                                                                cnt2<=0;
                                                                cnt1<=0;
                                                                state<=state25;
                                                        end
                                                else
                                                        begin
                                                                cnt2<=cnt2-1;
                                                                cnt1<=cnt1+1;
                                                        end
                                        end
                                ////////////////////////////////////////
                                add_1 <= Lp[cnt1] + Sp[cnt2];
                                F1<= (&Lp[cnt1]  ||  &Sp[cnt2])? 1:0;
                        end
                        ////////////////////////////////////////////////
                        state25:begin     //// getting power values of O2 : O16
                                if (cnt == 6)
                                        begin
                                                state<=state26;
                                                cnt<=0;
                                                poly_ready<=1;
                                        end
                                else
                                        cnt<=cnt+1;
                                ///////////////////////////////////////
                                case(cnt)
 
                                0:begin
                                        add_pow1<= O[2];
                                        add_pow2<= O[3];
                                        add_pow3<= O[4];
                                end
 
                                1:begin
                                        add_pow1<= O[5];
                                        add_pow2<= O[6];
                                        add_pow3<= O[7];
                                end
 
                                2:begin
                                        add_pow1<= O[8];
                                        add_pow2<= O[9];
                                        add_pow3<= O[10];
 
                                        O[2] <= pow1;
                                        O[3]  <= pow2;
                                        O[4] <= pow3;
                                end
 
                                3:begin
                                        add_pow1<= O[11];
                                        add_pow2<= O[12];
                                        add_pow3<= O[13];
 
                                        O[5] <= pow1;
                                        O[6]  <= pow2;
                                        O[7] <= pow3;
                                end
 
                                4:begin
                                        add_pow1<= O[14];
                                        add_pow2<= O[15];
                                        add_pow3<= O[16];
 
                                        O[8] <= pow1;
                                        O[9]  <= pow2;
                                        O[10] <= pow3;
                                end
 
                                5:begin
                                        O[11] <= pow1;
                                        O[12]  <= pow2;
                                        O[13] <= pow3;
                                end
 
                                default:begin
                                        O[14] <= pow1;
                                        O[15]  <= pow2;
                                        O[16] <= pow3;
                                end
 
                                endcase
 
                        end
                        /////////////////////////////////////////////////
                        default:begin     /// state26   
                                poly_ready<=0;
                                state<=state1;
                        end
                        ///////////////////////////////////////////////
                        endcase
                end
end
 
 
endmodule

Browse

Tools

Subversion Repositories reed_solomon_decoder

[/] [reed_solomon_decoder/] [trunk/] [rtl/] [Omega_Phy.v] - Blame information for rev 2

Line No.	Rev	Author	Line
1	2	aelmahmoud	`/* This program is free software: you can redistribute it and/or modify`
2			`it under the terms of the GNU General Public License as published by`
3			`the Free Software Foundation, either version 3 of the License, or`
4			`(at your option) any later version.`
5
6			`This program is distributed in the hope that it will be useful,`
7			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
8			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
9			`GNU General Public License for more details.`
10
11			`You should have received a copy of the GNU General Public License`
12			`along with this program. If not, see <http://www.gnu.org/licenses/>.`
13
14			`Email : semiconductors@varkongroup.com`
15			`Tel : 1-732-447-8611`
16
17			`*/`
18
19
20
21			`module Omega_Phy`
22			`///// calculates Omega and Phy polynomials`
23			`/// Omega = (Syndromes_16 * Lamda_8) mod16`
24			`/// Phy = dirvetive (Lamda_8)`
25			`(`
26
27			`input clk, // input clock planned to be 56 Mhz`
28			`input reset, // active high asynchronous reset`
29
30			`// active high flag for one clock to indicate that input Sm is ready`
31			`input Sm_ready,`
32			`// input modified syndromes in decimal format`
33			`input [7:0] Sm1,Sm2,Sm3,Sm4,Sm5,Sm6,Sm7,Sm8,`
34			`input [7:0] Sm9,Sm10,Sm11,Sm12,Sm13,Sm14,Sm15,Sm16,`
35
36			`// active high flag for one clock to indicate that lamda polynomial is ready`
37			`input L_ready,`
38			`/// lamda coeff values in decimal format`
39			`input [7:0] L1,L2,L3,L4,L5,L6,L7,L8,`
40
41			`input [7:0] pow1,pow2,pow3, /// output of power memories`
42			`input [7:0] dec1, /// output of decimal memories`
43
44			`output reg [7:0] add_pow1,add_pow2,add_pow3, /// address to power memories`
45			`output [7:0] add_dec1, /// address to decimal memories`
46
47			`// active high flag for one clock to indicate that Phy and Omega polynomials are ready`
48			`output reg poly_ready ,`
49			`// decimal value of first coeff of Omega polynomial`
50			`output [7:0] O1,`
51			`/// power values of omega polynomial coeff from 2:16`
52			`output [7:0] O2,O3,O4,O5,O6,O7,O8,O9,O10,O11,O12,O13,O14,O15,O16,`
53
54			`output reg [7:0] P1, // decimal value of first coeff of Phy polynomial`
55			`output reg [7:0] P3,P5,P7 /// power values of phy polynomial`
56
57
58			`);`
59
60
61
62			`parameter state1 = 19'b0000000000000000001;`
63			`parameter state2 = 19'b0000000000000000010;`
64			`parameter state10 = 19'b0000000000000000100;`
65			`parameter state11 = 19'b0000000000000001000;`
66			`parameter state12 = 19'b0000000000000010000;`
67			`parameter state13 = 19'b0000000000000100000;`
68			`parameter state14 = 19'b0000000000001000000;`
69			`parameter state15 = 19'b0000000000010000000;`
70			`parameter state16 = 19'b0000000000100000000;`
71			`parameter state17 = 19'b0000000001000000000;`
72			`parameter state18 = 19'b0000000010000000000;`
73			`parameter state19 = 19'b0000000100000000000;`
74			`parameter state20 = 19'b0000001000000000000;`
75			`parameter state21 = 19'b0000010000000000000;`
76			`parameter state22 = 19'b0000100000000000000;`
77			`parameter state23 = 19'b0001000000000000000;`
78			`parameter state24 = 19'b0010000000000000000;`
79			`parameter state25 = 19'b0100000000000000000;`
80			`parameter state26 = 19'b1000000000000000000;`
81
82			`reg [18:0] state = state1;`
83
84
85			`reg [7:0] Sp [1:15]; // syndromes power values`
86			`reg [7:0] L [1:8]; // lamda decimal values`
87			`reg [7:0] Lp [1:8]; // lamda power values`
88
89			`reg [7:0] O [1:16]; // omega values`
90
91			`assign O1=O[1];`
92			`assign O2=O[2];`
93			`assign O3=O[3];`
94			`assign O4=O[4];`
95			`assign O5=O[5];`
96			`assign O6=O[6];`
97			`assign O7=O[7];`
98			`assign O8=O[8];`
99			`assign O9=O[9];`
100			`assign O10=O[10];`
101			`assign O11=O[11];`
102			`assign O12=O[12];`
103			`assign O13=O[13];`
104			`assign O14=O[14];`
105			`assign O15=O[15];`
106			`assign O16=O[16];`
107
108
109			`reg [3:0] cnt;`
110			`reg [3:0] cnt1;`
111			`reg [3:0] cnt2;`
112
113
114			`reg [8:0] add_1;`
115			`reg F1; // is 255 flag`
116
117			`assign add_dec1 =(F1)? 8'h00 :(&add_1[7:0])? 8'h01 : add_1[7:0]+add_1[8]+1;`
118
119			`integer k;`
120
121			`always@ (posedge clk or posedge reset)`
122			`begin`
123			`if (reset)`
124			`begin`
125			`poly_ready<=0;`
126			`P1<= 0;P3<= 0;P5<= 0;P7<= 0;`
127			`add_pow1<=0;add_pow2<=0;add_pow3<=0;`
128
129			`add_1<=0;`
130			`F1<=0;`
131
132			`for(k=1;k<=15;k=k+1)`
133			`begin`
134			`Sp[k] <=0;`
135			`O[k] <=0;`
136			`end`
137
138			`for(k=1;k<=8;k=k+1)`
139			`begin`
140			`L[k]<=0;`
141			`Lp[k]<=0;`
142			`end`
143
144			`O[16] <=0;`
145
146			`cnt<=0;`
147			`cnt1<=0;`
148			`cnt2<=0;`
149			`state<=state1;`
150			`end`
151			`else`
152			`begin`
153			`case (state)`
154			`////////////////////////////////////////////`
155			`state1:begin ///// register inputs`
156
157			`if(Sm_ready)`
158			`begin`
159			`O[1]<=Sm1;`
160			`O[2]<=Sm2;O[3]<=Sm3;O[4]<=Sm4;O[5]<=Sm5;`
161			`O[6]<=Sm6;O[7]<=Sm7;O[8]<=Sm8;O[9]<=Sm9;`
162			`O[10]<=Sm10;O[11]<=Sm11;O[12]<=Sm12;`
163			`O[13]<=Sm13;O[14]<=Sm14;O[15]<=Sm15;O[16]<=Sm16;`
164			`end`
165
166			`if(L_ready)`
167			`begin`
168			`L[1]<=L1;L[2]<=L2;L[3]<=L3;L[4]<=L4;L[5]<=L5;`
169			`L[6]<=L6;L[7]<=L7;L[8]<=L8;`
170			`P1<= L1;P3<= 255;P5<= 255;P7<= 255;`
171			`state<=state2;`
172			`end`
173			`cnt<=0;`
174			`end`
175			`/////////////////////////////////////////////////////////////`
176			`state2:begin //// get power values of syndromes and lamda coeff`
177
178			`if (cnt == 9)`
179			`begin`
180			`state<=state10;`
181			`cnt<=0;`
182			`end`
183			`else`
184			`cnt<=cnt+1;`
185			`///////////////////////////////////////`
186			`case(cnt)`
187
188			`0:begin`
189			`add_pow1<= O[1];`
190			`add_pow2<= O[2];`
191			`add_pow3<= O[3];`
192			`end`
193
194			`1:begin`
195			`add_pow1<= O[4];`
196			`add_pow2<= O[5];`
197			`add_pow3<= O[6];`
198			`end`
199
200			`2:begin`
201			`add_pow1<= O[7];`
202			`add_pow2<= O[8];`
203			`add_pow3<= O[9];`
204
205
206			`Sp[1] <= pow1;`
207			`Sp[2] <= pow2;`
208			`Sp[3] <= pow3;`
209			`end`
210
211			`3:begin`
212			`add_pow1<= O[10];`
213			`add_pow2<= O[11];`
214			`add_pow3<= O[12];`
215
216			`Sp[4] <= pow1;`
217			`Sp[5] <= pow2;`
218			`Sp[6] <= pow3;`
219			`end`
220
221			`4:begin`
222			`add_pow1<= O[13];`
223			`add_pow2<= O[14];`
224			`add_pow3<= O[15];`
225
226			`Sp[7] <= pow1;`
227			`Sp[8] <= pow2;`
228			`Sp[9] <= pow3;`
229			`end`
230
231			`5:begin`
232			`add_pow1<= L[1];`
233			`add_pow2<= L[2];`
234			`add_pow3<= L[3];`
235
236			`Sp[10] <= pow1;`
237			`Sp[11] <= pow2;`
238			`Sp[12] <= pow3;`
239			`end`
240
241			`6:begin`
242			`add_pow1<= L[4];`
243			`add_pow2<= L[5];`
244			`add_pow3<= L[6];`
245
246			`Sp[13] <= pow1;`
247			`Sp[14] <= pow2;`
248			`Sp[15] <= pow3;`
249			`end`
250
251			`7:begin`
252			`add_pow1<= L[7];`
253			`add_pow2<= L[8];`
254
255			`Lp[1] <= pow1;`
256			`Lp[2] <= pow2;`
257			`Lp[3] <= pow3;`
258
259			`P3<=pow3;`
260			`end`
261
262			`8:begin`
263			`Lp[4] <= pow1;`
264			`Lp[5] <= pow2;`
265			`Lp[6] <= pow3;`
266
267			`P5<=pow2;`
268			`end`
269
270			`default:begin`
271			`Lp[7] <= pow1;`
272			`Lp[8] <= pow2;`
273
274			`P7<=pow1;`
275			`end`
276
277			`endcase`
278			`end`
279			`/////////////////////////////////////////////////////`
280			`/// just a name for the next state but it is state number three in sequence`
281			`state10:begin //// calculate O2`
282			`if(cnt == 2)`
283			`begin`
284			`state<=state11;`
285			`cnt<=0;`
286			`cnt1<=1;`
287			`cnt2<=2;`
288			`end`
289			`else`
290			`cnt<=cnt+1;`
291
292			`add_1<= Sp[1]+Lp[1];`
293			`F1<= (&Sp[1] \|\| &Lp[1])? 1:0;`
294
295			`if(cnt == 2)`
296			`O[2] <= O[2] ^ dec1;`
297
298			`end`
299			`/////////////////////////////////////////////////`
300			`state11:begin /// O3 calculation`
301			`if(cnt == 2)`
302			`begin`
303			`cnt<=0;`
304			`O[3]<=O[3]^dec1;`
305			`end`
306			`else`
307			`cnt<=cnt+1;`
308			`/////////////////////////////////////////`
309			`if (cnt == 2)`
310			`begin`
311			`if (cnt2 == 1)`
312			`begin`
313			`cnt2<=3;`
314			`cnt1<=1;`
315			`state<=state12;`
316			`end`
317			`else`
318			`begin`
319			`cnt2<=cnt2-1;`
320			`cnt1<=cnt1+1;`
321			`end`
322			`end`
323			`////////////////////////////////////////`
324			`add_1 <= Lp[cnt1] + Sp[cnt2];`
325			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
326			`end`
327			`/////////////////////////////////////////////////`
328			`state12:begin /// O4 calculation`
329			`if(cnt == 2)`
330			`begin`
331			`cnt<=0;`
332			`O[4]<=O[4]^dec1;`
333			`end`
334			`else`
335			`cnt<=cnt+1;`
336			`/////////////////////////////////////////`
337			`if (cnt == 2)`
338			`begin`
339			`if (cnt2 == 1)`
340			`begin`
341			`cnt2<=4;`
342			`cnt1<=1;`
343			`state<=state13;`
344			`end`
345			`else`
346			`begin`
347			`cnt2<=cnt2-1;`
348			`cnt1<=cnt1+1;`
349			`end`
350			`end`
351			`////////////////////////////////////////`
352			`add_1 <= Lp[cnt1] + Sp[cnt2];`
353			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
354			`end`
355			`///////////////////////////////////////////////////`
356			`state13:begin /// O5 calculation`
357			`if(cnt == 2)`
358			`begin`
359			`cnt<=0;`
360			`O[5]<=O[5]^dec1;`
361			`end`
362			`else`
363			`cnt<=cnt+1;`
364			`/////////////////////////////////////////`
365			`if (cnt == 2)`
366			`begin`
367			`if (cnt2 == 1)`
368			`begin`
369			`cnt2<=5;`
370			`cnt1<=1;`
371			`state<=state14;`
372			`end`
373			`else`
374			`begin`
375			`cnt2<=cnt2-1;`
376			`cnt1<=cnt1+1;`
377			`end`
378			`end`
379			`////////////////////////////////////////`
380			`add_1 <= Lp[cnt1] + Sp[cnt2];`
381			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
382			`end`
383			`////////////////////////////////////////////////////`
384			`state14:begin /// O6 calculation`
385			`if(cnt == 2)`
386			`begin`
387			`cnt<=0;`
388			`O[6]<=O[6]^dec1;`
389			`end`
390			`else`
391			`cnt<=cnt+1;`
392			`/////////////////////////////////////////`
393			`if (cnt == 2)`
394			`begin`
395			`if (cnt2 == 1)`
396			`begin`
397			`cnt2<=6;`
398			`cnt1<=1;`
399			`state<=state15;`
400			`end`
401			`else`
402			`begin`
403			`cnt2<=cnt2-1;`
404			`cnt1<=cnt1+1;`
405			`end`
406			`end`
407			`////////////////////////////////////////`
408			`add_1 <= Lp[cnt1] + Sp[cnt2];`
409			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
410			`end`
411			`///////////////////////////////////////////////////`
412			`state15:begin /// O7 calculation`
413			`if(cnt == 2)`
414			`begin`
415			`cnt<=0;`
416			`O[7]<=O[7]^dec1;`
417			`end`
418			`else`
419			`cnt<=cnt+1;`
420			`/////////////////////////////////////////`
421			`if (cnt == 2)`
422			`begin`
423			`if (cnt2 == 1)`
424			`begin`
425			`cnt2<=7;`
426			`cnt1<=1;`
427			`state<=state16;`
428			`end`
429			`else`
430			`begin`
431			`cnt2<=cnt2-1;`
432			`cnt1<=cnt1+1;`
433			`end`
434			`end`
435			`////////////////////////////////////////`
436			`add_1 <= Lp[cnt1] + Sp[cnt2];`
437			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
438			`end`
439			`////////////////////////////////////////////////`
440			`state16:begin /// O8 calculation`
441			`if(cnt == 2)`
442			`begin`
443			`cnt<=0;`
444			`O[8]<=O[8]^dec1;`
445			`end`
446			`else`
447			`cnt<=cnt+1;`
448			`/////////////////////////////////////////`
449			`if (cnt == 2)`
450			`begin`
451			`if (cnt2 == 1)`
452			`begin`
453			`cnt2<=8;`
454			`cnt1<=1;`
455			`state<=state17;`
456			`end`
457			`else`
458			`begin`
459			`cnt2<=cnt2-1;`
460			`cnt1<=cnt1+1;`
461			`end`
462			`end`
463			`////////////////////////////////////////`
464			`add_1 <= Lp[cnt1] + Sp[cnt2];`
465			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
466			`end`
467			`//////////////////////////////////////////////`
468			`state17:begin /// O9 calculation`
469			`if(cnt == 2)`
470			`begin`
471			`cnt<=0;`
472			`O[9]<=O[9]^dec1;`
473			`end`
474			`else`
475			`cnt<=cnt+1;`
476			`/////////////////////////////////////////`
477			`if (cnt == 2)`
478			`begin`
479			`if (cnt2 == 1)`
480			`begin`
481			`cnt2<=9;`
482			`cnt1<=1;`
483			`state<=state18;`
484			`end`
485			`else`
486			`begin`
487			`cnt2<=cnt2-1;`
488			`cnt1<=cnt1+1;`
489			`end`
490			`end`
491			`////////////////////////////////////////`
492			`add_1 <= Lp[cnt1] + Sp[cnt2];`
493			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
494			`end`
495			`//////////////////////////////////////////////////`
496			`state18:begin /// O10 calculation`
497			`if(cnt == 2)`
498			`begin`
499			`cnt<=0;`
500			`O[10]<=O[10]^dec1;`
501			`end`
502			`else`
503			`cnt<=cnt+1;`
504			`/////////////////////////////////////////`
505			`if (cnt == 2)`
506			`begin`
507			`if (cnt2 == 2)`
508			`begin`
509			`cnt2<=10;`
510			`cnt1<=1;`
511			`state<=state19;`
512			`end`
513			`else`
514			`begin`
515			`cnt2<=cnt2-1;`
516			`cnt1<=cnt1+1;`
517			`end`
518			`end`
519			`////////////////////////////////////////`
520			`add_1 <= Lp[cnt1] + Sp[cnt2];`
521			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
522			`end`
523			`///////////////////////////////////////////////////`
524			`state19:begin /// O11 calculation`
525			`if(cnt == 2)`
526			`begin`
527			`cnt<=0;`
528			`O[11]<=O[11]^dec1;`
529			`end`
530			`else`
531			`cnt<=cnt+1;`
532			`/////////////////////////////////////////`
533			`if (cnt == 2)`
534			`begin`
535			`if (cnt2 == 3)`
536			`begin`
537			`cnt2<=11;`
538			`cnt1<=1;`
539			`state<=state20;`
540			`end`
541			`else`
542			`begin`
543			`cnt2<=cnt2-1;`
544			`cnt1<=cnt1+1;`
545			`end`
546			`end`
547			`////////////////////////////////////////`
548			`add_1 <= Lp[cnt1] + Sp[cnt2];`
549			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
550			`end`
551			`/////////////////////////////////////////////////`
552			`state20:begin /// O12 calculation`
553			`if(cnt == 2)`
554			`begin`
555			`cnt<=0;`
556			`O[12]<=O[12]^dec1;`
557			`end`
558			`else`
559			`cnt<=cnt+1;`
560			`/////////////////////////////////////////`
561			`if (cnt == 2)`
562			`begin`
563			`if (cnt2 == 4)`
564			`begin`
565			`cnt2<=12;`
566			`cnt1<=1;`
567			`state<=state21;`
568			`end`
569			`else`
570			`begin`
571			`cnt2<=cnt2-1;`
572			`cnt1<=cnt1+1;`
573			`end`
574			`end`
575			`////////////////////////////////////////`
576			`add_1 <= Lp[cnt1] + Sp[cnt2];`
577			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
578			`end`
579			`/////////////////////////////////////////`
580			`state21:begin /// O13 calculation`
581			`if(cnt == 2)`
582			`begin`
583			`cnt<=0;`
584			`O[13]<=O[13]^dec1;`
585			`end`
586			`else`
587			`cnt<=cnt+1;`
588			`/////////////////////////////////////////`
589			`if (cnt == 2)`
590			`begin`
591			`if (cnt2 == 5)`
592			`begin`
593			`cnt2<=13;`
594			`cnt1<=1;`
595			`state<=state22;`
596			`end`
597			`else`
598			`begin`
599			`cnt2<=cnt2-1;`
600			`cnt1<=cnt1+1;`
601			`end`
602			`end`
603			`////////////////////////////////////////`
604			`add_1 <= Lp[cnt1] + Sp[cnt2];`
605			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
606			`end`
607			`////////////////////////////////////////////////`
608			`state22:begin /// O14 calculation`
609			`if(cnt == 2)`
610			`begin`
611			`cnt<=0;`
612			`O[14]<=O[14]^dec1;`
613			`end`
614			`else`
615			`cnt<=cnt+1;`
616			`/////////////////////////////////////////`
617			`if (cnt == 2)`
618			`begin`
619			`if (cnt2 == 6)`
620			`begin`
621			`cnt2<=14;`
622			`cnt1<=1;`
623			`state<=state23;`
624			`end`
625			`else`
626			`begin`
627			`cnt2<=cnt2-1;`
628			`cnt1<=cnt1+1;`
629			`end`
630			`end`
631			`////////////////////////////////////////`
632			`add_1 <= Lp[cnt1] + Sp[cnt2];`
633			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
634			`end`
635			`/////////////////////////////////////////////`
636			`state23:begin /// O15 calculation`
637			`if(cnt == 2)`
638			`begin`
639			`cnt<=0;`
640			`O[15]<=O[15]^dec1;`
641			`end`
642			`else`
643			`cnt<=cnt+1;`
644			`/////////////////////////////////////////`
645			`if (cnt == 2)`
646			`begin`
647			`if (cnt2 == 7)`
648			`begin`
649			`cnt2<=15;`
650			`cnt1<=1;`
651			`state<=state24;`
652			`end`
653			`else`
654			`begin`
655			`cnt2<=cnt2-1;`
656			`cnt1<=cnt1+1;`
657			`end`
658			`end`
659			`////////////////////////////////////////`
660			`add_1 <= Lp[cnt1] + Sp[cnt2];`
661			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
662			`end`
663			`//////////////////////////////////////////////`
664			`state24:begin /// O16 calculation`
665			`if(cnt == 2)`
666			`begin`
667			`cnt<=0;`
668			`O[16]<=O[16]^dec1;`
669			`end`
670			`else`
671			`cnt<=cnt+1;`
672			`/////////////////////////////////////////`
673			`if (cnt == 2)`
674			`begin`
675			`if (cnt2 == 8)`
676			`begin`
677			`cnt2<=0;`
678			`cnt1<=0;`
679			`state<=state25;`
680			`end`
681			`else`
682			`begin`
683			`cnt2<=cnt2-1;`
684			`cnt1<=cnt1+1;`
685			`end`
686			`end`
687			`////////////////////////////////////////`
688			`add_1 <= Lp[cnt1] + Sp[cnt2];`
689			`F1<= (&Lp[cnt1] \|\| &Sp[cnt2])? 1:0;`
690			`end`
691			`////////////////////////////////////////////////`
692			`state25:begin //// getting power values of O2 : O16`
693			`if (cnt == 6)`
694			`begin`
695			`state<=state26;`
696			`cnt<=0;`
697			`poly_ready<=1;`
698			`end`
699			`else`
700			`cnt<=cnt+1;`
701			`///////////////////////////////////////`
702			`case(cnt)`
703
704			`0:begin`
705			`add_pow1<= O[2];`
706			`add_pow2<= O[3];`
707			`add_pow3<= O[4];`
708			`end`
709
710			`1:begin`
711			`add_pow1<= O[5];`
712			`add_pow2<= O[6];`
713			`add_pow3<= O[7];`
714			`end`
715
716			`2:begin`
717			`add_pow1<= O[8];`
718			`add_pow2<= O[9];`
719			`add_pow3<= O[10];`
720
721			`O[2] <= pow1;`
722			`O[3] <= pow2;`
723			`O[4] <= pow3;`
724			`end`
725
726			`3:begin`
727			`add_pow1<= O[11];`
728			`add_pow2<= O[12];`
729			`add_pow3<= O[13];`
730
731			`O[5] <= pow1;`
732			`O[6] <= pow2;`
733			`O[7] <= pow3;`
734			`end`
735
736			`4:begin`
737			`add_pow1<= O[14];`
738			`add_pow2<= O[15];`
739			`add_pow3<= O[16];`
740
741			`O[8] <= pow1;`
742			`O[9] <= pow2;`
743			`O[10] <= pow3;`
744			`end`
745
746			`5:begin`
747			`O[11] <= pow1;`
748			`O[12] <= pow2;`
749			`O[13] <= pow3;`
750			`end`
751
752			`default:begin`
753			`O[14] <= pow1;`
754			`O[15] <= pow2;`
755			`O[16] <= pow3;`
756			`end`
757
758			`endcase`
759
760			`end`
761			`/////////////////////////////////////////////////`
762			`default:begin /// state26`
763			`poly_ready<=0;`
764			`state<=state1;`
765			`end`
766			`///////////////////////////////////////////////`
767			`endcase`
768			`end`
769			`end`
770
771
772			`endmodule`