1891 lines
84 KiB
C
1891 lines
84 KiB
C
/* hp2100_stddev.c: HP2100 standard devices simulator
|
|
|
|
Copyright (c) 1993-2016, Robert M. Supnik
|
|
Copyright (c) 2017-2018, J. David Bryan
|
|
|
|
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.
|
|
|
|
PTR 12597A-002 paper tape reader interface
|
|
PTP 12597A-005 paper tape punch interface
|
|
TTY 12531C buffered teleprinter interface
|
|
TBG 12539C time base generator
|
|
|
|
27-Feb-18 JDB Added the BBL
|
|
22-Nov-17 JDB Fixed TTY serial output buffer overflow handling
|
|
18-Sep-17 JDB Changed PTR "DIAG" modifier to "DIAGNOSTIC"
|
|
03-Aug-17 JDB PTP and TTY now append to existing file data
|
|
18-Jul-17 JDB The PTR device now handles the IOERR simulation stop
|
|
11-Jul-17 JDB Renamed "ibl_copy" to "cpu_ibl"
|
|
01-May-17 JDB Deleted ttp_stopioe, as a detached punch is no longer an error
|
|
08-Mar-17 JDB Added REALTIME, W1A, W1B, W2A, and W2B options to the TBG
|
|
Replaced IPTICK with a CPU speed calculation
|
|
27-Feb-17 JDB ibl_copy no longer returns a status code
|
|
23-Feb-17 JDB Modified ptr_boot to use IBL_S_CLR to clear the S register
|
|
17-Jan-17 JDB Changed "hp_---sc" and "hp_---dev" to "hp_---_dib"
|
|
30-Dec-16 JDB Modified the TTY to print if the punch is not attached
|
|
13-May-16 JDB Modified for revised SCP API function parameter types
|
|
30-Dec-14 JDB Added S-register parameters to ibl_copy
|
|
24-Dec-14 JDB Added casts for explicit downward conversions
|
|
28-Dec-12 JDB Allocate the TBG logical name during power-on reset
|
|
18-Dec-12 MP Now calls sim_activate_time to get remaining poll time
|
|
09-May-12 JDB Separated assignments from conditional expressions
|
|
12-Feb-12 JDB Add TBG as a logical name for the CLK device
|
|
10-Feb-12 JDB Deprecated DEVNO in favor of SC
|
|
28-Mar-11 JDB Tidied up signal handling
|
|
26-Oct-10 JDB Changed I/O signal handler for revised signal model
|
|
26-Jun-08 JDB Rewrote device I/O to model backplane signals
|
|
25-Apr-08 JDB Changed TTY output wait from 100 to 200 for MSU BASIC
|
|
18-Apr-08 JDB Removed redundant control char handling definitions
|
|
14-Apr-08 JDB Changed TTY console poll to 10 msec. real time
|
|
Synchronized CLK with TTY if set for 10 msec.
|
|
Added UNIT_IDLE to TTY and CLK
|
|
09-Jan-08 JDB Fixed PTR trailing null counter for tape re-read
|
|
31-Dec-07 JDB Added IPTICK register to CLK to display CPU instr/tick
|
|
Corrected and verified ioCRS actions
|
|
28-Dec-06 JDB Added ioCRS state to I/O decoders
|
|
22-Nov-05 RMS Revised for new terminal processing routines
|
|
13-Sep-04 JDB Added paper tape loop mode, DIAG/READER modifiers to PTR
|
|
Added PV_LEFT to PTR TRLLIM register
|
|
Modified CLK to permit disable
|
|
15-Aug-04 RMS Added tab to control char set (from Dave Bryan)
|
|
14-Jul-04 RMS Generalized handling of control char echoing
|
|
(from Dave Bryan)
|
|
26-Apr-04 RMS Fixed SFS x,C and SFC x,C
|
|
Fixed SR setting in IBL
|
|
Fixed input behavior during typeout for RTE-IV
|
|
Suppressed nulls on TTY output for RTE-IV
|
|
Implemented DMA SRQ (follows FLG)
|
|
29-Mar-03 RMS Added support for console backpressure
|
|
25-Apr-03 RMS Added extended file support
|
|
22-Dec-02 RMS Added break support
|
|
01-Nov-02 RMS Revised BOOT command for IBL ROMs
|
|
Fixed bug in TTY reset, TTY starts in input mode
|
|
Fixed bug in TTY mode OTA, stores data as well
|
|
Fixed clock to add calibration, proper start/stop
|
|
Added UC option to TTY output
|
|
30-May-02 RMS Widened POS to 32b
|
|
22-Mar-02 RMS Revised for dynamically allocated memory
|
|
03-Nov-01 RMS Changed DEVNO to use extended SET/SHOW
|
|
29-Nov-01 RMS Added read only unit support
|
|
24-Nov-01 RMS Changed TIME to an array
|
|
07-Sep-01 RMS Moved function prototypes
|
|
21-Nov-00 RMS Fixed flag, buffer power up state
|
|
Added status input for ptp, tty
|
|
15-Oct-00 RMS Added dynamic device number support
|
|
|
|
References:
|
|
- 2748B Tape Reader Operating and Service Manual
|
|
(02748-90041, October 1977)
|
|
- 12597A 8-Bit Duplex Register Interface Kit Operating and Service Manual
|
|
(12597-9002, September 1974)
|
|
- 12531C Buffered Teleprinter Interface Kit Operating and Service Manual
|
|
(12531-90033, November 1972)
|
|
- 12539C Time Base Generator Interface Kit Operating and Service Manual
|
|
(12539-90008, January 1975)
|
|
|
|
|
|
The HP 2748B Paper Tape Reader connects to the CPU via the 12597A 8-Bit
|
|
Duplex Register. The interface responds to I/O instructions as follows:
|
|
|
|
Output Data Word format (OTA and OTB):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - - - - - - - - - |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
An IOO signal clocks the lower eight bits into the output register, but the
|
|
output lines are not connected to the tape reader.
|
|
|
|
|
|
Input Data Word format (LIA and LIB):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - | tape data |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
The presence of a feed hole clocks the data byte into the input register. An
|
|
IOI signal enables the input register to the I/O Data Bus.
|
|
|
|
|
|
Boot Loader ROM S-Register format (12992K):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| ROM # | 0 0 | select code | 0 0 0 0 0 0 |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
The tape format must be absolute binary. Loader execution ends with one of
|
|
the following instructions:
|
|
|
|
HLT 11B - checksum error (A = calculated, B = expected)
|
|
HLT 55B - load address >= ROM loader address
|
|
HLT 77B - end of tape with successful read
|
|
|
|
Reader diagnostic mode simulates a tape loop by rewinding the tape image file
|
|
upon EOF. Normal mode EOF action is to supply TRLLIM nulls and then either
|
|
return SCPE_IOERR or SCPE_OK without setting the device flag.
|
|
|
|
|
|
|
|
The HP 2895B Paper Tape Punch connects to the CPU via the 12597A 8-Bit Duplex
|
|
Register. The interface responds to I/O instructions as follows:
|
|
|
|
Output Data Word format (OTA and OTB):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - | tape data |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
An IOO signal clocks the lower eight bits into the output register. The data
|
|
is punched when the STC signal sets the command flip-flop, which asserts the
|
|
PUNCH signal to the tape punch.
|
|
|
|
|
|
Input Data Word format (LIA and LIB):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - - - | L | - - - - - |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
L = Tape Supply is Low
|
|
|
|
Pin 21 of the interface connector is grounded, so the input register is
|
|
transparent, and bit 5 reflects the current state of the the tape low signal.
|
|
An IOI signal enables the input register to the I/O Data Bus.
|
|
|
|
|
|
|
|
The HP 2752A and 2754A Teleprinters are connected to the CPU via the HP
|
|
12531C Teleprinter interface. The interface responds to I/O instructions as
|
|
follows:
|
|
|
|
Output Data Word format (OTA and OTB):
|
|
|
|
15 |14 13 12 |11 10 9 | 8 7 6 | 5 4 3 | 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| 1 | I | P | N | - - - - - - - - - - - - | control
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| 0 | - - - - - - - | output character | data
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
I = set the interface to output/input mode (0/1)
|
|
P = enable the printer for output
|
|
N = enable the punch for output
|
|
|
|
|
|
Input Data Word format (LIA and LIB):
|
|
|
|
15 |14 13 12 |11 10 9 | 8 7 6 | 5 4 3 | 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| B | - - - - - - - | input character |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
B = interface is idle/busy (0/1)
|
|
|
|
To support CPU idling, the teleprinter interface (which doubles as the
|
|
simulator console) polls for input using a calibrated timer with a ten
|
|
millisecond period. Other polled-keyboard input devices (multiplexers and
|
|
the BACI card) synchronize with the console poll to ensure maximum available
|
|
idle time. The console poll is guaranteed to run, as the TTY device cannot
|
|
be disabled.
|
|
|
|
|
|
|
|
The time base generator interface responds to I/O instructions as follows:
|
|
|
|
Output Data Word format (OTA and OTB):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - - - - - - | tick rate |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Tick Rate Selection:
|
|
|
|
000 = 100 microseconds
|
|
001 = 1 millisecond
|
|
010 = 10 milliseconds
|
|
011 = 100 milliseconds
|
|
100 = 1 second
|
|
101 = 10 seconds
|
|
110 = 100 seconds
|
|
111 = 1000 seconds
|
|
|
|
If jumper W2 is in position B, the last four rates are divided by 1000,
|
|
producing rates of 1, 10, 100, and 1000 milliseconds, respectively.
|
|
|
|
|
|
Input Data Word format (LIA, LIB, MIA, and MIB):
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - - - - | E | - - - - |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
E = At least one tick has been lost
|
|
|
|
If jumper W1 is in position B, bit 5 also indicates a lost tick.
|
|
|
|
|
|
In hardware, the two configuration jumpers perform these functions:
|
|
|
|
Jumper Interpretation in position A Interpretation in position B
|
|
------ ---------------------------- ---------------------------------
|
|
W1 Input bit 5 is always zero Input bit 5 indicates a lost tick
|
|
|
|
W2 Last four rates are seconds Last four rates are milliseconds
|
|
|
|
The time base generator autocalibrates. If the TBG is set to a ten
|
|
millisecond period (e.g., as under RTE), it is synchronized to the console
|
|
poll. Otherwise (e.g., as under DOS or TSB, which use 100 millisecond
|
|
periods), it runs asynchronously. If the specified clock frequency is below
|
|
10Hz, the clock service routine runs at 10Hz and counts down a repeat counter
|
|
before generating an interrupt. Autocalibration will not work if the clock
|
|
is running at 1Hz or less.
|
|
*/
|
|
|
|
|
|
|
|
#include "hp2100_defs.h"
|
|
#include "hp2100_cpu.h"
|
|
|
|
|
|
|
|
#define TTY_OUT_WAIT 200 /* TTY output wait */
|
|
|
|
#define UNIT_V_DIAG (TTUF_V_UF + 0) /* diag mode */
|
|
#define UNIT_V_AUTOLF (TTUF_V_UF + 1) /* auto linefeed */
|
|
#define UNIT_DIAG (1 << UNIT_V_DIAG)
|
|
#define UNIT_AUTOLF (1 << UNIT_V_AUTOLF)
|
|
|
|
#define PTP_LOW 0000040 /* low tape */
|
|
#define TM_MODE 0100000 /* mode change */
|
|
#define TM_KBD 0040000 /* enable keyboard */
|
|
#define TM_PRI 0020000 /* enable printer */
|
|
#define TM_PUN 0010000 /* enable punch */
|
|
#define TP_BUSY 0100000 /* busy */
|
|
|
|
struct {
|
|
FLIP_FLOP control; /* control flip-flop */
|
|
FLIP_FLOP flag; /* flag flip-flop */
|
|
FLIP_FLOP flagbuf; /* flag buffer flip-flop */
|
|
} ptr = { CLEAR, CLEAR, CLEAR };
|
|
|
|
int32 ptr_trlcnt = 0; /* trailer counter */
|
|
int32 ptr_trllim = 40; /* trailer to add */
|
|
|
|
struct {
|
|
FLIP_FLOP control; /* control flip-flop */
|
|
FLIP_FLOP flag; /* flag flip-flop */
|
|
FLIP_FLOP flagbuf; /* flag buffer flip-flop */
|
|
} ptp = { CLEAR, CLEAR, CLEAR };
|
|
|
|
struct {
|
|
FLIP_FLOP control; /* control flip-flop */
|
|
FLIP_FLOP flag; /* flag flip-flop */
|
|
FLIP_FLOP flagbuf; /* flag buffer flip-flop */
|
|
} tty = { CLEAR, CLEAR, CLEAR };
|
|
|
|
int32 tty_buf = 0; /* tty buffer */
|
|
int32 tty_mode = 0; /* tty mode */
|
|
int32 tty_shin = 0377; /* tty shift in */
|
|
int32 tty_lf = 0; /* lf flag */
|
|
|
|
DEVICE ptr_dev, ptp_dev, tty_dev, clk_dev;
|
|
|
|
IOHANDLER ptrio;
|
|
t_stat ptr_svc (UNIT *uptr);
|
|
t_stat ptr_attach (UNIT *uptr, CONST char *cptr);
|
|
t_stat ptr_reset (DEVICE *dptr);
|
|
t_stat ptr_boot (int32 unitno, DEVICE *dptr);
|
|
|
|
IOHANDLER ptpio;
|
|
t_stat ptp_svc (UNIT *uptr);
|
|
t_stat ptp_reset (DEVICE *dptr);
|
|
|
|
IOHANDLER ttyio;
|
|
t_stat tti_svc (UNIT *uptr);
|
|
t_stat tto_svc (UNIT *uptr);
|
|
t_stat tty_reset (DEVICE *dptr);
|
|
t_stat tty_set_opt (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
|
|
t_stat tty_set_alf (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
|
|
t_stat tto_out (int32 c);
|
|
|
|
|
|
/* PTR data structures
|
|
|
|
ptr_dev PTR device descriptor
|
|
ptr_unit PTR unit descriptor
|
|
ptr_mod PTR modifiers
|
|
ptr_reg PTR register list
|
|
*/
|
|
|
|
DIB ptr_dib = { &ptrio, PTR };
|
|
|
|
UNIT ptr_unit = {
|
|
UDATA (&ptr_svc, UNIT_SEQ+UNIT_ATTABLE+UNIT_ROABLE, 0),
|
|
SERIAL_IN_WAIT
|
|
};
|
|
|
|
REG ptr_reg[] = {
|
|
{ ORDATA (BUF, ptr_unit.buf, 8) },
|
|
{ FLDATA (CTL, ptr.control, 0) },
|
|
{ FLDATA (FLG, ptr.flag, 0) },
|
|
{ FLDATA (FBF, ptr.flagbuf, 0) },
|
|
{ DRDATA (TRLCTR, ptr_trlcnt, 8), REG_HRO },
|
|
{ DRDATA (TRLLIM, ptr_trllim, 8), PV_LEFT },
|
|
{ DRDATA (POS, ptr_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, ptr_unit.wait, 24), PV_LEFT },
|
|
{ ORDATA (SC, ptr_dib.select_code, 6), REG_HRO },
|
|
{ ORDATA (DEVNO, ptr_dib.select_code, 6), REG_HRO },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB ptr_mod[] = {
|
|
{ UNIT_DIAG, UNIT_DIAG, "diagnostic mode", "DIAGNOSTIC", NULL },
|
|
{ UNIT_DIAG, 0, "reader mode", "READER", NULL },
|
|
{ MTAB_XTD | MTAB_VDV, 1u, "SC", "SC", &hp_set_dib, &hp_show_dib, (void *) &ptr_dib },
|
|
{ MTAB_XTD | MTAB_VDV | MTAB_NMO, ~1u, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &ptr_dib },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE ptr_dev = {
|
|
"PTR", /* device name */
|
|
&ptr_unit, /* unit array */
|
|
ptr_reg, /* register array */
|
|
ptr_mod, /* modifier array */
|
|
1, /* number of units */
|
|
10, /* address radix */
|
|
31, /* address width */
|
|
1, /* address increment */
|
|
8, /* data radix */
|
|
8, /* data width */
|
|
NULL, /* examine routine */
|
|
NULL, /* deposit routine */
|
|
&ptr_reset, /* reset routine */
|
|
&ptr_boot, /* boot routine */
|
|
&ptr_attach, /* attach routine */
|
|
NULL, /* detach routine */
|
|
&ptr_dib, /* device information block pointer */
|
|
DEV_DISABLE, /* device flags */
|
|
0, /* debug control flags */
|
|
NULL, /* debug flag name array */
|
|
NULL, /* memory size change routine */
|
|
NULL /* logical device name */
|
|
};
|
|
|
|
|
|
/* PTP data structures
|
|
|
|
ptp_dev PTP device descriptor
|
|
ptp_unit PTP unit descriptor
|
|
ptp_mod PTP modifiers
|
|
ptp_reg PTP register list
|
|
*/
|
|
|
|
DIB ptp_dib = { &ptpio, PTP };
|
|
|
|
UNIT ptp_unit = {
|
|
UDATA (&ptp_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_OUT_WAIT
|
|
};
|
|
|
|
REG ptp_reg[] = {
|
|
{ ORDATA (BUF, ptp_unit.buf, 8) },
|
|
{ FLDATA (CTL, ptp.control, 0) },
|
|
{ FLDATA (FLG, ptp.flag, 0) },
|
|
{ FLDATA (FBF, ptp.flagbuf, 0) },
|
|
{ DRDATA (POS, ptp_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, ptp_unit.wait, 24), PV_LEFT },
|
|
{ ORDATA (SC, ptp_dib.select_code, 6), REG_HRO },
|
|
{ ORDATA (DEVNO, ptp_dib.select_code, 6), REG_HRO },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB ptp_mod[] = {
|
|
{ MTAB_XTD | MTAB_VDV, 1u, "SC", "SC", &hp_set_dib, &hp_show_dib, (void *) &ptp_dib },
|
|
{ MTAB_XTD | MTAB_VDV | MTAB_NMO, ~1u, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &ptp_dib },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE ptp_dev = {
|
|
"PTP", /* device name */
|
|
&ptp_unit, /* unit array */
|
|
ptp_reg, /* register array */
|
|
ptp_mod, /* modifier array */
|
|
1, /* number of units */
|
|
10, /* address radix */
|
|
31, /* address width */
|
|
1, /* address increment */
|
|
8, /* data radix */
|
|
8, /* data width */
|
|
NULL, /* examine routine */
|
|
NULL, /* deposit routine */
|
|
&ptp_reset, /* reset routine */
|
|
NULL, /* boot routine */
|
|
&hp_attach, /* attach routine */
|
|
NULL, /* detach routine */
|
|
&ptp_dib, /* device information block pointer */
|
|
DEV_DISABLE, /* device flags */
|
|
0, /* debug control flags */
|
|
NULL, /* debug flag name array */
|
|
NULL, /* memory size change routine */
|
|
NULL /* logical device name */
|
|
};
|
|
|
|
|
|
/* TTY data structures
|
|
|
|
tty_dev TTY device descriptor
|
|
tty_unit TTY unit descriptor
|
|
tty_reg TTY register list
|
|
tty_mod TTy modifiers list
|
|
*/
|
|
|
|
#define TTI 0
|
|
#define TTO 1
|
|
#define TTP 2
|
|
|
|
DIB tty_dib = { &ttyio, TTY };
|
|
|
|
UNIT tty_unit[] = {
|
|
{ UDATA (&tti_svc, UNIT_IDLE | TT_MODE_UC, 0), POLL_PERIOD },
|
|
{ UDATA (&tto_svc, TT_MODE_UC, 0), TTY_OUT_WAIT },
|
|
{ UDATA (&tto_svc, UNIT_SEQ | UNIT_ATTABLE | TT_MODE_8B, 0), SERIAL_OUT_WAIT }
|
|
};
|
|
|
|
REG tty_reg[] = {
|
|
{ ORDATA (BUF, tty_buf, 8) },
|
|
{ ORDATA (MODE, tty_mode, 16) },
|
|
{ ORDATA (SHIN, tty_shin, 8), REG_HRO },
|
|
{ FLDATA (CTL, tty.control, 0) },
|
|
{ FLDATA (FLG, tty.flag, 0) },
|
|
{ FLDATA (FBF, tty.flagbuf, 0) },
|
|
{ FLDATA (KLFP, tty_lf, 0), REG_HRO },
|
|
{ DRDATA (KPOS, tty_unit[TTI].pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (KTIME, tty_unit[TTI].wait, 24), REG_NZ + PV_LEFT },
|
|
{ DRDATA (TPOS, tty_unit[TTO].pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TTIME, tty_unit[TTO].wait, 24), REG_NZ + PV_LEFT },
|
|
{ DRDATA (PPOS, tty_unit[TTP].pos, T_ADDR_W), PV_LEFT },
|
|
{ ORDATA (SC, tty_dib.select_code, 6), REG_HRO },
|
|
{ ORDATA (DEVNO, tty_dib.select_code, 6), REG_HRO },
|
|
{ NULL }
|
|
};
|
|
|
|
MTAB tty_mod[] = {
|
|
{ TT_MODE, TT_MODE_UC, "UC", "UC", &tty_set_opt },
|
|
{ TT_MODE, TT_MODE_7B, "7b", "7B", &tty_set_opt },
|
|
{ TT_MODE, TT_MODE_8B, "8b", "8B", &tty_set_opt },
|
|
{ TT_MODE, TT_MODE_7P, "7p", "7P", &tty_set_opt },
|
|
{ UNIT_AUTOLF, UNIT_AUTOLF, "autolf", "AUTOLF", &tty_set_alf },
|
|
{ UNIT_AUTOLF, 0 , NULL, "NOAUTOLF", &tty_set_alf },
|
|
{ MTAB_XTD | MTAB_VDV, 1u, "SC", "SC", &hp_set_dib, &hp_show_dib, (void *) &tty_dib },
|
|
{ MTAB_XTD | MTAB_VDV | MTAB_NMO, ~1u, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &tty_dib },
|
|
{ 0 }
|
|
};
|
|
|
|
DEVICE tty_dev = {
|
|
"TTY", /* device name */
|
|
tty_unit, /* unit array */
|
|
tty_reg, /* register array */
|
|
tty_mod, /* modifier array */
|
|
3, /* number of units */
|
|
10, /* address radix */
|
|
31, /* address width */
|
|
1, /* address increment */
|
|
8, /* data radix */
|
|
8, /* data width */
|
|
NULL, /* examine routine */
|
|
NULL, /* deposit routine */
|
|
&tty_reset, /* reset routine */
|
|
NULL, /* boot routine */
|
|
&hp_attach, /* attach routine */
|
|
NULL, /* detach routine */
|
|
&tty_dib, /* device information block pointer */
|
|
0, /* device flags */
|
|
0, /* debug control flags */
|
|
NULL, /* debug flag name array */
|
|
NULL, /* memory size change routine */
|
|
NULL /* logical device name */
|
|
};
|
|
|
|
|
|
/* Paper tape reader I/O signal handler.
|
|
|
|
Implementation notes:
|
|
|
|
1. The 12597A duplex register card is used to interface the paper tape
|
|
reader to the computer. This card has a device command flip-flop, which
|
|
supplies the READ signal to the tape reader. Under simulation, this
|
|
state is implied by the activation of the PTR unit.
|
|
|
|
2. The POPIO signal clears the output buffer of the duplex card. However,
|
|
the buffer outputs are not used by the paper tape reader. Under
|
|
simulation, we omit the buffer clear.
|
|
*/
|
|
|
|
uint32 ptrio (DIB *dibptr, IOCYCLE signal_set, uint32 stat_data)
|
|
{
|
|
IOSIGNAL signal;
|
|
IOCYCLE working_set = IOADDSIR (signal_set); /* add ioSIR if needed */
|
|
|
|
while (working_set) {
|
|
signal = IONEXT (working_set); /* isolate next signal */
|
|
|
|
switch (signal) { /* dispatch I/O signal */
|
|
|
|
case ioCLF: /* clear flag flip-flop */
|
|
ptr.flag = ptr.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTF: /* set flag flip-flop */
|
|
case ioENF: /* enable flag */
|
|
ptr.flag = ptr.flagbuf = SET;
|
|
break;
|
|
|
|
|
|
case ioSFC: /* skip if flag is clear */
|
|
setstdSKF (ptr);
|
|
break;
|
|
|
|
|
|
case ioSFS: /* skip if flag is set */
|
|
setstdSKF (ptr);
|
|
break;
|
|
|
|
|
|
case ioIOI: /* I/O data input */
|
|
stat_data = IORETURN (SCPE_OK, ptr_unit.buf); /* merge in return status */
|
|
break;
|
|
|
|
|
|
case ioPOPIO: /* power-on preset to I/O */
|
|
ptr.flag = ptr.flagbuf = SET; /* set flag and flag buffer */
|
|
break;
|
|
|
|
|
|
case ioCRS: /* control reset */
|
|
case ioCLC: /* clear control flip-flop */
|
|
ptr.control = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTC: /* set control flip-flop */
|
|
ptr.control = SET;
|
|
sim_activate (&ptr_unit, ptr_unit.wait);
|
|
break;
|
|
|
|
|
|
case ioSIR: /* set interrupt request */
|
|
setstdPRL (ptr); /* set standard PRL signal */
|
|
setstdIRQ (ptr); /* set standard IRQ signal */
|
|
setstdSRQ (ptr); /* set standard SRQ signal */
|
|
break;
|
|
|
|
|
|
case ioIAK: /* interrupt acknowledge */
|
|
ptr.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
default: /* all other signals */
|
|
break; /* are ignored */
|
|
}
|
|
|
|
working_set = working_set & ~signal; /* remove current signal from set */
|
|
}
|
|
|
|
return stat_data;
|
|
}
|
|
|
|
|
|
/* Unit service */
|
|
|
|
t_stat ptr_svc (UNIT *uptr)
|
|
{
|
|
int byte;
|
|
|
|
if ((ptr_unit.flags & UNIT_ATT) == 0) /* if the reader is not attached */
|
|
if (cpu_ss_ioerr != SCPE_OK) { /* then if the I/O error stop is enabled */
|
|
sim_activate (uptr, uptr->wait); /* then reschedule the operation */
|
|
|
|
cpu_ioerr_uptr = uptr; /* save the failing unit */
|
|
return STOP_NOTAPE; /* and report that the tape isn't loaded */
|
|
}
|
|
|
|
else /* otherwise no tape in the reader */
|
|
return SCPE_OK; /* just hangs the input operation */
|
|
|
|
byte = fgetc (uptr->fileref); /* get the next byte from the paper tape file */
|
|
|
|
if (feof (uptr->fileref)) /* if the file is positioned at the EOF */
|
|
if (uptr->flags & UNIT_DIAG && uptr->pos > 0) { /* then if DIAG mode is enabled and the tape isn't empty */
|
|
rewind (uptr->fileref); /* then rewind the tape */
|
|
uptr->pos = 0; /* to simulate loop mode */
|
|
|
|
byte = fgetc (uptr->fileref); /* get the first byte from the tape */
|
|
}
|
|
|
|
else /* otherwise READER mode is enabled or the tape is empty */
|
|
if (ptr_trlcnt < ptr_trllim) { /* so if trailer remains to be added */
|
|
ptr_trlcnt++; /* then count the trailer byte */
|
|
byte = 0; /* and return a NUL */
|
|
}
|
|
|
|
else if (cpu_ss_ioerr != SCPE_OK) { /* otherwise trailer is complete; if the I/O stop is enabled */
|
|
sim_activate (uptr, uptr->wait); /* then reschedule the operation */
|
|
|
|
cpu_ioerr_uptr = uptr; /* save the failing unit */
|
|
return STOP_EOT; /* and report that the tape is at EOF */
|
|
}
|
|
|
|
else /* otherwise tape exhaustion */
|
|
return SCPE_OK; /* just hangs the input operation */
|
|
|
|
if (ferror (uptr->fileref)) { /* if a host file I/O error occurred */
|
|
cprintf ("%s simulator paper tape reader I/O error: %s\n", /* then report the error to the console */
|
|
sim_name, strerror (errno));
|
|
|
|
clearerr (uptr->fileref); /* clear the error */
|
|
return SCPE_IOERR; /* and stop the simulator */
|
|
}
|
|
|
|
else { /* otherwise the read was successful */
|
|
uptr->buf = LOWER_BYTE (byte); /* so put the byte in the buffer */
|
|
uptr->pos = ftell (uptr->fileref); /* and update the file position */
|
|
|
|
if (byte != 0) /* if the byte is not a NUL */
|
|
ptr_trlcnt = 0; /* then clear the trailing NUL counter */
|
|
|
|
ptrio (&ptr_dib, ioENF, 0); /* set the device flag */
|
|
return SCPE_OK; /* and return success */
|
|
}
|
|
}
|
|
|
|
|
|
/* Attach routine - clear the trailer counter */
|
|
|
|
t_stat ptr_attach (UNIT *uptr, CONST char *cptr)
|
|
{
|
|
ptr_trlcnt = 0;
|
|
return attach_unit (uptr, cptr);
|
|
}
|
|
|
|
|
|
/* Reset routine - called from SCP */
|
|
|
|
t_stat ptr_reset (DEVICE *dptr)
|
|
{
|
|
IOPRESET (&ptr_dib); /* PRESET device (does not use PON) */
|
|
sim_cancel (&ptr_unit); /* deactivate unit */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
/* Paper tape reader bootstrap loaders (BBL and 12992K).
|
|
|
|
The Basic Binary Loader (BBL) performs three functions, depending on the
|
|
setting of the S register, as follows:
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| C | - - - - - - - - - - - - - - | V |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
C = Compare the paper tape to memory
|
|
V = Verify checksums on the paper tape
|
|
|
|
If bit 15 is set to 1, the loader will compare the absolute program on tape
|
|
to the contents of memory. If bit 0 is set to 1, the loader will verify the
|
|
checksums of the absolute binary records on tape without altering memory. If
|
|
neither bit is set, the loader will read the absolute program on the paper
|
|
tape into memory. Loader execution ends with one of the following halt
|
|
instructions:
|
|
|
|
* HLT 00 - a comparison error occurred; A = the tape value.
|
|
* HLT 11 - a checksum error occurred; A/B = the tape/calculated value.
|
|
* HLT 55 - the program load address would overlay the loader.
|
|
* HLT 77 - the end of tape was reached with a successful read.
|
|
|
|
The 12992K boot loader ROM reads an absolute program on the paper tape into
|
|
memory. The S register setting does not affect loader operation. Loader
|
|
execution ends with one of the following halt instructions:
|
|
|
|
* HLT 11 - a checksum error occurred; A/B = the calculated/tape value.
|
|
* HLT 55 - the program load address would overlay the ROM loader.
|
|
* HLT 77 - the end of tape was reached with a successful read.
|
|
|
|
Note that the A/B register contents are in the opposite order of those in the
|
|
BBL when a checksum error occurs.
|
|
*/
|
|
|
|
static const LOADER_ARRAY ptr_loaders = {
|
|
{ /* HP 21xx Basic Binary Loader (BBL) */
|
|
000, /* loader starting index */
|
|
IBL_NA, /* DMA index (not used) */
|
|
072, /* FWA index */
|
|
{ 0107700, /* 77700: START CLC 0,C */
|
|
0063770, /* 77701: LDA 77770 */
|
|
0106501, /* 77702: LIB 1 */
|
|
0004010, /* 77703: SLB */
|
|
0002400, /* 77704: CLA */
|
|
0006020, /* 77705: SSB */
|
|
0063771, /* 77706: LDA 77771 */
|
|
0073736, /* 77707: STA 77736 */
|
|
0006401, /* 77710: CLB,RSS */
|
|
0067773, /* 77711: LDB 77773 */
|
|
0006006, /* 77712: INB,SZB */
|
|
0027717, /* 77713: JMP 77717 */
|
|
0107700, /* 77714: CLC 0,C */
|
|
0102077, /* 77715: HLT 77 */
|
|
0027700, /* 77716: JMP 77700 */
|
|
0017762, /* 77717: JSB 77762 */
|
|
0002003, /* 77720: SZA,RSS */
|
|
0027712, /* 77721: JMP 77712 */
|
|
0003104, /* 77722: CMA,CLE,INA */
|
|
0073774, /* 77723: STA 77774 */
|
|
0017762, /* 77724: JSB 77762 */
|
|
0017753, /* 77725: JSB 77753 */
|
|
0070001, /* 77726: STA 1 */
|
|
0073775, /* 77727: STA 77775 */
|
|
0063775, /* 77730: LDA 77775 */
|
|
0043772, /* 77731: ADA 77772 */
|
|
0002040, /* 77732: SEZ */
|
|
0027751, /* 77733: JMP 77751 */
|
|
0017753, /* 77734: JSB 77753 */
|
|
0044000, /* 77735: ADB 0 */
|
|
0000000, /* 77736: NOP */
|
|
0002101, /* 77737: CLE,RSS */
|
|
0102000, /* 77740: HLT 0 */
|
|
0037775, /* 77741: ISZ 77775 */
|
|
0037774, /* 77742: ISZ 77774 */
|
|
0027730, /* 77743: JMP 77730 */
|
|
0017753, /* 77744: JSB 77753 */
|
|
0054000, /* 77745: CPB 0 */
|
|
0027711, /* 77746: JMP 77711 */
|
|
0102011, /* 77747: HLT 11 */
|
|
0027700, /* 77750: JMP 77700 */
|
|
0102055, /* 77751: HLT 55 */
|
|
0027700, /* 77752: JMP 77700 */
|
|
0000000, /* 77753: NOP */
|
|
0017762, /* 77754: JSB 77762 */
|
|
0001727, /* 77755: ALF,ALF */
|
|
0073776, /* 77756: STA 77776 */
|
|
0017762, /* 77757: JSB 77762 */
|
|
0033776, /* 77760: IOR 77776 */
|
|
0127753, /* 77761: JMP 77753,I */
|
|
0000000, /* 77762: NOP */
|
|
0103710, /* 77763: STC 10,C */
|
|
0102310, /* 77764: SFS 10 */
|
|
0027764, /* 77765: JMP 77764 */
|
|
0102510, /* 77766: LIA 10 */
|
|
0127762, /* 77767: JMP 77762,I */
|
|
0173775, /* 77770: STA 77775,I */
|
|
0153775, /* 77771: CPA 77775,I */
|
|
0100100, /* 77772: RRL 16 */
|
|
0177765, /* 77773: STB 77765,I */
|
|
0000000, /* 77774: NOP */
|
|
0000000, /* 77775: NOP */
|
|
0000000, /* 77776: NOP */
|
|
0000000 } }, /* 77777: NOP */
|
|
|
|
{ /* HP 1000 Loader ROM (12992K) */
|
|
IBL_START, /* loader starting index */
|
|
IBL_DMA, /* DMA index */
|
|
IBL_FWA, /* FWA index */
|
|
{ 0107700, /* 77700: ST CLC 0,C ; intr off */
|
|
0002401, /* 77701: CLA,RSS ; skip in */
|
|
0063756, /* 77702: CN LDA M11 ; feed frame */
|
|
0006700, /* 77703: CLB,CCE ; set E to rd byte */
|
|
0017742, /* 77704: JSB READ ; get #char */
|
|
0007306, /* 77705: CMB,CCE,INB,SZB ; 2's comp */
|
|
0027713, /* 77706: JMP *+5 ; non-zero byte */
|
|
0002006, /* 77707: INA,SZA ; feed frame ctr */
|
|
0027703, /* 77710: JMP *-3 */
|
|
0102077, /* 77711: HLT 77B ; stop */
|
|
0027700, /* 77712: JMP ST ; next */
|
|
0077754, /* 77713: STA WC ; word in rec */
|
|
0017742, /* 77714: JSB READ ; get feed frame */
|
|
0017742, /* 77715: JSB READ ; get address */
|
|
0074000, /* 77716: STB 0 ; init csum */
|
|
0077755, /* 77717: STB AD ; save addr */
|
|
0067755, /* 77720: CK LDB AD ; check addr */
|
|
0047777, /* 77721: ADB MAXAD ; below loader */
|
|
0002040, /* 77722: SEZ ; E =0 => OK */
|
|
0027740, /* 77723: JMP H55 */
|
|
0017742, /* 77724: JSB READ ; get word */
|
|
0040001, /* 77725: ADA 1 ; cont checksum */
|
|
0177755, /* 77726: STA AD,I ; store word */
|
|
0037755, /* 77727: ISZ AD */
|
|
0000040, /* 77730: CLE ; force wd read */
|
|
0037754, /* 77731: ISZ WC ; block done? */
|
|
0027720, /* 77732: JMP CK ; no */
|
|
0017742, /* 77733: JSB READ ; get checksum */
|
|
0054000, /* 77734: CPB 0 ; ok? */
|
|
0027702, /* 77735: JMP CN ; next block */
|
|
0102011, /* 77736: HLT 11 ; bad csum */
|
|
0027700, /* 77737: JMP ST ; next */
|
|
0102055, /* 77740: H55 HLT 55 ; bad address */
|
|
0027700, /* 77741: JMP ST ; next */
|
|
0000000, /* 77742: RD NOP */
|
|
0006600, /* 77743: CLB,CME ; E reg byte ptr */
|
|
0103710, /* 77744: STC RDR,C ; start reader */
|
|
0102310, /* 77745: SFS RDR ; wait */
|
|
0027745, /* 77746: JMP *-1 */
|
|
0106410, /* 77747: MIB RDR ; get byte */
|
|
0002041, /* 77750: SEZ,RSS ; E set? */
|
|
0127742, /* 77751: JMP RD,I ; no, done */
|
|
0005767, /* 77752: BLF,CLE,BLF ; shift byte */
|
|
0027744, /* 77753: JMP RD+2 ; again */
|
|
0000000, /* 77754: WC 000000 ; word count */
|
|
0000000, /* 77755: AD 000000 ; address */
|
|
0177765, /* 77756: M11 DEC -11 ; feed count */
|
|
0000000, /* 77757: NOP */
|
|
0000000, /* 77760: NOP */
|
|
0000000, /* 77761: NOP */
|
|
0000000, /* 77762: NOP */
|
|
0000000, /* 77763: NOP */
|
|
0000000, /* 77764: NOP */
|
|
0000000, /* 77765: NOP */
|
|
0000000, /* 77766: NOP */
|
|
0000000, /* 77767: NOP */
|
|
0000000, /* 77770: NOP */
|
|
0000000, /* 77771: NOP */
|
|
0000000, /* 77772: NOP */
|
|
0000000, /* 77773: NOP */
|
|
0000000, /* 77774: NOP */
|
|
0000000, /* 77775: NOP */
|
|
0000000, /* 77776: NOP */
|
|
0100100 } } /* 77777: MAXAD ABS -ST ; max addr */
|
|
};
|
|
|
|
|
|
/* Device boot routine.
|
|
|
|
This routine is called directly by the BOOT PTR and LOAD PTR commands to copy
|
|
the device bootstrap into the upper 64 words of the logical address space.
|
|
It is also called indirectly by a BOOT CPU or LOAD CPU command when the
|
|
specified HP 1000 loader ROM socket contains a 12992K ROM.
|
|
|
|
When called in response to a BOOT DPC or LOAD DPC command, the "unitno"
|
|
parameter indicates the unit number specified in the BOOT command or is zero
|
|
for the LOAD command, and "dptr" points at the PTR device structure.
|
|
Depending on the current CPU model, the BBL or 12992K loader ROM will be
|
|
copied into memory and configured for the PTR select code. If the CPU is a
|
|
1000, the S register will be set as it would be by the front-panel microcode.
|
|
|
|
When called for a BOOT/LOAD CPU command, the "unitno" parameter indicates the
|
|
select code to be used for configuration, and "dptr" will be NULL. As above,
|
|
the BBL or 12992K loader ROM will be copied into memory and configured for
|
|
the specified select code. The S register is assumed to be set correctly on
|
|
entry and is not modified.
|
|
|
|
For the 12992K boot loader ROM, the S register will be set as follows:
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| ROM # | 0 0 | PTR select code | 0 0 0 0 0 0 |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
*/
|
|
|
|
t_stat ptr_boot (int32 unitno, DEVICE *dptr)
|
|
{
|
|
if (dptr == NULL) /* if we are being called for a BOOT/LOAD CPU */
|
|
return cpu_copy_loader (ptr_loaders, unitno, /* then copy the boot loader to memory */
|
|
IBL_S_NOCLEAR, IBL_S_NOSET); /* but do not alter the S register */
|
|
|
|
else /* otherwise this is a BOOT/LOAD PTR */
|
|
return cpu_copy_loader (ptr_loaders, ptr_dib.select_code, /* so copy the boot loader to memory */
|
|
IBL_S_CLEAR, IBL_S_NOSET); /* and configure the S register if 1000 CPU */
|
|
}
|
|
|
|
|
|
/* Paper tape punch I/O signal handler.
|
|
|
|
Implementation notes:
|
|
|
|
1. The 12597A duplex register card is used to interface the paper tape
|
|
punch to the computer. This card has a device command flip-flop, which
|
|
supplies the PUNCH signal to the tape reader. Under simulation, this
|
|
state is implied by the activation of the PTP unit.
|
|
*/
|
|
|
|
uint32 ptpio (DIB *dibptr, IOCYCLE signal_set, uint32 stat_data)
|
|
{
|
|
IOSIGNAL signal;
|
|
IOCYCLE working_set = IOADDSIR (signal_set); /* add ioSIR if needed */
|
|
|
|
while (working_set) {
|
|
signal = IONEXT (working_set); /* isolate next signal */
|
|
|
|
switch (signal) { /* dispatch I/O signal */
|
|
|
|
case ioCLF: /* clear flag flip-flop */
|
|
ptp.flag = ptp.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTF: /* set flag flip-flop */
|
|
case ioENF: /* enable flag */
|
|
ptp.flag = ptp.flagbuf = SET;
|
|
break;
|
|
|
|
|
|
case ioSFC: /* skip if flag is clear */
|
|
setstdSKF (ptp);
|
|
break;
|
|
|
|
|
|
case ioSFS: /* skip if flag is set */
|
|
setstdSKF (ptp);
|
|
break;
|
|
|
|
|
|
case ioIOI: /* I/O data input */
|
|
if ((ptp_unit.flags & UNIT_ATT) == 0) /* not attached? */
|
|
stat_data = IORETURN (SCPE_OK, PTP_LOW); /* report as out of tape */
|
|
else
|
|
stat_data = IORETURN (SCPE_OK, 0);
|
|
break;
|
|
|
|
|
|
case ioIOO: /* I/O data output */
|
|
ptp_unit.buf = IODATA (stat_data); /* clear supplied status */
|
|
break;
|
|
|
|
|
|
case ioPOPIO: /* power-on preset to I/O */
|
|
ptp.flag = ptp.flagbuf = SET; /* set flag and flag buffer */
|
|
ptp_unit.buf = 0; /* clear output buffer */
|
|
break;
|
|
|
|
|
|
case ioCRS: /* control reset */
|
|
case ioCLC: /* clear control flip-flop */
|
|
ptp.control = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTC: /* set control flip-flop */
|
|
ptp.control = SET;
|
|
sim_activate (&ptp_unit, ptp_unit.wait);
|
|
break;
|
|
|
|
|
|
case ioSIR: /* set interrupt request */
|
|
setstdPRL (ptp); /* set standard PRL signal */
|
|
setstdIRQ (ptp); /* set standard IRQ signal */
|
|
setstdSRQ (ptp); /* set standard SRQ signal */
|
|
break;
|
|
|
|
|
|
case ioIAK: /* interrupt acknowledge */
|
|
ptp.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
default: /* all other signals */
|
|
break; /* are ignored */
|
|
}
|
|
|
|
working_set = working_set & ~signal; /* remove current signal from set */
|
|
}
|
|
|
|
return stat_data;
|
|
}
|
|
|
|
|
|
/* Unit service */
|
|
|
|
t_stat ptp_svc (UNIT *uptr)
|
|
{
|
|
if (uptr->flags & UNIT_ATT) /* if the punch is attached */
|
|
if (fputc (uptr->buf, uptr->fileref) == EOF) { /* then write the byte; if the write fails */
|
|
cprintf ("%s simulator paper tape punch I/O error: %s\n", /* then report the error to the console */
|
|
sim_name, strerror (errno));
|
|
|
|
clearerr (uptr->fileref); /* clear the error */
|
|
return SCPE_IOERR; /* and stop the simulator */
|
|
}
|
|
|
|
else { /* otherwise the write succeeds */
|
|
uptr->pos = ftell (uptr->fileref); /* so update the file position */
|
|
ptpio (&ptp_dib, ioENF, 0); /* and set the device flag */
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
/* Reset routine */
|
|
|
|
t_stat ptp_reset (DEVICE *dptr)
|
|
{
|
|
IOPRESET (&ptp_dib); /* PRESET device (does not use PON) */
|
|
sim_cancel (&ptp_unit); /* deactivate unit */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
/* Terminal I/O signal handler.
|
|
|
|
Output Word Format:
|
|
|
|
15 |14 13 12 |11 10 9 | 8 7 6 | 5 4 3 | 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| 1 | I | P | N | - - - - - - - - - - - - | control
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| 0 | - - - - - - - | output character | data
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
I = set the interface to output/input mode (0/1)
|
|
P = enable the printer for output
|
|
N = enable the punch for output
|
|
|
|
|
|
Input Word Format:
|
|
|
|
15 |14 13 12 |11 10 9 | 8 7 6 | 5 4 3 | 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| B | - - - - - - - | input character |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
|
|
Where:
|
|
|
|
B = interface is idle/busy (0/1)
|
|
|
|
*/
|
|
|
|
uint32 ttyio (DIB *dibptr, IOCYCLE signal_set, uint32 stat_data)
|
|
{
|
|
uint16 data;
|
|
IOSIGNAL signal;
|
|
IOCYCLE working_set = IOADDSIR (signal_set); /* add ioSIR if needed */
|
|
|
|
while (working_set) {
|
|
signal = IONEXT (working_set); /* isolate next signal */
|
|
|
|
switch (signal) { /* dispatch I/O signal */
|
|
|
|
case ioCLF: /* clear flag flip-flop */
|
|
tty.flag = tty.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTF: /* set flag flip-flop */
|
|
case ioENF: /* enable flag */
|
|
tty.flag = tty.flagbuf = SET;
|
|
break;
|
|
|
|
|
|
case ioSFC: /* skip if flag is clear */
|
|
setstdSKF (tty);
|
|
break;
|
|
|
|
|
|
case ioSFS: /* skip if flag is set */
|
|
setstdSKF (tty);
|
|
break;
|
|
|
|
|
|
case ioIOI: /* I/O data input */
|
|
data = (uint16) tty_buf;
|
|
|
|
if (!(tty_mode & TM_KBD) && sim_is_active (&tty_unit[TTO]))
|
|
data = data | TP_BUSY;
|
|
|
|
stat_data = IORETURN (SCPE_OK, data); /* merge in return status */
|
|
break;
|
|
|
|
|
|
case ioIOO: /* I/O data output */
|
|
data = IODATA (stat_data); /* clear supplied status */
|
|
|
|
if (data & TM_MODE)
|
|
tty_mode = data & (TM_KBD|TM_PRI|TM_PUN);
|
|
|
|
tty_buf = data & 0377;
|
|
break;
|
|
|
|
|
|
case ioCRS: /* control reset */
|
|
tty.control = CLEAR; /* clear control */
|
|
tty.flag = tty.flagbuf = SET; /* set flag and flag buffer */
|
|
tty_mode = TM_KBD; /* set tty, clear print/punch */
|
|
tty_shin = 0377; /* input inactive */
|
|
tty_lf = 0; /* no lf pending */
|
|
break;
|
|
|
|
|
|
case ioCLC: /* clear control flip-flop */
|
|
tty.control = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTC: /* set control flip-flop */
|
|
tty.control = SET;
|
|
|
|
if (!(tty_mode & TM_KBD)) /* output? */
|
|
sim_activate (&tty_unit[TTO], tty_unit[TTO].wait);
|
|
break;
|
|
|
|
|
|
case ioSIR: /* set interrupt request */
|
|
setstdPRL (tty); /* set standard PRL signal */
|
|
setstdIRQ (tty); /* set standard IRQ signal */
|
|
setstdSRQ (tty); /* set standard SRQ signal */
|
|
break;
|
|
|
|
|
|
case ioIAK: /* interrupt acknowledge */
|
|
tty.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
default: /* all other signals */
|
|
break; /* are ignored */
|
|
}
|
|
|
|
working_set = working_set & ~signal; /* remove current signal from set */
|
|
}
|
|
|
|
return stat_data;
|
|
}
|
|
|
|
|
|
/* TTY input service routine.
|
|
|
|
The console input poll routine is scheduled with a ten millisecond period
|
|
using a calibrated timer, which is the source of event timing for all of the
|
|
keyboard polling routines. Synchronizing other keyboard polls with the
|
|
console poll ensures maximum idle time.
|
|
|
|
Several HP operating systems require a CR and LF sequence for line
|
|
termination. This is awkward on a PC, as there is no LF key (CTRL+J is
|
|
needed instead). We provide an AUTOLF mode to add a LF automatically to each
|
|
CR input. When this mode is set, entering CR will set a flag, which will
|
|
cause a LF to be supplied automatically at the next input poll.
|
|
|
|
The 12531C teleprinter interface and the later 12880A CRT interface provide a
|
|
clever mechanism to detect a keypress during output. This is used by DOS and
|
|
RTE to allow the user to interrupt lengthy output operations to enter system
|
|
commands.
|
|
|
|
Referring to the 12531C schematic, the terminal input enters on pin X
|
|
("DATA FROM EIA COMPATIBLE DEVICE"). The signal passes through four
|
|
transistor inversions (Q8, Q1, Q2, and Q3) to appear on pin 12 of NAND gate
|
|
U104C. If the flag flip-flop is not set, the terminal input passes to the
|
|
(inverted) output of U104C and thence to the D input of the first of the
|
|
flip-flops forming the data register.
|
|
|
|
In the idle condition (no key pressed), the terminal input line is marking
|
|
(voltage negative), so in passing through a total of five inversions, a
|
|
logic one is presented at the serial input of the data register. During an
|
|
output operation, the register is parallel loaded and serially shifted,
|
|
sending the output data through the register to the device and -- this is
|
|
the crux -- filling the register with logic ones from U104C.
|
|
|
|
At the end of the output operation, the card flag is set, an interrupt
|
|
occurs, and the RTE driver is entered. The driver then does an LIA SC to
|
|
read the contents of the data register. If no key has been pressed during
|
|
the output operation, the register will read as all ones (octal 377). If,
|
|
however, any key was struck, at least one zero bit will be present. If the
|
|
register value doesn't equal 377, the driver sets the system "operator
|
|
attention" flag, which will cause DOS or RTE to output an asterisk prompt and
|
|
initiate a terminal read when the current output line is completed.
|
|
|
|
|
|
Implementation notes:
|
|
|
|
1. The current CPU speed, expressed as a multiple of the hardware speed, is
|
|
calculated for each service entry. It may be displayed at the SCP prompt
|
|
with the SHOW CPU SPEED command. The speed is only representative when
|
|
the CPU is not idling.
|
|
*/
|
|
|
|
t_stat tti_svc (UNIT *uptr)
|
|
{
|
|
int32 c;
|
|
|
|
uptr->wait = sim_rtcn_calb (POLL_RATE, TMR_POLL); /* calibrate poll timer */
|
|
sim_activate (uptr, uptr->wait); /* continue poll */
|
|
|
|
cpu_speed = uptr->wait / POLL_PERIOD; /* calculate the current CPU speed multiplier */
|
|
|
|
tty_shin = 0377; /* assume inactive */
|
|
|
|
if (tty_lf) { /* auto lf pending? */
|
|
c = 012; /* force lf */
|
|
tty_lf = 0;
|
|
}
|
|
|
|
else {
|
|
c = sim_poll_kbd ();
|
|
|
|
if (c < SCPE_KFLAG) /* no char or error? */
|
|
return c;
|
|
|
|
if (c & SCPE_BREAK) /* break? */
|
|
c = 0;
|
|
else
|
|
c = sim_tt_inpcvt (c, TT_GET_MODE (uptr->flags));
|
|
|
|
tty_lf = ((c & 0177) == 015) && (uptr->flags & UNIT_AUTOLF);
|
|
}
|
|
|
|
if (tty_mode & TM_KBD) { /* keyboard enabled? */
|
|
tty_buf = c; /* put char in buf */
|
|
uptr->pos = uptr->pos + 1;
|
|
|
|
ttyio (&tty_dib, ioENF, 0); /* set flag */
|
|
|
|
if (c)
|
|
tto_out (c); /* echo? */
|
|
}
|
|
|
|
else /* no, char shifts in */
|
|
tty_shin = c;
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
/* TTY output service routine */
|
|
|
|
t_stat tto_svc (UNIT *uptr)
|
|
{
|
|
t_stat r;
|
|
|
|
r = tto_out (tty_buf); /* output the character */
|
|
|
|
if (r == SCPE_OK) { /* if the output succeeded */
|
|
tty_buf = tty_shin; /* then shift the input line into the buffer */
|
|
tty_shin = 0377; /* and set the input line to the marking state */
|
|
|
|
ttyio (&tty_dib, ioENF, 0); /* set the flag */
|
|
return SCPE_OK; /* and return success */
|
|
}
|
|
|
|
else { /* otherwise an error occurred */
|
|
sim_activate (uptr, uptr->wait); /* so schedule a retry */
|
|
|
|
return (r == SCPE_STALL ? SCPE_OK : r); /* report a stall as success */
|
|
}
|
|
}
|
|
|
|
|
|
/* TTY output routine.
|
|
|
|
The 12531C Buffered Teleprinter Interface connects current-loop devices, such
|
|
as the HP 2752A (ASR33) and 2754A (ASR35) teleprinters, as well as EIA RS-232
|
|
devices, such as the HP 2749A (ASR33) teleprinter and HP 2600 terminal. For
|
|
output, the control word sent to the interface may set the print flip-flop,
|
|
the punch flip-flop, or both flip-flops. These flip-flops generate the PRINT
|
|
COMMAND and PUNCH COMMAND output signals, respectively. Setting either one
|
|
enables data transmission.
|
|
|
|
Only the 2754A responds to the PRINT and PUNCH COMMAND signals. All of the
|
|
other devices ignore these signals and respond only to the serial data out
|
|
signal. (The paper tape punches on the 2749A and 2752A teleprinters must be
|
|
enabled manually at the console and operate concurrently with the printers.)
|
|
|
|
This routine simulates a 2754A if the punch unit (TTY unit 2) is attached and
|
|
a generic terminal when the unit is detached. With the punch unit attached,
|
|
the punch flip-flop must be set to punch, and the print flip-flop must be set
|
|
to print. These flip-flops, and therefore their respective operations, are
|
|
independent. When the punch unit is detached, printing will occur if either
|
|
the print or punch flip-flop is set. If neither flip-flop is set, no output
|
|
occurs. Therefore, the logic is:
|
|
|
|
if punch-flip-flop and punch-attached
|
|
then punch character
|
|
|
|
if print-flip-flop or punch-flip-flop and not punch-attached
|
|
then print character
|
|
|
|
Certain HP programs, e.g., HP 2000F BASIC FOR DOS-M/DOS III, depend on the
|
|
2752A et. al. behavior. The DOS and RTE teleprinter drivers support text and
|
|
binary output modes. Text mode sets the print flip-flop, and binary mode
|
|
sets the punch flip-flop. These programs use binary mode to write single
|
|
characters to the teleprinter and expect that they will be printed. The
|
|
simulator follows this behavior.
|
|
*/
|
|
|
|
t_stat tto_out (int32 c)
|
|
{
|
|
t_stat r = SCPE_OK;
|
|
|
|
if (tty_mode & TM_PUN /* if punching is enabled */
|
|
&& tty_unit [TTP].flags & UNIT_ATT) /* and the punch is attached */
|
|
if (fputc (c, tty_unit [TTP].fileref) == EOF) { /* then write the byte; if the write fails */
|
|
cprintf ("%s simulator teleprinter punch I/O error: %s\n", /* then report the error to the console */
|
|
sim_name, strerror (errno));
|
|
|
|
clearerr (tty_unit [TTP].fileref); /* clear the error */
|
|
r = SCPE_IOERR; /* and stop the simulator */
|
|
}
|
|
|
|
else /* otherwise the output succeeded */
|
|
tty_unit [TTP].pos = ftell (tty_unit [TTP].fileref); /* so update the file position */
|
|
|
|
if (tty_mode & TM_PRI /* if printing is enabled */
|
|
|| tty_mode & TM_PUN /* or punching is enabled */
|
|
&& (tty_unit [TTP].flags & UNIT_ATT) == 0) { /* and the punch is not attached */
|
|
c = sim_tt_outcvt (c, TT_GET_MODE (tty_unit [TTO].flags)); /* then convert the character */
|
|
|
|
if (c >= 0) { /* if the character is valid */
|
|
r = sim_putchar_s (c); /* then output it to the console */
|
|
|
|
if (r == SCPE_OK) /* if the output succeeded */
|
|
tty_unit [TTO].pos = tty_unit [TTO].pos + 1; /* then update the file position */
|
|
}
|
|
}
|
|
|
|
return r; /* return the result */
|
|
}
|
|
|
|
|
|
/* TTY reset routine */
|
|
|
|
t_stat tty_reset (DEVICE *dptr)
|
|
{
|
|
if (sim_switches & SWMASK ('P')) /* initialization reset? */
|
|
tty_buf = 0; /* clear buffer */
|
|
|
|
IOPRESET (&tty_dib); /* PRESET device (does not use PON) */
|
|
|
|
tty_unit[TTI].wait = POLL_PERIOD; /* reset initial poll */
|
|
sim_rtcn_init (tty_unit[TTI].wait, TMR_POLL); /* init poll timer */
|
|
sim_activate (&tty_unit[TTI], tty_unit[TTI].wait); /* activate poll */
|
|
sim_cancel (&tty_unit[TTO]); /* cancel output */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
t_stat tty_set_opt (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
|
|
{
|
|
int32 u = uptr - tty_unit;
|
|
|
|
if (u > TTO) return SCPE_NOFNC;
|
|
if ((u == TTI) && (val == TT_MODE_7P))
|
|
val = TT_MODE_7B;
|
|
tty_unit[u].flags = (tty_unit[u].flags & ~TT_MODE) | val;
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
t_stat tty_set_alf (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
|
|
{
|
|
int32 u = uptr - tty_unit;
|
|
|
|
if (u != TTI) return SCPE_NOFNC;
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
/* Synchronize polling.
|
|
|
|
Return an event time corresponding either with the amount of time remaining
|
|
in the current poll (mode = INITIAL) or the amount of time in a full poll
|
|
period (mode = SERVICE). If the former call is made when the device service
|
|
routine is started, then making the latter call during unit service will
|
|
ensure that the polls remain synchronized.
|
|
*/
|
|
|
|
int32 sync_poll (POLLMODE poll_mode)
|
|
{
|
|
int32 poll_time;
|
|
|
|
if (poll_mode == INITIAL) {
|
|
poll_time = sim_activate_time (&tty_unit[TTI]);
|
|
|
|
if (poll_time)
|
|
return poll_time;
|
|
else
|
|
return POLL_PERIOD;
|
|
}
|
|
else
|
|
return tty_unit[TTI].wait;
|
|
}
|
|
|
|
|
|
|
|
/* 12539C Time Base Generator *************************************************/
|
|
|
|
|
|
/* Program constants */
|
|
|
|
static const int32 delay [8] = { /* clock delays, in event ticks per interval */
|
|
uS (100), /* 000 = 100 microseconds */
|
|
mS (1), /* 001 = 1 millisecond */
|
|
mS (10), /* 010 = 10 milliseconds */
|
|
mS (100), /* 011 = 100 milliseconds */
|
|
S (1), /* 100 = 1 second */
|
|
S (10), /* 101 = 10 seconds */
|
|
S (100), /* 110 = 100 seconds */
|
|
S (1000) /* 111 = 1000 seconds */
|
|
};
|
|
|
|
static const int32 ticks [8] = { /* clock ticks per second */
|
|
10000, /* 000 = 100 microseconds */
|
|
1000, /* 001 = 1 millisecond */
|
|
100, /* 010 = 10 milliseconds */
|
|
10, /* 011 = 100 milliseconds */
|
|
10, /* 100 = 1 second */
|
|
10, /* 101 = 10 seconds */
|
|
10, /* 110 = 100 seconds */
|
|
10 /* 111 = 1000 seconds */
|
|
};
|
|
|
|
static const int32 scale [8] = { /* prescaler counts per clock tick */
|
|
1, /* 000 = 100 microseconds */
|
|
1, /* 001 = 1 millisecond */
|
|
1, /* 010 = 10 milliseconds */
|
|
1, /* 011 = 100 milliseconds */
|
|
10, /* 100 = 1 second */
|
|
100, /* 101 = 10 seconds */
|
|
1000, /* 110 = 100 seconds */
|
|
10000 /* 111 = 1000 seconds */
|
|
};
|
|
|
|
|
|
/* Unit flags */
|
|
|
|
#define UNIT_CALTIME_SHIFT (UNIT_V_UF + 0) /* calibrated timing mode */
|
|
#define UNIT_W1B_SHIFT (UNIT_V_UF + 1) /* jumper W1 in position B */
|
|
#define UNIT_W2B_SHIFT (UNIT_V_UF + 2) /* jumper W2 in position B */
|
|
|
|
#define UNIT_CALTIME (1u << UNIT_CALTIME_SHIFT)
|
|
#define UNIT_W1B (1u << UNIT_W1B_SHIFT)
|
|
#define UNIT_W2B (1u << UNIT_W2B_SHIFT)
|
|
|
|
|
|
/* Control word.
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - - - - - - | tick rate |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
*/
|
|
|
|
#define CN_RATE_MASK 0000007u /* clock rate selector mask */
|
|
|
|
#define CN_RATE_SHIFT 0 /* clock rate alignment shift */
|
|
|
|
#define CN_RATE(c) (((c) & CN_RATE_MASK) >> CN_RATE_SHIFT)
|
|
|
|
static const char *const rate_name [8] = { /* clock rate selector names */
|
|
"100 microsecond", /* 000 = 100 microseconds */
|
|
"1 millisecond", /* 001 = 1 millisecond */
|
|
"10 millisecond", /* 010 = 10 milliseconds */
|
|
"100 millisecond", /* 011 = 100 milliseconds */
|
|
"1 second", /* 100 = 1 second */
|
|
"10 second", /* 101 = 10 seconds */
|
|
"100 second", /* 110 = 100 seconds */
|
|
"1000 second" /* 111 = 1000 seconds */
|
|
};
|
|
|
|
|
|
/* Status word.
|
|
|
|
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
| - - - - - - - - - - - | E | - - - - |
|
|
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
|
|
*/
|
|
|
|
#define ST_ERROR 0000020u /* lost tick error */
|
|
#define ST_ERROR_W1B 0000040u /* lost tick error if W1 in position B */
|
|
|
|
static const BITSET_NAME status_names [] = { /* Status word names */
|
|
"lost tick" /* bit 4 */
|
|
};
|
|
|
|
static const BITSET_FORMAT status_format = /* names, offset, direction, alternates, bar */
|
|
{ FMT_INIT (status_names, 4, msb_first, no_alt, no_bar) };
|
|
|
|
|
|
/* Time Base Generator state */
|
|
|
|
static struct {
|
|
FLIP_FLOP control; /* control flip-flop */
|
|
FLIP_FLOP flag; /* flag flip-flop */
|
|
FLIP_FLOP flagbuf; /* flag buffer flip-flop */
|
|
} clk = { CLEAR, CLEAR, CLEAR };
|
|
|
|
static int32 clk_select = 0; /* clock time select */
|
|
static int32 clk_ctr = 0; /* clock counter */
|
|
static FLIP_FLOP lost_tick = CLEAR; /* lost tick error flip-flop */
|
|
|
|
|
|
/* Time Base Generator local SCP support routines */
|
|
|
|
static IOHANDLER clk_interface;
|
|
static t_stat clk_service (UNIT *uptr);
|
|
static t_stat clk_reset (DEVICE *dptr);
|
|
|
|
|
|
/* Time Base Generator local utility routines */
|
|
|
|
static int32 clk_delay (int32 flg);
|
|
|
|
|
|
/* Time Base Generator SCP interface data structures */
|
|
|
|
|
|
/* Device information block */
|
|
|
|
DIB clk_dib = {
|
|
&clk_interface, /* device interface */
|
|
CLK, /* select code */
|
|
0 /* card index */
|
|
};
|
|
|
|
/* Unit list */
|
|
|
|
static UNIT clk_unit [] = {
|
|
{ UDATA (&clk_service, UNIT_IDLE | UNIT_CALTIME, 0) }
|
|
};
|
|
|
|
/* Register list */
|
|
|
|
static REG clk_reg [] = {
|
|
/* Macro Name Location Width Offset Flags */
|
|
/* ------ ------ ------------------- ----- ------ ------- */
|
|
{ ORDATA (SEL, clk_select, 3) },
|
|
{ DRDATA (CTR, clk_ctr, 14) },
|
|
{ FLDATA (CTL, clk.control, 0) },
|
|
{ FLDATA (FLG, clk.flag, 0) },
|
|
{ FLDATA (FBF, clk.flagbuf, 0) },
|
|
{ FLDATA (ERR, lost_tick, 0) },
|
|
{ ORDATA (SC, clk_dib.select_code, 6), REG_HRO },
|
|
{ ORDATA (DEVNO, clk_dib.select_code, 6), REG_HRO },
|
|
{ NULL }
|
|
};
|
|
|
|
/* Modifier list */
|
|
|
|
static MTAB clk_mod [] = {
|
|
/* Mask Value Match Value Print String Match String Validation Display Descriptor */
|
|
/* ------------ ------------ ------------------- ------------ ---------- ------- ---------- */
|
|
{ UNIT_CALTIME, UNIT_CALTIME, "calibrated timing", "CALTIME", NULL, NULL, NULL },
|
|
{ UNIT_CALTIME, 0, "realistic timing", "REALTIME", NULL, NULL, NULL },
|
|
{ UNIT_W1B, UNIT_W1B, "W1 position B", "W1B", NULL, NULL, NULL },
|
|
{ UNIT_W1B, 0, "W1 position A", "W1A", NULL, NULL, NULL },
|
|
{ UNIT_W2B, UNIT_W2B, "W2 position B", "W2B", NULL, NULL, NULL },
|
|
{ UNIT_W2B, 0, "W2 position A", "W2A", NULL, NULL, NULL },
|
|
|
|
/* Entry Flags Value Print String Match String Validation Display Descriptor */
|
|
/* ------------------- ----- ------------ ------------ ------------ ------------- ----------------- */
|
|
{ MTAB_XDV, 1u, "SC", "SC", &hp_set_dib, &hp_show_dib, (void *) &clk_dib },
|
|
{ MTAB_XDV | MTAB_NMO, ~1u, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &clk_dib },
|
|
|
|
{ 0 }
|
|
};
|
|
|
|
/* Debugging trace list */
|
|
|
|
static DEBTAB clk_deb [] = {
|
|
{ "CSRW", TRACE_CSRW }, /* interface control, status, read, and write actions */
|
|
{ "PSERV", TRACE_PSERV }, /* clock unit service scheduling calls */
|
|
{ "IOBUS", TRACE_IOBUS }, /* interface I/O bus signals and data words */
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
/* Device descriptor */
|
|
|
|
DEVICE clk_dev = {
|
|
"CLK", /* device name */
|
|
clk_unit, /* unit array */
|
|
clk_reg, /* register array */
|
|
clk_mod, /* modifier array */
|
|
1, /* number of units */
|
|
0, /* address radix */
|
|
0, /* address width */
|
|
0, /* address increment */
|
|
0, /* data radix */
|
|
0, /* data width */
|
|
NULL, /* examine routine */
|
|
NULL, /* deposit routine */
|
|
&clk_reset, /* reset routine */
|
|
NULL, /* boot routine */
|
|
NULL, /* attach routine */
|
|
NULL, /* detach routine */
|
|
&clk_dib, /* device information block pointer */
|
|
DEV_DISABLE | DEV_DEBUG, /* device flags */
|
|
0, /* debug control flags */
|
|
clk_deb, /* debug flag name array */
|
|
NULL, /* memory size change routine */
|
|
NULL /* logical device name */
|
|
};
|
|
|
|
|
|
|
|
/* Time Base Generator local SCP support routines */
|
|
|
|
|
|
/* Time Base Generator interface.
|
|
|
|
The time base generator (CLK) provides periodic interrupts from 100
|
|
microseconds to 1000 seconds. The CLK uses a calibrated timer to provide the
|
|
time base. For periods ranging from 1 to 1000 seconds, a 100 millisecond
|
|
timer is used, and 10 to 10000 ticks are counted before setting the device
|
|
flag to indicate that the period has expired.
|
|
|
|
If the period is set to ten milliseconds, the console poll timer is used
|
|
instead of an independent timer. This is to maximize the idle period.
|
|
|
|
In diagnostic mode, the clock period is set to the expected number of CPU
|
|
instructions, rather than wall-clock time, so that the diagnostic executes as
|
|
expected.
|
|
*/
|
|
|
|
static uint32 clk_interface (DIB *dibptr, IOCYCLE signal_set, uint32 stat_data)
|
|
{
|
|
uint16 status;
|
|
int32 tick_count;
|
|
IOSIGNAL signal;
|
|
IOCYCLE working_set = IOADDSIR (signal_set); /* add ioSIR if needed */
|
|
|
|
while (working_set) {
|
|
signal = IONEXT (working_set); /* isolate next signal */
|
|
|
|
switch (signal) { /* dispatch I/O signal */
|
|
|
|
case ioCLF: /* clear flag flip-flop */
|
|
clk.flag = clk.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTF: /* set flag flip-flop */
|
|
case ioENF: /* enable flag */
|
|
clk.flag = clk.flagbuf = SET;
|
|
break;
|
|
|
|
|
|
case ioSFC: /* skip if flag is clear */
|
|
setstdSKF (clk);
|
|
break;
|
|
|
|
|
|
case ioSFS: /* skip if flag is set */
|
|
setstdSKF (clk);
|
|
break;
|
|
|
|
|
|
case ioIOI: /* I/O data input */
|
|
if (lost_tick == SET) { /* if the lost-tick flip-flop is set */
|
|
status = ST_ERROR; /* then indicate an error */
|
|
|
|
if (clk_unit [0].flags & UNIT_W1B) /* if W1 is in position B */
|
|
status |= ST_ERROR_W1B; /* then set the status in bit 5 as well */
|
|
}
|
|
|
|
else /* otherwise the error flip-flop is clear */
|
|
status = 0; /* so clear the error status */
|
|
|
|
stat_data = IORETURN (SCPE_OK, status); /* merge in the return status */
|
|
|
|
tprintf (clk_dev, TRACE_CSRW, "Status is %s\n",
|
|
fmt_bitset (status, status_format));
|
|
break;
|
|
|
|
|
|
case ioIOO: /* I/O data output */
|
|
clk_select = CN_RATE (IODATA (stat_data)); /* save select */
|
|
sim_cancel (&clk_unit [0]); /* stop the clock */
|
|
clk.control = CLEAR; /* clear control */
|
|
working_set = working_set | ioSIR; /* set interrupt request (IOO normally doesn't) */
|
|
|
|
tprintf (clk_dev, TRACE_CSRW, "Control is %s rate\n",
|
|
rate_name [clk_select]);
|
|
break;
|
|
|
|
|
|
case ioPOPIO: /* power-on preset to I/O */
|
|
clk.flag = clk.flagbuf = SET; /* set flag and flag buffer */
|
|
break;
|
|
|
|
|
|
case ioCRS: /* control reset */
|
|
case ioCLC: /* clear control flip-flop */
|
|
clk.control = CLEAR;
|
|
sim_cancel (&clk_unit [0]); /* deactivate unit */
|
|
break;
|
|
|
|
|
|
case ioSTC: /* set control flip-flop */
|
|
clk.control = SET;
|
|
|
|
if (!sim_is_active (&clk_unit [0])) { /* clock running? */
|
|
tick_count = clk_delay (0); /* get tick count */
|
|
|
|
if (clk_unit [0].flags & UNIT_CALTIME) /* calibrated? */
|
|
if (clk_select == 2) /* 10 msec. interval? */
|
|
tick_count = sync_poll (INITIAL); /* sync poll */
|
|
else
|
|
sim_rtcn_init (tick_count, TMR_CLK); /* initialize timer */
|
|
|
|
tprintf (clk_dev, TRACE_PSERV, "Rate %s delay %d service rescheduled\n",
|
|
rate_name [clk_select], tick_count);
|
|
|
|
sim_activate (&clk_unit [0], tick_count); /* start clock */
|
|
clk_ctr = clk_delay (1); /* set repeat ctr */
|
|
}
|
|
|
|
lost_tick = CLEAR; /* clear error */
|
|
break;
|
|
|
|
|
|
case ioSIR: /* set interrupt request */
|
|
setstdPRL (clk); /* set standard PRL signal */
|
|
setstdIRQ (clk); /* set standard IRQ signal */
|
|
setstdSRQ (clk); /* set standard SRQ signal */
|
|
break;
|
|
|
|
|
|
case ioIAK: /* interrupt acknowledge */
|
|
clk.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
default: /* all other signals */
|
|
break; /* are ignored */
|
|
}
|
|
|
|
working_set = working_set & ~signal; /* remove current signal from set */
|
|
}
|
|
|
|
return stat_data;
|
|
}
|
|
|
|
|
|
/* CLK unit service.
|
|
|
|
As with the I/O handler, if the time base period is set to ten milliseconds,
|
|
the console poll timer is used instead of an independent timer.
|
|
|
|
|
|
Implementation notes:
|
|
|
|
1. If the TBG is calibrated, it is synchronized with the TTY keyboard poll
|
|
service to permit idling.
|
|
*/
|
|
|
|
static t_stat clk_service (UNIT *uptr)
|
|
{
|
|
int32 tick_count;
|
|
|
|
tprintf (clk_dev, TRACE_PSERV, "Service entered with prescaler %d\n",
|
|
clk_ctr);
|
|
|
|
if (clk.control == CLEAR) /* control clear? */
|
|
return SCPE_OK; /* done */
|
|
|
|
if (clk_unit [0].flags & UNIT_CALTIME) /* cal mode? */
|
|
if (clk_select == 2) /* 10 msec period? */
|
|
tick_count = sync_poll (SERVICE); /* sync poll */
|
|
else
|
|
tick_count = sim_rtcn_calb (ticks [clk_select], /* calibrate delay */
|
|
TMR_CLK);
|
|
|
|
else /* otherwise the TBG is in real-time mode */
|
|
tick_count = clk_delay (0); /* get fixed delay */
|
|
|
|
clk_ctr = clk_ctr - 1; /* decrement counter */
|
|
|
|
if (clk_ctr <= 0) { /* end of interval? */
|
|
if (clk.flag) {
|
|
lost_tick = SET; /* overrun? error */
|
|
|
|
tprintf (clk_dev, TRACE_PSERV, "Clock tick lost\n");
|
|
}
|
|
|
|
else
|
|
clk_interface (&clk_dib, ioENF, 0); /* set flag */
|
|
|
|
clk_ctr = clk_delay (1); /* reset counter */
|
|
}
|
|
|
|
tprintf (clk_dev, TRACE_PSERV, "Rate %s delay %d service %s\n",
|
|
rate_name [clk_select], tick_count,
|
|
(clk_select == 2 ? "coscheduled" : "scheduled"));
|
|
|
|
return sim_activate (uptr, tick_count); /* reactivate */
|
|
}
|
|
|
|
|
|
/* Reset routine */
|
|
|
|
static t_stat clk_reset (DEVICE *dptr)
|
|
{
|
|
if (sim_switches & SWMASK ('P')) { /* initialization reset? */
|
|
lost_tick = CLEAR; /* clear error */
|
|
clk_select = 0; /* clear select */
|
|
clk_ctr = 0; /* clear counter */
|
|
|
|
if (clk_dev.lname == NULL) /* logical name unassigned? */
|
|
clk_dev.lname = strdup ("TBG"); /* allocate and initialize the name */
|
|
}
|
|
|
|
IOPRESET (&clk_dib); /* PRESET device (does not use PON) */
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
|
|
/* Time Base Generator local utility routines */
|
|
|
|
|
|
/* Clock delay routine */
|
|
|
|
static int32 clk_delay (int32 flg)
|
|
{
|
|
int32 sel;
|
|
|
|
if (clk_unit [0].flags & UNIT_W2B && clk_select >= 4) /* if jumper W2 is in position B */
|
|
sel = clk_select - 3; /* then rates 4-7 rescale to 1-4 */
|
|
else /* otherwise */
|
|
sel = clk_select; /* the rate selector is used as is */
|
|
|
|
if (flg) /* if the prescaler value is wanted */
|
|
return scale [sel]; /* then return it */
|
|
else /* otherwise */
|
|
return delay [sel]; /* return the tick delay count */
|
|
}
|