From 6efa9c0a92a21a1f64842ee8637e93f905fc28bd Mon Sep 17 00:00:00 2001 From: John Forecast Date: Tue, 31 Mar 2020 15:20:04 -0700 Subject: [PATCH] PDP10, DISK: Add sim_disk support for PDP10 format disks add to the RP device This allows the underlying disk container formats that that sim_disk supports (VHD, SIMH or RAW) to be accessed from the PDP10 KS10 simulator, and later on to Rich Cornwell's PDP10-KA, PDP10-KI, and PDP10-KL simulators. --- PDP10/pdp10_rp.c | 139 +++++++++++++++++++++++++++++++++-------------- sim_disk.c | 52 +++++++++++++++--- sim_disk.h | 4 ++ 3 files changed, 146 insertions(+), 49 deletions(-) diff --git a/PDP10/pdp10_rp.c b/PDP10/pdp10_rp.c index b8f9bca3..82dc32f6 100644 --- a/PDP10/pdp10_rp.c +++ b/PDP10/pdp10_rp.c @@ -70,6 +70,7 @@ */ #include "pdp10_defs.h" +#include "sim_disk.h" #include #define RP_NUMDR 8 /* #drives */ @@ -83,13 +84,13 @@ /* Flags in the unit flags word */ -#define UNIT_V_WLK (UNIT_V_UF + 0) /* write locked */ -#define UNIT_V_DTYPE (UNIT_V_UF + 1) /* disk type */ +#define UNIT_V_WLK (DKUF_V_UF + 0) /* write locked */ +#define UNIT_V_DTYPE (DKUF_V_UF + 1) /* disk type */ #define UNIT_M_DTYPE 7 -#define UNIT_V_AUTO (UNIT_V_UF + 4) /* autosize */ -#define UNIT_V_UTS (UNIT_V_UF + 5) /* Up to speed */ +#define UNIT_V_AUTO (DKUF_V_UF + 4) /* autosize */ +#define UNIT_V_UTS (DKUF_V_UF + 5) /* Up to speed */ #define UNIT_UTS (1u << UNIT_V_UTS) -#define UNIT_V_DUMMY (UNIT_V_UF + 6) /* dummy flag */ +#define UNIT_V_DUMMY (DKUF_V_UF + 6) /* dummy flag */ #define UNIT_WLK (1 << UNIT_V_WLK) #define UNIT_DTYPE (UNIT_M_DTYPE << UNIT_V_DTYPE) #define UNIT_AUTO (1 << UNIT_V_AUTO) @@ -318,18 +319,25 @@ struct drvtyp { int32 size; /* #blocks */ int32 devtype; /* device type */ int32 ctrl; /* ctrl type */ + const char *name; /* device type name */ }; struct drvtyp drv_tab[] = { - { RM03_SECT, RM03_SURF, RM03_CYL, RM03_SIZE, RM03_DEV, MBA_RM_CTRL }, - { RP04_SECT, RP04_SURF, RP04_CYL, RP04_SIZE, RP04_DEV, MBA_RP_CTRL }, - { RM80_SECT, RM80_SURF, RM80_CYL, RM80_SIZE, RM80_DEV, MBA_RM_CTRL }, - { RP06_SECT, RP06_SURF, RP06_CYL, RP06_SIZE, RP06_DEV, MBA_RP_CTRL }, - { RM05_SECT, RM05_SURF, RM05_CYL, RM05_SIZE, RM05_DEV, MBA_RM_CTRL }, - { RP07_SECT, RP07_SURF, RP07_CYL, RP07_SIZE, RP07_DEV, MBA_RM_CTRL }, + { RM03_SECT, RM03_SURF, RM03_CYL, RM03_SIZE, RM03_DEV, MBA_RM_CTRL, "RM03" }, + { RP04_SECT, RP04_SURF, RP04_CYL, RP04_SIZE, RP04_DEV, MBA_RP_CTRL, "RP04" }, + { RM80_SECT, RM80_SURF, RM80_CYL, RM80_SIZE, RM80_DEV, MBA_RM_CTRL, "RM80" }, + { RP06_SECT, RP06_SURF, RP06_CYL, RP06_SIZE, RP06_DEV, MBA_RP_CTRL, "RP06" }, + { RM05_SECT, RM05_SURF, RM05_CYL, RM05_SIZE, RM05_DEV, MBA_RM_CTRL, "RM05" }, + { RP07_SECT, RP07_SURF, RP07_CYL, RP07_SIZE, RP07_DEV, MBA_RM_CTRL, "RP07" }, { 0 } }; +#define DBG_DSK 0x0001 /* display sim_disk activities */ + +DEBTAB rp_debug[] = { + {"DISK", DBG_DSK, "display sim_disk activities" }, + {0} +}; extern int32 ubmap[UBANUM][UMAP_MEMSIZE]; /* Unibus maps */ extern int32 ubcs[UBANUM]; extern uint32 fe_bootrh; @@ -373,6 +381,8 @@ void set_rper (int16 flag, int32 drv); void update_rpcs (int32 flags, int32 drv); void rp_go (int32 drv, int32 fnc); t_stat rp_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc); +t_stat rp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr); +const char *rp_description (DEVICE *dptr); /* RP data structures @@ -388,21 +398,21 @@ DIB rp_dib = { }; UNIT rp_unit[] = { - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) }, - { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+ + { UDATA (&rp_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_DISABLE+UNIT_AUTO+ UNIT_ROABLE+(RP06_DTYPE << UNIT_V_DTYPE), RP06_SIZE) } }; @@ -439,8 +449,10 @@ REG rp_reg[] = { }; MTAB rp_mod[] = { - { UNIT_WLK, 0, "write enabled", "WRITEENABLED", NULL }, - { UNIT_WLK, UNIT_WLK, "write locked", "LOCKED", 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_DTYPE+UNIT_ATT), (RM03_DTYPE << UNIT_V_DTYPE) + UNIT_ATT, "RM03", NULL, NULL }, { (UNIT_DTYPE+UNIT_ATT), (RP04_DTYPE << UNIT_V_DTYPE) + UNIT_ATT, @@ -466,19 +478,24 @@ MTAB rp_mod[] = { { (UNIT_AUTO+UNIT_DTYPE+UNIT_ATT), (RP07_DTYPE << UNIT_V_DTYPE), "RP07", NULL, NULL }, { (UNIT_AUTO+UNIT_ATT), UNIT_AUTO, "autosize", NULL, NULL }, - { UNIT_AUTO, UNIT_AUTO, NULL, "AUTOSIZE", NULL }, + { UNIT_AUTO, UNIT_AUTO, NULL, "AUTOSIZE", NULL, NULL, NULL, + "Enables disk autosize on attach" }, + { UNIT_AUTO, 0, NULL, "NOAUTOSIZE", NULL, NULL, NULL, + "Disables disk autosize on attach" }, + { MTAB_XTD|MTAB_VUN|MTAB_VALR, 0, "FORMAT", "FORMAT={SIMH|VHD|RAW}", + &sim_disk_set_fmt, &sim_disk_show_fmt, NULL, "Set/Display disk container format" }, { (UNIT_AUTO+UNIT_DTYPE), (RM03_DTYPE << UNIT_V_DTYPE), - NULL, "RM03", &rp_set_size }, + NULL, "RM03", &rp_set_size, NULL, NULL, "Set RP04 Disk Type" }, { (UNIT_AUTO+UNIT_DTYPE), (RP04_DTYPE << UNIT_V_DTYPE), - NULL, "RP04", &rp_set_size }, + NULL, "RP04", &rp_set_size, NULL, NULL, "Set RP04 Disk Type" }, { (UNIT_AUTO+UNIT_DTYPE), (RM80_DTYPE << UNIT_V_DTYPE), - NULL, "RM80", &rp_set_size }, + NULL, "RM80", &rp_set_size, NULL, NULL, "Set RM80 Disk Type" }, { (UNIT_AUTO+UNIT_DTYPE), (RP06_DTYPE << UNIT_V_DTYPE), - NULL, "RP06", &rp_set_size }, + NULL, "RP06", &rp_set_size, NULL, NULL, "Set RP06 Disk Type" }, { (UNIT_AUTO+UNIT_DTYPE), (RM05_DTYPE << UNIT_V_DTYPE), - NULL, "RM05", &rp_set_size }, + NULL, "RM05", &rp_set_size, NULL, NULL, "Set RM05 Disk Type" }, { (UNIT_AUTO+UNIT_DTYPE), (RP07_DTYPE << UNIT_V_DTYPE), - NULL, "RP07", &rp_set_size }, + NULL, "RP07", &rp_set_size, NULL, NULL, "Set RP07 Disk Type" }, { MTAB_XTD|MTAB_VDV, 0, "ADDRESS", NULL, NULL, &show_addr, NULL }, { MTAB_XTD|MTAB_VDV, 0, "VECTOR", NULL, @@ -491,7 +508,9 @@ DEVICE rp_dev = { RP_NUMDR, 8, 30, 1, 8, 36, NULL, NULL, &rp_reset, &rp_boot, &rp_attach, &rp_detach, - &rp_dib, DEV_UBUS + &rp_dib, DEV_UBUS | DEV_DEBUG, + 0, rp_debug, NULL, NULL, &rp_help, sim_disk_attach_help, NULL, + &rp_description }; /* I/O dispatch routines, I/O addresses 17776700 - 17776776 */ @@ -875,11 +894,12 @@ return; t_stat rp_svc (UNIT *uptr) { -int32 i, dtype, drv, err; +int32 i, dtype, drv; int32 ba, da, vpn; a10 pa10, mpa10; int32 wc10, twc10, awc10, fc10; static d10 dbuf[RP_MAXFR]; +t_stat r; dtype = GET_DTYPE (uptr->flags); /* get drive type */ drv = (int32) (uptr - rp_dev.units); /* get drv number */ @@ -946,7 +966,6 @@ switch (uptr->FUNC) { /* case on function */ wc10 = drv_tab[dtype].size - da; } - err = fseek (uptr->fileref, da * sizeof (d10), SEEK_SET); if (uptr->FUNC == FNC_WRITE) { /* write? */ for (twc10 = 0; twc10 < wc10; twc10++) { pa10 = ba >> 2; @@ -972,12 +991,15 @@ switch (uptr->FUNC) { /* case on function */ for (i = 0; i < fc10; i++) dbuf[twc10 + i] = 0; } - fxwrite (dbuf, sizeof (d10), twc10 + fc10, uptr->fileref); - err = ferror (uptr->fileref); + r = sim_disk_pdp10_wrsect (uptr, da/RP_NUMWD, (uint8 *)dbuf, + NULL, (twc10 + fc10 + RP_NUMWD - 1)/RP_NUMWD); } /* end if */ else { /* read, wchk, readh */ - awc10 = fxread (dbuf, sizeof (d10), wc10, uptr->fileref); - err = ferror (uptr->fileref); + t_seccnt sectsread; + + r = sim_disk_pdp10_rdsect (uptr, da/RP_NUMWD, (uint8 *)dbuf, + §sread, (wc10 + RP_NUMWD - 1)/RP_NUMWD); + awc10 = sectsread * RP_NUMWD; for ( ; awc10 < wc10; awc10++) dbuf[awc10] = 0; for (twc10 = 0; twc10 < wc10; twc10++) { @@ -1019,11 +1041,10 @@ switch (uptr->FUNC) { /* case on function */ rpda[drv] = (uint16)(rpda[drv] | ((da % drv_tab[dtype].surf) << DA_V_SF)); rpdc[drv] = (uint16)(da / drv_tab[dtype].surf); - if (err != 0) { /* error? */ + if (r != SCPE_OK) { /* error? */ set_rper (ER1_PAR, drv); /* set drive error */ update_rpcs (CS1_DONE | CS1_TRE, drv); /* set done, err */ - sim_perror ("RP I/O error"); - clearerr (uptr->fileref); + sim_printf ("RP I/O error"); return SCPE_IOERR; } /* fall through */ @@ -1153,9 +1174,13 @@ t_stat rp_attach (UNIT *uptr, CONST char *cptr) { int32 i, p; t_stat r; +static const char *drives[] = {"RM03", "RP04", "RM80", "RP06", "RM05", "RP07", NULL}; uptr->capac = drv_tab[GET_DTYPE (uptr->flags)].size; -r = attach_unit (uptr, cptr); +r = sim_disk_pdp10_attach (uptr, cptr, RP_NUMWD * sizeof (d10), sizeof (d10), + (uptr->flags & UNIT_AUTO) == 0, DBG_DSK, + drv_tab[GET_DTYPE (uptr->flags)].name, + 0, (uptr->flags & UNIT_AUTO) ? drives : NULL); if (r != SCPE_OK) return r; sim_cancel (uptr); @@ -1163,8 +1188,7 @@ uptr->flags &= ~UNIT_UTS; sim_activate_after (uptr, SPINUP_DLY); if ((uptr->flags & UNIT_AUTO) == 0) /* autosize? */ return SCPE_OK; -if ((p = sim_fsize (uptr->fileref)) == 0) - return SCPE_OK; +p = (int32)sim_disk_size (uptr); for (i = 0; drv_tab[i].sect != 0; i++) { if (p <= (drv_tab[i].size * (int) sizeof (d10))) { uptr->flags = (uptr->flags & ~UNIT_DTYPE) | (i << UNIT_V_DTYPE); @@ -1197,7 +1221,7 @@ if (sim_is_active (uptr)) { /* unit active? */ } uptr->flags &= ~UNIT_UTS; update_rpcs (0, drv); /* request intr */ -return detach_unit (uptr); +return sim_disk_detach (uptr); } /* Set size command validation routine */ @@ -1375,3 +1399,34 @@ for (i = 0; i < BOOT_LEN; i++) saved_PC = BOOT_START; return SCPE_OK; } + +t_stat rp_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr) +{ + fprintf (st, "RP04/05/06/07, RM02/03/05/80 Disk Pack Drives (RP)\n\n"); + fprintf (st, "The RP controller implements the Massbus family of large disk dri\ +ves. RP\n"); + fprintf (st, "options include the ability to set units write enabled or write locked, to\n"); + fprintf (st, "set the drive type to one of six disk types or autosize, and to write a DEC\n"); + fprintf (st, "standard 044 compliant bad block table on the last track.\n\n"); + fprint_set_help (st, dptr); + fprint_show_help (st, dptr); + fprintf (st, "\nThe type options can be used only when a unit is not attached to a file.\n"); + fprintf (st, "The bad block option can be used only when a unit is attached to a file.\n"); + fprintf (st, "The RP device supports the BOOT command.\n"); + fprint_reg_help (st, dptr); + fprintf (st, "\nError handling is as follows:\n\n"); + fprintf (st, " error STOP_IOE processed as\n"); + fprintf (st, " not attached 1 report error and stop\n"); + fprintf (st, " 0 disk not ready\n\n"); + fprintf (st, " end of file x assume rest of disk is zero\n"); + fprintf (st, " OS I/O error x report error and stop\n"); + fprintf (st, "\nDisk drives on the %s device can be attacbed to simulated storage in the\n", dptr->name); + fprintf (st, "following ways:\n\n"); + sim_disk_attach_help (st, dptr, uptr, flag, cptr); + return SCPE_OK; +} + +const char *rp_description (DEVICE *dptr) +{ + return "RP04/05/06/07 RM02/03/05/80 Massbus disk controller"; +} diff --git a/sim_disk.c b/sim_disk.c index f8672c51..99a4c561 100644 --- a/sim_disk.c +++ b/sim_disk.c @@ -53,6 +53,14 @@ Public routines: sim_disk_data_trace debug support sim_disk_test unit test routine + Guest-specific routines for PDP-10 which uses 1024 byte sectors and + requires mapping functions to allow access to the underlying 512 byte + sectors provided by the sim_disk routines + + sim_disk_pdp10_attach attach disk unit + sim_disk_pdp10_rdsect read PDP-10 disk sectors + sim_disk_pdp10_wrsect write PDP-10 disk sectors + Internal routines: sim_os_disk_open_raw platform specific open raw device @@ -89,7 +97,7 @@ struct disk_context { DEVICE *dptr; /* Device for unit (access to debug flags) */ uint32 dbit; /* debugging bit */ uint32 sector_size; /* Disk Sector Size (of the pseudo disk) */ - uint32 capac_factor; /* Units of Capacity (2 = word, 1 = byte) */ + uint32 capac_factor; /* Units of Capacity (8 = quadword, 2 = word, 1 = byte) */ uint32 xfer_element_size; /* Disk Bus Transfer size (1 - byte, 2 - word, 4 - longword) */ uint32 storage_sector_size;/* Sector size of the containing storage */ uint32 removable; /* Removable device flag */ @@ -692,7 +700,7 @@ sim_debug_unit (ctx->dbit, uptr, "sim_disk_wrsect(unit=%d, lba=0x%X, sects=%d)\n if (uptr->dynflags & UNIT_DISK_CHK) { DEVICE *dptr = find_dev_from_unit (uptr); - uint32 capac_factor = ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (word: 2, byte: 1) */ + uint32 capac_factor = ((dptr->dwidth / dptr->aincr) >= 32) ? 8 : ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (quadword: 8, word: 2, byte: 1) */ t_lba total_sectors = (t_lba)((uptr->capac*capac_factor)/(ctx->sector_size/((dptr->flags & DEV_SECTORS) ? 512 : 1))); t_lba sect; @@ -2012,7 +2020,7 @@ static FILESYSTEM_CHECK checks[] = { filesystem */ NULL }; -t_offset ret_val; +t_offset ret_val = (t_offset)-1; int i; for (i = 0; checks[i] != NULL; i++) { @@ -2097,7 +2105,7 @@ if (sim_switches & SWMASK ('C')) { /* create vhd disk & cop return sim_messagef (r, "Can't open source VHD: %s\n", cptr); } sim_messagef (SCPE_OK, "%s%d: creating new virtual disk '%s'\n", sim_dname (dptr), (int)(uptr-dptr->units), gbuf); - capac_factor = ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (word: 2, byte: 1) */ + capac_factor = ((dptr->dwidth / dptr->aincr) >= 32) ? 8 : ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (quadword: 8, word: 2, byte: 1) */ vhd = sim_vhd_disk_create (gbuf, ((t_offset)uptr->capac)*capac_factor*((dptr->flags & DEV_SECTORS) ? 512 : 1)); if (!vhd) { return sim_messagef (r, "%s%d: can't create virtual disk '%s'\n", sim_dname (dptr), (int)(uptr-dptr->units), gbuf); @@ -2274,7 +2282,7 @@ if ((uptr->filename == NULL) || (uptr->disk_ctx == NULL)) return _err_return (uptr, SCPE_MEM); strlcpy (uptr->filename, cptr, CBUFSIZE); /* save name */ ctx->sector_size = (uint32)sector_size; /* save sector_size */ -ctx->capac_factor = ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* save capacity units (word: 2, byte: 1) */ +ctx->capac_factor = ((dptr->dwidth / dptr->aincr) >= 32) ? 8 : ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* save capacity units (quadword: 8, word: 2, byte: 1) */ ctx->xfer_element_size = (uint32)xfer_element_size; /* save xfer_element_size */ ctx->dptr = dptr; /* save DEVICE pointer */ ctx->dbit = dbit; /* save debug bit */ @@ -2372,7 +2380,7 @@ if ((created) && (!copied)) { if (sim_switches & SWMASK ('I')) { /* Initialize To Sector Address */ uint8 *init_buf = (uint8*) malloc (1024*1024); t_lba lba, sect; - uint32 capac_factor = ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (word: 2, byte: 1) */ + uint32 capac_factor = ((dptr->dwidth / dptr->aincr) >= 32) ? 8 : ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (quadword: 8, word: 2, byte: 1) */ t_seccnt sectors_per_buffer = (t_seccnt)((1024*1024)/sector_size); t_lba total_sectors = (t_lba)((uptr->capac*capac_factor)/(sector_size/((dptr->flags & DEV_SECTORS) ? 512 : 1))); t_seccnt sects = sectors_per_buffer; @@ -2410,7 +2418,7 @@ if ((created) && (!copied)) { if (sim_switches & SWMASK ('K')) { t_stat r = SCPE_OK; t_lba lba, sect; - uint32 capac_factor = ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (word: 2, byte: 1) */ + uint32 capac_factor = ((dptr->dwidth / dptr->aincr) >= 32) ? 8 : ((dptr->dwidth / dptr->aincr) == 16) ? 2 : 1; /* capacity units (word: 2, byte: 1) */ t_seccnt sectors_per_buffer = (t_seccnt)((1024*1024)/sector_size); t_lba total_sectors = (t_lba)((uptr->capac*capac_factor)/(sector_size/((dptr->flags & DEV_SECTORS) ? 512 : 1))); t_seccnt sects = sectors_per_buffer; @@ -2869,6 +2877,36 @@ if (sim_deb && (dptr->dctrl & reason)) { } } +/* Guest specific Disk I/O support */ +#define PDP10_SECTORS 2 /* PDP-10 sectors are 1024 bytes */ + +t_stat sim_disk_pdp10_attach (UNIT *uptr, const char *cptr, size_t sector_size, size_t xfer_element_size, t_bool dontautosize, + uint32 dbit, const char *dtype, int completion_delay, const char **drivetypes) +{ +return sim_disk_attach_ex (uptr, cptr, sector_size / PDP10_SECTORS, xfer_element_size, dontautosize, dbit, dtype, 0, completion_delay, drivetypes); +} + +t_stat sim_disk_pdp10_rdsect (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectsread, t_seccnt sects) +{ +t_seccnt sectors; +t_stat r = sim_disk_rdsect (uptr, lba * PDP10_SECTORS, buf, §ors, sects * PDP10_SECTORS); + +if (sectsread) + *sectsread = sectors / PDP10_SECTORS; + +return r; +} + +t_stat sim_disk_pdp10_wrsect (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectswritten, t_seccnt sects) +{ +t_seccnt sectors; +t_stat r = sim_disk_wrsect (uptr, lba * PDP10_SECTORS, buf, §ors, sects * PDP10_SECTORS); + +if (sectswritten) + *sectswritten = sectors / PDP10_SECTORS; + +return r; +} /* OS Specific RAW Disk I/O support */ diff --git a/sim_disk.h b/sim_disk.h index 6d11c083..9307b85b 100644 --- a/sim_disk.h +++ b/sim_disk.h @@ -97,6 +97,10 @@ t_bool sim_disk_vhd_support (void); t_bool sim_disk_raw_support (void); void sim_disk_data_trace (UNIT *uptr, const uint8 *data, size_t lba, size_t len, const char* txt, int detail, uint32 reason); t_stat sim_disk_test (DEVICE *dptr); +t_stat sim_disk_pdp10_attach (UNIT *uptr, const char *cptr, size_t sector_size, size_t xfer_element_size, t_bool dontautosize, + uint32 dbit, const char *dtype, int completion_delay, const char **drivetypes); +t_stat sim_disk_pdp10_rdsect (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectsread, t_seccnt sects); +t_stat sim_disk_pdp10_wrsect (UNIT *uptr, t_lba lba, uint8 *buf, t_seccnt *sectswritten, t_seccnt sects); #ifdef __cplusplus }