home *** CD-ROM | disk | FTP | other *** search
/ minnie.tuhs.org / unixen.tar / unixen / PDP-11 / Boot_Images / 2.11_on_rl02 / pdpsim.tz / pdpsim / pdp18b_stddev.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-29  |  13.8 KB  |  551 lines
  1. /* pdp18b_stddev.c: 18b PDP's standard devices
  2.  
  3.    Copyright (c) 1994, Robert M Supnik, Digital Equipment Corporation
  4.    All rights reserved
  5.  
  6.    ptr        paper tape reader
  7.    ptp        paper tape punch
  8.    tti        keyboard
  9.    tto        teleprinter
  10.    clk        clock
  11. */
  12.  
  13. #include "pdp18b_defs.h"
  14.  
  15. extern int int_req, saved_PC;
  16. extern unsigned int M[];
  17. int clk_state = 0;
  18. int ptr_err = 0, ptr_stopioe = 0, ptr_state = 0;
  19. int ptp_err = 0, ptp_stopioe = 0;
  20. int tti_state = 0;
  21. int tto_state = 0;
  22. int clk_svc (UNIT *uptr);
  23. int ptr_svc (UNIT *uptr);
  24. int ptp_svc (UNIT *uptr);
  25. int tti_svc (UNIT *uptr);
  26. int tto_svc (UNIT *uptr);
  27. int clk_reset (DEVICE *dptr);
  28. int ptr_reset (DEVICE *dptr);
  29. int ptp_reset (DEVICE *dptr);
  30. int tti_reset (DEVICE *dptr);
  31. int tto_reset (DEVICE *dptr);
  32. int ptr_attach (UNIT *uptr, char *cptr);
  33. int ptp_attach (UNIT *uptr, char *cptr);
  34. int ptr_detach (UNIT *uptr);
  35. int ptp_detach (UNIT *uptr);
  36. int ptr_boot (int unitno);
  37. extern int sim_activate (UNIT *uptr, int interval);
  38. extern int sim_cancel (UNIT *uptr);
  39. extern int sim_poll_kbd (void);
  40. extern int sim_type_tty (char out);
  41. extern int attach_unit (UNIT *uptr, char *cptr);
  42. extern int detach_unit (UNIT *uptr);
  43.  
  44. /* CLK data structures
  45.  
  46.    clk_dev    CLK device descriptor
  47.    clk_unit    CLK unit
  48.    clk_reg    CLK register list
  49. */
  50.  
  51. UNIT clk_unit = { UDATA (&clk_svc, 0, 0), 5000 };
  52.  
  53. REG clk_reg[] = {
  54.     { FLDATA (INT, int_req, INT_V_CLK) },
  55.     { FLDATA (DONE, int_req, INT_V_CLK) },
  56.     { FLDATA (ENABLE, clk_state, 0) },
  57.     { DRDATA (TIME, clk_unit.wait, 24), REG_NZ + PV_LEFT },
  58.     { NULL }  };
  59.  
  60. DEVICE clk_dev = {
  61.     "CLK", &clk_unit, clk_reg, NULL,
  62.     1, 0, 0, 0, 0, 0,
  63.     NULL, NULL, &clk_reset,
  64.     NULL, NULL, NULL };
  65.  
  66. /* PTR data structures
  67.  
  68.    ptr_dev    PTR device descriptor
  69.    ptr_unit    PTR unit
  70.    ptr_reg    PTR register list
  71. */
  72.  
  73. UNIT ptr_unit = {
  74.     UDATA (&ptr_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_IN_WAIT };
  75.  
  76. REG ptr_reg[] = {
  77.     { ORDATA (BUF, ptr_unit.buf, 18) },
  78.     { FLDATA (INT, int_req, INT_V_PTR) },
  79.     { FLDATA (DONE, int_req, INT_V_PTR) },
  80. #if defined (IOS_PTRERR)
  81.     { FLDATA (ERR, ptr_err, 0) },
  82. #endif
  83.     { ORDATA (BCNT, ptr_state, 5), REG_HRO },
  84.     { DRDATA (POS, ptr_unit.pos, 32), PV_LEFT },
  85.     { DRDATA (TIME, ptr_unit.wait, 24), PV_LEFT },
  86.     { FLDATA (STOP_IOE, ptr_stopioe, 0) },
  87.     { NULL }  };
  88.  
  89. DEVICE ptr_dev = {
  90.     "PTR", &ptr_unit, ptr_reg, NULL,
  91.     1, 10, 32, 1, 8, 8,
  92.     NULL, NULL, &ptr_reset,
  93.     &ptr_boot, &ptr_attach, &ptr_detach };
  94.  
  95. /* PTP data structures
  96.  
  97.    ptp_dev    PTP device descriptor
  98.    ptp_unit    PTP unit
  99.    ptp_reg    PTP register list
  100. */
  101.  
  102. UNIT ptp_unit = {
  103.     UDATA (&ptp_svc, UNIT_SEQ+UNIT_ATTABLE, 0), SERIAL_OUT_WAIT };
  104.  
  105. REG ptp_reg[] = {
  106.     { ORDATA (BUF, ptp_unit.buf, 8) },
  107.     { FLDATA (INT, int_req, INT_V_PTP) },
  108.     { FLDATA (DONE, int_req, INT_V_PTP) },
  109. #if defined (IOS_PTPERR)
  110.     { FLDATA (ERR, ptp_err, 0) },
  111. #endif
  112.     { DRDATA (POS, ptp_unit.pos, 32), PV_LEFT },
  113.     { DRDATA (TIME, ptp_unit.wait, 24), PV_LEFT },
  114.     { FLDATA (STOP_IOE, ptp_stopioe, 0) },
  115.     { NULL }  };
  116.  
  117. DEVICE ptp_dev = {
  118.     "PTP", &ptp_unit, ptp_reg, NULL,
  119.     1, 10, 32, 1, 8, 8,
  120.     NULL, NULL, &ptp_reset,
  121.     NULL, &ptp_attach, &ptp_detach };
  122.  
  123. /* TTI data structures
  124.  
  125.    tti_dev    TTI device descriptor
  126.    tti_unit    TTI unit
  127.    tti_reg    TTI register list
  128.    tti_trans    ASCII to Baudot table
  129. */
  130.  
  131. #if defined (KSR28)
  132. #define TTI_WIDTH    5
  133. #define TTI_FIGURES    (1 << TTI_WIDTH)
  134. #define TTI_2ND        (1 << (TTI_WIDTH + 1))
  135. #define TTI_BOTH    (1 << (TTI_WIDTH + 2))
  136. #define BAUDOT_LETTERS    033
  137. #define BAUDOT_FIGURES    037
  138. #define BEL        064
  139.  
  140. static const int tti_trans[128] = {
  141.     BEL,BEL,BEL,BEL,BEL,BEL,BEL,BEL,
  142.     BEL,BEL,0210,BEL,BEL,0202,BEL,BEL,        /* lf, cr */
  143.     BEL,BEL,BEL,BEL,BEL,BEL,BEL,BEL,
  144.     BEL,BEL,BEL,BEL,BEL,BEL,BEL,BEL,
  145.     0204,066,061,045,062,BEL,053,072,        /* space - ' */
  146.     076,051,BEL,BEL,046,070,047,067,        /* ( - / */
  147.     055,075,071,060,052,041,065,074,        /* 0 - 7 */
  148.     054,043,056,057,BEL,BEL,BEL,063,        /* 8 - ? */
  149.     BEL,030,023,016,022,020,026,013,        /* @ - G */
  150.     005,014,032,036,011,007,006,003,        /* H - O */
  151.     015,035,012,024,001,034,017,031,        /* P - W */
  152.     027,025,021,BEL,BEL,BEL,BEL,BEL,        /* X - _ */
  153.     BEL,030,023,016,022,020,026,013,        /* ` - g */
  154.     005,014,032,036,011,007,006,003,        /* h - o */
  155.     015,035,012,024,001,034,017,031,        /* p - w */
  156.     027,025,021,BEL,BEL,BEL,BEL,BEL };        /* x - DEL */
  157. #else
  158.  
  159. #define TTI_WIDTH    8
  160. #endif
  161.  
  162. #define TTI_MASK    ((1 << TTI_WIDTH) - 1)
  163.  
  164. UNIT tti_unit = { UDATA (&tti_svc, 0, 0), KBD_POLL_WAIT };
  165.  
  166. REG tti_reg[] = {
  167.     { ORDATA (BUF, tti_unit.buf, TTI_WIDTH) },
  168.     { FLDATA (INT, int_req, INT_V_TTI) },
  169.     { FLDATA (DONE, int_req, INT_V_TTI) },
  170. #if defined (KSR28)
  171.     { ORDATA (TTI2ND, tti_state, (TTI_WIDTH + 3)), REG_HRO },
  172. #endif
  173.     { DRDATA (POS, tti_unit.pos, 32), PV_LEFT },
  174.     { DRDATA (TIME, tti_unit.wait, 24), REG_NZ + PV_LEFT },
  175.     { NULL }  };
  176.  
  177. DEVICE tti_dev = {
  178.     "TTI", &tti_unit, tti_reg, NULL,
  179.     1, 10, 32, 1, 8, 8,
  180.     NULL, NULL, &tti_reset,
  181.     NULL, NULL, NULL };
  182.  
  183. /* TTO data structures
  184.  
  185.    tto_dev    TTO device descriptor
  186.    tto_unit    TTO unit
  187.    tto_reg    TTO register list
  188.    tto_trans    Baudot to ASCII table
  189. */
  190.  
  191. #if defined (KSR28)
  192. #define TTO_WIDTH    5
  193. #define TTO_FIGURES    (1 << TTO_WIDTH)
  194.  
  195. static const char tto_trans[64] = {
  196.      0 ,'T',015,'O',' ','H','N','M',
  197.     012,'L','R','G','I','P','C','V',
  198.     'E','Z','D','B','S','Y','F','X',
  199.     'A','W','J', 0 ,'U','Q','K', 0,
  200.      0 ,'5',015,'9',' ','#',',','.',
  201.     012,')','4','&','8','0',':',';',
  202.     '3','"','$','?','\a','6','!','/',
  203.     '-','2','\'',0 ,'7','1','(', 0 };
  204. #else
  205.  
  206. #define TTO_WIDTH    8
  207. #endif
  208.  
  209. #define TTO_MASK    ((1 << TTO_WIDTH) - 1)
  210.  
  211. UNIT tto_unit = { UDATA (&tto_svc, 0, 0), SERIAL_OUT_WAIT };
  212.  
  213. REG tto_reg[] = {
  214.     { ORDATA (BUF, tto_unit.buf, TTO_WIDTH) },
  215.     { FLDATA (INT, int_req, INT_V_TTO) },
  216.     { FLDATA (DONE, int_req, INT_V_TTO) },
  217. #if defined (KSR28)
  218.     { FLDATA (TTO2ND, tto_state, 0), REG_HRO },
  219. #endif
  220.     { DRDATA (POS, tto_unit.pos, 32), PV_LEFT },
  221.     { DRDATA (TIME, tto_unit.wait, 24), PV_LEFT },
  222.     { NULL }  };
  223.  
  224. DEVICE tto_dev = {
  225.     "TTO", &tto_unit, tto_reg, NULL,
  226.     1, 10, 32, 1, 8, 8,
  227.     NULL, NULL, &tto_reset,
  228.     NULL, NULL, NULL };
  229.  
  230. /* Clock: IOT routine */
  231.  
  232. int clk (int pulse, int AC)
  233. {
  234. if (pulse == 001) return (int_req & INT_CLK)? IOT_SKP + AC: AC;    /* CLSF */
  235. if (pulse == 004) clk_reset (&clk_dev);            /* CLOF */
  236. else if (pulse == 044) {                /* CLON */
  237.     int_req = int_req & ~INT_CLK;            /* clear flag */
  238.     clk_state = 1;                    /* clock on */
  239.     sim_activate (&clk_unit, clk_unit.wait);  }    /* start clock */
  240. return AC;
  241. }
  242.  
  243. /* Unit service */
  244.  
  245. int clk_svc (UNIT *uptr)
  246. {
  247. if (clk_state) {                    /* clock on? */
  248.     M[7] = (M[7] + 1) & 0777777;            /* incr counter */
  249.     if (M[7] == 0) int_req = int_req | INT_CLK;    /* ovrflo? set flag */
  250.     sim_activate (&clk_unit, clk_unit.wait);  }    /* reactivate unit */
  251. return SCPE_OK;
  252. }
  253.  
  254. /* Reset routine */
  255.  
  256. int clk_reset (DEVICE *dptr)
  257. {
  258. int_req = int_req & ~INT_CLK;                /* clear flag */
  259. clk_state = 0;                        /* clock off */
  260. sim_cancel (&clk_unit);                    /* stop clock */
  261. return SCPE_OK;
  262. }
  263.  
  264. /* IORS service for all standard devices */
  265.  
  266. int std_iors (void)
  267. {
  268. return    ((int_req & INT_CLK)? IOS_CLK: 0) |
  269.     ((int_req & INT_PTR)? IOS_PTR: 0) |
  270.     ((int_req & INT_PTP)? IOS_PTP: 0) |
  271.     ((int_req & INT_TTI)? IOS_TTI: 0) |
  272.     ((int_req & INT_TTO)? IOS_TTO: 0) |
  273. #if defined (IOS_PTRERR)
  274.     (ptr_err? IOS_PTRERR: 0) |
  275. #endif
  276. #if defined (IOS_PTPERR)
  277.     (ptp_err? IOS_PTPERR: 0) |
  278. #endif
  279.     (clk_state? IOS_CLKON: 0);
  280. }
  281.  
  282. /* Paper tape reader: IOT routine */
  283.  
  284. int ptr (int pulse, int AC)
  285. {
  286. if (pulse == 001) return (int_req & INT_PTR)? IOT_SKP + AC: AC;    /* RSF */
  287. if (pulse & 002) {                    /* RRB, RCF */
  288.     int_req = int_req & ~INT_PTR;            /* clear done */
  289.     AC = ptr_unit.buf;  }                /* return buffer */
  290. if (pulse & 004) {                    /* RSA, RSB */
  291.     ptr_state = (pulse & 040)? 18: 0;        /* set mode */
  292.     int_req = int_req & ~INT_PTR;            /* clear done */
  293.     ptr_state = 0;                    /* alpha mode */
  294.     ptr_unit.buf = 0;                /* clear buffer */
  295.     sim_activate (&ptr_unit, ptr_unit.wait);  }
  296. return AC;
  297. }
  298.  
  299. /* Unit service */
  300.  
  301. int ptr_svc (UNIT *uptr)
  302. {
  303. int temp;
  304.  
  305. if ((ptr_unit.flags & UNIT_ATT) == 0) {            /* attached? */
  306. #if defined (IOS_PTRERR)
  307.     int_req = int_req | INT_PTR;            /* if err, set int */
  308.     ptr_err = 1;
  309. #endif
  310.     return IORETURN (ptr_stopioe, SCPE_UNATT);  }
  311. if ((temp = getc (ptr_unit.fileref)) == EOF) {        /* end of file? */
  312. #if defined (IOS_PTRERR)
  313.     int_req = int_req | INT_PTR;            /* if err, set done */
  314.     ptr_err = 1;
  315. #endif
  316.     if (feof (ptr_unit.fileref)) {
  317.         if (ptr_stopioe) printf ("PTR end of file\n");
  318.         else return SCPE_OK;  }
  319.     else perror ("PTR I/O error");
  320.     clearerr (ptr_unit.fileref);
  321.     return SCPE_IOERR;  }
  322. if (ptr_state == 0) ptr_unit.buf = temp & 0377;        /* alpha */
  323. else if (temp & 0200) {                    /* binary */
  324.     ptr_state = ptr_state - 6;
  325.     ptr_unit.buf = ptr_unit.buf | ((temp & 077) << ptr_state);  }
  326. if (ptr_state == 0) int_req = int_req | INT_PTR;        /* set flag */
  327. ptr_unit.pos = ptr_unit.pos + 1;
  328. return SCPE_OK;
  329. }
  330.  
  331. /* Reset routine */
  332.  
  333. int ptr_reset (DEVICE *dptr)
  334. {
  335. ptr_state = 0;                        /* clear state */
  336. ptr_unit.buf = 0;
  337. int_req = int_req & ~INT_PTR;                /* clear flag */
  338. ptr_err = (ptr_unit.flags & UNIT_ATT)? 0: 1;
  339. sim_cancel (&ptr_unit);                    /* deactivate unit */
  340. return SCPE_OK;
  341. }
  342.  
  343. /* Attach routine */
  344.  
  345. int ptr_attach (UNIT *uptr, char *cptr)
  346. {
  347. int reason;
  348.  
  349. reason = attach_unit (uptr, cptr);
  350. ptr_err = (ptr_unit.flags & UNIT_ATT)? 0: 1;
  351. return reason;
  352. }
  353.  
  354. /* Detach routine */
  355.  
  356. int ptr_detach (UNIT *uptr)
  357. {
  358. ptr_err = 1;
  359. return detach_unit (uptr);
  360. }
  361.  
  362. /* Bootstrap routine */
  363.  
  364. #define BOOT_START 017762
  365. #define BOOT_LEN (sizeof (boot_rom) / sizeof (int))
  366.  
  367. static const int boot_rom[] = {
  368.     0000000,                    /* r, 0 */
  369.     0700101,                    /* rsf */
  370.     0617763,                    /* jmp .-1 */
  371.     0700112,                    /* rrb */
  372.     0700144,                    /* rsb */
  373.     0637762,                    /* jmp i r */
  374.     0700144,                    /* go, rsb */
  375.     0117762,                    /* g, jms r */
  376.     0057775,                    /* dac out */
  377.     0417775,                    /* xct out */
  378.     0117762,                    /* jms r */
  379.     0000000,                    /* out, 0 */
  380.     0617771                        /* jmp g */
  381. };
  382.  
  383. int ptr_boot (int unitno)
  384. {
  385. int i;
  386.  
  387. for (i = 0; i < BOOT_LEN; i++) M[BOOT_START + i] = boot_rom[i];
  388. saved_PC = BOOT_START;
  389. return SCPE_OK;
  390. }
  391.  
  392. /* Paper tape punch: IOT routine */
  393.  
  394. int ptp (int pulse, int AC)
  395. {
  396. if (pulse == 001) return (int_req & INT_PTP)? IOT_SKP + AC: AC;    /* PSF */
  397. if (pulse & 002) int_req = int_req & ~INT_PTP;        /* PCF */
  398. if (pulse & 004) {                    /* PSA, PSB, PLS */
  399.     int_req = int_req & ~INT_PTP;            /* clear flag */
  400.     ptp_unit.buf = (pulse & 040)?            /* load punch buf */
  401.         (AC & 077) | 0200: AC & 0377;        /* bin or alpha */
  402.     sim_activate (&ptp_unit, ptp_unit.wait);  }    /* activate unit */
  403. return AC;
  404. }
  405.  
  406. /* Unit service */
  407.  
  408. int ptp_svc (UNIT *uptr)
  409. {
  410. int_req = int_req | INT_PTP;                /* set done flag */
  411. if ((ptp_unit.flags & UNIT_ATT) == 0) {            /* not attached? */
  412.     ptp_err = 1;                    /* set error */
  413.     return IORETURN (ptp_stopioe, SCPE_UNATT);  }
  414. if (putc (ptp_unit.buf, ptp_unit.fileref) == EOF) {    /* I/O error? */
  415.     ptp_err = 1;                    /* set error */
  416.     perror ("PTP I/O error");
  417.     clearerr (ptp_unit.fileref);
  418.     return SCPE_IOERR;  }
  419. ptp_unit.pos = ptp_unit.pos + 1;
  420. return SCPE_OK;
  421. }
  422.  
  423. /* Reset routine */
  424.  
  425. int ptp_reset (DEVICE *dptr)
  426. {
  427. ptp_unit.buf = 0;
  428. int_req = int_req & ~INT_PTP;                /* clear flag */
  429. ptp_err = (ptp_unit.flags & UNIT_ATT)? 0: 1;
  430. sim_cancel (&ptp_unit);                    /* deactivate unit */
  431. return SCPE_OK;
  432. }
  433.  
  434. /* Attach routine */
  435.  
  436. int ptp_attach (UNIT *uptr, char *cptr)
  437. {
  438. int reason;
  439.  
  440. reason = attach_unit (uptr, cptr);
  441. ptp_err = (ptp_unit.flags & UNIT_ATT)? 0: 1;
  442. return reason;
  443. }
  444.  
  445. /* Detach routine */
  446.  
  447. int ptp_detach (UNIT *uptr)
  448. {
  449. ptp_err = 1;
  450. return detach_unit (uptr);
  451. }
  452.  
  453. /* Terminal input: IOT routine */
  454.  
  455. int tti (int pulse, int AC)
  456. {
  457. if (pulse == 001) return (int_req & INT_TTI)? IOT_SKP + AC: AC;    /* KSF */
  458. if (pulse == 002) {                    /* KRB */
  459.     int_req = int_req & ~INT_TTI;            /* clear flag */
  460.     return tti_unit.buf & TTI_WIDTH;  }        /* return buffer */
  461. return AC;
  462. }
  463.  
  464. /* Unit service */
  465.  
  466. int tti_svc (UNIT *uptr)
  467. {
  468. int temp;
  469.  
  470. sim_activate (&tti_unit, tti_unit.wait);        /* continue poll */
  471.  
  472. #if defined (KSR28)                    /* Baudot... */
  473. if (tti_state & TTI_2ND) {                /* char waiting? */
  474.     tti_unit.buf = tti_state & TTI_WIDTH;        /* return char */
  475.     tti_state = tti_state & ~TTI_2ND;  }        /* not waiting */
  476. else {    if ((temp = sim_poll_kbd ()) < SCPE_KFLAG) return temp;
  477.     temp = tti_trans[temp & 0177];            /* translate char */
  478.     if (temp & TTI_BOTH) tti_unit.buf = temp & TTI_WIDTH;
  479.     else if ((temp & TTI_FIGURES) == (tti_state & TTI_FIGURES)) {
  480.         tti_unit.buf = temp & TTI_WIDTH;
  481.         tti_state = temp;  }            /* change state */
  482.     else {    tti_unit.buf = (temp & TTI_FIGURES)?
  483.                 BAUDOT_FIGURES: BAUDOT_LETTERS;
  484.         tti_state = temp | TTI_2ND;  }  }    /* set 2nd waiting */
  485.  
  486. #else                            /* ASCII... */
  487. if ((temp = sim_poll_kbd ()) < SCPE_KFLAG) return temp;    /* no char or error? */
  488. tti_unit.buf = (temp & 0377) | 0200;            /* got char */
  489. #endif
  490. int_req = int_req | INT_TTI;                /* set flag */
  491. tti_unit.pos = tti_unit.pos + 1;
  492. return SCPE_OK;
  493. }
  494.  
  495. /* Reset routine */
  496.  
  497. int tti_reset (DEVICE *dptr)
  498. {
  499. tti_unit.buf = 0;                    /* clear buffer */
  500. tti_state = 0;                        /* clear state */
  501. int_req = int_req & ~INT_TTI;                /* clear flag */
  502. sim_activate (&tti_unit, tti_unit.wait);        /* activate unit */
  503. return SCPE_OK;
  504. }
  505.  
  506. /* Terminal output: IOT routine */
  507.  
  508. int tto (int pulse, int AC)
  509. {
  510. if (pulse == 001) return (int_req & INT_TTO)? IOT_SKP + AC: AC;    /* TSF */
  511. if (pulse & 002) int_req = int_req & ~INT_TTO;        /* clear flag */
  512. if (pulse & 004) {                    /* load buffer */
  513.     sim_activate (&tto_unit, tto_unit.wait);    /* activate unit */
  514.     tto_unit.buf = AC & TTO_MASK;  }        /* load buffer */
  515. return AC;
  516. }
  517.  
  518. /* Unit service */
  519.  
  520. int tto_svc (UNIT *uptr)
  521. {
  522. int out, temp;
  523.  
  524. #if defined (KSR28)                    /* Baudot... */
  525. if (tto_unit.buf == BAUDOT_FIGURES) {            /* set figures? */
  526.     tto_state = TTO_FIGURES;
  527.     return SCPE_OK;  }
  528. if (tto_unit.buf == BAUDOT_LETTERS) {            /* set letters? */
  529.     tto_state = 0;
  530.     return SCPE_OK;  }
  531. out = tto_trans[tto_unit.buf + tto_state];        /* translate */
  532. #else
  533. out = tto_unit.buf & 0177;                /* ASCII... */
  534. #endif
  535. int_req = int_req | INT_TTO;                /* set flag */
  536. if ((temp = sim_type_tty (out)) != SCPE_OK) return temp;
  537. tto_unit.pos = tto_unit.pos + 1;
  538. return SCPE_OK;
  539. }
  540.  
  541. /* Reset routine */
  542.  
  543. int tto_reset (DEVICE *dptr)
  544. {
  545. tto_unit.buf = 0;                    /* clear buffer */
  546. tto_state = 0;                        /* clear state */
  547. int_req = int_req & ~INT_TTO;                /* clear flag */
  548. sim_cancel (&tto_unit);                    /* deactivate unit */
  549. return SCPE_OK;
  550. }
  551.