dispatch.cpp

一个通用的usb驱动程序列程

#include "WdmUsb.h"
#include "Ioctl.h"

//--------------------------Define----------------------------------

//--------------------------Routines---------------------------------

NTSTATUS WdmUsbCreate(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	NTSTATUS status=STATUS_SUCCESS;
	PWDMUSB_PIPE pipeHandle=NULL;
	PWDMUSB_DEVICE_EXTENSION dx=(PWDMUSB_DEVICE_EXTENSION)fdo->DeviceExtension;
	PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
	KdPrint(("Create file is %s",IrpStack->FileObject->FileName));
	if(dx->IODisabled)
		return CompleteIrp(Irp,STATUS_DEVICE_NOT_CONNECTED,0);
	InterlockedIncrement(&dx->OpenHandleCount);
	PFILE_OBJECT fileObject=IrpStack->FileObject;
	fileObject->FsContext=NULL;
#if DBG
	if(fileObject->FileName.Length==0)
		 DbgPrint("Create file Open Device");  
#endif
	if(fileObject->FileName.Length!=0)
	{
		status=STATUS_INSUFFICIENT_RESOURCES;
		for(ULONG i=0;i<WDMUSB_MAX_PIPES;i++)
		{
			if(RtlCompareMemory(fileObject->FileName.Buffer,
				             dx->PipeList[i].Name,
							 fileObject->FileName.Length)==
							 fileObject->FileName.Length&&
							 !dx->PipeList[i].Opened)
			{
				pipeHandle=(PWDMUSB_PIPE)&dx->PipeList[i];
				break;  
			}
		} 
		if(pipeHandle==NULL)status=STATUS_INVALID_PARAMETER;	
	}	
	if(pipeHandle)
	{
		KdPrint(("WdmUsbCreate: opening pipe %x",pipeHandle));
		fileObject->FsContext=pipeHandle;
		pipeHandle->Opened=TRUE;
        pipeHandle->bPerfTimerEnabled=FALSE;
		status=STATUS_SUCCESS;
	}
	KdPrint(("WdmUsbCreate: exit create %x",status));
	KdPrint(("WdmUsbCreate: OpenHandleCount %x",dx->OpenHandleCount));
	return CompleteIrp(Irp,status,0);
}
NTSTATUS WdmUsbClose(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	PWDMUSB_PIPE pipeHandle=NULL;
	PWDMUSB_DEVICE_EXTENSION dx=(PWDMUSB_DEVICE_EXTENSION)fdo->DeviceExtension;
	KdPrint(("WdmUsbClose"));
	InterlockedDecrement(&dx->OpenHandleCount);
	PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
	PFILE_OBJECT fileObject=IrpStack->FileObject;
	if(fileObject->FsContext)
	{
		pipeHandle=(PWDMUSB_PIPE)fileObject->FsContext;
		KdPrint(("WdmUsbCreate: closing pipe %x",pipeHandle));
        pipeHandle->Opened=FALSE;
	}
	KdPrint(("WdmUsbClose: exit close"));
	KdPrint(("WdmUsbClose: OpenHandleCount %x",dx->OpenHandleCount));
	return CompleteIrp(Irp,STATUS_SUCCESS,0);
}

NTSTATUS WdmUsbWrite(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	return UsbReadWrite(fdo,Irp,FALSE);
}
NTSTATUS WdmUsbRead(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	return UsbReadWrite(fdo,Irp,TRUE);
}
NTSTATUS WdmUsbDeviceIoControl(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	NTSTATUS status=STATUS_SUCCESS;
	PWDMUSB_DEVICE_EXTENSION dx=(PWDMUSB_DEVICE_EXTENSION)fdo->DeviceExtension;
	if(dx->IODisabled)
		return CompleteIrp(Irp,STATUS_DEVICE_NOT_CONNECTED,0);
	if(!LockDevice(dx))
		return CompleteIrp(Irp,STATUS_DELETE_PENDING,0);
	status=PowerUpDevice(fdo);
	if(!NT_SUCCESS(status))
		return CompleteIrp(Irp,status,0);
	PIO_STACK_LOCATION IrpStack=IoGetCurrentIrpStackLocation(Irp);
	ULONG BytesTxd=0;

	ULONG ControlCode=IrpStack->Parameters.DeviceIoControl.IoControlCode;
	ULONG InputLength=IrpStack->Parameters.DeviceIoControl.InputBufferLength;
	ULONG OutputLength=IrpStack->Parameters.DeviceIoControl.OutputBufferLength;

	KdPrint(("DeviceIoControl: Control code %x InputLength %d OutputLength %d",
				ControlCode, InputLength, OutputLength));
	switch(ControlCode)
	{
	case IOCTL_WDMUSB_GET_CONFIG_DESCRIPTOR:
		{
			PUSB_CONFIGURATION_DESCRIPTOR Descriptors=NULL;
			ULONG size;
			status=UsbGetConfigurationDescriptors(dx,Descriptors,0,size);
			if(NT_SUCCESS(status))
			{
				BytesTxd=size;
				if(BytesTxd>OutputLength)BytesTxd=OutputLength;
				RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,Descriptors,BytesTxd);
			}
			FreeIfAllocated(Descriptors);
			KdPrint(("IOCTL_WDMUSB_GET_CONFIG_DESCRIPTOR: status %x",status));
		}
		break;
    case IOCTL_WDMUSB_RESET_DEVICE:
		{			
		  	status=UsbResetDevice(dx);
            KdPrint(("IOCTL_WDMUSB_RESET_DEVICE: status %x",status));
		}
		break;
    case IOCTL_WDMUSB_RESET_PIPE:
		{
			PFILE_OBJECT fileObject=IrpStack->FileObject;
			PWDMUSB_PIPE pipe=(PWDMUSB_PIPE)fileObject->FsContext;
			if(pipe==NULL)
				status=STATUS_INVALID_PARAMETER;
			else 
				status=UsbResetPipe(dx,pipe);
			KdPrint(("IOCTL_WDMUSB_RESET_PIPE: status %x",status));
		}
		break;
	case IOCTL_WDMUSB_GET_DEVICE_DESCRIPTOR:
		{
			PUSB_DEVICE_DESCRIPTOR deviceDescriptor=NULL;
			ULONG size;
			status=UsbGetDeviceDescriptor(dx,deviceDescriptor,size);
			if(NT_SUCCESS(status))
			{
				BytesTxd=size;
				if(BytesTxd>OutputLength)BytesTxd=OutputLength;
				RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer,deviceDescriptor,BytesTxd);
			}
			FreeIfAllocated(deviceDescriptor);
			KdPrint(("IOCTL_WDMUSB_GET_DEVICE_DESCRIPTOR: status %x",status));
		}
		break;
    case IOCTL_WDMUSB_READ_REGISTERS:
		{
			ULONG size;
			KdPrint(("IOCTL_WDMUSB_READ_REGISTERS:starting"));
			status=UsbReadWriteRegister(dx,Irp,FALSE,size);
			if(NT_SUCCESS(status))
			{
				BytesTxd=size;
			}
            KdPrint(("IOCTL_WDMUSB_READ_REGISTERS:status %x",status));
		}
		break;
    case IOCTL_WDMUSB_WRITE_REGISTERS:
		{
			ULONG size;
			KdPrint(("IOCTL_WDMUSB_WRITE_REGISTERS:starting"));
			status=UsbReadWriteRegister(dx,Irp,TRUE,size);
			if(NT_SUCCESS(status))
			{
				BytesTxd=size;
			}
            KdPrint(("IOCTL_WDMUSB_WRITE_REGISTERS:status %x",status));
		}
		break;
	default:
		status=STATUS_INVALID_DEVICE_REQUEST;
	}    
	KdPrint(("DeviceIoControl: %d bytes written",(int)BytesTxd));
	CompleteIrp(Irp,status,BytesTxd);
	UnlockDevice(dx);
    return status;
}
NTSTATUS WdmUsbSystemIoControl(IN PDEVICE_OBJECT fdo,IN PIRP Irp)
{
	PWDMUSB_DEVICE_EXTENSION dx=(PWDMUSB_DEVICE_EXTENSION)fdo->DeviceExtension;
	if(dx->IODisabled)
		return CompleteIrp(Irp,STATUS_DEVICE_NOT_CONNECTED,0);
	if(!LockDevice(dx))
		return CompleteIrp(Irp,STATUS_DELETE_PENDING,0);
	KdPrint(("WdmUsbSystemIoControl"));
	IoSkipCurrentIrpStackLocation(Irp);
	NTSTATUS status=IoCallDriver(dx->NextStackDevice,Irp);
	UnlockDevice(dx);
	return status;
}
NTSTATUS CompleteIrp(IN PIRP Irp,IN NTSTATUS status,IN ULONG info)
{
	Irp->IoStatus.Status=status;
	Irp->IoStatus.Information=info;
	IoCompleteRequest(Irp,IO_NO_INCREMENT);
	return status;
}
//----------------------------Routines End--------------------------
NTSTATUS PowerUpDevice(IN PDEVICE_OBJECT fdo)
{
	PWDMUSB_DEVICE_EXTENSION dx=(PWDMUSB_DEVICE_EXTENSION)fdo->DeviceExtension;
	if(dx->PowerState>PowerDeviceD0)
	{
		NTSTATUS status=SendDeviceSetPower(dx,PowerDeviceD0);
		if(!NT_SUCCESS(status))
			return status;
	}
	if(dx->PowerIdleCounter)
		PoSetDeviceBusy(dx->PowerIdleCounter);
    return STATUS_SUCCESS;
}