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

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