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_rx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-29  |  13.4 KB  |  403 lines
  1. /* pdp11_rx.c: RX11/RX01 floppy disk simulator
  2.  
  3.    Copyright (c) 1993, 1994, 1995, 1996,
  4.    Robert M Supnik, Digital Equipment Corporation
  5.    Commercial use prohibited
  6.  
  7.    rx        RX11 disk controller
  8.  
  9.    An RX01 diskette consists of 77 tracks, each with 26 sectors of 128B.
  10.    Tracks are numbered 0-76, sectors 1-26.
  11. */
  12.  
  13. #include "pdp11_defs.h"
  14.  
  15. #define RX_NUMTR    77                /* tracks/disk */
  16. #define RX_M_TRACK    0377
  17. #define RX_NUMSC    26                /* sectors/track */
  18. #define RX_M_SECTOR    0377
  19. #define RX_NUMBY    128                /* bytes/sector */
  20. #define RX_SIZE        (RX_NUMTR * RX_NUMSC * RX_NUMBY)    /* bytes/disk */
  21. #define RX_NUMDR    2                /* drives/controller */
  22. #define RX_M_NUMDR    01
  23. #define UNIT_V_WLK    (UNIT_V_UF)            /* write locked */
  24. #define UNIT_WLK    (1u << UNIT_V_UF)
  25.  
  26. #define IDLE        0                /* idle state */
  27. #define RWDS        1                /* rw, sect next */
  28. #define RWDT        2                /* rw, track next */
  29. #define FILL        3                /* fill buffer */
  30. #define EMPTY        4                /* empty buffer */
  31. #define CMD_COMPLETE    5                /* set done next */
  32. #define INIT_COMPLETE    6                /* init compl next */
  33.  
  34. #define RXCS_V_FUNC    1                /* function */
  35. #define RXCS_M_FUNC    7
  36. #define  RXCS_FILL    0                /* fill buffer */
  37. #define  RXCS_EMPTY    1                /* empty buffer */
  38. #define  RXCS_WRITE    2                /* write sector */
  39. #define  RXCS_READ    3                /* read sector */
  40. #define  RXCS_RXES    5                /* read status */
  41. #define  RXCS_WRDEL    6                /* write del data */
  42. #define  RXCS_ECODE    7                /* read error code */
  43. #define RXCS_V_DRV    4                /* drive select */
  44. #define RXCS_V_DONE    5                /* done */
  45. #define RXCS_V_TR    7                /* xfer request */
  46. #define RXCS_V_INIT    14                /* init */
  47. #define RXCS_FUNC    (RXCS_M_FUNC << RXCS_V_FUNC)
  48. #define RXCS_DRV    (1u << RXCS_V_DRV)
  49. #define RXCS_DONE    (1u << RXCS_V_DONE)
  50. #define RXCS_TR        (1u << RXCS_V_TR)
  51. #define RXCS_INIT    (1u << RXCS_V_INIT)
  52. #define RXCS_ROUT    (CSR_ERR+RXCS_TR+CSR_IE+RXCS_DONE)
  53. #define RXCS_IMP    (RXCS_ROUT+RXCS_DRV+RXCS_FUNC)
  54. #define RXCS_RW        (CSR_IE)            /* read/write */
  55.  
  56. #define RXES_CRC    0001                /* CRC error */
  57. #define RXES_PAR    0002                /* parity error */
  58. #define RXES_ID        0004                /* init done */
  59. #define RXES_WLK    0010                /* write protect */
  60. #define RXES_DD        0100                /* deleted data */
  61. #define RXES_DRDY    0200                /* drive ready */
  62.  
  63. #define TRACK u3                    /* current track */
  64. #define CALC_DA(t,s) (((t) * RX_NUMSC) + ((s) - 1)) * RX_NUMBY
  65.  
  66. extern int int_req;
  67. int rx_csr = 0;                        /* control/status */
  68. int rx_dbr = 0;                        /* data buffer */
  69. int rx_esr = 0;                        /* error status */
  70. int rx_ecode = 0;                    /* error code */
  71. int rx_track = 0;                    /* desired track */
  72. int rx_sector = 0;                    /* desired sector */
  73. int rx_state = IDLE;                    /* controller state */
  74. int rx_stopioe = 1;                    /* stop on error */
  75. int rx_cwait = 100;                    /* command time */
  76. int rx_swait = 10;                    /* seek, per track */
  77. int rx_xwait = 1;                    /* tr set time */
  78. unsigned char buf[RX_NUMBY] = { 0 };            /* sector buffer */
  79. int bptr = 0;                        /* buffer pointer */
  80. int rx_svc (UNIT *uptr);
  81. int rx_reset (DEVICE *dptr);
  82. int rx_boot (int unitno);
  83. extern int sim_activate (UNIT *uptr, int interval);
  84. extern int sim_cancel (UNIT *uptr);
  85.  
  86. /* RX11 data structures
  87.  
  88.    rx_dev    RX device descriptor
  89.    rx_unit    RX unit list
  90.    rx_reg    RX register list
  91.    rx_mod    RX modifier list
  92. */
  93.  
  94. UNIT rx_unit[] = {
  95.     { UDATA (&rx_svc,
  96.       UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, RX_SIZE) },
  97.     { UDATA (&rx_svc,
  98.       UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, RX_SIZE) } };
  99.  
  100. REG rx_reg[] = {
  101.     { ORDATA (RXCS, rx_csr, 16) },
  102.     { ORDATA (RXDB, rx_dbr, 8) },
  103.     { ORDATA (RXES, rx_esr, 8) },
  104.     { ORDATA (RXERR, rx_ecode, 8) },
  105.     { ORDATA (RXTA, rx_track, 8) },
  106.     { ORDATA (RXSA, rx_sector, 8) },
  107.     { ORDATA (STAPTR, rx_state, 3), REG_RO },
  108.     { ORDATA (BUFPTR, bptr, 7)  },
  109.     { FLDATA (INT, int_req, INT_V_RX) },
  110.     { FLDATA (ERR, rx_csr, CSR_V_ERR) },
  111.     { FLDATA (TR, rx_csr, RXCS_V_TR) },
  112.     { FLDATA (IE, rx_csr, CSR_V_IE) },
  113.     { FLDATA (DONE, rx_csr, RXCS_V_DONE) },
  114.     { DRDATA (CTIME, rx_cwait, 24), PV_LEFT },
  115.     { DRDATA (STIME, rx_swait, 24), PV_LEFT },
  116.     { DRDATA (XTIME, rx_xwait, 24), PV_LEFT },
  117.     { FLDATA (FLG0, rx_unit[0].flags, UNIT_V_WLK), REG_HRO },
  118.     { FLDATA (FLG1, rx_unit[1].flags, UNIT_V_WLK), REG_HRO },
  119.     { FLDATA (STOP_IOE, rx_stopioe, 0) },
  120.     { BRDATA (**BUF, buf, 8, 8, RX_NUMBY), REG_HRO },
  121.     { NULL }  };
  122.  
  123. MTAB rx_mod[] = {
  124.     { UNIT_WLK, 0, "write enabled", "ENABLED", NULL },
  125.     { UNIT_WLK, UNIT_WLK, "write locked", "LOCKED", NULL },
  126.     { 0 }  };
  127.  
  128. DEVICE rx_dev = {
  129.     "RX", rx_unit, rx_reg, rx_mod,
  130.     RX_NUMDR, 8, 20, 1, 8, 8,
  131.     NULL, NULL, &rx_reset,
  132.     &rx_boot, NULL, NULL };
  133.  
  134. /* I/O dispatch routine, I/O addresses 17777170 - 17777172
  135.  
  136.    17777170        floppy CSR
  137.    17777172        floppy data register
  138. */
  139.  
  140. int rx_rd (int *data, int PA, int access)
  141. {
  142. switch ((PA >> 1) & 1) {                /* decode PA<1> */
  143. case 0:                            /* RXCS */
  144.     rx_csr = rx_csr & RXCS_IMP;            /* clear junk */
  145.     *data = rx_csr & RXCS_ROUT;
  146.     return SCPE_OK;
  147. case 1:                            /* RXDB */
  148.     if (rx_state == EMPTY) {            /* empty? */
  149.         sim_activate (&rx_unit[0], rx_xwait);
  150.         rx_csr = rx_csr & ~RXCS_TR;  }        /* clear xfer */
  151.     *data = rx_dbr;                    /* return data */
  152.     return SCPE_OK;  }                /* end switch PA */
  153. }                            /* end rx_rd */
  154.  
  155. int rx_wr (int data, int PA, int access)
  156. {
  157. int drv;
  158.  
  159. switch ((PA >> 1) & 1) {                /* decode PA<1> */
  160.  
  161. /* Writing RXCS, three cases:
  162.    1. Writing INIT, reset device
  163.    2. Idle and writing new function
  164.     - clear error, done, transfer ready, int req
  165.     - save int enable, function, drive
  166.     - start new function
  167.    3. Otherwise, write IE and update interrupts
  168. */
  169.  
  170. case 0:                            /* RXCS */
  171.     rx_csr = rx_csr & RXCS_IMP;            /* clear junk */
  172.     if (access == WRITEB) data = (PA & 1)?        /* write byte? */
  173.         (rx_csr & 0377) | (data << 8): (rx_csr & ~0377) | data;
  174.     if (data & RXCS_INIT) {                /* initialize? */
  175.         rx_reset (&rx_dev);            /* reset device */
  176.         return SCPE_OK;  }            /* end if init */
  177.     if ((data & CSR_GO) && (rx_state == IDLE)) {    /* new function? */
  178.         rx_csr = data & (CSR_IE + RXCS_DRV + RXCS_FUNC);
  179.         bptr = 0;                /* clear buf pointer */
  180.         switch ((data >> RXCS_V_FUNC) & RXCS_M_FUNC) {
  181.         case RXCS_FILL:
  182.             rx_state = FILL;        /* state = fill */
  183.             rx_csr = rx_csr | RXCS_TR;    /* xfer is ready */
  184.             break;
  185.         case RXCS_EMPTY:
  186.             rx_state = EMPTY;        /* state = empty */
  187.             sim_activate (&rx_unit[0], rx_xwait);
  188.             break;
  189.         case RXCS_READ: case RXCS_WRITE: case RXCS_WRDEL:
  190.             rx_state = RWDS;        /* state = get sector */
  191.             rx_csr = rx_csr | RXCS_TR;    /* xfer is ready */
  192.             rx_esr = rx_esr & RXES_ID;    /* clear errors */
  193.             break;
  194.         default:
  195.             rx_state = CMD_COMPLETE;    /* state = cmd compl */
  196.             drv = (data & RXCS_DRV) > 0;    /* get drive number */
  197.             sim_activate (&rx_unit[drv], rx_cwait);
  198.             break;  }            /* end switch func */
  199.         return SCPE_OK;  }            /* end if GO */
  200.     if ((data & CSR_IE) == 0) int_req = int_req & ~INT_RX;
  201.     else if ((rx_csr & (RXCS_DONE + CSR_IE)) == RXCS_DONE)
  202.         int_req = int_req | INT_RX;
  203.     rx_csr = (rx_csr & ~RXCS_RW) | (data & RXCS_RW);
  204.     return SCPE_OK;                    /* end case RXCS */
  205.  
  206. /* Accessing RXDB, two cases:
  207.    1. Write idle, write
  208.    2. Write not idle and TR set, state dependent
  209. */
  210.  
  211. case 1:                            /* RXDB */
  212.     if ((PA & 1) || ((rx_state != IDLE) && ((rx_csr & RXCS_TR) == 0)))
  213.         return SCPE_OK;                /* if ~IDLE, need tr */
  214.     rx_dbr = data & 0377;                /* save data */
  215.     if ((rx_state == FILL) || (rx_state == RWDS)) {    /* fill or sector? */
  216.         sim_activate (&rx_unit[0], rx_xwait);    /* sched event */
  217.         rx_csr = rx_csr & ~RXCS_TR;  }        /* clear xfer */
  218.     if (rx_state == RWDT) {                /* track? */
  219.         drv = (rx_csr & RXCS_DRV) > 0;        /* get drive number */
  220.         sim_activate (&rx_unit[drv],        /* sched done */
  221.             rx_swait * abs (rx_track - rx_unit[drv].TRACK));
  222.         rx_csr = rx_csr & ~RXCS_TR;  }        /* clear xfer */
  223.     return SCPE_OK;                    /* end case RXDB */
  224.     }                        /* end switch PA */
  225. }                            /* end rx_wr */
  226.  
  227. /* Unit service; the action to be taken depends on the transfer state:
  228.  
  229.    IDLE        Should never get here, treat as unknown command
  230.    RWDS        Just transferred sector, wait for track, set tr
  231.    RWDT        Just transferred track, do read or write, finish command
  232.    FILL        copy ir to buf[bptr], advance ptr
  233.         if bptr > max, finish command, else set tr
  234.    EMPTY    if bptr > max, finish command, else
  235.         copy buf[bptr] to ir, advance ptr, set tr
  236.    CMD_COMPLETE    copy requested data to ir, finish command
  237.    INIT_COMPLETE read drive 0, track 1, sector 1 to buffer, finish command
  238.  
  239.    For RWDT and CMD_COMPLETE, the input argument is the selected drive;
  240.    otherwise, it is drive 0.
  241. */
  242.  
  243. int rx_svc (UNIT *uptr)
  244. {
  245. int i, rval, err, func, da;
  246. void rx_done (int new_dbr, int new_ecode);
  247.  
  248. rval = SCPE_OK;                        /* assume ok */
  249. func = (rx_csr >> RXCS_V_FUNC) & RXCS_M_FUNC;        /* get function */
  250. switch (rx_state) {                    /* case on state */
  251. case IDLE:                        /* idle */
  252.     rx_done (rx_esr, 0);                /* done */
  253.     break;
  254. case EMPTY:                        /* empty buffer */
  255.     if (bptr >= RX_NUMBY) rx_done (rx_esr, 0);    /* done all? */
  256.     else {    rx_dbr = buf[bptr];            /* get next */
  257.         bptr = bptr + 1;
  258.         rx_csr = rx_csr | RXCS_TR;  }        /* set xfer */
  259.     break;
  260. case FILL:                        /* fill buffer */
  261.     buf[bptr] = rx_dbr;                /* write next */
  262.     bptr = bptr + 1;
  263.     if (bptr < RX_NUMBY) rx_csr = rx_csr | RXCS_TR;    /* if more, set xfer */
  264.     else rx_done (rx_esr, 0);            /* else done */
  265.     break;
  266. case RWDS:                        /* wait for sector */
  267.     rx_sector = rx_dbr & RX_M_SECTOR;        /* save sector */
  268.     rx_csr = rx_csr | RXCS_TR;            /* set xfer */
  269.     rx_state = RWDT;                /* advance state */
  270.     break;
  271. case RWDT:                        /* wait for track */
  272.     rx_track = rx_dbr & RX_M_TRACK;            /* save track */
  273.     if (rx_track >= RX_NUMTR) {            /* bad track? */
  274.         rx_done (rx_esr, 0040);            /* done, error */
  275.         break;  }
  276.     uptr -> TRACK = rx_track;            /* now on track */
  277.     if ((rx_sector == 0) || (rx_sector > RX_NUMSC)) {    /* bad sect? */
  278.         rx_done (rx_esr, 0070);            /* done, error */
  279.         break;  }
  280.     if ((uptr -> flags & UNIT_BUF) == 0) {        /* not buffered? */
  281.         rx_done (rx_esr, 0070);            /* done, error */
  282.         rval = SCPE_UNATT;            /* return error */
  283.         break;  }
  284.     da = CALC_DA (rx_track, rx_sector);        /* get disk address */
  285.     if (func == RXCS_WRDEL) rx_esr = rx_esr | RXES_DD;    /* del data? */
  286.     if (func == RXCS_READ) {            /* read? */
  287.         for (i = 0; i < RX_NUMBY; i++)
  288.             buf[i] = *(((char *) uptr -> filebuf) + da + i);  }
  289.     else {    if (uptr -> flags & UNIT_WLK) {        /* write and locked? */
  290.             rx_esr = rx_esr | RXES_WLK;    /* flag error */
  291.             rx_done (rx_esr, 0100);        /* done, error */
  292.             break;  }
  293.         for (i = 0; i < RX_NUMBY; i++)        /* write */
  294.             *(((char *) uptr -> filebuf) + da + i) = buf[i];
  295.         da = da + RX_NUMBY;
  296.         if (da > uptr -> hwmark) uptr -> hwmark = da;  }
  297.     rx_done (rx_esr, 0);                /* done */
  298.     break;
  299. case CMD_COMPLETE:                    /* command complete */
  300.     if (func == RXCS_ECODE) rx_done (rx_ecode, 0);
  301.     else if (uptr -> flags & UNIT_ATT) rx_done (rx_esr | RXES_DRDY, 0);
  302.     else rx_done (rx_esr, 0);
  303.     break;
  304. case INIT_COMPLETE:                    /* init complete */
  305.     rx_unit[0].TRACK = 1;                /* drive 0 to trk 1 */
  306.     rx_unit[1].TRACK = 0;                /* drive 1 to trk 0 */
  307.     if ((rx_unit[0].flags & UNIT_BUF) == 0) {    /* not buffered? */
  308.         rx_done (rx_esr | RXES_ID, 0010);    /* init done, error */
  309.         break;    }
  310.     da = CALC_DA (1, 1);                /* track 1, sector 1 */
  311.     for (i = 0; i < RX_NUMBY; i++)            /* read sector */
  312.         buf[i] = *(((char *) uptr -> filebuf) + da + i);
  313.     rx_done (rx_esr | RXES_ID | RXES_DRDY, 0);    /* set done */
  314.     if ((rx_unit[1].flags & UNIT_ATT) == 0) rx_ecode = 0020;
  315.     break;  }                    /* end case state */
  316. return IORETURN (rx_stopioe, rval);
  317. }                            /* end rx_svc */
  318.  
  319. /* Command complete.  Set done and put final value in interface register,
  320.    request interrupt if needed, return to IDLE state.
  321. */
  322.  
  323. void rx_done (int new_dbr, int new_ecode)
  324. {
  325. rx_csr = rx_csr | RXCS_DONE;                /* set done */
  326. if (rx_csr & CSR_IE) int_req = int_req | INT_RX;    /* if ie, intr */
  327. rx_dbr = new_dbr;                    /* update RXDB */
  328. if (new_ecode != 0) {                    /* test for error */
  329.     rx_ecode = new_ecode;
  330.     rx_csr = rx_csr | CSR_ERR;  }
  331. rx_state = IDLE;                    /* now idle */
  332. return;
  333. }
  334.  
  335. /* Device initialization.  The RX is one of the few devices that schedules
  336.    an I/O transfer as part of its initialization.
  337. */
  338.  
  339. int rx_reset (DEVICE *dptr)
  340. {
  341. int i;
  342.  
  343. rx_csr = rx_dbr = 0;                    /* clear regs */
  344. rx_esr = rx_ecode = 0;                    /* clear error */
  345. rx_state = INIT_COMPLETE;                /* set state */
  346. int_req = int_req & ~INT_RX;                /* clear int req */
  347. sim_cancel (&rx_unit[1]);                /* cancel drive 1 */
  348. sim_activate (&rx_unit[0],                /* start drive 0 */
  349.     rx_swait * abs (1 - rx_unit[0].TRACK));
  350. return SCPE_OK;
  351. }
  352.  
  353. /* Device bootstrap */
  354.  
  355. #define BOOT_START 02000
  356. #define BOOT_UNIT 02006
  357. #define BOOT_LEN (sizeof (boot_rom) / sizeof (int))
  358.  
  359. static const int boot_rom[] = {
  360.     0012706, 0002000,        /* MOV #2000, SP */
  361.     0012700, 0000000,        /* MOV #unit, R0    ; unit number */
  362.     0010003,            /* MOV R0, R3 */
  363.     0006303,            /* ASL R3 */
  364.     0006303,            /* ASL R3 */
  365.     0006303,            /* ASL R3 */
  366.     0006303,            /* ASL R3 */
  367.     0012701, 0177170,        /* MOV #RXCS, R1    ; csr */
  368.     0105711,            /* TSTB (R1)        ; ready? */
  369.     0001376,            /* BEQ .-2 */
  370.     0052703, 0000007,        /* BIS #READ+GO, R3 */
  371.     0010311,            /* MOV R3, (R1)        ; read & go */
  372.     0105711,            /* TSTB (R1)        ; xfr ready? */
  373.     0001376,            /* BEQ .-2 */
  374.     0012761, 0000001, 0000002,    /* MOV #1, 2(R1)    ; sector */
  375.     0105711,            /* TSTB (R1)        ; xfr ready? */
  376.     0001376,            /* BEQ .-2 */
  377.     0012761, 0000001, 0000002,    /* MOV #1, 2(R1)    ; track */
  378.     0005003,            /* CLR R3 */
  379.     0012711, 0000003,        /* MOV #EMPTY+GO, (R1)    ; empty & go */
  380.     0105711,            /* TSTB (R1)        ; xfr, done? */
  381.     0001376,            /* BEQ .-2 */
  382.     0100003,            /* BPL .+010 */
  383.     0116123, 0000002,        /* MOVB 2(R1), (R3)+    ; move byte */
  384.     0000772,            /* BR .-012 */
  385.     0005002,            /* CLR R2 */
  386.     0005003,            /* CLR R3 */
  387.     0005004,            /* CLR R4 */
  388.     0012705, 0062170,        /* MOV #"DX, R5 */
  389.     0005007                /* CLR R7 */
  390. };
  391.  
  392. int rx_boot (int unitno)
  393. {
  394. int i;
  395. extern int saved_PC;
  396. extern unsigned short M[];
  397.  
  398. for (i = 0; i < BOOT_LEN; i++) M[(BOOT_START >> 1) + i] = boot_rom[i];
  399. M[BOOT_UNIT >> 1] = unitno & RX_M_NUMDR;
  400. saved_PC = BOOT_START;
  401. return SCPE_OK;
  402. }
  403.