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_rd_en:   IN  std_logic_vector( 3 DOWNTO 0);

12)         i_wr_data: IN  std_logic_vector(31 DOWNTO 0);
13)         i_wr_en:   IN  std_logic_vector( 3 DOWNTO 0);

14)         pin_i_rx:  IN  std_logic;

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

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

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

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

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

69)     SIGNAL r_tx_state:  t_state                          := inactive;

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

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

78) 

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

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

135)     s_rx_rd_en <= '1' WHEN i_addr = "11" AND i_rd_en(1 DOWNTO 0) = "11"

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

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

158)                        pin_i_rx, s_rx_wr_rdy)

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

163)         VARIABLE v_complete:    boolean;

164)         VARIABLE v_bits:        natural RANGE 15 DOWNTO 0;

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

166)         VARIABLE v_bit_val:     std_logic;

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

168)     BEGIN

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

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

183)         v_complete    := false;

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

187)         v_data        := r_rx_data;

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

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

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

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

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

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

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

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

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

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

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

325)                        s_tx_rd_rdy, s_tx_rd_data)

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

332)         s_tx_rd_en  <= '0';

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

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

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

356)                 n_tx_data   <= s_tx_rd_data;

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

370)             IF r_tx_sample /= 6 THEN

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

443)                     IF i_rd_en(1 DOWNTO 0) = "11" THEN
444)                         o_rd_data(15 DOWNTO  0) <= r_cfg_scale;
445)                     END IF;
446)                     IF i_rd_en(2) = '1' THEN
447)                         o_rd_data(19 DOWNTO 16) <= r_cfg_bits;
448)                     END IF;
449)                     IF i_rd_en(3) = '1' THEN
450)                         o_rd_data(25 DOWNTO 24) <= r_cfg_stop;
451)                     END IF;

452)                 WHEN "01" =>

453)                     IF i_rd_en(0) = '1' THEN
454)                         o_rd_data(0) <= s_tx_wr_rdy;
455)                     END IF;
456)                     IF i_rd_en(1) = '1' THEN
457)                         o_rd_data(8) <= s_rx_rd_rdy;
458)                     END IF;

459)                 WHEN "11" =>

460)                     IF i_rd_en(1 DOWNTO 0) = "11" THEN
461)                         o_rd_data(15 DOWNTO 0) <= s_rx_rd_data;
462)                     END IF;