[simh.git] / I1401 / i1401_mt.c

/* i1401_mt.c: IBM 1401 magnetic tape simulator\r
\r
   Copyright (c) 1993-2007, Robert M. Supnik\r
\r
   Permission is hereby granted, free of charge, to any person obtaining a\r
   copy of this software and associated documentation files (the "Software"),\r
   to deal in the Software without restriction, including without limitation\r
   the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
   and/or sell copies of the Software, and to permit persons to whom the\r
   Software is furnished to do so, subject to the following conditions:\r
\r
   The above copyright notice and this permission notice shall be included in\r
   all copies or substantial portions of the Software.\r
\r
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
   ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
\r
   Except as contained in this notice, the name of Robert M Supnik shall not be\r
   used in advertising or otherwise to promote the sale, use or other dealings\r
   in this Software without prior written authorization from Robert M Supnik.\r
\r
   mt           7-track magtape\r
\r
   07-Jul-07    RMS     Removed restriction on load-mode binary tape\r
   28-Jun-07    RMS     Revised read tape mark behavior based on real hardware\r
                        (found by Van Snyder)\r
   16-Feb-06    RMS     Added tape capacity checking\r
   15-Sep-05    RMS     Yet another fix to load read group mark plus word mark\r
                        Added debug printouts (from Van Snyder)\r
   26-Aug-05    RMS     Revised to use API for write lock check\r
   16-Aug-03    RMS     End-of-record on load read works like move read\r
                        (verified on real 1401)\r
                        Added diagnostic read (space forward)\r
   25-Apr-03    RMS     Revised for extended file support\r
   28-Mar-03    RMS     Added multiformat support\r
   15-Mar-03    RMS     Fixed end-of-record on load read yet again\r
   28-Feb-03    RMS     Modified for magtape library\r
   31-Oct-02    RMS     Added error record handling\r
   10-Oct-02    RMS     Fixed end-of-record on load read writes WM plus GM\r
   30-Sep-02    RMS     Revamped error handling\r
   28-Aug-02    RMS     Added end of medium support\r
   12-Jun-02    RMS     End-of-record on move read preserves old WM under GM\r
                        (found by Van Snyder)\r
   03-Jun-02    RMS     Modified for 1311 support\r
   30-May-02    RMS     Widened POS to 32b\r
   22-Apr-02    RMS     Added protection against bad record lengths\r
   30-Jan-02    RMS     New zero footprint tape bootstrap from Van Snyder\r
   20-Jan-02    RMS     Changed write enabled modifier\r
   29-Nov-01    RMS     Added read only unit support\r
   18-Apr-01    RMS     Changed to rewind tape before boot\r
   07-Dec-00    RMS     Widened display width from 6 to 8 bits to see record lnt\r
                CEO     Added tape bootstrap\r
   14-Apr-99    RMS     Changed t_addr to unsigned\r
   04-Oct-98    RMS     V2.4 magtape format\r
\r
   Magnetic tapes are represented as a series of variable 16b records\r
   of the form:\r
\r
        32b byte count\r
        byte 0\r
        byte 1\r
        :\r
        byte n-2\r
        byte n-1\r
        32b byte count\r
\r
   If the byte count is odd, the record is padded with an extra byte\r
   of junk.  File marks are represented by a byte count of 0.\r
*/\r
\r
#include "i1401_defs.h"\r
#include "sim_tape.h"\r
\r
#define MT_NUMDR        7                               /* #drives */\r
#define MT_MAXFR        (MAXMEMSIZE * 2)                /* max transfer */\r
\r
uint8 dbuf[MT_MAXFR];                                   /* tape buffer */\r
\r
extern uint8 M[];                                       /* memory */\r
extern int32 ind[64];\r
extern int32 BS, iochk;\r
extern UNIT cpu_unit;\r
extern FILE *sim_deb;\r
\r
t_stat mt_reset (DEVICE *dptr);\r
t_stat mt_boot (int32 unitno, DEVICE *dptr);\r
t_stat mt_map_status (t_stat st);\r
UNIT *get_unit (int32 unit);\r
\r
/* MT data structures\r
\r
   mt_dev       MT device descriptor\r
   mt_unit      MT unit list\r
   mt_reg       MT register list\r
   mt_mod       MT modifier list\r
*/\r
\r
UNIT mt_unit[] = {\r
    { UDATA (NULL, UNIT_DIS, 0) },                      /* doesn't exist */\r
    { UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
             UNIT_ROABLE + UNIT_BCD, 0) },\r
    { UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
             UNIT_ROABLE + UNIT_BCD, 0) },\r
    { UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
             UNIT_ROABLE + UNIT_BCD, 0) },\r
    { UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
             UNIT_ROABLE + UNIT_BCD, 0) },\r
    { UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
             UNIT_ROABLE + UNIT_BCD, 0) },\r
    { UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
             UNIT_ROABLE + UNIT_BCD, 0) }\r
    };\r
\r
REG mt_reg[] = {\r
    { FLDATA (END, ind[IN_END], 0) },\r
    { FLDATA (ERR, ind[IN_TAP], 0) },\r
    { DRDATA (POS1, mt_unit[1].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
    { DRDATA (POS2, mt_unit[2].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
    { DRDATA (POS3, mt_unit[3].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
    { DRDATA (POS4, mt_unit[4].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
    { DRDATA (POS5, mt_unit[5].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
    { DRDATA (POS6, mt_unit[6].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
    { NULL }\r
    };\r
\r
MTAB mt_mod[] = {\r
    { MTUF_WLK, 0, "write enabled", "WRITEENABLED", NULL },\r
    { MTUF_WLK, MTUF_WLK, "write locked", "LOCKED", NULL }, \r
    { MTAB_XTD|MTAB_VUN, 0, "FORMAT", "FORMAT",\r
      &sim_tape_set_fmt, &sim_tape_show_fmt, NULL },\r
    { MTAB_XTD|MTAB_VUN, 0, "CAPACITY", "CAPACITY",\r
      &sim_tape_set_capac, &sim_tape_show_capac, NULL },\r
    { 0 }\r
    };\r
\r
DEVICE mt_dev = {\r
    "MT", mt_unit, mt_reg, mt_mod,\r
    MT_NUMDR, 10, 31, 1, 8, 8,\r
    NULL, NULL, &mt_reset,\r
    &mt_boot, &sim_tape_attach, &sim_tape_detach,\r
    NULL, DEV_DEBUG\r
    };\r
\r
/* Function routine\r
\r
   Inputs:\r
        unit    =       unit character\r
        mod     =       modifier character\r
   Outputs:\r
        status  =       status\r
*/\r
\r
t_stat mt_func (int32 unit, int32 mod)\r
{\r
t_mtrlnt tbc;\r
UNIT *uptr;\r
t_stat st;\r
\r
if ((uptr = get_unit (unit)) == NULL) return STOP_INVMTU; /* valid unit? */\r
if ((uptr->flags & UNIT_ATT) == 0) return SCPE_UNATT;   /* attached? */\r
switch (mod) {                                          /* case on modifier */\r
\r
    case BCD_A:                                         /* diagnostic read */\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
            ">>MT%d: diagnostic read\n", unit);\r
        ind[IN_END] = 0;                                /* clear end of file */\r
        st = sim_tape_sprecf (uptr, &tbc);              /* space fwd */\r
        break;\r
\r
    case BCD_B:                                         /* backspace */\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
            ">>MT%d: backspace\n", unit);\r
        ind[IN_END] = 0;                                /* clear end of file */\r
        st = sim_tape_sprecr (uptr, &tbc);              /* space rev */\r
        break;                                          /* end case */\r
\r
    case BCD_E:                                         /* erase = nop */\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
            ">>MT%d: erase\n", unit);\r
        if (sim_tape_wrp (uptr)) return STOP_MTL;\r
        return SCPE_OK;\r
\r
    case BCD_M:                                         /* write tapemark */\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
            ">>MT%d: write tape mark\n", unit);\r
        st = sim_tape_wrtmk (uptr);                     /* write tmk */\r
        break;\r
\r
    case BCD_R:                                         /* rewind */\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
            ">>MT%d: rewind\n", unit);\r
        sim_tape_rewind (uptr);                         /* update position */\r
        return SCPE_OK;\r
\r
    case BCD_U:                                         /* unload */\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
            ">>MT%d: rewind and unload\n", unit);\r
        sim_tape_rewind (uptr);                         /* update position */\r
        return detach_unit (uptr);                      /* detach */\r
\r
    default:\r
        return STOP_INVM;\r
        }\r
\r
return mt_map_status (st);\r
}\r
\r
/* Read and write routines\r
\r
   Inputs:\r
        unit    =       unit character\r
        flag    =       normal, word mark, or binary mode\r
        mod     =       modifier character\r
   Outputs:\r
        status  =       status\r
\r
   Fine point: after a read, the system writes a group mark just\r
   beyond the end of the record.  However, first it checks for a\r
   GM + WM; if present, the GM + WM is not changed.  Otherwise,\r
   an MCW read sets a GM, preserving the current WM; while an LCA\r
   read sets a GM and clears the WM.\r
*/\r
\r
t_stat mt_io (int32 unit, int32 flag, int32 mod)\r
{\r
int32 t, wm_seen;\r
t_mtrlnt i, tbc;\r
t_stat st;\r
t_bool passed_eot;\r
UNIT *uptr;\r
\r
if ((uptr = get_unit (unit)) == NULL) return STOP_INVMTU; /* valid unit? */\r
if ((uptr->flags & UNIT_ATT) == 0) return SCPE_UNATT;   /* attached? */\r
\r
switch (mod) {\r
\r
    case BCD_R:                                         /* read */\r
        if (DEBUG_PRS (mt_dev))\r
            fprintf (sim_deb, ">>MT%d: read from %d", unit, BS);\r
        ind[IN_TAP] = ind[IN_END] = 0;                  /* clear error */\r
        wm_seen = 0;                                    /* no word mk seen */\r
        st = sim_tape_rdrecf (uptr, dbuf, &tbc, MT_MAXFR); /* read rec */\r
        if (st == MTSE_RECE) ind[IN_TAP] = 1;           /* rec in error? */\r
        else if (st == MTSE_TMK) {                      /* tape mark? */\r
            ind[IN_END] = 1;                            /* set indicator */\r
            tbc = 1;                                    /* one char read */\r
            dbuf[0] = BCD_TAPMRK;                       /* BCD tapemark */\r
            }\r
        else if (st != MTSE_OK) {                       /* stop on error */\r
            if (DEBUG_PRS (mt_dev))\r
                fprintf (sim_deb, ", stopped by status = %d\n", st);\r
            break;\r
            }\r
        for (i = 0; i < tbc; i++) {                     /* loop thru buf */\r
            if (M[BS] == (BCD_GRPMRK + WM)) {           /* GWM in memory? */\r
                if (DEBUG_PRS (mt_dev))\r
                    fprintf (sim_deb, " to %d, stopped by GMWM\n", BS);\r
                BS++;                                   /* incr BS */\r
                if (ADDR_ERR (BS)) {                    /* test for wrap */\r
                    BS = BA | (BS % MAXMEMSIZE);\r
                    return STOP_WRAP;\r
                    }\r
                return SCPE_OK;                         /* done */\r
                }\r
            t = dbuf[i];                                /* get char */\r
            if (!(flag & MD_BIN) && (t == BCD_ALT))     /* BCD mode alt blank? */\r
                t = BCD_BLANK;                          /* real blank */\r
            if (flag & MD_WM) {                         /* word mk mode? */\r
                if ((t == BCD_WM) && (wm_seen == 0))    /* WM char, none prev? */\r
                    wm_seen = WM;                       /* set flag */\r
                else {\r
                    M[BS] = wm_seen | (t & CHAR);       /* char + wm seen */\r
                    wm_seen = 0;                        /* clear flag */\r
                    }\r
                }\r
            else M[BS] = (M[BS] & WM) | (t & CHAR);     /* preserve mem WM */\r
            if (!wm_seen) BS++;\r
            if (ADDR_ERR (BS)) {                        /* check next BS */\r
                BS = BA | (BS % MAXMEMSIZE);\r
                return STOP_WRAP;\r
                }\r
            }\r
        if (M[BS] != (BCD_GRPMRK + WM)) {               /* not GM+WM at end? */\r
            if (flag & MD_WM) M[BS] = BCD_GRPMRK;       /* LCA: clear WM */\r
            else M[BS] = (M[BS] & WM) | BCD_GRPMRK;     /* MCW: save WM */\r
            }\r
        if (DEBUG_PRS (mt_dev))\r
            fprintf (sim_deb, " to %d, stopped by EOR\n", BS);\r
        BS++;                                           /* adv BS */\r
        if (ADDR_ERR (BS)) {                            /* check final BS */\r
            BS = BA | (BS % MAXMEMSIZE);\r
            return STOP_WRAP;\r
            }\r
        break;\r
\r
    case BCD_W:\r
        if (sim_tape_wrp (uptr)) return STOP_MTL;       /* locked? */\r
        if (M[BS] == (BCD_GRPMRK + WM)) return STOP_MTZ;/* eor? */\r
        if (DEBUG_PRS (mt_dev))\r
            fprintf (sim_deb, ">>MT%d: write from %d", unit, BS);\r
        ind[IN_TAP] = ind[IN_END] = 0;                  /* clear error */\r
        for (tbc = 0; (t = M[BS++]) != (BCD_GRPMRK + WM); ) {\r
            if ((t & WM) && (flag & MD_WM))             /* WM in wm mode? */\r
                dbuf[tbc++] = BCD_WM;\r
            if (((t & CHAR) == BCD_BLANK) && !(flag & MD_BIN))\r
                dbuf[tbc++] = BCD_ALT;\r
            else dbuf[tbc++] = t & CHAR;\r
            if (ADDR_ERR (BS)) {                        /* check next BS */\r
                BS = BA | (BS % MAXMEMSIZE);\r
                return STOP_WRAP;\r
                }\r
            }\r
        if (DEBUG_PRS (mt_dev)) fprintf (sim_deb, " to %d\n", BS - 1);\r
        passed_eot = sim_tape_eot (uptr);               /* passed EOT? */\r
        st = sim_tape_wrrecf (uptr, dbuf, tbc);         /* write record */\r
        if (!passed_eot && sim_tape_eot (uptr))         /* just passed EOT? */\r
            ind[IN_END] = 1;\r
        if (ADDR_ERR (BS)) {                            /* check final BS */\r
            BS = BA | (BS % MAXMEMSIZE);\r
            return STOP_WRAP;\r
            }\r
        break;\r
\r
    default:\r
        return STOP_INVM;\r
        }\r
\r
return mt_map_status (st);\r
}\r
\r
/* Get unit pointer from unit number */\r
\r
UNIT *get_unit (int32 unit)\r
{\r
if ((unit <= 0) || (unit >= MT_NUMDR)) return NULL;\r
return mt_dev.units + unit;\r
}\r
\r
/* Map tape status */\r
\r
t_stat mt_map_status (t_stat st)\r
{\r
switch (st) {\r
\r
    case MTSE_OK:                                       /* no error */\r
    case MTSE_BOT:                                      /* reverse into BOT */\r
        break;\r
\r
    case MTSE_FMT:                                      /* illegal fmt */\r
        return SCPE_IERR;\r
\r
    case MTSE_UNATT:                                    /* not attached */\r
        return SCPE_UNATT;\r
\r
    case MTSE_INVRL:                                    /* invalid rec lnt */\r
        return SCPE_MTRLNT;\r
\r
    case MTSE_TMK:                                      /* end of file */\r
        ind[IN_END] = 1;                                /* set end mark */\r
        break;\r
\r
    case MTSE_IOERR:                                    /* IO error */\r
        ind[IN_TAP] = 1;                                /* set error */\r
        if (iochk) return SCPE_IOERR;\r
        break;\r
\r
    case MTSE_RECE:                                     /* record in error */\r
    case MTSE_EOM:                                      /* end of medium */\r
        ind[IN_TAP] = 1;                                /* set error */\r
        break;\r
\r
    case MTSE_WRP:                                      /* write protect */\r
        return STOP_MTL;\r
        }\r
\r
return SCPE_OK;\r
}\r
\r
/* Reset routine */\r
\r
t_stat mt_reset (DEVICE *dptr)\r
{\r
int32 i;\r
UNIT *uptr;\r
\r
for (i = 0; i < MT_NUMDR; i++) {                        /* clear pos flag */\r
    if (uptr = get_unit (i)) MT_CLR_PNU (uptr);\r
    }\r
ind[IN_END] = ind[IN_TAP] = 0;                          /* clear indicators */\r
return SCPE_OK;\r
}\r
\r
/* Bootstrap routine */\r
\r
t_stat mt_boot (int32 unitno, DEVICE *dptr)\r
{\r
extern int32 saved_IS;\r
\r
sim_tape_rewind (&mt_unit[unitno]);                     /* force rewind */\r
BS = 1;                                                 /* set BS = 001 */\r
mt_io (unitno, MD_WM, BCD_R);                           /* LDA %U1 001 R */\r
saved_IS = 1;\r
return SCPE_OK;\r
}\r
Commit	Line	Data
196ba1fc PH	1	/* i1401_mt.c: IBM 1401 magnetic tape simulator\r
	2	\r
	3	Copyright (c) 1993-2007, Robert M. Supnik\r
	4	\r
	5	Permission is hereby granted, free of charge, to any person obtaining a\r
	6	copy of this software and associated documentation files (the "Software"),\r
	7	to deal in the Software without restriction, including without limitation\r
	8	the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
	9	and/or sell copies of the Software, and to permit persons to whom the\r
	10	Software is furnished to do so, subject to the following conditions:\r
	11	\r
	12	The above copyright notice and this permission notice shall be included in\r
	13	all copies or substantial portions of the Software.\r
	14	\r
	15	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
	16	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
	17	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\r
	18	ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
	19	IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
	20	CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
	21	\r
	22	Except as contained in this notice, the name of Robert M Supnik shall not be\r
	23	used in advertising or otherwise to promote the sale, use or other dealings\r
	24	in this Software without prior written authorization from Robert M Supnik.\r
	25	\r
	26	mt 7-track magtape\r
	27	\r
	28	07-Jul-07 RMS Removed restriction on load-mode binary tape\r
	29	28-Jun-07 RMS Revised read tape mark behavior based on real hardware\r
	30	(found by Van Snyder)\r
	31	16-Feb-06 RMS Added tape capacity checking\r
	32	15-Sep-05 RMS Yet another fix to load read group mark plus word mark\r
	33	Added debug printouts (from Van Snyder)\r
	34	26-Aug-05 RMS Revised to use API for write lock check\r
	35	16-Aug-03 RMS End-of-record on load read works like move read\r
	36	(verified on real 1401)\r
	37	Added diagnostic read (space forward)\r
	38	25-Apr-03 RMS Revised for extended file support\r
	39	28-Mar-03 RMS Added multiformat support\r
	40	15-Mar-03 RMS Fixed end-of-record on load read yet again\r
	41	28-Feb-03 RMS Modified for magtape library\r
	42	31-Oct-02 RMS Added error record handling\r
	43	10-Oct-02 RMS Fixed end-of-record on load read writes WM plus GM\r
	44	30-Sep-02 RMS Revamped error handling\r
	45	28-Aug-02 RMS Added end of medium support\r
	46	12-Jun-02 RMS End-of-record on move read preserves old WM under GM\r
	47	(found by Van Snyder)\r
	48	03-Jun-02 RMS Modified for 1311 support\r
	49	30-May-02 RMS Widened POS to 32b\r
	50	22-Apr-02 RMS Added protection against bad record lengths\r
	51	30-Jan-02 RMS New zero footprint tape bootstrap from Van Snyder\r
	52	20-Jan-02 RMS Changed write enabled modifier\r
	53	29-Nov-01 RMS Added read only unit support\r
	54	18-Apr-01 RMS Changed to rewind tape before boot\r
	55	07-Dec-00 RMS Widened display width from 6 to 8 bits to see record lnt\r
	56	CEO Added tape bootstrap\r
	57	14-Apr-99 RMS Changed t_addr to unsigned\r
	58	04-Oct-98 RMS V2.4 magtape format\r
	59	\r
	60	Magnetic tapes are represented as a series of variable 16b records\r
	61	of the form:\r
	62	\r
	63	32b byte count\r
	64	byte 0\r
65	byte 1\r
66	:\r
67	byte n-2\r
68	byte n-1\r
69	32b byte count\r
70	\r
71	If the byte count is odd, the record is padded with an extra byte\r
72	of junk. File marks are represented by a byte count of 0.\r
73	*/\r
74	\r
75	#include "i1401_defs.h"\r
76	#include "sim_tape.h"\r
77	\r
78	#define MT_NUMDR 7 /* #drives */\r
79	#define MT_MAXFR (MAXMEMSIZE * 2) /* max transfer */\r
80	\r
81	uint8 dbuf[MT_MAXFR]; /* tape buffer */\r
82	\r
83	extern uint8 M[]; /* memory */\r
84	extern int32 ind[64];\r
85	extern int32 BS, iochk;\r
86	extern UNIT cpu_unit;\r
87	extern FILE *sim_deb;\r
88	\r
89	t_stat mt_reset (DEVICE *dptr);\r
90	t_stat mt_boot (int32 unitno, DEVICE *dptr);\r
91	t_stat mt_map_status (t_stat st);\r
92	UNIT *get_unit (int32 unit);\r
93	\r
94	/* MT data structures\r
95	\r
96	mt_dev MT device descriptor\r
97	mt_unit MT unit list\r
98	mt_reg MT register list\r
99	mt_mod MT modifier list\r
100	*/\r
101	\r
102	UNIT mt_unit[] = {\r
103	{ UDATA (NULL, UNIT_DIS, 0) }, /* doesn't exist */\r
104	{ UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
105	UNIT_ROABLE + UNIT_BCD, 0) },\r
106	{ UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
107	UNIT_ROABLE + UNIT_BCD, 0) },\r
108	{ UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
109	UNIT_ROABLE + UNIT_BCD, 0) },\r
110	{ UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
111	UNIT_ROABLE + UNIT_BCD, 0) },\r
112	{ UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
113	UNIT_ROABLE + UNIT_BCD, 0) },\r
114	{ UDATA (NULL, UNIT_DISABLE + UNIT_ATTABLE +\r
115	UNIT_ROABLE + UNIT_BCD, 0) }\r
116	};\r
117	\r
118	REG mt_reg[] = {\r
119	{ FLDATA (END, ind[IN_END], 0) },\r
120	{ FLDATA (ERR, ind[IN_TAP], 0) },\r
121	{ DRDATA (POS1, mt_unit[1].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
122	{ DRDATA (POS2, mt_unit[2].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
123	{ DRDATA (POS3, mt_unit[3].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
124	{ DRDATA (POS4, mt_unit[4].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
125	{ DRDATA (POS5, mt_unit[5].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
126	{ DRDATA (POS6, mt_unit[6].pos, T_ADDR_W), PV_LEFT + REG_RO },\r
127	{ NULL }\r
128	};\r
129	\r
130	MTAB mt_mod[] = {\r
131	{ MTUF_WLK, 0, "write enabled", "WRITEENABLED", NULL },\r
132	{ MTUF_WLK, MTUF_WLK, "write locked", "LOCKED", NULL }, \r
133	{ MTAB_XTD\|MTAB_VUN, 0, "FORMAT", "FORMAT",\r
134	&sim_tape_set_fmt, &sim_tape_show_fmt, NULL },\r
135	{ MTAB_XTD\|MTAB_VUN, 0, "CAPACITY", "CAPACITY",\r
136	&sim_tape_set_capac, &sim_tape_show_capac, NULL },\r
137	{ 0 }\r
138	};\r
139	\r
140	DEVICE mt_dev = {\r
141	"MT", mt_unit, mt_reg, mt_mod,\r
142	MT_NUMDR, 10, 31, 1, 8, 8,\r
143	NULL, NULL, &mt_reset,\r
144	&mt_boot, &sim_tape_attach, &sim_tape_detach,\r
145	NULL, DEV_DEBUG\r
146	};\r
147	\r
148	/* Function routine\r
149	\r
150	Inputs:\r
151	unit = unit character\r
152	mod = modifier character\r
153	Outputs:\r
154	status = status\r
155	*/\r
156	\r
157	t_stat mt_func (int32 unit, int32 mod)\r
158	{\r
159	t_mtrlnt tbc;\r
160	UNIT *uptr;\r
161	t_stat st;\r
162	\r
163	if ((uptr = get_unit (unit)) == NULL) return STOP_INVMTU; /* valid unit? */\r
164	if ((uptr->flags & UNIT_ATT) == 0) return SCPE_UNATT; /* attached? */\r
165	switch (mod) { /* case on modifier */\r
166	\r
167	case BCD_A: /* diagnostic read */\r
168	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
169	">>MT%d: diagnostic read\n", unit);\r
170	ind[IN_END] = 0; /* clear end of file */\r
171	st = sim_tape_sprecf (uptr, &tbc); /* space fwd */\r
172	break;\r
173	\r
174	case BCD_B: /* backspace */\r
175	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
176	">>MT%d: backspace\n", unit);\r
177	ind[IN_END] = 0; /* clear end of file */\r
178	st = sim_tape_sprecr (uptr, &tbc); /* space rev */\r
179	break; /* end case */\r
180	\r
181	case BCD_E: /* erase = nop */\r
182	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
183	">>MT%d: erase\n", unit);\r
184	if (sim_tape_wrp (uptr)) return STOP_MTL;\r
185	return SCPE_OK;\r
186	\r
187	case BCD_M: /* write tapemark */\r
188	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
189	">>MT%d: write tape mark\n", unit);\r
190	st = sim_tape_wrtmk (uptr); /* write tmk */\r
191	break;\r
192	\r
193	case BCD_R: /* rewind */\r
194	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
195	">>MT%d: rewind\n", unit);\r
196	sim_tape_rewind (uptr); /* update position */\r
197	return SCPE_OK;\r
198	\r
199	case BCD_U: /* unload */\r
200	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb,\r
201	">>MT%d: rewind and unload\n", unit);\r
202	sim_tape_rewind (uptr); /* update position */\r
203	return detach_unit (uptr); /* detach */\r
204	\r
205	default:\r
206	return STOP_INVM;\r
207	}\r
208	\r
209	return mt_map_status (st);\r
210	}\r
211	\r
212	/* Read and write routines\r
213	\r
214	Inputs:\r
215	unit = unit character\r
216	flag = normal, word mark, or binary mode\r
217	mod = modifier character\r
218	Outputs:\r
219	status = status\r
220	\r
221	Fine point: after a read, the system writes a group mark just\r
222	beyond the end of the record. However, first it checks for a\r
223	GM + WM; if present, the GM + WM is not changed. Otherwise,\r
224	an MCW read sets a GM, preserving the current WM; while an LCA\r
225	read sets a GM and clears the WM.\r
226	*/\r
227	\r
228	t_stat mt_io (int32 unit, int32 flag, int32 mod)\r
229	{\r
230	int32 t, wm_seen;\r
231	t_mtrlnt i, tbc;\r
232	t_stat st;\r
233	t_bool passed_eot;\r
234	UNIT *uptr;\r
235	\r
236	if ((uptr = get_unit (unit)) == NULL) return STOP_INVMTU; /* valid unit? */\r
237	if ((uptr->flags & UNIT_ATT) == 0) return SCPE_UNATT; /* attached? */\r
238	\r
239	switch (mod) {\r
240	\r
241	case BCD_R: /* read */\r
242	if (DEBUG_PRS (mt_dev))\r
243	fprintf (sim_deb, ">>MT%d: read from %d", unit, BS);\r
244	ind[IN_TAP] = ind[IN_END] = 0; /* clear error */\r
245	wm_seen = 0; /* no word mk seen */\r
246	st = sim_tape_rdrecf (uptr, dbuf, &tbc, MT_MAXFR); /* read rec */\r
247	if (st == MTSE_RECE) ind[IN_TAP] = 1; /* rec in error? */\r
248	else if (st == MTSE_TMK) { /* tape mark? */\r
249	ind[IN_END] = 1; /* set indicator */\r
250	tbc = 1; /* one char read */\r
251	dbuf[0] = BCD_TAPMRK; /* BCD tapemark */\r
252	}\r
253	else if (st != MTSE_OK) { /* stop on error */\r
254	if (DEBUG_PRS (mt_dev))\r
255	fprintf (sim_deb, ", stopped by status = %d\n", st);\r
256	break;\r
257	}\r
258	for (i = 0; i < tbc; i++) { /* loop thru buf */\r
259	if (M[BS] == (BCD_GRPMRK + WM)) { /* GWM in memory? */\r
260	if (DEBUG_PRS (mt_dev))\r
261	fprintf (sim_deb, " to %d, stopped by GMWM\n", BS);\r
262	BS++; /* incr BS */\r
263	if (ADDR_ERR (BS)) { /* test for wrap */\r
264	BS = BA \| (BS % MAXMEMSIZE);\r
265	return STOP_WRAP;\r
266	}\r
267	return SCPE_OK; /* done */\r
268	}\r
269	t = dbuf[i]; /* get char */\r
270	if (!(flag & MD_BIN) && (t == BCD_ALT)) /* BCD mode alt blank? */\r
271	t = BCD_BLANK; /* real blank */\r
272	if (flag & MD_WM) { /* word mk mode? */\r
273	if ((t == BCD_WM) && (wm_seen == 0)) /* WM char, none prev? */\r
274	wm_seen = WM; /* set flag */\r
275	else {\r
276	M[BS] = wm_seen \| (t & CHAR); /* char + wm seen */\r
277	wm_seen = 0; /* clear flag */\r
278	}\r
279	}\r
280	else M[BS] = (M[BS] & WM) \| (t & CHAR); /* preserve mem WM */\r
281	if (!wm_seen) BS++;\r
282	if (ADDR_ERR (BS)) { /* check next BS */\r
283	BS = BA \| (BS % MAXMEMSIZE);\r
284	return STOP_WRAP;\r
285	}\r
286	}\r
287	if (M[BS] != (BCD_GRPMRK + WM)) { /* not GM+WM at end? */\r
288	if (flag & MD_WM) M[BS] = BCD_GRPMRK; /* LCA: clear WM */\r
289	else M[BS] = (M[BS] & WM) \| BCD_GRPMRK; /* MCW: save WM */\r
290	}\r
291	if (DEBUG_PRS (mt_dev))\r
292	fprintf (sim_deb, " to %d, stopped by EOR\n", BS);\r
293	BS++; /* adv BS */\r
294	if (ADDR_ERR (BS)) { /* check final BS */\r
295	BS = BA \| (BS % MAXMEMSIZE);\r
296	return STOP_WRAP;\r
297	}\r
298	break;\r
299	\r
300	case BCD_W:\r
301	if (sim_tape_wrp (uptr)) return STOP_MTL; /* locked? */\r
302	if (M[BS] == (BCD_GRPMRK + WM)) return STOP_MTZ;/* eor? */\r
303	if (DEBUG_PRS (mt_dev))\r
304	fprintf (sim_deb, ">>MT%d: write from %d", unit, BS);\r
305	ind[IN_TAP] = ind[IN_END] = 0; /* clear error */\r
306	for (tbc = 0; (t = M[BS++]) != (BCD_GRPMRK + WM); ) {\r
307	if ((t & WM) && (flag & MD_WM)) /* WM in wm mode? */\r
308	dbuf[tbc++] = BCD_WM;\r
309	if (((t & CHAR) == BCD_BLANK) && !(flag & MD_BIN))\r
310	dbuf[tbc++] = BCD_ALT;\r
311	else dbuf[tbc++] = t & CHAR;\r
312	if (ADDR_ERR (BS)) { /* check next BS */\r
313	BS = BA \| (BS % MAXMEMSIZE);\r
314	return STOP_WRAP;\r
315	}\r
316	}\r
317	if (DEBUG_PRS (mt_dev)) fprintf (sim_deb, " to %d\n", BS - 1);\r
318	passed_eot = sim_tape_eot (uptr); /* passed EOT? */\r
319	st = sim_tape_wrrecf (uptr, dbuf, tbc); /* write record */\r
320	if (!passed_eot && sim_tape_eot (uptr)) /* just passed EOT? */\r
321	ind[IN_END] = 1;\r
322	if (ADDR_ERR (BS)) { /* check final BS */\r
323	BS = BA \| (BS % MAXMEMSIZE);\r
324	return STOP_WRAP;\r
325	}\r
326	break;\r
327	\r
328	default:\r
329	return STOP_INVM;\r
330	}\r
331	\r
332	return mt_map_status (st);\r
333	}\r
334	\r
335	/* Get unit pointer from unit number */\r
336	\r
337	UNIT *get_unit (int32 unit)\r
338	{\r
339	if ((unit <= 0) \|\| (unit >= MT_NUMDR)) return NULL;\r
340	return mt_dev.units + unit;\r
341	}\r
342	\r
343	/* Map tape status */\r
344	\r
345	t_stat mt_map_status (t_stat st)\r
346	{\r
347	switch (st) {\r
348	\r
349	case MTSE_OK: /* no error */\r
350	case MTSE_BOT: /* reverse into BOT */\r
351	break;\r
352	\r
353	case MTSE_FMT: /* illegal fmt */\r
354	return SCPE_IERR;\r
355	\r
356	case MTSE_UNATT: /* not attached */\r
357	return SCPE_UNATT;\r
358	\r
359	case MTSE_INVRL: /* invalid rec lnt */\r
360	return SCPE_MTRLNT;\r
361	\r
362	case MTSE_TMK: /* end of file */\r
363	ind[IN_END] = 1; /* set end mark */\r
364	break;\r
365	\r
366	case MTSE_IOERR: /* IO error */\r
367	ind[IN_TAP] = 1; /* set error */\r
368	if (iochk) return SCPE_IOERR;\r
369	break;\r
370	\r
371	case MTSE_RECE: /* record in error */\r
372	case MTSE_EOM: /* end of medium */\r
373	ind[IN_TAP] = 1; /* set error */\r
374	break;\r
375	\r
376	case MTSE_WRP: /* write protect */\r
377	return STOP_MTL;\r
378	}\r
379	\r
380	return SCPE_OK;\r
381	}\r
382	\r
383	/* Reset routine */\r
384	\r
385	t_stat mt_reset (DEVICE *dptr)\r
386	{\r
387	int32 i;\r
388	UNIT *uptr;\r
389	\r
390	for (i = 0; i < MT_NUMDR; i++) { /* clear pos flag */\r
391	if (uptr = get_unit (i)) MT_CLR_PNU (uptr);\r
392	}\r
393	ind[IN_END] = ind[IN_TAP] = 0; /* clear indicators */\r
394	return SCPE_OK;\r
395	}\r
396	\r
397	/* Bootstrap routine */\r
398	\r
399	t_stat mt_boot (int32 unitno, DEVICE *dptr)\r
400	{\r
401	extern int32 saved_IS;\r
402	\r
403	sim_tape_rewind (&mt_unit[unitno]); /* force rewind */\r
404	BS = 1; /* set BS = 001 */\r
405	mt_io (unitno, MD_WM, BCD_R); /* LDA %U1 001 R */\r
406	saved_IS = 1;\r
407	return SCPE_OK;\r
408	}\r