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

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