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_rk.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-29  |  11.8 KB  |  374 lines
  1. /* pdp8_rk.c: RK8E cartridge disk simulator
  2.  
  3.    Copyright (c) 1993, 1994, 1995,
  4.    Robert M Supnik, Digital Equipment Corporation
  5.    Commercial use prohibited
  6. */
  7.  
  8. #include "pdp8_defs.h"
  9.  
  10. /* Constants */
  11.  
  12. #define RK_NUMSC    16                /* sectors/surface */
  13. #define RK_NUMSF    2                /* surfaces/cylinder */
  14. #define RK_NUMCY    203                /* cylinders/drive */
  15. #define RK_NUMWD    256                /* words/sector */
  16. #define RK_SIZE    (RK_NUMCY * RK_NUMSF * RK_NUMSC * RK_NUMWD) /* words/drive */
  17. #define RK_NUMDR    4                /* drives/controller */
  18. #define RK_M_NUMDR    03
  19.  
  20. /* Flags in the unit flags word */
  21.  
  22. #define UNIT_V_ONLINE    (UNIT_V_UF)            /* present */
  23. #define UNIT_V_HWLK    (UNIT_V_UF + 1)            /* hwre write lock */
  24. #define UNIT_V_SWLK    (UNIT_V_UF + 2)            /* swre write lock */
  25. #define UNIT_W_UF    3                /* user flags width */
  26. #define UNIT_ONLINE    (1 << UNIT_V_ONLINE)
  27. #define UNIT_HWLK    (1 << UNIT_V_HWLK)
  28. #define UNIT_SWLK    (1 << UNIT_V_SWLK)
  29.  
  30. /* Parameters in the unit descriptor */
  31.  
  32. #define CYL        u3                /* current cylinder */
  33. #define FUNC        u4                /* function */
  34.  
  35. /* Status register */
  36.  
  37. #define RKS_DONE    04000                /* transfer done */
  38. #define RKS_HMOV    02000                /* heads moving */
  39. #define RKS_SKFL    00400                /* drive seek fail */
  40. #define RKS_NRDY    00200                /* drive not ready */
  41. #define RKS_BUSY    00100                /* control busy error */
  42. #define RKS_TMO        00040                /* timeout error */
  43. #define RKS_WLK        00020                /* write lock error */
  44. #define RKS_CRC        00010                /* CRC error */
  45. #define RKS_DLT        00004                /* data late error */
  46. #define RKS_STAT    00002                /* drive status error */
  47. #define RKS_CYL        00001                /* cyl address error */
  48. #define RKS_ERR    (RKS_BUSY+RKS_TMO+RKS_WLK+RKS_CRC+RKS_DLT+RKS_STAT+RKS_CYL)
  49.  
  50. /* Command register */
  51.  
  52. #define RKC_M_FUNC    07                /* function */
  53. #define  RKC_READ    0
  54. #define     RKC_RALL    1
  55. #define  RKC_WLK    2
  56. #define  RKC_SEEK    3
  57. #define  RKC_WRITE    4
  58. #define  RKC_WALL    5
  59. #define RKC_V_FUNC    9
  60. #define RKC_IE        00400                /* interrupt enable */
  61. #define RKC_SKDN    00200                /* int on seek done */
  62. #define RKC_HALF    00100                /* 128W sector */
  63. #define RKC_MEX        00070                /* memory extension */
  64. #define RKC_V_MEX    3
  65. #define RKC_M_DRV    03                /* drive select */
  66. #define RKC_V_DRV    1
  67. #define RKC_CYHI    00001                /* high cylinder addr */
  68.  
  69. #define GET_FUNC(x)    (((x) >> RKC_V_FUNC) & RKC_M_FUNC)
  70. #define GET_DRIVE(x)    (((x) >> RKC_V_DRV) & RKC_M_DRV)
  71. #define GET_MEX(x)    (((x) & RKC_MEX) << (12 - RKC_V_MEX))
  72.  
  73. /* Disk address */
  74.  
  75. #define RKD_V_SECT    0                /* sector */
  76. #define RKD_M_SECT    017
  77. #define RKD_V_SUR    4                /* surface */
  78. #define RKD_M_SUR    01
  79. #define RKD_V_CYL    5                /* cylinder */
  80. #define RKD_M_CYL    0177
  81. #define GET_CYL(x,y)    ((((x) & RKC_CYHI) << (12-RKD_V_CYL)) | \
  82.              (((y) >> RKD_V_CYL) & RKD_M_CYL))
  83. #define GET_DA(x,y)    ((((x) & RKC_CYHI) << 12) | y)
  84.  
  85. /* Reset commands */
  86.  
  87. #define RKX_CLS        0                /* clear status */
  88. #define RKX_CLC        1                /* clear control */
  89. #define RKX_CLD        2                /* clear drive */
  90. #define RKX_CLSA    3                /* clear status alt */
  91.  
  92. #define RK_INT_UPDATE \
  93.     if (((rk_sta & (RKS_DONE + RKS_ERR)) != 0) && \
  94.         ((rk_cmd & RKC_IE) != 0)) int_req = int_req | INT_RK; \
  95.     else int_req = int_req & ~INT_RK
  96. #define RK_MIN 10
  97. #define MAX(x,y) (((x) > (y))? (x): (y))
  98.  
  99. extern int int_req, stop_inst;
  100. extern unsigned short M[];
  101. extern UNIT cpu_unit;
  102. int rk_busy = 0;                    /* controller busy */
  103. int rk_sta = 0;                        /* status register */
  104. int rk_cmd = 0;                        /* command register */
  105. int rk_da = 0;                        /* disk address */
  106. int rk_ma = 0;                        /* memory address */
  107. int rk_swait = 10, rk_rwait = 10;            /* seek, rotate wait */
  108. int rk_stopioe = 1;                    /* stop on error */
  109. int rk_svc (UNIT *uptr);
  110. int rk_reset (DEVICE *dptr);
  111. int rk_boot (int unitno);
  112. void rk_go (int function, int cylinder);
  113. extern int sim_activate (UNIT *uptr, int interval);
  114. extern int sim_cancel (UNIT *uptr);
  115. extern int sim_is_active (UNIT *uptr);
  116.  
  117. /* RK-8E data structures
  118.  
  119.    rk_dev    RK device descriptor
  120.    rk_unit    RK unit list
  121.    rk_reg    RK register list
  122.    rk_mod    RK modifiers list
  123. */
  124.  
  125. UNIT rk_unit[] = {
  126.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  127.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  128.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) },
  129.     { UDATA (&rk_svc, UNIT_FIX+UNIT_ATTABLE+UNIT_ONLINE, RK_SIZE) } };
  130.  
  131. REG rk_reg[] = {
  132.     { ORDATA (STA, rk_sta, 12) },
  133.     { ORDATA (CMD, rk_cmd, 12) },
  134.     { ORDATA (DA, rk_da, 12) },
  135.     { ORDATA (MA, rk_ma, 12) },
  136.     { FLDATA (BUSY, rk_busy, 0) },
  137.     { FLDATA (INT, int_req, INT_V_RK) },
  138.     { DRDATA (STIME, rk_swait, 24), PV_LEFT },
  139.     { DRDATA (RTIME, rk_rwait, 24), PV_LEFT },
  140.     { GRDATA (FLG0, rk_unit[0].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_HRO },
  141.     { GRDATA (FLG1, rk_unit[1].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_HRO },
  142.     { GRDATA (FLG2, rk_unit[2].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_HRO },
  143.     { GRDATA (FLG3, rk_unit[3].flags, 8, UNIT_W_UF, UNIT_V_UF), REG_HRO },
  144.     { FLDATA (STOP_IOE, rk_stopioe, 0) },
  145.     { NULL }  };
  146.  
  147. MTAB rk_mod[] = {
  148.     { UNIT_ONLINE, 0, "offline", "OFFLINE", NULL },
  149.     { UNIT_ONLINE, UNIT_ONLINE, "online", "ONLINE", NULL },
  150.     { (UNIT_HWLK+UNIT_SWLK), 0, "write enabled", "ENABLED", NULL },
  151.     { (UNIT_HWLK+UNIT_SWLK), UNIT_HWLK, "write locked", "LOCKED", NULL },
  152.     { (UNIT_HWLK+UNIT_SWLK), UNIT_SWLK, "write locked", NULL, NULL },
  153.     { (UNIT_HWLK+UNIT_SWLK), (UNIT_HWLK+UNIT_SWLK), "write locked",
  154.         NULL, NULL }, 
  155.     { 0 }  };
  156.  
  157. DEVICE rk_dev = {
  158.     "RK", rk_unit, rk_reg, rk_mod,
  159.     RK_NUMDR, 8, 24, 1, 8, 12,
  160.     NULL, NULL, &rk_reset,
  161.     &rk_boot, NULL, NULL };
  162.  
  163. /* IOT routine */
  164.  
  165. int rk (int pulse, int AC)
  166. {
  167. int i;
  168. UNIT *uptr;
  169.  
  170. switch (pulse) {                    /* decode IR<9:11> */
  171. case 0:                            /* unused */
  172.     return (stop_inst << IOT_V_REASON) + AC;
  173. case 1:                            /* DSKP */
  174.     return (rk_sta & (RKS_DONE + RKS_ERR))?    /* skip on done, err */
  175.         IOT_SKP + AC: AC;
  176. case 2:                            /* DCLR */
  177.     rk_sta = 0;                    /* clear status */
  178.     switch (AC & 03) {                /* decode AC<10:11> */
  179.     case RKX_CLS:                    /* clear status */
  180.         if (rk_busy != 0) rk_sta = rk_sta | RKS_BUSY;
  181.     case RKX_CLSA:                    /* clear status alt */
  182.         break;
  183.     case RKX_CLC:                    /* clear control */
  184.         rk_cmd = rk_busy = 0;            /* clear registers */
  185.         rk_ma = rk_da = 0;
  186.         for (i = 0; i < RK_NUMDR; i++) sim_cancel (&rk_unit[i]);
  187.         break;
  188.     case RKX_CLD:                    /* reset drive */
  189.         if (rk_busy != 0) rk_sta = rk_sta | RKS_BUSY;
  190.         else rk_go (RKC_SEEK, 0);        /* seek to 0 */
  191.         break;  }                /* end switch AC */
  192.     break;
  193. case 3:                            /* DLAG */
  194.     if (rk_busy != 0) rk_sta = rk_sta | RKS_BUSY;
  195.     else {    rk_da = AC;                /* load disk addr */
  196.         rk_go (GET_FUNC (rk_cmd), GET_CYL (rk_cmd, rk_da));  }
  197.     break;
  198. case 4:                            /* DLCA */
  199.     if (rk_busy != 0) rk_sta = rk_sta | RKS_BUSY;
  200.     else rk_ma = AC;                /* load curr addr */
  201.     break;
  202. case 5:                            /* DRST */
  203.     uptr = rk_dev.units + GET_DRIVE (rk_cmd);    /* selected unit */
  204.     rk_sta = rk_sta & ~(RKS_HMOV + RKS_NRDY);    /* clear dynamic */
  205.     if ((uptr -> flags & UNIT_ATT) == 0) rk_sta = rk_sta | RKS_NRDY;
  206.     if (sim_is_active (uptr)) rk_sta = rk_sta | RKS_HMOV;
  207.     return rk_sta;
  208. case 6:                            /* DLDC */
  209.     if (rk_busy != 0) rk_sta = rk_sta | RKS_BUSY;
  210.     else {    rk_cmd = AC;                /* load command */
  211.         rk_sta = 0;  }                /* clear status */
  212.     break;
  213. case 7:                            /* DMAN */
  214.     break;  }                    /* end case pulse */
  215. RK_INT_UPDATE;                        /* update int req */
  216. return 0;                        /* clear AC */
  217. }
  218.  
  219. /* Initiate new function
  220.  
  221.    Called with function, cylinder, to allow recalibrate as well as
  222.    load and go to be processed by this routine.
  223.  
  224.    Assumes that the controller is idle, and that updating of interrupt
  225.    request will be done by the caller.
  226. */
  227.  
  228. void rk_go (int func, int cyl)
  229. {
  230. int t;
  231. UNIT *uptr;
  232.  
  233. if (func == RKC_RALL) func = RKC_READ;            /* all? use standard */
  234. if (func == RKC_WALL) func = RKC_WRITE;
  235. uptr = rk_dev.units + GET_DRIVE (rk_cmd);        /* selected unit */
  236. if (((uptr -> flags & UNIT_ONLINE) == 0) ||        /* not present or */
  237.     ((uptr -> flags & UNIT_ATT) == 0)) {        /* not attached? */
  238.     rk_sta = rk_sta | RKS_DONE | RKS_NRDY | RKS_STAT;
  239.     return;  }
  240. if (sim_is_active (uptr) || (cyl >= RK_NUMCY)) {    /* busy or bad cyl? */
  241.     rk_sta = rk_sta | RKS_DONE | RKS_STAT;
  242.     return;  }
  243. if ((func == RKC_WRITE) && (uptr -> flags & (UNIT_HWLK + UNIT_SWLK))) {
  244.     rk_sta = rk_sta | RKS_DONE | RKS_WLK;        /* write and locked? */
  245.     return;  }
  246. if (func == RKC_WLK) {                    /* write lock? */
  247.     uptr -> flags = uptr -> flags | UNIT_SWLK;
  248.     rk_sta = rk_sta | RKS_DONE;
  249.     return;  }
  250. t = abs (cyl - uptr -> CYL) * rk_swait;            /* seek time */
  251. if (func == RKC_SEEK) {                    /* seek? */
  252.     sim_activate (uptr, MAX (RK_MIN, t));        /* schedule */
  253.     rk_sta = rk_sta | RKS_DONE;  }            /* set done */
  254. else {    sim_activate (uptr, t + rk_rwait);        /* schedule */
  255.     rk_busy = 1;  }                    /* set busy */
  256. uptr -> FUNC = func;                    /* save func */
  257. uptr -> CYL = cyl;                    /* put on cylinder */
  258. return;
  259. }
  260.  
  261. /* Unit service
  262.  
  263.    If seek, complete seek command
  264.    Else complete data transfer command
  265.  
  266.    The unit control block contains the function and cylinder address for
  267.    the current command.
  268.  
  269.    Note that memory addresses wrap around in the current field.
  270. */
  271.  
  272. static unsigned short fill[RK_NUMWD/2] = { 0 };
  273. int rk_svc (UNIT *uptr)
  274. {
  275. int err, wc, wc1, awc, swc, pa, da;
  276. UNIT *seluptr;
  277.  
  278. if (uptr -> FUNC == RKC_SEEK) {                /* seek? */
  279.     seluptr = rk_dev.units + GET_DRIVE (rk_cmd);    /* see if selected */
  280.     if ((uptr == seluptr) && ((rk_cmd & RKC_SKDN) != 0)) {
  281.         rk_sta = rk_sta | RKS_DONE;
  282.         RK_INT_UPDATE;  }
  283.     return SCPE_OK;  }
  284.  
  285. if ((uptr -> flags & UNIT_ATT) == 0) {            /* not att? abort */
  286.     rk_sta = rk_sta | RKS_DONE | RKS_NRDY | RKS_STAT;
  287.     rk_busy = 0;
  288.     RK_INT_UPDATE;
  289.     return IORETURN (rk_stopioe, SCPE_UNATT);  }
  290.  
  291. pa = GET_MEX (rk_cmd) | rk_ma;                /* phys address */
  292. da = GET_DA (rk_cmd, rk_da) * RK_NUMWD * sizeof (short);/* disk address */
  293. swc = wc = (rk_cmd & RKC_HALF)? RK_NUMWD / 2: RK_NUMWD;    /* get transfer size */
  294. if ((wc1 = ((rk_ma + wc) - 010000)) > 0) wc = wc - wc1; /* if wrap, limit */
  295. err = fseek (uptr -> fileref, da, SEEK_SET);        /* locate sector */
  296.  
  297. if ((uptr -> FUNC == RKC_READ) && (err == 0) && MEM_ADDR_OK (pa)) { /* read? */
  298.     awc = fread (&M[pa], sizeof (short), wc, uptr -> fileref);
  299.     for ( ; awc < wc; awc++) M[pa + awc] = 0;     /* fill if eof */
  300.     err = ferror (uptr -> fileref);
  301.     if ((wc1 > 0) && (err == 0))  {            /* field wraparound? */
  302.         pa = pa & 070000;            /* wrap phys addr */
  303.         awc = fread (&M[pa], sizeof (short), wc1, uptr -> fileref);
  304.         for ( ; awc < wc1; awc++) M[pa + awc] = 0; /* fill if eof */
  305.         err = ferror (uptr -> fileref);  }  }
  306.  
  307. if ((uptr -> FUNC == RKC_WRITE) && (err == 0)) {    /* write? */
  308.     fwrite (&M[pa], sizeof (short), wc, uptr -> fileref);
  309.     err = ferror (uptr -> fileref);
  310.     if ((wc1 > 0) && (err == 0)) {            /* field wraparound? */
  311.         pa = pa & 070000;            /* wrap phys addr */
  312.         fwrite (&M[pa], sizeof (short), wc1, uptr -> fileref);
  313.         err = ferror (uptr -> fileref);  }
  314.     if ((rk_cmd & RKC_HALF) && (err == 0)) {    /* fill half sector */
  315.         fwrite (fill, sizeof (short), RK_NUMWD/2, uptr -> fileref);
  316.         err = ferror (uptr -> fileref);  }  }
  317.  
  318. rk_ma = (rk_ma + swc) & 07777;                /* incr mem addr reg */
  319. rk_sta = rk_sta | RKS_DONE;                /* set done */
  320. rk_busy = 0;
  321. RK_INT_UPDATE;
  322.  
  323. if (err != 0) {
  324.     perror ("RK I/O error");
  325.     clearerr (uptr -> fileref);
  326.     return SCPE_IOERR;  }
  327. return SCPE_OK;
  328. }
  329.  
  330. /* Reset routine */
  331.  
  332. int rk_reset (DEVICE *dptr)
  333. {
  334. int i;
  335. UNIT *uptr;
  336.  
  337. rk_cmd = rk_ma = rk_da = rk_sta = rk_busy = 0;
  338. int_req = int_req & ~INT_RK;                /* clear interrupt */
  339. for (i = 0; i < RK_NUMDR; i++) {            /* stop all units */
  340.     uptr = rk_dev.units + i;
  341.     sim_cancel (uptr);
  342.     uptr -> flags = uptr -> flags & ~UNIT_SWLK;
  343.     uptr -> CYL = uptr -> FUNC = 0;  }
  344. return SCPE_OK;
  345. }
  346.  
  347. /* Bootstrap routine */
  348.  
  349. #define BOOT_START 023
  350. #define BOOT_UNIT 032
  351. #define BOOT_LEN (sizeof (boot_rom) / sizeof (int))
  352.  
  353. static const int boot_rom[] = {
  354.     06007,            /* 23, CAF */
  355.     06744,            /* 24, DLCA        ; addr = 0 */
  356.     01032,            /* 25, TAD UNIT        ; unit no */
  357.     06746,            /* 26, DLDC        ; command, unit */
  358.     06743,            /* 27, DLAG        ; disk addr, go */
  359.     01032,            /* 30, TAD UNIT        ; unit no, for OS */
  360.     05031,            /* 31, JMP . */
  361.     00000            /* UNIT, 0         ; in bits <9:10> */
  362. };
  363.  
  364. int rk_boot (int unitno)
  365. {
  366. int i;
  367. extern int saved_PC;
  368.  
  369. for (i = 0; i < BOOT_LEN; i++) M[BOOT_START + i] = boot_rom[i];
  370. M[BOOT_UNIT] = (unitno & RK_M_NUMDR) << 1;
  371. saved_PC = BOOT_START;
  372. return SCPE_OK;
  373. }
  374.