/* id_ttp.c: Interdata PASLA console interface

   Copyright (c) 2000-2017, 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.

   ttp          console (on PAS)

   09-Mar-17    RMS     Fixed testing of 8b mode (COVERITY)
                        Fixed testing of echoed character (COVERITY)
   18-Apr-12    RMS     Revised to use clock coscheduling
   18-Jun-07    RMS     Added UNIT_IDLE flag to console input
   18-Oct-06    RMS     Sync keyboard to LFC clock
   22-Nov-05    RMS     Revised for new terminal processing routines
   29-Dec-03    RMS     Added support for console backpressure
   25-Apr-03    RMS     Revised for extended file support
*/

#include "id_defs.h"
#include <ctype.h>

#define TTI             0
#define TTO             1

/* Status byte */

#define STA_OVR         0x80                            /* overrun RO */
#define STA_PF          0x40                            /* parity err RO */
#define STA_FR          0x20                            /* framing err RO */
#define STA_RCV         (STA_OVR|STA_PF|STA_FR)
#define SET_EX          (STA_OVR|STA_PF|STA_FR)
#define STA_XMT         (STA_BSY)

/* Command bytes 1,0 */

#define CMD_ECHO        (0x10 << 8)                     /* echoplex */
#define CMD_WRT         (0x02 << 8)                     /* write/read */
#define CMD_TYP         0x01                            /* command type */

extern uint32 int_req[INTSZ], int_enb[INTSZ];
extern int32 pas_par (int32 cmd, int32 c);
extern int32 lfc_poll;

uint32 ttp_sta = 0;                                     /* status */
uint32 ttp_cmd = 0;                                     /* command */
uint32 ttp_kchp = 0;                                    /* rcvr chr pend */
uint32 ttp_karm = 0;                                    /* rcvr int armed */
uint32 ttp_tarm = 0;                                    /* xmt int armed */
uint8 ttp_tplte[] = { 0, 1, TPL_END };

uint32 ttp (uint32 dev, uint32 op, uint32 dat);
t_stat ttpi_svc (UNIT *uptr);
t_stat ttpo_svc (UNIT *uptr);
t_stat ttp_reset (DEVICE *dptr);
t_stat ttp_set_mode (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat ttp_set_break (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat ttp_set_enbdis (UNIT *uptr, int32 val, CONST char *cptr, void *desc);

/* TTP data structures */

DIB ttp_dib = { d_TTP, -1, v_TTP, ttp_tplte, &ttp, NULL };

UNIT ttp_unit[] = {
    { UDATA (&ttpi_svc, UNIT_IDLE, 0), KBD_POLL_WAIT },
    { UDATA (&ttpo_svc, 0, 0), SERIAL_OUT_WAIT }
    };

REG ttp_reg[] = {
    { HRDATA (CMD, ttp_cmd, 16) },
    { HRDATA (KBUF, ttp_unit[TTI].buf, 8) },
    { DRDATA (KPOS, ttp_unit[TTI].pos, T_ADDR_W), PV_LEFT },
    { DRDATA (KTIME, ttp_unit[TTI].wait, 24), REG_NZ + PV_LEFT + REG_HRO },
    { FLDATA (KIREQ, int_req[l_TTP], i_TTP) },
    { FLDATA (KIENB, int_enb[l_TTP], i_TTP) },
    { FLDATA (KARM, ttp_karm, 0) },
    { FLDATA (CHP, ttp_kchp, 0) },
    { HRDATA (TBUF, ttp_unit[TTO].buf, 8) },
    { DRDATA (TPOS, ttp_unit[TTO].pos, T_ADDR_W), PV_LEFT },
    { DRDATA (TTIME, ttp_unit[TTO].wait, 24), REG_NZ + PV_LEFT },
    { FLDATA (TIREQ, int_req[l_TTP], i_TTP + 1) },
    { FLDATA (TIENB, int_enb[l_TTP], i_TTP + 1) },
    { FLDATA (TARM, ttp_tarm, 0) },
    { HRDATA (DEVNO, ttp_dib.dno, 8), REG_HRO },
    { NULL }
    };

MTAB ttp_mod[] = {
    { TT_MODE, TT_MODE_UC, "UC", "UC", &ttp_set_mode },
    { TT_MODE, TT_MODE_7B, "7b", "7B", &ttp_set_mode },
    { TT_MODE, TT_MODE_8B, "8b", "8B", &ttp_set_mode },
    { TT_MODE, TT_MODE_7P, "7p", "7P", &ttp_set_mode },
    { MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, NULL, "ENABLED",
      &ttp_set_enbdis, NULL, NULL },
    { MTAB_XTD|MTAB_VDV|MTAB_NMO, DEV_DIS, NULL, "DISABLED",
      &ttp_set_enbdis, NULL, NULL },
    { MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, NULL, "BREAK",
      &ttp_set_break, NULL, NULL },
    { MTAB_XTD|MTAB_VDV, 0, "DEVNO", "DEVNO",
      &set_dev, &show_dev, NULL },
    { 0 }
    };

DEVICE ttp_dev = {
    "TTP", ttp_unit, ttp_reg, ttp_mod,
    2, 10, 31, 1, 16, 8,
    NULL, NULL, &ttp_reset,
    NULL, NULL, NULL,
    &ttp_dib, DEV_DIS
    };

/* Terminal: I/O routine */

uint32 ttp (uint32 dev, uint32 op, uint32 dat)
{
int32 xmt = dev & 1;
int32 t;

switch (op) {                                           /* case IO op */

    case IO_ADR:                                        /* select */
        return BY;                                      /* byte only */

    case IO_RD:                                         /* read */
        ttp_kchp = 0;                                   /* clr chr pend */
        ttp_sta = ttp_sta & ~STA_OVR;                   /* clr overrun */
        sim_activate_abs (&ttp_unit[TTI], ttp_unit[TTI].wait);
        return ttp_unit[TTI].buf;                       /* return buf */

    case IO_WD:                                         /* write */
        ttp_unit[TTO].buf = dat & 0xFF;                 /* store char */
        ttp_sta = ttp_sta | STA_BSY;                    /* set busy */
        sim_activate (&ttp_unit[TTO], ttp_unit[TTO].wait);
        break;

    case IO_SS:                                         /* status */
        if (xmt) t = ttp_sta & STA_XMT;                 /* xmt? just busy */
        else {                                          /* rcv */
            t = ttp_sta & STA_RCV;                      /* get static */
            if (!ttp_kchp)                              /* no char? busy */
                t = t | STA_BSY;
            if (t & SET_EX)                             /* test for ex */
                t = t | STA_EX;
            }
        return t;

    case IO_OC:                                         /* command */
        if (dat & CMD_TYP) {                            /* type 1? */
            ttp_cmd = (ttp_cmd & 0xFF) | (dat << 8);
            if (ttp_cmd & CMD_WRT)                      /* write? */
                ttp_tarm = int_chg (v_TTP + 1, dat, ttp_tarm);
            else ttp_karm = int_chg (v_TTP, dat, ttp_karm);
            }
        else ttp_cmd = (ttp_cmd & ~0xFF) | dat;
        break;
        }

return 0;
}

/* Unit service */

t_stat ttpi_svc (UNIT *uptr)
{
int32 c, out;

sim_activate (uptr, lfc_cosched (lfc_poll));            /* continue poll */
ttp_sta = ttp_sta & ~STA_FR;                            /* clear break */
if ((c = sim_poll_kbd ()) < SCPE_KFLAG)                 /* no char or error? */
    return c;
ttp_sta = ttp_sta & ~STA_PF;                            /* clear parity err */
if (ttp_kchp)                                           /* overrun? */
    ttp_sta = ttp_sta | STA_OVR;
if (ttp_karm)
    SET_INT (v_TTP);
if (c & SCPE_BREAK) {                                   /* break? */
    ttp_sta = ttp_sta | STA_FR;                         /* framing error */
    uptr->buf = 0;                                      /* no character */
    }
else {
    out = c & 0x7F;                                     /* echo is 7b */
    c = sim_tt_inpcvt (c, TT_GET_MODE (uptr->flags));
    if (TT_GET_MODE (uptr->flags) != TTUF_MODE_8B)      /* not 8b mode? */
        c = pas_par (ttp_cmd, c);                       /* apply parity */
    uptr->buf = c;                                      /* save char */
    uptr->pos = uptr->pos + 1;                          /* incr count */
    ttp_kchp = 1;                                       /* char pending */
    if (ttp_cmd & CMD_ECHO) {
        out = sim_tt_outcvt (out, TT_GET_MODE (uptr->flags));
        if (out >= 0)
            sim_putchar (out);
        ttp_unit[TTO].pos = ttp_unit[TTO].pos + 1;
        }
    }
return SCPE_OK;
}

t_stat ttpo_svc (UNIT *uptr)
{
int32 c;
t_stat r;

if (TT_GET_MODE (uptr->flags) == TTUF_MODE_8B)          /* 8b? */
    c = pas_par (ttp_cmd, uptr->buf);                   /* apply parity */
else c = sim_tt_outcvt (uptr->buf, TT_GET_MODE (uptr->flags));
if (c >= 0) {
    if ((r = sim_putchar_s (c)) != SCPE_OK) {           /* output; error? */
        sim_activate (uptr, uptr->wait);                /* try again */
        return ((r == SCPE_STALL)? SCPE_OK: r);
        }
    }
ttp_sta = ttp_sta & ~STA_BSY;                           /* not busy */
if (ttp_tarm)                                           /* set intr */
    SET_INT (v_TTP + 1);
uptr->pos = uptr->pos + 1;                              /* incr count */
return SCPE_OK;
}

/* Reset routine */

t_stat ttp_reset (DEVICE *dptr)
{
if (dptr->flags & DEV_DIS)
    sim_cancel (&ttp_unit[TTI]);
else sim_activate (&ttp_unit[TTI], lfc_poll);
sim_cancel (&ttp_unit[TTO]);
CLR_INT (v_TTP);                                        /* clear int */
CLR_ENB (v_TTP);
CLR_INT (v_TTP + 1);                                    /* disable int */
CLR_ENB (v_TTP + 1);
ttp_karm = ttp_tarm = 0;                                /* disarm int */
ttp_cmd = 0;
ttp_sta = 0;
ttp_kchp = 0;
return SCPE_OK;
}

/* Make mode flags uniform */

t_stat ttp_set_mode (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
ttp_unit[TTO].flags = (ttp_unit[TTO].flags & ~TT_MODE) | val;
if (val == TT_MODE_7P)
    val = TT_MODE_7B;
ttp_unit[TTI].flags = (ttp_unit[TTI].flags & ~TT_MODE) | val;
return SCPE_OK;
}

/* Set input break */

t_stat ttp_set_break (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
if (ttp_dev.flags & DEV_DIS)
    return SCPE_NOFNC;
ttp_sta = ttp_sta | STA_FR;
if (ttp_karm)                                           /* if armed, intr */
    SET_INT (v_TTP);
sim_cancel (&ttp_unit[TTI]);                            /* restart TT poll */
sim_activate (&ttp_unit[TTI], ttp_unit[TTI].wait);
return SCPE_OK;
}

/* Set enabled/disabled */

t_stat ttp_set_enbdis (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
extern DEVICE tt_dev;
extern t_stat tt_reset (DEVICE *dptr);

ttp_dev.flags = (ttp_dev.flags & ~DEV_DIS) | val;
tt_dev.flags = (tt_dev.flags & ~DEV_DIS) | (val ^ DEV_DIS);
ttp_reset (&ttp_dev);
tt_reset (&tt_dev);
return SCPE_OK;
}
