Files
CoCo3_Plus_MiSTer/rtl/sdc_top.sv
T
bholman cb40fed3b9 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.
2026-11-18 16:00:45 -07:00

589 lines
15 KiB
Systemverilog

// Original Coco 3 Plus contributions: Copyright (c) 2026 Brian K. Holman.
// Original component notices/terms retained; see COPYRIGHT.md and LICENSING.md.
////////////////////////////////////////////////////////////////////////////////
// Project Name: COCO3 Targeting MISTer
// File Name: sdc_top.sv
//
// CoCo SDC TOP Controller for MISTer
//
////////////////////////////////////////////////////////////////////////////////
//
//
// CoCo SDC TOP Controller (sdc_top.sv) by Stan Hodge ([email protected])
// Copyright (c) 2022 by Stan Hodge ([email protected])
//
// All rights reserved
// Redistribution and use in source and synthezised forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// Redistributions in synthesized form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// Neither the name of the author nor the names of other contributors may
// be used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Please report bugs to the author, but before you do so, please
// make sure that this is not a derivative work and that
// you have the latest version of this file.
//
// This is a full FDC controller for 2 floppy drives. It also has a 2 drive
// cocosdc imbedded. When booting with a superfloppy, the floppy portion
// of this controller will be shutdown and the normal 4 drive fdc will take
// over dfc on a different mpi slot.
//
// Ver 2.00 Implemented with single 1793 ...
//
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
module sdc_top(
input CLK, // clock
input RESET_N, // async reset
input [3:0] ADDRESS, // i/o port addr [extended for coco]
input CLK_EN,
input [7:0] DATA_IN, // data in
output [7:0] DATA_HDD, // data out
output HALT, // DMA request
output NMI_09,
// FDC host r/w handling
input FF40_CLK, // FDC Write support
input FF40_ENA,
input SDC_EN_CS, // FDC Read Data support
input WD1793_RD,
input WD1793_WR_CTRL, // 1793 RD & WR control signal generation
input WD1793_RD_CTRL,
// SDC I/O
input SDC_REG_W_ENA,
input SDC_REG_READ,
output ext_response,
// SD block level interface
input [1:0] img_mounted, // signaling that new image has been mounted
input img_readonly, // mounted as read only. valid only for active bit in img_mounted
input [63:0] img_size, // size of image in bytes.
output [31:0] sd_lba[2],
output [5:0] sd_blk_cnt[2], // number of blocks-1, total size ((sd_blk_cnt+1)*(1<<(BLKSZ+7))) must be <= 16384!
output reg [1:0] sd_rd,
output reg [1:0] sd_wr,
input [1:0] sd_ack,
// SD byte level access. Signals for 2-PORT altsyncram.
input [8:0] sd_buff_addr,
input [7:0] sd_buff_dout,
output [7:0] sd_buff_din[2],
input sd_buff_wr
);
wire [7:0] DRIVE_SEL_EXT;
wire MOTOR;
wire WRT_PREC;
wire DENSITY;
wire HALT_EN;
// Diagnostics only
//assign probe = {2'd0, HALT_EN_RST, sd_buff_wr, WR[0], RD[0], HALT_EN, HALT};
// Generate a 8.333 Mhz enable for the fdc... and control writes
wire ena_8Mhz;
wire [5:0] div_8mhz;
assign ena_8Mhz = (div_8mhz == 6'd5) ? 1'b1: 1'b0;
// Research: local positive-edge reset release for the WD1793 banks.
(* preserve *) reg [1:0] wd_reset_release = 2'b00;
always @(posedge CLK or negedge RESET_N)
if (!RESET_N) wd_reset_release <= 2'b00;
else wd_reset_release <= {wd_reset_release[0], 1'b1};
always@(negedge CLK or negedge RESET_N)
begin
if (~RESET_N) div_8mhz <= 6'd0;
else
begin
if (ena_8Mhz)
div_8mhz <= 6'd0;
else
div_8mhz <= div_8mhz + 6'd1;
end
end
localparam SDC_MAGIC_CMD = 8'h43;
wire sdc_always;
wire [7:0] FF40_READ_VALUE = {HALT_EN, DRIVE_SEL_EXT[3], DENSITY, WRT_PREC, MOTOR, DRIVE_SEL_EXT[2:0]};
wire SDC_EN = ((FF40_READ_VALUE == SDC_MAGIC_CMD) | sdc_always);
wire [7:0] SDC_READ_DATA;
wire FF40_RD = ({SDC_EN_CS, ADDRESS[3:0]} == 5'b10000);
//FDC read data path. =$ff40 or wd1793(s)
assign DATA_HDD =
(FF40_RD) ? FF40_READ_VALUE:
(SDC_EN | ext_response) ? SDC_READ_DATA:
(SDC_EN_CS & (ADDRESS[3:1] == 3'b001)) ? SDC_READ_DATA: // FF42 & FF43
(WD1793_RD) ? DATA_1793: //(1793[s])
8'h00;
wire [31:0] sdc_sd_lba[2];
wire [31:0] fdc_sd_lba[2];
wire [1:0] sdc_sd_rd;
wire [1:0] fdc_sd_rd;
wire [1:0] sdc_sd_wr;
wire [1:0] fdc_sd_wr;
wire [7:0] sdc_sd_buff_din[2];
wire [7:0] fdc_sd_buff_din[2];
wire [7:0] wd1793_sd_buff_din;
wire sdc_HALT;
assign sd_lba[0:1] = SDC_EN ? sdc_sd_lba[0:1]:
fdc_sd_lba[0:1];
assign sd_rd[1:0] = SDC_EN ? sdc_sd_rd[1:0]:
fdc_sd_rd[1:0];
assign sd_wr[1:0] = SDC_EN ? sdc_sd_wr[1:0]:
fdc_sd_wr[1:0];
assign sd_buff_din[0:1] = SDC_EN ? sdc_sd_buff_din[0:1]:
fdc_sd_buff_din[0:1];
sdc coco_sdc(
.CLK(CLK), // clock
.RESET_N(RESET_N), // async reset
.ADDRESS(ADDRESS), // i/o port addr [extended for coco]
.SDC_DATA_IN(DATA_IN), // data in
.SDC_READ_DATA(SDC_READ_DATA), // data out
.SDC_EN(SDC_EN), // SDC is active [input to sdc]
.CLK_EN(CLK_EN),
.SDC_WR(SDC_REG_W_ENA),
.SDC_RD(SDC_REG_READ),
.sdc_HALT(sdc_HALT),
.ext_response(ext_response),
.sdc_always(sdc_always),
// SD block level interface
.sd_lba(sdc_sd_lba[0:1]),
.sd_rd(sdc_sd_rd[1:0]),
.sd_wr(sdc_sd_wr[1:0]),
.sd_ack(sd_ack[1:0]),
// Drive descripters
.drive_wp(drive_wp),
.drive_ready(drive_ready),
.drive_size(drive_size[0:1]),
// SD byte level access. Signals for 2-PORT altsyncram.
.sd_buff_addr(sd_buff_addr),
.sd_buff_dout(sd_buff_dout),
.sd_buff_din(sdc_sd_buff_din[0:1]),
.sd_buff_wr(sd_buff_wr)
);
// $ff40 control register [part 1]
wire [3:0] DRIVE_SEL_EXT_PRE = {DATA_IN[6] // Side Select
, DATA_IN[2:0]}; // ONLY 2 drives (DS)
reg [2:0] drive_index;
// SD blk system is a array of 4 systems - one for each drive.
// 'drive_index' identifies which controller is addressd.
// drive 1-2 for the sdc is denoted as 1 , 2 [0 is no drive selected]
always @(negedge FF40_CLK or negedge RESET_N)
begin
if(!RESET_N)
begin
DRIVE_SEL_EXT <= 8'h00;
MOTOR <= 1'b0;
WRT_PREC <= 1'b0;
DENSITY <= 1'b0;
drive_index <= 3'd0;
end
else
begin
if (FF40_ENA)
begin
DRIVE_SEL_EXT <= {4'b0000, DRIVE_SEL_EXT_PRE};
MOTOR <= DATA_IN[3]; // Turn on motor, not used here just checked, 0=MotorOff 1=MotorOn
WRT_PREC <= DATA_IN[4]; // Write Precompensation, not used here
DENSITY <= DATA_IN[5]; // Density, not used here just checked
case(DRIVE_SEL_EXT_PRE)
4'b0010:
drive_index <= 3'd2;
4'b0001:
drive_index <= 3'd1;
4'b1010:
drive_index <= 3'd2;
4'b1001:
drive_index <= 3'd1;
4'b1011: // This is what the Magic Number $43 does so we select a non-active drive
drive_index <= 3'd1;
4'b1000: // This is no drive with DS = illegal drive
drive_index <= 3'd1;
4'b0000: // This is no drive (maybe 0 in ff40) = illegal drive
drive_index <= 3'd1;
default:
drive_index <= 3'd1;
endcase
end
end
end
// $ff40 control register [part 2]
always @(negedge FF40_CLK or negedge HALT_EN_RST)
begin
if(!HALT_EN_RST)
begin
HALT_EN <= 1'b0;
end
else
begin
if (FF40_ENA)
begin
HALT_EN <= DATA_IN[7]; // Normal Halt enable, 0=Disabled 1=Enabled
if (sdc_always)
HALT_EN <= 1'b0;
end
end
end
// Control signals for the wd1793
wire INTRQ[2];
wire DRQ[2];
wire selected_DRQ;
wire selected_INTRQ;
wire WR[2];
wire RD[2];
wire RD_E[2];
wire HALT_EN_RST;
wire [7:0] DATA_1793;
wire [7:0] dout[2];
reg read;
reg write;
reg read_d;
reg write_d;
reg [7:0] DATA_IN_L;
reg r_w_active;
reg clk_8Mhz_enable_found;
reg read1;
reg write1;
reg [1:0] ADDRESS_L;
assign RD[0] = (read || RD_E[0]) && (drive_index == 2'd1);
assign RD[1] = (read || RD_E[1]) && (drive_index == 3'd2);
// The idea here is to "stretch" the CPU read and write signals to ensure we catch a 8 mhz enable.
// For writes we will buffer the data out to ensure it does not go away.
// For reads it is expected that data is available asynchronusly at the cpu rate and the only reason to catch a
// 8Mhz edge is to update pointer and misc flags.
// This is very nasty code and will likely only work with the present CPU timing.
// It is heavily dependant on address and write data being available just after
// the previous cycle.
wire wd1793_r_w_sync_rst = RESET_N;
always @(negedge CLK or negedge wd1793_r_w_sync_rst)
begin
if(!wd1793_r_w_sync_rst)
begin
read_d <= 1'b0;
write_d <= 1'b0;
r_w_active <= 1'b0;
clk_8Mhz_enable_found <= 1'b0;
WR[0] <= 1'b0;
WR[1] <= 1'b0;
RD_E[0] <= 1'b0;
RD_E[1] <= 1'b0;
read1 <= 1'b0;
write1 <= 1'b0;
read <= 1'b0;
write <= 1'b0;
end
else
begin
// synchronizers
read1 <= WD1793_RD_CTRL & ~SDC_EN;
read <= read1;
write1 <= WD1793_WR_CTRL & ~SDC_EN;
write <= write1;
// delays for edge detection
read_d <= read;
write_d <= write;
if ((read1 & ~read) | (write1 & ~write))
begin
// Latch Address & Data
ADDRESS_L <= ADDRESS[1:0];
DATA_IN_L <= DATA_IN;
end
// Synchronus rising edge of write
if ((write == 1'b1) && (write_d == 1'b0))
begin
// Set Write
r_w_active <= 1'b1;
case (drive_index)
3'd1:
WR[0] <= 1'b1;
3'd2:
WR[1] <= 1'b1;
endcase
end
// Synchronus rising edge of read
if ((read == 1'b1) && (read_d == 1'b0))
begin
r_w_active <= 1'b1;
case (drive_index)
3'd1:
RD_E[0] <= 1'b1;
3'd2:
RD_E[1] <= 1'b1;
endcase
end
// Clears
if (ena_8Mhz && r_w_active)
clk_8Mhz_enable_found <= 1'b1;
// 1 50Mhz clock later...
if (clk_8Mhz_enable_found)
begin
clk_8Mhz_enable_found <= 1'b0;
r_w_active <= 1'b0;
WR[0] <= 1'b0;
WR[1] <= 1'b0;
RD_E[0] <= 1'b0;
RD_E[1] <= 1'b0;
end
end
end
// NMI from disk controller
// Selected INTRQ
assign selected_INTRQ = (drive_index == 3'd1) ? INTRQ[0]:
(drive_index == 3'd2) ? INTRQ[1]:
1'b0;
assign NMI_09 = ~SDC_EN & DENSITY & selected_INTRQ; // Send NMI if Double Density (Halt Mode)
// HALT from disk controller
// Selected DRQ
assign selected_DRQ = (drive_index == 3'd1) ? DRQ[0]:
(drive_index == 3'd2) ? DRQ[1]:
1'b1;
assign HALT = (~SDC_EN & HALT_EN & ~selected_DRQ) | sdc_HALT;
assign HALT_EN_RST = RESET_N & ~selected_INTRQ; // From controller schematic
// Data bus selection
assign DATA_1793 = (drive_index == 3'd1) ? dout[0]:
(drive_index == 3'd2) ? dout[1]:
8'd0;
// The SD_BLK interface and thus the wd1793 will allways transfer 1 blk. This is blk qty - 1 per spec.
assign sd_blk_cnt[1] = 6'd0;
assign sd_blk_cnt[0] = 6'd0;
reg drive_wp[2];
reg [1:0] drive_ready = 2'b00;
reg [1:0] double_sided = 2'b00;
reg [31:0] drive_size[2];
// As drives are mounted in MISTer this logic saves the write protect and generates ready for
// changing drives to the wd1793.
// This can also get the disk size to properly handle DS drives - TBD
// Reset of drive wp to a default of 1 removed because of persistance.
// Research: mount strobes are data from hps_io, not clock sources.
reg [1:0] img_mounted_d = 0;
always @(posedge CLK) img_mounted_d <= img_mounted;
reg [1:0] mount_pending = 0;
reg [1:0] mount_wp;
reg [1:0] mount_double_sided;
reg [31:0] mount_size[2];
always @(posedge CLK) mount_pending <= img_mounted_d & ~img_mounted;
// Drive 0
always @(posedge CLK)
begin
if (img_mounted_d[0] && !img_mounted[0])
begin
mount_wp[0] <= img_readonly;
mount_size[0] <= img_size[31:0]; //Size / 256 on [31:8]
mount_double_sided[0]<= (img_size > 64'd368600) & (img_size < 64'd740000);//20'd368640;
end
end
// Drive 1
always @(posedge CLK)
begin
if (img_mounted_d[1] && !img_mounted[1])
begin
mount_wp[1] <= img_readonly;
mount_size[1] <= img_size[31:0]; //Size / 256 on [31:8]
mount_double_sided[1]<= (img_size > 64'd368600) & (img_size < 64'd740000);//20'd368640;
end
end
// Research: commit metadata on consumer's falling phase after classification.
always @(negedge CLK) if (mount_pending[0]) begin
drive_wp[0] <= mount_wp[0];
drive_ready[0] <= 1'b1;
drive_size[0] <= mount_size[0];
double_sided[0] <= mount_double_sided[0];
end
always @(negedge CLK) if (mount_pending[1]) begin
drive_wp[1] <= mount_wp[1];
drive_ready[1] <= 1'b1;
drive_size[1] <= mount_size[1];
double_sided[1] <= mount_double_sided[1];
end
wd1793 #(1,0) coco_wd1793_sdc_0
(
.clk_sys(~CLK),
.ce(ena_8Mhz),
.reset(~wd_reset_release[1]),
.io_en(1'b1),
.rd(RD[0]),
.wr(WR[0]),
.addr(ADDRESS_L[1:0]),
.din(DATA_IN_L),
.dout(dout[0]),
.drq(DRQ[0]),
.intrq(INTRQ[0]),
.img_mounted(1'b0), // Not used when using _override
.img_mounted_overide(1'b1), // Load img_size and layout on each clock
.img_size(drive_size[0]),
.sd_lba(fdc_sd_lba[0]),
.sd_rd(fdc_sd_rd[0]),
.sd_wr(fdc_sd_wr[0]),
.sd_ack(sd_ack[0]),
.sd_buff_addr(sd_buff_addr),
.sd_buff_dout(sd_buff_dout),
.sd_buff_din(fdc_sd_buff_din[0]),
.sd_buff_wr(sd_buff_wr),
.wp(drive_wp[0]),
.size_code(3'd5), // 5 is 18 sector x 256 bits COCO standard
.layout(~double_sided[0]), // 0 = Track-Side-Sector, 1 - Side-Track-Sector
.side(double_sided[0] & DRIVE_SEL_EXT[3]),
.ready(drive_ready[0]),
.input_active(0), // Section not used
.input_addr(0),
.input_data(0),
.input_wr(0),
.buff_din(0)
);
wd1793 #(1,0) coco_wd1793_sdc_1
(
.clk_sys(~CLK),
.ce(ena_8Mhz),
.reset(~wd_reset_release[1]),
.io_en(1'b1),
.rd(RD[1]),
.wr(WR[1]),
.addr(ADDRESS_L[1:0]),
.din(DATA_IN_L),
.dout(dout[1]),
.drq(DRQ[1]),
.intrq(INTRQ[1]),
.img_mounted(1'b0), // Not used when using _override
.img_mounted_overide(1'b1), // Load img_size and layout on each clock
.img_size(drive_size[1]),
.sd_lba(fdc_sd_lba[1]),
.sd_rd(fdc_sd_rd[1]),
.sd_wr(fdc_sd_wr[1]),
.sd_ack(sd_ack[1]),
.sd_buff_addr(sd_buff_addr),
.sd_buff_dout(sd_buff_dout),
.sd_buff_din(fdc_sd_buff_din[1]),
.sd_buff_wr(sd_buff_wr),
.wp(drive_wp[1]),
.size_code(3'd5), // 5 is 18 sector x 256 bits COCO standard
.layout(~double_sided[1]), // 0 = Track-Side-Sector, 1 - Side-Track-Sector
.side(double_sided[1] & DRIVE_SEL_EXT[3]),
.ready(drive_ready[1]),
.input_active(0), // Section not used
.input_addr(0),
.input_data(0),
.input_wr(0),
.buff_din(0)
);
endmodule