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

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