| /* i1401_dp.c: IBM 1311 disk simulator | |
| Copyright (c) 2002-2005, Robert M. Supnik | |
| Permission is hereby granted, free of charge, to any person obtaining a | |
| copy of this software and associated documentation files (the "Software"), | |
| to deal in the Software without restriction, including without limitation | |
| the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| and/or sell copies of the Software, and to permit persons to whom the | |
| Software is furnished to do so, subject to the following conditions: | |
| The above copyright notice and this permission notice shall be included in | |
| all copies or substantial portions of the Software. | |
| THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
| ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER | |
| IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
| CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
| Except as contained in this notice, the name of Robert M Supnik shall not be | |
| used in advertising or otherwise to promote the sale, use or other dealings | |
| in this Software without prior written authorization from Robert M Supnik. | |
| dp 1311 disk pack | |
| 18-Oct-02 RMS Fixed bug in address comparison logic | |
| 19-Sep-02 RMS Minor edit for consistency with 1620 | |
| 15-Jun-02 RMS Reworked address comparison logic | |
| The 1311 disk pack has 100 cylinders, 10 tracks/cylinder, 20 sectors/track. | |
| Each sector contains 106 characters of information: | |
| 6c sector address | |
| 100c sector data | |
| By default, a sector's address field will be '000000', which is illegal. | |
| This is interpreted to mean the implied sector number that would be in | |
| place if the disk pack had been formatted with sequential sector numbers. | |
| The sector data can be 100 characters without word marks, or 90 characters | |
| with word marks. Load mode transfers 90 characters per sector with | |
| word marks, move mode transfers 100 characters per sector without word | |
| marks. No attempt is made to catch incompatible writes (eg, load mode | |
| write followed by move mode read). | |
| */ | |
| #include "i1401_defs.h" | |
| #define DP_NUMDR 5 /* #drives */ | |
| #define UNIT_V_WAE (UNIT_V_UF + 0) /* write addr enab */ | |
| #define UNIT_WAE (1 << UNIT_V_WAE) | |
| /* Disk format */ | |
| #define DP_ADDR 6 /* address */ | |
| #define DP_DATA 100 /* data */ | |
| #define DP_NUMCH (DP_ADDR + DP_DATA) | |
| #define DP_NUMSC 20 /* #sectors */ | |
| #define DP_NUMSF 10 /* #surfaces */ | |
| #define DP_NUMCY 100 /* #cylinders */ | |
| #define DP_TOTSC (DP_NUMCY*DP_NUMSF*DP_NUMSC) | |
| #define DP_SIZE (DP_TOTSC*DP_NUMCH) | |
| /* Disk control field */ | |
| #define DCF_DRV 0 /* drive select */ | |
| #define DCF_SEC 1 /* sector addr */ | |
| #define DCF_SEC_LEN 6 | |
| #define DCF_CNT (DCF_SEC + DCF_SEC_LEN) /* sector count */ | |
| #define DCF_CNT_LEN 3 | |
| #define DCF_LEN (DCF_CNT + DCF_CNT_LEN) | |
| #define DCF_DIR 1 /* direct seek */ | |
| #define DCF_DIR_LEN 4 | |
| #define DCF_DIR_FL (DCF_DIR + DCF_DIR_LEN) /* direct seek flag */ | |
| #define DCF_DSEEK 0xB | |
| /* Functions */ | |
| #define FNC_SEEK 0 /* seek */ | |
| #define FNC_CHECK 3 /* check */ | |
| #define FNC_READ 1 /* read sectors */ | |
| #define FNC_RSCO 5 /* read sec cnt overlay */ | |
| #define FNC_RTRK 6 /* read track */ | |
| #define FNC_WOFF 10 /* offset for write */ | |
| #define FNC_WRITE 11 /* write sectors */ | |
| #define FNC_WRSCO 15 /* write sec cnt overlay */ | |
| #define FNC_WRTRK 16 /* write track */ | |
| #define CYL u3 /* current cylinder */ | |
| extern uint8 M[]; /* memory */ | |
| extern int32 ind[64]; | |
| extern int32 AS, BS, iochk; | |
| extern int32 bcd_to_bin[16]; | |
| extern int32 bin_to_bcd[16]; | |
| extern UNIT cpu_unit; | |
| int32 dp_lastf = 0; /* prior function */ | |
| int32 dp_time = 0; /* seek time */ | |
| t_stat dp_reset (DEVICE *dptr); | |
| t_stat dp_rdadr (UNIT *uptr, int32 sec, int32 flg, int32 wchk); | |
| t_stat dp_rdsec (UNIT *uptr, int32 sec, int32 flg, int32 wchk); | |
| t_stat dp_wradr (UNIT *uptr, int32 sec, int32 flg); | |
| t_stat dp_wrsec (UNIT *uptr, int32 sec, int32 flg); | |
| int32 dp_fndsec (UNIT *uptr, int32 sec, int32 dcf); | |
| t_stat dp_nexsec (UNIT *uptr, int32 psec, int32 dcf); | |
| t_bool dp_zeroad (uint8 *ap); | |
| t_bool dp_cmp_ad (uint8 *ap, int32 dcf); | |
| int32 dp_trkop (int32 drv, int32 sec); | |
| int32 dp_cvt_bcd (int32 ad, int32 len); | |
| void dp_cvt_bin (int32 ad, int32 len, int32 val, int32 flg); | |
| int32 dp_get_cnt (int32 dcf); | |
| void dp_fill (UNIT *uptr, uint32 da, int32 cnt); | |
| /* DP data structures | |
| dp_dev DSK device descriptor | |
| dp_unit DSK unit list | |
| dp_reg DSK register list | |
| dp_mod DSK modifier list | |
| */ | |
| UNIT dp_unit[] = { | |
| { UDATA (NULL, UNIT_FIX + UNIT_DISABLE + UNIT_ATTABLE + | |
| UNIT_BUFABLE + UNIT_MUSTBUF + UNIT_BCD, DP_SIZE) }, | |
| { UDATA (NULL, UNIT_FIX + UNIT_DISABLE + UNIT_ATTABLE + | |
| UNIT_BUFABLE + UNIT_MUSTBUF + UNIT_BCD, DP_SIZE) }, | |
| { UDATA (NULL, UNIT_FIX + UNIT_DISABLE + UNIT_ATTABLE + | |
| UNIT_BUFABLE + UNIT_MUSTBUF + UNIT_BCD, DP_SIZE) }, | |
| { UDATA (NULL, UNIT_FIX + UNIT_DISABLE + UNIT_ATTABLE + | |
| UNIT_BUFABLE + UNIT_MUSTBUF + UNIT_BCD, DP_SIZE) }, | |
| { UDATA (NULL, UNIT_FIX + UNIT_DISABLE + UNIT_ATTABLE + | |
| UNIT_BUFABLE + UNIT_MUSTBUF + UNIT_BCD, DP_SIZE) } | |
| }; | |
| REG dp_reg[] = { | |
| { FLDATA (ACC, ind[IN_ACC], 0) }, | |
| { FLDATA (PWC, ind[IN_DPW], 0) }, | |
| { FLDATA (WLR, ind[IN_LNG], 0) }, | |
| { FLDATA (UNA, ind[IN_UNA], 0) }, | |
| { FLDATA (ERR, ind[IN_DSK], 0) }, | |
| { FLDATA (BSY, ind[IN_DBY], 0) }, | |
| { DRDATA (LASTF, dp_lastf, 3) }, | |
| { DRDATA (TIME, dp_time, 24), PV_LEFT }, | |
| { URDATA (CYL, dp_unit[0].CYL, 10, 8, 0, | |
| DP_NUMDR, PV_LEFT + REG_RO) }, | |
| { NULL } | |
| }; | |
| MTAB dp_mod[] = { | |
| { UNIT_WAE, 0, "write address disabled", "ADDROFF", NULL }, | |
| { UNIT_WAE, UNIT_WAE, "write address enabled", "ADDRON", NULL }, | |
| { 0 } | |
| }; | |
| DEVICE dp_dev = { | |
| "DP", dp_unit, dp_reg, dp_mod, | |
| DP_NUMDR, 10, 21, 1, 8, 7, | |
| NULL, NULL, &dp_reset, | |
| NULL, NULL, NULL | |
| }; | |
| /* Disk IO routine | |
| Inputs: | |
| fnc = function character | |
| flg = load vs move mode | |
| mod = modifier character | |
| Outputs: | |
| status = status | |
| */ | |
| t_stat dp_io (int32 fnc, int32 flg, int32 mod) | |
| { | |
| int32 dcf, drv, sec, psec, cnt, qwc, qzr, diff; | |
| UNIT *uptr; | |
| t_stat r; | |
| dcf = BS; /* save DCF addr */ | |
| qwc = 0; /* not wcheck */ | |
| ind[IN_DPW] = ind[IN_LNG] = ind[IN_UNA] = 0; /* clr indicators */ | |
| ind[IN_DSK] = ind[IN_ACC] = ind[IN_DBY] = 0; | |
| if (sim_is_active (&dp_unit[0])) { /* ctlr busy? */ | |
| ind[IN_DBY] = ind[IN_DSK] = 1; /* set indicators */ | |
| return SCPE_OK; /* done */ | |
| } | |
| AS = dcf + 6; /* AS for most ops */ | |
| BS = dcf + DCF_CNT - 1; /* minimum DCF */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; /* DCF in memory? */ | |
| if (M[dcf] & BBIT) drv = M[dcf + DCF_SEC + 1] & 0xE; /* impl sel? cyl 8-4-2 */ | |
| else drv = M[dcf] & DIGIT; /* get drive sel */ | |
| if ((drv == 0) || (drv & 1) || (drv > BCD_ZERO)) /* bad drive #? */ | |
| return STOP_INVDSK; | |
| drv = bcd_to_bin[drv] >> 1; /* convert */ | |
| uptr = dp_dev.units + drv; /* get unit ptr */ | |
| if ((uptr->flags & UNIT_ATT) == 0) { /* attached? */ | |
| ind[IN_DSK] = ind[IN_ACC] = 1; /* no, error */ | |
| CRETIOE (iochk, SCPE_UNATT); | |
| } | |
| if ((fnc == FNC_SEEK) && /* seek and */ | |
| (M[dcf + DCF_DIR_FL] & DCF_DSEEK) == DCF_DSEEK) { /* direct flag? */ | |
| diff = dp_cvt_bcd (dcf + DCF_DIR, DCF_DIR_LEN); /* cvt diff */ | |
| if (diff < 0) return STOP_INVDSC; /* error? */ | |
| diff = diff >> 1; /* diff is *2 */ | |
| if ((M[dcf + DCF_DIR + DCF_DIR_LEN - 1] & ZONE) == BBIT) | |
| diff = -diff; /* get sign */ | |
| uptr->CYL = uptr->CYL + diff; /* bound seek */ | |
| if (uptr->CYL < 0) uptr->CYL = 0; | |
| else if (uptr->CYL >= DP_NUMCY) { /* too big? */ | |
| uptr->CYL = 0; /* system hangs */ | |
| return STOP_INVDCY; | |
| } | |
| sim_activate (&dp_unit[0], dp_time); /* set ctlr busy */ | |
| return SCPE_OK; /* done! */ | |
| } | |
| sec = dp_cvt_bcd (dcf + DCF_SEC, DCF_SEC_LEN); /* cvt sector */ | |
| if ((sec < 0) || (sec >= (DP_NUMDR * DP_TOTSC))) /* bad sector? */ | |
| return STOP_INVDSC; | |
| if (fnc == FNC_SEEK) { /* seek? */ | |
| uptr->CYL = (sec / (DP_NUMSF * DP_NUMSC)) % /* set cyl # */ | |
| DP_NUMCY; | |
| sim_activate (&dp_unit[0], dp_time); /* set ctlr busy */ | |
| return SCPE_OK; /* done! */ | |
| } | |
| BS = dcf + DCF_LEN; /* full DCF */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; /* DCF in memory? */ | |
| cnt = dp_get_cnt (dcf); /* get count */ | |
| if (cnt < 0) return STOP_INVDCN; /* bad count? */ | |
| if (fnc >= FNC_WOFF) return STOP_INVDFN; /* invalid func */ | |
| if (mod == BCD_W) { /* write? */ | |
| if (fnc == FNC_CHECK) { /* write check? */ | |
| qwc = 1; /* special read */ | |
| fnc = dp_lastf; /* use last func */ | |
| } | |
| else { | |
| dp_lastf = fnc; /* save func */ | |
| fnc = fnc + FNC_WOFF; /* change to write */ | |
| } | |
| } | |
| else if (mod == BCD_R) dp_lastf = fnc; /* read? save func */ | |
| else return STOP_INVM; /* other? error */ | |
| switch (fnc) { /* case on function */ | |
| case FNC_RSCO: /* read sec cnt ov */ | |
| BS = dcf + DCF_CNT; /* set count back */ | |
| /* fall thru */ | |
| case FNC_READ: /* read */ | |
| psec = dp_fndsec (uptr, sec, dcf); /* find sector */ | |
| if (psec < 0) CRETIOE (iochk, STOP_INVDAD); /* addr cmp error? */ | |
| for (;;) { /* loop */ | |
| qzr = (--cnt == 0); /* set zero latch */ | |
| dp_cvt_bin (dcf + DCF_CNT, DCF_CNT_LEN, cnt, MD_WM); /* redo count */ | |
| if (r = dp_rdsec (uptr, psec, flg, qwc)) /* read sector */ | |
| break; | |
| cnt = dp_get_cnt (dcf); /* get new count */ | |
| if (cnt < 0) return STOP_INVDCN; /* bad count? */ | |
| if (qzr) break; /* zero latch? done */ | |
| sec++; psec++; /* next sector */ | |
| dp_cvt_bin (dcf + DCF_SEC, DCF_SEC_LEN, sec, flg); /* rewr sec */ | |
| if (r = dp_nexsec (uptr, psec, dcf)) break; /* find next */ | |
| } | |
| break; /* done, clean up */ | |
| case FNC_RTRK: /* read track */ | |
| AS = dcf + 9; /* special AS */ | |
| psec = dp_trkop (drv, sec); /* start of track */ | |
| for (;;) { /* loop */ | |
| qzr = (--cnt == 0); /* set zero latch */ | |
| dp_cvt_bin (dcf + DCF_CNT, DCF_CNT_LEN, cnt, MD_WM); /* redo count */ | |
| if (r = dp_rdadr (uptr, psec, flg, qwc)) /* read addr */ | |
| break; /* error? */ | |
| if (r = dp_rdsec (uptr, psec, flg, qwc)) /* read data */ | |
| break; /* error? */ | |
| cnt = dp_get_cnt (dcf); /* get new count */ | |
| if (cnt < 0) return STOP_INVDCN; /* bad count? */ | |
| if (qzr) break; /* zero latch? done */ | |
| psec = dp_trkop (drv, sec) + ((psec + 1) % DP_NUMSC); | |
| } | |
| break; /* done, clean up */ | |
| case FNC_WRSCO: /* write sec cnt ov */ | |
| BS = dcf + DCF_CNT; /* set count back */ | |
| /* fall through */ | |
| case FNC_WRITE: /* read */ | |
| psec = dp_fndsec (uptr, sec, dcf); /* find sector */ | |
| if (psec < 0) CRETIOE (iochk, STOP_INVDAD); /* addr cmp error? */ | |
| for (;;) { /* loop */ | |
| qzr = (--cnt == 0); /* set zero latch */ | |
| dp_cvt_bin (dcf + DCF_CNT, DCF_CNT_LEN, cnt, MD_WM); /* rewr cnt */ | |
| if (r = dp_wrsec (uptr, psec, flg)) break; /* write data */ | |
| if (qzr) break; /* zero latch? done */ | |
| sec++; psec++; /* next sector */ | |
| dp_cvt_bin (dcf + DCF_SEC, DCF_SEC_LEN, sec, flg); /* rewr sec */ | |
| if (r = dp_nexsec (uptr, psec, dcf)) break; /* find next */ | |
| } | |
| break; /* done, clean up */ | |
| case FNC_WRTRK: /* write track */ | |
| if ((uptr->flags & UNIT_WAE) == 0) /* enabled? */ | |
| return STOP_WRADIS; | |
| AS = dcf + 9; /* special AS */ | |
| psec = dp_trkop (drv, sec); /* start of track */ | |
| for (;;) { /* loop */ | |
| qzr = (--cnt == 0); /* set zero latch */ | |
| dp_cvt_bin (dcf + DCF_CNT, DCF_CNT_LEN, cnt, MD_WM); /* redo count */ | |
| if (r = dp_wradr (uptr, psec, flg)) break; /* write addr */ | |
| if (r = dp_wrsec (uptr, psec, flg)) break; /* write data */ | |
| if (qzr) break; /* zero latch? done */ | |
| psec = dp_trkop (drv, sec) + ((psec + 1) % DP_NUMSC); | |
| } | |
| break; /* done, clean up */ | |
| default: /* unknown */ | |
| return STOP_INVDFN; | |
| } | |
| if (r == SCPE_OK) { /* normal so far? */ | |
| BS++; /* advance BS */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; /* address error? */ | |
| if (M[BS - 1] != (WM + BCD_GRPMRK)) { /* GM + WM at end? */ | |
| ind[IN_LNG] = ind[IN_DSK] = 1; /* no, error */ | |
| r = STOP_INVDLN; | |
| } | |
| } | |
| CRETIOE (iochk || !ind[IN_DSK], r); /* return status */ | |
| } | |
| /* Read or compare address with memory */ | |
| t_stat dp_rdadr (UNIT *uptr, int32 sec, int32 flg, int32 qwc) | |
| { | |
| int32 i; | |
| uint8 ac; | |
| int32 da = (sec % DP_TOTSC) * DP_NUMCH; /* char number */ | |
| uint8 *ap = ((uint8 *) uptr->filebuf) + da; /* buf ptr */ | |
| t_bool zad = dp_zeroad (ap); /* zero address */ | |
| static const int32 dec_tab[DP_ADDR] = { /* powers of 10 */ | |
| 100000, 10000, 1000, 100, 10, 1 | |
| } ; | |
| for (i = 0; i < DP_ADDR; i++) { /* copy address */ | |
| if (M[BS] == (WM | BCD_GRPMRK)) { /* premature GWM? */ | |
| ind[IN_LNG] = ind[IN_DSK] = 1; /* error */ | |
| return STOP_INVDLN; | |
| } | |
| if (zad) { /* addr zero? */ | |
| ac = sec / dec_tab[i]; /* get addr digit */ | |
| sec = sec % dec_tab[i]; /* get remainder */ | |
| ac = bcd_to_bin[ac]; /* cvt to BCD */ | |
| } | |
| else ac = *ap; /* addr char */ | |
| if (qwc) { /* wr chk? skip if zad */ | |
| if (!zad && (flg? (M[BS] != ac): /* L? cmp with WM */ | |
| ((M[BS] & CHAR) != (ac & CHAR)))) { /* M? cmp w/o WM */ | |
| ind[IN_DPW] = ind[IN_DSK] = 1; | |
| return STOP_WRCHKE; | |
| } | |
| } | |
| else if (flg) M[BS] = ac & CHAR; /* load mode */ | |
| else M[BS] = (M[BS] & WM) | (ac & CHAR); /* move mode */ | |
| ap++; BS++; /* adv ptrs */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; | |
| } | |
| return SCPE_OK; | |
| } | |
| /* Read or compare data with memory */ | |
| t_stat dp_rdsec (UNIT *uptr, int32 sec, int32 flg, int32 qwc) | |
| { | |
| int32 i, lim; | |
| int32 da = (sec % DP_TOTSC) * DP_NUMCH; /* char number */ | |
| uint8 *ap = ((uint8 *) uptr->filebuf) + da + DP_ADDR; /* buf ptr */ | |
| lim = flg? (DP_DATA - 10): DP_DATA; /* load vs move */ | |
| for (i = 0; i < lim; i++) { /* copy data */ | |
| if (M[BS] == (WM | BCD_GRPMRK)) { /* premature GWM? */ | |
| ind[IN_LNG] = ind[IN_DSK] = 1; /* error */ | |
| return STOP_INVDLN; | |
| } | |
| if (qwc) { /* write check? */ | |
| if (flg? (M[BS] != *ap): /* load mode cmp */ | |
| ((M[BS] & CHAR) != (*ap & CHAR))) { /* move mode cmp */ | |
| ind[IN_DPW] = ind[IN_DSK] = 1; /* error */ | |
| return STOP_WRCHKE; | |
| } | |
| } | |
| else if (flg) M[BS] = *ap & (WM | CHAR); /* load mode */ | |
| else M[BS] = (M[BS] & WM) | (*ap & CHAR); /* word mode */ | |
| ap++; BS++; /* adv ptrs */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; | |
| } | |
| return SCPE_OK; | |
| } | |
| /* Write address to disk */ | |
| t_stat dp_wradr (UNIT *uptr, int32 sec, int32 flg) | |
| { | |
| int32 i; | |
| uint32 da = (sec % DP_TOTSC) * DP_NUMCH; /* char number */ | |
| uint8 *ap = ((uint8 *) uptr->filebuf) + da; /* buf ptr */ | |
| for (i = 0; i < DP_ADDR; i++) { /* copy address */ | |
| if (M[BS] == (WM | BCD_GRPMRK)) { /* premature GWM? */ | |
| dp_fill (uptr, da, DP_NUMCH - i); /* fill, set err */ | |
| ind[IN_LNG] = ind[IN_DSK] = 1; /* error */ | |
| return STOP_INVDLN; | |
| } | |
| if (flg) *ap = M[BS] & (WM | CHAR); /* L? copy WM */ | |
| else *ap = M[BS] & CHAR; /* M? strip WM */ | |
| if (da >= uptr->hwmark) uptr->hwmark = da + 1; | |
| da++; ap++; BS++; /* adv ptrs */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; | |
| } | |
| return SCPE_OK; | |
| } | |
| /* Write data to disk */ | |
| t_stat dp_wrsec (UNIT *uptr, int32 sec, int32 flg) | |
| { | |
| int32 i, lim; | |
| uint32 da = ((sec % DP_TOTSC) * DP_NUMCH) + DP_ADDR; /* char number */ | |
| uint8 *ap = ((uint8 *) uptr->filebuf) + da; /* buf ptr */ | |
| lim = flg? (DP_DATA - 10): DP_DATA; /* load vs move */ | |
| for (i = 0; i < lim; i++) { /* copy data */ | |
| if (M[BS] == (WM | BCD_GRPMRK)) { /* premature GWM? */ | |
| dp_fill (uptr, da, DP_DATA - i); /* fill, set err */ | |
| ind[IN_LNG] = ind[IN_DSK] = 1; /* error */ | |
| return STOP_INVDLN; | |
| } | |
| if (flg) *ap = M[BS] & (WM | CHAR); /* load, copy WM */ | |
| else *ap = M[BS] & CHAR; /* move, strip WM */ | |
| if (da >= uptr->hwmark) uptr->hwmark = da + 1; | |
| da++; ap++; BS++; /* adv ptrs */ | |
| if (ADDR_ERR (BS)) return STOP_WRAP; | |
| } | |
| return SCPE_OK; | |
| } | |
| /* Find sector */ | |
| int32 dp_fndsec (UNIT *uptr, int32 sec, int32 dcf) | |
| { | |
| int32 ctrk = sec % (DP_NUMSF * DP_NUMSC); /* curr trk-sec */ | |
| int32 psec = ((uptr->CYL) * (DP_NUMSF * DP_NUMSC)) + ctrk; | |
| int32 da = psec * DP_NUMCH; /* char number */ | |
| uint8 *ap = ((uint8 *) uptr->filebuf) + da; /* buf ptr */ | |
| int32 i; | |
| if (dp_zeroad (ap)) return psec; /* addr zero? ok */ | |
| if (dp_cmp_ad (ap, dcf)) return psec; /* addr comp? ok */ | |
| psec = psec - (psec % DP_NUMSC); /* sector 0 */ | |
| for (i = 0; i < DP_NUMSC; i++, psec++) { /* check track */ | |
| da = psec * DP_NUMCH; /* char number */ | |
| ap = ((uint8 *) uptr->filebuf) + da; /* word pointer */ | |
| if (dp_zeroad (ap)) continue; /* no implicit match */ | |
| if (dp_cmp_ad (ap, dcf)) return psec; /* match? */ | |
| } | |
| ind[IN_UNA] = ind[IN_DSK] = 1; /* no match */ | |
| return -1; | |
| } | |
| /* Find next sector - must be sequential, cannot cross cylinder boundary */ | |
| t_stat dp_nexsec (UNIT *uptr, int32 psec, int32 dcf) | |
| { | |
| int32 ctrk = psec % (DP_NUMSF * DP_NUMSC); /* curr trk-sec */ | |
| int32 da = psec * DP_NUMCH; /* word number */ | |
| uint8 *ap = ((uint8 *) uptr->filebuf) + da; /* buf ptr */ | |
| if (ctrk) { /* not trk zero? */ | |
| if (dp_zeroad (ap)) return SCPE_OK; /* addr zero? ok */ | |
| if (dp_cmp_ad (ap, dcf)) return SCPE_OK; /* addr comp? ok */ | |
| } | |
| ind[IN_UNA] = ind[IN_DSK] = 1; /* no, error */ | |
| return STOP_INVDAD; | |
| } | |
| /* Test for zero address */ | |
| t_bool dp_zeroad (uint8 *ap) | |
| { | |
| int32 i; | |
| for (i = 0; i < DP_ADDR; i++, ap++) { /* loop thru addr */ | |
| if (*ap & CHAR) return FALSE; /* nonzero? lose */ | |
| } | |
| return TRUE; /* all zeroes */ | |
| } | |
| /* Compare disk address to memory sector address - always omit word marks */ | |
| t_bool dp_cmp_ad (uint8 *ap, int32 dcf) | |
| { | |
| int32 i; | |
| uint8 c; | |
| for (i = 0; i < DP_ADDR; i++, ap++) { /* loop thru addr */ | |
| c = M[dcf + DCF_SEC + i]; /* sector addr char */ | |
| if ((c & CHAR) != (*ap & CHAR)) /* cmp w/o WM */ | |
| return FALSE; | |
| } | |
| return TRUE; /* compare ok */ | |
| } | |
| /* Track operation setup */ | |
| int32 dp_trkop (int32 drv, int32 sec) | |
| { | |
| int32 ctrk = (sec / DP_NUMSC) % DP_NUMSF; | |
| return ((drv * DP_TOTSC) + (dp_unit[drv].CYL * DP_NUMSF * DP_NUMSC) + | |
| (ctrk * DP_NUMSC)); | |
| } | |
| /* Convert DCF BCD field to binary */ | |
| int32 dp_cvt_bcd (int32 ad, int32 len) | |
| { | |
| uint8 c; | |
| int32 r; | |
| for (r = 0; len > 0; len--) { /* loop thru char */ | |
| c = M[ad] & DIGIT; /* get digit */ | |
| if ((c == 0) || (c > BCD_ZERO)) return -1; /* invalid? */ | |
| r = (r * 10) + bcd_to_bin[c]; /* cvt to bin */ | |
| ad++; /* next digit */ | |
| } | |
| return r; | |
| } | |
| /* Convert binary to DCF BCD field */ | |
| void dp_cvt_bin (int32 ad, int32 len, int32 val, int32 flg) | |
| { | |
| int32 r; | |
| for ( ; len > 0; len--) { /* loop thru char */ | |
| r = val % 10; /* get digit */ | |
| if (flg) M[ad + len - 1] = bin_to_bcd[r]; /* load mode? */ | |
| else M[ad + len - 1] = (M[ad + len - 1] & WM) | bin_to_bcd[r]; | |
| val = val / 10; | |
| } | |
| return; | |
| } | |
| /* Get and validate count */ | |
| int32 dp_get_cnt (int32 dcf) | |
| { | |
| int32 cnt = dp_cvt_bcd (dcf + DCF_CNT, DCF_CNT_LEN); /* get new count */ | |
| if (cnt < 0) return -1; /* bad count? */ | |
| if (cnt == 0) return 1000; /* 0 => 1000 */ | |
| return cnt; | |
| } | |
| /* Fill sector buffer with blanks */ | |
| void dp_fill (UNIT *uptr, uint32 da, int32 cnt) | |
| { | |
| while (cnt-- > 0) { /* fill with blanks */ | |
| *(((uint8 *) uptr->filebuf) + da) = BCD_BLANK; | |
| if (da >= uptr->hwmark) uptr->hwmark = da + 1; | |
| da++; | |
| } | |
| return; | |
| } | |
| /* Reset routine */ | |
| t_stat dp_reset (DEVICE *dptr) | |
| { | |
| int32 i; | |
| for (i = 0; i < DP_NUMDR; i++) dp_unit[i].CYL = 0; /* reset cylinder */ | |
| dp_lastf = 0; /* clear state */ | |
| ind[IN_DPW] = ind[IN_LNG] = ind[IN_UNA] = 0; /* clr indicators */ | |
| ind[IN_DSK] = ind[IN_ACC] = ind[IN_DBY] = 0; | |
| sim_cancel (&dp_unit[0]); /* cancel timer */ | |
| return SCPE_OK; | |
| } |