// PentEvo project (c) NedoPC 2008-2010
//
// most of pentevo ports are here
`include "../include/tune.v"
module zports(
input wire zclk, // z80 clock
input wire fclk, // global FPGA clock
input wire rst_n, // system reset
input wire zpos,
input wire zneg,
input wire [ 7:0] din,
output reg [ 7:0] dout,
output wire dataout,
input wire [15:0] a,
input wire iorq_n,
input wire mreq_n,
input wire m1_n,
input wire rd_n,
input wire wr_n,
output reg porthit, // when internal port hit occurs, this is 1, else 0; used for iorq1_n iorq2_n on zxbus
output wire [15:0] ideout,
input wire [15:0] idein,
output wire idedataout, // IDE must IN data from IDE device when idedataout=0, else it OUTs
output wire [ 2:0] ide_a,
output wire ide_cs0_n,
output wire ide_cs1_n,
output wire ide_rd_n,
output wire ide_wr_n,
input wire [ 4:0] keys_in, // keys (port FE)
input wire [ 7:0] mus_in, // mouse (xxDF)
input wire [ 4:0] kj_in,
output reg [ 2:0] border,
output reg beep,
input wire dos,
output wire ay_bdir,
output wire ay_bc1,
output wire [ 7:0] p7ffd,
output wire [ 7:0] peff7,
input wire [ 1:0] rstrom,
input wire tape_read,
output wire vg_cs_n,
input wire vg_intrq,
input wire vg_drq, // from vg93 module - drq + irq read
output wire vg_wrFF, // write strobe of #FF port
output reg sdcs_n,
output wire sd_start,
output wire [ 7:0] sd_datain,
input wire [ 7:0] sd_dataout,
// WAIT-ports related
//
output reg [ 7:0] gluclock_addr,
//
output reg [ 2:0] comport_addr,
//
output wire wait_start_gluclock, // begin wait from some ports
output wire wait_start_comport, //
//
output reg wait_rnw, // whether it was read(=1) or write(=0)
output reg [ 7:0] wait_write,
input wire [ 7:0] wait_read,
output wire atmF7_wr_fclk, // used in atm_pager.v
output reg [ 2:0] atm_scr_mode, // RG0..RG2 in docs
output reg atm_turbo, // turbo mode ON
output reg atm_pen, // pager_off in atm_pager.v, NOT inverted!!!
output reg atm_cpm_n, // permanent dos on
output reg atm_pen2, // PEN2 - fucking palette mode, NOT inverted!!!
output wire romrw_en, // from port BF
output wire pent1m_ram0_0, // d3.eff7
output wire pent1m_1m_on, // d2.eff7
output wire [ 5:0] pent1m_page, // full 1 meg page number
output wire pent1m_ROM // d4.7ffd
);
reg rstsync1,rstsync2;
localparam PORTFE = 8'hFE;
localparam PORTF7 = 8'hF7;
localparam NIDE10 = 8'h10;
localparam NIDE11 = 8'h11;
localparam NIDE30 = 8'h30;
localparam NIDE50 = 8'h50;
localparam NIDE70 = 8'h70;
localparam NIDE90 = 8'h90;
localparam NIDEB0 = 8'hB0;
localparam NIDED0 = 8'hD0;
localparam NIDEF0 = 8'hF0;
localparam NIDEC8 = 8'hC8;
localparam PORTFD = 8'hFD;
localparam VGCOM = 8'h1F;
localparam VGTRK = 8'h3F;
localparam VGSEC = 8'h5F;
localparam VGDAT = 8'h7F;
localparam VGSYS = 8'hFF;
localparam KJOY = 8'h1F;
localparam KMOUSE = 8'hDF;
localparam SDCFG = 8'h77;
localparam SDDAT = 8'h57;
localparam ATMF7 = 8'hF7;
localparam ATM77 = 8'h77;
localparam ZXEVBF = 8'hBF; // xxBF config port
localparam COMPORT = 8'hEF; // F8EF..FFEF - rs232 ports
reg external_port;
reg port_wr;
reg port_rd;
reg iowr_reg;
reg iord_reg;
reg port_wr_fclk,
port_rd_fclk;
reg [1:0] iowr_reg_fclk,
iord_reg_fclk;
wire [7:0] loa;
wire portfe_wr;
wire ideout_hi_wr;
wire idein_lo_rd;
reg [7:0] idehiin; // IDE high part read register: low part is read directly to Z80 bus,
// while high part is remembered here
reg ide_ports; // ide ports selected
reg ide_rd_trig; // nemo-divide read trigger
reg ide_rd_latch; // to save state of trigger during read cycle
reg ide_wrlo_trig, ide_wrhi_trig; // nemo-divide write triggers
reg ide_wrlo_latch, ide_wrhi_latch; // save state during write cycles
reg [15:0] idewrreg; // write register, either low or high part is pre-written here,
// while other part is out directly from Z80 bus
wire [ 7:0] iderdeven; // to control read data from "even" ide ports (all except #11)
wire [ 7:0] iderdodd; // read data from "odd" port (#11)
reg pre_bc1,pre_bdir;
wire gluclock_on;
reg shadow_en_reg; //bit0.xxBF
reg romrw_en_reg; //bit1.xxBF
wire shadow;
assign shadow = dos || shadow_en_reg;
assign loa=a[7:0];
always @*
begin
if( (loa==PORTFE) ||
(loa==PORTFD) ||
(loa==NIDE10) || (loa==NIDE11) || (loa==NIDE30) || (loa==NIDE50) || (loa==NIDE70) ||
(loa==NIDE90) || (loa==NIDEB0) || (loa==NIDED0) || (loa==NIDEF0) || (loa==NIDEC8) ||
(loa==KMOUSE) ||
( (loa==VGCOM)&&shadow ) || ( (loa==VGTRK)&&shadow ) || ( (loa==VGSEC)&&shadow ) || ( (loa==VGDAT)&&shadow ) ||
( (loa==VGSYS)&&shadow ) || ( (loa==KJOY)&&(!shadow) ) ||
( (loa==PORTF7)&&(!shadow) ) || ( (loa==SDCFG)&&(!shadow) ) || ( (loa==SDDAT) ) ||
( (loa==ATMF7)&&shadow ) || ( (loa==ATM77)&&shadow ) ||
( loa==ZXEVBF ) || ( loa==COMPORT )
)
porthit = 1'b1;
else
porthit = 1'b0;
end
always @*
begin
if( ((loa==PORTFD) && (a[15:14]==2'b11)) || // 0xFFFD ports
(( (loa==VGCOM)&&shadow ) || ( (loa==VGTRK)&&shadow ) || ( (loa==VGSEC)&&shadow ) || ( (loa==VGDAT)&&shadow )) ) // vg93 ports
external_port = 1'b1;
else
external_port = 1'b0;
end
assign dataout = porthit & (~iorq_n) & (~rd_n) & (~external_port);
// this is zclk-synchronous strobes
always @(posedge zclk)
begin
iowr_reg <= ~(iorq_n | wr_n);
iord_reg <= ~(iorq_n | rd_n);
if( (!iowr_reg) && (!iorq_n) && (!wr_n) )
port_wr <= 1'b1;
else
port_wr <= 1'b0;
if( (!iord_reg) && (!iorq_n) && (!rd_n) )
port_rd <= 1'b1;
else
port_rd <= 1'b0;
end
// fclk-synchronous stobes
//
always @(posedge fclk) if( zpos )
begin
iowr_reg_fclk[0] <= ~(iorq_n | wr_n);
iord_reg_fclk[0] <= ~(iorq_n | rd_n);
end
always @(posedge fclk)
begin
iowr_reg_fclk[1] <= iowr_reg_fclk[0];
iord_reg_fclk[1] <= iord_reg_fclk[0];
end
always @(posedge fclk)
begin
port_wr_fclk <= iowr_reg_fclk[0] && (!iowr_reg_fclk[1]);
port_rd_fclk <= iord_reg_fclk[0] && (!iord_reg_fclk[1]);
end
// dout data
always @*
begin
case( loa )
PORTFE:
dout = { 1'b1, tape_read, 1'b0, keys_in };
NIDE10,NIDE30,NIDE50,NIDE70,NIDE90,NIDEB0,NIDED0,NIDEF0,NIDEC8:
dout = iderdeven;
NIDE11:
dout = iderdodd;
//PORTFD:
VGSYS:
dout = { vg_intrq, vg_drq, 6'b111111 };
KJOY:
dout = {3'b000, kj_in};
KMOUSE:
dout = mus_in;
SDCFG:
dout = 8'h00; // always SD inserted, SD is in R/W mode
SDDAT:
dout = sd_dataout;
PORTF7: begin
if( !a[14] && gluclock_on ) // $BFF7 - data i/o
dout = wait_read;
else // any other $xxF7 port
dout = 8'hFF;
end
COMPORT: begin
dout = wait_read; // $F8EF..$FFEF
end
default:
dout = 8'hFF;
endcase
end
assign portfe_wr = ( (loa==PORTFE) && port_wr);
assign portfd_wr = ( (loa==PORTFD) && port_wr);
assign portf7_wr = ( (loa==PORTF7) && port_wr && (!shadow) );
assign portf7_rd = ( (loa==PORTF7) && port_rd && (!shadow) );
assign vg_wrFF = ( ( (loa==VGSYS)&&shadow ) && port_wr);
assign comport_wr = ( (loa==COMPORT) && port_wr);
assign comport_rd = ( (loa==COMPORT) && port_rd);
//port FE beep/border bit
always @(posedge zclk)
begin
if( portfe_wr )
begin
beep <= din[4]^din[3]; // beeper and tapeout in the same bit
border <= din[2:0];
end
end
// IDE ports
// IDE physical ports (that go to IDE device)
always @(loa)
case( loa )
NIDE10,NIDE30,NIDE50,NIDE70,NIDE90,NIDEB0,NIDED0,NIDEF0,NIDEC8: ide_ports = 1'b1;
default: ide_ports = 1'b0;
endcase
assign idein_lo_rd = port_rd && (loa==NIDE10) && (!ide_rd_trig);
// control read & write triggers, which allow nemo-divide mod to work.
//
// read trigger:
always @(posedge zclk)
begin
if( (loa==NIDE10) && port_rd && !ide_rd_trig )
ide_rd_trig <= 1'b1;
else if( ( ide_ports || (loa==NIDE11) ) && ( port_rd || port_wr ) )
ide_rd_trig <= 1'b0;
end
//
// two triggers for write sequence...
always @(posedge zclk)
if( ( ide_ports || (loa==NIDE11) ) && ( port_rd || port_wr ) )
begin
if( (loa==NIDE11) && port_wr )
ide_wrhi_trig <= 1'b1;
else
ide_wrhi_trig <= 1'b0;
//
if( (loa==NIDE10) && port_wr && !ide_wrhi_trig && !ide_wrlo_trig )
ide_wrlo_trig <= 1'b1;
else
ide_wrlo_trig <= 1'b0;
end
// normal read: #10(low), #11(high)
// divide read: #10(low), #10(high)
//
// normal write: #11(high), #10(low)
// divide write: #10(low), #10(high)
always @(posedge zclk)
begin
if( port_wr && (loa==NIDE11) )
idewrreg[15:8] <= din;
if( port_wr && (loa==NIDE10) && !ide_wrlo_trig )
idewrreg[ 7:0] <= din;
end
always @(posedge zclk)
if( idein_lo_rd )
idehiin <= idein[15:8];
assign ide_a = a[7:5];
// This is unknown shit... Probably need more testing with old WD
// drives WITHOUT this commented fix.
//
// trying to fix old WD drives...
//assign ide_cs0_n = iorq_n | (rd_n&wr_n) | (~ide_ports) | (~(loa!=NIDEC8));
//assign ide_cs1_n = iorq_n | (rd_n&wr_n) | (~ide_ports) | (~(loa==NIDEC8));
// fix ends...
assign ide_cs0_n = (~ide_ports) | (~(loa!=NIDEC8));
assign ide_cs1_n = (~ide_ports) | (~(loa==NIDEC8));
// generate read cycles for IDE as usual, except for reading #10
// instead of #11 for high byte (nemo-divide). I use additional latch
// since 'ide_rd_trig' clears during second Z80 IO read cycle to #10
always @* if( rd_n ) ide_rd_latch <= ide_rd_trig;
//
assign ide_rd_n = iorq_n | rd_n | (~ide_ports) | (ide_rd_latch && (loa==NIDE10));
always @* if( wr_n ) ide_wrlo_latch <= ide_wrlo_trig; // same for write triggers
always @* if( wr_n ) ide_wrhi_latch <= ide_wrhi_trig; //
//
assign ide_wr_n = iorq_n | wr_n | (~ide_ports) | ( (loa==NIDE10) && !ide_wrlo_latch && !ide_wrhi_latch );
// do NOT generate IDE write, if neither of ide_wrhi|lo latches
// set and writing to NIDE10
assign idedataout = ide_rd_n;
// data read by Z80 from IDE
//
assign iderdodd[ 7:0] = idehiin[ 7:0];
//
assign iderdeven[ 7:0] = (ide_rd_latch && (loa==NIDE10)) ? idehiin[ 7:0] : idein[ 7:0];
// data written to IDE from Z80
//
assign ideout[15:8] = ide_wrhi_latch ? idewrreg[15:8] : din[ 7:0];
assign ideout[ 7:0] = ide_wrlo_latch ? idewrreg[ 7:0] : din[ 7:0];
// AY control
always @*
begin
pre_bc1 = 1'b0;
pre_bdir = 1'b0;
if( loa==PORTFD )
begin
if( a[15:14]==2'b11 )
begin
pre_bc1=1'b1;
pre_bdir=1'b1;
end
else if( a[15:14]==2'b10 )
begin
pre_bc1=1'b0;
pre_bdir=1'b1;
end
end
end
assign ay_bc1 = pre_bc1 & (~iorq_n) & ((~rd_n)|(~wr_n));
assign ay_bdir = pre_bdir & (~iorq_n) & (~wr_n);
// 7FFD port
reg [7:0] p7ffd_int,peff7_int;
reg p7ffd_rom_int;
wire block7ffd;
wire block1m;
always @(posedge zclk, negedge rst_n)
begin
if( !rst_n )
p7ffd_int <= 7'h00;
else if( (a[15]==1'b0) && portfd_wr && (!block7ffd) )
p7ffd_int <= din; // 2..0 - page, 3 - screen, 4 - rom, 5 - block48k, 6..7 -
end
always @(posedge zclk)
begin
if( rstsync2 )
p7ffd_rom_int <= rstrom[0];
else if( (a[15]==1'b0) && portfd_wr && (!block7ffd) )
p7ffd_rom_int <= din[4];
end
assign block7ffd=p7ffd_int[5] & block1m;
// EFF7 port
always @(posedge zclk, negedge rst_n)
begin
if( !rst_n )
peff7_int <= 8'h00;
else if( !a[12] && portf7_wr )
peff7_int <= din; // 4 - turbooff, 0 - p16c on, 2 - block1meg
end
assign block1m = peff7_int[2];
assign p7ffd = { (block1m ? 3'b0 : p7ffd_int[7:5]),p7ffd_rom_int,p7ffd_int[3:0]};
assign peff7 = block1m ? { peff7_int[7], 1'b0, peff7_int[5], peff7_int[4], 3'b000, peff7_int[0] } : peff7_int;
assign pent1m_ROM = p7ffd_int[4];
assign pent1m_page[5:0] = { p7ffd_int[7:5], p7ffd_int[2:0] };
assign pent1m_1m_on = ~peff7_int[2];
assign pent1m_ram0_0 = peff7_int[3];
// gluclock ports (bit7:eff7 is above)
assign gluclock_on = peff7_int[7];
always @(posedge zclk)
begin
if( gluclock_on && portf7_wr ) // gluclocks on
begin
if( !a[13] ) // $DFF7 - addr reg
gluclock_addr <= din;
// write to waiting register is not here - in separate section managing wait_write
end
end
// comports
always @(posedge zclk)
begin
if( comport_wr || comport_rd )
comport_addr <= a[10:8 ];
end
// write to wait registers
always @(posedge zclk)
begin
// gluclocks
if( gluclock_on && portf7_wr && !a[14] ) // $BFF7 - data reg
wait_write <= din;
// com ports
else if( comport_wr ) // $F8EF..$FFEF - comports
wait_write <= din;
end
// wait from wait registers
//
// ACHTUNG!!!! here portxx_wr are ON Z80 CLOCK! logic must change when moving to fclk strobes
//
assign wait_start_gluclock = ( (!shadow) && gluclock_on && !a[14] && (portf7_rd || portf7_wr) ); // $BFF7 - gluclock r/w
//
assign wait_start_comport = ( comport_rd || comport_wr );
//
//
always @(posedge zclk) // wait rnw - only meanful during wait
begin
if( port_wr )
wait_rnw <= 1'b0;
if( port_rd )
wait_rnw <= 1'b1;
end
// VG93 control
assign vg_cs_n = (~shadow) | iorq_n | (rd_n & wr_n) | ( ~((loa==VGCOM)|(loa==VGTRK)|(loa==VGSEC)|(loa==VGDAT)) );
// reset rom selection
always @(posedge zclk)
begin
rstsync1<=~rst_n;
rstsync2<=rstsync1;
end
// SD card (z-controlâ••r compatible)
wire sdcfg_wr,sddat_wr,sddat_rd;
assign sdcfg_wr = ( (loa==SDCFG) && port_wr && (!shadow) ) ||
( (loa==SDDAT) && port_wr && shadow && (a[15]==1'b1) ) ;
assign sddat_wr = ( (loa==SDDAT) && port_wr && (!shadow) ) ||
( (loa==SDDAT) && port_wr && shadow && (a[15]==1'b0) ) ;
assign sddat_rd = ( (loa==SDDAT) && port_rd );
// SDCFG write - sdcs_n control
always @(posedge zclk, negedge rst_n)
begin
if( !rst_n )
sdcs_n <= 1'b1;
else // posedge zclk
if( sdcfg_wr )
sdcs_n <= din[1];
end
// start signal for SPI module with resyncing to fclk
reg sd_start_toggle;
reg [2:0] sd_stgl;
// Z80 clock
always @(posedge zclk)
if( sddat_wr || sddat_rd )
sd_start_toggle <= ~sd_start_toggle;
// FPGA clock
always @(posedge fclk)
sd_stgl[2:0] <= { sd_stgl[1:0], sd_start_toggle };
assign sd_start = ( sd_stgl[1] != sd_stgl[2] );
// data for SPI module
assign sd_datain = wr_n ? 8'hFF : din;
/////////////////////////////////////////////////////////////////////////////////////////////////
///////////////
// ATM ports //
///////////////
wire atm77_wr_fclk;
wire zxevbf_wr_fclk;
assign atmF7_wr_fclk = ( (loa==ATMF7) && shadow && port_wr_fclk );
assign atm77_wr_fclk = ( (loa==ATM77) && shadow && port_wr_fclk );
assign zxevbf_wr_fclk = ( (loa==ZXEVBF) && port_wr_fclk );
// port BF write
//
always @(posedge fclk, negedge rst_n)
if( !rst_n )
begin
shadow_en_reg = 1'b0;
romrw_en_reg = 1'b0;
end
else if( zxevbf_wr_fclk )
begin
shadow_en_reg <= din[0];
romrw_en_reg <= din[1];
end
assign romrw_en = romrw_en_reg;
// port xx77 write
always @(posedge fclk, negedge rst_n)
if( !rst_n )
begin
atm_scr_mode = 3'b011;
atm_turbo = 1'b1;
atm_pen = 1'b0; // UNLIKE ATM - reset with normal ROMs! (TEMPORARY???)
atm_cpm_n = 1'b1; // no permanent dos
atm_pen2 = 1'b0;
end
else if( atm77_wr_fclk )
begin
atm_scr_mode <= din[2:0];
atm_turbo <= din[3];
atm_pen <= ~a[8];
atm_cpm_n <= a[9];
atm_pen2 <= ~a[14];
end
endmodule