source: firmware/FAD/FACT_FAD_20MHz_VAR_PS/FACT_FAD_lib/hdl/w5300_interface.vhd @ 10888

Last change on this file since 10888 was 10888, checked in by neise, 8 years ago
- not yet tested; not yet simulated - w5300_modul2.vhd implements the new w5300_interface entity. it is not really getting simpler, but maybe we are on a good way anyway.
File size: 4.6 KB
Line 
1library IEEE;
2use IEEE.STD_LOGIC_1164.ALL;
3use IEEE.NUMERIC_STD.all;
4
5library FACT_FAD_lib;
6use FACT_FAD_lib.fad_definitions.ALL;
7
8ENTITY w5300_interface IS
9PORT(
10        clk                                                     : IN    std_logic;                                              -- expecting 50MHz
11       
12        wiz_reset                                       : OUT   std_logic;
13        cs                                                      : OUT   std_logic;
14        wr                                                      : OUT   std_logic;
15        rd                                                      : OUT   std_logic;
16        int                                                     : IN    std_logic;
17        wiz_data                                        : INOUT std_logic_vector (15 DOWNTO 0);
18        wiz_addr                                        : OUT   std_logic_vector (9 DOWNTO 0);
19       
20        read_i                                          : IN    std_logic;
21        write_i                                         : IN    std_logic;
22        addr_i                                          : IN    std_logic_vector (9 DOWNTO 0);
23        data_o                                          : OUT   std_logic_vector (15 DOWNTO 0)  := (others => '0');
24        data_i                                          : IN    std_logic_vector (15 DOWNTO 0);
25        ready_o                                         : OUT   std_logic := '0';
26        reset_i                                         : IN    std_logic
27);
28END w5300_interface ;
29
30architecture Behavioral of w5300_interface is
31
32        type state_type is (
33                RESET_WIZ,
34                IDLE,
35                --READ_STATE,
36                READ_WAIT,
37                --WRITE_STATE,
38                WRITE_WAIT
39--              ,CLEANUP
40               
41        );
42        signal state : state_type;
43
44        signal data_signal : std_logic_vector (15 DOWNTO 0) := (others => 'Z');
45        signal addr_signal : std_logic_vector (9 DOWNTO 0) := (others => '0');
46
47    signal read_sr : std_logic_vector (1 DOWNTO 0) := (others => '0');
48    signal write_sr : std_logic_vector (1 DOWNTO 0) := (others => '0');
49       
50        -- this counter counts the time, the cs signal is low in units of 1/clk_period
51        -- since it is increased already in IDLE state, it really
52        signal wait_ctr : integer range 0 to 15 := 0; 
53        signal RST_TIME : integer range 0 to 500000 := 500000; 
54
55        signal reset_counter : integer range 0 to RST_TIME := 0; 
56        signal ready : std_logic := '0';
57begin
58       
59main_process : process(clk)
60        begin
61       
62        ready_o <= ready and not write_i and not read_i;
63       
64        if rising_edge(clk) then
65                -- synch in read & write commands
66                read_sr         <= read_sr(0)   & read_i;
67                write_sr        <= write_sr(0)  & write_i;
68
69                --synthesis translate_off
70                RST_TIME <= 288;
71                --synthesis translate_on
72
73
74                case state is
75                        -- this state seems to lose 20ns of worthy time, but this is only true for single transmissions
76                        -- in case of continuous transmissions the W5300 datasheet demands min. 28ns time with CS high.
77                        -- this means min. 2 states @ a 50MHz clock.
78                        -- this is ensured by the IDLE state and a certain 'wait'-state and the end of each transmission.
79                        when IDLE =>
80                                cs <= '1';
81                                wr <= '1';
82                                rd <= '1';
83                                ready <= '1';
84                               
85                               
86                                if (read_i = '1' ) then
87                                        cs <= '0';
88                                        wr <= '1';
89                                        rd <= '0';
90                                        ready <= '0';
91                                       
92                                        wiz_addr <= addr_i;
93                                        wiz_data <= (others => 'Z');
94                                        state <= READ_WAIT;
95                                       
96                                elsif (write_i = '1' ) then
97                                        cs <= '0';
98                                        wr <= '0';
99                                        rd <= '1';
100                                        ready <= '0';
101                                       
102                                        wiz_addr <= addr_i;
103                                        wiz_data <= data_i;
104
105                                        state <= WRITE_WAIT;
106                                end if;
107                               
108                                if (reset_i = '1') then
109                                        state <= RESET_WIZ;
110                                end if;
111                       
112--                      when READ_STATE =>
113--                              cs <= '0';
114--                              wr <= '1';
115--                              rd <= '0';
116--                              wiz_addr <= addr_signal;
117--                              wiz_data <= data_signal;
118--                              wait_ctr <= wait_ctr + 1;
119--                              state <= READ_WAIT;
120--                             
121--                      when WRITE_STATE =>
122--                              cs <= '0';
123--                              wr <= '0';
124--                              rd <= '1';
125--                              wiz_addr <= addr_signal;
126--                              wiz_data <= data_signal;
127--                              wait_ctr <= wait_ctr + 1;
128--                              state <= WRITE_WAIT;
129--
130                        -- actually WRITE ACCESS needs less time than READ access.
131                        -- but in order to make an easy timed interface to this entity possible
132                        -- I decided to wait exactly the same time.
133                        -- anyway after min. 42ns (i.e. 60ns in case of 50MHz) the read reasult may be synched in.
134                       
135                        when READ_WAIT =>
136                                wait_ctr <= wait_ctr + 1;
137                                if (wait_ctr = TIME_UNTIL_READ_READY - 1) then
138                                        cs <= '1';
139                                        wr <= '1';
140                                        rd <= '1';
141                                        ready <= '1';
142                                       
143                                        wait_ctr <= 0;
144                                        data_o <= wiz_data;
145
146                                        state <= IDLE;
147                                end if;
148                               
149                               
150                        when WRITE_WAIT =>
151                                wait_ctr <= wait_ctr + 1;
152                                if (wait_ctr = TIME_UNTIL_WRITE_READY - 1) then
153                                        cs <= '1';
154                                        wr <= '1';
155                                        rd <= '1';
156                                        ready <= '1';
157                                       
158                                        wait_ctr <= 0;
159                                        data_o <= (others => 'Z');
160
161                                        state <= IDLE;
162                                end if;
163                               
164                       
165--                      when CLEANUP =>
166--                              ready <= '1';
167--                              cs <= '1';
168--                              wr <= '1';
169--                              rd <= '1';
170--                              data_o <= data_signal;
171--                              wiz_addr <= (others => 'Z');
172--                              wiz_data <= (others => 'Z');
173--                              state <= IDLE;
174                               
175                        when RESET_WIZ => 
176                                ready <= '0';
177                                cs <= '1';
178                                wr <= '1';
179                                rd <= '1';
180                               
181                                reset_counter <= reset_counter + 1;
182                                wiz_reset <= '0';
183                                if (reset_counter >= 100) then -- wait 2µs
184                                        wiz_reset <= '1';
185                                end if; 
186                                if (reset_counter >= RST_TIME -1) then -- wait 10ms
187                                        reset_counter <= 0;
188                                       
189                                        state <= IDLE;
190                                end if;                         
191                               
192                        end case;
193                       
194        end if; -- rising_edge(clk)
195                                               
196end process main_process;
197
198end Behavioral;
Note: See TracBrowser for help on using the repository browser.