Subversion Repositories f9daq

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

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

// functions for a fast fifo (first in first out) implementation

//

// (c) 1999-2004 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

//

// $Log: pcivme_fifo.c,v $

// Revision 1.3  2004/07/24 07:07:26  klaus

// Update copyright to 2004

//

// Revision 1.2  2003/11/15 19:12:50  klaus

// Update copyright to 2003

//

// Revision 1.1.1.1  2003/11/14 23:16:33  klaus

// First put into repository

//

// Revision 1.3  2002/10/27 16:17:48  klaus

// Typing bug fixed caused at log addition

//

// Revision 1.2  2002/10/27 16:11:02  klaus

// Added CVS log into header

//

// what                                            who          when

// started                                         AR           06.10.1999

// first release 1.0                                                       AR                   17.10.1999

//

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

// INCLUDES

//

#include <ntddk.h>

#include <pcivme_fifo.h>

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

// DEFINES

//

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

// TYPEDEFS

//

typedef struct

{

        USHORT wLevel;                                           // actual Number of Elements

        UCHAR  *pbBegin;                                         // points to begin of the buffer

        UCHAR  *pbEnd;                                           // points to the (end of the buffer + 1)

        UCHAR  *pbWrite;                                         // next write here

        UCHAR  *pbRead;                                          // next read (if any) here

        KSPIN_LOCK Lock;                                         // to guard access to the fifo

        BOOLEAN bOverflow;                                       // indicates a overflow to that FIFO

} FIFO_MANAGER;

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

// FUNCTIONS

//

// the global functions to manage the fifo

// first: init the fifo and allocate nonpaged memory

NTSTATUS InitializeFIFO(USHORT CountOfElements, PVOID *pHandle)

{

        ULONG allocSize;

        register FIFO_MANAGER *fifo_manager;

        *pHandle = NULL;

        allocSize = sizeof(FIFO_MANAGER) + sizeof(UCHAR) * CountOfElements + 16; // cause alignment

        *pHandle = ExAllocatePool(NonPagedPool, allocSize);

        if(*pHandle == NULL) return STATUS_NO_MEMORY;

        RtlZeroMemory(*pHandle, allocSize);

        fifo_manager = (FIFO_MANAGER *)*pHandle;

        // init the fifo_manager

        KeInitializeSpinLock(&fifo_manager->Lock);

        fifo_manager->wLevel  = 0;

        fifo_manager->bOverflow = FALSE;

        fifo_manager->pbBegin = (UCHAR *)(((ULONG)(fifo_manager + 1) + 8) & ~7); //align

        fifo_manager->pbEnd   = (UCHAR *)((ULONG)fifo_manager->pbBegin + sizeof(UCHAR) * CountOfElements);

        fifo_manager->pbWrite =

        fifo_manager->pbRead  = fifo_manager->pbBegin;

        // KdPrint(("fifo_manager: 0x%08x, begin: 0x%08x, end: 0x%08x\n",

        //                fifo_manager, fifo_manager->pbBegin, fifo_manager->pbEnd));

        return STATUS_SUCCESS;

}

// second: push elements to the FIFO

int PushElement(PVOID Handle, UCHAR bElement)

{

        register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;

        KIRQL  oldIrql;

        KeAcquireSpinLock(&fifo_manager->Lock, &oldIrql);

        if ((fifo_manager->wLevel) && (fifo_manager->pbWrite == fifo_manager->pbRead))

        {

                KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);

                return fifo_manager->wLevel;

        }

        *(fifo_manager->pbWrite)++ = bElement;

        // wrap around

    if (fifo_manager->pbWrite >= fifo_manager->pbEnd)

                fifo_manager->pbWrite = fifo_manager->pbBegin;

        // check for overflow - indicate - and reset pointer to same before

        if (fifo_manager->pbWrite == fifo_manager->pbRead)

        {

                fifo_manager->bOverflow = TRUE;

                fifo_manager->pbWrite--;

                if (fifo_manager->pbWrite < fifo_manager->pbBegin)

                        fifo_manager->pbWrite = fifo_manager->pbEnd - 1;

        }

        else

                (fifo_manager->wLevel)++;

        KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);

        return fifo_manager->wLevel;

}

// third: pull elements from the FIFO

int PullElement(PVOID Handle, UCHAR *pbElement)

{

        register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;

        KIRQL  oldIrql;

        if (!(fifo_manager->wLevel)) return 0;  

        KeAcquireSpinLock(&fifo_manager->Lock, &oldIrql);

        if (fifo_manager->wLevel)

        {

                *pbElement = *(fifo_manager->pbRead)++;

                (fifo_manager->wLevel)--;

        }

        else

                *pbElement = 0;  // the caller tries to get more than available?

        // wrap around

    if (fifo_manager->pbRead >= fifo_manager->pbEnd)

                fifo_manager->pbRead = fifo_manager->pbBegin;

        KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);

        return fifo_manager->wLevel;

}

// test how many elements are in the FIFO

int NumberOfElements(PVOID Handle)

{

        register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;

        return fifo_manager->wLevel;

}

// check and clear the overflow flag

BOOLEAN CheckAndClearOverflow(PVOID Handle)

{

        register FIFO_MANAGER *fifo_manager = (FIFO_MANAGER *)Handle;

        KIRQL  oldIrql;

        BOOLEAN helper;

        KeAcquireSpinLock(&fifo_manager->Lock, &oldIrql);

        helper = fifo_manager->bOverflow;

        fifo_manager->bOverflow = FALSE;

        KeReleaseSpinLock(&fifo_manager->Lock, oldIrql);

        return helper;

}

// close the FIFO and free the allocated memory

void DestroyFIFO(PVOID Handle)

{

        if (Handle != NULL) ExFreePool(Handle);

}