| /* hp2100_mux.c: HP 2100 12920A terminal multiplexor simulator | |
| Copyright (c) 2002-2005, 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,muxl,muxc 12920A terminal multiplexor | |
| 22-Nov-05 RMS Revised for new terminal processing routines | |
| 29-Jun-05 RMS Added SET MUXLn DISCONNECT | |
| 07-Oct-04 JDB Allow enable/disable from any device | |
| 26-Apr-04 RMS Fixed SFS x,C and SFC x,C | |
| Implemented DMA SRQ (follows FLG) | |
| 05-Jan-04 RMS Revised for tmxr library changes | |
| 21-Dec-03 RMS Added invalid character screening for TSB (from Mike Gemeny) | |
| 09-May-03 RMS Added network device flag | |
| 01-Nov-02 RMS Added 7B/8B support | |
| 22-Aug-02 RMS Updated for changes to sim_tmxr | |
| The 12920A consists of three separate devices | |
| mux scanner (upper data card) | |
| muxl lines (lower data card) | |
| muxm modem control (control card) | |
| The lower data card has no CMD flop; the control card has no CMD flop. | |
| The upper data card has none of the usual flops. | |
| Reference: | |
| - 12920A Asynchronous Multiplexer Interface Kits Operating and Service | |
| Manual (12920-90001, Oct-1972) | |
| */ | |
| #include "hp2100_defs.h" | |
| #include "sim_sock.h" | |
| #include "sim_tmxr.h" | |
| #include <ctype.h> | |
| #define MUX_LINES 16 /* user lines */ | |
| #define MUX_ILINES 5 /* diag rcv only */ | |
| #define UNIT_V_MDM (TTUF_V_UF + 0) /* modem control */ | |
| #define UNIT_MDM (1 << UNIT_V_MDM) | |
| #define MUXU_INIT_POLL 8000 | |
| #define MUXL_WAIT 500 | |
| /* Channel number (OTA upper, LIA lower or upper) */ | |
| #define MUX_V_CHAN 10 /* channel num */ | |
| #define MUX_M_CHAN 037 | |
| #define MUX_CHAN(x) (((x) >> MUX_V_CHAN) & MUX_M_CHAN) | |
| /* OTA, lower = parameters or data */ | |
| #define OTL_P 0100000 /* parameter */ | |
| #define OTL_TX 0040000 /* transmit */ | |
| #define OTL_ENB 0020000 /* enable */ | |
| #define OTL_TPAR 0010000 /* xmt parity */ | |
| #define OTL_ECHO 0010000 /* rcv echo */ | |
| #define OTL_DIAG 0004000 /* diagnose */ | |
| #define OTL_SYNC 0004000 /* sync */ | |
| #define OTL_V_LNT 8 /* char length */ | |
| #define OTL_M_LNT 07 | |
| #define OTL_LNT(x) (((x) >> OTL_V_LNT) & OTL_M_LNT) | |
| #define OTL_V_BAUD 0 /* baud rate */ | |
| #define OTL_M_BAUD 0377 | |
| #define OTL_BAUD(x) (((x) >> OTL_V_BAUD) & OTL_M_BAUD) | |
| #define OTL_CHAR 01777 /* char mask */ | |
| /* LIA, lower = received data */ | |
| #define LIL_PAR 0100000 /* parity */ | |
| #define PUT_DCH(x) (((x) & MUX_M_CHAN) << MUX_V_CHAN) | |
| #define LIL_CHAR 01777 /* character */ | |
| /* LIA, upper = status */ | |
| #define LIU_SEEK 0100000 /* seeking NI */ | |
| #define LIU_DG 0000010 /* diagnose */ | |
| #define LIU_BRK 0000004 /* break */ | |
| #define LIU_LOST 0000002 /* char lost */ | |
| #define LIU_TR 0000001 /* trans/rcv */ | |
| /* OTA, control */ | |
| #define OTC_SCAN 0100000 /* scan */ | |
| #define OTC_UPD 0040000 /* update */ | |
| #define OTC_V_CHAN 10 /* channel */ | |
| #define OTC_M_CHAN 017 | |
| #define OTC_CHAN(x) (((x) >> OTC_V_CHAN) & OTC_M_CHAN) | |
| #define OTC_EC2 0000200 /* enable Cn upd */ | |
| #define OTC_EC1 0000100 | |
| #define OTC_C2 0000040 /* Cn flops */ | |
| #define OTC_C1 0000020 | |
| #define OTC_ES2 0000010 /* enb comparison */ | |
| #define OTC_ES1 0000004 | |
| #define OTC_V_ES 2 | |
| #define OTC_SS2 0000002 /* SSn flops */ | |
| #define OTC_SS1 0000001 | |
| #define OTC_RW (OTC_ES2|OTC_ES1|OTC_SS2|OTC_SS1) | |
| #define RTS OCT_C2 /* C2 = rts */ | |
| #define DTR OTC_C1 /* C1 = dtr */ | |
| /* LIA, control */ | |
| #define LIC_MBO 0140000 /* always set */ | |
| #define LIC_V_CHAN 10 /* channel */ | |
| #define LIC_M_CHAN 017 | |
| #define PUT_CCH(x) (((x) & OTC_M_CHAN) << OTC_V_CHAN) | |
| #define LIC_I2 0001000 /* change flags */ | |
| #define LIC_I1 0000400 | |
| #define LIC_S2 0000002 /* Sn flops */ | |
| #define LIC_S1 0000001 | |
| #define LIC_V_I 8 /* S1 to I1 */ | |
| #define CDET LIC_S2 /* S2 = cdet */ | |
| #define DSR LIC_S1 /* S1 = dsr */ | |
| #define LIC_TSTI(ch) (((muxc_lia[ch] ^ muxc_ota[ch]) & \ | |
| ((muxc_ota[ch] & (OTC_ES2|OTC_ES1)) >> OTC_V_ES)) \ | |
| << LIC_V_I) | |
| extern uint32 PC; | |
| extern uint32 dev_cmd[2], dev_ctl[2], dev_flg[2], dev_fbf[2], dev_srq[2]; | |
| uint16 mux_sta[MUX_LINES]; /* line status */ | |
| uint16 mux_rpar[MUX_LINES + MUX_ILINES]; /* rcv param */ | |
| uint16 mux_xpar[MUX_LINES]; /* xmt param */ | |
| uint8 mux_rbuf[MUX_LINES + MUX_ILINES]; /* rcv buf */ | |
| uint8 mux_xbuf[MUX_LINES]; /* xmt buf */ | |
| uint8 mux_rchp[MUX_LINES + MUX_ILINES]; /* rcv chr pend */ | |
| uint8 mux_xdon[MUX_LINES]; /* xmt done */ | |
| uint8 muxc_ota[MUX_LINES]; /* ctrl: Cn,ESn,SSn */ | |
| uint8 muxc_lia[MUX_LINES]; /* ctrl: Sn */ | |
| uint32 mux_tps = 100; /* polls/second */ | |
| uint32 muxl_ibuf = 0; /* low in: rcv data */ | |
| uint32 muxl_obuf = 0; /* low out: param */ | |
| uint32 muxu_ibuf = 0; /* upr in: status */ | |
| uint32 muxu_obuf = 0; /* upr out: chan */ | |
| uint32 muxc_chan = 0; /* ctrl chan */ | |
| uint32 muxc_scan = 0; /* ctrl scan */ | |
| TMLN mux_ldsc[MUX_LINES] = { 0 }; /* line descriptors */ | |
| TMXR mux_desc = { MUX_LINES, 0, 0, mux_ldsc }; /* mux descriptor */ | |
| DEVICE muxl_dev, muxu_dev, muxc_dev; | |
| int32 muxlio (int32 inst, int32 IR, int32 dat); | |
| int32 muxuio (int32 inst, int32 IR, int32 dat); | |
| int32 muxcio (int32 inst, int32 IR, int32 dat); | |
| t_stat muxi_svc (UNIT *uptr); | |
| t_stat muxo_svc (UNIT *uptr); | |
| t_stat muxc_reset (DEVICE *dptr); | |
| t_stat mux_attach (UNIT *uptr, char *cptr); | |
| t_stat mux_detach (UNIT *uptr); | |
| t_stat mux_summ (FILE *st, UNIT *uptr, int32 val, void *desc); | |
| t_stat mux_show (FILE *st, UNIT *uptr, int32 val, void *desc); | |
| void mux_data_int (void); | |
| void mux_ctrl_int (void); | |
| void mux_diag (int32 c); | |
| static uint8 odd_par[256] = { | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 000-017 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 020-037 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 040-067 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 060-077 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 100-117 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 120-137 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 140-157 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 160-177 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 200-217 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 220-237 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 240-257 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 260-277 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, /* 300-317 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 320-337 */ | |
| 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, /* 340-367 */ | |
| 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1 /* 360-377 */ | |
| }; | |
| #define RCV_PAR(x) (odd_par[(x) & 0377]? LIL_PAR: 0) | |
| DIB mux_dib[] = { | |
| { MUXL, 0, 0, 0, 0, 0, &muxlio }, | |
| { MUXU, 0, 0, 0, 0, 0, &muxuio } | |
| }; | |
| #define muxl_dib mux_dib[0] | |
| #define muxu_dib mux_dib[1] | |
| /* MUX data structures | |
| muxu_dev MUX device descriptor | |
| muxu_unit MUX unit descriptor | |
| muxu_reg MUX register list | |
| muxu_mod MUX modifiers list | |
| */ | |
| UNIT muxu_unit = { UDATA (&muxi_svc, UNIT_ATTABLE, 0), MUXU_INIT_POLL }; | |
| REG muxu_reg[] = { | |
| { ORDATA (IBUF, muxu_ibuf, 16) }, | |
| { ORDATA (OBUF, muxu_obuf, 16) }, | |
| { FLDATA (CMD, muxu_dib.cmd, 0), REG_HRO }, | |
| { FLDATA (CTL, muxu_dib.ctl, 0), REG_HRO }, | |
| { FLDATA (FLG, muxu_dib.flg, 0), REG_HRO }, | |
| { FLDATA (FBF, muxu_dib.fbf, 0), REG_HRO }, | |
| { FLDATA (SRQ, muxu_dib.srq, 0), REG_HRO }, | |
| { ORDATA (DEVNO, muxu_dib.devno, 6), REG_HRO }, | |
| { NULL } | |
| }; | |
| MTAB muxu_mod[] = { | |
| { UNIT_ATT, UNIT_ATT, "connections", NULL, NULL, &mux_summ }, | |
| { MTAB_XTD | MTAB_VDV | MTAB_NMO, 1, "CONNECTIONS", NULL, | |
| NULL, &mux_show, NULL }, | |
| { MTAB_XTD | MTAB_VDV | MTAB_NMO, 0, "STATISTICS", NULL, | |
| NULL, &mux_show, NULL }, | |
| { MTAB_XTD|MTAB_VDV, 1, "DEVNO", "DEVNO", | |
| &hp_setdev, &hp_showdev, &muxl_dev }, | |
| { MTAB_XTD | MTAB_VDV, 1, NULL, "DISCONNECT", | |
| &tmxr_dscln, NULL, &mux_desc }, | |
| { 0 } | |
| }; | |
| DEVICE muxu_dev = { | |
| "MUX", &muxu_unit, muxu_reg, muxu_mod, | |
| 1, 10, 31, 1, 8, 8, | |
| &tmxr_ex, &tmxr_dep, &muxc_reset, | |
| NULL, &mux_attach, &mux_detach, | |
| &muxu_dib, DEV_NET | 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 } | |
| }; | |
| 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 }, | |
| { UNIT_MDM, 0, "no dataset", "NODATASET", NULL }, | |
| { UNIT_MDM, UNIT_MDM, "dataset", "DATASET", 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 }, | |
| { MTAB_XTD|MTAB_VDV, 1, "DEVNO", "DEVNO", | |
| &hp_setdev, &hp_showdev, &muxl_dev }, | |
| { 0 } | |
| }; | |
| REG muxl_reg[] = { | |
| { FLDATA (CMD, muxl_dib.cmd, 0), REG_HRO }, | |
| { FLDATA (CTL, muxl_dib.ctl, 0) }, | |
| { FLDATA (FLG, muxl_dib.flg, 0) }, | |
| { FLDATA (FBF, muxl_dib.fbf, 0) }, | |
| { FLDATA (SRQ, muxl_dib.srq, 0) }, | |
| { BRDATA (STA, mux_sta, 8, 16, MUX_LINES) }, | |
| { BRDATA (RPAR, mux_rpar, 8, 16, MUX_LINES + MUX_ILINES) }, | |
| { BRDATA (XPAR, mux_xpar, 8, 16, MUX_LINES) }, | |
| { BRDATA (RBUF, mux_rbuf, 8, 8, MUX_LINES + MUX_ILINES) }, | |
| { BRDATA (XBUF, mux_xbuf, 8, 8, MUX_LINES) }, | |
| { BRDATA (RCHP, mux_rchp, 8, 1, MUX_LINES + MUX_ILINES) }, | |
| { BRDATA (XDON, mux_xdon, 8, 1, MUX_LINES) }, | |
| { URDATA (TIME, muxl_unit[0].wait, 10, 24, 0, | |
| MUX_LINES, REG_NZ + PV_LEFT) }, | |
| { ORDATA (DEVNO, muxl_dib.devno, 6), REG_HRO }, | |
| { NULL } | |
| }; | |
| DEVICE muxl_dev = { | |
| "MUXL", muxl_unit, muxl_reg, muxl_mod, | |
| MUX_LINES, 10, 31, 1, 8, 8, | |
| NULL, NULL, &muxc_reset, | |
| NULL, NULL, NULL, | |
| &muxl_dib, DEV_DISABLE | |
| }; | |
| /* MUXM data structures | |
| muxc_dev MUXM device descriptor | |
| muxc_unit MUXM unit descriptor | |
| muxc_reg MUXM register list | |
| muxc_mod MUXM modifiers list | |
| */ | |
| DIB muxc_dib = { MUXC, 0, 0, 0, 0, 0, &muxcio }; | |
| UNIT muxc_unit = { UDATA (NULL, 0, 0) }; | |
| REG muxc_reg[] = { | |
| { FLDATA (CMD, muxc_dib.cmd, 0), REG_HRO }, | |
| { FLDATA (CTL, muxc_dib.ctl, 0) }, | |
| { FLDATA (FLG, muxc_dib.flg, 0) }, | |
| { FLDATA (FBF, muxc_dib.fbf, 0) }, | |
| { FLDATA (SRQ, muxc_dib.srq, 0) }, | |
| { FLDATA (SCAN, muxc_scan, 0) }, | |
| { ORDATA (CHAN, muxc_chan, 4) }, | |
| { BRDATA (DSO, muxc_ota, 8, 6, MUX_LINES) }, | |
| { BRDATA (DSI, muxc_lia, 8, 2, MUX_LINES) }, | |
| { ORDATA (DEVNO, muxc_dib.devno, 6), REG_HRO }, | |
| { NULL } | |
| }; | |
| MTAB muxc_mod[] = { | |
| { MTAB_XTD|MTAB_VDV, 0, "DEVNO", "DEVNO", | |
| &hp_setdev, &hp_showdev, &muxc_dev }, | |
| { 0 } | |
| }; | |
| DEVICE muxc_dev = { | |
| "MUXM", &muxc_unit, muxc_reg, muxc_mod, | |
| 1, 10, 31, 1, 8, 8, | |
| NULL, NULL, &muxc_reset, | |
| NULL, NULL, NULL, | |
| &muxc_dib, DEV_DISABLE | |
| }; | |
| /* IO instructions: data cards */ | |
| int32 muxlio (int32 inst, int32 IR, int32 dat) | |
| { | |
| int32 dev, ln; | |
| dev = IR & I_DEVMASK; /* get device no */ | |
| switch (inst) { /* case on opcode */ | |
| case ioFLG: /* flag clear/set */ | |
| if ((IR & I_HC) == 0) { setFSR (dev); } /* STF */ | |
| break; | |
| case ioSFC: /* skip flag clear */ | |
| if (FLG (dev) == 0) PC = (PC + 1) & VAMASK; | |
| break; | |
| case ioSFS: /* skip flag set */ | |
| if (FLG (dev) != 0) PC = (PC + 1) & VAMASK; | |
| break; | |
| case ioOTX: /* output */ | |
| muxl_obuf = dat; /* store data */ | |
| break; | |
| case ioMIX: /* merge */ | |
| dat = dat | muxl_ibuf; | |
| break; | |
| case ioLIX: /* load */ | |
| dat = muxl_ibuf; | |
| break; | |
| case ioCTL: /* control clear/set */ | |
| if (IR & I_CTL) { clrCTL (dev); } /* CLC */ | |
| else { /* STC */ | |
| setCTL (dev); /* set ctl */ | |
| ln = MUX_CHAN (muxu_obuf); /* get chan # */ | |
| if (muxl_obuf & OTL_P) { /* parameter set? */ | |
| if (muxl_obuf & OTL_TX) { /* transmit? */ | |
| if (ln < MUX_LINES) /* to valid line? */ | |
| mux_xpar[ln] = muxl_obuf; | |
| } | |
| else if (ln < (MUX_LINES + MUX_ILINES)) /* rcv, valid line? */ | |
| mux_rpar[ln] = muxl_obuf; | |
| } | |
| else if ((muxl_obuf & OTL_TX) && /* xmit data? */ | |
| (ln < MUX_LINES)) { /* to valid line? */ | |
| if (sim_is_active (&muxl_unit[ln])) /* still working? */ | |
| mux_sta[ln] = mux_sta[ln] | LIU_LOST; | |
| else sim_activate (&muxl_unit[ln], muxl_unit[ln].wait); | |
| mux_xbuf[ln] = muxl_obuf & OTL_CHAR; /* load buffer */ | |
| } | |
| } /* end STC */ | |
| break; | |
| default: | |
| break; | |
| } | |
| if (IR & I_HC) { /* H/C option */ | |
| clrFSR (dev); /* clear flag */ | |
| mux_data_int (); /* look for new int */ | |
| } | |
| return dat; | |
| } | |
| int32 muxuio (int32 inst, int32 IR, int32 dat) | |
| { | |
| switch (inst) { /* case on opcode */ | |
| case ioOTX: /* output */ | |
| muxu_obuf = dat; /* store data */ | |
| break; | |
| case ioMIX: /* merge */ | |
| dat = dat | muxu_ibuf; | |
| break; | |
| case ioLIX: /* load */ | |
| dat = muxu_ibuf; | |
| break; | |
| default: | |
| break; | |
| } | |
| return dat; | |
| } | |
| /* IO instructions: control card */ | |
| int32 muxcio (int32 inst, int32 IR, int32 dat) | |
| { | |
| int32 dev, ln, t, old; | |
| dev = IR & I_DEVMASK; /* get device no */ | |
| switch (inst) { /* case on opcode */ | |
| case ioFLG: /* flag clear/set */ | |
| if ((IR & I_HC) == 0) { setFSR (dev); } /* STF */ | |
| break; | |
| case ioSFC: /* skip flag clear */ | |
| if (FLG (dev) == 0) PC = (PC + 1) & VAMASK; | |
| break; | |
| case ioSFS: /* skip flag set */ | |
| if (FLG (dev) != 0) PC = (PC + 1) & VAMASK; | |
| break; | |
| case ioOTX: /* output */ | |
| if (dat & OTC_SCAN) muxc_scan = 1; /* set scan flag */ | |
| else muxc_scan = 0; | |
| if (dat & OTC_UPD) { /* update? */ | |
| ln = OTC_CHAN (dat); /* get channel */ | |
| old = muxc_ota[ln]; /* save prior val */ | |
| muxc_ota[ln] = (muxc_ota[ln] & ~OTC_RW) | /* save ESn,SSn */ | |
| (dat & OTC_RW); | |
| if (dat & OTC_EC2) muxc_ota[ln] = /* if EC2, upd C2 */ | |
| (muxc_ota[ln] & ~OTC_C2) | (dat & OTC_C2); | |
| if (dat & OTC_EC1) muxc_ota[ln] = /* if EC1, upd C1 */ | |
| (muxc_ota[ln] & ~OTC_C1) | (dat & OTC_C1); | |
| if ((muxl_unit[ln].flags & UNIT_MDM) && /* modem ctrl? */ | |
| (old & DTR) && !(muxc_ota[ln] & DTR)) { /* DTR drop? */ | |
| tmxr_linemsg (&mux_ldsc[ln], "\r\nLine hangup\r\n"); | |
| tmxr_reset_ln (&mux_ldsc[ln]); /* reset line */ | |
| muxc_lia[ln] = 0; /* dataset off */ | |
| } | |
| } /* end update */ | |
| break; | |
| case ioLIX: /* load */ | |
| dat = 0; | |
| case ioMIX: /* merge */ | |
| t = LIC_MBO | PUT_CCH (muxc_chan) | /* mbo, chan num */ | |
| LIC_TSTI (muxc_chan) | /* I2, I1 */ | |
| (muxc_ota[muxc_chan] & (OTC_ES2 | OTC_ES1)) | /* ES2, ES1 */ | |
| (muxc_lia[muxc_chan] & (LIC_S2 | LIC_S1)); /* S2, S1 */ | |
| dat = dat | t; /* return status */ | |
| muxc_chan = (muxc_chan + 1) & LIC_M_CHAN; /* incr channel */ | |
| break; | |
| case ioCTL: /* ctrl clear/set */ | |
| if (IR & I_CTL) { clrCTL (dev); } /* CLC */ | |
| else { setCTL (dev); } /* STC */ | |
| break; | |
| default: | |
| break; | |
| } | |
| if (IR & I_HC) { /* H/C option */ | |
| clrFSR (dev); /* clear flag */ | |
| mux_ctrl_int (); /* look for new int */ | |
| } | |
| return dat; | |
| } | |
| /* Unit service - receive side | |
| Poll for new connections | |
| Poll all active lines for input | |
| */ | |
| t_stat muxi_svc (UNIT *uptr) | |
| { | |
| int32 ln, c, t; | |
| if ((uptr->flags & UNIT_ATT) == 0) return SCPE_OK; /* attached? */ | |
| 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 ((muxl_unit[ln].flags & UNIT_MDM) && /* modem ctrl? */ | |
| (muxc_ota[ln] & DTR)) /* DTR? */ | |
| muxc_lia[ln] = muxc_lia[ln] | CDET; /* set cdet */ | |
| muxc_lia[ln] = muxc_lia[ln] | DSR; /* set dsr */ | |
| mux_ldsc[ln].rcve = 1; /* rcv enabled */ | |
| } | |
| tmxr_poll_rx (&mux_desc); /* poll for input */ | |
| for (ln = 0; ln < MUX_LINES; ln++) { /* loop thru lines */ | |
| if (mux_ldsc[ln].conn) { /* connected? */ | |
| if (c = tmxr_getc_ln (&mux_ldsc[ln])) { /* get char */ | |
| if (c & SCPE_BREAK) { /* break? */ | |
| mux_sta[ln] = mux_sta[ln] | LIU_BRK; | |
| mux_rbuf[ln] = 0; /* no char */ | |
| } | |
| else { /* normal */ | |
| if (mux_rchp[ln]) mux_sta[ln] = mux_sta[ln] | LIU_LOST; | |
| c = sim_tt_inpcvt (c, TT_GET_MODE (muxl_unit[ln].flags)); | |
| if (mux_rpar[ln] & OTL_ECHO) { /* echo? */ | |
| TMLN *lp = &mux_ldsc[ln]; /* get line */ | |
| tmxr_putc_ln (lp, c); /* output char */ | |
| tmxr_poll_tx (&mux_desc); /* poll xmt */ | |
| } | |
| mux_rbuf[ln] = c; /* save char */ | |
| mux_rchp[ln] = 1; /* char pending */ | |
| } | |
| if (mux_rpar[ln] & OTL_DIAG) mux_diag (c); /* rcv diag? */ | |
| } /* end if char */ | |
| } /* end if connected */ | |
| else muxc_lia[ln] = 0; /* disconnected */ | |
| } /* end for */ | |
| if (!FLG (muxl_dib.devno)) mux_data_int (); /* scan for data int */ | |
| if (!FLG (muxc_dib.devno)) mux_ctrl_int (); /* scan modem */ | |
| return SCPE_OK; | |
| } | |
| /* Unit service - transmit side */ | |
| t_stat muxo_svc (UNIT *uptr) | |
| { | |
| int32 c, ln = uptr - muxl_unit; /* line # */ | |
| if (mux_ldsc[ln].conn) { /* connected? */ | |
| if (mux_ldsc[ln].xmte) { /* xmt enabled? */ | |
| if ((mux_xbuf[ln] & OTL_SYNC) == 0) { /* start bit 0? */ | |
| TMLN *lp = &mux_ldsc[ln]; /* get line */ | |
| c = mux_xbuf[ln]; /* get char */ | |
| c = sim_tt_outcvt (c, TT_GET_MODE (muxl_unit[ln].flags)); | |
| if (mux_xpar[ln] & OTL_DIAG) /* xmt diag? */ | |
| mux_diag (mux_xbuf[ln]); /* before munge */ | |
| mux_xdon[ln] = 1; /* set done */ | |
| /* In (default) UC or (new) 7P, all these chars are suppressed automatically */ | |
| /* if ((TT_GET_MODE (muxl_unit[ln].flags) != TT_MODE_8B) && | |
| /* (c != 0x7f) && (c != 0x13) && /* not del, ^S? */ | |
| /* (c != 0x11) && (c != 0x5)) /* not ^Q, ^E? */ | |
| if (c >= 0) /* valid? */ | |
| tmxr_putc_ln (lp, c); /* output char */ | |
| 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 (!FLG (muxl_dib.devno)) mux_data_int (); /* scan for int */ | |
| return SCPE_OK; | |
| } | |
| /* Look for data interrupt */ | |
| void mux_data_int (void) | |
| { | |
| int32 i; | |
| for (i = 0; i < MUX_LINES; i++) { /* rcv lines */ | |
| if ((mux_rpar[i] & OTL_ENB) && mux_rchp[i]) { /* enabled, char? */ | |
| muxl_ibuf = PUT_CCH (i) | mux_rbuf[i] | /* lo buf = char */ | |
| RCV_PAR (mux_rbuf[i]); | |
| muxu_ibuf = PUT_CCH (i) | mux_sta[i]; /* hi buf = stat */ | |
| mux_rchp[i] = 0; /* clr char, stat */ | |
| mux_sta[i] = 0; | |
| setFSR (muxl_dib.devno); /* interrupt */ | |
| return; | |
| } | |
| } | |
| for (i = 0; i < MUX_LINES; i++) { /* xmt lines */ | |
| if ((mux_xpar[i] & OTL_ENB) && mux_xdon[i]) { /* enabled, done? */ | |
| muxu_ibuf = PUT_CCH (i) | mux_sta[i] | LIU_TR; /* hi buf = stat */ | |
| mux_xdon[i] = 0; /* clr done, stat */ | |
| mux_sta[i] = 0; | |
| setFSR (muxl_dib.devno); /* interrupt */ | |
| return; | |
| } | |
| } | |
| for (i = MUX_LINES; i < (MUX_LINES + MUX_ILINES); i++) { /* diag lines */ | |
| if ((mux_rpar[i] & OTL_ENB) && mux_rchp[i]) { /* enabled, char? */ | |
| muxl_ibuf = PUT_CCH (i) | mux_rbuf[i] | /* lo buf = char */ | |
| RCV_PAR (mux_rbuf[i]); | |
| muxu_ibuf = PUT_CCH (i) | mux_sta[i] | LIU_DG; /* hi buf = stat */ | |
| mux_rchp[i] = 0; /* clr char, stat */ | |
| mux_sta[i] = 0; | |
| setFSR (muxl_dib.devno); | |
| return; | |
| } | |
| } | |
| return; | |
| } | |
| /* Look for control interrupt */ | |
| void mux_ctrl_int (void) | |
| { | |
| int32 i; | |
| if (muxc_scan == 0) return; | |
| for (i = 0; i < MUX_LINES; i++) { | |
| muxc_chan = (muxc_chan + 1) & LIC_M_CHAN; /* step channel */ | |
| if (LIC_TSTI (muxc_chan)) { /* status change? */ | |
| setFSR (muxc_dib.devno); /* set flag */ | |
| break; | |
| } | |
| } | |
| return; | |
| } | |
| /* Set diagnostic lines for given character */ | |
| void mux_diag (int32 c) | |
| { | |
| int32 i; | |
| for (i = MUX_LINES; i < (MUX_LINES + MUX_ILINES); i++) { | |
| if (c & SCPE_BREAK) { /* break? */ | |
| mux_sta[i] = mux_sta[i] | LIU_BRK; | |
| mux_rbuf[i] = 0; /* no char */ | |
| } | |
| else { | |
| if (mux_rchp[i]) mux_sta[i] = mux_sta[i] | LIU_LOST; | |
| mux_rchp[i] = 1; | |
| mux_rbuf[i] = c; | |
| } | |
| } | |
| return; | |
| } | |
| /* Reset an individual line */ | |
| void mux_reset_ln (int32 i) | |
| { | |
| mux_rbuf[i] = mux_xbuf[i] = 0; /* clear state */ | |
| mux_rpar[i] = mux_xpar[i] = 0; | |
| mux_rchp[i] = mux_xdon[i] = 0; | |
| mux_sta[i] = 0; | |
| muxc_ota[i] = muxc_lia[i] = 0; /* clear modem */ | |
| if (mux_ldsc[i].conn) /* connected? */ | |
| muxc_lia[i] = muxc_lia[i] | DSR | /* cdet, dsr */ | |
| (muxl_unit[i].flags & UNIT_MDM? CDET: 0); | |
| sim_cancel (&muxl_unit[i]); | |
| return; | |
| } | |
| /* Reset routine */ | |
| t_stat muxc_reset (DEVICE *dptr) | |
| { | |
| int32 i, t; | |
| if (dptr == &muxc_dev) { /* make all consistent */ | |
| hp_enbdis_pair (dptr, &muxl_dev); | |
| hp_enbdis_pair (dptr, &muxu_dev); | |
| } | |
| else if (dptr == &muxl_dev) { | |
| hp_enbdis_pair (dptr, &muxc_dev); | |
| hp_enbdis_pair (dptr, &muxu_dev); | |
| } | |
| else { | |
| hp_enbdis_pair (dptr, &muxc_dev); | |
| hp_enbdis_pair (dptr, &muxl_dev); | |
| } | |
| muxl_dib.cmd = muxl_dib.ctl = 0; /* init lower */ | |
| muxl_dib.flg = muxl_dib.fbf = muxl_dib.srq = 1; | |
| muxu_dib.cmd = muxu_dib.ctl = 0; /* upper not */ | |
| muxu_dib.flg = muxu_dib.fbf = muxu_dib.srq = 0; /* implemented */ | |
| muxc_dib.cmd = muxc_dib.ctl = 0; /* init ctrl */ | |
| muxc_dib.flg = muxc_dib.fbf = muxc_dib.srq = 1; | |
| muxc_chan = muxc_scan = 0; /* init modem scan */ | |
| if (muxu_unit.flags & UNIT_ATT) { /* master att? */ | |
| if (!sim_is_active (&muxu_unit)) { | |
| t = sim_rtcn_init (muxu_unit.wait, TMR_MUX); | |
| sim_activate (&muxu_unit, t); /* activate */ | |
| } | |
| } | |
| else sim_cancel (&muxu_unit); /* else stop */ | |
| for (i = 0; i < MUX_LINES; i++) mux_reset_ln (i); | |
| return SCPE_OK; | |
| } | |
| /* Attach master unit */ | |
| t_stat mux_attach (UNIT *uptr, char *cptr) | |
| { | |
| t_stat r; | |
| int32 t; | |
| r = tmxr_attach (&mux_desc, uptr, cptr); /* attach */ | |
| if (r != SCPE_OK) return r; /* error */ | |
| t = sim_rtcn_init (muxu_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++) mux_ldsc[i].rcve = 0; /* disable rcv */ | |
| sim_cancel (uptr); /* stop poll */ | |
| return r; | |
| } | |
| /* Show summary processor */ | |
| t_stat mux_summ (FILE *st, UNIT *uptr, int32 val, void *desc) | |
| { | |
| int32 i, t; | |
| for (i = t = 0; i < MUX_LINES; i++) t = t + (mux_ldsc[i].conn != 0); | |
| if (t == 1) fprintf (st, "1 connection"); | |
| else fprintf (st, "%d connections", t); | |
| return SCPE_OK; | |
| } | |
| /* SHOW CONN/STAT processor */ | |
| t_stat mux_show (FILE *st, UNIT *uptr, int32 val, void *desc) | |
| { | |
| int32 i, t; | |
| for (i = t = 0; i < MUX_LINES; i++) t = t + (mux_ldsc[i].conn != 0); | |
| if (t) { | |
| for (i = 0; i < MUX_LINES; i++) { | |
| if (mux_ldsc[i].conn) { | |
| if (val) tmxr_fconns (st, &mux_ldsc[i], i); | |
| else tmxr_fstats (st, &mux_ldsc[i], i); | |
| } | |
| } | |
| } | |
| else fprintf (st, "all disconnected\n"); | |
| return SCPE_OK; | |
| } | |