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

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