home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Boot_Images / 2.11_on_rl02 / pdpsim.tz / pdpsim / pdp11_rk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-29  |  18.2 KB  |  565 lines
  1. /* RK11 cartridge disk simulator
  2.  
  3.    Copyright (c) 1993, 1994, 1996, Robert M Supnik,
  4.    Digital Equipment Corporation
  5.    Commercial use prohibited
  6.  
  7.    The RK11 is an eight drive cartridge disk subsystem.  An RK05 drive
  8.    consists of 203 cylinders, each with 2 surfaces containing 12 sectors
  9.    of 512 bytes.
  10.  
  11.    The most complicated part of the RK11 controller is the concept of
  12.    interrupt "polling".  While only one read or write can occur at a
  13.    time, the controller supports multiple seeks.  When a seek completes,
  14.    if done is set the drive attempts to interrupt.  If an interrupt is
  15.    already pending, the interrupt is "queued" until it can be processed.
  16.    When an interrupt occurs, RKDS<15:13> is loaded with the number of the
  17.    interrupting drive.
  18.  
  19.    To implement this structure, and to assure that read/write interrupts
  20.    take priority over seek interrupts, the controller contains an
  21.    interrupt queue, rkintq, with a bit for a controller interrupt and
  22.    then one for each drive.  In addition, the drive number of the last
  23.    non-seeking drive is recorded in last_drv.
  24. */
  25.  
  26. #include "pdp11_defs.h"
  27.  
  28. /* Constants */
  29.  
  30. #define RK_NUMWD    256                /* words/sector */
  31. #define RK_NUMSC    12                /* sectors/surface */
  32. #define RK_NUMSF    2                /* surfaces/cylinder */
  33. #define RK_NUMCY    203                /* cylinders/drive */
  34. #define RK_NUMTR    (RK_NUMCY * RK_NUMSF)        /* tracks/drive */
  35. #define RK_NUMDR    8                /* drives/controller */
  36. #define RK_M_NUMDR    07
  37. #define RK_SIZE (RK_NUMCY * RK_NUMSF * RK_NUMSC * RK_NUMWD)  /* words/drive */
  38. #define RK_MAXMEM    (MEMSIZE / sizeof (short))    /* words/memory */
  39. #define RK_CTLI        1                /* controller int */
  40. #define RK_SCPI(x)    (2u << (x))            /* drive int */
  41.  
  42. /* Flags in the unit flags word */
  43.  
  44. #define UNIT_V_ONLINE    (UNIT_V_UF)            /* present */
  45. #define UNIT_V_HWLK    (UNIT_V_UF + 1)            /* hwre write lock */
  46. #define UNIT_V_SWLK    (UNIT_V_UF + 2)            /* swre write lock */
  47. #define UNIT_W_UF    3                /* user flags width */
  48. #define UNIT_ONLINE    (1u << UNIT_V_ONLINE)
  49. #define UNIT_HWLK    (1u << UNIT_V_HWLK)
  50. #define UNIT_SWLK    (1u << UNIT_V_SWLK)
  51.  
  52. /* Parameters in the unit descriptor */
  53.  
  54. #define CYL        u3                /* current cylinder */
  55. #define FUNC        u4                /* function */
  56.  
  57. /* RKDS */
  58.  
  59. #define RKDS_SC        0000017                /* sector counter */
  60. #define RKDS_ON_SC    0000020                /* on sector */
  61. #define RKDS_WLK    0000040                /* write locked */
  62. #define RKDS_RWS    0000100                /* rd/wr/seek ready */
  63. #define RKDS_RDY    0000200                /* drive ready */
  64. #define RKDS_SC_OK    0000400                /* SC valid */
  65. #define RKDS_INC    0001000                /* seek incomplete */
  66. #define RKDS_UNSAFE    0002000                /* unsafe */
  67. #define RKDS_RK05    0004000                /* RK05 */
  68. #define RKDS_PWR    0010000                /* power low */
  69. #define RKDS_ID        0160000                /* drive ID */
  70. #define RKDS_V_ID    13
  71.  
  72. /* RKER */
  73.  
  74. #define RKER_WCE    0000001                /* write check */
  75. #define RKER_CSE    0000002                /* checksum */
  76. #define RKER_NXS    0000040                /* nx sector */
  77. #define RKER_NXC    0000100                /* nx cylinder */
  78. #define RKER_NXD    0000200                /* nx drive */
  79. #define RKER_TE        0000400                /* timing error */
  80. #define RKER_DLT    0001000                /* data late */
  81. #define RKER_NXM    0002000                /* nx memory */
  82. #define RKER_PGE    0004000                /* programming error */
  83. #define RKER_SKE    0010000                /* seek error */
  84. #define RKER_WLK    0020000                /* write lock */
  85. #define RKER_OVR    0040000                /* overrun */
  86. #define RKER_DRE    0100000                /* drive error */
  87. #define RKER_IMP    0177743                /* implemented */
  88. #define RKER_SOFT    (RKER_WCE+RKER_CSE)        /* soft errors */
  89. #define RKER_HARD    0177740                /* hard errors */
  90.  
  91. /* RKCS */
  92.  
  93. #define RKCS_M_FUNC    0000007                /* function */
  94. #define  RKCS_CTLRESET    0
  95. #define  RKCS_WRITE    1
  96. #define  RKCS_READ    2
  97. #define  RKCS_WCHK    3
  98. #define  RKCS_SEEK    4
  99. #define     RKCS_RCHK    5
  100. #define  RKCS_DRVRESET    6
  101. #define  RKCS_WLK    7
  102. #define RKCS_V_FUNC    1
  103. #define RKCS_MEX    0000060                /* memory extension */
  104. #define RKCS_V_MEX    4
  105. #define RKCS_SSE    0000400                /* stop on soft err */
  106. #define RKCS_FMT    0002000                /* format */
  107. #define RKCS_INH    0004000                /* inhibit increment */
  108. #define RKCS_SCP    0020000                /* search complete */
  109. #define RKCS_HERR    0040000                /* hard error */
  110. #define RKCS_ERR    0100000                /* error */
  111. #define RKCS_REAL    0026776                /* kept here */
  112. #define RKCS_RW        0006576                /* read/write */
  113. #define GET_FUNC(x)    (((x) >> RKCS_V_FUNC) & RKCS_M_FUNC)
  114.  
  115. /* RKDA */
  116.  
  117. #define RKDA_V_SECT    0                /* sector */
  118. #define RKDA_M_SECT    017
  119. #define RKDA_V_TRACK    4                /* track */
  120. #define RKDA_M_TRACK    0777
  121. #define RKDA_V_CYL    5                /* cylinder */
  122. #define RKDA_M_CYL    0377
  123. #define RKDA_V_DRIVE    13                /* drive */
  124. #define RKDA_M_DRIVE    07
  125. #define RKDA_DRIVE    (RKDA_M_DRIVE << RKDA_V_DRIVE)
  126. #define GET_SECT(x)    (((x) >> RKDA_V_SECT) & RKDA_M_SECT)
  127. #define GET_CYL(x)    (((x) >> RKDA_V_CYL) & RKDA_M_CYL)
  128. #define GET_TRACK(x)    (((x) >> RKDA_V_TRACK) & RKDA_M_TRACK)
  129. #define GET_DRIVE(x)    (((x) >> RKDA_V_DRIVE) & RKDA_M_DRIVE)
  130. #define GET_DA(x)    ((GET_TRACK (x) * RK_NUMSC) + GET_SECT (x))
  131.  
  132. /* RKBA */
  133.  
  134. #define RKBA_IMP    0177776                /* implemented */
  135.  
  136. #define RK_MIN 10
  137. #define MAX(x,y) (((x) > (y))? (x): (y))
  138.  
  139. extern int int_req;
  140. extern unsigned short M[];                /* memory */
  141. int rkcs = 0;                        /* control/status */
  142. int rkds = 0;                        /* drive status */
  143. int rkba = 0;                        /* memory address */
  144. int rkda = 0;                        /* disk address */
  145. int rker = 0;                        /* error status */
  146. int rkwc = 0;                        /* word count */
  147. int rkintq = 0;                        /* interrupt queue */
  148. int last_drv = 0;                    /* last r/w drive */
  149. int rk_stopioe = 1;                    /* stop on error */
  150. int rk_swait = 10;                    /* seek time */
  151. int rk_rwait = 10;                    /* rotate time */
  152. int rk_svc (UNIT *uptr);
  153. int rk_reset (DEVICE *dptr);
  154. void rk_go (void);
  155. void rk_set_done (int error);
  156. void rk_clr_done (void);
  157. int rk_boot (int unitno);
  158. extern int sim_activate (UNIT *uptr, int interval);
  159. extern int sim_cancel (UNIT *uptr);
  160. extern int sim_is_active (UNIT *uptr);
  161.  
  162. /* RK11 data structures
  163.  
  164.    rk_dev    RK device descriptor
  165.    rk_unit    RK unit list
  166.    rk_reg    RK register list
  167.    rk_mod    RK modifier list
  168. */
  169.  
  170. UNIT rk_unit[] = {
  171.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  172.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  173.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  174.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  175.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  176.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  177.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  178.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) } };
  179.  
  180. REG rk_reg[] = {
  181.     { ORDATA (RKCS, rkcs, 16) },
  182.     { ORDATA (RKDA, rkda, 16) },
  183.     { ORDATA (RKBA, rkba, 16) },
  184.     { ORDATA (RKWC, rkwc, 16) },
  185.     { ORDATA (RKDS, rkds, 16) },
  186.     { ORDATA (RKER, rker, 16) },
  187.     { ORDATA (INTQ, rkintq, 9) },
  188.     { ORDATA (DRVN, last_drv, 3) },
  189.     { FLDATA (INT, int_req, INT_V_RK) },
  190.     { FLDATA (ERR, rkcs, CSR_V_ERR) },
  191.     { FLDATA (DONE, rkcs, CSR_V_DONE) },
  192.     { FLDATA (IE, rkcs, CSR_V_IE) },
  193.     { DRDATA (STIME, rk_swait, 24), PV_LEFT },
  194.     { DRDATA (RTIME, rk_rwait, 24), PV_LEFT },
  195.     { GRDATA (FLG0, rk_unit[0].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  196.     { GRDATA (FLG1, rk_unit[1].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  197.     { GRDATA (FLG2, rk_unit[2].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  198.     { GRDATA (FLG3, rk_unit[3].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  199.     { GRDATA (FLG4, rk_unit[4].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  200.     { GRDATA (FLG5, rk_unit[5].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  201.     { GRDATA (FLG6, rk_unit[6].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  202.     { GRDATA (FLG7, rk_unit[7].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_RO },
  203.     { FLDATA (STOP_IOE, rk_stopioe, 0) },
  204.     { NULL }  };
  205.  
  206. MTAB rk_mod[] = {
  207.     { UNIT_ONLINE, 0, "offline", "OFFLINE", NULL },
  208.     { UNIT_ONLINE, UNIT_ONLINE, "online", "ONLINE", NULL },
  209.     { (UNIT_HWLK+UNIT_SWLK), 0, "write enabled", "ENABLED", NULL },
  210.     { (UNIT_HWLK+UNIT_SWLK), UNIT_HWLK, "write locked", "LOCKED", NULL },
  211.     { (UNIT_HWLK+UNIT_SWLK), UNIT_SWLK, "write locked", NULL, NULL },
  212.     { (UNIT_HWLK+UNIT_SWLK), (UNIT_HWLK+UNIT_SWLK), "write locked",
  213.         NULL, NULL }, 
  214.     { 0 }  };
  215.  
  216. DEVICE rk_dev = {
  217.     "RK", rk_unit, rk_reg, rk_mod,
  218.     RK_NUMDR, 8, 24, 1, 8, 16,
  219.     NULL, NULL, &rk_reset,
  220.     &rk_boot, NULL, NULL };
  221.  
  222. /* I/O dispatch routine, I/O addresses 17777400 - 17777416
  223.  
  224.    17777400    RKDS    read only, constructed from "id'd drive"
  225.             plus current drive status flags
  226.    17777402    RKER    read only, set as operations progress,
  227.             cleared by INIT or CONTROL RESET
  228.    17777404    RKCS    read/write
  229.    17777406    RKWC    read/write
  230.    17777410    RKBA    read/write
  231.    17777412    RKDA    read/write
  232.    17777414    RKMR    read/write, unimplemented
  233.    17777416    RKDB    read only, unimplemented
  234. */
  235.  
  236. int rk_rd (int *data, int PA, int access)
  237. {
  238. UNIT *uptr;
  239.  
  240. switch ((PA >> 1) & 07) {                /* decode PA<3:1> */
  241. case 0:                            /* RKDS: read only */
  242.     rkds = (rkds & RKDS_ID) | RKDS_RK05 | RKDS_SC_OK |
  243.         (rand () % RK_NUMSC);            /* random sector */
  244.     uptr = rk_dev.units + GET_DRIVE (rkda);        /* selected unit */
  245.     if (uptr -> flags & UNIT_ATT) rkds = rkds | RKDS_RDY;    /* attached? */
  246.     if (!sim_is_active (uptr)) rkds = rkds | RKDS_RWS;    /* idle? */
  247.     if (uptr -> flags & (UNIT_HWLK + UNIT_SWLK)) rkds = rkds | RKDS_WLK;
  248.     if (GET_SECT (rkda) == (rkds & RKDS_SC)) rkds = rkds | RKDS_ON_SC;
  249.     *data = rkds;
  250.     return SCPE_OK;
  251. case 1:                            /* RKER: read only */
  252.     *data = rker & RKER_IMP;
  253.     return SCPE_OK;
  254. case 2:                            /* RKCS */
  255.     rkcs = rkcs & RKCS_REAL;
  256.     if (rker) rkcs = rkcs | RKCS_ERR;        /* update err flags */
  257.     if (rker & RKER_HARD) rkcs = rkcs | RKCS_HERR;
  258.     *data = rkcs;
  259.     return SCPE_OK;
  260. case 3:                            /* RKWC */
  261.     *data = rkwc;
  262.     return SCPE_OK;
  263. case 4:                            /* RKBA */
  264.     *data = rkba & RKBA_IMP;
  265.     return SCPE_OK;
  266. case 5:                            /* RKDA */
  267.     *data = rkda;
  268.     return SCPE_OK;
  269. default:
  270.     *data = 0;
  271.     return SCPE_OK;  }                /* end switch */
  272. }                            /* end rk_rd */
  273.  
  274. int rk_wr (int data, int PA, int access)
  275. {
  276. int i, t;
  277. UNIT *uptr;
  278.  
  279. switch ((PA >> 1) & 07) {                /* decode PA<3:1> */
  280. case 0:                            /* RKDS: read only */
  281.     return SCPE_OK;
  282. case 1:                            /* RKER: read only */
  283.     return SCPE_OK;
  284. case 2:                            /* RKCS */
  285.     rkcs = rkcs & RKCS_REAL;
  286.     if (access == WRITEB) data = (PA & 1)?
  287.         (rkcs & 0377) | (data << 8): (rkcs & ~0377) | data;
  288.     if ((data & CSR_IE) == 0) {            /* int disable? */
  289.         rkintq = 0;                /* clr int queue */
  290.         int_req = int_req & ~INT_RK;  }        /* clr int request */
  291.     else if ((rkcs & (CSR_DONE + CSR_IE)) == CSR_DONE) {
  292.         rkintq = rkintq | RK_CTLI;        /* queue ctrl int */
  293.         int_req = int_req | INT_RK;  }        /* set int request */
  294.     rkcs = (rkcs & ~RKCS_RW) | (data & RKCS_RW);
  295.     if ((rkcs & CSR_DONE) && (data & CSR_GO)) rk_go (); /* new function? */
  296.     return SCPE_OK;
  297. case 3:                            /* RKWC */
  298.     if (access == WRITEB) data = (PA & 1)?
  299.         (rkwc & 0377) | (data << 8): (rkwc & ~0377) | data;
  300.     rkwc = data;
  301.     return SCPE_OK;
  302. case 4:                            /* RKBA */
  303.     if (access == WRITEB) data = (PA & 1)?
  304.         (rkba & 0377) | (data << 8): (rkba & ~0377) | data;
  305.     rkba = data & RKBA_IMP;
  306.     return SCPE_OK;
  307. case 5:                            /* RKDA */
  308.     if ((rkcs & CSR_DONE) == 0) return SCPE_OK;
  309.     if (access == WRITEB) data = (PA & 1)?
  310.         (rkda & 0377) | (data << 8): (rkda & ~0377) | data;
  311.     rkda = data;
  312.     return SCPE_OK;
  313. default:
  314.     return SCPE_OK;  }                /* end switch */
  315. }                            /* end rk_wr */
  316.  
  317. /* Initiate new function */
  318.  
  319. void rk_go (void)
  320. {
  321. int i, sect, cyl, func;
  322. UNIT *uptr;
  323.  
  324. func = GET_FUNC (rkcs);                    /* get function */
  325. if (func == RKCS_CTLRESET) {                /* control reset? */
  326.     rker = 0;                    /* clear errors */
  327.     rkda = 0;
  328.     rkba = 0;
  329.     rkcs = CSR_DONE;
  330.     rkintq = 0;                    /* clr int queue */
  331.     int_req = int_req & ~INT_RK;            /* clr int request */
  332.     return;  }
  333. rker = rker & ~RKER_SOFT;                /* clear soft errors */
  334. if (rker == 0) rkcs = rkcs & ~RKCS_ERR;            /* redo summary */
  335. rkcs = rkcs & ~RKCS_SCP;                /* clear sch compl*/
  336. rk_clr_done ();                        /* clear done */
  337. last_drv = GET_DRIVE (rkda);                /* get drive no */
  338. uptr = rk_dev.units + last_drv;                /* select unit */
  339. if ((uptr -> flags & UNIT_ONLINE) == 0) {        /* not present? */
  340.     rk_set_done (RKER_NXD);
  341.     return;  }
  342. if (((uptr -> flags & UNIT_ATT) == 0) || sim_is_active (uptr)) {
  343.     rk_set_done (RKER_DRE);                /* not att or busy */
  344.     return;  }
  345. if (rkcs & (RKCS_INH + RKCS_FMT)) {            /* format? */
  346.     rk_set_done (RKER_PGE);
  347.     return;  }
  348. if ((func == RKCS_WRITE) && (uptr -> flags & (UNIT_HWLK + UNIT_SWLK))) {
  349.     rk_set_done (RKER_WLK);                /* write and locked? */
  350.     return;  }
  351. if (func == RKCS_WLK) {                    /* write lock? */
  352.     uptr -> flags = uptr -> flags | UNIT_SWLK;
  353.     rk_set_done (0);
  354.     return;  }
  355. if (func == RKCS_DRVRESET) {                /* drive reset? */
  356.     uptr -> flags = uptr -> flags & ~UNIT_SWLK;
  357.     cyl = sect = 0;
  358.     func = RKCS_SEEK;  }
  359. else {    sect = GET_SECT (rkda);
  360.     cyl = GET_CYL (rkda);  }
  361. if (sect >= RK_NUMSC) {                    /* bad sector? */
  362.     rk_set_done (RKER_NXS);
  363.     return;  }
  364. if (cyl >= RK_NUMCY) {                    /* bad cyl? */
  365.     rk_set_done (RKER_NXC);
  366.     return;  }
  367. i = abs (cyl - uptr -> CYL) * rk_swait;            /* seek time */
  368. if (func == RKCS_SEEK) {                /* seek? */
  369.     rk_set_done (0);                /* set done */
  370.     sim_activate (uptr, MAX (RK_MIN, i));  }    /* schedule */
  371. else sim_activate (uptr, i + rk_rwait);
  372. uptr -> FUNC = func;                    /* save func */
  373. uptr -> CYL = cyl;                    /* put on cylinder */
  374. return;
  375. }
  376.  
  377. /* Service unit timeout
  378.  
  379.    If seek in progress, complete seek command
  380.    Else complete data transfer command
  381.  
  382.    The unit control block contains the function and disk address for
  383.    the current command.
  384. */
  385.  
  386. static unsigned short fill[RK_NUMWD] = { 0 };
  387. int rk_svc (UNIT *uptr)
  388. {
  389. int comp, drv, err, awc, twc, wc;
  390. int pa, da, fillc, track, sect;
  391.  
  392. drv = uptr - rk_dev.units;                /* get drv number */
  393. if (uptr -> FUNC == RKCS_SEEK) {            /* seek */
  394.     rkcs = rkcs | RKCS_SCP;                /* set seek done */
  395.     if (rkcs & CSR_IE) {                /* ints enabled? */
  396.         rkintq = rkintq | RK_SCPI (drv);    /* queue request */
  397.         if (rkcs & CSR_DONE) int_req = int_req | INT_RK;  }
  398.     else {    rkintq = 0;                /* clear queue */
  399.         int_req = int_req & ~INT_RK;  }        /* clear interrupt */
  400.     return SCPE_OK;  }
  401.  
  402. if ((uptr -> flags & UNIT_ATT) == 0) {            /* attached? */
  403.     rk_set_done (RKER_DRE);
  404.     return IORETURN (rk_stopioe, SCPE_UNATT);  }
  405. pa = (((rkcs & RKCS_MEX) << (16 - RKCS_V_MEX)) | rkba) >> 1;
  406. da = GET_DA (rkda) * RK_NUMWD;                /* get disk addr */
  407. twc = 0200000 - rkwc;                    /* get true wc */
  408. if ((pa + twc) > RK_MAXMEM) {                /* mem overrun? */
  409.     rker = rker | RKER_NXM;
  410.     wc = (RK_MAXMEM - pa);  }
  411. else wc = twc;
  412. if (wc < 0) {                        /* abort transfer? */
  413.     rk_set_done (0);
  414.     return SCPE_OK;  }
  415. if ((da + twc) > RK_SIZE) {                /* disk overrun? */
  416.     rker = rker | RKER_OVR;
  417.     if (wc > (RK_SIZE - da)) wc = RK_SIZE - da;  }
  418.  
  419. err = fseek (uptr -> fileref, da * sizeof (short), SEEK_SET);
  420.  
  421. if ((uptr -> FUNC == RKCS_READ) && (err == 0)) {    /* read? */
  422.     awc = fread (&M[pa], sizeof (short), wc, uptr -> fileref);
  423.     for ( ; awc < wc; awc++) M[pa + awc] = 0;
  424.     err = ferror (uptr -> fileref);  }
  425.  
  426. if ((uptr -> FUNC == RKCS_WRITE) && (err == 0)) {    /* write? */
  427.     fwrite (&M[pa], sizeof (short), wc, uptr -> fileref);
  428.     err = ferror (uptr -> fileref);
  429.     if ((err == 0) && (fillc = (wc & (RK_NUMWD - 1)))) {
  430.         fwrite (fill, sizeof (short), fillc, uptr -> fileref);
  431.         err = ferror (uptr -> fileref);  }  }
  432.  
  433. if ((uptr -> FUNC == RKCS_WCHK) && (err == 0)) {    /* write check? */
  434.     twc = wc;                    /* xfer length */
  435.     for (wc = 0; (err == 0) && (wc < twc); wc++)  {
  436.         awc = fread (&comp, sizeof (short), 1, uptr -> fileref);
  437.         if (awc == 0) comp = 0;
  438.         if (comp != M[pa + wc])  {
  439.             rker = rker | RKER_WCE;
  440.             if (rkcs & RKCS_SSE) break;  }  }
  441.     err = ferror (uptr -> fileref);  }
  442.  
  443. rkwc = (rkwc + wc) & 0177777;                /* final word count */
  444. pa = (pa + wc) << 1;                    /* final byte addr */
  445. rkba = pa & RKBA_IMP;                    /* lower 16b */
  446. rkcs = (rkcs & ~RKCS_MEX) | ((pa >> (16 - RKCS_V_MEX)) & RKCS_MEX);
  447. da = da + wc + (RK_NUMWD - 1);
  448. track = (da / RK_NUMWD) / RK_NUMSC;
  449. sect = (da / RK_NUMWD) % RK_NUMSC;
  450. rkda = (rkda & RKDA_DRIVE) | (track << RKDA_V_TRACK) | (sect << RKDA_V_SECT);
  451. rk_set_done (0);
  452.  
  453. if (err != 0) {                        /* error? */
  454.     perror ("RK I/O error");
  455.     clearerr (uptr -> fileref);
  456.     return SCPE_IOERR;  }
  457. return SCPE_OK;
  458. }
  459.  
  460. /* Interrupt state change routines
  461.  
  462.    rk_set_done        set done and possibly errors
  463.    rk_clr_done        clear done
  464.    rk_inta        acknowledge intererupt
  465. */
  466.  
  467. void rk_set_done (int error)
  468. {
  469.     rkcs = rkcs | CSR_DONE;                /* set done */
  470.     if (error != 0) {
  471.         rker = rker | error;            /* update error */
  472.         if (rker) rkcs = rkcs | RKCS_ERR;    /* update err flags */
  473.         if (rker & RKER_HARD) rkcs = rkcs | RKCS_HERR;  }
  474.     if (rkcs & CSR_IE) {                /* int enable? */
  475.         rkintq = rkintq | RK_CTLI;        /* set ctrl int */
  476.         int_req = int_req | INT_RK;  }        /* request int */
  477.     else {    rkintq = 0;                /* clear queue */
  478.         int_req = int_req & ~INT_RK;  }
  479.     return;
  480. }
  481.  
  482. void rk_clr_done (void)
  483. {
  484.     rkcs = rkcs & ~CSR_DONE;            /* clear done */
  485.     rkintq = rkintq & ~RK_CTLI;            /* clear ctl int */
  486.     int_req = int_req & ~INT_RK;            /* clear int req */
  487.     return;
  488. }
  489.  
  490. int rk_inta (void)
  491. {
  492. int i;
  493.  
  494. for (i = 0; i <= RK_NUMDR; i++) {            /* loop thru intq */
  495.     if (rkintq & (1u << i)) {            /* bit i set? */
  496.         rkintq = rkintq & ~(1u << i);        /* clear bit i */
  497.         if (rkintq) int_req = int_req | INT_RK;    /* queue next */
  498.         rkds = (rkds & ~RKDS_ID) |        /* id drive */
  499.             (((i == 0)? last_drv: i - 1) << RKDS_V_ID);
  500.         return VEC_RK;  }  }            /* return vector */
  501. rkintq = 0;                        /* clear queue */
  502. return 0;                        /* passive release */
  503. }
  504.  
  505. /* Device reset */
  506.  
  507. int rk_reset (DEVICE *dptr)
  508. {
  509. int i;
  510. UNIT *uptr;
  511.  
  512. rkcs = CSR_DONE;
  513. rkda = rkba = rker = rkds = 0;
  514. rkintq = last_drv = 0;
  515. int_req = int_req & ~INT_RK;
  516. for (i = 0; i < RK_NUMDR; i++) {
  517.     uptr = rk_dev.units + i;
  518.     sim_cancel (uptr);
  519.     uptr -> CYL = uptr -> FUNC = 0;
  520.     uptr -> flags = uptr -> flags & ~UNIT_SWLK;  }
  521. return SCPE_OK;
  522. }
  523.  
  524. /* Device bootstrap */
  525.  
  526. #define BOOT_START 02000        /* start */
  527. #define BOOT_UNIT 02006            /* where to store unit number */
  528. #define BOOT_LEN (sizeof (boot_rom) / sizeof (int))
  529.  
  530. static const int boot_rom[] = {
  531.     0012706, 0002000,        /* MOV #2000, SP */
  532.     0012700, 0000000,        /* MOV #unit, R0    ; unit number */
  533.     0010003,            /* MOV R0, R3 */
  534.     0000303,            /* SWAB R3 */
  535.     0006303,            /* ASL R3 */
  536.     0006303,            /* ASL R3 */
  537.     0006303,            /* ASL R3 */
  538.     0006303,            /* ASL R3 */
  539.     0006303,            /* ASL R3 */
  540.     0012701, 0177412,        /* MOV #RKDA, R1    ; csr */
  541.     0010311,            /* MOV R3, (R1)        ; load da */
  542.     0005041,            /* CLR -(R1)        ; clear ba */
  543.     0012741, 0177000,        /* MOV #-256.*2, -(R1)    ; load wc */
  544.     0012741, 0000005,        /* MOV #READ+GO, -(R1)    ; read & go */
  545.     0005002,            /* CLR R2 */
  546.     0005003,            /* CLR R3 */
  547.     0005004,            /* CLR R4 */
  548.     0012705, 0062153,        /* MOV #"DK, R5 */
  549.     0105711,            /* TSTB (R1) */
  550.     0100376,            /* BPL .-2 */
  551.     0105011,            /* CLRB (R1) */
  552.     0005007                /* CLR PC */
  553. };
  554.  
  555. int rk_boot (int unitno)
  556. {
  557. int i;
  558. extern int saved_PC;
  559.  
  560. for (i = 0; i < BOOT_LEN; i++) M[(BOOT_START >> 1) + i] = boot_rom[i];
  561. M[BOOT_UNIT >> 1] = unitno & RK_M_NUMDR;
  562. saved_PC = BOOT_START;
  563. return SCPE_OK;
  564. }
  565.