pdp6_dcs.c

/* pdp6_dcs.c: PDP-6 DC630 communication server simulator

   Copyright (c) 2011-2017, Richard Cornwell

   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
   RICHARD CORNWELL 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 Richard Cornwell shall not be
   used in advertising or otherwise to promote the sale, use or other dealings
   in this Software without prior written authorization from Richard Cornwell.

*/

#include "kx10_defs.h"
#include "sim_sock.h"
#include "sim_tmxr.h"

#ifndef NUM_DEVS_DCS
#define NUM_DEVS_DCS 0
#endif

#if (NUM_DEVS_DCS > 0)

#define DCS_DEVNUM 0300

#define DCS_LINES    16


#define STATUS   u3

#define RPI_CHN  000007         /* IN STATUS. */
#define TPI_CHN  000700         /* In STATUS */
#define RLS_SCN  000010         /* CONO DCSA release scanner */
#define RST_SCN  000020         /* CONO DCSA reset to 0 */
#define RSCN_ACT 000040         /* Scanner line is active */
#define XMT_RLS  004000         /* Clear transmitter flag */
#define XSCN_ACT 004000         /* Transmit scanner active */

#define DATA     0000377
#define LINE     0000077        /* Line number in Left */


int      dcs_rx_scan = 0;                        /* Scan counter */
int      dcs_tx_scan = 0;                        /* Scan counter */
int      dcs_send_line = 0;                      /* Send line number */
TMLN     dcs_ldsc[DCS_LINES] = { 0 };            /* Line descriptors */
TMXR     dcs_desc = { DCS_LINES, 0, 0, dcs_ldsc };
uint32   dcs_tx_enable, dcs_rx_rdy;              /* Flags */
uint32   dcs_enable;                             /* Enable line */
uint32   dcs_rx_conn;                            /* Connection flags */
extern int32 tmxr_poll;

t_stat dcs_devio(uint32 dev, uint64 *data);
t_stat dcs_svc (UNIT *uptr);
t_stat dcs_doscan (UNIT *uptr);
t_stat dcs_reset (DEVICE *dptr);
t_stat dcs_setnl (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat dcs_set_log (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat dcs_set_nolog (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat dcs_show_log (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat dcs_attach (UNIT *uptr, CONST char *cptr);
t_stat dcs_detach (UNIT *uptr);
t_stat dcs_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag,
        const char *cptr);
const char *dcs_description (DEVICE *dptr);

/* Type 630 data structures

   dcs_dev      Type 630 device descriptor
   dcs_unit     Type 630 unit descriptor
   dcs_reg      Type 630 register list
*/


#if !PDP6
#define D DEV_DIS
#else
#define D 0
#endif

DIB dcs_dib = { DCS_DEVNUM, 2, &dcs_devio, NULL };

UNIT dcs_unit = {
    UDATA (&dcs_svc, TT_MODE_7B+UNIT_IDLE+UNIT_ATTABLE, 0), KBD_POLL_WAIT
    };

REG dcs_reg[] = {
    { DRDATA (TIME, dcs_unit.wait, 24), REG_NZ + PV_LEFT },
    { DRDATA (STATUS, dcs_unit.STATUS, 18), PV_LEFT },
    { NULL }
    };

MTAB dcs_mod[] = {
    { TT_MODE, TT_MODE_KSR, "KSR", "KSR", NULL },
    { TT_MODE, TT_MODE_7B,  "7b",  "7B",  NULL },
    { TT_MODE, TT_MODE_8B,  "8b",  "8B",  NULL },
    { TT_MODE, TT_MODE_7P,  "7p",  "7P",  NULL },
    { MTAB_XTD|MTAB_VDV|MTAB_VALR, 1, NULL, "DISCONNECT",
        &tmxr_dscln, NULL, &dcs_desc, "Disconnect a specific line" },
    { UNIT_ATT, UNIT_ATT, "SUMMARY", NULL,
        NULL, &tmxr_show_summ, (void *) &dcs_desc, "Display a summary of line states" },
    { MTAB_XTD|MTAB_VDV|MTAB_NMO, 1, "CONNECTIONS", NULL,
        NULL, &tmxr_show_cstat, (void *) &dcs_desc, "Display current connections" },
    { MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, "STATISTICS", NULL,
        NULL, &tmxr_show_cstat, (void *) &dcs_desc, "Display multiplexer statistics" },
    { MTAB_XTD|MTAB_VDV|MTAB_VALR, 0, "LINES", "LINES=n",
        &dcs_setnl, &tmxr_show_lines, (void *) &dcs_desc, "Set number of lines" },
    { MTAB_XTD|MTAB_VDV|MTAB_NC, 0, NULL, "LOG=n=file",
        &dcs_set_log, NULL, (void *)&dcs_desc },
    { MTAB_XTD|MTAB_VDV|MTAB_VALR, 0, NULL, "NOLOG",
        &dcs_set_nolog, NULL, (void *)&dcs_desc, "Disable logging on designated line" },
    { MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, "LOG", NULL,
        NULL, &dcs_show_log, (void *)&dcs_desc, "Display logging for all lines" },
    { 0 }
    };

DEVICE dcs_dev = {
    "DCS", &dcs_unit, dcs_reg, dcs_mod,
    1, 10, 31, 1, 8, 8,
    &tmxr_ex, &tmxr_dep, &dcs_reset,
    NULL, &dcs_attach, &dcs_detach,
    &dcs_dib, DEV_MUX | DEV_DISABLE | DEV_DEBUG | D, 0, dev_debug,
    NULL, NULL, &dcs_help, NULL, NULL, &dcs_description
    };


/* IOT routine */
t_stat dcs_devio(uint32 dev, uint64 *data) {
    UNIT *uptr = &dcs_unit;
    TMLN *lp;
    int   ln;

    switch(dev & 7) {
    case CONI:
         /* Check if we might have any interrupts pending */
         if ((uptr->STATUS & (RSCN_ACT|XSCN_ACT)) != 0)
             dcs_doscan(uptr);
         *data = uptr->STATUS & (RPI_CHN|TPI_CHN);
         if ((uptr->STATUS & (RSCN_ACT)) == 0)
            *data |= 010LL;
         if ((uptr->STATUS & (XSCN_ACT)) == 0)
            *data |= 01000LL;
         sim_debug(DEBUG_CONI, &dcs_dev, "DCS %03o CONI %06o PC=%o\n",
               dev, (uint32)*data, PC);
         break;

    case CONO:
         /* Set PI */
         uptr->STATUS &= ~(RPI_CHN|TPI_CHN);
         uptr->STATUS |= (RPI_CHN|TPI_CHN) & *data;
         if (*data & RST_SCN)
             dcs_rx_scan = 0;
         if ((*data & (RLS_SCN|RST_SCN)) != 0)
             uptr->STATUS |= RSCN_ACT;
         if ((*data & (XMT_RLS)) != 0) {
             uptr->STATUS |= XSCN_ACT;
             dcs_tx_enable &= ~(1 << dcs_tx_scan);
         }

         sim_debug(DEBUG_CONO, &dcs_dev, "DCS %03o CONO %06o PC=%06o\n",
               dev, (uint32)*data, PC);
         dcs_doscan(uptr);
         break;

    case DATAO:
    case DATAO|4:
         ln = (dev & 4) ? dcs_send_line : dcs_tx_scan;
         if (ln < dcs_desc.lines) {
             lp = &dcs_ldsc[ln];
             if (lp->conn) {
                int32 ch = *data & DATA;
                ch = sim_tt_outcvt(ch, TT_GET_MODE (dcs_unit.flags) | TTUF_KSR);
                tmxr_putc_ln (lp, ch);
                dcs_tx_enable |= (1 << ln);
             }
         }
         if (dev & 4) {
             uptr->STATUS |= XSCN_ACT;
             dcs_doscan(uptr);
         }
         sim_debug(DEBUG_DATAIO, &dcs_dev, "DC %03o DATO %012llo PC=%06o\n",
                    dev, *data, PC);
         break;

    case DATAI:
    case DATAI|4:
         ln = dcs_rx_scan;
         if (ln < dcs_desc.lines) {
             /* Nothing happens if no recieve data, which is transmit ready */
             lp = &dcs_ldsc[ln];
             if (tmxr_rqln (lp) > 0) {
                int32 ch = tmxr_getc_ln (lp);
                if (ch & SCPE_BREAK)                      /* break? */
                    ch = 0;
                else
                    ch = sim_tt_inpcvt (ch, TT_GET_MODE(dcs_unit.flags) | TTUF_KSR);
                *data = (uint64)(ch & DATA);
                dcs_tx_enable &= ~(1 << ln);
             }
             dcs_rx_rdy &= ~(1 << ln);
         }
         if (dev & 4) {
             uptr->STATUS |= RSCN_ACT;
             dcs_doscan(uptr);
         }
         sim_debug(DEBUG_DATAIO, &dcs_dev, "DCS %03o DATI %012llo PC=%06o\n",
                    dev, *data, PC);
         break;
    case CONI|4:
         /* Read in scanner */
         if ((uptr->STATUS & (RSCN_ACT)) != 0)
             *data = (uint64)(dcs_tx_scan) + 2;
         else
             *data = (uint64)(dcs_rx_scan) + 2;
         sim_debug(DEBUG_CONI, &dcs_dev, "DCS %03o CONI %06o PC=%o recieve line\n",
               dev, (uint32)*data, PC);
         break;

    case CONO|4:
         /* Output buffer pointer */
         dcs_send_line = (int)(*data & 077) - 2;
         sim_debug(DEBUG_CONO, &dcs_dev, "DCS %03o CONO %06o PC=%06o send line\n",
               dev, (uint32)*data, PC);
         break;
    }
    return SCPE_OK;
}


/* Unit service */

t_stat dcs_svc (UNIT *uptr)
{
int32 ln;

    if ((uptr->flags & UNIT_ATT) == 0)                  /* attached? */
        return SCPE_OK;
    ln = tmxr_poll_conn (&dcs_desc);                     /* look for connect */
    if (ln >= 0) {                                      /* got one? rcv enb*/
        dcs_ldsc[ln].rcve = 1;
        dcs_tx_enable |= 1 << ln;
        sim_debug(DEBUG_DETAIL, &dcs_dev, "DC line connect %d\n", ln);
    }
    tmxr_poll_tx(&dcs_desc);
    tmxr_poll_rx(&dcs_desc);
    for (ln = 0; ln < dcs_desc.lines; ln++) {
       /* Check to see if any pending data for this line */
       if (tmxr_rqln(&dcs_ldsc[ln]) > 0) {
           dcs_rx_rdy |= (1 << ln);
           sim_debug(DEBUG_DETAIL, &dcs_dev, "DC recieve %d\n", ln);
       }
       /* Check if disconnect */
       if ((dcs_rx_conn & (1 << ln)) != 0 && dcs_ldsc[ln].conn == 0) {
           dcs_tx_enable &= ~(1 << ln);
           dcs_rx_conn &= ~(1 << ln);
           sim_debug(DEBUG_DETAIL, &dcs_dev, "DC line disconnect %d\n", ln);
       }
    }

    /* If any pending status request, raise the PI signal */
    dcs_doscan(uptr);
    sim_clock_coschedule(uptr, tmxr_poll);              /* continue poll */
    return SCPE_OK;
}

/* Scan to see if something to do */
t_stat dcs_doscan (UNIT *uptr) {

   clr_interrupt(DCS_DEVNUM);
   if ((uptr->STATUS & (RSCN_ACT)) != 0) {
       for (;dcs_rx_rdy != 0; dcs_rx_scan++) {
          dcs_rx_scan &= 037;
          /* Check if we found it */
          if (dcs_rx_rdy & (1 << dcs_rx_scan)) {
             uptr->STATUS &= ~RSCN_ACT;
             /* Stop scanner */
             set_interrupt(DCS_DEVNUM, uptr->STATUS);
             return SCPE_OK;
          }
       }
   }
   if ((uptr->STATUS & (XSCN_ACT)) != 0) {
       for (;dcs_tx_enable != 0; dcs_tx_scan++) {
          dcs_tx_scan &= 037;
          /* Check if we found it */
          if (dcs_tx_enable & (1 << dcs_tx_scan)) {
             uptr->STATUS &= ~XSCN_ACT;
             /* Stop scanner */
             set_interrupt(DCS_DEVNUM, (uptr->STATUS >> 6));
             return SCPE_OK;
          }
       }
   }
   return SCPE_OK;
}

/* Reset routine */

t_stat dcs_reset (DEVICE *dptr)
{
    if (dcs_unit.flags & UNIT_ATT)                           /* if attached, */
        sim_activate (&dcs_unit, tmxr_poll);                 /* activate */
    else
        sim_cancel (&dcs_unit);                             /* else stop */
    dcs_tx_enable = 0;
    dcs_rx_rdy = 0;                             /* Flags */
    dcs_rx_conn = 0;
    dcs_send_line = 0;
    dcs_tx_scan = 0;
    dcs_rx_scan = 0;
    dcs_unit.STATUS = 0;
    clr_interrupt(DCS_DEVNUM);
    return SCPE_OK;
}


/* SET LINES processor */

t_stat dcs_setnl (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
    int32 newln, i, t;
    t_stat r;

    if (cptr == NULL)
        return SCPE_ARG;
    newln = (int32) get_uint (cptr, 10, DCS_LINES, &r);
    if ((r != SCPE_OK) || (newln == dcs_desc.lines))
        return r;
    if ((newln == 0) || (newln >= DCS_LINES) || (newln % 8) != 0)
        return SCPE_ARG;
    if (newln < dcs_desc.lines) {
        for (i = newln, t = 0; i < dcs_desc.lines; i++)
            t = t | dcs_ldsc[i].conn;
        if (t && !get_yn ("This will disconnect users; proceed [N]?", FALSE))
            return SCPE_OK;
        for (i = newln; i < dcs_desc.lines; i++) {
            if (dcs_ldsc[i].conn) {
                tmxr_linemsg (&dcs_ldsc[i], "\r\nOperator disconnected line\r\n");
                tmxr_send_buffered_data (&dcs_ldsc[i]);
                }
            tmxr_detach_ln (&dcs_ldsc[i]);               /* completely reset line */
        }
    }
    if (dcs_desc.lines < newln)
        memset (dcs_ldsc + dcs_desc.lines, 0, sizeof(*dcs_ldsc)*(newln-dcs_desc.lines));
    dcs_desc.lines = newln;
    return dcs_reset (&dcs_dev);                         /* setup lines and auto config */
}

/* SET LOG processor */

t_stat dcs_set_log (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
    t_stat r;
    char gbuf[CBUFSIZE];
    int32 ln;

    if (cptr == NULL)
        return SCPE_ARG;
    cptr = get_glyph (cptr, gbuf, '=');
    if ((cptr == NULL) || (*cptr == 0) || (gbuf[0] == 0))
        return SCPE_ARG;
    ln = (int32) get_uint (gbuf, 10, dcs_desc.lines, &r);
    if ((r != SCPE_OK) || (ln >= dcs_desc.lines))
        return SCPE_ARG;
    return tmxr_set_log (NULL, ln, cptr, desc);
}

/* SET NOLOG processor */

t_stat dcs_set_nolog (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
    t_stat r;
    int32 ln;

    if (cptr == NULL)
        return SCPE_ARG;
    ln = (int32) get_uint (cptr, 10, dcs_desc.lines, &r);
    if ((r != SCPE_OK) || (ln >= dcs_desc.lines))
        return SCPE_ARG;
    return tmxr_set_nolog (NULL, ln, NULL, desc);
}

/* SHOW LOG processor */

t_stat dcs_show_log (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
{
    int32 i;

    for (i = 0; i < dcs_desc.lines; i++) {
        fprintf (st, "line %d: ", i);
        tmxr_show_log (st, NULL, i, desc);
        fprintf (st, "\n");
        }
    return SCPE_OK;
}


/* Attach routine */

t_stat dcs_attach (UNIT *uptr, CONST char *cptr)
{
t_stat reason;

reason = tmxr_attach (&dcs_desc, uptr, cptr);
if (reason != SCPE_OK)
  return reason;
sim_activate (uptr, tmxr_poll);
return SCPE_OK;
}

/* Detach routine */

t_stat dcs_detach (UNIT *uptr)
{
  int32  i;
  t_stat reason;
reason = tmxr_detach (&dcs_desc, uptr);
for (i = 0; i < dcs_desc.lines; i++)
    dcs_ldsc[i].rcve = 0;
sim_cancel (uptr);
return reason;
}

t_stat dcs_help (FILE *st, DEVICE *dptr, UNIT *uptr, int32 flag, const char *cptr)
{
fprintf (st, "Type 630 Terminal Interfaces\n\n");
fprintf (st, "The Type 630 supported up to 8 blocks of 8 lines. Modem control was on a seperate\n");
fprintf (st, "line. The number of lines is specified with a SET command:\n\n");
fprintf (st, "   sim> SET DCS LINES=n          set number of additional lines to n [8-32]\n\n");
fprintf (st, "Lines must be set in multiples of 8.\n");
fprintf (st, "The ATTACH command specifies the port to be used:\n\n");
tmxr_attach_help (st, dptr, uptr, flag, cptr);
fprintf (st, "The additional terminals can be set to one of four modes: UC, 7P, 7B, or 8B.\n\n");
fprintf (st, "  mode  input characters        output characters\n\n");
fprintf (st, "  UC    lower case converted    lower case converted to upper case,\n");
fprintf (st, "        to upper case,          high-order bit cleared,\n");
fprintf (st, "        high-order bit cleared  non-printing characters suppressed\n");
fprintf (st, "  7P    high-order bit cleared  high-order bit cleared,\n");
fprintf (st, "                                non-printing characters suppressed\n");
fprintf (st, "  7B    high-order bit cleared  high-order bit cleared\n");
fprintf (st, "  8B    no changes              no changes\n\n");
fprintf (st, "The default mode is 7P.\n");
fprintf (st, "Finally, each line supports output logging.  The SET DCn LOG command enables\n");
fprintf (st, "logging on a line:\n\n");
fprintf (st, "   sim> SET DCSn LOG=filename   log output of line n to filename\n\n");
fprintf (st, "The SET DCSn NOLOG command disables logging and closes the open log file,\n");
fprintf (st, "if any.\n\n");
fprintf (st, "Once DC is attached and the simulator is running, the terminals listen for\n");
fprintf (st, "connections on the specified port.  They assume that the incoming connections\n");
fprintf (st, "are Telnet connections.  The connections remain open until disconnected either\n");
fprintf (st, "by the Telnet client, a SET DC DISCONNECT command, or a DETACH DC command.\n\n");
fprintf (st, "Other special commands:\n\n");
fprintf (st, "   sim> SHOW DCS CONNECTIONS    show current connections\n");
fprintf (st, "   sim> SHOW DCS STATISTICS     show statistics for active connections\n");
fprintf (st, "   sim> SET DCSn DISCONNECT     disconnects the specified line.\n");
fprint_reg_help (st, &dcs_dev);
fprintf (st, "\nThe additional terminals do not support save and restore.  All open connections\n");
fprintf (st, "are lost when the simulator shuts down or DC is detached.\n");
return SCPE_OK;
}

const char *dcs_description (DEVICE *dptr)
{
return "Type 630 asynchronous line interface";
}

#endif