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

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