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

Subversion Repositories pcie_sg_dma

[/] [pcie_sg_dma/] [branches/] [Virtex6/] [ML605_ISE13.3/] [MySource/] [FF_tagram64x36.vhd] - Blame information for rev 13

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 13 barabba 
----------------------------------------------------------------------------------
2 
-- Company:
3 
-- Engineer:
4 
--
5 
-- Design Name:
6 
-- Module Name:    FF_TagRam64x36 - Behavioral
7 
-- Project Name:
8 
-- Target Devices:
9 
-- Tool versions:
10 
-- Description:
11 
--
12 
-- Dependencies:
13 
--
14 
-- Revision 1.00 - first release. 16.01.2009
15 
--
16 
-- Additional Comments:
17 
--
18 
----------------------------------------------------------------------------------
19 
 
20 
library IEEE;
21 
use IEEE.STD_LOGIC_1164.ALL;
22 
use IEEE.STD_LOGIC_ARITH.ALL;
23 
use IEEE.STD_LOGIC_UNSIGNED.ALL;
24 
 
25 
library work;
26 
use work.abb64Package.all;
27 
 
28 
-- Uncomment the following library declaration if instantiating
29 
-- any Xilinx primitives in this code.
30 
--library UNISIM;
31 
--use UNISIM.VComponents.all;
32 
 
33 
entity FF_TagRam64x36 is
34 
  port (
35 
        wea      : in  STD_LOGIC;
36 
        web      : in  STD_LOGIC;
37 
        addra    : in  STD_LOGIC_VECTOR ( C_TAGRAM_AWIDTH-1 downto 0 );
38 
        addrb    : in  STD_LOGIC_VECTOR ( C_TAGRAM_AWIDTH-1 downto 0 );
39 
        douta    : out STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
40 
        doutb    : out STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
41 
        dina     : in  STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
42 
        dinb     : in  STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
43 
        clk      : in  STD_LOGIC
44 
       );
45 
end FF_TagRam64x36;
46 
 
47 
architecture STRUCTURE of FF_TagRam64x36 is
48 
 
49 
  TYPE     FF_RAM_Matrix is ARRAY (C_TAG_MAP_WIDTH-1 downto 0)
50 
                                   of std_logic_vector (C_TAGRAM_DWIDTH-1 downto 0);
51 
  signal   FF_Reg          : FF_RAM_Matrix;
52 
 
53 
  signal   FF_Muxer_a      : STD_LOGIC_VECTOR ( C_TAG_MAP_WIDTH-1 downto 0 );
54 
  signal   FF_Muxer_b      : STD_LOGIC_VECTOR ( C_TAG_MAP_WIDTH-1 downto 0 );
55 
  --
56 
  signal   wea_r1          : STD_LOGIC;
57 
  signal   web_r1          : STD_LOGIC;
58 
  signal   dina_r1         : STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
59 
  signal   dinb_r1         : STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
60 
  signal   douta_i         : STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
61 
  signal   doutb_i         : STD_LOGIC_VECTOR ( C_TAGRAM_DWIDTH-1 downto 0 );
62 
 
63 
 
64 
 
65 
begin
66 
 
67 
   douta     <=  douta_i;
68 
   doutb     <=  (OTHERS=>'0');   -- doutb_i;
69 
 
70 
   -- ---------------------------------------
71 
   --
72 
   Syn_Delay_Writes:
73 
   process ( clk )
74 
   begin
75 
      if clk'event and clk = '1' then
76 
         wea_r1  <= wea;
77 
         web_r1  <= web;
78 
         dina_r1 <= dina;
79 
         dinb_r1 <= dinb;
80 
      end if;
81 
   end process;
82 
 
83 
 
84 
   -- ---------------------------------------
85 
   --
86 
   FF_Address:
87 
   process ( clk )
88 
   begin
89 
      if clk'event and clk = '1' then
90 
 
91 
         FOR k IN 0 TO C_TAG_MAP_WIDTH-1 LOOP
92 
 
93 
            if addra=CONV_STD_LOGIC_VECTOR(k, C_TAGRAM_AWIDTH)
94 
               then
95 
               FF_Muxer_a(k)   <= '1';
96 
            else
97 
               FF_Muxer_a(k)   <= '0';
98 
            end if;
99 
 
100 
         END LOOP;
101 
 
102 
         FOR k IN 0 TO C_TAG_MAP_WIDTH-1 LOOP
103 
 
104 
            if addrb=CONV_STD_LOGIC_VECTOR(k, C_TAGRAM_AWIDTH)
105 
               then
106 
               FF_Muxer_b(k)   <= '1';
107 
            else
108 
               FF_Muxer_b(k)   <= '0';
109 
            end if;
110 
 
111 
         END LOOP;
112 
 
113 
      end if;
114 
   end process;
115 
 
116 
 
117 
   -- ---------------------------------------
118 
   --
119 
   FF_Matrix_Write:
120 
   process ( clk )
121 
   begin
122 
     if clk'event and clk = '1' then
123 
 
124 
       FOR k IN 0 TO C_TAG_MAP_WIDTH-1 LOOP
125 
 
126 
         if wea_r1='1' and web_r1='1' and FF_Muxer_a(k)='1' and FF_Muxer_b(k)='1' then
127 
            FF_Reg(k)   <= dina_r1;
128 
         elsif wea_r1='1' and FF_Muxer_a(k)='1' then
129 
            FF_Reg(k)   <= dina_r1;
130 
         elsif web_r1='1' and FF_Muxer_b(k)='1' then
131 
            FF_Reg(k)   <= dinb_r1;
132 
         else
133 
            FF_Reg(k)   <= FF_Reg(k);
134 
         end if;
135 
 
136 
       END LOOP;
137 
 
138 
     end if;
139 
   end process;
140 
 
141 
 
142 
   -- ---------------------------------------
143 
   --
144 
   FF_Matrix_Read:
145 
   process ( clk )
146 
   begin
147 
     if clk'event and clk = '1' then
148 
 
149 
         case FF_Muxer_a is
150 
 
151 
            when X"0000000000000001" =>
152 
              douta_i     <= FF_Reg(0);
153 
            when X"0000000000000002" =>
154 
              douta_i     <= FF_Reg(1);
155 
            when X"0000000000000004" =>
156 
              douta_i     <= FF_Reg(2);
157 
            when X"0000000000000008" =>
158 
              douta_i     <= FF_Reg(3);
159 
            when X"0000000000000010" =>
160 
              douta_i     <= FF_Reg(4);
161 
            when X"0000000000000020" =>
162 
              douta_i     <= FF_Reg(5);
163 
            when X"0000000000000040" =>
164 
              douta_i     <= FF_Reg(6);
165 
            when X"0000000000000080" =>
166 
              douta_i     <= FF_Reg(7);
167 
            when X"0000000000000100" =>
168 
              douta_i     <= FF_Reg(8);
169 
            when X"0000000000000200" =>
170 
              douta_i     <= FF_Reg(9);
171 
            when X"0000000000000400" =>
172 
              douta_i     <= FF_Reg(10);
173 
            when X"0000000000000800" =>
174 
              douta_i     <= FF_Reg(11);
175 
            when X"0000000000001000" =>
176 
              douta_i     <= FF_Reg(12);
177 
            when X"0000000000002000" =>
178 
              douta_i     <= FF_Reg(13);
179 
            when X"0000000000004000" =>
180 
              douta_i     <= FF_Reg(14);
181 
            when X"0000000000008000" =>
182 
              douta_i     <= FF_Reg(15);
183 
 
184 
            when X"0000000000010000" =>
185 
              douta_i     <= FF_Reg(16);
186 
            when X"0000000000020000" =>
187 
              douta_i     <= FF_Reg(17);
188 
            when X"0000000000040000" =>
189 
              douta_i     <= FF_Reg(18);
190 
            when X"0000000000080000" =>
191 
              douta_i     <= FF_Reg(19);
192 
            when X"0000000000100000" =>
193 
              douta_i     <= FF_Reg(20);
194 
            when X"0000000000200000" =>
195 
              douta_i     <= FF_Reg(21);
196 
            when X"0000000000400000" =>
197 
              douta_i     <= FF_Reg(22);
198 
            when X"0000000000800000" =>
199 
              douta_i     <= FF_Reg(23);
200 
            when X"0000000001000000" =>
201 
              douta_i     <= FF_Reg(24);
202 
            when X"0000000002000000" =>
203 
              douta_i     <= FF_Reg(25);
204 
            when X"0000000004000000" =>
205 
              douta_i     <= FF_Reg(26);
206 
            when X"0000000008000000" =>
207 
              douta_i     <= FF_Reg(27);
208 
            when X"0000000010000000" =>
209 
              douta_i     <= FF_Reg(28);
210 
            when X"0000000020000000" =>
211 
              douta_i     <= FF_Reg(29);
212 
            when X"0000000040000000" =>
213 
              douta_i     <= FF_Reg(30);
214 
            when X"0000000080000000" =>
215 
              douta_i     <= FF_Reg(31);
216 
 
217 
            when X"0000000100000000" =>
218 
              douta_i     <= FF_Reg(32);
219 
            when X"0000000200000000" =>
220 
              douta_i     <= FF_Reg(33);
221 
            when X"0000000400000000" =>
222 
              douta_i     <= FF_Reg(34);
223 
            when X"0000000800000000" =>
224 
              douta_i     <= FF_Reg(35);
225 
            when X"0000001000000000" =>
226 
              douta_i     <= FF_Reg(36);
227 
            when X"0000002000000000" =>
228 
              douta_i     <= FF_Reg(37);
229 
            when X"0000004000000000" =>
230 
              douta_i     <= FF_Reg(38);
231 
            when X"0000008000000000" =>
232 
              douta_i     <= FF_Reg(39);
233 
            when X"0000010000000000" =>
234 
              douta_i     <= FF_Reg(40);
235 
            when X"0000020000000000" =>
236 
              douta_i     <= FF_Reg(41);
237 
            when X"0000040000000000" =>
238 
              douta_i     <= FF_Reg(42);
239 
            when X"0000080000000000" =>
240 
              douta_i     <= FF_Reg(43);
241 
            when X"0000100000000000" =>
242 
              douta_i     <= FF_Reg(44);
243 
            when X"0000200000000000" =>
244 
              douta_i     <= FF_Reg(45);
245 
            when X"0000400000000000" =>
246 
              douta_i     <= FF_Reg(46);
247 
            when X"0000800000000000" =>
248 
              douta_i     <= FF_Reg(47);
249 
 
250 
            when X"0001000000000000" =>
251 
              douta_i     <= FF_Reg(48);
252 
            when X"0002000000000000" =>
253 
              douta_i     <= FF_Reg(49);
254 
            when X"0004000000000000" =>
255 
              douta_i     <= FF_Reg(50);
256 
            when X"0008000000000000" =>
257 
              douta_i     <= FF_Reg(51);
258 
            when X"0010000000000000" =>
259 
              douta_i     <= FF_Reg(52);
260 
            when X"0020000000000000" =>
261 
              douta_i     <= FF_Reg(53);
262 
            when X"0040000000000000" =>
263 
              douta_i     <= FF_Reg(54);
264 
            when X"0080000000000000" =>
265 
              douta_i     <= FF_Reg(55);
266 
            when X"0100000000000000" =>
267 
              douta_i     <= FF_Reg(56);
268 
            when X"0200000000000000" =>
269 
              douta_i     <= FF_Reg(57);
270 
            when X"0400000000000000" =>
271 
              douta_i     <= FF_Reg(58);
272 
            when X"0800000000000000" =>
273 
              douta_i     <= FF_Reg(59);
274 
            when X"1000000000000000" =>
275 
              douta_i     <= FF_Reg(60);
276 
            when X"2000000000000000" =>
277 
              douta_i     <= FF_Reg(61);
278 
            when X"4000000000000000" =>
279 
              douta_i     <= FF_Reg(62);
280 
--            when X"8000000000000000" =>
281 
--              douta_i     <= FF_Reg(63);
282 
            when OTHERS =>
283 
              douta_i     <= FF_Reg(63);
284 
 
285 
         end case;
286 
 
287 
     end if;
288 
   end process;
289 
 
290 
 
291 
end architecture STRUCTURE;
292 
 

powered by: WebSVN 2.1.0

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