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:
bholman committed 2026-11-18 16:00:45 -07:00
1 parent 8b8cf72d1f
commit cb40fed3b9
126 files changed
+12795 -528

No files matched your search

+120
View File
@@ -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
+57
View File
@@ -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
+148
View File
@@ -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
+34
View File
@@ -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
+48
View File
@@ -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
+32
View File
@@ -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
+80
View File
@@ -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
+61
View File
@@ -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
+40
View File
@@ -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
+87
View File
@@ -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
+87
View File
@@ -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
+26
View File
@@ -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
+63
View File
@@ -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
+36
View File
@@ -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
+92
View File
@@ -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
+33
View File
@@ -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()
+206
View File
@@ -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()
+198
View File
@@ -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