Subversion Repositories f9daq

//-------------------------------------------------------------------------

// WINNT driver for PCICC32 interface from ARW Elektronik, Germany --------

// all around recognition and basic services of VMEMM

//

// (c) 2000-2002 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

//

// what                                            who          when

// started from pcivme_v.c                         AR           02.07.2000

// changed making procedure (only VCC > 6.0)       AR           30.05.2002

//

//-------------------------------------------------------------------------

// INCLUDES

//

#include <ntddk.h>

#include <pcicc32_drv.h>

#include <pcicc32_v.h>

#include <pcicc32_local.h>  // all around the pciada interface

#ifndef WORD                            // don't touch include files of WIN95 driver

#define WORD USHORT

#endif

#ifndef DWORD

#define DWORD ULONG

#endif

//------------------------------------------------------------------------

// PROTOTYPES

//

//------------------------------------------------------------------------

// GLOBALS

//

//------------------------------------------------------------------------

// FUNCTIONS

//

//------------------------------------------------------------------------

// test connection to VMEMM devices without disturbing anything 

//

//---------------------------------------------------------------------

// checks a connection with a small test pattern

//

NTSTATUS TestConnection(PCIADA *pciada)

{

        USHORT *pwADRH = (USHORT *)_WORD_NAF(pciada->pvVirtIfr, 30, 1, 0);

        USHORT *pwADRL = (USHORT *)_WORD_NAF(pciada->pvVirtIfr, 30, 0, 0);

        int i;

        USHORT wRet;

    USHORT wADRHContent;

    USHORT wADRLContent;

        KdPrint(("TestConnection()\n"));

        wADRHContent = READ_REGISTER_USHORT(pwADRH);    // save previous content

        wADRLContent = READ_REGISTER_USHORT(pwADRL);

        for (i = 0; i < 10000; i++)

        {

                WRITE_REGISTER_USHORT(pwADRH, 0x5555);

                WRITE_REGISTER_USHORT(pwADRL, 0xAAAA);

                wRet = READ_REGISTER_USHORT(pwADRH);

                if (wRet != 0x5555) return STATUS_UNSUCCESSFUL;

                WRITE_REGISTER_USHORT(pwADRH, 0xAAAA);

                WRITE_REGISTER_USHORT(pwADRL, 0x5555);

                wRet = READ_REGISTER_USHORT(pwADRH);

                if (wRet != 0xAAAA) return STATUS_UNSUCCESSFUL;

                WRITE_REGISTER_USHORT(pwADRH, 0x0000);

                WRITE_REGISTER_USHORT(pwADRL, 0xFFFF);

                wRet = READ_REGISTER_USHORT(pwADRH);

                if (wRet != 0x0000) return STATUS_UNSUCCESSFUL;

                WRITE_REGISTER_USHORT(pwADRH, 0xFFFF);

                WRITE_REGISTER_USHORT(pwADRL, 0x0000);

                wRet = READ_REGISTER_USHORT(pwADRH);

                if (wRet != 0xFFFF) return STATUS_UNSUCCESSFUL;

        }

        WRITE_REGISTER_USHORT(pwADRH, wADRHContent);    // restore previous content

        WRITE_REGISTER_USHORT(pwADRL, wADRLContent);

        KdPrint(("TestConnection() OK.\n"));

        return STATUS_SUCCESS;

}

//------------------------------------------------------------------------

// scan VMEMM devices without disturbing anything 

//

NTSTATUS PCICC32ScanCC32(PDEVICE_OBJECT deviceObj)

{

        int i;

        int nPCIADAs = ((DEVICE_EXT*)(deviceObj->DeviceExtension))->nPCIADAs;

        PCIADA           *pciada;

        USHORT           wCntrl;

        USHORT                   wIntCSR;

        USHORT                   wModuleStatus;

        KdPrint(("PCICC32ScanCC32(nPCIADAs = %d)\n", nPCIADAs));

    for (i = 0; i < nPCIADAs; i++)

    {

                pciada = &((DEVICE_EXT*)(deviceObj->DeviceExtension))->pciada[i];

                wCntrl  = READ_REGISTER_USHORT(pciada->pwCntrl);   // save it for later use

        wIntCSR = READ_REGISTER_USHORT(pciada->pwIntCSR);

                KdPrint(("wCntrl = 0x%04x, wIntCSR = 0x%04x\n", wCntrl, wIntCSR));

                WRITE_REGISTER_USHORT(pciada->pwCntrl, INHIBIT_CC32);  // switch off before open

                WRITE_REGISTER_USHORT(pciada->pwIntCSR, DISABLE_PCIADA_IRQS);

                WRITE_REGISTER_USHORT(pciada->pwCntrl, RELEASE_CC32);  // open it for test

                if (wCntrl & 0x0800)

                {

                        if (TestConnection(pciada) == STATUS_SUCCESS)

                        {      

                                wModuleStatus  = READ_REGISTER_USHORT(pciada->pvVirtIfr);

                                pciada->bConnected              = TRUE;

                                // interpret the content

                                pciada->wModuleNumber   = (wModuleStatus & MASK_MODNR)   >> 4;

                                pciada->wFPGAVersion    = (wModuleStatus & MASK_FPGA)    >> 8;

                                pciada->wModuleType             = (wModuleStatus & MASK_MODTYPE) >> 12;

                                KdPrint(("PCIADA %d <-> CC32 %d\n", i, pciada->wModuleNumber));

                        }

                        else

                                pciada->wModuleNumber = 0xFFFF;  // not recognized, take it out

                }

                else

                        pciada->wModuleNumber = 0xFFFF;  // not recognized, take it out

                if (pciada->wModuleNumber != 0xFFFF)

                  WRITE_REGISTER_USHORT(pciada->pwCntrl,  wCntrl);   // restore state

                else

                  WRITE_REGISTER_USHORT(pciada->pwCntrl,  INHIBIT_CC32);  

                WRITE_REGISTER_USHORT(pciada->pwIntCSR, wIntCSR);    // restore interrupt masks

    }

        return STATUS_SUCCESS;

}

//------------------------------------------------------------------------

// deinit all PCIADAs in a passive state 

//

NTSTATUS PCICC32DeInitPCIADAs(PDEVICE_OBJECT deviceObj)

{

        int              i;

        DEVICE_EXT       *pDevExt = (DEVICE_EXT*)deviceObj->DeviceExtension;

        int                              nPCIADAs = pDevExt->nPCIADAs;

        PCIADA           *pciada;

        KdPrint(("PCICC32DeInitPCIADAs()\n"));

        // dis connect the interrupts to service routines

        for (i = 0; i < nPCIADAs; i++)

        {

                pciada = &pDevExt->pciada[i];

                WRITE_REGISTER_USHORT(pciada->pwCntrl,  INHIBIT_CC32);

                // this is the same as globalInterruptDisable(pciada);

                WRITE_REGISTER_USHORT(pciada->pwIntCSR, DISABLE_PCIADA_IRQS);

        }

        return STATUS_SUCCESS;

}

//------------------------------------------------------------------------

// switches pciada on or off 

//

void enableCC32(PCIADA *pciada)

{

        WRITE_REGISTER_USHORT(pciada->pwCntrl,  RELEASE_CC32);

}

void disableCC32(PCIADA *pciada)

{

        WRITE_REGISTER_USHORT(pciada->pwCntrl,  INHIBIT_CC32);

}