folkert/simh-testsetgenerator
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
simh-testsetgenerator/HP3000/hp3000_atc.c
Mark Pizzolato 6bbbc19e01 HP3000: Update to early Release 8 which is still simh V4.x API compatible 
Dave Bryan has migrated support for this simulator to http://simh.trailing-edge.com/hp
2020-02-16 22:24:16 -08:00

2976 lines
149 KiB
C
Raw Blame History

/* hp3000_atc.c: HP 3000 30032B Asynchronous Terminal Controller simulator
Copyright (c) 2014-2018, J. David Bryan
Copyright (c) 2002-2012, 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 THE
AUTHORS 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 names of the authors shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from the authors.
ATCD,ATCC HP 30032B Asynchronous Terminal Controller
30-Apr-18 JDB Corrected typo in "store" routine comment
18-Dec-17 JDB Return event time instead of status from "activate_unit"
11-Dec-17 JDB Reschedule "line_service" if receive buffer has data
26-Oct-17 JDB Call "tmxr_poll_tx" if transmit buffer is full
05-Sep-17 JDB Changed REG_A (permit any symbolic override) to REG_X
16-Sep-16 JDB Fixed atcd_detach to skip channel cancel if SIM_SW_REST
12-Sep-16 JDB Changed DIB register macro usage from SRDATA to DIB_REG
20-Jul-16 JDB Corrected poll_unit "wait" field initializer.
26-Jun-16 JDB Removed tmxr_set_modem_control_passthru call in atcc_reset
09-Jun-16 JDB Added casts for ptrdiff_t to int32 values
16-May-16 JDB Fixed interrupt mask setting
13-May-16 JDB Modified for revised SCP API function parameter types
21-Mar-16 JDB Changed uint16 types to HP_WORD
26-Aug-15 JDB First release version
31-Jul-15 JDB Passes the terminal control diagnostic (D438A)
11-Aug-14 JDB Passes the terminal data diagnostic (D427A)
28-Jul-14 JDB Created from the HP 2100 12920A MUX device simulator
References:
- 30032B Asynchronous Terminal Controller Installation and Service Manual
(30032-90004, February 1977)
- Stand-Alone HP 30032B Terminal Data Interface Diagnostic
(30032-90011, October 1980)
- Stand-Alone HP 30061A Terminal Controller Interface Diagnostic
(30060-90004, February 1976)
- HP 3000 Series III Engineering Diagrams Set
(30000-90141, April 1980)
The HP 30032B Asynchronous Terminal Controller is a 16-channel terminal
multiplexer used with the HP 3000 CX through Series III systems. The ATC
connects from 1 to 16 serial terminals or modems to the HP 3000 at
programmable baud rates from 75 to 2400 bits per second. Character sizes are
also programmable from 5 to 12 bits in length, including the start and stop
bits. Each channel can be independently configured, including for separate
send and receive rates. The ATC is not buffered, so the CPU has to retrieve
each character from a given channel before the next character arrives. To
avoid saturating the CPU with interrupt requests, the ATC maintains an
internal "mini-interrupt" system that queues requests and holds additional
interrupts off until the CPU acknowledges the current request.
The HP 3000CX and Series I use a dedicated serial interface for the system
console, while user terminals are connected to the ATC. For the Series II
and III, the separate card is eliminated, and channel 0 of the ATC is
reserved for the console.
This module is an adaptation of the code originally written by Bob Supnik for
the HP2100 MUX simulator. The MUX device simulates an HP 12920A interface
for an HP 2100/1000 computer. The 12920A is an ATC with the HP 3000 I/O bus
connection replaced by an HP 2100 I/O bus connection. Programming and
operation of the two multiplexers are virtually identical.
The ATC consists of a Terminal Data Interface, which provides direct
connection for 16 serial terminals, and one or two optional Terminal Control
Interfaces, which provides control and status lines for Bell 103 and 202 data
sets, respectively. The ATC base product, order number 30032, consisted of
one TDI card. Option -001 added one TCI, and option -002 added two. A
second ATC subsystem could be added to support an additional 16 terminals or
modems.
This simulation provides one TDI and one optional TCI. Each of the channels
may be connected either to a Telnet session or a serial port on the host
machine. Channel 0 is connected to the simulation console, which initially
performs I/O to the controlling window but may be rerouted instead to a
Telnet session or serial port, if desired. Additional channel configuration
options select the input mode (upshifted or normal), output mode (8-bit,
7-bit, printable, or upshifted), and whether the HP-standard ENQ/ACK
handshaking is done by the external device or internally by the simulator.
A device mode specifies whether terminals or diagnostic loopback cables are
connected to the TDI and TCI. Enabling the diagnostic mode simulates the
installation of eight HP 30062-60003 diagnostic test (loopback) cables
between channels 0-1, 2-3, etc., as required by the multiplexer diagnostics.
In this mode, sending data on one channel automatically receives the same
data on the alternate channel. In addition, all Telnet and serial sessions
are disconnected, and the TDI is detached from the listening port. While in
diagnostic mode, the ATTACH command is not allowed. Enabling terminal mode
allows the TDI to be attached to accept incoming connections again.
Another device mode specifies whether the TDI operates in real-time or
optimized ("fast") timing mode. In the former, character send and receive
events occur at approximately the same rate (in machine instructions) as in
hardware. The latter mode increases the rate to the maximum value consistent
with correct operation in MPE.
Both the TDI and TCI are normally enabled, although the TCI will not be used
unless MPE is configured to use data sets on one or more channels. When so
configured, logging off will cause the channel to disconnect the Telnet
session or drop the Data Terminal Ready signal on the serial port. A channel
controlled by the TCI will be marked as "data set" in a unit listing;
channels not controlled will be marked as "direct".
The TDI and TCI may be disabled, if desired, although the TDI must be
detached from the listening port first. Disabling the TDI does not affect
the simulation console, as the CPU process clock will take over console
polling automatically.
The Terminal Data Interface provides 16 send channels, 16 receive channels,
and 5 auxiliary channels. The auxiliary channels are receive-only and do
not connect to external devices. Rather, they may be connected as a group to
one or more of the other channels. Their primary purpose is to diagnose
conditions (e.g., baud rate) on the connected channel(s).
In hardware, a recirculating memory stores seven 8-bit words of data,
parameters, and status for each of the 37 channels. A set of registers form
a "window" into the recirculating memory, and the memory makes one complete
pass every 69.44 microseconds. Serial transfer rates are determined by each
channel's parameter word, which specifies the number of recirculations that
occur for each bit sent or received.
In simulation, the memory is represented by separate buffer, parameter, and
status arrays. Recirculation is simulated by indexing through each of the
arrays in sequence.
The TDI responds only to direct I/O instructions, as follows:
TDI Control Word Format (CIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| M | R | channel number | - - - - - - - | E | A |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
M = master reset
R = reset interrupts
E = enable store of preceding data or parameter word to memory
A = acknowledge interrupt
TDI Status Word Format (TIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| S | D | I | - | C | R | L | B | - - - - - - - - |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
S = SIO OK (always 0)
D = direct read/write I/O OK
I = interrupt request
C = read/write completion flag
R = receive/send (0/1) character interrupt
L = character lost
B = break status
TDI Parameter Word Format (WIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 1 | R | I | E | D | char size | baud rate |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
R = receive/send (0/1) configuration
I = enable channel completion interrupt
E = enable echo (receive) or generate parity (send)
D = diagnose using the auxiliary channels
Character size:
The three least-significant bits of the sum of the data, parity, and stop
bits. For example, 7E1 is 1001, so 001 is coded.
Baud rate:
The value (14400 / device bit rate) - 1. For example, 2400 baud is 005.
TDI Output Data Word Format (WIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | - - | S | send data |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
S = sync bit
data = right-justified with leading ones
TDI Input Data Word Format (RIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| channel | P | receive data |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
P = computed parity
data = right-justified with leading ones
The Terminal Control Interface provides two serial control outputs and two
serial status inputs for each of 16 channels. The first TCI connects to the
Request to Send (CA) and Data Terminal Ready (CD) control lines and the Data
Carrier Detect (CF) and Data Set Ready (CC) status lines. Addressable
latches hold the control line values and assert them continuously to the 16
channels. In addition, a 16-word by 4-bit RAM holds the expected state for
each channel's status lines and the corresponding interrupt enable bits to
provide notification if those lines change.
The TCI responds only to direct I/O instructions, as follows:
TCI Control Word Format (CIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| M | R | S | U | channel | W | X | Q | T | Y | Z | C | D |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
M = master reset
R = reset interrupts
S = scan status
U = enable DCD/DSR state update
W = enable RTS change
X = enable DTR change
Q = new RTS state
T = new DTR state
Y = DCD interrupt enabled
Z = DSR interrupt enabled
C = expected DCD state
D = expected DSR state
TCI Status Word Format (TIO or RIO):
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | I | 1 | channel | 0 | 0 | J | K | Y | Z | C | D |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
Where:
I = interrupt request
J = DCD interrupt present
K = DSR interrupt present
Y = DCD interrupt enabled
Z = DSR interrupt enabled
C = current DCD state
D = current DSR state
Implementation notes:
1. The UNIT_MODEM flag indicates that a channel is controlled by the TCI.
However, no modifier entry is provided, nor is one needed, as the flag is
set automatically when the TCI first initializes the channel. MPE
defines separate terminal subtype numbers for directly connected
terminals and modem-connected terminals, which are set at system
generation time.
2. Both TMXR_VALID and SCPE_KFLAG are set on internally generated ACKs only
so that a debug trace will record the generation correctly.
*/
#include <ctype.h>
#include "hp3000_defs.h"
#include "hp3000_io.h"
#include "sim_tmxr.h"
/* Program limits */
#define TERM_COUNT 16 /* number of terminal channels */
#define AUX_COUNT 5 /* number of auxiliary channels */
#define POLL_COUNT 1 /* number of poll units */
#define RECV_CHAN_COUNT (TERM_COUNT + AUX_COUNT) /* number of receive channels */
#define SEND_CHAN_COUNT TERM_COUNT /* number of send channels */
#define UNIT_COUNT (TERM_COUNT + POLL_COUNT) /* number of units */
#define FIRST_TERM 0 /* first terminal index */
#define LAST_TERM (FIRST_TERM + TERM_COUNT - 1) /* last terminal index */
#define FIRST_AUX TERM_COUNT /* first auxiliary index */
#define LAST_AUX (FIRST_AUX + AUX_COUNT - 1) /* last auxiliary index */
/* Program constants */
#define FAST_IO_TIME 500 /* initial fast receive/send time in event ticks */
#define POLL_RATE 100 /* poll 100 times per second (unless synchronized) */
#define POLL_TIME mS (10) /* poll time is 10 milliseconds */
#define NUL '\000' /* null */
#define ENQ '\005' /* enquire */
#define ACK '\006' /* acknowledge */
#define ASCII_MASK 000177u /* 7-bit ASCII character set mask */
#define GEN_ACK (TMXR_VALID | SCPE_KFLAG | ACK) /* a generated ACK character */
#define SCAN_ALL (-1) /* scan all channels for completion */
/* Parity functions derived from the global lookup table */
#define RECV_PARITY(c) (odd_parity [(c) & D8_MASK] ? 0 : DDR_PARITY)
#define SEND_PARITY(c) (odd_parity [(c) & D8_MASK] ? 0 : DDS_PARITY)
/* Debug flags */
#define DEB_CSRW (1u << 0) /* trace command initiations and completions */
#define DEB_XFER (1u << 1) /* trace data receptions and transmissions */
#define DEB_IOB (1u << 2) /* trace I/O bus signals and data words */
#define DEB_SERV (1u << 3) /* trace channel service scheduling calls */
#define DEB_PSERV (1u << 4) /* trace poll service scheduling calls */
/* Common per-unit multiplexer channel state variables */
#define recv_time u3 /* realistic receive time in event ticks */
#define send_time u4 /* realistic send time in event ticks */
#define stop_bits u5 /* stop bits to be added to each character received */
/* Device flags */
#define DEV_DIAG_SHIFT (DEV_V_UF + 0) /* diagnostic loopback */
#define DEV_REALTIME_SHIFT (DEV_V_UF + 1) /* timing mode is realistic */
#define DEV_DIAG (1u << DEV_DIAG_SHIFT) /* diagnostic mode flag */
#define DEV_REALTIME (1u << DEV_REALTIME_SHIFT) /* realistic timing flag */
/* Unit flags */
#define UNIT_CAPSLOCK_SHIFT (TTUF_V_UF + 0) /* caps lock mode */
#define UNIT_LOCALACK_SHIFT (TTUF_V_UF + 1) /* local ACK mode */
#define UNIT_MODEM_SHIFT (TTUF_V_UF + 2) /* modem control */
#define UNIT_CAPSLOCK (1u << UNIT_CAPSLOCK_SHIFT) /* caps lock is down flag */
#define UNIT_LOCALACK (1u << UNIT_LOCALACK_SHIFT) /* ENQ/ACK mode is local flag */
#define UNIT_MODEM (1u << UNIT_MODEM_SHIFT) /* channel connects to a data set flag */
/* Unit references */
#define line_unit atcd_unit /* receive/send channel units */
#define poll_unit atcd_unit [LAST_TERM + 1] /* input polling unit */
/* Activation reasons */
typedef enum {
Receive,
Send,
Loop,
Stall
} ACTIVATOR;
/* TDI control word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| M | R | channel number | - - - - - - - | E | A |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*/
#define DCN_MR 0100000u /* (M) master reset */
#define DCN_IRQ_RESET 0040000u /* (R) interrupt request reset */
#define DCN_CHAN_MASK 0037000u /* channel number mask */
#define DCN_ENABLE 0000002u /* (E) enable store of preceding data or parameter word */
#define DCN_ACKN 0000001u /* (A) acknowledge interrupt */
#define DCN_CHAN_SHIFT 9 /* channel number alignment shift */
#define DCN_CHAN(c) (((c) & DCN_CHAN_MASK) >> DCN_CHAN_SHIFT)
static const BITSET_NAME tdi_control_names [] = { /* TDI control word names */
"master reset", /* bit 0 */
"reset interrupt", /* bit 1 */
NULL, /* bit 2 */
NULL, /* bit 3 */
NULL, /* bit 4 */
NULL, /* bit 5 */
NULL, /* bit 6 */
NULL, /* bit 7 */
NULL, /* bit 8 */
NULL, /* bit 9 */
NULL, /* bit 10 */
NULL, /* bit 11 */
NULL, /* bit 12 */
NULL, /* bit 13 */
"store word", /* bit 14 */
"acknowledge interrupt" /* bit 15 */
};
static const BITSET_FORMAT tdi_control_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tdi_control_names, 0, msb_first, no_alt, no_bar) };
/* TDI status word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| - | D | I | - | C | R | L | B | - - - - - - - - |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*/
#define DST_DIO_OK 0040000u /* (D) direct I/O OK to use */
#define DST_IRQ 0020000u /* (I) interrupt requested */
#define DST_COMPLETE 0004000u /* (C) operation is complete and channel is ready to interrupt */
#define DST_SEND_IRQ 0002000u /* (R) interrupt request is for character sent */
#define DST_CHAR_LOST 0001000u /* (L) character was lost */
#define DST_BREAK 0000400u /* (B) break occurred */
#define DST_DIAGNOSE 0000000u /* status is from an auxiliary channel (not used on ATC) */
#define DST_CHAN(n) 0 /* position channel number for status (not used on ATC) */
static const BITSET_NAME tdi_status_names [] = { /* TDI status word names */
"DIO OK", /* bit 1 */
"interrupt", /* bit 2 */
NULL, /* bit 3 */
"complete", /* bit 4 */
"\1send\0receive", /* bit 5 */
"lost", /* bit 6 */
"break" /* bit 7 */
};
static const BITSET_FORMAT tdi_status_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tdi_status_names, 8, msb_first, has_alt, no_bar) };
/* TDI parameter word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 1 | R | I | E | D | char size | baud rate |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
The baud rate is encoded as 14400 / device_bit_rate - 1, but the manual says
to round the result, so that, e.g., the 110 baud rate encoding of 129.91 is
rounded to 130. To reconstruct the rate without floating-point calculations,
the parameter print routine uses:
baud_rate = (2 * 14400 / (encoded_rate + 1) + 1) / 2
...which is equivalent to:
baud_rate = (int) (14400 / (encoded_rate + 1) + 0.5)
The multiplexer pads the received character data to the left with one-bits.
The PAD_BITS function generates the pad bits, assuming that the received
character transmission has one stop bit. This isn't always correct, e.g., a
Teleprinter uses two stop bits at 110 baud, but there's no way to reconstruct
the number of stop bits from the receive parameter word.
*/
#define DPI_IS_PARAM 0100000u /* value is a parameter (always set) */
#define DPI_IS_SEND 0040000u /* (R) value is a send parameter */
#define DPI_ENABLE_IRQ 0020000u /* (I) enable interrupt requests */
#define DPI_ENABLE_PARITY 0010000u /* (E) enable parity for send */
#define DPI_ENABLE_ECHO 0010000u /* (E) enable echo for receive */
#define DPI_DIAGNOSE 0004000u /* (D) connect to the auxiliary channels */
#define DPI_SIZE_MASK 0003400u /* character size mask */
#define DPI_RATE_MASK 0000377u /* baud rate mask */
#define DPI_CHAR_CONFIG (DPI_SIZE_MASK | DPI_RATE_MASK) /* character configuration data */
#define DPI_SIZE_SHIFT 8 /* character size alignment shift */
#define DPI_RATE_SHIFT 0 /* baud rate alignment shift */
#define DPI_CHAR_SIZE(p) (((p) & DPI_SIZE_MASK) >> DPI_SIZE_SHIFT)
#define DPI_BAUD_RATE(p) (((p) & DPI_RATE_MASK) >> DPI_RATE_SHIFT)
#define BAUD_RATE(p) ((28800 / (DPI_BAUD_RATE (p) + 1) + 1) / 2)
#define PAD_BITS(c) (~((1u << bits_per_char [DPI_CHAR_SIZE (c)] - 2) - 1))
static const uint32 bits_per_char [8] = { /* bits per character, indexed by DPI_CHAR_SIZE encoding */
9, 10, 11, 12, 5, 6, 7, 8
};
static const BITSET_NAME tdi_parameter_names [] = { /* TDI parameter word names */
"\1send\0receive", /* bit 1 */
"enable interrupt", /* bit 2 */
"enable parity/echo", /* bit 3 */
"diagnose" /* bit 4 */
};
static const BITSET_FORMAT tdi_parameter_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tdi_parameter_names, 11, msb_first, has_alt, append_bar) };
/* TDI output (send) data word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| 0 | 1 | - - | S | send data |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*/
#define DDS_IS_SEND 0040000u /* value is a send data word (always set) */
#define DDS_SYNC 0004000u /* (S) sync */
#define DDS_DATA_MASK 0003777u /* data value mask */
#define DDS_PARITY 0000200u /* data parity bit */
#define DDS_MARK (DDS_SYNC | DDS_DATA_MASK) /* all-mark character */
#define DDS_DATA(d) ((d) & DDS_DATA_MASK)
static const BITSET_NAME tdi_output_data_names [] = { /* TDI output data word names */
"send", /* bit 1 */
NULL, /* bit 2 */
NULL, /* bit 3 */
"sync" /* bit 4 */
};
static const BITSET_FORMAT tdi_output_data_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tdi_output_data_names, 11, msb_first, no_alt, append_bar) };
/* TDI input (receive) data word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| channel | P | receive data |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*/
#define DDR_CHAN_MASK 0174000u /* channel number mask */
#define DDR_PARITY 0002000u /* (P) computed parity bit */
#define DDR_DATA_MASK 0001777u /* data value mask */
#define DDR_CHAN_SHIFT 11 /* channel number alignment shift */
#define DDR_DATA_SHIFT 0 /* data alignment shift */
#define DDR_CHAN(n) ((n) << DDR_CHAN_SHIFT & DDR_CHAN_MASK)
#define DDR_DATA(d) ((d) << DDR_DATA_SHIFT & DDR_DATA_MASK)
#define DDR_TO_CHAN(w) (((w) & DDR_CHAN_MASK) >> DDR_CHAN_SHIFT)
#define DDR_TO_DATA(w) (((w) & DDR_DATA_MASK) >> DDR_DATA_SHIFT)
static const BITSET_NAME tdi_input_data_names [] = { /* TDI input data word names */
"\1odd parity\0even parity", /* bit 5 */
};
static const BITSET_FORMAT tdi_input_data_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tdi_input_data_names, 10, msb_first, has_alt, append_bar) };
/* TCI control word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| M | R | S | U | channel | W | X | Q | T | Y | Z | C | D |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*/
#define CCN_MR 0100000u /* (M) master reset */
#define CCN_IRQ_RESET 0040000u /* (R) interrupt request reset */
#define CCN_SCAN 0020000u /* (S) scan enable */
#define CCN_UPDATE 0010000u /* (U) update enable */
#define CCN_CHAN_MASK 0007400u /* channel number mask */
#define CCN_ECX_MASK 0000300u /* control output enable mask */
#define CCN_EC2 0000200u /* (W) C2 output enable */
#define CCN_EC1 0000100u /* (X) C1 output enable */
#define CCN_CX_MASK 0000060u /* output mask */
#define CCN_C2 0000040u /* (Q) C2 output [RTS] */
#define CCN_C1 0000020u /* (T) C1 output [DTR] */
#define CCN_STAT_MASK 0000017u /* status RAM mask */
#define CCN_ESX_MASK 0000014u /* status interrupt enable mask */
#define CCN_ES2 0000010u /* (Y) S2 interrupt enable */
#define CCN_ES1 0000004u /* (Z) S1 interrupt enable */
#define CCN_SX_MASK 0000003u /* status mask */
#define CCN_S2 0000002u /* (C) S2 status [DCD]*/
#define CCN_S1 0000001u /* (D) S1 status [DSR] */
#define CCN_CHAN_SHIFT 8 /* channel number alignment shift */
#define CCN_CX_SHIFT 4 /* control alignment shift */
#define CCN_ECX_SHIFT 2 /* control output enable alignment shift (to Cx) */
#define CCN_ESX_SHIFT 2 /* status interrupt enable alignment shift */
#define CCN_CHAN(c) (((c) & CCN_CHAN_MASK) >> CCN_CHAN_SHIFT)
#define CCN_ECX(c) (((c) & CCN_ECX_MASK) >> CCN_ECX_SHIFT)
#define CCN_CX(c) (((c) & CCN_CX_MASK) >> CCN_CX_SHIFT)
#define CCN_ESX(c) (((c) & CCN_ESX_MASK) >> CCN_ESX_SHIFT)
static const BITSET_NAME tci_control_names [] = { /* TCI control word names */
"master reset", /* bit 0 */
"reset interrupt", /* bit 1 */
"scan", /* bit 2 */
"update", /* bit 3 */
NULL, /* bit 4 */
NULL, /* bit 5 */
NULL, /* bit 6 */
NULL, /* bit 7 */
"EC2", /* bit 8 */
"EC1", /* bit 9 */
"\1C2\0~C2", /* bit 10 */
"\1C1\0~C1", /* bit 11 */
"ES2", /* bit 12 */
"ES1", /* bit 13 */
"\1S2\0~S2", /* bit 14 */
"\1S1\0~S1" /* bit 15 */
};
static const BITSET_FORMAT tci_control_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tci_control_names, 0, msb_first, has_alt, no_bar) };
/* TCI status word.
0 | 1 2 3 | 4 5 6 | 7 8 9 |10 11 12 |13 14 15
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| - | 1 | I | 1 | channel | - | - | J | K | Y | Z | C | D |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
*/
#define CST_DIO_OK 0040000u /* direct I/O OK to use (always set) */
#define CST_IRQ 0020000u /* (I) interrupt request */
#define CST_ON 0010000u /* (always set) */
#define CST_CHAN_MASK 0007400u /* channel number mask */
#define CST_IX_MASK 0000060u /* status interrupt mask */
#define CST_I2 0000040u /* (J) S2 interrupt */
#define CST_I1 0000020u /* (K) S1 interrupt */
#define CST_ESX_MASK 0000014u /* status interrupt enable mask */
#define CST_ES2 0000010u /* (Y) S2 interrupt enable */
#define CST_ES1 0000004u /* (Z) S1 interrupt enable */
#define CST_SX_MASK 0000003u /* status mask */
#define CST_S2 0000002u /* (C) S2 status [DCD] */
#define CST_S1 0000001u /* (D) S1 status [DSR] */
#define CST_CHAN_SHIFT 8 /* channel number alignment shift */
#define CST_IX_SHIFT 4 /* status interrupt alignment shift */
#define CST_CHAN(n) ((n) << CST_CHAN_SHIFT & CST_CHAN_MASK)
#define CST_IX(i) ((i) << CST_IX_SHIFT & CST_IX_MASK)
static const BITSET_NAME tci_status_names [] = { /* TCI status word names */
"interrupt", /* bit 2 */
NULL, /* bit 3 */
NULL, /* bit 4 */
NULL, /* bit 5 */
NULL, /* bit 6 */
NULL, /* bit 7 */
NULL, /* bit 8 */
NULL, /* bit 9 */
"I2", /* bit 10 */
"I1", /* bit 11 */
"ES2", /* bit 12 */
"ES1", /* bit 13 */
"\1S2\0~S2", /* bit 14 */
"\1S1\0~S1" /* bit 15 */
};
static const BITSET_FORMAT tci_status_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tci_status_names, 0, msb_first, has_alt, no_bar) };
/* TCI #1 serial line bits */
#define RTS CCN_C2 /* TCI #1 C2 = Request to Send */
#define DTR CCN_C1 /* TCI #1 C1 = Data Terminal Ready */
#define DCD CCN_S2 /* TCI #1 S2 = Data Carrier Detect */
#define DSR CCN_S1 /* TCI #1 S1 = Data Set Ready */
static const BITSET_NAME tci_line_names [] = { /* TCI serial line status names */
"RTS", /* bit 10 */
"DTR", /* bit 11 */
NULL, /* bit 12 */
NULL, /* bit 13 */
"DCD", /* bit 14 */
"DSR" /* bit 15 */
};
static const BITSET_FORMAT tci_line_format = /* names, offset, direction, alternates, bar */
{ FMT_INIT (tci_line_names, 0, msb_first, no_alt, no_bar) };
/* ATC global state */
t_bool atc_is_polling = TRUE; /* TRUE if the ATC is polling for the simulation console */
/* TDI interface state */
static HP_WORD tdi_control_word = 0; /* control word */
static HP_WORD tdi_status_word = 0; /* status word */
static HP_WORD tdi_read_word = 0; /* read word */
static HP_WORD tdi_write_word = 0; /* write word */
static FLIP_FLOP tdi_interrupt_mask = SET; /* interrupt mask flip-flop */
static FLIP_FLOP tdi_data_flag = CLEAR; /* data flag */
static int32 fast_data_time = FAST_IO_TIME; /* fast receive/send time */
/* TDI per-channel state */
static HP_WORD recv_status [RECV_CHAN_COUNT]; /* receive status words */
static HP_WORD recv_param [RECV_CHAN_COUNT]; /* receive parameter words */
static HP_WORD recv_buffer [RECV_CHAN_COUNT]; /* receive character buffers */
static HP_WORD send_status [SEND_CHAN_COUNT]; /* send status words */
static HP_WORD send_param [SEND_CHAN_COUNT]; /* send parameter words */
static HP_WORD send_buffer [SEND_CHAN_COUNT]; /* send character buffers */
/* TCI interface state */
static HP_WORD tci_control_word = 0; /* control word */
static HP_WORD tci_status_word = 0; /* status word */
static uint32 tci_cntr = 0; /* channel counter */
static FLIP_FLOP tci_interrupt_mask = SET; /* interrupt mask flip-flop */
static FLIP_FLOP tci_scan = CLEAR; /* scanning enabled flip-flop */
/* TCI per-channel state */
static uint8 cntl_status [TERM_COUNT]; /* C2/C1/S2/S1 line status */
static uint8 cntl_param [TERM_COUNT]; /* ES2/ES1/S2/S1 parameter RAM */
/* ATC local SCP support routines */
static CNTLR_INTRF atcd_interface;
static CNTLR_INTRF atcc_interface;
static t_stat atc_set_endis (UNIT *uptr, int32 value, CONST char *cptr, void *desc);
static t_stat atc_set_mode (UNIT *uptr, int32 value, CONST char *cptr, void *desc);
static t_stat atc_show_mode (FILE *st, UNIT *uptr, int32 value, CONST void *desc);
static t_stat atc_show_status (FILE *st, UNIT *uptr, int32 value, CONST void *desc);
static t_stat atcd_reset (DEVICE *dptr);
static t_stat atcc_reset (DEVICE *dptr);
static t_stat atcd_attach (UNIT *uptr, CONST char *cptr);
static t_stat atcd_detach (UNIT *uptr);
/* ATC local utility routines */
static void tdi_set_interrupt (void);
static void tdi_master_reset (void);
static void tci_master_reset (void);
static t_stat line_service (UNIT *uptr);
static t_stat poll_service (UNIT *uptr);
static int32 activate_unit (UNIT *uptr, ACTIVATOR reason);
static uint32 service_time (HP_WORD control, ACTIVATOR reason);
static void store (HP_WORD control, HP_WORD data);
static void receive (int32 channel, int32 data, t_bool loopback);
static void diagnose (HP_WORD control, int32 data);
static void scan_channels (int32 channel);
static HP_WORD scan_status (void);
/* ATC SCP data structures */
DEVICE atcd_dev; /* incomplete device structure */
DEVICE atcc_dev; /* incomplete device structure */
/* Terminal multiplexer library structures.
The ATC uses the connection line order feature to bypass channel 0, which is
dedicated to the system console. For convenience, the system console is
connected to the simulation console. As such, it calls the console I/O
routines instead of the terminal multiplexer routines.
User-defined line order is not supported.
*/
static int32 atcd_order [TERM_COUNT] = { /* line connection order */
1, 1, 2, 3, 4, 5, 6, 7,
8, 9, 10, 11, 12, 13, 14, 15 };
static TMLN atcd_ldsc [TERM_COUNT] = { /* line descriptors */
{ 0 }
};
static TMXR atcd_mdsc = { /* multiplexer descriptor */
TERM_COUNT, /* number of terminal lines */
0, /* listening port (reserved) */
0, /* master socket (reserved) */
atcd_ldsc, /* line descriptors */
atcd_order, /* line connection order */
NULL /* multiplexer device (derived internally) */
};
/* Device information blocks */
static DIB atcd_dib = {
&atcd_interface, /* device interface */
7, /* device number */
SRNO_UNUSED, /* service request number */
0, /* interrupt priority */
INTMASK_E /* interrupt mask */
};
static DIB atcc_dib = {
&atcc_interface, /* device interface */
8, /* device number */
SRNO_UNUSED, /* service request number */
8, /* interrupt priority */
INTMASK_E /* interrupt mask */
};
/* Unit lists.
The first sixteen TDI units correspond to the sixteen multiplexer main
send/receive channels. These handle character I/O via the Telnet library. A
seventeenth unit is responsible for polling for connections and socket I/O.
It also holds the master socket.
Channel 0 is reserved for the system console and is connected to the
simulation console. As such, it's not likely to be using an HP terminal
emulator, so the default is CAPSLOCK input mode and 7P output mode. The
remainder of the channels default to NOCAPSLOCK and 7B, as they're likely to
be connected to HP terminals or terminal emulators. All channels initially
omit the UNIT_MODEM flag to allow the MPE terminal subtype configuration to
determine which channels support data sets and which do not.
The TDI line service routine runs only when there are characters to read or
write. It is scheduled either at a realistic rate corresponding to the
programmed baud rate of the channel to be serviced, or at a somewhat faster
optimized rate. The multiplexer connection and input poll must run
continuously, but it may operate much more slowly, as the only requirement is
that it must not present a perceptible lag to human input. It is coscheduled
with the process clock to permit idling. The poll unit is hidden by
disabling it, so as to present a logical picture of the multiplexer to the
user.
The TCI does not use any units, but a dummy one is defined to satisfy SCP
requirements.
Implementation notes:
1. There are no units corresponding to the auxiliary receive channels. This
is because reception isn't scheduled on these channels but instead occurs
concurrently with the main channel that is connected to the auxiliary
channels.
*/
static UNIT atcd_unit [UNIT_COUNT] = {
{ UDATA (&line_service, TT_MODE_7P | UNIT_LOCALACK | UNIT_CAPSLOCK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&line_service, TT_MODE_7B | UNIT_LOCALACK, 0) },
{ UDATA (&poll_service, UNIT_ATTABLE | UNIT_DIS | UNIT_IDLE, 0), POLL_TIME } /* multiplexer poll unit */
};
static UNIT atcc_unit [] = { /* a dummy unit to satisfy SCP requirements */
{ UDATA (NULL, 0, 0) }
};
/* Register lists.
The internal state of the TDI and TCI are exposed to the user and to ensure
that SAVE and RESTORE pick up the values. The user may set FTIME explicitly
as needed to accommodate software that does not work with the default
setting.
Implementation notes:
1. The TCI control and status line register definitions use the VM-defined
FBDATA macro. This macro defines a flag that is replicated in the same
bit position in each element of an array.
*/
static REG atcd_reg [] = {
/* Macro Name Location Radix Width Offset Depth Flags */
/* ------ ------ ------------------- ----- ----- ------ ---------------- --------------- */
{ ORDATA (CNTL, tdi_control_word, 16), REG_FIT },
{ ORDATA (STAT, tdi_status_word, 16), REG_FIT },
{ ORDATA (READ, tdi_read_word, 16), REG_X | REG_FIT },
{ ORDATA (WRITE, tdi_write_word, 16), REG_X | REG_FIT },
{ FLDATA (FLAG, tdi_data_flag, 0) },
{ FLDATA (MASK, tdi_interrupt_mask, 0) },
{ DRDATA (FTIME, fast_data_time, 24), PV_LEFT },
{ BRDATA (RSTAT, recv_status, 8, 16, RECV_CHAN_COUNT) },
{ BRDATA (RPARM, recv_param, 8, 16, RECV_CHAN_COUNT) },
{ BRDATA (RBUFR, recv_buffer, 8, 16, RECV_CHAN_COUNT), REG_X },
{ BRDATA (SSTAT, send_status, 8, 16, SEND_CHAN_COUNT) },
{ BRDATA (SPARM, send_param, 8, 16, SEND_CHAN_COUNT) },
{ BRDATA (SBUFR, send_buffer, 8, 16, SEND_CHAN_COUNT), REG_X },
{ FLDATA (POLL, atc_is_polling, 0), REG_HRO },
DIB_REGS (atcd_dib),
{ NULL }
};
static REG atcc_reg [] = {
/* Macro Name Location Width Offset Depth Flags */
/* ------ ------ ------------------- ----- ------ ---------- ------- */
{ ORDATA (CNTL, tci_control_word, 16), REG_FIT },
{ ORDATA (STAT, tci_status_word, 16), REG_FIT },
{ DRDATA (CNTR, tci_cntr, 4) },
{ FLDATA (SCAN, tci_scan, 0) },
{ FLDATA (MASK, tci_interrupt_mask, 0) },
{ FBDATA (C2, cntl_status, 5, TERM_COUNT, PV_RZRO) },
{ FBDATA (C1, cntl_status, 4, TERM_COUNT, PV_RZRO) },
{ FBDATA (S2, cntl_status, 1, TERM_COUNT, PV_RZRO) },
{ FBDATA (S1, cntl_status, 0, TERM_COUNT, PV_RZRO) },
{ FBDATA (ES2, cntl_param, 3, TERM_COUNT, PV_RZRO) },
{ FBDATA (ES1, cntl_param, 2, TERM_COUNT, PV_RZRO) },
{ FBDATA (MS2, cntl_param, 1, TERM_COUNT, PV_RZRO) },
{ FBDATA (MS1, cntl_param, 0, TERM_COUNT, PV_RZRO) },
DIB_REGS (atcc_dib),
{ NULL }
};
/* Modifier lists */
typedef enum {
Fast_Time,
Real_Time,
Terminal,
Diagnostic
} DEVICE_MODES;
static MTAB atcd_mod [] = {
/* Mask Value Match Value Print String Match String Validation Display Descriptor */
/* ------------- ------------- ---------------- ------------ ---------- ------- ---------- */
{ UNIT_MODEM, UNIT_MODEM, "data set", NULL, NULL, NULL, NULL },
{ UNIT_MODEM, 0, "direct", NULL, NULL, NULL, NULL },
{ UNIT_LOCALACK, UNIT_LOCALACK, "local ENQ/ACK", "LOCALACK", NULL, NULL, NULL },
{ UNIT_LOCALACK, 0, "remote ENQ/ACK", "REMOTEACK", NULL, NULL, NULL },
{ UNIT_CAPSLOCK, UNIT_CAPSLOCK, "CAPS LOCK down", "CAPSLOCK", NULL, NULL, NULL },
{ UNIT_CAPSLOCK, 0, "CAPS LOCK up", "NOCAPSLOCK", NULL, NULL, NULL },
{ TT_MODE, TT_MODE_UC, "UC output", "UC", NULL, NULL, NULL },
{ TT_MODE, TT_MODE_7B, "7b output", "7B", NULL, NULL, NULL },
{ TT_MODE, TT_MODE_7P, "7p output", "7P", NULL, NULL, NULL },
{ TT_MODE, TT_MODE_8B, "8b output", "8B", NULL, NULL, NULL },
/* Entry Flags Value Print String Match String Validation Display Descriptor */
/* -------------------- ----------- ------------- ------------ --------------- ---------------- ------------------- */
{ MTAB_XUN | MTAB_NC, 0, "LOG", "LOG", &tmxr_set_log, &tmxr_show_log, (void *) &atcd_mdsc },
{ MTAB_XUN | MTAB_NC, 0, NULL, "NOLOG", &tmxr_set_nolog, NULL, (void *) &atcd_mdsc },
{ MTAB_XUN, 0, NULL, "DISCONNECT", &tmxr_dscln, NULL, (void *) &atcd_mdsc },
{ MTAB_XDV, Fast_Time, NULL, "FASTTIME", &atc_set_mode, NULL, (void *) &atcd_dev },
{ MTAB_XDV, Real_Time, NULL, "REALTIME", &atc_set_mode, NULL, (void *) &atcd_dev },
{ MTAB_XDV, Terminal, NULL, "TERMINAL", &atc_set_mode, NULL, (void *) &atcd_dev },
{ MTAB_XDV, Diagnostic, NULL, "DIAGNOSTIC", &atc_set_mode, NULL, (void *) &atcd_dev },
{ MTAB_XDV, 0, "MODES", NULL, NULL, &atc_show_mode, (void *) &atcd_dev },
{ MTAB_XDV, 0, "", NULL, NULL, &atc_show_status, (void *) &atcd_mdsc },
{ MTAB_XDV | MTAB_NMO, 1, "CONNECTIONS", NULL, NULL, &tmxr_show_cstat, (void *) &atcd_mdsc },
{ MTAB_XDV | MTAB_NMO, 0, "STATISTICS", NULL, NULL, &tmxr_show_cstat, (void *) &atcd_mdsc },
{ MTAB_XDV, VAL_DEVNO, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &atcd_dib },
{ MTAB_XDV, VAL_INTMASK, "INTMASK", "INTMASK", &hp_set_dib, &hp_show_dib, (void *) &atcd_dib },
{ MTAB_XDV, VAL_INTPRI, "INTPRI", "INTPRI", &hp_set_dib, &hp_show_dib, (void *) &atcd_dib },
{ MTAB_XDV | MTAB_NMO, 1, NULL, "ENABLED", &atc_set_endis, NULL, NULL },
{ MTAB_XDV | MTAB_NMO, 0, NULL, "DISABLED", &atc_set_endis, NULL, NULL },
{ 0 }
};
static MTAB atcc_mod [] = {
/* Entry Flags Value Print String Match String Validation Display Descriptor */
/* ----------- ----------- ------------ ------------ ------------- -------------- ------------------ */
{ MTAB_XDV, Terminal, NULL, "TERMINAL", &atc_set_mode, NULL, (void *) &atcc_dev },
{ MTAB_XDV, Diagnostic, NULL, "DIAGNOSTIC", &atc_set_mode, NULL, (void *) &atcc_dev },
{ MTAB_XDV, 1, "MODES", NULL, NULL, &atc_show_mode, (void *) &atcc_dev },
{ MTAB_XDV, VAL_DEVNO, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &atcc_dib },
{ MTAB_XDV, VAL_INTMASK, "INTMASK", "INTMASK", &hp_set_dib, &hp_show_dib, (void *) &atcc_dib },
{ MTAB_XDV, VAL_INTPRI, "INTPRI", "INTPRI", &hp_set_dib, &hp_show_dib, (void *) &atcc_dib },
{ 0 }
};
/* Debugging trace lists */
static DEBTAB atcd_deb [] = {
{ "CSRW", DEB_CSRW }, /* Interface control, status, read, and write actions */
{ "SERV", DEB_SERV }, /* Channel unit service scheduling calls */
{ "PSERV", DEB_PSERV }, /* Poll unit service scheduling calls */
{ "XFER", DEB_XFER }, /* Data receptions and transmissions */
{ "IOBUS", DEB_IOB }, /* Interface I/O bus signals and data words */
{ NULL, 0 }
};
static DEBTAB atcc_deb [] = {
{ "CSRW", DEB_CSRW }, /* Interface control, status, read, and write actions */
{ "PSERV", DEB_PSERV }, /* Poll unit service scheduling calls */
{ "XFER", DEB_XFER }, /* Control and status line changes */
{ "IOBUS", DEB_IOB }, /* Interface I/O bus signals and data words */
{ NULL, 0 }
};
/* Device descriptors.
Both devices may be disabled. However, we want to be able to disable the TDI
while it is polling for the simulation console, which the standard SCP
routine will not do (it refuses if any unit is active). So we define our own
DISABLED and ENABLED modifiers and a validation routine that sets or clears
the DEV_DIS flag and then calls atcd_reset. The reset routine cancels or
reenables the poll as indicated.
Implementation notes:
1. The ATCD device does not specify the DEV_DISABLE flag to avoid the
DISABLED and ENABLED modifiers from being listed twice for a SHOW ATCD
MODIFIERS command. SIMH 3.9 tested for user-defined ENABLED/DISABLED
modifiers and skipped the printing that results from specifying
DEV_DISABLE. SIMH 4.0 no longer does this, so we omit the flag to
suppress the duplicate printing (the flag is otherwise used only to
validate the SET DISABLED command).
*/
DEVICE atcd_dev = {
"ATCD", /* device name */
atcd_unit, /* unit array */
atcd_reg, /* register array */
atcd_mod, /* modifier array */
UNIT_COUNT, /* number of units */
10, /* address radix */
PA_WIDTH, /* address width */
1, /* address increment */
8, /* data radix */
DV_WIDTH, /* data width */
&tmxr_ex, /* examine routine */
&tmxr_dep, /* deposit routine */
&atcd_reset, /* reset routine */
NULL, /* boot routine */
&atcd_attach, /* attach routine */
&atcd_detach, /* detach routine */
&atcd_dib, /* device information block pointer */
DEV_DEBUG, /* device flags */
0, /* debug control flags */
atcd_deb, /* debug flag name array */
NULL, /* memory size change routine */
NULL }; /* logical device name */
DEVICE atcc_dev = {
"ATCC", /* device name */
atcc_unit, /* unit array */
atcc_reg, /* register array */
atcc_mod, /* modifier array */
1, /* number of units */
10, /* address radix */
PA_WIDTH, /* address width */
1, /* address increment */
8, /* data radix */
DV_WIDTH, /* data width */
NULL, /* examine routine */
NULL, /* deposit routine */
&atcc_reset, /* reset routine */
NULL, /* boot routine */
NULL, /* attach routine */
NULL, /* detach routine */
&atcc_dib, /* device information block pointer */
DEV_DEBUG | DEV_DISABLE, /* device flags */
0, /* debug control flags */
atcc_deb, /* debug flag name array */
NULL, /* memory size change routine */
NULL }; /* logical device name */
/* ATC local SCP support routines */
/* TDI interface.
The interface is installed on the IOP bus and receives direct I/O commands
from the IOP. In simulation, the asserted signals on the bus are represented
as bits in the inbound_signals set. Each signal is processed sequentially in
numerical order, and a set of similar outbound_signals is assembled and
returned to the caller, simulating assertion of the corresponding backplane
signals.
Before a channel can receive or send, it must be configured. The number of
the channel to configure is set via a CIO instruction, followed by parameters
for baud rate and character size via WIO instructions. Data to be sent is
passed to the interface via WIO, while received data is picked up with RIO
instructions.
When a channel has completed sending or receiving a character, it will set
its completion flag. If the TDI data flag is clear, indicating that all
prior interrupts have been serviced, a scan of the serviced channel is made
to see if the channel is enabled to interrupt. If it is, the TDI data flag
will be set, the channel flag will be cleared, and an interrupt will be
requested. When the interrupt is serviced and acknowledged, the flag will be
cleared, and the scan will continue to look for other channel flags.
The status word is set during the scan to reflect the interrupting channel
status. If status bit 3 (DST_COMPLETE) is clear, then status bits 5, 6, and
7 (DST_SEND_IRQ, DST_CHAR_LOST, and DST_BREAK) retain their values from the
prior send or receive interrupt.
Implementation notes:
1. In hardware, the DIO OK status bit (bit 1) is denied when a store to the
recirculating memory is pending and is reasserted once the designated
channel rotates into the window and the parameter or data is stored. The
duration of the denial varies from 0 to 69.44 microseconds, depending on
the location of the window in memory when DWRITESTB is asserted. In
simulation, DIO OK is always asserted.
2. Receipt of a DRESETINT signal clears the interrupt request and active
flip-flops but does not cancel a request pending but not yet serviced by
the IOP. However, when the IOP does service the request by asserting
INTPOLLIN, the interface routine returns INTPOLLOUT, which will cancel
the request.
*/
static SIGNALS_DATA atcd_interface (DIB *dibptr, INBOUND_SET inbound_signals, HP_WORD inbound_value)
{
INBOUND_SIGNAL signal;
INBOUND_SET working_set = inbound_signals;
HP_WORD outbound_value = 0;
OUTBOUND_SET outbound_signals = NO_SIGNALS;
dprintf (atcd_dev, DEB_IOB, "Received data %06o with signals %s\n",
inbound_value, fmt_bitset (inbound_signals, inbound_format));
while (working_set) { /* while signals remain */
signal = IONEXTSIG (working_set); /* isolate the next signal */
switch (signal) { /* dispatch the I/O signal */
case DCONTSTB:
dprintf (atcd_dev, DEB_CSRW, (inbound_value & DCN_ENABLE
? "Control is %s | channel %u\n"
: "Control is %s\n"),
fmt_bitset (inbound_value, tdi_control_format),
DCN_CHAN (inbound_value));
tdi_control_word = inbound_value; /* save the control word */
if (tdi_control_word & DCN_MR) /* if master reset is requested */
tdi_master_reset (); /* then perform an I/O reset */
if (tdi_control_word & DCN_IRQ_RESET) /* if reset interrupt is requested */
dibptr->interrupt_request = CLEAR; /* then clear the interrupt request */
if (tdi_control_word & DCN_ENABLE) /* if output is enabled */
store (tdi_control_word, tdi_write_word); /* then store the parameter or data word */
if (tdi_control_word & DCN_ACKN) { /* if acknowledge interrupt is requested */
tdi_data_flag = CLEAR; /* then clear the data flag */
scan_channels (SCAN_ALL); /* scan all channels for a new interrupt request */
}
break;
case DSTATSTB:
tdi_status_word |= DST_DIO_OK; /* the interface is always ready for commands */
if (dibptr->interrupt_request == SET) /* reflect the interrupt request value */
tdi_status_word |= DST_IRQ; /* in the status word */
else /* to indicate */
tdi_status_word &= ~DST_IRQ; /* whether or not a request is pending */
if (tdi_data_flag == SET) /* reflect the data flag value */
tdi_status_word |= DST_COMPLETE; /* in the status word */
else /* to indicate */
tdi_status_word &= ~DST_COMPLETE; /* whether or not a channel has completed */
outbound_value = tdi_status_word; /* return the status word */
dprintf (atcd_dev, DEB_CSRW, "Status is %s\n",
fmt_bitset (outbound_value, tdi_status_format));
break;
case DWRITESTB:
tdi_write_word = inbound_value; /* save the data or parameter word */
if (DPRINTING (atcd_dev, DEB_CSRW))
if (inbound_value & DPI_IS_PARAM)
hp_debug (&atcd_dev, DEB_CSRW, "Parameter is %s%u bits | %u baud\n",
fmt_bitset (inbound_value, tdi_parameter_format),
bits_per_char [DPI_CHAR_SIZE (inbound_value)],
BAUD_RATE (inbound_value));
else
hp_debug (&atcd_dev, DEB_CSRW, "Output data is %s%04o\n",
fmt_bitset (inbound_value, tdi_output_data_format),
DDS_DATA (inbound_value));
break;
case DREADSTB:
outbound_value = tdi_read_word; /* return the data word */
dprintf (atcd_dev, DEB_CSRW, "Input data is channel %u | %s%04o\n",
DDR_TO_CHAN (outbound_value),
fmt_bitset (outbound_value, tdi_input_data_format),
DDR_TO_DATA (outbound_value));
break;
case DSETINT:
dibptr->interrupt_request = SET; /* request an interrupt */
if (tdi_interrupt_mask) /* if the interrupt mask is satisfied */
outbound_signals |= INTREQ; /* then assert the INTREQ signal */
break;
case DRESETINT:
dibptr->interrupt_active = CLEAR; /* reset the interrupt active flip-flop */
break;
case INTPOLLIN:
if (dibptr->interrupt_request) { /* if a request is pending */
dibptr->interrupt_request = CLEAR; /* then clear it */
dibptr->interrupt_active = SET; /* and mark it now active */
outbound_signals |= INTACK; /* acknowledge the interrupt */
outbound_value = dibptr->device_number; /* and return our device number */
}
else /* otherwise the request has been reset */
outbound_signals |= INTPOLLOUT; /* so let the IOP know to cancel it */
break;
case DSETMASK:
if (dibptr->interrupt_mask == INTMASK_E) /* if the mask is always enabled */
tdi_interrupt_mask = SET; /* then set the mask flip-flop */
else /* otherwise */
tdi_interrupt_mask = D_FF (dibptr->interrupt_mask /* set the mask flip-flop if the mask bit */
& inbound_value); /* is present in the mask value */
if (tdi_interrupt_mask && dibptr->interrupt_request) /* if the mask is enabled and a request is pending */
outbound_signals |= INTREQ; /* then assert INTREQ */
break;
case DSTARTIO: /* not used by this interface */
case XFERERROR: /* not used by this interface */
case ACKSR: /* not used by this interface */
case TOGGLESR: /* not used by this interface */
case TOGGLESIOOK: /* not used by this interface */
case TOGGLEINXFER: /* not used by this interface */
case TOGGLEOUTXFER: /* not used by this interface */
case READNEXTWD: /* not used by this interface */
case PREADSTB: /* not used by this interface */
case PWRITESTB: /* not used by this interface */
case PCMD1: /* not used by this interface */
case PCONTSTB: /* not used by this interface */
case PSTATSTB: /* not used by this interface */
case DEVNODB: /* not used by this interface */
case SETINT: /* not used by this interface */
case EOT: /* not used by this interface */
case SETJMP: /* not used by this interface */
case CHANSO: /* not used by this interface */
case PFWARN: /* not used by this interface */
break;
}
IOCLEARSIG (working_set, signal); /* remove the current signal from the set */
}
dprintf (atcd_dev, DEB_IOB, "Returned data %06o with signals %s\n",
outbound_value, fmt_bitset (outbound_signals, outbound_format));
return IORETURN (outbound_signals, outbound_value); /* return the outbound signals and value */
}
/* TCI interface.
The interface is installed on the IOP bus and receives direct I/O commands
from the IOP. In simulation, the asserted signals on the bus are represented
as bits in the inbound_signals set. Each signal is processed sequentially in
numerical order, and a set of similar outbound_signals is assembled and
returned to the caller, simulating assertion of the corresponding backplane
signals. For this interface, a read order executes identically to a test
order, and a write order is ignored.
The control word contains three independent enables that affect the
interpretation of the rest of the word. Bit 3 (CCN_UPDATE) must be set to
enable storing bits 12-15 (CCN_ES2/1 and CCN_S2/1) into the state RAM. Bits
8 (CCN_EC2) and 9 (CCN_EC1) must be set to enable storing bits 10 (CCN_C2)
and 11 (CCN_C1), respectively, into the addressable latch. If none of these
enables are set, then only bits 0-2 are interpreted.
Implementation notes:
1. The cntl_status array contains the values for the serial device control
and status lines. The line bit positions in the array correspond to the
C2/C1 and S2/S1 positions in the control word.
2. A control word write directed to a given channel sets that channel's
UNIT_MODEM flag to indicate that the serial line status should be
updated at each input poll service.
3. The terminal multiplexer library will disconnect an associated Telnet
session if DTR is dropped.
4. Receipt of a DRESETINT signal clears the interrupt request and active
flip-flops but does not cancel a request pending but not yet serviced by
the IOP. However, when the IOP does service the request by asserting
INTPOLLIN, the interface routine returns INTPOLLOUT, which will cancel
the request.
*/
static SIGNALS_DATA atcc_interface (DIB *dibptr, INBOUND_SET inbound_signals, HP_WORD inbound_value)
{
INBOUND_SIGNAL signal;
INBOUND_SET working_set = inbound_signals;
HP_WORD outbound_value = 0;
OUTBOUND_SET outbound_signals = NO_SIGNALS;
int32 set_lines, clear_lines;
dprintf (atcc_dev, DEB_IOB, "Received data %06o with signals %s\n",
inbound_value, fmt_bitset (inbound_signals, inbound_format));
while (working_set) { /* while signals remain */
signal = IONEXTSIG (working_set); /* isolate the next signal */
switch (signal) { /* dispatch the I/O signal */
case DCONTSTB:
tci_cntr = CCN_CHAN (inbound_value); /* set the counter to the target channel */
dprintf (atcc_dev, DEB_CSRW, "Control is channel %u | %s\n",
tci_cntr, fmt_bitset (inbound_value, tci_control_format));
tci_control_word = inbound_value; /* save the control word */
line_unit [tci_cntr].flags |= UNIT_MODEM; /* set the modem control flag on this unit */
if (tci_control_word & CCN_MR) /* if master reset is requested */
tci_master_reset (); /* then perform an I/O reset */
if (tci_control_word & CCN_IRQ_RESET) /* if reset interrupt is requested */
dibptr->interrupt_request = CLEAR; /* then clear the interrupt request */
cntl_status [tci_cntr] = cntl_status [tci_cntr] /* set the control lines */
& ~CCN_ECX (tci_control_word) /* that are enabled for output */
| CCN_CX_MASK /* to the control bits */
& CCN_ECX (tci_control_word) /* that are enabled */
& tci_control_word; /* in the control word */
dprintf (atcc_dev, DEB_XFER, "Channel %u line status is %s\n",
tci_cntr, fmt_bitset (cntl_status [tci_cntr], tci_line_format));
if (atcc_dev.flags & DEV_DIAG) { /* if the interface is in diagnostic mode */
cntl_status [tci_cntr ^ 1] = /* then loop the control lines */
cntl_status [tci_cntr ^ 1] & ~CCN_SX_MASK /* back to the alternate channel */
| CCN_CX (cntl_status [tci_cntr]); /* from the selected channel */
dprintf (atcc_dev, DEB_XFER, "Channel %u line status is %s\n",
tci_cntr ^ 1, fmt_bitset (cntl_status [tci_cntr ^ 1], tci_line_format));
}
else if (tci_control_word & CCN_ECX_MASK) { /* otherwise if either control line is enabled */
set_lines = 0; /* then prepare the multiplexer library to set */
clear_lines = 0; /* the modem status (either real or simulated) */
if (tci_control_word & CCN_EC2) /* if control line 2 is enabled for output */
if (RTS & cntl_status [tci_cntr]) /* then if the line is asserted */
set_lines |= TMXR_MDM_RTS; /* then set the RTS line up */
else /* otherwise */
clear_lines |= TMXR_MDM_RTS; /* set it down */
if (tci_control_word & CCN_EC1) /* if control line 1 is enabled for output */
if (DTR & cntl_status [tci_cntr]) /* then if the line is asserted */
set_lines |= TMXR_MDM_DTR; /* then set the DTR line up */
else { /* otherwise */
clear_lines |= TMXR_MDM_DTR; /* set it down */
if (cntl_status [tci_cntr] & DCD) /* setting DTR down will disconnect the channel */
dprintf (atcc_dev, DEB_CSRW, "Channel %u disconnected by DTR drop\n",
tci_cntr);
}
tmxr_set_get_modem_bits (&atcd_ldsc [tci_cntr], /* tell the multiplexer library */
set_lines, clear_lines, /* to set or clear the indicated lines */
NULL); /* and omit returning the current status */
}
if (tci_control_word & CCN_UPDATE) /* if the status output is enabled */
cntl_param [tci_cntr] = tci_control_word /* then store the status line enables and states */
& CCN_STAT_MASK; /* in the parameter RAM */
tci_scan = D_FF (tci_control_word & CCN_SCAN); /* set or clear the scan flip-flop as directed */
if (tci_scan) /* if scanning is enabled */
scan_status (); /* then look for channel status changes */
break;
case DREADSTB: /* RIO and TIO return the same value */
case DSTATSTB:
tci_status_word = CST_DIO_OK | CST_ON /* form the status word */
| CST_CHAN (tci_cntr)
| cntl_param [tci_cntr] & CST_ESX_MASK
| cntl_status [tci_cntr] & CST_SX_MASK
| scan_status ();
if (dibptr->interrupt_request == SET) /* reflect the interrupt request value */
tci_status_word |= CST_IRQ; /* in the status word */
outbound_value = tci_status_word; /* return the status word */
dprintf (atcc_dev, DEB_CSRW, "Status is channel %u | %s\n",
tci_cntr, fmt_bitset (outbound_value, tci_status_format));
break;
case DSETINT:
dibptr->interrupt_request = SET; /* request an interrupt */
if (tci_interrupt_mask) /* if the interrupt mask is satisfied */
outbound_signals |= INTREQ; /* then assert the INTREQ signal */
break;
case DRESETINT:
dibptr->interrupt_active = CLEAR; /* reset the interrupt active flip-flop */
break;
case INTPOLLIN:
if (dibptr->interrupt_request) { /* if a request is pending */
dibptr->interrupt_request = CLEAR; /* then clear it */
dibptr->interrupt_active = SET; /* and mark it now active */
outbound_signals |= INTACK; /* acknowledge the interrupt */
outbound_value = dibptr->device_number; /* and return our device number */
}
else /* otherwise the request has been reset */
outbound_signals |= INTPOLLOUT; /* so let the IOP know to cancel it */
break;
case DSETMASK:
if (dibptr->interrupt_mask == INTMASK_E) /* if the mask is always enabled */
tci_interrupt_mask = SET; /* then set the mask flip-flop */
else /* otherwise */
tci_interrupt_mask = D_FF (dibptr->interrupt_mask /* set the mask flip-flop if the mask bit */
& inbound_value); /* is present in the mask value */
if (tci_interrupt_mask && dibptr->interrupt_request) /* if the mask is enabled and a request is pending */
outbound_signals |= INTREQ; /* then assert INTREQ */
break;
case DWRITESTB: /* not used by this interface */
case DSTARTIO: /* not used by this interface */
case XFERERROR: /* not used by this interface */
case ACKSR: /* not used by this interface */
case TOGGLESR: /* not used by this interface */
case TOGGLESIOOK: /* not used by this interface */
case TOGGLEINXFER: /* not used by this interface */
case TOGGLEOUTXFER: /* not used by this interface */
case READNEXTWD: /* not used by this interface */
case PREADSTB: /* not used by this interface */
case PWRITESTB: /* not used by this interface */
case PCMD1: /* not used by this interface */
case PCONTSTB: /* not used by this interface */
case PSTATSTB: /* not used by this interface */
case DEVNODB: /* not used by this interface */
case SETINT: /* not used by this interface */
case EOT: /* not used by this interface */
case SETJMP: /* not used by this interface */
case CHANSO: /* not used by this interface */
case PFWARN: /* not used by this interface */
break;
}
IOCLEARSIG (working_set, signal); /* remove the current signal from the set */
}
dprintf (atcc_dev, DEB_IOB, "Returned data %06o with signals %s\n",
outbound_value, fmt_bitset (outbound_signals, outbound_format));
return IORETURN (outbound_signals, outbound_value); /* return the outbound signals and value */
}
/* Enable or disable the TDI.
This validation routine is entered with "value" set to 1 for an ENABLE and 0
for a DISABLE, and "cptr" pointing to the next character after the keyword.
If the TDI is already enabled or disabled, respectively, the routine returns
with no further action. Otherwise, if "value" is 1, the device is enabled by
clearing the DEV_DIS flag, and the polling flag is set TRUE to indicate that
the TDI is polling for the simulation console. If "value" is 0, a check is
made to see if the TDI is listening for connections. If it is, the disable
request is rejected; the device must be detached first. Otherwise, the
device is disabled by setting the DEV_DIS flag, and the polling flag is set
FALSE to indicate that the TDI is no longer polling for the simulation
console (the PCLK device will take over when the polling flag is FALSE).
In either case, the device is reset, which will restart or cancel the poll,
as appropriate.
*/
static t_stat atc_set_endis (UNIT *uptr, int32 value, CONST char *cptr, void *desc)
{
if (value) /* if this is an ENABLE request */
if (atcd_dev.flags & DEV_DIS) { /* then if the device is disabled */
atcd_dev.flags &= ~DEV_DIS; /* then reenable it */
atc_is_polling = TRUE; /* and set the polling flag */
}
else /* otherwise the device is already enabled */
return SCPE_OK; /* so there's nothing to do */
else /* otherwise this is a DISABLE request */
if (atcd_dev.flags & DEV_DIS) /* so if the device is already disabled */
return SCPE_OK; /* so there's nothing to do */
else if (poll_unit.flags & UNIT_ATT) /* otherwise if the poll unit is still attached */
return SCPE_NOFNC; /* then report that the command failed */
else { /* otherwise */
atcd_dev.flags |= DEV_DIS; /* disable the device */
atc_is_polling = FALSE; /* and clear the polling flag */
}
return atcd_reset (&atcd_dev); /* reset the TDI and restart or cancel polling */
}
/* Set the device modes.
The device flag implied by the DEVICE_MODES "value" passed to the routine is
set or cleared in the device specified by the "desc" parameter. The unit and
character pointers are not used.
Implementation notes:
1. In hardware, terminals and modems must be disconnected from the ATC and
loopback cables installed between each pair or channels when the
diagnostic is run. In simulation, setting DIAG mode detaches any
existing listening port, so that Telnet sessions will not interfere with
the internal loopback connections from the send to the receive channels.
*/
static t_stat atc_set_mode (UNIT *uptr, int32 value, CONST char *cptr, void *desc)
{
DEVICE * const dptr = (DEVICE *) desc; /* a pointer to the device */
switch ((DEVICE_MODES) value) { /* dispatch based on the mode to set */
case Fast_Time: /* entering optimized timing mode */
dptr->flags &= ~DEV_REALTIME; /* so clear the real-time flag */
break;
case Real_Time: /* entering realistic timing mode */
dptr->flags |= DEV_REALTIME; /* so set the flag */
break;
case Terminal: /* entering terminal mode */
dptr->flags &= ~DEV_DIAG; /* so clear the diagnostic flag */
break;
case Diagnostic: /* entering the diagnostic mode */
dptr->flags |= DEV_DIAG; /* so set the flag */
if (dptr == &atcd_dev) /* if we're setting the TDI mode */
atcd_detach (&poll_unit); /* then detach any existing connections */
break;
}
return SCPE_OK;
}
/* Show the device modes.
The output stream and device pointer are passed in the "st" and "desc"
parameters, respectively. If "value" is 0, then all of the flags are checked
for the TDI. If "value" is 1, then only the diagnostic flag is checked for
the TCI. The unit pointer is not used.
*/
static t_stat atc_show_mode (FILE *st, UNIT *uptr, int32 value, CONST void *desc)
{
const DEVICE * const dptr = (const DEVICE *) desc; /* a pointer to the device */
if (value == 0) /* if this is the TDI */
if (dptr->flags & DEV_REALTIME) /* then if the real-time flag is set */
fputs ("realistic timing, ", st); /* then report that we are using realistic timing */
else /* otherwise */
fputs ("fast timing, ", st); /* report that we are using optimized timing */
if (dptr->flags & DEV_DIAG) /* if the diagnostic flag is set */
fputs ("diagnostic mode", st); /* then report that we're in loopback mode */
else /* otherwise */
fputs ("terminal mode", st); /* we're in normal (terminal) mode */
return SCPE_OK;
}
/* Show the TDI device status.
The attachment condition and connection count are printed to the stream
specified by "st" as part of the ATCD device display. The "desc" parameter
is a pointer to the terminal multiplexer library descriptor; the unit pointer
and value parameters are not used.
*/
static t_stat atc_show_status (FILE *st, UNIT *uptr, int32 value, CONST void *desc)
{
if (poll_unit.flags & UNIT_ATT) /* if the poll unit is attached */
fprintf (st, "attached to port %s, ", /* then report it */
poll_unit.filename); /* with the listening port number */
else /* otherwise */
fprintf (st, "not attached, "); /* report the condition */
tmxr_show_summ (st, uptr, value, desc); /* also report the count of connections */
return SCPE_OK;
}
/* TDI device reset.
This routine is called for a RESET or RESET ATCD command. It is the
simulation equivalent of the IORESET signal, which is asserted by the front
panel LOAD and DUMP switches.
If a power-on reset (RESET -P) is being done, the poll timer is initialized.
In addition, the original FASTTIME setting is restored, in case it's been
changed by the user.
If the polling flag is set, then start or resynchronize the poll unit with
the process clock to enable idling. If the CPU process clock is calibrated,
then the poll event service is synchronized with the process clock service.
Otherwise, the service time is set up but is otherwise asynchronous with the
process clock.
If the polling flag is clear, then the poll is stopped, as it's not needed.
Implementation notes:
1. To synchronize events, the poll must be activated absolutely, as a
service event may already be scheduled, and normal activation will not
disturb an existing event.
*/
static t_stat atcd_reset (DEVICE *dptr)
{
tdi_master_reset (); /* perform a master reset */
if (sim_switches & SWMASK ('P')) { /* if this is a power-on reset */
sim_rtcn_init (poll_unit.wait, TMR_ATC); /* then initialize the poll timer */
fast_data_time = FAST_IO_TIME; /* restore the initial fast data time */
atcd_ldsc [0].xmte = 1; /* enable transmission on the system console port */
}
if (atc_is_polling) { /* if we're polling for the simulation console */
if (cpu_is_calibrated) /* then if the process clock is calibrated */
poll_unit.wait = sim_activate_time (cpu_pclk_uptr); /* then synchronize with it */
else /* otherwise */
poll_unit.wait = POLL_TIME; /* set up an independent poll time */
sim_activate_abs (&poll_unit, poll_unit.wait); /* restart the poll timer */
}
else /* otherwise */
sim_cancel (&poll_unit); /* cancel the poll */
return SCPE_OK;
}
/* TCI device reset.
This routine is called for a RESET or RESET ATCC command. It is the
simulation equivalent of the IORESET signal, which is asserted by the front
panel LOAD and DUMP switches.
If a power-on reset (RESET -P) is being done, then local modem control is
established by setting DTR on all channels. This is necessary so that
channels not controlled by the TCI will be able to connect (TCI-controlled
channels will have their DTR and RTS state set by the MPE TCI initialization
routine).
*/
static t_stat atcc_reset (DEVICE *dptr)
{
uint32 channel;
tci_master_reset (); /* perform a master reset */
if (sim_switches & SWMASK ('P')) { /* if this is a power-on reset */
for (channel = 0; channel < TERM_COUNT; channel++) /* then for each terminal channel */
tmxr_set_get_modem_bits (&atcd_ldsc [channel], /* set the DTR line on */
TMXR_MDM_DTR, /* to allow non-TCI channels to connect */
0, NULL);
}
return SCPE_OK;
}
/* Attach the TDI to a Telnet listening port.
This routine is called by the ATTACH ATCD <port> command to attach the TDI to
the listening port indicated by <port>. Logically, it is the ATCD device
that is attached; however, SIMH only allows units to be attached. This makes
sense for devices such as tape drives, where the attached media is a property
of a specific drive. In our case, though, the listening port is a property
of the TDI card, not of any given serial line. As ATTACH ATCD is equivalent
to ATTACH ATCD0, the port would, by default, be attached to the first channel
and be reported there in a SHOW ATCD command.
To preserve the logical picture, we attach the port to the Telnet poll unit,
which is normally disabled to inhibit its display. Attaching to a disabled
unit is not allowed, so we first enable the unit, then attach it, then
disable it again. Attachment is reported by the "atc_show_status" routine.
A direct attach to the poll unit is allowed only when restoring a previously
saved session via the RESTORE command.
*/
static t_stat atcd_attach (UNIT *uptr, CONST char *cptr)
{
t_stat status;
if (atcd_dev.flags & DEV_DIAG) /* if the TDI is in diagnostic mode */
return SCPE_NOFNC; /* then the command is not allowed */
if (uptr != line_unit /* if we're not attaching unit 0 */
&& (uptr != &poll_unit || !(sim_switches & SIM_SW_REST))) /* and not we're not restoring the poll unit */
return SCPE_NOATT; /* then the unit specified is not attachable */
poll_unit.flags &= ~UNIT_DIS; /* enable the poll unit */
status = tmxr_attach (&atcd_mdsc, &poll_unit, cptr); /* and attach it to the specified listening port */
poll_unit.flags |= UNIT_DIS; /* and then disable it again */
return status;
}
/* Detach the TDI.
Normally, this routine is called by the DETACH ATCD command, which is
equivalent to DETACH ATCD0. However, it may be called with other units in
three cases.
A DETACH ALL command will call us for unit 16 (the poll unit) if it is
attached. A RESTORE command also will call us for unit 16 if it is attached.
In the latter case, the terminal channels will have already been rescheduled
as appropriate, so canceling them is skipped. Also, during simulator
shutdown, we will be called for units 0-15 (detach_all in scp.c calls the
detach routines of all units that do NOT have UNIT_ATTABLE), as well as for
unit 16 if it is attached. In all cases, it is imperative that we not reject
the request for unit 16; otherwise any remaining device detaches will not be
performed.
Implementation notes:
1. Detaching the multiplexer resets each line first, which flushes the
output buffer. This ensures that buffered data that has not been output
via a poll_service entry before the DETACH command was issued is written
before the line is disconnected.
*/
static t_stat atcd_detach (UNIT *uptr)
{
uint32 channel;
t_stat status = SCPE_OK;
if (uptr == line_unit || uptr == &poll_unit) { /* if we're detaching the base unit or poll unit */
status = tmxr_detach (&atcd_mdsc, &poll_unit); /* then detach the listening port */
if ((sim_switches & SIM_SW_REST) == 0) /* if this is not a RESTORE call */
for (channel = 0; channel < TERM_COUNT; channel++) { /* then for each terminal channel */
atcd_ldsc [channel].rcve = FALSE; /* disable reception */
sim_cancel (&line_unit [channel]); /* and cancel any transfer in progress */
}
}
return status;
}
/* ATC local utility routines */
/* Request a TDI interrupt.
The data flag and interrupt request flip-flops are set. If the interrupt
mask permits, the interrupt request is passed to the IOP.
*/
static void tdi_set_interrupt (void)
{
tdi_data_flag = SET; /* set the data flag */
atcd_dib.interrupt_request = SET; /* request an interrupt */
if (tdi_interrupt_mask) /* if the interrupt mask is satisfied */
iop_assert_INTREQ (&atcd_dib); /* then assert the INTREQ signal to the IOP */
return;
}
/* TDI master reset.
A master reset is generated either by an IORESET signal or a programmed
master reset (CIO bit 0 set). It clears any pending or active interrupt,
sets the interrupt mask, clears the status word and data flag, and resets all
channels to their initial, unconfigured state.
Implementation notes:
1. In hardware, a master reset sets the Initialize flip-flop. This causes a
direct clear of the recirculating memory window registers, thereby
clearing each channel's buffer, parameter, and status values as they
pass through the window. The flip-flop is cleared when a control word is
sent with the master clear bit (CIO bit 0) cleared. A full recirculation
takes 69.44 microseconds, so the CPU must allow at least this time for
each channel to pass through the window to ensure that all memory
locations are reset. In simulation, the clear occurs "instantaneously."
*/
static void tdi_master_reset (void)
{
uint32 chan;
atcd_dib.interrupt_request = CLEAR; /* clear any current */
atcd_dib.interrupt_active = CLEAR; /* interrupt request */
tdi_interrupt_mask = SET; /* set the interrupt mask */
tdi_status_word = 0; /* clear the status word */
tdi_data_flag = CLEAR; /* and the data flag */
for (chan = FIRST_TERM; chan <= LAST_TERM; chan++) { /* for each terminal channel */
recv_buffer [chan] = 0; /* clear the receive data buffer */
recv_param [chan] = 0; /* and parameter */
recv_status [chan] = 0; /* and status */
send_buffer [chan] = 0; /* also clear the send data buffer */
send_param [chan] = 0; /* and parameter */
send_status [chan] = 0; /* and status */
sim_cancel (&line_unit [chan]); /* cancel any transfer in progress */
}
for (chan = FIRST_AUX; chan <= LAST_AUX; chan++) { /* for each auxiliary channel */
recv_buffer [chan] = 0; /* clear the receive data buffer */
recv_param [chan] = 0; /* and parameter */
recv_status [chan] = 0; /* and status */
}
return;
}
/* TCI master reset.
A master reset is generated either by an IORESET signal or a programmed
master reset (CIO bit 0 set). It clears any pending or active interrupt,
sets the interrupt mask, clears the control word and channel counter, and
resets all channels to their initial, unconfigured state.
Implementation notes:
1. In hardware, a master reset sets the Status Clear flip-flop. This causes
a direct clear of the Control Word Holding Register and enables writing
into each location of the addressable latches and state RAM. The
flip-flop is reset automatically when the channel counter rolls over.
This takes approximately 12 microseconds, so the CPU must allow at least
this time before sending new control information. In simulation, the
master reset occurs "instantaneously."
2. In hardware, the C2 and C1 control line outputs are cleared by a master
clear. In simulation, we also clear the S2 and S1 status line input
values. This is OK, because they will be reestablished at the next poll
service entry.
*/
static void tci_master_reset (void)
{
uint32 chan;
atcc_dib.interrupt_request = CLEAR; /* clear any current */
atcc_dib.interrupt_active = CLEAR; /* interrupt request */
tci_interrupt_mask = SET; /* set the interrupt mask */
tci_control_word = 0; /* clear the control word */
tci_cntr = 0; /* and the channel counter */
for (chan = FIRST_TERM; chan <= LAST_TERM; chan++) { /* for each terminal channel */
cntl_status [chan] = 0; /* clear all serial line values */
cntl_param [chan] = 0; /* and the parameter RAM */
}
return;
}
/* Multiplexer channel service.
The channel service routine runs only when there are characters to read or
write. It is scheduled either at a realistic rate corresponding to the
programmed baud rate of the channel to be serviced, or at a somewhat faster
optimized rate. It is entered when a channel buffer is ready for output,
when the poll routine determines that there are characters ready for input,
or while waiting for an ACK to complete an ENQ/ACK handshake.
On entry, the receive channel buffer is checked for a character. If one is
not already present, then the terminal multiplexer library is called to
retrieve the waiting character. If a valid character is now available, it is
processed. If the receive channel has its "diagnose" bit set, the character
is also passed to the auxiliary channels.
If a received character is not available, then the unit's "wait" field is
checked to see if an ACK is expected in reply to an earlier ENQ. If a wait
time is present, it is doubled, and the service is rescheduled. However, if
the new wait time is longer than the current poll time, service rescheduling
is abandoned in favor of the normal poll for received characters.
The send channel buffer is then checked for a character to output. If one is
present, then if it is an all-mark (sync) character, it is discarded, as the
receiver would never see it. Otherwise, if the TDI is in diagnostic mode,
then the character is looped back to the associated receive channel by
storing it in that channel's receive buffer and then recursively calling the
routine for that channel.
If the TDI is in terminal mode, then if the channel flag is set for local
ENQ/ACK handshaking, and the character is an ENQ, it is discarded, an ACK is
stored in the channel's receive buffer, and its reception is scheduled.
Otherwise, the character is processed and then transmitted either to the
simulation console (if output is to channel 0) or to the terminal multiplexer
library for output via Telnet or a serial port on the host machine. If the
channel has its "diagnose" bit set, the character is also passed to the
auxiliary channels. If an ENQ was transmitted, service is rescheduled to
wait for reception of the ACK.
If the data flag is clear, the indicated receive and send channels are
checked for completion flags. If either is set, an interrupt is requested.
If characters remain in the Telnet receive buffer, the service routine is
rescheduled to receive the next one. Otherwise, the routine goes idle until
the next character is output or the next poll determines that there are
characters to receive.
Implementation notes:
1. The "wait" fields of the channel units are not used (i.e., are set to
zero) except when channels are waiting for ACKs. Because we want to
retrieve the ACK as quickly as possible but also minimize the load on the
host system, we initially wait the normal reception time (fast or
realistic) and then double the wait each time it expires without
reception. Therefore, a non-zero "wait" value indicates that an ACK is
expected.
2. Receipt of any character cancels a pending ACK wait, even though it is
possible that the character is not an ACK (for example, if the character
was received but not processed before the ENQ was sent).
3. Calling "tmxr_getc_ln" for channel 0 is OK, as reception is disabled by
default and therefore will return 0.
4. The send channel buffer will always be non-zero if a character is present
(even a NUL) because the data word will have DDS_IS_SEND set.
The receive buffer will always be non-zero if a character is present
(even a NUL) because characters from the console will have SCPE_KFLAG
set, characters from the terminal multiplexer library will have
TMXR_VALID set, and characters looped back from sending will have
DDS_IS_SEND set.
5. Reception of a loopback character is performed immediately because the
reception occurs concurrently with transmission. Reception of a locally
generated ACK is scheduled with a one-character delay to reflect the
remote device transmission delay.
6. If storing an ACK locally overwrites a character already present but not
yet processed, then the receive routine will set the character lost flag.
7. Both TMXR_VALID and SCPE_KFLAG are set on internally generated ACKs only
so that a debug trace will record the generation correctly.
8. The console library "sim_putchar_s" routine and the terminal multiplexer
library "tmxr_putc_ln" routine return SCPE_STALL if they are called when
the transmit buffer is full. When called to add the last character to
the buffer, the routines return SCPE_OK but also change the "xmte" field
of the terminal multiplexer line (TMLN) structure from 1 to 0 to indicate
that further calls will be rejected; the value is set back to 1 when the
transmit buffer empties.
Entry with the transmit buffer full causes the service to be rescheduled
to retry the write after a short delay. The "tmxr_poll_tx" routine must
be called in this case, as it is responsible for transmitting the buffer
contents and therefore freeing space in the buffer.
Both library "put" routines also return SCPE_LOST if the line has been
dropped on the remote end. We ignore that error here to allow the
simulation to continue while ignoring the output to a disconnected
terminal.
9. Characters written using "tmxr_putc_ln" are buffered and not transmitted
until the buffer is full, the character is an ENQ (and so we will be
waiting to receive an ACK), or the next input poll is performed. The
last case ensures that the buffer is flushed when output is complete, as
there is no indication from the CPU that the last character has been
sent. This does incur a delay of up to 10 milliseconds, but this is
imperceptible by the user. Buffering offers significantly better
throughput compared to transmitting each character as it is written.
10. The receive/send completion flag (buffer flag) will not set unless the
interrupt enable flag for that channel is also set. If enable is not
set, the completion indication will be lost.
*/
static t_stat line_service (UNIT *uptr)
{
const int32 channel = (int32) (uptr - line_unit); /* the channel number */
const int32 alt_channel = channel ^ 1; /* alternate channel number for diagnostic mode */
const t_bool loopback = (atcd_dev.flags & DEV_DIAG) != 0; /* TRUE if device is set for diagnostic mode */
int32 recv_data, send_data, char_data, cvtd_data;
t_stat result = SCPE_OK;
dprintf (atcd_dev, DEB_SERV, "Channel %d service entered\n",
channel);
/* Reception service */
recv_data = recv_buffer [channel]; /* get the current buffer character */
if (recv_data == 0) { /* if no character is present */
if (uptr->wait) /* then if the channel is waiting for an ACK */
tmxr_poll_rx (&atcd_mdsc); /* then poll the line to see if it has arrived */
recv_data = tmxr_getc_ln (&atcd_ldsc [channel]); /* see if there's now a character ready */
}
if (recv_data & ~DDR_DATA_MASK) { /* if we now have a valid character */
receive (channel, recv_data, loopback); /* then process the reception */
if (recv_param [channel] & DPI_DIAGNOSE) /* if a diagnosis is requested */
diagnose (recv_param [channel], recv_data); /* then route the data to the auxiliary channels */
uptr->wait = 0; /* clear any pending ACK wait */
}
else if (uptr->wait) { /* otherwise if an ACK is expected but has not arrived */
uptr->wait = uptr-> wait * 2; /* then double the wait time for the next check */
if (uptr->wait < poll_unit.wait) { /* if the wait is shorter than the standard poll wait */
sim_activate (uptr, uptr->wait); /* then reschedule the line service */
dprintf (atcd_dev, DEB_SERV, "Channel %d delay %d service rescheduled for ACK\n",
channel, uptr->wait);
}
}
/* Transmission service */
if (send_buffer [channel]) { /* if data is available to send */
send_data = DDS_DATA (send_buffer [channel]); /* then pick up the data and stop bits */
char_data = send_data & ASCII_MASK; /* and also the ASCII character value */
if (send_status [channel] & DST_COMPLETE) { /* if the last completion hasn't been acknowledged */
send_status [channel] |= DST_CHAR_LOST; /* then indicate an overrun condition */
dprintf (atcd_dev, DEB_CSRW, "Channel %d send data overrun\n",
channel);
}
if ((send_buffer [channel] & DDS_MARK) == DDS_MARK) { /* if it's an all-mark character */
send_buffer [channel] = 0; /* then the receiver won't see it */
if (send_param [channel] & DPI_ENABLE_IRQ) /* if this channel is enabled to interrupt */
send_status [channel] |= DST_COMPLETE; /* then set the completion flag */
dprintf (atcd_dev, DEB_XFER, (loopback
? "Channel %d sync character sent to channel %d\n"
: "Channel %d sync character sent\n"),
channel, alt_channel);
}
else if (loopback) { /* otherwise if the device is in loopback mode */
if (send_param [channel] & DPI_DIAGNOSE) /* then if a diagnosis is requested */
diagnose (send_param [channel], send_data); /* then route the data to the auxiliary channels */
if ((send_buffer [channel] & DDR_DATA_MASK) == 0) /* if all bits are clear */
recv_buffer [alt_channel] = SCPE_BREAK; /* then it will be seen as a BREAK */
else /* otherwise a character will be received */
recv_buffer [alt_channel] = send_buffer [channel]; /* so store it in the buffer */
send_buffer [channel] = 0; /* clear the send buffer */
if (send_param [channel] & DPI_ENABLE_IRQ) /* if this channel is enabled to interrupt */
send_status [channel] |= DST_COMPLETE; /* then set the completion flag */
dprintf (atcd_dev, DEB_XFER, "Channel %d character %s sent to channel %d\n",
channel, fmt_char (char_data), alt_channel);
line_service (&line_unit [alt_channel]); /* receive the character on the alternate channel */
}
else if (char_data == ENQ && uptr->flags & UNIT_LOCALACK) { /* otherwise if it's an ENQ and local reply is enabled */
recv_buffer [channel] = GEN_ACK; /* then "receive" an ACK on the channel */
send_buffer [channel] = 0; /* discard the ENQ */
if (send_param [channel] & DPI_ENABLE_IRQ) /* if this channel is enabled to interrupt */
send_status [channel] |= DST_COMPLETE; /* then set the completion flag */
dprintf (atcd_dev, DEB_XFER, "Channel %d character ENQ absorbed internally\n",
channel);
activate_unit (uptr, Receive); /* schedule the reception */
}
else { /* otherwise it's a normal character */
cvtd_data = sim_tt_outcvt (LOWER_BYTE (send_data), /* so convert it as directed */
TT_GET_MODE (uptr->flags)); /* by the output mode flag */
if (cvtd_data >= 0 && atcd_ldsc [channel].xmte == 0) { /* if it's printable but the transmit buffer is full */
activate_unit (uptr, Stall); /* then retry the output a while later */
tmxr_poll_tx (&atcd_mdsc); /* transmit the line buffer */
dprintf (atcd_dev, DEB_XFER, "Channel %d character %s transmission stalled for full buffer\n",
channel, fmt_char (cvtd_data));
}
else { /* otherwise the character will be consumed */
if (cvtd_data >= 0) /* if the converted character is printable */
if (channel == 0) /* then if we are writing to channel 0 */
result = sim_putchar_s (cvtd_data); /* then output it to the simulation console */
else { /* otherwise */
result = tmxr_putc_ln (&atcd_ldsc [channel], /* output it to the multiplexer line */
cvtd_data);
if (char_data == ENQ /* if sending an ENQ */
|| atcd_ldsc [channel].xmte == 0) /* or the output buffer is full */
tmxr_poll_tx (&atcd_mdsc); /* then transmit the line buffer */
}
if (result == SCPE_OK || result == SCPE_LOST) { /* if the character is queued to transmit */
if (DPRINTING (atcd_dev, DEB_XFER))
if (result == SCPE_LOST)
hp_debug (&atcd_dev, DEB_XFER, "Channel %d character %s discarded by connection loss\n",
channel, fmt_char (char_data));
else if (cvtd_data >= 0)
hp_debug (&atcd_dev, DEB_XFER, "Channel %d character %s sent\n",
channel, fmt_char (cvtd_data));
else
hp_debug (&atcd_dev, DEB_XFER, "Channel %d character %s discarded by output filter\n",
channel, fmt_char (char_data));
if (send_param [channel] & DPI_DIAGNOSE) /* if a diagnosis is requested */
diagnose (send_param [channel], send_data); /* then route the data to the auxiliary channels */
send_buffer [channel] = 0; /* clear the buffer */
if (send_param [channel] & DPI_ENABLE_IRQ) /* if this channel is enabled to interrupt */
send_status [channel] |= DST_COMPLETE; /* then set the completion flag */
if (cvtd_data == ENQ && result == SCPE_OK) /* if an ENQ was successfully sent */
uptr->wait = activate_unit (uptr, Receive); /* then schedule the ACK reception */
result = SCPE_OK; /* return OK in case the connection was lost */
}
}
}
}
if (tdi_data_flag == CLEAR) /* if an interrupt is not currently pending */
scan_channels (channel); /* then scan the channels for completion flags */
if (tmxr_rqln (&atcd_ldsc [channel])) /* if characters are still available on this channel */
activate_unit (uptr, Receive); /* then reschedule the line service */
return result; /* return the result of the service */
}
/* Multiplexer poll service.
The poll service routine is used to poll for Telnet connections and incoming
characters. It also polls the simulation console for channel 0 and flushes
the output buffers for all channels. Polling starts at simulator startup or
when the TDI is enabled and stops when it is disabled.
Implementation notes:
1. The poll service routine may be entered with the TCI either enabled or
disabled. It will not be entered if the TDI is disabled, as it may be
disabled only when it is detached from a listening port.
2. If a character is received on the simulation console, we must call the
channel 0 line service directly. This is necessary because the poll time
may be shorter than the channel service time, and as the console provides
no buffering, a second character received before the channel service had
been entered would be lost.
3. A channel that is waiting for an ACK to complete an ENQ/ACK handshake has
its unit "wait" field set non-zero. If the field value is greater than
the realistic reception time, then the line service is scheduled
immediately, as the channel has already waited the minimum time necessary
(the "wait" field value is doubled each time the line service is entered
before the ACK has been received). Otherwise, the service is scheduled
using the normal reception time.
*/
static t_stat poll_service (UNIT *uptr)
{
int32 chan, line_state;
t_stat status = SCPE_OK;
dprintf (atcd_dev, DEB_PSERV, "Poll delay %d service entered\n",
uptr->wait);
if ((atcc_dev.flags & DEV_DIS) == 0)
dprintf (atcc_dev, DEB_PSERV, "Poll delay %d service entered\n",
uptr->wait);
if ((atcd_dev.flags & DEV_DIAG) == 0) { /* if we're not in diagnostic mode */
chan = tmxr_poll_conn (&atcd_mdsc); /* then check for a new multiplexer connection */
if (chan != -1) { /* if a new connection was established */
atcd_ldsc [chan].rcve = TRUE; /* then enable the channel to receive */
dprintf (atcc_dev, DEB_XFER, "Channel %d connected\n",
chan);
}
}
tmxr_poll_tx (&atcd_mdsc); /* flush the multiplexer output buffers */
tmxr_poll_rx (&atcd_mdsc); /* and poll the multiplexer connections for input */
if ((atcc_dev.flags & (DEV_DIAG | DEV_DIS)) == 0) /* if we're not in diagnostic mode or are disabled */
for (chan = FIRST_TERM; chan <= LAST_TERM; chan++) /* then scan the channels for line state changes */
if (line_unit [chan].flags & UNIT_MODEM) { /* if the channel is controlled by the TCI */
tmxr_set_get_modem_bits (&atcd_ldsc [chan], /* then get the current line state */
0, 0, &line_state);
if (line_state & TMXR_MDM_DCD) /* if DCD is set */
cntl_status [chan] |= DCD; /* then set the corresponding line flag */
else { /* otherwise DCD is clear */
if (cntl_status [chan] & DCD) /* and a disconnect occurred if DCD was previously set */
dprintf (atcc_dev, DEB_XFER, "Channel %d disconnect dropped DCD and DSR\n",
chan);
cntl_status [chan] &= ~DCD; /* clear the corresponding flag */
}
if (line_state & TMXR_MDM_DSR) /* if DSR is set */
cntl_status [chan] |= DSR; /* then set the corresponding line flag */
else /* otherwise */
cntl_status [chan] &= ~DSR; /* clear the flag */
}
status = sim_poll_kbd (); /* poll the simulation console keyboard for input */
if (status >= SCPE_KFLAG) { /* if a character was present */
recv_buffer [0] = (HP_WORD) status; /* then save it for processing */
status = SCPE_OK; /* and then clear the status */
line_service (&line_unit [0]); /* run the system console's I/O service */
}
for (chan = FIRST_TERM; chan <= LAST_TERM; chan++) /* check each of the channels for available input */
if (tmxr_rqln (&atcd_ldsc [chan])) /* if characters are available on this channel */
if (line_unit [chan].wait > line_unit [chan].recv_time) { /* then if the channel is waiting for an ACK */
sim_cancel (&line_unit [chan]); /* then cancel any current wait */
activate_unit (&line_unit [chan], Loop); /* and activate the line service immediately */
}
else /* otherwise this is a normal input */
activate_unit (&line_unit [chan], Receive); /* so schedule with the normal receive timing */
if (cpu_is_calibrated) /* if the process clock is calibrated */
uptr->wait = sim_activate_time (cpu_pclk_uptr); /* then synchronize with it */
else /* otherwise */
uptr->wait = sim_rtcn_calb (POLL_RATE, TMR_ATC); /* calibrate the poll timer independently */
sim_activate (uptr, uptr->wait); /* continue polling */
if (tci_scan) /* if scanning is active */
scan_status (); /* then check for line status changes */
return status; /* return the service status */
}
/* Activate a channel unit.
The specified unit is activated to receive or send a character. The reason
for the activation is specified by the "reason" parameter. If the TDI is in
real-time mode, the previously calculated service time is used to schedule
the event. Otherwise, the current value of the optimized timing delay is
used. If tracing is enabled, the activation is logged to the debug file.
Implementation notes:
1. The loopback time is the difference between the reception and
transmission times, as the latter event has already occurred when we are
called.
*/
static int32 activate_unit (UNIT *uptr, ACTIVATOR reason)
{
const int32 channel = (int32) (uptr - line_unit); /* the channel number */
int32 delay = 0;
if (atcd_dev.flags & (DEV_DIAG | DEV_REALTIME)) /* if either diagnostic or real-time mode is set */
switch (reason) { /* then dispatch the REALTIME activation */
case Receive: /* reception event */
delay = uptr->recv_time; /* schedule for the realistic reception time */
break;
case Send: /* transmission event */
delay = uptr->send_time; /* schedule for the realistic transmission time */
break;
case Loop: /* diagnostic loopback reception event */
delay = uptr->recv_time - uptr->send_time; /* schedule the additional reception overhead */
if (delay < 0) /* if the receive time is less than the send time */
delay = 0; /* then schedule the reception immediately */
break;
case Stall: /* transmission stall event */
delay = uptr->send_time / 10; /* reschedule the transmission after a delay */
break;
}
else /* otherwise, we are in optimized timing mode */
switch (reason) { /* so dispatch the FASTTIME activation */
case Receive: /* reception event */
case Send: /* transmission event */
delay = fast_data_time; /* use the optimized timing value */
break;
case Loop: /* diagnostic loopback reception event */
delay = 1; /* use a nominal delay */
break;
case Stall: /* transmission stall event */
delay = fast_data_time / 10; /* reschedule the transmission after a delay */
break;
}
dprintf (atcd_dev, DEB_SERV, "Channel %d delay %d service scheduled\n",
channel, delay);
sim_activate (uptr, delay); /* activate the unit */
return delay; /* and return the activation delay */
}
/* Calculate the service time.
The realistic channel service time in event ticks per character is calculated
from the encoded character size and baud rate in the supplied control word.
The time consists of the transfer time plus a small overhead, which is
different for receiving and sending.
The character size field in the control word is generated by this equation:
encoded_size = (bits_per_character - 1) AND 7
That is, the encoded character size is the value expressed by the three
least-significant bits of the count of the data and stop bits. Therefore,
the actual number of bits per character (including the start bit) is encoded
as:
Actual Encoded
------ -------
5 4
6 5
7 6
8 7
9 0
10 1
11 2
12 3
The baud rate field in the control word is generated by this equation:
14400
encoded_rate = --------- - 1
baud_rate
The transmission and overhead times are related to the recirculation of the
multiplexer's internal memory, which contains the data, parameters, and
status for each of the 16 send channels, 16 receive channels, and 5 auxiliary
channels. Data for a given channel can be accessed only once per
recirculation, which takes 69.44 microseconds (1/14400 of a second). The
encoded rate plus one gives the number of recirculations corresponding to a
single bit time; multiplying by the number of bits per character gives the
number of recirculations to send or receive an entire character.
All operations encounter two overhead delays. First, an average of one-half
of a recirculation must occur to align the memory with the channel of
interest. Second, a full recirculation is required after receiving or
sending is complete before an interrupt may be generated.
For receiving, there is an additional delay to right-justify the received
character in the data accumulator. The accumulator is a 12-bit shift
register, with received data bits are shifted from left to right. When the
final bit is entered, the register must be shifted additionally until the
first data bit is in the LSB (i.e., until the start bit is shifted out of the
register). One shift per recirculation is performed, and the number of
additional shifts required is 12 + 1 - the number of bits per character.
Justification begins immediately after the stop bit has been received, so the
full set of recirculations for that bit are skipped in lieu of justification.
Also, reception of the start bit is delayed by one-half of the bit time to
improve noise immunity.
Therefore, given R = encoded_rate + 1 and B = bits_per_character, the number
of memory recirculations required for sending is:
0.5 to align memory with the target channel (on average)
+ R * B to send the start, data, and stop bits
+ 1 to set the data flag to request an interrupt
For example, at 2400 baud (encoded rate 5), a 10-bit character size, and
69.44 microseconds per circulation, the service time would be:
34.7 usec to align
4166.7 usec to send the start, data, and stop bits
69.4 usec to set the data flag
===========
4270.8 usec from initiation to data flag
The number of memory recirculations required for receiving is:
0.5 to align memory with the target channel (on average)
+ R / 2 to receive the start bit
+ R * (B - 1) to receive the data and stop bits
+ (12 - B + 1) to right-justify the data
+ 1 to set the data flag to request an interrupt
Using the same example as above, the service time would be:
34.7 usec to align
208.3 usec to receive the start bit
3750.0 usec to receive the data and stop bits
208.3 usec to right-justify the data
69.4 usec to set the data flag
===========
4270.7 usec from initiation to data flag
Implementation notes:
1. The multiplexer uses an 8-bit field to set the baud rate. In practice,
only the common rates (110, 150, 300, 600, 1200, 2400) will be used.
Still, the real-time calculation must accommodate any valid setting, so a
lookup table is infeasible.
2. The receive calculation is simplified by noting that R / 2 + R * (B - 1)
is equivalent to R * B - R / 2, so the send calculation may be reused.
Note that the receive time may be less than the send time, typically when
the baud rate is low, so that the time to send the stop bits is longer
than the time to right-justify the reception. This means that the
"addition" of the receive overhead may actually be a subtraction.
*/
static uint32 service_time (HP_WORD control, ACTIVATOR reason)
{
const double recirc_time = 69.44; /* microseconds per memory recirculation */
const uint32 recirc_per_bit = DPI_BAUD_RATE (control) + 1; /* number of memory recirculations per bit */
const uint32 char_size = bits_per_char [DPI_CHAR_SIZE (control)]; /* number of bits per character */
double usec_per_char;
usec_per_char = recirc_time * /* calculate the overhead for sending */
(char_size * recirc_per_bit + 1.5);
if (reason == Receive) /* if we're receiving */
usec_per_char += recirc_time * /* then add the additional receiving overhead */
(12 - char_size + 1
- recirc_per_bit / 2.0);
return (uint32) (usec_per_char / USEC_PER_EVENT); /* return the service time for indicated rate */
}
/* Store a word in the recirculating memory.
A parameter or data word is stored in the recirculating memory for the
channel indicated by the associated field of the "control" parameter. If the
channel number is out of range, the store is ignored.
For receive and send parameters, the realistic service time is calculated and
stored in the unit for use when a receive or send event is scheduled. For
send data, parity is calculated and added if specified by the channel's
parameter, and the transmission event is scheduled. For a receive parameter,
the pad bits that would normally be added during right-justification after
reception are calculated and stored in the unit.
Implementation notes:
1. Service times are not calculated or set for auxiliary channels because
events are not scheduled on them (and so no units are allocated for
them).
2. Pad bits begin with the stop bit and continue until the character is
right-justified in the receive buffer. The calculation assumes one stop
bit, but there is no way of ascertaining the actual number of stop bits
from the parameter word.
*/
static void store (HP_WORD control, HP_WORD data)
{
const uint32 channel = DCN_CHAN (control); /* current channel number */
if (data & DDS_IS_SEND) /* if this is a send parameter or data */
if (channel > LAST_TERM) /* then report if the channel number is out of range */
dprintf (atcd_dev, DEB_CSRW, "Send channel %u invalid\n",
channel);
else if (data & DPI_IS_PARAM) { /* otherwise if this is a parameter store */
send_param [channel] = data; /* then save it */
line_unit [channel].send_time = /* and set the service time */
service_time (data, Send);
dprintf (atcd_dev, DEB_CSRW, "Channel %u send parameter %06o stored\n",
channel, data);
}
else { /* otherwise this is a data store */
if (send_param [channel] & DPI_ENABLE_PARITY) /* if parity is enabled */
data = data & ~DDS_PARITY /* then replace the parity bit */
| SEND_PARITY (data); /* with the calculated value */
send_buffer [channel] = data; /* store it in the buffer */
dprintf (atcd_dev, DEB_CSRW, "Channel %u send data %06o stored\n",
channel, data);
activate_unit (&line_unit [channel], Send); /* schedule the transmission event */
}
else /* otherwise this is a receive parameter */
if (channel >= RECV_CHAN_COUNT) /* report if the channel number is out of range */
dprintf (atcd_dev, DEB_CSRW, "Receive channel %u invalid\n",
channel);
else if (data & DPI_IS_PARAM) { /* otherwise if this is a parameter store */
recv_param [channel] = data; /* then save it */
if (channel <= LAST_TERM) { /* if this is a terminal channel */
line_unit [channel].recv_time = /* and not an auxiliary channel */
service_time (data, Receive); /* then set the service time */
line_unit [channel].stop_bits = /* set the stop bits mask for reception */
PAD_BITS (data);
}
dprintf (atcd_dev, DEB_CSRW, "Channel %u receive parameter %06o stored\n",
channel, data);
}
else /* otherwise a data store to a receive channel is invalid */
dprintf (atcd_dev, DEB_CSRW, "Channel %u receive output data word %06o invalid\n",
channel, data);
}
/* Process a character received from a channel.
This routine is called to process received data on a channel, typically when
a character exists in the channel's receive buffer, but also when a character
is received on an auxiliary channel. The "channel" parameter indicates the
channel on which reception occurred, "data" is the (full) character data
as received from the console or terminal multiplexer libraries, and
"loopback" is TRUE if the data should be looped back to the alternate channel
for diagnostic execution.
On entry, the bits required to pad the character are obtained. If a BREAK
was detected, then break status is set, and the character is set to NUL,
reflecting the all-space reception. Otherwise, if a character is already
present in the receive buffer, "character lost" status is set to indicate
that it will be overwritten.
If this is a loopback reception, and echo is enabled on the channel, the
character is sent back to the alternate channel. Otherwise, if this is a
main and not auxiliary channel reception, the character is upshifted if the
UNIT_CAPSLOCK flag is set. If echo is enabled, the character is written back
to the console or terminal multiplexer library line. Finally, the completion
flag is set if enabled.
Implementation notes:
1. The echo to a terminal multiplexer library line will return SCPE_LOST if
the line has been dropped on the remote end. We can ignore the error
here, as the line drop will be picked up when the next input poll is
performed.
In addition, the SCPE_STALL returned for a full output buffer is also
ignored, as there's no way of queuing echoed characters while waiting for
the buffer to empty.
*/
static void receive (int32 channel, int32 data, t_bool loopback)
{
int32 recv_data, char_data, char_echo, pad;
recv_data = data & DDR_DATA_MASK; /* mask to just the character data */
char_data = recv_data & ASCII_MASK; /* and to the equivalent ASCII character */
if (channel <= LAST_TERM) /* if this is a receive channel */
pad = line_unit [channel].stop_bits; /* then set the stop-bit padding from the unit */
else /* otherwise it's an auxiliary channel */
pad = PAD_BITS (recv_param [channel]); /* so calculate the padding */
if (data & SCPE_BREAK) { /* if a break was detected */
recv_buffer [channel] = NUL; /* then return a NUL character */
recv_status [channel] |= DST_BREAK; /* and set break reception status */
dprintf (atcd_dev, DEB_XFER, "Channel %d break detected\n",
channel);
}
else { /* otherwise a normal character was received */
if (recv_status [channel] & DST_COMPLETE) { /* if a character is already pending */
recv_status [channel] |= DST_CHAR_LOST; /* then the previous character will be lost */
dprintf (atcd_dev, DEB_CSRW, "Channel %d receive data overrun\n",
channel);
}
recv_buffer [channel] = recv_data | pad; /* save the character and padding in the buffer */
if (loopback) { /* if this channel has a loopback cable installed */
if (recv_param [channel] & DPI_ENABLE_ECHO) { /* and the channel has echo enabled */
recv_buffer [channel ^ 1] = data; /* then send the data back to the other channel */
activate_unit (&line_unit [channel ^ 1], Loop); /* schedule the reception */
dprintf (atcd_dev, DEB_XFER, "Channel %d character %s echoed to channel %d\n",
channel, fmt_char (char_data), channel ^ 1);
}
}
else if (channel <= LAST_TERM) { /* otherwise if it's a receive channel */
if (line_unit [channel].flags & UNIT_CAPSLOCK) { /* then if caps lock is down */
recv_data = toupper (recv_data); /* then convert to upper case if lower */
recv_buffer [channel] = recv_data | pad; /* and replace the character in the buffer */
}
if (recv_param [channel] & DPI_ENABLE_ECHO) { /* if the channel has echo enabled */
char_echo = sim_tt_outcvt (recv_data, /* then convert the character per the output mode */
TT_GET_MODE (line_unit [channel].flags));
if (char_echo >= 0) { /* if the converted character is valid for the mode */
if (channel == 0) /* then if this is for channel 0 */
sim_putchar (char_echo); /* then write it back to the simulation console */
else { /* otherwise */
tmxr_putc_ln (&atcd_ldsc [channel], /* write it to the multiplexer output line */
char_echo);
if (atcd_ldsc [channel].xmte == 0) /* if the output buffer is full */
tmxr_poll_tx (&atcd_mdsc); /* then transmit the line buffer */
}
dprintf (atcd_dev, DEB_XFER, ("Channel %d character %s echoed\n"),
channel, fmt_char (char_echo));
}
else /* otherwise the echo character was discarded */
dprintf (atcd_dev, DEB_XFER, "Channel %d character %s echo discarded by output filter\n",
channel, fmt_char (char_data));
}
}
}
if (recv_param [channel] & DPI_ENABLE_IRQ) /* if the channel is enabled to interrupt */
recv_status [channel] |= DST_COMPLETE; /* then set the completion flag */
dprintf (atcd_dev, DEB_XFER, "Channel %d character %s %s\n",
channel, fmt_char (char_data),
(data == GEN_ACK ? "generated internally" : "received"));
return;
}
/* Check for a character received on an auxiliary channel.
If a send or receive channel has its "diagnose" bit set, then this routine is
called to check if any of the auxiliary channels would receive the character
too. If one or more would, then the "receive" routine is called to store the
character in the appropriate buffer.
The diagnosis mode is typically used to speed-sense a receive channel.
In hardware, reception on a given channel is simultaneously received on the
five auxiliary channels, with each channel set for a different baud rate.
When a specific character (e.g., CR) is sent, only the channel with the
correct baud rate setting will receive the intended character. By
determining which channel received the correct data, the baud rate of the
sending terminal may be obtained.
In simulation, a main channel will receive a character regardless of the baud
rate configuration. Therefore, an auxiliary channel will receive the same
character only if it is configured for the same baud rate and character size.
*/
static void diagnose (HP_WORD control, int32 data)
{
const HP_WORD config = control & DPI_CHAR_CONFIG; /* main channel character size and baud rate */
int32 channel;
for (channel = FIRST_AUX; channel <= LAST_AUX; channel++) /* scan the auxiliary channels */
if ((recv_param [channel] & DPI_CHAR_CONFIG) == config) /* if the character configurations match */
receive (channel, data, FALSE); /* then receive the data on this channel */
return;
}
/* Scan the channels for a transfer completion interrupt.
If the multiplexer data flag is not set, this routine is called to scan the
channels for completion flags. If the "channel" parameter value is SCAN_ALL,
then all of the channels are checked. Otherwise, only the specified channel
is checked.
If a channel has its completion flag set, the multiplexer data and status
words are set for return to the CPU, the data flag is set, and an interrupt
is requested. The channel requesting the interrupt is contained in the
status word.
In hardware, the recirculating buffer consists of the sixteen receive
channels, then the sixteen send channels, and then the five auxiliary
channels. The completion flags are checked in this order during the
recirculation after a completion flag is set. If the scan has been inhibited
by the data flag, it will commence with the channel currently in the
recirculation window at the time the flag was cleared and then continue in
the order indicated.
In simulation, the scan is always initiated as though at the beginning of a
recirculation.
Implementation notes:
1. After a send completion, the data word contains all ones (stop bits).
*/
static void scan_channels (int32 channel)
{
int32 chan, first_chan, last_chan;
if (channel == SCAN_ALL) { /* if all channels are to be scanned */
first_chan = FIRST_TERM; /* then set the loop limits */
last_chan = LAST_TERM; /* to the full range of channels */
}
else /* otherwise scan just the channel indicated */
first_chan = last_chan = channel; /* plus the auxiliary channels if requested */
for (chan = first_chan; chan <= last_chan; chan++) { /* scan the receive channels */
if (recv_status [chan] & DST_COMPLETE) { /* if this channel's completion flag is set */
tdi_read_word = DDR_DATA (recv_buffer [chan]) /* then form the input data word */
| DDR_CHAN (chan) /* from the character, channel, and parity */
| RECV_PARITY (recv_buffer [chan]);
tdi_status_word = recv_status [chan] /* form the partial status word */
| DST_CHAN (chan);
recv_buffer [chan] = 0; /* clear the receive buffer */
recv_status [chan] = 0; /* and the channel status */
dprintf (atcd_dev, DEB_CSRW, "Channel %d receive interrupt requested\n",
chan);
tdi_set_interrupt (); /* set the data flag and request an interrupt */
return; /* and terminate scanning */
}
}
for (chan = first_chan; chan <= last_chan; chan++) { /* scan the send channels */
if (send_status [chan] & DST_COMPLETE) { /* if this channel's completion flag is set */
tdi_read_word = DDR_DATA_MASK /* then form the input data word from the */
| DDR_CHAN (chan); /* data input buffer and the channel number */
tdi_status_word = send_status [chan] /* form the partial status word */
| DST_CHAN (chan)
| DST_SEND_IRQ;
send_status [chan] = 0; /* clear the channel status */
dprintf (atcd_dev, DEB_CSRW, "Channel %d send interrupt requested\n",
chan);
tdi_set_interrupt (); /* set the data flag and request an interrupt */
return; /* and terminate scanning */
}
}
if (channel == SCAN_ALL /* if we're scanning all channels */
|| send_param [channel] & DPI_DIAGNOSE /* or the indicated channel is diagnosing */
|| recv_param [channel] & DPI_DIAGNOSE) /* its transmission or reception */
for (chan = FIRST_AUX; chan <= LAST_AUX; chan++) { /* then scan the auxiliary channels */
if (recv_status [chan] & DST_COMPLETE) { /* if this channel's completion flag is set */
tdi_read_word = DDR_DATA (recv_buffer [chan]) /* then form the input data word */
| DDR_CHAN (chan) /* from the character, channel, and parity */
| RECV_PARITY (recv_buffer [chan]);
tdi_status_word = recv_status [chan] /* form the partial status word */
| DST_CHAN (chan)
| DST_DIAGNOSE;
recv_buffer [chan] = 0; /* clear the receive buffer */
recv_status [chan] = 0; /* and the channel status */
dprintf (atcd_dev, DEB_CSRW, "Channel %d receive interrupt requested\n",
chan);
tdi_set_interrupt (); /* set the data flag and request an interrupt */
return; /* and terminate scanning */
}
}
return; /* no channel has completed */
}
/* Check for a control interrupt.
If the scan flag is clear, then return the interrupt status bits for the
channel indicated by the current control counter value. Otherwise, scan all
of the control channels, starting with the current counter, to check for a
status mismatch. This occurs when either of the incoming status bits does
not match the stored status, and the corresponding mismatch detection is
enabled. If an enabled mismatch is found, request an interrupt from the CPU,
clear the scan flag, and return the interrupt status bits with the counter
pointing at the interrupting channel.
*/
static HP_WORD scan_status (void)
{
uint32 chan_count;
HP_WORD interrupts;
if (tci_scan) /* if the control interface is scanning */
chan_count = TERM_COUNT; /* then look at all of the channels */
else /* otherwise */
chan_count = 1; /* look at only the current channel */
while (chan_count > 0) { /* scan the control channels */
interrupts = CST_IX (CCN_ESX (cntl_param [tci_cntr]) /* check for an enabled status mismatch */
& (cntl_param [tci_cntr] ^ cntl_status [tci_cntr]));
if (tci_scan) { /* if the interface is scanning */
if (interrupts) { /* and a mismatch was found */
atcc_dib.interrupt_request = SET; /* then request an interrupt */
if (tci_interrupt_mask) /* if the interrupt mask is satisfied */
iop_assert_INTREQ (&atcc_dib); /* then assert the INTREQ signal */
tci_scan = CLEAR; /* stop the scan at the current channel */
dprintf (atcc_dev, DEB_CSRW, "Channel %u interrupt requested\n",
tci_cntr);
break;
}
tci_cntr = (tci_cntr + 1) % TERM_COUNT; /* set the counter to the next channel in sequence */
}
chan_count = chan_count - 1; /* drop the count of channels to check */
}
return interrupts; /* return the interrupt status bits */
}
Reference in a new issue View git blame Copy permalink