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_rx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-29  |  13.7 KB  |  416 lines
  1. /* pdp8_rx.c: RX8E/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        RX8E 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.  The RX8E can store data in
  11.    8b mode or 12b mode.  In 8b mode, the controller reads or writes
  12.    128 bytes per sector.  In 12b mode, the reads or writes 64 12b words
  13.    per sector.  The 12b words are bit packed into the first 96 bytes
  14.    of the sector; the last 32 bytes are zeroed on writes.
  15. */
  16.  
  17. #include "pdp8_defs.h"
  18.  
  19. #define RX_NUMTR    77                /* tracks/disk */
  20. #define RX_M_TRACK    0377
  21. #define RX_NUMSC    26                /* sectors/track */
  22. #define RX_M_SECTOR    0377
  23. #define RX_NUMBY    128                /* bytes/sector */
  24. #define RX_NUMWD    (RX_NUMBY / 2)            /* words/sector */
  25. #define RX_SIZE        (RX_NUMTR * RX_NUMSC * RX_NUMBY)    /* bytes/disk */
  26. #define RX_NUMDR    2                /* drives/controller */
  27. #define RX_M_NUMDR    01
  28. #define UNIT_V_WLK    (UNIT_V_UF)            /* write locked */
  29. #define UNIT_WLK    (1 << UNIT_V_UF)
  30.  
  31. #define IDLE        0                /* idle state */
  32. #define RWDS        1                /* rw, sect next */
  33. #define RWDT        2                /* rw, track next */
  34. #define FILL        3                /* fill buffer */
  35. #define EMPTY        4                /* empty buffer */
  36. #define CMD_COMPLETE    5                /* set done next */
  37. #define INIT_COMPLETE    6                /* init compl next */
  38.  
  39. #define RXCS_V_FUNC    1                /* function */
  40. #define RXCS_M_FUNC    7
  41. #define  RXCS_FILL    0                /* fill buffer */
  42. #define  RXCS_EMPTY    1                /* empty buffer */
  43. #define  RXCS_WRITE    2                /* write sector */
  44. #define  RXCS_READ    3                /* read sector */
  45. #define  RXCS_RXES    5                /* read status */
  46. #define  RXCS_WRDEL    6                /* write del data */
  47. #define  RXCS_ECODE    7                /* read error code */
  48. #define RXCS_DRV    0020                /* drive */
  49. #define RXCS_MODE    0100                /* mode */
  50. #define RXCS_MAINT    0200                /* maintenance */
  51.  
  52. #define RXES_CRC    0001                /* CRC error */
  53. #define RXES_PAR    0002                /* parity error */
  54. #define RXES_ID        0004                /* init done */
  55. #define RXES_WLK    0010                /* write protect */
  56. #define RXES_DD        0100                /* deleted data */
  57. #define RXES_DRDY    0200                /* drive ready */
  58.  
  59. #define TRACK u3                    /* current track */
  60. #define READ_RXDBR ((rx_csr & RXCS_MODE)? AC | (rx_dbr & 0377): rx_dbr)
  61. #define CALC_DA(t,s) (((t) * RX_NUMSC) + ((s) - 1)) * RX_NUMBY
  62.  
  63. extern int int_req, dev_done, dev_enable;
  64. int rx_tr = 0;                        /* xfer ready flag */
  65. int rx_err = 0;                        /* error flag */
  66. int rx_csr = 0;                        /* control/status */
  67. int rx_dbr = 0;                        /* data buffer */
  68. int rx_esr = 0;                        /* error status */
  69. int rx_ecode = 0;                    /* error code */
  70. int rx_track = 0;                    /* desired track */
  71. int rx_sector = 0;                    /* desired sector */
  72. int rx_state = IDLE;                    /* controller state */
  73. int rx_cwait = 100;                    /* command time */
  74. int rx_swait = 10;                    /* seek, per track */
  75. int rx_xwait = 1;                    /* tr set time */
  76. int rx_stopioe = 1;                    /* stop on error */
  77. unsigned char buf[RX_NUMBY] = { 0 };            /* sector buffer */
  78. int bufptr = 0;                        /* buffer pointer */
  79. int rx_svc (UNIT *uptr);
  80. int rx_reset (DEVICE *dptr);
  81. int rx_boot (int unitno);
  82. extern int sim_activate (UNIT *uptr, int interval);
  83. extern int sim_cancel (UNIT *uptr);
  84.  
  85. /* RX8E data structures
  86.  
  87.    rx_dev    RX device descriptor
  88.    rx_unit    RX unit list
  89.    rx_reg    RX register list
  90.    rx_mod    RX modifier list
  91. */
  92.  
  93. UNIT rx_unit[] = {
  94.     { UDATA (&rx_svc,
  95.       UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, RX_SIZE) },
  96.     { UDATA (&rx_svc,
  97.       UNIT_FIX+UNIT_ATTABLE+UNIT_BUFABLE+UNIT_MUSTBUF, RX_SIZE) }  };
  98.  
  99. REG rx_reg[] = {
  100.     { ORDATA (RXCS, rx_csr, 12) },
  101.     { ORDATA (RXDB, rx_dbr, 12) },
  102.     { ORDATA (RXES, rx_esr, 8) },
  103.     { ORDATA (RXERR, rx_ecode, 8) },
  104.     { ORDATA (RXTA, rx_track, 8) },
  105.     { ORDATA (RXSA, rx_sector, 8) },
  106.     { ORDATA (STAPTR, rx_state, 3), REG_RO },
  107.     { ORDATA (BUFPTR, bufptr, 7)  },
  108.     { FLDATA (TR, rx_tr, 0) },
  109.     { FLDATA (ERR, rx_err, 0) },
  110.     { FLDATA (DONE, dev_done, INT_V_RX) },
  111.     { FLDATA (ENABLE, dev_enable, INT_V_RX) },
  112.     { FLDATA (INT, int_req, INT_V_RX) },
  113.     { DRDATA (CTIME, rx_cwait, 24), PV_LEFT },
  114.     { DRDATA (STIME, rx_swait, 24), PV_LEFT },
  115.     { DRDATA (XTIME, rx_xwait, 24), PV_LEFT },
  116.     { FLDATA (FLG0, rx_unit[0].flags, UNIT_V_WLK), REG_HRO },
  117.     { FLDATA (FLG1, rx_unit[1].flags, UNIT_V_WLK), REG_HRO },
  118.     { FLDATA (STOP_IOE, rx_stopioe, 0) },
  119.     { BRDATA (*BUF, buf, 8, 8, RX_NUMBY), REG_HRO },
  120.     { NULL }  };
  121.  
  122. MTAB rx_mod[] = {
  123.     { UNIT_WLK, 0, "write enabled", "ENABLED", NULL },
  124.     { UNIT_WLK, UNIT_WLK, "write locked", "LOCKED", NULL },
  125.     { 0 }  };
  126.  
  127. DEVICE rx_dev = {
  128.     "RX", rx_unit, rx_reg, rx_mod,
  129.     RX_NUMDR, 8, 20, 1, 8, 8,
  130.     NULL, NULL, &rx_reset,
  131.     &rx_boot, NULL, NULL };
  132.  
  133. /* IOT routine */
  134.  
  135. int rx (int pulse, int AC)
  136. {
  137. int drv, i, rval;
  138. UNIT *uptr;
  139.  
  140. switch (pulse) {                    /* decode IR<9:11> */
  141. case 0:                            /* unused */
  142.     return AC;
  143. case 1:                            /* LCD */
  144.     if (rx_state != IDLE) return AC;        /* ignore if busy */
  145.     rx_dbr = rx_csr = AC;                /* save new command */
  146.     dev_done = dev_done & ~INT_RX;            /* clear done, int */
  147.     int_req = int_req & ~INT_RX;
  148.     rx_tr = rx_err = 0;                /* clear flags */
  149.     bufptr = 0;                    /* clear buf pointer */
  150.     switch ((AC >> RXCS_V_FUNC) & RXCS_M_FUNC) {    /* decode command */
  151.     case RXCS_FILL:
  152.         rx_state = FILL;            /* state = fill */
  153.         rx_tr = 1;                /* xfer is ready */
  154.         break;
  155.     case RXCS_EMPTY:
  156.         rx_state = EMPTY;            /* state = empty */
  157.         sim_activate (&rx_unit[0], rx_xwait);    /* sched xfer */
  158.         break;
  159.     case RXCS_READ: case RXCS_WRITE: case RXCS_WRDEL:
  160.         rx_state = RWDS;            /* state = get sector */
  161.         rx_tr = 1;                /* xfer is ready */
  162.         rx_esr = rx_esr & RXES_ID;        /* clear errors */
  163.         break;
  164.     default:
  165.         rx_state = CMD_COMPLETE;        /* state = cmd compl */
  166.         drv = (rx_csr & RXCS_DRV) > 0;        /* get drive number */
  167.         sim_activate (&rx_unit[drv], rx_cwait);    /* sched done */
  168.         break;  }                /* end switch func */
  169.     return AC;
  170. case 2:                            /* XDR */
  171.     switch (rx_state & 07) {            /* case on state */
  172.     default:                    /* default */
  173.         return READ_RXDBR;            /* return data reg */
  174.     case EMPTY:                    /* emptying buffer */
  175.         sim_activate (&rx_unit[0], rx_xwait);    /* sched xfer */
  176.         return READ_RXDBR;            /* return data reg */
  177.     case RWDS:                    /* sector */
  178.         rx_sector = AC & RX_M_SECTOR;        /* save sector */
  179.     case FILL:                    /* fill */
  180.         rx_dbr = AC;                /* save data */
  181.         sim_activate (&rx_unit[0], rx_xwait);    /* sched xfer */
  182.         break;
  183.     case RWDT:                    /* track */
  184.         rx_track = AC & RX_M_TRACK;        /* save track */
  185.         rx_dbr = AC;                /* save data */
  186.         drv = (rx_csr & RXCS_DRV) > 0;        /* get drive number */
  187.         sim_activate (&rx_unit[drv],        /* sched done */
  188.             rx_swait * abs (rx_track - rx_unit[drv].TRACK));
  189.         break;  }                /* end switch state */
  190.     return AC;
  191. case 3:                            /* STR */
  192.     if (rx_tr != 0) {
  193.         rx_tr = 0;
  194.         return IOT_SKP + AC;  }
  195.     return AC;
  196. case 4:                            /* SER */
  197.     if (rx_err != 0) {
  198.         rx_err = 0;
  199.         return IOT_SKP + AC;  }
  200.     return AC;
  201. case 5:                            /* SDN */
  202.     if ((dev_done & INT_RX) != 0) {
  203.         dev_done = dev_done & ~INT_RX;
  204.         int_req = int_req & ~INT_RX;
  205.         return IOT_SKP + AC;  }
  206.     return AC;
  207. case 6:                            /* INTR */
  208.     if (AC & 1) dev_enable = dev_enable | INT_RX;
  209.     else dev_enable = dev_enable & ~INT_RX;
  210.     int_req = INT_UPDATE;
  211.     return AC;
  212. case 7:                            /* INIT */
  213.     rx_reset (&rx_dev);                /* reset device */
  214.     return AC;  }                    /* end case pulse */
  215. }
  216.  
  217. /* Unit service; the action to be taken depends on the transfer state:
  218.  
  219.    IDLE        Should never get here, treat as unknown command
  220.    RWDS        Just transferred sector, wait for track, set tr
  221.    RWDT        Just transferred track, do read or write, finish command
  222.    FILL        copy dbr to buf[bufptr], advance ptr
  223.            if bufptr > max, finish command, else set tr
  224.    EMPTY    if bufptr > max, finish command, else
  225.         copy buf[bufptr] to dbr, advance ptr, set tr
  226.    CMD_COMPLETE    copy requested data to dbr, finish command
  227.    INIT_COMPLETE read drive 0, track 1, sector 1 to buffer, finish command
  228.  
  229.    For RWDT and CMD_COMPLETE, the input argument is the selected drive;
  230.    otherwise, it is drive 0.
  231. */
  232.  
  233. int rx_svc (UNIT *uptr)
  234. {
  235. int i, rval, err, func, byptr, da;
  236. void rx_done (int new_dbr, int new_ecode);
  237. #define PTR12(x) (((x) + (x) + (x)) >> 1)
  238.  
  239. rval = SCPE_OK;                        /* assume ok */
  240. func = (rx_csr >> RXCS_V_FUNC) & RXCS_M_FUNC;        /* get function */
  241. switch (rx_state) {                    /* case on state */
  242. case IDLE:                        /* idle */
  243.     rx_done (rx_esr, 0);                /* done */
  244.     break;
  245. case EMPTY:                        /* empty buffer */
  246.     if (rx_csr & RXCS_MODE) {            /* 8b xfer? */
  247.         if (bufptr >= RX_NUMBY) {        /* done? */
  248.             rx_done (rx_esr, 0);        /* set done */
  249.             break;  }            /* and exit */
  250.         rx_dbr = buf[bufptr];  }        /* else get data */
  251.     else {    byptr = PTR12 (bufptr);            /* 12b xfer */
  252.         if (bufptr >= RX_NUMWD) {        /* done? */
  253.             rx_done (rx_esr, 0);        /* set done */
  254.             break;  }            /* and exit */
  255.         rx_dbr = (bufptr & 1)?            /* get data */
  256.             ((buf[byptr] & 017) << 8) | buf[byptr + 1]:
  257.             (buf[byptr] << 4) | ((buf[byptr + 1] >> 4) & 017);  }
  258.     bufptr = bufptr + 1;
  259.     rx_tr = 1;
  260.     break;
  261. case FILL:                        /* fill buffer */
  262.     if (rx_csr & RXCS_MODE) {            /* 8b xfer? */
  263.         buf[bufptr] = rx_dbr;            /* fill buffer */
  264.         bufptr = bufptr + 1;
  265.         if (bufptr < RX_NUMBY) rx_tr = 1;    /* if more, set xfer */
  266.         else rx_done (rx_esr, 0);  }        /* else done */
  267.     else {     byptr = PTR12 (bufptr);            /* 12b xfer */
  268.         if (bufptr & 1) {            /* odd or even? */
  269.           buf[byptr] = (buf[byptr] & 0360) | ((rx_dbr >> 8) & 017);
  270.           buf[byptr + 1] = rx_dbr & 0377;  }
  271.         else {
  272.           buf[byptr] = (rx_dbr >> 4) & 0377;
  273.           buf[byptr + 1] = (rx_dbr & 017) << 4;  }
  274.         bufptr = bufptr + 1;
  275.         if (bufptr < RX_NUMWD) rx_tr = 1;    /* if more, set xfer */
  276.         else {    for (i = PTR12 (RX_NUMWD); i < RX_NUMBY; i++)
  277.                 buf[i] = 0;        /* else fill sector */
  278.             rx_done (rx_esr, 0);  }  }    /* set done */
  279.     break;
  280. case RWDS:                        /* wait for sector */
  281.     rx_tr = 1;                    /* set xfer ready */
  282.     rx_state = RWDT;                /* advance state */
  283.     break;
  284. case RWDT:                        /* wait for track */
  285.     if (rx_track >= RX_NUMTR) {            /* bad track? */
  286.         rx_done (rx_esr, 0040);            /* done, error */
  287.         break;  }
  288.     uptr -> TRACK = rx_track;            /* now on track */
  289.     if ((rx_sector == 0) || (rx_sector > RX_NUMSC)) {    /* bad sect? */
  290.         rx_done (rx_esr, 0070);            /* done, error */
  291.         break;  }
  292.     if ((uptr -> flags & UNIT_BUF) == 0) {        /* not buffered? */
  293.         rx_done (rx_esr, 0070);            /* done, error */
  294.         rval = SCPE_UNATT;            /* return error */
  295.         break;  }
  296.     da = CALC_DA (rx_track, rx_sector);        /* get disk address */
  297.     if (func == RXCS_WRDEL) rx_esr = rx_esr | RXES_DD;    /* del data? */
  298.     if (func == RXCS_READ) {            /* read? */
  299.         for (i = 0; i < RX_NUMBY; i++)
  300.             buf[i] = *(((char *) uptr -> filebuf) + da + i);  }
  301.     else {    if (uptr -> flags & UNIT_WLK) {        /* write and locked? */
  302.             rx_esr = rx_esr | RXES_WLK;    /* flag error */
  303.             rx_done (rx_esr, 0100);        /* done, error */
  304.             break;  }
  305.         for (i = 0; i < RX_NUMBY; i++)        /* write */
  306.             *(((char *) uptr -> filebuf) + da + i) = buf[i];
  307.         da = da + RX_NUMBY;
  308.         if (da > uptr -> hwmark) uptr -> hwmark = da;  }
  309.     rx_done (rx_esr, 0);                /* done */
  310.     break;
  311. case CMD_COMPLETE:                    /* command complete */
  312.     if (func == RXCS_ECODE) rx_done (rx_ecode, 0);
  313.     else if (uptr -> flags & UNIT_ATT) rx_done (rx_esr | RXES_DRDY, 0);
  314.     else rx_done (rx_esr, 0);
  315.     break;
  316. case INIT_COMPLETE:                    /* init complete */
  317.     rx_unit[0].TRACK = 1;                /* drive 0 to trk 1 */
  318.     rx_unit[1].TRACK = 0;                /* drive 1 to trk 0 */
  319.     if ((rx_unit[0].flags & UNIT_BUF) == 0) {    /* not buffered? */
  320.         rx_done (rx_esr | RXES_ID, 0010);    /* init done, error */
  321.         break;    }
  322.     da = CALC_DA (1, 1);                /* track 1, sector 1 */
  323.     for (i = 0; i < RX_NUMBY; i++)            /* read sector */
  324.         buf[i] = *(((char *) uptr -> filebuf) + da + i);
  325.     rx_done (rx_esr | RXES_ID | RXES_DRDY, 0);    /* set done */
  326.     if ((rx_unit[1].flags & UNIT_ATT) == 0) rx_ecode = 0020;
  327.     break;  }                    /* end case state */
  328. return IORETURN (rx_stopioe, rval);
  329. }
  330.  
  331. /* Command complete.  Set done and put final value in interface register,
  332.    return to IDLE state.
  333. */
  334.  
  335. void rx_done (int new_dbr, int new_ecode)
  336. {
  337. dev_done = dev_done | INT_RX;                /* set done */
  338. int_req = INT_UPDATE;                    /* update ints */
  339. rx_dbr = new_dbr;                    /* update buffer */
  340. if (new_ecode != 0) {                    /* test for error */
  341.     rx_ecode = new_ecode;
  342.     rx_err = 1;  }
  343. rx_state = IDLE;                    /* now idle */
  344. return;
  345. }
  346.  
  347. /* Reset routine.  The RX is one of the few devices that schedules
  348.    an I/O transfer as part of its initialization.
  349. */
  350.  
  351. int rx_reset (DEVICE *dptr)
  352. {
  353. int i;
  354.  
  355. rx_esr = rx_ecode = 0;                    /* clear error */
  356. rx_tr = rx_err = 0;                    /* clear flags */
  357. dev_done = dev_done & ~INT_RX;                /* clear done, int */
  358. int_req = int_req & ~INT_RX;
  359. rx_dbr = rx_csr = 0;                    /* 12b mode, drive 0 */
  360. rx_state = INIT_COMPLETE;                /* set state */
  361. sim_cancel (&rx_unit[1]);                /* cancel drive 1 */
  362. sim_activate (&rx_unit[0],                /* start drive 0 */
  363.     rx_swait * abs (1 - rx_unit[0].TRACK));
  364. return SCPE_OK;
  365. }
  366.  
  367. /* Bootstrap routine */
  368.  
  369. #define BOOT_START 022
  370. #define BOOT_INST 060
  371. #define BOOT_LEN (sizeof (boot_rom) / sizeof (int))
  372.  
  373. static const int boot_rom[] = {
  374.     06705,            /* 22, SDN */
  375.     05020,            /* 23, JMP .-1 */
  376.     07126,            /* 24, CLL CML RTL    ; read command + */
  377.     01060,            /* 25, TAD UNIT        ; unit no */
  378.     06701,            /* 26, LCD        ; load read+unit */
  379.     07201,            /* 27, CLL IAC         ; AC = 1 */
  380.     04053,            /* 30, JMS 053        ; load sector */
  381.     04053,            /* 31, JMS 053        ; load track */
  382.     07104,            /* 32, CLL RAL        ; AC = 2 */
  383.     06705,            /* 33, SDN */
  384.     05054,            /* 34, JMP 54 */
  385.     06704,            /* 35, SER */
  386.     07450,            /* 36, SNA        ; more to do? */
  387.     07610,            /* 37, CLA SKP        ; error */
  388.     05046,            /* 40, JMP 46        ; go empty */
  389.     07402, 07402,        /* 41-45, HALT        ; error */
  390.     07402, 07402, 07402,
  391.     06701,            /* 46, LCD        ; load empty */
  392.     04053,            /* 47, JMS 53        ; get data */
  393.     03002,            /* 50, DCA 2        ; store */
  394.     02050,            /* 51, ISZ 50        ; incr store */
  395.     05047,            /* 52, JMP 47        ; loop until done */
  396.     00000,            /* 53, 0 */
  397.     06703,            /* 54, STR */
  398.     05033,            /* 55, JMP 33 */
  399.     06702,            /* 56, XDR */
  400.     05453,            /* 57, JMP I 53 */
  401.     07024,            /* UNIT, CML RAL    ; for unit 1 */
  402.     06030            /* 61, KCC */
  403. };
  404.  
  405. int rx_boot (int unitno)
  406. {
  407. int i;
  408. extern int saved_PC;
  409. extern unsigned short M[];
  410.  
  411. for (i = 0; i < BOOT_LEN; i++) M[BOOT_START + i] = boot_rom[i];
  412. M[BOOT_INST] = unitno? 07024: 07004;
  413. saved_PC = BOOT_START;
  414. return SCPE_OK;
  415. }
  416.