home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snip9707.zip / X00API.C < prev    next >
C/C++ Source or Header  |  1997-07-05  |  11KB  |  415 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /*
  4.  *   X00API.C: X00 FOSSIL driver
  5.  *   
  6.  *   Created by R.F. Pels.
  7.  *   modified by Bob Stout
  8.  *   Placed in the public domain by R.F. Pels.
  9.  */
  10.  
  11. #include "x00api.h"
  12. #include <dos.h>
  13. #include "mk_fp.h"
  14.  
  15. static union  REGS  x00regs;
  16. static struct SREGS x00sregs;
  17. int                 x00error = 0;
  18.  
  19. #if defined(__cplusplus) && __cplusplus
  20.  extern "C" {
  21. #endif
  22.  
  23. #ifndef MK_FP
  24.  #define MK_FP(seg,offset) \
  25.         ((void _far *)(((unsigned long)(seg)<<16) | (unsigned)(offset)))
  26. #endif
  27.  
  28. #if defined(__TURBOC__) || defined (__POWERC)
  29.  #define PEEK(s,o) peek(s,o)
  30. #else /* MSC or ZTC */
  31.  #define PEEK(s,o) *((unsigned _far *)(MK_FP((s),(o))))
  32. #endif
  33.  
  34. unsigned int  x00_detect(void)
  35. {
  36.         unsigned int segofx00;
  37.         unsigned int ofsofx00;
  38.         
  39.         /* Peek in interrupt vector table for start of FOSSIL */
  40.  
  41.         ofsofx00 = PEEK(0, X00_VECTOR * 4);
  42.         segofx00 = PEEK(0, (X00_VECTOR * 4) + 2);
  43.         
  44.         /* Peek in start of FOSSIL + X00_IDOFFSET */
  45.  
  46.         return (PEEK(segofx00, ofsofx00 + X00_IDOFFSET));
  47. }
  48.  
  49. FOSSILSTATUS  x00_set(unsigned char set, PORT port)
  50. {
  51.         FOSSILSTATUS retval;
  52.         
  53.         x00regs.x.ax = SET_BAUDRATE | set;
  54.         x00regs.x.dx = port;
  55.         int86(X00_VECTOR, &x00regs, &x00regs);
  56.         retval.statusword = x00regs.x.ax;
  57.         return retval;
  58. }
  59.  
  60. FOSSILSTATUS  x00_tx_char(unsigned char c, PORT port)
  61. {
  62.         FOSSILSTATUS retval;
  63.         
  64.         x00regs.x.ax = TX_CHAR | c;
  65.         x00regs.x.dx = port;
  66.         int86(X00_VECTOR, &x00regs, &x00regs);
  67.         retval.statusword = x00regs.x.ax;
  68.         return retval;
  69. }
  70.  
  71. unsigned char  x00_rx_char(PORT port)
  72. {
  73.         x00regs.x.ax = RX_CHAR;
  74.         x00regs.x.dx = port;
  75.         int86(X00_VECTOR, &x00regs, &x00regs);
  76.         return (unsigned char)(x00regs.x.ax & 0xff);
  77. }
  78.  
  79. FOSSILSTATUS  x00_status(PORT port)
  80. {
  81.         FOSSILSTATUS retval;
  82.         
  83.         x00regs.x.ax = STATUS;
  84.         x00regs.x.dx = port;
  85.         int86(X00_VECTOR, &x00regs, &x00regs);
  86.         retval.statusword = x00regs.x.ax;
  87.         return retval;
  88. }
  89.  
  90. FOSSILINIT    x00_init(PORT port, unsigned char far *ctlc_flagbyte)
  91. {
  92.         FOSSILINIT retval;
  93.         
  94.         x00regs.x.ax = INITIALIZE;
  95.         if (ctlc_flagbyte != (unsigned char far *)0)
  96.         {
  97.                 x00regs.x.dx = 0x00ff;
  98.                 x00regs.x.bx = 0x4F50;
  99.                 segread(&x00sregs);
  100.                 x00sregs.es  = FP_SEG(ctlc_flagbyte);
  101.                 x00regs.x.cx = FP_OFF(ctlc_flagbyte);
  102.         }
  103.         else
  104.         {
  105.                 x00regs.x.bx = 0x0000; /* in any case _NOT_ 0x4f50 */
  106.                 x00regs.x.dx = port;
  107.         }
  108.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  109.         retval.result       = x00regs.x.ax;
  110.         retval.max_function = (unsigned char)(x00regs.x.bx & 0xff);
  111.         retval.revision     = (unsigned char)(x00regs.x.bx >> 8);
  112.         return retval;
  113. }
  114.  
  115. void          x00_deinit(PORT port)
  116. {
  117.         x00regs.x.ax = DEINITIALIZE;
  118.         x00regs.x.dx = port;
  119.         int86(X00_VECTOR, &x00regs, &x00regs);
  120. }
  121.  
  122. unsigned int  x00_raise_dtr(PORT port)
  123. {
  124.         unsigned int retval;
  125.         
  126.         x00regs.x.ax = RAISE_DTR;
  127.         x00regs.x.dx = port;
  128.         int86(X00_VECTOR, &x00regs, &x00regs);
  129.         if ((x00regs.x.ax & 0x0001) == 1)
  130.         {
  131.                 retval = X00_DTR_HIGH;
  132.         }
  133.         else    retval = X00_DTR_LOW;
  134.         return retval;
  135. }
  136.  
  137. unsigned int  x00_lower_dtr(PORT port)
  138. {
  139.         unsigned int retval;
  140.         
  141.         x00regs.x.ax = LOWER_DTR;
  142.         x00regs.x.dx = port;
  143.         int86(X00_VECTOR, &x00regs, &x00regs);
  144.         if ((x00regs.x.ax & 0x0001) == 1)
  145.         {
  146.                 retval = X00_DTR_HIGH;
  147.         }
  148.         else    retval = X00_DTR_LOW;
  149.         return retval;
  150. }
  151.  
  152. FOSSILSYSINFO x00_sysinfo(void)
  153. {
  154.         FOSSILSYSINFO retval;
  155.         
  156.         x00regs.x.ax = GET_SYS_INFO;
  157.         int86(X00_VECTOR, &x00regs, &x00regs);
  158.         retval.tick_number        = (unsigned char)(x00regs.x.ax & 0xff);
  159.         retval.ticks_per_second   = (unsigned char)(x00regs.x.ax >> 8);
  160.         retval.approx_ms_per_tick = x00regs.x.dx;
  161.         return retval;
  162. }
  163.  
  164. void          x00_flush_output(PORT port)
  165. {
  166.         x00regs.x.ax = FLUSH_OUTPUT;
  167.         x00regs.x.dx = port;
  168.         int86(X00_VECTOR, &x00regs, &x00regs);
  169. }
  170.  
  171. void          x00_purge_output(PORT port)
  172. {
  173.         x00regs.x.ax = PURGE_OUTPUT;
  174.         x00regs.x.dx = port;
  175.         int86(X00_VECTOR, &x00regs, &x00regs);
  176. }
  177.  
  178. void          x00_purge_input(PORT port)
  179. {
  180.         x00regs.x.ax = PURGE_INPUT;
  181.         x00regs.x.dx = port;
  182.         int86(X00_VECTOR, &x00regs, &x00regs);
  183. }
  184.  
  185. unsigned int  x00_tx_char_nowait(unsigned char c, PORT port)
  186. {
  187.         unsigned int retval;
  188.         
  189.         x00regs.x.ax = TX_CHAR_NOWAIT | c;
  190.         x00regs.x.dx = port;
  191.         int86(X00_VECTOR, &x00regs, &x00regs);
  192.         if ((x00regs.x.ax & 0x0001) == 1)
  193.         {
  194.                 retval = X00_OK;
  195.         }
  196.         else    retval = X00_CHAR_NOT_SENT;
  197.         return retval;
  198. }
  199.  
  200. unsigned int  x00_peek_ahead_input(PORT port)
  201. {
  202.         x00regs.x.ax = PEEK_AHEAD_INPUT;
  203.         x00regs.x.dx = port;
  204.         int86(X00_VECTOR, &x00regs, &x00regs);
  205.         return x00regs.x.ax;
  206. }
  207.  
  208. unsigned int   x00_peek_ahead_kbd(void)
  209. {
  210.         x00regs.x.ax = PEEK_AHEAD_KBD;
  211.         int86(X00_VECTOR, &x00regs, &x00regs);
  212.         return x00regs.x.ax;
  213. }
  214.  
  215. unsigned int  x00_read_kbd(void)
  216. {
  217.         x00regs.x.ax = READ_KBD;
  218.         int86(X00_VECTOR, &x00regs, &x00regs);
  219.         return x00regs.x.ax;
  220. }
  221.  
  222. void          x00_flow_control(FOSSILFLOWCTRL f, PORT port)
  223. {
  224.         x00regs.x.ax = FLOW_CONTROL | 0xf0 | f.flowword;
  225.         x00regs.x.dx = port;
  226.         int86(X00_VECTOR, &x00regs, &x00regs);
  227. }
  228.  
  229. unsigned int  x00_ctlc_ctlk_check(FOSSILCTLCCTLK c, PORT port)
  230. {
  231.         x00regs.x.ax = CTLC_CTLK_CHECK | c.checkword;
  232.         x00regs.x.dx = port;
  233.         int86(X00_VECTOR, &x00regs, &x00regs);
  234.         return x00regs.x.ax;
  235. }
  236.  
  237. void          x00_set_cup(unsigned char row, unsigned char col)
  238. {
  239.         x00regs.x.ax = SET_CUP;
  240.         x00regs.x.dx = (row << 8) | col;
  241.         int86(X00_VECTOR, &x00regs, &x00regs);
  242. }
  243.  
  244. void          x00_get_cup(unsigned char *row, unsigned char *col)
  245. {
  246.         x00regs.x.ax = GET_CUP;
  247.         int86(X00_VECTOR, &x00regs, &x00regs);
  248.         *col = (unsigned char)(x00regs.x.dx & 0xff);
  249.         *row = (unsigned char)(x00regs.x.dx >> 8);
  250. }
  251.  
  252. void          x00_write_ANSI_char(unsigned char c)
  253. {
  254.         x00regs.x.ax = WRITE_ANSI_CHAR | c;
  255.         int86(X00_VECTOR, &x00regs, &x00regs);
  256. }
  257.  
  258. void          x00_enable_watchdog(PORT port)
  259. {
  260.         x00regs.x.ax = ENABLE_WATCHDOG;
  261.         x00regs.x.dx = port;
  262.         int86(X00_VECTOR, &x00regs, &x00regs);
  263. }
  264.  
  265. void          x00_disable_watchdog(PORT port)
  266. {
  267.         x00regs.x.ax = DISABLE_WATCHDOG;
  268.         x00regs.x.dx = port;
  269.         int86(X00_VECTOR, &x00regs, &x00regs);
  270. }
  271.  
  272. void          x00_write_BIOS_char(unsigned char c)
  273. {
  274.         x00regs.x.ax = WRITE_BIOS_CHAR | c;
  275.         int86(X00_VECTOR, &x00regs, &x00regs);
  276. }
  277.  
  278. unsigned int  x00_insert_tick_func(void (far *tickfunc)())
  279. {
  280.         unsigned int retval;
  281.         
  282.         x00regs.x.ax = INSERT_TICK_FUNC;
  283.         x00regs.x.dx = FP_OFF(tickfunc);
  284.         segread(&x00sregs);
  285.         x00sregs.es  = FP_SEG(tickfunc);
  286.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  287.         if (x00regs.x.ax == 0x0000)
  288.         {
  289.                 retval = X00_OK;
  290.         }
  291.         else    retval = X00_INS_TICK;
  292.         return retval;
  293. }
  294.  
  295. unsigned int  x00_delete_tick_func(void (far *tickfunc)())
  296. {
  297.         unsigned int retval;
  298.         
  299.         x00regs.x.ax = DELETE_TICK_FUNC;
  300.         x00regs.x.dx = FP_OFF(tickfunc);
  301.         segread(&x00sregs);
  302.         x00sregs.es  = FP_SEG(tickfunc);
  303.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  304.         if (x00regs.x.ax == 0x0000)
  305.         {
  306.                 retval = X00_OK;
  307.         }
  308.         else    retval = X00_DEL_TICK;
  309.         return retval;
  310. }
  311.  
  312. void          x00_boot_machine(unsigned int boottype)
  313. {
  314.         x00regs.x.ax = BOOT_MACHINE | (boottype & 0x0001);
  315.         int86(X00_VECTOR, &x00regs, &x00regs);
  316. }
  317.  
  318. unsigned int  x00_read_block(unsigned int count, void far *buf, PORT port)
  319. {
  320.         x00regs.x.ax = READ_BLOCK;
  321.         x00regs.x.cx = count;
  322.         x00regs.x.dx = port;
  323.         segread(&x00sregs);
  324.         x00sregs.es  = FP_SEG(buf);
  325.         x00regs.x.di = FP_OFF(buf);
  326.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  327.         return x00regs.x.ax;
  328. }
  329.  
  330. unsigned int  x00_write_block(unsigned int count, void far *buf, PORT port)
  331. {
  332.         x00regs.x.ax = WRITE_BLOCK;
  333.         x00regs.x.cx = count;
  334.         x00regs.x.dx = port;
  335.         segread(&x00sregs);
  336.         x00sregs.es  = FP_SEG(buf);
  337.         x00regs.x.di = FP_OFF(buf);
  338.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  339.         return x00regs.x.ax;
  340. }
  341.  
  342. void          x00_start_break_signal(PORT port)
  343. {
  344.         x00regs.x.ax = START_BREAK_SIGNAL;
  345.         x00regs.x.dx = port;
  346.         int86(X00_VECTOR, &x00regs, &x00regs);
  347. }
  348.  
  349. void          x00_stop_break_signal(PORT port)
  350. {
  351.         x00regs.x.ax = STOP_BREAK_SIGNAL;
  352.         x00regs.x.dx = port;
  353.         int86(X00_VECTOR, &x00regs, &x00regs);
  354. }
  355.  
  356. unsigned int  x00_get_driverinfo(void far *buf, PORT port)
  357. {
  358.         x00regs.x.ax = GET_DRIVER_INFO;
  359.         x00regs.x.cx = sizeof(FOSSILINFO);
  360.         segread(&x00sregs);
  361.         x00sregs.es  = FP_SEG(buf);
  362.         x00regs.x.di = FP_OFF(buf);
  363.         x00regs.x.dx = port;
  364.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  365.         return x00regs.x.ax;
  366. }
  367.  
  368. unsigned int  x00_install_appendage(unsigned char appcode,
  369.                                               void (far *appfunc)())
  370. {
  371.         unsigned int retval;
  372.         
  373.         x00regs.x.ax = INSTALL_APPENDAGE | appcode;
  374.         segread(&x00sregs);
  375.         x00sregs.es  = FP_SEG(appfunc);
  376.         x00regs.x.dx = FP_OFF(appfunc);
  377.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  378.         if (x00regs.x.ax == X00_PRESENT)
  379.         {
  380.                 if ((x00regs.x.bx & 0xff00) == 1)
  381.                 {
  382.                         retval = X00_OK;
  383.                 }
  384.                 else    retval = X00_INS_APP;
  385.         }
  386.         else    retval = X00_NOT_HERE;
  387.         return retval;
  388. }
  389.  
  390. unsigned int  x00_remove_appendage(unsigned char appcode,
  391.                                              void (far *appfunc)())
  392. {
  393.         unsigned int retval;
  394.         
  395.         x00regs.x.ax = REMOVE_APPENDAGE | appcode;
  396.         segread(&x00sregs);
  397.         x00sregs.es  = FP_SEG(appfunc);
  398.         x00regs.x.dx = FP_OFF(appfunc);
  399.         int86x(X00_VECTOR, &x00regs, &x00regs, &x00sregs);
  400.         if (x00regs.x.ax == X00_PRESENT)
  401.         {
  402.                 if ((x00regs.x.bx & 0xff00) == 1)
  403.                 {
  404.                         retval = X00_OK;
  405.                 }
  406.                 else    retval = X00_REM_APP;
  407.         }
  408.         else    retval = X00_NOT_HERE;
  409.         return retval;
  410. }
  411.  
  412. #if defined(__cplusplus) && __cplusplus
  413.  }
  414. #endif
  415.