646 lines
23 KiB
C
646 lines
23 KiB
C
/* sds_stddev.c: SDS 940 standard devices
|
|
|
|
Copyright (c) 2001-2020, 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.
|
|
|
|
ptr paper tape reader
|
|
ptp paper tape punch
|
|
tti keyboard
|
|
tto teleprinter
|
|
|
|
23-Oct-20 RMS TTO recognizes no leader flag (Ken Rector)
|
|
29-Dec-03 RMS Added console backpressure support
|
|
25-Apr-03 RMS Revised for extended file support
|
|
*/
|
|
|
|
#include "sds_defs.h"
|
|
#include "sim_tmxr.h"
|
|
|
|
#define TT_CR 052 /* typewriter */
|
|
#define TT_TB 072
|
|
#define TT_BS 032
|
|
|
|
extern uint32 xfr_req;
|
|
extern int32 stop_invins, stop_invdev, stop_inviop;
|
|
int32 ptr_sor = 0; /* start of rec */
|
|
int32 ptr_stopioe = 0; /* no stop on err */
|
|
int32 ptp_ldr = 0; /* no leader */
|
|
int32 ptp_stopioe = 1;
|
|
int32 tto_ldr = 0; /* no leader */
|
|
int32 tto_retry = 0; /* retry due to stall */
|
|
DSPT std_tplt[] = { { 1, 0 }, { 0, 0 } }; /* template */
|
|
|
|
t_stat ptr (uint32 fnc, uint32 inst, uint32 *dat);
|
|
t_stat ptr_svc (UNIT *uptr);
|
|
t_stat ptr_reset (DEVICE *dptr);
|
|
t_stat ptr_boot (int32 unitno, DEVICE *dptr);
|
|
void ptr_set_err (void);
|
|
t_stat ptp (uint32 fnc, uint32 inst, uint32 *dat);
|
|
t_stat ptp_svc (UNIT *uptr);
|
|
t_stat ptp_reset (DEVICE *dptr);
|
|
t_stat ptp_out (int32 dat);
|
|
void ptp_set_err (void);
|
|
t_stat tti (uint32 fnc, uint32 inst, uint32 *dat);
|
|
t_stat tti_svc (UNIT *uptr);
|
|
t_stat tti_reset (DEVICE *dptr);
|
|
t_stat tto (uint32 fnc, uint32 inst, uint32 *dat);
|
|
t_stat tto_svc (UNIT *uptr);
|
|
t_stat tto_reset (DEVICE *dptr);
|
|
t_stat tto_out (int32 dat);
|
|
int8 ascii_to_sds(int8 ch);
|
|
int8 sds_to_ascii(int8 ch);
|
|
|
|
/* PTR data structures
|
|
|
|
ptr_dev PTR device descriptor
|
|
ptr_unit PTR unit
|
|
ptr_reg PTR register list
|
|
*/
|
|
|
|
DIB ptr_dib = { CHAN_W, DEV_PTR, XFR_PTR, std_tplt, &ptr };
|
|
|
|
UNIT ptr_unit = {
|
|
UDATA (&ptr_svc, UNIT_SEQ+UNIT_ATTABLE+UNIT_ROABLE, 0),
|
|
SERIAL_IN_WAIT
|
|
};
|
|
|
|
REG ptr_reg[] = {
|
|
{ ORDATA (BUF, ptr_unit.buf, 7) },
|
|
{ FLDATA (XFR, xfr_req, XFR_V_PTR) },
|
|
{ FLDATA (SOR, ptr_sor, 0) },
|
|
{ DRDATA (POS, ptr_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, ptr_unit.wait, 24), REG_NZ + PV_LEFT },
|
|
{ FLDATA (STOP_IOE, ptr_stopioe, 0) },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB ptr_mod[] = {
|
|
{ MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",
|
|
&set_chan, &show_chan, NULL },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE ptr_dev = {
|
|
"PTR", &ptr_unit, ptr_reg, ptr_mod,
|
|
1, 10, 31, 1, 8, 8,
|
|
NULL, NULL, &ptr_reset,
|
|
&ptr_boot, NULL, NULL,
|
|
&ptr_dib, DEV_DISABLE
|
|
};
|
|
|
|
/* PTP data structures
|
|
|
|
ptp_dev PTP device descriptor
|
|
ptp_unit PTP unit
|
|
ptp_reg PTP register list
|
|
*/
|
|
|
|
DIB ptp_dib = { CHAN_W, DEV_PTP, XFR_PTP, std_tplt, &ptp };
|
|
|
|
UNIT ptp_unit = {
|
|
UDATA (&ptp_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_OUT_WAIT
|
|
};
|
|
|
|
REG ptp_reg[] = {
|
|
{ ORDATA (BUF, ptp_unit.buf, 7) },
|
|
{ FLDATA (XFR, xfr_req, XFR_V_PTP) },
|
|
{ FLDATA (LDR, ptp_ldr, 0) },
|
|
{ DRDATA (POS, ptp_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, ptp_unit.wait, 24), REG_NZ + PV_LEFT },
|
|
{ FLDATA (STOP_IOE, ptp_stopioe, 0) },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB ptp_mod[] = {
|
|
{ MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",
|
|
&set_chan, &show_chan, NULL },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE ptp_dev = {
|
|
"PTP", &ptp_unit, ptp_reg, ptp_mod,
|
|
1, 10, 31, 1, 8, 8,
|
|
NULL, NULL, &ptp_reset,
|
|
NULL, NULL, NULL,
|
|
&ptp_dib, DEV_DISABLE
|
|
};
|
|
|
|
/* TTI data structures
|
|
|
|
tti_dev TTI device descriptor
|
|
tti_unit TTI unit
|
|
tti_reg TTI register list
|
|
*/
|
|
|
|
DIB tti_dib = { CHAN_W, DEV_TTI, XFR_TTI, std_tplt, &tti };
|
|
|
|
UNIT tti_unit = { UDATA (&tti_svc, 0, 0), KBD_POLL_WAIT };
|
|
|
|
REG tti_reg[] = {
|
|
{ ORDATA (BUF, tti_unit.buf, 6) },
|
|
{ FLDATA (XFR, xfr_req, XFR_V_TTI) },
|
|
{ DRDATA (POS, tti_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, tti_unit.wait, 24), REG_NZ + PV_LEFT },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB tti_mod[] = {
|
|
{ MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",
|
|
&set_chan, &show_chan, &tti_dib },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE tti_dev = {
|
|
"TTI", &tti_unit, tti_reg, tti_mod,
|
|
1, 10, 31, 1, 8, 8,
|
|
NULL, NULL, &tti_reset,
|
|
NULL, NULL, NULL,
|
|
&tti_dib, 0
|
|
};
|
|
|
|
/* TTO data structures
|
|
|
|
tto_dev TTO device descriptor
|
|
tto_unit TTO unit
|
|
tto_reg TTO register list
|
|
*/
|
|
|
|
DIB tto_dib = { CHAN_W, DEV_TTO, XFR_TTO, std_tplt, &tto };
|
|
|
|
UNIT tto_unit = { UDATA (&tto_svc, 0, 0), SERIAL_OUT_WAIT };
|
|
|
|
REG tto_reg[] = {
|
|
{ ORDATA (BUF, tto_unit.buf, 6) },
|
|
{ FLDATA (XFR, xfr_req, XFR_V_TTO) },
|
|
{ FLDATA (LDR, tto_ldr, 0) },
|
|
{ FLDATA (RETRY, tto_retry, 0), REG_HRO },
|
|
{ DRDATA (POS, tto_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, tto_unit.wait, 24), REG_NZ + PV_LEFT },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB tto_mod[] = {
|
|
{ MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",
|
|
&set_chan, &show_chan, &tto_dib },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE tto_dev = {
|
|
"TTO", &tto_unit, tto_reg, tto_mod,
|
|
1, 10, 31, 1, 8, 8,
|
|
NULL, NULL, &tto_reset,
|
|
NULL, NULL, NULL,
|
|
&tto_dib, 0
|
|
};
|
|
|
|
/* Paper tape reader
|
|
|
|
conn - inst = EOM0, dat = NULL
|
|
eom1 - inst = EOM1, dat = NULL
|
|
sks - inst = SKS, dat = ptr to result
|
|
disc - inst = device number, dat = NULL
|
|
wreor - inst = device number, dat = NULL
|
|
read - inst = device number, dat = ptr to data
|
|
write - inst = device number, dat = ptr to result
|
|
|
|
The paper tape reader is a streaming input device. Once started, it
|
|
continues to read until disconnected. Leader before the current record
|
|
is ignored; leader after the current record sets channel EndOfRecord.
|
|
*/
|
|
|
|
t_stat ptr (uint32 fnc, uint32 inst, uint32 *dat)
|
|
{
|
|
int32 new_ch;
|
|
|
|
switch (fnc) { /* case function */
|
|
|
|
case IO_CONN: /* connect */
|
|
new_ch = I_GETEOCH (inst); /* get new chan */
|
|
if (new_ch != ptr_dib.chan) /* inv conn? err */
|
|
return SCPE_IERR;
|
|
ptr_sor = 1; /* start of rec */
|
|
xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */
|
|
sim_activate (&ptr_unit, ptr_unit.wait); /* activate */
|
|
break;
|
|
|
|
case IO_DISC: /* disconnect */
|
|
ptr_sor = 0; /* clear state */
|
|
xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */
|
|
sim_cancel (&ptr_unit); /* deactivate unit */
|
|
break;
|
|
|
|
case IO_READ: /* read */
|
|
xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */
|
|
*dat = ptr_unit.buf & 077; /* get buf data */
|
|
if (ptr_unit.buf != odd_par[*dat]) /* good parity? */
|
|
chan_set_flag (ptr_dib.chan, CHF_ERR); /* no, error */
|
|
break;
|
|
|
|
case IO_WREOR: /* write eor */
|
|
break;
|
|
|
|
case IO_EOM1: /* EOM mode 1*/
|
|
case IO_WRITE: /* write */
|
|
CRETINS; /* error */
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Unit service */
|
|
|
|
t_stat ptr_svc (UNIT *uptr)
|
|
{
|
|
int32 temp;
|
|
|
|
if ((ptr_unit.flags & UNIT_ATT) == 0) { /* attached? */
|
|
ptr_set_err (); /* no, err, disc */
|
|
CRETIOE (ptr_stopioe, SCPE_UNATT);
|
|
}
|
|
if ((temp = getc (ptr_unit.fileref)) == EOF) { /* end of file? */
|
|
ptr_set_err (); /* yes, err, disc */
|
|
if (feof (ptr_unit.fileref)) { /* end of file? */
|
|
if (ptr_stopioe)
|
|
sim_printf ("PTR end of file\n");
|
|
else return SCPE_OK;
|
|
}
|
|
else sim_perror ("PTR I/O error"); /* I/O error */
|
|
clearerr (ptr_unit.fileref);
|
|
return SCPE_IOERR;
|
|
}
|
|
ptr_unit.pos = ptr_unit.pos + 1; /* inc position */
|
|
if (temp) { /* leader/gap? */
|
|
ptr_unit.buf = temp & 0177; /* no, save char */
|
|
xfr_req = xfr_req | XFR_PTR; /* set xfr flag */
|
|
ptr_sor = 0; /* in record */
|
|
}
|
|
else if (!ptr_sor) /* end record? */
|
|
chan_set_flag (ptr_dib.chan, CHF_EOR); /* ignore leader */
|
|
sim_activate (&ptr_unit, ptr_unit.wait); /* get next char */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Fatal error */
|
|
|
|
void ptr_set_err (void)
|
|
{
|
|
chan_set_flag (ptr_dib.chan, CHF_EOR | CHF_ERR); /* eor, error */
|
|
chan_disc (ptr_dib.chan); /* disconnect */
|
|
xfr_req = xfr_req & ~XFR_PTR; /* clear xfr */
|
|
sim_cancel (&ptr_unit); /* stop */
|
|
return;
|
|
}
|
|
|
|
/* Reset routine */
|
|
|
|
t_stat ptr_reset (DEVICE *dptr)
|
|
{
|
|
chan_disc (ptr_dib.chan); /* disconnect */
|
|
ptr_sor = 0; /* clear state */
|
|
ptr_unit.buf = 0;
|
|
xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */
|
|
sim_cancel (&ptr_unit); /* deactivate unit */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Boot routine - simulate FILL console command */
|
|
|
|
t_stat ptr_boot (int32 unitno, DEVICE *dptr)
|
|
{
|
|
extern uint32 P, M[];
|
|
|
|
M[0] = 077777771; /* -7B */
|
|
M[1] = 007100000; /* LDX 0 */
|
|
M[2] = 000203604; /* EOM 3604B */
|
|
M[3] = 003200002; /* WIM 2 */
|
|
M[4] = 000100002; /* BRU 2 */
|
|
P = 1; /* start at 1 */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Paper tape punch
|
|
|
|
conn - inst = EOM0, dat = NULL
|
|
eom1 - inst = EOM1, dat = NULL
|
|
sks - inst = SKS, dat = ptr to result
|
|
disc - inst = device number, dat = NULL
|
|
wreor - inst = device number, dat = NULL
|
|
read - inst = device number, dat = ptr to data
|
|
write - inst = device number, dat = ptr to result
|
|
|
|
The paper tape punch is an asynchronous streaming output device. That is,
|
|
it can never cause a channel rate error; if no data is available, it waits.
|
|
*/
|
|
|
|
t_stat ptp (uint32 fnc, uint32 inst, uint32 *dat)
|
|
{
|
|
int32 new_ch;
|
|
|
|
switch (fnc) { /* case function */
|
|
|
|
case IO_CONN:
|
|
new_ch = I_GETEOCH (inst); /* get new chan */
|
|
if (new_ch != ptp_dib.chan) /* inv conn? err */
|
|
return SCPE_IERR;
|
|
ptp_ldr = (inst & CHC_NLDR)? 0: 1; /* leader? */
|
|
xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */
|
|
sim_activate (&ptp_unit, ptp_unit.wait); /* activate */
|
|
break;
|
|
|
|
case IO_DISC: /* disconnect */
|
|
ptp_ldr = 0; /* clear state */
|
|
xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */
|
|
sim_cancel (&ptp_unit); /* deactivate unit */
|
|
break;
|
|
|
|
case IO_WRITE: /* write */
|
|
xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */
|
|
sim_activate (&ptp_unit, ptp_unit.wait); /* activate */
|
|
ptp_unit.buf = odd_par[(*dat) & 077]; /* save data */
|
|
return ptp_out (ptp_unit.buf); /* punch w/ par */
|
|
|
|
case IO_WREOR: /* write eor */
|
|
break;
|
|
|
|
case IO_EOM1: /* EOM mode 1*/
|
|
case IO_READ: /* read */
|
|
CRETINS; /* error */
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Unit service */
|
|
|
|
t_stat ptp_svc (UNIT *uptr)
|
|
{
|
|
int32 i;
|
|
t_stat r = SCPE_OK;
|
|
|
|
if (ptp_ldr) { /* need leader? */
|
|
for (i = 0; i < 12; i++) { /* punch leader */
|
|
if ((r = ptp_out (0)))
|
|
break;
|
|
}
|
|
}
|
|
ptp_ldr = 0; /* clear flag */
|
|
chan_set_ordy (ptp_dib.chan); /* ptp ready */
|
|
return r;
|
|
}
|
|
|
|
/* Punch I/O */
|
|
|
|
t_stat ptp_out (int32 dat)
|
|
{
|
|
if ((ptp_unit.flags & UNIT_ATT) == 0) { /* attached? */
|
|
ptp_set_err (); /* no, disc, err */
|
|
CRETIOE (ptp_stopioe, SCPE_UNATT);
|
|
}
|
|
if (putc (dat, ptp_unit.fileref) == EOF) { /* I/O error? */
|
|
ptp_set_err (); /* yes, disc, err */
|
|
sim_perror ("PTP I/O error"); /* print msg */
|
|
clearerr (ptp_unit.fileref);
|
|
return SCPE_IOERR;
|
|
}
|
|
ptp_unit.pos = ptp_unit.pos + 1; /* inc position */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Fatal error */
|
|
|
|
void ptp_set_err (void)
|
|
{
|
|
chan_set_flag (ptp_dib.chan, CHF_ERR); /* error */
|
|
chan_disc (ptp_dib.chan); /* disconnect */
|
|
xfr_req = xfr_req & ~XFR_PTP; /* clear xfr */
|
|
sim_cancel (&ptp_unit); /* stop */
|
|
return;
|
|
}
|
|
|
|
/* Reset routine */
|
|
|
|
t_stat ptp_reset (DEVICE *dptr)
|
|
{
|
|
chan_disc (ptp_dib.chan); /* disconnect */
|
|
ptp_ldr = 0; /* clear state */
|
|
ptp_unit.buf = 0;
|
|
xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */
|
|
sim_cancel (&ptp_unit); /* deactivate unit */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Typewriter input
|
|
|
|
conn - inst = EOM0, dat = NULL
|
|
eom1 - inst = EOM1, dat = NULL
|
|
sks - inst = SKS, dat = ptr to result
|
|
disc - inst = device number, dat = NULL
|
|
wreor - inst = device number, dat = NULL
|
|
read - inst = device number, dat = ptr to data
|
|
write - inst = device number, dat = ptr to result
|
|
|
|
The typewriter input is an asynchronous input device. That is, it can
|
|
never cause a channel rate error; if no data is available, it waits.
|
|
*/
|
|
|
|
t_stat tti (uint32 fnc, uint32 inst, uint32 *dat)
|
|
{
|
|
int32 new_ch;
|
|
|
|
switch (fnc) { /* case function */
|
|
|
|
case IO_CONN: /* connect */
|
|
new_ch = I_GETEOCH (inst); /* get new chan */
|
|
if (new_ch != tti_dib.chan) /* inv conn? err */
|
|
return SCPE_IERR;
|
|
xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */
|
|
break;
|
|
|
|
case IO_DISC: /* disconnect */
|
|
xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */
|
|
break;
|
|
|
|
case IO_READ: /* read */
|
|
xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */
|
|
*dat = tti_unit.buf; /* get buf data */
|
|
break;
|
|
|
|
case IO_WREOR: /* write eor */
|
|
break;
|
|
|
|
case IO_EOM1: /* EOM mode 1*/
|
|
case IO_WRITE: /* write */
|
|
CRETINS; /* error */
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Unit service */
|
|
|
|
t_stat tti_svc (UNIT *uptr)
|
|
{
|
|
int32 temp;
|
|
|
|
sim_activate (&tti_unit, tti_unit.wait); /* continue poll */
|
|
if ((temp = sim_poll_kbd ()) < SCPE_KFLAG) /* no char or error? */
|
|
return temp;
|
|
if (temp & SCPE_BREAK) /* ignore break */
|
|
return SCPE_OK;
|
|
temp = temp & 0177;
|
|
tti_unit.pos = tti_unit.pos + 1;
|
|
if (ascii_to_sds (temp) >= 0) {
|
|
tti_unit.buf = ascii_to_sds(temp); /* internal rep */
|
|
sim_putchar (temp); /* echo */
|
|
if (temp == '\r') /* lf after cr */
|
|
sim_putchar ('\n');
|
|
xfr_req = xfr_req | XFR_TTI; /* set xfr flag */
|
|
}
|
|
else sim_putchar (007); /* ding! */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
t_stat tti_reset (DEVICE *dptr)
|
|
{
|
|
tmxr_set_console_units (&tti_unit, &tto_unit);
|
|
chan_disc (tti_dib.chan); /* disconnect */
|
|
tti_unit.buf = 0; /* clear state */
|
|
xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */
|
|
sim_activate (&tti_unit, tti_unit.wait); /* start poll */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Typewriter output
|
|
|
|
conn - inst = EOM0, dat = NULL
|
|
eom1 - inst = EOM1, dat = NULL
|
|
sks - inst = SKS, dat = ptr to result
|
|
disc - inst = device number, dat = NULL
|
|
wreor - inst = device number, dat = NULL
|
|
read - inst = device number, dat = ptr to data
|
|
write - inst = device number, dat = ptr to result
|
|
|
|
The typewriter output is an asynchronous streaming output device. That is,
|
|
it can never cause a channel rate error; if no data is available, it waits.
|
|
|
|
Typewriter output may be stalled, if the device is connected to a Telnet
|
|
connection, so the output routine must be able to try output repeatedly.
|
|
*/
|
|
|
|
t_stat tto (uint32 fnc, uint32 inst, uint32 *dat)
|
|
{
|
|
int32 new_ch;
|
|
|
|
switch (fnc) { /* case function */
|
|
|
|
case IO_CONN:
|
|
new_ch = I_GETEOCH (inst); /* get new chan */
|
|
if (new_ch != tto_dib.chan) /* inv conn? err */
|
|
return SCPE_IERR;
|
|
tto_ldr = (inst & CHC_NLDR)? 0: 1; /* leader? */
|
|
tto_retry = 0; /* no retry */
|
|
xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */
|
|
sim_activate (&tto_unit, tto_unit.wait); /* activate */
|
|
break;
|
|
|
|
case IO_DISC: /* disconnect */
|
|
tto_ldr = 0; /* clr state */
|
|
tto_retry = 0;
|
|
xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */
|
|
sim_cancel (&tto_unit); /* deactivate unit */
|
|
break;
|
|
|
|
case IO_WRITE: /* write */
|
|
xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */
|
|
tto_unit.buf = (*dat) & 077; /* save data */
|
|
sim_activate (&tto_unit, tto_unit.wait); /* activate */
|
|
return tto_out (tto_unit.buf); /* write the data */
|
|
|
|
case IO_WREOR: /* write eor */
|
|
break;
|
|
|
|
case IO_EOM1: /* EOM mode 1*/
|
|
case IO_READ: /* read */
|
|
CRETINS; /* error */
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Unit service - handle leader, retry */
|
|
|
|
t_stat tto_svc (UNIT *uptr)
|
|
{
|
|
if (tto_ldr != 0) { /* need leader? */
|
|
sim_putchar (0); /* output, no stall */
|
|
tto_ldr = 0; /* no more leader */
|
|
}
|
|
if (tto_retry != 0) /* retry? */
|
|
tto_out (uptr->buf); /* try again, could stall */
|
|
if (tto_retry == 0) /* now no retry? */
|
|
chan_set_ordy (tto_dib.chan); /* tto ready */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
t_stat tto_out (int32 dat)
|
|
{
|
|
int32 asc;
|
|
t_stat r;
|
|
|
|
tto_retry = 0; /* assume no retry */
|
|
if (dat == TT_CR) /* control chars? */
|
|
asc = '\r';
|
|
else if (dat == TT_BS)
|
|
asc = '\b';
|
|
else if (dat == TT_TB)
|
|
asc = '\t';
|
|
else asc = sds_to_ascii (dat); /* translate */
|
|
r = sim_putchar_s (asc); /* output */
|
|
if (r == SCPE_STALL) { /* stall? */
|
|
tto_retry = 1;
|
|
sim_activate (&tto_unit, tto_unit.wait); /* retry */
|
|
return SCPE_OK;
|
|
}
|
|
if (r != SCPE_OK) /* error? */
|
|
return r;
|
|
tto_unit.pos = tto_unit.pos + 1; /* inc position */
|
|
chan_set_ordy (tto_dib.chan); /* tto rdy */
|
|
if (asc == '\r') { /* CR? */
|
|
sim_putchar ('\n'); /* add lf, no stall */
|
|
tto_unit.pos = tto_unit.pos + 1; /* inc position */
|
|
}
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Reset routine */
|
|
|
|
t_stat tto_reset (DEVICE *dptr)
|
|
{
|
|
chan_disc (tto_dib.chan); /* disconnect */
|
|
tto_unit.buf = 0; /* clear state */
|
|
tto_ldr = 0;
|
|
tto_retry = 0;
|
|
xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */
|
|
sim_cancel (&tto_unit); /* deactivate unit */
|
|
return SCPE_OK;
|
|
}
|