Subversion Repositories pentevo

Rev

Rev 467 | Rev 511 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. // simulate fpga top-level with external dram, rom, z80
  2. // (c) 2010 NedoPC
  3.  
  4. `include "../include/tune.v"
  5.  
  6.  
  7.  
  8. //`define ZLOG 1
  9.  
  10.  
  11.  
  12. `define HALF_CLK_PERIOD (17.8)
  13.  
  14. `define ZCLK_DELAY      (9.5)
  15.  
  16. // toshibo
  17. //`define Z80_DELAY_DOWN  (17.0)
  18. //`define Z80_DELAY_UP    (22.0)
  19.  
  20. // z0840008
  21. `define Z80_DELAY_DOWN   34
  22. `define Z80_DELAY_UP     30
  23.  
  24. module tb;
  25.  
  26.         reg fclk;
  27.  
  28.         wire clkz_out,clkz_in;
  29.  
  30.         reg iorq_n,mreq_n,rd_n,wr_n; // has some delays relative to z*_n (below)
  31.         reg m1_n,rfsh_n;             //
  32.  
  33.         wire res;                    //
  34.         tri1 ziorq_n,zmreq_n,zrd_n,zwr_n,zm1_n,zrfsh_n; // connected to Z80
  35.  
  36.         tri1 int_n,wait_n,nmi_n;
  37.         wire zint_n,zwait_n,znmi_n;
  38.  
  39.         wire [15:0] #((`Z80_DELAY_DOWN+`Z80_DELAY_UP)/2) za;
  40.         wire [ 7:0] #((`Z80_DELAY_DOWN+`Z80_DELAY_UP)/2) zd;
  41. //      wire [15:0] za;
  42. //      wire [ 7:0] zd;
  43.  
  44.         wire [ 7:0] zd_dut_to_z80;
  45. //      wire [ 7:0] zd_z80_to_dut;
  46.  
  47.  
  48.         wire csrom, romoe_n, romwe_n;
  49.         wire rompg0_n, dos_n;
  50.         wire rompg2,rompg3,rompg4;
  51.  
  52.         wire [15:0] rd;
  53.         wire [9:0] ra;
  54.         wire rwe_n,rucas_n,rlcas_n,rras0_n,rras1_n;
  55.  
  56.  
  57.         tri1 [15:0] ide_d;
  58.  
  59.  
  60.         wire hsync,vsync;
  61.         wire [1:0] red,grn,blu;
  62.  
  63.  
  64.  
  65.  
  66.         assign zwait_n = (wait_n==1'b0) ? 1'b0 : 1'b1;
  67.         assign znmi_n = (nmi_n==1'b0) ? 1'b0 : 1'b1;
  68.         assign zint_n = (int_n==1'b0) ? 1'b0 : 1'b1;
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75.         initial
  76.         begin
  77.  
  78.                 fclk = 1'b0;
  79.  
  80.                 forever #`HALF_CLK_PERIOD fclk = ~fclk;
  81.         end
  82.  
  83.  
  84.         assign #`ZCLK_DELAY clkz_in = ~clkz_out;
  85.  
  86.  
  87.  
  88.  
  89.  
  90.  
  91.  
  92.         top DUT( .fclk(fclk),
  93.                  .clkz_out(clkz_out),
  94.                  .clkz_in(clkz_in),
  95.  
  96.                // z80
  97.                  .iorq_n(iorq_n),
  98.                  .mreq_n(mreq_n),
  99.                  .rd_n(rd_n),
  100.                  .wr_n(wr_n),
  101.                  .m1_n(m1_n),
  102.                  .rfsh_n(rfsh_n),
  103.                  .int_n(int_n),
  104.                  .nmi_n(nmi_n),
  105.                  .wait_n(wait_n),
  106.                  .res(res),
  107.                  //
  108.                  .d(zd),
  109.                  .a(za),
  110.  
  111.                  // ROM
  112.                  .csrom(csrom),
  113.                  .romoe_n(romoe_n),
  114.                  .romwe_n(romwe_n),
  115.                  .rompg0_n(rompg0_n),
  116.                  .dos_n(dos_n),
  117.                  .rompg2(rompg2),
  118.                  .rompg3(rompg3),
  119.                  .rompg4(rompg4),
  120.  
  121.                  // DRAM
  122.                  .rd(rd),
  123.                  .ra(ra),
  124.                  .rwe_n(rwe_n),
  125.                  .rucas_n(rucas_n),
  126.                  .rlcas_n(rlcas_n),
  127.                  .rras0_n(rras0_n),
  128.                  .rras1_n(rras1_n),
  129.  
  130.                  // ZX-bus
  131.                  .iorqge1(1'b0),
  132.                  .iorqge2(1'b0),
  133.  
  134.                  // IDE
  135.                  .ide_d(ide_d),
  136.                  .ide_rdy(1'b1),
  137.  
  138.                  // VG93
  139.                  .step(1'b0),
  140.                  .vg_sl(1'b0),
  141.                  .vg_sr(1'b0),
  142.                  .vg_tr43(1'b0),
  143.                  .rdat_b_n(1'b1),
  144.                  .vg_wf_de(1'b0),
  145.                  .vg_drq(1'b1),
  146.                  .vg_irq(1'b1),
  147.                  .vg_wd(1'b0),
  148.  
  149.                  // SDcard SPI
  150.                  .sddi(1'b1),
  151.  
  152.                  // ATmega SPI
  153.                  .spics_n(1'b1),
  154.                  .spick(1'b0),
  155.                  .spido(1'b1),
  156.  
  157.                  .vhsync(hsync),
  158.                  .vvsync(vsync),
  159.                  .vred(red),
  160.                  .vgrn(grn),
  161.                  .vblu(blu)
  162.  
  163.                );
  164.  
  165.  
  166.  
  167.  
  168.         assign zd_dut_to_z80 = tb.DUT.ena_ram ? tb.DUT.dout_ram : ( tb.DUT.ena_ports ? tb.DUT.dout_ports : ( tb.DUT.drive_ff ? 8'hFF : 8'bZZZZZZZZ ) );
  169.  
  170.        
  171.  
  172.  
  173.  
  174.         wire zrst_n = ~res;
  175.  
  176.         T80a z80( .RESET_n(zrst_n),
  177.                   .CLK_n(clkz_in),
  178.                   .WAIT_n(zwait_n),
  179.                   .INT_n(zint_n),
  180.                   .NMI_n(znmi_n),
  181.                   .M1_n(zm1_n),
  182.                   .RFSH_n(zrfsh_n),
  183.                   .MREQ_n(zmreq_n),
  184.                   .IORQ_n(ziorq_n),
  185.                   .RD_n(zrd_n),
  186.                   .WR_n(zwr_n),
  187.                   .BUSRQ_n(1'b1),
  188.                   .A(za),
  189. //                .D(zd),
  190.                   .D_I(zd_dut_to_z80),
  191.                   .D_O(zd)
  192.                 );
  193.  
  194.         // now make delayed versions of signals
  195.         //
  196.         reg  mreq_wr_n;
  197.         wire iorq_wr_n, full_wr_n;
  198.         //
  199.         // first, assure there is no X's at the start
  200.         //
  201.         initial
  202.         begin
  203.                 m1_n      = 1'b1;
  204.                 rfsh_n    = 1'b1;
  205.                 mreq_n    = 1'b1;
  206.                 iorq_n    = 1'b1;
  207.                 rd_n      = 1'b1;
  208.                 wr_n      = 1'b1;
  209.                 mreq_wr_n = 1'b1;
  210.         end
  211.         //
  212.         always @(zm1_n)
  213.                 if( zm1_n )
  214.                         m1_n <= #`Z80_DELAY_UP zm1_n;
  215.                 else
  216.                         m1_n <= #`Z80_DELAY_DOWN zm1_n;
  217.         //
  218.         always @(zrfsh_n)
  219.                 if( zrfsh_n )
  220.                         rfsh_n <= #`Z80_DELAY_UP zrfsh_n;
  221.                 else
  222.                         rfsh_n <= #`Z80_DELAY_DOWN zrfsh_n;
  223.         //
  224.         always @(zmreq_n)
  225.                 if( zmreq_n )
  226.                         mreq_n <= #`Z80_DELAY_UP zmreq_n;
  227.                 else
  228.                         mreq_n <= #`Z80_DELAY_DOWN zmreq_n;
  229.         //
  230.         always @(ziorq_n)
  231.                 if( ziorq_n )
  232.                         iorq_n <= #`Z80_DELAY_UP ziorq_n;
  233.                 else
  234.                         iorq_n <= #`Z80_DELAY_DOWN ziorq_n;
  235.         //
  236.         always @(zrd_n)
  237.                 if( zrd_n )
  238.                         rd_n <= #`Z80_DELAY_UP zrd_n;
  239.                 else
  240.                         rd_n <= #`Z80_DELAY_DOWN zrd_n;
  241.         //
  242.         //
  243.         // special handling for broken T80 WR_n
  244.         //     
  245.         always @(negedge clkz_in)
  246.                 mreq_wr_n <= zwr_n;
  247.         //
  248.         assign iorq_wr_n = ziorq_n | (~zrd_n) | (~zm1_n);
  249.         //
  250.         assign full_wr_n = mreq_wr_n & iorq_wr_n;
  251.         //
  252.         // this way glitches won't affect state of wr_n
  253.         always @(full_wr_n)
  254.                 if( !full_wr_n )
  255.                         #`Z80_DELAY_DOWN wr_n <= full_wr_n;
  256.                 else
  257.                         #`Z80_DELAY_UP wr_n <= full_wr_n;
  258.  
  259.  
  260.  
  261.  
  262.  
  263.         // ROM model
  264.         rom romko(
  265.                    .addr( {rompg4,rompg3,rompg2,dos_n, (~rompg0_n), za[13:0]} ),
  266.                    .data(zd_dut_to_z80),
  267.                    .ce_n( romoe_n | (~csrom) )
  268.                  );
  269.  
  270.         // DRAM model
  271.         drammem dramko1(
  272.                          .ma(ra),
  273.                          .d(rd),
  274.                          .ras_n(rras0_n),
  275.                          .ucas_n(rucas_n),
  276.                          .lcas_n(rlcas_n),
  277.                          .we_n(rwe_n)
  278.                        );
  279.         //
  280.         drammem dramko2(
  281.                          .ma(ra),
  282.                          .d(rd),
  283.                          .ras_n(rras1_n),
  284.                          .ucas_n(rucas_n),
  285.                          .lcas_n(rlcas_n),
  286.                          .we_n(rwe_n)
  287.                        );
  288.         defparam dramko1._verbose_ = 0;
  289.         defparam dramko2._verbose_ = 0;
  290.  
  291.  
  292.  
  293. `ifndef GATE
  294.  
  295.         // trace rom page
  296.         wire rma14,rma15;
  297.  
  298.         assign rma14 = DUT.page[0][0];
  299.         assign rma15 = DUT.page[0][1];
  300.  
  301.  
  302.         always @(rma14 or rma15)
  303.         begin
  304. //              $display("at time %t us",$time/1000000);
  305.  
  306. //              case( {rma15, rma14} )
  307.  
  308. //              2'b00: $display("BASIC 48");
  309. //              2'b01: $display("TR-DOS");
  310. //              2'b10: $display("BASIC 128");
  311. //              2'b11: $display("GLUKROM");
  312. //              default: $display("unknown");
  313.  
  314. //              endcase
  315.  
  316. //              $display("");
  317.         end
  318.  
  319.  
  320.         // trace ram page
  321.         wire [5:0] rpag;
  322.  
  323.         assign rpag=DUT.page[3][5:0];
  324.  
  325.         always @(rpag)
  326.         begin
  327. //              $display("at time %t us",$time/1000000);
  328.  
  329. //              $display("RAM page is %d",rpag);
  330.  
  331. //              $display("");
  332.         end
  333.  
  334.  
  335.  
  336.         // key presses/nmi/whatsoever
  337.         initial
  338.         begin
  339.                 #1;
  340.                 tb.DUT.zkbdmus.kbd = 40'd0;
  341.                 tb.DUT.zkbdmus.kbd[36] = 1'b1;
  342.                 @(negedge int_n);
  343.                 @(negedge int_n);
  344.                 tb.DUT.zkbdmus.kbd[36] = 1'b0;
  345.         end
  346. /*
  347.         initial
  348.         begin : gen_nmi
  349.  
  350.                 reg [21:0] a;
  351.  
  352.                 #1000000000;
  353.  
  354.                 a = 22'h3FC066;
  355.  
  356.                 put_byte(a,8'hF5); a=a+1;
  357.                 put_byte(a,8'hC5); a=a+1;
  358.                 put_byte(a,8'hD5); a=a+1;
  359.                 put_byte(a,8'hE5); a=a+1;
  360.  
  361.                 put_byte(a,8'h10); a=a+1;
  362.                 put_byte(a,8'hFE); a=a+1;
  363.  
  364.                 put_byte(a,8'h14); a=a+1;
  365.  
  366.                 put_byte(a,8'h01); a=a+1;
  367.                 put_byte(a,8'hFE); a=a+1;
  368.                 put_byte(a,8'h7F); a=a+1;
  369.  
  370.                 put_byte(a,8'hED); a=a+1;
  371.                 put_byte(a,8'h51); a=a+1;
  372.  
  373.                 put_byte(a,8'hED); a=a+1;
  374.                 put_byte(a,8'h78); a=a+1;
  375.  
  376.                 put_byte(a,8'h1F); a=a+1;
  377.                
  378.                 put_byte(a,8'hDA); a=a+1;
  379.                 put_byte(a,8'h6A); a=a+1;
  380.                 put_byte(a,8'h00); a=a+1;
  381.  
  382.                 put_byte(a,8'hE1); a=a+1;
  383.                 put_byte(a,8'hD1); a=a+1;
  384.                 put_byte(a,8'hC1); a=a+1;
  385.                 put_byte(a,8'hF1); a=a+1;
  386.  
  387.                 put_byte(a,8'hD3); a=a+1;
  388.                 put_byte(a,8'hBE); a=a+1;
  389.  
  390.                 put_byte(a,8'hED); a=a+1;
  391.                 put_byte(a,8'h45); a=a+1;
  392.  
  393.  
  394.                 @(posedge fclk);
  395.                 tb.DUT.slavespi.cfg0_reg_out[1] = 1'b1;
  396.                 @(posedge fclk);
  397.                 tb.DUT.slavespi.cfg0_reg_out[1] = 1'b0;
  398.  
  399.                 #64000000;
  400.  
  401.                 tb.DUT.zkbdmus.kbd[39] = 1'b1;
  402.                 @(negedge int_n);
  403.                 tb.DUT.zkbdmus.kbd[39] = 1'b0;
  404.         end
  405. */
  406.  
  407. `endif
  408.  
  409.  
  410.  
  411.  
  412.  
  413.  
  414.  
  415.  
  416. `ifdef ZLOG
  417.         reg [ 7:0] old_opcode;
  418.         reg [15:0] old_opcode_addr;
  419.  
  420.         wire [7:0] zdd = zd_dut_to_z80;
  421.  
  422.         reg was_m1;
  423.  
  424.         always @(zm1_n)
  425.         if( zm1_n )
  426.                 was_m1 <= 1'b0;
  427.         else
  428.                 was_m1 = 1'b1;
  429.  
  430.         always @(posedge (zmreq_n | zrd_n | zm1_n | (~zrfsh_n)) )
  431.         if( was_m1 )
  432.         begin
  433.                 if( (zdd!==old_opcode) || (za!==old_opcode_addr) )
  434.                 begin          
  435.                         if( tb.DUT.z80mem.romnram )
  436. //                              $display("Z80OPROM: addr %x, opcode %x, time %t",za,zdd,$time);
  437.                                 $display("Z80OPROM: addr %x, opcode %x",za,zdd);
  438.                         else
  439. //                              $display("Z80OPRAM: addr %x, opcode %x, time %t",za,zdd,$time);
  440.                                 $display("Z80OPRAM: addr %x, opcode %x",za,zdd);
  441.                 end
  442.  
  443.                 old_opcode      = zdd;
  444.                 old_opcode_addr = za;
  445.         end
  446.  
  447.         always @(posedge (zmreq_n | zrd_n | (~zm1_n) | (~zrfsh_n)) )
  448.         if( !was_m1 )
  449.         begin
  450.                 if( tb.DUT.z80mem.romnram )
  451. //                      $display("Z80RDROM: addr %x, rddata %x, time %t",za,zdd,$time);
  452.                         $display("Z80RDROM: addr %x, rddata %x",za,zdd);
  453.                 else
  454. //                      $display("Z80RDRAM: addr %x, rddata %x, time %t",za,zdd,$time);
  455.                         $display("Z80RDRAM: addr %x, rddata %x",za,zdd);
  456.         end
  457.  
  458.         always @(posedge (zmreq_n | zwr_n | (~zm1_n) | (~zrfsh_n)) )
  459.         begin
  460.                 if( tb.DUT.z80mem.romnram )
  461. //                      $display("Z80WRROM: addr %x, wrdata %x, time %t",za,zd,$time);
  462.                         $display("Z80WRROM: addr %x, wrdata %x",za,zd);
  463.                 else
  464. //                      $display("Z80WRRAM: addr %x, wrdata %x, time %t",za,zd,$time);
  465.                         $display("Z80WRRAM: addr %x, wrdata %x",za,zd);
  466.         end
  467. `endif
  468.  
  469.  
  470.  
  471.  
  472.         // turbo
  473. `ifdef C7MHZ
  474.         initial
  475.                 force tb.DUT.zclock.turbo = 2'b01;
  476. `else
  477.         `ifdef C35MHZ
  478.  
  479.                 initial
  480.                         force tb.DUT.zclock.turbo = 2'b00;
  481.  
  482.         `endif
  483. `endif
  484.  
  485.  
  486.  
  487.  
  488.  
  489.         // force fetch mode
  490. //      initial
  491. //      begin
  492. //              force tb.DUT.dramarb.bw = 2'b11;
  493. //
  494. //              #(64'd2400000000);
  495. //
  496. //              release tb.DUT.dramarb.bw;
  497. //      end
  498.  
  499.  
  500.  
  501.  
  502.  
  503.  
  504.  
  505.  
  506.  
  507.         // picture out
  508.         pixer pixer
  509.         (
  510.                 .clk(fclk),
  511.  
  512.                 .vsync(vsync),
  513.                 .hsync(hsync),
  514.                 .red(red),
  515.                 .grn(grn),
  516.                 .blu(blu)
  517.         );
  518.  
  519.  
  520.  
  521.  
  522.         // time ticks
  523.         always
  524.         begin : timemark
  525.  
  526.                 integer ms;
  527.  
  528.                 ms = ($time/1000000);
  529.  
  530. //              $display("timemark %d ms",ms);
  531.  
  532.                 #10000000.0; // 1 ms
  533.         end
  534.  
  535.  
  536.  
  537.  
  538.  
  539.  
  540.  
  541.  
  542.  
  543.  
  544.  
  545.         task put_byte;
  546.  
  547.                 input [21:0] addr;
  548.                 input [ 7:0] data;
  549.  
  550.  
  551.                
  552.                 reg [19:0] arraddr;
  553.  
  554.                 begin
  555.  
  556.                         arraddr = { addr[21:12], addr[11:2] };
  557.  
  558.                         case( addr[1:0] ) // chipsel, bytesel
  559.  
  560.                         2'b00: tb.dramko1.array[arraddr][15:8] = data;
  561.                         2'b01: tb.dramko1.array[arraddr][ 7:0] = data;
  562.                         2'b10: tb.dramko2.array[arraddr][15:8] = data;
  563.                         2'b11: tb.dramko2.array[arraddr][ 7:0] = data;
  564.  
  565.                         endcase
  566.                 end
  567.  
  568.         endtask
  569.  
  570.  
  571.  
  572.  
  573.  
  574. endmodule
  575.  
  576.  
  577.