source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/w5300_modul2.vhd @ 10888

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