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

Subversion Repositories reed_solomon_coder

[/] [reed_solomon_coder/] [trunk/] [syndromecalculator.v] - Blame information for rev 10

Details | Compare with Previous | View Log


`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
// Company: University of Hamburg, University of Kiel, Germany
// Engineer: Cagil G�m�s, Andreas Bahr
// 
// Create Date:    15:10:07 12/02/2015 
// Design Name: 
// Module Name:    syndrome_calculator 
// Project Name: 
// Target Devices: 
// Tool versions: 
// Description: It takes 36 bits input data (20 bits message + 16 bits parity ) and returns 4 bits long 4 Syndromes. 
//                               If there is no errors ( all syndromes are zero) it puts the "no_error" flag high.
 
// Dependencies: None
//
// Revision: 
// Revision 0.01 - File Created
// Additional Comments: 
//
//////////////////////////////////////////////////////////////////////////////////
module syndromecalculator(
 
 
        input wire clk,
        input wire reset,
        input wire [35:0] data_in ,
 
        input wire go,
        input wire job_done,
        output reg [3:0] syndrome_1 ,
        output reg [3:0] syndrome_2 ,
        output reg [3:0] syndrome_3 ,
        output reg [3:0] syndrome_4 ,
        output reg no_errors,
        output reg ready
         );
 
reg [3:0] state;
 
parameter [3:0] IDLE                                     = 4'b0000,      // Idle State - Waiting for go signal
                                         CALCULATE                              = 4'b0001,
                                         ERRORCHECK                             = 4'b0111,
                                         FINISH                                 = 4'b0011;
 
always @(posedge clk or negedge reset)
begin
        if(!reset)
                begin
 
                        state <= IDLE;
                        syndrome_1 <= 0 ;
                        syndrome_2 <= 0 ;
                        syndrome_3 <= 0 ;
                        syndrome_4 <= 0 ;
                        ready <= 0 ;
                end
 
        else
                begin
 
                        case(state)
 
                                IDLE:
                                        begin
 
                                                syndrome_1 <= 0 ;
                                                syndrome_2 <= 0 ;
                                                syndrome_3 <= 0 ;
                                                syndrome_4 <= 0 ;
 
 
                                                if(go)
                                                        state <= CALCULATE;
                                                else
                                                        state <= IDLE;
 
                                        end
 
 
                                CALCULATE:
                                        begin
 
                                        syndrome_1 <=
                GFMult_fn(data_in[35:32],4'b0101)^GFMult_fn(data_in[31:28],4'b1011)^
                GFMult_fn(data_in[27:24],4'b1100)^GFMult_fn(data_in[23:20],4'b0110)^
                GFMult_fn(data_in[19:16],4'b0011)^GFMult_fn(data_in[15:12],4'b1000)^
                GFMult_fn(data_in[11:8],4'b0100)^GFMult_fn(data_in[7:4],4'b0010)^
                GFMult_fn(data_in[3:0],4'b0001);
 
                                        syndrome_2 <=
 
                GFMult_fn(data_in[35:32],4'b0010)^GFMult_fn(data_in[31:28],4'b1001)^
                GFMult_fn(data_in[27:24],4'b1111)^GFMult_fn(data_in[23:20],4'b0111)^
                GFMult_fn(data_in[19:16],4'b0101)^GFMult_fn(data_in[15:12],4'b1100)^
                GFMult_fn(data_in[11:8],4'b0011)^GFMult_fn(data_in[7:4],4'b0100)^
                GFMult_fn(data_in[3:0],4'b0001);
 
                                        syndrome_3 <=
 
                GFMult_fn(data_in[35:32],4'b1010)^GFMult_fn(data_in[31:28],4'b1100)^
                GFMult_fn(data_in[27:24],4'b1000)^GFMult_fn(data_in[23:20],4'b0001)^
                GFMult_fn(data_in[19:16],4'b1111)^GFMult_fn(data_in[15:12],4'b1010)^
                GFMult_fn(data_in[11:8],4'b1100)^GFMult_fn(data_in[7:4],4'b1000)^
                GFMult_fn(data_in[3:0],4'b0001);
 
                                        syndrome_4 <=
 
                GFMult_fn(data_in[35:32],4'b0100)^GFMult_fn(data_in[31:28],4'b1101)^
                GFMult_fn(data_in[27:24],4'b1010)^GFMult_fn(data_in[23:20],4'b0110)^
                GFMult_fn(data_in[19:16],4'b0010)^GFMult_fn(data_in[15:12],4'b1111)^
                GFMult_fn(data_in[11:8],4'b0101)^GFMult_fn(data_in[7:4],4'b0011)^
                GFMult_fn(data_in[3:0],4'b0001);
 
 
                                        state <= ERRORCHECK ;
 
 
                                        end
 
                                ERRORCHECK:
                                        begin
 
                                                if( (syndrome_1== 0) && (syndrome_2== 0) && (syndrome_3== 0) && (syndrome_4== 0))
                                                        no_errors <= 1;
                                                else
                                                        no_errors <= 0;
 
 
                                                state <= FINISH;
 
                                        end
 
 
 
 
 
                                FINISH:
                                        begin
 
                                                ready <= 1 ;
 
                                                if(job_done)
                                                        state <= IDLE;
                                                else
                                                        state <= FINISH;
 
 
 
                                        end
 
                        default: state <= IDLE;
 
 
                        endcase
 
 
                end
 
 
 
 
end
 
// For implementation of the GF(2^4) Multiplier function GFMult_fn, please refer to: 
// Design of a Synthesisable Reed-Solomon ECC Core
// David Banks
// Publishing Systems and Solutions Laboratory
// HP Laboratories Bristol
// https://www.hpl.hp.com/techreports/2001/HPL-2001-124.html
//
// parameter WIDTH = 4;
// parameter PRIMITIVE = 5'b10011;
 
// function [...]GFMult_fn;
// [...]
// [...]
// [...]
// endfunction
 
 
 
endmodule
 

Line No.	Rev	Author	Line
1	10	cau_sse	`timescale 1ns / 1ps
2			`//////////////////////////////////////////////////////////////////////////////////`
3			`// Company: University of Hamburg, University of Kiel, Germany`
4			`// Engineer: Cagil G�m�s, Andreas Bahr`
5			`//`
6			`// Create Date: 15:10:07 12/02/2015`
7			`// Design Name:`
8			`// Module Name: syndrome_calculator`
9			`// Project Name:`
10			`// Target Devices:`
11			`// Tool versions:`
12			`// Description: It takes 36 bits input data (20 bits message + 16 bits parity ) and returns 4 bits long 4 Syndromes.`
13			`// If there is no errors ( all syndromes are zero) it puts the "no_error" flag high.`
14
15			`// Dependencies: None`
16			`//`
17			`// Revision:`
18			`// Revision 0.01 - File Created`
19			`// Additional Comments:`
20			`//`
21			`//////////////////////////////////////////////////////////////////////////////////`
22			`module syndromecalculator(`
23
24
25			`input wire clk,`
26			`input wire reset,`
27			`input wire [35:0] data_in ,`
28
29			`input wire go,`
30			`input wire job_done,`
31			`output reg [3:0] syndrome_1 ,`
32			`output reg [3:0] syndrome_2 ,`
33			`output reg [3:0] syndrome_3 ,`
34			`output reg [3:0] syndrome_4 ,`
35			`output reg no_errors,`
36			`output reg ready`
37			`);`
38
39			`reg [3:0] state;`
40
41			`parameter [3:0] IDLE = 4'b0000, // Idle State - Waiting for go signal`
42			`CALCULATE = 4'b0001,`
43			`ERRORCHECK = 4'b0111,`
44			`FINISH = 4'b0011;`
45
46			`always @(posedge clk or negedge reset)`
47			`begin`
48			`if(!reset)`
49			`begin`
50
51			`state <= IDLE;`
52			`syndrome_1 <= 0 ;`
53			`syndrome_2 <= 0 ;`
54			`syndrome_3 <= 0 ;`
55			`syndrome_4 <= 0 ;`
56			`ready <= 0 ;`
57			`end`
58
59			`else`
60			`begin`
61
62			`case(state)`
63
64			`IDLE:`
65			`begin`
66
67			`syndrome_1 <= 0 ;`
68			`syndrome_2 <= 0 ;`
69			`syndrome_3 <= 0 ;`
70			`syndrome_4 <= 0 ;`
71
72
73			`if(go)`
74			`state <= CALCULATE;`
75			`else`
76			`state <= IDLE;`
77
78			`end`
79
80
81			`CALCULATE:`
82			`begin`
83
84			`syndrome_1 <=`
85			`GFMult_fn(data_in[35:32],4'b0101)^GFMult_fn(data_in[31:28],4'b1011)^`
86			`GFMult_fn(data_in[27:24],4'b1100)^GFMult_fn(data_in[23:20],4'b0110)^`
87			`GFMult_fn(data_in[19:16],4'b0011)^GFMult_fn(data_in[15:12],4'b1000)^`
88			`GFMult_fn(data_in[11:8],4'b0100)^GFMult_fn(data_in[7:4],4'b0010)^`
89			`GFMult_fn(data_in[3:0],4'b0001);`
90
91			`syndrome_2 <=`
92
93			`GFMult_fn(data_in[35:32],4'b0010)^GFMult_fn(data_in[31:28],4'b1001)^`
94			`GFMult_fn(data_in[27:24],4'b1111)^GFMult_fn(data_in[23:20],4'b0111)^`
95			`GFMult_fn(data_in[19:16],4'b0101)^GFMult_fn(data_in[15:12],4'b1100)^`
96			`GFMult_fn(data_in[11:8],4'b0011)^GFMult_fn(data_in[7:4],4'b0100)^`
97			`GFMult_fn(data_in[3:0],4'b0001);`
98
99			`syndrome_3 <=`
100
101			`GFMult_fn(data_in[35:32],4'b1010)^GFMult_fn(data_in[31:28],4'b1100)^`
102			`GFMult_fn(data_in[27:24],4'b1000)^GFMult_fn(data_in[23:20],4'b0001)^`
103			`GFMult_fn(data_in[19:16],4'b1111)^GFMult_fn(data_in[15:12],4'b1010)^`
104			`GFMult_fn(data_in[11:8],4'b1100)^GFMult_fn(data_in[7:4],4'b1000)^`
105			`GFMult_fn(data_in[3:0],4'b0001);`
106
107			`syndrome_4 <=`
108
109			`GFMult_fn(data_in[35:32],4'b0100)^GFMult_fn(data_in[31:28],4'b1101)^`
110			`GFMult_fn(data_in[27:24],4'b1010)^GFMult_fn(data_in[23:20],4'b0110)^`
111			`GFMult_fn(data_in[19:16],4'b0010)^GFMult_fn(data_in[15:12],4'b1111)^`
112			`GFMult_fn(data_in[11:8],4'b0101)^GFMult_fn(data_in[7:4],4'b0011)^`
113			`GFMult_fn(data_in[3:0],4'b0001);`
114
115
116			`state <= ERRORCHECK ;`
117
118
119			`end`
120
121			`ERRORCHECK:`
122			`begin`
123
124			`if( (syndrome_1== 0) && (syndrome_2== 0) && (syndrome_3== 0) && (syndrome_4== 0))`
125			`no_errors <= 1;`
126			`else`
127			`no_errors <= 0;`
128
129
130			`state <= FINISH;`
131
132			`end`
133
134
135
136
137
138			`FINISH:`
139			`begin`
140
141			`ready <= 1 ;`
142
143			`if(job_done)`
144			`state <= IDLE;`
145			`else`
146			`state <= FINISH;`
147
148
149
150			`end`
151
152			`default: state <= IDLE;`
153
154
155			`endcase`
156
157
158			`end`
159
160
161
162
163			`end`
164
165			`// For implementation of the GF(2^4) Multiplier function GFMult_fn, please refer to:`
166			`// Design of a Synthesisable Reed-Solomon ECC Core`
167			`// David Banks`
168			`// Publishing Systems and Solutions Laboratory`
169			`// HP Laboratories Bristol`
170			`// https://www.hpl.hp.com/techreports/2001/HPL-2001-124.html`
171			`//`
172			`// parameter WIDTH = 4;`
173			`// parameter PRIMITIVE = 5'b10011;`
174
175			`// function [...]GFMult_fn;`
176			`// [...]`
177			`// [...]`
178			`// [...]`
179			`// endfunction`
180
181
182
183			`endmodule`
184

Browse

Tools

Subversion Repositories reed_solomon_coder

[/] [reed_solomon_coder/] [trunk/] [syndromecalculator.v] - Blame information for rev 10