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

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