home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Boot_Images / 2.11_on_rl02 / pdpsim.tz / pdpsim / pdp8_pt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-29  |  5.0 KB  |  187 lines
  1. /* pdp8_pt.c: PDP-8 paper tape reader/punch simulator
  2.  
  3.    Copyright (c) 1993, 1994, 1995,
  4.    Robert M Supnik, Digital Equipment Corporation
  5.    Commercial use prohibited
  6.  
  7.    ptr        paper tape reader
  8.    ptp        paper tape punch
  9. */
  10.  
  11. #include "pdp8_defs.h"
  12.  
  13. extern int int_req, dev_done, dev_enable, stop_inst;
  14. int ptr_stopioe = 0, ptp_stopioe = 0;            /* stop on error */
  15. int ptr_svc (UNIT *uptr);
  16. int ptp_svc (UNIT *uptr);
  17. int ptr_reset (DEVICE *dptr);
  18. int ptp_reset (DEVICE *dptr);
  19. extern int sim_activate (UNIT *uptr, int interval);
  20. extern int sim_cancel (UNIT *uptr);
  21.  
  22. /* PTR data structures
  23.  
  24.    ptr_dev    PTR device descriptor
  25.    ptr_unit    PTR unit descriptor
  26.    ptr_reg    PTR register list
  27. */
  28.  
  29. UNIT ptr_unit = {
  30.     UDATA (&ptr_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_IN_WAIT };
  31.  
  32. REG ptr_reg[] = {
  33.     { ORDATA (BUF, ptr_unit.buf, 8) },
  34.     { FLDATA (DONE, dev_done, INT_V_PTR) },
  35.     { FLDATA (ENABLE, dev_enable, INT_V_PTR) },
  36.     { FLDATA (INT, int_req, INT_V_PTR) },
  37.     { DRDATA (POS, ptr_unit.pos, 32), PV_LEFT },
  38.     { DRDATA (TIME, ptr_unit.wait, 24), PV_LEFT },
  39.     { FLDATA (STOP_IOE, ptr_stopioe, 0) },
  40.     { NULL }  };
  41.  
  42. DEVICE ptr_dev = {
  43.     "PTR", &ptr_unit, ptr_reg, NULL,
  44.     1, 10, 32, 1, 8, 8,
  45.     NULL, NULL, &ptr_reset,
  46.     NULL, NULL, NULL };
  47.  
  48. /* PTP data structures
  49.  
  50.    ptp_dev    PTP device descriptor
  51.    ptp_unit    PTP unit descriptor
  52.    ptp_reg    PTP register list
  53. */
  54.  
  55. UNIT ptp_unit = {
  56.     UDATA (&ptp_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_OUT_WAIT };
  57.  
  58. REG ptp_reg[] = {
  59.     { ORDATA (BUF, ptp_unit.buf, 8) },
  60.     { FLDATA (DONE, dev_done, INT_V_PTP) },
  61.     { FLDATA (ENABLE, dev_enable, INT_V_PTP) },
  62.     { FLDATA (INT, int_req, INT_V_PTP) },
  63.     { DRDATA (POS, ptp_unit.pos, 32), PV_LEFT },
  64.     { DRDATA (TIME, ptp_unit.wait, 24), PV_LEFT },
  65.     { FLDATA (STOP_IOE, ptp_stopioe, 0) },
  66.     { NULL }  };
  67.  
  68. DEVICE ptp_dev = {
  69.     "PTP", &ptp_unit, ptp_reg, NULL,
  70.     1, 10, 32, 1, 8, 8,
  71.     NULL, NULL, &ptp_reset,
  72.     NULL, NULL, NULL };
  73.  
  74. /* Paper tape reader: IOT routine */
  75.  
  76. int ptr (int pulse, int AC)
  77. {
  78. switch (pulse) {                    /* decode IR<9:11> */
  79. case 0:                         /* RPE */
  80.     dev_enable = dev_enable | (INT_PTR+INT_PTP);    /* set enable */
  81.     int_req = INT_UPDATE;                /* update interrupts */
  82.     return AC;
  83. case 1:                            /* RSF */
  84.     return (dev_done & INT_PTR)? IOT_SKP + AC: AC;    
  85. case 6:                            /* RFC!RRB */
  86.     sim_activate (&ptr_unit, ptr_unit.wait);
  87. case 2:                            /* RRB */
  88.     dev_done = dev_done & ~INT_PTR;            /* clear flag */
  89.     int_req = int_req & ~INT_PTR;            /* clear int req */
  90.     return (AC | ptr_unit.buf);            /* or data to AC */
  91. case 4:                            /* RFC */
  92.     sim_activate (&ptr_unit, ptr_unit.wait);
  93.     dev_done = dev_done & ~INT_PTR;            /* clear flag */
  94.     int_req = int_req & ~INT_PTR;            /* clear int req */
  95.     return AC;
  96. default:
  97.     return (stop_inst << IOT_V_REASON) + AC;  }    /* end switch */
  98. }
  99.  
  100. /* Unit service */
  101.  
  102. int ptr_svc (UNIT *uptr)
  103. {
  104. int temp;
  105.  
  106. if ((ptr_unit.flags & UNIT_ATT) == 0)            /* attached? */
  107.     return IORETURN (ptr_stopioe, SCPE_UNATT);
  108. if ((temp = getc (ptr_unit.fileref)) == EOF) {
  109.     if (feof (ptr_unit.fileref)) {
  110.         if (ptr_stopioe) printf ("PTR end of file\n");
  111.         else return SCPE_OK;  }
  112.     else perror ("PTR I/O error");
  113.     clearerr (ptr_unit.fileref);
  114.     return SCPE_IOERR;  }
  115. dev_done = dev_done | INT_PTR;                /* set done */
  116. int_req = INT_UPDATE;                    /* update interrupts */
  117. ptr_unit.buf = temp & 0377;
  118. ptr_unit.pos = ptr_unit.pos + 1;
  119. return SCPE_OK;
  120. }
  121.  
  122. /* Reset routine */
  123.  
  124. int ptr_reset (DEVICE *dptr)
  125. {
  126. ptr_unit.buf = 0;
  127. dev_done = dev_done & ~INT_PTR;                /* clear done, int */
  128. int_req = int_req & ~INT_PTR;
  129. dev_enable = dev_enable | INT_PTR;            /* set enable */
  130. sim_cancel (&ptr_unit);                    /* deactivate unit */
  131. return SCPE_OK;
  132. }
  133.  
  134. /* Paper tape punch: IOT routine */
  135.  
  136. int ptp (int pulse, int AC)
  137. {
  138. switch (pulse) {                    /* decode IR<9:11> */
  139. case 0:                         /* PCE */
  140.     dev_enable = dev_enable & ~(INT_PTR+INT_PTP);    /* clear enables */
  141.     int_req = INT_UPDATE;                /* update interrupts */
  142.     return AC;
  143. case 1:                            /* PSF */
  144.     return (dev_done & INT_PTP)? IOT_SKP + AC: AC;
  145. case 2:                            /* PCF */
  146.     dev_done = dev_done & ~INT_PTP;            /* clear flag */
  147.     int_req = int_req & ~INT_PTP;            /* clear int req */
  148.     return AC;
  149. case 6:                            /* PLS */
  150.     dev_done = dev_done & ~INT_PTP;            /* clear flag */
  151.     int_req = int_req & ~INT_PTP;            /* clear int req */
  152. case 4:                            /* PPC */
  153.     ptp_unit.buf = AC & 0377;            /* load punch buf */
  154.     sim_activate (&ptp_unit, ptp_unit.wait);    /* activate unit */
  155.     return AC;
  156. default:
  157.     return (stop_inst << IOT_V_REASON) + AC;  }    /* end switch */
  158. }
  159.  
  160. /* Unit service */
  161.  
  162. int ptp_svc (UNIT *uptr)
  163. {
  164. dev_done = dev_done | INT_PTP;                /* set done */
  165. int_req = INT_UPDATE;                    /* update interrupts */
  166. if ((ptp_unit.flags & UNIT_ATT) == 0)            /* attached? */
  167.     return IORETURN (ptp_stopioe, SCPE_UNATT);
  168. if (putc (ptp_unit.buf, ptp_unit.fileref) == EOF) {
  169.     perror ("PTP I/O error");
  170.     clearerr (ptp_unit.fileref);
  171.     return SCPE_IOERR;  }
  172. ptp_unit.pos = ptp_unit.pos + 1;
  173. return SCPE_OK;
  174. }
  175.  
  176. /* Reset routine */
  177.  
  178. int ptp_reset (DEVICE *dptr)
  179. {
  180. ptp_unit.buf = 0;
  181. dev_done = dev_done & ~INT_PTP;                /* clear done, int */
  182. int_req = int_req & ~INT_PTP;
  183. dev_enable = dev_enable | INT_PTP;            /* set enable */
  184. sim_cancel (&ptp_unit);                    /* deactivate unit */
  185. return SCPE_OK;
  186. }
  187.