mirror of
https://github.com/open-simh/simh.git
synced 2026-01-15 16:07:47 +00:00
66c264d678
After a frantic week of file exchanges, here is RC2. A lot has changed. 1. HP2100 updates completed, with new features and peripherals. 2. Many, many small file updates for nits found by compilers and static checkers. 3. A few genuine bugs fixed. 4. New makefile and MMS file. A note on the makefile. It has almost doubled in size and attempts to ferret out PCAP locales properly, as well as do serious optimizations if gcc is used. It needs to be tested in more environments. If you run into issues, please report them to Mark Pizzolato as well as me. The old makefile, updated for the extra files in the HP2100, is included as makefile_old. You can use that if the new makefile causes problems in your environment. I'm still targeting a May Day release, with a final RC around Tax Day (April 15). That leaves times for one more interim RC, if needed. At this point, I regard the release as feature-complete. Bug fixes are still fine. The actual release will have all incomplete and beta simulators in a separate zip file, including Alpha, Sigma, Sage (the microcomputers, not the 50s anti-aircraft computer), and SC1, the SiCortex MIPS simulator. There will be new releases of all the simulation tools as well. /Bob
449 lines
16 KiB
C
449 lines
16 KiB
C
/* s3_cd.c: IBM 1442 card reader/punch
|
|
|
|
Copyright (c) 2001-2012, Charles E. Owen
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a
|
|
copy of this software and associated documentation files (the "Software"),
|
|
to deal in the Software without restriction, including without limitation
|
|
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
and/or sell copies of the Software, and to permit persons to whom the
|
|
Software is furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
|
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
Except as contained in this notice, the name of Charles E. Owen shall not be
|
|
used in advertising or otherwise to promote the sale, use or other dealings
|
|
in this Software without prior written authorization from Charles E. Owen.
|
|
|
|
cdr card reader
|
|
cdp card punch
|
|
cdp2 card punch stacker 2
|
|
|
|
19-Mar-12 RMS Fixed declaration of conversion tables (Mark Pizzolato)
|
|
25-Apr-03 RMS Revised for extended file support
|
|
08-Oct-02 RMS Added impossible function catcher
|
|
|
|
Normally, cards are represented as ASCII text streams terminated by newlines.
|
|
This allows cards to be created and edited as normal files. Set the EBCDIC
|
|
flag on the card unit allows cards to be read or punched in EBCDIC format,
|
|
suitable for binary data.
|
|
*/
|
|
|
|
#include "s3_defs.h"
|
|
#include <ctype.h>
|
|
|
|
extern uint8 M[];
|
|
extern unsigned char ebcdic_to_ascii[];
|
|
extern unsigned char ascii_to_ebcdic[];
|
|
int32 s1sel, s2sel;
|
|
char rbuf[CBUFSIZE]; /* > CDR_WIDTH */
|
|
t_stat cdr_svc (UNIT *uptr);
|
|
t_stat cdr_boot (int32 unitno, DEVICE *dptr);
|
|
t_stat cdr_attach (UNIT *uptr, char *cptr);
|
|
t_stat cd_reset (DEVICE *dptr);
|
|
t_stat read_card (int32 ilnt, int32 mod);
|
|
t_stat punch_card (int32 ilnt, int32 mod);
|
|
|
|
int32 DAR; /* Data address register */
|
|
int32 LCR; /* Length Count Register */
|
|
int32 lastcard = 0; /* Last card switch */
|
|
int32 carderr = 0; /* Error switch */
|
|
int32 pcherror = 0; /* Punch error */
|
|
int32 notready = 0; /* Not ready error */
|
|
int32 cdr_ebcdic = 0; /* EBCDIC mode on reader */
|
|
int32 cdp_ebcdic = 0; /* EBCDIC mode on punch */
|
|
|
|
extern int32 GetMem(int32 addr);
|
|
extern int32 PutMem(int32 addr, int32 data);
|
|
|
|
/* Card reader data structures
|
|
|
|
cdr_dev CDR descriptor
|
|
cdr_unit CDR unit descriptor
|
|
cdr_reg CDR register list
|
|
*/
|
|
|
|
UNIT cdr_unit = { UDATA (&cdr_svc, UNIT_SEQ+UNIT_ATTABLE, 0), 100 };
|
|
|
|
REG cdr_reg[] = {
|
|
{ FLDATA (LAST, lastcard, 0) },
|
|
{ FLDATA (ERR, carderr, 0) },
|
|
{ FLDATA (NOTRDY, notready, 0) },
|
|
{ HRDATA (DAR, DAR, 16) },
|
|
{ HRDATA (LCR, LCR, 16) },
|
|
{ FLDATA (EBCDIC, cdr_ebcdic, 0) },
|
|
{ FLDATA (S2, s2sel, 0) },
|
|
{ DRDATA (POS, cdr_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ DRDATA (TIME, cdr_unit.wait, 24), PV_LEFT },
|
|
{ BRDATA (BUF, rbuf, 8, 8, CDR_WIDTH) },
|
|
{ NULL }
|
|
};
|
|
|
|
DEVICE cdr_dev = {
|
|
"CDR", &cdr_unit, cdr_reg, NULL,
|
|
1, 10, 31, 1, 8, 7,
|
|
NULL, NULL, &cd_reset,
|
|
&cdr_boot, &cdr_attach, NULL
|
|
};
|
|
|
|
/* CDP data structures
|
|
|
|
cdp_dev CDP device descriptor
|
|
cdp_unit CDP unit descriptor
|
|
cdp_reg CDP register list
|
|
*/
|
|
|
|
UNIT cdp_unit = { UDATA (NULL, UNIT_SEQ+UNIT_ATTABLE, 0) };
|
|
|
|
REG cdp_reg[] = {
|
|
{ FLDATA (ERR, pcherror, 0) },
|
|
{ FLDATA (EBCDIC, cdp_ebcdic, 0) },
|
|
{ FLDATA (S2, s2sel, 0) },
|
|
{ FLDATA (NOTRDY, notready, 0) },
|
|
{ HRDATA (DAR, DAR, 16) },
|
|
{ HRDATA (LCR, LCR, 16) },
|
|
{ DRDATA (POS, cdp_unit.pos, T_ADDR_W), PV_LEFT },
|
|
{ NULL }
|
|
};
|
|
|
|
DEVICE cdp_dev = {
|
|
"CDP", &cdp_unit, cdp_reg, NULL,
|
|
1, 10, 31, 1, 8, 7,
|
|
NULL, NULL, &cd_reset,
|
|
NULL, NULL, NULL
|
|
};
|
|
|
|
/* Stacker data structures
|
|
|
|
stack_dev STACK device descriptor
|
|
stack_unit STACK unit descriptors
|
|
stack_reg STACK register list
|
|
*/
|
|
|
|
UNIT stack_unit[] = {
|
|
{ UDATA (NULL, UNIT_SEQ+UNIT_ATTABLE, 0) }
|
|
};
|
|
|
|
REG stack_reg[] = {
|
|
{ DRDATA (POS0, stack_unit[0].pos, 32), PV_LEFT },
|
|
{ NULL }
|
|
};
|
|
|
|
DEVICE stack_dev = {
|
|
"CDP2", stack_unit, stack_reg, NULL,
|
|
1, 10, 31, 1, 8, 7,
|
|
NULL, NULL, &cd_reset,
|
|
NULL, NULL, NULL
|
|
};
|
|
|
|
|
|
/* -------------------------------------------------------------------- */
|
|
|
|
/* 1442: master routine */
|
|
|
|
int32 crd (int32 op, int32 m, int32 n, int32 data)
|
|
{
|
|
int32 iodata;
|
|
switch (op) {
|
|
case 0: /* SIO 1442 */
|
|
/* if (n == 1)
|
|
return STOP_IBKPT; */
|
|
switch (data) { /* Select stacker */
|
|
case 0x00:
|
|
break;
|
|
case 0x01:
|
|
s2sel = 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch (n) {
|
|
case 0x00: /* Feed */
|
|
iodata = SCPE_OK;
|
|
break;
|
|
case 0x01: /* Read only */
|
|
if (cdr_ebcdic)
|
|
iodata = read_card(0, 1);
|
|
else
|
|
iodata = read_card(0, 0);
|
|
break;
|
|
case 0x02: /* Punch and feed */
|
|
iodata = punch_card(0, 0);
|
|
break;
|
|
case 0x03: /* Read Col Binary */
|
|
iodata = read_card(0, 1);
|
|
break;
|
|
case 0x04: /* Punch no feed */
|
|
iodata = punch_card(0, 1);
|
|
break;
|
|
default:
|
|
return STOP_INVDEV;
|
|
}
|
|
return iodata;
|
|
case 1: /* LIO 1442 */
|
|
switch (n) {
|
|
case 0x00: /* Load LCR */
|
|
LCR = data & 0xffff;
|
|
break;
|
|
case 0x04:
|
|
DAR = data & 0xffff;
|
|
break;
|
|
default:
|
|
return STOP_INVDEV;
|
|
}
|
|
return SCPE_OK;
|
|
case 2: /* TIO 1442 */
|
|
iodata = 0;
|
|
switch (n) {
|
|
case 0x00: /* Error */
|
|
if (carderr || pcherror || notready)
|
|
iodata = 1;
|
|
if ((cdr_unit.flags & UNIT_ATT) == 0)
|
|
iodata = 1; /* attached? */
|
|
break;
|
|
case 0x02: /* Busy */
|
|
if (sim_is_active (&cdr_unit))
|
|
iodata = 1;
|
|
break;
|
|
default:
|
|
return (STOP_INVDEV << 16);
|
|
}
|
|
return ((SCPE_OK << 16) | iodata);
|
|
case 3: /* SNS 1442 */
|
|
iodata = 0;
|
|
switch (n) {
|
|
case 0x01:
|
|
break;
|
|
case 0x02:
|
|
break;
|
|
case 0x03:
|
|
if (carderr)
|
|
iodata |= 0x80;
|
|
if (lastcard)
|
|
iodata |= 0x40;
|
|
if (pcherror)
|
|
iodata |= 0x20;
|
|
if ((cdr_unit.flags & UNIT_ATT) == 0)
|
|
iodata |= 0x08;
|
|
if (notready)
|
|
iodata |= 0x08;
|
|
break;
|
|
case 0x04:
|
|
iodata = DAR;
|
|
break;
|
|
default:
|
|
return (STOP_INVDEV << 16);
|
|
}
|
|
iodata |= ((SCPE_OK << 16) & 0xffff0000);
|
|
return (iodata);
|
|
case 4: /* APL 1442 */
|
|
iodata = 0;
|
|
switch (n) {
|
|
case 0x00: /* Error */
|
|
if (carderr || pcherror || notready)
|
|
iodata = 1;
|
|
if ((cdr_unit.flags & UNIT_ATT) == 0)
|
|
iodata = 1; /* attached? */
|
|
break;
|
|
case 0x02: /* Busy */
|
|
if (sim_is_active (&cdr_unit))
|
|
iodata = 1;
|
|
break;
|
|
default:
|
|
return (STOP_INVDEV << 16);
|
|
}
|
|
return ((SCPE_OK << 16) | iodata);
|
|
default:
|
|
break;
|
|
}
|
|
printf (">>CRD non-existent function %d\n", op);
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Card read routine
|
|
mod 0 = ASCII read
|
|
mod 1 = EBCDIC read
|
|
*/
|
|
|
|
t_stat read_card (int32 ilnt, int32 mod)
|
|
{
|
|
int32 i;
|
|
t_stat r;
|
|
|
|
if (sim_is_active (&cdr_unit)) { /* busy? */
|
|
sim_cancel (&cdr_unit); /* cancel */
|
|
if (r = cdr_svc (&cdr_unit)) return r; /* process */
|
|
}
|
|
|
|
if (((cdp_unit.flags & UNIT_ATT) != 0 ||
|
|
(stack_unit[0].flags & UNIT_ATT) != 0) && /* Punch is attached and */
|
|
(cdr_unit.flags & UNIT_ATT) == 0) { /* reader is not --- */
|
|
for (i = 0; i < 80; i++) { /* Assume blank cards in hopper */
|
|
PutMem(DAR, 0x40);
|
|
DAR++;
|
|
}
|
|
sim_activate (&cdr_unit, cdr_unit.wait); /* activate */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
if ((cdr_unit.flags & UNIT_ATT) == 0) return SCPE_UNATT; /* attached? */
|
|
|
|
lastcard = carderr = notready = s1sel = s2sel = 0; /* default stacker */
|
|
|
|
for (i = 0; i < CBUFSIZE; i++) rbuf[i] = 0x20; /* clear buffer */
|
|
if (mod) {
|
|
for (i = 0; i < 80; i++) {
|
|
rbuf[i] = fgetc(cdr_unit.fileref); /* Read EBCDIC */
|
|
}
|
|
} else {
|
|
fgets (rbuf, CBUFSIZE, cdr_unit.fileref); /* read Ascii */
|
|
}
|
|
if (feof (cdr_unit.fileref)) { /* eof? */
|
|
notready = 1;
|
|
return STOP_NOCD;
|
|
}
|
|
if (ferror (cdr_unit.fileref)) { /* error? */
|
|
perror ("Card reader I/O error");
|
|
clearerr (cdr_unit.fileref);
|
|
carderr = 1;
|
|
return SCPE_OK; }
|
|
cdr_unit.pos = ftell (cdr_unit.fileref); /* update position */
|
|
i = getc (cdr_unit.fileref); /* see if more */
|
|
if (feof (cdr_unit.fileref)) lastcard = 1; /* eof? set flag */
|
|
fseek (cdr_unit.fileref, cdr_unit.pos, SEEK_SET);
|
|
for (i = 0; i < 80; i++) {
|
|
if (mod == 0) { /* If ASCII mode... */
|
|
if (rbuf[i] == '\n' || /* remove ASCII CR/LF */
|
|
rbuf[i] == '\r' ||
|
|
rbuf[i] == 0x00)
|
|
rbuf[i] = ' ';
|
|
rbuf[i] = ascii_to_ebcdic[rbuf[i]]; /* convert to EBCDIC */
|
|
}
|
|
PutMem(DAR, rbuf[i]); /* Copy to main memory */
|
|
DAR++;
|
|
}
|
|
sim_activate (&cdr_unit, cdr_unit.wait); /* activate */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Card reader service. If a stacker select is active, copy to the
|
|
selected stacker. Otherwise, copy to the normal stacker. If the
|
|
unit is unattached, simply exit.
|
|
*/
|
|
|
|
t_stat cdr_svc (UNIT *uptr)
|
|
{
|
|
int32 i;
|
|
|
|
if (s2sel) uptr = &stack_unit[0]; /* stacker 1? */
|
|
else uptr = &stack_unit[0]; /* then default */
|
|
if ((uptr -> flags & UNIT_ATT) == 0) return SCPE_OK; /* attached? */
|
|
for (i = 0; i < CDR_WIDTH; i++) rbuf[i] = ebcdic_to_ascii[rbuf[i]];
|
|
for (i = CDR_WIDTH - 1; (i >= 0) && (rbuf[i] == ' '); i--) rbuf[i] = 0;
|
|
rbuf[CDR_WIDTH] = 0; /* null at end */
|
|
fputs (rbuf, uptr -> fileref); /* write card */
|
|
fputc ('\n', uptr -> fileref); /* plus new line */
|
|
if (ferror (uptr -> fileref)) { /* error? */
|
|
perror ("Card stacker I/O error");
|
|
clearerr (uptr -> fileref);
|
|
}
|
|
uptr -> pos = ftell (uptr -> fileref); /* update position */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Card punch routine
|
|
|
|
mod: not used
|
|
*/
|
|
|
|
t_stat punch_card (int32 ilnt, int32 mod)
|
|
{
|
|
int32 i, colcount;
|
|
static char pbuf[CDP_WIDTH + 1]; /* + null */
|
|
UNIT *uptr;
|
|
|
|
if (s2sel) uptr = &stack_unit[0]; /* stack 2? */
|
|
else uptr = &cdp_unit; /* normal output */
|
|
if ((uptr -> flags & UNIT_ATT) == 0) { /* Attached? */
|
|
notready = 1;
|
|
return SCPE_OK;
|
|
}
|
|
pcherror = s1sel = notready = 0; /* clear flags */
|
|
|
|
colcount = 128 - LCR;
|
|
for (i = 0; i < colcount; i++) { /* Fetch data */
|
|
if (cdp_ebcdic)
|
|
pbuf[i] = GetMem(DAR) & 0xff;
|
|
else
|
|
pbuf[i] = ebcdic_to_ascii[GetMem(DAR)];
|
|
DAR++;
|
|
}
|
|
for (i = CDP_WIDTH - 1; (i >= 0) && (pbuf[i] == ' '); i--) pbuf[i] = 0;
|
|
pbuf[CDP_WIDTH] = 0; /* trailing null */
|
|
if (!cdp_ebcdic) {
|
|
fputs (pbuf, uptr -> fileref); /* output card */
|
|
fputc ('\n', uptr -> fileref); /* plus new line */
|
|
} else {
|
|
for (i = 0; i < 80; i++) {
|
|
fputc(pbuf[i], uptr -> fileref);
|
|
}
|
|
}
|
|
if (ferror (uptr -> fileref)) { /* error? */
|
|
perror ("Card punch I/O error");
|
|
clearerr (uptr -> fileref);
|
|
pcherror = 1;
|
|
}
|
|
uptr -> pos = ftell (uptr -> fileref); /* update position */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Select stack routine
|
|
|
|
Modifiers have been checked by the caller
|
|
Modifiers are 1, 2, for the respective stack
|
|
*/
|
|
|
|
t_stat select_stack (int32 ilnt, int32 mod)
|
|
{
|
|
if (mod == 1) s1sel = 1;
|
|
else if (mod == 2) s2sel = 1;
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Card reader/punch reset */
|
|
|
|
t_stat cd_reset (DEVICE *dptr)
|
|
{
|
|
lastcard = carderr = notready = pcherror = 0; /* clear indicators */
|
|
s1sel = s2sel = 0; /* clear stacker sel */
|
|
sim_cancel (&cdr_unit); /* clear reader event */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* Card reader attach */
|
|
|
|
t_stat cdr_attach (UNIT *uptr, char *cptr)
|
|
{
|
|
carderr = lastcard = notready = 0; /* clear last card */
|
|
return attach_unit (uptr, cptr);
|
|
}
|
|
|
|
/* Bootstrap routine */
|
|
|
|
t_stat cdr_boot (int32 unitno, DEVICE *dptr)
|
|
{
|
|
cdr_ebcdic = 1;
|
|
DAR = 0;
|
|
LCR = 80;
|
|
read_card(0, 1);
|
|
return SCPE_OK;
|
|
}
|