regisaint.c

本程序用以示范如何挂接windows系统下的硬件中断（如并口中断

/********************************************************************/
/*Register Isa Interrupt driver composed by 曾国强*******************/
/********************************************************************/
#include <ntddk.h>
#include"DebugPrint.h"
#include"RegIsaIntIOCtl.h"

#define outportb(ADDR,BYTE) 	WRITE_PORT_UCHAR(ADDR,BYTE)
#define inportb(ADDR)		READ_PORT_UCHAR(ADDR)

typedef struct _IntPara{
	/*interrupt vector*/
	unsigned short		m_IrqNum;
	/*m_TrigManner==true:Latched; m_TrigManner==false:LevelSensitive*/
	int				m_TrigManner;
}IntPara,*PIntPara;


typedef struct _LOCAL_DEVICE_INFO {
    PKINTERRUPT 		InterruptObject;
    ULONG				Level;      
    ULONG				Vector;     
    KAFFINITY			Affinity;
	IntPara				m_IntPara;
	int					m_ConnectInt;/*m_ConnectInt==true:Connected; m_ConnectInt==false:disconnected*/
} LOCAL_DEVICE_INFO, *PLOCAL_DEVICE_INFO;

/*断开中断*/
VOID UnRegisterInt(IN PLOCAL_DEVICE_INFO deviceExt);
/*连接中断*/
NTSTATUS RegisterInt(IN PLOCAL_DEVICE_INFO	DeviceExtension,IN PDEVICE_OBJECT DeviceObject);


PKEVENT IntComeEvent;/*获得应用程序生成的事件*/

NTSTATUS RegIsaIntCreateDispatch(IN PDEVICE_OBJECT DeviceObject,
								IN PIRP Irp)
{
	PLOCAL_DEVICE_INFO deviceExt;/*设备扩展*/
	PIO_STACK_LOCATION IrpStack;/*Irp栈*/
	
	NTSTATUS status;
	NTSTATUS status_reg;
	ULONG				 dwIoControlCode;
	PULONG               pSystemBuffer;/*系统缓冲区指针*/
	IntPara				 IntParaTemp;
	deviceExt=DeviceObject->DeviceExtension;
	Irp->IoStatus.Information = 0;
	Irp->IoStatus.Status = STATUS_SUCCESS;

	IrpStack = IoGetCurrentIrpStackLocation(Irp);

	pSystemBuffer = Irp->AssociatedIrp.SystemBuffer;

	switch (IrpStack->MajorFunction)
	{
		case IRP_MJ_CREATE:		/*与WIN32应用程序中的CreateFile对应，锁定内存*/
			break;
		case IRP_MJ_CLOSE:		/*与WIN32应用程序中的CloseHandle对应，此处解除对内存的锁定*/
			break;
		case IRP_MJ_DEVICE_CONTROL:		/*与WIN32应用程序中的DeviceIoControl对应*/
			dwIoControlCode = IrpStack->Parameters.DeviceIoControl.IoControlCode;
			switch (dwIoControlCode)
			{
				case RegisterIsaInt:
					IntParaTemp=*(IntPara*)pSystemBuffer;
					/*连接不同的中断*/
					if(IntParaTemp.m_IrqNum!=deviceExt->m_IntPara.m_IrqNum)
					{
						/*先前挂接的中断还没有断开*/
						if(deviceExt->m_ConnectInt==1)
						{
							UnRegisterInt(deviceExt);
							deviceExt->m_ConnectInt=0;
						}
						deviceExt->m_IntPara=IntParaTemp;
						status_reg=RegisterInt(deviceExt,DeviceObject);
						if(NT_SUCCESS(status_reg))
							deviceExt->m_ConnectInt=1;
						else
							deviceExt->m_ConnectInt=0;
						*(int*)pSystemBuffer=deviceExt->m_ConnectInt;
						Irp->IoStatus.Information=sizeof(deviceExt->m_ConnectInt);
					}
					/*连接相同的中断*/
					else
					{
						/*尚未挂接中断，可以直接挂接*/
						if(deviceExt->m_ConnectInt==0)
						{
							deviceExt->m_IntPara=IntParaTemp;
							status_reg=RegisterInt(deviceExt,DeviceObject);
							if(NT_SUCCESS(status_reg))
								deviceExt->m_ConnectInt=1;	
							else
								deviceExt->m_ConnectInt=0;
							*(int*)pSystemBuffer=deviceExt->m_ConnectInt;
							Irp->IoStatus.Information=sizeof(deviceExt->m_ConnectInt);
						}
						/*已经挂接了中断*/
						else
						{
							/*中断的触发方式改变了，则重新断开，并挂接*/
							if(IntParaTemp.m_TrigManner!=deviceExt->m_IntPara.m_TrigManner)
							{
								UnRegisterInt(deviceExt);
								deviceExt->m_ConnectInt=0;
								deviceExt->m_IntPara=IntParaTemp;
								status_reg=RegisterInt(deviceExt,DeviceObject);
								if(NT_SUCCESS(status_reg))
									deviceExt->m_ConnectInt=1;
								else
									deviceExt->m_ConnectInt=0;
								*(int*)pSystemBuffer=deviceExt->m_ConnectInt;
								Irp->IoStatus.Information=sizeof(deviceExt->m_ConnectInt);
							}
							/*中断的触发方式没有改变，则什么都不做*/
							else
							{
								*(int*)pSystemBuffer=deviceExt->m_ConnectInt;
								Irp->IoStatus.Information=sizeof(deviceExt->m_ConnectInt);
							}
						}
					}
					break;
				case UnRegisterIsaInt:
					if(deviceExt->m_ConnectInt==1)
					{
						UnRegisterInt(deviceExt);
						deviceExt->m_ConnectInt=0;
					}
					break;
				case PassDownEvent:
					ObReferenceObjectByHandle((HANDLE)(*pSystemBuffer), 
											0x0002,
											NULL, 
											UserMode,
											(PVOID *)(&IntComeEvent),
											NULL);
					break;
				default:		// 不支持的IOCTL
					Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
			}
	}
	status = Irp->IoStatus.Status;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return status;
}

VOID RegIsaIntDpcRoutine(IN PKDPC Dpc, PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
{
	PLOCAL_DEVICE_INFO DeviceExtension;
	PIRP pIrp;

	pIrp = DeviceObject->CurrentIrp;
	DeviceExtension = DeviceObject->DeviceExtension;
	/*设置事件为有效状态*/
	KeSetEvent(IntComeEvent,2,FALSE);
}

//中断处理例程
BOOLEAN RegIsaIntIsr(IN PKINTERRUPT Interrupt, IN OUT PVOID Context)
{
	PDEVICE_OBJECT DeviceObject = Context;
	/*请求异步过程调用*/
	IoRequestDpc(DeviceObject,
	 			DeviceObject->CurrentIrp,
				NULL);
	return TRUE;
}


/*断开中断*/
VOID UnRegisterInt(IN PLOCAL_DEVICE_INFO deviceExt)
{
	/* Disconnect Interrupt */ 
	IoDisconnectInterrupt(deviceExt->InterruptObject);
	DebugPrint("RegIsaInt.sys: Disconnect interrupt!\n");
}
/*挂接中断*/
NTSTATUS RegisterInt(IN PLOCAL_DEVICE_INFO	DeviceExtension,IN PDEVICE_OBJECT DeviceObject)
{
	NTSTATUS status;
	ULONG				MappedVector;
   	KIRQL				Irql;
	DeviceExtension->Level = DeviceExtension->m_IntPara.m_IrqNum;
	DeviceExtension->Vector = DeviceExtension->Level;

   	MappedVector = HalGetInterruptVector(Isa,						
                                           0,							
                                           DeviceExtension->Level,		
                                           DeviceExtension->Vector,	
                                           &Irql,						
                                           &DeviceExtension->Affinity);

 	if (MappedVector == 0)
		DebugPrint("RegIsaInt.sys: HalGetInterruptVector failed\n");
	if(DeviceExtension->m_IntPara.m_TrigManner==1)/*边沿触发*/
	{
  		status = IoConnectInterrupt(&DeviceExtension->InterruptObject, // InterruptObject
  						    RegIsaIntIsr,				   // ServiceRoutine
  						    DeviceObject,				   // ServiceContext
 						    NULL,					   // SpinLock
						    MappedVector,				   // Vector
  						    Irql,					   // Irql
						    Irql,					   // SynchronizeIrql
						    Latched,				   // InterruptMode
  						    TRUE,					   // ShareVector
						    DeviceExtension->Affinity,	   // ProcessorEnableMask
						    FALSE);					   // FloatingSave
	}
	else/*电平触发*/
	{
		status = IoConnectInterrupt(&DeviceExtension->InterruptObject, // InterruptObject
  						    RegIsaIntIsr,				   // ServiceRoutine
  						    DeviceObject,				   // ServiceContext
 						    NULL,					   // SpinLock
						    MappedVector,				   // Vector
  						    Irql,					   // Irql
						    Irql,					   // SynchronizeIrql
						    LevelSensitive,				   // InterruptMode
  						    TRUE,					   // ShareVector
						    DeviceExtension->Affinity,	   // ProcessorEnableMask
						    FALSE);		
	}
  	if (!NT_SUCCESS (status)) 
		DebugPrint("RegIsaInt.sys: IoConnectInterrupt Failed\n");
	else
		DebugPrint("RegIsaInt.sys: success to register interrupt\n");
	
	return status;

}

//卸载例程
VOID RegIsaIntUnload(IN PDRIVER_OBJECT DriverObject)
{
	WCHAR DOSNameBuffer[] = L"\\DosDevices\\RegIsaInt";
	UNICODE_STRING uniDOSString;

    PLOCAL_DEVICE_INFO deviceExt= DriverObject->DeviceObject->DeviceExtension;
	/*断开已经连接的中断*/
	if(deviceExt->m_ConnectInt==1)
	  UnRegisterInt(deviceExt);
	/* Delete Symbolic Link */
	RtlInitUnicodeString(&uniDOSString, DOSNameBuffer);
	IoDeleteSymbolicLink (&uniDOSString);
      /* Delete Device */
	IoDeleteDevice(DriverObject->DeviceObject);
	/*关闭DebugPrint调试软件的句柄*/
	DebugPrintClose();
}


//驱动程序的入口
NTSTATUS DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
{
	PDEVICE_OBJECT		DeviceObject;
	NTSTATUS			status;
   	PLOCAL_DEVICE_INFO	DeviceExtension;
   	
	ULONG				i;
 
	LONG				EventState;
	WCHAR				NameBuffer[] = L"\\Device\\RegIsaInt";
	WCHAR				DOSNameBuffer[] = L"\\DosDevices\\RegIsaInt";
	UNICODE_STRING		uniNameString, uniDOSString,uniEventName;

//打开DebugPrint软件的句柄
#if DBG 
	DebugPrintInit("Wdm1 checked");
#else
	DebugPrintInit("Wdm1 free");
#endif

	RtlInitUnicodeString(&uniNameString, NameBuffer);
	RtlInitUnicodeString(&uniDOSString, DOSNameBuffer);
	
	//由驱动对象生成一个设备对象
	status = IoCreateDevice(DriverObject,			// DriverObject
					sizeof(LOCAL_DEVICE_INFO),	// DeviceExtensionSize
					&uniNameString,			// DeviceName
					FILE_DEVICE_UNKNOWN,		// DeviceType
					0,					// DeviceCharacteristics
					TRUE,					// Exclusive
					&DeviceObject);			// *DeviceObject

	if(!NT_SUCCESS(status)) return status;
	
	DeviceExtension = DeviceObject->DeviceExtension;
	/*创建一个符号链接*/
	status = IoCreateSymbolicLink (&uniDOSString, &uniNameString);
	/*初始化异步过程调用*/
	IoInitializeDpcRequest(DeviceObject,RegIsaIntDpcRoutine);
	if (!NT_SUCCESS(status)) return status;

    DriverObject->MajorFunction[IRP_MJ_CREATE]         = 
  	DriverObject->MajorFunction[IRP_MJ_CLOSE]          =
	DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =RegIsaIntCreateDispatch;
	DriverObject->DriverUnload = RegIsaIntUnload;
	
	DeviceExtension->m_ConnectInt=0;
	DeviceExtension->m_IntPara.m_TrigManner=1;
	DeviceExtension->m_IntPara.m_IrqNum=2;
	DebugPrint("RegIsaInt.sys: Driver Entry!\n");
	return STATUS_SUCCESS;
}