Subversion Repositories pentevo

Rev

Rev 469 | 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.         defparam dramko1._init_ = 0;
  292.         defparam dramko2._init_ = 0;
  293.  
  294.  
  295.  
  296. `ifndef GATE
  297.  
  298.         // trace rom page
  299.         wire rma14,rma15;
  300.  
  301.         assign rma14 = DUT.page[0][0];
  302.         assign rma15 = DUT.page[0][1];
  303.  
  304.  
  305.         always @(rma14 or rma15)
  306.         begin
  307. //              $display("at time %t us",$time/1000000);
  308.  
  309. //              case( {rma15, rma14} )
  310.  
  311. //              2'b00: $display("BASIC 48");
  312. //              2'b01: $display("TR-DOS");
  313. //              2'b10: $display("BASIC 128");
  314. //              2'b11: $display("GLUKROM");
  315. //              default: $display("unknown");
  316.  
  317. //              endcase
  318.  
  319. //              $display("");
  320.         end
  321.  
  322.  
  323.         // trace ram page
  324.         wire [5:0] rpag;
  325.  
  326.         assign rpag=DUT.page[3][5:0];
  327.  
  328.         always @(rpag)
  329.         begin
  330. //              $display("at time %t us",$time/1000000);
  331.  
  332. //              $display("RAM page is %d",rpag);
  333.  
  334. //              $display("");
  335.         end
  336.  
  337.  
  338.  
  339.         // key presses/nmi/whatsoever
  340.         initial
  341.         begin
  342.                 #1;
  343.                 tb.DUT.zkbdmus.kbd = 40'd0;
  344.                 tb.DUT.zkbdmus.kbd[36] = 1'b1;
  345.                 @(negedge int_n);
  346.                 @(negedge int_n);
  347.                 tb.DUT.zkbdmus.kbd[36] = 1'b0;
  348.         end
  349. /*
  350.         initial
  351.         begin : gen_nmi
  352.  
  353.                 reg [21:0] a;
  354.  
  355.                 #1000000000;
  356.  
  357.                 a = 22'h3FC066;
  358.  
  359.                 put_byte(a,8'hF5); a=a+1;
  360.                 put_byte(a,8'hC5); a=a+1;
  361.                 put_byte(a,8'hD5); a=a+1;
  362.                 put_byte(a,8'hE5); a=a+1;
  363.  
  364.                 put_byte(a,8'h10); a=a+1;
  365.                 put_byte(a,8'hFE); a=a+1;
  366.  
  367.                 put_byte(a,8'h14); a=a+1;
  368.  
  369.                 put_byte(a,8'h01); a=a+1;
  370.                 put_byte(a,8'hFE); a=a+1;
  371.                 put_byte(a,8'h7F); a=a+1;
  372.  
  373.                 put_byte(a,8'hED); a=a+1;
  374.                 put_byte(a,8'h51); a=a+1;
  375.  
  376.                 put_byte(a,8'hED); a=a+1;
  377.                 put_byte(a,8'h78); a=a+1;
  378.  
  379.                 put_byte(a,8'h1F); a=a+1;
  380.                
  381.                 put_byte(a,8'hDA); a=a+1;
  382.                 put_byte(a,8'h6A); a=a+1;
  383.                 put_byte(a,8'h00); a=a+1;
  384.  
  385.                 put_byte(a,8'hE1); a=a+1;
  386.                 put_byte(a,8'hD1); a=a+1;
  387.                 put_byte(a,8'hC1); a=a+1;
  388.                 put_byte(a,8'hF1); a=a+1;
  389.  
  390.                 put_byte(a,8'hD3); a=a+1;
  391.                 put_byte(a,8'hBE); a=a+1;
  392.  
  393.                 put_byte(a,8'hED); a=a+1;
  394.                 put_byte(a,8'h45); a=a+1;
  395.  
  396.  
  397.                 @(posedge fclk);
  398.                 tb.DUT.slavespi.cfg0_reg_out[1] = 1'b1;
  399.                 @(posedge fclk);
  400.                 tb.DUT.slavespi.cfg0_reg_out[1] = 1'b0;
  401.  
  402.                 #64000000;
  403.  
  404.                 tb.DUT.zkbdmus.kbd[39] = 1'b1;
  405.                 @(negedge int_n);
  406.                 tb.DUT.zkbdmus.kbd[39] = 1'b0;
  407.         end
  408. */
  409.  
  410. `endif
  411.  
  412.  
  413.  
  414.  
  415.  
  416.  
  417.  
  418.  
  419. `ifdef ZLOG
  420.         reg [ 7:0] old_opcode;
  421.         reg [15:0] old_opcode_addr;
  422.  
  423.         wire [7:0] zdd = zd_dut_to_z80;
  424.  
  425.         reg was_m1;
  426.  
  427.         always @(zm1_n)
  428.         if( zm1_n )
  429.                 was_m1 <= 1'b0;
  430.         else
  431.                 was_m1 = 1'b1;
  432.  
  433.         always @(posedge (zmreq_n | zrd_n | zm1_n | (~zrfsh_n)) )
  434.         if( was_m1 )
  435.         begin
  436.                 if( (zdd!==old_opcode) || (za!==old_opcode_addr) )
  437.                 begin          
  438.                         if( tb.DUT.z80mem.romnram )
  439. //                              $display("Z80OPROM: addr %x, opcode %x, time %t",za,zdd,$time);
  440.                                 $display("Z80OPROM: addr %x, opcode %x",za,zdd);
  441.                         else
  442. //                              $display("Z80OPRAM: addr %x, opcode %x, time %t",za,zdd,$time);
  443.                                 $display("Z80OPRAM: addr %x, opcode %x",za,zdd);
  444.                 end
  445.  
  446.                 old_opcode      = zdd;
  447.                 old_opcode_addr = za;
  448.         end
  449.  
  450.         always @(posedge (zmreq_n | zrd_n | (~zm1_n) | (~zrfsh_n)) )
  451.         if( !was_m1 )
  452.         begin
  453.                 if( tb.DUT.z80mem.romnram )
  454. //                      $display("Z80RDROM: addr %x, rddata %x, time %t",za,zdd,$time);
  455.                         $display("Z80RDROM: addr %x, rddata %x",za,zdd);
  456.                 else
  457. //                      $display("Z80RDRAM: addr %x, rddata %x, time %t",za,zdd,$time);
  458.                         $display("Z80RDRAM: addr %x, rddata %x",za,zdd);
  459.         end
  460.  
  461.         always @(posedge (zmreq_n | zwr_n | (~zm1_n) | (~zrfsh_n)) )
  462.         begin
  463.                 if( tb.DUT.z80mem.romnram )
  464. //                      $display("Z80WRROM: addr %x, wrdata %x, time %t",za,zd,$time);
  465.                         $display("Z80WRROM: addr %x, wrdata %x",za,zd);
  466.                 else
  467. //                      $display("Z80WRRAM: addr %x, wrdata %x, time %t",za,zd,$time);
  468.                         $display("Z80WRRAM: addr %x, wrdata %x",za,zd);
  469.         end
  470. `endif
  471.  
  472.  
  473.  
  474.  
  475.         // turbo
  476. `ifdef C7MHZ
  477.         initial
  478.                 force tb.DUT.zclock.turbo = 2'b01;
  479. `else
  480.         `ifdef C35MHZ
  481.  
  482.                 initial
  483.                         force tb.DUT.zclock.turbo = 2'b00;
  484.  
  485.         `endif
  486. `endif
  487.  
  488.  
  489.  
  490.  
  491.  
  492.         // force fetch mode
  493. //      initial
  494. //      begin
  495. //              force tb.DUT.dramarb.bw = 2'b11;
  496. //
  497. //              #(64'd2400000000);
  498. //
  499. //              release tb.DUT.dramarb.bw;
  500. //      end
  501.  
  502.  
  503.  
  504.  
  505.  
  506.  
  507.  
  508.  
  509.  
  510.         // picture out
  511.         pixer pixer
  512.         (
  513.                 .clk(fclk),
  514.  
  515.                 .vsync(vsync),
  516.                 .hsync(hsync),
  517.                 .red(red),
  518.                 .grn(grn),
  519.                 .blu(blu)
  520.         );
  521.  
  522.  
  523.  
  524. /*
  525.         // time ticks
  526.         always
  527.         begin : timemark
  528.  
  529.                 integer ms;
  530.  
  531.                 ms = ($time/1000000);
  532.  
  533. //              $display("timemark %d ms",ms);
  534.  
  535.                 #10000000.0; // 1 ms
  536.         end
  537. */
  538.  
  539.  
  540.  
  541.  
  542.         // init dram
  543.         initial
  544.         begin
  545.                 integer i;
  546.  
  547.                 for(i=0;i<4*1024*1024;i=i+1)
  548.                 begin
  549.                         put_byte(i,(i%257));
  550.                 end
  551.         end
  552.  
  553.  
  554.  
  555.  
  556.  
  557.  
  558.  
  559.  
  560.  
  561.  
  562.         task put_byte;
  563.  
  564.                 input [21:0] addr;
  565.                 input [ 7:0] data;
  566.  
  567.  
  568.                
  569.                 reg [19:0] arraddr;
  570.  
  571.                 begin
  572.  
  573.                         arraddr = { addr[21:12], addr[11:2] };
  574.  
  575.                         case( addr[1:0] ) // chipsel, bytesel
  576.  
  577.                         2'b00: tb.dramko1.array[arraddr][15:8] = data;
  578.                         2'b01: tb.dramko1.array[arraddr][ 7:0] = data;
  579.                         2'b10: tb.dramko2.array[arraddr][15:8] = data;
  580.                         2'b11: tb.dramko2.array[arraddr][ 7:0] = data;
  581.  
  582.                         endcase
  583.                 end
  584.  
  585.         endtask
  586.  
  587.  
  588.  
  589.  
  590.  
  591. endmodule
  592.  
  593.  
  594.