/* 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;
}
