804 lines
30 KiB
C
804 lines
30 KiB
C
/* zx-200a.c: Intel double density disk adapter adapter
|
|
|
|
Copyright (c) 2010, William A. Beech
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a
|
|
copy of this software and associated documentation files (the "Software"),
|
|
to deal in the Software without restriction, including without limitation
|
|
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
and/or sell copies of the Software, and to permit persons to whom the
|
|
Software is furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
WILLIAM A. BEECH BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
Except as contained in this notice, the name of William A. Beech shall not be
|
|
used in advertising or otherwise to promote the sale, use or other dealings
|
|
in this Software without prior written authorization from William A. Beech.
|
|
|
|
MODIFICATIONS:
|
|
|
|
28 Jun 16 - Original file.
|
|
|
|
NOTES:
|
|
|
|
This controller will mount 4 DD disk images on drives :F0: thru :F3: addressed
|
|
at ports 078H to 07FH. It also will mount 2 SD disk images on :F4: and :F5:
|
|
addressed at ports 088H to 08FH. These are on physical drives :F0: and :F1:.
|
|
|
|
Registers:
|
|
|
|
078H - Read - Subsystem status
|
|
bit 0 - ready status of drive 0
|
|
bit 1 - ready status of drive 1
|
|
bit 2 - state of channel's interrupt FF
|
|
bit 3 - controller presence indicator
|
|
bit 4 - DD controller presence indicator
|
|
bit 5 - ready status of drive 2
|
|
bit 6 - ready status of drive 3
|
|
bit 7 - zero
|
|
|
|
079H - Read - Read result type (bits 2-7 are zero)
|
|
00 - I/O complete with error
|
|
01 - Reserved
|
|
10 - Result byte contains diskette ready status
|
|
11 - Reserved
|
|
079H - Write - IOPB address low byte.
|
|
|
|
07AH - Write - IOPB address high byte and start operation.
|
|
|
|
07BH - Read - Read result byte
|
|
If result type is 00H
|
|
bit 0 - deleted record
|
|
bit 1 - CRC error
|
|
bit 2 - seek error
|
|
bit 3 - address error
|
|
bit 4 - data overrun/underrun
|
|
bit 5 - write protect
|
|
bit 6 - write error
|
|
bit 7 - not ready
|
|
If result type is 02H and ready has changed
|
|
bit 0 - zero
|
|
bit 1 - zero
|
|
bit 2 - zero
|
|
bit 3 - zero
|
|
bit 4 - drive 2 ready
|
|
bit 5 - drive 3 ready
|
|
bit 6 - drive 0 ready
|
|
bit 7 - drive 1 ready
|
|
else return 0
|
|
|
|
07FH - Write - Reset diskette system.
|
|
|
|
Operations:
|
|
NOP - 0x00
|
|
Seek - 0x01
|
|
Format Track - 0x02
|
|
Recalibrate - 0x03
|
|
Read Data - 0x04
|
|
Verify CRC - 0x05
|
|
Write Data - 0x06
|
|
Write Deleted Data - 0x07
|
|
|
|
IOPB - I/O Parameter Block
|
|
Byte 0 - Channel Word
|
|
bit 3 - data word length (=8-bit, 1=16-bit)
|
|
bit 4-5 - interrupt control
|
|
00 - I/O complete interrupt to be issued
|
|
01 - I/O complete interrupts are disabled
|
|
10 - illegal code
|
|
11 - illegal code
|
|
bit 6- randon format sequence
|
|
|
|
Byte 1 - Diskette Instruction
|
|
bit 0-2 - operation code
|
|
000 - no operation
|
|
001 - seek
|
|
010 - format track
|
|
011 - recalibrate
|
|
100 - read data
|
|
101 - verify CRC
|
|
110 - write data
|
|
111 - write deleted data
|
|
bit 3 - data word length ( same as byte-0, bit-3)
|
|
bit 4-5 - unit select
|
|
00 - drive 0
|
|
01 - drive 1
|
|
10 - drive 2
|
|
11 - drive 3
|
|
bit 6-7 - reserved (zero)
|
|
|
|
Byte 2 - Number of Records
|
|
|
|
Byte 4 - Track Address
|
|
|
|
Byte 5 - Sector Address
|
|
|
|
Byte 6 - Buffer Low Address
|
|
|
|
Byte 7 - Buffer High Address
|
|
|
|
u3 -
|
|
u4 -
|
|
u5 - fdc number (board instance number).
|
|
u6 - fdd number.
|
|
|
|
The ZX-200A appears to the multibus system as if there were an iSBC-201
|
|
installed addressed at 0x88-0x8f and an iSBC-202 installed addressed at
|
|
0x78-0x7F. The DD disks are drive 0 - 3. The SD disks are mapped over
|
|
DD disks 0 - 1. Thus drive 0 - 1 can be SD or DD, but not both. Drive
|
|
2 - 3 are always DD.
|
|
*/
|
|
|
|
#include "system_defs.h" /* system header in system dir */
|
|
|
|
#define DEBUG 0
|
|
|
|
#define UNIT_V_WPMODE (UNIT_V_UF) /* Write protect */
|
|
#define UNIT_WPMODE (1 << UNIT_V_WPMODE)
|
|
|
|
#define FDD_NUM 4
|
|
|
|
//disk controoler operations
|
|
#define DNOP 0x00 //disk no operation
|
|
#define DSEEK 0x01 //disk seek
|
|
#define DFMT 0x02 //disk format
|
|
#define DHOME 0x03 //disk home
|
|
#define DREAD 0x04 //disk read
|
|
#define DVCRC 0x05 //disk verify CRC
|
|
#define DWRITE 0x06 //disk write
|
|
|
|
//status
|
|
#define RDY0 0x01 //FDD 0 ready
|
|
#define RDY1 0x02 //FDD 1 ready
|
|
#define FDCINT 0x04 //FDC interrupt flag
|
|
#define FDCPRE 0x08 //FDC board present
|
|
#define FDCDD 0x10 //fdc is DD
|
|
#define RDY2 0x20 //FDD 2 ready
|
|
#define RDY3 0x40 //FDD 3 ready
|
|
|
|
//result type
|
|
#define RERR 0x00 //FDC returned error
|
|
#define ROK 0x02 //FDC returned ok
|
|
|
|
// If result type is RERR then rbyte is
|
|
#define RB0DR 0x01 //deleted record
|
|
#define RB0CRC 0x02 //CRC error
|
|
#define RB0SEK 0x04 //seek error
|
|
#define RB0ADR 0x08 //address error
|
|
#define RB0OU 0x10 //data overrun/underrun
|
|
#define RB0WP 0x20 //write protect
|
|
#define RB0WE 0x40 //write error
|
|
#define RB0NR 0x80 //not ready
|
|
|
|
// If result type is ROK then rbyte is
|
|
#define RB1RD2 0x10 //drive 2 ready
|
|
#define RB1RD3 0x20 //drive 3 ready
|
|
#define RB1RD0 0x40 //drive 0 ready
|
|
#define RB1RD1 0x80 //drive 1 ready
|
|
|
|
//disk geometry values
|
|
#define MDSSD 256256 //single density FDD size
|
|
#define MDSDD 512512 //double density FDD size
|
|
#define MAXSECSD 26 //single density last sector
|
|
#define MAXSECDD 52 //double density last sector
|
|
#define MAXTRK 76 //last track
|
|
|
|
/* external function prototypes */
|
|
|
|
extern uint16 reg_dev(uint8 (*routine)(t_bool, uint8), uint16, uint8);
|
|
extern uint8 multibus_get_mbyte(uint16 addr);
|
|
extern uint16 multibus_get_mword(uint16 addr);
|
|
extern void multibus_put_mbyte(uint16 addr, uint8 val);
|
|
extern uint8 multibus_put_mword(uint16 addr, uint16 val);
|
|
|
|
/* external globals */
|
|
|
|
extern uint16 port; //port called in dev_table[port]
|
|
extern int32 PCX;
|
|
|
|
/* internal function prototypes */
|
|
|
|
t_stat zx200a_reset(DEVICE *dptr, uint16 base);
|
|
void zx200a_reset1(uint8);
|
|
t_stat zx200a_attach (UNIT *uptr, CONST char *cptr);
|
|
t_stat zx200a_set_mode (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
|
|
uint8 zx200a0(t_bool io, uint8 data);
|
|
uint8 zx200a1(t_bool io, uint8 data);
|
|
uint8 zx200a2(t_bool io, uint8 data);
|
|
uint8 zx200a3(t_bool io, uint8 data);
|
|
uint8 zx200a7(t_bool io, uint8 data);
|
|
void zx200a_diskio(uint8 fdcnum);
|
|
|
|
/* globals */
|
|
|
|
int32 zx200a_fdcnum = 0; //actual number of ZX-200A instances + 1
|
|
|
|
typedef struct { //FDD definition
|
|
// uint8 *buf;
|
|
int t0;
|
|
int rdy;
|
|
uint8 sec;
|
|
uint8 cyl;
|
|
uint8 dd;
|
|
// uint8 maxsec;
|
|
// uint8 maxcyl;
|
|
} FDDDEF;
|
|
|
|
typedef struct { //FDC definition
|
|
uint16 baseport; //FDC base port
|
|
uint16 iopb; //FDC IOPB
|
|
uint8 stat; //FDC status
|
|
uint8 rdychg; //FDC ready change
|
|
uint8 rtype; //FDC result type
|
|
uint8 rbyte0; //FDC result byte for type 00
|
|
uint8 rbyte1; //FDC result byte for type 10
|
|
uint8 intff; //fdc interrupt FF
|
|
FDDDEF fdd[FDD_NUM]; //indexed by the FDD number
|
|
} FDCDEF;
|
|
|
|
FDCDEF zx200a[4]; //indexed by the zx200a instance number
|
|
|
|
UNIT zx200a_unit[] = {
|
|
{ UDATA (0, UNIT_ATTABLE+UNIT_DISABLE+UNIT_BUFABLE+UNIT_MUSTBUF, MDSDD), 20 },
|
|
{ UDATA (0, UNIT_ATTABLE+UNIT_DISABLE+UNIT_BUFABLE+UNIT_MUSTBUF, MDSDD), 20 },
|
|
{ UDATA (0, UNIT_ATTABLE+UNIT_DISABLE+UNIT_BUFABLE+UNIT_MUSTBUF, MDSDD), 20 },
|
|
{ UDATA (0, UNIT_ATTABLE+UNIT_DISABLE+UNIT_BUFABLE+UNIT_MUSTBUF, MDSDD), 20 }
|
|
};
|
|
|
|
REG zx200a_reg[] = {
|
|
{ HRDATA (STAT0, zx200a[0].stat, 8) }, /* zx200a 0 status */
|
|
{ HRDATA (RTYP0, zx200a[0].rtype, 8) }, /* zx200a 0 result type */
|
|
{ HRDATA (RBYT0A, zx200a[0].rbyte0, 8) }, /* zx200a 0 result byte 0 */
|
|
{ HRDATA (RBYT0B, zx200a[0].rbyte1, 8) }, /* zx200a 0 result byte 1 */
|
|
{ HRDATA (INTFF0, zx200a[0].intff, 8) }, /* zx200a 0 interrupt f/f */
|
|
{ HRDATA (STAT1, zx200a[1].stat, 8) }, /* zx200a 1 status */
|
|
{ HRDATA (RTYP1, zx200a[1].rtype, 8) }, /* zx200a 1 result type */
|
|
{ HRDATA (RBYT1A, zx200a[1].rbyte0, 8) }, /* zx200a 1 result byte 0 */
|
|
{ HRDATA (RBYT1B, zx200a[1].rbyte1, 8) }, /* zx200a 1 result byte 1 */
|
|
{ HRDATA (INTFF1, zx200a[1].intff, 8) }, /* zx200a 1 interrupt f/f */
|
|
{ HRDATA (STAT2, zx200a[2].stat, 8) }, /* zx200a 2 status */
|
|
{ HRDATA (RTYP2, zx200a[2].rtype, 8) }, /* zx200a 2 result type */
|
|
{ HRDATA (RBYT2A, zx200a[2].rbyte0, 8) }, /* zx200a 2 result byte 0 */
|
|
{ HRDATA (RBYT2B, zx200a[2].rbyte1, 8) }, /* zx200a 2 result byte 1 */
|
|
{ HRDATA (INTFF2, zx200a[2].intff, 8) }, /* zx200a 2 interrupt f/f */
|
|
{ HRDATA (STAT3, zx200a[3].stat, 8) }, /* zx200a 3 status */
|
|
{ HRDATA (RTYP3, zx200a[3].rtype, 8) }, /* zx200a 3 result type */
|
|
{ HRDATA (RBYT3A, zx200a[3].rbyte0, 8) }, /* zx200a 3 result byte 0 */
|
|
{ HRDATA (RBYT3B, zx200a[3].rbyte1, 8) }, /* zx200a 3 result byte 1 */
|
|
{ HRDATA (INTFF3, zx200a[3].intff, 8) }, /* zx200a 3 interrupt f/f */
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB zx200a_mod[] = {
|
|
{ UNIT_WPMODE, 0, "RW", "RW", &zx200a_set_mode },
|
|
{ UNIT_WPMODE, UNIT_WPMODE, "WP", "WP", &zx200a_set_mode },
|
|
{ 0 }
|
|
};
|
|
|
|
DEBTAB zx200a_debug[] = {
|
|
{ "ALL", DEBUG_all },
|
|
{ "FLOW", DEBUG_flow },
|
|
{ "READ", DEBUG_read },
|
|
{ "WRITE", DEBUG_write },
|
|
{ "XACK", DEBUG_xack },
|
|
{ "LEV1", DEBUG_level1 },
|
|
{ "LEV2", DEBUG_level2 },
|
|
{ NULL }
|
|
};
|
|
|
|
/* address width is set to 16 bits to use devices in 8086/8088 implementations */
|
|
|
|
DEVICE zx200a_dev = {
|
|
"ZX200A", //name
|
|
zx200a_unit, //units
|
|
zx200a_reg, //registers
|
|
zx200a_mod, //modifiers
|
|
FDD_NUM, //numunits
|
|
16, //aradix
|
|
16, //awidth
|
|
1, //aincr
|
|
16, //dradix
|
|
8, //dwidth
|
|
NULL, //examine
|
|
NULL, //deposit
|
|
NULL, //reset
|
|
NULL, //boot
|
|
&zx200a_attach, //attach
|
|
NULL, //detach
|
|
NULL, //ctxt
|
|
DEV_DEBUG+DEV_DISABLE+DEV_DIS, //flags
|
|
DEBUG_flow + DEBUG_read + DEBUG_write, //dctrl
|
|
zx200a_debug, //debflags
|
|
NULL, //msize
|
|
NULL //lname
|
|
};
|
|
|
|
/* I/O instruction handlers, called from the CPU module when an
|
|
IN or OUT instruction is issued.
|
|
*/
|
|
|
|
/* Service routines to handle simulator functions */
|
|
|
|
/* Reset routine */
|
|
|
|
t_stat zx200a_reset(DEVICE *dptr, uint16 base)
|
|
{
|
|
int32 i;
|
|
UNIT *uptr;
|
|
|
|
sim_printf(" ZX-200A FDC Board");
|
|
if (ZX200A_NUM) {
|
|
sim_printf(" - Found on Port %02X\n", base);
|
|
sim_printf(" ZX200A-%d: Hardware Reset\n", zx200a_fdcnum);
|
|
sim_printf(" ZX200A-%d: Registered at %04X\n", zx200a_fdcnum, base);
|
|
//register base port address for this FDC instance
|
|
zx200a[zx200a_fdcnum].baseport = base;
|
|
//register I/O port addresses for each function
|
|
reg_dev(zx200a0, base, zx200a_fdcnum);
|
|
reg_dev(zx200a1, base + 1, zx200a_fdcnum);
|
|
reg_dev(zx200a2, base + 2, zx200a_fdcnum);
|
|
reg_dev(zx200a3, base + 3, zx200a_fdcnum);
|
|
reg_dev(zx200a7, base + 7, zx200a_fdcnum);
|
|
reg_dev(zx200a0, base+16, zx200a_fdcnum);
|
|
reg_dev(zx200a1, base+16 + 1, zx200a_fdcnum);
|
|
reg_dev(zx200a2, base+16 + 2, zx200a_fdcnum);
|
|
reg_dev(zx200a3, base+16 + 3, zx200a_fdcnum);
|
|
reg_dev(zx200a7, base+16 + 7, zx200a_fdcnum);
|
|
// one-time initialization for all FDDs for this FDC instance
|
|
for (i = 0; i < FDD_NUM; i++) {
|
|
uptr = zx200a_dev.units + i;
|
|
uptr->u5 = zx200a_fdcnum; //fdc device number
|
|
uptr->u6 = i; //fdd unit number
|
|
uptr->flags |= UNIT_WPMODE; //set WP in unit flags
|
|
}
|
|
zx200a_reset1(zx200a_fdcnum);
|
|
zx200a_fdcnum++;
|
|
} else
|
|
sim_printf(" - Not Found\n");
|
|
return SCPE_OK;
|
|
}
|
|
/* Software reset routine */
|
|
|
|
void zx200a_reset1(uint8 fdcnum)
|
|
{
|
|
int32 i;
|
|
UNIT *uptr;
|
|
|
|
sim_printf(" ZX-200A-%d: Initializing\n", fdcnum);
|
|
zx200a[fdcnum].stat = 0; //clear status
|
|
for (i = 0; i < FDD_NUM; i++) { /* handle all units */
|
|
uptr = zx200a_dev.units + i;
|
|
zx200a[fdcnum].stat |= FDCPRE | FDCDD; //set the FDC status
|
|
zx200a[fdcnum].rtype = ROK;
|
|
if (uptr->capac == 0) { /* if not configured */
|
|
sim_printf(" ZX-200A%d: Configured, Status=%02X Not attached\n", i, zx200a[fdcnum].stat);
|
|
} else {
|
|
switch(i){
|
|
case 0:
|
|
zx200a[fdcnum].stat |= RDY0; //set FDD 0 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD0;
|
|
break;
|
|
case 1:
|
|
zx200a[fdcnum].stat |= RDY1; //set FDD 1 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD1;
|
|
break;
|
|
case 2:
|
|
zx200a[fdcnum].stat |= RDY2; //set FDD 2 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD2;
|
|
break;
|
|
case 3:
|
|
zx200a[fdcnum].stat |= RDY3; //set FDD 3 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD3;
|
|
break;
|
|
}
|
|
zx200a[fdcnum].rdychg = 0;
|
|
sim_printf(" ZX-200A%d: Configured, Status=%02X Attached to %s\n",
|
|
i, zx200a[fdcnum].stat, uptr->filename);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* zx200a attach - attach an .IMG file to a FDD */
|
|
|
|
t_stat zx200a_attach (UNIT *uptr, CONST char *cptr)
|
|
{
|
|
t_stat r;
|
|
uint8 fdcnum, fddnum;
|
|
|
|
sim_debug (DEBUG_flow, &zx200a_dev, " zx200a_attach: Entered with cptr=%s\n", cptr);
|
|
if ((r = attach_unit (uptr, cptr)) != SCPE_OK) {
|
|
sim_printf(" zx200a_attach: Attach error\n");
|
|
return r;
|
|
}
|
|
fdcnum = uptr->u5;
|
|
fddnum = uptr->u6;
|
|
switch(fddnum){
|
|
case 0:
|
|
zx200a[fdcnum].stat |= RDY0; //set FDD 0 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD0;
|
|
break;
|
|
case 1:
|
|
zx200a[fdcnum].stat |= RDY1; //set FDD 1 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD1;
|
|
break;
|
|
case 2:
|
|
zx200a[fdcnum].stat |= RDY2; //set FDD 2 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD2;
|
|
break;
|
|
case 3:
|
|
zx200a[fdcnum].stat |= RDY3; //set FDD 3 ready
|
|
zx200a[fdcnum].rbyte1 |= RB1RD3;
|
|
break;
|
|
}
|
|
zx200a[fdcnum].rtype = ROK;
|
|
if (uptr->capac == 256256 && (fddnum == 2 || fddnum == 3)) { /* 8" 256K SSSD */
|
|
zx200a[fdcnum].fdd[fddnum].dd = 0;
|
|
// zx200a[fdcnum].fdd[fddnum].maxcyl = 77;
|
|
// zx200a[fdcnum].fdd[fddnum].maxsec = 26;
|
|
zx200a[fdcnum].fdd[fddnum].sec = 1;
|
|
zx200a[fdcnum].fdd[fddnum].cyl = 0;
|
|
}
|
|
else if (uptr->capac == 512512) { /* 8" 512K SSDD */
|
|
zx200a[fdcnum].fdd[fddnum].dd = 1;
|
|
// zx200a[fdcnum].fdd[fddnum].maxcyl = 77;
|
|
// zx200a[fdcnum].fdd[fddnum].maxsec = 52;
|
|
zx200a[fdcnum].fdd[fddnum].sec = 1;
|
|
zx200a[fdcnum].fdd[fddnum].cyl = 0;
|
|
} else
|
|
sim_printf(" ZX-200A-%d: Invalid disk image or SD on drive 0 or 1\n", fdcnum);
|
|
sim_printf(" ZX-200A-%d: Configured %d bytes, Attached to %s\n",
|
|
fdcnum, uptr->capac, uptr->filename);
|
|
sim_debug (DEBUG_flow, &zx200a_dev, " ZX-200A_attach: Done\n");
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* zx200a set mode = Write protect */
|
|
|
|
t_stat zx200a_set_mode (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
|
|
{
|
|
// sim_debug (DEBUG_flow, &zx200a_dev, " zx200a_set_mode: Entered with val=%08XH uptr->flags=%08X\n",
|
|
// val, uptr->flags);
|
|
if (val & UNIT_WPMODE) { /* write protect */
|
|
uptr->flags |= val;
|
|
} else { /* read write */
|
|
uptr->flags &= ~val;
|
|
}
|
|
// sim_debug (DEBUG_flow, &zx200a_dev, " zx200a_set_mode: Done\n");
|
|
return SCPE_OK;
|
|
}
|
|
|
|
uint8 zx200_get_dn(void)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<ZX200A_NUM; i++)
|
|
if ((port >= zx200a[i].baseport && port <= zx200a[i].baseport + 7) ||
|
|
(port >= zx200a[i].baseport+16 && port <= zx200a[i].baseport+16 + 7))
|
|
return i;
|
|
sim_printf("zx200_get_dn: port %04X not in zx200 device table\n", port);
|
|
return 0xFF;
|
|
}
|
|
|
|
/* I/O instruction handlers, called from the CPU module when an
|
|
IN or OUT instruction is issued.
|
|
*/
|
|
|
|
/* zx200a control port functions */
|
|
|
|
uint8 zx200a0(t_bool io, uint8 data)
|
|
{
|
|
uint8 fdcnum;
|
|
|
|
if ((fdcnum = zx200_get_dn()) != 0xFF) {
|
|
if (io == 0) { /* read ststus*/
|
|
if (DEBUG)
|
|
sim_printf("\n zx-200a0-%d: 0x78/88 returned status=%02X PCX=%04X",
|
|
fdcnum, zx200a[fdcnum].stat, PCX);
|
|
return zx200a[fdcnum].stat;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8 zx200a1(t_bool io, uint8 data)
|
|
{
|
|
uint8 fdcnum;
|
|
|
|
if ((fdcnum = zx200_get_dn()) != 0xFF) {
|
|
if (io == 0) { /* read operation */
|
|
zx200a[fdcnum].intff = 0; //clear interrupt FF
|
|
zx200a[fdcnum].stat &= ~FDCINT;
|
|
if (DEBUG)
|
|
sim_printf("\n zx-200a1-%d: 0x79/89 returned rtype=%02X intff=%02X status=%02X PCX=%04X",
|
|
fdcnum, zx200a[fdcnum].rtype, zx200a[fdcnum].intff, zx200a[fdcnum].stat, PCX);
|
|
return zx200a[fdcnum].rtype;
|
|
} else { /* write control port */
|
|
zx200a[fdcnum].iopb = data;
|
|
if (DEBUG)
|
|
sim_printf("\n zx-200a1-%d: 0x79/88 IOPB low=%02X PCX=%04X",
|
|
fdcnum, data, PCX);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8 zx200a2(t_bool io, uint8 data)
|
|
{
|
|
uint8 fdcnum;
|
|
|
|
if ((fdcnum = zx200_get_dn()) != 0xFF) {
|
|
if (io == 0) { /* read data port */
|
|
;
|
|
} else { /* write data port */
|
|
zx200a[fdcnum].iopb |= (data << 8);
|
|
if (DEBUG)
|
|
sim_printf("\n zx-200a2-%d: 0x7A/8A IOPB=%04X PCX=%04X",
|
|
fdcnum, zx200a[fdcnum].iopb, PCX);
|
|
zx200a_diskio(fdcnum);
|
|
if (zx200a[fdcnum].intff)
|
|
zx200a[fdcnum].stat |= FDCINT;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8 zx200a3(t_bool io, uint8 data)
|
|
{
|
|
uint8 fdcnum;
|
|
|
|
if ((fdcnum = zx200_get_dn()) != 0xFF) {
|
|
if (io == 0) { /* read data port */
|
|
if (zx200a[fdcnum].rtype == 0) {
|
|
if (DEBUG)
|
|
sim_printf("\n zx200a3-%d: 0x7B/8B returned rbyte0=%02X PCX=%04X",
|
|
fdcnum, zx200a[fdcnum].rbyte0, PCX);
|
|
return zx200a[fdcnum].rbyte0;
|
|
} else {
|
|
if (zx200a[fdcnum].rdychg) {
|
|
if (DEBUG)
|
|
sim_printf("\n zx200a3-%d: 0x7B/8B returned rbyte1=%02X PCX=%04X",
|
|
fdcnum, zx200a[fdcnum].rbyte1, PCX);
|
|
return zx200a[fdcnum].rbyte1;
|
|
} else {
|
|
if (DEBUG)
|
|
sim_printf("\n zx200a3-%d: 0x7B/8B returned rbytex=%02X PCX=%04X",
|
|
fdcnum, 0, PCX);
|
|
return 0;
|
|
}
|
|
}
|
|
} else { /* write data port */
|
|
; //stop diskette operation
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* reset ZX-200A */
|
|
uint8 zx200a7(t_bool io, uint8 data)
|
|
{
|
|
uint8 fdcnum;
|
|
|
|
if ((fdcnum = zx200_get_dn()) != 0xFF) {
|
|
if (io == 0) { /* read data port */
|
|
;
|
|
} else { /* write data port */
|
|
zx200a_reset1(fdcnum);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// perform the actual disk I/O operation
|
|
|
|
void zx200a_diskio(uint8 fdcnum)
|
|
{
|
|
uint8 cw, di, nr, ta, sa, data, nrptr;
|
|
uint16 ba;
|
|
uint32 dskoff;
|
|
uint8 fddnum, fmtb;
|
|
uint32 i;
|
|
UNIT *uptr;
|
|
uint8 *fbuf;
|
|
|
|
//parse the IOPB
|
|
cw = multibus_get_mbyte(zx200a[fdcnum].iopb);
|
|
di = multibus_get_mbyte(zx200a[fdcnum].iopb + 1);
|
|
nr = multibus_get_mbyte(zx200a[fdcnum].iopb + 2);
|
|
ta = multibus_get_mbyte(zx200a[fdcnum].iopb + 3);
|
|
sa = multibus_get_mbyte(zx200a[fdcnum].iopb + 4);
|
|
ba = multibus_get_mword(zx200a[fdcnum].iopb + 5);
|
|
fddnum = (di & 0x30) >> 4;
|
|
uptr = zx200a_dev.units + fddnum;
|
|
fbuf = (uint8 *) (zx200a_dev.units + fddnum)->filebuf;
|
|
if (DEBUG) {
|
|
sim_printf("\n zx200a-%d: zx200a_diskio IOPB=%04X FDD=%02X STAT=%02X",
|
|
fdcnum, zx200a[fdcnum].iopb, fddnum, zx200a[fdcnum].stat);
|
|
sim_printf("\n zx200a-%d: cw=%02X di=%02X nr=%02X ta=%02X sa=%02X ba=%04X",
|
|
fdcnum, cw, di, nr, ta, sa, ba);
|
|
}
|
|
//check for not ready
|
|
switch(fddnum) {
|
|
case 0:
|
|
if ((zx200a[fdcnum].stat & RDY0) == 0) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0NR;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Ready error on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
break;
|
|
case 1:
|
|
if ((zx200a[fdcnum].stat & RDY1) == 0) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0NR;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Ready error on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
break;
|
|
case 2:
|
|
if ((zx200a[fdcnum].stat & RDY2) == 0) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0NR;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Ready error on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
break;
|
|
case 3:
|
|
if ((zx200a[fdcnum].stat & RDY3) == 0) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0NR;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Ready error on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
//check for address error
|
|
if (zx200a[fdcnum].fdd[fddnum].dd == 1) {
|
|
if (
|
|
((di & 0x07) != DHOME) && (
|
|
(sa > MAXSECDD) ||
|
|
((sa + nr) > (MAXSECDD + 1)) ||
|
|
(sa == 0) ||
|
|
(ta > MAXTRK)
|
|
)) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0ADR;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Address error on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
} else if (zx200a[fdcnum].fdd[fddnum].dd == 0) {
|
|
if (
|
|
((di & 0x07) != DHOME) && (
|
|
(sa > MAXSECSD) ||
|
|
((sa + nr) > (MAXSECSD + 1)) ||
|
|
(sa == 0) ||
|
|
(ta > MAXTRK)
|
|
)) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0ADR;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Address error on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
}
|
|
switch (di & 0x07) {
|
|
case DNOP:
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
case DSEEK:
|
|
zx200a[fdcnum].fdd[fddnum].sec = sa;
|
|
zx200a[fdcnum].fdd[fddnum].cyl = ta;
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
case DHOME:
|
|
zx200a[fdcnum].fdd[fddnum].sec = sa;
|
|
zx200a[fdcnum].fdd[fddnum].cyl = 0;
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
case DVCRC:
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
case DFMT:
|
|
//check for WP
|
|
if(uptr->flags & UNIT_WPMODE) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0WP;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Write protect error 1 on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
fmtb = multibus_get_mbyte(ba); //get the format byte
|
|
if (zx200a[fdcnum].fdd[fddnum].dd == 1) {
|
|
//calculate offset into DD disk image
|
|
dskoff = ((ta * MAXSECDD) + (sa - 1)) * 128;
|
|
for(i=0; i<=((uint32)(MAXSECDD) * 128); i++) {
|
|
*(fbuf + (dskoff + i)) = fmtb;
|
|
}
|
|
} else {
|
|
//calculate offset into SD disk image
|
|
dskoff = ((ta * MAXSECSD) + (sa - 1)) * 128;
|
|
for(i=0; i<=((uint32)(MAXSECSD) * 128); i++) {
|
|
*(fbuf + (dskoff + i)) = fmtb;
|
|
}
|
|
}
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
case DREAD:
|
|
nrptr = 0;
|
|
while(nrptr < nr) {
|
|
//calculate offset into disk image
|
|
if (zx200a[fdcnum].fdd[fddnum].dd == 1) {
|
|
dskoff = ((ta * MAXSECDD) + (sa - 1)) * 128;
|
|
} else {
|
|
dskoff = ((ta * MAXSECSD) + (sa - 1)) * 128;
|
|
}
|
|
if (DEBUG)
|
|
sim_printf("\n isbc202-%d: cw=%02X di=%02X nr=%02X ta=%02X sa=%02X ba=%04X dskoff=%06X",
|
|
fdcnum, cw, di, nr, ta, sa, ba, dskoff);
|
|
//copy sector from image to RAM
|
|
for (i=0; i<128; i++) {
|
|
data = *(fbuf + (dskoff + i));
|
|
multibus_put_mbyte(ba + i, data);
|
|
}
|
|
sa++;
|
|
ba+=0x80;
|
|
nrptr++;
|
|
}
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
case DWRITE:
|
|
//check for WP
|
|
if(uptr->flags & UNIT_WPMODE) {
|
|
zx200a[fdcnum].rtype = RERR;
|
|
zx200a[fdcnum].rbyte0 = RB0WP;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
sim_printf("\n zx200a-%d: Write protect error 2 on drive %d", fdcnum, fddnum);
|
|
return;
|
|
}
|
|
nrptr = 0;
|
|
while(nrptr < nr) {
|
|
//calculate offset into disk image
|
|
if (zx200a[fdcnum].fdd[fddnum].dd == 1) {
|
|
dskoff = ((ta * MAXSECDD) + (sa - 1)) * 128;
|
|
} else {
|
|
dskoff = ((ta * MAXSECSD) + (sa - 1)) * 128;
|
|
}
|
|
if (DEBUG)
|
|
sim_printf("\n isbc202-%d: cw=%02X di=%02X nr=%02X ta=%02X sa=%02X ba=%04X dskoff=%06X",
|
|
fdcnum, cw, di, nr, ta, sa, ba, dskoff);
|
|
for (i=0; i<128; i++) { //copy sector from image to RAM
|
|
data = multibus_get_mbyte(ba + i);
|
|
*(fbuf + (dskoff + i)) = data;
|
|
}
|
|
sa++;
|
|
ba+=0x80;
|
|
nrptr++;
|
|
}
|
|
zx200a[fdcnum].rtype = ROK;
|
|
zx200a[fdcnum].intff = 1; //set interrupt FF
|
|
break;
|
|
default:
|
|
sim_printf("\n zx200a-%d: zx200a_diskio bad di=%02X", fdcnum, di & 0x07);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* end of zx-200a.c */
|