OpenCores
URL https://opencores.org/ocsvn/spacewiresystemc/spacewiresystemc/trunk

Subversion Repositories spacewiresystemc

[/] [spacewiresystemc/] [trunk/] [rtl/] [RTL_VB/] [fifo_rx.v] - Blame information for rev 36

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 33 redbear 
//+FHDR------------------------------------------------------------------------
2 
//Copyright (c) 2013 Latin Group American Integhrated Circuit, Inc. All rights reserved
3 
//GLADIC Open Source RTL
4 
//-----------------------------------------------------------------------------
5 
//FILE NAME      :
6 
//DEPARTMENT     : IC Design / Verification
7 
//AUTHOR         : Felipe Fernandes da Costa
8 
//AUTHOR’S EMAIL :
9 
//-----------------------------------------------------------------------------
10 
//RELEASE HISTORY
11 
//VERSION DATE AUTHOR DESCRIPTION
12 
//1.0 YYYY-MM-DD name
13 
//-----------------------------------------------------------------------------
14 
//KEYWORDS : General file searching keywords, leave blank if none.
15 
//-----------------------------------------------------------------------------
16 
//PURPOSE  : ECSS_E_ST_50_12C_31_july_2008
17 
//-----------------------------------------------------------------------------
18 
//PARAMETERS
19 
//PARAM NAME            RANGE   : DESCRIPTION : DEFAULT : UNITS
20 
//e.g.DATA_WIDTH        [32,16] : width of the data : 32:
21 
//-----------------------------------------------------------------------------
22 
//REUSE ISSUES
23 
//Reset Strategy        :
24 
//Clock Domains         :
25 
//Critical Timing       :
26 
//Test Features         :
27 
//Asynchronous I/F      :
28 
//Scan Methodology      :
29 
//Instantiations        :
30 
//Synthesizable (y/n)   :
31 
//Other                 :
32 
//-FHDR------------------------------------------------------------------------
33 
module fifo_rx
34 
#(
35 
        parameter integer DWIDTH = 9,
36 
        parameter integer AWIDTH = 6
37 
)
38 
 
39 
(
40 
        input clock, reset, wr_en, rd_en,
41 
        input [DWIDTH-1:0] data_in,
42 
        output reg f_full,f_empty,
43 
        output reg open_slot_fct,
44 
        output reg overflow_credit_error,
45 
        output reg [DWIDTH-1:0] data_out,
46 
        output reg [AWIDTH-1:0] counter
47 
);
48 
 
49 
        reg [DWIDTH-1:0] mem [0:2**AWIDTH-1];
50 
 
51 
        reg [AWIDTH-1:0] wr_ptr;
52 
        reg [AWIDTH-1:0] rd_ptr;
53 
 
54 
        reg block_read;
55 
        reg block_write;
56 
 
57 
        reg [AWIDTH-1:0] credit_counter;
58 
 
59 
//Write pointer
60 
        always@(posedge clock or negedge reset)
61 
        begin
62 
                if (!reset)
63 
                begin
64 
                        wr_ptr <= {(AWIDTH){1'b0}};
65 34 redbear 
                        mem[0] <= {(DWIDTH){1'b0}};
66 
                        mem[1] <= {(DWIDTH){1'b0}};
67 
                        mem[2] <= {(DWIDTH){1'b0}};
68 
                        mem[3] <= {(DWIDTH){1'b0}};
69 
                        mem[4] <= {(DWIDTH){1'b0}};
70 
                        mem[5] <= {(DWIDTH){1'b0}};
71 
                        mem[6] <= {(DWIDTH){1'b0}};
72 
                        mem[7] <= {(DWIDTH){1'b0}};
73 
                        mem[8] <= {(DWIDTH){1'b0}};
74 
                        mem[9] <= {(DWIDTH){1'b0}};
75 
                        mem[10] <= {(DWIDTH){1'b0}};
76 
 
77 
                        mem[11] <= {(DWIDTH){1'b0}};
78 
                        mem[12] <= {(DWIDTH){1'b0}};
79 
                        mem[13] <= {(DWIDTH){1'b0}};
80 
                        mem[14] <= {(DWIDTH){1'b0}};
81 
                        mem[15] <= {(DWIDTH){1'b0}};
82 
                        mem[16] <= {(DWIDTH){1'b0}};
83 
                        mem[17] <= {(DWIDTH){1'b0}};
84 
                        mem[18] <= {(DWIDTH){1'b0}};
85 
                        mem[19] <= {(DWIDTH){1'b0}};
86 
                        mem[20] <= {(DWIDTH){1'b0}};
87 
                        mem[21] <= {(DWIDTH){1'b0}};
88 
 
89 
                        mem[22] <= {(DWIDTH){1'b0}};
90 
                        mem[23] <= {(DWIDTH){1'b0}};
91 
                        mem[24] <= {(DWIDTH){1'b0}};
92 
                        mem[25] <= {(DWIDTH){1'b0}};
93 
                        mem[26] <= {(DWIDTH){1'b0}};
94 
                        mem[27] <= {(DWIDTH){1'b0}};
95 
                        mem[28] <= {(DWIDTH){1'b0}};
96 
                        mem[29] <= {(DWIDTH){1'b0}};
97 
                        mem[30] <= {(DWIDTH){1'b0}};
98 
                        mem[31] <= {(DWIDTH){1'b0}};
99 
                        mem[32] <= {(DWIDTH){1'b0}};
100 
 
101 
 
102 
                        mem[33] <= {(DWIDTH){1'b0}};
103 
                        mem[34] <= {(DWIDTH){1'b0}};
104 
                        mem[35] <= {(DWIDTH){1'b0}};
105 
                        mem[36] <= {(DWIDTH){1'b0}};
106 
                        mem[37] <= {(DWIDTH){1'b0}};
107 
                        mem[38] <= {(DWIDTH){1'b0}};
108 
                        mem[39] <= {(DWIDTH){1'b0}};
109 
                        mem[40] <= {(DWIDTH){1'b0}};
110 
                        mem[41] <= {(DWIDTH){1'b0}};
111 
                        mem[42] <= {(DWIDTH){1'b0}};
112 
                        mem[43] <= {(DWIDTH){1'b0}};
113 
 
114 
                        mem[44] <= {(DWIDTH){1'b0}};
115 
                        mem[45] <= {(DWIDTH){1'b0}};
116 
                        mem[46] <= {(DWIDTH){1'b0}};
117 
                        mem[47] <= {(DWIDTH){1'b0}};
118 
                        mem[48] <= {(DWIDTH){1'b0}};
119 
                        mem[49] <= {(DWIDTH){1'b0}};
120 
                        mem[50] <= {(DWIDTH){1'b0}};
121 
                        mem[51] <= {(DWIDTH){1'b0}};
122 
                        mem[52] <= {(DWIDTH){1'b0}};
123 
                        mem[53] <= {(DWIDTH){1'b0}};
124 
                        mem[54] <= {(DWIDTH){1'b0}};
125 
 
126 
                        mem[55] <= {(DWIDTH){1'b0}};
127 
                        mem[56] <= {(DWIDTH){1'b0}};
128 
                        mem[57] <= {(DWIDTH){1'b0}};
129 
                        mem[58] <= {(DWIDTH){1'b0}};
130 
                        mem[59] <= {(DWIDTH){1'b0}};
131 
                        mem[60] <= {(DWIDTH){1'b0}};
132 
                        mem[61] <= {(DWIDTH){1'b0}};
133 
                        mem[62] <= {(DWIDTH){1'b0}};
134 
                        mem[63] <= {(DWIDTH){1'b0}};
135 33 redbear 
                        block_write <= 1'b0;
136 
                        overflow_credit_error<=1'b0;
137 
                end
138 
                else
139 
                begin
140 
                        if(block_write)
141 
                        begin
142 
                                if(!wr_en)
143 34 redbear 
                                begin
144 
                                        block_write <= 1'b0;
145 
                                        wr_ptr <= wr_ptr + 6'd1;
146 
                                end
147 33 redbear 
                        end
148 
                        else if (wr_en && !f_full)
149 
                        begin
150 
                                block_write <= 1'b1;
151 
                                mem[wr_ptr]<=data_in;
152 
                        end
153 
 
154 
                        if(wr_en && credit_counter > 6'd55)
155 
                        begin
156 
 
157 
                                overflow_credit_error<=1'b1;
158 
                        end
159 
                end
160 
        end
161 
 
162 
//FULL - EMPTY COUNTER
163 
 
164 
        always@(posedge clock or negedge reset)
165 
        begin
166 
                if (!reset)
167 
                begin
168 
                        f_full  <= 1'b0;
169 
                        f_empty <= 1'b1;
170 
                        counter <= {(AWIDTH){1'b0}};
171 
                        credit_counter <= 6'd55;
172 
                end
173 
                else
174 
                begin
175 
 
176 34 redbear 
                        if((wr_en && !f_full && !block_write) && (rd_en && !f_empty && !block_read))
177 33 redbear 
                        begin
178 36 redbear 
                                if(rd_ptr == 6'd7 || rd_ptr == 6'd15 || rd_ptr == 6'd23 || rd_ptr == 6'd31 || rd_ptr == 6'd39 || rd_ptr == 6'd47 || rd_ptr == 6'd55 || rd_ptr == 6'd63)
179 34 redbear 
                                        credit_counter   <= credit_counter - 6'd1 + 6'd8;
180 33 redbear 
                                else
181 34 redbear 
                                        credit_counter   <= credit_counter - 6'd1;
182 33 redbear 
                        end
183 34 redbear 
                        else if (wr_en && !f_full && !block_write)
184 
                        begin
185 
                                credit_counter   <= credit_counter - 6'd1;
186 
                        end
187 33 redbear 
                        else if(rd_en && !f_empty && !block_read)
188 
                        begin
189 36 redbear 
                                if(rd_ptr == 6'd7 || rd_ptr == 6'd15 || rd_ptr == 6'd23 || rd_ptr == 6'd31 || rd_ptr == 6'd39 || rd_ptr == 6'd47 || rd_ptr == 6'd55 || rd_ptr == 6'd63)
190 34 redbear 
                                begin
191 33 redbear 
                                        credit_counter <= credit_counter + 6'd8;
192 34 redbear 
                                end
193 
                        end
194 
                        else
195 
                                credit_counter <= credit_counter;
196 33 redbear 
 
197 34 redbear 
                        if((wr_en && !f_full && !block_write) && (rd_en && !f_empty && !block_read))
198 
                        begin
199 
                                counter <= counter;
200 
                        end
201 
                        else if (wr_en && !f_full && !block_write)
202 
                        begin
203 
                                counter <= counter + 6'd1;
204 
                        end
205 
                        else if(rd_en && !f_empty && !block_read)
206 
                        begin
207 33 redbear 
                                counter <= counter - 6'd1;
208 
                        end
209 34 redbear 
                        else
210 
                        begin
211 
                                counter <= counter;
212 
                        end
213 33 redbear 
 
214 
                        if(counter == 6'd63)
215 
                        begin
216 
                                f_full <= 1'b1;
217 
                        end
218 
                        else
219 
                        begin
220 
                                f_full <= 1'b0;
221 
                        end
222 
 
223 
                        if(counter == 6'd0)
224 
                        begin
225 
                                f_empty <= 1'b1;
226 
                        end
227 
                        else
228 
                        begin
229 
                                f_empty <= 1'b0;
230 
                        end
231 
                end
232 
        end
233 
 
234 
//Read pointer
235 
        always@(posedge clock or negedge reset)
236 
        begin
237 
                if (!reset)
238 
                begin
239 
                        rd_ptr <= {(AWIDTH){1'b0}};
240 
                        data_out <= 9'd0;
241 
                        open_slot_fct<= 1'b0;
242 
                        block_read <= 1'b0;
243 
                end
244 
                else
245 
                begin
246 
 
247 36 redbear 
                        if(rd_ptr == 6'd7 || rd_ptr == 6'd15 || rd_ptr == 6'd23 || rd_ptr == 6'd31 || rd_ptr == 6'd39 || rd_ptr == 6'd47 || rd_ptr == 6'd55 || rd_ptr == 6'd63)
248 33 redbear 
                        begin
249 
                                open_slot_fct<= 1'b1;
250 
                        end
251 
                        else
252 
                        begin
253 
                                open_slot_fct<= 1'b0;
254 
                        end
255 34 redbear 
 
256 
                        if(block_read)
257 33 redbear 
                        begin
258 
                                if(!rd_en)
259 34 redbear 
                                begin
260 33 redbear 
                                        block_read<= 1'b0;
261 34 redbear 
                                end
262 33 redbear 
                        end
263 
                        else
264 
                        if(rd_en && !f_empty)
265 
                        begin
266 
                                block_read<= 1'b1;
267 34 redbear 
                                rd_ptr <= rd_ptr+ 6'd1;
268 33 redbear 
                        end
269 34 redbear 
 
270 
                        data_out  <= mem[rd_ptr];
271 
 
272 33 redbear 
                end
273 
        end
274 
 
275 
endmodule

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.