Introduce Coco 3 Plus for MiSTer
Add original-firmware Sound & Speech, four configurable Multi-Pak sockets, bounded per-slot ROM allocation and a nine-page menu organized around devices and media. Repair inherited clock/reset/CPU-memory/video paths and add explicit conditional external-I/O timing contracts. Preserve native Main startup-file ordering, saved layouts, stock-core separation and the coco3plus media profile. Provide native Windows tool downloads, pinned ToolShed ROM assembly, fresh Quartus builds, functional and fitted timing checks, reviewed release packaging and passwordless SSH installation with backups. Retain original component notices, document contribution copyright and keep SSC ROM inputs outside Git. Validation: Quartus17.0.2 Build602 seed5, zero errors; 15 functional jobs, 368 both-corner timing scopes and eight tooling-integrity checks pass. The renamed build reaches Disk BASIC, PRINT1+1 returns2 and SSC loads ready. Physical cold power cycling and conditional board-delay assumptions remain separate. Full original upstream histories are preserved before this single consolidated implementation commit.
This commit is contained in:
1 parent
8b8cf72d1f
commit
cb40fed3b9
126 files changed
+12795
-528
No files matched your search
@@ -0,0 +1,120 @@
|
||||
`timescale 1ns/1ps
|
||||
module bh_mpi_core_tb;
|
||||
reg clk=0;always #5 clk=~clk;
|
||||
reg power=1,reset_n=0,cart=0,internal_rom=1,commit=0,rnw=1;
|
||||
reg [15:0] address=0;reg [1:0] rom_mode=0;reg [9:0] switches=6;
|
||||
reg [7:0] cpu_data=0;reg [11:0] layout={3'd1,3'd1,3'd1,3'd1};
|
||||
reg boot_loading=0,download=0,wr=0;reg [15:0] file_index=6;
|
||||
reg [24:0] file_address=0;reg [7:0] file_data=0;
|
||||
reg ext_response=0,ser_irq=1,amw_trigger=0,amw_ready=0,amw_en=0;
|
||||
wire [7:0] flash;wire fd,sd,serial,bankport,loading,loaded,restart,cart_irq;
|
||||
wire [3:0] fault;wire [1:0] scs,cts;
|
||||
actual_mpi_core dut(clk,power,reset_n,cart,internal_rom,commit,rnw,address,
|
||||
rom_mode,switches,cpu_data,layout,boot_loading,download,wr,file_index,file_address,file_data,
|
||||
ext_response,ser_irq,amw_trigger,amw_ready,amw_en,flash,fd,sd,serial,bankport,
|
||||
fault,loading,loaded,restart,scs,cts,cart_irq);
|
||||
integer n,i,j,c,r;
|
||||
reg [7:0] expected;
|
||||
function [7:0] pattern(input integer slot,input integer pos);
|
||||
begin pattern=(slot*41)^(pos>>14)^8'hc7;end
|
||||
endfunction
|
||||
task tick;begin @(negedge clk);#1;end endtask
|
||||
task write_port(input [15:0] port,input [7:0] value);
|
||||
begin @(posedge clk);address=port;cpu_data=value;commit=1;rnw=0;tick;
|
||||
@(posedge clk);commit=0;rnw=1;end
|
||||
endtask
|
||||
task route(input integer romslot,input integer ioslot);
|
||||
begin write_port(16'hff7f,(romslot<<4)|ioslot);tick;
|
||||
if(cts!==romslot[1:0]||scs!==ioslot[1:0])$fatal(1,"Independent FF7F selectors");end
|
||||
endtask
|
||||
task read_rom(input integer slot,input integer bank);
|
||||
begin cart=1;internal_rom=0;address=16'hc100;rom_mode=0;repeat(2)tick;
|
||||
expected=pattern(slot,bank*16384);
|
||||
if(flash!==expected)$fatal(1,"Core ROM/bank mapping slot=%0d bank=%0d got=%h exp=%h",slot,bank,flash,expected);
|
||||
cart=0;internal_rom=1;end
|
||||
endtask
|
||||
initial begin
|
||||
repeat(4)tick;power=0;reset_n=1;repeat(3)tick;
|
||||
if(cts!==3||scs!==3)$fatal(1,"Startup slot reset");
|
||||
// Original Main parses remembered FC files before loading the saved layout.
|
||||
// Slot4 defaults to floppy but the persisted layout makes it a program ROM.
|
||||
boot_loading=1;layout={3'd2,3'd1,3'd3,3'd6};repeat(3)tick;
|
||||
@(posedge clk);file_index=9;download=1;wr=1;file_address=0;file_data=pattern(3,0);tick;
|
||||
@(posedge clk);wr=0;download=0;repeat(4)tick;
|
||||
if(dut.mpi_rom_valid[3]!==1'b1)$fatal(1,"FC9 lost before saved layout restoration");
|
||||
layout={3'd1,3'd2,3'd3,3'd6};repeat(3)tick;boot_loading=0;repeat(3)tick;
|
||||
route(3,3);read_rom(3,0);
|
||||
// Other remembered files must be discarded if their final socket is absent.
|
||||
boot_loading=1;layout[5:3]=0;repeat(3)tick;
|
||||
@(posedge clk);file_index=7;download=1;wr=1;file_address=0;file_data=pattern(1,0);tick;
|
||||
@(posedge clk);wr=0;download=0;repeat(4)tick;
|
||||
if(dut.mpi_rom_valid[1]!==1'b1)$fatal(1,"Startup staging did not retain FC7");
|
||||
boot_loading=0;repeat(3)tick;
|
||||
if(dut.mpi_rom_valid[1]!==1'b0||dut.mpi_program_roms.owned[1]!==0)
|
||||
$fatal(1,"Inactive remembered ROM survived final layout");
|
||||
layout={3'd1,3'd1,3'd1,3'd1};repeat(3)tick;
|
||||
for(n=0;n<4;n=n+1)begin
|
||||
@(posedge clk);file_index=6+n;download=1;wr=0;tick;
|
||||
for(i=0;i<65536;i=i+1)begin
|
||||
@(posedge clk);wr=1;file_address=i;file_data=pattern(n,i);tick;
|
||||
end
|
||||
@(posedge clk);wr=0;download=0;repeat(3)tick;
|
||||
end
|
||||
if(fault!==0)$fatal(1,"Program transfer fault");
|
||||
// Cold-start request must survive an arbitrarily delayed reset/sequencer.
|
||||
repeat(100)tick;if(!dut.mpi_rom_cold_pending||restart)$fatal(1,"Restart pending lost/early");
|
||||
amw_ready=1;#1;if(restart!==1'b1)$fatal(1,"Ready sequencer missed deferred restart");
|
||||
amw_en=1;tick;amw_en=0;tick;if(restart)$fatal(1,"Restart did not retire on consume");
|
||||
for(n=0;n<4;n=n+1)begin
|
||||
route(n,n);write_port(16'hff40,n);tick;
|
||||
end
|
||||
for(c=0;c<4;c=c+1)for(r=0;r<4;r=r+1)begin
|
||||
route(c,r);write_port(16'hff40,r);read_rom(c,c);
|
||||
address=16'hff40;#1;
|
||||
if(bankport!==1'b1||dut.rom_banks[r]!==r[2:0])$fatal(1,"I/O bank route follows wrong socket");
|
||||
end
|
||||
// Ordinary reset preserves inserted ROM bytes and zeroes each bank.
|
||||
reset_n=0;repeat(3)tick;reset_n=1;repeat(3)tick;
|
||||
for(n=0;n<4;n=n+1)begin route(n,0);read_rom(n,0);end
|
||||
// Move each storage controller through every slot, retaining separate CTS.
|
||||
for(n=0;n<4;n=n+1)begin
|
||||
layout=0;layout[n*3+:3]=2;
|
||||
for(c=0;c<4;c=c+1)for(r=0;r<4;r=r+1)begin
|
||||
route(c,r);address=16'hff48;#1;
|
||||
if(fd!==(r==n)||sd!==1'b0)$fatal(1,"Moved floppy decode");
|
||||
address=16'hff68;#1;if(serial!==(r==n))$fatal(1,"Serial companion decode");
|
||||
cart=1;internal_rom=0;address=16'hc100;repeat(2)tick;
|
||||
if(flash!==(c==n?8'hd4:8'hff))$fatal(1,"Disk/empty ROM decode");
|
||||
cart=0;internal_rom=1;
|
||||
end
|
||||
layout[n*3+:3]=3;
|
||||
for(r=0;r<4;r=r+1)begin
|
||||
route(0,r);address=16'hff48;#1;
|
||||
if(sd!==(r==n)||fd!==1'b0)$fatal(1,"Moved SDC decode");
|
||||
end
|
||||
end
|
||||
// The inherited OS9 SDC response workaround remains conditional on presence.
|
||||
layout={3'd2,3'd0,3'd3,3'd0};route(3,3);address=16'hff48;ext_response=1;#1;
|
||||
`ifdef CoCo3_sdc_fix_os9_driver
|
||||
if(fd||!sd)$fatal(1,"OS9 SDC response priority lost");
|
||||
`else
|
||||
if(!fd||sd)$fatal(1,"Unexpected OS9 override in ordinary build");
|
||||
`endif
|
||||
layout={3'd2,3'd0,3'd0,3'd0};#1;if(!fd||sd)$fatal(1,"Absent SDC stole disk I/O");
|
||||
ext_response=0;
|
||||
// A separately routed serial controller must still deliver its active-low
|
||||
// interrupt while a program ROM owns CTS.
|
||||
layout={3'd2,3'd1,3'd0,3'd0};route(2,3);
|
||||
// Those earlier ROMs were intentionally removed by the device-layout tests.
|
||||
// Insert a fresh program image before testing its concurrent serial IRQ.
|
||||
@(posedge clk);file_index=8;download=1;wr=1;file_address=0;file_data=pattern(2,0);tick;
|
||||
@(posedge clk);wr=0;download=0;repeat(4)tick;
|
||||
if(!dut.mpi_rom_valid[2])$fatal(1,"Reinserted ROM did not load");
|
||||
ser_irq=0;commit=1;repeat(3)tick;
|
||||
if(cart_irq!==1'b0)$fatal(1,"ROM presence masked serial IRQ");
|
||||
ser_irq=1;commit=0;
|
||||
$display("PASS actual core MPI bindings: independent selectors/banks, four images, moved controllers, empty bus, OS9 compatibility, deferred restart and reset retention");
|
||||
$finish;
|
||||
end
|
||||
initial begin #10000000;$fatal(1,"Core binding watchdog");end
|
||||
endmodule
|
||||
@@ -0,0 +1,57 @@
|
||||
`timescale 1ns/1ps
|
||||
// Original Main init: reset1, FC4/5/6/9 with status polls after each transfer,
|
||||
// restore saved configuration with reset1, then Main's own reset0 release.
|
||||
module bh_mpi_startup_tb;
|
||||
reg clk=0;always #5 clk=~clk;
|
||||
reg power=1;reg [63:0] requested=0;
|
||||
wire [63:0] accepted,status_in;wire status_set;
|
||||
bh_mpi_config cfg(clk,power,requested,accepted,status_in,status_set);
|
||||
reg pending=0;reg [63:0] pending_value;
|
||||
always @(posedge clk)if(status_set)begin pending<=1;pending_value<=status_in;end
|
||||
reg download=0,wr=0;reg [15:0] file_index=0;
|
||||
reg [24:0] file_address=0;reg [7:0] file_data=0;
|
||||
wire [7:0] flash;wire [3:0] fault;
|
||||
actual_mpi_core dut(.clk_sys(clk),.SSC_POWER_RESET(power),.RESET_N(!power),
|
||||
.CART_SEL(1'b1),.ROM_SEL(1'b0),.PH_2(1'b0),.RW_N(1'b1),.ADDRESS(16'hc000),
|
||||
.ROM(2'b0),.SWITCH(10'd6),.DATA_OUT(8'd0),.MPI_LAYOUT(accepted[54:43]),
|
||||
.MPI_BOOT_LOADING(accepted[0]),.ioctl_download(download),.ioctl_wr(wr),
|
||||
.ioctl_index(file_index),.ioctl_addr(file_address),.ioctl_data(file_data),
|
||||
.ext_response(1'b0),.SER_IRQ(1'b1),.AMW_Trigger(1'b0),.AMW_Ready(1'b0),
|
||||
.AMW_EN(1'b0),.FLASH_DATA(flash),.MPI_ROM_FAULT(fault));
|
||||
task tick;begin @(negedge clk);#1;end endtask
|
||||
task host_poll;
|
||||
begin
|
||||
repeat(4)tick;
|
||||
if(pending)begin
|
||||
@(posedge clk);#1;requested=pending_value&~64'd1;pending=0;
|
||||
repeat(4)tick;
|
||||
end
|
||||
end
|
||||
endtask
|
||||
task stream(input [15:0] index,input [7:0] value);
|
||||
begin
|
||||
@(posedge clk);#1;file_index=index;download=1;wr=1;file_address=0;file_data=value;
|
||||
tick;
|
||||
@(posedge clk);#1;download=0;wr=0;repeat(5)tick;
|
||||
host_poll;
|
||||
end
|
||||
endtask
|
||||
initial begin
|
||||
repeat(4)tick;@(posedge clk);#1;power=0;requested=1;repeat(8)tick;
|
||||
stream(4,8'h11);
|
||||
if(requested[0]!==1'b1)$fatal(1,"Main status acknowledgement cleared init reset after FC4");
|
||||
stream(5,8'h22);stream(6,8'ha1);stream(9,8'hd4);
|
||||
if(dut.mpi_rom_valid!==4'b1001)$fatal(1,"Startup streams discarded before saved layout: valid=%b fault=%b status=%h enabled=%b",dut.mpi_rom_valid,fault,accepted,dut.mpi_rom_enabled);
|
||||
// Final saved layout differs from initial defaults: FD3 and ROM4.
|
||||
@(posedge clk);#1;requested=accepted;
|
||||
requested[54:43]={3'd1,3'd2,3'd3,3'd6};requested[13:12]=2;
|
||||
repeat(8)tick;host_poll;
|
||||
if(!requested[0])$fatal(1,"Premature status acknowledgement during saved reset");
|
||||
@(posedge clk);#1;requested[0]=0;repeat(10)tick;host_poll;
|
||||
if(accepted[54:43]!=={3'd1,3'd2,3'd3,3'd6}||dut.mpi_rom_valid!==4'b1001||fault!==0)
|
||||
$fatal(1,"Restored layout/ROMs lost or stale migration overwrote configuration");
|
||||
$display("PASS actual core MPI bindings: original Main init/status polls retain FC6/FC9 through saved layout restoration");
|
||||
$finish;
|
||||
end
|
||||
initial begin #100000;$fatal(1,"Main startup ordering watchdog");end
|
||||
endmodule
|
||||
@@ -0,0 +1,148 @@
|
||||
`timescale 1ns/1ps
|
||||
module bh_mpi_tb;
|
||||
reg clk=0;always #5 clk=~clk;
|
||||
reg reset=1;
|
||||
reg [63:0] requested=0;
|
||||
wire [63:0] accepted,status_in;wire status_set;
|
||||
bh_mpi_config cfg(clk,reset,requested,accepted,status_in,status_set);
|
||||
reg [11:0] layout=0;reg [1:0] cts=0,scs=0;
|
||||
wire [2:0] rk,ik;wire fd,sd,rom,serial,ssc,orch,fdp,sdp;
|
||||
bh_mpi_router router(layout,cts,scs,rk,ik,fd,sd,rom,serial,ssc,orch,fdp,sdp);
|
||||
reg [1:0] read_slot=0;reg [16:0] read_address=0;
|
||||
reg download=0,wr=0;reg [7:0] file_index=0,data=0;
|
||||
reg [24:0] address=0;wire [7:0] read_data;
|
||||
wire loading,loaded;wire [3:0] valid,fault;
|
||||
reg [3:0] enabled=15;
|
||||
bh_mpi_rom memory(clk,reset,read_slot,read_address,read_data,
|
||||
download,wr,file_index,address,data,loading,valid,fault,loaded,enabled);
|
||||
integer l,c,s,n,k,j,routes=0;
|
||||
reg [2:0] a,b;
|
||||
reg expect_ssc,expect_orch,expect_fd,expect_sd;
|
||||
reg [63:0] next_request,saved;
|
||||
reg [7:0] expected_byte;
|
||||
function [7:0] pattern(input integer slot,input integer location);
|
||||
begin pattern=(location>>8)^(location>>14)^(slot*71)^8'h96;end
|
||||
endfunction
|
||||
task tick;begin @(posedge clk);#1;end endtask
|
||||
task apply(input [63:0] value);
|
||||
begin @(negedge clk);requested=value;repeat(8)tick;end
|
||||
endtask
|
||||
task change(input integer slot,input [2:0] device);
|
||||
begin next_request=accepted;next_request[43+slot*3+:3]=device;apply(next_request);end
|
||||
endtask
|
||||
task boot;
|
||||
begin @(negedge clk);reset=1;download=0;wr=0;repeat(3)tick;
|
||||
@(negedge clk);reset=0;repeat(3)tick;end
|
||||
endtask
|
||||
task stream(input integer slot,input integer length,input integer bad_at);
|
||||
begin
|
||||
@(negedge clk);file_index=6+slot;download=1;wr=0;tick;
|
||||
for(k=0;k<length;k=k+1)begin
|
||||
@(negedge clk);wr=1;address=k+(k==bad_at?1:0);data=pattern(slot,k);tick;
|
||||
end
|
||||
@(negedge clk);wr=0;download=0;repeat(3)tick;
|
||||
end
|
||||
endtask
|
||||
task verify_byte(input integer slot,input integer offset,input integer physical);
|
||||
begin
|
||||
@(negedge clk);read_slot=slot;read_address=offset;repeat(2)tick;
|
||||
expected_byte=pattern(slot,physical);
|
||||
if(read_data!==expected_byte)$fatal(1,"ROM data slot=%d off=%h expected=%h got=%h",slot,offset,expected_byte,read_data);
|
||||
end
|
||||
endtask
|
||||
initial begin
|
||||
layout=12'hfff;#1;
|
||||
// Independent exhaustive layout oracle: all4096 layouts,16 separate ROM/I/O routes.
|
||||
for(l=0;l<4096;l=l+1)begin
|
||||
layout=l;expect_ssc=0;expect_orch=0;expect_fd=0;expect_sd=0;
|
||||
for(n=0;n<4;n=n+1)begin
|
||||
a=(l>>(n*3))&7;
|
||||
if(a==4||a==6)expect_ssc=1;
|
||||
if(a==5||a==6)expect_orch=1;
|
||||
if(a==2)expect_fd=1;
|
||||
if(a==3)expect_sd=1;
|
||||
end
|
||||
for(c=0;c<4;c=c+1)for(s=0;s<4;s=s+1)begin
|
||||
cts=c;scs=s;#1;a=(l>>(c*3))&7;b=(l>>(s*3))&7;
|
||||
if(rk!==a||ik!==b||fd!==(b==2)||sd!==(b==3)||
|
||||
rom!==((b==1)||(b==5)||(b==6))||serial!==((b==2)||(b==3)||(b==7))||
|
||||
ssc!==expect_ssc||orch!==expect_orch||fdp!==expect_fd||sdp!==expect_sd)
|
||||
$fatal(1,"Routing layout=%h cts=%d scs=%d",layout,c,s);
|
||||
routes=routes+1;
|
||||
end
|
||||
end
|
||||
boot;
|
||||
if(accepted[63]!==1'b1||accepted[54:43]!=={3'd2,3'd1,3'd3,3'd6})
|
||||
$fatal(1,"Initial all-zero configuration did not migrate");
|
||||
apply(64'd1);
|
||||
repeat(10)begin tick;if(status_set)$fatal(1,"Premature initialization status request");end
|
||||
apply(64'd0);
|
||||
for(n=0;n<4;n=n+1)begin
|
||||
next_request=64'h0000000000020148;next_request[13:12]=n;
|
||||
apply(next_request);
|
||||
if(!accepted[63]||accepted[13:12]!==((n+1)&3)||
|
||||
accepted[54:43]!=={3'd2,3'd1,3'd3,3'd6}||
|
||||
accepted[31:16]!==next_request[31:16])$fatal(1,"Legacy status migration");
|
||||
saved=accepted;repeat(10)tick;
|
||||
if(accepted!==saved)$fatal(1,"Migration changed while host status stable");
|
||||
apply(saved);
|
||||
if(accepted!==saved)$fatal(1,"Host acknowledgement was not idempotent");
|
||||
end
|
||||
change(0,2); // Move floppy from slot4 into slot1, dropping that slot's legacy audio.
|
||||
if(accepted[45:43]!==2||accepted[54:52]!==0)$fatal(1,"Singleton controller did not move");
|
||||
for(n=0;n<4;n=n+1)change(n,1);
|
||||
if(accepted[54:43]!=={3'd1,3'd1,3'd1,3'd1})$fatal(1,"ROM slots are not independent");
|
||||
next_request=accepted;next_request[54:43]={3'd2,3'd1,3'd3,3'd6};apply(next_request);
|
||||
change(2,4); // Moving SSC out of combined audio leaves Orchestra behind.
|
||||
if(accepted[45:43]!==5||accepted[51:49]!==4||!accepted[42])$fatal(1,"SSC move/ownership split");
|
||||
change(1,5);
|
||||
if(accepted[45:43]!==0||accepted[48:46]!==5)$fatal(1,"Orchestra singleton move");
|
||||
for(n=0;n<4;n=n+1)change(n,0);
|
||||
if(accepted[54:43]!==0||accepted[42])$fatal(1,"Empty layout retains phantom device");
|
||||
boot;
|
||||
for(n=0;n<4;n=n+1)begin
|
||||
read_slot=n;repeat(2)tick;if(read_data!==8'hff)$fatal(1,"Empty socket not open bus");
|
||||
stream(n,65536,-1);
|
||||
end
|
||||
if(valid!==4'b1111||fault!==0)$fatal(1,"Four64K ROMs not loaded");
|
||||
for(n=0;n<4;n=n+1)for(j=0;j<4;j=j+1)verify_byte(n,j*16384+371,j*16384+371);
|
||||
stream(0,131072,-1); // Capacity failure must not overwrite the other three ROMs.
|
||||
if(valid!==4'b1110||!fault[0])$fatal(1,"Capacity failure was not isolated");
|
||||
for(n=1;n<4;n=n+1)verify_byte(n,32791,32791);
|
||||
stream(0,8192,-1);verify_byte(0,7371,7371);verify_byte(0,7371+65536,7371);
|
||||
stream(0,32,7);
|
||||
if(valid[0]||!fault[0])$fatal(1,"Nonsequential transfer accepted");
|
||||
for(n=1;n<4;n=n+1)verify_byte(n,49167,49167);
|
||||
boot;stream(0,131072,-1);stream(1,131072,-1);
|
||||
if(valid!==4'b0011)$fatal(1,"Two128K ROMs not loaded");
|
||||
for(n=0;n<2;n=n+1)for(j=0;j<8;j=j+1)verify_byte(n,j*16384+813,j*16384+813);
|
||||
stream(2,1,-1);if(!fault[2]||valid[2])$fatal(1,"Full pool did not refuse load");
|
||||
verify_byte(0,123879,123879);verify_byte(1,123879,123879);
|
||||
enabled[1]=0;repeat(3)tick;
|
||||
if(valid[1]||fault[1])$fatal(1,"Removed ROM retained occupancy/fault");
|
||||
stream(2,131072,-1);verify_byte(0,123879,123879);verify_byte(2,123879,123879);
|
||||
enabled[2]=0;repeat(3)tick;stream(2,16,-1);
|
||||
if(valid[2]||fault[2])$fatal(1,"Inactive remembered ROM was loaded");
|
||||
enabled=15;
|
||||
// Removing a different socket on a failed transfer's completion edge must
|
||||
// release both owners; otherwise the cleared owner's blocks leak forever.
|
||||
boot;stream(0,131072,-1);
|
||||
@(negedge clk);file_index=7;download=1;wr=1;address=1;data=0;tick;
|
||||
@(negedge clk);download=0;wr=0;tick;
|
||||
@(negedge clk);enabled[0]=0;tick;repeat(3)tick;
|
||||
if(valid[0]||!fault[1])$fatal(1,"Concurrent removal/failure state");
|
||||
enabled=15;stream(2,131072,-1);stream(3,131072,-1);
|
||||
if(valid!==4'b1100)$fatal(1,"Concurrent removal/failure leaked pool blocks");
|
||||
boot;stream(3,131073,-1);
|
||||
if(valid[3]||!fault[3])$fatal(1,"Oversized ROM accepted");
|
||||
stream(3,128,-1);verify_byte(3,32779,11);
|
||||
// Old index1 remains an alias for the third slot, without changing other stores.
|
||||
@(negedge clk);file_index=1;download=1;wr=1;address=0;data=8'h5a;tick;
|
||||
@(negedge clk);download=0;wr=0;repeat(3)tick;
|
||||
read_slot=2;read_address=0;repeat(2)tick;
|
||||
if(!valid[2]||read_data!==8'h5a)$fatal(1,"Legacy cartridge index alias");
|
||||
$display("PASS %0d routing combinations, migration/moves, four ROMs, banking, mirrors, capacity and malformed-load isolation",routes);
|
||||
$finish;
|
||||
end
|
||||
initial begin #30000000;$fatal(1,"MPI test timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,34 @@
|
||||
`timescale 1ns/1ps
|
||||
module boot_control_tb;
|
||||
reg clk=0,reset=1,display=0,cold=0;
|
||||
always #5 clk=~clk;
|
||||
wire actual_reset_n,actual_ee,reference_reset_n,reference_ee;
|
||||
reg [1:0] delayed_display=0,delayed_cold=0;
|
||||
always @(posedge clk or posedge reset)
|
||||
if(reset) begin delayed_display<=0;delayed_cold<=0;end
|
||||
else begin delayed_display<={delayed_display[0],display};delayed_cold<={delayed_cold[0],cold};end
|
||||
EE_Cold_Bt dut(clk,reset,display,cold,actual_reset_n,actual_ee);
|
||||
EE_Cold_Bt_reference reference(clk,reset,delayed_display[1],delayed_cold[1],reference_reset_n,reference_ee);
|
||||
integer comparisons=0;
|
||||
always @(negedge clk) if(!reset) begin
|
||||
comparisons=comparisons+1;
|
||||
if({actual_reset_n,actual_ee,dut.prog,dut.timer,dut.next_instruction}!==
|
||||
{reference_reset_n,reference_ee,reference.prog,reference.timer,reference.next_instruction})
|
||||
$fatal(1,"boot-control program differs from upstream with two-stage input delay");
|
||||
end
|
||||
initial begin
|
||||
repeat(4) @(negedge clk);#1;reset=0;
|
||||
#12;cold=1;#35;cold=0;
|
||||
// Exercise actual full production cold-boot timer/program.
|
||||
repeat(5500000) @(negedge clk);
|
||||
#2;display=1;#37;display=0;
|
||||
repeat(14000000) @(negedge clk);
|
||||
#2;display=1;cold=1;#31;display=0;cold=0;
|
||||
repeat(12) @(negedge clk);#2;reset=1;
|
||||
repeat(4) @(negedge clk);#1;reset=0;
|
||||
repeat(100) @(negedge clk);
|
||||
$display("PASS %0d complete production boot-program comparisons: cold boot, Easter Egg, simultaneous priority and reset, with explicit two-stage input latency",comparisons);
|
||||
$finish;
|
||||
end
|
||||
initial begin #200000000;$fatal(1,"boot control timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,48 @@
|
||||
`timescale 1ns/1ps
|
||||
module bridge_protocol_tb;
|
||||
reg clk=0,fast=0,reset=1,request=0,read_cycle=1,memory_ack=0;
|
||||
reg [24:0] address=0;
|
||||
reg [7:0] data=0;
|
||||
wire [24:0] captured_address;
|
||||
wire [7:0] captured_data;
|
||||
wire captured_read,memory_request,ack;
|
||||
cpu_sdram_bridge dut(clk,fast,reset,address,data,request,read_cycle,memory_ack,ack,captured_address,captured_data,captured_read,memory_request);
|
||||
always #10 clk=~clk;
|
||||
always #5 fast=~fast;
|
||||
task edge_wait;
|
||||
begin @(negedge clk);#1;end
|
||||
endtask
|
||||
integer i;
|
||||
reg [24:0] expected_address;
|
||||
reg [7:0] expected_data;
|
||||
reg expected_read;
|
||||
initial begin
|
||||
edge_wait();reset=0;
|
||||
for(i=0;i<300;i=i+1) begin
|
||||
// Previous acknowledgement may still be high when a new request arrives.
|
||||
memory_ack=1;repeat(2) @(negedge fast);
|
||||
@(posedge clk);#1;
|
||||
request=1;address=$random;data=$random;read_cycle=i[0];
|
||||
expected_address=address;expected_data=data;expected_read=read_cycle;
|
||||
repeat(3) begin edge_wait();if(ack!==0 || memory_request!==0) $fatal(1,"stale ACK accepted");end
|
||||
memory_ack=0;edge_wait();edge_wait();
|
||||
if(memory_request!==1 || {captured_address,captured_data,captured_read}!=={expected_address,expected_data,expected_read}) $fatal(1,"request capture missing");
|
||||
address=~address;data=~data;read_cycle=~read_cycle;
|
||||
repeat(i%7+1) begin
|
||||
edge_wait();
|
||||
if({captured_address,captured_data,captured_read}!=={expected_address,expected_data,expected_read}) $fatal(1,"payload changed during wait");
|
||||
end
|
||||
memory_ack=1;@(negedge fast);#1;if(ack!==1) $fatal(1,"fresh ACK missing");
|
||||
request=0;#1;if(ack!==0) $fatal(1,"ACK leaked after request drop");
|
||||
edge_wait();if(memory_request!==0) $fatal(1,"request did not drop");
|
||||
end
|
||||
memory_ack=0;request=1;edge_wait();edge_wait();
|
||||
reset=1;edge_wait();if(memory_request!==0) $fatal(1,"reset did not abort request");
|
||||
repeat(3) begin edge_wait();if(memory_request!==0) $fatal(1,"request restarted during reset");end
|
||||
request=0;reset=0;edge_wait();request=1;edge_wait();
|
||||
if(memory_request!==1) $fatal(1,"post-reset request failed");
|
||||
$display("PASS 300 request scoreboards: stale ACK rejection, fresh ACK, captured payload stability, arbitrary waits, reset abort/restart");
|
||||
$finish;
|
||||
end
|
||||
initial begin #1000000;$fatal(1,"bridge protocol timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,32 @@
|
||||
`timescale 1ns/1ps
|
||||
module completion_phase_tb;
|
||||
reg sys=1,fast=1,clear=1,ready=0;
|
||||
reg [15:0] data=0;
|
||||
always #10 sys=~sys;
|
||||
always #5 fast=~fast;
|
||||
wire phase_ready;
|
||||
wire [15:0] phase_data;
|
||||
actual_completion dut(fast,clear,ready,data,phase_ready,phase_data);
|
||||
integer comparisons=0,i;
|
||||
reg observing=0;
|
||||
// Compare the values the original and repaired CPU-side consuming edge sees,
|
||||
// before the coincident positive-fast producer's NBA updates.
|
||||
always @(negedge sys) if(observing && !clear) begin
|
||||
if(phase_ready!==dut.data_ready) $fatal(1,"completion phase changed CPU-visible readiness");
|
||||
if(phase_ready && phase_data!==dut.hold_data) $fatal(1,"completion flag/data became incoherent");
|
||||
comparisons=comparisons+1;
|
||||
end
|
||||
initial begin
|
||||
repeat(4) @(negedge sys);#1;clear=0;observing=1;
|
||||
for(i=0;i<20000;i=i+1) begin
|
||||
@(negedge fast);#1;data=$random;ready=$random;
|
||||
if(i%19==0) clear=1;
|
||||
if(i%19==3) clear=0;
|
||||
end
|
||||
clear=1;#1;
|
||||
if(phase_ready!==0 || dut.data_ready!==0) $fatal(1,"completion clear missing");
|
||||
$display("PASS %0d original/repaired completion flag/data observations at actual CPU phase; no extra CPU sampling cycle, random producer traffic and clears",comparisons);
|
||||
$finish;
|
||||
end
|
||||
initial begin #1000000;$fatal(1,"completion phase timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,80 @@
|
||||
`timescale 1ns/1ps
|
||||
module cpu_sdram_bridge_tb;
|
||||
reg clk=1,fast=1,reset=1;
|
||||
always #10 clk=~clk;
|
||||
always #5 fast=~fast;
|
||||
reg [24:0] address=0;
|
||||
reg [7:0] data=0;
|
||||
reg request=0,read_cycle=1;
|
||||
wire [24:0] tx_address;
|
||||
wire [7:0] tx_data;
|
||||
wire tx_request,tx_read,ack,controller_ack,ready;
|
||||
cpu_sdram_bridge dut(clk,fast,reset,address,data,request,read_cycle,controller_ack,ack,tx_address,tx_data,tx_read,tx_request);
|
||||
wire [15:0] dq,dout;
|
||||
wire [12:0] row;
|
||||
wire [1:0] bank;
|
||||
wire ras,cas,we;
|
||||
// Constant read bus, not a physical SDRAM array/timing model.
|
||||
assign dq=we?16'ha55a:16'hzzzz;
|
||||
sdram_32r8w memory(.init(reset),.clk(fast),.SDRAM_DQ(dq),.SDRAM_A(row),.SDRAM_BA(bank),
|
||||
.SDRAM_nRAS(ras),.SDRAM_nCAS(cas),.SDRAM_nWE(we),.sdram_dout(dout),
|
||||
.sdram_cpu_addr(tx_address),.sdram_cpu_din(tx_data),.sdram_cpu_req(tx_request),
|
||||
.sdram_cpu_rnw(tx_read),.sdram_cpu_ack(controller_ack),.sdram_cpu_ready(ready),
|
||||
.sdram_vid_addr(25'd0),.sdram_vid_req(1'b0));
|
||||
reg [24:0] expected_address;
|
||||
reg [7:0] expected_data;
|
||||
reg expected_read,checking=0;
|
||||
reg ready_seen=0;
|
||||
reg [15:0] returned_data;
|
||||
integer activations=0,commands=0,transactions=0;
|
||||
always @(posedge fast) begin
|
||||
#1;
|
||||
if(checking) begin
|
||||
if(ready) begin ready_seen=1;returned_data=dout;end
|
||||
if({ras,cas,we}===3'b011) begin
|
||||
if(row!==expected_address[22:10] || bank!==expected_address[24:23]) $fatal(1,"wrong row/bank payload");
|
||||
activations=activations+1;
|
||||
end
|
||||
if({ras,cas,we}===3'b101 || {ras,cas,we}===3'b100) begin
|
||||
if(row[8:0]!==expected_address[9:1] || row[10:9]!==2'b10) $fatal(1,"wrong column/autoprecharge");
|
||||
if(row[12:11] !== (expected_read?2'b00:{~expected_address[0],expected_address[0]})) $fatal(1,"wrong byte mask");
|
||||
if((we===1)!==expected_read) $fatal(1,"wrong read/write command");
|
||||
if(!expected_read && dq!=={expected_data,expected_data}) $fatal(1,"wrong binary write data");
|
||||
commands=commands+1;
|
||||
end
|
||||
end
|
||||
end
|
||||
task transaction(input [24:0] a,input [7:0] d,input reg r);
|
||||
integer count,old_commands,old_activations;
|
||||
begin
|
||||
@(posedge clk);#2;
|
||||
expected_address=a;expected_data=d;expected_read=r;
|
||||
old_commands=commands;old_activations=activations;
|
||||
address=a;data=d;read_cycle=r;checking=1;request=1;ready_seen=0;
|
||||
count=0;
|
||||
while(ack!==1 && count<1000) begin @(negedge fast);#1;count=count+1;end
|
||||
if(ack!==1) $fatal(1,"request acknowledgement timeout");
|
||||
// Once acknowledged, decode inputs may change; the transaction stays captured.
|
||||
@(negedge clk);#1;request=0;address=~a;data=~d;read_cycle=~r;
|
||||
count=0;
|
||||
while(ready_seen!==1 && count<1000) begin @(negedge fast);#1;count=count+1;end
|
||||
if(ready_seen!==1) $fatal(1,"transaction completion timeout");
|
||||
if(r && returned_data!==16'ha55a) $fatal(1,"read return data missing");
|
||||
repeat(5) @(negedge clk);
|
||||
#2;
|
||||
if(commands!=old_commands+1 || activations!=old_activations+1) $fatal(1,"lost/duplicate transaction");
|
||||
if(tx_request!==0 || ack!==0) $fatal(1,"request/ack did not clear");
|
||||
checking=0;transactions=transactions+1;
|
||||
end
|
||||
endtask
|
||||
integer i;
|
||||
initial begin
|
||||
repeat(8) @(negedge clk);reset=0;
|
||||
repeat(26000) @(negedge fast); // Complete >=200 us SDRAM initialization.
|
||||
for(i=0;i<25;i=i+1) begin transaction(25'b1<<i,8'h55,0);transaction(~(25'b1<<i),8'haa,1);end
|
||||
for(i=0;i<256;i=i+1) begin transaction($random,i,0);transaction($random,i,1);end
|
||||
$display("PASS %0d bridge + actual SDRAM-controller transactions: all address bits/banks/byte masks, all 256 write bytes, read/ack/ready, refresh stalls, no duplicates",transactions);
|
||||
$finish;
|
||||
end
|
||||
initial begin #10000000;$fatal(1,"SDRAM bridge regression timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,61 @@
|
||||
`timescale 1ns/1ps
|
||||
module disk_buffer_pipeline_tb;
|
||||
reg clk=0,enable=0,sampling=0;
|
||||
always #10 clk=~clk;
|
||||
integer period=2,tick=0,reads=0;
|
||||
reg [8:0] sdc_pointer=0;
|
||||
reg [10:0] wd_pointer=0,write_address=0;
|
||||
reg [7:0] write_data=0;
|
||||
reg writing=0,sdc_writing=0;
|
||||
wire [7:0] sdc_raw,wd_raw,sdc_piped,wd_piped;
|
||||
sdc_dpram sdc_memory(.clock(clk),.address_a(write_address[8:0]),.data_a(write_data),.wren_a(sdc_writing),
|
||||
.address_b(sdc_pointer),.data_b(8'd0),.wren_b(1'b0),.q_b(sdc_raw));
|
||||
wd1793_dpram wd_memory(.clock(~clk),.address_a(write_address),.data_a(write_data),.wren_a(writing),
|
||||
.address_b(wd_pointer),.data_b(8'd0),.wren_b(1'b0),.q_b(wd_raw));
|
||||
actual_sdc_pipeline sdc_pipe(clk,sdc_raw,sdc_piped);
|
||||
actual_wd_pipeline wd_pipe(~clk,1'b1,wd_raw,8'd0,wd_piped);
|
||||
function [7:0] pattern(input integer value);
|
||||
pattern=(value^(value>>3)^(value>>7));
|
||||
endfunction
|
||||
// WD native positive clock is the system negative edge in the full wrapper.
|
||||
always @(negedge clk) if(enable && sampling) wd_pointer<=wd_pointer+1'b1;
|
||||
always @(negedge clk) begin
|
||||
if(!sampling) begin enable<=0;tick<=0;end
|
||||
else begin
|
||||
enable<=(tick==0);tick<=(tick>=period-1)?0:tick+1;
|
||||
if(enable) begin
|
||||
if(sdc_raw!==pattern(reads%512) || wd_raw!==pattern(reads%2048)) begin
|
||||
`ifdef NEGATIVE_CONSECUTIVE
|
||||
$fatal(1,"unsupported consecutive CPU disk read");
|
||||
`else
|
||||
$fatal(1,"RAM pointer/read phase mismatch");
|
||||
`endif
|
||||
end
|
||||
if(sdc_piped!==sdc_raw || wd_piped!==wd_raw) $fatal(1,"CPU observed stale disk buffer: read=%0d Eperiod=%0d SDC=%h/%h WD=%h/%h ptr=%0d/%0d",reads,period,sdc_piped,sdc_raw,wd_piped,wd_raw,sdc_pointer,wd_pointer);
|
||||
sdc_pointer<=sdc_pointer+1'b1;reads=reads+1;
|
||||
end
|
||||
end
|
||||
end
|
||||
integer i,profile;
|
||||
initial begin
|
||||
for(i=0;i<2048;i=i+1) begin
|
||||
@(negedge clk);#1;write_address=i;write_data=pattern(i);writing=1;
|
||||
// SDC is 512 bytes; write its independent expected low-address pattern.
|
||||
sdc_writing=(i<512);
|
||||
end
|
||||
@(negedge clk);#1;writing=0;sdc_writing=0;
|
||||
for(profile=0;profile<2;profile=profile+1) begin
|
||||
@(negedge clk);#1;sampling=0;sdc_pointer=0;wd_pointer=0;reads=0;
|
||||
`ifdef NEGATIVE_CONSECUTIVE
|
||||
period=1;
|
||||
`else
|
||||
period=profile?6:2;
|
||||
`endif
|
||||
repeat(4) @(negedge clk);#1;sampling=1;
|
||||
wait(reads>=2100);@(posedge clk);#1;sampling=0;
|
||||
$display("PASS 2100 actual SDC/WD DPRAM CPU read comparisons, pointer phases, 512/2048-byte wrap; E period %0d",period);
|
||||
end
|
||||
$finish;
|
||||
end
|
||||
initial begin #1000000;$fatal(1,"disk buffer regression timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,40 @@
|
||||
`timescale 1ns/1ps
|
||||
// Real platform CE generator and I2S serializer, including the 48/96 kHz switch.
|
||||
module external_audio_tb;
|
||||
reg clk=0, reset=1, rate=0;
|
||||
always #20.341 clk=~clk;
|
||||
wire bclk,lrclk,data;
|
||||
audio_pin_contract dut(clk,reset,rate,bclk,lrclk,data);
|
||||
integer cycle=0, last_change=-10000, last_rise=-10000;
|
||||
integer setup_min=10000, hold_min=10000, rises=0, changes=0;
|
||||
reg checking=0;
|
||||
always @(posedge clk) cycle=cycle+1;
|
||||
always @(data or lrclk) if(checking) begin
|
||||
if(cycle-last_rise < hold_min) hold_min=cycle-last_rise;
|
||||
if(cycle-last_rise < 3) $fatal(1,"I2S receiver hold slot lost: %0d",cycle-last_rise);
|
||||
last_change=cycle;changes=changes+1;
|
||||
end
|
||||
always @(posedge bclk) if(checking) begin
|
||||
if(cycle-last_change < setup_min) setup_min=cycle-last_change;
|
||||
if(cycle-last_change < 5) $fatal(1,"I2S receiver setup slot lost: %0d",cycle-last_change);
|
||||
last_rise=cycle;rises=rises+1;
|
||||
end
|
||||
initial begin
|
||||
dut.ce_phase.cnt=0;
|
||||
dut.divider_phase.div=0;
|
||||
repeat(10) @(negedge clk);
|
||||
reset=0;
|
||||
repeat(100) @(negedge clk);
|
||||
checking=1;
|
||||
repeat(30000) @(negedge clk);
|
||||
rate=1;
|
||||
repeat(30000) @(negedge clk);
|
||||
rate=0;
|
||||
repeat(30000) @(negedge clk);
|
||||
checking=0;
|
||||
if(rises<5000 || changes<1000 || setup_min!=5 || hold_min!=3)
|
||||
$fatal(1,"Incomplete I2S transition coverage rises=%0d changes=%0d setup=%0d hold=%0d",rises,changes,setup_min,hold_min);
|
||||
$display("PASS audio pin slots: %0d rises, %0d changes; setup >=%0d cycles, hold >=%0d cycles",rises,changes,setup_min,hold_min);
|
||||
$finish;
|
||||
end
|
||||
endmodule
|
||||
@@ -0,0 +1,87 @@
|
||||
`timescale 1ns/1ps
|
||||
module external_i2c_tb;
|
||||
reg clk=0,start=0,rd=0;
|
||||
reg slave_present=0,slave_release=1;
|
||||
reg [7:0] slave_data=8'ha5;
|
||||
always #10 clk=~clk;
|
||||
tri1 scl,sda;
|
||||
// Slave maximum 900 ns clock-to-data plus independent pin-edge extrema.
|
||||
assign #(0,`SDA_FALL_NS,`SDA_RELEASE_NS) sda=slave_release ? 1'bz : 1'b0;
|
||||
wire done,error;
|
||||
wire [7:0] data;
|
||||
i2c #(50_000_000,`BUS_HZ) dut(.CLK(clk),.START(start),.READ(rd),.I2C_ADDR(7'h20),
|
||||
.I2C_WLEN(1'b1),.I2C_WDATA1(8'h96),.I2C_WDATA2(8'h5a),
|
||||
.I2C_RDATA(data),.END(done),.ACK(error),.I2C_SCL(scl),.I2C_SDA(sda));
|
||||
realtime rise_time=0,fall_time=0,data_time=0,start_time=0,stop_time=0;
|
||||
realtime minimum_low=1e9,minimum_high=1e9,minimum_setup=1e9;
|
||||
integer rises=0,starts=0,stops=0,j,timeout;
|
||||
integer bit_index=0,byte_index=0,checked_bytes=0;
|
||||
reg [7:0] byte_value=0,expected_byte;
|
||||
reg active=0,checking=0,first_fall=0;
|
||||
always @(negedge scl) begin
|
||||
if(slave_present && active) begin
|
||||
if(bit_index==8 && (!rd || byte_index==0)) slave_release <= #900 0;
|
||||
else if(rd && byte_index==1 && bit_index<8) slave_release <= #900 slave_data[7-bit_index];
|
||||
else slave_release <= #900 1;
|
||||
end else slave_release <= #900 1;
|
||||
end
|
||||
always @(negedge sda) if(checking) begin
|
||||
data_time=$realtime;
|
||||
if(scl===1) begin
|
||||
if(stop_time>0 && $realtime-stop_time<1300) $fatal(1,"I2C bus free below 1300ns");
|
||||
start_time=$realtime;starts=starts+1;active=1;first_fall=1;
|
||||
bit_index=0;byte_index=0;byte_value=0;
|
||||
end
|
||||
end
|
||||
always @(posedge sda) if(checking) begin
|
||||
data_time=$realtime;
|
||||
if(scl===1 && active) begin
|
||||
if($realtime-rise_time<600) $fatal(1,"I2C stop setup below 600ns");
|
||||
stop_time=$realtime;stops=stops+1;active=0;
|
||||
end
|
||||
end
|
||||
always @(negedge scl) if(checking && active) begin
|
||||
if($realtime-rise_time<minimum_high) minimum_high=$realtime-rise_time;
|
||||
if($realtime-rise_time<600) $fatal(1,"I2C high below 600ns");
|
||||
if(first_fall && $realtime-start_time<600) $fatal(1,"I2C start hold below 600ns");
|
||||
first_fall=0;
|
||||
fall_time=$realtime;
|
||||
end
|
||||
always @(posedge scl) if(checking && active && fall_time>0) begin
|
||||
if(rise_time>0 && $realtime-rise_time<2500) $fatal(1,"I2C fast-mode period below 2500ns");
|
||||
if($realtime-fall_time<minimum_low) minimum_low=$realtime-fall_time;
|
||||
if($realtime-fall_time<1300) $fatal(1,"I2C low below 1300ns: %0.3f",$realtime-fall_time);
|
||||
if($realtime-data_time<minimum_setup) minimum_setup=$realtime-data_time;
|
||||
if($realtime-data_time<100) $fatal(1,"I2C data setup below 100ns");
|
||||
rise_time=$realtime;rises=rises+1;
|
||||
if(bit_index<8) begin
|
||||
byte_value={byte_value[6:0],sda};
|
||||
if(bit_index==7) begin
|
||||
expected_byte=(byte_index==0) ? (rd ? 8'h41 : 8'h40) :
|
||||
rd ? (slave_present ? slave_data : 8'hff) : (byte_index==1 ? 8'h96 : 8'h5a);
|
||||
if(byte_value!==expected_byte) $fatal(1,"I2C transmitted-byte mismatch index=%0d actual=%h expected=%h",byte_index,byte_value,expected_byte);
|
||||
checked_bytes=checked_bytes+1;
|
||||
end
|
||||
end
|
||||
if(bit_index==8) begin bit_index=0;byte_index=byte_index+1;end
|
||||
else bit_index=bit_index+1;
|
||||
end
|
||||
initial begin
|
||||
dut.cnt=0;dut.I2C_CLOCK=0;
|
||||
repeat(20) @(negedge clk);
|
||||
checking=1;
|
||||
for(j=0;j<40;j=j+1) begin
|
||||
@(negedge clk);rd=j[0];slave_present=(j>=20);slave_data=j[1]?8'ha5:8'h5a;start=1;
|
||||
repeat(3) @(negedge clk);start=0;
|
||||
timeout=0;
|
||||
while(!done && timeout<10000) begin @(negedge clk);timeout=timeout+1;end
|
||||
if(timeout==10000) $fatal(1,"I2C completion timeout");
|
||||
if(error!==!slave_present || (rd && data!==(slave_present ? slave_data : 8'hff)))
|
||||
$fatal(1,"I2C ACK/data behavior error=%b data=%h present=%b",error,data,slave_present);
|
||||
repeat(500) @(negedge clk);
|
||||
end
|
||||
if(starts!=40 || stops!=40 || rises<600 || checked_bytes!=100) $fatal(1,"Incomplete I2C waveform coverage %0d/%0d/%0d/%0d",starts,stops,rises,checked_bytes);
|
||||
$display("PASS I2C fast-mode slots: %0d rises, low=%0.3f high=%0.3f setup=%0.3f ns",rises,minimum_low,minimum_high,minimum_setup);
|
||||
$finish;
|
||||
end
|
||||
endmodule
|
||||
@@ -0,0 +1,87 @@
|
||||
`timescale 1ns/1ps
|
||||
// Pin-command minimum intervals, independent of the controller's state encoding.
|
||||
module external_sdram_commands_tb;
|
||||
reg clk=0,init=1,req=0,rnw=0;
|
||||
always #4.365079 clk=~clk;
|
||||
wire [15:0] dq;
|
||||
assign dq=rnw ? 16'h965a : 16'hzzzz;
|
||||
wire [12:0] address;
|
||||
wire [1:0] bank;
|
||||
wire cs,ras,cas,we,memclk,ack,ready;
|
||||
reg [24:0] cpu_address=0;
|
||||
integer commands=0,activates=0,writes=0,reads=0,refreshes=0;
|
||||
realtime released=0, next_command=0;
|
||||
realtime last_active[0:3],next_active[0:3];
|
||||
realtime now_time, earliest;
|
||||
realtime last_refresh=-1;
|
||||
reg configured=0;
|
||||
integer b,j,timeout;
|
||||
reg started=0;
|
||||
sdram_probe dut(.init(init),.clk(clk),.SDRAM_DQ(dq),.SDRAM_A(address),.SDRAM_BA(bank),
|
||||
.SDRAM_nCS(cs),.SDRAM_nRAS(ras),.SDRAM_nCAS(cas),.SDRAM_nWE(we),.SDRAM_CLK(memclk),
|
||||
.sdram_cpu_addr(cpu_address),.sdram_cpu_din(8'h5a),.sdram_cpu_req(req),.sdram_cpu_rnw(rnw),
|
||||
.sdram_cpu_ack(ack),.sdram_cpu_ready(ready),.sdram_vid_addr(25'd0),.sdram_vid_req(1'b0));
|
||||
initial for(b=0;b<4;b=b+1) begin last_active[b]=-1000000;next_active[b]=0;end
|
||||
always @(posedge memclk) if(!init && {ras,cas,we}!==3'b111) begin
|
||||
now_time=$realtime;
|
||||
if(!started) begin
|
||||
if(!$test$plusargs("IGNORE_STARTUP") && now_time-released<200000)
|
||||
$fatal(1,"SDRAM startup below 200 us: %0.3f ns",now_time-released);
|
||||
started=1;
|
||||
end
|
||||
if(now_time+0.001<next_command) $fatal(1,"SDRAM refresh/precharge/mode recovery");
|
||||
commands=commands+1;
|
||||
case({ras,cas,we})
|
||||
3'b011: begin
|
||||
if(!$test$plusargs("IGNORE_TRC") && now_time-last_active[bank]<63.0) $fatal(1,"SDRAM tRC below 63 ns: %0.3f",now_time-last_active[bank]);
|
||||
if(!$test$plusargs("IGNORE_TRC") && now_time+0.001<next_active[bank]) $fatal(1,"SDRAM auto-precharge recovery");
|
||||
last_active[bank]=now_time;activates=activates+1;
|
||||
end
|
||||
3'b101,3'b100: begin
|
||||
if(now_time-last_active[bank]<21.0) $fatal(1,"SDRAM tRCD below 21 ns");
|
||||
if({ras,cas,we}==3'b100) begin
|
||||
writes=writes+1;earliest=now_time+14.0;
|
||||
end else begin
|
||||
reads=reads+1;earliest=now_time+2.0*8.730158;
|
||||
end
|
||||
if(earliest<last_active[bank]+42.0) earliest=last_active[bank]+42.0;
|
||||
if(address[10]) next_active[bank]=earliest+21.0;
|
||||
end
|
||||
3'b010: next_command=now_time+21.0;
|
||||
3'b001: begin
|
||||
next_command=now_time+63.0;refreshes=refreshes+1;
|
||||
if(configured) begin
|
||||
if(last_refresh>=0 && now_time-last_refresh>7812.5) $fatal(1,"SDRAM refresh interval above 7812.5 ns: %0.3f",now_time-last_refresh);
|
||||
last_refresh=now_time;
|
||||
end
|
||||
end
|
||||
3'b000: begin next_command=now_time+14.0;configured=1;end
|
||||
endcase
|
||||
end
|
||||
task transfer(input bit read_mode,input [24:0] addr);
|
||||
begin
|
||||
@(negedge clk);rnw=read_mode;cpu_address=addr;req=1;
|
||||
timeout=0;
|
||||
while(!ack && timeout<40000) begin @(negedge clk);timeout=timeout+1;end
|
||||
if(timeout==40000) $fatal(1,"SDRAM request timeout");
|
||||
req=0;
|
||||
while(ack) @(negedge clk);
|
||||
if(read_mode) begin
|
||||
timeout=0;
|
||||
while(!ready && timeout<100) begin @(negedge clk);timeout=timeout+1;end
|
||||
if(timeout==100) $fatal(1,"SDRAM read timeout");
|
||||
end
|
||||
end
|
||||
endtask
|
||||
initial begin
|
||||
repeat(10) @(negedge clk);
|
||||
init=0;released=$realtime;
|
||||
// Legal held-until-ACK requests may be queued during startup.
|
||||
for(j=0;j<128;j=j+1) transfer(0,{9'd0,j[7:0],8'd0});
|
||||
for(j=0;j<32;j=j+1) transfer(1,{9'd0,j[7:0],8'd0});
|
||||
repeat(50000) @(negedge clk);
|
||||
if(writes!=128 || reads!=32 || refreshes<3) $fatal(1,"Incomplete command coverage");
|
||||
$display("PASS SDRAM command intervals: startup >=200us, %0d ACT, %0d WR, %0d RD, %0d REF",activates,writes,reads,refreshes);
|
||||
$finish;
|
||||
end
|
||||
endmodule
|
||||
@@ -0,0 +1,26 @@
|
||||
`timescale 1ns/1ps
|
||||
module keyboard_control_phase_tb;
|
||||
reg clk=0;
|
||||
always #5 clk=~clk;
|
||||
reg [3:0] controls=4'b1000,expected_controls=4'b1000;
|
||||
reg [72:0] keys=0;
|
||||
reg [7:0] columns=0;
|
||||
wire observed,reference_value;
|
||||
actual_keyboard_controls candidate(clk,controls,keys,columns,observed);
|
||||
reference_keyboard_controls reference(expected_controls,keys,columns,reference_value);
|
||||
integer flags,column,pattern,comparisons=0;
|
||||
initial begin
|
||||
for(flags=0;flags<16;flags=flags+1)
|
||||
for(column=0;column<256;column=column+1)
|
||||
for(pattern=0;pattern<256;pattern=pattern+1) begin
|
||||
@(posedge clk);controls=flags;columns=column;keys[55:48]=pattern;
|
||||
#1;
|
||||
if(observed!==reference_value) $fatal(1,"Keyboard flags changed before sampling edge");
|
||||
@(negedge clk);#1;expected_controls=controls;#1;
|
||||
if(observed!==reference_value) $fatal(1,"Keyboard row/control decode changed");
|
||||
comparisons=comparisons+1;
|
||||
end
|
||||
$display("PASS %0d exhaustive keyboard-row comparisons: all 16 EE/MUGS/shift controls, 256 column masks, 256 key patterns; original decode and one-negative-edge observation",comparisons);
|
||||
$finish;
|
||||
end
|
||||
endmodule
|
||||
@@ -0,0 +1,63 @@
|
||||
`timescale 1ns/1ps
|
||||
module peripheral_phase_tb;
|
||||
reg clk=0;
|
||||
always #10 clk=~clk;
|
||||
reg enable=0;
|
||||
reg [8:0] address=0;
|
||||
reg [7:0] data=0;
|
||||
reg [15:0] palette=0;
|
||||
reg selected=0;
|
||||
reg ssc_palette_owner=1;
|
||||
wire write_enable=enable && selected;
|
||||
wire candidate_write_enable,supports_ssc;
|
||||
actual_vdac_write qualification(enable,selected,ssc_palette_owner,candidate_write_enable,supports_ssc);
|
||||
wire [7:0] old_q,new_q;
|
||||
sdc_reference old_ram(.clock(clk),.address_a(9'd0),.data_a(8'd0),.wren_a(1'b0),
|
||||
.address_b(address),.data_b(data),.wren_b(write_enable),.q_b(old_q));
|
||||
sdc_dpram new_ram(.clock(clk),.address_a(9'd0),.data_a(8'd0),.wren_a(1'b0),
|
||||
.address_b(address),.data_b(data),.wren_b(write_enable),.q_b(new_q));
|
||||
reg [15:0] old_palette[0:255],new_palette[0:255];
|
||||
integer old_writes=0,new_writes=0;
|
||||
always @(posedge clk) if(write_enable&&ssc_palette_owner) begin
|
||||
old_palette[data]<=palette;old_writes=old_writes+1;
|
||||
end
|
||||
// Exact generated VDAC write-clock expression; generated wrapper supplies it.
|
||||
wire candidate_write_clock;
|
||||
actual_vdac_clock write_clock(clk,candidate_write_clock);
|
||||
always @(posedge candidate_write_clock) if(candidate_write_enable) begin
|
||||
new_palette[data]<=palette;new_writes=new_writes+1;
|
||||
end
|
||||
integer tick=0,cycles=0,i,seed=32'h451a46d0;
|
||||
integer blocked_writes=0;
|
||||
reg previous_enable=0;
|
||||
// Model actual CPU contract: bus state changes at consuming negative edges;
|
||||
// the producer chooses the *next* enable in the same NBA update.
|
||||
always @(negedge clk) begin
|
||||
if(enable) begin
|
||||
address<=$random(seed);data<=$random(seed);palette<=$random(seed);
|
||||
selected<=$random(seed);
|
||||
end
|
||||
previous_enable<=enable;
|
||||
enable<=!enable && (($random(seed)&3)!=0);
|
||||
cycles=cycles+1;
|
||||
end
|
||||
initial begin
|
||||
for(i=0;i<512;i=i+1) begin old_ram.ram[i]=0;new_ram.ram[i]=0;end
|
||||
for(i=0;i<256;i=i+1) begin old_palette[i]=0;new_palette[i]=0;end
|
||||
repeat(20000) begin
|
||||
@(negedge clk);#1;
|
||||
if(cycles==10000&&supports_ssc)ssc_palette_owner=0;
|
||||
if(cycles==15000)ssc_palette_owner=1;
|
||||
if(!ssc_palette_owner&&write_enable)blocked_writes=blocked_writes+1;
|
||||
if(old_writes!==new_writes) $fatal(1,"VDAC write count mismatch");
|
||||
for(i=0;i<512;i=i+1)
|
||||
if(old_ram.ram[i]!==new_ram.ram[i]) $fatal(1,"SDC CPU write mismatch at %0d",i);
|
||||
for(i=0;i<256;i=i+1)
|
||||
if(old_palette[i]!==new_palette[i]) $fatal(1,"VDAC write payload mismatch at %0d",i);
|
||||
end
|
||||
if(new_writes<2000) $fatal(1,"Insufficient randomized writes");
|
||||
if(supports_ssc&&blocked_writes<500)$fatal(1,"Insufficient SSC palette write suppression");
|
||||
$display("PASS 20000 CPU bus intervals, %0d SDC/VDAC writes: old positive/new negative edge payload, address, enable and memory equality",new_writes);
|
||||
$finish;
|
||||
end
|
||||
endmodule
|
||||
@@ -0,0 +1,36 @@
|
||||
`timescale 1ns/1ps
|
||||
module reset_domains_tb;
|
||||
reg clk_sys=0,CLK_114=0,run_sys=1,run_fast=1,RESET_RAW_N=1;
|
||||
always #10 if(run_sys) clk_sys=~clk_sys;
|
||||
always #5 if(run_fast) CLK_114=~CLK_114;
|
||||
wire RESET_N,RESET_POS_N,RESET_FAST_N,WD_RESET_N;
|
||||
actual_reset_domains dut(clk_sys,CLK_114,RESET_RAW_N,RESET_N,RESET_POS_N,RESET_FAST_N);
|
||||
actual_wd_release disk(clk_sys,RESET_N,WD_RESET_N);
|
||||
reg observing=0;
|
||||
always @(posedge RESET_N) if(observing && clk_sys!==0) $fatal(1,"main reset released on wrong phase");
|
||||
always @(posedge RESET_POS_N) if(observing && clk_sys!==1) $fatal(1,"positive reset released on wrong phase");
|
||||
always @(posedge RESET_FAST_N) if(observing && CLK_114!==1) $fatal(1,"fast reset released on wrong phase");
|
||||
always @(posedge WD_RESET_N) if(observing && clk_sys!==1) $fatal(1,"disk reset released on wrong phase");
|
||||
integer phase;
|
||||
initial begin
|
||||
repeat(5) @(negedge clk_sys);observing=1;
|
||||
for(phase=0;phase<7;phase=phase+1) begin
|
||||
#(phase+1);RESET_RAW_N=0;#1;
|
||||
if({RESET_N,RESET_POS_N,RESET_FAST_N,WD_RESET_N}!==0) $fatal(1,"asynchronous domain assertion missing");
|
||||
@(negedge clk_sys);run_sys=0;run_fast=0;
|
||||
#13;RESET_RAW_N=1;#40;
|
||||
if({RESET_N,RESET_POS_N,RESET_FAST_N,WD_RESET_N}!==0) $fatal(1,"stopped clocks released reset");
|
||||
run_sys=1;
|
||||
@(negedge clk_sys);#1;if(RESET_N!==0) $fatal(1,"main released after only one edge");
|
||||
@(negedge clk_sys);#1;if(RESET_N!==1 || RESET_FAST_N!==0) $fatal(1,"main/fast release ordering wrong");
|
||||
@(posedge clk_sys);#1;if(WD_RESET_N!==0) $fatal(1,"disk released after one edge");
|
||||
@(posedge clk_sys);#1;if(WD_RESET_N!==1) $fatal(1,"disk release missing");
|
||||
run_fast=1;
|
||||
@(posedge CLK_114);#1;if(RESET_FAST_N!==0) $fatal(1,"fast released after one edge");
|
||||
@(posedge CLK_114);#1;if(RESET_FAST_N!==1) $fatal(1,"fast release missing");
|
||||
end
|
||||
$display("PASS actual domain and WD reset chains: seven phases, asynchronous assertion, two consuming edges, independently stopped clocks and release phases");
|
||||
$finish;
|
||||
end
|
||||
initial begin #10000;$fatal(1,"domain reset timeout");end
|
||||
endmodule
|
||||
@@ -0,0 +1,92 @@
|
||||
`timescale 1ns/1ps
|
||||
module ssc_mister_system_tb;
|
||||
reg clk=0,pll_lock=0,cpu_ready=0,mode=1,commit=0,rnw=1;
|
||||
wire power_reset;
|
||||
actual_ssc_power_reset power_release(clk,pll_lock,power_reset);
|
||||
always #5 clk=~clk;
|
||||
reg [15:0] address=16'hff7e;
|
||||
reg [7:0] data=0,index=0,file_data=0;
|
||||
reg [24:0] file_address=0;
|
||||
reg download=0,wr=0;
|
||||
reg [11:0] mpi_layout={3'd2,3'd1,3'd3,3'd6};
|
||||
wire ready,fault,read_valid,palette_owner;
|
||||
wire [7:0] read_data;
|
||||
wire [15:0] left,right;
|
||||
actual_ssc_mister_system dut(.clk_sys(clk),.SSC_POWER_RESET(power_reset),.RESET_POS_N(cpu_ready),
|
||||
.SSC_MODE(mode),.MPI_LAYOUT(mpi_layout),.PH_2(commit),.RW_N(rnw),.ADDRESS(address),.DATA_OUT(data),
|
||||
.ioctl_download(download),.ioctl_wr(wr),.ioctl_index({8'd0,index}),.ioctl_addr(file_address),.ioctl_data(file_data),
|
||||
.SOUND_EN(1'b1),.SEL(2'd2),.ORCH_LEFT(8'd128),.ORCH_RIGHT(8'd128),.SOUND(8'd0),
|
||||
.SSC_READY(ready),.SSC_FAULT(fault),.SOUND_LEFT(left),.SOUND_RIGHT(right),
|
||||
.READ_VALID(read_valid),.READ_DATA(read_data),.PALETTE_OWNER(palette_owner));
|
||||
reg [7:0] pic[0:4095],voice[0:2047];
|
||||
string pic_path,voice_path;
|
||||
integer fd,n,i,phi=0,commands=0,host_reads=0,audio_changes=0,previous_audio=0,voice_nonzero=0;
|
||||
always @(posedge clk)if(!power_reset)begin
|
||||
if(dut.ssc.phi_ce)begin
|
||||
phi=phi+1;if(phi%50000==0)begin $display("PROGRESS actual MiSTer bindings phi=%0d commands=%0d",phi,commands);$fflush();end
|
||||
end
|
||||
if(fault)$fatal(1,"actual MiSTer binding cartridge fault PC=%04x",dut.ssc_debug_pc);
|
||||
if(dut.ssc.command_read)host_reads=host_reads+1;
|
||||
if(dut.ssc.speech_valid&&dut.ssc.speech_sample!=0)voice_nonzero=voice_nonzero+1;
|
||||
if(dut.ssc_audio_valid)begin if(left!=previous_audio)audio_changes=audio_changes+1;previous_audio=left;end
|
||||
end
|
||||
task wait_phi(input integer ticks);
|
||||
integer target;
|
||||
begin target=phi+ticks;while(phi<target)begin @(posedge clk);#1;end end
|
||||
endtask
|
||||
task load(input [7:0] kind,input integer length);
|
||||
begin
|
||||
@(negedge clk);#1;index=kind;download=1;
|
||||
for(i=0;i<length;i=i+1)begin
|
||||
wr=1;file_address=i;file_data=kind[5:0]==4?pic[i]:voice[i];
|
||||
@(posedge clk);#1;@(negedge clk);#1;
|
||||
end
|
||||
download=0;wr=0;repeat(4)begin @(posedge clk);#1;end
|
||||
end
|
||||
endtask
|
||||
task send(input [7:0] value);
|
||||
integer deadline;
|
||||
begin
|
||||
address=16'hff7e;rnw=1;deadline=phi+89489;
|
||||
while((!read_valid||!read_data[7])&&phi<deadline)begin @(posedge clk);#1;end
|
||||
if(!read_valid||!read_data[7])$fatal(1,"actual MiSTer busy timeout command=%0d",commands);
|
||||
@(posedge clk);#1;address=16'hff7e;data=value;commit=1;rnw=0;
|
||||
@(negedge clk);#1;@(posedge clk);#1;commit=0;rnw=1;commands=commands+1;
|
||||
@(negedge clk);#1;
|
||||
end
|
||||
endtask
|
||||
initial begin
|
||||
if(!$value$plusargs("PIC_PATH=%s",pic_path)||!$value$plusargs("SPEECH_PATH=%s",voice_path))$fatal(1,"missing original ROM paths");
|
||||
fd=$fopen(pic_path,"rb");n=$fread(pic,fd);$fclose(fd);if(n!=4096)$fatal(1,"PIC length");
|
||||
fd=$fopen(voice_path,"rb");n=$fread(voice,fd);$fclose(fd);if(n!=2048)$fatal(1,"voice length");
|
||||
repeat(4)@(posedge clk);@(negedge clk);#1;
|
||||
if(!power_reset)$fatal(1,"SSC power reset released without PLL lock");
|
||||
pll_lock=1;@(posedge clk);#1;if(!power_reset)$fatal(1,"SSC power reset released too soon");
|
||||
@(posedge clk);#1;if(power_reset)$fatal(1,"SSC power reset did not release after two clock edges");
|
||||
load(8'h44,4096);load(8'h05,2048);
|
||||
if(!dut.ssc_files_valid||read_data[7])$fatal(1,"MiSTer original-ROM files/reset guard failed");
|
||||
cpu_ready=1;wait_phi(27000);
|
||||
if(ready!==1'b1||read_valid!==1'b1||read_data[7]!==1'b1||palette_owner!==1'b0)$fatal(1,"MiSTer boot/read ownership failed");
|
||||
$display("BOOT actual MiSTer bindings PASS phi=%0d",phi);$fflush();
|
||||
send(8'h98);send(8'h0f);send(0);send(8'hfa);send(2);send(0);send(0);send(8'hfa);send(0);send(8'hff);send(8'hd8);
|
||||
wait_phi(45000);
|
||||
if(audio_changes<20||dut.ssc.ay.registers[8][3:0]==0)$fatal(1,"actual MiSTer tone/audio bindings failed changes=%0d volume=%h left=%h orch=%b mode=%b",audio_changes,dut.ssc.ay.registers[8],left,dut.mpi_orchestra_present,dut.ssc_mode_active);
|
||||
send("A");send(" ");send(13);
|
||||
n=phi+268466;
|
||||
while(voice_nonzero<100&&phi<n)begin @(posedge clk);#1;end
|
||||
if(voice_nonzero<100||host_reads!=14)$fatal(1,"actual MiSTer speech/command bindings failed reads=%0d speech=%0d",host_reads,voice_nonzero);
|
||||
@(posedge clk);#1;mode=0;@(negedge clk);#1;
|
||||
if(read_valid||!palette_owner||left!=16'h8080||right!=16'h8080)$fatal(1,"actual MiSTer palette/legacy-audio restore failed");
|
||||
repeat(4)begin @(posedge clk);#1;end
|
||||
if(!dut.ssc_files_valid)$fatal(1,"actual MiSTer mode switch lost ROMs");
|
||||
// Removing the device restores palette ownership even with the old SSC mode
|
||||
// bit retained. Reinsert in a different socket; firmware ROMs stay available.
|
||||
mode=1;mpi_layout=12'd0;repeat(4)begin @(posedge clk);#1;end
|
||||
if(ready!==1'b0||read_valid!==1'b0||palette_owner!==1'b1)$fatal(1,"Removed SSC still responds");
|
||||
mpi_layout={3'd4,3'd0,3'd0,3'd5};wait_phi(27000);
|
||||
if(ready!==1'b1||read_valid!==1'b1||palette_owner!==1'b0||dut.ssc_files_valid!==1'b1)$fatal(1,"Moved SSC did not reboot from retained ROMs");
|
||||
$display("RESULT {\"passed\":true,\"phi\":%0d,\"host_bytes\":%0d,\"host_reads\":%0d,\"audio_changes\":%0d,\"speech_nonzero\":%0d}",phi,commands,host_reads,audio_changes,voice_nonzero);
|
||||
$display("PASS actual MiSTer SSC bindings: original HPS ROM files, reset guard, negative-edge CPU writes/status, real RTL tone/speech and legacy ownership/audio restore");$finish;
|
||||
end
|
||||
initial begin #400000000;$fatal(1,"actual MiSTer SSC binding watchdog");end
|
||||
endmodule
|
||||
@@ -0,0 +1,33 @@
|
||||
"""Check release integrity boundaries against a real completed local build."""
|
||||
import json,sys,tempfile,unittest,zipfile
|
||||
from pathlib import Path
|
||||
ROOT=Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0,str(ROOT/'tools'))
|
||||
from release import default_config,make_release,SSC
|
||||
class ReleaseGuards(unittest.TestCase):
|
||||
def test_fresh_profile_preserves_status_contract(self):
|
||||
data=default_config(True);self.assertEqual(len(data),16)
|
||||
value=int.from_bytes(data,'little')
|
||||
self.assertEqual(value>>63,1)
|
||||
self.assertEqual((value>>12)&3,3)
|
||||
self.assertEqual([(value>>(43+3*i))&7 for i in range(4)],[6,3,1,2])
|
||||
self.assertEqual(value^int.from_bytes(default_config(False),'little'),1<<42)
|
||||
def test_changed_ssc_fails_before_creating_output(self):
|
||||
with tempfile.TemporaryDirectory(dir=ROOT/'build') as folder:
|
||||
base=Path(folder);roms=base/'roms';roms.mkdir()
|
||||
for name in SSC:
|
||||
original=(ROOT/'roms/ssc'/name).read_bytes()
|
||||
(roms/name).write_bytes(original)
|
||||
chip=roms/'pic-7040-510.bin';data=bytearray(chip.read_bytes());data[-1]^=1;chip.write_bytes(data)
|
||||
out=base/'release'
|
||||
with self.assertRaisesRegex(RuntimeError,'incorrect input'):
|
||||
make_release(out,ROOT/'build/fpga',ROOT/'build/roms',roms)
|
||||
self.assertFalse(out.exists())
|
||||
def test_corresponding_source_contains_no_local_roms(self):
|
||||
release=ROOT/'dist/coco3plus'
|
||||
with zipfile.ZipFile(release/'corresponding-source.zip') as archive:
|
||||
names=archive.namelist();self.assertTrue(any(n.endswith('/rtl/coco3fpga.sv') for n in names))
|
||||
self.assertFalse(any('/roms/ssc/' in n or '/.deps/' in n or '/build/' in n for n in names))
|
||||
record=json.loads((release/'manifest.json').read_text())
|
||||
self.assertEqual(record['files']['config/coco3plus_v51.CFG']['policy'],'create-if-missing')
|
||||
if __name__=='__main__':unittest.main()
|
||||
@@ -0,0 +1,206 @@
|
||||
"""Exercise simulator-install and source-release boundaries without real ROMs.
|
||||
|
||||
Copyright (c) 2026 Brian K. Holman.
|
||||
Original test contributions: BSD-3-Clause; see LICENSES/.
|
||||
"""
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tarfile
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
import zipfile
|
||||
|
||||
REPOSITORY = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(REPOSITORY / 'tools'))
|
||||
import bootstrap
|
||||
import release
|
||||
|
||||
|
||||
def digest(path):
|
||||
return hashlib.sha256(path.read_bytes()).hexdigest()
|
||||
|
||||
|
||||
class SimulatorInstallGuards(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory(dir=REPOSITORY / 'build')
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.base = Path(self.temporary.name)
|
||||
|
||||
def archive(self, *, include_runtime=True):
|
||||
archive = self.base / 'simulator.tgz'
|
||||
members = {
|
||||
'oss-cad-suite/bin/iverilog.exe': b'fake compiler fixture',
|
||||
'oss-cad-suite/share/readme.txt': b'fixture support data',
|
||||
}
|
||||
if include_runtime:
|
||||
members['oss-cad-suite/bin/vvp.exe'] = b'fake runtime fixture'
|
||||
with tarfile.open(archive, 'w:gz') as tar:
|
||||
for name, data in members.items():
|
||||
entry = tarfile.TarInfo(name)
|
||||
entry.size = len(data)
|
||||
tar.addfile(entry, io.BytesIO(data))
|
||||
return archive, members
|
||||
|
||||
def test_existing_incomplete_install_is_preserved_and_rejected(self):
|
||||
archive, _ = self.archive()
|
||||
folder = self.base / 'installed'
|
||||
folder.mkdir()
|
||||
sentinel = folder / 'partial-user-file'
|
||||
sentinel.write_bytes(b'preserve prior incomplete evidence')
|
||||
|
||||
with self.assertRaisesRegex(RuntimeError, 'Incomplete/legacy simulator'):
|
||||
bootstrap.install_simulator(archive, folder, digest(archive))
|
||||
|
||||
self.assertEqual(sentinel.read_bytes(), b'preserve prior incomplete evidence')
|
||||
self.assertEqual(list(folder.iterdir()), [sentinel])
|
||||
self.assertFalse(folder.with_name('installed.partial').exists())
|
||||
|
||||
def test_complete_extraction_is_published_then_corruption_is_rejected(self):
|
||||
archive, members = self.archive()
|
||||
folder = self.base / 'installed'
|
||||
archive_hash = digest(archive)
|
||||
|
||||
bootstrap.install_simulator(archive, folder, archive_hash)
|
||||
|
||||
self.assertTrue(folder.is_dir())
|
||||
self.assertFalse(folder.with_name('installed.partial').exists())
|
||||
marker = json.loads((folder / '.coco3plus-install.json').read_text())
|
||||
self.assertEqual(marker['archive_sha256'], archive_hash)
|
||||
self.assertEqual(set(marker['files']), set(members))
|
||||
for name, data in members.items():
|
||||
self.assertEqual((folder / name).read_bytes(), data)
|
||||
self.assertEqual(marker['files'][name]['sha256'], digest(folder / name))
|
||||
|
||||
# A healthy rerun verifies the installed tree. A same-length mutation
|
||||
# must also be rejected; checking existence or length alone is inadequate.
|
||||
bootstrap.install_simulator(archive, folder, archive_hash)
|
||||
executable = folder / 'oss-cad-suite/bin/vvp.exe'
|
||||
mutated = bytearray(executable.read_bytes())
|
||||
mutated[-1] ^= 1
|
||||
executable.write_bytes(mutated)
|
||||
|
||||
with self.assertRaisesRegex(RuntimeError, 'installation incomplete/changed'):
|
||||
bootstrap.install_simulator(archive, folder, archive_hash)
|
||||
self.assertEqual(executable.read_bytes(), bytes(mutated))
|
||||
|
||||
def test_failed_extraction_never_publishes_a_complete_directory(self):
|
||||
archive, _ = self.archive(include_runtime=False)
|
||||
folder = self.base / 'installed'
|
||||
|
||||
with self.assertRaisesRegex(RuntimeError, 'Missing simulator executable'):
|
||||
bootstrap.install_simulator(archive, folder, digest(archive))
|
||||
|
||||
self.assertFalse(folder.exists())
|
||||
partial = folder.with_name('installed.partial')
|
||||
self.assertTrue(partial.is_dir())
|
||||
self.assertFalse((partial / '.coco3plus-install.json').exists())
|
||||
|
||||
|
||||
class PublicSourceReleaseGuards(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory(dir=REPOSITORY / 'build')
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.root = Path(self.temporary.name) / 'repository'
|
||||
self.root.mkdir()
|
||||
self.hooks = Path(self.temporary.name) / 'empty-hooks'
|
||||
self.hooks.mkdir()
|
||||
files = {
|
||||
'.gitignore': b'/build/\n/dist/\n',
|
||||
'.gitattributes': b'* -text\n',
|
||||
'NOTICE.md': b'Fixture notice only.\n',
|
||||
'LICENSING.md': b'Fixture component terms.\n',
|
||||
'COPYRIGHT.md': b'Fixture attribution.\n',
|
||||
'LICENSES/Fixture.txt': b'Fixture license text.\n',
|
||||
'rtl/ssc/LICENSE': b'Fixture SSC notice only; no ROM contents.\n',
|
||||
'rtl/example.sv': b'module example; endmodule\n',
|
||||
}
|
||||
for name, data in files.items():
|
||||
path = self.root / name
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_bytes(data)
|
||||
self.git('init', '--quiet')
|
||||
self.git('add', '--', *files)
|
||||
self.git('-c', 'user.name=Tooling Test',
|
||||
'-c', '[email protected]',
|
||||
'-c', 'commit.gpgsign=false',
|
||||
'commit', '--quiet', '-m', 'Create isolated fixture')
|
||||
self.tracked = set(files)
|
||||
self.revision = self.git('rev-parse', 'HEAD').decode().strip()
|
||||
|
||||
self.build = self.root / 'build/fpga'
|
||||
rbf = self.build / 'project/output_files/CoCo3.rbf'
|
||||
rbf.parent.mkdir(parents=True)
|
||||
rbf.write_bytes(b'FAKE RBF FOR RELEASE TEST ONLY')
|
||||
record = {
|
||||
'passed': True,
|
||||
'rbf_bytes': rbf.stat().st_size,
|
||||
'rbf_sha256': digest(rbf),
|
||||
'inputs': {'rtl/example.sv': digest(self.root / 'rtl/example.sv')},
|
||||
}
|
||||
(self.build / 'build.json').write_text(json.dumps(record))
|
||||
self.output = self.root / 'dist/public-release'
|
||||
self.root_patch = patch.object(release, 'ROOT', self.root)
|
||||
self.root_patch.start()
|
||||
self.addCleanup(self.root_patch.stop)
|
||||
|
||||
def git(self, *arguments):
|
||||
return subprocess.check_output(
|
||||
['git', '-c', 'core.autocrlf=false',
|
||||
'-c', 'core.hooksPath=' + str(self.hooks), *arguments],
|
||||
cwd=self.root, stderr=subprocess.STDOUT)
|
||||
|
||||
def package(self):
|
||||
# Neither input directory exists. Public packaging must not read ROMs.
|
||||
return release.make_release(
|
||||
self.output, self.build, self.root / 'missing-boot-roms',
|
||||
self.root / 'missing-ssc-roms', public=True)
|
||||
|
||||
def test_untracked_private_files_do_not_enter_public_release(self):
|
||||
(self.root / '.env').write_text('fixture-private-value=not-for-export\n')
|
||||
(self.root / 'private-notes.txt').write_text('private fixture notes\n')
|
||||
untracked = self.git('ls-files', '--others', '--exclude-standard').decode()
|
||||
self.assertIn('.env', untracked)
|
||||
self.assertIn('private-notes.txt', untracked)
|
||||
|
||||
record = self.package()
|
||||
|
||||
self.assertTrue(record['public_package'])
|
||||
self.assertFalse(record['ssc_included'])
|
||||
self.assertTrue(record['roms_required_separately'])
|
||||
self.assertEqual(record['source_revision'], self.revision)
|
||||
fat_files = {p.relative_to(self.output / 'fat').as_posix()
|
||||
for p in (self.output / 'fat').rglob('*') if p.is_file()}
|
||||
self.assertFalse(any(Path(n).suffix.lower() in ('.rom', '.bin', '.ccc')
|
||||
for n in fat_files))
|
||||
self.assertIn('_Computer/.coco3plus/' +
|
||||
record['rbf_sha256'][:12] + '/coco3plus.rbf', fat_files)
|
||||
self.assertEqual(set(record['files']), fat_files)
|
||||
with zipfile.ZipFile(self.output / 'corresponding-source.zip') as archive:
|
||||
source_files = {n for n in archive.namelist() if not n.endswith('/')}
|
||||
self.assertEqual(source_files,
|
||||
{'coco3plus/' + n for n in self.tracked})
|
||||
self.assertFalse(any('.env' in n or 'private-notes' in n
|
||||
for n in source_files))
|
||||
with zipfile.ZipFile(self.output.with_name('public-release.zip')) as archive:
|
||||
self.assertNotIn('.env', archive.namelist())
|
||||
self.assertNotIn('private-notes.txt', archive.namelist())
|
||||
|
||||
def test_dirty_tracked_source_rejects_before_output_creation(self):
|
||||
notice = self.root / 'NOTICE.md'
|
||||
notice.write_bytes(notice.read_bytes() + b'Unreviewed tracked change.\n')
|
||||
self.assertTrue(self.git('status', '--porcelain', '--untracked-files=no'))
|
||||
|
||||
with self.assertRaisesRegex(RuntimeError, 'Commit reviewed changes'):
|
||||
self.package()
|
||||
|
||||
self.assertFalse(self.output.exists())
|
||||
self.assertFalse(self.output.with_name('public-release.zip').exists())
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -0,0 +1,198 @@
|
||||
`timescale 1ns/1ps
|
||||
// Logical SDRAM command/data model. Not an electrical SDRAM timing model.
|
||||
module video_read_model #(parameter RETURN_DELAY_NS=0, COMMAND_DELAY_NS=0)(input clk, input [2:0] command,
|
||||
input [12:0] address, input [1:0] bank, inout [15:0] dq,
|
||||
output integer reads=0, output integer refreshes=0);
|
||||
reg [12:0] rows[0:3];
|
||||
reg [15:0] pipe[0:3];
|
||||
reg [3:0] valid=0;
|
||||
reg [15:0] drive=16'hzzzz;
|
||||
reg [23:0] word_address;
|
||||
integer i;
|
||||
wire [2:0] pin_command;
|
||||
wire [12:0] pin_address;
|
||||
wire [1:0] pin_bank;
|
||||
assign #(COMMAND_DELAY_NS) pin_command=command;
|
||||
assign #(COMMAND_DELAY_NS) pin_address=address;
|
||||
assign #(COMMAND_DELAY_NS) pin_bank=bank;
|
||||
assign dq=drive;
|
||||
function [15:0] contents(input [23:0] a);
|
||||
contents=a[15:0] ^ {a[23:16],a[23:16]} ^ 16'h96a5;
|
||||
endfunction
|
||||
always @(negedge clk) begin
|
||||
drive <= #(RETURN_DELAY_NS) (valid[0]?pipe[0]:16'hzzzz);
|
||||
for(i=0;i<3;i=i+1) pipe[i]=pipe[i+1];
|
||||
valid=valid>>1;
|
||||
if(pin_command===3'b011) rows[pin_bank]=pin_address;
|
||||
if(pin_command===3'b001) refreshes=refreshes+1;
|
||||
if(pin_command===3'b101) begin
|
||||
word_address={pin_bank,rows[pin_bank],pin_address[8:0]};
|
||||
// Sequential burst length two wraps within the aligned pair.
|
||||
pipe[2]=contents(word_address);pipe[3]=contents(word_address ^ 24'd1);
|
||||
valid[2]=1;valid[3]=1;reads=reads+1;
|
||||
end
|
||||
end
|
||||
endmodule
|
||||
|
||||
module video_channel #(parameter CANDIDATE=0)(
|
||||
input clk,reset,hborder, input [24:0] base,
|
||||
input [6:0] offset, input coco1, input [3:0] hres,
|
||||
input wide,contention, output [8:0] buffer_address,
|
||||
output [15:0] buffer_data, output buffer_write,
|
||||
output [4:0] fetch_state, output integer cpu_reads=0,
|
||||
output integer memory_reads,refreshes);
|
||||
wire [24:0] vid_address;
|
||||
wire request,ack,ready;
|
||||
wire [15:0] dout,dq;
|
||||
wire [12:0] row;
|
||||
wire [1:0] bank;
|
||||
wire ras,cas,we,cpu_ack,cpu_ready;
|
||||
reg cpu_request=0;
|
||||
integer phase=0;
|
||||
// Independent competing CPU requests; each held until acknowledgement.
|
||||
always @(posedge clk) begin
|
||||
if(reset) begin cpu_request<=0;phase<=0;end
|
||||
else begin
|
||||
phase<=phase+1;
|
||||
if(cpu_ack) cpu_request<=0;
|
||||
else if(contention && phase%23==0) cpu_request<=1;
|
||||
if(cpu_ready) cpu_reads<=cpu_reads+1;
|
||||
end
|
||||
end
|
||||
coco_mem_fetch fetch(.fast_clk(clk),.RESET_N(!reset),
|
||||
.SDRAM_VID_REQ(request),.SDRAM_VID_ADDR(vid_address),
|
||||
.SDRAM_VID_ACK(ack),.SDRAM_VID_READY(ready),.SDRAM_DOUT(dout),
|
||||
.BUFF_ADD(buffer_address),.BUFF_DATA_O(buffer_data),.BUFFER_WRITE(buffer_write),
|
||||
.RAM_ADDRESS(base),.HBORDER(hborder),.HOR_OFFSET(offset),
|
||||
.COCO1(coco1),.HRES(hres),.CT_320_160(wide));
|
||||
assign fetch_state=fetch.state;
|
||||
generate if(CANDIDATE) begin
|
||||
sdram_candidate memory(.init(reset),.clk(clk),.SDRAM_DQ(dq),.SDRAM_A(row),
|
||||
.SDRAM_BA(bank),.SDRAM_nRAS(ras),.SDRAM_nCAS(cas),.SDRAM_nWE(we),
|
||||
.sdram_dout(dout),.sdram_cpu_addr(25'h1023456),.sdram_cpu_din(8'd0),
|
||||
.sdram_cpu_req(cpu_request),.sdram_cpu_rnw(1'b1),.sdram_cpu_ack(cpu_ack),
|
||||
.sdram_cpu_ready(cpu_ready),.sdram_vid_addr(vid_address),.sdram_vid_req(request),
|
||||
.sdram_vid_ack(ack),.sdram_vid_ready(ready));
|
||||
end else begin
|
||||
sdram_reference memory(.init(reset),.clk(clk),.SDRAM_DQ(dq),.SDRAM_A(row),
|
||||
.SDRAM_BA(bank),.SDRAM_nRAS(ras),.SDRAM_nCAS(cas),.SDRAM_nWE(we),
|
||||
.sdram_dout(dout),.sdram_cpu_addr(25'h1023456),.sdram_cpu_din(8'd0),
|
||||
.sdram_cpu_req(cpu_request),.sdram_cpu_rnw(1'b1),.sdram_cpu_ack(cpu_ack),
|
||||
.sdram_cpu_ready(cpu_ready),.sdram_vid_addr(vid_address),.sdram_vid_req(request),
|
||||
.sdram_vid_ack(ack),.sdram_vid_ready(ready));
|
||||
end endgenerate
|
||||
`ifndef REFERENCE_RETURN_DELAY
|
||||
`define REFERENCE_RETURN_DELAY 0
|
||||
`endif
|
||||
`ifndef CANDIDATE_RETURN_DELAY
|
||||
`define CANDIDATE_RETURN_DELAY 0
|
||||
`endif
|
||||
// The functional comparison tests the payload/handshake at the declared return
|
||||
// latency. Physical min/max windows are checked separately by external-I/O STA.
|
||||
video_read_model #(.RETURN_DELAY_NS(CANDIDATE ? `CANDIDATE_RETURN_DELAY : `REFERENCE_RETURN_DELAY)) model(clk,{ras,cas,we},row,bank,dq,memory_reads,refreshes);
|
||||
endmodule
|
||||
|
||||
module video_sdram_tb;
|
||||
reg clk=0,reset=1,hborder=0;
|
||||
always #5 clk=~clk;
|
||||
reg [24:0] base=0;
|
||||
reg [6:0] offset=0;
|
||||
reg coco1=0,wide=1,contention=0;
|
||||
reg [3:0] hres=0;
|
||||
wire [8:0] address[0:1];
|
||||
wire [15:0] data[0:1];
|
||||
wire [1:0] write_buffer;
|
||||
wire [4:0] state[0:1];
|
||||
wire [31:0] cpu_reads[0:1],memory_reads[0:1],refreshes[0:1];
|
||||
genvar g;
|
||||
generate for(g=0;g<2;g=g+1) begin
|
||||
video_channel #(.CANDIDATE(g)) channel(clk,reset,hborder,base,offset,coco1,hres,
|
||||
wide,contention,address[g],data[g],write_buffer[g],state[g],
|
||||
cpu_reads[g],memory_reads[g],refreshes[g]);
|
||||
end endgenerate
|
||||
reg checking=0;
|
||||
integer count[0:1];
|
||||
reg [15:0] reference_data[0:511],candidate_data[0:511];
|
||||
integer k,limit,scenario=0,total_words=0;
|
||||
reg [8:0] word_offset;
|
||||
reg [24:0] expected_byte;
|
||||
reg [23:0] expected_word;
|
||||
reg [15:0] expected_data;
|
||||
integer beat_index;
|
||||
always @(posedge clk) begin
|
||||
if(checking) for(k=0;k<2;k=k+1) if(write_buffer[k]) begin
|
||||
if(address[k]!==count[k]) $fatal(1,"buffer index channel=%0d scenario=%0d count=%0d actual=%h",k,scenario,count[k],address[k]);
|
||||
if(count[k]>=512) $fatal(1,"buffer overrun");
|
||||
if(k==0) reference_data[count[k]]=data[k];else candidate_data[count[k]]=data[k];
|
||||
// Check the visible line against an address-derived oracle, independent of
|
||||
// the DUT FSM. Extra upstream guard words are compared separately below.
|
||||
if(count[k]<limit) begin
|
||||
// Predict the pair transactions from the starting word alignment. On an
|
||||
// odd start the first pair contributes one word, subsequent pairs two.
|
||||
// Apply the upstream window mask to each transaction, not each beat:
|
||||
// those differ at a 256-byte wrap when the base itself is odd-word aligned.
|
||||
if(base[1]^offset[0]) begin
|
||||
word_offset=(count[k]==0)?offset:(offset+1+((count[k]-1)&~1));
|
||||
beat_index=(count[k]==0)?0:((count[k]-1)&1);
|
||||
end else begin
|
||||
word_offset=offset+(count[k]&~1);beat_index=count[k]&1;
|
||||
end
|
||||
if(coco1 || !hres[3]) word_offset=word_offset & 9'h07f;
|
||||
expected_byte=base+{word_offset,1'b0};
|
||||
expected_word=expected_byte[24:1] ^ beat_index;
|
||||
expected_data=expected_word[15:0] ^ {expected_word[23:16],expected_word[23:16]} ^ 16'h96a5;
|
||||
if(data[k]!==expected_data) $fatal(1,"video data channel=%0d scenario=%0d word=%0d expected=%h got=%h",k,scenario,count[k],expected_data,data[k]);
|
||||
end
|
||||
count[k]=count[k]+1;
|
||||
end
|
||||
end
|
||||
task line(input [24:0] a,input [6:0] o,input c,input [3:0] h,input w,input busy_cpu);
|
||||
integer timeout,j;
|
||||
begin
|
||||
@(negedge clk);#1;hborder=0;checking=0;
|
||||
base=a;offset=o;coco1=c;hres=h;wide=w;contention=busy_cpu;
|
||||
repeat(25) @(negedge clk);
|
||||
#1;count[0]=0;count[1]=0;limit=w?320:160;checking=1;hborder=1;
|
||||
timeout=0;
|
||||
while((state[0]!==10 || state[1]!==10) && timeout<12000) begin
|
||||
@(negedge clk);timeout=timeout+1;
|
||||
end
|
||||
if(timeout==12000) $fatal(1,"line fetch timeout scenario=%0d",scenario);
|
||||
repeat(20) @(negedge clk);
|
||||
#1;checking=0;
|
||||
if(count[0]<limit || count[0]!==count[1]) $fatal(1,"line length mismatch %0d %0d",count[0],count[1]);
|
||||
for(j=0;j<count[0];j=j+1) if(reference_data[j]!==candidate_data[j]) $fatal(1,"baseline/candidate mismatch word=%0d",j);
|
||||
total_words=total_words+count[1];scenario=scenario+1;
|
||||
end
|
||||
endtask
|
||||
integer mode,off,trial;
|
||||
initial begin
|
||||
count[0]=0;count[1]=0;
|
||||
repeat(8) @(negedge clk);#1;reset=0;
|
||||
repeat(26000) @(negedge clk);
|
||||
// Address carry boundaries, all mode bits, odd/even starts, 256/1024-byte
|
||||
// wrapping and both fetch widths; CPU activity exercises arbitration.
|
||||
for(mode=0;mode<32;mode=mode+1)
|
||||
for(off=0;off<4;off=off+1)
|
||||
line((mode%4==0)?25'h1fffffe:((mode%4==1)?25'h07ffffe:25'h00003fe),
|
||||
(off<2)?off:(126+off-2),mode[4],mode[3:0],mode[0],mode[1]);
|
||||
for(trial=0;trial<48;trial=trial+1)
|
||||
line($random & 25'h1fffffe,$random,$random,$random,$random,1);
|
||||
if(cpu_reads[0]<10 || cpu_reads[1]<10 || refreshes[0]<3 || refreshes[1]<3)
|
||||
$fatal(1,"contention/refresh not exercised");
|
||||
$display("PASS %0d lines / %0d buffered words: baseline equivalence, address-derived data, mode/offset/wrap, CPU contention, refresh",scenario,total_words);
|
||||
// Abort a line at several phases. Reset the actual fetch/controller and
|
||||
// retain the production-length SDRAM startup, then fetch anew.
|
||||
for(trial=0;trial<4;trial=trial+1) begin
|
||||
@(negedge clk);#1;hborder=0;
|
||||
repeat(30) @(negedge clk);#1;hborder=1;
|
||||
repeat(3+trial*7) @(negedge clk);#1;reset=1;hborder=0;
|
||||
repeat(4) @(negedge clk);#1;reset=0;
|
||||
repeat(26000) @(negedge clk);
|
||||
line(25'h01ffffe,trial[6:0],0,8,1,1);
|
||||
end
|
||||
$display("PASS four active-line reset/reinitialization phases; %0d total lines",scenario);
|
||||
$finish;
|
||||
end
|
||||
initial begin #30000000;$fatal(1,"video regression timeout");end
|
||||
endmodule
|
||||
Reference in new issue
Block a user