driver.h

The PCI Local bus concept was developed to break the PC data I/O bottleneck and clearly opens the d

#ifndef DRIVER_H
#define DRIVER_H

#ifdef __cplusplus
extern "C" {
#endif

#include <wdm.h>							// standard declarations for WDM

#ifdef __cplusplus
}
#endif

#include <stdio.h>
#include "../../common/amccdef.h"
#include "../../common/siddkapi_win.h"

#define arraysize(p) (sizeof(p)/sizeof((p)[0]))

enum DEVICESTATE
{
	STOPPED,								// device stopped
	WORKING,								// started and working
	PENDINGSTOP,							// stop pending
	PENDINGREMOVE,							// remove pending
	SURPRISEREMOVED,						// removed by surprise
	REMOVED									// removed
};

typedef VOID (__stdcall *PQNOTIFYFUNC)(PVOID);

typedef struct _DEVQUEUE
{
	LIST_ENTRY head;
	KSPIN_LOCK lock;
	PDRIVER_STARTIO StartIo;
	LONG stallcount;
	PIRP CurrentIrp;
	KEVENT evStop;
	PQNOTIFYFUNC notify;
	PVOID notifycontext;
	NTSTATUS abortstatus;

} DEVQUEUE, *PDEVQUEUE;

typedef struct _SI_Transfer_Info
{
	ULONG BytesRequested;
	ULONG BytesRemaining;
	PUCHAR LogicalAddress;
	ULONG CurrentTransferSize;
	PIRP pIrp;
	BOOLEAN TransferInProgress;
	KDPC TimerDPC;
	KTIMER Timer;
	PADAPTER_OBJECT Adapter;
	ULONG NumberOfMapRegisters;
	PVOID MapRegisterBase;
	PMDL Mdl;

} SI_TRANSFER_INFO;

// Device extension structure

typedef struct tagDEVICE_EXTENSION
{
	PDEVICE_OBJECT DeviceObject;			// device object this extension belongs to
	PDEVICE_OBJECT LowerDeviceObject;		// next lower driver in same stack
	DEVICESTATE state;						// state of the device
	DEVICESTATE oldstate;					// previous state of the device
	UNICODE_STRING ifname;					// interface name
	LONG usage;								// use count on this device
	KEVENT evRemove;						// set when okay to remove this device
	BOOLEAN enabled;						// TRUE if device enabled for interrupts
	BOOLEAN removing;						// TRUE if we're trying to remove this device
	BOOLEAN mem_mapped[PCI_TYPE0_ADDRESSES];// TRUE if memory address is memory mapped
	PULONG base[PCI_TYPE0_ADDRESSES];		// base port or memory address
	ULONG base_len[PCI_TYPE0_ADDRESSES];	// length of base port or memory address region

	// Asynchronous Data Transfer Values
	SI_TRANSFER_INFO ReadTransfer;			// structure for BusMastered Read Transfers
	SI_TRANSFER_INFO WriteTransfer;			// structure for BusMastered Write Transfers
	ULONG Timeout_ms;						// timeout value for BusMastered Transfers
	PKINTERRUPT InterruptObject;			// interrupt to which device is connected
	ULONG int_cause;						// used for tracking cause of interrupts
	ULONG Callback_Event;					// handle for the callback event
	DEVQUEUE dqReadWrite;

	// Addresses used for direct mapping of application space
	PULONG Direct_Baddr[PCI_TYPE0_ADDRESSES];
	PHYSICAL_ADDRESS Phys_Addr[PCI_TYPE0_ADDRESSES];
	PMDL Mdl[PCI_TYPE0_ADDRESSES];

} DEVICE_EXTENSION, *PDEVICE_EXTENSION;

// Global functions

NTSTATUS CompleteRequest(IN PIRP Irp, IN NTSTATUS status, IN ULONG info);
BOOLEAN LockDevice(IN PDEVICE_EXTENSION pdx);
BOOLEAN LockDevice(IN PDEVICE_OBJECT fdo);
VOID UnlockDevice(IN PDEVICE_EXTENSION pdx);
VOID UnlockDevice(IN PDEVICE_OBJECT fdo);
VOID UnlockDeviceAndWait(IN PDEVICE_EXTENSION pdx);
NTSTATUS OnRequestComplete(IN PDEVICE_OBJECT fdo, IN PIRP Irp, IN PKEVENT Event);
NTSTATUS ForwardAndWait(PDEVICE_EXTENSION pdx, PIRP Irp);
VOID Sheldon_StartIo(IN PDEVICE_OBJECT fdo, IN PIRP Irp);
VOID SheldonTimerRoutine(PKDPC Dpc, PVOID Context, PVOID junk1, PVOID junk2);
BOOLEAN SheldonIsr(IN PKINTERRUPT Interrupt, IN PVOID ServiceContext);
VOID SheldonDpcForIsr(IN PKDPC Dpc, IN PDEVICE_OBJECT pDeviceObj, IN PIRP Irp, IN PVOID Context);
NTSTATUS SheldonUnMapDirect(PDEVICE_EXTENSION pdx);

VOID InitializeQueue(PDEVQUEUE pdq, PDRIVER_STARTIO StartIo);
VOID StartPacket(PDEVQUEUE pdq, PDEVICE_OBJECT fdo, PIRP Irp, PDRIVER_CANCEL cancel);
PIRP StartNextPacket(PDEVQUEUE pdq, PDEVICE_OBJECT fdo);
VOID CancelRequest(PDEVQUEUE pdq, PIRP Irp);
VOID CleanupRequests(PDEVQUEUE pdq, PFILE_OBJECT fop, NTSTATUS status);
VOID StallRequests(PDEVQUEUE pdq);
VOID RestartRequests(PDEVQUEUE pdq, PDEVICE_OBJECT fdo);
PIRP GetCurrentIrp(PDEVQUEUE pdq);
BOOLEAN CheckBusyAndStall(PDEVQUEUE pdq);
VOID WaitForCurrentIrp(PDEVQUEUE pdq);
VOID AbortRequests(PDEVQUEUE pdq, NTSTATUS status);
VOID AllowRequests(PDEVQUEUE pdq);
NTSTATUS AreRequestsBeingAborted(PDEVQUEUE pdq);
NTSTATUS StallRequestsAndNotify(PDEVQUEUE pdq, PQNOTIFYFUNC notify, PVOID context);

VOID OnCancel(PDEVICE_OBJECT fdo, PIRP Irp);

// I/O request handlers

NTSTATUS Sheldon_Create(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_Cleanup(PDEVICE_OBJECT fdo, PIRP Irp);
NTSTATUS Sheldon_Close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_ProcessIOCTL(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_Read(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_Write(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_ProcessSysControlIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_ProcessPnPIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
NTSTATUS Sheldon_ProcessPowerIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);

#endif