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

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