mirror of
https://github.com/SEPPDROID/Digital-Research-Source-Code.git
synced 2025-10-23 00:14:25 +00:00
851 lines
16 KiB
C
851 lines
16 KiB
C
/*=======================================================================*/
|
|
/*/---------------------------------------------------------------------\*/
|
|
/*| |*/
|
|
/*| CP/M-68K(tm) BIOS for the EXORMACS |*/
|
|
/*| |*/
|
|
/*| Copyright 1982, Digital Research. |*/
|
|
/*| |*/
|
|
/*\---------------------------------------------------------------------/*/
|
|
/*=======================================================================*/
|
|
|
|
#define DEBUG 0
|
|
|
|
#define TRACEPORT 0xffee015
|
|
|
|
#include "[bill.cpm68k.csupport]stdtypes.h"
|
|
|
|
char copyright[] = "Copyright 1982, Digital Research";
|
|
|
|
struct memb { BYTE byte; };
|
|
struct memw { WORD word; };
|
|
struct meml { LONG lword;};
|
|
|
|
|
|
/************************************************************************/
|
|
/* I/O Device Definitions */
|
|
/************************************************************************/
|
|
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Define the two ACIA ports on the DEBUG board */
|
|
/************************************************************************/
|
|
|
|
#define PORT1 0xFFEE011
|
|
#define PORT2 0xFFEE015
|
|
|
|
#define PORTCTRL 0
|
|
#define PORTSTAT 0
|
|
#define PORTRDR 2
|
|
#define PORTTDR 2
|
|
|
|
#define PORTRSET 3
|
|
#define PORTINIT 0x11
|
|
|
|
#define PORTRDRF 1
|
|
#define PORTTDRE 2
|
|
|
|
|
|
/************************************************************************/
|
|
/* Define Disk I/O Addresses and Related Constants */
|
|
/************************************************************************/
|
|
|
|
#define DSKIPC 0xFF0000 /* IPC Base Address */
|
|
|
|
#define DSKINTV 0x3FC /* Address of Disk Interrupt Vector */
|
|
|
|
#define INTTOIPC 0xD /* offsets */
|
|
#define RSTTOIPC 0xF
|
|
#define MSGTOIPC 0x101
|
|
#define ACKTOIPC 0x103
|
|
#define PKTTOIPC 0x105
|
|
#define MSGFMIPC 0x181
|
|
#define ACKFMIPC 0x183
|
|
#define PKTFMIPC 0x185
|
|
|
|
#define DSKREAD 0x10
|
|
#define DSKWRITE 0x20
|
|
|
|
#define STX 0x02
|
|
#define ETX 0x03
|
|
#define ACK 0x06
|
|
#define NAK 0x15
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* BIOS Table Definitions */
|
|
/************************************************************************/
|
|
|
|
struct dpb
|
|
{
|
|
WORD spt;
|
|
BYTE bsh;
|
|
BYTE blm;
|
|
BYTE exm;
|
|
BYTE dpbjunk;
|
|
WORD dsm;
|
|
WORD drm;
|
|
BYTE al0;
|
|
BYTE al1;
|
|
WORD cks;
|
|
WORD off;
|
|
};
|
|
|
|
|
|
|
|
struct dph
|
|
{
|
|
BYTE *xltp;
|
|
WORD dphscr[3];
|
|
BYTE *dirbufp;
|
|
struct dpb *dpbp;
|
|
BYTE *csvp;
|
|
BYTE *alvp;
|
|
};
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Directory Buffer for use by the BDOS */
|
|
/************************************************************************/
|
|
|
|
BYTE dirbuf[128];
|
|
|
|
|
|
/************************************************************************/
|
|
/* CSV's */
|
|
/************************************************************************/
|
|
|
|
BYTE csv0[16];
|
|
BYTE csv1[16];
|
|
BYTE csv2[16];
|
|
|
|
|
|
/************************************************************************/
|
|
/* ALV's */
|
|
/************************************************************************/
|
|
|
|
BYTE alv0[32]; /* (dsm0 / 8) + 1 */
|
|
BYTE alv1[32]; /* (dsm1 / 8) + 1 */
|
|
BYTE alv2[2002]; /* (dsm2 / 8) + 1 */
|
|
|
|
|
|
/************************************************************************/
|
|
/* Disk Parameter Blocks */
|
|
/************************************************************************/
|
|
|
|
/* The following dpb definitions express the intent of the writer, */
|
|
/* unfortunately, due to a compiler bug, these lines cannot be used. */
|
|
/* Therefore, the obscure code following them has been inserted. */
|
|
|
|
/************* spt, bsh, blm, exm, jnk, dsm, drm, al0, al1, cks, off
|
|
|
|
struct dpb dpb0={ 26, 3, 7, 0, 0, 242, 63, 0xC0, 0, 16, 2};
|
|
struct dpb dpb1={ 26, 4, 15, 0, 0, 242, 63, 0xC0, 0, 16, 2};
|
|
struct dpb dpb2={ 26, 3, 7, 0, 0, 16008, 63, 0xC0, 0, 16, 2};
|
|
|
|
********** end of readable definitions *************/
|
|
|
|
/* The Alcyon C compiler assumes all structures are arrays of int, so */
|
|
/* in the following definitions, adjacent pairs of chars have been */
|
|
/* combined into int constants --- what a kludge! **********************/
|
|
|
|
struct dpb dpb0 = { 26, 775, 0, 242, 63, -16384, 16, 2 };
|
|
struct dpb dpb1 = { 26, 1039, 0, 242, 63, -16384, 16, 2 };
|
|
struct dpb dpb2 = { 26, 775, 0, 16008, 63, -16384, 16, 2 };
|
|
|
|
/*************** End of kludge *****************/
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Sector Translate Table */
|
|
/************************************************************************/
|
|
|
|
BYTE xlt[26] = { 1, 7, 13, 19, 25, 5, 11, 17, 23, 3, 9, 15, 21,
|
|
2, 8, 14, 20, 26, 6, 12, 18, 24, 4, 10, 16, 22 };
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Disk Parameter Headers */
|
|
/* */
|
|
/* Four disks are defined : dsk a: diskno=0, dev name=#fd04 */
|
|
/* dsk b: diskno=1, dev name=#fd05 */
|
|
/* dsk c: diskno=2, dev name=#hd00 */
|
|
/* dsk d: diskno=3, dev name=#hd01 */
|
|
/************************************************************************/
|
|
|
|
struct dph dphtab[4] =
|
|
{ {&xlt, 0, 0, 0, &dirbuf, &dpb0, &csv0, &alv0}, /*dsk a*/
|
|
{&xlt, 0, 0, 0, &dirbuf, &dpb0, &csv1, &alv1}, /*dsk b*/
|
|
{ 0L, 0, 0, 0, &dirbuf, &dpb2, &csv2, &alv2}, /*dsk c*/
|
|
{ 0L, 0, 0, 0, &dirbuf, &dpb2, &csv2, &alv2}, /*dsk d*/
|
|
};
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Memory Region Table */
|
|
/************************************************************************/
|
|
|
|
struct mrt { WORD count;
|
|
LONG tpalow;
|
|
LONG tpalen;
|
|
}
|
|
memtab = { 1, 0x0002,0x0000, 0x0003,0xfff0 };/* kludge init by int */
|
|
|
|
|
|
/************************************************************************/
|
|
/* IOBYTE */
|
|
/************************************************************************/
|
|
|
|
WORD iobyte;
|
|
|
|
|
|
/************************************************************************/
|
|
/* Currently Selected Disk Stuff */
|
|
/************************************************************************/
|
|
|
|
WORD settrk, setsec, setdsk;
|
|
BYTE *setdma;
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Track Buffering Definitions and Variables */
|
|
/************************************************************************/
|
|
|
|
#define NUMTB 10 /* must be at least 3 for some algorithms */
|
|
|
|
struct tbstr {
|
|
struct tbstr *nextbuf;
|
|
BYTE buf[26*128];
|
|
WORD dsk;
|
|
WORD trk;
|
|
BYTE valid;
|
|
BYTE dirty;
|
|
};
|
|
|
|
struct tbstr *firstbuf;
|
|
struct tbstr *lastbuf;
|
|
|
|
struct tbstr tbuf[NUMTB];
|
|
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/* Disk I/O Packets for the UDC and other Disk I/O Variables */
|
|
/************************************************************************/
|
|
|
|
struct hmpkst {
|
|
BYTE a1;
|
|
BYTE a2;
|
|
BYTE a3;
|
|
BYTE dskno;
|
|
BYTE com1;
|
|
BYTE com2;
|
|
BYTE a6;
|
|
BYTE a7;
|
|
}
|
|
hmpack = { 512, 1792, 0, 768 }; /* kludge init by words */
|
|
|
|
|
|
struct rwpkst {
|
|
BYTE stxchr;
|
|
BYTE pktid;
|
|
BYTE pktsize;
|
|
BYTE dskno;
|
|
BYTE chcmd;
|
|
BYTE devcmd;
|
|
WORD numblks;
|
|
WORD blksize;
|
|
LONG iobf;
|
|
WORD cksum;
|
|
LONG lsect;
|
|
BYTE etxchr;
|
|
BYTE rwpad;
|
|
};
|
|
|
|
struct rwpkst rwpack = { 512, 5376, 4097, 13, 256, 0, 0, 0, 0, 0, 768 };
|
|
|
|
|
|
BYTE cnvdsk[4] = { 4, 5, 0, 1 }; /* convert from CP/M dsk # to Exormacs */
|
|
|
|
#define MAXDSK 3
|
|
|
|
|
|
#define DSKIDLE 0
|
|
#define MSGSENT 1
|
|
#define NAKRCVD 2
|
|
#define ACKRCVD 3
|
|
#define IODONE 4
|
|
#define DSKERROR 5
|
|
|
|
|
|
WORD dskstate = DSKIDLE;
|
|
|
|
|
|
/************************************************************************/
|
|
/* Generic Serial Port I/O Procedures */
|
|
/************************************************************************/
|
|
|
|
portinit(port)
|
|
REG BYTE *port;
|
|
{
|
|
*(port + PORTCTRL) = PORTRSET;
|
|
*(port + PORTCTRL) = PORTINIT;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
portstat(port)
|
|
REG BYTE *port;
|
|
{
|
|
return ( *(port + PORTSTAT) & PORTRDRF) == PORTRDRF;
|
|
}
|
|
|
|
|
|
|
|
|
|
BYTE portin(port)
|
|
REG BYTE *port;
|
|
{
|
|
while (portstat(port) == 0) ;
|
|
return *(port + PORTRDR);
|
|
}
|
|
|
|
|
|
|
|
|
|
portout(port, ch)
|
|
REG BYTE *port;
|
|
REG BYTE ch;
|
|
{
|
|
while ( (*(port + PORTSTAT) & PORTTDRE) != PORTTDRE) ;
|
|
*(port + PORTTDR) = ch;
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
/* Error procedure for BIOS */
|
|
/************************************************************************/
|
|
|
|
bioserr(errmsg)
|
|
REG BYTE *errmsg;
|
|
{
|
|
printstr("\n\rBIOS ERROR -- ");
|
|
printstr(errmsg);
|
|
printstr(".\n\r");
|
|
}
|
|
|
|
printstr(s) /* used by bioserr */
|
|
REG BYTE *s;
|
|
{
|
|
while (*s) {portout(PORT1,*s); s += 1; };
|
|
}
|
|
|
|
#if DEBUG
|
|
|
|
printrace(s)
|
|
REG BYTE *s;
|
|
{
|
|
while (*s) {portout(TRACEPORT, *s); s += 1;}
|
|
}
|
|
|
|
printnum(n)
|
|
REG LONG n;
|
|
{
|
|
REG WORD i;
|
|
REG BYTE d;
|
|
|
|
i = 32;
|
|
|
|
while (i)
|
|
{
|
|
i -= 4;
|
|
d = (n >> i) & 0x0fL;
|
|
if ( d <= '9' ) d = d + '0';
|
|
else d = d - 10 + 'a';
|
|
portout(TRACEPORT, d);
|
|
}
|
|
portout(TRACEPORT, ' ');
|
|
}
|
|
|
|
|
|
printds(ds)
|
|
WORD ds;
|
|
{
|
|
switch(ds){
|
|
case DSKIDLE: printrace("DSKIDLE");
|
|
break;
|
|
case MSGSENT: printrace("MSGSENT");
|
|
break;
|
|
case NAKRCVD: printrace("NAKRCVD");
|
|
break;
|
|
case ACKRCVD: printrace("ACKRCVD");
|
|
break;
|
|
case IODONE: printrace("IODONE");
|
|
break;
|
|
case DSKERROR: printrace("DSKERROR");
|
|
break;
|
|
default: printrace("Invalid");
|
|
break;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
/************************************************************************/
|
|
/* Disk I/O Procedures */
|
|
/************************************************************************/
|
|
|
|
|
|
EXTERN dskia();
|
|
EXTERN setimask();
|
|
|
|
dskic()
|
|
{
|
|
/* Disk Interrupt Handler -- C Language Portion */
|
|
|
|
#if DEBUG
|
|
|
|
printrace("\n\rDisk Interrupt ");
|
|
printds(dskstate);
|
|
printrace("->");
|
|
|
|
#endif
|
|
|
|
switch ( dskstate )
|
|
{
|
|
case DSKIDLE: ;
|
|
case IODONE: ;
|
|
case DSKERROR:;
|
|
case NAKRCVD: {
|
|
if ( ((DSKIPC+ACKFMIPC)->byte == ACK) ||
|
|
((DSKIPC+ACKFMIPC)->byte == NAK) )
|
|
{
|
|
(DSKIPC+ACKFMIPC)->byte = 0;
|
|
}
|
|
|
|
if ( (DSKIPC+MSGFMIPC)->byte == 0x80 )
|
|
{
|
|
(DSKIPC+ACKTOIPC)->byte = ACK;
|
|
(DSKIPC+MSGFMIPC)->byte = 0;
|
|
(DSKIPC+INTTOIPC)->byte = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MSGSENT: {
|
|
if ( (DSKIPC+ACKFMIPC)->byte == ACK )
|
|
{
|
|
(DSKIPC+ACKFMIPC)->byte = 0;
|
|
dskstate = ACKRCVD;
|
|
}
|
|
else if ( (DSKIPC+ACKFMIPC)->byte == NAK )
|
|
{
|
|
(DSKIPC+ACKFMIPC)->byte = 0;
|
|
dskstate = NAKRCVD;
|
|
}
|
|
else
|
|
{
|
|
bioserr("Expected ACK or NAK");
|
|
dskstate = DSKERROR;
|
|
return;
|
|
}
|
|
|
|
if ( (DSKIPC+MSGFMIPC)->byte == 0x80 )
|
|
{ dskstate = IODONE; }
|
|
}
|
|
break;
|
|
|
|
case ACKRCVD: {
|
|
if ( (DSKIPC+MSGFMIPC)->byte != 0x80 )
|
|
{ bioserr("Expected status packet from IPC");}
|
|
else dskstate = IODONE;
|
|
|
|
(DSKIPC+MSGFMIPC)->byte = 0;
|
|
(DSKIPC+ACKTOIPC)->byte = ACK;
|
|
(DSKIPC+INTTOIPC)->byte = 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
#if DEBUG
|
|
printds(dskstate);
|
|
printrace("\n\r");
|
|
#endif
|
|
|
|
} /* end of dskic */
|
|
|
|
|
|
sendpkt(pktadr, pktsize)
|
|
REG BYTE *pktadr;
|
|
REG WORD pktsize;
|
|
{
|
|
REG BYTE *iopackp;
|
|
REG WORD imsave;
|
|
|
|
while ( (DSKIPC+MSGTOIPC)->byte ); /* wait til ready */
|
|
if ( (DSKIPC+ACKFMIPC)->byte == NAK ) bioserr("NAK from IPC");
|
|
(DSKIPC+ACKFMIPC)->byte = 0;
|
|
(DSKIPC+MSGFMIPC)->byte = 0;
|
|
iopackp = (DSKIPC+PKTTOIPC);
|
|
do {*iopackp = *pktadr++; iopackp += 2; pktsize -= 1;} while(pktsize);
|
|
(DSKIPC+MSGTOIPC)->byte = 0x80;
|
|
imsave = setimask(7);
|
|
dskstate = MSGSENT;
|
|
(DSKIPC+INTTOIPC)->byte = 0;
|
|
setimask(imsave);
|
|
}
|
|
|
|
|
|
dskxfer(dsk, trk, bufp, cmd)
|
|
REG WORD dsk, trk, cmd;
|
|
REG BYTE *bufp;
|
|
{
|
|
/* build packet */
|
|
rwpack.dskno = cnvdsk[dsk];
|
|
rwpack.iobf = bufp;
|
|
rwpack.lsect = trk * 13;
|
|
rwpack.chcmd = cmd;
|
|
sendpkt(&rwpack, 21);
|
|
while (dskstate == MSGSENT); /* wait */
|
|
if (dskstate == NAKRCVD) bioserr("NAK from IPC");
|
|
while (dskstate == ACKRCVD); /* wait */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
flush1(tbp)
|
|
REG struct tbstr *tbp;
|
|
{
|
|
if ( tbp->valid && tbp->dirty )
|
|
dskxfer(tbp->dsk, tbp->trk, tbp->buf, DSKWRITE);
|
|
|
|
tbp->dirty = 0;
|
|
|
|
return(0);
|
|
}
|
|
|
|
|
|
flush()
|
|
{
|
|
REG struct tbstr *tbp;
|
|
|
|
tbp = firstbuf;
|
|
while (tbp)
|
|
{
|
|
flush1(tbp);
|
|
tbp = tbp->nextbuf;
|
|
}
|
|
}
|
|
|
|
|
|
fill(tbp)
|
|
REG struct tbstr *tbp;
|
|
{
|
|
|
|
if ( tbp->valid && tbp->dirty ) flush1(tbp);
|
|
|
|
dskxfer(setdsk, settrk, tbp->buf, DSKREAD);
|
|
|
|
tbp->valid = 1;
|
|
tbp->dirty = 0;
|
|
tbp->trk = settrk;
|
|
tbp->dsk = setdsk;
|
|
|
|
}
|
|
|
|
|
|
struct tbstr *gettrk()
|
|
{
|
|
REG struct tbstr *tbp;
|
|
REG struct tbstr *ltbp;
|
|
REG struct tbstr *mtbp;
|
|
|
|
tbp = firstbuf;
|
|
ltbp = 0;
|
|
mtbp = 0;
|
|
|
|
while (tbp)
|
|
{
|
|
if ( (tbp->valid) && (tbp->dsk == setdsk)
|
|
&& (tbp->trk == settrk) )
|
|
{
|
|
if (ltbp)
|
|
{
|
|
ltbp->nextbuf = tbp->nextbuf;
|
|
tbp->nextbuf = firstbuf;
|
|
firstbuf = tbp;
|
|
}
|
|
return tbp;
|
|
}
|
|
else
|
|
{
|
|
mtbp = ltbp;
|
|
ltbp = tbp;
|
|
tbp = tbp->nextbuf;
|
|
}
|
|
}
|
|
|
|
if (mtbp) mtbp->nextbuf = 0; /* detach lru buffer */
|
|
if ( (! firstbuf->valid) ||
|
|
(firstbuf->trk > dphtab[firstbuf->dsk].dpbp->off) ) /* dir trk? */
|
|
{
|
|
ltbp->nextbuf = firstbuf;
|
|
firstbuf = ltbp;
|
|
}
|
|
else
|
|
{
|
|
ltbp->nextbuf = firstbuf->nextbuf;
|
|
firstbuf->nextbuf = ltbp;
|
|
}
|
|
flush1(ltbp);
|
|
fill(ltbp);
|
|
return ltbp;
|
|
}
|
|
|
|
|
|
|
|
read()
|
|
{
|
|
REG BYTE *p;
|
|
REG BYTE *q;
|
|
REG WORD i;
|
|
REG struct tbstr *tbp;
|
|
|
|
tbp = gettrk();
|
|
p = (tbp->buf) + ((setsec-1) << 7); /* multiply by shifting */
|
|
q = setdma;
|
|
i = 128;
|
|
do {*q++ = *p++; i -= 1;} while (i);
|
|
return(0);
|
|
}
|
|
|
|
|
|
write(mode)
|
|
BYTE mode;
|
|
{
|
|
REG BYTE *p;
|
|
REG BYTE *q;
|
|
REG WORD i;
|
|
REG struct tbstr *tbp;
|
|
|
|
tbp = gettrk();
|
|
p = (tbp->buf) + ((setsec-1) << 7); /* multiply by shifting */
|
|
q = setdma;
|
|
i = 128;
|
|
if ( (mode != 1) || (tbp->dirty) ) /* normal case */
|
|
{
|
|
do {*p++ = *q++; i -= 1;} while (i);
|
|
tbp->dirty = 1;
|
|
}
|
|
else /* for dir write, only mark dirty if changed. */
|
|
{
|
|
do
|
|
{
|
|
if (*p != *q) tbp->dirty=1;
|
|
*p++ = *q++;
|
|
i -= 1;
|
|
}
|
|
while (i);
|
|
}
|
|
if ( mode == 1 ) flush();
|
|
return(0);
|
|
}
|
|
|
|
|
|
|
|
BYTE sectran(s, xp)
|
|
WORD s;
|
|
BYTE *xp;
|
|
{
|
|
return xp[s];
|
|
}
|
|
|
|
|
|
LONG setxvect(vnum, vval)
|
|
WORD vnum;
|
|
LONG vval;
|
|
{
|
|
REG LONG oldval;
|
|
REG BYTE *vloc;
|
|
|
|
vloc = ( (long)vnum ) << 2;
|
|
oldval = vloc->lword;
|
|
vloc->lword = vval;
|
|
|
|
return(oldval);
|
|
|
|
}
|
|
|
|
|
|
LONG seldsk(dsk, logged)
|
|
REG BYTE dsk;
|
|
BYTE logged;
|
|
{
|
|
REG struct dph *dphp;
|
|
REG BYTE check;
|
|
|
|
if (dsk > MAXDSK) return(0L);
|
|
setdsk = dsk;
|
|
dphp = &dphtab[dsk];
|
|
if ( ! logged )
|
|
{
|
|
|
|
hmpack.dskno = cnvdsk[setdsk];
|
|
hmpack.com1 = 0x30;
|
|
hmpack.com2 = 0x02;
|
|
(DSKIPC+ACKFMIPC)->byte = 6;
|
|
if ( (DSKIPC+MSGTOIPC)->byte ) {bioserr("ERR 6"); return 0L;}
|
|
else sendpkt(&hmpack, 7);
|
|
while ( dskstate == MSGSENT ); /* wait */
|
|
if (dskstate == NAKRCVD) {bioserr("NAK from IPC"); return 0L;}
|
|
while ( dskstate == ACKRCVD ); /* wait */
|
|
check = (DSKIPC+PKTFMIPC+0x18)->byte;
|
|
switch ( check )
|
|
{
|
|
case 3: dphp->dpbp = &dpb0;
|
|
break;
|
|
|
|
case 7: dphp->dpbp = &dpb1;
|
|
break;
|
|
|
|
default: {bioserr("ERR 7"); return 0L;}
|
|
break;
|
|
}
|
|
}
|
|
return(dphp);
|
|
}
|
|
|
|
|
|
/************************************************************************/
|
|
/* BIOS PROPER */
|
|
/************************************************************************/
|
|
|
|
|
|
|
|
|
|
biosinit()
|
|
{
|
|
REG WORD i;
|
|
|
|
portinit(PORT1);
|
|
portinit(PORT2);
|
|
for ( i = 0; i < NUMTB; ++i )
|
|
{
|
|
tbuf[i].valid = 0;
|
|
tbuf[i].dirty = 0;
|
|
if ( (i+1) < NUMTB ) tbuf[i].nextbuf = &tbuf[i+1];
|
|
else tbuf[i].nextbuf = 0;
|
|
}
|
|
firstbuf = &tbuf[0];
|
|
lastbuf = &tbuf[NUMTB-1];
|
|
}
|
|
|
|
|
|
|
|
|
|
LONG bios(d0, d1, d2)
|
|
WORD d0;
|
|
LONG d1, d2;
|
|
{
|
|
|
|
#if DEBUG
|
|
|
|
if ( d0 > 7) {
|
|
printrace("\n\rBIOS( ");
|
|
printnum((long)d0);
|
|
printnum(d1);
|
|
printnum(d2);
|
|
printrace(")\n\r");
|
|
}
|
|
|
|
#endif
|
|
|
|
switch(d0)
|
|
{
|
|
case 0: init(); /* INIT */
|
|
break;
|
|
|
|
case 1: wboot(); /* WBOOT */
|
|
break;
|
|
|
|
case 2: return(portstat(PORT1)); /* CONST */
|
|
break;
|
|
|
|
case 3: return(portin(PORT1)); /* CONIN */
|
|
break;
|
|
|
|
case 4: portout(PORT1, (char)d1); /* CONOUT */
|
|
break;
|
|
|
|
case 5: ; /* LIST */
|
|
case 6: portout(PORT2, (char)d1); /* PUNCH */
|
|
break;
|
|
|
|
case 7: return(portin(PORT2)); /* READER */
|
|
break;
|
|
|
|
case 8: settrk = 0; /* HOME */
|
|
break;
|
|
|
|
case 9: return(seldsk((char)d1, (char)d2)); /* SELDSK */
|
|
break;
|
|
|
|
case 10: settrk = (int)d1; /* SETTRK */
|
|
break;
|
|
|
|
case 11: setsec = (int)d1; /* SETSEC */
|
|
break;
|
|
|
|
case 12: setdma = d1; /* SETDMA */
|
|
break;
|
|
|
|
case 13: return(read()); /* READ */
|
|
break;
|
|
|
|
case 14: return(write((char)d1)); /* WRITE */
|
|
break;
|
|
|
|
case 15: return(portstat(PORT2)); /* LISTST */
|
|
break;
|
|
|
|
case 16: return(sectran((int)d1, d2)); /* SECTRAN */
|
|
break;
|
|
|
|
case 18: return(&memtab); /* GMRTA */
|
|
break;
|
|
|
|
case 19: return(iobyte); /* GETIOB */
|
|
break;
|
|
|
|
case 20: iobyte = (int)d1; /* SETIOB */
|
|
break;
|
|
|
|
case 21: return(flush()); /* FLUSH */
|
|
break;
|
|
|
|
case 22: return(setxvect((int)d1,d2)); /* SETXVECT */
|
|
break;
|
|
|
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
} /* end bios procedure */
|
|
|
|
|
|
|
|
/* End of C Bios */
|