703 lines
32 KiB
C
703 lines
32 KiB
C
/* hp2100_lps.c: HP 2100 12653A Line Printer Interface simulator
|
|
|
|
Copyright (c) 1993-2016, Robert M. Supnik
|
|
Copyright (c) 2017, 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.
|
|
|
|
LPS HP 12653A Line Printer Interface
|
|
|
|
03-Aug-17 JDB Changed perror call for I/O errors to cprintf
|
|
20-Jul-17 JDB Removed "lps_stopioe" variable and register
|
|
17-Mar-17 JDB Added "-N" handling to the attach routine
|
|
15-Mar-17 JDB Changed DEBUG_PRS calls to tprintfs
|
|
13-May-16 JDB Modified for revised SCP API function parameter types
|
|
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
|
|
Revised detection of CLC at last DMA cycle
|
|
19-Oct-10 JDB Corrected 12566B (DIAG mode) jumper settings
|
|
26-Jun-08 JDB Rewrote device I/O to model backplane signals
|
|
10-May-07 RMS Added UNIT_TEXT flag
|
|
11-Jan-07 JDB CLC cancels I/O event if DIAG (jumper W9 in "A" pos)
|
|
Added ioCRS state to I/O decoders
|
|
19-Nov-04 JDB Added restart when set online, etc.
|
|
Fixed col count for non-printing chars
|
|
01-Oct-04 JDB Added SET OFFLINE/ONLINE, POWEROFF/POWERON
|
|
Fixed status returns for error conditions
|
|
Fixed handling of non-printing characters
|
|
Fixed handling of characters after column 80
|
|
Improved timing model accuracy for RTE
|
|
Added fast/realistic timing
|
|
Added debug printouts
|
|
03-Jun-04 RMS Fixed timing (found by Dave Bryan)
|
|
26-Apr-04 RMS Fixed SFS x,C and SFC x,C
|
|
Implemented DMA SRQ (follows FLG)
|
|
25-Apr-03 RMS Revised for extended file support
|
|
24-Oct-02 RMS Added microcircuit test features
|
|
30-May-02 RMS Widened POS to 32b
|
|
03-Dec-01 RMS Changed DEVNO to use extended SET/SHOW
|
|
07-Sep-01 RMS Moved function prototypes
|
|
21-Nov-00 RMS Fixed flag, fbf power up state
|
|
Added command flop
|
|
15-Oct-00 RMS Added variable device number support
|
|
|
|
References:
|
|
- 2767A Line Printer Operating and Service Manual
|
|
(02767-90002, October 1973)
|
|
- General Purpose Register Diagnostic Reference Manual
|
|
(24391-90001, April 1982)
|
|
|
|
The HP 12653A Line Printer Interface Kit connects the 2767A printer to the HP
|
|
1000 family. The subsystem consists of an interface card employing TTL-level
|
|
line drivers and receivers, an interconnecting cable, and an HP 2767A (from
|
|
356 to 1110 lines per minute) line printer. The interface is supported by
|
|
RTE and DOS drivers DVR12. The interface supports DMA transfers, but the OS
|
|
drivers do not use them.
|
|
|
|
The 2767 impact printer has a rotating drum with 80 columns of 64 raised
|
|
characters. ASCII codes 32 through 95 (SPACE through "_") form the print
|
|
repertoire. The printer responds to the control characters FF, LF, and CR.
|
|
|
|
The 80 columns are divided into four zones of 20 characters each that are
|
|
addressed sequentially. Received characters are buffered in a 20-character
|
|
memory. When the 20th printable character is received, the current zone is
|
|
printed, and the memory is reset. In the absence of print command
|
|
characters, a zone print operation will commence after each group of 20
|
|
printable characters is transmitted to the printer.
|
|
|
|
The print command characters have these actions:
|
|
|
|
* CR -- print the characters in the current zone, reset to zone 1, and clear
|
|
the buffer memory.
|
|
* LF -- same as CR, plus advances the paper one line.
|
|
* FF -- same as CR, plus advances the paper to the top of the next form.
|
|
|
|
The 2767 provides two status bits via the interface:
|
|
|
|
bit 15 -- printer not ready
|
|
bit 0 -- printer busy
|
|
|
|
The expected status returns are:
|
|
|
|
100001 -- power off or cable disconnected
|
|
100001 -- initial power on, then changes to 000001 within sixty
|
|
seconds of initial power on
|
|
000001 -- power on, paper unloaded or printer offline or not idle
|
|
000000 -- power on, paper loaded and printer online and idle
|
|
|
|
These simulator commands provide the listed printer states:
|
|
|
|
SET LPS POWEROFF --> power off or cable disconnected
|
|
SET LPS POWERON --> power on
|
|
SET LPS OFFLINE --> printer offline
|
|
SET LPS ONLINE --> printer online
|
|
ATT LPS <file> --> paper loaded
|
|
DET LPS --> paper out
|
|
|
|
The following implemented behaviors have been inferred from secondary sources
|
|
(diagnostics, operating system drivers, etc.), due to absent or contradictory
|
|
authoritative information; future correction may be needed:
|
|
|
|
1. Paper out sets BUSY instead of NOT READY.
|
|
2. Print operation in progress sets BUSY instead of NOT READY.
|
|
3. Characters not in the print repertoire are replaced with blanks.
|
|
4. The 81st and succeeding characters overprint the current line.
|
|
|
|
The "General Purpose Register Diagnostic Reference Manual" states that the
|
|
12653A is a "special microcircuit interface," suggesting that it is a
|
|
derivative of the 12566B Microcircuit Interface Kit. No specific manual for
|
|
this interface kit has been found.
|
|
|
|
A diagnostic mode is provided to simulate the installation of the 1251-0332
|
|
loopback connecctor, modified to connect pins Z/22 to pins AA/23 as required
|
|
by the diagnostic. This ties the output data lines to the input data lines
|
|
and the device command output to the device flag input.
|
|
|
|
Jumper settings depend on the CPU model. For the 2114/15/16 CPUs, jumper W1
|
|
is installed in position B and jumper W2 in position C. In these positions,
|
|
the card flag sets two instructions after the STC, allowing DMA to steal
|
|
every third cycle. For the 2100 and 1000 CPUs, jumper W1 is installed in
|
|
position C and jumper W2 in position B. In these positions, the card flag
|
|
sets one instruction after the STC, allowing DMA to steal every other cycle.
|
|
For all CPUs, jumpers W3 and W4 are installed in position B, W5-W8 are
|
|
installed, and W9 is installed in position A.
|
|
*/
|
|
|
|
|
|
|
|
#include "hp2100_defs.h"
|
|
#include "hp2100_cpu.h"
|
|
|
|
|
|
|
|
/* Printer program constants */
|
|
|
|
#define CR '\r' /* carriage return */
|
|
#define LF '\n' /* line feed */
|
|
#define FF '\f' /* form feed */
|
|
|
|
#define DATA_MASK 0177u /* printer uses only 7 bits for data */
|
|
|
|
#define LPS_ZONECNT 20 /* zone char count */
|
|
#define LPS_PAGECNT 80 /* page char count */
|
|
#define LPS_PAGELNT 60 /* page line length */
|
|
#define LPS_FORMLNT 66 /* form line length */
|
|
|
|
/* Printer power states */
|
|
|
|
#define LPS_ON 0 /* power is on */
|
|
#define LPS_OFF 1 /* power is off */
|
|
#define LPS_TURNING_ON 2 /* power is turning on */
|
|
|
|
#define LPS_BUSY 0000001 /* busy status */
|
|
#define LPS_NRDY 0100000 /* not ready status */
|
|
#define LPS_PWROFF LPS_BUSY | LPS_NRDY /* power-off status */
|
|
|
|
#define UNIT_V_DIAG (UNIT_V_UF + 0) /* diagnostic mode */
|
|
#define UNIT_V_POWEROFF (UNIT_V_UF + 1) /* unit powered off */
|
|
#define UNIT_V_OFFLINE (UNIT_V_UF + 2) /* unit offline */
|
|
#define UNIT_DIAG (1 << UNIT_V_DIAG)
|
|
#define UNIT_POWEROFF (1 << UNIT_V_POWEROFF)
|
|
#define UNIT_OFFLINE (1 << UNIT_V_OFFLINE)
|
|
|
|
static struct {
|
|
FLIP_FLOP control; /* control flip-flop */
|
|
FLIP_FLOP flag; /* flag flip-flop */
|
|
FLIP_FLOP flagbuf; /* flag buffer flip-flop */
|
|
} lps = { CLEAR, CLEAR, CLEAR };
|
|
|
|
static int32 lps_ccnt = 0; /* character count */
|
|
static int32 lps_lcnt = 0; /* line count */
|
|
static int32 lps_sta = 0; /* printer status */
|
|
static int32 lps_timing = 1; /* timing type */
|
|
static uint32 lps_power = LPS_ON; /* power state */
|
|
|
|
/* Hardware timing:
|
|
(based on 1580 instr/msec) instr msec calc msec
|
|
------------------------
|
|
- character transfer time : ctime = 2 2 us
|
|
- per-zone printing time : ptime = 55300 35 40
|
|
- per-line paper slew time : stime = 17380 11 13
|
|
- power-on ready delay time : rtime = 158000 100
|
|
|
|
NOTE: the printer acknowledges before the print motion has stopped to allow
|
|
for continuous slew, so the set times are a bit less than the calculated
|
|
operation time from the manual.
|
|
|
|
NOTE: the 2767 diagnostic checks completion times, so the realistic timing
|
|
must be used. Because simulator timing is in instructions, and because the
|
|
diagnostic uses the TIMER instruction (~1580 executions per millisecond) when
|
|
running on a 1000-E/F but a software timing loop (~400-600 executions per
|
|
millisecond) when running on anything else, realistic timings are decreased by
|
|
three-fourths when not executing on an E/F.
|
|
*/
|
|
|
|
static int32 lps_ctime = 0; /* char xfer time */
|
|
static int32 lps_ptime = 0; /* zone printing time */
|
|
static int32 lps_stime = 0; /* paper slew time */
|
|
static int32 lps_rtime = 0; /* power-on ready time */
|
|
|
|
typedef int32 TIMESET[4]; /* set of controller times */
|
|
|
|
static int32 *const lps_timers[] = { &lps_ctime, &lps_ptime, &lps_stime, &lps_rtime };
|
|
|
|
static const TIMESET lps_times[2] = {
|
|
{ 2, 55300, 17380, 158000 }, /* REALTIME */
|
|
{ 2, 1000, 1000, 1000 } /* FASTTIME */
|
|
};
|
|
|
|
DEVICE lps_dev;
|
|
|
|
static IOHANDLER lpsio;
|
|
|
|
static t_stat lps_svc (UNIT *uptr);
|
|
static t_stat lps_reset (DEVICE *dptr);
|
|
static t_stat lps_restart (UNIT *uptr, int32 value, CONST char *cptr, void *desc);
|
|
static t_stat lps_poweroff (UNIT *uptr, int32 value, CONST char *cptr, void *desc);
|
|
static t_stat lps_poweron (UNIT *uptr, int32 value, CONST char *cptr, void *desc);
|
|
static t_stat lps_attach (UNIT *uptr, CONST char *cptr);
|
|
static t_stat lps_set_timing (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
|
|
static t_stat lps_show_timing (FILE *st, UNIT *uptr, int32 val, CONST void *desc);
|
|
|
|
/* LPS data structures
|
|
|
|
lps_dev LPS device descriptor
|
|
lps_unit LPS unit descriptor
|
|
lps_reg LPS register list
|
|
*/
|
|
|
|
static DIB lps_dib = { &lpsio, LPS };
|
|
|
|
static UNIT lps_unit = {
|
|
UDATA (&lps_svc, UNIT_SEQ+UNIT_ATTABLE+UNIT_DISABLE+UNIT_TEXT, 0)
|
|
};
|
|
|
|
static REG lps_reg[] = {
|
|
/* Macro Name Location Width Offset Flags */
|
|
/* ------ ------ ------------------- --------- ------ ------- */
|
|
{ ORDATA (BUF, lps_unit.buf, 16), REG_X },
|
|
{ ORDATA (STA, lps_sta, 16) },
|
|
{ ORDATA (POWER, lps_power, 2), REG_RO },
|
|
{ FLDATA (CTL, lps.control, 0) },
|
|
{ FLDATA (FLG, lps.flag, 0) },
|
|
{ FLDATA (FBF, lps.flagbuf, 0) },
|
|
{ DRDATA (CCNT, lps_ccnt, 7), PV_LEFT },
|
|
{ DRDATA (LCNT, lps_lcnt, 7), PV_LEFT },
|
|
{ DRDATA (POS, lps_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (CTIME, lps_ctime, 24), PV_LEFT },
|
|
{ DRDATA (PTIME, lps_ptime, 24), PV_LEFT },
|
|
{ DRDATA (STIME, lps_stime, 24), PV_LEFT },
|
|
{ DRDATA (RTIME, lps_rtime, 24), PV_LEFT },
|
|
{ FLDATA (TIMING, lps_timing, 0), REG_HRO },
|
|
{ ORDATA (SC, lps_dib.select_code, 6), REG_HRO },
|
|
{ ORDATA (DEVNO, lps_dib.select_code, 6), REG_HRO },
|
|
{ NULL }
|
|
};
|
|
|
|
static MTAB lps_mod[] = {
|
|
/* Mask Value Match Value Print String Match String Validation Display Descriptor */
|
|
/* ------------- ------------- ----------------- ------------- ------------------ ------- ---------- */
|
|
{ UNIT_DIAG, UNIT_DIAG, "diagnostic mode", "DIAGNOSTIC", NULL, NULL, NULL },
|
|
{ UNIT_DIAG, 0, "printer mode", "PRINTER", NULL, NULL, NULL },
|
|
|
|
{ UNIT_OFFLINE, UNIT_OFFLINE, "offline", "OFFLINE", NULL, NULL, NULL },
|
|
{ UNIT_OFFLINE, 0, "online", "ONLINE", &lps_restart, NULL, NULL },
|
|
|
|
{ UNIT_POWEROFF, UNIT_POWEROFF, "power off", "POWEROFF", &lps_poweroff, NULL, NULL },
|
|
{ UNIT_POWEROFF, 0, "power on", "POWERON", &lps_poweron, NULL, NULL },
|
|
|
|
/* Entry Flags Value Print String Match String Validation Display Descriptor */
|
|
/* ------------------- ----- ------------ ------------ ---------------- ----------------- ----------------- */
|
|
{ MTAB_XDV, 1, NULL, "FASTTIME", &lps_set_timing, NULL, NULL },
|
|
{ MTAB_XDV, 0, NULL, "REALTIME", &lps_set_timing, NULL, NULL },
|
|
{ MTAB_XDV, 0, "TIMING", NULL, NULL, &lps_show_timing, NULL },
|
|
|
|
{ MTAB_XDV, 1u, "SC", "SC", &hp_set_dib, &hp_show_dib, (void *) &lps_dib },
|
|
{ MTAB_XDV | MTAB_NMO, ~1u, "DEVNO", "DEVNO", &hp_set_dib, &hp_show_dib, (void *) &lps_dib },
|
|
{ 0 }
|
|
};
|
|
|
|
static DEBTAB lps_deb [] = {
|
|
{ "CMDS", DEB_CMDS },
|
|
{ "CPU", DEB_CPU },
|
|
{ "XFER", DEB_XFER },
|
|
{ "STATE", TRACE_STATE },
|
|
{ "IOBUS", TRACE_IOBUS }, /* interface I/O bus signals and data words */
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
DEVICE lps_dev = {
|
|
"LPS", /* device name */
|
|
&lps_unit, /* unit array */
|
|
lps_reg, /* register array */
|
|
lps_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 */
|
|
&lps_reset, /* reset routine */
|
|
NULL, /* boot routine */
|
|
&lps_attach, /* attach routine */
|
|
NULL, /* detach routine */
|
|
&lps_dib, /* device information block */
|
|
DEV_DISABLE | DEV_DIS | DEV_DEBUG, /* device flags */
|
|
0, /* debug control flags */
|
|
lps_deb, /* debug flag name table */
|
|
NULL, /* memory size change routine */
|
|
NULL /* logical device name */
|
|
};
|
|
|
|
|
|
/* I/O signal handler.
|
|
|
|
Implementation note:
|
|
|
|
1. The 211x DMA diagnostic expects that a programmed STC and CLC sequence
|
|
will set the card flag in two instructions, whereas a last-DMA-cycle
|
|
assertion of STC and CLC simultaneously will not.
|
|
*/
|
|
|
|
static uint32 lpsio (DIB *dibptr, IOCYCLE signal_set, uint32 stat_data)
|
|
{
|
|
int32 current_line, current_char;
|
|
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 */
|
|
lps.flag = lps.flagbuf = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTF: /* set flag flip-flop */
|
|
case ioENF: /* enable flag */
|
|
lps.flag = lps.flagbuf = SET;
|
|
break;
|
|
|
|
|
|
case ioSFC: /* skip if flag is clear */
|
|
setstdSKF (lps);
|
|
break;
|
|
|
|
|
|
case ioSFS: /* skip if flag is set */
|
|
setstdSKF (lps);
|
|
break;
|
|
|
|
|
|
case ioIOI: /* I/O data input */
|
|
if ((lps_unit.flags & UNIT_DIAG) == 0) { /* real lpt? */
|
|
if (lps_power == LPS_ON) { /* power on? */
|
|
if (((lps_unit.flags & UNIT_ATT) == 0) || /* paper out? */
|
|
(lps_unit.flags & UNIT_OFFLINE) || /* offline? */
|
|
sim_is_active (&lps_unit)) lps_sta = LPS_BUSY;
|
|
|
|
else
|
|
lps_sta = 0;
|
|
}
|
|
|
|
else
|
|
lps_sta = LPS_PWROFF;
|
|
}
|
|
|
|
stat_data = IORETURN (SCPE_OK, lps_sta); /* diag, rtn status */
|
|
|
|
tprintf (lps_dev, DEB_CPU, "Status %06o returned\n", lps_sta);
|
|
break;
|
|
|
|
|
|
case ioIOO: /* I/O data output */
|
|
lps_unit.buf = IODATA (stat_data);
|
|
|
|
tprintf (lps_dev, DEB_CPU, "Control %06o (%s) output\n",
|
|
lps_unit.buf, fmt_char (lps_unit.buf & DATA_MASK));
|
|
break;
|
|
|
|
|
|
case ioPOPIO: /* power-on preset to I/O */
|
|
lps.flag = lps.flagbuf = SET; /* set flag and flag buffer */
|
|
lps_unit.buf = 0; /* clear output buffer */
|
|
break;
|
|
|
|
|
|
case ioCRS: /* control reset */
|
|
lps.control = CLEAR; /* clear control */
|
|
sim_cancel (&lps_unit); /* deactivate unit */
|
|
break;
|
|
|
|
|
|
case ioCLC: /* clear control flip-flop */
|
|
lps.control = CLEAR;
|
|
break;
|
|
|
|
|
|
case ioSTC: /* set control flip-flop */
|
|
lps.control = SET; /* set control */
|
|
|
|
if (lps_unit.flags & UNIT_DIAG) { /* diagnostic? */
|
|
lps_sta = lps_unit.buf; /* loop back data */
|
|
|
|
if (!(signal_set & ioCLC)) /* CLC not asserted simultaneously? */
|
|
if (UNIT_CPU_TYPE == UNIT_TYPE_211X) /* 2114/15/16 CPU? */
|
|
sim_activate (&lps_unit, 3); /* schedule flag after two instructions */
|
|
else /* 2100 or 1000 */
|
|
sim_activate (&lps_unit, 2); /* schedule flag after next instruction */
|
|
}
|
|
|
|
else { /* real lpt, sched */
|
|
current_char = lps_ccnt + 1;
|
|
current_line = lps_lcnt + 1;
|
|
|
|
if ((lps_unit.buf != FF) &&
|
|
(lps_unit.buf != LF) &&
|
|
(lps_unit.buf != CR)) { /* normal char */
|
|
lps_ccnt = lps_ccnt + 1; /* incr char counter */
|
|
if (lps_ccnt % LPS_ZONECNT == 0) /* end of zone? */
|
|
lps_unit.wait = lps_ptime; /* print zone */
|
|
else
|
|
lps_unit.wait = lps_ctime; /* xfer char */
|
|
}
|
|
|
|
else { /* print cmd */
|
|
if (lps_ccnt % LPS_ZONECNT == 0) /* last zone printed? */
|
|
lps_unit.wait = lps_ctime; /* yes, so just char time */
|
|
else
|
|
lps_unit.wait = lps_ptime; /* no, so print needed */
|
|
|
|
lps_ccnt = 0; /* reset char counter */
|
|
|
|
if (lps_unit.buf == LF) { /* line advance */
|
|
lps_lcnt = (lps_lcnt + 1) % LPS_PAGELNT;
|
|
|
|
if (lps_lcnt > 0)
|
|
lps_unit.wait += lps_stime;
|
|
else
|
|
lps_unit.wait += /* allow for perf skip */
|
|
lps_stime * (LPS_FORMLNT - LPS_PAGELNT);
|
|
}
|
|
|
|
else if (lps_unit.buf == FF) { /* form advance */
|
|
lps_unit.wait += lps_stime * (LPS_FORMLNT - lps_lcnt);
|
|
lps_lcnt = 0;
|
|
}
|
|
}
|
|
|
|
sim_activate (&lps_unit, lps_unit.wait);
|
|
|
|
tprintf (lps_dev, DEB_CMDS, "Character %s scheduled for line %d, column %d, time = %d\n",
|
|
fmt_char (lps_unit.buf & DATA_MASK), current_line, current_char, lps_unit.wait);
|
|
}
|
|
break;
|
|
|
|
|
|
case ioSIR: /* set interrupt request */
|
|
setstdPRL (lps); /* set standard PRL signal */
|
|
setstdIRQ (lps); /* set standard IRQ signal */
|
|
setstdSRQ (lps); /* set standard SRQ signal */
|
|
break;
|
|
|
|
|
|
case ioIAK: /* interrupt acknowledge */
|
|
lps.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.
|
|
|
|
As a convenience to the user, the printer output file is flushed when a TOF
|
|
operation is performed.
|
|
*/
|
|
|
|
static t_stat lps_svc (UNIT *uptr)
|
|
{
|
|
int32 c = uptr->buf & DATA_MASK;
|
|
|
|
if (lps_power == LPS_TURNING_ON) { /* printer warmed up? */
|
|
lps_power = LPS_ON; /* change state */
|
|
lps_restart (uptr, 0, NULL, NULL); /* restart I/O if hung */
|
|
tprintf (lps_dev, TRACE_STATE, "Power state is ON\n");
|
|
return SCPE_OK; /* done */
|
|
}
|
|
|
|
if (uptr->flags & UNIT_DIAG) { /* diagnostic? */
|
|
lpsio (&lps_dib, ioENF, 0); /* set flag */
|
|
return SCPE_OK; /* done */
|
|
}
|
|
|
|
if ((uptr->flags & (UNIT_ATT | UNIT_OFFLINE | UNIT_POWEROFF)) != UNIT_ATT) /* not ready? */
|
|
return SCPE_OK;
|
|
|
|
lpsio (&lps_dib, ioENF, 0); /* set flag */
|
|
|
|
if (((c < ' ') || (c > '_')) && /* non-printing char? */
|
|
(c != FF) && (c != LF) && (c != CR)) {
|
|
tprintf (lps_dev, DEB_XFER, "Character %s erased\n", fmt_char (c));
|
|
c = ' '; /* replace with blank */
|
|
}
|
|
|
|
if (lps_ccnt > LPS_PAGECNT) { /* 81st character? */
|
|
fputc (CR, uptr->fileref); /* return to line start */
|
|
uptr->pos = uptr->pos + 1; /* update pos */
|
|
lps_ccnt = 1; /* reset char counter */
|
|
tprintf (lps_dev, DEB_XFER, "Line wraparound to column 1\n");
|
|
}
|
|
|
|
fputc (c, uptr->fileref); /* "print" char */
|
|
uptr->pos = uptr->pos + 1; /* update pos */
|
|
|
|
tprintf (lps_dev, DEB_XFER, "Character %s printed\n", fmt_char (c));
|
|
|
|
if (lps_lcnt == 0) { /* if the printer is at the TOF */
|
|
fflush (uptr->fileref); /* then flush the file buffer for inspection */
|
|
|
|
if (c == LF) { /* LF did TOF? */
|
|
fputc (FF, uptr->fileref); /* do perf skip */
|
|
uptr->pos = uptr->pos + 1; /* update pos */
|
|
tprintf (lps_dev, DEB_XFER, "Perforation skip to TOF\n");
|
|
}
|
|
}
|
|
|
|
if (ferror (uptr->fileref)) { /* if a host file I/O error occurred */
|
|
cprintf ("%s simulator printer I/O error: %s\n", /* then report the error to the console */
|
|
sim_name, strerror (errno));
|
|
|
|
clearerr (uptr->fileref); /* clear the error */
|
|
|
|
lps_unit.flags |= UNIT_OFFLINE; /* set offline */
|
|
return SCPE_IOERR;
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
|
|
/* Reset routine */
|
|
|
|
static t_stat lps_reset (DEVICE *dptr)
|
|
{
|
|
if (sim_switches & SWMASK ('P')) { /* power-on reset? */
|
|
lps_power = LPS_ON; /* power is on */
|
|
lps_set_timing (NULL, lps_timing, NULL, NULL); /* init timing set */
|
|
}
|
|
|
|
IOPRESET (&lps_dib); /* PRESET device (does not use PON) */
|
|
|
|
lps_sta = 0; /* clear status */
|
|
sim_cancel (&lps_unit); /* deactivate unit */
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Restart I/O routine
|
|
|
|
If I/O is started via STC, and the printer is powered off, offline,
|
|
or out of paper, the CTL and CMD flip-flops will set, a service event
|
|
will be scheduled, and the service routine will be entered. If
|
|
STOP_IOE is not set, the I/O operation will "hang" at that point
|
|
until the printer is powered on, set online, or paper is supplied
|
|
(attached).
|
|
|
|
If a pending operation is "hung" when this routine is called, it is
|
|
restarted, which clears CTL and sets FBF and FLG, completing the
|
|
original I/O request.
|
|
*/
|
|
|
|
static t_stat lps_restart (UNIT *uptr, int32 value, CONST char *cptr, void *desc)
|
|
{
|
|
if (lps.control && !sim_is_active (uptr))
|
|
sim_activate (uptr, 0); /* reschedule I/O */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Printer power off */
|
|
|
|
static t_stat lps_poweroff (UNIT *uptr, int32 value, CONST char *cptr, void *desc)
|
|
{
|
|
lps_power = LPS_OFF; /* change state */
|
|
tprintf (lps_dev, TRACE_STATE, "Power state is OFF\n");
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Printer power on */
|
|
|
|
static t_stat lps_poweron (UNIT *uptr, int32 value, CONST char *cptr, void *desc)
|
|
{
|
|
if (lps_unit.flags & UNIT_DIAG) { /* diag mode? */
|
|
lps_power = LPS_ON; /* no delay */
|
|
tprintf (lps_dev, TRACE_STATE, "Power state is ON\n");
|
|
}
|
|
else {
|
|
lps_power = LPS_TURNING_ON; /* change state */
|
|
lps_unit.flags |= UNIT_OFFLINE; /* set offline */
|
|
sim_activate (&lps_unit, lps_rtime); /* schedule ready */
|
|
tprintf (lps_dev, TRACE_STATE, "Power state is TURNING ON, scheduled time = %d\n",
|
|
lps_rtime);
|
|
}
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Attach the printer image file.
|
|
|
|
The specified file is attached to the indicated unit. This is the simulation
|
|
equivalent of loading paper into the printer and pressing the ONLINE button.
|
|
The transition from offline to online typically generates an interrupt.
|
|
|
|
A new image file may be requested by giving the "-N" switch to the ATTACH
|
|
command. If an existing file is specified with "-N", it will be cleared; if
|
|
specified without "-N", printer output will be appended to the end of the
|
|
existing file content. In all cases, the paper is positioned at the top of
|
|
the form.
|
|
|
|
|
|
Implementation notes:
|
|
|
|
1. If we are called during a RESTORE command to reattach a file previously
|
|
attached when the simulation was SAVEd, the device status and file
|
|
position are not altered. This is because SIMH 4.x restores the register
|
|
contents before reattaching, while 3.x reattaches before restoring the
|
|
registers.
|
|
*/
|
|
|
|
static t_stat lps_attach (UNIT *uptr, CONST char *cptr)
|
|
{
|
|
t_stat result;
|
|
|
|
result = hp_attach (uptr, cptr); /* attach the specified printer image file for appending */
|
|
|
|
if (result == SCPE_OK /* if the attach was successful */
|
|
&& (sim_switches & SIM_SW_REST) == 0) { /* and we are not being called during a RESTORE command */
|
|
lps_ccnt = 0; /* then clear the character counter */
|
|
lps_lcnt = 0; /* and set top of form */
|
|
|
|
lps_restart (uptr, 0, NULL, NULL); /* restart I/O if hung */
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* Set printer timing
|
|
|
|
Realistic timing is factored, depending on CPU model, to account for the
|
|
timing method employed by the diagnostic. */
|
|
|
|
static t_stat lps_set_timing (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
|
|
{
|
|
uint32 i, factor = 1;
|
|
|
|
lps_timing = (val != 0); /* determine choice */
|
|
if ((lps_timing == 0) && /* calc speed factor */
|
|
(UNIT_CPU_MODEL != UNIT_1000_E) &&
|
|
(UNIT_CPU_MODEL != UNIT_1000_F))
|
|
factor = 4;
|
|
for (i = 0; i < (sizeof (lps_timers) / sizeof (lps_timers[0])); i++)
|
|
*lps_timers[i] = lps_times[lps_timing][i] / factor; /* assign times */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Show printer timing */
|
|
|
|
static t_stat lps_show_timing (FILE *st, UNIT *uptr, int32 val, CONST void *desc)
|
|
{
|
|
if (lps_timing) fputs ("fast timing", st);
|
|
else fputs ("realistic timing", st);
|
|
return SCPE_OK;
|
|
}
|