home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / windr440.zip / windrive.zip / WinDriver / samples / int_io / int_io.c
C/C++ Source or Header  |  2000-03-30  |  4KB  |  150 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - INT_IO.C
  3. //
  4. // This is a skeleton driver for an ISA card. The driver 
  5. // implements IO port access and interrupt handler installation.
  6. // 
  7. ////////////////////////////////////////////////////////////////
  8.  
  9. #include "../../include/windrvr.h"
  10. #include "../../include/windrvr_int_thread.h"
  11. #include <stdio.h>
  12.  
  13. // put your IO range here (this example 0x378-0x37a)
  14. enum {MY_IO_BASE = 0x378};
  15. enum {MY_IO_SIZE = 0x3};
  16. // put your IRQ number to install here (this example IRQ 5)
  17. enum {MY_IRQ = 5};
  18.  
  19. // global WinDriver handle
  20. HANDLE hWD;
  21.  
  22. // interrupt structure
  23. WD_INTERRUPT Intrp;
  24.  
  25. static char line[256];
  26.  
  27. // this is equivalent to the assember "inp" command
  28. BYTE IO_ReadByte(DWORD dwIOAddr)
  29. {
  30.     WD_TRANSFER trns;
  31.     BZERO(trns);
  32.     trns.cmdTrans = RP_BYTE; // R-Read P-Port BYTE
  33.     trns.dwPort = dwIOAddr;
  34.     WD_Transfer( hWD, &trns); // Perform read
  35.     return trns.Data.Byte;
  36. }
  37.  
  38. // this is equivalent to the assember "outp" command
  39. void IO_WriteByte(DWORD dwIOAddr, BYTE bData)
  40. {
  41.     WD_TRANSFER trns;
  42.     BZERO(trns);
  43.     trns.cmdTrans = WP_BYTE; // R-Write P-Port BYTE
  44.     trns.dwPort = dwIOAddr;
  45.     trns.Data.Byte = bData;
  46.     WD_Transfer( hWD, &trns); // Perform write
  47. }
  48.  
  49. void IO_ReadByteString(DWORD dwIOAddr, PBYTE pBuf, DWORD dwBytes)
  50. {
  51.     WD_TRANSFER trns;
  52.     BZERO(trns);
  53.     trns.cmdTrans = RP_SBYTE; // R-Read, P-Port, S-String BYTE
  54.     trns.dwPort = dwIOAddr;
  55.     trns.dwBytes = dwBytes;
  56.     trns.fAutoinc = FALSE;
  57.     trns.dwOptions = 0;
  58.     trns.Data.pBuffer = pBuf;
  59.     WD_Transfer( hWD, &trns); // Perform read
  60. }
  61.  
  62. void IO_WriteByteString(DWORD dwIOAddr, PBYTE pBuf, DWORD dwBytes)
  63. {
  64.     WD_TRANSFER trns;
  65.     BZERO(trns);
  66.     trns.cmdTrans = WP_SBYTE; // W-Write, P-Port, S-String BYTE
  67.     trns.dwPort = dwIOAddr;
  68.     trns.dwBytes = dwBytes;
  69.     trns.fAutoinc = FALSE;
  70.     trns.dwOptions = 0;
  71.     trns.Data.pBuffer = pBuf;
  72.     WD_Transfer( hWD, &trns); // Perform write
  73. }
  74.  
  75. // interrupt handler routine. you can use pData to pass information from InterruptThreadEnable()
  76. VOID interrupt_handler (PVOID pData)
  77. {
  78.     // do your interrupt routine here 
  79.     printf ("Got interrupt %d\n", Intrp.dwCounter);
  80. }
  81.  
  82. int main()
  83. {
  84.     WD_CARD_REGISTER cardReg;
  85.     WD_VERSION verBuf;
  86.  
  87.     hWD = WD_Open();
  88.     if (hWD==INVALID_HANDLE_VALUE)
  89.     {
  90.         printf ("error opening WINDRVR\n");
  91.         return 0;
  92.     }
  93.  
  94.     BZERO(verBuf);
  95.     WD_Version (hWD, &verBuf);
  96.     printf (WD_PROD_NAME " version - %s\n", verBuf.cVer);
  97.     if (verBuf.dwVer<WD_VER)
  98.     {
  99.         printf ("error incorrect WINDRVR version. needs ver %d\n",WD_VER);
  100.         return 0;
  101.     }
  102.  
  103.     BZERO(cardReg);
  104.     cardReg.Card.dwItems = 2;
  105.     cardReg.Card.Item[0].item = ITEM_INTERRUPT;
  106.     cardReg.Card.Item[0].fNotSharable = TRUE;
  107.     cardReg.Card.Item[0].I.Int.dwInterrupt = MY_IRQ;
  108.     cardReg.Card.Item[0].I.Int.dwOptions = 0;
  109.     cardReg.Card.Item[1].item = ITEM_IO;
  110.     cardReg.Card.Item[1].fNotSharable = TRUE;
  111.     cardReg.Card.Item[1].I.IO.dwAddr = MY_IO_BASE;
  112.     cardReg.Card.Item[1].I.IO.dwBytes = MY_IO_SIZE;
  113.     cardReg.fCheckLockOnly = FALSE;
  114.     WD_CardRegister (hWD, &cardReg);
  115.     if (cardReg.hCard==0)
  116.     {
  117.         printf ("Failed locking device");
  118.     }
  119.     else
  120.     {
  121.         HANDLE thread_handle;
  122.     
  123.         BZERO(Intrp);
  124.         Intrp.hInterrupt = cardReg.Card.Item[0].I.Int.hInterrupt;
  125.         Intrp.Cmd = NULL;
  126.         Intrp.dwCmds = 0;
  127.         Intrp.dwOptions = 0;
  128.         printf ("starting interrupt thread\n");
  129.         // this calls WD_IntEnable() and creates an interrupt handler thread
  130.         if (!InterruptThreadEnable(&thread_handle, hWD, &Intrp, interrupt_handler, NULL))
  131.         {
  132.             printf ("failed enabling interrupt\n");
  133.         }
  134.         else
  135.         {
  136.             // call your driver code here 
  137.             printf ("Press Enter to uninstall interrupt\n");
  138.             gets(line);
  139.             
  140.             // this calls WD_IntDisable()
  141.             InterruptThreadDisable(thread_handle);
  142.         }
  143.         WD_CardUnregister(hWD, &cardReg);
  144.     }
  145.  
  146.     WD_Close(hWD);
  147.     return 0;
  148. }
  149.  
  150.