/* sds_mux.c: SDS 940 terminal multiplexor simulator

   Copyright (c) 2001-2008, 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.

   mux          terminal multiplexor

   19-Nov-08    RMS     Revixed for common TMXR show routines
   29-Dec-06    RMS     Revised to use console conversion routines
   29-Jun-05    RMS     Added SET MUXLn DISCONNECT
   21-Jun-05    RMS     Fixed bug in SHOW CONN/STATS
   05-Jan-04    RMS     Revised for tmxr library changes
   09-May-03    RMS     Added network device flag

   This module implements up to 32 individual serial interfaces, representing
   either the project Genie terminal multiplexor or the SDS 940 CTE option.
*/

#include "sds_defs.h"
#include "sim_sock.h"
#include "sim_tmxr.h"
#include <ctype.h>

#define PROJ_GENIE      (cpu_unit.flags & UNIT_GENIE)
#define MUX_NUMLIN      mux_desc.lines

#define MUX_LINES       32                              /* lines */
#define MUX_FLAGS       4                               /* intr per line */
#define MUX_FLAGMASK    (MUX_FLAGS - 1)
#define MUX_SCANMAX     (MUX_LINES * MUX_FLAGS)         /* flags to scan */
#define MUX_SCANMASK    (MUX_SCANMAX - 1)
#define MUX_INIT_POLL   8000
#define MUXL_WAIT       250
#define MUX_SETFLG(l,x) mux_flags[((l) * MUX_FLAGS) + (x)] = 1
#define MUX_SETINT(x)   int_req = int_req | (INT_MUXR >> (x))
#define MUX_CLRINT(x)   int_req = int_req & ~(INT_MUXR >> (x))
#define MUX_CHKINT(x)   (int_req & (INT_MUXR >> (x)))

/* PIN/POT */

#define P_V_CHAR        16                              /* char */
#define P_M_CHAR        0377
#define P_CHAR(x)       (((x) >> P_V_CHAR) & P_M_CHAR)
#define PIN_OVR         000100000                       /* overrun */
#define POT_NOX         000100000                       /* no xmit */
#define POT_XMI         000040000                       /* xmit int */
#define POT_GLNE        000020000                       /* Genie: enable */
#define POT_SCDT        000020000                       /* 940: clr DTR */
#define P_V_CHAN        0                               /* channel */
#define P_M_CHAN        (MUX_LINES - 1)
#define P_CHAN(x)       (((x) >> P_V_CHAN) & P_M_CHAN)

/* SKS 940 */

#define SKS_XBE         000001000                       /* xmt buf empty */
#define SKS_CRO         000000400                       /* carrier on */
#define SKS_DSR         000000200                       /* data set ready */
#define SKS_CHAN(x)     P_CHAN(x)

/* SKS Genie */

#define SKG_V_CHAN      7
#define SKG_M_CHAN      (MUX_LINES - 1)
#define SKG_CHAN(x)     (((x) >> SKG_V_CHAN) & SKG_M_CHAN)

/* Flags */

#define MUX_FRCV        0                               /* receive */
#define MUX_FXMT        1                               /* transmit */
#define MUX_FCRN        2                               /* carrier on */
#define MUX_FCRF        3                               /* carrier off */

/* Line status */

#define MUX_SCHP        001                             /* char pending */
#define MUX_SOVR        002                             /* overrun */
#define MUX_SLNE        004                             /* line enabled */
#define MUX_SXIE        010                             /* xmt int enab */
#define MUX_SCRO        020                             /* carrier on */
#define MUX_SDSR        040                             /* data set ready */

/* Data */

extern uint32 alert, int_req;
extern int32 stop_invins, stop_invdev, stop_inviop;
extern UNIT cpu_unit;

uint8 mux_rbuf[MUX_LINES];                              /* rcv buf */
uint8 mux_xbuf[MUX_LINES];                              /* xmt buf */
uint8 mux_sta[MUX_LINES];                               /* status */
uint8 mux_flags[MUX_SCANMAX];                           /* flags */
uint32 mux_tps = 100;                                   /* polls/second */
uint32 mux_scan = 0;                                    /* scanner */
uint32 mux_slck = 0;                                    /* scanner locked */

TMLN mux_ldsc[MUX_LINES] = { {0} };                     /* line descriptors */
TMXR mux_desc = { MUX_LINES, 0, 0, mux_ldsc };          /* mux descriptor */

t_stat mux (uint32 fnc, uint32 inst, uint32 *dat);
t_stat muxi_svc (UNIT *uptr);
t_stat muxo_svc (UNIT *uptr);
t_stat mux_reset (DEVICE *dptr);
t_stat mux_attach (UNIT *uptr, CONST char *cptr);
t_stat mux_detach (UNIT *uptr);
t_stat mux_summ (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat mux_show (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
t_stat mux_vlines (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
void mux_reset_ln (int32 ln);
void mux_scan_next (void);

/* MUX data structures

   mux_dev      MUX device descriptor
   mux_unit     MUX unit descriptor
   mux_reg      MUX register list
   mux_mod      MUX modifiers list
*/

DIB mux_dib = { -1, DEV3_GMUX, 0, NULL, &mux };

UNIT mux_unit = { UDATA (&muxi_svc, UNIT_ATTABLE, 0), MUX_INIT_POLL };

REG mux_reg[] = {
    { BRDATA (STA, mux_sta, 8, 6, MUX_LINES) },
    { BRDATA (RBUF, mux_rbuf, 8, 8, MUX_LINES) },
    { BRDATA (XBUF, mux_xbuf, 8, 8, MUX_LINES) },
    { BRDATA (INT, mux_flags, 8, 1, MUX_SCANMAX) },
    { ORDATA (SCAN, mux_scan, 7) },
    { FLDATA (SLCK, mux_slck, 0) },
    { DRDATA (TPS, mux_tps, 8), REG_NZ + PV_LEFT },
    { NULL }
    };

MTAB mux_mod[] = {
    { MTAB_XTD | MTAB_VDV, 0, "LINES", "LINES",
      &mux_vlines, tmxr_show_lines, (void *) &mux_desc },
    { MTAB_XTD | MTAB_VDV, 1, NULL, "DISCONNECT",
      &tmxr_dscln, NULL, &mux_desc },
    { UNIT_ATT, UNIT_ATT, "summary", NULL,
      NULL, &tmxr_show_summ, (void *) &mux_desc },
    { MTAB_XTD | MTAB_VDV | MTAB_NMO, 1, "CONNECTIONS", NULL,
      NULL, &tmxr_show_cstat, (void *) &mux_desc },
    { MTAB_XTD | MTAB_VDV | MTAB_NMO, 0, "STATISTICS", NULL,
      NULL, &tmxr_show_cstat, (void *) &mux_desc },
    { 0 }
    };

DEVICE mux_dev = {
    "MUX", &mux_unit, mux_reg, mux_mod,
    1, 10, 31, 1, 8, 8,
    &tmxr_ex, &tmxr_dep, &mux_reset,
    NULL, &mux_attach, &mux_detach,
    &mux_dib, DEV_MUX | DEV_DISABLE
    };

/* MUXL data structures

   muxl_dev     MUXL device descriptor
   muxl_unit    MUXL unit descriptor
   muxl_reg     MUXL register list
   muxl_mod     MUXL modifiers list
*/

UNIT muxl_unit[] = {
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT },
    { UDATA (&muxo_svc, TT_MODE_UC, 0), MUXL_WAIT }
    };

MTAB muxl_mod[] = {
    { TT_MODE, TT_MODE_UC, "UC", "UC", 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_VUN, 0, NULL, "DISCONNECT",
      &tmxr_dscln, NULL, &mux_desc },
    { MTAB_XTD|MTAB_VUN|MTAB_NC, 0, "LOG", "LOG",
      &tmxr_set_log, &tmxr_show_log, &mux_desc },
    { MTAB_XTD|MTAB_VUN|MTAB_NC, 0, NULL, "NOLOG",
      &tmxr_set_nolog, NULL, &mux_desc },
    { 0 }
    };

REG muxl_reg[] = {
    { URDATA (TIME, muxl_unit[0].wait, 10, 24, 0,
              MUX_LINES, REG_NZ + PV_LEFT) },
    { NULL }
    };

DEVICE muxl_dev = {
    "MUXL", muxl_unit, muxl_reg, muxl_mod,
    MUX_LINES, 10, 31, 1, 8, 8,
    NULL, NULL, &mux_reset,
    NULL, NULL, NULL,
    NULL, 0
    };

/* MUX: IO routine */

/* Mux routine -  EOM 30001 or EOM 77777,2 */

t_stat mux (uint32 fnc, uint32 inst, uint32 *dat)
{
uint32 ln;

switch (fnc) {

    case IO_CONN:                                       /* connect */
        if ((PROJ_GENIE && (inst == 000230001)) ||      /* set alert */
           (!PROJ_GENIE && (inst == 020277777)))
           alert = POT_MUX;
        else CRETINS;
        break;

    case IO_SKS:                                        /* skip */
        if (PROJ_GENIE && ((inst & 077770077) == 004030001)) {
            ln = SKG_CHAN (inst);                       /* get line */
            if (!sim_is_active (&muxl_unit[ln]))
                *dat = 1;
            }
        else if (!PROJ_GENIE && ((inst & 077776000) == 024076000)) {
            ln = SKS_CHAN (inst);                       /* get line */
            if (inst & (SKS_XBE|SKS_CRO|SKS_DSR)) *dat = 1;
            if (((inst & SKS_XBE) && sim_is_active (&muxl_unit[ln])) ||
                ((inst & SKS_CRO) && !(mux_sta[ln] & MUX_SCRO)) ||
                ((inst & SKS_DSR) && !(mux_sta[ln] & MUX_SDSR)))
                *dat = 0;                               /* no skip if fail */
            }
        else CRETINS;

    default:
        return SCPE_IERR;
        }                                               /* end case */

return SCPE_OK;
}

/* PIN routine */

t_stat pin_mux (uint32 num, uint32 *dat)
{
uint32 ln = mux_scan >> 2;
uint32 flag = mux_scan & MUX_FLAGMASK;

if (!mux_slck)                                          /* scanner must be locked */
    return SCPE_IERR;
mux_scan = mux_scan & MUX_SCANMASK;                     /* mask scan */
mux_flags[mux_scan] = 0;                                /* clear flag */
if (flag == MUX_FRCV) {                                 /* rcv event? */
    *dat = ln | ((uint32) mux_rbuf[ln] << P_V_CHAR) |   /* line + char + */
        ((mux_sta[ln] & MUX_SOVR)? PIN_OVR: 0);         /* overrun */
    mux_sta[ln] = mux_sta[ln] & ~(MUX_SCHP | MUX_SOVR);
    }
else *dat = ln;                                         /* just line */
mux_slck = 0;                                           /* unlock scanner */
mux_scan_next ();                                       /* kick scanner */
return SCPE_OK;
}

t_stat pot_mux (uint32 num, uint32 *dat)
{
uint32 ln = P_CHAN (*dat);
uint32 chr = P_CHAR (*dat);

if (PROJ_GENIE && ((*dat & POT_GLNE) == 0)) {           /* Genie disable? */
    mux_sta[ln] = mux_sta[ln] & ~MUX_SLNE;              /* clear status */
    mux_ldsc[ln].rcve = 0;
    }
else if (!PROJ_GENIE && (*dat & POT_SCDT)) {            /* SDS disable? */
    if (mux_ldsc[ln].conn) {                            /* connected? */
        tmxr_linemsg (&mux_ldsc[ln], "\r\nLine hangup\r\n");
        tmxr_reset_ln (&mux_ldsc[ln]);                  /* reset line */
        mux_reset_ln (ln);                              /* reset state */
        MUX_SETFLG (ln, MUX_FCRF);                      /* set carrier off */
        mux_scan_next ();                               /* kick scanner */
        }
    mux_sta[ln] = mux_sta[ln] & ~MUX_SLNE;              /* clear status */
    mux_ldsc[ln].rcve = 0;
    }
else {                                                  /* enabled */
    if ((*dat & POT_NOX) == 0) {                        /* output char? */
        mux_xbuf[ln] = chr;                             /* store char */
        sim_activate (&muxl_unit[ln], muxl_unit[ln].wait);
        }
    if (*dat & POT_XMI)
        mux_sta[ln] = mux_sta[ln] | MUX_SXIE;
    else mux_sta[ln] = mux_sta[ln] & ~MUX_SXIE;
    mux_sta[ln] = mux_sta[ln] | MUX_SLNE;               /* line is enabled */
    mux_ldsc[ln].rcve = 1;
    if ((*dat & POT_NOX) &&                             /* if no transmit char && */
        (mux_sta[ln] & MUX_SXIE) &&                     /* line enabled && */
        !sim_is_active (&muxl_unit[ln])) {              /* tx buffer empty */
        MUX_SETFLG (ln, MUX_FXMT);                      /* then set flag to request */
        mux_scan_next ();                               /* a tx interrupt */
        }
    }
return SCPE_OK;
}

/* Unit service - receive side

   Poll all active lines for input
   Poll for new connections
*/

t_stat muxi_svc (UNIT *uptr)
{
int32 ln, c, t;

if ((uptr->flags & UNIT_ATT) == 0)                      /* attached? */
    return SCPE_OK;
t = sim_rtcn_calb (mux_tps, TMR_MUX);                   /* calibrate */
sim_activate (uptr, t);                                 /* continue poll */
ln = tmxr_poll_conn (&mux_desc);                        /* look for connect */
if (ln >= 0) {                                          /* got one? */
    if (!PROJ_GENIE && (mux_sta[ln] & MUX_SLNE)) {      /* modem & DTR? */
        mux_sta[ln] = mux_sta[ln] | (MUX_SCRO|MUX_SDSR);/* carrier on */
        MUX_SETFLG (ln, MUX_FCRN);                      /* set carr on flag */
        mux_scan_next ();                               /* kick scanner */
        }
    mux_ldsc[ln].rcve = 1;                              /* set rcv enable */
    }
tmxr_poll_rx (&mux_desc);                               /* poll for input */
for (ln = 0; ln < MUX_NUMLIN; ln++) {                   /* loop thru lines */
    if (mux_ldsc[ln].conn) {                            /* connected? */
        if ((c = tmxr_getc_ln (&mux_ldsc[ln]))) {       /* get char */
            if (mux_sta[ln] & MUX_SCHP)                 /* already got one? */
                mux_sta[ln] = mux_sta[ln] | MUX_SOVR;   /* overrun */
            else mux_sta[ln] = mux_sta[ln] | MUX_SCHP;  /* char pending */
            if (c & SCPE_BREAK)                         /* break? */
                c = 0;
            else c = sim_tt_inpcvt (c, TT_GET_MODE (muxl_unit[ln].flags));
            mux_rbuf[ln] = c;                           /* save char */
            MUX_SETFLG (ln, MUX_FRCV);                  /* set rcv flag */
            mux_scan_next ();                           /* kick scanner */
            }
        }
    else mux_sta[ln] = 0;                               /* disconnected */
    }                                                   /* end for */
return SCPE_OK;
}

/* Unit service - transmit side */

t_stat muxo_svc (UNIT *uptr)
{
int32 c;
uint32 ln = uptr - muxl_unit;                           /* line # */

if (mux_ldsc[ln].conn) {                                /* connected? */
    if (mux_ldsc[ln].xmte) {                            /* xmt enabled? */
        c = sim_tt_outcvt (mux_xbuf[ln], TT_GET_MODE (muxl_unit[ln].flags));
        if (c >= 0)                                     /* output char */
            tmxr_putc_ln (&mux_ldsc[ln], c);
        tmxr_poll_tx (&mux_desc);                       /* poll xmt */
        }
    else {                                              /* buf full */
        tmxr_poll_tx (&mux_desc);                       /* poll xmt */
        sim_activate (uptr, muxl_unit[ln].wait);        /* wait */
        return SCPE_OK;
        }
    }
if (mux_sta[ln] & MUX_SXIE) {
    MUX_SETFLG (ln, MUX_FXMT);                          /* set flag */
    mux_scan_next ();                                   /* kick scanner */
    }
return SCPE_OK;
}

/* Kick scanner
*
* Per 940 Ref Man:
*   If more than one raised flag is encountered by the scanner, only
*   the one of highest priority will result in an interrupt. The others
*   will be ignored until the scanner has completed scanning all other
*   channels. The receive flag will be given highest priority, followed
*   by the transmit flag, the carrier-on flag, and the carrier-off flag.
*
* To implement, advance mux_scan to last flag of current channel (by
* merging MUX_FLAGMASK) so scan loop commences with receive flag of next
* channel.
*
* When two or more channels are active, do not queue an interrupt
* request if the same interrupt is already requesting.  To do so will
* cause an interrupt to be lost.
*/

void mux_scan_next (void)
{
int32 i;

if (mux_slck)                                           /* locked? */
    return;
mux_scan |= MUX_FLAGMASK;                               /* last flag of current ch.     */
                                                        /*  will be Rx flag of next ch. */
for (i = 0; i < MUX_SCANMAX; i++) {                     /* scan flags */
    mux_scan = (mux_scan + 1) & MUX_SCANMASK;           /* next flag */
    if (mux_flags[mux_scan] &&                          /* flag set */
        !MUX_CHKINT (mux_scan & MUX_FLAGMASK)) {        /*  and not requesting int? */
        mux_slck = 1;                                   /* lock scanner */
        MUX_SETINT (mux_scan & MUX_FLAGMASK);           /* request int */
        return;
        }
    }
return;
}

/* Reset routine */

t_stat mux_reset (DEVICE *dptr)
{
int32 i, t;

if (mux_dev.flags & DEV_DIS)                            /* master disabled? */
    muxl_dev.flags = muxl_dev.flags | DEV_DIS;          /* disable lines */
else muxl_dev.flags = muxl_dev.flags & ~DEV_DIS;
if (mux_unit.flags & UNIT_ATT) {                        /* master att? */
    if (!sim_is_active (&mux_unit)) {
        t = sim_rtcn_init (mux_unit.wait, TMR_MUX);
        sim_activate (&mux_unit, t);                    /* activate */
        }
    }
else sim_cancel (&mux_unit);                            /* else stop */
for (i = 0; i < MUX_LINES; i++)
    mux_reset_ln (i);
for (i = 0; i < MUX_FLAGS; i++)                         /* clear all ints */
    MUX_CLRINT (i);
return SCPE_OK;
}

/* Attach master unit */

t_stat mux_attach (UNIT *uptr, CONST char *cptr)
{
t_stat r;
int32 t;

r = tmxr_attach (&mux_desc, uptr, cptr);                /* attach */
if (r != SCPE_OK)                                       /* error */
    return r;
t = sim_rtcn_init (mux_unit.wait, TMR_MUX);
sim_activate (uptr, t);                                 /* start poll */
return SCPE_OK;
}

/* Detach master unit */

t_stat mux_detach (UNIT *uptr)
{
int32 i;
t_stat r;

r = tmxr_detach (&mux_desc, uptr);                      /* detach */
for (i = 0; i < MUX_LINES; i++)                         /* disable rcv */
    mux_ldsc[i].rcve = 0;
sim_cancel (uptr);                                      /* stop poll */
return r;
}

/* Change number of lines */

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

if (cptr == NULL)
    return SCPE_ARG;
newln = get_uint (cptr, 10, MUX_LINES, &r);
if ((r != SCPE_OK) || (newln == MUX_NUMLIN))
    return r;
if (newln == 0)
    return SCPE_ARG;
if (newln < MUX_NUMLIN) {
    for (i = newln, t = 0; i < MUX_NUMLIN; i++)
        t = t | mux_ldsc[i].conn;
    if (t && !get_yn ("This will disconnect users; proceed [N]?", FALSE))
            return SCPE_OK;
    for (i = newln; i < MUX_NUMLIN; i++) {
        if (mux_ldsc[i].conn) {
            tmxr_linemsg (&mux_ldsc[i], "\r\nOperator disconnected line\r\n");
            tmxr_reset_ln (&mux_ldsc[i]);               /* reset line */
            }
        muxl_unit[i].flags = muxl_unit[i].flags | UNIT_DIS;
        mux_reset_ln (i);
        }
    }
else {
    for (i = MUX_NUMLIN; i < newln; i++) {
        muxl_unit[i].flags = muxl_unit[i].flags & ~UNIT_DIS;
        mux_reset_ln (i);
        }
    }
MUX_NUMLIN = newln;
return SCPE_OK;
}

/* Reset an individual line */

void mux_reset_ln (int32 ln)
{
int32 flg = ln * MUX_FLAGS;

if (mux_ldsc[ln].conn)
    mux_sta[ln] = MUX_SCRO | MUX_SDSR;
else mux_sta[ln] = 0;
sim_cancel (&muxl_unit[ln]);
mux_flags[flg + MUX_FRCV] = 0;
mux_flags[flg + MUX_FXMT] = 0;
mux_flags[flg + MUX_FCRN] = 0;
mux_flags[flg + MUX_FCRF] = 0;
return;
}
