mips_sys

1) -- MIPS I system

2) -- Copyright 2011-2012 Stefan Schuermans <stefan@blinkenarea.org>

3) -- Copyleft GNU public license V2 or later
4) --          http://www.gnu.org/copyleft/gpl.html
5) 

6) LIBRARY IEEE;
7) USE IEEE.STD_LOGIC_1164.ALL;
8) USE IEEE.NUMERIC_STD.ALL;
9) 
10) ENTITY e_io_uart IS
11)     PORT (
12)         rst:       IN  std_logic;
13)         clk:       IN  std_logic;
14)         i_addr:    IN  std_logic_vector( 1 DOWNTO 0);
15)         o_rd_data: OUT std_logic_vector(31 DOWNTO 0);

16)         i_rd_en:   IN  std_logic_vector( 3 DOWNTO 0);

17)         i_wr_data: IN  std_logic_vector(31 DOWNTO 0);
18)         i_wr_en:   IN  std_logic_vector( 3 DOWNTO 0);

19)         pin_i_rx:  IN  std_logic;

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

35)     SIGNAL s_rx_wr_rdy:  std_logic;
36)     SIGNAL s_rx_wr_data: std_logic_vector(15 DOWNTO 0);
37)     SIGNAL s_rx_wr_en:   std_logic;
38)     SIGNAL s_rx_rd_rdy:  std_logic;
39)     SIGNAL s_rx_rd_data: std_logic_vector(15 DOWNTO 0);
40)     SIGNAL s_rx_rd_en:   std_logic;
41) 

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

61)     SIGNAL s_tx_wr_rdy:  std_logic;
62)     SIGNAL s_tx_wr_en:   std_logic;
63)     SIGNAL s_tx_rd_rdy:  std_logic;
64)     SIGNAL s_tx_rd_data: std_logic_vector(15 DOWNTO 0);
65)     SIGNAL s_tx_rd_en:   std_logic;
66) 

67)     SIGNAL n_tx_scale:  natural RANGE 2**16 - 1 DOWNTO 0;
68)     SIGNAL r_tx_scale:  natural RANGE 2**16 - 1 DOWNTO 0 := 1;
69)     SIGNAL n_tx_bits:   natural RANGE 15        DOWNTO 0;
70)     SIGNAL r_tx_bits:   natural RANGE 15        DOWNTO 0 := 1;
71)     SIGNAL n_tx_stop:   natural RANGE 3         DOWNTO 0;
72)     SIGNAL r_tx_stop:   natural RANGE 3         DOWNTO 0 := 1;
73)     SIGNAL n_tx_state:  t_state;

74)     SIGNAL r_tx_state:  t_state                          := inactive;

75)     SIGNAL n_tx_cnt:    natural RANGE 2**16 - 1 DOWNTO 0;
76)     SIGNAL r_tx_cnt:    natural RANGE 2**16 - 1 DOWNTO 0 := 0;
77)     SIGNAL n_tx_sample: natural RANGE 6         DOWNTO 0;
78)     SIGNAL r_tx_sample: natural RANGE 6         DOWNTO 0 := 0;
79)     SIGNAL n_tx_bit:    natural RANGE 15        DOWNTO 0;
80)     SIGNAL r_tx_bit:    natural RANGE 15        DOWNTO 0 := 0;
81)     SIGNAL n_tx_data:   std_logic_vector(15 DOWNTO 0);

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

83) 

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

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

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

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

159)     p_rx_next: PROCESS(r_cfg_scale, r_cfg_bits, r_cfg_stop,
160)                        r_rx_scale, r_rx_bits, r_rx_stop,
161)                        r_rx_state, r_rx_cnt, r_rx_sample, r_rx_bit,
162)                        r_rx_samples, r_rx_data,

163)                        pin_i_rx, s_rx_wr_rdy)

164)         VARIABLE v_next_cnt:    boolean;
165)         VARIABLE v_next_sample: boolean;
166)         VARIABLE v_next_bit:    boolean;
167)         VARIABLE v_next_state:  boolean;

168)         VARIABLE v_complete:    boolean;

169)         VARIABLE v_bits:        natural RANGE 15 DOWNTO 0;

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

171)         VARIABLE v_bit_val:     std_logic;

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

173)     BEGIN

174)         s_rx_wr_data <= (OTHERS => '0');
175)         s_rx_wr_en   <= '0';

176)         n_rx_scale   <= r_rx_scale;
177)         n_rx_bits    <= r_rx_bits;
178)         n_rx_stop    <= r_rx_stop;
179)         n_rx_state   <= r_rx_state;
180)         n_rx_cnt     <= r_rx_cnt;
181)         n_rx_sample  <= r_rx_sample;
182)         n_rx_bit     <= r_rx_bit;
183)         n_rx_samples <= r_rx_samples;
184)         v_next_cnt    := false;
185)         v_next_sample := false;
186)         v_next_bit    := false;
187)         v_next_state  := false;

188)         v_complete    := false;

189)         v_bits        := 0;
190)         v_samples     := "000";
191)         v_bit_val     := '0';

192)         v_data        := r_rx_data;

193)         IF r_rx_state = inactive THEN
194)             IF pin_i_rx = '0' THEN
195)                 n_rx_scale   <= to_integer(unsigned(r_cfg_scale));
196)                 n_rx_bits    <= to_integer(unsigned(r_cfg_bits));
197)                 n_rx_stop    <= to_integer(unsigned(r_cfg_stop));
198)                 n_rx_state   <= start;
199)                 n_rx_cnt     <= 0;
200)                 n_rx_sample  <= 3; -- sample in middle of received bits
201)                 n_rx_bit     <= 0;

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

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

229)                     WHEN start =>
230)                         IF v_bit_val /= '0' THEN
231)                             v_data(15) := '1'; -- set error bit
232)                         END IF;
233)                     WHEN data  =>
234)                         v_data(r_rx_bit) := v_bit_val;
235)                     WHEN stop  =>
236)                         IF v_bit_val /= '1' THEN
237)                             v_data(15) := '1'; -- set error bit
238)                         END IF;

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

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

268)                 WHEN OTHERS => NULL;
269)             END CASE;
270)         END IF;

271)         IF v_complete THEN
272)             IF s_rx_wr_rdy = '1' THEN
273)                 s_rx_wr_data <= v_data;
274)                 s_rx_wr_en   <= '1';
275)                 v_data(15)   := '0'; -- clear error bit
276)             ELSE
277)                 v_data(15)   := '1'; -- set error bit (RX FIFO overflow)
278)             END IF;
279)         END IF;
280)         n_rx_data <= v_data;

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

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

327)     p_tx_next: PROCESS(r_cfg_scale, r_cfg_bits, r_cfg_stop,
328)                        r_tx_scale, r_tx_bits, r_tx_stop,
329)                        r_tx_state, r_tx_cnt, r_tx_sample, r_tx_bit, r_tx_data,

330)                        s_tx_rd_rdy, s_tx_rd_data)

331)         VARIABLE v_next_cnt:    boolean;
332)         VARIABLE v_next_sample: boolean;
333)         VARIABLE v_next_bit:    boolean;
334)         VARIABLE v_next_state:  boolean;
335)         VARIABLE v_bits:        natural RANGE 15 DOWNTO 0;
336)     BEGIN

337)         s_tx_rd_en  <= '0';

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

352)             IF s_tx_rd_rdy = '1' THEN
353)                 s_tx_rd_en  <= '1';

354)                 n_tx_scale  <= to_integer(unsigned(r_cfg_scale));
355)                 n_tx_bits   <= to_integer(unsigned(r_cfg_bits));
356)                 n_tx_stop   <= to_integer(unsigned(r_cfg_stop));
357)                 n_tx_state  <= start;
358)                 n_tx_cnt    <= 0;
359)                 n_tx_sample <= 0;
360)                 n_tx_bit    <= 0;

361)                 n_tx_data   <= s_tx_rd_data;

362)             END IF;
363)         ELSE
364)             v_next_cnt := true;
365)         END IF;
366)         IF v_next_cnt THEN
367)             IF r_tx_cnt + 1 /= r_tx_scale THEN
368)                 n_tx_cnt <= r_tx_cnt + 1;
369)             ELSE
370)                 n_tx_cnt <= 0;
371)                 v_next_sample := true;
372)             END IF;
373)         END IF;
374)         IF v_next_sample THEN

375)             IF r_tx_sample /= 6 THEN

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

448)                     IF i_rd_en(1 DOWNTO 0) = "11" THEN
449)                         o_rd_data(15 DOWNTO  0) <= r_cfg_scale;
450)                     END IF;
451)                     IF i_rd_en(2) = '1' THEN
452)                         o_rd_data(19 DOWNTO 16) <= r_cfg_bits;
453)                     END IF;
454)                     IF i_rd_en(3) = '1' THEN
455)                         o_rd_data(25 DOWNTO 24) <= r_cfg_stop;
456)                     END IF;

457)                 WHEN "01" =>

458)                     IF i_rd_en(0) = '1' THEN
459)                         o_rd_data(0) <= s_tx_wr_rdy;
460)                     END IF;
461)                     IF i_rd_en(1) = '1' THEN
462)                         o_rd_data(8) <= s_rx_rd_rdy;
463)                     END IF;

464)                 WHEN "11" =>

465)                     IF i_rd_en(1 DOWNTO 0) = "11" THEN
466)                         o_rd_data(15 DOWNTO 0) <= s_rx_rd_data;
467)                     END IF;