github.com/simh.simh
1
0
Fork 0
mirror of https://github.com/simh/simh.git synced 2026-01-26 20:12:23 +00:00
Code Releases Activity

PDP11, PDP10, 3B2, All VAXen: Leverage extended disk support for all disks

Browse Source 
Disk container metadata is fully supported and, when possible, containers
can be moved between "reasonable" alternate DEVICEs and systems.
This commit is contained in:
Mark Pizzolato
2022-06-15 15:14:42 -07:00
parent a9ce7b3b11
commit 12e51eafaf
19 changed files with 753 additions and 1338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

119
PDP11/pdp11_hk.c
View File

@@ -71,40 +71,30 @@ extern uint32 cpu_opt;
#include "sim_disk.h"
#define HK_NUMDR 8 /* #drives */
#define HK_NUMCY6 411 /* cyl/drive */
#define HK_NUMCY7 815 /* cyl/drive */
#define RK06_NUMCYL 411 /* cyl/drive */
#define RK07_NUMCYL 815 /* cyl/drive */
#define HK_NUMSF 3 /* tracks/cyl */
#define HK_NUMSC 22 /* sectors/track */
#define HK_NUMWD 256 /* words/sector */
#define RK06_SIZE (HK_NUMCY6*HK_NUMSF*HK_NUMSC*HK_NUMWD)
#define RK07_SIZE (HK_NUMCY7*HK_NUMSF*HK_NUMSC*HK_NUMWD)
#define HK_SIZE(x) (((x)->flags & UNIT_DTYPE)? RK07_SIZE: RK06_SIZE)
#define HK_CYL(x) (((x)->flags & UNIT_DTYPE)? HK_NUMCY7: HK_NUMCY6)
#define RK06_SIZE (RK06_NUMCYL*HK_NUMSF*HK_NUMSC) /* sectors/drive */
#define RK07_SIZE (RK07_NUMCYL*HK_NUMSF*HK_NUMSC) /* sectors/drive */
#define HK_SIZE(x) ((x)->drvtyp->size)
#define HK_CYL(x) ((x)->drvtyp->cyl)
#define HK_MAXFR (1 << 16)
struct drvtyp {
int32 sect; /* sectors */
int32 surf; /* surfaces */
int32 cyl; /* cylinders */
int32 size; /* #blocks */
const char *name; /* device type name */
};
#define HK_DRV(d) \
{ HK_NUMSC, HK_NUMSF, d##_NUMCYL, d##_SIZE, #d, 512 }
static struct drvtyp drv_tab[] = {
{ HK_NUMSC, HK_NUMSF, HK_NUMCY6, RK06_SIZE, "RK06" },
{ HK_NUMSC, HK_NUMSF, HK_NUMCY7, RK07_SIZE, "RK07" },
static DRVTYP drv_tab[] = {
HK_DRV (RK06),
HK_DRV (RK07),
{ 0 }
};
/* Flags in the unit flags word */
#define UNIT_V_DTYPE (DKUF_V_UF + 0) /* disk type */
#define UNIT_V_DUMMY (UNIT_V_DTYPE + 1) /* dummy flag */
#define UNIT_DTYPE (1 << UNIT_V_DTYPE)
#define UNIT_RK06 (0 << UNIT_V_DTYPE)
#define UNIT_RK07 (1 << UNIT_V_DTYPE)
#define UNIT_V_DUMMY (DKUF_V_UF + 0) /* dummy flag */
#define UNIT_DUMMY (1 << UNIT_V_DUMMY)
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & 1)
#define UNIT_NOAUTO DKUF_NOAUTOSIZE
/* Parameters in the unit descriptor */
@@ -551,7 +541,7 @@ int32 hkof = 0; /* offset */
int32 hkmr = 0; /* maint registers */
int32 hkmr2 = 0;
int32 hkmr3 = 0;
int32 hkdc = 0; /* cylinder */
uint32 hkdc = 0; /* cylinder */
int32 hkspr = 0; /* spare */
int32 hkci = 0; /* ctlr interrupt */
int32 hkdi = 0; /* drive interrupt */
@@ -580,8 +570,6 @@ void update_hkcs (int32 flags, int32 drv);
void update_hkds (int32 drv);
void hk_err (int32 cs1e, int32 cs2e, int32 drve, int32 drv);
void hk_go (int32 drv);
t_stat hk_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat hk_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat hk_set_bad (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat hk_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
const char *hk_description (DEVICE *dptr);
@@ -601,24 +589,7 @@ DIB hk_dib = {
1, IVCL (HK), VEC_AUTO, { &hk_inta }, IOLN_HK,
};
UNIT hk_unit[] = {
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) },
{ UDATA (&hk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE+UNIT_RK06, RK06_SIZE) }
};
UNIT hk_unit[HK_NUMDR] = {{0}};
REG hk_reg[] = {
{ GRDATADF (HKCS1, hkcs1, DEV_RDX, 16, 0, "control/status 1", hk_cs1_bits) },
@@ -666,12 +637,6 @@ MTAB hk_mod[] = {
&set_writelock, NULL, NULL, "Write lock tape drive" },
{ UNIT_DUMMY, 0, NULL, "BADBLOCK",
&hk_set_bad, NULL, NULL, "write bad block table on last track" },
{ MTAB_XTD|MTAB_VUN, 0, NULL, "RK06",
&hk_set_type, NULL, NULL, "Set RK06 Disk Type" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "RK07",
&hk_set_type, NULL, NULL, "Set RK07 Disk Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &hk_show_type, NULL, "Display device type" },
{ UNIT_NOAUTO, 0, "autosize", "AUTOSIZE",
NULL, NULL, NULL, "Set type based on file size at attach" },
{ UNIT_NOAUTO, UNIT_NOAUTO, "noautosize", "NOAUTOSIZE",
@@ -702,7 +667,7 @@ DEVICE hk_dev = {
&hk_boot, &hk_attach, &hk_detach,
&hk_dib, DEV_DISABLE | DEV_UBUS | DEV_Q18 | DEV_DISK | DEV_DEBUG, 0,
hk_deb, NULL, NULL, &hk_help, NULL, NULL,
&hk_description
&hk_description, NULL, &drv_tab
};
/* I/O dispatch routines, I/O addresses 17777440 - 17777476 */
@@ -947,7 +912,7 @@ fnc = GET_FNC (hkcs1);
sim_debug (HKDEB_OPS, &hk_dev, ">>HK%d strt: fnc=%s, cs1=%o, cs2=%o, ds=%o, er=%o, cyl=%o, da=%o, ba=%o, wc=%o\n",
drv, hk_funcs[fnc], hkcs1, hkcs2, hkds[drv], hker[drv], hkdc, hkda, hkba, hkwc);
uptr = hk_dev.units + drv; /* get unit */
dte = ((hkcs1 & CS1_DT) !=0) != ((uptr->flags & UNIT_DTYPE) != 0);
dte = ((hkcs1 & CS1_DT) !=0) != (strcasecmp (uptr->drvtyp->name, "RK07") == 0);
if (fnc != FNC_NOP) /* !nop, clr msg sel */
hkmr = hkmr & ~MR_MS;
@@ -1067,10 +1032,10 @@ return;
t_stat hk_svc (UNIT *uptr)
{
int32 i, t, dc, fnc;
int32 t, dc, fnc;
t_seccnt sectsread;
t_stat err = 0;
int32 wc, awc, da;
uint32 i, wc, awc, da;
uint32 drv, ba;
uint16 comp;
DEVICE *dptr = find_dev_from_unit (uptr);
@@ -1148,11 +1113,11 @@ switch (fnc) { /* case on function */
da = GET_DA (hkdc, hkda) * HK_NUMWD; /* get disk addr */
wc = 0200000 - hkwc; /* get true wc */
if ((da + wc) > HK_SIZE (uptr)) { /* disk overrun? */
if ((da + wc) > uptr->capac) { /* disk overrun? */
hker[drv] = hker[drv] | ER_AOE; /* set err */
hkds[drv] = hkds[drv] | DS_ATA; /* set attn */
wc = HK_SIZE (uptr) - da; /* trim xfer */
if (da >= HK_SIZE (uptr)) { /* none left? */
wc = (int32)(uptr->capac - da); /* trim xfer */
if (da >= uptr->capac) { /* none left? */
update_hkcs (CS1_DONE, drv); /* then done */
break;
}
@@ -1317,7 +1282,7 @@ if (hk_unit[drv].flags & UNIT_DIS) { /* disabled? */
}
sim_debug (HKDEB_TRC, &hk_dev, "update_hkds(drv=%d)\n", drv);
hkds[drv] = (hkds[drv] & (DS_VV | DS_PIP | DS_ATA)) | DS_VLD | DS_DRA;
if (hk_unit[drv].flags & UNIT_RK07)
if (strcasecmp(hk_unit[drv].drvtyp->name, "RK07") == 0)
hkds[drv] = hkds[drv] | DS_DT;
if (hk_unit[drv].flags & UNIT_ATT) { /* attached? */
if (!sim_is_active (&hk_unit[drv])) /* not busy? */
@@ -1391,7 +1356,7 @@ switch (msg) {
((hkds[drv] & DS_PIP)? A0_PIP: 0) |
((uptr->flags & UNIT_WPRT)? A0_WRL: 0) |
((hk_off[drv])? A0_OF: 0) |
((uptr->flags & UNIT_RK07)? A0_DT: 0) |
((strcasecmp(uptr->drvtyp->name, "RK07") == 0)? A0_DT: 0) |
((hkds[drv] & DS_VV)? A0_VV: 0) | A0_DRA;
if (uptr->flags & UNIT_ATT)
v = v | A0_SPO | (!sim_is_active (uptr)? A0_RDY: 0);
@@ -1468,8 +1433,20 @@ t_stat hk_reset (DEVICE *dptr)
{
int32 i;
UNIT *uptr;
static t_bool inited = FALSE;
sim_debug (HKDEB_TRC, &hk_dev, "hk_reset()\n");
if (!inited) {
inited = TRUE;
for (i = 0; i < HK_NUMDR; i++) {
uptr = dptr->units + i;
uptr->action = &hk_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE;
sim_disk_set_drive_type_by_name (uptr, "RK06");
}
}
hkcs1 = CS1_DONE; /* set done */
hkcs2 = CS2_IR; /* clear state */
hkmr = hkmr2 = hkmr3 = 0;
@@ -1503,20 +1480,19 @@ t_stat hk_attach (UNIT *uptr, CONST char *cptr)
uint32 drv;
t_stat r;
int32 old_hkds;
static const char *drives[] = {"RK06", "RK07", NULL};
uptr->capac = HK_SIZE (uptr);
r = sim_disk_attach_ex (uptr, cptr, HK_NUMWD * sizeof (uint16),
sizeof (uint16), TRUE, 0,
(uptr->capac == RK06_SIZE) ? "RK06" : "RK07", HK_NUMSC, 0,
(uptr->flags & UNIT_NOAUTO) ? NULL : drives);
NULL);
if (r != SCPE_OK) /* error? */
return r;
drv = (uint32) (uptr - hk_dev.units); /* get drv number */
old_hkds = hkds[drv]; /* save hkds */
hkds[drv] = DS_ATA | DS_RDY |
((uptr->flags & UNIT_WPRT)? DS_WRL: 0) |
((uptr->flags & UNIT_DTYPE)? DS_DT: 0);
((strcasecmp (uptr->drvtyp->name, "RK07") == 0)? DS_DT: 0);
hker[drv] = 0; /* upd drv status */
hk_off[drv] = 0;
hk_dif[drv] = 0;
@@ -1549,27 +1525,6 @@ if ((old_hkds & DS_ATA) == 0) /* ATN transition? */
return sim_disk_detach (uptr);
}
/* Set type command validation routine */
t_stat hk_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if ((val < 0) || (cptr && *cptr))
return SCPE_ARG;
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
uptr->capac = (t_addr)drv_tab[val].size;
return SCPE_OK;
}
/* Show unit type */
t_stat hk_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", drv_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
/* Set bad block routine */
t_stat hk_set_bad (UNIT *uptr, int32 val, CONST char *cptr, void *desc)

85
PDP11/pdp11_rc.c
View File

@@ -74,12 +74,10 @@
#error "RC11 is not supported!"
#endif
#include "pdp11_defs.h"
#include <math.h>
#include "sim_disk.h"
#include <math.h>
#define UNIT_V_PLAT (DKUF_V_UF + 0) /* #platters - 1 */
#define UNIT_M_PLAT 03
#define UNIT_GETP(x) ((((x) >> UNIT_V_PLAT) & UNIT_M_PLAT) + 1)
#define UNIT_GETP(u) ((u)->capac / (RC_NUMWD * RC_NUMSC * RC_NUMCY))
#define UNIT_NOAUTO DKUF_NOAUTOSIZE
#define UNIT_PLAT (UNIT_M_PLAT << UNIT_V_PLAT)
@@ -87,11 +85,25 @@
#define RC_NUMWD 32 /* words/sector */
#define RC_NUMSC 64 /* sectors/track */
#define RC_NUMTR 32 /* tracks/disk */
#define RC_DKSIZE (RC_NUMTR * RC_NUMWD * RC_NUMSC)/* words/disk */
#define RC_NUMCY 32 /* tracks/disk */
#define RC_DKSIZE (RC_NUMCY * RC_NUMSC) /* sectors/disk */
#define RC_NUMDK 4 /* disks/controller */
#define RC_WMASK (RC_NUMWD * RC_NUMSC - 1) /* word mask */
#define RC_DRV(d) \
{ RC_NUMSC, d, RC_NUMCY, RC_NUMCY * RC_NUMSC * d, \
#d "P", RC_NUMWD * 2, 0, NULL, 0, 0, NULL, \
"Set to " #d " platter device" }
static DRVTYP drv_tab[] = {
RC_DRV(1),
RC_DRV(2),
RC_DRV(3),
RC_DRV(4),
{ 0 }
};
/* Parameters in the unit descriptor */
#define FUNC u4 /* function */
@@ -146,7 +158,7 @@
/* extract memory extension address (bits 17,18) */
#define GET_MEX(x) (((x) & RCCS_MEX) << (16 - RCCS_V_MEX))
#define GET_POS(x) ((int) fmod (sim_gtime() / ((double) (x)), \
((double) (RC_NUMWD * RC_NUMSC))))
((double) RC_NUMSC)))
extern int32 R[];
@@ -169,8 +181,6 @@ static t_stat rc_wr (int32, int32, int32);
static t_stat rc_svc (UNIT *);
static t_stat rc_reset (DEVICE *);
static t_stat rc_attach (UNIT *, CONST char *);
static t_stat rc_set_size (UNIT *, int32, CONST char *, void *);
static t_stat rc_show_size (FILE *, UNIT *, int32, CONST void *);
static uint32 update_rccs (uint32, uint32);
static const char *rc_description (DEVICE *dptr);
@@ -191,10 +201,7 @@ static DIB rc_dib = {
1, IVCL (RC), VEC_AUTO, { NULL }, IOLN_RC,
};
static UNIT rc_unit = {
UDATA (&rc_svc, UNIT_FIX + UNIT_ATTABLE + UNIT_BUFABLE +
UNIT_MUSTBUF + UNIT_ROABLE + UNIT_BINK, RC_DKSIZE)
};
static UNIT rc_unit = {0};
static const REG rc_reg[] = {
{ ORDATA (RCLA, rc_la, 16) },
@@ -218,16 +225,8 @@ static const REG rc_reg[] = {
};
static const MTAB rc_mod[] = {
{ UNIT_PLAT, (0 << UNIT_V_PLAT), NULL, "1P",
&rc_set_size, NULL, NULL, "Set to 1 platter device" },
{ UNIT_PLAT, (1 << UNIT_V_PLAT), NULL, "2P",
&rc_set_size, NULL, NULL, "Set to 2 platter device" },
{ UNIT_PLAT, (2 << UNIT_V_PLAT), NULL, "3P",
&rc_set_size, NULL, NULL, "Set to 3 platter device" },
{ UNIT_PLAT, (3 << UNIT_V_PLAT), NULL, "4P",
&rc_set_size, NULL, NULL, "Set to 4 platter device" },
{ MTAB_XTD|MTAB_VUN, 0, "PLATTERS", NULL,
NULL, &rc_show_size, NULL, "Display Platters" },
NULL, &sim_disk_show_drive_type, NULL, "Display Platters" },
{ UNIT_NOAUTO, 0, "autosize", "AUTOSIZE",
NULL, NULL, NULL, "set platters based on file size at ATTACH" },
{ UNIT_NOAUTO, UNIT_NOAUTO, "noautosize", "NOAUTOSIZE",
@@ -251,7 +250,7 @@ DEVICE rc_dev = {
&rc_dib,
DEV_DISABLE | DEV_DIS | DEV_UBUS | DEV_DEBUG | DEV_DISK, 0,
NULL, NULL, NULL, NULL, NULL, NULL,
&rc_description
&rc_description, NULL, &drv_tab
};
/* I/O dispatch routine, I/O addresses 17777440 - 17777456 */
@@ -342,7 +341,7 @@ static t_stat rc_wr (int32 data, int32 PA, int32 access)
rc_cs &= ~RCCS_NED;
update_rccs (0, 0);
/* perform unit select */
if (((rc_da >> 11) & 03) >= UNIT_GETP(rc_unit.flags))
if (((rc_da >> 11) & 03) >= UNIT_GETP(&rc_unit))
update_rccs (RCCS_NED, 0);
else
rc_la = rc_da;
@@ -461,7 +460,7 @@ static t_stat rc_svc (UNIT *uptr)
}
ma = GET_MEX (rc_cs) | rc_ca; /* 18b mem addr */
da = rc_da * RC_NUMTR; /* sector->word offset */
da = rc_da * RC_NUMCY; /* sector->word offset */
u_old = (da >> 16) & 03; /* save starting unit# */
do {
u_new = (da >> 16) & 03;
@@ -469,7 +468,7 @@ static t_stat rc_svc (UNIT *uptr)
update_rccs (RCCS_NED, RCER_OVFL);
break;
}
if (u_new >= UNIT_GETP(uptr->flags)) { /* disk overflow? */
if (u_new >= UNIT_GETP(uptr)) { /* disk overflow? */
update_rccs (RCCS_NED, 0);
break;
}
@@ -554,6 +553,14 @@ static uint32 update_rccs (uint32 newcs, uint32 newer)
static t_stat rc_reset (DEVICE *dptr)
{
static t_bool inited = FALSE;
if (!inited) {
inited = TRUE;
rc_unit.action = &rc_svc;
rc_unit.flags = UNIT_FIX | UNIT_ATTABLE | UNIT_BUFABLE | UNIT_MUSTBUF | UNIT_ROABLE | UNIT_BINK;
sim_disk_set_drive_type_by_name (&rc_unit, "1P");
}
rc_cs = RCCS_DONE;
rc_la = rc_da = 0;
rc_er = 0;
@@ -570,32 +577,8 @@ static t_stat rc_reset (DEVICE *dptr)
static t_stat rc_attach (UNIT *uptr, CONST char *cptr)
{
static const char *platters[] = {"1P", "2P", "3P", "4P", NULL};
char plat[32];
sprintf (plat, "%dP", UNIT_GETP (uptr->flags));
return sim_disk_attach_ex (uptr, cptr, RC_NUMWD * sizeof (uint16), sizeof (uint16),
TRUE, 0, plat, FALSE, 0, (uptr->flags & UNIT_NOAUTO) ? NULL : platters);
}
/* Change disk size */
static t_stat rc_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if (val < 0)
return (SCPE_IERR);
if (uptr->flags & UNIT_ATT)
return (SCPE_ALATT);
uptr->capac = UNIT_GETP (val) * RC_DKSIZE;
uptr->flags = uptr->flags | UNIT_NOAUTO;
return (SCPE_OK);
}
static t_stat rc_show_size (FILE *st, UNIT *uptr, int32 flag, CONST void *desc)
{
fprintf (st, "%dP", UNIT_GETP (uptr->flags));
return SCPE_OK;
TRUE, 0, uptr->drvtyp->name, FALSE, 0, NULL);
}
static const char *rc_description (DEVICE *dptr)

77
PDP11/pdp11_rk.c
View File

@@ -104,24 +104,19 @@
#define RK_NUMTR (RK_NUMCY * RK_NUMSF) /* tracks/drive */
#define RK_NUMDR 8 /* drives/controller */
#define RK_M_NUMDR 07
#define RK_SIZE (RK_NUMCY * RK_NUMSF * RK_NUMSC * RK_NUMWD)
#define RK_SIZE (RK_NUMCY * RK_NUMSF * RK_NUMSC)
#define RK_RSRVSEC (3 * RK_NUMSF * RK_NUMSC) /* reserved (unused) disk area */
/* words/drive */
#define RK_CTLI 1 /* controller int */
#define RK_SCPI(x) (2u << (x)) /* drive int */
#define RK_MAXFR (1 << 16) /* max transfer */
#define RK_DRV(d) \
{ RK_NUMSC, RK_NUMSF, RK_NUMCY, RK_SIZE, #d, \
RK_NUMWD*2 }
struct drvtyp {
int32 sect; /* sectors */
int32 surf; /* surfaces */
int32 cyl; /* cylinders */
int32 size; /* #blocks */
const char *name; /* device type name */
};
static struct drvtyp drv_tab[] = {
{ RK_NUMSC, RK_NUMSF, RK_NUMCY*2, RK_SIZE, "RK05" },
static DRVTYP drv_tab[] = {
RK_DRV(RK05),
{ 0 }
};
@@ -132,7 +127,6 @@ static struct drvtyp drv_tab[] = {
#define UNIT_HWLK UNIT_WPRT
#define UNIT_SWLK (1u << UNIT_V_SWLK)
#define UNIT_NOAUTO DKUF_NOAUTOSIZE /* autosize disabled */
#define GET_DTYPE(x) (0)
/* Parameters in the unit descriptor */
@@ -354,7 +348,6 @@ void rk_set_done (int32 error);
void rk_clr_done (void);
t_stat rk_boot (int32 unitno, DEVICE *dptr);
t_stat rk_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
t_stat rk_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rk_attach (UNIT *uptr, CONST char *cptr);
t_stat rk_detach (UNIT *uptr);
const char *rk_description (DEVICE *dptr);
@@ -384,24 +377,7 @@ DIB rk_dib = {
1, IVCL (RK), VEC_AUTO, { &rk_inta }, IOLN_RK,
};
UNIT rk_unit[] = {
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) },
{ UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+
UNIT_ROABLE, RK_SIZE) }
};
UNIT rk_unit[RK_NUMDR] = {{0}};
REG rk_reg[] = {
{ ORDATADF (RKCS, rkcs, 16, "control/status", rk_cs_bits) },
@@ -429,8 +405,6 @@ MTAB rk_mod[] = {
&set_writelock, &show_writelock, NULL, "Write enable tape drive" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "LOCKED",
&set_writelock, NULL, NULL, "Write lock tape drive" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rk_show_type, NULL, "Display device type" },
{ UNIT_NOAUTO, 0, "autosize", "AUTOSIZE",
NULL, NULL, NULL, "Set type based on file size at attach" },
{ UNIT_NOAUTO, UNIT_NOAUTO, "noautosize", "NOAUTOSIZE",
@@ -451,7 +425,7 @@ DEVICE rk_dev = {
&rk_boot, &rk_attach, &rk_detach,
&rk_dib, DEV_DISABLE | DEV_UBUS | DEV_Q18 | DEV_DEBUG | RK_DIS | DEV_DISK, 0,
rk_deb, NULL, NULL, &rk_help, NULL, NULL,
&rk_description
&rk_description, NULL, &drv_tab
};
/* I/O dispatch routine, I/O addresses 17777400 - 17777416
@@ -892,6 +866,17 @@ t_stat rk_reset (DEVICE *dptr)
{
int32 i;
UNIT *uptr;
static t_bool inited = FALSE;
if (!inited) {
inited = TRUE;
for (i = 0; i < RK_NUMDR; i++) {
uptr = dptr->units + i;
uptr->action = &rk_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE;
sim_disk_set_drive_type_by_name (uptr, "RK05");
}
}
rkcs = CSR_DONE;
rkda = rkba = rker = rkds = 0;
@@ -916,17 +901,11 @@ return auto_config (0, 0);
t_stat rk_attach (UNIT *uptr, CONST char *cptr)
{
t_stat r;
static const char *drives[] = {"RK05", NULL};
r = sim_disk_attach_ex2 (uptr, cptr, RK_NUMWD * sizeof (uint16),
sizeof (uint16), TRUE, 0,
"RK05", 0, 0,
(uptr->flags & UNIT_NOAUTO) ? NULL: drives,
RK_RSRVSEC);
if (r != SCPE_OK) /* error? */
return r;
return SCPE_OK;
return sim_disk_attach_ex2 (uptr, cptr, RK_NUMWD * sizeof (uint16),
sizeof (uint16), TRUE, 0,
"RK05", 0, 0,
NULL,
RK_RSRVSEC);
}
t_stat rk_detach (UNIT *uptr)
@@ -935,14 +914,6 @@ sim_cancel (uptr);
return sim_disk_detach (uptr);
}
/* Show unit type */
t_stat rk_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", drv_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
/* Device bootstrap */
#if defined (UC15) || !defined (VM_PDP11)

100
PDP11/pdp11_rl.c
View File

@@ -104,23 +104,20 @@
#define RL_NUMWD (128) /* words/sector */
#define RL_NUMSC (40) /* sectors/surface */
#define RL_NUMSF (2) /* surfaces/cylinder */
#define RL_NUMCY (256) /* cylinders/drive */
#define RL01_NUMCYL (256) /* cylinders/drive */
#define RL02_NUMCYL (512) /* cylinders/drive */
#define RL_NUMDR (4) /* drives/controller */
#define RL_MAXFR (RL_NUMSC * RL_NUMWD) /* max transfer */
#define RL01_SIZE (RL_NUMCY * RL_NUMSF * RL_NUMSC * RL_NUMWD) /* words/drive */
#define RL02_SIZE (RL01_SIZE * 2) /* words/drive */
struct drvtyp {
int32 sect; /* sectors */
int32 surf; /* surfaces */
int32 cyl; /* cylinders */
int32 size; /* #blocks */
const char *name; /* device type name */
};
#define RL_DRV(d) \
{ RL_NUMSC, RL_NUMSF, d##_NUMCYL, \
(RL_NUMSC * RL_NUMSF * d##_NUMCYL), \
#d, 256, DRVFL_RMV | DRVFL_TYPE_RL, \
"DL" }
static struct drvtyp drv_tab[] = {
{ RL_NUMSC, RL_NUMSF, RL_NUMCY, RL01_SIZE, "RL01" },
{ RL_NUMSC, RL_NUMSF, RL_NUMCY*2, RL02_SIZE, "RL02" },
static DRVTYP drv_tab[] = {
RL_DRV(RL01),
RL_DRV(RL02),
{ 0 }
};
@@ -132,16 +129,13 @@ static struct drvtyp drv_tab[] = {
/* Flags in the unit flags word */
#define UNIT_V_RL02 (DKUF_V_UF + 0) /* RL01 vs RL02 */
#define UNIT_V_DUMMY (UNIT_V_RL02 + 1) /* dummy flag, for SET BADBLOCK */
#define UNIT_V_DUMMY (DKUF_V_UF + 0) /* dummy flag, for SET BADBLOCK */
#define UNIT_V_OFFL (UNIT_V_DUMMY + 1) /* unit off line */
#define UNIT_V_BRUSH (UNIT_V_OFFL + 1) /* unit has brushes */
#define UNIT_BRUSH (1u << UNIT_V_BRUSH)
#define UNIT_OFFL (1u << UNIT_V_OFFL)
#define UNIT_DUMMY (1u << UNIT_V_DUMMY)
#define UNIT_RL02 (1u << UNIT_V_RL02)
#define UNIT_NOAUTO DKUF_NOAUTOSIZE /* autosize disable */
#define GET_DTYPE(x) (((x) >> UNIT_V_RL02) & 1)
/* Parameters in the unit descriptor */
@@ -280,8 +274,6 @@ t_stat rl_reset (DEVICE *dptr);
void rl_set_done (int32 error);
t_stat rl_boot (int32 unitno, DEVICE *dptr);
t_stat rl_attach (UNIT *uptr, CONST char *cptr);
t_stat rl_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rl_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rl_set_bad (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
static void rlv_maint (void);
t_stat rl_detach (UNIT *uptr);
@@ -311,12 +303,7 @@ static DIB rl_dib = {
IOBA_AUTO, IOLN_RL, &rl_rd, &rl_wr,
1, IVCL (RL), VEC_AUTO, { NULL }, IOLN_RL };
static UNIT rl_unit[] = {
{ UDATA (&rl_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE, RL01_SIZE) },
{ UDATA (&rl_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE, RL01_SIZE) },
{ UDATA (&rl_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE, RL01_SIZE) },
{ UDATA (&rl_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE, RL01_SIZE) }
};
static UNIT rl_unit[RL_NUMDR] = {{0}};
static const REG rl_reg[] = {
{ GRDATAD (RLCS, rlcs, DEV_RDX, 16, 0, "control/status") },
@@ -372,12 +359,6 @@ static const MTAB rl_mod[] = {
&set_writelock, NULL, NULL, "Write lock disk drive" },
{ UNIT_DUMMY, 0, NULL, "BADBLOCK",
&rl_set_bad, NULL, NULL, "Write bad block table on last track" },
{ MTAB_XTD|MTAB_VUN, 0, NULL, "RL01",
&rl_set_type, NULL, NULL, "Set RL01 Disk Type" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "RL02",
&rl_set_type, NULL, NULL, "Set RL02 Disk Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rl_show_type, NULL, "Display device type" },
{ UNIT_NOAUTO, 0, "autosize", "AUTOSIZE",
NULL, NULL, NULL, "Set type based on file size at attach" },
{ UNIT_NOAUTO, UNIT_NOAUTO, "noautosize", "NOAUTOSIZE",
@@ -408,7 +389,7 @@ DEVICE rl_dev = {
&rl_boot, &rl_attach, &rl_detach,
&rl_dib, DEV_DISABLE | DEV_UBUS | DEV_QBUS | DEV_DISK | DEV_DEBUG, 0,
rl_deb, NULL, NULL, &rl_help, NULL, NULL,
&rl_description
&rl_description, NULL, &drv_tab
};
/* Drive states */
@@ -537,8 +518,7 @@ bit is cleared by software. If set, check for interrupts and return.
offs = GET_CYL (rlda); /* offset */
if (rlda & RLDA_SK_DIR) { /* in or out? */
newc = curr + offs; /* out */
maxc = (uptr->flags & UNIT_RL02)?
RL_NUMCY * 2: RL_NUMCY;
maxc = uptr->drvtyp->cyl;
if (newc >= maxc)
newc = maxc - 1;
} else {
@@ -579,7 +559,7 @@ max 17ms for 1 track seek w/head switch
uptr->STAT &= ~RLDS_ERR;
/* develop drive state */
rlmp = (uint16)(uptr->STAT | (uptr->TRK & RLDS_HD));
if (uptr->flags & UNIT_RL02)
if (0 == strcasecmp (uptr->drvtyp->name, "RL02"))
rlmp |= RLDS_RL02;
if (uptr->flags & UNIT_WPRT)
rlmp |= RLDS_WLK;
@@ -1001,7 +981,20 @@ t_stat rl_reset (DEVICE *dptr)
{
int32 i;
UNIT *uptr;
static t_bool inited = FALSE;
if (!inited) {
inited = TRUE;
for (i = 0; i < RL_NUMDR; i++) {
char cmd[CBUFSIZE];
uptr = dptr->units + i;
uptr->action = &rl_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE;
snprintf (cmd, sizeof (cmd), "%s %s", sim_uname (uptr), "RL01");
set_cmd (0, cmd);
}
}
rlcs = CSR_DONE;
rlda = rlba = rlbae = rlmp = rlmp1 = rlmp2 = 0;
CLR_INT (RL);
@@ -1022,13 +1015,10 @@ return auto_config (0, 0);
t_stat rl_attach (UNIT *uptr, CONST char *cptr)
{
t_stat r;
static const char *drives[] = {"RL01", "RL02", NULL};
uptr->capac = (uptr->flags & UNIT_RL02)? RL02_SIZE: RL01_SIZE;
r = sim_disk_attach_ex (uptr, cptr, RL_NUMWD * sizeof (uint16),
sizeof (uint16), TRUE, 0,
(uptr->capac == RL02_SIZE) ? "RL02" : "RL01", RL_NUMSC, 0,
(uptr->flags & UNIT_NOAUTO) ? NULL : drives);
uptr->drvtyp->name, RL_NUMSC, 0, NULL);
if (r != SCPE_OK) /* error? */
return r;
/*
@@ -1047,38 +1037,6 @@ uptr->STAT = RLDS_BHO | RLDS_LOAD;
return sim_disk_detach (uptr);
}
/* Set size routine */
t_stat rl_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
uptr->capac = (val & UNIT_RL02)? RL02_SIZE: RL01_SIZE;
return SCPE_OK;
}
/* Set type command validation routine */
t_stat rl_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if ((val < 0) || (cptr && *cptr))
return SCPE_ARG;
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
uptr->flags = (uptr->flags & ~UNIT_RL02) | (val << UNIT_V_RL02);
uptr->capac = (t_addr)drv_tab[val].size;
return SCPE_OK;
}
/* Show unit type */
t_stat rl_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", drv_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
/* Set bad block routine */

230
PDP11/pdp11_rp.c
View File

@@ -57,13 +57,11 @@
#elif defined (VM_PDP11)
#include "pdp11_defs.h"
#define INIT_DTYPE RM03_DTYPE
#define INIT_SIZE RM03_SIZE
#define INIT_DTYPE "RM03"
#elif defined (VM_VAX)
#include "vax_defs.h"
#define INIT_DTYPE RP06_DTYPE
#define INIT_SIZE RP06_SIZE
#define INIT_DTYPE "RP06"
#define DMASK 0xFFFF
#if (!UNIBUS)
#error "Qbus not supported!"
@@ -74,25 +72,21 @@
#include "sim_disk.h"
#include <math.h>
#define RP_CTRL 0 /* ctrl is RP */
#define RM_CTRL 1 /* ctrl is RM */
#define RP_CTRL DRVFL_TYPE_RP /* ctrl is RP */
#define RM_CTRL DRVFL_TYPE_RM /* ctrl is RM */
#define RP_NUMDR 8 /* #drives */
#define RP_NUMWD 256 /* words/sector */
#define RP_MAXFR (1 << 16) /* max transfer */
#define GET_SECTOR(x,d) ((int) fmod (sim_gtime() / ((double) (x)), \
((double) drv_tab[d].sect)))
((double) d->sect)))
#define RM_OF (MBA_RMASK + 1)
/* Flags in the unit flags word */
#define UNIT_V_DTYPE (DKUF_V_UF + 0) /* disk type */
#define UNIT_M_DTYPE 7
#define UNIT_V_AUTO (DKUF_V_UF + 3) /* autosize */
#define UNIT_V_DUMMY (DKUF_V_UF + 4) /* dummy flag */
#define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE)
#define UNIT_V_AUTO (DKUF_V_UF + 0) /* autosize */
#define UNIT_V_DUMMY (UNIT_V_AUTO + 1) /* dummy flag */
#define UNIT_AUTO (1 << UNIT_V_AUTO)
#define UNIT_DUMMY (1 << UNIT_V_DUMMY)
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & UNIT_M_DTYPE)
/* Parameters in the unit descriptor */
@@ -265,8 +259,8 @@ BITFIELD rp_as_bits[] = {
#define DA_V_SF 8 /* track pos */
#define DA_M_SF 077 /* track mask */
#define DA_MBZ 0140300
#define GET_SC(x) (((x) >> DA_V_SC) & DA_M_SC)
#define GET_SF(x) (((x) >> DA_V_SF) & DA_M_SF)
#define GET_SC(x) (uint32)(((x) >> DA_V_SC) & DA_M_SC)
#define GET_SF(x) (uint32)(((x) >> DA_V_SF) & DA_M_SF)
BITFIELD rp_da_bits[] = {
BITF(SA,5), /* Sector Address */
@@ -341,9 +335,9 @@ BITFIELD rp_of_bits[] = {
#define DC_V_CY 0 /* cylinder pos */
#define DC_M_CY 01777 /* cylinder mask */
#define DC_MBZ 0176000
#define GET_CY(x) (((x) >> DC_V_CY) & DC_M_CY)
#define GET_DA(c,fs,d) ((((GET_CY (c) * drv_tab[d].surf) + \
GET_SF (fs)) * drv_tab[d].sect) + GET_SC (fs))
#define GET_CY(x) (uint32)(((x) >> DC_V_CY) & DC_M_CY)
#define GET_DA(c,fs,d) ((((GET_CY (c) * d->surf) + \
GET_SF (fs)) * d->sect) + GET_SC (fs))
BITFIELD rp_dc_bits[] = {
BITF(DC,10), /* Offset Direction */
@@ -484,81 +478,62 @@ BITFIELD *rp_reg_bits[] = {
Note: the RP07, despite its designation, belongs to the RM family
*/
#define RM03_DTYPE 0
#define RM03_SECT 32
#define RM03_SURF 5
#define RM03_CYL 823
#define RM03_DEC144 1
#define RM03_DEV 020024
#define RM03_SIZE (RM03_SECT * RM03_SURF * RM03_CYL * RP_NUMWD)
#define RP04_DTYPE 1
#define RP04_SECT 22
#define RP04_SURF 19
#define RP04_CYL 411
#define RP04_DEC144 0
#define RP04_DEV 020020
#define RP04_SIZE (RP04_SECT * RP04_SURF * RP04_CYL * RP_NUMWD)
#define RP05_DTYPE 2
#define RP05_SECT 22
#define RP05_SURF 19
#define RP05_CYL 411
#define RP05_DEC144 0
#define RP05_DEV 020021
#define RP05_SIZE (RP05_SECT * RP05_SURF * RP05_CYL * RP_NUMWD)
#define RM80_DTYPE 3
#define RM80_SECT 31
#define RM80_SURF 14
#define RM80_CYL 559
#define RM80_DEC144 1
#define RM80_DEV 020026
#define RM80_SIZE (RM80_SECT * RM80_SURF * RM80_CYL * RP_NUMWD)
#define RP06_DTYPE 4
#define RP06_SECT 22
#define RP06_SURF 19
#define RP06_CYL 815
#define RP06_DEC144 0
#define RP06_DEV 020022
#define RP06_SIZE (RP06_SECT * RP06_SURF * RP06_CYL * RP_NUMWD)
#define RM05_DTYPE 5
#define RM05_SECT 32
#define RM05_SURF 19
#define RM05_CYL 823
#define RM05_DEC144 1
#define RM05_DEV 020027
#define RM05_SIZE (RM05_SECT * RM05_SURF * RM05_CYL * RP_NUMWD)
#define RP07_DTYPE 6
#define RP07_SECT 50
#define RP07_SURF 32
#define RP07_CYL 630
#define RP07_DEC144 1
#define RP07_DEV 020042
#define RP07_SIZE (RP07_SECT * RP07_SURF * RP07_CYL * RP_NUMWD)
struct drvtyp {
int32 sect; /* sectors */
int32 surf; /* surfaces */
int32 cyl; /* cylinders */
int32 size; /* #blocks */
int32 devtype; /* device type */
int32 dec144; /* DEC Std 144 bad block */
int32 ctrl; /* ctrl type */
const char *name; /* device type name */
};
#define RP_DRV(d, ct) \
{ d##_SECT, d##_SURF, d##_CYL, (d##_SECT * d##_SURF * d##_CYL), \
#d, 512, (d##_DEC144 * DRVFL_DEC144) + ct##_CTRL, \
(ct##_CTRL == RM_CTRL)? "DR" : "DB", \
0, d##_DEV }
static struct drvtyp drv_tab[] = {
{ RM03_SECT, RM03_SURF, RM03_CYL, RM03_SIZE, RM03_DEV, RM03_DEC144, RM_CTRL, "RM03" },
{ RP04_SECT, RP04_SURF, RP04_CYL, RP04_SIZE, RP04_DEV, RP04_DEC144, RP_CTRL, "RP04" },
{ RP05_SECT, RP05_SURF, RP05_CYL, RP05_SIZE, RP05_DEV, RP05_DEC144, RP_CTRL, "RP05" },
{ RM80_SECT, RM80_SURF, RM80_CYL, RM80_SIZE, RM80_DEV, RM80_DEC144, RM_CTRL, "RM80" },
{ RP06_SECT, RP06_SURF, RP06_CYL, RP06_SIZE, RP06_DEV, RP06_DEC144, RP_CTRL, "RP06" },
{ RM05_SECT, RM05_SURF, RM05_CYL, RM05_SIZE, RM05_DEV, RM05_DEC144, RM_CTRL, "RM05" },
{ RP07_SECT, RP07_SURF, RP07_CYL, RP07_SIZE, RP07_DEV, RP07_DEC144, RM_CTRL, "RP07" },
static DRVTYP drv_tab[] = {
RP_DRV (RM03, RM),
RP_DRV (RP04, RP),
RP_DRV (RP05, RP),
RP_DRV (RM80, RM),
RP_DRV (RP06, RP),
RP_DRV (RM05, RM),
RP_DRV (RP07, RM),
{ 0 }
};
@@ -592,8 +567,6 @@ void rp_set_er (int16 flg, int32 drv);
void rp_clr_as (int32 mask);
void rp_update_ds (uint16 flg, int32 drv);
t_stat rp_go (int32 drv);
t_stat rp_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rp_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rp_set_bad (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
int32 rp_abort (void);
t_stat rp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
@@ -612,24 +585,7 @@ const char *rp_description (DEVICE *dptr);
DIB rp_dib = { MBA_AUTO, IOLN_RP, &rp_mbrd, &rp_mbwr, 0, 0, 0, { &rp_abort } };
UNIT rp_unit[] = {
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) },
{ UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+
UNIT_ROABLE+(INIT_DTYPE << UNIT_V_DTYPE), INIT_SIZE) }
};
UNIT rp_unit[RP_NUMDR] = {{0}};
REG rp_reg[] = {
{ BRDATADF (CS1, rpcs1, DEV_RDX, 16, RP_NUMDR, "current operation", rp_cs1_bits) },
@@ -663,22 +619,6 @@ MTAB rp_mod[] = {
&set_writelock, NULL, NULL, "Write lock disk drive" },
{ UNIT_DUMMY, 0, NULL, "BADBLOCK",
&rp_set_bad, NULL, NULL, "write bad block table on last track" },
{ MTAB_XTD|MTAB_VUN, RM03_DTYPE, NULL, "RM03",
&rp_set_type, NULL, NULL, "Set RM03 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RP04_DTYPE, NULL, "RP04",
&rp_set_type, NULL, NULL, "Set RP04 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RP05_DTYPE, NULL, "RP05",
&rp_set_type, NULL, NULL, "Set RP05 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RM80_DTYPE, NULL, "RM80",
&rp_set_type, NULL, NULL, "Set RM80 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RP06_DTYPE, NULL, "RP06",
&rp_set_type, NULL, NULL, "Set RP06 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RM05_DTYPE, NULL, "RM05",
&rp_set_type, NULL, NULL, "Set RM05 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RP07_DTYPE, NULL, "RP07",
&rp_set_type, NULL, NULL, "Set RP07 Disk Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rp_show_type, NULL, "Display device type" },
{ UNIT_AUTO, UNIT_AUTO, "autosize", "AUTOSIZE",
NULL, NULL, NULL, "Set type based on file size at attach" },
{ UNIT_AUTO, 0, "noautosize", "NOAUTOSIZE",
@@ -711,7 +651,7 @@ DEVICE rp_dev = {
&rp_boot, &rp_attach, &rp_detach,
&rp_dib, DEV_DISABLE | DEV_MBUS | DEV_DEBUG | DEV_DISK,
0, rp_debug, NULL, NULL, &rp_help, NULL, NULL,
&rp_description
&rp_description, NULL, &drv_tab
};
const char *rp_regnam[] =
@@ -786,7 +726,7 @@ const char *rp_regnam[] =
t_stat rp_mbrd (int32 *data, int32 ofs, int32 drv)
{
uint32 val, dtype, i;
uint32 val, i;
UNIT *uptr;
rp_update_ds (0, drv); /* update ds */
@@ -795,9 +735,8 @@ if (uptr->flags & UNIT_DIS) { /* nx disk */
*data = 0;
return MBE_NXD;
}
dtype = GET_DTYPE (uptr->flags); /* get drive type */
ofs = ofs & MBA_RMASK; /* mask offset */
if (drv_tab[dtype].ctrl == RM_CTRL) /* RM? convert */
if (DRVFL_GET_IFTYPE(uptr->drvtyp) == RM_CTRL) /* RM? convert */
ofs = ofs + RM_OF;
switch (ofs) { /* decode offset */
@@ -827,7 +766,7 @@ switch (ofs) { /* decode offset */
break;
case RP_LA_OF: case RM_LA_OF: /* RPLA */
val = GET_SECTOR (rp_rwait, dtype) << LA_V_SC;
val = GET_SECTOR (rp_rwait, uptr->drvtyp) << LA_V_SC;
break;
case RP_MR_OF: case RM_MR_OF: /* RPMR */
@@ -835,7 +774,7 @@ switch (ofs) { /* decode offset */
break;
case RP_DT_OF: case RM_DT_OF: /* RPDT */
val = drv_tab[dtype].devtype;
val = uptr->drvtyp->model;
break;
case RP_SN_OF: case RM_SN_OF: /* RPSN */
@@ -883,7 +822,7 @@ switch (ofs) { /* decode offset */
return MBE_NXR;
}
sim_debug(DBG_REG, &rp_dev, "rp_mbrd(drv=%d(%s), %s=0x%X)\n", drv, drv_tab[dtype].name, rp_regnam[ofs], val);
sim_debug(DBG_REG, &rp_dev, "rp_mbrd(drv=%d(%s), %s=0x%X)\n", drv, uptr->drvtyp->name, rp_regnam[ofs], val);
sim_debug_bits(DBG_REG, &rp_dev, rp_reg_bits[ofs], val, val, 1);
*data = val;
@@ -896,9 +835,8 @@ t_stat rp_mbwr (int32 data, int32 ofs, int32 drv)
{
uint32 old_reg;
UNIT *uptr = rp_dev.units + drv; /* get unit */
int32 dtype = GET_DTYPE (uptr->flags); /* get drive type */
sim_debug(DBG_REG, &rp_dev, "rp_mbwr(drv=%d(%s), %s=0x%X)\n", drv, drv_tab[dtype].name, rp_regnam[ofs], data);
sim_debug(DBG_REG, &rp_dev, "rp_mbwr(drv=%d(%s), %s=0x%X)\n", drv, uptr->drvtyp->name, rp_regnam[ofs], data);
if (uptr->flags & UNIT_DIS) /* nx disk */
return MBE_NXD;
@@ -909,7 +847,7 @@ if ((ofs != RP_AS_OF) && sim_is_active (uptr)) { /* unit busy? */
}
rmhr[drv] = (uint16)data; /* save write */
ofs = ofs & MBA_RMASK; /* mask offset */
if (drv_tab[dtype].ctrl == RM_CTRL) /* RM? convert */
if (DRVFL_GET_IFTYPE(uptr->drvtyp) == RM_CTRL) /* RM? convert */
ofs = ofs + RM_OF;
switch (ofs) { /* decode PA<5:1> */
@@ -985,9 +923,8 @@ t_stat rp_go (int32 drv)
int32 dc, fnc, t;
DEVICE *dptr = &rp_dev;
UNIT *uptr = dptr->units + drv; /* get unit */
int32 dtype = GET_DTYPE (uptr->flags); /* get drive type */
sim_debug(DBG_REQ, dptr, "rp_go(drv=%d(%s))\n", drv, drv_tab[dtype].name);
sim_debug(DBG_REQ, dptr, "rp_go(drv=%d(%s))\n", drv, uptr->drvtyp->name);
fnc = GET_FNC (rpcs1[drv]); /* get function */
sim_debug(DBG_REQ, dptr, ">>RP%d STRT: fnc=%s, ds=%o, cyl=%o, da=%o, er=%o\n",
@@ -1006,7 +943,7 @@ switch (fnc) { /* case on function */
case FNC_DCLR: /* drive clear */
rper1[drv] = rper2[drv] = rper3[drv] = 0; /* clear errors */
rpec2[drv] = 0; /* clear EC2 */
if (drv_tab[dtype].ctrl == RM_CTRL) /* RM? */
if (DRVFL_GET_IFTYPE(uptr->drvtyp) == RM_CTRL) /* RM? */
rpmr[drv] = 0; /* clear maint */
else rpec1[drv] = 0; /* RP, clear EC1 */
rpds[drv] = rpds[drv] & ~DS_ERR; /* Clear ERR */
@@ -1034,7 +971,7 @@ switch (fnc) { /* case on function */
return SCPE_OK;
case FNC_UNLOAD: /* unload */
if (drv_tab[dtype].ctrl == RM_CTRL) { /* RM? */
if (DRVFL_GET_IFTYPE(uptr->drvtyp) == RM_CTRL) {/* RM? */
rp_set_er (ER1_ILF, drv); /* not supported */
break;
}
@@ -1049,9 +986,9 @@ switch (fnc) { /* case on function */
rp_set_er (ER1_UNS, drv); /* unsafe */
break;
}
if ((GET_CY (dc) >= drv_tab[dtype].cyl) || /* bad cylinder */
(GET_SF (rpda[drv]) >= drv_tab[dtype].surf) || /* bad surface */
(GET_SC (rpda[drv]) >= drv_tab[dtype].sect)) { /* or bad sector? */
if ((GET_CY (dc) >= uptr->drvtyp->cyl) || /* bad cylinder */
(GET_SF (rpda[drv]) >= uptr->drvtyp->surf) || /* bad surface */
(GET_SC (rpda[drv]) >= uptr->drvtyp->sect)) { /* or bad sector? */
rp_set_er (ER1_IAE, drv);
break;
}
@@ -1072,9 +1009,9 @@ switch (fnc) { /* case on function */
rp_set_er (ER1_UNS, drv); /* unsafe */
break;
}
if ((GET_CY (dc) >= drv_tab[dtype].cyl) || /* bad cylinder */
(GET_SF (rpda[drv]) >= drv_tab[dtype].surf) || /* bad surface */
(GET_SC (rpda[drv]) >= drv_tab[dtype].sect)) { /* or bad sector? */
if ((GET_CY (dc) >= uptr->drvtyp->cyl) || /* bad cylinder */
(GET_SF (rpda[drv]) >= uptr->drvtyp->surf) || /* bad surface */
(GET_SC (rpda[drv]) >= uptr->drvtyp->sect)) { /* or bad sector? */
rp_set_er (ER1_IAE, drv);
break;
}
@@ -1122,17 +1059,17 @@ sim_activate (uptr, 0);
t_stat rp_svc (UNIT *uptr)
{
int32 i, fnc, dtype, drv, err;
int32 wc, abc, awc, mbc, da;
int32 i, fnc, drv, err;
int32 wc, abc, awc, mbc;
uint32 da;
DEVICE *dptr = find_dev_from_unit (uptr);
DIB *dibp = (DIB *) dptr->ctxt;
dtype = GET_DTYPE (uptr->flags); /* get drive type */
drv = (int32) (uptr - rp_dev.units); /* get drv number */
da = GET_DA (rpdc[drv], rpda[drv], dtype) * RP_NUMWD; /* get disk addr */
da = GET_DA (rpdc[drv], rpda[drv], uptr->drvtyp) * RP_NUMWD;/* get disk addr */
fnc = GET_FNC (rpcs1[drv]); /* get function */
sim_debug(DBG_TRC, dptr, "rp_svc(rp%d(%s), %s, da=0x%X, fnc=%s)\n", drv, drv_tab[dtype].name, uptr->io_complete ? "Bottom" : "Top", da, rp_fname[fnc]);
sim_debug(DBG_TRC, dptr, "rp_svc(rp%d(%s), %s, da=0x%X, fnc=%s)\n", drv, uptr->drvtyp->name, uptr->io_complete ? "Bottom" : "Top", da, rp_fname[fnc]);
if ((uptr->flags & UNIT_ATT) == 0) { /* not attached? */
rp_set_er (ER1_UNS, drv); /* set drive error */
@@ -1172,11 +1109,11 @@ if (!uptr->io_complete) { /* Top End (I/O Initiation) Processing */
case FNC_READH: /* read headers */
mbc = rpxbc[drv] = (uint16)mba_get_bc (dibp->ba);/* get byte count */
wc = (mbc + 1) >> 1; /* convert to words */
if ((da + wc) > drv_tab[dtype].size) { /* disk overrun? */
if ((da + wc) > uptr->capac) { /* disk overrun? */
rp_set_er (ER1_AOE, drv); /* set err */
wc = drv_tab[dtype].size - da; /* trim xfer */
wc = (int32)(uptr->capac - da); /* trim xfer */
mbc = wc << 1; /* trim mb count */
if (da >= drv_tab[dtype].size) { /* none left? */
if (da >= uptr->capac) { /* none left? */
mba_set_exc (dibp->ba); /* set exception */
rp_update_ds (DS_ATA, drv); /* set attn */
break;
@@ -1238,13 +1175,13 @@ else { /* Bottom End (After I/O processing) */
else mba_wrbufW (dibp->ba, mbc, rpxb[drv]);/* store in mem */
} /* end if read */
da = da + wc + (RP_NUMWD - 1);
if (da >= drv_tab[dtype].size)
if (da >= uptr->capac)
rpds[drv] = rpds[drv] | DS_LST;
da = da / RP_NUMWD;
rpda[drv] = (uint16)(da % drv_tab[dtype].sect);
da = da / drv_tab[dtype].sect;
rpda[drv] = (uint16)(rpda[drv] | ((da % drv_tab[dtype].surf) << DA_V_SF));
rpdc[drv] = (uint16)(da / drv_tab[dtype].surf);
rpda[drv] = (uint16)(da % uptr->drvtyp->sect);
da = da / uptr->drvtyp->sect;
rpda[drv] = (uint16)(rpda[drv] | ((da % uptr->drvtyp->surf) << DA_V_SF));
rpdc[drv] = (uint16)(da / uptr->drvtyp->surf);
uptr->CYL = rpdc[drv];
if (err != 0) { /* error? */
@@ -1330,10 +1267,20 @@ t_stat rp_reset (DEVICE *dptr)
{
int32 i;
UNIT *uptr;
static t_bool inited = FALSE;
sim_debug(DBG_TRC, dptr, "rp_reset()\n");
mba_set_enbdis (dptr);
if (!inited) {
inited = TRUE;
for (i = 0; i < RP_NUMDR; i++) {
uptr = dptr->units + i;
uptr->action = &rp_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_AUTO|UNIT_ROABLE;
sim_disk_set_drive_type_by_name (uptr, INIT_DTYPE);
}
}
for (i = 0; i < RP_NUMDR; i++) {
uptr = dptr->units + i;
sim_cancel (uptr);
@@ -1341,9 +1288,11 @@ for (i = 0; i < RP_NUMDR; i++) {
if (uptr->flags & UNIT_ATT)
rpds[i] = (rpds[i] & DS_VV) | DS_DPR | DS_RDY | DS_MOL |
((uptr->flags & UNIT_WPRT)? DS_WRL: 0);
else if (uptr->flags & UNIT_DIS)
rpds[i] = 0;
else rpds[i] = DS_DPR;
else
if (uptr->flags & UNIT_DIS)
rpds[i] = 0;
else
rpds[i] = DS_DPR;
rpcs1[i] = 0;
rper1[i] = 0;
rpof[i] = 0;
@@ -1371,14 +1320,12 @@ t_stat rp_attach (UNIT *uptr, CONST char *cptr)
int32 drv;
t_stat r;
DEVICE *dptr = find_dev_from_unit (uptr);
static const char *drives[] = {"RM03", "RP04", "RP05", "RM80", "RP06", "RM05", "RP07", NULL};
uptr->capac = drv_tab[GET_DTYPE (uptr->flags)].size;
r = sim_disk_attach_ex (uptr, cptr, RP_NUMWD * sizeof (uint16),
sizeof (uint16), TRUE, DBG_DSK,
drv_tab[GET_DTYPE (uptr->flags)].name,
drv_tab[GET_DTYPE (uptr->flags)].dec144 ? drv_tab[GET_DTYPE (uptr->flags)].sect : 0,
0, (uptr->flags & UNIT_AUTO) ? drives : NULL);
uptr->drvtyp->name,
(uptr->drvtyp->flags & DRVFL_DEC144) ? uptr->drvtyp->sect : 0,
0, NULL);
if (r != SCPE_OK) /* error? */
return r;
drv = (int32) (uptr - dptr->units); /* get drv number */
@@ -1405,35 +1352,14 @@ if (!sim_is_running) /* from console? */
return sim_disk_detach (uptr);
}
/* Set type command validation routine */
t_stat rp_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if ((val < 0) || (cptr && *cptr))
return SCPE_ARG;
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
uptr->capac = (t_addr)drv_tab[val].size;
return SCPE_OK;
}
/* Show unit type */
t_stat rp_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", drv_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
/* Set bad block routine */
t_stat rp_set_bad (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if (drv_tab[GET_DTYPE (uptr->flags)].dec144)
return pdp11_bad_block (uptr, drv_tab[GET_DTYPE (uptr->flags)].sect, RP_NUMWD);
if (uptr->drvtyp->flags & DRVFL_DEC144)
return pdp11_bad_block (uptr, uptr->drvtyp->sect, RP_NUMWD);
return sim_messagef (SCPE_ARG, "%s: %s disk drives did not have a DEC Standard 144 bad block table\n",
sim_uname (uptr), drv_tab[GET_DTYPE (uptr->flags)].name);
sim_uname (uptr), uptr->drvtyp->name);
}
/* Boot routine */
@@ -1479,7 +1405,7 @@ for (i = 0; i < BOOT_LEN; i++)
WrMemW (BOOT_START + (2 * i), boot_rom[i]);
WrMemW (BOOT_UNIT, unitno & (RP_NUMDR - 1));
WrMemW (BOOT_CSR, mba_get_csr (rp_dib.ba) & DMASK);
if (drv_tab[GET_DTYPE (uptr->flags)].ctrl == RP_CTRL)
if (DRVFL_GET_IFTYPE(uptr->drvtyp) == RP_CTRL)
WrMemW (BOOT_START, 042102); /* "BD" */
else
WrMemW (BOOT_START, 042122); /* "RD" */

403
PDP11/pdp11_rq.c
View File

@@ -157,14 +157,9 @@ extern int32 MMR2;
#define UNIT_V_ONL (DKUF_V_UF + 0) /* online */
#define UNIT_V_ATP (UNIT_V_ONL + 1) /* attn pending */
#define UNIT_V_DTYPE (UNIT_V_ATP + 1) /* drive type */
#define UNIT_W_DTYPE 5 /* 5b drive type encode */
#define UNIT_M_DTYPE ((1u << UNIT_W_DTYPE) - 1)
#define UNIT_ONL (1 << UNIT_V_ONL)
#define UNIT_ATP (1 << UNIT_V_ATP)
#define UNIT_NOAUTO DKUF_NOAUTOSIZE /* noautosize */
#define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE)
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & UNIT_M_DTYPE)
#define cpkt us9 /* current packet */
#define pktq us10 /* packet queue */
#define uf buf /* settable unit flags */
@@ -173,9 +168,9 @@ extern int32 MMR2;
#define io_status u5 /* io status from callback */
#define io_complete u6 /* io completion flag */
#define rqxb up11 /* xfer buffer */
#define RQ_RMV(u) ((drv_tab[GET_DTYPE (u->flags)].flgs & RQDF_RMV)? \
#define RQ_RMV(u) ((u->drvtyp->flags & RQDF_RMV)? \
UF_RMV: 0)
#define RQ_WPH(u) (((drv_tab[GET_DTYPE (u->flags)].flgs & RQDF_RO) || \
#define RQ_WPH(u) (((u->drvtyp->flags & RQDF_RO) || \
(u->flags & UNIT_WPRT) || sim_disk_wrp (u))? UF_WPH: 0)
#define CST_S1 0 /* init stage 1 */
@@ -283,12 +278,14 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
the drive size.
*/
#define RQDF_RMV 001 /* removable */
#define RQDF_RO 002 /* read only */
#define RQDF_SDI 004 /* SDI drive */
#define RQDF_DSSI 010 /* DSSI drive */
#define RQDF_RMV DRVFL_RMV /* removable */
#define RQDF_RO DRVFL_RO /* read only */
#define RQDF_MFM DRVFL_TYPE_MFM /* MFM drive */
#define RQDF_SDI DRVFL_TYPE_SDI /* SDI drive */
#define RQDF_DSSI DRVFL_TYPE_DSSI /* DSSI drive */
#define RQDF_RC DRVFL_TYPE_RC /* RC drive */
#define RX50_DTYPE 0
#define RX50_SECT 10
#define RX50_SURF 1
#define RX50_CYL 80
@@ -302,9 +299,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RX50_RBN 0
#define RX50_MOD 7
#define RX50_MED 0x25658032
#define RX50_FLGS RQDF_RMV
#define RX50_FLGS (RQDF_RMV | RQDF_MFM)
#define RX33_DTYPE 1
#define RX33_SECT 15
#define RX33_SURF 2
#define RX33_CYL 80
@@ -318,9 +314,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RX33_RBN 0
#define RX33_MOD 10
#define RX33_MED 0x25658021
#define RX33_FLGS RQDF_RMV
#define RX33_FLGS (RQDF_RMV | RQDF_MFM)
#define RD51_DTYPE 2
#define RD51_SECT 18
#define RD51_SURF 4
#define RD51_CYL 306
@@ -334,9 +329,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RD51_RBN 144
#define RD51_MOD 6
#define RD51_MED 0x25644033
#define RD51_FLGS 0
#define RD51_FLGS RQDF_MFM
#define RD31_DTYPE 3
#define RD31_SECT 17
#define RD31_SURF 4
#define RD31_CYL 615 /* last unused */
@@ -350,9 +344,9 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RD31_RBN 100
#define RD31_MOD 12
#define RD31_MED 0x2564401F
#define RD31_FLGS 0
#define RD31_FLGS RQDF_MFM
#define RD52_DTYPE 4 /* Quantum params */
/* Quantum drive params */
#define RD52_SECT 17
#define RD52_SURF 8
#define RD52_CYL 512
@@ -366,9 +360,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RD52_RBN 168
#define RD52_MOD 8
#define RD52_MED 0x25644034
#define RD52_FLGS 0
#define RD52_FLGS RQDF_MFM
#define RD53_DTYPE 5
#define RD53_SECT 17
#define RD53_SURF 8
#define RD53_CYL 1024 /* last unused */
@@ -382,9 +375,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RD53_RBN 280
#define RD53_MOD 9
#define RD53_MED 0x25644035
#define RD53_FLGS 0
#define RD53_FLGS RQDF_MFM
#define RD54_DTYPE 6
#define RD54_SECT 17
#define RD54_SURF 15
#define RD54_CYL 1225 /* last unused */
@@ -398,9 +390,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RD54_RBN 609
#define RD54_MOD 13
#define RD54_MED 0x25644036
#define RD54_FLGS 0
#define RD54_FLGS RQDF_MFM
#define RA82_DTYPE 7 /* SDI drive */
#define RA82_SECT 57 /* +1 spare/track */
#define RA82_SURF 15
#define RA82_CYL 1435 /* 0-1422 user */
@@ -414,9 +405,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA82_RBN 21345 /* 1 *15*1423 */
#define RA82_MOD 11
#define RA82_MED 0x25641052
#define RA82_FLGS RQDF_SDI
#define RA82_FLGS RQDF_SDI /* SDI drive */
#define RRD40_DTYPE 8
#define RRD40_SECT 128
#define RRD40_SURF 1
#define RRD40_CYL 10400
@@ -430,9 +420,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RRD40_RBN 0
#define RRD40_MOD 26
#define RRD40_MED 0x25652228
#define RRD40_FLGS (RQDF_RMV | RQDF_RO)
#define RRD40_FLGS (RQDF_RMV | RQDF_RO | RQDF_MFM)
#define RA72_DTYPE 9 /* SDI drive */
#define RA72_SECT 51 /* +1 spare/trk */
#define RA72_SURF 20
#define RA72_CYL 1921 /* 0-1914 user */
@@ -446,9 +435,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA72_RBN 38300 /* 1 *20*1915 */
#define RA72_MOD 37
#define RA72_MED 0x25641048
#define RA72_FLGS RQDF_SDI
#define RA72_FLGS RQDF_SDI /* SDI drive */
#define RA90_DTYPE 10 /* SDI drive */
#define RA90_SECT 69 /* +1 spare/trk */
#define RA90_SURF 13
#define RA90_CYL 2656 /* 0-2648 user */
@@ -462,9 +450,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA90_RBN 34437 /* 1 *13*2649 */
#define RA90_MOD 19
#define RA90_MED 0x2564105A
#define RA90_FLGS RQDF_SDI
#define RA90_FLGS RQDF_SDI /* SDI drive */
#define RA92_DTYPE 11 /* SDI drive */
#define RA92_SECT 73 /* +1 spare/trk */
#define RA92_SURF 13
#define RA92_CYL 3101 /* 0-3098 user */
@@ -478,9 +465,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA92_RBN 40287 /* 1 *13*3099 */
#define RA92_MOD 29
#define RA92_MED 0x2564105C
#define RA92_FLGS RQDF_SDI
#define RA92_FLGS RQDF_SDI /* SDI drive */
#define RA8U_DTYPE 12 /* user defined */
#define RA8U_SECT 57 /* from RA82 */
#define RA8U_SURF 15
#define RA8U_CYL 1435 /* from RA82 */
@@ -488,18 +474,14 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA8U_GPC 1
#define RA8U_XBN 0
#define RA8U_DBN 0
#define RA8U_LBN 1216665 /* from RA82 */
#define RA8U_LBN 4007911 /* larger than all others */
#define RA8U_RCTS 400
#define RA8U_RCTC 8
#define RA8U_RBN 21345
#define RA8U_MOD 11 /* RA82 */
#define RA8U_MED 0x25641052 /* RA82 */
#define RA8U_FLGS RQDF_SDI
#define RA8U_MINC 10000 /* min cap LBNs */
#define RA8U_MAXC 4194303 /* max cap LBNs */
#define RA8U_EMAXC 2147483647 /* ext max cap */
#define RA8U_FLGS (RQDF_SDI | DRVFL_SETSIZE) /* user defined size */
#define RA60_DTYPE 13 /* SDI drive */
#define RA60_SECT 42 /* +1 spare/track */
#define RA60_SURF 6
#define RA60_CYL 1600 /* 0-1587 user */
@@ -513,9 +495,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA60_RBN 9528 /* 1 *6*1588 */
#define RA60_MOD 4
#define RA60_MED 0x22A4103C
#define RA60_FLGS (RQDF_RMV | RQDF_SDI)
#define RA60_FLGS (RQDF_RMV | RQDF_SDI) /* SDI Drive */
#define RA81_DTYPE 14 /* SDI drive */
#define RA81_SECT 51 /* +1 spare/track */
#define RA81_SURF 14
#define RA81_CYL 1258 /* 0-1247 user */
@@ -529,9 +510,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA81_RBN 17472 /* 1 *14*1248 */
#define RA81_MOD 5
#define RA81_MED 0x25641051
#define RA81_FLGS RQDF_SDI
#define RA81_FLGS RQDF_SDI /* SDI Drive */
#define RA71_DTYPE 15 /* SDI drive */
#define RA71_SECT 51 /* +1 spare/track */
#define RA71_SURF 14
#define RA71_CYL 1921 /* 0-1914 user */
@@ -545,9 +525,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA71_RBN 26810 /* 1 *14*1915 */
#define RA71_MOD 40
#define RA71_MED 0x25641047
#define RA71_FLGS RQDF_SDI
#define RA71_FLGS RQDF_SDI /* SDI Drive */
#define RD32_DTYPE 16
#define RD32_SECT 17
#define RD32_SURF 6
#define RD32_CYL 820
@@ -561,9 +540,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RD32_RBN 200
#define RD32_MOD 15
#define RD32_MED 0x25644020
#define RD32_FLGS 0
#define RD32_FLGS RQDF_MFM
#define RC25_DTYPE 17 /* */
#define RC25_SECT 50 /* */
#define RC25_SURF 8
#define RC25_CYL 1260 /* */
@@ -579,7 +557,6 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RC25_MED 0x20643019
#define RC25_FLGS RQDF_RMV
#define RCF25_DTYPE 18 /* */
#define RCF25_SECT 50 /* */
#define RCF25_SURF 8
#define RCF25_CYL 1260 /* */
@@ -593,9 +570,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RCF25_RBN 0 /* */
#define RCF25_MOD 3
#define RCF25_MED 0x20643319
#define RCF25_FLGS 0
#define RCF25_FLGS RQDF_RC /* RC Disk */
#define RA80_DTYPE 19 /* SDI drive */
#define RA80_SECT 31 /* +1 spare/track */
#define RA80_SURF 14
#define RA80_CYL 546 /* */
@@ -609,11 +585,10 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA80_RBN 0 /* */
#define RA80_MOD 1
#define RA80_MED 0x25641050
#define RA80_FLGS RQDF_SDI
#define RA80_FLGS RQDF_SDI /* SDI drive */
// [RLA] Most of these RA70 parameters came from doing a DUSTAT on a real
// [RLA] RA70 drive. The remainder are just educated guesses...
#define RA70_DTYPE 20 /* SDI drive */
#define RA70_SECT 33 /* +1 spare/track */
#define RA70_SURF 11 /* tracks/cylinder */
#define RA70_CYL 1507 /* 0-1506 user */
@@ -627,10 +602,9 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA70_RBN 16577 /* 1*11*1507 */
#define RA70_MOD 18 /* ??? */
#define RA70_MED 0x25641046 /* RA70 MEDIA ID */
#define RA70_FLGS RQDF_SDI
#define RA70_FLGS RQDF_SDI /* SDI drive */
// [RLA] Likewise for the RA73 ...
#define RA73_DTYPE 21 /* SDI drive */
#define RA73_SECT 70 /* +1 spare/track */
#define RA73_SURF 21 /* tracks/cylinder */
#define RA73_CYL 2667 /* 0-2666 user */
@@ -644,13 +618,12 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RA73_RBN 56007 /* 1*21*2667 */
#define RA73_MOD 47 /* ??? */
#define RA73_MED 0x25641049 /* RA73 MEDIA ID */
#define RA73_FLGS RQDF_SDI
#define RA73_FLGS RQDF_SDI /* SDI drive */
/* The RF drives don't have any useful error parameters. */
/* These entries are derived from basic geometry and size */
/* info in Ultrix 4.5 disktab entries. */
#define RF30_DTYPE 22 /* DSSI drive */
#define RF30_SECT 37 /* +1 spare/track */
#define RF30_SURF 6
#define RF30_CYL 1320 /* 0-1914 user */
@@ -664,9 +637,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RF30_RBN 26810 /* 1 *14*1915 */
#define RF30_MOD 21
#define RF30_MED 0x2264601E
#define RF30_FLGS RQDF_DSSI
#define RF30_FLGS RQDF_DSSI /* DSSI drive */
#define RF31_DTYPE 23 /* DSSI drive */
#define RF31_SECT 50 /* +1 spare/track */
#define RF31_SURF 8
#define RF31_CYL 1861 /* 0-1860 user */
@@ -680,9 +652,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RF31_RBN 26810 /* 1 *14*1915 */
#define RF31_MOD 27
#define RF31_MED 0x2264601F
#define RF31_FLGS RQDF_DSSI
#define RF31_FLGS RQDF_DSSI /* DSSI drive */
#define RF35_DTYPE 24 /* DSSI drive */
#define RF35_SECT 57 /* +1 spare/track */
#define RF35_SURF 14
#define RF35_CYL 1861 /* 0-1860 user */
@@ -696,9 +667,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RF35_RBN 26810 /* 1 *14*1915 */
#define RF35_MOD 27
#define RF35_MED 0x2264601F
#define RF35_FLGS RQDF_DSSI
#define RF35_FLGS RQDF_DSSI /* DSSI drive */
#define RF71_DTYPE 25 /* DSSI drive */
#define RF71_SECT 37 /* +1 spare/track */
#define RF71_SURF 16
#define RF71_CYL 1320 /* 0-1914 user */
@@ -712,9 +682,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RF71_RBN 26810 /* 1 *14*1915 */
#define RF71_MOD 40
#define RF71_MED 0x22646047
#define RF71_FLGS RQDF_DSSI
#define RF71_FLGS RQDF_DSSI /* DSSI drive */
#define RF72_DTYPE 26 /* DSSI drive */
#define RF72_SECT 50 /* +1 spare/track */
#define RF72_SURF 21
#define RF72_CYL 1861 /* 0-1860 user */
@@ -728,9 +697,8 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RF72_RBN 26810 /* 1 *14*1915 */
#define RF72_MOD 28
#define RF72_MED 0x22646048
#define RF72_FLGS RQDF_DSSI
#define RF72_FLGS RQDF_DSSI /* DSSI drive */
#define RF73_DTYPE 27 /* DSSI drive */
#define RF73_SECT 71 /* +1 spare/track */
#define RF73_SURF 21
#define RF73_CYL 2621 /* 0-2620 user */
@@ -744,7 +712,7 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define RF73_RBN 26810 /* 1 *14*1915 */
#define RF73_MOD 35
#define RF73_MED 0x22646049
#define RF73_FLGS RQDF_DSSI
#define RF73_FLGS RQDF_DSSI /* DSSI drive */
/* Controller parameters */
@@ -779,32 +747,22 @@ x RA73 70(+1) 21 2667+ 21 1 ? 3920490
#define KRU50_UQPM 26
#define KRU50_MODEL 26
struct drvtyp {
uint16 sect; /* sectors */
int32 surf; /* surfaces */
int32 cyl; /* cylinders */
uint16 tpg; /* trk/grp */
uint16 gpc; /* grp/cyl */
int32 xbn; /* XBN size */
int32 dbn; /* DBN size */
uint32 lbn; /* LBN size */
uint16 rcts; /* RCT size */
int32 rctc; /* RCT copies */
int32 rbn; /* RBNs */
uint16 mod; /* MSCP model */
int32 MediaId; /* MSCP media */
int32 flgs; /* flags */
const char *name; /* name */
};
#define RQ_DRV(d) \
{ d##_SECT, d##_SURF, d##_CYL, d##_TPG, \
d##_GPC, d##_XBN, d##_DBN, d##_LBN, \
d##_RCTS, d##_RCTC, d##_RBN, d##_MOD, \
d##_MED, d##_FLGS, #d }
{ d##_SECT, d##_SURF, d##_CYL, d##_LBN, \
#d, 512, d##_FLGS, NULL, \
d##_MED, d##_MOD, NULL, NULL, \
d##_TPG, d##_GPC, d##_XBN, d##_DBN, \
d##_RCTS, d##_RCTC, d##_RBN }
#define RQ_DRV_A(d,a) \
{ d##_SECT, d##_SURF, d##_CYL, d##_LBN, \
#d, 512, d##_FLGS, NULL, \
d##_MED, d##_MOD, #a, NULL, \
d##_TPG, d##_GPC, d##_XBN, d##_DBN, \
d##_RCTS, d##_RCTC, d##_RBN }
#define RQ_SIZE(d) d##_LBN
static struct drvtyp drv_tab[] = {
static DRVTYP drv_tab[] = {
RQ_DRV (RX50),
RQ_DRV (RX33),
RQ_DRV (RD51),
@@ -813,15 +771,13 @@ static struct drvtyp drv_tab[] = {
RQ_DRV (RD53),
RQ_DRV (RD54),
RQ_DRV (RA82),
RQ_DRV (RRD40),
RQ_DRV_A (RRD40,CDROM),
RQ_DRV (RA72),
RQ_DRV (RA90),
RQ_DRV (RA92),
RQ_DRV (RA8U),
RQ_DRV (RA92),
RQ_DRV (RA60),
RQ_DRV (RA81),
RQ_DRV (RA71),
RQ_DRV (RD32),
RQ_DRV (RC25),
RQ_DRV (RCF25),
RQ_DRV (RA80),
@@ -829,46 +785,14 @@ static struct drvtyp drv_tab[] = {
RQ_DRV (RA73),
RQ_DRV (RF30),
RQ_DRV (RF31),
RQ_DRV (RF35),
RQ_DRV (RF71),
RQ_DRV (RF72),
RQ_DRV (RF73),
RQ_DRV_A (RA8U, RAUSER),
{ 0 }
};
#undef RQ_DRV
#define RQ_DRV(d) #d
static const char *drv_types[] = {
RQ_DRV (RX50),
RQ_DRV (RX33),
RQ_DRV (RD51),
RQ_DRV (RD31),
RQ_DRV (RD52),
RQ_DRV (RD53),
RQ_DRV (RD54),
RQ_DRV (RA82),
RQ_DRV (RRD40),
RQ_DRV (RA72),
RQ_DRV (RA90),
RQ_DRV (RA92),
RQ_DRV (RA8U),
RQ_DRV (RA60),
RQ_DRV (RA81),
RQ_DRV (RA71),
RQ_DRV (RD32),
RQ_DRV (RC25),
RQ_DRV (RCF25),
RQ_DRV (RA80),
RQ_DRV (RA70),
RQ_DRV (RA73),
RQ_DRV (RF30),
RQ_DRV (RF31),
RQ_DRV (RF71),
RQ_DRV (RF72),
RQ_DRV (RF73),
NULL
};
struct ctlrtyp {
uint32 uqpm; /* port model */
uint16 model; /* controller model */
@@ -979,12 +903,10 @@ t_stat rq_attach (UNIT *uptr, CONST char *cptr);
t_stat rq_detach (UNIT *uptr);
t_stat rq_boot (int32 unitno, DEVICE *dptr);
t_stat rq_set_wlk (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rq_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rq_set_ctype (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rq_set_plug (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rq_show_plug (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rq_set_drives (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rq_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rq_show_ctype (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rq_show_wlk (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rq_show_ctrl (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
@@ -1051,16 +973,7 @@ DIB rq_dib = {
1, IVCL (RQ), 0, { &rq_inta }, IOLN_RQ
};
UNIT rq_unit[RQ_MAXDR + 2] = {
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RX50_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RX50)) },
};
UNIT rq_unit[RQ_MAXDR + 2];
REG rq_reg[] = {
{ GRDATAD (SA, rq_ctx.sa, DEV_RDX, 16, 0, "status/address register") },
@@ -1100,7 +1013,6 @@ REG rq_reg[] = {
{ URDATAD (PLUG, rq_unit[0].unit_plug, 10, 32, 0, RQ_NUMDR, PV_LEFT | REG_RO, "unit plug value, units 0 to 3") },
{ GRDATA (DEVADDR, rq_dib.ba, DEV_RDX, 32, 0), REG_HRO },
{ GRDATA (DEVVEC, rq_dib.vec, DEV_RDX, 16, 0), REG_HRO },
{ DRDATA (DEVLBN, drv_tab[RA8U_DTYPE].lbn, 22), REG_HRO },
{ NULL }
};
@@ -1135,68 +1047,6 @@ MTAB rq_mod[] = {
&rq_set_ctype, NULL, NULL, "Set RUX50 (UNIBUS RX50) Controller Type" },
{ MTAB_XTD|MTAB_VUN|MTAB_NMO, 0, "UNITQ", NULL,
NULL, &rq_show_unitq, NULL, "Display unit queue" },
{ MTAB_XTD|MTAB_VUN, RX50_DTYPE, NULL, "RX50",
&rq_set_type, NULL, NULL, "Set RX50 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RX33_DTYPE, NULL, "RX33",
&rq_set_type, NULL, NULL, "Set RX33 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD31_DTYPE, NULL, "RD31",
&rq_set_type, NULL, NULL, "Set RD31 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD32_DTYPE, NULL, "RD32",
&rq_set_type, NULL, NULL, "Set RD32 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD51_DTYPE, NULL, "RD51",
&rq_set_type, NULL, NULL, "Set RD51 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD52_DTYPE, NULL, "RD52",
&rq_set_type, NULL, NULL, "Set RD52 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD53_DTYPE, NULL, "RD53",
&rq_set_type, NULL, NULL, "Set RD53 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD54_DTYPE, NULL, "RD54",
&rq_set_type, NULL, NULL, "Set RD54 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA60_DTYPE, NULL, "RA60",
&rq_set_type, NULL, NULL, "Set RA60 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA81_DTYPE, NULL, "RA81",
&rq_set_type, NULL, NULL, "Set RA81 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA82_DTYPE, NULL, "RA82",
&rq_set_type, NULL, NULL, "Set RA82 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD40_DTYPE, NULL, "RRD40",
&rq_set_type, NULL, NULL, "Set RRD40 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD40_DTYPE, NULL, "CDROM",
&rq_set_type, NULL, NULL, "Set CDROM Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA70_DTYPE, NULL, "RA70",
&rq_set_type, NULL, NULL, "Set RA70 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA71_DTYPE, NULL, "RA71",
&rq_set_type, NULL, NULL, "Set RA71 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA72_DTYPE, NULL, "RA72",
&rq_set_type, NULL, NULL, "Set RA72 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA73_DTYPE, NULL, "RA73",
&rq_set_type, NULL, NULL, "Set RA73 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA90_DTYPE, NULL, "RA90",
&rq_set_type, NULL, NULL, "Set RA90 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA92_DTYPE, NULL, "RA92",
&rq_set_type, NULL, NULL, "Set RA92 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RC25_DTYPE, NULL, "RC25",
&rq_set_type, NULL, NULL, "Set RC25 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RCF25_DTYPE, NULL, "RCF25",
&rq_set_type, NULL, NULL, "Set RCF25 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RA80_DTYPE, NULL, "RA80",
&rq_set_type, NULL, NULL, "Set RA80 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RF30_DTYPE, NULL, "RF30",
&rq_set_type, NULL, NULL, "Set RF30 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RF31_DTYPE, NULL, "RF31",
&rq_set_type, NULL, NULL, "Set RF31 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RF35_DTYPE, NULL, "RF35",
&rq_set_type, NULL, NULL, "Set RF35 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RF71_DTYPE, NULL, "RF71",
&rq_set_type, NULL, NULL, "Set RF71 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RF72_DTYPE, NULL, "RF72",
&rq_set_type, NULL, NULL, "Set RF72 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RF73_DTYPE, NULL, "RF73",
&rq_set_type, NULL, NULL, "Set RF73 Disk Type" },
{ MTAB_XTD|MTAB_VUN|MTAB_VALR, RA8U_DTYPE, NULL, "RAUSER=SizeInMB",
&rq_set_type, NULL, NULL, "Set RAUSER Disk Type and its size" },
{ MTAB_XTD|MTAB_VUN, RA8U_DTYPE, NULL, "RA8U",
&rq_set_type, NULL, NULL, NULL },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rq_show_type, NULL, "Display device type" },
{ MTAB_XTD|MTAB_VUN|MTAB_VALR, 0, "UNIT", "UNIT=val (0-65534)",
&rq_set_plug, &rq_show_plug, NULL, "Set/Display Unit plug value" },
{ MTAB_XTD|MTAB_VDV|MTAB_VALR, 0, NULL, "DRIVES=val (4-254)",
@@ -1226,7 +1076,7 @@ DEVICE rq_dev = {
&rq_boot, &rq_attach, &rq_detach,
&rq_dib, DEV_DISABLE | DEV_UBUS | DEV_QBUS | DEV_DEBUG | DEV_DISK | DEV_SECTORS,
0, rq_debug, NULL, NULL, &rq_help, NULL, NULL,
&rq_description
&rq_description, NULL, &drv_tab
};
/* RQB data structures
@@ -1244,16 +1094,7 @@ DIB rqb_dib = {
1, IVCL (RQ), 0, { &rq_inta }, IOLN_RQ
};
UNIT rqb_unit[RQ_MAXDR + 2] = {
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
};
UNIT rqb_unit[RQ_MAXDR + 2] = {{0}};
REG rqb_reg[] = {
{ GRDATAD (SA, rqb_ctx.sa, DEV_RDX, 16, 0, "status/address register") },
@@ -1299,7 +1140,7 @@ DEVICE rqb_dev = {
&rq_boot, &rq_attach, &rq_detach,
&rqb_dib, DEV_DISABLE | DEV_DIS | DEV_UBUS | DEV_QBUS | DEV_DEBUG | DEV_DISK | DEV_SECTORS,
0, rq_debug, NULL, NULL, &rq_help, NULL, NULL,
&rq_description
&rq_description, NULL, &drv_tab
};
/* RQC data structures
@@ -1317,16 +1158,7 @@ DIB rqc_dib = {
1, IVCL (RQ), 0, { &rq_inta }, IOLN_RQ
};
UNIT rqc_unit[RQ_MAXDR + 2] = {
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
};
UNIT rqc_unit[RQ_MAXDR + 2] = {{0}};
REG rqc_reg[] = {
{ GRDATAD (SA, rqc_ctx.sa, DEV_RDX, 16, 0, "status/address register") },
@@ -1372,7 +1204,7 @@ DEVICE rqc_dev = {
&rq_boot, &rq_attach, &rq_detach,
&rqc_dib, DEV_DISABLE | DEV_DIS | DEV_UBUS | DEV_QBUS | DEV_DEBUG | DEV_DISK | DEV_SECTORS,
0, rq_debug, NULL, NULL, &rq_help, NULL, NULL,
&rq_description
&rq_description, NULL, &drv_tab
};
/* RQD data structures
@@ -1390,16 +1222,7 @@ DIB rqd_dib = {
1, IVCL (RQ), 0, { &rq_inta }, IOLN_RQ
};
UNIT rqd_unit[RQ_MAXDR + 2] = {
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
{ UDATA (&rq_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RQ_SIZE (RD54)) },
};
UNIT rqd_unit[RQ_MAXDR + 2] = {{0}};
REG rqd_reg[] = {
{ GRDATAD (SA, rqd_ctx.sa, DEV_RDX, 16, 0, "status/address register") },
@@ -1445,7 +1268,7 @@ DEVICE rqd_dev = {
&rq_boot, &rq_attach, &rq_detach,
&rqd_dib, DEV_DISABLE | DEV_DIS | DEV_UBUS | DEV_QBUS | DEV_DEBUG | DEV_DISK | DEV_SECTORS,
0, rq_debug, NULL, NULL, &rq_help, NULL, NULL,
&rq_description
&rq_description, NULL, &drv_tab
};
static DEVICE *rq_devmap[RQ_NUMCT] = {
@@ -1902,7 +1725,7 @@ t_bool rq_gus (MSC *cp, uint16 pkt, t_bool q)
{
uint16 lu = cp->pak[pkt].d[CMD_UN]; /* unit # */
uint16 cmd = GETP (pkt, CMD_OPC, OPC); /* opcode */
uint16 dtyp, sts, rbpar;
uint16 sts, rbpar;
UNIT *uptr;
sim_debug (DBG_TRC, rq_devmap[cp->cnum], "rq_gus\n");
@@ -1920,15 +1743,15 @@ if ((uptr = rq_getucb (cp, lu))) { /* unit exist? */
sts = ST_SUC;
else sts = ST_AVL; /* avail */
rq_putr_unit (cp, pkt, uptr, lu, FALSE); /* fill unit fields */
dtyp = GET_DTYPE (uptr->flags); /* get drive type */
if (drv_tab[dtyp].rcts) /* ctrl bad blk? */
if (uptr->drvtyp->rcts) /* ctrl bad blk? */
rbpar = 1;
else rbpar = 0; /* fill geom, bblk */
cp->pak[pkt].d[GUS_TRK] = drv_tab[dtyp].sect;
cp->pak[pkt].d[GUS_GRP] = drv_tab[dtyp].tpg;
cp->pak[pkt].d[GUS_CYL] = drv_tab[dtyp].gpc;
else
rbpar = 0; /* fill geom, bblk */
cp->pak[pkt].d[GUS_TRK] = uptr->drvtyp->sect;
cp->pak[pkt].d[GUS_GRP] = uptr->drvtyp->tpg;
cp->pak[pkt].d[GUS_CYL] = uptr->drvtyp->gpc;
cp->pak[pkt].d[GUS_UVER] = 0;
cp->pak[pkt].d[GUS_RCTS] = drv_tab[dtyp].rcts;
cp->pak[pkt].d[GUS_RCTS] = uptr->drvtyp->rcts;
cp->pak[pkt].d[GUS_RBSC] =
(rbpar << GUS_RB_V_RBNS) | (rbpar << GUS_RB_V_RCTC);
}
@@ -1991,7 +1814,7 @@ if (cp->pak[pkt].d[SCC_MSV]) { /* MSCP ver = 0? */
else {
sts = ST_SUC; /* success */
cmd = GETP (pkt, CMD_OPC, OPC); /* get opcode */
cp->cflgs = (cp->cflgs & CF_RPL) | /* hack ctrl flgs */
cp->cflgs = (cp->cflgs & CF_RPL) | /* hack ctrl flags */
cp->pak[pkt].d[SCC_CFL];
if ((cp->htmo = cp->pak[pkt].d[SCC_TMO])) /* set timeout */
cp->htmo = cp->htmo + 2; /* if nz, round up */
@@ -2058,7 +1881,7 @@ if ((uptr = rq_getucb (cp, lu))) { /* unit exist? */
rq_enqt (cp, &uptr->pktq, pkt); /* do later */
return OK;
}
if (GET_DTYPE (uptr->flags) != RX33_DTYPE) /* RX33? */
if (strcasecmp (uptr->drvtyp->name, "RX33") != 0) /* RX33? */
sts = ST_CMD | I_OPCD; /* no, err */
else if ((cp->pak[pkt].d[FMT_IH] & 0100000) == 0) /* magic bit set? */
sts = ST_CMD | I_FMTI; /* no, err */
@@ -2126,7 +1949,6 @@ return rq_putpkt (cp, pkt, TRUE);
uint16 rq_rw_valid (MSC *cp, uint16 pkt, UNIT *uptr, uint16 cmd)
{
uint32 dtyp = GET_DTYPE (uptr->flags); /* get drive type */
uint32 lbn = GETP32 (pkt, RW_LBNL); /* get lbn */
uint32 bc = GETP32 (pkt, RW_BCL); /* get byte cnt */
uint32 maxlbn = (uint32)uptr->capac; /* get max lbn */
@@ -2144,7 +1966,7 @@ if (bc & 0xF0000000) /* 'reasonable' bc? */
return (ST_CMD | I_BCNT);
// if (lbn & 0xF0000000) return (ST_CMD | I_LBN); /* 'reasonable' lbn? */
if (lbn >= maxlbn) { /* accessing RCT? */
if (lbn >= (maxlbn + drv_tab[dtyp].rcts)) /* beyond copy 1? */
if (lbn >= (maxlbn + uptr->drvtyp->rcts)) /* beyond copy 1? */
return (ST_CMD | I_LBN); /* lbn err */
if (bc != RQ_NUMBY) /* bc must be 512 */
return (ST_CMD | I_BCNT);
@@ -2442,7 +2264,7 @@ t_bool rq_dte (MSC *cp, UNIT *uptr, uint16 err)
{
uint16 pkt, tpkt;
uint16 lu, ccyl, csurf, csect;
uint32 dtyp, lbn, t;
uint32 lbn, t;
sim_debug (DBG_TRC, rq_devmap[cp->cnum], "rq_dte\n");
@@ -2453,15 +2275,14 @@ if (!rq_deqf (cp, &pkt)) /* get log pkt */
tpkt = uptr->cpkt; /* rw pkt */
lu = cp->pak[tpkt].d[CMD_UN]; /* unit # */
lbn = GETP32 (tpkt, RW_WBLL); /* recent LBN */
dtyp = GET_DTYPE (uptr->flags); /* drv type */
if (drv_tab[dtyp].flgs & RQDF_SDI) /* SDI? ovhd @ end */
if (uptr->drvtyp->flags & RQDF_SDI) /* SDI? ovhd @ end */
t = 0;
else t = (drv_tab[dtyp].xbn + drv_tab[dtyp].dbn) / /* ovhd cylinders */
(drv_tab[dtyp].sect * drv_tab[dtyp].surf);
ccyl = (uint16)(t + (lbn / drv_tab[dtyp].cyl)); /* curr real cyl */
t = lbn % drv_tab[dtyp].cyl; /* trk relative blk */
csurf = (uint16)(t / drv_tab[dtyp].surf); /* curr surf */
csect = (uint16)(t % drv_tab[dtyp].surf); /* curr sect */
else t = (uptr->drvtyp->xbn + uptr->drvtyp->dbn) / /* ovhd cylinders */
(uptr->drvtyp->sect * uptr->drvtyp->surf);
ccyl = (uint16)(t + (lbn / uptr->drvtyp->cyl)); /* curr real cyl */
t = lbn % uptr->drvtyp->cyl; /* trk relative blk */
csurf = (uint16)(t / uptr->drvtyp->surf); /* curr surf */
csect = (uint16)(t % uptr->drvtyp->surf); /* curr sect */
cp->pak[pkt].d[ELP_REFL] = cp->pak[tpkt].d[CMD_REFL]; /* copy cmd ref */
cp->pak[pkt].d[ELP_REFH] = cp->pak[tpkt].d[CMD_REFH];
@@ -2479,7 +2300,7 @@ cp->pak[pkt].d[DTE_UIDA] = lu; /* unit ID */
cp->pak[pkt].d[DTE_UIDB] = 0;
cp->pak[pkt].d[DTE_UIDC] = 0;
cp->pak[pkt].d[DTE_UIDD] = (UID_DISK << DTE_UIDD_V_CLS) |
(drv_tab[dtyp].mod << DTE_UIDD_V_MOD);
(uptr->drvtyp->model << DTE_UIDD_V_MOD);
cp->pak[pkt].d[DTE_UVER] = 0; /* unit versn */
cp->pak[pkt].d[DTE_SCYL] = ccyl; /* cylinder */
cp->pak[pkt].d[DTE_VSNL] = 01234 + lu; /* vol ser # */
@@ -2764,7 +2585,6 @@ return;
void rq_putr_unit (MSC *cp, uint16 pkt, UNIT *uptr, uint16 lu, t_bool all)
{
uint32 dtyp = GET_DTYPE (uptr->flags); /* get drive type */
uint32 maxlbn = (uint32)uptr->capac; /* get max lbn */
sim_debug (DBG_TRC, rq_devmap[cp->cnum], "rq_putr_unit\n");
@@ -2777,8 +2597,8 @@ cp->pak[pkt].d[ONL_UIDA] = lu; /* UID low */
cp->pak[pkt].d[ONL_UIDB] = 0;
cp->pak[pkt].d[ONL_UIDC] = 0;
cp->pak[pkt].d[ONL_UIDD] = (UID_DISK << ONL_UIDD_V_CLS) |
(drv_tab[dtyp].mod << ONL_UIDD_V_MOD); /* UID hi */
PUTP32 (pkt, ONL_MEDL, drv_tab[dtyp].MediaId); /* media type */
(uptr->drvtyp->model << ONL_UIDD_V_MOD); /* UID hi */
PUTP32 (pkt, ONL_MEDL, sim_disk_get_mediaid (uptr)); /* media type */
if (all) { /* if long form */
PUTP32 (pkt, ONL_SIZL, maxlbn); /* user LBNs */
cp->pak[pkt].d[ONL_VSNL] = 01234 + lu; /* vol serial # */
@@ -2897,9 +2717,7 @@ return ERR;
t_stat rq_set_wlk (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
uint32 dtyp = GET_DTYPE (uptr->flags); /* get drive type */
if ((drv_tab[dtyp].flgs & RQDF_RO) && (val == 0)) /* not on read only */
if ((uptr->drvtyp->flags & RQDF_RO) && (val == 0)) /* not on read only */
return sim_messagef (SCPE_NOFNC, "%s: Can't enable write on Read Only device\n", sim_uname (uptr));
return set_writelock (uptr, val, cptr, desc);
}
@@ -2908,40 +2726,13 @@ return set_writelock (uptr, val, cptr, desc);
t_stat rq_show_wlk (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
uint32 dtyp = GET_DTYPE (uptr->flags); /* get drive type */
if (drv_tab[dtyp].flgs & RQDF_RO)
if (uptr->drvtyp->flags & RQDF_RO)
fprintf (st, "read only");
else
show_writelock (st, uptr, val, desc);
return SCPE_OK;
}
/* Set unit type (and capacity if user defined) */
t_stat rq_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
uint32 cap;
uint32 max = sim_toffset_64? RA8U_EMAXC: RA8U_MAXC;
t_stat r;
if ((val < 0) || ((val != RA8U_DTYPE) && cptr))
return SCPE_ARG;
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
if (cptr) {
cap = (uint32) get_uint (cptr, 10, 0xFFFFFFFF, &r);
if ((sim_switches & SWMASK ('L')) == 0)
cap = cap * ((sim_switches & SWMASK ('B')) ? 2048 : 1954);
if ((r != SCPE_OK) || (cap < RA8U_MINC) || (cap > max))
return SCPE_ARG;
drv_tab[val].lbn = cap;
}
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
uptr->capac = (t_addr)drv_tab[val].lbn;
return SCPE_OK;
}
/* Show unit plug */
t_stat rq_show_plug (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
@@ -3010,14 +2801,6 @@ for (i=new_drives; i < old_drives; i++) {
return SCPE_OK;
}
/* Show unit type */
t_stat rq_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", drv_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
/* Set controller type */
t_stat rq_set_ctype (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
@@ -3047,12 +2830,12 @@ MSC *cp = rq_ctxmap[uptr->cnum];
t_stat r;
t_bool dontchangecapac = (uptr->flags & UNIT_NOAUTO);
if (drv_tab[GET_DTYPE (uptr->flags)].flgs & RQDF_RO) {
if (uptr->drvtyp->flags & RQDF_RO) {
sim_switches |= SWMASK ('R');
dontchangecapac = FALSE;
}
r = sim_disk_attach_ex (uptr, cptr, RQ_NUMBY, sizeof (uint16), dontchangecapac, DBG_DSK,
drv_tab[GET_DTYPE (uptr->flags)].name, 0, 0, (uptr->flags & UNIT_NOAUTO) ? NULL : drv_types);
uptr->drvtyp->name, 0, 0, NULL);
if (r != SCPE_OK)
return r;
@@ -3071,7 +2854,7 @@ r = sim_disk_detach (uptr); /* detach unit */
if (r != SCPE_OK)
return r;
uptr->flags = uptr->flags & ~(UNIT_ONL | UNIT_ATP); /* clr onl, atn pend */
uptr->uf = 0; /* clr unit flgs */
uptr->uf = 0; /* clr unit flags */
return SCPE_OK;
}
@@ -3126,6 +2909,12 @@ if (!plugs_inited ) {
rq_devmap[i]->units[d].flags |= UNIT_DIS;
rq_devmap[i]->units[d].flags &= ~UNIT_DISABLE;
}
else {
static const char *default_drives[RQ_NUMDR] = { "RD54", "RD54", "RD54", "RX50" };
rq_devmap[i]->units[d].action = &rq_svc;
rq_devmap[i]->units[d].flags = UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE;
sim_disk_set_drive_type_by_name (&rq_devmap[i]->units[d], default_drives[d]);
}
rq_devmap[i]->units[d].unit_plug =
#if defined (VM_VAX)
d; /* VAX default units */
@@ -3144,7 +2933,7 @@ if (UNIBUS) /* Unibus? */
cp->sa = SA_S1 | SA_S1C_DI | SA_S1C_MP;
else
cp->sa = SA_S1 | SA_S1C_Q22 | SA_S1C_DI | SA_S1C_MP;/* init SA val */
cp->cflgs = CF_RPL; /* ctrl flgs off */
cp->cflgs = CF_RPL; /* ctrl flags off */
cp->htmo = RQ_DHTMO; /* default timeout */
cp->hat = cp->htmo; /* default timer */
cp->cq.ba = cp->cq.lnt = cp->cq.idx = 0; /* clr cmd ring */

61
PDP11/pdp11_rx.c
View File

@@ -51,15 +51,27 @@
#include "pdp11_defs.h"
#define RX_NUMTR 77 /* tracks/disk */
#include "sim_disk.h"
#define RX_NUMCY 77 /* tracks/disk */
#define RX_NUMSF 1 /* surfaces */
#define RX_M_TRACK 0377
#define RX_NUMSC 26 /* sectors/track */
#define RX_M_SECTOR 0177
#define RX_NUMBY 128 /* bytes/sector */
#define RX_SIZE (RX_NUMTR * RX_NUMSC * RX_NUMBY) /* bytes/disk */
#define RX_SIZE (RX_NUMCY * RX_NUMSC * RX_NUMSF)/* sectors/disk */
#define RX_NUMDR 2 /* drives/controller */
#define RX_M_NUMDR 01
#define RX_DRV(d) \
{ RX_NUMSC, RX_NUMSF, RX_NUMCY, RX_SIZE, \
#d, RX_NUMBY, DRVFL_RMV, "DY" }
static DRVTYP drv_tab[] = {
RX_DRV (RX01),
{ 0 }
};
#define IDLE 0 /* idle state */
#define RWDS 1 /* rw, sect next */
#define RWDT 2 /* rw, track next */
@@ -124,6 +136,8 @@ int32 rx_enb = 1; /* device enable */
t_stat rx_rd (int32 *data, int32 PA, int32 access);
t_stat rx_wr (int32 data, int32 PA, int32 access);
t_stat rx_svc (UNIT *uptr);
t_stat rx_attach (UNIT *uptr, CONST char *cptr);
t_stat rx_detach (UNIT *uptr);
t_stat rx_reset (DEVICE *dptr);
t_stat rx_boot (int32 unitno, DEVICE *dptr);
void rx_done (int32 esr_flags, int32 new_ecode);
@@ -143,12 +157,7 @@ DIB rx_dib = {
1, IVCL (RX), VEC_AUTO, { NULL }, IOLN_RX,
};
UNIT rx_unit[] = {
{ UDATA (&rx_svc,
UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, RX_SIZE) },
{ UDATA (&rx_svc,
UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, RX_SIZE) }
};
UNIT rx_unit[RX_NUMDR] = {{0}};
REG rx_reg[] = {
{ ORDATA (RXCS, rx_csr, 16) },
@@ -197,8 +206,9 @@ DEVICE rx_dev = {
"RX", rx_unit, rx_reg, rx_mod,
RX_NUMDR, 8, 20, 1, 8, 8,
NULL, NULL, &rx_reset,
&rx_boot, NULL, NULL,
&rx_dib, DEV_DISABLE | DEV_UBUS | DEV_QBUS
&rx_boot, &rx_attach, &rx_detach,
&rx_dib, DEV_DISABLE | DEV_UBUS | DEV_QBUS | DEV_DISK, 0,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &drv_tab
};
/* I/O dispatch routine, I/O addresses 17777170 - 17777172
@@ -372,7 +382,7 @@ switch (rx_state) { /* case on state */
rx_done (0, 0110); /* done, error */
return IORETURN (rx_stopioe, SCPE_UNATT);
}
if (rx_track >= RX_NUMTR) { /* bad track? */
if (rx_track >= RX_NUMCY) { /* bad track? */
rx_done (0, 0040); /* done, error */
break;
}
@@ -458,6 +468,20 @@ return;
t_stat rx_reset (DEVICE *dptr)
{
static t_bool inited = FALSE;
if (!inited) {
int32 i;
UNIT *uptr;
inited = TRUE;
for (i = 0; i < RX_NUMDR; i++) {
uptr = dptr->units + i;
uptr->action = &rx_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF;
sim_disk_set_drive_type_by_name (uptr, "RX01");
}
}
rx_csr = rx_dbr = 0; /* clear regs */
rx_esr = rx_ecode = 0; /* clear error */
rx_track = rx_sector = 0; /* clear addr */
@@ -474,6 +498,21 @@ else rx_done (0, 0010); /* no, error */
return auto_config (0, 0); /* run autoconfig */
}
/* Attach routine */
t_stat rx_attach (UNIT *uptr, CONST char *cptr)
{
return sim_disk_attach (uptr, cptr, RX_NUMBY,
sizeof (uint16), TRUE, 0,
"RX01", 0, 0);
}
t_stat rx_detach (UNIT *uptr)
{
sim_cancel (uptr);
return sim_disk_detach (uptr);
}
/* Device bootstrap */
#define BOOT_START 02000 /* start */

160
PDP11/pdp11_ry.c
View File

@@ -56,21 +56,31 @@
#define DEV_DISI DEV_DIS
#endif
#include "sim_disk.h"
#define RX_NUMTR 77 /* tracks/disk */
#define RX_M_TRACK 0377
#define RX_NUMSF 1 /* surfaces (heads) */
#define RX_NUMSC 26 /* sectors/track */
#define RX_M_SECTOR 0177
#define RX_NUMBY 128
#define RX_SIZE (RX_NUMTR * RX_NUMSC * RX_NUMBY)
#define RY_NUMBY 256 /* bytes/sector */
#define RY_SIZE (RX_NUMTR * RX_NUMSC * RY_NUMBY)
#define RX01_NUMBY 128
#define RX02_NUMBY 256 /* bytes/sector */
#define RX_NUMDR 2 /* drives/controller */
#define RX_M_NUMDR 01
#define UNIT_V_DEN (UNIT_V_UF + 0) /* double density */
#define UNIT_V_AUTO (UNIT_V_UF + 1) /* autosize */
#define UNIT_DEN (1u << UNIT_V_DEN)
#define UNIT_V_AUTO (UNIT_V_UF + 0) /* autosize */
#define UNIT_AUTO (1u << UNIT_V_AUTO)
#define RY_DRV(d,a) \
{ RX_NUMSC, RX_NUMSF, RX_NUMTR, (RX_NUMSC * RX_NUMTR),\
#d, d##_NUMBY*2, DRVFL_RMV, \
"DY", 0, 0, #a }
static DRVTYP drv_tab[] = {
RY_DRV(RX01,SINGLE),
RY_DRV(RX02,DOUBLE),
{ 0 }
};
#define IDLE 0 /* idle state */
#define RWDS 1 /* rw, sect next */
#define RWDT 2 /* rw, track next */
@@ -134,7 +144,7 @@
#define RYES_ERR (RYES_NXM|RYES_WCO|RYES_DERR|RYES_ACLO|RYES_CRC)
#define TRACK u3 /* current track */
#define CALC_DA(t,s,b) (((t) * RX_NUMSC) + ((s) - 1)) * b
#define CALC_DA(t,s) (((t) * RX_NUMSC) + ((s) - 1))
int32 ry_csr = 0; /* control/status */
int32 ry_dbr = 0; /* data buffer */
@@ -149,7 +159,7 @@ int32 ry_stopioe = 1; /* stop on error */
int32 ry_cwait = 100; /* command time */
int32 ry_swait = 10; /* seek, per track */
int32 ry_xwait = 1; /* tr set time */
uint8 rx2xb[RY_NUMBY] = { 0 }; /* sector buffer */
uint8 rx2xb[RX02_NUMBY] = { 0 }; /* sector buffer */
t_stat ry_rd (int32 *data, int32 PA, int32 access);
t_stat ry_wr (int32 data, int32 PA, int32 access);
@@ -157,8 +167,9 @@ t_stat ry_svc (UNIT *uptr);
t_stat ry_reset (DEVICE *dptr);
t_stat ry_boot (int32 unitno, DEVICE *dptr);
void ry_done (int32 esr_flags, uint8 new_ecode);
t_stat ry_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat ry_show_density (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat ry_attach (UNIT *uptr, CONST char *cptr);
t_stat ry_detach (UNIT *uptr);
t_stat ry_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
const char *ry_description (DEVICE *dptr);
@@ -178,12 +189,7 @@ DIB ry_dib = {
1, IVCL (RY), VEC_AUTO, { NULL }, IOLN_RY,
};
UNIT ry_unit[] = {
{ UDATA (&ry_svc, UNIT_DEN+UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF,
RY_SIZE) },
{ UDATA (&ry_svc, UNIT_DEN+UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF,
RY_SIZE) }
};
UNIT ry_unit[RX_NUMDR] = {{0}};
REG ry_reg[] = {
{ GRDATAD (RYCS, ry_csr, DEV_RDX, 16, 0, "status") },
@@ -203,7 +209,7 @@ REG ry_reg[] = {
{ DRDATAD (CTIME, ry_cwait, 24, "command completion time"), PV_LEFT },
{ DRDATAD (STIME, ry_swait, 24, "seek time, per track"), PV_LEFT },
{ DRDATAD (XTIME, ry_xwait, 24, "transfer ready delay"), PV_LEFT },
{ BRDATAD (SBUF, rx2xb, 8, 8, RY_NUMBY, "sector buffer array") },
{ BRDATAD (SBUF, rx2xb, 8, 8, sizeof (rx2xb), "sector buffer array") },
{ FLDATAD (STOP_IOE, ry_stopioe, 0, "stop on I/O error") },
{ URDATA (CAPAC, ry_unit[0].capac, 10, T_ADDR_W, 0,
RX_NUMDR, REG_HRO | PV_LEFT) },
@@ -213,21 +219,15 @@ REG ry_reg[] = {
};
MTAB ry_mod[] = {
{ MTAB_XTD|MTAB_VUN, 0, "write enabled", "WRITEENABLED",
&set_writelock, &show_writelock, NULL, "Write enable floppy drive" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "LOCKED",
&set_writelock, NULL, NULL, "Write lock floppy drive" },
{ (UNIT_DEN+UNIT_ATT), UNIT_ATT, "single density", NULL, NULL },
{ (UNIT_DEN+UNIT_ATT), (UNIT_DEN+UNIT_ATT), "double density", NULL, NULL },
{ (UNIT_AUTO+UNIT_DEN+UNIT_ATT), 0, "single density", NULL, NULL },
{ (UNIT_AUTO+UNIT_DEN+UNIT_ATT), UNIT_DEN, "double density", NULL, NULL },
{ UNIT_WLK, 0, "write enabled", "WRITEENABLED",
NULL, NULL, NULL, "Write enable disk drive" },
{ UNIT_WLK, UNIT_WLK, "write locked", "LOCKED",
NULL, NULL, NULL, "Write lock disk drive" },
{ (UNIT_AUTO+UNIT_ATT), UNIT_AUTO, "autosize", NULL, NULL },
{ UNIT_AUTO, UNIT_AUTO, NULL, "AUTOSIZE",
NULL, NULL, NULL, "set density based on file size at ATTACH" },
{ (UNIT_AUTO+UNIT_DEN), 0, NULL, "SINGLE",
&ry_set_size, NULL, NULL, "Set to Single density (256Kb)" },
{ (UNIT_AUTO+UNIT_DEN), UNIT_DEN, NULL, "DOUBLE",
&ry_set_size, NULL, NULL, "Set to Double density (512Kb)" },
{ MTAB_XTD|MTAB_VUN, 0, "DENSITY", NULL,
NULL, &ry_show_density, NULL, "Display disk density" },
#if defined (VM_PDP11)
{ MTAB_XTD|MTAB_VDV|MTAB_VALR, 004, "ADDRESS", "ADDRESS",
&set_addr, &show_addr, NULL, "Bus Address" },
@@ -246,10 +246,10 @@ DEVICE ry_dev = {
"RY", ry_unit, ry_reg, ry_mod,
RX_NUMDR, DEV_RDX, 20, 1, DEV_RDX, 8,
NULL, NULL, &ry_reset,
&ry_boot, &ry_attach, NULL,
&ry_dib, DEV_DISABLE | DEV_DISI | DEV_UBUS | DEV_Q18, 0,
&ry_boot, &ry_attach, &ry_detach,
&ry_dib, DEV_DISABLE | DEV_DISI | DEV_UBUS | DEV_Q18 | DEV_DISK, 0,
NULL, NULL, NULL, &ry_help, NULL, NULL,
&ry_description
&ry_description, NULL, &drv_tab
};
/* I/O dispatch routine, I/O addresses 17777170 - 17777172
@@ -376,13 +376,12 @@ return SCPE_OK;
t_stat ry_svc (UNIT *uptr)
{
int32 i, t, func, bps;
int32 t, func, bps;
static uint8 estat[8];
uint32 ba, da;
int8 *fbuf = (int8 *) uptr->filebuf;
func = RYCS_GETFNC (ry_csr); /* get function */
bps = (ry_csr & RYCS_DEN)? RY_NUMBY: RX_NUMBY; /* get sector size */
bps = (ry_csr & RYCS_DEN)? RX02_NUMBY: RX01_NUMBY; /* get sector size */
ba = (RYCS_GETUAE (ry_csr) << 16) | ry_ba; /* get mem addr */
switch (ry_state) { /* case on state */
@@ -407,8 +406,7 @@ switch (ry_state) { /* case on state */
break;
}
if (func == RYCS_FILL) { /* fill? read */
for (i = 0; i < RY_NUMBY; i++)
rx2xb[i] = 0;
memset (rx2xb, 0, sizeof (rx2xb));
t = Map_ReadB (ba, ry_wc << 1, rx2xb);
}
else t = Map_WriteB (ba, ry_wc << 1, rx2xb);
@@ -430,7 +428,7 @@ switch (ry_state) { /* case on state */
return SCPE_OK;
case RWXFR: /* read/write */
if ((uptr->flags & UNIT_BUF) == 0) { /* not buffered? */
if ((uptr->flags & UNIT_ATT) == 0) { /* not attached? */
ry_done (0, 0110); /* done, error */
return IORETURN (ry_stopioe, SCPE_UNATT);
}
@@ -443,28 +441,24 @@ switch (ry_state) { /* case on state */
ry_done (0, 0070); /* done, error */
break;
}
if (((uptr->flags & UNIT_DEN) != 0) ^
if ((0 == strcmp (uptr->drvtyp->name, "RX02")) ^
((ry_csr & RYCS_DEN) != 0)) { /* densities agree? */
ry_done (RYES_DERR, 0240); /* no, error */
break;
}
da = CALC_DA (ry_track, ry_sector, bps); /* get disk address */
da = CALC_DA (ry_track, ry_sector); /* get disk address */
if (func == RYCS_WRDEL) /* del data? */
ry_esr = ry_esr | RYES_DD;
if (func == RYCS_READ) { /* read? */
for (i = 0; i < bps; i++)
rx2xb[i] = fbuf[da + i];
}
if (func == RYCS_READ) /* read? */
sim_disk_rdsect (uptr, da, rx2xb, NULL, 1); /* read sector */
else {
if (uptr->flags & UNIT_WPRT) { /* write and locked? */
ry_done (0, 0100); /* done, error */
break;
}
for (i = 0; i < bps; i++) /* write */
fbuf[da + i] = rx2xb[i];
da = da + bps;
if (da > uptr->hwmark)
uptr->hwmark = da;
sim_disk_wrsect (uptr, da, rx2xb, NULL, 1); /* write */
if ((da * bps) > uptr->hwmark)
uptr->hwmark = (da * bps);
}
ry_done (0, 0); /* done */
break;
@@ -479,12 +473,12 @@ switch (ry_state) { /* case on state */
break;
case SDXFR: /* erase disk */
for (i = 0; i < (int32) uptr->capac; i++)
fbuf[i] = 0;
sim_disk_erase (uptr);
uptr->hwmark = (uint32) uptr->capac;
if (ry_csr & RYCS_DEN)
uptr->flags = uptr->flags | UNIT_DEN;
else uptr->flags = uptr->flags & ~UNIT_DEN;
sim_disk_set_drive_type_by_name (uptr, "RX02");
else
sim_disk_set_drive_type_by_name (uptr, "RX01");
ry_done (0, 0);
break;
@@ -503,9 +497,9 @@ switch (ry_state) { /* case on state */
estat[4] = ry_track;
estat[5] = ry_sector;
estat[6] = ((ry_csr & RYCS_DRV)? 0200: 0) |
((ry_unit[1].flags & UNIT_DEN)? 0100: 0) |
((0 == strcasecmp (ry_unit[1].drvtyp->name, "RX02"))? 0100: 0) |
((uptr->flags & UNIT_ATT)? 0040: 0) |
((ry_unit[0].flags & UNIT_DEN)? 0020: 0) |
((0 == strcasecmp (ry_unit[0].drvtyp->name, "RX02"))? 0020: 0) |
((ry_csr & RYCS_DEN)? 0001: 0);
estat[7] = (uint8)uptr->TRACK;
t = Map_WriteB (ba, 8, estat); /* DMA to memory */
@@ -519,13 +513,12 @@ switch (ry_state) { /* case on state */
case INIT_COMPLETE: /* init complete */
ry_unit[0].TRACK = 1; /* drive 0 to trk 1 */
ry_unit[1].TRACK = 0; /* drive 1 to trk 0 */
if ((uptr->flags & UNIT_BUF) == 0) { /* not buffered? */
if ((uptr->flags & UNIT_ATT) == 0) { /* not attached? */
ry_done (RYES_ID, 0010); /* init done, error */
break;
}
da = CALC_DA (1, 1, bps); /* track 1, sector 1 */
for (i = 0; i < bps; i++) /* read sector */
rx2xb[i] = fbuf[da + i];
da = CALC_DA (1, 1); /* track 1, sector 1 */
sim_disk_rdsect (uptr, da, rx2xb, NULL, 1); /* read sector */
ry_done (RYES_ID, 0); /* set done */
if ((ry_unit[1].flags & UNIT_ATT) == 0)
ry_ecode = 0020;
@@ -552,7 +545,7 @@ if (drv) /* updates RYES */
ry_esr = ry_esr | RYES_USEL;
if (ry_unit[drv].flags & UNIT_ATT) {
ry_esr = ry_esr | RYES_DRDY;
if (ry_unit[drv].flags & UNIT_DEN)
if (0 == strcmp (ry_unit[drv].drvtyp->name, "RX02"))
ry_esr = ry_esr | RYES_DDEN;
}
if ((new_ecode > 0) || (ry_esr & RYES_ERR)) /* test for error */
@@ -568,6 +561,20 @@ return;
t_stat ry_reset (DEVICE *dptr)
{
int32 i;
static t_bool inited = FALSE;
if (!inited) {
inited = TRUE;
for (i = 0; i < RX_NUMDR; i++) {
UNIT *uptr;
uptr = dptr->units + i;
uptr->action = &ry_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF;
sim_disk_set_drive_type_by_name (uptr, "RX02");
}
}
ry_csr = ry_dbr = 0; /* clear registers */
ry_esr = ry_ecode = 0; /* clear error */
ry_ba = ry_wc = 0; /* clear wc, ba */
@@ -577,7 +584,7 @@ CLR_INT (RY); /* clear int req */
sim_cancel (&ry_unit[1]); /* cancel drive 1 */
if (dptr->flags & UNIT_DIS) /* disabled? */
sim_cancel (&ry_unit[0]);
else if (ry_unit[0].flags & UNIT_BUF) { /* attached? */
else if (ry_unit[0].flags & UNIT_ATT) { /* attached? */
ry_state = INIT_COMPLETE; /* yes, sched init */
sim_activate (&ry_unit[0], ry_swait * abs (1 - ry_unit[0].TRACK));
}
@@ -589,24 +596,23 @@ return auto_config (dptr->name, 1); /* run autoconfig */
t_stat ry_attach (UNIT *uptr, CONST char *cptr)
{
uint32 sz;
if ((uptr->flags & UNIT_AUTO) && (sz = sim_fsize_name (cptr))) {
if (sz > RX_SIZE)
uptr->flags = uptr->flags | UNIT_DEN;
else uptr->flags = uptr->flags & ~UNIT_DEN;
}
uptr->capac = (uptr->flags & UNIT_DEN)? RY_SIZE: RX_SIZE;
return attach_unit (uptr, cptr);
return sim_disk_attach_ex (uptr, cptr, uptr->drvtyp->sectsize,
sizeof (uint8), TRUE, 0,
uptr->drvtyp->name, RX_NUMSC, 0,
NULL);
}
/* Set size routine */
t_stat ry_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
t_stat ry_detach (UNIT *uptr)
{
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
uptr->capac = val? RY_SIZE: RX_SIZE;
sim_cancel (uptr);
return sim_disk_detach (uptr);
}
/* Show density */
t_stat ry_show_density (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s density", (strcasecmp (uptr->drvtyp->name, "RX01") == 0) ? "single" : "double");
return SCPE_OK;
}
@@ -685,7 +691,7 @@ t_stat ry_boot (int32 unitno, DEVICE *dptr)
{
size_t i;
if ((ry_unit[unitno & RX_M_NUMDR].flags & UNIT_DEN) == 0)
if (0 != strcasecmp (ry_unit[unitno & RX_M_NUMDR].drvtyp->name, "RX02"))
return SCPE_NOFNC;
for (i = 0; i < BOOT_LEN; i++)
WrMemW (BOOT_START + (2 * i), boot_rom[i]);

36
PDP11/pdp11_td.c
View File

@@ -456,6 +456,8 @@ OP CODE 11 (Resened)
#include "pdp11_td.h"
#include "sim_disk.h"
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
/* DL Definitions */
@@ -528,6 +530,7 @@ static const char *tdc_regnam[] =
#define TD_NUMBY 512 /* bytes/block */
#define TD_SIZE (TD_NUMBLK * TD_NUMBY) /* bytes/tape */
#define TD_OPDAT 001 /* Data */
#define TD_OPCMD 002 /* Command */
#define TD_OPINI 004 /* INIT */
@@ -641,6 +644,8 @@ static t_stat td_reset (DEVICE *dptr);
static t_stat td_set_ctrls (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
static t_stat td_show_ctlrs (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
static t_stat td_boot (int32 unitno, DEVICE *dptr);
static t_stat td_attach (UNIT *uptr, CONST char *cptr);
static t_stat td_detach (UNIT *uptr);
static t_stat td_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
static void tdi_set_int (int32 ctlr, t_bool val);
static int32 tdi_iack (void);
@@ -667,7 +672,7 @@ static DIB td_dib = {
2, IVCL (TDRX), VEC_AUTO, { &tdi_iack, &tdo_iack }, IOLN_DL,
};
static UNIT td_unit[2*TD_NUMCTLR];
static UNIT td_unit[2*TD_NUMCTLR] = {{0}};
static REG td_reg[] = {
{ DRDATAD (CTRLRS, td_ctrls, 4, "number of controllers"), REG_HRO },
@@ -715,10 +720,10 @@ DEVICE tdc_dev = {
"TDC", td_unit, td_reg, td_mod,
2*TD_NUMCTLR, DEV_RDX, 20, 1, DEV_RDX, 8,
NULL, NULL, &td_reset,
&td_boot, NULL, NULL,
&td_dib, DEV_DISABLE | DEV_DIS | DEV_UBUS | DEV_QBUS | DEV_DEBUG, 0,
&td_boot, &td_attach, &td_detach,
&td_dib, DEV_DISABLE | DEV_DIS | DEV_UBUS | DEV_QBUS | DEV_DEBUG | DEV_DISK, 0,
td_deb, NULL, NULL, &td_help, NULL, NULL,
&td_description
&td_description, NULL, &drv_tab
};
#define CSI_CLR_INT ctlr->rx_set_int (ctlr-td_ctlr, 0)
@@ -1413,12 +1418,12 @@ for (ctl=0; ctl<TD_NUMCTLR; ctl++) {
ctlr->rx_set_int = tdi_set_int;
ctlr->tx_set_int = tdo_set_int;
td_unit[2*ctl+0].action = &td_svc;
td_unit[2*ctl+0].flags |= UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF|UNIT_DIS;
td_unit[2*ctl+0].capac = TD_SIZE;
td_unit[2*ctl+0].flags = UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF|UNIT_DIS;
sim_disk_set_drive_type_by_name (&td_unit[2*ctl+0], "TU58");
td_unit[2*ctl+0].up7 = ctlr;
td_unit[2*ctl+1].action = &td_svc;
td_unit[2*ctl+1].flags |= UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF|UNIT_DIS;
td_unit[2*ctl+1].capac = TD_SIZE;
td_unit[2*ctl+1].flags = UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF|UNIT_DIS;
sim_disk_set_drive_type_by_name (&td_unit[2*ctl+1], "TU58");
td_unit[2*ctl+1].up7 = ctlr;
td_reset_ctlr (ctlr);
sim_cancel (&td_unit[2*ctl]);
@@ -1498,11 +1503,11 @@ uint32 i;
CTLR *ctlr = &td_ctlr[TD_NUMCTLR];
for (i=0; i<dptr->numunits; i++) {
dptr->units[i].capac = TD_SIZE;
dptr->units[i].action = td_svc;
dptr->units[i].flags |= UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF;
dptr->units[i].up7 = (void *)ctlr;
sim_cancel (&dptr->units[i]);
sim_disk_set_drive_type_by_name (&dptr->units[i], "TU58");
}
ctlr->dptr = dptr;
ctlr->uptr = dptr->units;
@@ -1511,6 +1516,19 @@ ctlr->tx_set_int = tx_set_int;
return td_reset_ctlr (ctlr);
}
static t_stat td_attach (UNIT *uptr, CONST char *cptr)
{
return sim_disk_attach (uptr, cptr, TD_NUMBY,
sizeof (uint16), TRUE, 0,
"TU58", 0, 0);
}
static t_stat td_detach (UNIT *uptr)
{
sim_cancel (uptr);
return sim_disk_detach (uptr);
}
/* Device bootstrap */
#if defined (VM_PDP11)

9
PDP11/pdp11_td.h
View File

@@ -37,6 +37,7 @@
#define PDP11_TD_H
#include "sim_defs.h"
#include "sim_disk.h"
typedef struct CTLR CTLR;
@@ -86,4 +87,12 @@ static DEBTAB td_deb[] = {
{ NULL, 0 }
};
#define TD_DRV(d) \
{ 128, 4, 1, 512, #d, 512 }
static DRVTYP drv_tab[] = {
TD_DRV (TU58),
{ 0 }
};
#endif /* _PDP11_TD_H */