5531ccb175
These changes facilitate more robust parameter type checking and helps to identify unexpected coding errors. Most simulators can now also be compiled with a C++ compiler without warnings. Additionally, these changes have also been configured to facilitate easier backporting of simulator and device simulation modules to run under the simh v3.9+ SCP framework.
415 lines
16 KiB
C
415 lines
16 KiB
C
/* pdp1_dcs.c: PDP-1D terminal multiplexor simulator
|
|
|
|
Copyright (c) 2006-2013, 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.
|
|
|
|
dcs Type 630 data communications subsystem
|
|
|
|
11-Oct-2013 RMS Poll DCS immediately after attach to pick up connect
|
|
19-Nov-2008 RMS Revised for common TMXR show routines
|
|
|
|
This module implements up to 32 individual serial interfaces.
|
|
*/
|
|
|
|
#include "pdp1_defs.h"
|
|
#include "sim_sock.h"
|
|
#include "sim_tmxr.h"
|
|
|
|
#define DCS_LINES 32 /* lines */
|
|
#define DCS_LINE_MASK (DCS_LINES - 1)
|
|
#define DCSL_WAIT 1000 /* output wait */
|
|
#define DCS_NUMLIN dcs_desc.lines
|
|
|
|
int32 dcs_sbs = 0; /* SBS level */
|
|
uint32 dcs_send = 0; /* line for send */
|
|
uint32 dcs_scan = 0; /* line for scanner */
|
|
uint8 dcs_flg[DCS_LINES]; /* line flags */
|
|
uint8 dcs_buf[DCS_LINES]; /* line bufffers */
|
|
|
|
extern int32 iosta, stop_inst;
|
|
extern int32 tmxr_poll;
|
|
|
|
TMLN dcs_ldsc[DCS_LINES] = { {0} }; /* line descriptors */
|
|
TMXR dcs_desc = { DCS_LINES, 0, 0, dcs_ldsc }; /* mux descriptor */
|
|
|
|
t_stat dcsi_svc (UNIT *uptr);
|
|
t_stat dcso_svc (UNIT *uptr);
|
|
t_stat dcs_reset (DEVICE *dptr);
|
|
t_stat dcs_attach (UNIT *uptr, CONST char *cptr);
|
|
t_stat dcs_detach (UNIT *uptr);
|
|
t_stat dcs_vlines (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
|
|
void dcs_reset_ln (int32 ln);
|
|
void dcs_scan_next (t_bool unlk);
|
|
|
|
/* DCS data structures
|
|
|
|
dcs_dev DCS device descriptor
|
|
dcs_unit DCS unit descriptor
|
|
dcs_reg DCS register list
|
|
dcs_mod DCS modifiers list
|
|
*/
|
|
|
|
UNIT dcs_unit = { UDATA (&dcsi_svc, UNIT_ATTABLE, 0) };
|
|
|
|
REG dcs_reg[] = {
|
|
{ BRDATAD (BUF, dcs_buf, 8, 8, DCS_LINES, "input buffer, lines 0 to 31") },
|
|
{ BRDATAD (FLAGS, dcs_flg, 8, 1, DCS_LINES, "line ready flag, lines 0 to 31") },
|
|
{ FLDATAD (SCNF, iosta, IOS_V_DCS, "scanner ready flag") },
|
|
{ ORDATAD (SCAN, dcs_scan, 5, "scanner line number") },
|
|
{ ORDATAD (SEND, dcs_send, 5, "output line number") },
|
|
{ DRDATA (SBSLVL, dcs_sbs, 4), REG_HRO },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB dcs_mod[] = {
|
|
{ MTAB_XTD|MTAB_VDV, 0, "SBSLVL", "SBSLVL",
|
|
&dev_set_sbs, &dev_show_sbs, (void *) &dcs_sbs },
|
|
{ MTAB_XTD | MTAB_VDV, 0, "LINES", "LINES",
|
|
&dcs_vlines, &tmxr_show_lines, (void *) &dcs_desc },
|
|
{ MTAB_XTD | MTAB_VDV, 1, NULL, "DISCONNECT",
|
|
&tmxr_dscln, NULL, (void *) &dcs_desc },
|
|
{ UNIT_ATT, UNIT_ATT, "summary", NULL,
|
|
NULL, &tmxr_show_summ, (void *) &dcs_desc },
|
|
{ MTAB_XTD | MTAB_VDV | MTAB_NMO, 1, "CONNECTIONS", NULL,
|
|
NULL, &tmxr_show_cstat, (void *) &dcs_desc },
|
|
{ MTAB_XTD | MTAB_VDV | MTAB_NMO, 0, "STATISTICS", NULL,
|
|
NULL, &tmxr_show_cstat, (void *) &dcs_desc },
|
|
{ 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,
|
|
NULL, DEV_MUX | DEV_DISABLE | DEV_DIS
|
|
};
|
|
|
|
/* DCSL data structures
|
|
|
|
dcsl_dev DCSL device descriptor
|
|
dcsl_unit DCSL unit descriptor
|
|
dcsl_reg DCSL register list
|
|
dcsl_mod DCSL modifiers list
|
|
*/
|
|
|
|
UNIT dcsl_unit[] = {
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT },
|
|
{ UDATA (&dcso_svc, TT_MODE_UC, 0), DCSL_WAIT }
|
|
};
|
|
|
|
MTAB dcsl_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, &dcs_desc },
|
|
{ MTAB_XTD|MTAB_VUN|MTAB_NC, 0, "LOG", "LOG",
|
|
&tmxr_set_log, &tmxr_show_log, &dcs_desc },
|
|
{ MTAB_XTD|MTAB_VUN|MTAB_NC, 0, NULL, "NOLOG",
|
|
&tmxr_set_nolog, NULL, &dcs_desc },
|
|
{ 0 }
|
|
};
|
|
|
|
REG dcsl_reg[] = {
|
|
{ URDATAD (TIME, dcsl_unit[0].wait, 10, 24, 0,
|
|
DCS_LINES, REG_NZ + PV_LEFT, "time from I/O initiation to interrupt, lines 0 to 31") },
|
|
{ NULL }
|
|
};
|
|
|
|
DEVICE dcsl_dev = {
|
|
"DCSL", dcsl_unit, dcsl_reg, dcsl_mod,
|
|
DCS_LINES, 10, 31, 1, 8, 8,
|
|
NULL, NULL, &dcs_reset,
|
|
NULL, NULL, NULL,
|
|
NULL, DEV_DIS | DEV_MUX
|
|
};
|
|
|
|
/* DCS IOT routine */
|
|
|
|
int32 dcs (int32 inst, int32 dev, int32 dat)
|
|
{
|
|
int32 pls = (inst >> 6) & 077;
|
|
|
|
if (dcs_dev.flags & DEV_DIS) /* disabled? */
|
|
return (stop_inst << IOT_V_REASON) | dat; /* illegal inst */
|
|
if (pls & 020) /* pulse 20? clr IO */
|
|
dat = 0;
|
|
|
|
switch (pls & 057) { /* case IR<6,8:11> */
|
|
|
|
case 000: /* RCH */
|
|
dat |= dcs_buf[dcs_scan]; /* return line buf */
|
|
dcs_flg[dcs_scan] = 0; /* clr line flag */
|
|
break;
|
|
|
|
case 001: /* RRC */
|
|
dat |= dcs_scan; /* return line num */
|
|
break;
|
|
|
|
case 010: /* RCC */
|
|
dat |= dcs_buf[dcs_scan]; /* return line buf */
|
|
dcs_flg[dcs_scan] = 0; /* clr line flag */
|
|
/* fall through */
|
|
case 011: /* RSC */
|
|
dcs_scan_next (TRUE); /* unlock scanner */
|
|
break;
|
|
|
|
case 040: /* TCB */
|
|
dcs_buf[dcs_send] = dat & 0377; /* load buffer */
|
|
dcs_flg[dcs_send] = 0; /* clr line flag */
|
|
sim_activate (&dcsl_unit[dcs_send], dcsl_unit[dcs_send].wait);
|
|
break;
|
|
|
|
case 041: /* SSB */
|
|
dcs_send = dat & DCS_LINE_MASK; /* load line num */
|
|
break;
|
|
|
|
case 050: /* TCC */
|
|
dcs_buf[dcs_scan] = dat & 0377; /* load buffer */
|
|
dcs_flg[dcs_scan] = 0; /* clr line flag */
|
|
sim_activate (&dcsl_unit[dcs_scan], dcsl_unit[dcs_scan].wait);
|
|
dcs_scan_next (TRUE); /* unlock scanner */
|
|
break;
|
|
|
|
default:
|
|
return (stop_inst << IOT_V_REASON) | dat; /* illegal inst */
|
|
} /* end case */
|
|
|
|
return dat;
|
|
}
|
|
|
|
/* Unit service - receive side
|
|
|
|
Poll all active lines for input
|
|
Poll for new connections
|
|
*/
|
|
|
|
t_stat dcsi_svc (UNIT *uptr)
|
|
{
|
|
int32 ln, c, out;
|
|
|
|
if ((uptr->flags & UNIT_ATT) == 0) /* attached? */
|
|
return SCPE_OK;
|
|
if (dcs_dev.flags & DEV_DIS)
|
|
return SCPE_OK;
|
|
sim_activate (uptr, tmxr_poll); /* continue poll */
|
|
ln = tmxr_poll_conn (&dcs_desc); /* look for connect */
|
|
if (ln >= 0) { /* got one? */
|
|
dcs_ldsc[ln].rcve = 1; /* set rcv enable */
|
|
}
|
|
tmxr_poll_rx (&dcs_desc); /* poll for input */
|
|
for (ln = 0; ln < DCS_NUMLIN; ln++) { /* loop thru lines */
|
|
if (dcs_ldsc[ln].conn) { /* connected? */
|
|
if ((c = tmxr_getc_ln (&dcs_ldsc[ln]))) { /* get char */
|
|
if (c & SCPE_BREAK) /* break? */
|
|
c = 0;
|
|
else c = sim_tt_inpcvt (c, TT_GET_MODE (dcsl_unit[ln].flags)|TTUF_KSR);
|
|
dcs_buf[ln] = c; /* save char */
|
|
dcs_flg[ln] = 1; /* set line flag */
|
|
dcs_scan_next (FALSE); /* kick scanner */
|
|
out = sim_tt_outcvt (c & 0177, TT_GET_MODE (dcsl_unit[ln].flags));
|
|
if (out >= 0) {
|
|
tmxr_putc_ln (&dcs_ldsc[ln], out); /* echo char */
|
|
tmxr_poll_tx (&dcs_desc); /* poll xmt */
|
|
}
|
|
}
|
|
}
|
|
else dcs_ldsc[ln].rcve = 0; /* disconnected */
|
|
} /* end for */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Unit service - transmit side */
|
|
|
|
t_stat dcso_svc (UNIT *uptr)
|
|
{
|
|
int32 c;
|
|
uint32 ln = uptr - dcsl_unit; /* line # */
|
|
|
|
if (dcs_dev.flags & DEV_DIS)
|
|
return SCPE_OK;
|
|
if (dcs_ldsc[ln].conn) { /* connected? */
|
|
if (dcs_ldsc[ln].xmte) { /* xmt enabled? */
|
|
c = sim_tt_outcvt (dcs_buf[ln] & 0177, TT_GET_MODE (uptr->flags));
|
|
if (c >= 0) /* output char */
|
|
tmxr_putc_ln (&dcs_ldsc[ln], c);
|
|
tmxr_poll_tx (&dcs_desc); /* poll xmt */
|
|
}
|
|
else { /* buf full */
|
|
tmxr_poll_tx (&dcs_desc); /* poll xmt */
|
|
sim_activate (uptr, uptr->wait); /* reschedule */
|
|
return SCPE_OK;
|
|
}
|
|
}
|
|
dcs_flg[ln] = 1; /* set line flag */
|
|
dcs_scan_next (FALSE); /* kick scanner */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Kick scanner */
|
|
|
|
void dcs_scan_next (t_bool unlk)
|
|
{
|
|
int32 i;
|
|
|
|
if (unlk) /* unlock? */
|
|
iosta &= ~IOS_DCS;
|
|
else if (iosta & IOS_DCS) /* no, locked? */
|
|
return;
|
|
for (i = 0; i < DCS_LINES; i++) { /* scan flags */
|
|
dcs_scan = (dcs_scan + 1) & DCS_LINE_MASK; /* next flag */
|
|
if (dcs_flg[dcs_scan] != 0) { /* flag set? */
|
|
iosta |= IOS_DCS; /* lock scanner */
|
|
dev_req_int (dcs_sbs); /* request intr */
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Reset routine */
|
|
|
|
t_stat dcs_reset (DEVICE *dptr)
|
|
{
|
|
int32 i;
|
|
|
|
if (dcs_dev.flags & DEV_DIS) /* master disabled? */
|
|
dcsl_dev.flags = dcsl_dev.flags | DEV_DIS; /* disable lines */
|
|
else dcsl_dev.flags = dcsl_dev.flags & ~DEV_DIS;
|
|
if (dcs_unit.flags & UNIT_ATT) /* master att? */
|
|
sim_activate_abs (&dcs_unit, tmxr_poll); /* activate */
|
|
else sim_cancel (&dcs_unit); /* else stop */
|
|
for (i = 0; i < DCS_LINES; i++) /* reset lines */
|
|
dcs_reset_ln (i);
|
|
dcs_send = 0;
|
|
dcs_scan = 0;
|
|
iosta &= ~IOS_DCS; /* clr intr req */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Attach master unit */
|
|
|
|
t_stat dcs_attach (UNIT *uptr, CONST char *cptr)
|
|
{
|
|
t_stat r;
|
|
|
|
r = tmxr_attach (&dcs_desc, uptr, cptr); /* attach */
|
|
if (r != SCPE_OK) /* error */
|
|
return r;
|
|
sim_activate_abs (uptr, 0); /* start poll at once */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Detach master unit */
|
|
|
|
t_stat dcs_detach (UNIT *uptr)
|
|
{
|
|
int32 i;
|
|
t_stat r;
|
|
|
|
r = tmxr_detach (&dcs_desc, uptr); /* detach */
|
|
for (i = 0; i < DCS_LINES; i++) /* disable rcv */
|
|
dcs_ldsc[i].rcve = 0;
|
|
sim_cancel (uptr); /* stop poll */
|
|
return r;
|
|
}
|
|
|
|
/* Change number of lines */
|
|
|
|
t_stat dcs_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, DCS_LINES, &r);
|
|
if ((r != SCPE_OK) || (newln == DCS_NUMLIN))
|
|
return r;
|
|
if (newln == 0)
|
|
return SCPE_ARG;
|
|
if (newln < DCS_LINES) {
|
|
for (i = newln, t = 0; i < DCS_NUMLIN; 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_NUMLIN; i++) {
|
|
if (dcs_ldsc[i].conn) {
|
|
tmxr_linemsg (&dcs_ldsc[i], "\r\nOperator disconnected line\r\n");
|
|
tmxr_reset_ln (&dcs_ldsc[i]); /* reset line */
|
|
}
|
|
dcsl_unit[i].flags = dcsl_unit[i].flags | UNIT_DIS;
|
|
dcs_reset_ln (i);
|
|
}
|
|
}
|
|
else {
|
|
for (i = DCS_NUMLIN; i < newln; i++) {
|
|
dcsl_unit[i].flags = dcsl_unit[i].flags & ~UNIT_DIS;
|
|
dcs_reset_ln (i);
|
|
}
|
|
}
|
|
DCS_NUMLIN = newln;
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Reset an individual line */
|
|
|
|
void dcs_reset_ln (int32 ln)
|
|
{
|
|
sim_cancel (&dcsl_unit[ln]);
|
|
dcs_buf[ln] = 0;
|
|
dcs_flg[ln] = 0;
|
|
return;
|
|
}
|