mips_sys

1) LIBRARY IEEE;
2) USE IEEE.STD_LOGIC_1164.ALL;
3) USE IEEE.NUMERIC_STD.ALL;
4) 
5) ENTITY e_io_uart IS
6)     PORT (
7)         rst:       IN  std_logic;
8)         clk:       IN  std_logic;
9)         i_addr:    IN  std_logic_vector( 1 DOWNTO 0);
10)         o_rd_data: OUT std_logic_vector(31 DOWNTO 0);
11)         i_wr_data: IN  std_logic_vector(31 DOWNTO 0);
12)         i_wr_en:   IN  std_logic_vector( 3 DOWNTO 0);

13)         pin_i_rx:  IN  std_logic;

14)         pin_o_tx:  OUT std_logic
15)     );
16) END ENTITY e_io_uart;
17) 
18) ARCHITECTURE a_io_uart OF e_io_uart IS
19) 
20)     TYPE t_state IS (inactive, start, data, stop);
21) 
22)     SIGNAL n_cfg_scale: std_logic_vector(15 DOWNTO 0);
23)     SIGNAL r_cfg_scale: std_logic_vector(15 DOWNTO 0) := X"0001";
24)     SIGNAL n_cfg_bits:  std_logic_vector( 3 DOWNTO 0);
25)     SIGNAL r_cfg_bits:  std_logic_vector( 3 DOWNTO 0) := X"1";
26)     SIGNAL n_cfg_stop:  std_logic_vector( 1 DOWNTO 0);
27)     SIGNAL r_cfg_stop:  std_logic_vector( 1 DOWNTO 0) := "01";
28) 

29)     SIGNAL s_rx_wr_rdy:  std_logic;
30)     SIGNAL s_rx_wr_data: std_logic_vector(15 DOWNTO 0);
31)     SIGNAL s_rx_wr_en:   std_logic;
32)     SIGNAL s_rx_rd_rdy:  std_logic;
33)     SIGNAL s_rx_rd_data: std_logic_vector(15 DOWNTO 0);
34)     SIGNAL s_rx_rd_en:   std_logic;
35) 

36)     SIGNAL n_rx_scale:   natural RANGE 2**16 - 1 DOWNTO 0;
37)     SIGNAL r_rx_scale:   natural RANGE 2**16 - 1 DOWNTO 0 := 1;
38)     SIGNAL n_rx_bits:    natural RANGE 15        DOWNTO 0;
39)     SIGNAL r_rx_bits:    natural RANGE 15        DOWNTO 0 := 1;
40)     SIGNAL n_rx_stop:    natural RANGE 3         DOWNTO 0;
41)     SIGNAL r_rx_stop:    natural RANGE 3         DOWNTO 0 := 1;
42)     SIGNAL n_rx_state:   t_state;
43)     SIGNAL r_rx_state:   t_state                          := inactive;
44)     SIGNAL n_rx_cnt:     natural RANGE 2**16 - 1 DOWNTO 0;
45)     SIGNAL r_rx_cnt:     natural RANGE 2**16 - 1 DOWNTO 0 := 0;
46)     SIGNAL n_rx_sample:  natural RANGE 6         DOWNTO 0;
47)     SIGNAL r_rx_sample:  natural RANGE 6         DOWNTO 0 := 0;
48)     SIGNAL n_rx_bit:     natural RANGE 15        DOWNTO 0;
49)     SIGNAL r_rx_bit:     natural RANGE 15        DOWNTO 0 := 0;
50)     SIGNAL n_rx_samples: std_logic_vector( 1 DOWNTO 0);
51)     SIGNAL r_rx_samples: std_logic_vector( 1 DOWNTO 0)    := "00";
52)     SIGNAL n_rx_data:    std_logic_vector(15 DOWNTO 0);
53)     SIGNAL r_rx_data:    std_logic_vector(15 DOWNTO 0)    := X"0000";
54) 

55)     SIGNAL s_tx_wr_rdy:  std_logic;
56)     SIGNAL s_tx_wr_en:   std_logic;
57)     SIGNAL s_tx_rd_rdy:  std_logic;
58)     SIGNAL s_tx_rd_data: std_logic_vector(15 DOWNTO 0);
59)     SIGNAL s_tx_rd_en:   std_logic;
60) 

61)     SIGNAL n_tx_scale:  natural RANGE 2**16 - 1 DOWNTO 0;
62)     SIGNAL r_tx_scale:  natural RANGE 2**16 - 1 DOWNTO 0 := 1;
63)     SIGNAL n_tx_bits:   natural RANGE 15        DOWNTO 0;
64)     SIGNAL r_tx_bits:   natural RANGE 15        DOWNTO 0 := 1;
65)     SIGNAL n_tx_stop:   natural RANGE 3         DOWNTO 0;
66)     SIGNAL r_tx_stop:   natural RANGE 3         DOWNTO 0 := 1;
67)     SIGNAL n_tx_state:  t_state;

68)     SIGNAL r_tx_state:  t_state                          := inactive;

69)     SIGNAL n_tx_cnt:    natural RANGE 2**16 - 1 DOWNTO 0;
70)     SIGNAL r_tx_cnt:    natural RANGE 2**16 - 1 DOWNTO 0 := 0;
71)     SIGNAL n_tx_sample: natural RANGE 6         DOWNTO 0;
72)     SIGNAL r_tx_sample: natural RANGE 6         DOWNTO 0 := 0;
73)     SIGNAL n_tx_bit:    natural RANGE 15        DOWNTO 0;
74)     SIGNAL r_tx_bit:    natural RANGE 15        DOWNTO 0 := 0;
75)     SIGNAL n_tx_data:   std_logic_vector(15 DOWNTO 0);

76)     SIGNAL r_tx_data:   std_logic_vector(15 DOWNTO 0)    := X"0000";

77) 

78)     COMPONENT e_block_fifo IS
79)         GENERIC (
80)             addr_width: natural;
81)             data_width: natural
82)         );
83)         PORT (
84)             rst:       IN  std_logic;
85)             clk:       IN  std_logic;
86)             o_wr_rdy:  OUT std_logic;
87)             i_wr_data: IN  std_logic_vector(data_width - 1 DOWNTO 0);
88)             i_wr_en:   IN  std_logic;
89)             o_rd_rdy:  OUT std_logic;
90)             o_rd_data: OUT std_logic_vector(data_width - 1 DOWNTO 0);
91)             i_rd_en:   IN  std_logic
92)         );
93)     END COMPONENT e_block_fifo;
94) 

95) BEGIN
96) 
97)     p_cfg_next: PROCESS(r_cfg_scale, r_cfg_bits, r_cfg_stop,
98)                         i_addr, i_wr_data, i_wr_en)
99)     BEGIN
100)         n_cfg_scale <= r_cfg_scale;
101)         n_cfg_bits  <= r_cfg_bits;
102)         n_cfg_stop  <= r_cfg_stop;
103)         IF i_addr = "00" THEN
104)             IF i_wr_en(1 DOWNTO 0) = "11" AND
105)                i_wr_data(15 DOWNTO 0) /= X"0000" THEN
106)                 n_cfg_scale <= i_wr_data(15 DOWNTO 0);
107)             END IF;
108)             IF i_wr_en(2) = '1' AND
109)                i_wr_data(23 DOWNTO 20) = X"0" AND
110)                i_wr_data(19 DOWNTO 16) /= X"0" THEN
111)                 n_cfg_bits <= i_wr_data(19 DOWNTO 16);
112)             END IF;
113)             IF i_wr_en(3) = '1' AND
114)                i_wr_data(31 DOWNTO 26) = "000000" AND
115)                i_wr_data(25 DOWNTO 24) /= "00" THEN
116)                 n_cfg_stop <= i_wr_data(25 DOWNTO 24);
117)             END IF;
118)         END IF;
119)     END PROCESS p_cfg_next;
120) 
121)     p_cfg_sync: PROCESS(rst, clk)
122)     BEGIN
123)         IF rst = '1' THEN
124)             r_cfg_scale <= X"0001";
125)             r_cfg_bits  <= X"1";
126)             r_cfg_stop  <= "01";
127)         ELSIF rising_edge(clk) THEN
128)             r_cfg_scale <= n_cfg_scale;
129)             r_cfg_bits  <= n_cfg_bits;
130)             r_cfg_stop  <= n_cfg_stop;
131)         END IF;
132)     END PROCESS p_cfg_sync;
133) 

134)     s_rx_rd_en <= '1' WHEN i_addr = "11" AND i_wr_en(1 DOWNTO 0) = "11"
135)                   ELSE '0';
136) 
137)     rx_fifo: e_block_fifo
138)         GENERIC MAP (
139)             addr_width => 4,
140)             data_width => 16
141)         )
142)         PORT MAP (
143)             rst       => rst,
144)             clk       => clk,
145)             o_wr_rdy  => s_rx_wr_rdy,
146)             i_wr_data => s_rx_wr_data,
147)             i_wr_en   => s_rx_wr_en,
148)             o_rd_rdy  => s_rx_rd_rdy,
149)             o_rd_data => s_rx_rd_data,
150)             i_rd_en   => s_rx_rd_en
151)         );
152) 

153)     p_rx_next: PROCESS(r_cfg_scale, r_cfg_bits, r_cfg_stop,
154)                        r_rx_scale, r_rx_bits, r_rx_stop,
155)                        r_rx_state, r_rx_cnt, r_rx_sample, r_rx_bit,
156)                        r_rx_samples, r_rx_data,

157)                        pin_i_rx, s_rx_wr_rdy)

158)         VARIABLE v_next_cnt:    boolean;
159)         VARIABLE v_next_sample: boolean;
160)         VARIABLE v_next_bit:    boolean;
161)         VARIABLE v_next_state:  boolean;

162)         VARIABLE v_complete:    boolean;

163)         VARIABLE v_bits:        natural RANGE 15 DOWNTO 0;

164)         VARIABLE v_samples:     std_logic_vector( 2 DOWNTO 0);

165)         VARIABLE v_bit_val:     std_logic;

166)         VARIABLE v_data:        std_logic_vector(15 DOWNTO 0);

167)     BEGIN

168)         s_rx_wr_data <= (OTHERS => '0');
169)         s_rx_wr_en   <= '0';

170)         n_rx_scale   <= r_rx_scale;
171)         n_rx_bits    <= r_rx_bits;
172)         n_rx_stop    <= r_rx_stop;
173)         n_rx_state   <= r_rx_state;
174)         n_rx_cnt     <= r_rx_cnt;
175)         n_rx_sample  <= r_rx_sample;
176)         n_rx_bit     <= r_rx_bit;
177)         n_rx_samples <= r_rx_samples;
178)         v_next_cnt    := false;
179)         v_next_sample := false;
180)         v_next_bit    := false;
181)         v_next_state  := false;

182)         v_complete    := false;

183)         v_bits        := 0;
184)         v_samples     := "000";
185)         v_bit_val     := '0';

186)         v_data        := r_rx_data;

187)         IF r_rx_state = inactive THEN
188)             IF pin_i_rx = '0' THEN
189)                 n_rx_scale   <= to_integer(unsigned(r_cfg_scale));
190)                 n_rx_bits    <= to_integer(unsigned(r_cfg_bits));
191)                 n_rx_stop    <= to_integer(unsigned(r_cfg_stop));
192)                 n_rx_state   <= start;
193)                 n_rx_cnt     <= 0;
194)                 n_rx_sample  <= 3; -- sample in middle of received bits
195)                 n_rx_bit     <= 0;

196)                 -- n_rx_samples: no initialization needed
197)                 -- n_rx_data/v_data: keep error bit (bit 15), no initialization needed for other bits

198)             END IF;
199)         ELSE
200)             v_next_cnt := true;
201)         END IF;
202)         IF v_next_cnt THEN
203)             IF r_rx_cnt + 1 /= r_rx_scale THEN
204)                 n_rx_cnt <= r_rx_cnt + 1;
205)             ELSE
206)                 n_rx_cnt <= 0;
207)                 v_next_sample := true;
208)             END IF;
209)         END IF;
210)         IF v_next_sample THEN
211)             IF r_rx_sample = 4 THEN
212)                 n_rx_samples(0) <= pin_i_rx;
213)             ELSIF r_rx_sample = 5 THEN
214)                 n_rx_samples(1) <= pin_i_rx;
215)             ELSIF r_rx_sample = 6 THEN
216)                 v_samples := pin_i_rx & r_rx_samples;
217)                 CASE v_samples IS
218)                    WHEN "000" | "001" | "010" | "100" => v_bit_val := '0';
219)                    WHEN "011" | "101" | "110" | "111" => v_bit_val := '1';
220)                    WHEN OTHERS => NULL;
221)                 END CASE;
222)                 CASE r_rx_state IS

223)                     WHEN start =>
224)                         IF v_bit_val /= '0' THEN
225)                             v_data(15) := '1'; -- set error bit
226)                         END IF;
227)                     WHEN data  =>
228)                         v_data(r_rx_bit) := v_bit_val;
229)                     WHEN stop  =>
230)                         IF v_bit_val /= '1' THEN
231)                             v_data(15) := '1'; -- set error bit
232)                         END IF;

233)                     WHEN OTHERS => NULL;
234)                 END CASE;
235)             END IF;
236)             IF r_rx_sample /= 6 THEN
237)                 n_rx_sample <= r_rx_sample + 1;
238)             ELSE
239)                 n_rx_sample <= 0;
240)                 v_next_bit := true;
241)             END IF;
242)         END IF;
243)         IF v_next_bit THEN
244)             CASE r_rx_state IS
245)                 WHEN start => v_bits := 1;
246)                 WHEN data  => v_bits := r_rx_bits;
247)                 WHEN stop  => v_bits := r_rx_stop;
248)                 WHEN OTHERS => NULL;
249)             END CASE;
250)             IF r_rx_bit + 1 /= v_bits THEN
251)                 n_rx_bit <= r_rx_bit + 1;
252)             ELSE
253)                 n_rx_bit <= 0;
254)                 v_next_state := true;
255)             END IF;
256)         END IF;
257)         IF v_next_state THEN
258)             CASE r_rx_state IS
259)                 WHEN start => n_rx_state <= data;
260)                 WHEN data  => n_rx_state <= stop;

261)                 WHEN stop  => n_rx_state <= inactive; v_complete := true;

262)                 WHEN OTHERS => NULL;
263)             END CASE;
264)         END IF;

265)         IF v_complete THEN
266)             IF s_rx_wr_rdy = '1' THEN
267)                 s_rx_wr_data <= v_data;
268)                 s_rx_wr_en   <= '1';
269)                 v_data(15)   := '0'; -- clear error bit
270)             ELSE
271)                 v_data(15)   := '1'; -- set error bit (RX FIFO overflow)
272)             END IF;
273)         END IF;
274)         n_rx_data <= v_data;

275)     END PROCESS p_rx_next;
276) 
277)     p_rx_sync: PROCESS(rst, clk)
278)     BEGIN
279)         IF rst = '1' THEN
280)             r_rx_scale   <= 1;
281)             r_rx_bits    <= 1;
282)             r_rx_stop    <= 1;
283)             r_rx_state   <= inactive;
284)             r_rx_cnt     <= 0;
285)             r_rx_sample  <= 0;
286)             r_rx_bit     <= 0;
287)             r_rx_samples <= "00";
288)             r_rx_data    <= X"0000";
289)         ELSIF rising_edge(clk) THEN
290)             r_rx_scale   <= n_rx_scale;
291)             r_rx_bits    <= n_rx_bits;
292)             r_rx_stop    <= n_rx_stop;
293)             r_rx_state   <= n_rx_state;
294)             r_rx_cnt     <= n_rx_cnt;
295)             r_rx_sample  <= n_rx_sample;
296)             r_rx_bit     <= n_rx_bit;
297)             r_rx_samples <= n_rx_samples;
298)             r_rx_data    <= n_rx_data;
299)         END IF;
300)     END PROCESS p_rx_sync;
301) 

302)     s_tx_wr_en <= '1' WHEN i_addr = "10" AND i_wr_en(1 DOWNTO 0) = "11"
303)                   ELSE '0';
304) 
305)     tx_fifo: e_block_fifo
306)         GENERIC MAP (
307)             addr_width => 4,
308)             data_width => 16
309)         )
310)         PORT MAP (
311)             rst       => rst,
312)             clk       => clk,
313)             o_wr_rdy  => s_tx_wr_rdy,
314)             i_wr_data => i_wr_data(15 DOWNTO 0),
315)             i_wr_en   => s_tx_wr_en,
316)             o_rd_rdy  => s_tx_rd_rdy,
317)             o_rd_data => s_tx_rd_data,
318)             i_rd_en   => s_tx_rd_en
319)         );
320) 

321)     p_tx_next: PROCESS(r_cfg_scale, r_cfg_bits, r_cfg_stop,
322)                        r_tx_scale, r_tx_bits, r_tx_stop,
323)                        r_tx_state, r_tx_cnt, r_tx_sample, r_tx_bit, r_tx_data,

324)                        s_tx_rd_rdy, s_tx_rd_data)

325)         VARIABLE v_next_cnt:    boolean;
326)         VARIABLE v_next_sample: boolean;
327)         VARIABLE v_next_bit:    boolean;
328)         VARIABLE v_next_state:  boolean;
329)         VARIABLE v_bits:        natural RANGE 15 DOWNTO 0;
330)     BEGIN

331)         s_tx_rd_en  <= '0';

332)         n_tx_scale  <= r_tx_scale;
333)         n_tx_bits   <= r_tx_bits;
334)         n_tx_stop   <= r_tx_stop;
335)         n_tx_state  <= r_tx_state;
336)         n_tx_cnt    <= r_tx_cnt;
337)         n_tx_sample <= r_tx_sample;
338)         n_tx_bit    <= r_tx_bit;
339)         n_tx_data   <= r_tx_data;
340)         v_next_cnt    := false;
341)         v_next_sample := false;
342)         v_next_bit    := false;
343)         v_next_state  := false;
344)         v_bits        := 0;
345)         IF r_tx_state = inactive THEN

346)             IF s_tx_rd_rdy = '1' THEN
347)                 s_tx_rd_en  <= '1';

348)                 n_tx_scale  <= to_integer(unsigned(r_cfg_scale));
349)                 n_tx_bits   <= to_integer(unsigned(r_cfg_bits));
350)                 n_tx_stop   <= to_integer(unsigned(r_cfg_stop));
351)                 n_tx_state  <= start;
352)                 n_tx_cnt    <= 0;
353)                 n_tx_sample <= 0;
354)                 n_tx_bit    <= 0;

355)                 n_tx_data   <= s_tx_rd_data;

356)             END IF;
357)         ELSE
358)             v_next_cnt := true;
359)         END IF;
360)         IF v_next_cnt THEN
361)             IF r_tx_cnt + 1 /= r_tx_scale THEN
362)                 n_tx_cnt <= r_tx_cnt + 1;
363)             ELSE
364)                 n_tx_cnt <= 0;
365)                 v_next_sample := true;
366)             END IF;
367)         END IF;
368)         IF v_next_sample THEN

369)             IF r_tx_sample /= 6 THEN

370)                 n_tx_sample <= r_tx_sample + 1;
371)             ELSE
372)                 n_tx_sample <= 0;
373)                 v_next_bit := true;
374)             END IF;
375)         END IF;
376)         IF v_next_bit THEN
377)             CASE r_tx_state IS
378)                 WHEN start => v_bits := 1;
379)                 WHEN data  => v_bits := r_tx_bits;
380)                 WHEN stop  => v_bits := r_tx_stop;
381)                 WHEN OTHERS => NULL;
382)             END CASE;
383)             IF r_tx_bit + 1 /= v_bits THEN
384)                 n_tx_bit <= r_tx_bit + 1;
385)             ELSE
386)                 n_tx_bit <= 0;
387)                 v_next_state := true;
388)             END IF;
389)         END IF;
390)         IF v_next_state THEN
391)             CASE r_tx_state IS
392)                 WHEN start => n_tx_state <= data;
393)                 WHEN data  => n_tx_state <= stop;
394)                 WHEN stop  => n_tx_state <= inactive;
395)                 WHEN OTHERS => NULL;
396)             END CASE;
397)         END IF;
398)     END PROCESS p_tx_next;
399) 
400)     p_tx_sync: PROCESS(rst, clk)
401)     BEGIN
402)         IF rst = '1' THEN
403)             r_tx_scale  <= 1;
404)             r_tx_bits   <= 1;
405)             r_tx_stop   <= 1;
406)             r_tx_state  <= inactive;
407)             r_tx_cnt    <= 0;
408)             r_tx_sample <= 0;
409)             r_tx_bit    <= 0;
410)             r_tx_data   <= X"0000";
411)         ELSIF rising_edge(clk) THEN
412)             r_tx_scale  <= n_tx_scale;
413)             r_tx_bits   <= n_tx_bits;
414)             r_tx_stop   <= n_tx_stop;
415)             r_tx_state  <= n_tx_state;
416)             r_tx_cnt    <= n_tx_cnt;
417)             r_tx_sample <= n_tx_sample;
418)             r_tx_bit    <= n_tx_bit;
419)             r_tx_data   <= n_tx_data;
420)         END IF;
421)     END PROCESS p_tx_sync;
422) 
423)     p_tx_out: PROCESS(r_tx_bit, r_tx_state, r_tx_data)
424)     BEGIN
425)         pin_o_tx <= '1';
426)         CASE r_tx_state IS
427)             WHEN start => pin_o_tx <= '0';
428)             WHEN data  => pin_o_tx <= r_tx_data(r_tx_bit);
429)             WHEN stop  => pin_o_tx <= '1';
430)             WHEN OTHERS => NULL;
431)         END CASE;
432)     END PROCESS p_tx_out;
433) 
434)     p_read: PROCESS(rst, clk)
435)     BEGIN
436)         IF rst = '1' THEN
437)             o_rd_data <= (OTHERS => '0');
438)         ELSIF rising_edge(clk) THEN
439)             o_rd_data <= (OTHERS => '0');
440)             CASE i_addr IS
441)                 WHEN "00" =>
442)                     o_rd_data(15 DOWNTO  0) <= r_cfg_scale;
443)                     o_rd_data(19 DOWNTO 16) <= r_cfg_bits;
444)                     o_rd_data(25 DOWNTO 24) <= r_cfg_stop;
445)                 WHEN "01" =>

446)                     o_rd_data(0) <= s_tx_wr_rdy;

447)                     o_rd_data(8) <= s_rx_rd_rdy;
448)                 WHEN "11" =>
449)                     o_rd_data(15 DOWNTO 0) <= s_rx_rd_data;