Subversion Repositories f9daq

Rev

Rev 19 | Blame | Compare with Previous | Last modification | View Log | RSS feed

//-------------------------------------------------------------------------
// WINNT driver for PCIVME interface from ARW Elektronik, Germany ---------
// the ioctl functions
//
// (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_io.c,v $
// Revision 1.3  2004/07/24 07:07:26  klaus
// Update copyright to 2004
//
// Revision 1.2  2003/11/15 19:12:51  klaus
// Update copyright to 2003
//
// Revision 1.1.1.1  2003/11/14 23:16:33  klaus
// First put into repository
//
// Revision 1.6  2002/10/27 18:30:57  klaus
// simpel typing correction
//
// Revision 1.5  2002/10/27 18:29:56  klaus
// honor backward compatibilty with non-extended modifier addressing
//
// Revision 1.4  2002/10/27 17:02:30  klaus
// File addressing bug > 2 Gbtye circumvent
//
// 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           03.07.1999
// first release 1.0                                                                     AR                           17.10.1999
// changed resource allocation caused by WIN2000   AR           08.06.2002
//

//-------------------------------------------------------------------------
// INCLUDES
//
#include <ntddk.h>
#include <devioctl.h>
#include <pcivme_drv.h>
#include <pcivme.h>
#include <pcivme_v.h>
#include <pcivme_io.h>
#include <pciif.h>
#include <pcivme_i.h>
#include <pcivme_fifo.h>

//------------------------------------------------------------------------
// DEFINES
//

// buffers usage must match the corresponding ioctl code!
#define SET_BUFFERS_METHOD_OUT_DIRECT \
{\
        InputLength   = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
        OutputLength  = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
        pInputBuffer  = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
        pOutputBuffer = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));\
}


#define SET_BUFFERS_METHOD_IN_DIRECT \
{\
        InputLength   = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
        OutputLength  = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
        pInputBuffer  = ((void *)(MmGetSystemAddressForMdl(Irp->MdlAddress)));\
        pOutputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
}


#define SET_BUFFERS_METHOD_BUFFERED \
{\
        InputLength   = IrpStack->Parameters.DeviceIoControl.InputBufferLength;\
        OutputLength  = IrpStack->Parameters.DeviceIoControl.OutputBufferLength;\
        pInputBuffer  = pOutputBuffer = ((void *)(Irp->AssociatedIrp.SystemBuffer));\
}


#define COMPLETE_REQUEST \
{\
        if (Status != STATUS_PENDING)\
        {\
                Irp->IoStatus.Status      = Status; \
                Irp->IoStatus.Information = irp_info; \
                IoCompleteRequest(Irp,IO_NO_INCREMENT); \
        }\
}


// compatibilty issues to WIN95 driver calls
#ifndef WORD
#define WORD USHORT
#endif

#ifndef DWORD
#define DWORD ULONG
#endif

#ifndef BYTE
#define BYTE UCHAR
#endif

#ifndef BOOL
#define BOOL BOOLEAN
#endif

#define MODIFIER_MASK     0x3F // mask for address modifier

//-------------------------------------------------------------------------
// GLOBALS
//
const PCIVME_INIT_ELEMENT init_element[] =
         {{LCR,  WORD_ACCESS, 0x4c,       DISABLE_PCIADA_IRQS}, // disable interrupts
          {LCR,  WORD_ACCESS, 0x50,       RELEASE_VMEMM},       // enable interface

          {VIC,  BYTE_ACCESS, (WORD)0x03, 0xf8+1},    // VIICR

          {VIC,  BYTE_ACCESS, (WORD)0x07, 0x78+1},    // VICR1
          {VIC,  BYTE_ACCESS, (WORD)0x0b, 0x78+2},
          {VIC,  BYTE_ACCESS, (WORD)0x0f, 0x78+3},
          {VIC,  BYTE_ACCESS, (WORD)0x13, 0x78+4},
          {VIC,  BYTE_ACCESS, (WORD)0x17, 0x78+5},
          {VIC,  BYTE_ACCESS, (WORD)0x1b, 0x78+6},
          {VIC,  BYTE_ACCESS, (WORD)0x1f, 0x78+7},    // VICR7

          {VIC,  BYTE_ACCESS, (WORD)0x23, 0xf8+0},    // DSICR

          {VIC,  BYTE_ACCESS, (WORD)0x27, 0xf8+1},    // LICR1
          {VIC,  BYTE_ACCESS, (WORD)0x2b, 0xf8+2},
          {VIC,  BYTE_ACCESS, (WORD)0x2f, 0xf8+3},
          {VIC,  BYTE_ACCESS, (WORD)0x33, 0xf8+4},
          {VIC,  BYTE_ACCESS, (WORD)0x37, 0xf8+5},
          {VIC,  BYTE_ACCESS, (WORD)0x3b, 0x38+6},
          {VIC,  BYTE_ACCESS, (WORD)0x3f, 0x38+7},    // LICR7

          {VIC,  BYTE_ACCESS, (WORD)0x43, 0xf8+2},    // ICGS
          {VIC,  BYTE_ACCESS, (WORD)0x47, 0xf8+3},    // ICMS

          {VIC,  BYTE_ACCESS, (WORD)0x4b, 0xf8+6},    // EGICR

          {VIC,  BYTE_ACCESS, (WORD)0x4f, 0x08},      // ICGS-IVBR (!)
          {VIC,  BYTE_ACCESS, (WORD)0x53, 0x0c},      // ICMS-IVBR (!)

          {VIC,  BYTE_ACCESS, (WORD)0x57, 0x00},      // LIVBR (!)

          {VIC,  BYTE_ACCESS, (WORD)0x5b, 0x10},      // EGIVBR (!)

          {VIC,  BYTE_ACCESS, (WORD)0x5f, 0x00},      // ICSR

          {VIC,  BYTE_ACCESS, (WORD)0x63, 0x00},      // ICR0
          {VIC,  BYTE_ACCESS, (WORD)0x67, 0x00},
          {VIC,  BYTE_ACCESS, (WORD)0x6b, 0x00},
          {VIC,  BYTE_ACCESS, (WORD)0x6f, 0x00},
          {VIC,  BYTE_ACCESS, (WORD)0x73, 0x00},      // ICR4

          {VIC,  BYTE_ACCESS, (WORD)0x83, 0xfe},      // VIRSR

          {VIC,  BYTE_ACCESS, (WORD)0x87, 0x0f},      // VIVR1
          {VIC,  BYTE_ACCESS, (WORD)0x8b, 0x0f},
          {VIC,  BYTE_ACCESS, (WORD)0x8f, 0x0f},
          {VIC,  BYTE_ACCESS, (WORD)0x93, 0x0f},
          {VIC,  BYTE_ACCESS, (WORD)0x97, 0x0f},
          {VIC,  BYTE_ACCESS, (WORD)0x9b, 0x0f},
          {VIC,  BYTE_ACCESS, (WORD)0x9f, 0x0f},      // VIVR7

          {VIC,  BYTE_ACCESS, (WORD)0xa3, 0x3c},      // TTR

          {VIC,  BYTE_ACCESS, (WORD)0xb3, 0x40},      // ARCR
          {VIC,  BYTE_ACCESS, (WORD)0xb7, 0x29},      // AMSR
          {VIC,  BYTE_ACCESS, (WORD)0xd3, 0x00},      // RCR

          {IFR,  LONG_ACCESS, (WORD)ADRHL, 0xF0F0F0F0},  // ADR-H, ADR-L
          {IFR,  WORD_ACCESS, (WORD)CSR  , 0x0000},      // Contr-Reg

          {VIC,  BYTE_ACCESS, (WORD)0x7f, 0x80},         // ICR7

          {LCR,  WORD_ACCESS, 0x4c, DISABLE_PCIADA_IRQS},// disable interrupts
         
          {STOP, WORD_ACCESS, 0,     0}};

const PCIVME_INIT_ELEMENT deinit_element_pre[] =
         {{VIC,  BYTE_ACCESS, (WORD)0x7f, 0x00},         // ICR7 - sysfail
          {LCR,  WORD_ACCESS, 0x4c, DISABLE_PCIADA_IRQS},// disable interrupts
          {STOP, WORD_ACCESS, 0,    0}};

const PCIVME_INIT_ELEMENT deinit_element_post[] =
         {{LCR,  WORD_ACCESS, 0x50, INHIBIT_VMEMM},      // disable interface
          {STOP, WORD_ACCESS, 0,    0}};


//--------------------------------------------------------------------------
// LOCAL FUNCTIONS
//

//--------------------------------------------------------------------------
// fast read or write functions - portable -
static void readByte(void *to, ULONG dwLength, void *from)
{
        READ_REGISTER_BUFFER_UCHAR((PUCHAR)from, (PUCHAR)to, dwLength);
}

static void readWord(void *to, ULONG dwLength, void *from)
{
        dwLength >>= 1;
        READ_REGISTER_BUFFER_USHORT((PUSHORT)from, (PUSHORT)to, dwLength);
}

static void readLong(void *to, ULONG dwLength, void *from)
{
        dwLength >>= 2;
        READ_REGISTER_BUFFER_ULONG((PULONG)from, (PULONG)to, dwLength);
}

static void writeByte(void *to, ULONG dwLength, void *from)
{
        WRITE_REGISTER_BUFFER_UCHAR((PUCHAR)to, (PUCHAR)from, dwLength);
}

static void writeWord(void *to, ULONG dwLength, void *from)
{
        dwLength >>= 1;
        WRITE_REGISTER_BUFFER_USHORT((PUSHORT)to, (PUSHORT)from, dwLength);
}

static void writeLong(void *to, ULONG dwLength, void *from)
{
        dwLength >>= 2;
        WRITE_REGISTER_BUFFER_ULONG((PULONG)to, (PULONG)from, dwLength);
}

//------------------------------------------------------------------------
// insert the irq queue into the linked list of queues
static NTSTATUS insertQueueInList(PFILE_OBJ pFile_obj, PCIADA *pciada)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        FIFO_LIST   *next;
        KIRQL           OldIrql;

        KdPrint(("insertQueueInList()\n"));

        if (pFile_obj->bQueueIrq)  // still enabled and in list
                return Status;

        // allocate memory to hold the list and its container
        next = (FIFO_LIST *)ExAllocatePool(NonPagedPool, sizeof(FIFO_LIST));
        if(next == (FIFO_LIST *)NULL)
                return STATUS_INSUFFICIENT_RESOURCES;
        else
        {
                // fill contents in entry
                next->pFile_obj                 = pFile_obj;
                next->pIrqListHandle    = pFile_obj->pIrqListHandle;

                // insert the entry in the list
                KeAcquireSpinLock(&pciada->IrqListLock, &OldIrql);
                KdPrint(("InsertHeadList(0x%08x, 0x%08x)\n", &pciada->IrqListList, &next->entry));
                InsertHeadList(&pciada->IrqListList, &next->entry);
                KeReleaseSpinLock(&pciada->IrqListLock, OldIrql);

                // show and mark it
                pFile_obj->bQueueIrq = TRUE;
        }

        return Status;
}

//------------------------------------------------------------------------
// remove the irq queue from the linked list of queues
NTSTATUS removeQueueFromList(PFILE_OBJ pFile_obj, PCIADA *pciada)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        FIFO_LIST   *next;
        PLIST_ENTRY pList;
        KIRQL           OldIrql;

        KdPrint(("removeQueueFromList(0x%08x, 0x%08x)\n", pFile_obj, pciada));

        pList = &pciada->IrqListList;  

        if ((pFile_obj == (FILE_OBJ *)NULL) || (pciada == (PCIADA *)NULL)) return Status;

        // search for coincidence of pFile_obj in the list
        KeAcquireSpinLock(&pciada->IrqListLock, &OldIrql);
        while (pList->Flink != &pciada->IrqListList)
        {
                pList = pList->Flink;
                next = CONTAINING_RECORD(pList, FIFO_LIST, entry);
                if (next->pFile_obj == pFile_obj)   // found
                {
                        KdPrint(("RemoveEntryList(0%08x)\n", pList));
                        RemoveEntryList(pList);
                        ExFreePool((PVOID)next);
                        break;
                }
        }
        KeReleaseSpinLock(&pciada->IrqListLock, OldIrql);

        // in every case switch it off (again)
        pFile_obj->bQueueIrq = FALSE;

        KdPrint(("removeQueueFromList OK\n"));
        return Status;
}

//--------------------------------------------------------------------------
// parsing of user supplied input for validy
static BOOLEAN check_command(const PCIVME_INIT_ELEMENT *psInitElement)
{
  USHORT range;
  USHORT access_size;
 
  switch (psInitElement->range)
  {
    case LCR: range = 0x54;     break;
    case IFR: range = 0x0c;     break;
    case VIC: range = 0xe4;
              if ((psInitElement->offset & 3) != 3)
                return FALSE;
              break;
    default:  range = 0;        break;
  }

  switch (psInitElement->type)
  {
    case LONG_ACCESS: if (psInitElement->offset & 3)
                        return FALSE;
                      access_size = sizeof(ULONG);
                      break;
    case WORD_ACCESS: if (psInitElement->offset & 1)
                        return FALSE;
                      access_size = sizeof( USHORT);
                      break;
    case BYTE_ACCESS: access_size = sizeof( UCHAR); break;
    default         : access_size = 0xFFFF;        break;
  }

  if ((psInitElement->offset + access_size) > range)
    return FALSE;       // ignore it
   
  return TRUE;
}

//------------------------------------------------------------------------
// iterate through all commands
static VOID CmdMachine(const PCIVME_INIT_ELEMENT *psInitElement,
                                                 PVOID pvLcr, PVOID pvIfr)
{
  PVOID adr;
 
  // standard initialisierungen  
  while (psInitElement->range != STOP)
  {
    /*
        KdPrint(("CmdMachine: %d %d 0x%02x 0x%02x\n",
                psInitElement->range,  psInitElement->type,
                psInitElement->offset, psInitElement->value));
    */


    if (check_command(psInitElement))
    {
      switch (psInitElement->range)
      {
        case LCR: adr = pvLcr; break;
        case VIC: adr = (PVOID)((ULONG)pvIfr + (USHORT)VICBASE); break;
        case IFR:
        default:  adr = pvIfr; break;  
      }

      switch (psInitElement->type)
      {
        case LONG_ACCESS:
                  WRITE_REGISTER_ULONG((ULONG *)((UCHAR *)adr + psInitElement->offset),  
                                                                     psInitElement->value);
          break;
        case WORD_ACCESS:
                  WRITE_REGISTER_USHORT((USHORT *)((UCHAR *)adr + psInitElement->offset),
                                                             (USHORT)psInitElement->value);
          break;
        case BYTE_ACCESS:
        default:
                  WRITE_REGISTER_UCHAR((UCHAR *)((UCHAR *)adr + psInitElement->offset),  
                                                              (UCHAR)psInitElement->value);
          break;
      }
    }
    psInitElement++;
  }
}

//------------------------------------------------------------------------
// init the interface with build in and user supplied constants
static BOOLEAN InitInterface(const PCIVME_INIT_COMMAND *psInitCmd,
                                                    PVOID pvLcr, PVOID pvIfr)
{
  PCIVME_INIT_ELEMENT *psVie;
 
  if ((psInitCmd == (PCIVME_INIT_COMMAND *)BOGUSADDRESS) ||
      (psInitCmd == (PCIVME_INIT_COMMAND *)NULL)         ||
          (pvLcr         == (PVOID)BOGUSADDRESS)                 ||
      (pvLcr     == (PVOID)NULL)                         ||
          (pvIfr         == (PVOID)BOGUSADDRESS)                 ||
          (pvIfr     == (PVOID)NULL))
    return FALSE;

  psVie = (PCIVME_INIT_ELEMENT *)psInitCmd->sVie;
  CmdMachine(init_element , pvLcr, pvIfr);    // standard initialisierungen  
  CmdMachine(psVie,         pvLcr, pvIfr);    // benutzer initialisierungen
 
  return TRUE;
}

// deinit the interface with user supplied and build in constants
static BOOLEAN DeInitInterface(const PCIVME_INIT_COMMAND *psDeInitCmd,
                                                   PVOID pvLcr, PVOID pvIfr)
{
  PCIVME_INIT_ELEMENT *psVie;

  if ((psDeInitCmd == (PCIVME_INIT_COMMAND *)BOGUSADDRESS) ||
      (psDeInitCmd == (PCIVME_INIT_COMMAND *)NULL)         ||
          (pvLcr           == (PVOID)BOGUSADDRESS)                 ||
      (pvLcr       == (PVOID)NULL)                         ||
          (pvIfr           == (PVOID)BOGUSADDRESS)                 ||
          (pvIfr       == (PVOID)NULL))
    return FALSE;

  psVie = (PCIVME_INIT_ELEMENT *)psDeInitCmd->sVie;
  CmdMachine(deinit_element_pre,   pvLcr, pvIfr); // standard de-initialisierungen  
  CmdMachine(psVie,                pvLcr, pvIfr); // benutzer de-initialisierungen
  CmdMachine(deinit_element_post , pvLcr, pvIfr); // disable interface
 
  return TRUE;
}

//------------------------------------------------------------------------
// a inserter into a user managed queue of IRPs
//
void InsertIRPtoQueue(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
        DEVICE_EXT *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
        KIRQL           oldIrql;

    KdPrint(("InsertIRPtoQueue(0x%08x)\n", Irp));

        KeAcquireSpinLock(&pDevExt->IRPLock, &oldIrql);
        InsertHeadList(&pDevExt->IRPList, &Irp->Tail.Overlay.ListEntry);
        KeReleaseSpinLock(&pDevExt->IRPLock, oldIrql);
}

//------------------------------------------------------------------------
// a remover out of a user managed queue of IRPs
//
PIRP RemoveIRPfromQueue(PDEVICE_OBJECT device_Obj, FILE_OBJ *pFile_obj)
{
        DEVICE_EXT      *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
        KIRQL           oldIrql;
        register PLIST_ENTRY pList = &pDevExt->IRPList;
        PIRP        Irp;
        PIRP        pIrp = (PIRP)NULL;
        FILE_OBJ        *file_obj;

    KdPrint(("RemoveIRPfromQueue()\n"));

        KeAcquireSpinLock(&pDevExt->IRPLock, &oldIrql);
 
        while (pList->Flink != &pDevExt->IRPList)  // until the end is reached
        {
                pList = pList->Flink;
                Irp  = CONTAINING_RECORD(pList, IRP, Tail.Overlay.ListEntry);
                file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

                KdPrint(("pList 0x%08x, pList->Flink 0x%08x, Irp 0x%08x, file_obj 0x%08x\n", pList, pList->Flink, Irp, file_obj));

                if ((file_obj == pFile_obj) && (pFile_obj != (FILE_OBJ *)NULL))
                {
                        RemoveEntryList(pList);
                        pIrp = Irp;
                        break;
                }
        }

        KeReleaseSpinLock(&pDevExt->IRPLock, oldIrql);

    KdPrint(("return RemoveIRPfromQueue(0x%08x)\n", pIrp));

        return pIrp;
}

//------------------------------------------------------------------------
// a remover out of a user managed queue of IRPs
//
PIRP RemoveIRPfromQueueByIrp(PDEVICE_OBJECT device_Obj, PIRP pIrpIn)
{
        DEVICE_EXT      *pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);
        KIRQL           oldIrql;
        register PLIST_ENTRY pList = &pDevExt->IRPList;
        PIRP        Irp;
        PIRP        pIrp = (PIRP)NULL;

    KdPrint(("RemoveIRPfromQueueByIrp()\n"));

        KeAcquireSpinLock(&pDevExt->IRPLock, &oldIrql);

        while (pList->Flink != &pDevExt->IRPList)  // until the end is reached
        {
                pList = pList->Flink;
                Irp  = CONTAINING_RECORD(pList, IRP, Tail.Overlay.ListEntry);

                KdPrint(("pList 0x%08x, pList->Flink 0x%08x, Irp 0x%08x\n", pList, pList->Flink, Irp));

                if (pIrpIn == Irp)
                {
                        RemoveEntryList(pList);
                        pIrp = Irp;
                        break;
                }
        }

        KeReleaseSpinLock(&pDevExt->IRPLock, oldIrql);

    KdPrint(("return RemoveIRPfromQueueByIrp(0x%08x)\n", pIrp));

        return pIrp;
}

//------------------------------------------------------------------------
// the default cancel routine for an queued Irp
//
void CancelRequest(PDEVICE_OBJECT device_Obj, PIRP Irp)
{
        PIRP pIrpCancel = RemoveIRPfromQueueByIrp(device_Obj, Irp);

        if (pIrpCancel == (PIRP)NULL)
        {
                IoReleaseCancelSpinLock(Irp->CancelIrql);
                KdPrint(("Nothing to do: CancelRequest(0x%08x)\n", Irp));
                return;
        }
        else
        {
                IoReleaseCancelSpinLock(Irp->CancelIrql);

                KdPrint(("Done: CancelRequest(0x%08x)\n", Irp));

                Irp->IoStatus.Status = STATUS_CANCELLED;
                Irp->IoStatus.Information = 0;
 
                IoCompleteRequest(Irp, IO_NO_INCREMENT);
        }
}
 

//------------------------------------------------------------------------
// the custom deffered routine to finish blocking io on read_vector
void fMyDefferedRoutine(PKDPC Dpc, PVOID pvDevice_object,
                                                                         PVOID pvPciada, PVOID pvVector)
{
        NTSTATUS Status = STATUS_SUCCESS;
        ULONG irp_info  = sizeof(PCIVME_VECTOR_RESPONSE);
    PIRP  Irp = (PIRP)NULL;
        PDEVICE_OBJECT device_Obj = (PDEVICE_OBJECT)pvDevice_object;
        PCIADA *pciada = (PCIADA *)pvPciada;
        FIFO_LIST               *next;
        KIRQL                   oldIrqlCancel;
        KIRQL                   oldIrqlList;
        register PLIST_ENTRY pList = &pciada->IrqListList;
        UNREFERENCED_PARAMETER(pvVector);
        UNREFERENCED_PARAMETER(Dpc);
    KdPrint(("fMyDefferedRoutine()\n"));

        // beware off damage due to intercept with cancel of thread
    IoAcquireCancelSpinLock(&oldIrqlCancel);
        KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);
 
        while (pList->Flink != &pciada->IrqListList)  // until the end is reached
        {
                pList = pList->Flink;
                KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList); // shorten block
 
                next = CONTAINING_RECORD(pList, FIFO_LIST, entry);

                // get my associated packet
                Irp = RemoveIRPfromQueue(device_Obj, next->pFile_obj);

                if (Irp != (PIRP)NULL)
                {
                        PCIVME_VECTOR_REQUEST  *pVectorRequest  = (PCIVME_VECTOR_REQUEST  *)(Irp->AssociatedIrp.SystemBuffer);
                        PCIVME_VECTOR_RESPONSE *pVectorResponse = (PCIVME_VECTOR_RESPONSE *)pVectorRequest;
                        USHORT wRequestCount = pVectorRequest->wRequestCount;
                        UCHAR  *pbVector     = &pVectorResponse->bStatusID;
                        FILE_OBJ *file_obj   = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
                        UCHAR  bNumberOfElements = (UCHAR) NumberOfElements(file_obj->pIrqListHandle);
 
                        // pull the vectors off the fifo
                        pVectorResponse->wCount = 0;
                        while ((bNumberOfElements) && (wRequestCount--))
                        {
                                bNumberOfElements   = (UCHAR) PullElement(file_obj->pIrqListHandle,
                                                                        (void *)pbVector);
                                pbVector++;
                                pVectorResponse->wCount++;
                        }
                        pVectorResponse->wPendingCount = bNumberOfElements;
                        pVectorResponse->bOverflow     = CheckAndClearOverflow(file_obj->pIrqListHandle);
                        irp_info = sizeof(PCIVME_VECTOR_RESPONSE) +
                                     sizeof(UCHAR) * (pVectorResponse->wCount - 1);

                        // release the cancel routine from this Irp
                        IoSetCancelRoutine(Irp, NULL);

                        COMPLETE_REQUEST;
                }
       
                KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);
        }

        // release the spin locks
        KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList);
        IoReleaseCancelSpinLock(oldIrqlCancel);
}

//------------------------------------------------------------------------
// all functions called from ioctl jump table
//

//------------------------------------------------------------------------
// initialize all hardware associated to a given wModuleNumber
static NTSTATUS ioctl_init_hardware(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = 0;
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        DEVICE_EXT      *pDevExt;
        PCIVME_INIT_COMMAND *pInitCommand;
        PCIADA      *pciada;
        FILE_OBJ        *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

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

        SET_BUFFERS_METHOD_BUFFERED;

        // do what must be here in between --- start ---
        pInitCommand = (PCIVME_INIT_COMMAND *)pInputBuffer;

    KdPrint(("ioctl_init_hardware(%d)\n", file_obj->uwAssociatedVMEMM));

        pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

        if (pciada != NULL)
        {
                KIRQL oldIrql;

                if (pciada->dwLinkCount == 1)
                {
                        // lock other users out
                        KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);

                        if (InitInterface(pInitCommand, pciada->pvVirtLcr, pciada->pvVirtIfr))
                        {
                                // fill cache for page and modifier
                                pciada->dwVMEPage = READ_REGISTER_ULONG(pciada->pdwVMEAdr)  & ~VME_ADR_MASK;
                                pciada->bModifier = READ_REGISTER_UCHAR(pciada->pbModifier) & MODIFIER_MASK;
                        }
                        else
                                Status = STATUS_UNSUCCESSFUL;

                        // release the lock
                        KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
                }
                else
                        Status = STATUS_UNSUCCESSFUL;
        }
        else
                Status = STATUS_UNSUCCESSFUL;

        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_init_hardware(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// De-initialise all hardware associated to a given wModuleNumber
static NTSTATUS ioctl_deinit_hardware(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = 0;
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        DEVICE_EXT      *pDevExt;
        PCIVME_INIT_COMMAND *pInitCommand;
        PCIADA      *pciada;
        FILE_OBJ    *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
    KdPrint(("ioctl_deinit_hardware()\n"));

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

        SET_BUFFERS_METHOD_BUFFERED;

        // do what must be hier in between --- start ---
        pInitCommand = (PCIVME_INIT_COMMAND *)pInputBuffer;

    KdPrint(("ioctl_deinit_hardware(%d)\n", file_obj->uwAssociatedVMEMM));

        pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

        if (pciada != NULL)
        {
                KIRQL oldIrql;

                if (pciada->dwLinkCount == 1)
                {
                        // lock other users out
                        KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);

                        if (DeInitInterface(pInitCommand, pciada->pvVirtLcr, pciada->pvVirtIfr))
                                globalInterruptDisable(pciada);
                        else
                                Status = STATUS_UNSUCCESSFUL;

                        // everyone likes to have PCIVME
                        KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
                }
                else
                        Status = STATUS_UNSUCCESSFUL;
        }
        else
                Status = STATUS_UNSUCCESSFUL;
        // do what must be hier in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_deinit_hardware(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// a dummy entry because of compatibiltiy (near) WIN95 driver
static NTSTATUS ioctl_dummy(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = 0;
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIVME_INIT_COMMAND *pInitCommand;
        FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

        SET_BUFFERS_METHOD_BUFFERED;
        UNREFERENCED_PARAMETER(device_Obj);
#ifndef _DEBUG
        UNREFERENCED_PARAMETER(file_obj);
#endif
        pInitCommand = (PCIVME_INIT_COMMAND *)pInputBuffer;

    KdPrint(("ioctl_dummy(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
       
        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_dummy(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// requests fixed unchangeable information - not compatible to WIN95 driver
static NTSTATUS ioctl_get_static_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_STATIC_STATUS);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIADA      *pciada;
        DEVICE_EXT      *pDevExt;
        PCIVME_STATIC_STATUS *pStaticStatus;
        FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

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

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_get_static_status(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
        if (OutputLength >= sizeof(PCIVME_STATIC_STATUS))
        {
                pStaticStatus = (PCIVME_STATIC_STATUS *)pOutputBuffer;

                pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

                pStaticStatus->dwInterface              = file_obj->uwAssociatedVMEMM;  

                pStaticStatus->wNumMemWindows   = 3;      
                pStaticStatus->wNumIOPorts              = 2;
                pStaticStatus->wNumIRQs                 = 1;
                pStaticStatus->wNumDMAs                 = 0;
     
                pStaticStatus->dwLinkCount              = pciada->dwLinkCount;

                pStaticStatus->wModuleType              = pciada->wModuleType;
                pStaticStatus->wFPGAVersion             = pciada->wFPGAVersion;
                pStaticStatus->wModuleNumber    = pciada->wModuleNumber;
                pStaticStatus->wWordMode                = pciada->bWordMode;

                pStaticStatus->wSysControl              = pciada->bSysControl;
                pStaticStatus->wConnected               = pciada->bConnected;
 
                pStaticStatus->pvLcr                    = pciada->pvPhysLcr;
                pStaticStatus->pvIfr                    = pciada->pvPhysIfr;
               
                pStaticStatus->dwDriverVersion  = DRIVER_VERSION;
                pStaticStatus->dwDriverVariant  = DRIVER_VARIANT;
        }
        else
                Status = STATUS_BUFFER_TOO_SMALL;
        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_get_static_status(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// requests changeable status
static NTSTATUS ioctl_get_dynamic_status(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_DYNAMIC_STATUS);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIADA      *pciada;
        DEVICE_EXT      *pDevExt;
        PCIVME_DYNAMIC_STATUS *pDynamicStatus;
        FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_get_dynamic_status(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
        pDevExt = (DEVICE_EXT *)(device_Obj->DeviceExtension);

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_get_static_status(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
        if (OutputLength >= sizeof(PCIVME_DYNAMIC_STATUS))
        {
                USHORT temp;

                pDynamicStatus = (PCIVME_DYNAMIC_STATUS *)pOutputBuffer;

                pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

                pDynamicStatus->dwInterface     = file_obj->uwAssociatedVMEMM;
 
                temp = READ_REGISTER_USHORT(pciada->pwCntrl);
                pDynamicStatus->wVMEMM_enable           = ((temp & 0x0180) == 0x0180) ? 1 : 0;
                pDynamicStatus->wVMEMM_connected        = ((temp & 0x0c00) == 0x0800) ? 1 : 0;
                temp = READ_REGISTER_USHORT(pciada->pwIntCSR);
                pDynamicStatus->wPCIADAIrq                      = (temp & 0x0004) ? 1 : 0;
                pDynamicStatus->wVMEMMIrq                       = (temp & 0x0020) ? 1 : 0;
        }
        else
                Status = STATUS_BUFFER_TOO_SMALL;

        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_get_dynamic_status(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// get the next vector out of the vector queue
static NTSTATUS ioctl_read_vector(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_VECTOR_RESPONSE);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIVME_VECTOR_RESPONSE *pVectorResponse;
        PCIVME_VECTOR_REQUEST  *pVectorRequest;
        FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
    KIRQL       oldIrql;
        BOOLEAN     bPoll;
        USHORT      wRequestCount;

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_read_vector(%d)\n", file_obj->uwAssociatedVMEMM));

        pVectorRequest  = (PCIVME_VECTOR_REQUEST  *)pInputBuffer;
        pVectorResponse = (PCIVME_VECTOR_RESPONSE *)pOutputBuffer;

        // check the available room for vectors and correct if too less
        if (OutputLength <
                   (sizeof(PCIVME_VECTOR_RESPONSE) +
                       (pVectorRequest->wRequestCount - 1) * sizeof(UCHAR)))
                pVectorRequest->wRequestCount =
                    (USHORT)OutputLength - sizeof(PCIVME_VECTOR_RESPONSE) + sizeof(UCHAR);
 
        // empty the inputbuffer as early as possible
        wRequestCount = pVectorRequest->wRequestCount;
        bPoll             = pVectorRequest->bPoll;

        // do what must be here in between -----------
    if (OutputLength >= sizeof(PCIVME_VECTOR_RESPONSE)) // at least room for one
        {
                UCHAR  bNumberOfElements;
                UCHAR  *pbVector = &pVectorResponse->bStatusID;

                pVectorResponse->dwInterface = file_obj->uwAssociatedVMEMM;                    

                bNumberOfElements = (UCHAR) NumberOfElements(file_obj->pIrqListHandle);

                if ((bNumberOfElements) || (bPoll))
                {
                        KdPrint(("Direct return (%d)\n", bNumberOfElements));

                        pVectorResponse->wCount = 0;
                        while ((bNumberOfElements) && (wRequestCount--))
                        {
                                bNumberOfElements   = (UCHAR) PullElement(file_obj->pIrqListHandle,
                                                                        (void *)pbVector);
                                pbVector++;
                                pVectorResponse->wCount++;
                        }
                        pVectorResponse->wPendingCount = bNumberOfElements;
                        pVectorResponse->bOverflow     = CheckAndClearOverflow(file_obj->pIrqListHandle);
                        irp_info = sizeof(PCIVME_VECTOR_RESPONSE) +
                                     sizeof(UCHAR) * (pVectorResponse->wCount - 1);
                }
                else                    // go in wait queue for an irq
                {
                        IoAcquireCancelSpinLock(&oldIrql);

                        if (Irp->Cancel)    // cancel while doing
                        {
                                KdPrint(("Canceld return (%d)\n", bNumberOfElements));
                                Status = STATUS_CANCELLED;
                        }
                        else
                        {
                                KdPrint(("Blocking return (%d)\n", bNumberOfElements));

                                InsertIRPtoQueue(device_Obj, Irp);

                                Status = STATUS_PENDING;

                                // mark irp as pending and return
                                IoMarkIrpPending(Irp);
                                IoSetCancelRoutine(Irp, CancelRequest);
                        } // if (Irp->Cancel) ...
                       
                        IoReleaseCancelSpinLock(oldIrql);
                }
        }
        else
                Status = STATUS_BUFFER_TOO_SMALL;
       
        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_read_vector(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// control or read the VIC68A on the VMEMM
static NTSTATUS ioctl_access_VIC68A(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_VIC68A_ACTION);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIADA      *pciada;
        DEVICE_EXT      *pDevExt;
        PCIVME_VIC68A_ACTION *pVIC68A_action_in;
        PCIVME_VIC68A_ACTION *pVIC68A_action_out;
        FILE_OBJ        *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

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

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_access_VIC68A(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
        pVIC68A_action_in       = (PCIVME_VIC68A_ACTION *)pInputBuffer;
        pVIC68A_action_out      = (PCIVME_VIC68A_ACTION *)pOutputBuffer;

        if ((pVIC68A_action_in->wRegisterAddress <= (USHORT)SRR)    &&
                        ((pVIC68A_action_in->wRegisterAddress & 0x03) == 3) &&
                                (OutputLength >= sizeof(PCIVME_VIC68A_ACTION)))
        {
                PUCHAR  pbAddress;
                UCHAR   bByte=0;
                KIRQL   oldIrql;

                pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

                pVIC68A_action_out      = pVIC68A_action_in;  // copy it  
       
                pbAddress = (PUCHAR)((ULONG)(pciada->pvVirtIfr) + VICBASE + pVIC68A_action_in->wRegisterAddress);
 
                // lock other users out
                KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);

                switch(pVIC68A_action_in->wAccessMode)
                {
                        case VIC68A_WRITE:      WRITE_REGISTER_UCHAR(pbAddress, pVIC68A_action_in->bContent);
                                                                bByte      = READ_REGISTER_UCHAR(pbAddress);
                                                                break;
                        case VIC68A_WRITE_ONLY:
                                                                WRITE_REGISTER_UCHAR(pbAddress, pVIC68A_action_in->bContent);
                                                                break;
                        case VIC68A_OR:         bByte      = READ_REGISTER_UCHAR(pbAddress);
                                                                bByte     |= pVIC68A_action_in->bContent;
                                                                WRITE_REGISTER_UCHAR(pbAddress, bByte);
                                                                bByte      = READ_REGISTER_UCHAR(pbAddress);
                                                                break;
                        case VIC68A_AND:        bByte      = READ_REGISTER_UCHAR(pbAddress);
                                                                bByte     &= pVIC68A_action_in->bContent;
                                                                WRITE_REGISTER_UCHAR(pbAddress, bByte);
                                                                bByte      = READ_REGISTER_UCHAR(pbAddress);
                                                                break;
                        default:                        Status = STATUS_ILLEGAL_INSTRUCTION;
                        case VIC68A_READ:       bByte      = READ_REGISTER_UCHAR(pbAddress);
                                                                break;
                }
                // free lock
                KeReleaseSpinLock(&pciada->AccessLock, oldIrql);

                pVIC68A_action_out->bContent = bByte;
        }
        else
                Status = STATUS_ILLEGAL_INSTRUCTION;
        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_access_VIC68A(), Status = 0x%08x\n", Status));

        return Status;
}


//------------------------------------------------------------------------
// if the interrupt is disabled for a blocking path, cancel the block
static void ReleaseBlockingIrp(PDEVICE_OBJECT device_Obj, PCIADA *pciada, PFILE_OBJ pFile_obj)
{
        NTSTATUS Status = STATUS_CANCELLED;
        PIRP                    Irp;
        KIRQL                   oldIrqlCancel;
        KIRQL                   oldIrqlList;

        // beware off damage due to intercept with cancel of thread
        IoAcquireCancelSpinLock(&oldIrqlCancel);
        KeAcquireSpinLock(&pciada->IrqListLock, &oldIrqlList);

        // get my associated packet
        Irp = RemoveIRPfromQueue(device_Obj, pFile_obj);

        if (Irp != (PIRP)NULL)
        {
                PCIVME_VECTOR_REQUEST  *pVectorRequest  = (PCIVME_VECTOR_REQUEST  *)(Irp->AssociatedIrp.SystemBuffer);
                PCIVME_VECTOR_RESPONSE *pVectorResponse = (PCIVME_VECTOR_RESPONSE *)pVectorRequest;
                ULONG irp_info  = sizeof(PCIVME_VECTOR_RESPONSE);

                // pull the vectors off the fifo
                pVectorResponse->wCount            = 0;
                pVectorResponse->wPendingCount = 0;
                pVectorResponse->bOverflow     = FALSE;
                irp_info = sizeof(PCIVME_VECTOR_RESPONSE);

                // release the cancel routine from this Irp
                IoSetCancelRoutine(Irp, NULL);

                COMPLETE_REQUEST;
        }

        // release the spin locks
        KeReleaseSpinLock(&pciada->IrqListLock, oldIrqlList);
        IoReleaseCancelSpinLock(oldIrqlCancel);
}


//------------------------------------------------------------------------
// switch the filling of the interrupt vector queue on or off, check the queue
static NTSTATUS ioctl_control_interrupts(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_IRQ_CONTROL);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIADA      *pciada;
        DEVICE_EXT      *pDevExt;
        PCIVME_IRQ_CONTROL *pIrqControlIn;
        PCIVME_IRQ_CONTROL *pIrqControlOut;
        PFILE_OBJ pFile_obj = (PFILE_OBJ)Irp->Tail.Overlay.OriginalFileObject->FsContext;

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

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_control_interrupts(%d)\n", pFile_obj->uwAssociatedVMEMM));

        pIrqControlIn  = (PCIVME_IRQ_CONTROL *)pInputBuffer;
        pIrqControlOut = (PCIVME_IRQ_CONTROL *)pOutputBuffer;

        pciada = pDevExt->vmemm[pFile_obj->uwAssociatedVMEMM];

        // do what must be here in between -----------
        if (pIrqControlIn->wEnable)
        {
                Status = insertQueueInList(pFile_obj, pciada);
                if (!pciada->nInterruptHandlers)
                {
                        KdPrint(("Interrupts enabled.\n"));

                        globalInterruptEnable(pciada);
                        pciada->nInterruptHandlers++;
                }
        }
        else
        {
                if (pciada->nInterruptHandlers <= 1)
                {
                        KdPrint(("Interrupts disabled.\n"));

                        globalInterruptDisable(pciada);
                        pciada->nInterruptHandlers = 0;
                }

                Status = removeQueueFromList(pFile_obj, pciada);
                ReleaseBlockingIrp(device_Obj, pciada, pFile_obj);
        }

        // give back if the user grants space
        if (OutputLength >= sizeof(PCIVME_IRQ_CONTROL))
        {
                pIrqControlOut->dwInterface = pFile_obj->uwAssociatedVMEMM;
                pIrqControlOut->wEnable     = pFile_obj->bQueueIrq;
        }
       
        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_control_interrupts(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// generate a uninterruptible read-modify-write cycle
static NTSTATUS ioctl_TAS(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_TAS_STRUCT);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIADA      *pciada;
        DEVICE_EXT      *pDevExt;
        FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
        KIRQL           oldIrql;
        UCHAR           tempContent;
        PBOOLEAN        pbPrevBusError;
        PVOID       pvPartialAdr;

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

        SET_BUFFERS_METHOD_BUFFERED;
 
    KdPrint(("ioctl_TAS(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
        if (OutputLength >= sizeof(PCIVME_TAS_STRUCT))
        {
                PCIVME_TAS_STRUCT *pTAS_struct_in;
                PCIVME_TAS_STRUCT *pTAS_struct_out;
                USHORT csr;                     // storage for old csr content
                ULONG  pageAddress; // intermediate for the page register content
                UCHAR  bAddressModifier;

                pTAS_struct_in  = (PCIVME_TAS_STRUCT *)pInputBuffer;
                pTAS_struct_out = (PCIVME_TAS_STRUCT *)pOutputBuffer;

                pTAS_struct_out = pTAS_struct_in;
                pTAS_struct_out->dwInterface = file_obj->uwAssociatedVMEMM;
                pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

                // take the file_obj associated modifier if greater than ...
                bAddressModifier = (pTAS_struct_in->wModifier > 63) ?
                        file_obj->bAddressModifier : (UCHAR)pTAS_struct_in->wModifier;
 
                // lock other users out
                KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);

                // check for modifier (and set if needed)
                if (pciada->bModifier != bAddressModifier)
                {
                        WRITE_REGISTER_UCHAR(pciada->pbModifier, bAddressModifier);
                        pciada->bModifier = bAddressModifier;
                }
               
                // check for page address (and set if needed)
                pageAddress = pTAS_struct_in->dwAddress & ~VME_ADR_MASK;
                if (pageAddress != pciada->dwVMEPage)
                {
                        WRITE_REGISTER_ULONG(pciada->pdwVMEAdr, pageAddress);
                        pciada->dwVMEPage = pageAddress;
                }
 
                // save VMEMM csr register and prepare for read modify write
                csr = READ_REGISTER_USHORT(pciada->pwCSR);
                WRITE_REGISTER_USHORT(pciada->pwCSR,  (USHORT)(csr | FLAG_RMC));

                // prepare the TAS
                tempContent = pTAS_struct_in->bContent; // in and out point to same buffer
                pvPartialAdr = (PVOID)((PUCHAR)pciada->pvVME + (pTAS_struct_in->dwAddress & VME_ADR_MASK));

                // get prepared for bus errors
                file_obj->bBusError = FALSE;
                pbPrevBusError = ExchangePointer(&pciada->pbBusError, &file_obj->bBusError);

                // do the TAS
                readByte(&pTAS_struct_out->bContent , 1, pvPartialAdr);
                writeByte(pvPartialAdr , 1, &tempContent);
                readByte(&tempContent , 1, pvPartialAdr);  // to overcome write on ..

                // restore csr
                WRITE_REGISTER_USHORT(pciada->pwCSR, csr);

                // release the lock
                KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
                ExchangePointer(&pciada->pbBusError, pbPrevBusError);
                if (file_obj->bBusError) Status = STATUS_ACCESS_VIOLATION;
        }
        else
                Status = STATUS_BUFFER_TOO_SMALL;

        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_TAS(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// make a VME reset
static NTSTATUS ioctl_reset(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = sizeof(PCIVME_RESET_RESULT);
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        DEVICE_EXT      *pDevExt;
        FILE_OBJ *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;

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

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_reset(%d)\n", file_obj->uwAssociatedVMEMM));

        // do what must be here in between -----------
        if (OutputLength >= sizeof(PCIVME_RESET_RESULT))
        {
                PCIVME_RESET_RESULT  *pResetResult  = (PCIVME_RESET_RESULT *)pOutputBuffer;
                PCIVME_RESET_COMMAND *pResetCommand = (PCIVME_RESET_COMMAND *)pInputBuffer;
                PCIADA                           *pciada = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];
                USHORT wIRQStatus;
                USHORT wControl;
                UCHAR  *pbReset;
                KIRQL  oldIrql;

                // set default result return size and contents
                pResetResult->dwInterface       = file_obj->uwAssociatedVMEMM;
 
                if (pciada->dwLinkCount == 1)
                {
                        // lock other users out
                        KeAcquireSpinLock(&pciada->AccessLock, &oldIrql);

                        // am I connected and switched on??
                        if ((READ_REGISTER_USHORT(pciada->pwCntrl) & 0x0980) == 0x0980)
                        {
                                // do command
                                switch (pResetCommand->wCommand)
                                {
                                        case POLL_RESET_CMD:  
                                                break;
                                        case VME_RESET_CMD:    
                                                WRITE_REGISTER_UCHAR(pciada->pbModifier, 0);
                                                pbReset = (UCHAR  *)((UCHAR *)pciada->pvVirtIfr +
                                                                                                (ULONG)VICBASE + (ULONG)SRR);
                                                WRITE_REGISTER_UCHAR(pbReset, 0xf0);  // make VME reset                        
                                                break;
                                        case LOCAL_RESET_CMD:  
                                                WRITE_REGISTER_UCHAR(pciada->pbModifier, 0);
                                                WRITE_REGISTER_USHORT(pciada->pwIRQStat, LOCAL_RESET);
                                                break;
                                        case GLOBAL_RESET_CMD:
                                                WRITE_REGISTER_UCHAR(pciada->pbModifier, 0);
                                                WRITE_REGISTER_USHORT(pciada->pwIRQStat, GLOBAL_RESET);
                                                break;

                                        default: Status = STATUS_ILLEGAL_INSTRUCTION;
                                }

                                // save IRQ status of PCIADA and switch off PCIADA interrupts
                                wIRQStatus = READ_REGISTER_USHORT(pciada->pwIntCSR);
                                WRITE_REGISTER_USHORT(pciada->pwIntCSR, (USHORT)(wIRQStatus & ~0x0040));
 
                                // always poll reset status - access will sometimes generate PCIADA #2 interrupt
                                pResetResult->wResult = READ_REGISTER_UCHAR(pciada->pbModifier);

                                // reset any pending PCIADA interrupt #2  
                                wControl   = READ_REGISTER_USHORT(pciada->pwCntrl);
                                WRITE_REGISTER_USHORT(pciada->pwCntrl, (USHORT)(wControl & ~0x0100));
                                WRITE_REGISTER_USHORT(pciada->pwCntrl, wControl);
     
                                // restore IRQStatus
                                WRITE_REGISTER_USHORT(pciada->pwIntCSR, wIRQStatus);

                        }
                        else
                                Status = STATUS_ALREADY_DISCONNECTED;

                        // get other users free entry
                        KeReleaseSpinLock(&pciada->AccessLock, oldIrql);
                }
                else
                        Status = STATUS_UNSUCCESSFUL;
        }
        else
                Status = STATUS_BUFFER_TOO_SMALL;
        // do what must be here in between --- end ---

        COMPLETE_REQUEST;

    KdPrint(("ioctl_reset(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// set parameter for this path for future access to VME
static NTSTATUS ioctl_access_para(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack)
{
        NTSTATUS        Status    = STATUS_SUCCESS;
        ULONG           irp_info  = 0;
        PVOID           pInputBuffer,pOutputBuffer;
        ULONG           InputLength, OutputLength;
        PCIVME_ACCESS_COMMAND *pAccessPara;
        FILE_OBJ    *file_obj = (FILE_OBJ *)Irp->Tail.Overlay.OriginalFileObject->FsContext;
        DEVICE_EXT      *pDevExt  = (DEVICE_EXT *)(device_Obj->DeviceExtension);
        PCIADA      *pciada   = pDevExt->vmemm[file_obj->uwAssociatedVMEMM];

        SET_BUFFERS_METHOD_BUFFERED;

    KdPrint(("ioctl_access_para(%d)\n", file_obj->uwAssociatedVMEMM));
   
        pAccessPara = (PCIVME_ACCESS_COMMAND *)pInputBuffer;

        // do here in between what has to be done -----------------
        file_obj->bAddressModifier  = pAccessPara->bAddressModifier & MODIFIER_MASK;
        file_obj->bAccessType       = pAccessPara->bAccessType;
        file_obj->bIncrement        = pAccessPara->bIncrement;
        file_obj->dwAddressMask     = pAccessPara->bAccessType - 1;

        // honor backward compatibility
        if (file_obj->bAddressModifier & 0x30)
                file_obj->dwAccessBase = 0;
        else
                file_obj->dwAccessBase      = pAccessPara->dwAccessBase;

        // access_type          increment
        //      1                               0,1,2,3,4
        //      2                               0,2,4
        //      4                               0,4

        if (pAccessPara->bIncrement % pAccessPara->bAccessType)
                Status = STATUS_DATATYPE_MISALIGNMENT;

        switch (pAccessPara->bAccessType)
        {
                case BYTE_ACCESS: file_obj->fRead  = readByte;
                                                  file_obj->fWrite = writeByte;
                                                  break;
                case WORD_ACCESS: file_obj->fRead  = readWord;
                                                  file_obj->fWrite = writeWord;
                                                  break;
                case LONG_ACCESS: if (pciada->bWordMode)
                                                  {
                                                        file_obj->fRead  = readWord;
                                                        file_obj->fWrite = writeWord;
                                                  }
                                                  else
                                                  {
                                                        file_obj->fRead  = readLong;
                                                        file_obj->fWrite = writeLong;
                                                  }
                                                  break;
                default: Status = STATUS_UNSUCCESSFUL; break;
        }
        // do here in between what has to be done end -------------

        COMPLETE_REQUEST;

    KdPrint(("ioctl_access_para(), Status = 0x%08x\n", Status));

        return Status;
}

//------------------------------------------------------------------------
// the ultimate jumptable for ioctl
//
NTSTATUS (*ioctl[])(PDEVICE_OBJECT device_Obj, PIRP Irp, PIO_STACK_LOCATION IrpStack) =  
{
        ioctl_init_hardware,                    // 0
        ioctl_deinit_hardware,                  // 1
        ioctl_dummy,                                    // 2
        ioctl_dummy,                                    // 3
        ioctl_get_static_status,                // 4
        ioctl_get_dynamic_status,               // 5
        ioctl_read_vector,                              // 6
        ioctl_access_VIC68A,                    // 7
        ioctl_dummy,                                    // 8
        ioctl_control_interrupts,       // 9
        ioctl_TAS,                                              // 10
        ioctl_dummy,                                    // 11
        ioctl_reset,                                    // 12
        ioctl_access_para                               // 13
};