ISA驱动源码，IO+IRQ，安装文件INF

我有ISA驱动源码，IO+IRQ，安装文件INF
QQ:251753978

楼主给发一个好吗??谢谢
lafite@sohu.com

这个。。免费的把？

给偶一份好不？
pangshengjin@163.com

给我也发一份，OK?
xi_pzh@263.net

inducement

楼主我想要。
netroot@21cn.com

搂住最好把它传到本站上来

是啊，用来学习还是蛮好的！
我也要一份
pop_yang@163.net

give me a copy ,
email: sunvan_hu@163.com

我有ISA驱动源码，IO+IRQ，安装文件INF
QQ:251753978

如果是想共享就放上来，如果是要卖钱就明说，弄得那么多人这里喊，其实这样的驱动是非常简单的，也大可不必这里卖关子

您好，能发给我吗？万分感谢。
wangyueying@126.com

我也需要一份。
linweichuan@sohu.com

大哥帮帮忙给我一份,急需

sorry 我的  email : wonder_2001@163.com

ISA的其实很简单，用driverworks按提示一步步操作下去即可，不用给我发了。

给我发一份可以吗？myxeei316@sina.com

可以给我一份吗？谢谢～！
li-mn@163.com

可以给我一份吗？谢谢～！
xue_feng2005@126.com

没有发现这么多人要
*******************************************
//
// Driver.c - Chapter 7 - Loopback Driver
//
// Copyright (C) 2000 by Jerry Lozano
//

#include \"Driver.h\"
#include \"stdlib.h\"
#include <math.h>

// Forward declarations
//
static NTSTATUS CreateDevice (IN PDRIVER_OBJECT pDriverObject,IN ULONG ulDeviceNumber);
static VOID DriverUnload (IN PDRIVER_OBJECT pDriverObject);
static NTSTATUS DispatchCreate (IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
static NTSTATUS DispatchClose (IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp);
static NTSTATUS DispatchDeviceControl (IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp) ;

BOOLEAN Isr (IN PKINTERRUPT pIntObj,IN PVOID pServiceContext);

bool LockAdContext( PDEVICE_EXTENSION pDevExt, void * pInBuf, __int32 inLength );
void UnLockAdContext(PDEVICE_EXTENSION pDevExt);
bool LockBuffers(PDEVICE_EXTENSION pDevExt);
void UnLockBuffers(PDEVICE_EXTENSION pDevExt);
void EnableDynamicAcq(PDEVICE_EXTENSION pDevExt);
void DisableDynamicAcq(PDEVICE_EXTENSION pDevExt);
void RollBackData(PDEVICE_EXTENSION pDevExt);
void RefreshZeros(PDEVICE_EXTENSION pDevExt);
void DumpAdContext(PDEVICE_EXTENSION pDevExt);

extern \"C\"
NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING pRegistryPath)
{
ULONG ulDeviceNumber = 0;
NTSTATUS status;

// Announce other driver entry points
pDriverObject->DriverUnload = DriverUnload;
// This includes Dispatch routines for Create
pDriverObject->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;
pDriverObject->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;
pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchDeviceControl;

// For each physical or logical device detected
// that will be under this Driver\'s control,
// a new Device object must be created.
status = CreateDevice(pDriverObject, ulDeviceNumber);
return status;
}

NTSTATUS CreateDevice(IN PDRIVER_OBJECT pDriverObject, IN ULONG ulDeviceNumber)
{
NTSTATUS status;
PDEVICE_OBJECT pDevObj;
PDEVICE_EXTENSION pDevExt;

// Form the internal Device Name
CUString devName(\"\\\\Device\\\\Gcu2kSampleDevice\");
devName += CUString(ulDeviceNumber);

// Now create the device
status = IoCreateDevice(pDriverObject,
sizeof(DEVICE_EXTENSION),
&(UNICODE_STRING)devName,
FILE_DEVICE_UNKNOWN,
0, TRUE,
&pDevObj );
if (!NT_SUCCESS(status))
return status;

// Announce that we will be working with a copy of the user\'s buffer
pDevObj->Flags |= DO_BUFFERED_IO;

// Initialize the Device Extension
pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
pDevExt->pDevice = pDevObj; // back pointer
pDevExt->DeviceNumber = ulDeviceNumber;
pDevExt->ustrDeviceName = devName;

pDevExt->spinLock = 0;
pDevExt->isrControlCode = 0;
pDevExt->pIntObj = NULL;

pDevExt->pMdlAdContext = NULL;
pDevExt->pLockedAdContext = NULL;

pDevExt->bLockAdContext = false;
pDevExt->bLockBuffers = false;
pDevExt->enableDynamicAcq = 0;
pDevExt->enableStaticAcq = 0;

// Create & connect to an Interrupt object
// To make interrupts real, we must translate irq into
// a HAL irq and vector (with processor affinity)
KIRQL kIrql;
KAFFINITY kAffinity;
ULONG kVector =HalGetInterruptVector(Isa, 0, IRQ, 0, &kIrql, &kAffinity);

//DbgPrint(\"Interrupt %x converted: kIrql = %x, kAffinity = %x, kVector = %x\\n\",
// IRQ, kIrql, kAffinity, kVector);

status =IoConnectInterrupt(
&pDevExt->pIntObj, // the Interrupt object
Isr, // our ISR
pDevExt, // Service Context
NULL, // no spin lock
kVector, // vector
kIrql, // DIRQL
kIrql, // DIRQL
Latched, // Latched or LevelSensitive
TRUE, // Shared?
kAffinity, // processors in an MP set
FALSE ); // save FP registers?
if (!NT_SUCCESS(status)) {
DbgPrint(\" IoConnectInterrupt failed\");
IoDeleteDevice( pDevObj );
return status;
}

// Form the symbolic link name
CUString symLinkName(\"\\\\??\\\\Gcu2kSampleDevice\");
symLinkName += CUString(ulDeviceNumber+1); // 1 based
pDevExt->ustrSymLinkName = symLinkName;

// Now create the link name
status = IoCreateSymbolicLink( &(UNICODE_STRING)symLinkName,&(UNICODE_STRING)devName );
if (!NT_SUCCESS(status)) {
IoDeleteDevice( pDevObj );
return status;
}

return STATUS_SUCCESS;
}


NTSTATUS DispatchCreate(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = 0; // no bytes xfered
IoCompleteRequest( pIrp, IO_NO_INCREMENT );
return STATUS_SUCCESS;
}

NTSTATUS DispatchClose(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
// Dig out the Device Extension from the Device object
PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION) pDevObj->DeviceExtension;

if(pDevExt->enableDynamicAcq)
DisableDynamicAcq(pDevExt);

if(pDevExt->bLockBuffers)
UnLockBuffers(pDevExt);

if(pDevExt->bLockAdContext)
UnLockAdContext(pDevExt);

pIrp->IoStatus.Status = STATUS_SUCCESS;
pIrp->IoStatus.Information = 0; // no bytes xfered
IoCompleteRequest( pIrp, IO_NO_INCREMENT );
return STATUS_SUCCESS;
}


VOID DriverUnload(IN PDRIVER_OBJECT pDriverObject)
{
PDEVICE_OBJECT pNextObj;

// Loop through each device controlled by Driver
pNextObj = pDriverObject->DeviceObject;
while (pNextObj != NULL) {
PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION) pNextObj->DeviceExtension;

// Delete our Interrupt object
if (pDevExt->pIntObj)
IoDisconnectInterrupt( pDevExt->pIntObj );

UNICODE_STRING pLinkName = pDevExt->ustrSymLinkName;
IoDeleteSymbolicLink(&pLinkName);
pNextObj = pNextObj->NextDevice;
IoDeleteDevice( pDevExt->pDevice );
}
}

bool LockAdContext(PDEVICE_EXTENSION pDevExt, void *pInBuf, __int32 inLength)
{
if(pDevExt->bLockAdContext)
return true;

InterlockedExchange(&(pDevExt->spinLock), 1);
__try{
AdContext *pUserAdContext = (AdContext *)pInBuf;
pDevExt->pUserAdContext = pUserAdContext;
PMDL pMdl = IoAllocateMdl(pUserAdContext, inLength, FALSE, TRUE, NULL);
pDevExt->pMdlAdContext = pMdl;
MmProbeAndLockPages(pMdl, UserMode,IoModifyAccess);
pDevExt->pLockedAdContext = (AdContext *)MmGetSystemAddressForMdlSafe(pMdl, NormalPagePriority);
pDevExt->bLockAdContext = true;
DbgPrint(\"driver: lock AdContext success\");
}__except (1){
pDevExt->pMdlAdContext = NULL;
pDevExt->pLockedAdContext = NULL;
DbgPrint(\"driver: failed to lock AdContext\");
}
InterlockedExchange(&(pDevExt->spinLock),0);
return pDevExt->bLockAdContext;
}

void UnLockAdContext(PDEVICE_EXTENSION pDevExt)
{
if(!pDevExt->bLockAdContext)
return ;

InterlockedExchange(&(pDevExt->spinLock),1);
{
MmUnlockPages(pDevExt->pMdlAdContext);
IoFreeMdl(pDevExt->pMdlAdContext);
pDevExt->pMdlAdContext = NULL;
pDevExt->pLockedAdContext = NULL;
pDevExt->bLockAdContext = false;
DbgPrint(\"driver: unlock AdContext success\");
}
InterlockedExchange(&(pDevExt->spinLock),0);
}


bool LockBuffers(PDEVICE_EXTENSION pDevExt)
{
if(!pDevExt->bLockAdContext){
DbgPrint(\"driver: failed to lock buffers due to failed lock AdContext\");
return false;
}

if(pDevExt->bLockBuffers){
DbgPrint(\"driver: Try to lock buffers twice\");
return true;
}

InterlockedExchange(&(pDevExt->spinLock), 1);
__try{
PMDL pMdl;
int dynamicBufWords = pDevExt->pLockedAdContext->DBufBoundWords;
for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++){
pMdl = IoAllocateMdl(pDevExt->pLockedAdContext->ad.pBuf, dynamicBufWords*2,FALSE,TRUE,NULL);
pDevExt->pLockedAdContext->ad.pMdl = pMdl;
MmProbeAndLockPages(pMdl, UserMode,IoModifyAccess);
pDevExt->pLockedAdContext->ad.pMapBuf = (unsigned short *)MmGetSystemAddressForMdlSafe(pMdl,NormalPagePriority);
}
pDevExt->bLockBuffers = true;
DbgPrint(\"driver: lock buffers success\");

//Start first A/D
for(i=0; i<pDevExt->pLockedAdContext->adsNumber; i++)
WRITE_PORT_USHORT( &(pDevExt->pLockedAdContext->ad.startPort),0);

//Delay 15 microSeconds
//LARGE_INTEGER  interval;
//KeDelayExecutionThread(KernelMode,FALSE,&interval);

}__except (1){
for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++){
pDevExt->pLockedAdContext->ad.pMdl = NULL;
pDevExt->pLockedAdContext->ad.pMapBuf = NULL;
}
DbgPrint(\"driver: failed to lock buffers\");
}
InterlockedExchange(&(pDevExt->spinLock),0);
return pDevExt->bLockBuffers;
}

void UnLockBuffers(PDEVICE_EXTENSION pDevExt)
{
if(!pDevExt->bLockBuffers)
return ;

InterlockedExchange(&(pDevExt->spinLock), 1);
{
pDevExt->isrControlCode = 0;

for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++)
if(pDevExt->pLockedAdContext->ad.pMdl != NULL){
MmUnlockPages(pDevExt->pLockedAdContext->ad.pMdl);
IoFreeMdl(pDevExt->pLockedAdContext->ad.pMdl);
pDevExt->pLockedAdContext->ad.pMdl = NULL;
pDevExt->pLockedAdContext->ad.pMapBuf = NULL;
}
pDevExt->bLockBuffers = false;
DbgPrint(\"driver: unlock buffers success\");
}
InterlockedExchange(&(pDevExt->spinLock),0);
}

void EnableDynamicAcq(PDEVICE_EXTENSION pDevExt)
{
InterlockedExchange(&(pDevExt->spinLock), 1);
InterlockedExchange(&(pDevExt->enableDynamicAcq), 1);
InterlockedExchange(&(pDevExt->spinLock),0);
}

void DisableDynamicAcq(PDEVICE_EXTENSION pDevExt)
{
InterlockedExchange(&(pDevExt->spinLock), 1);
InterlockedExchange(&(pDevExt->enableDynamicAcq), 0);
InterlockedExchange(&(pDevExt->spinLock),0);
}

void StartStaticAcq(PDEVICE_EXTENSION pDevExt)
{
InterlockedExchange(&(pDevExt->spinLock), 1);
if(pDevExt->pLockedAdContext->SBufBoundWords > SBUFBOUNDWORDS)
pDevExt->pLockedAdContext->SBufBoundWords = SBUFBOUNDWORDS;

pDevExt->pLockedAdContext->staticIndex = 0;
for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++){
pDevExt->pLockedAdContext->ad.staticSumAd = 0;
for(int j=0; j<pDevExt->pLockedAdContext->SBufBoundWords; j++)
pDevExt->pLockedAdContext->ad.staticAd[j] = 0;
}
InterlockedExchange(&(pDevExt->enableStaticAcq), 1);
InterlockedExchange(&(pDevExt->spinLock),0);
}

void StopStaticAcq(PDEVICE_EXTENSION pDevExt)
{
InterlockedExchange(&(pDevExt->spinLock), 1);
InterlockedExchange(&(pDevExt->enableStaticAcq), 0);
InterlockedExchange(&(pDevExt->spinLock),0);
}

void RollBackData(PDEVICE_EXTENSION pDevExt)
{
//roll data back with 50 words
if(!pDevExt->bLockBuffers)
return ;

InterlockedExchange(&(pDevExt->spinLock), 1);

for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++)
for(int j=50; j<pDevExt->pLockedAdContext->validWords; j++)
pDevExt->pLockedAdContext->ad.pMapBuf[j-50] = pDevExt->pLockedAdContext->ad.pMapBuf[j];
pDevExt->pLockedAdContext->validWords-=50;

InterlockedExchange(&(pDevExt->spinLock),0);
}

void RefreshZeros(PDEVICE_EXTENSION pDevExt)
{
//roll data back with 50 words
if(!pDevExt->bLockBuffers)
return ;

InterlockedExchange(&(pDevExt->spinLock), 1);
//用最前面的200个word的平均值更新零点
for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++){
for(unsigned int sum=0,j=0; j<200; j++)
sum += pDevExt->pLockedAdContext->ad.pMapBuf[j];
pDevExt->pLockedAdContext->ad.pMapBuf[0] = sum/200;
}

InterlockedExchange(&(pDevExt->spinLock),0);
}

NTSTATUS DispatchDeviceControl(IN PDEVICE_OBJECT pDevObj,IN PIRP pIrp)
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
PIO_STACK_LOCATION pIrpStack =IoGetCurrentIrpStackLocation( pIrp );
ULONG ioControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;

void * pInBuf = (__int32 *) pIrpStack->Parameters.DeviceIoControl.Type3InputBuffer;
__int32 inLength = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;

    switch (ioControlCode) {
case IOCTL_LOCK_AD_CONTEXT:
if(!LockAdContext(pDevExt, pInBuf, inLength))
status=STATUS_NOT_MAPPED_DATA;
break;

case IOCTL_UNLOCK_AD_CONTEXT:
UnLockAdContext(pDevExt);
break;

case IOCTL_LOCK_BUFFERS:
if(!LockBuffers(pDevExt))
status=STATUS_NOT_MAPPED_DATA;
break;

case IOCTL_UNLOCK_BUFFERS:
UnLockBuffers(pDevExt);
break;

case IOCTL_START_DYNAMIC_ACQ:
pDevExt->firstAcq=1;
EnableDynamicAcq(pDevExt);
break;

case IOCTL_START_STATIC_ACQ:
StartStaticAcq(pDevExt);
break;

case IOCTL_STOP_STATIC_ACQ:
StopStaticAcq(pDevExt);
break;

case IOCTL_STOP_DYNAMIC_ACQ:
DisableDynamicAcq(pDevExt);
break;

case IOCTL_ROLL_BACK_DATA:
RollBackData(pDevExt);
break;

case IOCTL_REFRESH_ZEROS:
RefreshZeros(pDevExt);
break;

case IOCTL_DUMP_AD_CONTEXT:
DumpAdContext(pDevExt);
break;
case IOCTL_OPEN_XCJP:
OpenXcjp(pDevExt);
break;
case IOCTL_CLOSE_XCJP:
CloseXcjp(pDevExt);
break;
default:
DbgPrint(\"invalid ioControlCode\");
status = STATUS_INVALID_DEVICE_REQUEST;
break;
}

pIrp->IoStatus.Information = 0;
pIrp->IoStatus.Status = status;

IoCompleteRequest( pIrp, IO_NO_INCREMENT );
return status;
}

void DumpAdContext(PDEVICE_EXTENSION pDevExt)
{
if(!pDevExt->bLockAdContext){
DbgPrint(\"AdContext has not been locked!\");
return;
}

DbgPrint(\"pUserAdContext=%x\",pDevExt->pUserAdContext);
DbgPrint(\"pLockedAdContext=%x\",pDevExt->pLockedAdContext);
DbgPrint(\"DBufBoundWords=%d\",pDevExt->pLockedAdContext->DBufBoundWords);
DbgPrint(\"validWords=%d\",pDevExt->pLockedAdContext->validWords);

DbgPrint(\"adsNumber=%d\",pDevExt->pLockedAdContext->adsNumber);
for(int i=0; i<pDevExt->pLockedAdContext->adsNumber; i++){
DbgPrint(\"Ad[%d].startPort=%x\",i,pDevExt->pLockedAdContext->ad.startPort);
DbgPrint(\"Ad[%d].dataport=%x\",i,pDevExt->pLockedAdContext->ad.dataport);
DbgPrint(\"Ad[%d].pBuf=%x\",i,pDevExt->pLockedAdContext->ad.pBuf);

if(!pDevExt->bLockBuffers)
DbgPrint(\"Ad[%d].pMapBuf=%x,buffer has not been locked\",i,pDevExt->pLockedAdContext->ad.pMapBuf);
else
DbgPrint(\"Ad[%d].pMapBuf=%x\",i,pDevExt->pLockedAdContext->ad.pMapBuf);
}
}

BOOLEAN Isr(IN PKINTERRUPT pIntObj,IN PVOID pServiceContext)
{
PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pServiceContext;

if((pDevExt->spinLock) || (!pDevExt->bLockAdContext))
return TRUE;

AdContext *pLockedAdContext = pDevExt->pLockedAdContext;

// read current A/D
if((pDevExt->enableStaticAcq) || (pDevExt->enableDynamicAcq))
for(int i=0; i<pLockedAdContext->adsNumber; i++)
pLockedAdContext->ad.currentAd =
READ_PORT_USHORT((PUSHORT)(pLockedAdContext->ad.dataport))>>1;

// static acquire
if(pDevExt->enableStaticAcq){
for(int i=0; i<pLockedAdContext->adsNumber; i++){
pLockedAdContext->ad.staticSumAd -=
pLockedAdContext->ad.staticAd[pLockedAdContext->staticIndex];

pLockedAdContext->ad.staticAd[pLockedAdContext->staticIndex] =
pLockedAdContext->ad.currentAd;

pLockedAdContext->ad.staticSumAd += pLockedAdContext->ad.currentAd;

pLockedAdContext->ad.averageAd = (unsigned short)
(pLockedAdContext->ad.staticSumAd / pLockedAdContext->SBufBoundWords);
}

pLockedAdContext->staticIndex++;
if(pLockedAdContext->staticIndex == pLockedAdContext->SBufBoundWords)
pLockedAdContext->staticIndex = 0;
}

// dynamic acquire
if(pDevExt->enableDynamicAcq){
if(pLockedAdContext->validWords >= pLockedAdContext->DBufBoundWords){
DbgPrint(\"Isr overflow to upper!\");
return true;
}

for(int i=0; i<pLockedAdContext->adsNumber; i++)
pLockedAdContext->ad.pMapBuf[pLockedAdContext->validWords] =
pLockedAdContext->ad.currentAd;

if(1==pDevExt->firstAcq){
pDevExt->firstAcq=0;
}else{
pLockedAdContext->validWords++;
}
}

// start next A/D
WRITE_PORT_USHORT((PUSHORT)(pLockedAdContext->ad[0].startPort),0);

for(int i=1; i<pLockedAdContext->adsNumber; i++){
bool bSameStartPort=false;

for(int j=0;j<=i-1;j++)
if(pLockedAdContext->ad.startPort==pLockedAdContext->ad[j].startPort)
bSameStartPort=true;

if(!bSameStartPort)
WRITE_PORT_USHORT( (PUSHORT)(pLockedAdContext->ad.startPort),0);
}

return TRUE;
}