source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/w5300_modul.vhd @ 10957

Last change on this file since 10957 was 10957, checked in by neise, 9 years ago
File size: 50.7 KB
Line 
1-- Module Name:    w5300_modul - Behavioral
2library IEEE;
3use IEEE.STD_LOGIC_1164.ALL;
4use IEEE.STD_LOGIC_ARITH.ALL;
5use IEEE.STD_LOGIC_UNSIGNED.ALL;
6library FACT_FAD_lib;
7use FACT_FAD_lib.fad_definitions.ALL;
8
9ENTITY w5300_modul IS
10  generic(
11    RAM_ADDR_WIDTH : integer := 14
12  );
13   PORT( 
14      state          : OUT    std_logic_vector (7 DOWNTO 0);  -- state is encoded here ... useful for debugging.
15          debug_data_ram_empty : OUT    std_logic;
16          debug_data_valid : OUT    std_logic;
17          data_generator_idle_i : IN std_logic;
18          socket_tx_free_out : out std_logic_vector (16 DOWNTO 0);  -- 17bit value .. that's true
19     
20      clk            : IN     std_logic;
21      wiz_reset      : OUT    std_logic                     := '1';
22      addr           : OUT    std_logic_vector (9 DOWNTO 0);
23      data           : INOUT  std_logic_vector (15 DOWNTO 0);
24      cs             : OUT    std_logic                     := '1';
25      wr             : OUT    std_logic                     := '1';
26      led            : OUT    std_logic_vector (7 DOWNTO 0) := (OTHERS => '0');
27      rd             : OUT    std_logic                     := '1';
28      int            : IN     std_logic;
29      write_length   : IN     std_logic_vector (16 DOWNTO 0);
30      ram_start_addr : IN     std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
31      ram_data       : IN     std_logic_vector (15 DOWNTO 0);
32      ram_addr       : OUT    std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
33      data_valid     : IN     std_logic;
34      data_valid_ack : OUT    std_logic := '0';
35      busy           : OUT    std_logic                     := '1';
36      write_header_flag, write_end_flag : IN std_logic;
37      fifo_channels : IN std_logic_vector (3 downto 0);
38      -- softtrigger:
39      s_trigger : OUT std_logic := '0';
40      c_trigger_enable: out std_logic := '0';
41      c_trigger_mult: out std_logic_vector (15 DOWNTO 0) := conv_std_logic_vector(0 ,16); --subject to changes
42     
43     
44
45          -- FAD configuration signals:
46          ------------------------------------------------------------------------------
47                memory_manager_config_start_o   : out std_logic := '0';
48                memory_manager_config_valid_i   : in std_logic;
49               
50                spi_interface_config_start_o    : out std_logic := '0';
51                spi_interface_config_valid_i    : in std_logic;
52               
53                --data_generator_config_start_o : out std_logic := '0';
54                --data_generator_config_valid_i : in std_logic;
55               
56                dac_setting                                             : out dac_array_type := DEFAULT_DAC;            --<<-- default defined in fad_definitions.vhd
57                roi_setting                                             : out roi_array_type := DEFAULT_ROI;            --<<-- default defined in fad_definitions.vhd
58               
59                runnumber                                               : out std_logic_vector (31 DOWNTO 0) := conv_std_logic_vector(0 ,32); 
60                reset_trigger_id                                : out std_logic := '0';
61
62                data_ram_empty                                  : IN std_logic;
63               
64          ------------------------------------------------------------------------------
65     
66          -- MAC/IP calculation signals:
67          ------------------------------------------------------------------------------
68      MAC_jumper : in std_logic_vector (1 downto 0);
69      BoardID : in std_logic_vector (3 downto 0);
70      CrateID : in std_logic_vector (1 downto 0);
71          ------------------------------------------------------------------------------
72     
73          -- user controllable enable signals
74          ------------------------------------------------------------------------------
75          trigger_enable : out std_logic; 
76         
77      denable : out std_logic := '0'; -- default domino wave on. ... in case if REFCLK error ... REFCLK counter will override.
78      dwrite_enable : out std_logic := '1'; -- default DWRITE low.
79      sclk_enable : out std_logic := '1'; -- default DWRITE HIGH.
80      srclk_enable : out std_logic := '1'; -- default SRCLK on.
81          ------------------------------------------------------------------------------
82         
83          -- ADC CLK generator, is able to shift phase with respect to X_50M
84          -- these signals control the behavior of the digital clock manager (DCM)
85          ------------------------------------------------------------------------------
86          ps_direction : out std_logic := '1'; -- default phase shift upwards
87      ps_do_phase_shift : out std_logic := '0'; --pulse this to phase shift once
88      ps_reset : out std_logic := '0'; -- pulse this to reset the variable phase shift
89      ps_ready : in std_logic;
90      ------------------------------------------------------------------------------
91         
92          -- signals used to control FAD LED bahavior:
93          -- one of the three LEDs is used for com-status info
94          ------------------------------------------------------------------------------
95      socks_waiting : out std_logic;
96      socks_connected: out std_logic
97          ------------------------------------------------------------------------------
98       
99       
100         
101   );
102END w5300_modul ;
103
104architecture Behavioral of w5300_modul is 
105
106type state_init_type is (
107        INTERRUPT, RESET, WRITE_REG, READ_REG, WRITE_DATA,
108        INIT, LOCATE, IM, MT, STX, STX1, STX2, STX3, SRX, SRX1, SRX2, SRX3, MAC, MAC1, MAC2, GW, GW1, SNM, SNM1, IP, IP1, TIMEOUT, RETRY,
109        SI, SI1, SI1b, SI2, SI3, SI4, SI5, SI6, ESTABLISH, EST1, 
110       
111        CONFIG, WAIT_100NS, WAIT_UNTIL_DG_IDLE, WAIT_FOR_DATA_RAM_EMPTY,  -- <-- this is THE deadlock state
112        CONFIG_MEMORY_MANAGER, WAIT_FOR_CONFIG_MEMORY_MANAGER,
113        CONFIG_DATA_GENERATOR, WAIT_FOR_CONFIG_DATA_GENERATOR,
114        CONFIG_DAC_ONLY, WAIT_FOR_CONFIG_DAC_ONLY,
115       
116        MAIN, MAIN1, MAIN2, MAIN3, CHK_RECEIVED, READ_DATA
117);
118type state_write_type is (
119        WR_START, 
120        WR_GET_EVT_ID_WAIT1, WR_GET_EVT_ID1, WR_GET_EVT_ID_WAIT2, WR_GET_EVT_ID2,
121        WR_MOD7_STARTED, WR_WAIT_FOR_MOD7,
122        WR_CHECK_FOR_FIFO_SPACE_01, WR_CHECK_FOR_FIFO_SPACE_02, WR_CHECK_FOR_FIFO_SPACE_03, WR_CHECK_FOR_FIFO_SPACE_04, 
123        WR_05, WR_05_PREPARE_LENGTH_INFO, WR_05_POSTPREPARE_LENGTH_INFO,
124        WORKAROUND_CHECK_FIFO_SPACE_01, WORKAROUND_CHECK_FIFO_SPACE_02, WORKAROUND_CHECK_FIFO_SPACE_03, WORKAROUND_CHECK_FIFO_SPACE_04,
125        WR_05a, WR_05b, WR_06, WR_07, 
126        WR_ACK, WR_WAIT_FOR_ACK, WAIT_FOR_DATA_VALID_HIGH_AGAIN,
127        WR_FIFO, WR_FIFO1, WR_ADC, WR_ADC1, WR_ADC2,
128        WR_ENDFLAG, WR_ENDFLAG1, WR_ENDFLAG2, WR_ENDFLAG3
129); 
130type state_interrupt_1_type is (IR1_01, IR1_02, IR1_03, IR1_04);
131type state_interrupt_2_type is (IR2_01, IR2_02, IR2_03, IR2_04, IR2_05, IR2_06);
132type state_read_data_type is (
133        RD_1, 
134        RD_2, 
135        RD_3, 
136        RD_4, 
137        RD_5,
138        WAIT_FOR_TRIGGER_ID_RESET_1, WAIT_FOR_TRIGGER_ID_RESET_2,
139        RD_6,
140        READ_COMMAND_DATA_SECTION,
141        PUT_COMMAND_DATA_SECTION,
142        EXECUTE,
143        RD_END
144);
145
146signal RST_TIME : std_logic_vector(19 downto 0) := X"7A120";
147
148signal par_addr : std_logic_vector (9 downto 0) := (OTHERS => '0');
149signal par_data : std_logic_vector (15 downto 0) := (OTHERS => '0');
150signal data_read : std_logic_vector (15 downto 0) := (OTHERS => '0');
151signal adc_data_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
152
153signal state_init, next_state , next_state_tmp : state_init_type := RESET;
154signal count : std_logic_vector (2 downto 0) := "000";
155signal state_write : state_write_type := WR_START;
156signal state_interrupt_1 : state_interrupt_1_type := IR1_01;
157signal state_interrupt_2 : state_interrupt_2_type := IR2_01;
158signal state_read_data : state_read_data_type := RD_1;
159
160signal interrupt_ignore : std_logic := '1';
161signal int_flag : std_logic := '0';
162signal ram_access : std_logic := '0';
163
164signal zaehler : std_logic_vector (19 downto 0) := (OTHERS => '0');
165signal data_cnt : integer := 0;
166signal drs_cnt : integer :=0;
167signal channel_cnt : integer range 0 to 9 :=0;
168signal socket_cnt : std_logic_vector (2 downto 0) := "000";
169signal roi_max : std_logic_vector (10 downto 0);
170signal data_end : integer := 0;
171
172signal socket_tx_free : std_logic_vector (16 downto 0) := (others => '0');
173signal write_length_bytes : std_logic_vector (16 downto 0);
174
175signal socket_rx_received : std_logic_vector (16 downto 0) := (others => '0');
176signal chk_recv_cntr : integer range 0 to 10000 := 0;
177
178-- --
179signal wait_cntr : integer range 0 to 10000 := 0;
180-- --
181
182signal rx_packets_cnt : std_logic_vector (15 downto 0);
183
184signal update_of_rois : std_logic := '1';
185signal update_of_lessimportant : std_logic := '1';
186
187
188signal trigger_enable_sig : std_logic := '0';
189signal trigger_enable_storage_sig : std_logic;
190
191signal local_write_length   : std_logic_vector (16 DOWNTO 0);
192signal local_ram_start_addr : std_logic_vector (RAM_ADDR_WIDTH-1 DOWNTO 0);
193signal local_ram_addr       : std_logic_vector (RAM_ADDR_WIDTH-1 downto 0);
194signal local_socket_nr      : std_logic_vector (2 DOWNTO 0);
195signal local_write_header_flag, local_write_end_flag : std_logic;
196signal local_fifo_channels : std_logic_vector (3 downto 0);
197
198signal wait_100ns_sig : std_logic_vector (5 downto 0) := "000000";
199
200signal config_addr : integer range 0 to 47;
201type config_data_type is array (0 to 47) of std_logic_vector(15 downto 0); 
202signal config_setting : config_data_type := (
203--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
204--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
205--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
206--              X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A", X"000A",                --<<-- ROIs = 10 TESTING ONLY
207
208                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
209                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
210                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
211                X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400", X"0400",                --<<-- ROIs = 1024
212
213                X"61A8", X"0000", X"0000", X"0000", X"7080", X"7080", X"7080", X"7080",                                  --<<-- DACs
214                X"0000",
215                X"0000", X"0000",  -- MSword // LSword
216                X"0000"                                         -- this is a dummy address; this address is used only, if the user sent an invalid address within a WRITE command
217                );
218               
219               
220
221-- signals used for MAC/IP calculation:
222-- these 2 synch in, the jumper state.
223signal FAD_in_cam : std_logic := '0';
224signal FAD_at_ETHZ : std_logic := '0';
225-- these 2 synch in the FMP lines encoding the FAD position in the cam.
226signal bid : std_logic_vector (3 downto 0);
227signal cid : std_logic_vector (1 downto 0);
228-- these are just used as local variables, to make reading easier.
229signal mac_loc : mac_type;
230signal ip_loc : ip_type;
231signal gateway_loc : ip_type;
232signal netmask_loc : ip_type;
233
234        -- signals for synching in asynchronous input signals
235                ------------------------------------------------------------------------------
236                signal w5300_interrupt_sr : std_logic_vector(1 downto 0) := "11";
237                 --?? not sure if this init value is good
238                 -- but should be no problem, because interrupt_ignore is not true during the first 2 clock cycles.
239                 -- I hope!
240                signal data_valid_sr : std_logic_vector(1 downto 0) := "00"; 
241                ------------------------------------------------------------------------------
242                -- synch in CONFIG inputs
243                signal memory_manager_config_valid_i_sr         : std_logic_vector(1 downto 0) := "00";
244                signal spi_interface_config_valid_i_sr          : std_logic_vector(1 downto 0) := "00";
245                --signal data_generator_config_valid_i_sr               : std_logic_vector(1 downto 0) := "00";
246                signal data_ram_empty_sr                                        : std_logic_vector(1 downto 0) := (OTHERS => '0');
247
248
249                signal data_generator_idle_sr : std_logic_vector(2 downto 0) := "000";
250
251-- only for debugging
252--signal error_cnt : std_logic_vector (7 downto 0) := (others => '0');
253--signal last_trigger_id : std_logic_vector (15 downto 0) := (others => '0');
254signal DG_run_mode_temp_storage_signal : std_logic;
255signal data_generator_run_mode_signal : std_logic := '1'; -- default triggers will be accepted
256-- signals for different socket modes: DN 04.01.11
257signal socket_send_mode : std_logic := '0'; -- if 0 data is send via socket 0; if 1 data is send via the other sockets.
258-- signals for Sockek Number calculation
259signal event_number : std_logic_vector(31 downto 0);
260signal mod7_start : std_logic := '0';
261signal mod7_started : std_logic;
262signal mod7_valid : std_logic;
263signal mod7_result : std_logic_vector(2 downto 0);
264
265
266signal state_sig : std_logic_vector(7 downto 0) := X"FF";
267
268signal number_of_words_written_to_fifo :  std_logic_vector(15 downto 0) := (others => '0');
269signal number_of_bytes_written_to_fifo :  std_logic_vector(16 downto 0) := (others => '0');
270
271COMPONENT mod7
272         PORT (
273                        clk       : IN     std_logic;
274                        number    : IN     std_logic_vector (31 DOWNTO 0);
275                        start     : IN     std_logic;
276                        remainder : OUT    std_logic_vector (2 DOWNTO 0) := (others => '0');
277                        started   : OUT    std_logic                     := '0';
278                        valid     : OUT    std_logic                     := '0'
279         );
280         END COMPONENT;
281
282
283
284begin
285       
286        mod7_calculator : mod7
287        PORT MAP (
288                --locals => actuals
289                clk                     =>clk   ,
290                number          =>event_number  ,
291                start           =>mod7_start    ,
292                remainder       =>mod7_result   ,
293                started         =>mod7_started  ,
294                valid           =>mod7_valid
295        );
296
297
298  --synthesis translate_off
299  RST_TIME <= X"00120";
300  --synthesis translate_on
301 
302  -- concurrent statemnets
303 
304-- output config settings as DAC and ROI arrays.
305state <= state_sig;
306
307debug_data_valid <= interrupt_ignore;
308--debug_data_ram_empty <= data_ram_empty_sr(1);
309--debug_data_valid <= data_valid_sr(1);
310roi_mapping : for i in 0 to 35 generate
311        roi_setting(i) <= conv_integer(config_setting(i)) when (conv_integer(config_setting(i)) < 1025) else 1024;
312end generate roi_mapping;
313dac_mapping : for i in 0 to 7 generate
314        dac_setting(i) <= conv_integer(config_setting(i+36));
315end generate dac_mapping;
316c_trigger_mult <= config_setting(44);
317
318
319
320trigger_enable <= trigger_enable_sig;
321
322
323        w5300_proc : process (clk)
324        begin
325                if rising_edge (clk) then
326                --socket_tx_free_out <= socket_tx_free;
327               
328               
329                -- synch asynchronous inputs in:
330                memory_manager_config_valid_i_sr        <= memory_manager_config_valid_i_sr(0)  & memory_manager_config_valid_i;
331                spi_interface_config_valid_i_sr         <= spi_interface_config_valid_i_sr(0)   & spi_interface_config_valid_i;
332                --data_generator_config_valid_i_sr      <=      data_generator_config_valid_i_sr(0)     & data_generator_config_valid_i;
333                data_ram_empty_sr                                       <= data_ram_empty_sr(0)                 & data_ram_empty;               
334                data_generator_idle_sr                          <= data_generator_idle_sr( 1 downto 0 ) & data_generator_idle_i;
335               
336                w5300_interrupt_sr <= w5300_interrupt_sr(0) & int;
337                data_valid_sr <= data_valid_sr(0) & data_valid;
338               
339                        -- interrupt is handled synchronously
340                        -- W5300 pulls low its interrpt line in case of:
341                        --      When Sockets time out and
342                        -- When sockets receive disconnection request.
343                       
344                        if (w5300_interrupt_sr(1) = '0') and (interrupt_ignore = '0') then
345                                case state_interrupt_1 is
346                                        when IR1_01 =>
347                                        state_sig <= X"FF";
348                                                int_flag <= '1';
349                                                busy <= '1';
350                                                state_interrupt_1 <= IR1_02;  --wait one cycle
351                                        when IR1_02 =>
352                                        state_sig <= X"FE";
353                                                state_interrupt_1 <= IR1_03;
354                                        when IR1_03 =>
355                                        state_sig <= X"FD";
356                                                state_init <= INTERRUPT;
357                                                socket_cnt <= "000";
358                                                ram_access <= '0';
359                                                zaehler <= X"00000";    --what is this zaehler counting?
360                                                count <= "000";                 --what is this count counting?
361                                                int_flag <= '0';
362                                                interrupt_ignore <= '1';
363                                                state_interrupt_1 <= IR1_04;  --this state is not existing? bad coding habit???
364                                        when others =>
365                                                state_sig <= X"FC";
366                                                null;
367                                end case;
368                        end if; -- int = '0'
369                       
370                        if int_flag = '0' then
371                                case state_init is
372                                        -- Interrupt
373                                        when INTERRUPT =>
374                                                case state_interrupt_2 is
375                                                        when IR2_01 =>
376                                                        state_sig <= X"FB";
377                                                                par_addr <= W5300_IR;
378                                                                state_init <= READ_REG;
379                                                                next_state <= INTERRUPT;
380                                                                state_interrupt_2 <= IR2_02;
381                                                               
382                                                        -- check if it was a Sx Interrupt of Socket n
383                                                        -- therfor: loop over all channel.
384                                                        -- if the loop ended but no Sx Interrupt was found --> IR2_06
385                                                        -- if an Sx Interrupt was found go to --> IR2_03 and check what happened.
386                                                        when IR2_02 => 
387                                                        state_sig <= X"FA";
388                                                                if (data_read (conv_integer(socket_cnt)) = '1') then -- Sx Interrupt
389                                                                        state_interrupt_2 <= IR2_03;
390                                                                else
391                                                                        socket_cnt <= socket_cnt + 1;
392                                                                        if (socket_cnt = 7) then
393                                                                                state_interrupt_2 <= IR2_06;
394                                                                        else
395                                                                                state_interrupt_2 <= IR2_02;  -- go on with loop
396                                                                        end if; 
397                                                                end if;
398                                                               
399                                                        -- check the Interrupt register of the Socket, which caused the Interrupt.
400                                                        when IR2_03 =>
401                                                        state_sig <= X"F9";
402                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC; -- Sx Interrupt Register
403                                                                state_init <= READ_REG;
404                                                                next_state <= INTERRUPT;
405                                                                state_interrupt_2 <= IR2_04;
406                                                        -- before checking what happened, clear the Interrupt register, so we can proceed.
407                                                        when IR2_04 =>
408                                                        state_sig <= X"F8";
409                                                                par_addr <= W5300_S0_IR + socket_cnt * W5300_S_INC;
410                                                                par_data <= data_read; -- clear Interrupts
411                                                                state_init <= WRITE_REG;
412                                                                next_state <= INTERRUPT;
413                                                                state_interrupt_2 <= IR2_05;
414                                                        -- send the command to close this socket
415                                                        -- then go back and read the main Interrupt register again,
416                                                        -- if this was not Socket 7 ... if it was Socket 7, we're done anyway.
417                                                        when IR2_05 =>
418                                                        state_sig <= X"F7";
419                                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
420                                                                par_data <= X"0010"; -- CLOSE
421                                                                state_init <= WRITE_REG;
422                                                                next_state <= INTERRUPT;
423                                                                socket_cnt <= socket_cnt + 1;
424                                                                if (socket_cnt = 7) then
425                                                                  state_interrupt_2 <= IR2_06;
426                                                                else
427                                                                  state_interrupt_2 <= IR2_01;
428                                                                end if; 
429
430                                                        -- we go on and reset, the W5300 and this entire state machine.
431                                                        when IR2_06 =>
432                                                        state_sig <= X"F6";
433                                                                state_interrupt_1 <= IR1_01;
434                                                                state_interrupt_2 <= IR2_01;
435                                                                socket_cnt <= "000";
436                                                                state_init <= RESET;
437                                                        when others =>
438                                                                state_interrupt_1 <= IR1_01;
439                                                                state_interrupt_2 <= IR2_01;
440                                                                socket_cnt <= "000";
441                                                                state_init <= RESET;
442                                                end case;
443                                               
444                                        -- reset W5300
445                                        when RESET =>
446                                          state_sig <= X"01";
447                                                socket_send_mode <= '0';
448                                                busy <= '1';
449                                                zaehler <= zaehler + 1;
450                                                socks_waiting <= '0';
451                                                socks_connected <= '0';
452                                                wiz_reset <= '0';
453                                                --led <= X"FF";
454                                                if (zaehler >= X"00064") then -- wait 2µs
455                                                        wiz_reset <= '1';
456                                                end if; 
457                                                if (zaehler = RST_TIME) then -- wait 10ms
458                                                        zaehler <= X"00000";
459                                                        socket_cnt <= "000";
460                                                        count <= "000";
461                                                        ram_access <= '0';
462                                                        interrupt_ignore <= '0';
463                                                        rd <= '1';
464                                                        wr <= '1';
465                                                        cs <= '1';
466                                                        state_write <= WR_START;
467                                                        state_init <= INIT;
468                                                end if;
469                                               
470                                        -- Init
471                                        when INIT =>
472                                          state_sig <= X"02";
473                                                -- status of MAC jumpers is synched in
474                                                -- and Board- and CrateID are synched in
475                                                FAD_in_cam <= MAC_jumper(1); -- see position of jumpers in FACT logbook
476                                                FAD_at_ETHZ <= MAC_jumper(0); -- MAC_jumper(1) is where D_T(7) was; MAC_jumper(0) is where D_T(6) was;
477                                                bid <= BoardID;
478                                                cid <= CrateID;
479                                                par_addr <= W5300_MR;
480                                                par_data <= X"0000";
481                                                state_init <= WRITE_REG;
482                                                next_state <= LOCATE;
483                               
484                                        when LOCATE =>
485                                           state_sig <= X"03";                                   
486                                                state_init <= IM;
487
488                                                if (FAD_in_cam = '1') then
489                                                        if (bid = "1111" and cid="11") then
490                                                                -- if BID = "1111" and CID="11" then FAD is not really in cam
491                                                                -- I don't know what to do now.
492                                                                -- I could wait a long time, and then just assume, I was not in cam.
493                                                                -- this should never happen!!!!!
494                                                                -- impossible to find this out, if in cam
495                                                                gateway_loc <= ETHZ_GATEWAY;
496                                                                netmask_loc <= ETHZ_NETMASK;                                           
497                                                                mac_loc <= MAC_FAD2; 
498                                                                ip_loc <= IP_ETHZ_FAD2;
499                                                                --state_init <= INIT;
500                                                        else -- everything is fine
501                                                                -- IP & MAC are calculated from BID & CID
502                                                                -- code here
503                                                                gateway_loc <= CAM_GATEWAY;
504                                                                netmask_loc <= CAM_NETMASK;                                             
505                                                                mac_loc <= (CAM_MAC_prefix (0), CAM_MAC_prefix (1)  , conv_std_logic_vector ( conv_integer(cid)*10+conv_integer(bid)  , 16)   ); 
506                                                                ip_loc <= ( CAM_IP_PREFIX(0) , CAM_IP_PREFIX(1) , IP_offset + conv_integer(cid) , IP_offset + conv_integer(bid) );
507                                                        end if;
508                                                else -- FAD is tested, either at ETHZ or at TUDO AND either with FMP or without.
509                                                        if ( FAD_at_ETHZ = '0' ) then
510                                                                -- easy FAD is at TUDO -> only one choice.
511                                                                mac_loc <= MAC_FAD0;
512                                                                ip_loc <= IP_TUDO;
513                                                                gateway_loc <= TUDO_GATEWAY;
514                                                                netmask_loc <= TUDO_NETMASK;
515                                                        else -- FAD is at ETHZ but not in cam --> IP lookup table is needed.
516                                                                if (bid = "1111" and cid="11") then -- FAD is not in crate
517                                                                        mac_loc <= MAC_FAD0;
518                                                                        ip_loc <= IP_ETHZ_FAD0;
519                                                                        gateway_loc <= ETHZ_GATEWAY;
520                                                                        netmask_loc <= ETHZ_NETMASK;                                           
521                                                                else
522                                                                        -- FAD is at ETHZ and in crate:
523                                                                        -- crate ID is not of importance.
524                                                                        -- we only have 3 MACs and IPs so far, so only the first boardIDs are allowed.
525                                                                        if ( conv_integer(bid) < MAC_LIST'length) then
526                                                                                gateway_loc <= ETHZ_GATEWAY;
527                                                                                netmask_loc <= ETHZ_NETMASK;                                           
528                                                                                mac_loc <= MAC_LIST(conv_integer(bid));
529                                                                                ip_loc <= IP_LIST(conv_integer(bid));
530                                                                        end if; -- conv_integer
531                                                                end if; -- bid=1111 & cid=11
532                                                        end if; --FAD_at_ETHZ = 0
533                                                end if; --FAD_in_cam = 1
534                                               
535                                        -- Interrupt Mask
536                                        when IM =>
537                                          state_sig <= X"04";
538                                                par_addr <= W5300_IMR;
539                                                par_data <= X"00FF"; -- S0-S7 Interrupts
540                                                state_init <= WRITE_REG;
541                                                next_state <= MT;
542                                               
543                                        -- Memory Type
544                                        when MT =>
545                                          par_addr <=   W5300_MTYPER;
546                                          par_data <= X"7FFF"; -- 8K RX, 120K TX-Buffer
547                                          state_init <= WRITE_REG;
548                                          next_state <= STX;
549                                         
550                                        -- Socket TX Memory Size
551                                        when STX =>
552                                          par_data <= X"0F0F"; -- 15K TX
553
554                                                par_addr <= W5300_TMS01R;
555                                                state_init <=WRITE_REG;
556                                                next_state <= STX1;
557          when STX1 =>
558            par_addr <= W5300_TMS23R;
559            state_init <=WRITE_REG;
560            next_state <= STX2;
561          when STX2 =>
562            par_addr <= W5300_TMS45R;
563            state_init <=WRITE_REG;
564            next_state <= STX3;
565          when STX3 =>
566            par_addr <= W5300_TMS67R;
567            state_init <=WRITE_REG;
568            next_state <= SRX;
569                                       
570          -- Socket RX Memory Size
571          when SRX =>
572            par_data <= X"0101"; -- 1K RX
573             
574            par_addr <= W5300_RMS01R;
575            state_init <=WRITE_REG;
576            next_state <= SRX1;
577          when SRX1 =>
578            par_addr <= W5300_RMS23R;
579            state_init <=WRITE_REG;
580            next_state <= SRX2;
581          when SRX2 =>
582            par_addr <= W5300_RMS45R;
583            state_init <=WRITE_REG;
584            next_state <= SRX3;
585          when SRX3 =>
586            par_addr <= W5300_RMS67R;
587            state_init <=WRITE_REG;
588            next_state <= MAC;
589         
590                                        -- MAC
591                                        when MAC =>
592                                                par_addr <= W5300_SHAR;
593                                                par_data <= mac_loc(0);
594                                                state_init <= WRITE_REG;
595                                                next_state <= MAC1;
596                                        when MAC1 =>
597                                                par_addr <= W5300_SHAR + 2;
598                                                par_data <= mac_loc(1);
599                                                state_init <= WRITE_REG;
600                                                next_state <= MAC2;
601                                        when MAC2 =>
602                                                par_addr <= W5300_SHAR + 4;
603                                                par_data <= mac_loc(2);
604                                                state_init <= WRITE_REG;
605                                                next_state <= GW;
606                                               
607                                        -- Gateway
608                                        when GW =>
609                                                par_addr <= W5300_GAR;
610                                                par_data (15 downto 8) <= conv_std_logic_vector(gateway_loc(0),8);
611                                                par_data (7 downto 0) <= conv_std_logic_vector(gateway_loc(1),8);
612                                                state_init <= WRITE_REG;
613                                                next_state <= GW1;
614                                        when GW1 =>
615                                                par_addr <= W5300_GAR + 2;
616                                                par_data (15 downto 8) <= conv_std_logic_vector(gateway_loc(2),8);
617                                                par_data (7 downto 0) <= conv_std_logic_vector(gateway_loc(3),8);
618                                                state_init <= WRITE_REG;
619                                                next_state <= SNM;
620                                               
621                                        -- Subnet Mask
622                                        when SNM =>
623                                                par_addr <= W5300_SUBR;
624                                                par_data (15 downto 8) <= conv_std_logic_vector(netmask_loc(0),8);
625                                                par_data (7 downto 0) <= conv_std_logic_vector(netmask_loc(1),8);
626                                                state_init <= WRITE_REG;
627                                                next_state <= SNM1;
628                                        when SNM1 =>
629                                                par_addr <= W5300_SUBR + 2;
630                                                par_data (15 downto 8) <= conv_std_logic_vector(netmask_loc(2),8);
631                                                par_data (7 downto 0) <= conv_std_logic_vector(netmask_loc(3),8);
632                                                state_init <= WRITE_REG;
633                                                next_state <= IP;
634                                        -- Own IP-Address
635                                        when IP =>
636                                                par_addr <= W5300_SIPR;
637                                                par_data (15 downto 8) <= conv_std_logic_vector(ip_loc(0),8);
638                                                par_data (7 downto 0) <= conv_std_logic_vector(ip_loc(1),8);
639                                                state_init <= WRITE_REG;
640                                                next_state <= IP1;
641                                        when IP1 =>
642                                                par_addr <= W5300_SIPR + 2;
643                                                par_data (15 downto 8) <= conv_std_logic_vector(ip_loc(2),8);
644                                                par_data (7 downto 0) <= conv_std_logic_vector(ip_loc(3),8);
645                                                state_init <= WRITE_REG;
646                                                next_state <= SI;
647--                                      when TIMEOUT =>
648--            par_addr <=       W5300_RTR;
649--            par_data <= X"07D0"; -- 0x07D0 = 200ms
650--            state_init <= WRITE_REG;
651--            next_state <= RETRY;
652--          when RETRY =>
653--            par_addr <=       W5300_RCR;
654--            par_data <= X"0008";
655--            state_init <= WRITE_REG;
656--            next_state <= SI;
657--                                       
658
659                                        -- Socket Init
660                                        when SI =>
661                                          state_sig <= X"05";
662                                                par_addr <= W5300_S0_MR + socket_cnt * W5300_S_INC;
663                                                par_data <= X"0101"; -- ALIGN, TCP
664                                                state_init <= WRITE_REG;
665                                                next_state <= SI1;
666                                        -- Sx Interrupt Mask
667                                        when SI1 =>
668                                                par_addr <= W5300_S0_IMR + socket_cnt * W5300_S_INC;
669                                                par_data <= X"000A"; -- TIMEOUT, DISCON
670                                                state_init <= WRITE_REG;
671                                                next_state <= SI1b;
672                                        when SI1b =>
673                                                par_addr <= W5300_S0_PORTOR + socket_cnt * W5300_S_INC;
674                                                par_data <= X"0606"; -- send automatic KEEP ALIVE every 30s.
675                                                state_init <= WRITE_REG;
676                                                next_state <= SI2;                                             
677                                        when SI2 =>
678                                                par_addr <= W5300_S0_PORTR + socket_cnt * W5300_S_INC;
679                                                par_data <= conv_std_logic_vector(FIRST_PORT + unsigned (socket_cnt), 16);
680                                                state_init <= WRITE_REG;
681                                                next_state <= SI3;
682                                        when SI3 =>
683                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
684                                                par_data <= X"0001"; -- OPEN
685                                                state_init <= WRITE_REG;
686                                                next_state <= SI4;
687                                        when SI4 =>
688                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
689                                                state_init <= READ_REG;
690                                                next_state <= SI5;
691                                        when SI5 =>
692                                                if (data_read (7 downto 0) = X"13") then -- is open?
693                                                        state_init <= SI6;
694                                                else
695                                                        state_init <= SI4;
696                                                end if;
697                                        when SI6 =>
698                                                par_addr <= W5300_S0_CR + socket_cnt * W5300_S_INC;
699                                                par_data <= X"0002"; -- LISTEN
700                                                state_init <= WRITE_REG;
701                                                socket_cnt <= socket_cnt + 1;
702                                                if (socket_cnt = 7) then
703                                                  socket_cnt <= "000";
704                                                  next_state <= ESTABLISH; -- All Sockets open
705                                                else
706                                                  next_state <= SI; -- Next Socket
707                                                end if;
708                                  -- End Socket Init
709                                               
710                                        when ESTABLISH =>
711                                                state_sig <= X"07";
712                                                socks_waiting <= '1';
713                                                socks_connected <= '0';
714                                                par_addr <= W5300_S0_SSR + socket_cnt * W5300_S_INC;
715                                                state_init <= READ_REG;
716                                                next_state <= EST1;
717                                        when EST1 =>
718                                                state_sig <= X"08";
719                                                case data_read (7 downto 0) is
720                                                        when X"17" => -- established
721                                                                if (socket_cnt = 7) then
722                                                                  socket_cnt <= "000";
723                                                                  busy <= '0';
724                                                                  state_init <= MAIN;
725                                                                  --state_init <= CONFIG_MEMORY_MANAGER;
726                                                                else
727                                                                  socket_cnt <= socket_cnt + 1;
728                                                                  state_init <= ESTABLISH;
729                                                                end if;
730                                                        when others =>
731                                                                state_init <= ESTABLISH;
732                                                end case;
733                                               
734                                        when CONFIG =>   -- Triggers are disabled here!
735                                          state_sig <= X"06";
736                                                trigger_enable_storage_sig <= trigger_enable_sig;                               -- store last value of this signal.
737                                                trigger_enable_sig <= '0';                                                                              --no triggers must occur, while configurating.
738                                                state_init <= WAIT_100NS;                                                                               
739                                               
740                                        when WAIT_100NS =>
741                                                state_sig <= X"15";
742                                                wait_100ns_sig <= wait_100ns_sig + 1;
743                                                if (wait_100ns_sig = "110010") then
744                                                        wait_100ns_sig <= "000000";
745                                                        state_init <= WAIT_UNTIL_DG_IDLE;       
746                                                end if;
747                                               
748                                        when WAIT_UNTIL_DG_IDLE =>
749                                                state_sig <= X"16";
750                                                if (data_generator_idle_sr = "111") then
751                                                        --state_init <= CONFIG_MEMORY_MANAGER;
752                                                        state_init <= CONFIG_MEMORY_MANAGER;
753                                                end if;
754                                       
755                                       
756                                       
757                                       
758                                               
759                                        when WAIT_FOR_DATA_RAM_EMPTY =>                                                                 -- GUARANTIED DEAD LOCK HERE, because RAM will never empty, when staying in this state.
760                                          state_sig <= X"17";
761                                                if (data_ram_empty_sr(1) = '1') then
762                                                        state_init <= CONFIG_MEMORY_MANAGER;
763                                                end if;
764                                       
765                                        when CONFIG_MEMORY_MANAGER =>
766                                          state_sig <= X"18";
767                                                memory_manager_config_start_o <= '1';
768                                                if (memory_manager_config_valid_i_sr = "00") then
769                                                        state_init <= WAIT_FOR_CONFIG_MEMORY_MANAGER;
770                                                end if;
771                                       
772                                        when WAIT_FOR_CONFIG_MEMORY_MANAGER =>
773                                          state_sig <= X"19";
774                                                memory_manager_config_start_o <= '0';
775                                                if (memory_manager_config_valid_i_sr(1) = '1') then
776                                                        --state_init <= CONFIG_DATA_GENERATOR;
777                                                        trigger_enable_sig <= trigger_enable_storage_sig;
778                                                        state_init <= MAIN;
779                                                end if;
780                                       
781--                                      when CONFIG_DATA_GENERATOR =>
782--                                        state_sig <= X"1A";
783--                                              data_generator_config_start_o <= '1';
784--                                              if (data_generator_config_valid_i_sr = "00") then
785--                                                      state_init <= WAIT_FOR_CONFIG_DATA_GENERATOR;
786--                                              end if;
787--                                      when WAIT_FOR_CONFIG_DATA_GENERATOR =>
788--                                        state_sig <= X"1B";
789--                                              data_generator_config_start_o <= '0';
790--                                              if (data_generator_config_valid_i_sr ="11") then
791--                                                      trigger_enable_sig <= trigger_enable_storage_sig; --restore value of this signal to the value it had before CONFIG
792--                                                      state_init <= MAIN;
793--                                              end if;
794                                               
795                                               
796                                                when CONFIG_DAC_ONLY =>
797                                                  state_sig <= X"1C";
798                                                        spi_interface_config_start_o <= '1';
799                                                        if (spi_interface_config_valid_i_sr ="00") then
800                                                                state_init <= WAIT_FOR_CONFIG_DAC_ONLY;
801                                                        end if;
802                                               
803                                                when WAIT_FOR_CONFIG_DAC_ONLY =>
804                                                  state_sig <= X"1D";
805                                                        spi_interface_config_start_o <= '0';
806                                                        if (spi_interface_config_valid_i_sr ="11") then
807                                                                state_init <= MAIN;
808                                                        end if;
809                                                       
810----------------------------------------------------------------------------------
811-- MAIN "loop" -------------------------------------------------------------------
812----------------------------------------------------------------------------------
813         
814                                        when MAIN =>
815                                        state_sig <= X"20";
816                                        socks_waiting <= '0';
817                                        socks_connected <= '1';
818                                        ps_do_phase_shift <= '0';
819                                        ps_reset <= '0';
820                                        data_valid_ack <= '0';
821                                       
822                                               
823                                                if (update_of_rois = '1') then
824                                                        update_of_rois <= '0';
825                                                        state_init <= CONFIG;
826--                                                      if (trigger_enable_sig = '1') then
827--                                                              trigger_enable_storage_sig <= trigger_enable_sig;
828--                                                      end if;
829--                                                      trigger_enable_sig <= '0';
830--
831--                                                      update_of_rois <= '0';
832--                                                      state_init <= CONFIG_MEMORY_MANAGER;
833--                                                      if (data_ram_empty_sr(1) = '1') then
834--                                                              update_of_rois <= '0';
835--                                                              state_init <= CONFIG_MEMORY_MANAGER;
836--                                                      else
837--                                                              state_init <= MAIN2;
838--                                                      end if;
839                                                       
840                                                elsif (update_of_lessimportant = '1') then                             
841                                                        update_of_lessimportant <= '0';
842                                                        state_init <= CONFIG_DAC_ONLY;
843                                                else -- update_of_rois='0' and update_of_lessimportant='0'
844                                                        state_init <= MAIN1;
845                                                        --data_valid_int <= data_valid;
846                                                end if;
847                       
848                                        when MAIN1 =>
849                                          state_sig <= X"21";
850                                                if (chk_recv_cntr = 1000) then
851                                                        chk_recv_cntr <= 0;
852                                                        state_read_data <= RD_1;
853                                                        state_init <= READ_DATA;
854                                                        busy <= '1';
855                                                else
856                                                        chk_recv_cntr <= chk_recv_cntr + 1; 
857                                                        state_init <= MAIN2;
858                                                end if;
859                                        when MAIN2 =>
860                                          state_sig <= X"22";
861                                                busy <= '0';
862                                                --if (data_valid = '1') then
863                                                if (data_valid_sr(1) = '1') then
864                                                        --data_valid_int <= '0';
865                                                        busy <= '1';
866                                                        local_write_length <= write_length;
867                                                        local_ram_start_addr <= ram_start_addr;
868                                                        local_ram_addr <= (others => '0');
869                                                        local_write_header_flag <= write_header_flag;
870                                                        local_write_end_flag <= write_end_flag;
871                                                        local_fifo_channels <= fifo_channels;
872                                                        --                data_valid_ack <= '1';
873                                                        --                next_state <= MAIN;
874                                                        --                state_init <= WRITE_DATA;
875                                                        state_init <= MAIN3;
876                                                else
877                                                        state_init <= MAIN1; 
878                                                end if;
879                                        when MAIN3 =>
880                                                debug_data_ram_empty <= local_write_end_flag;
881                                          state_sig <= X"23";
882                                                -- needed for the check: if there is enough space in W5300 FIFO
883                                                write_length_bytes <= (local_write_length (15 downto 0) & '0')   ; -- shift left (*2)
884                                               
885                                                next_state <= MAIN;
886                                                state_init <= WRITE_DATA;
887                                               
888                                               
889----------------------------------------------------------------------------------
890-- END OF MAIN         -----------------------------------------------------------
891----------------------------------------------------------------------------------
892
893                                        -- read data from socket 0 
894                                        when READ_DATA =>
895                                                case state_read_data is
896                                                when RD_1 =>
897                                                  state_sig <= X"30";
898                                                        par_addr <= W5300_S0_RX_RSR;
899                                                        state_init <= READ_REG;
900                                                        next_state <= READ_DATA;
901                                                        state_read_data <= RD_2;
902                                                when RD_2 =>
903                                                  state_sig <= X"31";
904                                                        socket_rx_received (16) <= data_read(0);
905                                                        par_addr <= W5300_S0_RX_RSR + X"2";
906                                                        state_init <= READ_REG;
907                                                        next_state <= READ_DATA;
908                                                        state_read_data <= RD_3;
909                                                when RD_3 =>
910                                                  state_sig <= X"32";
911                                                        socket_rx_received (15 downto 0) <= data_read;
912                                                        state_read_data <= RD_4;
913                                                when RD_4 =>
914                                                  state_sig <= X"33";
915                                                        if (socket_rx_received (16 downto 0) > ('0' & X"000")) then
916                                                                rx_packets_cnt <= socket_rx_received (16 downto 1); -- socket_rx_received / 2
917                                                                state_read_data <= RD_5;
918                                                        else
919                                                                busy <= '0';
920                                                                state_init <= MAIN;
921                                                        end if;
922                                                when RD_5 =>
923                                                  state_sig <= X"34";
924                                                        s_trigger <= '0';
925                                                        ps_do_phase_shift <= '0';
926                                                        reset_trigger_id <= '0';
927                                                       
928                                                        if (rx_packets_cnt > 0) then
929                                                                rx_packets_cnt <= rx_packets_cnt - '1';
930                                                                par_addr <= W5300_S0_RX_FIFOR;
931                                                                state_init <= READ_REG;
932                                                                next_state <= READ_DATA;
933                                                                state_read_data <= RD_6;
934                                                        else
935                                                                state_read_data <= RD_END;
936                                                        end if;
937                                                       
938                                                when RD_6 =>
939                                                  state_sig <= X"35";
940                                                        -- The next 16bit word is assumed to contain a 'command' so it is
941                                                        -- beeing parsed in this state
942                                                        case data_read (15 downto 8) is
943                                                        when CMD_START =>
944                                                               
945                                                                state_read_data <= RD_5;
946                                                        when CMD_STOP => 
947                                                               
948                                                                state_read_data <= RD_5;
949                                                        when CMD_MODE_ALL_SOCKETS =>  -- all data will be send via socket 1..7
950                                                                socket_send_mode <= '1';
951                                                                state_read_data <= RD_5;
952                                                        when CMD_MODE_COMMAND => -- all data will be send via socket 0
953                                                                socket_send_mode <= '0';
954                                                                state_read_data <= RD_5;   
955                                                        when CMD_TRIGGER =>
956                                                                s_trigger <= '1';
957                                                                state_read_data <= RD_5;
958                                                        when CMD_DWRITE_RUN =>
959                                                                dwrite_enable <= '1';
960                                                                state_read_data <= RD_5;
961                                                        when CMD_DWRITE_STOP =>
962                                                                dwrite_enable <= '0';
963                                                                state_read_data <= RD_5;
964                                                        when CMD_SCLK_ON =>
965                                                                sclk_enable <= '1';
966                                                                state_read_data <= RD_5;
967                                                        when CMD_SCLK_OFF =>
968                                                                sclk_enable <= '0';
969                                                                state_read_data <= RD_5;
970                                                        when CMD_DENABLE =>
971                                                                denable <= '1';
972                                                                state_read_data <= RD_5;
973                                                        when CMD_DDISABLE =>
974                                                                denable <= '0';
975                                                                state_read_data <= RD_5;
976                                                        when CMD_TRIGGER_C =>
977                                                                c_trigger_enable <= '1';
978                                                                state_read_data <= RD_5;
979                                                        when CMD_TRIGGER_S =>
980                                                          c_trigger_enable <= '0';
981                                                          state_read_data <= RD_5;
982
983                                                        -- phase shift commands here:
984                                                        when CMD_PS_DO =>
985                                                          ps_do_phase_shift <= '1';
986                                                          state_read_data <= RD_5;
987                                                        when CMD_PS_DIRINC =>
988                                                          ps_direction <= '1';
989                                                          state_read_data <= RD_5;
990                                                        when CMD_PS_RESET =>
991                                                          ps_reset <= '1';
992                                                          state_read_data <= RD_5;
993                                                        when CMD_SRCLK_ON =>
994                                                          srclk_enable <= '1';
995                                                          state_read_data <= RD_5;
996                                                        when CMD_SRCLK_OFF =>
997                                                          srclk_enable <= '0';
998                                                          state_read_data <= RD_5;
999                                                        when CMD_TRIGGERS_ON =>
1000                                                          trigger_enable_sig <= '1';
1001                                                          state_read_data <= RD_5;
1002                                                        when CMD_TRIGGERS_OFF =>
1003                                                          trigger_enable_sig <= '0';
1004                                                          state_read_data <= RD_5;
1005                                                        when CMD_PS_DIRDEC =>
1006                                                          ps_direction <= '0';
1007                                                          state_read_data <= RD_5;
1008                                                         
1009                                                        when CMD_RESET_TRIGGER_ID =>
1010                                                                reset_trigger_id <= '1';
1011                                                                state_read_data <= WAIT_FOR_TRIGGER_ID_RESET_1;
1012                                                               
1013                                                        when CMD_WRITE =>
1014                                                                if ( (conv_integer(data_read (7 downto 0)) >= 0) and (conv_integer(data_read (7 downto 0)) <= 46) ) then
1015                                                                        config_addr <= conv_integer(data_read (7 downto 0));
1016                                                                        state_read_data <= READ_COMMAND_DATA_SECTION;
1017                                                                else
1018                                                                        config_addr <= 47;
1019                                                                        state_read_data <= READ_COMMAND_DATA_SECTION;
1020                                                                end if;
1021                                                               
1022                                                        when CMD_EXECUTE =>
1023                                                                state_read_data <= EXECUTE;
1024                                                               
1025                                                        when others =>
1026                                                                state_read_data <= RD_5;
1027                                                        end case;
1028                -- read data
1029                               
1030                                                when WAIT_FOR_TRIGGER_ID_RESET_1 =>
1031                                                  state_sig <= X"36";
1032                                                        state_read_data <= WAIT_FOR_TRIGGER_ID_RESET_2;
1033                                                when WAIT_FOR_TRIGGER_ID_RESET_2 =>
1034                                                  state_sig <= X"37";
1035                                                        state_read_data <= RD_5;
1036                        -- these states are beeing processed, if the 'command' was a 'write command'
1037                        --      so it is assumed, that some data in config RAM changed, and we need full (re)config
1038                        when READ_COMMAND_DATA_SECTION =>
1039                          state_sig <= X"38";
1040                                if (rx_packets_cnt > 0) then
1041                                        rx_packets_cnt <= rx_packets_cnt - '1';
1042                                        par_addr <= W5300_S0_RX_FIFOR;
1043                                        state_init <= READ_REG;
1044                                        next_state <= READ_DATA;
1045                                        state_read_data <= PUT_COMMAND_DATA_SECTION;
1046                                else
1047                                        state_read_data <= RD_END;
1048                                end if;
1049                       
1050                        when PUT_COMMAND_DATA_SECTION =>
1051                          state_sig <= X"39";
1052                                config_setting(config_addr) <= data_read;
1053                               
1054--                              if (config_addr < 36) then
1055--                                      update_of_rois <= '1';
1056--                              else
1057--                                      if (config_addr < 45 ) then
1058--                                              update_of_lessimportant <= '1';
1059--                                      end if;
1060--                              end if;
1061                               
1062                                state_read_data <= RD_5;
1063                               
1064                        when EXECUTE =>
1065                                update_of_rois <= '1';
1066                                update_of_lessimportant <= '1';
1067                                runnumber <= config_setting(45) & config_setting(46);
1068                               
1069                                state_read_data <= RD_5;
1070
1071                        when RD_END =>
1072                          state_sig <= X"3A";
1073                                par_addr <= W5300_S0_CR;
1074                par_data <= X"0040"; -- RECV
1075                state_init <= WRITE_REG;
1076                                next_state <= MAIN;
1077                               
1078      when others =>
1079        state_sig <= X"3F";
1080     
1081            end case; -- state_data_read
1082               
1083   
1084
1085                                        when WRITE_DATA =>
1086                                                case state_write is
1087                                                       
1088                                                  when WR_START =>
1089                                                    state_sig <= X"40";
1090                                                    if (local_write_header_flag = '1') then
1091                                                                ram_addr <= local_ram_start_addr + 6; -- Address of HIGH word of Event ID
1092                                                                state_write <= WR_GET_EVT_ID_WAIT1;
1093                                                        else
1094                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01;
1095                                                    end if;
1096                                                     
1097                                                  when WR_GET_EVT_ID_WAIT1 =>
1098                                                    state_sig <= X"41";
1099                                                    state_write <= WR_GET_EVT_ID1;
1100                                                  when WR_GET_EVT_ID1 =>
1101                                                    state_sig <= X"42";
1102                                                                event_number(31 downto 16) <= ram_data;
1103                                                                ram_addr <= local_ram_start_addr + 9; -- Address of LOW word of Event ID
1104                                                                state_write <= WR_GET_EVT_ID_WAIT2;
1105                                                        when WR_GET_EVT_ID_WAIT2 =>
1106                                                                state_write <= WR_GET_EVT_ID2;
1107                                                  when WR_GET_EVT_ID2 =>
1108                                                    state_sig <= X"43";
1109                                                                event_number(15 downto 0) <= ram_data;
1110                                                                mod7_start <= '1';
1111                                                                if (mod7_valid = '0') then
1112                                                                        state_write <= WR_MOD7_STARTED;
1113                                                                else
1114                                                                        state_write <= WR_GET_EVT_ID2;
1115                                                                end if;
1116                                                               
1117                                                        when WR_MOD7_STARTED =>
1118                                                          state_sig <= X"44";
1119                                                                if (mod7_started = '1') then
1120                                                                        mod7_start <= '0';
1121                                                                        state_write <= WR_WAIT_FOR_MOD7;
1122                                                                end if;
1123
1124                                                        when WR_WAIT_FOR_MOD7 =>
1125                                                          state_sig <= X"45";
1126                                                          next_state_tmp <= next_state;
1127                                                                if (mod7_valid = '1') then
1128                                                                        if (socket_send_mode = '1') then -- send via all sockets
1129                                                                                                local_socket_nr <= mod7_result + 1;
1130                                                                        else -- only send via socket 0\
1131                                                                                                local_socket_nr <= "000";
1132                                                                        end if;
1133                                                                       
1134                                                                        data_cnt <= 0;
1135                                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01; 
1136                                                                else 
1137                                                                        state_write <= WR_WAIT_FOR_MOD7;
1138                                                                end if;
1139                                                               
1140                                                        -- Check FIFO Size
1141                                                        when WR_CHECK_FOR_FIFO_SPACE_01 =>
1142                                                          state_sig <= X"46";
1143                                                                par_addr <= W5300_S0_TX_FSR + local_socket_nr * W5300_S_INC;
1144                                                                state_init <= READ_REG;
1145                                                                next_state <= WRITE_DATA;
1146                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_02;
1147                                                        when WR_CHECK_FOR_FIFO_SPACE_02 =>
1148                                                          state_sig <= X"47";
1149                                                                socket_tx_free (16) <= data_read(0);
1150                                                                par_addr <= W5300_S0_TX_FSR + (local_socket_nr * W5300_S_INC) + X"2";
1151                                                                state_init <= READ_REG;
1152                                                                next_state <= WRITE_DATA;
1153                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_03;
1154                                                        when WR_CHECK_FOR_FIFO_SPACE_03 =>
1155                                                          state_sig <= X"48";
1156                                                                socket_tx_free (15 downto 0) <= data_read;
1157                                                                state_write <= WR_CHECK_FOR_FIFO_SPACE_04;
1158                                                        when WR_CHECK_FOR_FIFO_SPACE_04 =>
1159                                                          state_sig <= X"49";
1160                                                                socket_tx_free_out <= socket_tx_free;
1161--                                                              if (socket_tx_free (16 downto 0) < write_length_bytes) then
1162                                                                if (socket_tx_free (16 downto 0) < W5300_TX_FIFO_SIZE_8B) then
1163                                                               
1164                                                                        state_write <= WR_CHECK_FOR_FIFO_SPACE_01;
1165                                                                else
1166                                                                        if (local_write_header_flag = '1') then
1167                                                                                state_write <= WR_FIFO;
1168                                                                        else
1169                                                                                state_write <= WR_ADC;
1170                                                                        end if; 
1171                                                                end if;
1172                                                       
1173                                                        -- Fill FIFO
1174
1175                                                        -- Write Header
1176                                                        when WR_FIFO =>
1177                                                          state_sig <= X"4A";
1178                                                                ram_addr <= local_ram_start_addr + local_ram_addr;
1179                                                                state_write <= WR_FIFO1;
1180                                                        when WR_FIFO1 =>
1181                                                          state_sig <= X"4B";
1182                                                                data_cnt <= data_cnt + 1;
1183                                                                if (data_cnt < PACKAGE_HEADER_LENGTH) then --???
1184                                                                  local_ram_addr <= local_ram_addr + 1;
1185--                                                                if (data_cnt = 2 or data_cnt = 5 or data_cnt = 8 ) then -- skip empty words
1186--                                                                  local_ram_addr <= local_ram_addr + 2;
1187--                                                                end if;
1188--                                                                if (data_cnt = 9) then -- skip empty words
1189--                                                                  local_ram_addr <= local_ram_addr + 4;
1190--                                                                end if; 
1191                                                                        par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1192                                                                        ram_access <= '1';
1193                                                                        state_init <= WRITE_REG;
1194                                                                        number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1195                                                                        next_state <= WRITE_DATA;
1196                                                                        state_write <= WR_FIFO;
1197                                                                else
1198                                                                        state_write <= WR_ADC;
1199                                                                end if;
1200                                                        -- End Write Header
1201                                                       
1202                                                        -- Write ADC-Data
1203                                                        ---- Start...
1204                                                        when WR_ADC =>
1205                                                          state_sig <= X"4C";
1206                                                                adc_data_addr <= local_ram_start_addr + local_ram_addr;
1207                                                                drs_cnt <= 0;
1208                                                                channel_cnt <= 1;
1209                                                                data_cnt <= 0;
1210                                                                roi_max <= (others => '0');
1211                                                                data_end <= POSITION_OF_ROI_IN_CHANNEL_HEADER;
1212                                                                state_write <= WR_ADC1;
1213
1214                                                        ---- Write Channel
1215                                                        when WR_ADC1 =>
1216                                                          state_sig <= X"4D";
1217                                                                -- read ROI and set end of Channel-Data
1218                                                                if (data_cnt = POSITION_OF_ROI_IN_CHANNEL_HEADER) then
1219                                                                        data_end <= conv_integer (ram_data) + CHANNEL_HEADER_SIZE;
1220                                                                        if (ram_data > roi_max) then
1221                                                                                roi_max <= ram_data (10 downto 0);
1222                                                                        end if;
1223                                                                end if;
1224                                                                ram_addr <= adc_data_addr + drs_cnt + (data_cnt * 4);
1225                                                                state_write <= WR_ADC2;
1226                                                        when WR_ADC2 =>
1227                                                       
1228                                                                if (data_cnt < data_end) then
1229                                                                        par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1230                                                                        ram_access <= '1';
1231                                                                        state_init <= WRITE_REG;
1232                                                                        number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1233                                                                        next_state <= WRITE_DATA;
1234                                                                        data_cnt <= data_cnt + 1;
1235                                                                        state_write <= WR_ADC1;
1236                                                                else
1237                                                                        -- Next DRS
1238                                                                        if (drs_cnt < 3) then
1239                                                                                drs_cnt <= drs_cnt + 1;
1240                                                                                data_cnt <= 0;
1241                                                                                data_end <= POSITION_OF_ROI_IN_CHANNEL_HEADER;
1242                                                                                state_write <= WR_ADC1;
1243                                                                        else
1244                                                                                -- Next Channel
1245                                                                                if (channel_cnt < local_fifo_channels) then
1246                                                                                        channel_cnt <= channel_cnt + 1;
1247                                                                                        roi_max <= (others => '0');
1248                                                                                        drs_cnt <= 0;
1249                                                                                        data_cnt <= 0;
1250                                                                                        data_end <= POSITION_OF_ROI_IN_CHANNEL_HEADER;
1251                                                                                        adc_data_addr <= adc_data_addr + ((conv_integer(roi_max) + CHANNEL_HEADER_SIZE) * 4);
1252                                                                                        state_write <= WR_ADC1;
1253                                                                                else
1254                                                                                        -- Ready
1255                                                                                        if (local_write_end_flag = '1') then
1256                                                                                                state_write <= WR_ENDFLAG;
1257                                                                                        else
1258                                                                                                state_write <= WR_05a;
1259                                                                                        end if;
1260                                                                                end if;
1261                                                                        end if;   
1262                                                                end if;
1263                                                                -- End Write ADC-Data
1264
1265              -- Write End Package Flag
1266              when WR_ENDFLAG =>
1267                state_sig <= X"4F";
1268                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + CHANNEL_HEADER_SIZE) * 4);
1269                state_write <= WR_ENDFLAG1;
1270              when WR_ENDFLAG1 =>
1271                par_addr <= W5300_S0_TX_FIFOR + local_socket_nr * W5300_S_INC;
1272                ram_access <= '1';
1273                state_init <= WRITE_REG;
1274                                number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1275                next_state <= WRITE_DATA;
1276                state_write <= WR_ENDFLAG2;
1277              when WR_ENDFLAG2 =>
1278                ram_addr <= adc_data_addr + ((conv_integer(roi_max) + CHANNEL_HEADER_SIZE) * 4) + 1;
1279                state_write <= WR_ENDFLAG3;
1280              when WR_ENDFLAG3 =>
1281                state_init <= WRITE_REG;
1282                next_state <= WRITE_DATA;
1283                                number_of_words_written_to_fifo <= number_of_words_written_to_fifo + 1;
1284                state_write <= WR_05a;
1285             
1286              -- End Write End Package Flag
1287             
1288              -- Wait????
1289              when WR_05a =>
1290                                state_sig <= X"4E";
1291                if (wait_cntr < 10) then -- 3000 works???
1292                  wait_cntr <= wait_cntr + 1;
1293                else
1294                  wait_cntr <= 0;
1295                  state_write <= WR_05b;
1296                end if;
1297              when WR_05b =>
1298                state_write <= WR_05_PREPARE_LENGTH_INFO;
1299
1300              --Send FIFO       
1301                                                        when WR_05_PREPARE_LENGTH_INFO =>
1302                                                                --number_of_words_written_to_fifo <= number_of_words_written_to_fifo - 1;
1303                                                                state_init <= WRITE_DATA;
1304                                                                state_write <= WR_05_POSTPREPARE_LENGTH_INFO;
1305                                                               
1306                                                       
1307                                                        when WR_05_POSTPREPARE_LENGTH_INFO =>
1308                                                                number_of_bytes_written_to_fifo <= number_of_words_written_to_fifo(15 downto 0) & '0';   
1309                                                                state_init <= WRITE_DATA;
1310                                                                state_write <= WR_05;
1311                                                       
1312                                                       
1313                                                        when WORKAROUND_CHECK_FIFO_SPACE_01 =>
1314                                                                par_addr <= W5300_S0_TX_FSR + local_socket_nr * W5300_S_INC;
1315                                                                state_init <= READ_REG;
1316                                                                next_state <= WRITE_DATA;
1317                                                                state_write <= WORKAROUND_CHECK_FIFO_SPACE_02;
1318                                                        when WORKAROUND_CHECK_FIFO_SPACE_02 =>
1319                                                                socket_tx_free (16) <= data_read(0);
1320                                                                par_addr <= W5300_S0_TX_FSR + (local_socket_nr * W5300_S_INC) + X"2";
1321                                                                state_init <= READ_REG;
1322                                                                next_state <= WRITE_DATA;
1323                                                                state_write <= WORKAROUND_CHECK_FIFO_SPACE_03;
1324                                                        when WORKAROUND_CHECK_FIFO_SPACE_03 =>
1325                                                                socket_tx_free (15 downto 0) <= data_read;
1326                                                                state_write <= WORKAROUND_CHECK_FIFO_SPACE_04;
1327                                                        when WORKAROUND_CHECK_FIFO_SPACE_04 =>
1328                                                                write_length_bytes <= TX_FIFO_MAX_FREE - socket_tx_free;
1329                                                                state_write <= WR_05;
1330                                                       
1331                                                       
1332                                                       
1333                                                       
1334                                                       
1335                                                       
1336                                                        when WR_05 =>
1337                                                          ram_access <= '0';
1338                                                                state_sig <= X"50";
1339                                                                par_addr <= W5300_S0_TX_WRSR + local_socket_nr * W5300_S_INC;
1340                                                                par_data <= (0 => write_length_bytes (16), others => '0');
1341                                                                --par_data <= (0 => number_of_bytes_written_to_fifo(16), others => '0');
1342                                                                state_init <= WRITE_REG;
1343                                                                state_write <= WR_06;
1344                                                        when WR_06 =>
1345                                                                par_addr <= W5300_S0_TX_WRSR + (local_socket_nr * W5300_S_INC) + X"2";
1346                                                                par_data <= write_length_bytes (15 downto 0);
1347                                                                --par_data <= number_of_bytes_written_to_fifo(15 downto 0);
1348                                                               
1349                                                                state_init <= WRITE_REG;
1350                                                                state_write <= WR_07;
1351                                                        when WR_07 =>
1352                                                                number_of_words_written_to_fifo <= (others => '0');
1353                                                                state_sig <= X"51";
1354                                                                par_addr <= W5300_S0_CR + local_socket_nr * W5300_S_INC;
1355                                                                par_data <= X"0020"; -- Send
1356                                                                state_init <= WRITE_REG;
1357                                                                state_write <= WR_ACK;
1358                                                        when WR_ACK =>                                                  -- handshake with MM
1359                                                                data_valid_ack <= '1';
1360                                                                state_write <= WR_WAIT_FOR_ACK;
1361                                                        when WR_WAIT_FOR_ACK =>                                 -- handshake ACK with MM
1362                                                                state_write <= WR_WAIT_FOR_ACK;
1363                                                                if (data_valid_sr(1) = '0') then
1364                                                                        data_valid_ack <= '0';
1365                                                                       
1366                                                                        if (local_write_end_flag = '1') then
1367                                                                                -- the last package was just written, and we can go back to the main state
1368                                                                                state_init <= MAIN;
1369                                                                                state_write <= WR_START;
1370                                                                        else
1371                                                                                -- we just wrote, a part of an event and should not go back to main, in order to avoid
1372                                                                                -- intermediate reconfiguration of the MM, in case an 'EXECUTE' command just arrived.
1373                                                                                -- but neither we should not go back to MAIN2, because data_valid is still low, as part of the MM-handshake.
1374                                                                                --      so we have to wait, until data_valid goes back high.
1375                                                                                --      if it never goes high, this can be a deadlock again, but it MUST go high,
1376                                                                                -- because we did not send away the entire event, yet.
1377                                                                                state_init <= WRITE_DATA;
1378                                                                                state_write <= WAIT_FOR_DATA_VALID_HIGH_AGAIN;
1379                                                                        end if;
1380                                                                       
1381                                                                       
1382                                                                end if;
1383                                                       
1384                                                        when WAIT_FOR_DATA_VALID_HIGH_AGAIN =>
1385                                                                if (data_valid_sr(1) = '1') then
1386                                                                        state_init <= MAIN2;
1387                                                                        state_write <= WR_START;
1388                                                                end if;
1389                                                       
1390                                                        when others =>
1391                                                                state_sig <= X"4F";
1392                                                end case;
1393                                                -- End WRITE_DATA
1394                                               
1395                                        when READ_REG =>
1396                                          --state_sig <= X"50";
1397                                                case count is
1398                                                        when "000" =>
1399                                                                cs <= '0';
1400                                                                rd <= '0';
1401                                                                wr <= '1';
1402                                                                data <= (others => 'Z'); -- !!!!!!!!!!
1403                                                                count <= "001";
1404                                                                addr <= par_addr;
1405                                                        when "001" =>
1406                                                                count <= "010";
1407                                                        when "010" =>
1408                                                                count <= "100";
1409                                                        when "100" =>
1410                                                                data_read <= data;
1411                                                                count <= "110";
1412                                                        when "110" =>
1413                                                                count <= "111";
1414                                                        when "111" =>
1415                                                                cs <= '1';
1416                                                                rd <= '1';
1417                                                                count <= "000";
1418                                                                state_init <= next_state;
1419                                                        when others =>
1420                                                                null;
1421                                                end case;
1422                                       
1423                                        when WRITE_REG =>
1424                                          --state_sig <= X"60";
1425                                                case count is
1426                                                        when "000" =>
1427                                                                cs <= '0';
1428                                                                wr <= '0';
1429                                                                rd <= '1';
1430                                                                addr <= par_addr; 
1431                                                                if (ram_access = '1') then
1432                                                                        data <= ram_data;
1433                                                                else
1434                                                                        data <= par_data;
1435                                                                end if;
1436                                                                count <= "100";
1437                                                        when "100" =>
1438                                                                count <= "101";
1439                                                        when "101" =>
1440                                                                count <= "110";
1441                                                        when "110" =>
1442                                                                cs <= '1';
1443                                                                wr <= '1';
1444                                                                state_init <= next_state;
1445                                                                count <= "000";
1446                                                        when others =>
1447                                                          state_sig <= X"E0";
1448                                                                null;
1449                                                end case;
1450                                       
1451                                        when others =>
1452                                          state_sig <= X"F0";
1453                                                null;
1454                                end case;
1455                        end if; -- int_flag = '0'
1456
1457                end if; -- rising_edge (clk)
1458
1459        end process w5300_proc;
1460
1461end Behavioral;
1462
Note: See TracBrowser for help on using the repository browser.