[simh.git] / SDS / sds_stddev.c

/* sds_stddev.c: SDS 940 standard devices\r
\r
   Copyright (c) 2001-2005, 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
   ptr          paper tape reader\r
   ptp          paper tape punch\r
   tti          keyboard\r
   tto          teleprinter\r
\r
   29-Dec-03    RMS     Added console backpressure support\r
   25-Apr-03    RMS     Revised for extended file support\r
*/\r
\r
#include "sds_defs.h"\r
\r
#define TT_CR           052                             /* typewriter */\r
#define TT_TB           072\r
#define TT_BS           032\r
\r
extern uint32 xfr_req;\r
extern int32 stop_invins, stop_invdev, stop_inviop;\r
int32 ptr_sor = 0;                                      /* start of rec */\r
int32 ptr_stopioe = 1;                                  /* stop on err */\r
int32 ptp_ldr = 0;                                      /* no leader */\r
int32 ptp_stopioe = 1;\r
DSPT std_tplt[] = { { 1, 0 }, { 0, 0 }  };              /* template */\r
\r
DEVICE ptr_dev, ptp_dev;\r
t_stat ptr (uint32 fnc, uint32 inst, uint32 *dat);\r
t_stat ptr_svc (UNIT *uptr);\r
t_stat ptr_reset (DEVICE *dptr);\r
t_stat ptr_boot (int32 unitno, DEVICE *dptr);\r
void ptr_set_err (void);\r
t_stat ptp (uint32 fnc, uint32 inst, uint32 *dat);\r
t_stat ptp_svc (UNIT *uptr);\r
t_stat ptp_reset (DEVICE *dptr);\r
t_stat ptp_out (int32 dat);\r
void ptp_set_err (void);\r
t_stat tti (uint32 fnc, uint32 inst, uint32 *dat);\r
t_stat tti_svc (UNIT *uptr);\r
t_stat tti_reset (DEVICE *dptr);\r
t_stat tto (uint32 fnc, uint32 inst, uint32 *dat);\r
t_stat tto_svc (UNIT *uptr);\r
t_stat tto_reset (DEVICE *dptr);\r
\r
extern const char ascii_to_sds[128];\r
extern const char sds_to_ascii[64];\r
extern const char odd_par[64];\r
\r
/* PTR data structures\r
\r
   ptr_dev      PTR device descriptor\r
   ptr_unit     PTR unit\r
   ptr_reg      PTR register list\r
*/\r
\r
DIB ptr_dib = { CHAN_W, DEV_PTR, XFR_PTR, std_tplt, &ptr };\r
\r
UNIT ptr_unit = {\r
    UDATA (&ptr_svc, UNIT_SEQ+UNIT_ATTABLE+UNIT_ROABLE, 0),\r
           SERIAL_IN_WAIT\r
    };\r
\r
REG ptr_reg[] = {\r
    { ORDATA (BUF, ptr_unit.buf, 7) },\r
    { FLDATA (XFR, xfr_req, XFR_V_PTR) },\r
    { FLDATA (SOR, ptr_sor, 0) },\r
    { DRDATA (POS, ptr_unit.pos, T_ADDR_W), PV_LEFT },\r
    { DRDATA (TIME, ptr_unit.wait, 24), REG_NZ + PV_LEFT },\r
    { FLDATA (STOP_IOE, ptr_stopioe, 0) },\r
    { NULL }\r
    };\r
\r
MTAB ptr_mod[] = {\r
    { MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
      &set_chan, &show_chan, NULL },\r
    { 0 }\r
    };\r
\r
DEVICE ptr_dev = {\r
    "PTR", &ptr_unit, ptr_reg, ptr_mod,\r
    1, 10, 31, 1, 8, 8,\r
    NULL, NULL, &ptr_reset,\r
    &ptr_boot, NULL, NULL,\r
    &ptr_dib, DEV_DISABLE\r
    };\r
\r
/* PTP data structures\r
\r
   ptp_dev      PTP device descriptor\r
   ptp_unit     PTP unit\r
   ptp_reg      PTP register list\r
*/\r
\r
DIB ptp_dib = { CHAN_W, DEV_PTP, XFR_PTP, std_tplt, &ptp };\r
\r
UNIT ptp_unit = {\r
    UDATA (&ptp_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_OUT_WAIT\r
    };\r
\r
REG ptp_reg[] = {\r
    { ORDATA (BUF, ptp_unit.buf, 7) },\r
    { FLDATA (XFR, xfr_req, XFR_V_PTP) },\r
    { FLDATA (LDR, ptp_ldr, 0) },\r
    { DRDATA (POS, ptp_unit.pos, T_ADDR_W), PV_LEFT },\r
    { DRDATA (TIME, ptp_unit.wait, 24), REG_NZ + PV_LEFT },\r
    { FLDATA (STOP_IOE, ptp_stopioe, 0) },\r
    { NULL }\r
    };\r
\r
MTAB ptp_mod[] = {\r
    { MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
      &set_chan, &show_chan, NULL },\r
    { 0 }\r
    };\r
\r
DEVICE ptp_dev = {\r
    "PTP", &ptp_unit, ptp_reg, ptp_mod,\r
    1, 10, 31, 1, 8, 8,\r
    NULL, NULL, &ptp_reset,\r
    NULL, NULL, NULL,\r
    &ptp_dib, DEV_DISABLE\r
    };\r
\r
/* TTI data structures\r
\r
   tti_dev      TTI device descriptor\r
   tti_unit     TTI unit\r
   tti_reg      TTI register list\r
*/\r
\r
DIB tti_dib = { CHAN_W, DEV_TTI, XFR_TTI, std_tplt, &tti };\r
\r
UNIT tti_unit = { UDATA (&tti_svc, 0, 0), KBD_POLL_WAIT };\r
\r
REG tti_reg[] = {\r
    { ORDATA (BUF, tti_unit.buf, 6) },\r
    { FLDATA (XFR, xfr_req, XFR_V_TTI) },\r
    { DRDATA (POS, tti_unit.pos, T_ADDR_W), PV_LEFT },\r
    { DRDATA (TIME, tti_unit.wait, 24), REG_NZ + PV_LEFT },\r
    { NULL }\r
    };\r
\r
MTAB tti_mod[] = {\r
    { MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
      &set_chan, &show_chan, &tti_dib },\r
    { 0 }\r
    };\r
\r
DEVICE tti_dev = {\r
    "TTI", &tti_unit, tti_reg, tti_mod,\r
    1, 10, 31, 1, 8, 8,\r
    NULL, NULL, &tti_reset,\r
    NULL, NULL, NULL,\r
    &tti_dib, 0\r
    };\r
\r
/* TTO data structures\r
\r
   tto_dev      TTO device descriptor\r
   tto_unit     TTO unit\r
   tto_reg      TTO register list\r
*/\r
\r
DIB tto_dib = { CHAN_W, DEV_TTO, XFR_TTO, std_tplt, &tto };\r
\r
UNIT tto_unit = { UDATA (&tto_svc, 0, 0), SERIAL_OUT_WAIT };\r
\r
REG tto_reg[] = {\r
    { ORDATA (BUF, tto_unit.buf, 6) },\r
    { FLDATA (XFR, xfr_req, XFR_V_TTO) },\r
    { DRDATA (POS, tto_unit.pos, T_ADDR_W), PV_LEFT },\r
    { DRDATA (TIME, tto_unit.wait, 24), REG_NZ + PV_LEFT },\r
    { NULL }\r
    };\r
\r
MTAB tto_mod[] = {\r
    { MTAB_XTD|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
      &set_chan, &show_chan, &tto_dib },\r
    { 0 }\r
    };\r
\r
DEVICE tto_dev = {\r
    "TTO", &tto_unit, tto_reg, tto_mod,\r
    1, 10, 31, 1, 8, 8,\r
    NULL, NULL, &tto_reset,\r
    NULL, NULL, NULL,\r
    &tto_dib, 0\r
    };\r
\r
/* Paper tape reader\r
\r
   conn -       inst = EOM0, dat = NULL\r
   eom1 -       inst = EOM1, dat = NULL\r
   sks -        inst = SKS, dat = ptr to result\r
   disc -       inst = device number, dat = NULL\r
   wreor -      inst = device number, dat = NULL\r
   read -       inst = device number, dat = ptr to data\r
   write -      inst = device number, dat = ptr to result\r
\r
   The paper tape reader is a streaming input device.  Once started, it\r
   continues to read until disconnected.  Leader before the current record\r
   is ignored; leader after the current record sets channel EndOfRecord.\r
*/\r
\r
t_stat ptr (uint32 fnc, uint32 inst, uint32 *dat)\r
{\r
int32 new_ch;\r
\r
switch (fnc) {                                          /* case function */\r
\r
    case IO_CONN:                                       /* connect */\r
        new_ch = I_GETEOCH (inst);                      /* get new chan */\r
        if (new_ch != ptr_dib.chan) return SCPE_IERR;   /* inv conn? err */\r
        ptr_sor = 1;                                    /* start of rec */\r
        xfr_req = xfr_req & ~XFR_PTR;                   /* clr xfr flag */\r
        sim_activate (&ptr_unit, ptr_unit.wait);        /* activate */\r
        break;\r
\r
    case IO_DISC:                                       /* disconnect */\r
        ptr_sor = 0;                                    /* clear state */\r
        xfr_req = xfr_req & ~XFR_PTR;                   /* clr xfr flag */\r
        sim_cancel (&ptr_unit);                         /* deactivate unit */\r
        break;\r
\r
    case IO_READ:                                       /* read */\r
        xfr_req = xfr_req & ~XFR_PTR;                   /* clr xfr flag */\r
        *dat = ptr_unit.buf & 077;                      /* get buf data */\r
        if (ptr_unit.buf != odd_par[*dat])              /* good parity? */\r
            chan_set_flag (ptr_dib.chan, CHF_ERR);      /* no, error */\r
        break;\r
\r
    case IO_WREOR:                                      /* write eor */\r
        break;\r
\r
    case IO_EOM1:                                       /* EOM mode 1*/\r
    case IO_WRITE:                                      /* write */\r
        CRETINS;                                        /* error */\r
        }\r
\r
return SCPE_OK;\r
}\r
\r
/* Unit service */\r
\r
t_stat ptr_svc (UNIT *uptr)\r
{\r
int32 temp;\r
\r
if ((ptr_unit.flags & UNIT_ATT) == 0) {                 /* attached? */\r
    ptr_set_err ();                                     /* no, err, disc */\r
    CRETIOE (ptr_stopioe, SCPE_UNATT);\r
    }\r
if ((temp = getc (ptr_unit.fileref)) == EOF) {          /* end of file? */\r
    ptr_set_err ();                                     /* yes, err, disc */\r
    if (feof (ptr_unit.fileref)) {                      /* end of file? */\r
        if (ptr_stopioe) printf ("PTR end of file\n");\r
        else return SCPE_OK;\r
        }\r
    else perror ("PTR I/O error");                      /* I/O error */\r
    clearerr (ptr_unit.fileref);\r
    return SCPE_IOERR;\r
    }\r
ptr_unit.pos = ptr_unit.pos + 1;                        /* inc position */\r
if (temp) {                                             /* leader/gap? */\r
    ptr_unit.buf = temp & 0177;                         /* no, save char */\r
    xfr_req = xfr_req | XFR_PTR;                        /* set xfr flag */\r
    ptr_sor = 0;                                        /* in record */\r
    }\r
else if (!ptr_sor)                                      /* end record? */\r
    chan_set_flag (ptr_dib.chan, CHF_EOR);              /* ignore leader */\r
sim_activate (&ptr_unit, ptr_unit.wait);                /* get next char */\r
return SCPE_OK;\r
}\r
\r
/* Fatal error */\r
\r
void ptr_set_err (void)\r
{\r
chan_set_flag (ptr_dib.chan, CHF_EOR | CHF_ERR);        /* eor, error */\r
chan_disc (ptr_dib.chan);                               /* disconnect */\r
xfr_req = xfr_req & ~XFR_PTR;                           /* clear xfr */\r
sim_cancel (&ptr_unit);                                 /* stop */\r
return;\r
}\r
\r
/* Reset routine */\r
\r
t_stat ptr_reset (DEVICE *dptr)\r
{\r
chan_disc (ptr_dib.chan);                               /* disconnect */\r
ptr_sor = 0;                                            /* clear state */\r
ptr_unit.buf = 0;\r
xfr_req = xfr_req & ~XFR_PTR;                           /* clr xfr flag */\r
sim_cancel (&ptr_unit);                                 /* deactivate unit */\r
return SCPE_OK;\r
}\r
\r
/* Boot routine - simulate FILL console command */\r
\r
t_stat ptr_boot (int32 unitno, DEVICE *dptr)\r
{\r
extern uint32 P, M[];\r
\r
M[0] = 077777771;                                       /* -7B */\r
M[1] = 007100000;                                       /* LDX 0 */\r
M[2] = 000203604;                                       /* EOM 3604B */\r
M[3] = 003200002;                                       /* WIM 2 */\r
M[4] = 000100002;                                       /* BRU 2 */\r
P = 1;                                                  /* start at 1 */\r
return SCPE_OK;\r
}\r
\r
/* Paper tape punch\r
\r
   conn -       inst = EOM0, dat = NULL\r
   eom1 -       inst = EOM1, dat = NULL\r
   sks -        inst = SKS, dat = ptr to result\r
   disc -       inst = device number, dat = NULL\r
   wreor -      inst = device number, dat = NULL\r
   read -       inst = device number, dat = ptr to data\r
   write -      inst = device number, dat = ptr to result\r
\r
   The paper tape punch is an asynchronous streaming output device.  That is,\r
   it can never cause a channel rate error; if no data is available, it waits.\r
*/\r
\r
t_stat ptp (uint32 fnc, uint32 inst, uint32 *dat)\r
{\r
int32 new_ch;\r
\r
switch (fnc) {                                          /* case function */\r
\r
    case IO_CONN:\r
        new_ch = I_GETEOCH (inst);                      /* get new chan */\r
        if (new_ch != ptp_dib.chan) return SCPE_IERR;   /* inv conn? err */\r
        ptp_ldr = (inst & CHC_NLDR)? 0: 1;              /* leader? */\r
        xfr_req = xfr_req & ~XFR_PTP;                   /* clr xfr flag */\r
        sim_activate (&ptp_unit, ptp_unit.wait);        /* activate */\r
        break;\r
\r
    case IO_DISC:                                       /* disconnect */\r
        ptp_ldr = 0;                                    /* clear state */\r
        xfr_req = xfr_req & ~XFR_PTP;                   /* clr xfr flag */\r
        sim_cancel (&ptp_unit);                         /* deactivate unit */\r
        break;\r
\r
    case IO_WRITE:                                      /* write */\r
        xfr_req = xfr_req & ~XFR_PTP;                   /* clr xfr flag */\r
        sim_activate (&ptp_unit, ptp_unit.wait);        /* activate */\r
        ptp_unit.buf = odd_par[(*dat) & 077];           /* save data */\r
        return ptp_out (ptp_unit.buf);                  /* punch w/ par */\r
\r
    case IO_WREOR:                                      /* write eor */\r
        break;\r
\r
    case IO_EOM1:                                       /* EOM mode 1*/\r
    case IO_READ:                                       /* read */\r
        CRETINS;                                        /* error */\r
        }\r
\r
return SCPE_OK;\r
}\r
\r
/* Unit service */\r
\r
t_stat ptp_svc (UNIT *uptr)\r
{\r
int32 i;\r
t_stat r = SCPE_OK;\r
\r
if (ptp_ldr) {                                          /* need leader? */\r
    for (i = 0; i < 12; i++) {                          /* punch leader */\r
        if (r = ptp_out (0)) break;\r
        }\r
    }\r
ptp_ldr = 0;                                            /* clear flag */\r
chan_set_ordy (ptp_dib.chan);                           /* ptp ready */\r
return r;\r
}\r
\r
/* Punch I/O */\r
\r
t_stat ptp_out (int32 dat)\r
{\r
if ((ptp_unit.flags & UNIT_ATT) == 0) {                 /* attached? */\r
    ptp_set_err ();                                     /* no, disc, err */\r
    CRETIOE (ptp_stopioe, SCPE_UNATT);\r
    }\r
if (putc (dat, ptp_unit.fileref) == EOF) {              /* I/O error? */\r
    ptp_set_err ();                                     /* yes, disc, err */\r
    perror ("PTP I/O error");                           /* print msg */\r
    clearerr (ptp_unit.fileref);\r
    return SCPE_IOERR;\r
    }\r
ptp_unit.pos = ptp_unit.pos + 1;                        /* inc position */\r
return SCPE_OK;\r
}\r
\r
/* Fatal error */\r
\r
void ptp_set_err (void)\r
{\r
chan_set_flag (ptp_dib.chan, CHF_ERR);                  /* error */\r
chan_disc (ptp_dib.chan);                               /* disconnect */\r
xfr_req = xfr_req & ~XFR_PTP;                           /* clear xfr */\r
sim_cancel (&ptp_unit);                                 /* stop */\r
return;\r
}\r
\r
/* Reset routine */\r
\r
t_stat ptp_reset (DEVICE *dptr)\r
{\r
chan_disc (ptp_dib.chan);                               /* disconnect */\r
ptp_ldr = 0;                                            /* clear state */\r
ptp_unit.buf = 0;\r
xfr_req = xfr_req & ~XFR_PTP;                           /* clr xfr flag */\r
sim_cancel (&ptp_unit);                                 /* deactivate unit */\r
return SCPE_OK;\r
}\r
\r
/* Typewriter input\r
\r
   conn -       inst = EOM0, dat = NULL\r
   eom1 -       inst = EOM1, dat = NULL\r
   sks -        inst = SKS, dat = ptr to result\r
   disc -       inst = device number, dat = NULL\r
   wreor -      inst = device number, dat = NULL\r
   read -       inst = device number, dat = ptr to data\r
   write -      inst = device number, dat = ptr to result\r
\r
   The typewriter input is an asynchronous input device.  That is, it can\r
   never cause a channel rate error; if no data is available, it waits.\r
*/\r
\r
t_stat tti (uint32 fnc, uint32 inst, uint32 *dat)\r
{\r
int32 new_ch;\r
\r
switch (fnc) {                                          /* case function */\r
\r
    case IO_CONN:                                       /* connect */\r
        new_ch = I_GETEOCH (inst);                      /* get new chan */\r
        if (new_ch != tti_dib.chan) return SCPE_IERR;   /* inv conn? err */\r
        xfr_req = xfr_req & ~XFR_TTI;                   /* clr xfr flag */\r
        break;\r
\r
    case IO_DISC:                                       /* disconnect */\r
        xfr_req = xfr_req & ~XFR_TTI;                   /* clr xfr flag */\r
        break;\r
\r
    case IO_READ:                                       /* read */\r
        xfr_req = xfr_req & ~XFR_TTI;                   /* clr xfr flag */\r
        *dat = tti_unit.buf;                            /* get buf data */\r
        break;\r
\r
    case IO_WREOR:                                      /* write eor */\r
        break;\r
\r
    case IO_EOM1:                                       /* EOM mode 1*/\r
    case IO_WRITE:                                      /* write */\r
        CRETINS;                                        /* error */\r
        }\r
\r
return SCPE_OK;\r
}\r
\r
/* Unit service */\r
\r
t_stat tti_svc (UNIT *uptr)\r
{\r
int32 temp;\r
\r
sim_activate (&tti_unit, tti_unit.wait);                /* continue poll */\r
if ((temp = sim_poll_kbd ()) < SCPE_KFLAG) return temp; /* no char or error? */\r
if (temp & SCPE_BREAK) return SCPE_OK;                  /* ignore break */\r
temp = temp & 0177;\r
tti_unit.pos = tti_unit.pos + 1;\r
if (ascii_to_sds[temp] >= 0) {\r
    tti_unit.buf = ascii_to_sds[temp];                  /* internal rep */\r
    sim_putchar (temp);                                 /* echo */\r
    if (temp == '\r') sim_putchar ('\n');               /* lf after cr */\r
    xfr_req = xfr_req | XFR_TTI;                        /* set xfr flag */\r
    }\r
else sim_putchar (007);                                 /* ding! */\r
return SCPE_OK;\r
}\r
\r
t_stat tti_reset (DEVICE *dptr)\r
{\r
chan_disc (tti_dib.chan);                               /* disconnect */\r
tti_unit.buf = 0;                                       /* clear state */\r
xfr_req = xfr_req & ~XFR_TTI;                           /* clr xfr flag */\r
sim_activate (&tti_unit, tti_unit.wait);                /* start poll */\r
return SCPE_OK;\r
}\r
\r
/* Typewriter output\r
\r
   conn -       inst = EOM0, dat = NULL\r
   eom1 -       inst = EOM1, dat = NULL\r
   sks -        inst = SKS, dat = ptr to result\r
   disc -       inst = device number, dat = NULL\r
   wreor -      inst = device number, dat = NULL\r
   read -       inst = device number, dat = ptr to data\r
   write -      inst = device number, dat = ptr to result\r
\r
   The typewriter output is an asynchronous streaming output device.  That is,\r
   it can never cause a channel rate error; if no data is available, it waits.\r
*/\r
\r
t_stat tto (uint32 fnc, uint32 inst, uint32 *dat)\r
{\r
int32 new_ch;\r
\r
switch (fnc) {                                          /* case function */\r
\r
    case IO_CONN:\r
        new_ch = I_GETEOCH (inst);                      /* get new chan */\r
        if (new_ch != tto_dib.chan) return SCPE_IERR;   /* inv conn? err */\r
        xfr_req = xfr_req & ~XFR_TTO;                   /* clr xfr flag */\r
        sim_activate (&tto_unit, tto_unit.wait);        /* activate */\r
        break;\r
\r
    case IO_DISC:                                       /* disconnect */\r
        xfr_req = xfr_req & ~XFR_TTO;                   /* clr xfr flag */\r
        sim_cancel (&tto_unit);                         /* deactivate unit */\r
        break;\r
\r
    case IO_WRITE:                                      /* write */\r
        xfr_req = xfr_req & ~XFR_TTO;                   /* clr xfr flag */\r
        tto_unit.buf = (*dat) & 077;                    /* save data */\r
        sim_activate (&tto_unit, tto_unit.wait);        /* activate */\r
        break;\r
\r
    case IO_WREOR:                                      /* write eor */\r
        break;\r
    \r
    case IO_EOM1:                                       /* EOM mode 1*/\r
    case IO_READ:                                       /* read */\r
        CRETINS;                                        /* error */\r
        }\r
\r
return SCPE_OK;\r
}\r
\r
/* Unit service */\r
\r
t_stat tto_svc (UNIT *uptr)\r
{\r
int32 asc;\r
t_stat r;\r
\r
if (uptr->buf == TT_CR) asc = '\r';                     /* control chars? */\r
else if (uptr->buf == TT_BS) asc = '\b';\r
else if (uptr->buf == TT_TB) asc = '\t';\r
else asc = sds_to_ascii[uptr->buf];                     /* translate */\r
if ((r = sim_putchar_s (asc)) != SCPE_OK) {             /* output; error? */\r
    sim_activate (uptr, uptr->wait);                    /* retry */\r
    return ((r == SCPE_STALL)? SCPE_OK: r);             /* !stall? report */\r
    }\r
uptr->pos = uptr->pos + 1;                              /* inc position */\r
chan_set_ordy (tto_dib.chan);                           /* tto rdy */\r
if (asc == '\r') {                                      /* CR? */\r
    sim_putchar ('\n');                                 /* add lf */\r
    uptr->pos = uptr->pos + 1;                          /* inc position */\r
    }\r
return SCPE_OK;\r
}\r
\r
/* Reset routine */\r
\r
t_stat tto_reset (DEVICE *dptr)\r
{\r
chan_disc (tto_dib.chan);                               /* disconnect */\r
tto_unit.buf = 0;                                       /* clear state */\r
xfr_req = xfr_req & ~XFR_TTO;                           /* clr xfr flag */\r
sim_cancel (&tto_unit);                                 /* deactivate unit */\r
return SCPE_OK;\r
}\r
Commit	Line	Data
196ba1fc PH	1	/* sds_stddev.c: SDS 940 standard devices\r
	2	\r
	3	Copyright (c) 2001-2005, 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	ptr paper tape reader\r
	27	ptp paper tape punch\r
	28	tti keyboard\r
	29	tto teleprinter\r
	30	\r
	31	29-Dec-03 RMS Added console backpressure support\r
	32	25-Apr-03 RMS Revised for extended file support\r
	33	*/\r
	34	\r
	35	#include "sds_defs.h"\r
	36	\r
	37	#define TT_CR 052 /* typewriter */\r
	38	#define TT_TB 072\r
	39	#define TT_BS 032\r
	40	\r
	41	extern uint32 xfr_req;\r
	42	extern int32 stop_invins, stop_invdev, stop_inviop;\r
	43	int32 ptr_sor = 0; /* start of rec */\r
	44	int32 ptr_stopioe = 1; /* stop on err */\r
	45	int32 ptp_ldr = 0; /* no leader */\r
	46	int32 ptp_stopioe = 1;\r
	47	DSPT std_tplt[] = { { 1, 0 }, { 0, 0 } }; /* template */\r
	48	\r
	49	DEVICE ptr_dev, ptp_dev;\r
	50	t_stat ptr (uint32 fnc, uint32 inst, uint32 *dat);\r
	51	t_stat ptr_svc (UNIT *uptr);\r
	52	t_stat ptr_reset (DEVICE *dptr);\r
	53	t_stat ptr_boot (int32 unitno, DEVICE *dptr);\r
	54	void ptr_set_err (void);\r
	55	t_stat ptp (uint32 fnc, uint32 inst, uint32 *dat);\r
	56	t_stat ptp_svc (UNIT *uptr);\r
	57	t_stat ptp_reset (DEVICE *dptr);\r
	58	t_stat ptp_out (int32 dat);\r
	59	void ptp_set_err (void);\r
	60	t_stat tti (uint32 fnc, uint32 inst, uint32 *dat);\r
	61	t_stat tti_svc (UNIT *uptr);\r
	62	t_stat tti_reset (DEVICE *dptr);\r
	63	t_stat tto (uint32 fnc, uint32 inst, uint32 *dat);\r
	64	t_stat tto_svc (UNIT *uptr);\r
65	t_stat tto_reset (DEVICE *dptr);\r
66	\r
67	extern const char ascii_to_sds[128];\r
68	extern const char sds_to_ascii[64];\r
69	extern const char odd_par[64];\r
70	\r
71	/* PTR data structures\r
72	\r
73	ptr_dev PTR device descriptor\r
74	ptr_unit PTR unit\r
75	ptr_reg PTR register list\r
76	*/\r
77	\r
78	DIB ptr_dib = { CHAN_W, DEV_PTR, XFR_PTR, std_tplt, &ptr };\r
79	\r
80	UNIT ptr_unit = {\r
81	UDATA (&ptr_svc, UNIT_SEQ+UNIT_ATTABLE+UNIT_ROABLE, 0),\r
82	SERIAL_IN_WAIT\r
83	};\r
84	\r
85	REG ptr_reg[] = {\r
86	{ ORDATA (BUF, ptr_unit.buf, 7) },\r
87	{ FLDATA (XFR, xfr_req, XFR_V_PTR) },\r
88	{ FLDATA (SOR, ptr_sor, 0) },\r
89	{ DRDATA (POS, ptr_unit.pos, T_ADDR_W), PV_LEFT },\r
90	{ DRDATA (TIME, ptr_unit.wait, 24), REG_NZ + PV_LEFT },\r
91	{ FLDATA (STOP_IOE, ptr_stopioe, 0) },\r
92	{ NULL }\r
93	};\r
94	\r
95	MTAB ptr_mod[] = {\r
96	{ MTAB_XTD\|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
97	&set_chan, &show_chan, NULL },\r
98	{ 0 }\r
99	};\r
100	\r
101	DEVICE ptr_dev = {\r
102	"PTR", &ptr_unit, ptr_reg, ptr_mod,\r
103	1, 10, 31, 1, 8, 8,\r
104	NULL, NULL, &ptr_reset,\r
105	&ptr_boot, NULL, NULL,\r
106	&ptr_dib, DEV_DISABLE\r
107	};\r
108	\r
109	/* PTP data structures\r
110	\r
111	ptp_dev PTP device descriptor\r
112	ptp_unit PTP unit\r
113	ptp_reg PTP register list\r
114	*/\r
115	\r
116	DIB ptp_dib = { CHAN_W, DEV_PTP, XFR_PTP, std_tplt, &ptp };\r
117	\r
118	UNIT ptp_unit = {\r
119	UDATA (&ptp_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_OUT_WAIT\r
120	};\r
121	\r
122	REG ptp_reg[] = {\r
123	{ ORDATA (BUF, ptp_unit.buf, 7) },\r
124	{ FLDATA (XFR, xfr_req, XFR_V_PTP) },\r
125	{ FLDATA (LDR, ptp_ldr, 0) },\r
126	{ DRDATA (POS, ptp_unit.pos, T_ADDR_W), PV_LEFT },\r
127	{ DRDATA (TIME, ptp_unit.wait, 24), REG_NZ + PV_LEFT },\r
128	{ FLDATA (STOP_IOE, ptp_stopioe, 0) },\r
129	{ NULL }\r
130	};\r
131	\r
132	MTAB ptp_mod[] = {\r
133	{ MTAB_XTD\|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
134	&set_chan, &show_chan, NULL },\r
135	{ 0 }\r
136	};\r
137	\r
138	DEVICE ptp_dev = {\r
139	"PTP", &ptp_unit, ptp_reg, ptp_mod,\r
140	1, 10, 31, 1, 8, 8,\r
141	NULL, NULL, &ptp_reset,\r
142	NULL, NULL, NULL,\r
143	&ptp_dib, DEV_DISABLE\r
144	};\r
145	\r
146	/* TTI data structures\r
147	\r
148	tti_dev TTI device descriptor\r
149	tti_unit TTI unit\r
150	tti_reg TTI register list\r
151	*/\r
152	\r
153	DIB tti_dib = { CHAN_W, DEV_TTI, XFR_TTI, std_tplt, &tti };\r
154	\r
155	UNIT tti_unit = { UDATA (&tti_svc, 0, 0), KBD_POLL_WAIT };\r
156	\r
157	REG tti_reg[] = {\r
158	{ ORDATA (BUF, tti_unit.buf, 6) },\r
159	{ FLDATA (XFR, xfr_req, XFR_V_TTI) },\r
160	{ DRDATA (POS, tti_unit.pos, T_ADDR_W), PV_LEFT },\r
161	{ DRDATA (TIME, tti_unit.wait, 24), REG_NZ + PV_LEFT },\r
162	{ NULL }\r
163	};\r
164	\r
165	MTAB tti_mod[] = {\r
166	{ MTAB_XTD\|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
167	&set_chan, &show_chan, &tti_dib },\r
168	{ 0 }\r
169	};\r
170	\r
171	DEVICE tti_dev = {\r
172	"TTI", &tti_unit, tti_reg, tti_mod,\r
173	1, 10, 31, 1, 8, 8,\r
174	NULL, NULL, &tti_reset,\r
175	NULL, NULL, NULL,\r
176	&tti_dib, 0\r
177	};\r
178	\r
179	/* TTO data structures\r
180	\r
181	tto_dev TTO device descriptor\r
182	tto_unit TTO unit\r
183	tto_reg TTO register list\r
184	*/\r
185	\r
186	DIB tto_dib = { CHAN_W, DEV_TTO, XFR_TTO, std_tplt, &tto };\r
187	\r
188	UNIT tto_unit = { UDATA (&tto_svc, 0, 0), SERIAL_OUT_WAIT };\r
189	\r
190	REG tto_reg[] = {\r
191	{ ORDATA (BUF, tto_unit.buf, 6) },\r
192	{ FLDATA (XFR, xfr_req, XFR_V_TTO) },\r
193	{ DRDATA (POS, tto_unit.pos, T_ADDR_W), PV_LEFT },\r
194	{ DRDATA (TIME, tto_unit.wait, 24), REG_NZ + PV_LEFT },\r
195	{ NULL }\r
196	};\r
197	\r
198	MTAB tto_mod[] = {\r
199	{ MTAB_XTD\|MTAB_VDV, 0, "CHANNEL", "CHANNEL",\r
200	&set_chan, &show_chan, &tto_dib },\r
201	{ 0 }\r
202	};\r
203	\r
204	DEVICE tto_dev = {\r
205	"TTO", &tto_unit, tto_reg, tto_mod,\r
206	1, 10, 31, 1, 8, 8,\r
207	NULL, NULL, &tto_reset,\r
208	NULL, NULL, NULL,\r
209	&tto_dib, 0\r
210	};\r
211	\r
212	/* Paper tape reader\r
213	\r
214	conn - inst = EOM0, dat = NULL\r
215	eom1 - inst = EOM1, dat = NULL\r
216	sks - inst = SKS, dat = ptr to result\r
217	disc - inst = device number, dat = NULL\r
218	wreor - inst = device number, dat = NULL\r
219	read - inst = device number, dat = ptr to data\r
220	write - inst = device number, dat = ptr to result\r
221	\r
222	The paper tape reader is a streaming input device. Once started, it\r
223	continues to read until disconnected. Leader before the current record\r
224	is ignored; leader after the current record sets channel EndOfRecord.\r
225	*/\r
226	\r
227	t_stat ptr (uint32 fnc, uint32 inst, uint32 *dat)\r
228	{\r
229	int32 new_ch;\r
230	\r
231	switch (fnc) { /* case function */\r
232	\r
233	case IO_CONN: /* connect */\r
234	new_ch = I_GETEOCH (inst); /* get new chan */\r
235	if (new_ch != ptr_dib.chan) return SCPE_IERR; /* inv conn? err */\r
236	ptr_sor = 1; /* start of rec */\r
237	xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */\r
238	sim_activate (&ptr_unit, ptr_unit.wait); /* activate */\r
239	break;\r
240	\r
241	case IO_DISC: /* disconnect */\r
242	ptr_sor = 0; /* clear state */\r
243	xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */\r
244	sim_cancel (&ptr_unit); /* deactivate unit */\r
245	break;\r
246	\r
247	case IO_READ: /* read */\r
248	xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */\r
249	dat = ptr_unit.buf & 077; / get buf data */\r
250	if (ptr_unit.buf != odd_par[dat]) / good parity? */\r
251	chan_set_flag (ptr_dib.chan, CHF_ERR); /* no, error */\r
252	break;\r
253	\r
254	case IO_WREOR: /* write eor */\r
255	break;\r
256	\r
257	case IO_EOM1: /* EOM mode 1*/\r
258	case IO_WRITE: /* write */\r
259	CRETINS; /* error */\r
260	}\r
261	\r
262	return SCPE_OK;\r
263	}\r
264	\r
265	/* Unit service */\r
266	\r
267	t_stat ptr_svc (UNIT *uptr)\r
268	{\r
269	int32 temp;\r
270	\r
271	if ((ptr_unit.flags & UNIT_ATT) == 0) { /* attached? */\r
272	ptr_set_err (); /* no, err, disc */\r
273	CRETIOE (ptr_stopioe, SCPE_UNATT);\r
274	}\r
275	if ((temp = getc (ptr_unit.fileref)) == EOF) { /* end of file? */\r
276	ptr_set_err (); /* yes, err, disc */\r
277	if (feof (ptr_unit.fileref)) { /* end of file? */\r
278	if (ptr_stopioe) printf ("PTR end of file\n");\r
279	else return SCPE_OK;\r
280	}\r
281	else perror ("PTR I/O error"); /* I/O error */\r
282	clearerr (ptr_unit.fileref);\r
283	return SCPE_IOERR;\r
284	}\r
285	ptr_unit.pos = ptr_unit.pos + 1; /* inc position */\r
286	if (temp) { /* leader/gap? */\r
287	ptr_unit.buf = temp & 0177; /* no, save char */\r
288	xfr_req = xfr_req \| XFR_PTR; /* set xfr flag */\r
289	ptr_sor = 0; /* in record */\r
290	}\r
291	else if (!ptr_sor) /* end record? */\r
292	chan_set_flag (ptr_dib.chan, CHF_EOR); /* ignore leader */\r
293	sim_activate (&ptr_unit, ptr_unit.wait); /* get next char */\r
294	return SCPE_OK;\r
295	}\r
296	\r
297	/* Fatal error */\r
298	\r
299	void ptr_set_err (void)\r
300	{\r
301	chan_set_flag (ptr_dib.chan, CHF_EOR \| CHF_ERR); /* eor, error */\r
302	chan_disc (ptr_dib.chan); /* disconnect */\r
303	xfr_req = xfr_req & ~XFR_PTR; /* clear xfr */\r
304	sim_cancel (&ptr_unit); /* stop */\r
305	return;\r
306	}\r
307	\r
308	/* Reset routine */\r
309	\r
310	t_stat ptr_reset (DEVICE *dptr)\r
311	{\r
312	chan_disc (ptr_dib.chan); /* disconnect */\r
313	ptr_sor = 0; /* clear state */\r
314	ptr_unit.buf = 0;\r
315	xfr_req = xfr_req & ~XFR_PTR; /* clr xfr flag */\r
316	sim_cancel (&ptr_unit); /* deactivate unit */\r
317	return SCPE_OK;\r
318	}\r
319	\r
320	/* Boot routine - simulate FILL console command */\r
321	\r
322	t_stat ptr_boot (int32 unitno, DEVICE *dptr)\r
323	{\r
324	extern uint32 P, M[];\r
325	\r
326	M[0] = 077777771; /* -7B */\r
327	M[1] = 007100000; /* LDX 0 */\r
328	M[2] = 000203604; /* EOM 3604B */\r
329	M[3] = 003200002; /* WIM 2 */\r
330	M[4] = 000100002; /* BRU 2 */\r
331	P = 1; /* start at 1 */\r
332	return SCPE_OK;\r
333	}\r
334	\r
335	/* Paper tape punch\r
336	\r
337	conn - inst = EOM0, dat = NULL\r
338	eom1 - inst = EOM1, dat = NULL\r
339	sks - inst = SKS, dat = ptr to result\r
340	disc - inst = device number, dat = NULL\r
341	wreor - inst = device number, dat = NULL\r
342	read - inst = device number, dat = ptr to data\r
343	write - inst = device number, dat = ptr to result\r
344	\r
345	The paper tape punch is an asynchronous streaming output device. That is,\r
346	it can never cause a channel rate error; if no data is available, it waits.\r
347	*/\r
348	\r
349	t_stat ptp (uint32 fnc, uint32 inst, uint32 *dat)\r
350	{\r
351	int32 new_ch;\r
352	\r
353	switch (fnc) { /* case function */\r
354	\r
355	case IO_CONN:\r
356	new_ch = I_GETEOCH (inst); /* get new chan */\r
357	if (new_ch != ptp_dib.chan) return SCPE_IERR; /* inv conn? err */\r
358	ptp_ldr = (inst & CHC_NLDR)? 0: 1; /* leader? */\r
359	xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */\r
360	sim_activate (&ptp_unit, ptp_unit.wait); /* activate */\r
361	break;\r
362	\r
363	case IO_DISC: /* disconnect */\r
364	ptp_ldr = 0; /* clear state */\r
365	xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */\r
366	sim_cancel (&ptp_unit); /* deactivate unit */\r
367	break;\r
368	\r
369	case IO_WRITE: /* write */\r
370	xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */\r
371	sim_activate (&ptp_unit, ptp_unit.wait); /* activate */\r
372	ptp_unit.buf = odd_par[(dat) & 077]; / save data */\r
373	return ptp_out (ptp_unit.buf); /* punch w/ par */\r
374	\r
375	case IO_WREOR: /* write eor */\r
376	break;\r
377	\r
378	case IO_EOM1: /* EOM mode 1*/\r
379	case IO_READ: /* read */\r
380	CRETINS; /* error */\r
381	}\r
382	\r
383	return SCPE_OK;\r
384	}\r
385	\r
386	/* Unit service */\r
387	\r
388	t_stat ptp_svc (UNIT *uptr)\r
389	{\r
390	int32 i;\r
391	t_stat r = SCPE_OK;\r
392	\r
393	if (ptp_ldr) { /* need leader? */\r
394	for (i = 0; i < 12; i++) { /* punch leader */\r
395	if (r = ptp_out (0)) break;\r
396	}\r
397	}\r
398	ptp_ldr = 0; /* clear flag */\r
399	chan_set_ordy (ptp_dib.chan); /* ptp ready */\r
400	return r;\r
401	}\r
402	\r
403	/* Punch I/O */\r
404	\r
405	t_stat ptp_out (int32 dat)\r
406	{\r
407	if ((ptp_unit.flags & UNIT_ATT) == 0) { /* attached? */\r
408	ptp_set_err (); /* no, disc, err */\r
409	CRETIOE (ptp_stopioe, SCPE_UNATT);\r
410	}\r
411	if (putc (dat, ptp_unit.fileref) == EOF) { /* I/O error? */\r
412	ptp_set_err (); /* yes, disc, err */\r
413	perror ("PTP I/O error"); /* print msg */\r
414	clearerr (ptp_unit.fileref);\r
415	return SCPE_IOERR;\r
416	}\r
417	ptp_unit.pos = ptp_unit.pos + 1; /* inc position */\r
418	return SCPE_OK;\r
419	}\r
420	\r
421	/* Fatal error */\r
422	\r
423	void ptp_set_err (void)\r
424	{\r
425	chan_set_flag (ptp_dib.chan, CHF_ERR); /* error */\r
426	chan_disc (ptp_dib.chan); /* disconnect */\r
427	xfr_req = xfr_req & ~XFR_PTP; /* clear xfr */\r
428	sim_cancel (&ptp_unit); /* stop */\r
429	return;\r
430	}\r
431	\r
432	/* Reset routine */\r
433	\r
434	t_stat ptp_reset (DEVICE *dptr)\r
435	{\r
436	chan_disc (ptp_dib.chan); /* disconnect */\r
437	ptp_ldr = 0; /* clear state */\r
438	ptp_unit.buf = 0;\r
439	xfr_req = xfr_req & ~XFR_PTP; /* clr xfr flag */\r
440	sim_cancel (&ptp_unit); /* deactivate unit */\r
441	return SCPE_OK;\r
442	}\r
443	\r
444	/* Typewriter input\r
445	\r
446	conn - inst = EOM0, dat = NULL\r
447	eom1 - inst = EOM1, dat = NULL\r
448	sks - inst = SKS, dat = ptr to result\r
449	disc - inst = device number, dat = NULL\r
450	wreor - inst = device number, dat = NULL\r
451	read - inst = device number, dat = ptr to data\r
452	write - inst = device number, dat = ptr to result\r
453	\r
454	The typewriter input is an asynchronous input device. That is, it can\r
455	never cause a channel rate error; if no data is available, it waits.\r
456	*/\r
457	\r
458	t_stat tti (uint32 fnc, uint32 inst, uint32 *dat)\r
459	{\r
460	int32 new_ch;\r
461	\r
462	switch (fnc) { /* case function */\r
463	\r
464	case IO_CONN: /* connect */\r
465	new_ch = I_GETEOCH (inst); /* get new chan */\r
466	if (new_ch != tti_dib.chan) return SCPE_IERR; /* inv conn? err */\r
467	xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */\r
468	break;\r
469	\r
470	case IO_DISC: /* disconnect */\r
471	xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */\r
472	break;\r
473	\r
474	case IO_READ: /* read */\r
475	xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */\r
476	dat = tti_unit.buf; / get buf data */\r
477	break;\r
478	\r
479	case IO_WREOR: /* write eor */\r
480	break;\r
481	\r
482	case IO_EOM1: /* EOM mode 1*/\r
483	case IO_WRITE: /* write */\r
484	CRETINS; /* error */\r
485	}\r
486	\r
487	return SCPE_OK;\r
488	}\r
489	\r
490	/* Unit service */\r
491	\r
492	t_stat tti_svc (UNIT *uptr)\r
493	{\r
494	int32 temp;\r
495	\r
496	sim_activate (&tti_unit, tti_unit.wait); /* continue poll */\r
497	if ((temp = sim_poll_kbd ()) < SCPE_KFLAG) return temp; /* no char or error? */\r
498	if (temp & SCPE_BREAK) return SCPE_OK; /* ignore break */\r
499	temp = temp & 0177;\r
500	tti_unit.pos = tti_unit.pos + 1;\r
501	if (ascii_to_sds[temp] >= 0) {\r
502	tti_unit.buf = ascii_to_sds[temp]; /* internal rep */\r
503	sim_putchar (temp); /* echo */\r
504	if (temp == '\r') sim_putchar ('\n'); /* lf after cr */\r
505	xfr_req = xfr_req \| XFR_TTI; /* set xfr flag */\r
506	}\r
507	else sim_putchar (007); /* ding! */\r
508	return SCPE_OK;\r
509	}\r
510	\r
511	t_stat tti_reset (DEVICE *dptr)\r
512	{\r
513	chan_disc (tti_dib.chan); /* disconnect */\r
514	tti_unit.buf = 0; /* clear state */\r
515	xfr_req = xfr_req & ~XFR_TTI; /* clr xfr flag */\r
516	sim_activate (&tti_unit, tti_unit.wait); /* start poll */\r
517	return SCPE_OK;\r
518	}\r
519	\r
520	/* Typewriter output\r
521	\r
522	conn - inst = EOM0, dat = NULL\r
523	eom1 - inst = EOM1, dat = NULL\r
524	sks - inst = SKS, dat = ptr to result\r
525	disc - inst = device number, dat = NULL\r
526	wreor - inst = device number, dat = NULL\r
527	read - inst = device number, dat = ptr to data\r
528	write - inst = device number, dat = ptr to result\r
529	\r
530	The typewriter output is an asynchronous streaming output device. That is,\r
531	it can never cause a channel rate error; if no data is available, it waits.\r
532	*/\r
533	\r
534	t_stat tto (uint32 fnc, uint32 inst, uint32 *dat)\r
535	{\r
536	int32 new_ch;\r
537	\r
538	switch (fnc) { /* case function */\r
539	\r
540	case IO_CONN:\r
541	new_ch = I_GETEOCH (inst); /* get new chan */\r
542	if (new_ch != tto_dib.chan) return SCPE_IERR; /* inv conn? err */\r
543	xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */\r
544	sim_activate (&tto_unit, tto_unit.wait); /* activate */\r
545	break;\r
546	\r
547	case IO_DISC: /* disconnect */\r
548	xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */\r
549	sim_cancel (&tto_unit); /* deactivate unit */\r
550	break;\r
551	\r
552	case IO_WRITE: /* write */\r
553	xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */\r
554	tto_unit.buf = (dat) & 077; / save data */\r
555	sim_activate (&tto_unit, tto_unit.wait); /* activate */\r
556	break;\r
557	\r
558	case IO_WREOR: /* write eor */\r
559	break;\r
560	\r
561	case IO_EOM1: /* EOM mode 1*/\r
562	case IO_READ: /* read */\r
563	CRETINS; /* error */\r
564	}\r
565	\r
566	return SCPE_OK;\r
567	}\r
568	\r
569	/* Unit service */\r
570	\r
571	t_stat tto_svc (UNIT *uptr)\r
572	{\r
573	int32 asc;\r
574	t_stat r;\r
575	\r
576	if (uptr->buf == TT_CR) asc = '\r'; /* control chars? */\r
577	else if (uptr->buf == TT_BS) asc = '\b';\r
578	else if (uptr->buf == TT_TB) asc = '\t';\r
579	else asc = sds_to_ascii[uptr->buf]; /* translate */\r
580	if ((r = sim_putchar_s (asc)) != SCPE_OK) { /* output; error? */\r
581	sim_activate (uptr, uptr->wait); /* retry */\r
582	return ((r == SCPE_STALL)? SCPE_OK: r); /* !stall? report */\r
583	}\r
584	uptr->pos = uptr->pos + 1; /* inc position */\r
585	chan_set_ordy (tto_dib.chan); /* tto rdy */\r
586	if (asc == '\r') { /* CR? */\r
587	sim_putchar ('\n'); /* add lf */\r
588	uptr->pos = uptr->pos + 1; /* inc position */\r
589	}\r
590	return SCPE_OK;\r
591	}\r
592	\r
593	/* Reset routine */\r
594	\r
595	t_stat tto_reset (DEVICE *dptr)\r
596	{\r
597	chan_disc (tto_dib.chan); /* disconnect */\r
598	tto_unit.buf = 0; /* clear state */\r
599	xfr_req = xfr_req & ~XFR_TTO; /* clr xfr flag */\r
600	sim_cancel (&tto_unit); /* deactivate unit */\r
601	return SCPE_OK;\r
602	}\r