Subversion Repositories f9daq

/*
   cc32lib_NT.c -- a simple access library for the PCICC32 PCI to CAMAC Interface
                   from ARW Elektronik - the WINNT parts

   (c) 2000 ARW Elektronik

   this source code is published under GPL (Open Source). You can use, redistrubute and
   modify it unless this header   is not modified or deleted. No warranty is given that
   this software will work like expected.
   This product is not authorized for use as critical component in life support systems
   wihout the express written approval of ARW Elektronik Germany.
 
   Please announce changes and hints to ARW Elektronik

   derived from the previous WIN95 library                              AR   30.07.2000
   added buffer, UNTIL_NOT_Q and AUTOREAD functionality                 AR   17.03.2001
*/
 
/*--- INCLUDES -----------------------------------------------------------------------------------*/
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <winioctl.h>

#include "pcicc32.h"  /* PCI common ioctl commands and structures between driver and library  */
#include "libcc32_NT.h"          /* shared header bewteen applictaion and library                        */

/*--- DEFINES ------------------------------------------------------------------------------------*/
#define DEFDEVICENAME "\\\\.\\PCICC32:\\CC32_xx"

/*--- EXTERNALS ----------------------------------------------------------------------------------*/

/*--- TYPEDEFS -----------------------------------------------------------------------------------*/
typedef struct
{
        HANDLE nHandle;                     /* the handle of this device */
        int    nModuleNumber;               /* the number of the module */
        unsigned short wLastAccessWidth;    /* the last parametrized data access width */
        unsigned short wLastAttributes;     /* the last Attributes to this channel */
        unsigned long  dwLastAccessAddress; /* the last access address to speed up */
} CC32_DEVICE_NT;

/*--- FUNCTIONS -----------------------------------------------------------------------*/

//--------------------------------------------------------------------------------------
// get the PCIADA status from the PCI side of the interface
//
static int getStatus(HANDLE nHandle, DWORD dwInterface, char *nTimeout, char *nLAM)
{
        PCICC32_STATUS status;
        DWORD DIOC_count;             // count of returned bytes of DeviceIoControl
        DWORD result;

        if (nHandle == (HANDLE)-1) return -1;

        *nTimeout = *nLAM = 0;

        // attach a window into the CC32 space ----------------
        result = DeviceIoControl(nHandle, PCICC32_GET_STATUS,
                                                &dwInterface, sizeof(dwInterface),
                                                &status,      sizeof(status), &DIOC_count, NULL);

    if (!result)
                return GetLastError();
        else
        {
                *nTimeout = (char)status.bTimeout;
                *nLAM     = (char)status.bInterrupt;

                return 0;
        }
}

//--------------------------------------------------------------------------------------
// clear the PCIADA status
//
static int clearStatus(HANDLE nHandle, DWORD dwInterface)
{
        DWORD DIOC_count;             // count of returned bytes of DeviceIoControl
        DWORD result;

        if (nHandle == (HANDLE)-1) return -1;

        // attach a window into the CC32 space ----------------
        result = DeviceIoControl(nHandle, PCICC32_CLEAR_STATUS,
                                                &dwInterface, sizeof(dwInterface),
                                                NULL,      0, &DIOC_count, NULL);

    if (!result)
                return GetLastError();
        else
                return 0;
}

//-------------------------------------------------------------------------
// set the future access parameters - override the current
//
static int setAccessParameter(HANDLE hHandle, USHORT wAccessType, USHORT wBlockTransfer)
{
        DWORD result;
        DWORD   DIOC_count;     // count of returned bytes of DeviceIoControl
    PCICC32_ACCESS_COMMAND access_parameter;

        access_parameter.wAccessType            = wAccessType;
        access_parameter.wBlockTransfer         = wBlockTransfer;

        result = DeviceIoControl(hHandle, PCICC32_SET_ACCESS_PARA,
                                        &access_parameter, (DWORD)sizeof(access_parameter), NULL,
                                                   0, &DIOC_count, NULL);      
        if (!result)
                return GetLastError();
        else
                return 0;
}

//-------------------------------------------------------------------------
// create a DeviceName out of cszDeviceName and nIfcNum
//
static char *DeviceName(int nIfcNum)
{
        static char buffer[255];
        char *ptr = buffer;

        strncpy(buffer, DEFDEVICENAME, strlen(DEFDEVICENAME));

        while (*ptr) ptr++;
       
        do
        {
                ptr--;
        } while (*ptr != '_');  // step back until '-'

        ptr++;
       
        if (nIfcNum >= 10)      // add the interface number
        {
                *ptr++   = '1';
                nIfcNum -= 10;
        }

        *ptr++ = '0' + nIfcNum;
        *ptr = 0;

        // a little help for the users
    return buffer;
}

//-------------------------------------------------------------------------
// open my path to the interface
//
static HANDLE openPath(char *name)
{
    return (HANDLE)CreateFile(
                     name,
                     GENERIC_READ | GENERIC_WRITE,
                     0,
                     NULL,
                     OPEN_EXISTING,
                     FILE_ATTRIBUTE_NORMAL,
                     NULL
                     );
}

//--------------------------------------------------------------------------------------
// open the device
//
int cc32_open_NT(char *cszPath, int nModuleNumber, void **handle)
{
        CC32_DEVICE_NT *dev;
        int error = 0;
       
        *handle = (void *)0;
       
        dev = (CC32_DEVICE_NT *)malloc(sizeof(CC32_DEVICE_NT));
        if (!dev) return errno;
       
        dev->nModuleNumber = nModuleNumber;
        dev->nHandle = INVALID_HANDLE_VALUE;
        dev->wLastAccessWidth    = 0xffff;         /* invalidate for future use */

        // start the driver ------------------
        dev->nHandle = openPath(DeviceName(nModuleNumber));
       
        if (dev->nHandle == INVALID_HANDLE_VALUE)
                error = GetLastError();
        else
        {
                SetFilePointer(dev->nHandle, 0, NULL, FILE_BEGIN);
                dev->dwLastAccessAddress = 0;
                dev->wLastAttributes = 0;
                dev->wLastAccessWidth = 0;
        }

        if (error)
        {
                free(dev);
                return error;
        }

        *handle = (void *)dev;
       
        return NO_ERROR;
}

//--------------------------------------------------------------------------------------
// close the device
//
int cc32_close_NT(void *handle)
{
        CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        int error = NO_ERROR;
       
        if (dev)
        {
                if (dev->nHandle != INVALID_HANDLE_VALUE)
                        CloseHandle(dev->nHandle);
       
                free(dev);
        }
        else
                error = ERROR_INVALID_FUNCTION;
               
        return error;
}

//--------------------------------------------------------------------------------------
// read a word
//
unsigned short cc32_read_word_NT(void *handle, unsigned int N, unsigned int A, unsigned int F)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long  adr = NAF(N,A,F);
        unsigned short buffer;
        unsigned long  bytesRead;

        // cache the data access width
        if (dev->wLastAccessWidth != WORD_ACCESS)
        {
                dev->wLastAccessWidth = WORD_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        ReadFile(dev->nHandle, &buffer, WORD_ACCESS, &bytesRead, NULL);

        return buffer;
}

//--------------------------------------------------------------------------------------
// read a long
//
unsigned long cc32_read_long_all_NT(void *handle, unsigned int N, unsigned int A, unsigned int F)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long  adr = NAF(N,A,F);
        unsigned long  buffer;
        unsigned long  bytesRead;

        // cache the data access width
        if (dev->wLastAccessWidth != LONG_ACCESS)
        {
                dev->wLastAccessWidth = LONG_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        ReadFile(dev->nHandle, &buffer, LONG_ACCESS, &bytesRead, NULL);

        return buffer;
}

//--------------------------------------------------------------------------------------
// read a long and get Q and X
//
unsigned long cc32_read_long_NT(void *handle, unsigned int N, unsigned int A, unsigned int F, char *Q, char *X)
{
        unsigned long erg = cc32_read_long_all_NT(handle, N, A, F);
       
        *Q = (erg & 0x80000000) ? 1 : 0;
        *X = (erg & 0x40000000) ? 1 : 0;

        return erg & 0x00FFFFFF;
}

//--------------------------------------------------------------------------------------
// write a word
//
void cc32_write_word_NT(void *handle, unsigned int N, unsigned int A, unsigned int F, unsigned short uwData)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long adr = NAF(N,A,F);
        DWORD bytesWritten;
       
        // cache the data access width
        if (dev->wLastAccessWidth != WORD_ACCESS)
        {
                dev->wLastAccessWidth = WORD_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        WriteFile(dev->nHandle, &uwData, WORD_ACCESS, &bytesWritten, NULL);
}

//--------------------------------------------------------------------------------------
// write a long
//
void cc32_write_long_NT(void *handle, unsigned int N, unsigned int A, unsigned int F, unsigned long ulData)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long adr = NAF(N,A,F);
        DWORD bytesWritten;
       
        // cache the data access width
        if (dev->wLastAccessWidth != LONG_ACCESS)
        {
                dev->wLastAccessWidth = LONG_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        WriteFile(dev->nHandle, &ulData, LONG_ACCESS, &bytesWritten, NULL);
}

//--------------------------------------------------------------------------------------
// clear the PCIADA status
//
int cc32_poll_error_NT(void *handle, char *nTimeout, char *nLam)
{
        CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        int error;
       
    if ((error = getStatus(dev->nHandle, dev->nModuleNumber, nTimeout, nLam)))
                return error;
               
        if (*nTimeout)  /* clear error */
        {
                if ((error = clearStatus(dev->nHandle, dev->nModuleNumber)))
                        return error;  
        }
       
        return NO_ERROR;
}

//--------------------------------------------------------------------------------------
// read 'len' words or 'UNTIL_NOT_Q' from a address made out of N,A,F
//
int cc32_read_word_buffer_NT(void * handle, unsigned int N, unsigned int A, unsigned int F,
                                                                                                                                unsigned short *pwBuffer, unsigned long *pdwLen)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long  adr = NAF(N,A,F);
        unsigned long dwLen;

        // cache the data access width
        if (dev->wLastAccessWidth != WORD_ACCESS)
        {
                dev->wLastAccessWidth = WORD_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        *pdwLen <<= 1;  // make bytes
        dwLen = *pdwLen;
        if (!ReadFile(dev->nHandle, pwBuffer, dwLen, pdwLen, NULL))
                return GetLastError();

        *pdwLen >>= 1;  // make words
        return 0;
}

//--------------------------------------------------------------------------------------
// read 'len' longs or 'UNTIL_NOT_Q' from a address made out of N,A,F, mask 24 bits out
//
int cc32_read_long_buffer_NT(void * handle, unsigned int N, unsigned int A, unsigned int F,
                                                                                                                                unsigned long *pdwBuffer, unsigned long *pdwLen)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long  adr = NAF(N,A,F);
        unsigned long *pdwPtr = pdwBuffer;
        unsigned long *pdwEnd = pdwBuffer;
        unsigned long dwLen;

        // cache the data access width
        if (dev->wLastAccessWidth != LONG_ACCESS)
        {
                dev->wLastAccessWidth = LONG_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        *pdwLen <<= 2;   // make bytes
        dwLen = *pdwLen;
        if (!ReadFile(dev->nHandle, pdwBuffer, dwLen, pdwLen, NULL))
                return GetLastError();

        pdwEnd += *pdwLen;
        while (pdwEnd < pdwPtr)
                *pdwPtr++ &= 0x00FFFFFF;  // mask Q and X bits

        *pdwLen >>= 2;   // make longs
        return 0;
}

//--------------------------------------------------------------------------------------
// read 'len' longs or 'UNTIL_NOT_Q' from a address made out of N,A,F, without interpretation
//
int cc32_read_long_all_buffer_NT(void * handle, unsigned int N, unsigned int A, unsigned int F,
                                                                                                                                unsigned long *pdwBuffer, unsigned long *pdwLen)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        unsigned long  adr = NAF(N,A,F);
        unsigned long dwLen;

        // cache the data access width
        if (dev->wLastAccessWidth != LONG_ACCESS)
        {
                dev->wLastAccessWidth = LONG_ACCESS;
                setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
        }

        // cache the address
        if (dev->dwLastAccessAddress != adr)
        {
          SetFilePointer(dev->nHandle, adr, NULL, FILE_BEGIN);
          dev->dwLastAccessAddress = adr;
        }

        *pdwLen <<= 2;   // make bytes
        dwLen = *pdwLen;
        if (!ReadFile(dev->nHandle, pdwBuffer, dwLen, pdwLen, NULL))
                return GetLastError();

        *pdwLen >>= 2;   // make longs
        return 0;
}

//--------------------------------------------------------------------------------------
// switch UNTIL_NOT_Q or AUTOREAD on or off
//
int cc32_access_switch_NT(void *handle, unsigned short uwSwitch)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;

        dev->wLastAttributes  = uwSwitch;
        return setAccessParameter(dev->nHandle, dev->wLastAccessWidth, dev->wLastAttributes);
}

//--------------------------------------------------------------------------------------
// switch interrupts on
//
int cc32_enable_interrupt_NT(void *handle)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        DWORD result;
        DWORD   DIOC_count;     // count of returned bytes of DeviceIoControl
        PCICC32_IRQ_CONTROL irqCntrl;

        irqCntrl.dwInterface = 0;  // don't bother at WINNT
        irqCntrl.wEnable     = 1;  // enable it

        result = DeviceIoControl(dev->nHandle, PCICC32_CONTROL_INTERRUPTS,
                                        &irqCntrl, sizeof(irqCntrl), NULL, 0, &DIOC_count, NULL);        

        if (!result)
                return GetLastError();
        else
                return NO_ERROR;
}

//--------------------------------------------------------------------------------------
// switch interrupts off
//
int cc32_disable_interrupt_NT(void *handle)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        DWORD result;
        DWORD   DIOC_count;     // count of returned bytes of DeviceIoControl
        PCICC32_IRQ_CONTROL irqCntrl;

        irqCntrl.dwInterface = 0;  // don't bother at WINNT
        irqCntrl.wEnable     = 0;  // disable it

        result = DeviceIoControl(dev->nHandle, PCICC32_CONTROL_INTERRUPTS,
                                        &irqCntrl, sizeof(irqCntrl), NULL, 0, &DIOC_count, NULL);        

        if (!result)
                return GetLastError();
        else
                return NO_ERROR;
}

//--------------------------------------------------------------------------------------
// wait blocking for the next interrupt
//
int cc32_get_interrupt_NT(void *handle, unsigned long *dwStatus)
{
        register CC32_DEVICE_NT *dev = (CC32_DEVICE_NT *)handle;
        DWORD result;
        DWORD   DIOC_count;     // count of returned bytes of DeviceIoControl
        PCICC32_IRQ_RESPONSE response;
        int nError;
        OVERLAPPED sOverlapped;

        sOverlapped.hEvent    = NULL;
        result = DeviceIoControl(dev->nHandle, PCICC32_INSTALL_IRQ_BLOCK,
                                        NULL, 0, &response, sizeof(response), &DIOC_count, NULL);
       
        *dwStatus = response.dwInterruptFlags;

        if (!result)
        {
                nError = GetLastError();

                // a real error
                if ((nError != ERROR_IO_PENDING) && (nError != ERROR_SUCCESS))
                        return nError;

                // my IO is pending - wait for it
                if (nError == ERROR_IO_PENDING)
                {
                        result = GetOverlappedResult(dev->nHandle, &sOverlapped, &DIOC_count, TRUE);
                       
                        *dwStatus = response.dwInterruptFlags;

                        if (!result)
                        {
                                nError = GetLastError();   // if it was cancelled
                                if (nError == ERROR_OPERATION_ABORTED)
                                        return NO_ERROR;       // accept it as 'normal'
                                else
                                        return nError;
                        }
                }
        }

        return NO_ERROR;
}