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

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