folkert/simh-testsetgenerator
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
simh-testsetgenerator/SDS/sds_dsk.c
Mark Pizzolato 5531ccb175 ALL: Massive 'const' cleanup 
These changes facilitate more robust parameter type checking and helps
to identify unexpected coding errors.

Most simulators can now also be compiled with a C++ compiler without
warnings.

Additionally, these changes have also been configured to facilitate easier
backporting of simulator and device simulation modules to run under the
simh v3.9+ SCP framework.
2016-05-15 15:25:33 -07:00

391 lines
16 KiB
C
Raw Blame History

/* sds_dsk.c: SDS 940 moving head disk simulator
Copyright (c) 2001-2008, Robert M. Supnik
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
ROBERT M SUPNIK 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 Robert M Supnik shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from Robert M Supnik.
dsk moving head disk
The SDS 9164 disk has a subsector feature, allowing each 64W sector to be
viewed as 16W packets. In addition, it has a chaining feature, allowing
records to be extended beyond a sector boundary. To accomodate this, the
first word of each sector has 3 extra bits:
<26> = end of chain flag
<25:24> = 4 - number of packets
These values were chosen so that 000 = continue chain, full sector.
*/
#include "sds_defs.h"
#define UNIT_V_WLK (UNIT_V_UF + 0) /* write locked */
#define UNIT_WLK (1 << UNIT_V_WLK)
#define UNIT_WPRT (UNIT_WLK | UNIT_RO) /* write protect */
#define DSK_PKTWD 16 /* words/packet */
#define DSK_NUMPKT 4 /* packets/sector */
#define DSK_NUMWD (DSK_PKTWD*DSK_NUMPKT) /* words/sector */
#define DSK_N_SC 5 /* sect addr width */
#define DSK_V_SC 0 /* position */
#define DSK_M_SC ((1 << DSK_N_SC) - 1) /* mask */
#define DSK_NUMSC (1 << DSK_N_SC) /* sectors/track */
#define DSK_N_TR 8 /* track addr width */
#define DSK_V_TR (DSK_N_SC) /* position */
#define DSK_M_TR ((1 << DSK_N_TR) - 1) /* mask */
#define DSK_NUMTR (1 << DSK_N_TR) /* tracks/surface */
#define DSK_N_SF 5 /* surf addr width */
#define DSK_V_SF (DSK_N_SC + DSK_N_TR) /* position */
#define DSK_M_SF ((1 << DSK_N_SF) - 1) /* mask */
#define DSK_NUMSF (1 << DSK_N_SF) /* surfaces/drive */
#define DSK_SCSIZE (DSK_NUMSF*DSK_NUMTR*DSK_NUMSC) /* sectors/drive */
#define DSK_AMASK (DSK_SCSIZE - 1) /* address mask */
#define DSK_SIZE (DSK_SCSIZE * DSK_NUMWD) /* words/drive */
#define DSK_GETTR(x) (((x) >> DSK_V_TR) & DSK_M_TR)
#define cyl u3 /* curr cylinder */
#define DSK_SIP (1 << (DSK_N_TR + 2))
#define DSK_V_PKT 24
#define DSK_M_PKT 03
#define DSK_V_CHN 26
#define DSK_GETPKT(x) (4 - (((x) >> DSK_V_PKT) & DSK_M_PKT))
#define DSK_ENDCHN(x) ((x) & (1 << DSK_V_CHN))
extern uint32 xfr_req;
extern uint32 alert;
extern int32 stop_invins, stop_invdev, stop_inviop;
int32 dsk_da = 0; /* disk addr */
int32 dsk_op = 0; /* operation */
int32 dsk_err = 0; /* error flag */
uint32 dsk_buf[DSK_NUMWD]; /* sector buf */
int32 dsk_bptr = 0; /* byte ptr */
int32 dsk_blnt = 0; /* byte lnt */
int32 dsk_time = 5; /* time per char */
int32 dsk_stime = 200; /* seek time */
int32 dsk_stopioe = 1;
DSPT dsk_tplt[] = { /* template */
{ 1, 0 },
{ 1, DEV_OUT },
{ 0, 0 }
};
t_stat dsk_svc (UNIT *uptr);
t_stat dsk_reset (DEVICE *dptr);
t_stat dsk_fill (uint32 dev);
t_stat dsk_read_buf (uint32 dev);
t_stat dsk_write_buf (uint32 dev);
void dsk_end_op (uint32 fl);
t_stat dsk (uint32 fnc, uint32 inst, uint32 *dat);
/* DSK data structures
dsk_dev device descriptor
dsk_unit unit descriptor
dsk_reg register list
*/
DIB dsk_dib = { CHAN_F, DEV_DSK, XFR_DSK, dsk_tplt, &dsk };
UNIT dsk_unit = { UDATA (&dsk_svc, UNIT_FIX+UNIT_ATTABLE, DSK_SIZE) };
REG dsk_reg[] = {
{ BRDATA (BUF, dsk_buf, 8, 24, DSK_NUMWD) },
{ DRDATA (BPTR, dsk_bptr, 9), PV_LEFT },
{ DRDATA (BLNT, dsk_bptr, 9), PV_LEFT },
{ ORDATA (DA, dsk_da, 21) },
{ ORDATA (INST, dsk_op, 24) },
{ FLDATA (XFR, xfr_req, XFR_V_DSK) },
{ FLDATA (ERR, dsk_err, 0) },
{ DRDATA (WTIME, dsk_time, 24), REG_NZ + PV_LEFT },
{ DRDATA (STIME, dsk_stime,24), REG_NZ + PV_LEFT },
{ FLDATA (STOP_IOE, dsk_stopioe, 0) },
{ NULL }
};
MTAB dsk_mod[] = {
{ UNIT_WLK, 0, "write enabled", "WRITEENABLED", NULL },
{ UNIT_WLK, UNIT_WLK, "write locked", "LOCKED", NULL },
{ MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",
&set_chan, &show_chan, NULL },
{ 0 }
};
DEVICE dsk_dev = {
"DSK", &dsk_unit, dsk_reg, dsk_mod,
1, 8, 24, 1, 8, 27,
NULL, NULL, &dsk_reset,
NULL, NULL, NULL,
&dsk_dib, DEV_DISABLE
};
/* Moving head disk routine
conn - inst = EOM0, dat = NULL
eom1 - inst = EOM1, dat = NULL
sks - inst = SKS, dat = ptr to result
disc - inst = device number, dat = NULL
wreor - inst = device number, dat = NULL
read - inst = device number, dat = ptr to data
write - inst = device number, dat = ptr to result
*/
t_stat dsk (uint32 fnc, uint32 inst, uint32 *dat)
{
int32 i, t, new_ch, dsk_wptr, dsk_byte;
t_stat r;
switch (fnc) { /* case on function */
case IO_CONN: /* connect */
new_ch = I_GETEOCH (inst); /* get new chan */
if (new_ch != dsk_dib.chan) /* wrong chan? */
return SCPE_IERR;
dsk_op = inst; /* save instr */
dsk_bptr = dsk_blnt = 0; /* init ptrs */
for (i = 0; i < DSK_NUMWD; i++) /* clear buffer */
dsk_buf[i] = 0;
xfr_req = xfr_req & ~XFR_DSK; /* clr xfr flg */
sim_activate (&dsk_unit, dsk_stime); /* activate */
break;
case IO_EOM1: /* EOM mode 1 */
new_ch = I_GETEOCH (inst); /* get new chan */
if (new_ch != dsk_dib.chan) /* wrong chan? */
return SCPE_IERR;
if (inst & 07600) /* inv inst? */
CRETIOP;
alert = POT_DSK; /* alert */
break;
case IO_DISC: /* disconnect */
dsk_end_op (0); /* normal term */
if (inst & DEV_OUT)
return dsk_fill (inst); /* fill write */
break;
case IO_WREOR: /* write eor */
dsk_end_op (CHF_EOR); /* eor term */
return dsk_fill (inst); /* fill write */
case IO_SKS: /* SKS */
new_ch = I_GETSKCH (inst); /* sks chan */
if (new_ch != dsk_dib.chan)
return SCPE_IERR; /* wrong chan? */
t = I_GETSKCND (inst); /* sks cond */
if (((t == 000) && !sim_is_active (&dsk_unit) &&/* 10026: ready */
(dsk_unit.flags & UNIT_ATT)) ||
((t == 004) && !dsk_err && /* 11026: !err */
(dsk_unit.flags & UNIT_ATT)) ||
((t == 010) && ((dsk_unit.cyl & DSK_SIP) == 0)) || /* 12026: on trk */
((t == 014) && !(dsk_unit.flags & UNIT_WPRT)) || /* 13026: !wrprot */
((t == 001) && (dsk_unit.flags & UNIT_ATT))) /* 10226: online */
*dat = 1;
break;
case IO_READ:
xfr_req = xfr_req & ~XFR_DSK; /* clr xfr req */
if (dsk_bptr >= dsk_blnt) { /* no more data? */
if ((r = dsk_read_buf (inst))) /* read sector */
return r;
}
dsk_wptr = dsk_bptr >> 2; /* word pointer */
dsk_byte = dsk_bptr & 03; /* byte in word */
*dat = (dsk_buf[dsk_wptr] >> ((3 - dsk_byte) * 6)) & 077;
dsk_bptr = dsk_bptr + 1; /* incr buf ptr */
if ((dsk_bptr >= dsk_blnt) && /* end sector, */
((dsk_op & CHC_BIN) || DSK_ENDCHN (dsk_buf[0])))/* sec mode | eoch? */
dsk_end_op (CHF_EOR); /* eor term */
break;
case IO_WRITE:
xfr_req = xfr_req & ~XFR_DSK; /* clr xfr req */
if (dsk_bptr >= (DSK_NUMWD * 4)) { /* full? */
if ((r = dsk_write_buf (inst))) /* write sector */
return r;
}
dsk_wptr = dsk_bptr >> 2; /* word pointer */
dsk_buf[dsk_wptr] = ((dsk_buf[dsk_wptr] << 6) | (*dat & 077)) & DMASK;
dsk_bptr = dsk_bptr + 1; /* incr buf ptr */
break;
default:
CRETINS;
}
return SCPE_OK;
}
/* PIN routine - return disk address */
t_stat pin_dsk (uint32 num, uint32 *dat)
{
*dat = dsk_da; /* ret disk addr */
return SCPE_OK;
}
/* POT routine - start seek */
t_stat pot_dsk (uint32 num, uint32 *dat)
{
int32 st;
if (sim_is_active (&dsk_unit)) /* busy? wait */
return STOP_IONRDY;
dsk_da = (*dat) & DSK_AMASK; /* save dsk addr */
st = abs (DSK_GETTR (dsk_da) - /* calc seek time */
(dsk_unit.cyl & DSK_M_TR)) * dsk_stime;
if (st == 0 /* min time */
) st = dsk_stime;
sim_activate (&dsk_unit, st); /* set timer */
dsk_unit.cyl = dsk_unit.cyl | DSK_SIP; /* seeking */
return SCPE_OK;
}
/* Unit service and read/write */
t_stat dsk_svc (UNIT *uptr)
{
if (uptr->cyl & DSK_SIP) { /* end seek? */
uptr->cyl = DSK_GETTR (dsk_da); /* on cylinder */
if (dsk_op) /* sched r/w */
sim_activate (&dsk_unit, dsk_stime);
}
else {
xfr_req = xfr_req | XFR_DSK; /* set xfr req */
sim_activate (&dsk_unit, dsk_time); /* activate */
}
return SCPE_OK;
}
/* Read sector */
t_stat dsk_read_buf (uint32 dev)
{
int32 da, pkts, awc;
if ((dsk_unit.flags & UNIT_ATT) == 0) { /* !attached? */
dsk_end_op (CHF_ERR | CHF_EOR); /* disk error */
CRETIOE (dsk_stopioe, SCPE_UNATT);
}
da = dsk_da * DSK_NUMWD * sizeof (uint32);
fseek (dsk_unit.fileref, da, SEEK_SET); /* locate sector */
awc = fxread (dsk_buf, sizeof (uint32), DSK_NUMWD, dsk_unit.fileref);
if (ferror (dsk_unit.fileref)) { /* error? */
dsk_end_op (CHF_ERR | CHF_EOR); /* disk error */
return SCPE_IOERR;
}
for ( ; awc < DSK_NUMWD; awc++)
dsk_buf[awc] = 0;
pkts = DSK_GETPKT (dsk_buf[0]); /* get packets */
dsk_blnt = pkts * DSK_PKTWD * 4; /* new buf size */
dsk_bptr = 0; /* init bptr */
dsk_da = (dsk_da + 1) & DSK_AMASK; /* incr disk addr */
return SCPE_OK;
}
/* Write sector. If this routine is called directly, then the sector
buffer is full, and there is at least one more character to write;
therefore, there are 4 packets in the sector, and the sector is not
the end of the chain.
*/
t_stat dsk_write_buf (uint32 dev)
{
int32 i, da;
if ((dsk_unit.flags & UNIT_ATT) == 0) { /* !attached? */
dsk_end_op (CHF_ERR | CHF_EOR); /* disk error */
CRETIOE (dsk_stopioe, SCPE_UNATT);
}
if (dsk_unit.flags & UNIT_WPRT) { /* write prot? */
dsk_end_op (CHF_ERR | CHF_EOR); /* disk error */
return SCPE_OK;
}
da = dsk_da * DSK_NUMWD * sizeof (uint32);
fseek (dsk_unit.fileref, da, SEEK_SET); /* locate sector */
fxwrite (dsk_buf, sizeof (uint32), DSK_NUMWD, dsk_unit.fileref);
if (ferror (dsk_unit.fileref)) { /* error? */
dsk_end_op (CHF_ERR | CHF_EOR); /* disk error */
return SCPE_IOERR;
}
dsk_bptr = 0; /* init bptr */
dsk_da = (dsk_da + 1) & DSK_AMASK; /* incr disk addr */
for (i = 0; i < DSK_NUMWD; i++) /* clear buffer */
dsk_buf[i] = 0;
return SCPE_OK;
}
/* Fill incomplete sector at end of operation. Calculate the number
of packets and set the end of chain flag.
*/
t_stat dsk_fill (uint32 dev)
{
int32 nochn = (dsk_op & CHC_BIN)? 0: 1; /* chain? */
int32 pktend = (dsk_bptr + ((DSK_PKTWD * 4) - 1)) & /* end pkt */
~((DSK_PKTWD * 4) - 1);
int32 pkts = pktend / (DSK_PKTWD * 4); /* # packets */
if (dsk_bptr == 0) /* no fill? */
return SCPE_OK;
for ( ; dsk_bptr < pktend; dsk_bptr++) { /* fill packet */
int32 dsk_wptr = dsk_bptr >> 2;
dsk_buf[dsk_wptr] = (dsk_buf[dsk_wptr] << 6) & DMASK;
}
dsk_buf[0] = dsk_buf[0] | (nochn << DSK_V_CHN) | /* insert chain, */
((4 - pkts) << DSK_V_PKT); /* num pkts */
return dsk_write_buf (dev); /* write sec */
}
/* Terminate DSK operation */
void dsk_end_op (uint32 fl)
{
if (fl) /* set flags */
chan_set_flag (dsk_dib.chan, fl);
dsk_op = 0; /* clear op */
xfr_req = xfr_req & ~XFR_DSK; /* clear xfr */
sim_cancel (&dsk_unit); /* stop */
if (fl & CHF_ERR) { /* error? */
chan_disc (dsk_dib.chan); /* disconnect */
dsk_err = 1; /* set disk err */
}
return;
}
/* Reset routine */
t_stat dsk_reset (DEVICE *dptr)
{
int32 i;
chan_disc (dsk_dib.chan); /* disconnect */
dsk_da = 0; /* clear state */
dsk_op = 0;
dsk_err = 0;
dsk_bptr = dsk_blnt = 0;
xfr_req = xfr_req & ~XFR_DSK; /* clr xfr req */
sim_cancel (&dsk_unit); /* deactivate */
dsk_unit.cyl = 0;
for (i = 0; i < DSK_NUMWD; i++) /* clear buffer */
dsk_buf[i] = 0;
return SCPE_OK;
}
Reference in a new issue View git blame Copy permalink