github.com/simh.simh
1
0
Fork 0
mirror of https://github.com/simh/simh.git synced 2026-05-02 06:15:23 +00:00
Code Releases Activity

Merge changes from v3.9-0 rc1

Browse Source
This commit is contained in:
Mark Pizzolato
2012-03-19 16:05:24 -07:00
parent e04a987353
commit fffad7c20e
145 changed files with 29917 additions and 15649 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
sigma/sigma_pt.c Normal file
View File

@@ -0,0 +1,297 @@
/* sigma_pt.c: Sigma 7060 paper tape reader/punch
Copyright (c) 2007-2008, Robert M. Supnik
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
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 Robert M Supnik shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from Robert M Supnik.
pt 7060 paper-tape reader/punch
*/
#include "sigma_io_defs.h"
/* Device definitions */
#define PTR 0
#define PTP 1
/* Device states */
#define PTS_INIT 0x101
#define PTS_END 0x102
#define PTS_WRITE 0x1
#define PTS_READ 0x2
#define PTS_READI 0x82
/* Device status */
#define PTDV_PMAN 0x20
#define PTDV_RMAN 0x10
uint32 pt_cmd = 0;
uint32 ptr_nzc = 0;
uint32 ptr_stopioe = 1;
uint32 ptp_stopioe = 1;
extern uint32 chan_ctl_time;
extern uint8 ascii_to_ebcdic[128];
extern uint8 ebcdic_to_ascii[256];
uint32 pt_disp (uint32 op, uint32 dva, uint32 *dvst);
uint32 pt_tio_status (void);
uint32 pt_tdv_status (void);
t_stat pt_chan_err (uint32 st);
t_stat pt_svc (UNIT *uptr);
t_stat pt_reset (DEVICE *dptr);
t_stat pt_attach (UNIT *uptr, char *cptr);
/* PT data structures
pt_dev PT device descriptor
pt_unit PT unit descriptors
pt_reg PT register list
pt_mod PT modifiers list
*/
dib_t pt_dib = { DVA_PT, pt_disp };
UNIT pt_unit[] = {
{ UDATA (&pt_svc, UNIT_ATTABLE+UNIT_SEQ+UNIT_ROABLE, 0), SERIAL_IN_WAIT },
{ UDATA (&pt_svc, UNIT_ATTABLE+UNIT_SEQ, 0), SERIAL_OUT_WAIT }
};
REG pt_reg[] = {
{ HRDATA (CMD, pt_cmd, 9) },
{ FLDATA (NZC, ptr_nzc,0) },
{ DRDATA (RPOS, pt_unit[PTR].pos, T_ADDR_W), PV_LEFT },
{ DRDATA (RTIME, pt_unit[PTR].wait, 24), PV_LEFT },
{ FLDATA (RSTOP_IOE, ptr_stopioe, 0) },
{ DRDATA (PPOS, pt_unit[PTP].pos, T_ADDR_W), PV_LEFT },
{ DRDATA (PTIME, pt_unit[PTP].wait, 24), REG_NZ + PV_LEFT },
{ FLDATA (PSTOP_IOE, ptp_stopioe, 0) },
{ HRDATA (DEVNO, pt_dib.dva, 12), REG_HRO },
{ NULL }
};
MTAB pt_mod[] = {
{ MTAB_XTD|MTAB_VDV, 0, "CHAN", "CHAN",
&io_set_dvc, &io_show_dvc, NULL },
{ MTAB_XTD|MTAB_VDV, 0, "DVA", "DVA",
&io_set_dva, &io_show_dva, NULL },
{ MTAB_XTD|MTAB_VDV|MTAB_NMO, 0, "CSTATE", NULL,
NULL, &io_show_cst, NULL },
{ 0 }
};
DEVICE pt_dev = {
"PT", pt_unit, pt_reg, pt_mod,
2, 10, 31, 1, 16, 8,
NULL, NULL, &pt_reset,
&io_boot, &pt_attach, NULL,
&pt_dib, DEV_DISABLE
};
/* Reader/punch: IO dispatch routine */
uint32 pt_disp (uint32 op, uint32 dva, uint32 *dvst)
{
switch (op) { /* case on op */
case OP_SIO: /* start I/O */
*dvst = pt_tio_status (); /* get status */
if ((*dvst & DVS_DST) == 0) { /* idle? */
pt_cmd = PTS_INIT; /* start dev thread */
sim_activate (&pt_unit[PTR], chan_ctl_time);
}
break;
case OP_TIO: /* test status */
*dvst = pt_tio_status (); /* return status */
break;
case OP_TDV: /* test status */
*dvst = pt_tdv_status (); /* return status */
break;
case OP_HIO: /* halt I/O */
chan_clr_chi (pt_dib.dva); /* clr int*/
*dvst = pt_tio_status (); /* get status */
if ((*dvst & DVS_DST) != 0) { /* busy? */
sim_cancel (&pt_unit[PTR]); /* stop dev thread */
chan_uen (pt_dib.dva); /* uend */
}
break;
case OP_AIO: /* acknowledge int */
chan_clr_chi (pt_dib.dva); /* clr int*/
*dvst = 0; /* no status */
break;
default:
*dvst = 0;
return SCPE_IERR;
}
return 0;
}
/* Service routine */
t_stat pt_svc (UNIT *uptr)
{
int32 c;
uint32 cmd;
uint32 st;
switch (pt_cmd) { /* case on state */
case PTS_INIT: /* I/O init */
st = chan_get_cmd (pt_dib.dva, &cmd); /* get command */
if (CHS_IFERR (st)) /* channel error? */
return pt_chan_err (st);
if ((cmd == PTS_WRITE) || /* valid command? */
((cmd & 0x7F) == PTS_READ))
pt_cmd = cmd; /* next state */
else pt_cmd = PTS_END; /* no, end state */
sim_activate (uptr, chan_ctl_time); /* continue thread */
break;
case PTS_READ:
case PTS_READI:
sim_activate (uptr, uptr->wait); /* continue thread */
if ((uptr->flags & UNIT_ATT) == 0) /* not attached? */
return ptr_stopioe? SCPE_UNATT: SCPE_OK;
if ((c = getc (uptr->fileref)) == EOF) { /* read char */
if (feof (uptr->fileref)) { /* end of file? */
chan_set_chf (pt_dib.dva, CHF_LNTE); /* length error */
pt_cmd = PTS_END; /* end state */
break;
}
else { /* real error */
perror ("PTR I/O error");
clearerr (uptr->fileref);
chan_set_chf (pt_dib.dva, CHF_XMDE); /* data error */
return pt_chan_err (SCPE_IOERR); /* force uend */
}
}
uptr->pos = uptr->pos + 1;
if (c != 0) /* leader done? */
ptr_nzc = 1; /* set flag */
if ((pt_cmd == PTS_READI) || ptr_nzc) {
st = chan_WrMemB (pt_dib.dva, c); /* write to memory */
if (CHS_IFERR (st)) /* channel error? */
return pt_chan_err (st);
if (st == CHS_ZBC) /* bc == 0? */
pt_cmd = PTS_END; /* end state */
}
break;
case PTS_WRITE: /* write */
sim_activate (uptr, pt_unit[PTP].wait); /* continue thread */
if ((pt_unit[PTP].flags & UNIT_ATT) == 0) /* not attached? */
return ptp_stopioe? SCPE_UNATT: SCPE_OK;
st = chan_RdMemB (pt_dib.dva, &c); /* read from channel */
if (CHS_IFERR (st)) /* channel error? */
return pt_chan_err (st);
if (putc (c, pt_unit[PTP].fileref) == EOF) {
perror ("PTP I/O error");
clearerr (pt_unit[PTP].fileref);
chan_set_chf (pt_dib.dva, CHF_XMDE); /* data error */
return pt_chan_err (SCPE_IOERR); /* force uend */
}
pt_unit[PTP].pos = pt_unit[PTP].pos + 1;
if (st == CHS_ZBC) /* bc == 0? */
pt_cmd = PTS_END; /* end state */
break;
case PTS_END: /* command done */
st = chan_end (pt_dib.dva); /* set channel end */
if (CHS_IFERR (st)) /* channel error? */
return pt_chan_err (st);
if (st == CHS_CCH) { /* command chain? */
pt_cmd = PTS_INIT; /* restart thread */
sim_activate (uptr, chan_ctl_time);
}
break;
}
return SCPE_OK;
}
/* PT status routine */
uint32 pt_tio_status (void)
{
uint32 st;
if (((pt_unit[PTR].flags & UNIT_ATT) == 0) || /* rdr not att? */
((pt_unit[PTP].flags & UNIT_ATT) == 0)) /* pun not att? */
st = 0;
else st = DVS_AUTO; /* otherwise ok */
if (sim_is_active (&pt_unit[PTR])) /* dev busy? */
st |= (DVS_CBUSY | DVS_DBUSY | (CC2 << DVT_V_CC));
return st;
}
uint32 pt_tdv_status (void)
{
uint32 st;
st = 0;
if ((pt_unit[PTR].flags & UNIT_ATT) == 0) /* rdr not att? */
st |= PTDV_RMAN;
if ((pt_unit[PTP].flags & UNIT_ATT) == 0) /* pun not att? */
st |= PTDV_PMAN;
return st;
}
/* Channel error */
t_stat pt_chan_err (uint32 st)
{
sim_cancel (&pt_unit[PTR]); /* stop dev thread */
chan_uen (pt_dib.dva); /* uend */
if (st < CHS_ERR)
return st;
return SCPE_OK;
}
/* Reset routine */
t_stat pt_reset (DEVICE *dptr)
{
sim_cancel (&pt_unit[PTR]); /* stop dev thread */
pt_cmd = 0;
chan_reset_dev (pt_dib.dva); /* clr int, active */
return SCPE_OK;
}
/* Attach routine */
t_stat pt_attach (UNIT *uptr, char *cptr)
{
t_stat st;
st = attach_unit (uptr, cptr);
if ((uptr == &pt_unit[PTR]) && (st == SCPE_OK))
ptr_nzc = 0;
return st;
}