github.com/simh.simh
1
0
Fork 0
mirror of https://github.com/simh/simh.git synced 2026-01-11 23:52:58 +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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
3B2/3b2_scsi.c
View File

@ -65,25 +65,14 @@ uint8 ha_subdev_cnt;
uint32 ha_crc = 0;
uint32 cq_offset = 0;
static struct scsi_dev_t ha_tab[] = {
static DRVTYP ha_tab[] = {
HA_DISK(SD327),
HA_TAPE(ST120)
};
#define SCSI_U_FLAGS (UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ \
UNIT_ROABLE+(SD327_DTYPE << UNIT_V_DTYPE))
#define SCSI_U_FLAGS (UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE)
UNIT ha_unit[] = {
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 0 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 1 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 2 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 3 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 4 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 5 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 6 */
{ UDATA (&ha_svc, SCSI_U_FLAGS, HA_SIZE(SD327)) }, /* SCSI ID 7 */
{ UDATA (&ha_svc, UNIT_DIS, 0) }, /* CIO unit */
};
UNIT ha_unit[9] = {0}; /* SCSI ID 0-7 + CIO Unit */
static UNIT *cio_unit = &ha_unit[8];
@ -94,12 +83,6 @@ MTAB ha_mod[] = {
&scsi_set_wlk, NULL, NULL, "Write lock disk drive" },
{ MTAB_XTD|MTAB_VUN, 0, "WRITE", NULL,
NULL, &scsi_show_wlk, NULL, "Display drive writelock status" },
{ MTAB_XTD|MTAB_VUN, SD327_DTYPE, NULL, "SD327",
&ha_set_type, NULL, NULL, "Set CDC 327MB Disk Type" },
{ MTAB_XTD|MTAB_VUN, ST120_DTYPE, NULL, "ST120",
&ha_set_type, NULL, NULL, "Set Wangtek 120MB Tape Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &ha_show_type, NULL, "Display device type" },
{ MTAB_XTD|MTAB_VUN, 0, "FORMAT", "FORMAT",
&scsi_set_fmt, &scsi_show_fmt, NULL, "Set/Display unit format" },
{ 0 }
@ -143,6 +126,8 @@ DEVICE ha_dev = {
NULL,
NULL,
NULL,
NULL,
&ha_tab
};
void ha_cio_reset(uint8 cid)
@ -157,14 +142,28 @@ void ha_cio_reset(uint8 cid)
t_stat ha_reset(DEVICE *dptr)
{
uint8 cid;
uint32 t, dtyp;
uint32 t;
UNIT *uptr;
t_stat r;
static t_bool inited = FALSE;
sim_debug(HA_TRACE, &ha_dev,
"[%08x] [ha_reset] Resetting SCSI device\n",
R[NUM_PC]);
if (!inited) {
inited = TRUE;
for (t = 0; t < dptr->numunits - 1; t++) {
uptr = dptr->units + t;
uptr->action = &ha_svc;
uptr->flags = SCSI_U_FLAGS;
sim_disk_set_drive_type_by_name (uptr, "SD327");
}
uptr = dptr->units + t;
uptr->action = &ha_svc;
uptr->flags = UNIT_DIS;
}
ha_state.pump_state = PUMP_NONE;
if (ha_buf == NULL) {
@ -187,8 +186,6 @@ t_stat ha_reset(DEVICE *dptr)
uptr->flags = UNIT_DIS;
}
scsi_add_unit(&ha_bus, t, uptr);
dtyp = GET_DTYPE(uptr->flags);
scsi_set_unit(&ha_bus, uptr, &ha_tab[dtyp]);
scsi_reset_unit(uptr);
}
@ -253,7 +250,6 @@ static void ha_calc_subdevs()
{
uint32 target;
UNIT *uptr;
SCSI_DEV *dev;
ha_subdev_cnt = 0;
@ -262,7 +258,6 @@ static void ha_calc_subdevs()
for (target = 0; target < 8; target++) {
uptr = &ha_unit[target];
if (uptr->flags & UNIT_ATT) {
dev = (SCSI_DEV *)uptr->up7;
ha_subdev_tab[ha_subdev_cnt++] = target;
}
}
@ -790,7 +785,6 @@ static void ha_cmd(uint8 op, uint8 subdev, uint32 addr, int32 len, t_bool expres
{
int32 i, block;
UNIT *uptr;
SCSI_DEV *dev;
int8 target;
/* Immediately cancel any pending IRQs */
@ -864,13 +858,11 @@ static void ha_cmd(uint8 op, uint8 subdev, uint32 addr, int32 len, t_bool expres
uptr = &ha_unit[target];
dev = (SCSI_DEV *)uptr->up7;
sim_debug(HA_TRACE, &ha_dev,
"[ha_cmd] [DSD] Probing subdev %d, target %d, devtype %d\n",
i, target, dev->devtype);
i, target, uptr->drvtyp->devtype);
switch(dev->devtype) {
switch(uptr->drvtyp->devtype) {
case SCSI_DISK:
sim_debug(HA_TRACE, &ha_dev,
"[ha_cmd] [DSD] Subdev %d is DISK (writing to addr %08x)\n",
@ -921,9 +913,7 @@ static void ha_cmd(uint8 op, uint8 subdev, uint32 addr, int32 len, t_bool expres
return;
}
dev = (SCSI_DEV *)uptr->up7;
switch(dev->devtype) {
switch(uptr->drvtyp->devtype) {
case SCSI_DISK:
ha_boot_disk(uptr, target);
break;
@ -981,11 +971,10 @@ static void ha_cmd(uint8 op, uint8 subdev, uint32 addr, int32 len, t_bool expres
return;
}
dev = (SCSI_DEV *)uptr->up7;
block = pread_w(addr); /* Logical block we've been asked to read */
addr = pread_w(addr + 4); /* Dereference the pointer to the destination */
switch(dev->devtype) {
switch(uptr->drvtyp->devtype) {
case SCSI_TAPE:
ha_read_block_tape(uptr, addr);
break;
@ -1341,30 +1330,6 @@ void ha_fcm_express()
}
}
t_stat ha_set_type(UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if (val < 0 || cptr || val > HA_MAX_DTYPE) {
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) ha_tab[val].lbn;
scsi_set_unit(&ha_bus, uptr, &ha_tab[val]);
scsi_reset_unit(uptr);
return SCPE_OK;
}
t_stat ha_show_type(FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf(st, "%s", ha_tab[GET_DTYPE(uptr->flags)].name);
return SCPE_OK;
}
/* Used for debugging only */
/* TODO: Remove after testing */
static void dump_edt()

20
3B2/3b2_scsi.h
View File

@ -93,14 +93,13 @@
ha_state.reply.status = (cio_stat); \
}
#define HA_MAX_DTYPE 1
/* CDC Wren IV 327 MB Hard Disk (AT&T KS-23483,L3) */
#define SD327_DTYPE 0
#define SD327_PQUAL 0x00
#define SD327_SCSI 1
#define SD327_BLK 512
#define SD327_LBN 640396
#define SD327_TEXT "Set CDC 327MB Disk Type"
#define SD327_MANU "AT&T"
#define SD327_DESC "KS23483"
#define SD327_REV "0001" /* TODO: Find real rev */
@ -118,28 +117,25 @@
#define SD327_RPM 3600
/* Wangtek 120MB cartridge tape (AT&T KS-23465) */
#define ST120_DTYPE 1
#define ST120_PQUAL 0x00
#define ST120_SCSI 1
#define ST120_BLK 512
#define ST120_LBN 266004
#define ST120_TEXT "Set Wangtek 120MB Tape Type"
#define ST120_MANU "WANGTEK"
#define ST120_DESC "KS23465"
#define ST120_REV "CX17"
#define ST120_DENS 5
#define UNIT_V_DTYPE (SCSI_V_UF + 0)
#define UNIT_M_DTYPE 0x1f
#define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE)
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & UNIT_M_DTYPE)
#define HA_DISK(d) { \
#define HA_DISK(d) { DRV_SCSI( \
SCSI_DISK, d##_PQUAL, d##_SCSI, FALSE, d##_BLK, \
d##_LBN, d##_MANU, d##_DESC, d##_REV, #d, 0 \
d##_LBN, d##_MANU, d##_DESC, d##_REV, #d, 0, \
d##_TEXT) \
}
#define HA_TAPE(d) { \
#define HA_TAPE(d) { DRV_SCSI( \
SCSI_TAPE, d##_PQUAL, d##_SCSI, TRUE, d##_BLK, \
d##_LBN, d##_MANU, d##_DESC, d##_REV, #d, 0 \
d##_LBN, d##_MANU, d##_DESC, d##_REV, #d, 0, \
d##_TEXT) \
}
#define HA_SIZE(d) d##_LBN

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 */

177
VAX/vax4xx_rd.c
View File

@ -37,9 +37,8 @@
#endif
#define RD_NUMDR 3
#define RD_RMV(u) ((drv_tab[GET_DTYPE (u->flags)].flgs & RDDF_RMV)? \
UF_RMV: 0)
#define RDDF_RMV 01 /* removable */
#define RD_RMV(u) ((u->drvtyp->flags & RDDF_RMV)? UF_RMV : 0)
#define RDDF_RMV DRVFL_RMV /* removable */
#define RD_NUMBY 512 /* bytes/sector */
#define RD_MAXFR (1 << 14) /* max transfer */
@ -108,8 +107,6 @@
#define TRM_ERR_VER 2 /* Error in VERIFY sequence */
#define TRM_ERR_TRAN 3 /* Error in DATA TRANSFER sequence */
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & UNIT_M_DTYPE)
#define DBG_REG 0x0001 /* registers */
#define DBG_CMD 0x0002 /* commands */
#define DBG_RD 0x0004 /* disk reads */
@ -125,8 +122,8 @@
#define CUR_DRV (rd_cstat & CST_SDRV) /* currently selected drive */
#define GET_SPT(u) (drv_tab[GET_DTYPE (u->flags)].sect)
#define GET_SURF(u) (drv_tab[GET_DTYPE (u->flags)].surf)
#define GET_SPT(u) (u->drvtyp->sect)
#define GET_SURF(u) (u->drvtyp->surf)
#define GET_DA(u,c,h,s) ((c * (GET_SPT(u) * GET_SURF(u))) \
+ (h * GET_SPT(u)) + s)
@ -141,7 +138,6 @@
RD54 17 15 1225 15 1 7*8 311256
*/
#define RX33_DTYPE 0
#define RX33_SECT 15
#define RX33_SURF 2
#define RX33_CYL 80
@ -156,9 +152,8 @@
#define RX33_CYLR 0
#define RX33_CCS 0
#define RX33_MED 0x25658021
#define RX33_FLGS RDDF_RMV
#define RX33_FLGS RDDF_RMV | DRVFL_NOCHNG
#define RD31_DTYPE 1
#define RD31_SECT 17
#define RD31_SURF 4
#define RD31_CYL 616 /* last unused */
@ -173,9 +168,8 @@
#define RD31_CYLR 615
#define RD31_CCS 9
#define RD31_MED 0x2564401F
#define RD31_FLGS 0
#define RD31_FLGS DRVFL_NORMV
#define RD32_DTYPE 2
#define RD32_SECT 17
#define RD32_SURF 6
#define RD32_CYL 821 /* last unused */
@ -190,9 +184,8 @@
#define RD32_CYLR 821
#define RD32_CCS 14
#define RD32_MED 0x25644020
#define RD32_FLGS 0
#define RD32_FLGS DRVFL_NORMV
#define RD53_DTYPE 3
#define RD53_SECT 17
#define RD53_SURF 8
#define RD53_CYL 1024 /* last unused */
@ -207,9 +200,8 @@
#define RD53_CYLR 1024
#define RD53_CCS 13
#define RD53_MED 0x25644035
#define RD53_FLGS 0
#define RD53_FLGS DRVFL_NORMV
#define RD54_DTYPE 4
#define RD54_SECT 17
#define RD54_SURF 15
#define RD54_CYL 1225 /* last unused */
@ -224,12 +216,8 @@
#define RD54_CYLR 1225
#define RD54_CCS 14
#define RD54_MED 0x25644036
#define RD54_FLGS 0
#define RD54_FLGS DRVFL_NORMV
#define UNIT_V_DTYPE (DKUF_V_UF + 0) /* drive type */
#define UNIT_W_DTYPE 3 /* 3b drive type encode */
#define UNIT_M_DTYPE ((1u << UNIT_W_DTYPE) - 1)
#define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE)
#define UNIT_NOAUTO DKUF_NOAUTOSIZE
struct drvtyp {
@ -252,16 +240,19 @@ struct drvtyp {
};
#define RD_DRV(d) \
d##_SECT, d##_SURF, d##_CYL, d##_TPG, \
d##_XBN, d##_DBN, d##_LBN, d##_RCTS, \
d##_RCTC, d##_RBN, d##_CYLP, d##_CYLR, \
d##_CCS, d##_MED, d##_FLGS
#define RD_SIZE(d) (d##_LBN * RD_NUMBY)
{ d##_SECT, d##_SURF, d##_CYL, d##_LBN, \
#d, RD_NUMBY, DRVFL_TYPE_MFM | d##_FLGS,\
"DU", d##_MED, 0, NULL, NULL, \
d##_TPG, 0, d##_XBN, d##_DBN, d##_RCTS, \
d##_RCTC, d##_RBN, d##_CYLP, d##_CYLR, \
d##_CCS }
static struct drvtyp drv_tab[] = {
{ RD_DRV (RX33), "RX33" },{ RD_DRV (RD31), "RD31" },
{ RD_DRV (RD32), "RD32" },{ RD_DRV (RD53), "RD53" },
{ RD_DRV (RD54), "RD54" },
static DRVTYP drv_tab[] = {
RD_DRV (RX33),
RD_DRV (RD31),
RD_DRV (RD32),
RD_DRV (RD53),
RD_DRV (RD54),
{ 0 }
};
@ -290,8 +281,6 @@ void rd_set_dstat (UNIT *uptr);
void rd_done (int32 term_code, t_bool setint);
void rd_cmd (int32 data);
int32 rd_decode_cmd (int32 data);
t_stat rd_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rd_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat rd_attach (UNIT *uptr, CONST char *cptr);
t_stat rd_detach (UNIT *uptr);
t_stat rd_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
@ -309,14 +298,7 @@ DIB rd_dib = {
RD_ROM_INDEX, BOOT_CODE_ARRAY, BOOT_CODE_SIZE
};
UNIT rd_unit[] = {
{ UDATA (&rd_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RD_SIZE (RD54)) },
{ UDATA (&rd_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RD54_DTYPE << UNIT_V_DTYPE), RD_SIZE (RD54)) },
{ UDATA (&rd_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RX33_DTYPE << UNIT_V_DTYPE), RD_SIZE (RX33)) }
};
UNIT rd_unit[RD_NUMDR] = {{0}};
REG rd_reg[] = {
{ DRDATA (RPTR, rd_rg_p, 4), REG_HRO },
@ -336,7 +318,6 @@ REG rd_reg[] = {
{ HRDATAD (TCON, rd_term, 8, "Termination Conditions") },
{ DRDATAD (CWAIT, rd_cwait, 24, "Command wait time"), PV_LEFT + REG_NZ },
{ DRDATAD (DWAIT, rd_dwait, 24, "Data wait time"), PV_LEFT + REG_NZ },
{ URDATA (CAPAC, rd_unit[0].capac, 10, T_ADDR_W, 0, RD_NUMDR, REG_HRO | PV_LEFT) },
{ FLDATAD (INT, int_req[IPL_SCA], INT_V_SCA, "Interrupt pending flag") },
{ NULL }
};
@ -357,18 +338,6 @@ MTAB rd_mod[] = {
&set_writelock, &show_writelock, NULL, "Write enable drive" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "LOCKED",
&set_writelock, NULL, NULL, "Write lock drive" },
{ MTAB_XTD|MTAB_VUN, RX33_DTYPE, NULL, "RX33",
&rd_set_type, NULL, NULL, "Set RX33 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD31_DTYPE, NULL, "RD31",
&rd_set_type, NULL, NULL, "Set RD31 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD32_DTYPE, NULL, "RD32",
&rd_set_type, NULL, NULL, "Set RD32 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD53_DTYPE, NULL, "RD53",
&rd_set_type, NULL, NULL, "Set RD53 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RD54_DTYPE, NULL, "RD54",
&rd_set_type, NULL, NULL, "Set RD54 Disk Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rd_show_type, NULL, "Display device type" },
{ UNIT_NOAUTO, UNIT_NOAUTO, "noautosize", "NOAUTOSIZE", NULL, NULL, NULL, "Disable disk autosize on attach" },
{ UNIT_NOAUTO, 0, "autosize", "AUTOSIZE", NULL, NULL, NULL, "Enable disk autosize on attach" },
{ MTAB_XTD|MTAB_VUN | MTAB_VALR, 0, "FORMAT", "FORMAT={SIMH|VHD|RAW}",
@ -381,9 +350,9 @@ DEVICE rd_dev = {
RD_NUMDR, DEV_RDX, 20, 1, DEV_RDX, 8,
NULL, NULL, &rd_reset,
NULL, &rd_attach, &rd_detach,
&rd_dib, DEV_DEBUG | RD_FLAGS, 0,
&rd_dib, DEV_DEBUG | DEV_SECTORS | DEV_DISK | RD_FLAGS, 0,
rd_debug, NULL, NULL, &rd_help, NULL, NULL,
&rd_description
&rd_description, NULL, drv_tab
};
/* RD read
@ -597,7 +566,7 @@ switch (uptr->CMD) {
else
uptr->CYL++; /* out */
max_cyl = drv_tab[GET_DTYPE (uptr->flags)].cyl;
max_cyl = uptr->drvtyp->cyl;
if (uptr->CYL == max_cyl) /* check for wrap */
uptr->CYL = 0;
if (uptr->CYL == -1)
@ -638,7 +607,7 @@ return CMD_UNKNOWN;
/* read cylinder 0 - simulate special formatting */
t_stat rd_rdcyl0 (int32 hd, int32 dtype)
t_stat rd_rdcyl0 (int32 hd, UNIT *uptr)
{
uint32 i;
uint16 c;
@ -647,28 +616,28 @@ if (hd <= 2) {
memset (rd_xb, 0, sizeof(*rd_xb) * 256); /* fill sector buffer with 0's */
/* rd_xb[0]-rd_xb[3] */ /* 8 bytes of zero */
rd_xb[4] = 0x3600;
rd_xb[5] = drv_tab[dtype].xbn & WMASK; /* number of XBNs */
rd_xb[6] = (drv_tab[dtype].xbn >> 16) & WMASK;
rd_xb[7] = drv_tab[dtype].dbn & WMASK; /* number of DBNs */
rd_xb[8] = (drv_tab[dtype].dbn >> 16) & WMASK;
rd_xb[9] = drv_tab[dtype].lbn & WMASK; /* number of LBNs (Logical-Block-Numbers) */
rd_xb[10] = (drv_tab[dtype].lbn >> 16) & WMASK;
rd_xb[11] = drv_tab[dtype].rbn & WMASK; /* number of RBNs (Replacement-Block-Numbers) */
rd_xb[12] = (drv_tab[dtype].rbn >> 16) & WMASK;
rd_xb[13] = drv_tab[dtype].sect; /* number of sectors per track */
rd_xb[14] = drv_tab[dtype].tpg; /* number of tracks */
rd_xb[15] = drv_tab[dtype].cyl; /* number of cylinders */
rd_xb[16] = drv_tab[dtype].cylp; /* first cylinder for write precompensation */
rd_xb[17] = drv_tab[dtype].cylr; /* first cylinder for reduced write current */
rd_xb[5] = uptr->drvtyp->xbn & WMASK; /* number of XBNs */
rd_xb[6] = (uptr->drvtyp->xbn >> 16) & WMASK;
rd_xb[7] = uptr->drvtyp->dbn & WMASK; /* number of DBNs */
rd_xb[8] = (uptr->drvtyp->dbn >> 16) & WMASK;
rd_xb[9] = uptr->drvtyp->size & WMASK; /* number of LBNs (Logical-Block-Numbers) */
rd_xb[10] = (uptr->drvtyp->size >> 16) & WMASK;
rd_xb[11] = uptr->drvtyp->rbn & WMASK; /* number of RBNs (Replacement-Block-Numbers) */
rd_xb[12] = (uptr->drvtyp->rbn >> 16) & WMASK;
rd_xb[13] = uptr->drvtyp->sect; /* number of sectors per track */
rd_xb[14] = uptr->drvtyp->tpg; /* number of tracks */
rd_xb[15] = uptr->drvtyp->cyl; /* number of cylinders */
rd_xb[16] = uptr->drvtyp->cylp; /* first cylinder for write precompensation */
rd_xb[17] = uptr->drvtyp->cylr; /* first cylinder for reduced write current */
rd_xb[18] = 0; /* seek rate or zero for buffered seeks */
rd_xb[19] = 1; /* 0 if CRC, 1 if ECC is being used */
rd_xb[20] = drv_tab[dtype].rcts; /* "replacement control table" (RCT) */
rd_xb[21] = drv_tab[dtype].rctc; /* number of copies of the RCT */
rd_xb[22] = drv_tab[dtype].med & WMASK; /* media identifier */
rd_xb[23] = (drv_tab[dtype].med >> 16) & WMASK;
rd_xb[20] = uptr->drvtyp->rcts; /* "replacement control table" (RCT) */
rd_xb[21] = uptr->drvtyp->rctc; /* number of copies of the RCT */
rd_xb[22] = uptr->drvtyp->MediaId & WMASK; /* media identifier */
rd_xb[23] = (uptr->drvtyp->MediaId >> 16) & WMASK;
rd_xb[24] = 1; /* sector-to-sector interleave */
rd_xb[25] = 7; /* head-to-head skew */
rd_xb[26] = drv_tab[dtype].ccs; /* cylinder-to-cylinder skew */
rd_xb[26] = uptr->drvtyp->ccs; /* cylinder-to-cylinder skew */
rd_xb[27] = 16; /* size of GAP 0 in the MFM format */
rd_xb[28] = 16; /* size of GAP 1 in the MFM format */
rd_xb[29] = 5; /* size of GAP 2 in the MFM format */
@ -709,18 +678,17 @@ return sim_disk_wrsect (uptr, lba, (uint8 *)rd_xb, &sectswritten, sects);
t_stat rd_svc (UNIT *uptr)
{
t_lba lba;
int32 dtype = GET_DTYPE (uptr->flags);
switch (uptr->CMD) {
case CMD_RDPHY:
case CMD_RDLOG:
uptr->CYL = rd_dcyl;
uptr->HEAD = rd_dhead;
if (dtype >= RD31_DTYPE) {
if (strcasecmp (uptr->drvtyp->name, "RX33") != 0) {
if (rd_dcyl == 0) {
lba = 0;
sim_debug (DBG_RD, &rd_dev, "cyl=%04d, hd=%d, sect=%02d, lba=%08X\n", rd_dcyl, rd_dhead, rd_dsect, lba);
rd_rdcyl0 (rd_dhead, dtype);
rd_rdcyl0 (rd_dhead, uptr);
}
else {
lba = GET_DA (uptr, (rd_dcyl - 1), rd_dhead, rd_dsect);
@ -752,7 +720,7 @@ switch (uptr->CMD) {
uptr->HEAD = rd_dhead;
ddb_ReadW (rd_dma, (rd_scnt * RD_NUMBY), rd_xb);
rd_dma = (rd_dma + (rd_scnt * RD_NUMBY)) & 0xFFFFFF;
if (dtype >= RD31_DTYPE) {
if (strcasecmp (uptr->drvtyp->name, "RX33") != 0) {
if (rd_dcyl == 0) {
lba = 0;
sim_debug (DBG_WR, &rd_dev, "cyl=%04d, hd=%d, sect=%02d, lba=%08X (ignored)\n", rd_dcyl, rd_dhead, rd_dsect, lba);
@ -850,6 +818,22 @@ if ((rd_term & 0x20) && setint) {
t_stat rd_reset (DEVICE *dptr)
{
static t_bool inited = FALSE;
if (!inited) {
int32 i;
inited = TRUE;
for (i = 0; i < RD_NUMDR; i++) {
UNIT *uptr = rd_unit + i;
uptr->action = &rd_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE;
}
sim_disk_set_drive_type_by_name (&rd_unit[0], "RD54");
sim_disk_set_drive_type_by_name (&rd_unit[1], "RD54");
sim_disk_set_drive_type_by_name (&rd_unit[2], "RX33");
}
rd_rg_p = 0;
CLR_INT (SCA); /* clear int req */
rd_done (TRM_OK, FALSE);
@ -867,12 +851,9 @@ return SCPE_OK;
t_stat rd_attach (UNIT *uptr, CONST char *cptr)
{
const char *drives[] = {"RX33", "RD31", "RD32", "RD53", "RD54", };
return sim_disk_attach_ex (uptr, cptr, RD_NUMBY,
sizeof (uint8), TRUE, DBG_DSK,
drv_tab[GET_DTYPE (uptr->flags)].name, 0, 0,
(uptr->flags & UNIT_NOAUTO) ? NULL: drives);
uptr->drvtyp->name, 0, 0, NULL);
}
/* Detach routine */
@ -883,36 +864,6 @@ sim_cancel (uptr);
return sim_disk_detach (uptr);
}
/* Set unit type */
t_stat rd_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if (uptr->flags & UNIT_ATT)
return SCPE_ALATT;
if ((uptr == &rd_unit[0]) || (uptr == &rd_unit[1])) { /* hard disk only */
if (val < RD31_DTYPE)
return SCPE_ARG;
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
}
if (uptr == &rd_unit[2]) { /* floppy disk only */
if (val > RX33_DTYPE)
return SCPE_ARG;
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
}
uptr->capac = ((t_addr) drv_tab[val].lbn) * RD_NUMBY;
return SCPE_OK;
}
/* Show unit type */
t_stat rd_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", drv_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
t_stat rd_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr)
{
fprintf (st, "HDC9224 Disk Controller (RD)\n\n");

177
VAX/vax4xx_rz80.c
View File

@ -114,11 +114,6 @@
#define UA_SELECT 0
#define UNIT_V_DTYPE (SCSI_V_UF + 0) /* drive type */
#define UNIT_M_DTYPE 0x1F
#define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE)
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & UNIT_M_DTYPE)
typedef struct {
uint32 cnum; /* ctrl number */
uint8 odata; /* output data */
@ -144,8 +139,6 @@ t_stat rz_isvc (UNIT *uptr);
t_stat rz_reset (DEVICE *dptr);
t_stat rz_attach (UNIT *uptr, CONST char *cptr);
t_stat rz_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr);
t_stat rz_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat rz_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
void rz_update_status (CTLR *rz);
void rz_setint (CTLR *rz, uint32 flags);
void rz_clrint (CTLR *rz);
@ -163,25 +156,7 @@ const char *rz_description (DEVICE *dptr);
CTLR rz_ctx = { 0 };
UNIT rz_unit[] = {
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_isvc, UNIT_DIS, 0) }
};
UNIT rz_unit[RZ_NUMDR + 1] = {{0}};
REG rz_reg[] = {
{ FLDATAD ( INT, int_req[IPL_SCA], INT_V_SCA, "interrupt pending flag") },
@ -205,44 +180,6 @@ MTAB rz_mod[] = {
&scsi_set_wlk, &scsi_show_wlk, NULL, "Write enable drive" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "LOCKED",
&scsi_set_wlk, NULL, NULL, "Write lock drive" },
{ MTAB_XTD|MTAB_VUN, RZ23_DTYPE, NULL, "RZ23",
&rz_set_type, NULL, NULL, "Set RZ23 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ23L_DTYPE, NULL, "RZ23L",
&rz_set_type, NULL, NULL, "Set RZ23L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ24_DTYPE, NULL, "RZ24",
&rz_set_type, NULL, NULL, "Set RZ24 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ24L_DTYPE, NULL, "RZ24L",
&rz_set_type, NULL, NULL, "Set RZ24L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ25_DTYPE, NULL, "RZ25",
&rz_set_type, NULL, NULL, "Set RZ25 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ25L_DTYPE, NULL, "RZ25L",
&rz_set_type, NULL, NULL, "Set RZ25L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ26_DTYPE, NULL, "RZ26",
&rz_set_type, NULL, NULL, "Set RZ26 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ26L_DTYPE, NULL, "RZ26L",
&rz_set_type, NULL, NULL, "Set RZ26L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ55_DTYPE, NULL, "RZ55",
&rz_set_type, NULL, NULL, "Set RZ55 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD40_DTYPE, NULL, "CDROM",
&rz_set_type, NULL, NULL, "Set RRD40 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD40_DTYPE, NULL, "RRD40",
&rz_set_type, NULL, NULL, "Set RRD40 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD42_DTYPE, NULL, "RRD42",
&rz_set_type, NULL, NULL, "Set RRD42 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRW11_DTYPE, NULL, "RRW11",
&rz_set_type, NULL, NULL, "Set RRW11 Disk Type" },
{ MTAB_XTD|MTAB_VUN, CDW900_DTYPE, NULL, "CDW900",
&rz_set_type, NULL, NULL, "Set SONY CDW-900E Disk Type" },
{ MTAB_XTD|MTAB_VUN, XR1001_DTYPE, NULL, "XR1001",
&rz_set_type, NULL, NULL, "Set JVC XR-W1001 Disk Type" },
{ MTAB_XTD|MTAB_VUN, TZK50_DTYPE, NULL, "TZK50",
&rz_set_type, NULL, NULL, "Set DEC TZK50 Tape Type" },
{ MTAB_XTD|MTAB_VUN, TZ30_DTYPE, NULL, "TZ30",
&rz_set_type, NULL, NULL, "Set DEC TZ30 Tape Type" },
{ MTAB_XTD|MTAB_VUN|MTAB_VALR, RZU_DTYPE, NULL, "RZUSER",
&rz_set_type, NULL, NULL, "Set RZUSER=size Disk Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rz_show_type, NULL, "Display device type" },
{ SCSI_NOAUTO, SCSI_NOAUTO, "noautosize", "NOAUTOSIZE", NULL, NULL, NULL, "Disables disk autosize on attach" },
{ SCSI_NOAUTO, 0, "autosize", "AUTOSIZE", NULL, NULL, NULL, "Enables disk autosize on attach" },
{ MTAB_XTD|MTAB_VUN, 0, "FORMAT", "FORMAT",
@ -250,35 +187,14 @@ MTAB rz_mod[] = {
{ 0 }
};
static const char *drv_types[] = {
"RZ23",
"RZ23L",
"RZ24",
"RZ24L",
"RZ25",
"RZ25L",
"RZ26",
"RZ26L",
"RZ55",
"CDROM",
"RRD40",
"RRD42",
"RRW11",
"CDW900",
"XR1001",
"TZK50",
"TZ30",
"RZUSER"
};
DEVICE rz_dev = {
"RZ", rz_unit, rz_reg, rz_mod,
RZ_NUMDR + 1, DEV_RDX, 31, 1, DEV_RDX, 8,
NULL, NULL, &rz_reset,
NULL, &rz_attach, &scsi_detach,
NULL, DEV_DEBUG | DEV_DISK | DEV_SECTORS | RZ_FLAGS,
NULL, DEV_DEBUG | DEV_SCSI | DEV_SECTORS | RZ_FLAGS,
0, rz_debug, NULL, NULL, &rz_help, NULL, NULL,
&rz_description
&rz_description, NULL, &drv_tab
};
/* RZB data structures
@ -294,25 +210,7 @@ DIB rzb_dib = {
RZ_ROM_INDEX, BOOT_CODE_ARRAY, BOOT_CODE_SIZE
};
UNIT rzb_unit[] = {
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_isvc, UNIT_DIS, 0) }
};
UNIT rzb_unit[RZ_NUMDR + 1] = {{0}};
REG rzb_reg[] = {
{ FLDATAD ( INT, int_req[IPL_SCB], INT_V_SCB, "interrupt pending flag") },
@ -324,9 +222,9 @@ DEVICE rzb_dev = {
RZ_NUMDR + 1, DEV_RDX, 31, 1, DEV_RDX, 8,
NULL, NULL, &rz_reset,
NULL, &rz_attach, &scsi_detach,
&rzb_dib, DEV_DEBUG | DEV_DISK | DEV_SECTORS | RZB_FLAGS,
0, rz_debug, NULL, NULL,
&rz_help, NULL /* help and attach_help routines */
&rzb_dib, DEV_DEBUG | DEV_SCSI | DEV_SECTORS | RZB_FLAGS,
0, rz_debug, NULL, NULL, &rz_help, NULL, NULL,
&rz_description, NULL, &drv_tab /* help and attach_help routines */
};
static DEVICE *rz_devmap[RZ_NUMCT] = {
@ -788,11 +686,28 @@ scsi_reset (&rz->bus);
t_stat rz_reset (DEVICE *dptr)
{
int32 ctlr, i;
uint32 dtyp;
int32 ctlr, i, j;
CTLR *rz;
UNIT *uptr;
t_stat r;
static t_bool inited = FALSE;
if (!inited) {
inited = TRUE;
for (i = 0; i < RZ_NUMCT; i++) {
for (j = 0; j < RZ_NUMDR; j++) {
uptr = rz_devmap[i]->units + j;
uptr->action = &rz_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE;
sim_disk_set_drive_type_by_name (uptr, "RZ23");
if (j == RZ_SCSI_ID) /* initiator ID? */
uptr->flags = UNIT_DIS; /* disable unit */
}
uptr = rz_devmap[i]->units + j;
uptr->action = &rz_isvc;
uptr->flags = UNIT_DIS;
}
}
for (i = 0, ctlr = -1; i < RZ_NUMCT; i++) { /* find ctrl num */
if (rz_devmap[i] == dptr)
@ -816,8 +731,6 @@ for (i = 0; i < (RZ_NUMDR + 1); i++) { /* init units */
uptr->flags = UNIT_DIS; /* disable unit */
if (i < RZ_NUMDR) {
scsi_add_unit (&rz->bus, i, uptr);
dtyp = GET_DTYPE (uptr->flags);
scsi_set_unit (&rz->bus, uptr, &rzdev_tab[dtyp]);
scsi_reset_unit (uptr);
}
}
@ -825,42 +738,6 @@ rz_sw_reset (rz);
return SCPE_OK;
}
/* Set unit type (and capacity if user defined) */
t_stat rz_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
CTLR *rz = rz_ctxmap[uptr->cnum];
uint32 cap;
uint32 max = sim_toffset_64? RZU_EMAXC: RZU_MAXC;
t_stat r;
if ((val < 0) || ((val != RZU_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 * 1954;
if ((r != SCPE_OK) || (cap < RZU_MINC) || (cap > max))
return SCPE_ARG;
rzdev_tab[val].lbn = cap;
}
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
uptr->capac = (t_addr)rzdev_tab[val].lbn;
scsi_set_unit (&rz->bus, uptr, &rzdev_tab[val]);
scsi_reset_unit (uptr);
return SCPE_OK;
}
/* Show unit type */
t_stat rz_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", rzdev_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
t_stat rz_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr)
{
fprintf (st, "NCR 5380 SCSI Controller (%s)\n\n", dptr->name);
@ -883,7 +760,7 @@ return SCPE_OK;
t_stat rz_attach (UNIT *uptr, CONST char *cptr)
{
return scsi_attach_ex (uptr, cptr, drv_types);
return scsi_attach_ex (uptr, cptr, NULL);
}
const char *rz_description (DEVICE *dptr)

148
VAX/vax4xx_rz94.c
View File

@ -66,12 +66,8 @@
#define CFG1_TEST 0x08 /* chip test */
#define CFG1_MYID 0x07 /* my bus id */
#define UNIT_V_DTYPE (SCSI_V_UF + 0) /* drive type */
#define UNIT_M_DTYPE 0x1F
#define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE)
#define GET_DTYPE(x) (((x) >> UNIT_V_DTYPE) & UNIT_M_DTYPE)
#define RZ_MAXFR (1u << 16) /* max transfer */
#define RZ_NUMDR 8
uint32 rz_last_cmd = 0;
uint32 rz_txi = 0; /* transfer count */
@ -128,25 +124,7 @@ const char *rz_description (DEVICE *dptr);
rz_reg RZ register list
*/
UNIT rz_unit[] = {
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_ROABLE+
(RZ23_DTYPE << UNIT_V_DTYPE), RZ_SIZE (RZ23)) },
{ UDATA (&rz_svc, UNIT_DIS, 0) }
};
UNIT rz_unit[RZ_NUMDR + 1] = {{0}};
REG rz_reg[] = {
{ FLDATAD (INT, int_req[IPL_SC], INT_V_SC, "interrupt pending flag") },
@ -158,44 +136,6 @@ MTAB rz_mod[] = {
&scsi_set_wlk, &scsi_show_wlk, NULL, "Write enable drive" },
{ MTAB_XTD|MTAB_VUN, 1, NULL, "LOCKED",
&scsi_set_wlk, NULL, NULL, "Write lock drive" },
{ MTAB_XTD|MTAB_VUN, RZ23_DTYPE, NULL, "RZ23",
&rz_set_type, NULL, NULL, "Set RZ23 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ23L_DTYPE, NULL, "RZ23L",
&rz_set_type, NULL, NULL, "Set RZ23L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ24_DTYPE, NULL, "RZ24",
&rz_set_type, NULL, NULL, "Set RZ24 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ24L_DTYPE, NULL, "RZ24L",
&rz_set_type, NULL, NULL, "Set RZ24L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ25_DTYPE, NULL, "RZ25",
&rz_set_type, NULL, NULL, "Set RZ25 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ25L_DTYPE, NULL, "RZ25L",
&rz_set_type, NULL, NULL, "Set RZ25L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ26_DTYPE, NULL, "RZ26",
&rz_set_type, NULL, NULL, "Set RZ26 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ26L_DTYPE, NULL, "RZ26L",
&rz_set_type, NULL, NULL, "Set RZ26L Disk Type" },
{ MTAB_XTD|MTAB_VUN, RZ55_DTYPE, NULL, "RZ55",
&rz_set_type, NULL, NULL, "Set RZ55 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD40_DTYPE, NULL, "CDROM",
&rz_set_type, NULL, NULL, "Set RRD40 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD40_DTYPE, NULL, "RRD40",
&rz_set_type, NULL, NULL, "Set RRD40 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRD42_DTYPE, NULL, "RRD42",
&rz_set_type, NULL, NULL, "Set RRD42 Disk Type" },
{ MTAB_XTD|MTAB_VUN, RRW11_DTYPE, NULL, "RRW11",
&rz_set_type, NULL, NULL, "Set RRW11 Disk Type" },
{ MTAB_XTD|MTAB_VUN, CDW900_DTYPE, NULL, "CDW900",
&rz_set_type, NULL, NULL, "Set SONY CDW-900E Disk Type" },
{ MTAB_XTD|MTAB_VUN, XR1001_DTYPE, NULL, "XR1001",
&rz_set_type, NULL, NULL, "Set JVC XR-W1001 Disk Type" },
{ MTAB_XTD|MTAB_VUN, TZK50_DTYPE, NULL, "TZK50",
&rz_set_type, NULL, NULL, "Set DEC TZK50 Tape Type" },
{ MTAB_XTD|MTAB_VUN, TZ30_DTYPE, NULL, "TZ30",
&rz_set_type, NULL, NULL, "Set DEC TZ30 Tape Type" },
{ MTAB_XTD|MTAB_VUN|MTAB_VALR, RZU_DTYPE, NULL, "RZUSER",
&rz_set_type, NULL, NULL, "Set RZUSER=size Disk Type" },
{ MTAB_XTD|MTAB_VUN, 0, "TYPE", NULL,
NULL, &rz_show_type, NULL, "Display device type" },
{ SCSI_NOAUTO, SCSI_NOAUTO, "noautosize", "NOAUTOSIZE", NULL, NULL, NULL, "Disables disk autosize on attach" },
{ SCSI_NOAUTO, 0, "autosize", "AUTOSIZE", NULL, NULL, NULL, "Enables disk autosize on attach" },
{ MTAB_XTD|MTAB_VUN, 0, "FORMAT", "FORMAT",
@ -203,35 +143,14 @@ MTAB rz_mod[] = {
{ 0 }
};
static const char *drv_types[] = {
"RZ23",
"RZ23L",
"RZ24",
"RZ24L",
"RZ25",
"RZ25L",
"RZ26",
"RZ26L",
"RZ55",
"CDROM",
"RRD40",
"RRD42",
"RRW11",
"CDW900",
"XR1001",
"TZK50",
"TZ30",
"RZUSER"
};
DEVICE rz_dev = {
"RZ", rz_unit, rz_reg, rz_mod,
9, DEV_RDX, 8, 1, DEV_RDX, 8,
NULL, NULL, &rz_reset,
NULL, &rz_attach, &scsi_detach,
NULL, DEV_DISABLE | DEV_DEBUG | DEV_DISK | DEV_SECTORS,
NULL, DEV_DISABLE | DEV_DEBUG | DEV_SCSI | DEV_SECTORS,
0, rz_debug, NULL, NULL, &rz_help, NULL, NULL,
&rz_description
&rz_description, NULL, &drv_tab
};
/* Register names for Debug tracing */
@ -807,8 +726,8 @@ scsi_reset (&rz_bus);
t_stat rz_reset (DEVICE *dptr)
{
uint32 i;
uint32 dtyp;
UNIT *uptr;
static t_bool inited = FALSE;
t_stat r;
if (rz_buf == NULL)
@ -819,54 +738,25 @@ r = scsi_init (&rz_bus, RZ_MAXFR); /* init SCSI bus */
if (r != SCPE_OK)
return r;
rz_bus.dptr = dptr; /* set bus device */
for (i = 0; i < 8; i++) {
if (!inited) {
inited = TRUE;
for (i = 0; i < 8; i++) {
uptr = dptr->units + i;
uptr->action = &rz_svc;
uptr->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_DISABLE|UNIT_ROABLE;
sim_disk_set_drive_type_by_name (uptr, "RZ23");
if (i == RZ_SCSI_ID) /* initiator ID? */
uptr->flags = UNIT_DIS; /* disable unit */
scsi_add_unit (&rz_bus, i, &rz_unit[i]);
}
uptr = dptr->units + i;
if (i == RZ_SCSI_ID) /* initiator ID? */
uptr->flags = UNIT_DIS; /* disable unit */
scsi_add_unit (&rz_bus, i, &rz_unit[i]);
dtyp = GET_DTYPE (rz_unit[i].flags);
scsi_set_unit (&rz_bus, &rz_unit[i], &rzdev_tab[dtyp]);
scsi_reset_unit (&rz_unit[i]);
uptr->action = &rz_svc;
uptr->flags = UNIT_DIS;
}
rz_sw_reset ();
return SCPE_OK;
}
/* Set unit type (and capacity if user defined) */
t_stat rz_set_type (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
uint32 cap;
uint32 max = sim_toffset_64? RZU_EMAXC: RZU_MAXC;
t_stat r;
if ((val < 0) || ((val != RZU_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 * 1954;
if ((r != SCPE_OK) || (cap < RZU_MINC) || (cap > max))
return SCPE_ARG;
rzdev_tab[val].lbn = cap;
}
uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (val << UNIT_V_DTYPE);
uptr->capac = (t_addr)rzdev_tab[val].lbn;
scsi_set_unit (&rz_bus, uptr, &rzdev_tab[val]);
scsi_reset_unit (uptr);
return SCPE_OK;
}
/* Show unit type */
t_stat rz_show_type (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
fprintf (st, "%s", rzdev_tab[GET_DTYPE (uptr->flags)].name);
return SCPE_OK;
}
t_stat rz_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr)
{
fprintf (st, "NCR 53C94 SCSI Controller (%s)\n\n", dptr->name);
@ -889,7 +779,7 @@ return SCPE_OK;
t_stat rz_attach (UNIT *uptr, CONST char *cptr)
{
return scsi_attach_ex (uptr, cptr, drv_types);
return scsi_attach_ex (uptr, cptr, NULL);
}
const char *rz_description (DEVICE *dptr)

4
VAX/vax730_stddev.c
View File

@ -398,8 +398,8 @@ DEVICE td_dev = {
2, DEV_RDX, 20, 1, DEV_RDX, 8,
NULL, NULL, &td_reset,
NULL, NULL, NULL,
NULL, DEV_DEBUG, 0, td_deb, NULL, NULL, NULL, NULL, NULL,
&td_description
NULL, DEV_DEBUG | DEV_DISK, 0, td_deb, NULL, NULL, NULL, NULL, NULL,
&td_description, NULL, &drv_tab
};
static void set_csi_int (int32 ctlr, t_bool val)

4
VAX/vax750_stddev.c
View File

@ -390,8 +390,8 @@ DEVICE td_dev = {
1, DEV_RDX, 20, 1, DEV_RDX, 8,
NULL, NULL, &td_reset,
NULL, NULL, NULL,
NULL, DEV_DEBUG, 0, td_deb, NULL, NULL, NULL, NULL, NULL,
&td_description
NULL, DEV_DEBUG | DEV_DISK, 0, td_deb, NULL, NULL, NULL, NULL, NULL,
&td_description, NULL, &drv_tab
};
static void set_csi_int (int32 ctlr, t_bool val)

49
VAX/vax780_stddev.c
View File

@ -82,6 +82,7 @@
#include "vax_defs.h"
#include "sim_tmxr.h"
#include "sim_disk.h"
/* Terminal definitions */
@ -155,8 +156,9 @@ static BITFIELD tmr_iccs_bits [] = {
#define FL_M_TRACK 0377
#define FL_NUMSC 26 /* sectors/track */
#define FL_M_SECTOR 0177
#define FL_NUMSF 1
#define FL_NUMBY 128 /* bytes/sector */
#define FL_SIZE (FL_NUMTR * FL_NUMSC * FL_NUMBY)/* bytes/disk */
#define FL_SIZE (FL_NUMTR * FL_NUMSC) /* sectors/disk */
#define FL_IDLE 0 /* idle state */
#define FL_RWDS 1 /* rw, sect next */
@ -190,6 +192,16 @@ static BITFIELD tmr_iccs_bits [] = {
#define TRACK u3 /* current track */
#define CALC_DA(t,s) (((t) * FL_NUMSC) + ((s) - 1)) * FL_NUMBY
#define FL_DRV(d) \
{ FL_NUMSC, FL_NUMSF, FL_NUMTR, FL_SIZE, #d, \
FL_NUMBY }
static DRVTYP drv_typ[] = {
FL_DRV(RX01),
{ 0 }
};
int32 tti_csr = 0; /* control/status */
uint32 tti_buftime; /* time input character arrived */
int32 tti_buf = 0; /* buffer */
@ -248,6 +260,8 @@ t_stat clk_detach (UNIT *uptr);
t_stat tmr_reset (DEVICE *dptr);
t_stat fl_svc (UNIT *uptr);
t_stat fl_reset (DEVICE *dptr);
t_stat fl_attach (UNIT *uptr, CONST char *cptr);
t_stat fl_detach (UNIT *uptr);
int32 icr_rd (void);
void tmr_sched (uint32 incr);
t_stat todr_resync (void);
@ -402,8 +416,7 @@ DEVICE tmr_dev = {
fl_mod RX modifier list
*/
UNIT fl_unit = { UDATA (&fl_svc,
UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, FL_SIZE) };
UNIT fl_unit = {0};
REG fl_reg[] = {
{ HRDATAD (FNC, fl_fnc, 8, "function select") },
@ -434,9 +447,9 @@ DEVICE fl_dev = {
"CS", &fl_unit, fl_reg, fl_mod,
1, DEV_RDX, 20, 1, DEV_RDX, 8,
NULL, NULL, &fl_reset,
NULL, NULL, NULL,
NULL, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL,
&fl_description
NULL, &fl_attach, &fl_detach,
NULL, DEV_DISK, 0, NULL, NULL, NULL, NULL, NULL, NULL,
&fl_description, NULL, &drv_typ
};
/* Terminal MxPR routines
@ -1221,12 +1234,36 @@ tti_buf = FL_CPROT; /* status */
fl_state = FL_IDLE; /* floppy idle */
}
/* Attach routine */
t_stat fl_attach (UNIT *uptr, CONST char *cptr)
{
return sim_disk_attach (uptr, cptr, FL_NUMBY,
sizeof (uint8), TRUE, 0,
"RX01", 0, 0);
}
t_stat fl_detach (UNIT *uptr)
{
sim_cancel (uptr);
return sim_disk_detach (uptr);
}
/* Reset */
t_stat fl_reset (DEVICE *dptr)
{
uint32 i;
extern int32 sys_model;
static t_bool inited = FALSE;
if (!inited) {
inited = TRUE;
dptr->units->action = &fl_svc;
dptr->units->flags = UNIT_FIX|UNIT_ATTABLE|UNIT_BUFABLE|UNIT_MUSTBUF;
sim_disk_set_drive_type_by_name (dptr->units, "RX01");
}
fl_esr = FL_STAINC;
fl_ecode = 0; /* clear error */

149
VAX/vax_rzdev.h
View File

@ -29,202 +29,247 @@
#include "sim_scsi.h"
#define RZ23_DTYPE 0
#define RZ23_TYPE SCSI_DISK
#define RZ23_PQUAL 0
#define RZ23_SCSI 1
#define RZ23_RM FALSE
#define RZ23_FLGS 0
#define RZ23_BLK 512
#define RZ23_LBN 204864
#define RZ23_SECTS 33
#define RZ23_SURFS 4
#define RZ23_CYLS 776
#define RZ23_MANU "DEC"
#define RZ23_DESC "RZ23 (C) DEC"
#define RZ23_REV "0A18"
#define RZ23L_DTYPE 1
#define RZ23L_TYPE SCSI_DISK
#define RZ23L_PQUAL 0
#define RZ23L_SCSI 1
#define RZ23L_RM FALSE
#define RZ23L_FLGS 0
#define RZ23L_BLK 512
#define RZ23L_LBN 237588
#define RZ23L_SECTS 39
#define RZ23L_SURFS 4
#define RZ23L_CYLS 1524
#define RZ23L_MANU "DEC"
#define RZ23L_DESC "RZ23L (C) DEC"
#define RZ23L_REV "2528"
#define RZ24_DTYPE 2
#define RZ24_TYPE SCSI_DISK
#define RZ24_PQUAL 0
#define RZ24_SCSI 1
#define RZ24_RM FALSE
#define RZ24_FLGS 0
#define RZ24_BLK 512
#define RZ24_LBN 409792
#define RZ24_SECTS 38
#define RZ24_SURFS 8
#define RZ24_CYLS 1348
#define RZ24_MANU "DEC"
#define RZ24_DESC "RZ24 (C) DEC"
#define RZ24_REV "4041"
#define RZ24L_DTYPE 3
#define RZ24L_TYPE SCSI_DISK
#define RZ24L_PQUAL 0
#define RZ24L_SCSI 2
#define RZ24L_RM FALSE
#define RZ24L_FLGS 0
#define RZ24L_BLK 512
#define RZ24L_LBN 479350
#define RZ24L_SECTS 66
#define RZ24L_SURFS 4
#define RZ24L_CYLS 1818
#define RZ24L_MANU "DEC"
#define RZ24L_DESC "RZ24L (C) DEC"
#define RZ24L_REV "4766"
#define RZ25_DTYPE 4
#define RZ25_TYPE SCSI_DISK
#define RZ25_PQUAL 0
#define RZ25_SCSI 2
#define RZ25_RM FALSE
#define RZ25_FLGS 0
#define RZ25_BLK 512
#define RZ25_LBN 832527
#define RZ25_SECTS 62
#define RZ25_SURFS 9
#define RZ25_CYLS 1492
#define RZ25_MANU "DEC"
#define RZ25_DESC "RZ25 (C) DEC"
#define RZ25_REV "0700"
#define RZ25L_DTYPE 5
#define RZ25L_TYPE SCSI_DISK
#define RZ25L_PQUAL 0
#define RZ25L_SCSI 2
#define RZ25L_RM FALSE
#define RZ25L_FLGS 0
#define RZ25L_BLK 512
#define RZ25L_LBN 1046206
#define RZ25L_SECTS 79
#define RZ25L_SURFS 8
#define RZ25L_CYLS 1891
#define RZ25L_MANU "DEC"
#define RZ25L_DESC "RZ25L (C) DEC"
#define RZ25L_REV "0008"
#define RZ26_DTYPE 6
#define RZ26_TYPE SCSI_DISK
#define RZ26_PQUAL 0
#define RZ26_SCSI 2
#define RZ26_RM FALSE
#define RZ26_FLGS 0
#define RZ26_BLK 512
#define RZ26_LBN 2050860
#define RZ26_SECTS 57
#define RZ26_SURFS 14
#define RZ26_CYLS 2570
#define RZ26_MANU "DEC"
#define RZ26_DESC "RZ26 (C) DEC"
#define RZ26_REV "0700"
#define RZ26L_DTYPE 7
#define RZ26L_TYPE SCSI_DISK
#define RZ26L_PQUAL 0
#define RZ26L_SCSI 2
#define RZ26L_RM FALSE
#define RZ26L_FLGS 0
#define RZ26L_BLK 512
#define RZ26L_LBN 2050860
#define RZ26L_SECTS 57
#define RZ26L_SURFS 14
#define RZ26L_CYLS 2570
#define RZ26L_MANU "DEC"
#define RZ26L_DESC "RZ26L (C) DEC"
#define RZ26L_REV "0008"
#define RZ55_DTYPE 8
#define RZ55_TYPE SCSI_DISK
#define RZ55_PQUAL 0
#define RZ55_SCSI 1
#define RZ55_RM FALSE
#define RZ55_FLGS 0
#define RZ55_BLK 512
#define RZ55_LBN 648437
#define RZ55_SECTS 36
#define RZ55_SURFS 15
#define RZ55_CYLS 1224
#define RZ55_MANU "DEC"
#define RZ55_DESC "RZ55"
#define RZ55_REV "0900"
#define RRD40_DTYPE 9
#define RRD40_TYPE SCSI_CDROM
#define RRD40_PQUAL 0
#define RRD40_SCSI 1
#define RRD40_RM TRUE
#define RRD40_FLGS DRVFL_RMV
#define RRD40_BLK 512
#define RRD40_LBN 1160156
#define RRD40_SECTS 150 /* ??? */
#define RRD40_SURFS 1
#define RRD40_CYLS 7800 /* ??? */
#define RRD40_MANU "DEC"
#define RRD40_DESC "RRD40"
#define RRD40_REV "250D"
#define RRD42_DTYPE 10
#define RRD42_TYPE SCSI_CDROM
#define RRD42_PQUAL 0
#define RRD42_SCSI 1
#define RRD42_RM TRUE
#define RRD42_FLGS DRVFL_RMV
#define RRD42_BLK 512
#define RRD42_LBN 1160156
#define RRD42_SECTS 150 /* ??? */
#define RRD42_SURFS 1
#define RRD42_CYLS 7800 /* ??? */
#define RRD42_MANU "DEC"
#define RRD42_DESC "RRD42"
#define RRD42_REV "1.1A"
#define RRW11_DTYPE 11
#define RRW11_TYPE SCSI_WORM
#define RRW11_PQUAL 0
#define RRW11_SCSI 1
#define RRW11_RM TRUE
#define RRW11_FLGS DRVFL_RMV
#define RRW11_BLK 512
#define RRW11_LBN 1160156
#define RRW11_SECTS 150 /* ??? */
#define RRW11_SURFS 1
#define RRW11_CYLS 7800 /* ??? */
#define RRW11_MANU "DEC"
#define RRW11_DESC "RRW11"
#define RRW11_REV "1.1A"
#define CDW900_DTYPE 12
#define CDW900_TYPE SCSI_WORM
#define CDW900_PQUAL 0
#define CDW900_SCSI 1
#define CDW900_RM TRUE
#define CDW900_FLGS DRVFL_RMV
#define CDW900_BLK 512
#define CDW900_LBN 1160156
#define CDW900_SECTS 150 /* ??? */
#define CDW900_SURFS 1
#define CDW900_CYLS 7800 /* ??? */
#define CDW900_MANU "SONY"
#define CDW900_DESC "CDW-900E"
#define CDW900_REV "1.13"
#define XR1001_DTYPE 13
#define XR1001_TYPE SCSI_WORM
#define XR1001_PQUAL 0
#define XR1001_SCSI 1
#define XR1001_RM TRUE
#define XR1001_FLGS DRVFL_RMV
#define XR1001_BLK 512
#define XR1001_LBN 1160156
#define XR1001_SECTS 150 /* ??? */
#define XR1001_SURFS 1
#define XR1001_CYLS 7800 /* ??? */
#define XR1001_MANU "JVC"
#define XR1001_DESC "XR-W1001"
#define XR1001_REV "1.1A"
#define TZK50_DTYPE 14
#define TZK50_TYPE SCSI_TAPE
#define TZK50_PQUAL 0x50
#define TZK50_SCSI 1
#define TZK50_RM TRUE
#define TZK50_FLGS DRVFL_RMV
#define TZK50_BLK 512
#define TZK50_LBN 1160156
#define TZK50_SECTS 0 /* ??? */
#define TZK50_SURFS 0
#define TZK50_CYLS 0 /* ??? */
#define TZK50_MANU "DEC"
#define TZK50_DESC "TZK50"
#define TZK50_REV "1.1A"
#define TZ30_DTYPE 15
#define TZ30_TYPE SCSI_TAPE
#define TZ30_PQUAL 0x30
#define TZ30_SCSI 1
#define TZ30_RM TRUE
#define TZ30_FLGS DRVFL_RMV
#define TZ30_BLK 512
#define TZ30_LBN 1160156
#define TZ30_SECTS 0 /* ??? */
#define TZ30_SURFS 0
#define TZ30_CYLS 0 /* ??? */
#define TZ30_MANU "DEC"
#define TZ30_DESC "TZK50"
#define TZ30_REV "1.1A"
#define RZU_DTYPE 16 /* user defined */
#define RZU_TYPE SCSI_DISK
#define RZU_PQUAL 0
#define RZU_SCSI 2
#define RZU_RM TRUE
#define RZU_BLK 512
#define RZU_LBN 236328 /* from RZ23 */
#define RZU_MANU "SIMH"
#define RZU_DESC "RZUSER"
#define RZU_REV "0001"
#define RZU_MINC 10000 /* min cap LBNs */
#define RZU_MAXC 4194303 /* max cap LBNs */
#define RZU_EMAXC 2147483647 /* ext max cap */
#define RZU_TYPE SCSI_DISK
#define RZU_PQUAL 0
#define RZU_SCSI 2
#define RZU_FLGS DRVFL_RMV | DRVFL_SETSIZE
#define RZU_BLK 512
#define RZU_LBN 2500860
#define RZU_SECTS 150 /* ??? */
#define RZU_SURFS 15
#define RZU_CYLS 1200 /* ??? */
#define RZU_MANU "SIMH"
#define RZU_DESC "RZUSER"
#define RZU_REV "0001"
#define RZ_DEV(d) \
{ d##_TYPE, d##_PQUAL, d##_SCSI, d##_RM, d##_BLK, \
d##_LBN, d##_MANU, d##_DESC, d##_REV, #d }
#define RZ_SIZE(d) d##_LBN
#define RZ_DEV(d) \
{ d##_SECTS, d##_SURFS, d##_CYLS, \
d##_LBN, #d, d##_BLK, \
(DRVFL_TYPE_SCSI | d##_FLGS | \
((d##_TYPE == SCSI_CDROM) ? DRVFL_RO : 0)), \
((d##_TYPE == SCSI_TAPE) ? "MK" : "DK"), 0, 0,\
NULL, NULL, 0,0,0,0,0,0,0,0,0,0, \
d##_TYPE, d##_PQUAL, d##_SCSI, \
d##_MANU, d##_DESC, d##_REV }
#define RZ_DEV_A(d,a) \
{ d##_SECTS, d##_SURFS, d##_CYLS, \
d##_LBN, #d, d##_BLK, \
(DRVFL_TYPE_SCSI | d##_FLGS | \
((d##_TYPE == SCSI_CDROM) ? DRVFL_RO : 0)), \
((d##_TYPE == SCSI_TAPE) ? "MK" : "DK"), 0, 0,\
#a, NULL, 0,0,0,0,0,0,0,0,0,0, \
d##_TYPE, d##_PQUAL, d##_SCSI, \
d##_MANU, d##_DESC, d##_REV }
static struct scsi_dev_t rzdev_tab[] = {
static DRVTYP drv_tab[] = {
RZ_DEV (RZ23),
RZ_DEV (RZ23L),
RZ_DEV (RZ24),
@ -234,14 +279,14 @@ static struct scsi_dev_t rzdev_tab[] = {
RZ_DEV (RZ26),
RZ_DEV (RZ26L),
RZ_DEV (RZ55),
RZ_DEV (RRD40),
RZ_DEV_A (RRD40,CDROM),
RZ_DEV (RRD42),
RZ_DEV (RRW11),
RZ_DEV (CDW900),
RZ_DEV (XR1001),
RZ_DEV (TZK50),
RZ_DEV (TZ30),
RZ_DEV (RZU),
RZ_DEV_A (RZU,RZUSER),
{ 0 }
};