| /* 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; (size_t)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; | |
| } |