source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/memory_manager_beha.vhd @ 10738

Last change on this file since 10738 was 10738, checked in by neise, 8 years ago
File size: 12.5 KB
Line 
1--
2-- VHDL Architecture FACT_FAD_lib.memory_manager.beha
3--
4-- Created:
5--          by - kai.UNKNOWN (E5PCXX)
6--          at - 14:33:25 02.03.2010
7--
8-- using Mentor Graphics HDL Designer(TM) 2008.1 (Build 17)
9--
10library ieee;
11use ieee.std_logic_1164.all;
12use IEEE.STD_LOGIC_ARITH.all;
13use ieee.STD_LOGIC_UNSIGNED.all;
14
15library FACT_FAD_lib;
16use FACT_FAD_lib.fad_definitions.all;
17
18-- library UNISIM;
19-- use UNISIM.VComponents.all;
20-- USE IEEE.NUMERIC_STD.all;
21
22-- RAM_ADDR_WIDTH_64B is used for
23-- output ram_start_addr
24
25-- RAM_ADDR_WIDTH_16B is used for
26-- output wiz_ram_start_addr
27
28
29ENTITY memory_manager IS
30generic(
31        RAM_ADDR_WIDTH_64B : integer := 12;
32        RAM_ADDR_WIDTH_16B : integer := 14 
33);
34PORT( 
35        clk : IN std_logic;
36        config_start : IN std_logic;
37        ram_write_ready : IN std_logic;
38        -- --
39        ram_write_ready_ack : OUT std_logic := '0';
40        -- --
41        roi_array : IN roi_array_type;
42        ram_write_ea : OUT std_logic := '0';
43        config_ready : OUT std_logic := '1';
44        roi_max : OUT roi_max_type := (others => conv_std_logic_vector (0, 11));
45        package_length : OUT std_logic_vector (15 downto 0) := (others => '0');
46        wiz_ram_start_addr : OUT std_logic_vector (RAM_ADDR_WIDTH_16B-1 downto 0) := (others => '0');
47        wiz_write_length : OUT std_logic_vector (16 downto 0) := (others => '0');
48        wiz_number_of_channels : OUT std_logic_vector (3 downto 0) := (others => '0');
49        wiz_write_ea : OUT std_logic := '0';
50        wiz_write_header : OUT std_logic := '0';
51        wiz_write_end : OUT std_logic := '0';
52        wiz_busy : IN std_logic;
53        wiz_ack : IN std_logic;
54        ram_start_addr : OUT std_logic_vector (RAM_ADDR_WIDTH_64B-1 DOWNTO 0) := (others => '0');
55        data_ram_empty : out std_logic
56);
57
58-- Declarations
59
60END memory_manager ;
61
62--
63ARCHITECTURE beha OF memory_manager IS
64
65type state_mm_type is (MM_CONFIG, MAX_ROI, MAX_ROI1, MAX_ROI2, FIFO_CALC, RAM_CALC, RAM_CALC1, RAM_CALC2, MM_MAIN, MM_MAIN1, MM_MAIN2, MM_MAIN3, MM_MAIN4);
66signal state_mm : state_mm_type := MM_CONFIG;
67
68--type roi_array_type is array (0 to 35) of integer range 0 to 1024;
69type roi_max_array_type is array (0 to 8) of integer range 0 to 1024;
70type channel_size_type is array (0 to 8) of integer range 0 to W5300_TX_FIFO_SIZE;
71type fifo_write_length_type is array (0 to 8) of integer range 0 to W5300_TX_FIFO_SIZE;
72type fifo_channels_array_type is array (0 to 8) of integer range 0 to 9;
73type fifo_package_size_ram_type is array (0 to 8) of integer range 0 to RAM_SIZE_16B;
74
75signal roi_max_array : roi_max_array_type := (others => 0);
76
77-- size of channel groups (16 bit)
78signal channel_size : channel_size_type := (others => 0);
79-- write length of packages (16 bit)
80signal fifo_write_length : fifo_write_length_type := (others => 0);
81-- number of channels per package
82signal fifo_channels_array : fifo_channels_array_type := (others => 0);
83-- size of packages in ram (16 bit)
84signal fifo_package_size_ram : fifo_package_size_ram_type := (others => 0);
85--
86signal event_size_ram : integer range 0 to RAM_SIZE_16B := 0;
87signal event_size_ram_64b : integer range 0 to RAM_SIZE_64B := 0;
88signal event_size : integer range 0 to RAM_SIZE_16B := 0;
89
90signal drs_id : integer range 0 to 4 := 0;
91signal channel_id : integer range 0 to 9 := 0;
92signal channel_index : integer range 0 to 9 := 0;
93signal package_index : integer range 0 to 9 := 0;
94signal number_of_packages : integer range 0 to 9 := 0;
95signal max_events_ram, events_in_ram : integer range 0 to 2048;
96signal event_start_addr : integer range 0 to (RAM_SIZE_64B - 1);
97signal write_start_addr : integer range 0 to (RAM_SIZE_16B - 1);
98signal event_ready_flag : std_logic := '0';
99signal wiz_ack_flag : std_logic := '0';
100-- never used DN18.05.11
101--signal wiz_write_ea_flag: std_logic := '0';
102
103signal roi_index : integer range 0 to 45 := 0;
104signal temp_roi : integer range 0 to 1024 := 0;
105
106-- SYNCH IN INPUT SIGNALS -----------------------------------------
107
108        signal config_start_sr          : std_logic_vector(1 downto 0) := "00";
109        signal ram_write_ready_sr       : std_logic_vector(1 downto 0) := "00";
110        signal wiz_busy_sr                      : std_logic_vector(1 downto 0) := "00";
111        signal wiz_ack_sr                       : std_logic_vector(1 downto 0) := "00";
112                -- no shift register, but local copy.
113        signal roi_array_local : roi_array_type;
114
115BEGIN
116
117--  led <= conv_std_logic_vector (events_in_ram, 4) & "00" & wiz_ack & wiz_busy;
118  data_ram_empty <= '1' when events_in_ram = 0 else '0'; 
119 
120  mm : process (clk)
121  begin
122    if rising_edge (clk) then
123        -- here: the synchin in of asynchronous input signals takes place.
124        config_start_sr         <= config_start_sr(0) & config_start;
125        ram_write_ready_sr      <= ram_write_ready_sr(0) & ram_write_ready;
126        wiz_busy_sr                     <= wiz_busy_sr(0) & wiz_busy;
127        wiz_ack_sr                      <= wiz_ack_sr(0) & wiz_ack;
128
129        roi_array_local         <= roi_array;
130       
131      case state_mm is
132   
133        when MM_CONFIG =>
134                        -- this if clause was doubled ... already in MAIN state config_start = '1' was checked...
135                        -- this is imho not needed and can cause trouble... DN 17.05.11
136          --if (config_start_sr = "11") then
137            config_ready <= '0';
138            roi_max_array <= (others => 0);
139            channel_size <= (others => 0);
140            fifo_write_length <= (others => 0);
141            fifo_channels_array <= (others => 0);
142            event_size <= 0;
143            ram_write_ea <= '0';
144            state_mm <= MAX_ROI;
145          --end if;
146       
147        -- calculate max ROIs and channel sizes
148        when MAX_ROI =>
149          roi_index <= (drs_id * 9) + channel_id;
150          state_mm <= MAX_ROI1;
151        when MAX_ROI1 =>
152          temp_roi <= roi_array_local (roi_index);
153          state_mm <= MAX_ROI2;
154        when MAX_ROI2 =>
155          if (channel_id < 9) then
156            if ( temp_roi > roi_max_array (channel_id)) then
157              roi_max_array (channel_id) <= temp_roi;
158            end if;
159            channel_size (channel_id) <= channel_size (channel_id) + temp_roi + CHANNEL_HEADER_SIZE;
160            drs_id <= drs_id + 1;
161            state_mm <= MAX_ROI;
162            if (drs_id = 3) then
163              drs_id <= 0;
164              channel_id <= channel_id + 1;
165            end if;
166          else
167            drs_id <= 0;
168            channel_id <= 0;
169            channel_size (0) <= channel_size (0) + PACKAGE_HEADER_LENGTH;
170            channel_size (8) <= channel_size (8) + PACKAGE_END_LENGTH;
171            state_mm <= FIFO_CALC;
172          end if;
173       
174        -- calculate number of channels that fit in FIFO
175        when FIFO_CALC =>
176          if (channel_id < 9) then
177            if ((fifo_write_length (package_index) + channel_size (channel_id)) <= W5300_TX_FIFO_SIZE) then
178              fifo_write_length (package_index) <= fifo_write_length (package_index) + channel_size (channel_id);
179              fifo_channels_array (package_index) <= fifo_channels_array (package_index) + 1;
180              channel_id <= channel_id + 1;
181              event_size <= event_size + channel_size (channel_id);
182            else
183              package_index <= package_index + 1;
184            end if;
185          else
186            number_of_packages <= package_index + 1;
187            package_index <= 0;
188            channel_index <= 0;
189            channel_id <= 0;
190            fifo_package_size_ram <= (others => 0);
191            fifo_package_size_ram (0) <= PACKAGE_HEADER_LENGTH + PACKAGE_HEADER_ZEROS; 
192            event_size_ram <= 0;
193            event_size_ram_64b <= 0;
194            max_events_ram <= 0;           
195            state_mm <= RAM_CALC;
196          end if;
197         
198        when RAM_CALC =>
199          if (package_index < number_of_packages) then
200            if (channel_index < fifo_channels_array (package_index)) then
201              fifo_package_size_ram (package_index) <= 
202                          fifo_package_size_ram (package_index) + ((roi_max_array (channel_id) + CHANNEL_HEADER_SIZE) * NUMBER_OF_DRS);
203              channel_index <= channel_index + 1;
204              channel_id <= channel_id + 1;
205            else
206              package_index <= package_index + 1;
207              event_size_ram <= event_size_ram + fifo_package_size_ram (package_index);
208              channel_index <= 0;
209            end if;
210          else
211            fifo_package_size_ram (package_index - 1) <= fifo_package_size_ram (package_index - 1) + PACKAGE_END_LENGTH + PACKAGE_END_ZEROS;
212            event_size_ram <= event_size_ram + PACKAGE_END_LENGTH + PACKAGE_END_ZEROS;
213            state_mm <= RAM_CALC1;
214          end if;
215        when RAM_CALC1 =>
216          max_events_ram <= max_events_ram + 1;
217          if ((max_events_ram * event_size_ram) <= RAM_SIZE_16B) then
218            state_mm <= RAM_CALC1;
219          else
220            max_events_ram <= max_events_ram - 1;
221            state_mm <= RAM_CALC2;
222          end if;
223        when RAM_CALC2 =>
224          event_size_ram_64b <= (event_size_ram / 4);
225          events_in_ram <= 0;
226          event_start_addr <= 0;
227          write_start_addr <= 0;
228          package_index <= 0;
229          channel_id <= 0;
230          ram_start_addr <= (others => '0');
231          ram_write_ea <= '1';
232          config_ready <= '1';
233          package_length <= conv_std_logic_vector (event_size, 16);
234          for i in 0 to 8 loop
235            roi_max(i) <= conv_std_logic_vector(roi_max_array(i), 11);
236          end loop;
237         
238          event_ready_flag <= '0';
239          wiz_ack_flag <= '0';
240          -- never used --> commented out: DN18.05.11
241                  --wiz_write_ea_flag <= '0';
242          state_mm <= MM_MAIN;
243         
244        when MM_MAIN =>
245          state_mm <= MM_MAIN1;
246          if (config_start_sr = "11") then
247            --config_ready <= '0';
248            if (events_in_ram = 0) then
249              state_mm <= MM_CONFIG;
250            end if;
251          end if;
252
253        when MM_MAIN1 =>
254          state_mm <= MM_MAIN2;
255          if ((ram_write_ready_sr = "11") and (event_ready_flag = '0')) then
256            ram_write_ea <= '0';
257            -- --
258            ram_write_ready_ack <= '1';
259            -- --
260            events_in_ram <= events_in_ram + 1;
261            if ((event_start_addr + event_size_ram_64b) < (RAM_SIZE_64B - event_size_ram_64b)) then
262              event_start_addr <= event_start_addr + event_size_ram_64b;
263            else
264              event_start_addr <= 0;
265            end if;
266            event_ready_flag <= '1';
267          end if;
268         
269
270        when MM_MAIN2 =>
271          state_mm <= MM_MAIN3;
272          if ((event_ready_flag = '1') and (ram_write_ready_sr = "00")) then
273            if (events_in_ram < max_events_ram) then
274              ram_write_ea <= '1';             
275              ram_start_addr <= conv_std_logic_vector(event_start_addr, RAM_ADDR_WIDTH_64B);
276              event_ready_flag <= '0';
277              -- --
278              ram_write_ready_ack <= '0';
279              -- --
280            end if;
281          end if;
282
283        when MM_MAIN3 =>
284          state_mm <= MM_MAIN4;
285          if ((wiz_ack_sr = "11") and (wiz_ack_flag = '0')) then
286            wiz_ack_flag <= '1';
287            wiz_write_ea <= '0';
288            package_index <= package_index + 1;
289            if (package_index = (number_of_packages - 1)) then
290              -- next address
291              if ((write_start_addr + fifo_package_size_ram (package_index)) < (RAM_SIZE_16B - event_size_ram)) then
292                write_start_addr <= write_start_addr + fifo_package_size_ram (package_index);
293              else
294                write_start_addr <= 0;
295              end if;
296            else
297              write_start_addr <= write_start_addr + fifo_package_size_ram (package_index);
298            end if;
299          end if; -- wiz_ack_int
300         
301        when MM_MAIN4 =>
302          state_mm <= MM_MAIN;
303          if ((events_in_ram > 0) and (wiz_busy_sr = "00")) then
304            if (package_index < number_of_packages) then             
305              wiz_ram_start_addr <= conv_std_logic_vector(write_start_addr, RAM_ADDR_WIDTH_16B);
306              wiz_write_length <= conv_std_logic_vector(fifo_write_length (package_index), 17);
307              wiz_number_of_channels <= conv_std_logic_vector(fifo_channels_array (package_index), 4);
308              wiz_write_ea <= '1';
309              wiz_ack_flag <= '0';
310              if (package_index = 0) then
311                -- first package -> write header
312                wiz_write_header <= '1';
313              else
314                wiz_write_header <= '0';
315              end if;
316              if (package_index = (number_of_packages - 1)) then
317                -- last package -> write end-flag
318                wiz_write_end <= '1';
319              else
320                wiz_write_end <= '0';
321              end if;
322            else
323              events_in_ram <= events_in_ram - 1;
324              package_index <= 0;
325            end if;
326          end if; 
327         
328       
329      end case; -- state_mm
330    end if;
331  end process mm; 
332 
333   
334 
335END ARCHITECTURE beha;
336
Note: See TracBrowser for help on using the repository browser.