simulation/testbench_address_decoder.vhd

   1
   2 library IEEE;
   3 use IEEE.std_logic_1164.all;
   4 --use ieee.std_logic_unsigned.all;
   5 use ieee.std_logic_arith.all;
   6 use std.textio.all;
   7
   8
   9 entity testbench_address_decoder is
  10 end testbench_address_decoder;
  11
  12 architecture stimulus of testbench_address_decoder is
  13     component address_decoder
  14     generic (abus_size : integer := 16; dbus_size : integer := 8);
  15         port (  phi2        : in std_logic;
  16                 R_nW        : in std_logic;
  17                 addr       : in std_logic_vector (abus_size - 1 downto 0);
  18                 d_io       : inout std_logic_vector (dbus_size - 1 downto 0)
  19     );
  20     end component;
  21
  22     component v_address_decoder
  23     generic (abus_size : integer := 14; dbus_size : integer := 8);
  24         port (  clk         : in std_logic;
  25                 rd_n        : in std_logic;
  26                 wr_n        : in std_logic;
  27                 ale         : in std_logic;
  28                 vram_ad     : inout std_logic_vector (7 downto 0);
  29                 vram_a      : in std_logic_vector (13 downto 8)
  30             );
  31     end component;
  32
  33 component d_flip_flop
  34     generic (
  35             dsize : integer := 8
  36             );
  37     port (
  38             clk     : in std_logic;
  39             res_n   : in std_logic;
  40             set_n   : in std_logic;
  41             we_n    : in std_logic;
  42             d       : in std_logic_vector (dsize - 1 downto 0);
  43             q       : out std_logic_vector (dsize - 1 downto 0)
  44         );
  45 end component;
  46
  47     constant cpu_clk : time := 589 ns;
  48     constant size8 : integer := 8;
  49     constant size16 : integer := 16;
  50     constant size14 : integer := 14;
  51
  52     signal cclk         : std_logic;
  53     signal phi2         : std_logic;
  54     signal rr_nw        : std_logic;
  55     signal aa16         : std_logic_vector (size16 - 1 downto 0);
  56     signal dd8_io       : std_logic_vector (size8 - 1 downto 0);
  57
  58     signal v_ad         : std_logic_vector (size8 - 1 downto 0);
  59     signal v_a          : std_logic_vector (size14 - 1 downto size8);
  60     signal v_addr       : std_logic_vector (size14 - 1 downto 0);
  61     signal v_data       : std_logic_vector (size8 - 1 downto 0);
  62
  63     signal v_rd_n       : std_logic;
  64     signal v_wr_n       : std_logic;
  65     signal v_ale        : std_logic;
  66
  67     signal v_dff_we_n        : std_logic;
  68
  69 begin
  70     dut0 : address_decoder generic map (size16, size8)
  71         port map (phi2, rr_nw, aa16, dd8_io);
  72
  73     phi2 <= not cclk;
  74
  75     p1 : process
  76     variable i : integer := 0;
  77     begin
  78         cclk <= '1';
  79         wait for cpu_clk / 2;
  80         cclk <= '0';
  81         wait for cpu_clk / 2;
  82     end process;
  83
  84     -----test for rom/ram .
  85     p2 : process
  86     variable i : integer := 0;
  87     variable tmp : std_logic_vector (size8 - 1 downto 0);
  88     constant loopcnt : integer := 5;
  89     begin
  90
  91         --syncronize with clock dropping edge.
  92         wait for cpu_clk;
  93
  94         dd8_io <= (others => 'Z');
  95
  96         for i in 0 to loopcnt loop
  97             dd8_io <= conv_std_logic_vector(i, size8);
  98             aa16 <= conv_std_logic_vector(i, size16);
  99             wait for cpu_clk;
 100         end loop;
 101         dd8_io <= (others => 'Z');
 102
 103         ---read test.
 104         rr_nw <= '1';
 105         --ram at 0x0000
 106         aa16 <= x"0000";
 107         wait for cpu_clk;
 108         aa16 <= x"0010";
 109         wait for cpu_clk;
 110
 111         --rom at 0x8000
 112         aa16 <= x"8000";
 113         wait for cpu_clk;
 114         aa16 <= x"8001";
 115         wait for cpu_clk;
 116         aa16 <= x"ffff";
 117         wait for cpu_clk;
 118
 119         --unknown addr at 0x4000
 120         aa16 <= x"4000";
 121         wait for cpu_clk;
 122         aa16 <= x"0010";
 123         wait for cpu_clk;
 124
 125         --write test
 126         rr_nw <= '0';
 127         for i in 0 to loopcnt loop
 128             --write to ram
 129             aa16 <= conv_std_logic_vector(i, size16);
 130             dd8_io <= conv_std_logic_vector(i, size8);
 131             wait for cpu_clk;
 132         end loop;
 133
 134         dd8_io <= (others => 'Z');
 135         rr_nw <= '1';
 136         for i in 0 to loopcnt loop
 137             --read ram
 138             aa16 <= conv_std_logic_vector(i, size16);
 139             wait for cpu_clk;
 140         end loop;
 141         --wait;
 142
 143         rr_nw <= '0';
 144         for i in 0 to loopcnt loop
 145             --write to rom
 146             aa16 <= conv_std_logic_vector(16#8000# + i, size16);
 147             dd8_io <= conv_std_logic_vector(i * 10, size8);
 148             wait for cpu_clk;
 149             aa16 <= conv_std_logic_vector(16#F000# + i, size16);
 150             dd8_io <= conv_std_logic_vector(i * 10, size8);
 151             wait for cpu_clk;
 152         end loop;
 153
 154         rr_nw <= '1';
 155         dd8_io <= (others => 'Z');
 156         for i in 0 to loopcnt loop
 157             --read ram
 158             aa16 <= conv_std_logic_vector(16#8000# + i, size16);
 159             wait for cpu_clk;
 160             aa16 <= conv_std_logic_vector(16#F000# + i, size16);
 161             wait for cpu_clk;
 162         end loop;
 163
 164         rr_nw <= '0';
 165         for i in 0 to loopcnt loop
 166             --write to rom
 167             aa16 <= conv_std_logic_vector(i, size16);
 168             dd8_io <= conv_std_logic_vector(i ** 2, size8);
 169             wait for cpu_clk;
 170         end loop;
 171
 172         dd8_io <= "ZZZZZZZZ";
 173         rr_nw <= '1';
 174         --ram mirror test.
 175         for i in 0 to loopcnt loop
 176             --write to rom
 177             aa16 <= conv_std_logic_vector(16#0000# + i, size16);
 178             wait for cpu_clk;
 179             aa16 <= conv_std_logic_vector(16#0800# + i, size16);
 180             wait for cpu_clk;
 181             aa16 <= conv_std_logic_vector(16#1000# + i, size16);
 182             wait for cpu_clk;
 183             aa16 <= conv_std_logic_vector(16#1800# + i, size16);
 184             wait for cpu_clk;
 185             aa16 <= conv_std_logic_vector(16#2000# + i, size16);
 186             wait for cpu_clk;
 187             aa16 <= conv_std_logic_vector(16#4000# + i, size16);
 188             wait for cpu_clk;
 189             aa16 <= conv_std_logic_vector(16#8000# + i, size16);
 190             wait for cpu_clk;
 191         end loop;
 192         wait for cpu_clk;
 193
 194         --write ram
 195         rr_nw <= '0';
 196         for i in 100 to 110 loop
 197             --write to ram
 198             aa16 <= conv_std_logic_vector(i, size16);
 199             dd8_io <= conv_std_logic_vector(i, size8);
 200             wait for cpu_clk;
 201         end loop;
 202         --read.
 203         rr_nw <= '1';
 204         dd8_io <= "ZZZZZZZZ";
 205         for i in 100 to 110 loop
 206             --write to ram
 207             aa16 <= conv_std_logic_vector(i, size16);
 208             wait for cpu_clk;
 209         end loop;
 210
 211         dd8_io <= "ZZZZZZZZ";
 212         --read rom, ram, rom, ram ...
 213         rr_nw <= '1';
 214         aa16 <= conv_std_logic_vector(100, size16);
 215         wait for cpu_clk;
 216         aa16 <= conv_std_logic_vector(16#8010#, size16);
 217         wait for cpu_clk;
 218         aa16 <= conv_std_logic_vector(103, size16);
 219         wait for cpu_clk;
 220         aa16 <= conv_std_logic_vector(16#8013#, size16);
 221         wait for cpu_clk;
 222         aa16 <= conv_std_logic_vector(109, size16);
 223         wait for cpu_clk;
 224         aa16 <= conv_std_logic_vector(16#f0a3#, size16);
 225         wait for cpu_clk;
 226
 227         --w,r,w,r,w,r,w...
 228         aa16 <= conv_std_logic_vector(100, size16);
 229         dd8_io <= conv_std_logic_vector(100, size8);
 230         rr_nw <= '0';
 231         wait for cpu_clk;
 232         dd8_io <= "ZZZZZZZZ";
 233         rr_nw <= '1';
 234         wait for cpu_clk;
 235
 236         aa16 <= conv_std_logic_vector(101, size16);
 237         dd8_io <= conv_std_logic_vector(200, size8);
 238         rr_nw <= '0';
 239         wait for cpu_clk;
 240         dd8_io <= "ZZZZZZZZ";
 241         rr_nw <= '1';
 242         wait for cpu_clk;
 243
 244         aa16 <= conv_std_logic_vector(401, size16); -- 401 = 0x191
 245         dd8_io <= conv_std_logic_vector(30, size8);
 246         rr_nw <= '0';
 247         wait for cpu_clk;
 248         rr_nw <= '1';
 249         dd8_io <= "ZZZZZZZZ";
 250         wait for cpu_clk;
 251
 252         --copy rom > ram > rom > ram
 253         aa16 <= conv_std_logic_vector(16#f024#, size16);
 254         rr_nw <= '1';
 255         wait for cpu_clk;
 256         aa16 <= conv_std_logic_vector(500, size16);  -- 500 = 0x1f4
 257         tmp := dd8_io;
 258         dd8_io <= tmp;
 259         rr_nw <= '0';
 260         wait for cpu_clk;
 261
 262         dd8_io <= "ZZZZZZZZ";
 263         aa16 <= conv_std_logic_vector(16#8003#, size16);
 264         rr_nw <= '1';
 265         wait for cpu_clk;
 266         aa16 <= conv_std_logic_vector(501, size16);
 267         dd8_io <= dd8_io;
 268         rr_nw <= '0';
 269         wait for cpu_clk;
 270
 271         aa16 <= conv_std_logic_vector(16#8005#, size16);
 272         dd8_io <= "ZZZZZZZZ";
 273         rr_nw <= '1';
 274         wait for cpu_clk;
 275         aa16 <= conv_std_logic_vector(502, size16);
 276         dd8_io <= dd8_io;
 277         rr_nw <= '0';
 278         wait for cpu_clk;
 279
 280         --read the written value
 281         rr_nw <= '1';
 282         dd8_io <= "ZZZZZZZZ";
 283         aa16 <= conv_std_logic_vector(500, size16);
 284         wait for cpu_clk;
 285         rr_nw <= '1';
 286         aa16 <= conv_std_logic_vector(501, size16);
 287         wait for cpu_clk;
 288         rr_nw <= '1';
 289         aa16 <= conv_std_logic_vector(502, size16);
 290         wait for cpu_clk;
 291
 292         --copy rom to ram.
 293         for i in 0 to 50 loop
 294             dd8_io <= "ZZZZZZZZ";
 295             aa16 <= conv_std_logic_vector(16#8000# + i, size16);
 296             rr_nw <= '1';
 297             wait for cpu_clk;
 298             aa16 <= conv_std_logic_vector(1024 + i, size16);
 299             dd8_io <= dd8_io;
 300             rr_nw <= '0';
 301             wait for cpu_clk;
 302         end loop;
 303         --check the valude.
 304         dd8_io <= "ZZZZZZZZ";
 305         rr_nw <= '1';
 306         for i in 0 to 50 loop
 307             aa16 <= conv_std_logic_vector(1024 + i, size16);
 308             wait for cpu_clk;
 309         end loop;
 310
 311         --copy ram to ram.
 312         --fill the value in the empty address.
 313         for i in 6 to 50 loop
 314             aa16 <= conv_std_logic_vector(i, size16);
 315             dd8_io <= conv_std_logic_vector(i**2, size8);
 316             rr_nw <= '0';
 317             wait for cpu_clk;
 318             rr_nw <= '1';
 319             wait for cpu_clk;
 320         end loop;
 321         for i in 0 to 50 loop
 322             dd8_io <= "ZZZZZZZZ";
 323             aa16 <= conv_std_logic_vector(i, size16);
 324             rr_nw <= '1';
 325             wait for cpu_clk;
 326             aa16 <= conv_std_logic_vector(2000 + i, size16);
 327             dd8_io <= dd8_io;
 328             rr_nw <= '0';
 329             wait for cpu_clk;
 330         end loop;
 331         --check the valude.
 332         dd8_io <= "ZZZZZZZZ";
 333         rr_nw <= '1';
 334         for i in 0 to 50 loop
 335             aa16 <= conv_std_logic_vector(2000 + i, size16);
 336             wait for cpu_clk;
 337         end loop;
 338
 339         wait;
 340     end process;
 341
 342     v_ad <= v_addr(size8 - 1 downto 0);
 343     v_a <= v_addr(size14 - 1 downto size8);
 344
 345     dut1 : v_address_decoder generic map (size14, size8)
 346         port map (phi2, v_rd_n, v_wr_n, v_ale, v_ad, v_a);
 347
 348     dff : d_flip_flop generic map (size8)
 349         port map (cclk, '1', '1', v_dff_we_n, v_ad, v_data);
 350
 351     -----test for vram/chr-rom
 352     p3 : process
 353     variable i : integer := 0;
 354     variable tmp : std_logic_vector (size8 - 1 downto 0);
 355     constant loopcnt : integer := 5;
 356     begin
 357
 358         --syncronize with clock dropping edge.
 359         wait for cpu_clk / 2;
 360
 361
 362         --copy from chr rom to name tbl.
 363         for i in 0 to loopcnt loop
 364             --read rom
 365             v_ale <= '1';
 366             v_rd_n <= '1';
 367             v_wr_n <= '1';
 368             v_dff_we_n <= '1';
 369             v_addr <= conv_std_logic_vector(16#0000# + i, size14);
 370             wait for cpu_clk;
 371             v_dff_we_n <= '0';
 372             v_addr(7 downto 0) <= (others => 'Z');
 373             v_ale <= '0';
 374             v_rd_n <= '0';
 375             v_wr_n <= '1';
 376             wait for cpu_clk;
 377
 378             --write name tbl #0
 379             v_dff_we_n <= '1';
 380             v_ale <= '1';
 381             v_rd_n <= '1';
 382             v_wr_n <= '1';
 383             v_addr <= conv_std_logic_vector(16#2000# + i, size14);
 384             wait for cpu_clk;
 385             v_addr(7 downto 0) <= (others => 'Z');
 386             v_ale <= '0';
 387             v_rd_n <= '1';
 388             v_wr_n <= '0';
 389             v_addr(7 downto 0) <= v_data;
 390             wait for cpu_clk;
 391         end loop;
 392
 393         --data check...
 394         v_wr_n <= '1';
 395         for i in 0 to loopcnt loop
 396             v_addr <= conv_std_logic_vector(16#2000# + i, size14);
 397             v_ale <= '1';
 398             v_rd_n <= '1';
 399             wait for cpu_clk;
 400             v_addr(7 downto 0) <= (others => 'Z');
 401             v_ale <= '0';
 402             v_rd_n <= '0';
 403             wait for cpu_clk;
 404
 405             --mirror check..
 406             v_addr <= conv_std_logic_vector(16#2400# + i, size14);
 407             v_ale <= '1';
 408             v_rd_n <= '1';
 409             wait for cpu_clk;
 410             v_addr(7 downto 0) <= (others => 'Z');
 411             v_ale <= '0';
 412             v_rd_n <= '0';
 413             wait for cpu_clk;
 414
 415             v_addr <= conv_std_logic_vector(16#2800# + i, size14);
 416             v_ale <= '1';
 417             v_rd_n <= '1';
 418             wait for cpu_clk;
 419             v_addr(7 downto 0) <= (others => 'Z');
 420             v_ale <= '0';
 421             v_rd_n <= '0';
 422             wait for cpu_clk;
 423         end loop;
 424
 425         --copy from chr rom to plt tbl.
 426         for i in 10 to loopcnt + 10 loop
 427             --read rom
 428             v_ale <= '1';
 429             v_rd_n <= '1';
 430             v_wr_n <= '1';
 431             v_dff_we_n <= '1';
 432             v_addr <= conv_std_logic_vector(16#0000# + i, size14);
 433             wait for cpu_clk;
 434             v_dff_we_n <= '0';
 435             v_addr(7 downto 0) <= (others => 'Z');
 436             v_ale <= '0';
 437             v_rd_n <= '0';
 438             v_wr_n <= '1';
 439             wait for cpu_clk;
 440
 441             --write plt tbl #0
 442             v_dff_we_n <= '1';
 443             v_ale <= '1';
 444             v_rd_n <= '1';
 445             v_wr_n <= '1';
 446             v_addr <= conv_std_logic_vector(16#3f00# + i, size14);
 447             wait for cpu_clk;
 448             v_addr(7 downto 0) <= (others => 'Z');
 449             v_ale <= '0';
 450             v_rd_n <= '1';
 451             v_wr_n <= '0';
 452             v_addr(7 downto 0) <= v_data;
 453             wait for cpu_clk;
 454         end loop;
 455
 456         --data check...
 457         v_wr_n <= '1';
 458         for i in 10 to loopcnt + 10 loop
 459             v_addr <= conv_std_logic_vector(16#3f00# + i, size14);
 460             v_ale <= '1';
 461             v_rd_n <= '1';
 462             wait for cpu_clk;
 463             v_addr(7 downto 0) <= (others => 'Z');
 464             v_ale <= '0';
 465             v_rd_n <= '0';
 466             wait for cpu_clk;
 467
 468             --mirror check..
 469             v_addr <= conv_std_logic_vector(16#3ff0# + i, size14);
 470             v_ale <= '1';
 471             v_rd_n <= '1';
 472             wait for cpu_clk;
 473             v_addr(7 downto 0) <= (others => 'Z');
 474             v_ale <= '0';
 475             v_rd_n <= '0';
 476             wait for cpu_clk;
 477         end loop;
 478
 479         ---read test.
 480         ----all data, selctor check.
 481         v_wr_n <= '1';
 482         for i in 0 to 16#4000# - 1 loop
 483             --read rom
 484             v_ale <= '1';
 485             v_rd_n <= '1';
 486             v_addr <= conv_std_logic_vector(16#0000# + i, size14);
 487             wait for cpu_clk;
 488             v_ale <= '0';
 489             v_rd_n <= '0';
 490             v_addr(size8 - 1 downto 0) <= (others => 'Z');
 491             wait for cpu_clk;
 492         end loop;
 493
 494         wait;
 495     end process;
 496
 497 end stimulus ;
 498