home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / windr440.zip / windrive.zip / WinDriver / plx / 9060 / lib / p9060_lib.c next >
C/C++ Source or Header  |  2000-03-30  |  21KB  |  658 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - P9060_LIB.C
  3. //
  4. // Library for 'WinDriver for PLX 9060' API. 
  5. // The basic idea is to get a handle for the board
  6. // with P9060_Open() and use it in the rest of the program
  7. // when calling WD functions.  Call P9060_Close() when done.
  8. // 
  9. ////////////////////////////////////////////////////////////////
  10.  
  11. #include "../../../include/windrvr.h"
  12. #include "../../../include/windrvr_int_thread.h"
  13. #include "p9060_lib.h"
  14. #include <stdio.h>
  15.  
  16. // this string is set to an error message, if one occurs
  17. CHAR P9060_ErrorString[1024];
  18.  
  19. // internal function used by P9060_Open()
  20. BOOL P9060_DetectCardElements(P9060_HANDLE hPlx);
  21. // internal function used by P9060_Read... and P9060_Write... functions
  22. void P9060_SetMode (P9060_HANDLE hPlx, P9060_MODE mode, DWORD dwLocalAddr);
  23.  
  24. DWORD P9060_CountCards (DWORD dwVendorID, DWORD dwDeviceID)
  25. {
  26.     WD_VERSION ver;
  27.     WD_PCI_SCAN_CARDS pciScan;
  28.     HANDLE hWD;
  29.  
  30.     P9060_ErrorString[0] = '\0';
  31.     hWD = WD_Open();
  32.     // check if handle valid & version OK
  33.     if (hWD==INVALID_HANDLE_VALUE) 
  34.     {
  35.         sprintf( P9060_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
  36.         return 0;
  37.     }
  38.  
  39.     BZERO(ver);
  40.     WD_Version(hWD,&ver);
  41.     if (ver.dwVer<WD_VER) 
  42.     {
  43.         sprintf( P9060_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
  44.         WD_Close (hWD);
  45.         return 0;
  46.     }
  47.  
  48.     BZERO(pciScan);
  49.     pciScan.searchId.dwVendorId = dwVendorID;
  50.     pciScan.searchId.dwDeviceId = dwDeviceID;
  51.     WD_PciScanCards (hWD, &pciScan);
  52.     WD_Close (hWD);
  53.     if (pciScan.dwCards==0)
  54.         sprintf( P9060_ErrorString, "no cards found\n");
  55.     return pciScan.dwCards;
  56. }
  57.  
  58.  
  59. BOOL P9060_Open (P9060_HANDLE *phPlx, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum, DWORD dwOptions)
  60. {
  61.     P9060_HANDLE hPlx = (P9060_HANDLE) malloc (sizeof (P9060_STRUCT));
  62.     DWORD dwIntStatus;
  63.  
  64.     WD_VERSION ver;
  65.     WD_PCI_SCAN_CARDS pciScan;
  66.     WD_PCI_CARD_INFO pciCardInfo;
  67.  
  68.     *phPlx = NULL;
  69.     P9060_ErrorString[0] = '\0';
  70.     BZERO(*hPlx);
  71.  
  72.     hPlx->cardReg.hCard = 0;
  73.     hPlx->hWD = WD_Open();
  74.  
  75.     // check if handle valid & version OK
  76.     if (hPlx->hWD==INVALID_HANDLE_VALUE) 
  77.     {
  78.         sprintf( P9060_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
  79.         goto Exit;
  80.     }
  81.  
  82.     BZERO(ver);
  83.     WD_Version(hPlx->hWD,&ver);
  84.     if (ver.dwVer<WD_VER) 
  85.     {
  86.         sprintf( P9060_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
  87.         goto Exit;
  88.     }
  89.  
  90.     BZERO(pciScan);
  91.     pciScan.searchId.dwVendorId = dwVendorID;
  92.     pciScan.searchId.dwDeviceId = dwDeviceID;
  93.     WD_PciScanCards (hPlx->hWD, &pciScan);
  94.     if (pciScan.dwCards==0) // Found at least one card
  95.     {
  96.         sprintf( P9060_ErrorString, "Could not find PCI card\n");
  97.         goto Exit;
  98.     }
  99.     if (pciScan.dwCards<=nCardNum)
  100.     {
  101.         sprintf( P9060_ErrorString, "Card out of range of available cards\n");
  102.         goto Exit;
  103.     }
  104.  
  105.     BZERO(pciCardInfo);
  106.     pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
  107.     WD_PciGetCardInfo (hPlx->hWD, &pciCardInfo);
  108.     hPlx->pciSlot = pciCardInfo.pciSlot;
  109.     hPlx->cardReg.Card = pciCardInfo.Card;
  110.  
  111.     hPlx->fUseInt = (dwOptions & P9060_OPEN_USE_INT) ? TRUE : FALSE;
  112.     if (!hPlx->fUseInt)
  113.     {
  114.         DWORD i;
  115.         // Remove interrupt item if not needed
  116.         for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
  117.         {
  118.             WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];
  119.             if (pItem->item==ITEM_INTERRUPT)
  120.                 pItem->item = ITEM_NONE;
  121.         }
  122.     }
  123.     else
  124.     {
  125.         DWORD i;
  126.         // make interrupt resource sharable
  127.         for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
  128.         {
  129.             WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];
  130.             if (pItem->item==ITEM_INTERRUPT)
  131.                 pItem->fNotSharable = FALSE;
  132.         }
  133.     }
  134.  
  135.     hPlx->cardReg.fCheckLockOnly = FALSE;
  136.     WD_CardRegister (hPlx->hWD, &hPlx->cardReg);
  137.     if (hPlx->cardReg.hCard==0)
  138.     {
  139.         sprintf ( P9060_ErrorString, "Failed locking device\n");
  140.         goto Exit;
  141.     }
  142.  
  143.     if (!P9060_DetectCardElements(hPlx))
  144.     {
  145.         sprintf ( P9060_ErrorString, "Card does not have all items expected for PLX 9060\n");
  146.         goto Exit;
  147.     }
  148.  
  149.     // set the values to be written to REGION_DESC register
  150.     hPlx->modeDesc[P9060_MODE_BYTE] = (DWORD) (P9060_MODE_DESC | P9060_MODE_DESC_BYTE);
  151.     hPlx->modeDesc[P9060_MODE_WORD] = (DWORD) (P9060_MODE_DESC | P9060_MODE_DESC_WORD);
  152.     hPlx->modeDesc[P9060_MODE_DWORD] = (DWORD) (P9060_MODE_DESC | P9060_MODE_DESC_DWORD);
  153.  
  154.     // this enables target abort so it wont get stuck 
  155.     dwIntStatus = P9060_ReadReg (hPlx, P9060_INT_STATUS);
  156.     P9060_WriteReg (hPlx, P9060_INT_STATUS, dwIntStatus | BIT12);
  157.  
  158.     // Open finished OK
  159.     *phPlx = hPlx;
  160.     return TRUE;
  161.  
  162. Exit:
  163.     // Error durin Open
  164.     if (hPlx->cardReg.hCard) 
  165.         WD_CardUnregister(hPlx->hWD, &hPlx->cardReg);
  166.     if (hPlx->hWD!=INVALID_HANDLE_VALUE)
  167.         WD_Close(hPlx->hWD);
  168.     free (hPlx);
  169.     return FALSE;
  170. }
  171.  
  172. DWORD P9060_ReadPCIReg(P9060_HANDLE hPlx, DWORD dwReg)
  173. {
  174.     WD_PCI_CONFIG_DUMP pciCnf;
  175.     DWORD dwVal;
  176.  
  177.     BZERO (pciCnf);
  178.     pciCnf.pciSlot = hPlx->pciSlot;
  179.     pciCnf.pBuffer = &dwVal;
  180.     pciCnf.dwOffset = dwReg;
  181.     pciCnf.dwBytes = 4;
  182.     pciCnf.fIsRead = TRUE;
  183.     WD_PciConfigDump(hPlx->hWD,&pciCnf);
  184.     return dwVal;
  185. }
  186.  
  187. void P9060_WritePCIReg(P9060_HANDLE hPlx, DWORD dwReg, DWORD dwData)
  188. {
  189.     WD_PCI_CONFIG_DUMP pciCnf;
  190.  
  191.     BZERO (pciCnf);
  192.     pciCnf.pciSlot = hPlx->pciSlot;
  193.     pciCnf.pBuffer = &dwData;
  194.     pciCnf.dwOffset = dwReg;
  195.     pciCnf.dwBytes = 4;
  196.     pciCnf.fIsRead = FALSE;
  197.     WD_PciConfigDump(hPlx->hWD,&pciCnf);
  198. }
  199.  
  200. BOOL P9060_DetectCardElements(P9060_HANDLE hPlx)
  201. {
  202.     DWORD i;
  203.     DWORD ad_sp;
  204.  
  205.     BZERO(hPlx->Int);
  206.     BZERO(hPlx->addrDesc);
  207.  
  208.     for (i=0; i<hPlx->cardReg.Card.dwItems; i++)
  209.     {
  210.         WD_ITEMS *pItem = &hPlx->cardReg.Card.Item[i];
  211.  
  212.         switch (pItem->item)
  213.         {
  214.         case ITEM_MEMORY:
  215.         case ITEM_IO:
  216.             {
  217.                 DWORD dwBytes;
  218.                 DWORD dwAddr;
  219.                 DWORD dwPhysAddr;
  220.                 DWORD dwAddrDirect = 0;
  221.                 BOOL fIsMemory;
  222.                 if (pItem->item==ITEM_MEMORY)
  223.                 {
  224.                     dwBytes = pItem->I.Mem.dwBytes;
  225.                     dwAddr = pItem->I.Mem.dwTransAddr;
  226.                     dwAddrDirect = pItem->I.Mem.dwUserDirectAddr;
  227.                     dwPhysAddr = pItem->I.Mem.dwPhysicalAddr;
  228.                     fIsMemory = TRUE;
  229.                 }
  230.                 else 
  231.                 {
  232.                     dwBytes = pItem->I.IO.dwBytes;
  233.                     dwAddr = pItem->I.IO.dwAddr;
  234.                     dwPhysAddr = dwAddr;
  235.                     fIsMemory = FALSE;
  236.                 }
  237.  
  238.                 for (ad_sp=P9060_ADDR_REG; ad_sp<=P9060_ADDR_EPROM; ad_sp++)
  239.                 {
  240.                     DWORD dwPCIAddr;
  241.                     DWORD dwPCIReg;
  242.  
  243.                     if (hPlx->addrDesc[ad_sp].dwAddr) continue;
  244.                     if (ad_sp==P9060_ADDR_REG) dwPCIReg = PCI_BAR0;
  245.                     else if (ad_sp<P9060_ADDR_EPROM) 
  246.                         dwPCIReg = PCI_BAR2 + 4*(ad_sp-P9060_ADDR_SPACE0);
  247.                     else dwPCIReg = PCI_ERBAR;
  248.                     dwPCIAddr = P9060_ReadPCIReg(hPlx, dwPCIReg);
  249.                     if (dwPCIAddr & 1)
  250.                     {
  251.                         if (fIsMemory) continue;
  252.                         dwPCIAddr &= ~0x3;
  253.                     }
  254.                     else
  255.                     {
  256.                         if (!fIsMemory) continue;
  257.                         dwPCIAddr &= ~0xf;
  258.                     }
  259.                     if (dwPCIAddr==dwPhysAddr)
  260.                         break;
  261.                 }
  262.                 if (ad_sp<=P9060_ADDR_EPROM)
  263.                 {
  264.                     DWORD j;
  265.                     hPlx->addrDesc[ad_sp].dwBytes = dwBytes;
  266.                     hPlx->addrDesc[ad_sp].dwAddr = dwAddr;
  267.                     hPlx->addrDesc[ad_sp].dwAddrDirect = dwAddrDirect;
  268.                     hPlx->addrDesc[ad_sp].fIsMemory = fIsMemory;
  269.                     hPlx->addrDesc[ad_sp].dwMask = 0;
  270.                     for (j=1; j<hPlx->addrDesc[ad_sp].dwBytes && j!=0x80000000; j *= 2)
  271.                     {
  272.                         hPlx->addrDesc[ad_sp].dwMask = 
  273.                             (hPlx->addrDesc[ad_sp].dwMask << 1) | 1;
  274.                     }
  275.                 }
  276.             }
  277.             break;
  278.         case ITEM_INTERRUPT:
  279.             if (hPlx->Int.Int.hInterrupt) return FALSE;
  280.             hPlx->Int.Int.hInterrupt = pItem->I.Int.hInterrupt;
  281.             break;
  282.         }
  283.     }
  284.  
  285.     // check that all the items needed were found
  286.     // check if interrupt found
  287.     if (hPlx->fUseInt && !hPlx->Int.Int.hInterrupt) 
  288.     {
  289.         return FALSE;
  290.     }
  291.  
  292.     // check that the registers space was found
  293.     if (!P9060_IsAddrSpaceActive(hPlx, P9060_ADDR_REG)) 
  294.             //|| hPlx->addrDesc[P9060_ADDR_REG].dwBytes!=P9060_RANGE_REG)
  295.         return FALSE;
  296.  
  297.     // check that address space 0 was found
  298.     if (!P9060_IsAddrSpaceActive(hPlx, P9060_ADDR_SPACE0)) return FALSE;
  299.     hPlx->addrSpace = P9060_ADDR_SPACE0;
  300.  
  301.     return TRUE;
  302. }
  303.  
  304. void P9060_Close(P9060_HANDLE hPlx)
  305. {
  306.     // disable interrupts
  307.     if (P9060_IntIsEnabled(hPlx))
  308.         P9060_IntDisable(hPlx);
  309.  
  310.     // unregister card
  311.     if (hPlx->cardReg.hCard) 
  312.         WD_CardUnregister(hPlx->hWD, &hPlx->cardReg);
  313.  
  314.     // close WinDriver
  315.     WD_Close(hPlx->hWD);
  316.  
  317.     free (hPlx);
  318. }
  319.  
  320. BOOL P9060_IsAddrSpaceActive(P9060_HANDLE hPlx, P9060_ADDR addrSpace)
  321. {
  322.     return hPlx->addrDesc[addrSpace].dwAddr!=0;
  323. }
  324.  
  325. DWORD P9060_ReadReg (P9060_HANDLE hPlx, DWORD dwReg)
  326. {
  327.     return P9060_ReadSpaceDWord(hPlx, P9060_ADDR_REG, dwReg);
  328. }
  329.  
  330. void P9060_WriteReg (P9060_HANDLE hPlx, DWORD dwReg, DWORD dwData)
  331. {
  332.     P9060_WriteSpaceDWord(hPlx, P9060_ADDR_REG, dwReg, dwData);
  333. }
  334.  
  335. BYTE P9060_ReadSpaceByte (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset)
  336. {
  337.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  338.     {
  339.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  340.         BYTE *pByte = (BYTE *) dwAddr;
  341.         return *pByte;
  342.     }
  343.     else
  344.     {
  345.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  346.         WD_TRANSFER trans;
  347.         BZERO(trans);
  348.         trans.cmdTrans = RP_BYTE;
  349.         trans.dwPort = dwAddr;
  350.         WD_Transfer (hPlx->hWD, &trans);
  351.         return trans.Data.Byte;
  352.     }
  353. }
  354.  
  355. void P9060_WriteSpaceByte (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset, BYTE data)
  356. {
  357.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  358.     {
  359.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  360.         BYTE *pByte = (BYTE *) dwAddr;
  361.         *pByte = data;
  362.     }
  363.     else
  364.     {
  365.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  366.         WD_TRANSFER trans;
  367.         BZERO(trans);
  368.         trans.cmdTrans = WP_BYTE;
  369.         trans.dwPort = dwAddr;
  370.         trans.Data.Byte = data;
  371.         WD_Transfer (hPlx->hWD, &trans);
  372.     }
  373. }
  374.  
  375. WORD P9060_ReadSpaceWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset)
  376. {
  377.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  378.     {
  379.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  380.         WORD *pWord = (WORD *) dwAddr;
  381.         return *pWord;
  382.     }
  383.     else
  384.     {
  385.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  386.         WD_TRANSFER trans;
  387.         BZERO(trans);
  388.         trans.cmdTrans = RP_WORD;
  389.         trans.dwPort = dwAddr;
  390.         WD_Transfer (hPlx->hWD, &trans);
  391.         return trans.Data.Word;
  392.     }
  393. }
  394.  
  395. void P9060_WriteSpaceWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset, WORD data)
  396. {
  397.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  398.     {
  399.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  400.         WORD *pWord = (WORD *) dwAddr;
  401.         *pWord = data;
  402.     }
  403.     else
  404.     {
  405.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  406.         WD_TRANSFER trans;
  407.         BZERO(trans);
  408.         trans.cmdTrans = WP_WORD;
  409.         trans.dwPort = dwAddr;
  410.         trans.Data.Word = data;
  411.         WD_Transfer (hPlx->hWD, &trans);
  412.     }
  413. }
  414.  
  415. DWORD P9060_ReadSpaceDWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset)
  416. {
  417.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  418.     {
  419.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  420.         DWORD *pDword = (DWORD *) dwAddr;
  421.         return *pDword;
  422.     }
  423.     else
  424.     {
  425.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  426.         WD_TRANSFER trans;
  427.         BZERO(trans);
  428.         trans.cmdTrans = RP_DWORD;
  429.         trans.dwPort = dwAddr;
  430.         WD_Transfer (hPlx->hWD, &trans);
  431.         return trans.Data.Dword;
  432.     }
  433. }
  434.  
  435. void P9060_WriteSpaceDWord (P9060_HANDLE hPlx, P9060_ADDR addrSpace, DWORD dwOffset, DWORD data)
  436. {
  437.     if (hPlx->addrDesc[addrSpace].fIsMemory)
  438.     {
  439.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddrDirect + dwOffset;
  440.         DWORD *pDword = (DWORD *) dwAddr;
  441.         *pDword = data;
  442.     }
  443.     else
  444.     {
  445.         DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  446.         WD_TRANSFER trans;
  447.         BZERO(trans);
  448.         trans.cmdTrans = WP_DWORD;
  449.         trans.dwPort = dwAddr;
  450.         trans.Data.Dword = data;
  451.         WD_Transfer (hPlx->hWD, &trans);
  452.     }
  453. }
  454.  
  455. void P9060_ReadWriteSpaceBlock (P9060_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
  456.                     DWORD dwBytes, BOOL fIsRead, P9060_ADDR addrSpace, P9060_MODE mode)
  457. {
  458.     DWORD dwAddr = hPlx->addrDesc[addrSpace].dwAddr + dwOffset;
  459.     WD_TRANSFER trans;
  460.  
  461.     BZERO(trans);
  462.  
  463.     if (hPlx->addrDesc[addrSpace].fIsMemory) 
  464.     {
  465.         if (fIsRead) 
  466.         {
  467.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
  468.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = RM_SWORD;
  469.             else trans.cmdTrans = RM_SDWORD;
  470.         }
  471.         else 
  472.         {
  473.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
  474.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = WM_SWORD;
  475.             else trans.cmdTrans = WM_SDWORD;
  476.         }
  477.     }
  478.     else 
  479.     {
  480.         if (fIsRead) 
  481.         {
  482.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
  483.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = RP_SWORD;
  484.             else trans.cmdTrans = RP_SDWORD;
  485.         }
  486.         else 
  487.         {
  488.             if (mode==P9060_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
  489.             else if (mode==P9060_MODE_WORD) trans.cmdTrans = WP_SWORD;
  490.             else trans.cmdTrans = WP_SDWORD;
  491.         }
  492.     }
  493.     trans.dwPort = dwAddr;
  494.     trans.fAutoinc = TRUE;
  495.     trans.dwBytes = dwBytes;
  496.     trans.dwOptions = 0;
  497.     trans.Data.pBuffer = buf;
  498.     WD_Transfer (hPlx->hWD, &trans);
  499. }
  500.  
  501. void P9060_ReadSpaceBlock (P9060_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
  502.                     DWORD dwBytes, P9060_ADDR addrSpace, P9060_MODE mode)
  503. {
  504.     P9060_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, TRUE, addrSpace, mode);
  505. }
  506.  
  507. void P9060_WriteSpaceBlock (P9060_HANDLE hPlx, DWORD dwOffset, PVOID buf, 
  508.                      DWORD dwBytes, P9060_ADDR addrSpace, P9060_MODE mode)
  509. {
  510.     P9060_ReadWriteSpaceBlock (hPlx, dwOffset, buf, dwBytes, FALSE, addrSpace, mode);
  511. }
  512.  
  513. void P9060_SetMode (P9060_HANDLE hPlx, P9060_MODE mode, DWORD dwLocalAddr)
  514. {
  515.     P9060_WriteReg (hPlx, P9060_REGION_DESC, hPlx->modeDesc[mode]);
  516.     hPlx->addrDesc[hPlx->addrSpace].dwLocalBase = dwLocalAddr & ~hPlx->addrDesc[hPlx->addrSpace].dwMask;
  517.     hPlx->addrDesc[hPlx->addrSpace].dwLocalBase |= BIT0;
  518.     P9060_WriteReg (hPlx, P9060_REMAP_PTOL_0, hPlx->addrDesc[hPlx->addrSpace].dwLocalBase);
  519. }
  520.  
  521. BYTE P9060_ReadByte (P9060_HANDLE hPlx, DWORD dwLocalAddr)
  522. {
  523.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  524.     P9060_SetMode (hPlx, P9060_MODE_BYTE, dwLocalAddr);
  525.     return P9060_ReadSpaceByte(hPlx, hPlx->addrSpace, dwOffset);
  526. }
  527.  
  528. void P9060_WriteByte (P9060_HANDLE hPlx, DWORD dwLocalAddr, BYTE data)
  529. {
  530.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  531.     P9060_SetMode (hPlx, P9060_MODE_BYTE, dwLocalAddr);
  532.     P9060_WriteSpaceByte(hPlx, hPlx->addrSpace, dwOffset, data);
  533. }
  534.  
  535. WORD P9060_ReadWord (P9060_HANDLE hPlx, DWORD dwLocalAddr)
  536. {
  537.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  538.     P9060_SetMode (hPlx, P9060_MODE_WORD, dwLocalAddr);
  539.     return P9060_ReadSpaceWord(hPlx, hPlx->addrSpace, dwOffset);
  540. }
  541.  
  542. void P9060_WriteWord (P9060_HANDLE hPlx, DWORD dwLocalAddr, WORD data)
  543. {
  544.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  545.     P9060_SetMode (hPlx, P9060_MODE_WORD, dwLocalAddr);
  546.     P9060_WriteSpaceWord(hPlx, hPlx->addrSpace, dwOffset, data);
  547. }
  548.  
  549. DWORD P9060_ReadDWord (P9060_HANDLE hPlx, DWORD dwLocalAddr)
  550. {
  551.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  552.     P9060_SetMode (hPlx, P9060_MODE_DWORD, dwLocalAddr);
  553.     return P9060_ReadSpaceDWord(hPlx, hPlx->addrSpace, dwOffset);
  554. }
  555.  
  556. void P9060_WriteDWord (P9060_HANDLE hPlx, DWORD dwLocalAddr, DWORD data)
  557. {
  558.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  559.     P9060_SetMode (hPlx, P9060_MODE_DWORD, dwLocalAddr);
  560.     P9060_WriteSpaceDWord(hPlx, hPlx->addrSpace, dwOffset, data);
  561. }
  562.  
  563. void P9060_ReadWriteBlock (P9060_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
  564.                     DWORD dwBytes, BOOL fIsRead, P9060_MODE mode)
  565. {
  566.     DWORD dwOffset = hPlx->addrDesc[hPlx->addrSpace].dwMask & dwLocalAddr;
  567.     P9060_SetMode (hPlx, mode, dwLocalAddr);
  568.     P9060_ReadWriteSpaceBlock(hPlx, dwOffset, buf, dwBytes, fIsRead, hPlx->addrSpace, mode);
  569. }
  570.  
  571. void P9060_ReadBlock (P9060_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
  572.                     DWORD dwBytes, P9060_MODE mode)
  573. {
  574.     P9060_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, TRUE, mode);
  575. }
  576.  
  577. void P9060_WriteBlock (P9060_HANDLE hPlx, DWORD dwLocalAddr, PVOID buf, 
  578.                      DWORD dwBytes, P9060_MODE mode)
  579. {
  580.     P9060_ReadWriteBlock (hPlx, dwLocalAddr, buf, dwBytes, FALSE, mode);
  581. }
  582.  
  583. BOOL P9060_IntIsEnabled (P9060_HANDLE hPlx)
  584. {
  585.     if (!hPlx->fUseInt) return FALSE;
  586.     if (!hPlx->Int.hThread) return FALSE;
  587.     return TRUE;
  588. }
  589.  
  590. VOID P9060_IntHandler (PVOID pData)
  591. {
  592.     P9060_HANDLE hPlx = (P9060_HANDLE) pData;
  593.     P9060_INT_RESULT intResult;
  594.  
  595.     intResult.dwCounter = hPlx->Int.Int.dwCounter;
  596.     intResult.dwLost = hPlx->Int.Int.dwLost;
  597.     intResult.fStopped = hPlx->Int.Int.fStopped;
  598.     intResult.dwStatusReg = hPlx->Int.Trans[0].Data.Dword;
  599.     hPlx->Int.funcIntHandler(hPlx, &intResult);
  600. }
  601.  
  602. BOOL P9060_IntEnable (P9060_HANDLE hPlx, P9060_INT_HANDLER funcIntHandler)
  603. {
  604.     DWORD dwIntStatus;
  605.     DWORD dwAddr;
  606.  
  607.     if (!hPlx->fUseInt) return FALSE;
  608.     // check if interrupt is already enabled
  609.     if (hPlx->Int.hThread) return FALSE;
  610.  
  611.     dwIntStatus = P9060_ReadReg (hPlx, P9060_INT_STATUS);
  612.  
  613.     BZERO(hPlx->Int.Trans);
  614.     // This is a samlpe of handling interrupts:
  615.     // Two transfer commands are issued. First the value of the interrrupt control/status
  616.     // register is read. Then, a value of ZERO is written.
  617.     // This will cancel interrupts after the first interrupt occurs.
  618.     // When using interrupts, this section will have to change:
  619.     // you must put transfer commands to CANCEL the source of the interrupt, otherwise, the 
  620.     // PC will hang when an interrupt occurs!
  621.     dwAddr = hPlx->addrDesc[P9060_ADDR_REG].dwAddr + P9060_INT_STATUS;
  622.     hPlx->Int.Trans[0].cmdTrans = hPlx->addrDesc[P9060_ADDR_REG].fIsMemory ? RM_DWORD : RP_DWORD;
  623.     hPlx->Int.Trans[0].dwPort = dwAddr;
  624.     hPlx->Int.Trans[1].cmdTrans = hPlx->addrDesc[P9060_ADDR_REG].fIsMemory ? WM_DWORD : WP_DWORD;
  625.     hPlx->Int.Trans[1].dwPort = dwAddr;
  626.     hPlx->Int.Trans[1].Data.Dword = dwIntStatus & ~(BIT8|BIT10); // put here the data to write to the control register
  627.     hPlx->Int.Int.dwCmds = 2; 
  628.     hPlx->Int.Int.Cmd = hPlx->Int.Trans;
  629.     hPlx->Int.Int.dwOptions |= INTERRUPT_CMD_COPY;
  630.  
  631.     // create interrupt handler thread
  632.     hPlx->Int.funcIntHandler = funcIntHandler;
  633.     if (!InterruptThreadEnable(&hPlx->Int.hThread, hPlx->hWD, &hPlx->Int.Int, P9060_IntHandler, (PVOID) hPlx))
  634.         return FALSE;
  635.  
  636.     // this enables interrupts
  637.     P9060_WriteReg (hPlx, P9060_INT_STATUS, dwIntStatus | (BIT8|BIT10));
  638.  
  639.     return TRUE;
  640. }
  641.  
  642. void P9060_IntDisable (P9060_HANDLE hPlx)
  643. {
  644.     DWORD dwIntStatus;
  645.  
  646.     if (!hPlx->fUseInt) return;
  647.     if (!hPlx->Int.hThread) return;
  648.  
  649.     // this disables interrupts
  650.     dwIntStatus = P9060_ReadReg (hPlx, P9060_INT_STATUS);
  651.     P9060_WriteReg (hPlx, P9060_INT_STATUS, dwIntStatus & ~(BIT8|BIT10));
  652.  
  653.     // this calls WD_IntDisable()
  654.     InterruptThreadDisable(hPlx->Int.hThread);
  655.     hPlx->Int.hThread = NULL;
  656. }
  657.  
  658.