a6964f849d
Very minor in all cases, but the strange case of swtp_cpu.c This module used expressions of the form: PC = ++PC & ADDRMASK; Officially, the C language says that expressions which modify the same variable in more than one place have undefined behavior. These were changed to the legal form which performs the desired action: PC = (PC + 1) & ADDRMASK;
309 lines
9 KiB
C
309 lines
9 KiB
C
/* ibm1130_ptrp.c: IBM 1130 paper tape reader/punch emulation
|
|
|
|
Based on the SIMH simulator package written by Robert M Supnik
|
|
|
|
Brian Knittel
|
|
Revision History
|
|
|
|
2004.10.22 - Written.
|
|
|
|
* (C) Copyright 2004, Brian Knittel.
|
|
* You may freely use this program, but: it offered strictly on an AS-IS, AT YOUR OWN
|
|
* RISK basis, there is no warranty of fitness for any purpose, and the rest of the
|
|
* usual yada-yada. Please keep this notice and the copyright in any distributions
|
|
* or modifications.
|
|
*
|
|
* This is not a supported product, but I welcome bug reports and fixes.
|
|
* Mail to simh@ibm1130.org
|
|
*/
|
|
|
|
#include "ibm1130_defs.h"
|
|
|
|
/***************************************************************************************
|
|
* 1134 Paper Tape Reader device PTR
|
|
* 1055 Paper Tape Punch device PTP (shares DSW with PTR)
|
|
***************************************************************************************/
|
|
|
|
#define PTR1134_DSW_READER_RESPONSE 0x4000
|
|
#define PTR1134_DSW_PUNCH_RESPONSE 0x1000
|
|
#define PTR1134_DSW_READER_BUSY 0x0800
|
|
#define PTR1134_DSW_READER_NOT_READY 0x0400
|
|
#define PTR1134_DSW_PUNCH_BUSY 0x0200
|
|
#define PTR1134_DSW_PUNCH_NOT_READY 0x0100
|
|
|
|
#define IS_ONLINE(u) (((u)->flags & (UNIT_ATT|UNIT_DIS)) == UNIT_ATT)
|
|
|
|
static t_stat ptr_svc (UNIT *uptr);
|
|
static t_stat ptr_reset (DEVICE *dptr);
|
|
static t_stat ptr_attach (UNIT *uptr, char *cptr);
|
|
static t_stat ptr_detach (UNIT *uptr);
|
|
static t_stat ptr_boot (int32 unitno, DEVICE *dptr);
|
|
static t_stat ptp_svc (UNIT *uptr);
|
|
static t_stat ptp_reset (DEVICE *dptr);
|
|
static t_stat ptp_attach (UNIT *uptr, char *cptr);
|
|
static t_stat ptp_detach (UNIT *uptr);
|
|
|
|
static int16 ptr_dsw = 0; /* device status word */
|
|
static int32 ptr_wait = 1000; /* character read wait */
|
|
static uint8 ptr_char = 0; /* last character read */
|
|
static int32 ptp_wait = 1000; /* character punch wait */
|
|
|
|
UNIT ptr_unit[1] = {
|
|
{ UDATA (&ptr_svc, UNIT_ATTABLE, 0) },
|
|
};
|
|
|
|
REG ptr_reg[] = {
|
|
{ HRDATA (DSW, ptr_dsw, 16) }, /* device status word */
|
|
{ DRDATA (WTIME, ptr_wait, 24), PV_LEFT }, /* character read wait */
|
|
{ DRDATA (LASTCHAR, ptr_char, 8), PV_LEFT }, /* last character read */
|
|
{ NULL } };
|
|
|
|
DEVICE ptr_dev = {
|
|
"PTR", ptr_unit, ptr_reg, NULL,
|
|
1, 16, 16, 1, 16, 16,
|
|
NULL, NULL, ptr_reset,
|
|
ptr_boot, ptr_attach, ptr_detach};
|
|
|
|
UNIT ptp_unit[1] = {
|
|
{ UDATA (&ptp_svc, UNIT_ATTABLE, 0) },
|
|
};
|
|
|
|
REG ptp_reg[] = {
|
|
{ HRDATA (DSW, ptr_dsw, 16) }, /* device status word (this is the same as the reader's!) */
|
|
{ DRDATA (WTIME, ptp_wait, 24), PV_LEFT }, /* character punch wait */
|
|
{ NULL } };
|
|
|
|
DEVICE ptp_dev = {
|
|
"PTP", ptp_unit, ptp_reg, NULL,
|
|
1, 16, 16, 1, 16, 16,
|
|
NULL, NULL, ptp_reset,
|
|
NULL, ptp_attach, ptp_detach};
|
|
|
|
/* xio_1134_papertape - XIO command interpreter for the 1134 paper tape reader and 1055 paper tape punch */
|
|
|
|
void xio_1134_papertape (int32 iocc_addr, int32 iocc_func, int32 iocc_mod)
|
|
{
|
|
char msg[80];
|
|
|
|
switch (iocc_func) {
|
|
case XIO_READ: /* read: return last character read */
|
|
M[iocc_addr & mem_mask] = (uint16) (ptr_char << 8);
|
|
break;
|
|
|
|
case XIO_WRITE: /* write: initiate punch operation */
|
|
if ((ptr_dsw & PTR1134_DSW_PUNCH_NOT_READY) == 0 && IS_ONLINE(ptp_unit)) {
|
|
putc((M[iocc_addr & mem_mask] >> 8) & 0xFF, ptp_unit->fileref);
|
|
ptp_unit->pos++;
|
|
}
|
|
sim_activate(ptp_unit, ptp_wait); /* schedule interrupt */
|
|
SETBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY | PTR1134_DSW_PUNCH_BUSY);
|
|
break;
|
|
|
|
case XIO_SENSE_DEV: /* sense device status */
|
|
ACC = ptr_dsw;
|
|
if (iocc_mod & 0x01) { /* reset interrupts */
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_READER_RESPONSE | PTR1134_DSW_PUNCH_RESPONSE);
|
|
CLRBIT(ILSW[4], ILSW_4_1134_TAPE);
|
|
}
|
|
break;
|
|
|
|
case XIO_CONTROL: /* control: initiate character read */
|
|
sim_activate(ptr_unit, ptr_wait); /* schedule interrupt */
|
|
SETBIT(ptr_dsw, PTR1134_DSW_READER_BUSY | PTR1134_DSW_READER_NOT_READY);
|
|
break;
|
|
|
|
default:
|
|
sprintf(msg, "Invalid 1134 reader/1055 punch XIO function %x", iocc_func);
|
|
xio_error(msg);
|
|
}
|
|
}
|
|
|
|
/* ptr_svc - emulated timeout - 1134 read operation complete */
|
|
|
|
static t_stat ptr_svc (UNIT *uptr)
|
|
{
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_READER_BUSY); /* clear reader busy flag */
|
|
SETBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY); /* assume at end of file */
|
|
|
|
if (IS_ONLINE(uptr)) { /* fetch character from file */
|
|
ptr_char = getc(uptr->fileref);
|
|
uptr->pos++;
|
|
|
|
if (! feof(uptr->fileref)) /* there's more left */
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY);
|
|
}
|
|
|
|
SETBIT(ptr_dsw, PTR1134_DSW_READER_RESPONSE); /* indicate read complete */
|
|
|
|
SETBIT(ILSW[4], ILSW_4_1134_TAPE); /* initiate interrupt */
|
|
calc_ints();
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptp_svc - emulated timeout -- 1055 punch operation complete */
|
|
|
|
static t_stat ptp_svc (UNIT *uptr)
|
|
{
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_PUNCH_BUSY); /* clear punch busy flag */
|
|
|
|
if (IS_ONLINE(uptr)) /* update punch ready status */
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY);
|
|
else
|
|
SETBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY);
|
|
|
|
SETBIT(ptr_dsw, PTR1134_DSW_PUNCH_RESPONSE); /* indicate punch complete */
|
|
|
|
SETBIT(ILSW[4], ILSW_4_1134_TAPE); /* initiate interrupt */
|
|
calc_ints();
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptr_reset - reset emulated paper tape reader */
|
|
|
|
static t_stat ptr_reset (DEVICE *dptr)
|
|
{
|
|
sim_cancel(ptr_unit);
|
|
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_READER_BUSY | PTR1134_DSW_READER_RESPONSE);
|
|
SETBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY);
|
|
|
|
if (IS_ONLINE(ptr_unit) && ! feof(ptr_unit->fileref))
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY);
|
|
|
|
if ((ptr_dsw & PTR1134_DSW_PUNCH_RESPONSE) == 0) { /* punch isn't interrupting either */
|
|
CLRBIT(ILSW[4], ILSW_4_1134_TAPE);
|
|
calc_ints();
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptp_reset - reset emulated paper tape punch */
|
|
|
|
static t_stat ptp_reset (DEVICE *dptr)
|
|
{
|
|
sim_cancel(ptp_unit);
|
|
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_PUNCH_BUSY | PTR1134_DSW_PUNCH_RESPONSE);
|
|
SETBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY);
|
|
|
|
if (IS_ONLINE(ptp_unit))
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY);
|
|
|
|
if ((ptr_dsw & PTR1134_DSW_READER_RESPONSE) == 0) { /* reader isn't interrupting either */
|
|
CLRBIT(ILSW[4], ILSW_4_1134_TAPE);
|
|
calc_ints();
|
|
}
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptr_attach - attach file to simulated paper tape reader */
|
|
|
|
static t_stat ptr_attach (UNIT *uptr, char *cptr)
|
|
{
|
|
t_stat rval;
|
|
|
|
SETBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY); /* assume failure */
|
|
|
|
if ((rval = attach_unit(uptr, cptr)) != SCPE_OK) /* use standard attach */
|
|
return rval;
|
|
|
|
if ((ptr_dsw & PTR1134_DSW_READER_BUSY) == 0 && ! feof(uptr->fileref))
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY); /* we're in business */
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptr_attach - detach file from simulated paper tape reader */
|
|
|
|
static t_stat ptr_detach (UNIT *uptr)
|
|
{
|
|
SETBIT(ptr_dsw, PTR1134_DSW_READER_NOT_READY);
|
|
|
|
return detach_unit(uptr);
|
|
}
|
|
|
|
/* ptr_attach - perform paper tape initial program load */
|
|
|
|
static t_stat ptr_boot (int32 unitno, DEVICE *dptr)
|
|
{
|
|
int ch, nch, val, addr;
|
|
t_bool leader = TRUE, start = FALSE;
|
|
t_stat rval;
|
|
|
|
addr = 0;
|
|
nch = 0;
|
|
val = 0;
|
|
|
|
for (;;) {
|
|
if ((ch = getc(ptr_unit->fileref)) == EOF) {
|
|
printf("EOF on paper tape without finding Channel 5 end-of-load mark\n");
|
|
break;
|
|
}
|
|
|
|
if (leader) {
|
|
if ((ch & 0x7F) == 0x7F) /* ignore leading rubouts or "delete" characters */
|
|
continue;
|
|
|
|
leader = FALSE; /* after first nonrubout, any punch in channel 5 terminates load */
|
|
}
|
|
|
|
/* this is untested -- not sure of actual byte ordering */
|
|
|
|
val = (val << 4) | (ch & 0x0F); /* get next nybble */
|
|
|
|
if (++nch == 4) { /* if we now have four nybbles, store the word */
|
|
M[addr & mem_mask] = (uint16) val;
|
|
|
|
addr++; /* prepare for next word */
|
|
nch = 0;
|
|
val = 0;
|
|
}
|
|
|
|
if (ch & 0x10) { /* channel 5 punch terminates load */
|
|
start = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (! start) /* if we didn't get a valid load, report EOF error */
|
|
return SCPE_EOF;
|
|
|
|
if ((rval = reset_all(0)) != SCPE_OK) /* force a reset */
|
|
return rval;
|
|
|
|
IAR = 0; /* start running at address 0 */
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptp_attach - attach file to simulated paper tape punch */
|
|
|
|
static t_stat ptp_attach (UNIT *uptr, char *cptr)
|
|
{
|
|
t_stat rval;
|
|
|
|
SETBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY); /* assume failure */
|
|
|
|
if ((rval = attach_unit(uptr, cptr)) != SCPE_OK) /* use standard attach */
|
|
return rval;
|
|
|
|
fseek(uptr->fileref, 0, SEEK_END); /* if we opened an existing file, append to it */
|
|
uptr->pos = ftell(uptr->fileref);
|
|
|
|
if ((ptr_dsw & PTR1134_DSW_PUNCH_BUSY) == 0)
|
|
CLRBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY); /* we're in business */
|
|
|
|
return SCPE_OK;
|
|
}
|
|
|
|
/* ptp_detach - detach file from simulated paper tape punch */
|
|
|
|
static t_stat ptp_detach (UNIT *uptr)
|
|
{
|
|
SETBIT(ptr_dsw, PTR1134_DSW_PUNCH_NOT_READY);
|
|
|
|
return detach_unit(uptr);
|
|
}
|