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

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