xxgdrvdevice.cpp

中科院许西刚博士编写的USB的ＷＤＭ驱动程序。

	PUCHAR pBuffer = (PUCHAR) I.BufferedReadDest();

    ULONG dwTotalSize = I.ReadSize(CURRENT);
	ULONG dwMaxSize = m_Endpoint1IN.MaximumTransferSize();	
	if (dwTotalSize > dwMaxSize)
	{
		ASSERT(dwMaxSize);
		dwTotalSize = dwMaxSize;
	}
// TODO:	Handle the the XXGDRV_IOCTL_READ_DATA request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.
	PURB pUrb = m_Endpoint1IN.BuildBulkTransfer(
			    	pBuffer,      	// Where is data coming from?
					dwTotalSize,  	// How much data to read?
					TRUE,         	// direction (TRUE = IN)
					NULL,			// Link to next URB
					TRUE			// Allow a short transfer
					);        	
	status = m_Endpoint1IN.SubmitUrb(pUrb, NULL, NULL, 1500L);
	
	ulReturned = pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength;
	//delete pUrb;
// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
	//I.Information() = 0;
	I.Information() =ulReturned;
	I.Status() = status;
	return status;
}

////////////////////////////////////////////////////////////////////////
//  XXGDrvDevice::XXGDRV_IOCTL_WRITE_DATA_Handler
//
//	Routine Description:
//		Handler for IO Control Code XXGDRV_IOCTL_WRITE_DATA
//
//	Parameters:
//		I - IRP containing IOCTL request
//
//	Return Value:
//		NTSTATUS - Status code indicating success or failure
//
//	Comments:
//		This routine implements the XXGDRV_IOCTL_WRITE_DATA function.
//		This routine runs at passive level.
//

NTSTATUS XXGDrvDevice::XXGDRV_IOCTL_WRITE_DATA_Handler(KIrp I)
{
	ULONG ulReturned = 0;
	NTSTATUS status = STATUS_SUCCESS;

	//t << "Entering XXGDrvDevice::XXGDRV_IOCTL_WRITE_DATA_Handler, " << I << EOL;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER
	// Always ok to write 0 elements.
	/*
	if (I.WriteSize() == 0)
	{
		I.Information() = 0;
		return I.PnpComplete(this, STATUS_SUCCESS);
	}
	ULONG dwTotalSize = I.WriteSize(CURRENT);
	ULONG dwMaxSize = m_Endpoint1OUT.MaximumTransferSize();
	if (dwTotalSize > dwMaxSize)
	{
		ASSERT(dwMaxSize);
		dwTotalSize = dwMaxSize;
	}

	PUCHAR pBuffer = (PUCHAR)I.IoctlBuffer();
*/
	//KMemory Mem(pBuffer, dwTotalSize);
	//Mem.SetPageArray();


// TODO:	Handle the the XXGDRV_IOCTL_WRITE_DATA request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.
		PURB pUrb = m_Endpoint1OUT.BuildBulkTransfer(
					(unsigned char*)I.IoctlBuffer(),          // Where is data coming from?
					I.IoctlInputBufferSize(),  // How much data to read?
					FALSE,        // direction (FALSE = OUT)
					NULL		  // Link to next URB
					);	  
		if (pUrb == NULL)
		{
			//delete pCompInfo;
			I.Information() = 0;
			return I.PnpComplete(this, STATUS_INSUFFICIENT_RESOURCES);
		}

		status = m_Endpoint1OUT.SubmitUrb(pUrb, NULL, NULL, 1500L);
		ulReturned = pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength;
		//delete pUrb;

// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
		I.Information() =ulReturned;
		I.Status() = status;
		//I.Information() = 0;

	return status;
}

////////////////////////////////////////////////////////////////////////
//  XXGDrvDevice::XXGDRV_IOCTL_SET_CMD_Handler
//
//	Routine Description:
//		Handler for IO Control Code XXGDRV_IOCTL_SET_CMD
//
//	Parameters:
//		I - IRP containing IOCTL request
//
//	Return Value:
//		NTSTATUS - Status code indicating success or failure
//
//	Comments:
//		This routine implements the XXGDRV_IOCTL_SET_CMD function.
//		This routine runs at passive level.
//

NTSTATUS XXGDrvDevice::XXGDRV_IOCTL_SET_CMD_Handler(KIrp I)
{
	NTSTATUS status = STATUS_SUCCESS;
	ULONG ulReturned = 0;

//	t << "Entering XXGDrvDevice::XXGDRV_IOCTL_SET_CMD_Handler, " << I << EOL;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER


// TODO:	Handle the the XXGDRV_IOCTL_SET_CMD request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.
	PURB pUrb = m_Lower.BuildVendorRequest(
			(unsigned char*)I.IoctlBuffer(),						// transfer buffer
			I.IoctlInputBufferSize(),		// transfer buffer size
			0,								// request reserved bits
			(BYTE)CMD_SET_CMD,				// request
			0,								// Value
			FALSE,							// bIn
			TRUE,							// bShortOk
			NULL,							// Link
			0								// Index
			);

		// transmit
		status = m_Lower.SubmitUrb(pUrb, NULL, NULL, 1500L);
		if(NT_SUCCESS(status)) 
		{
			ulReturned = pUrb->UrbControlVendorClassRequest.TransferBufferLength;
	    }
		//delete pUrb;

// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
	I.Information() = ulReturned;
	I.Status() = status;
	//I.Information() = 0;

	return status;
}

////////////////////////////////////////////////////////////////////////
//  XXGDrvDevice::XXGDRV_IOCTL_GET_CMD_Handler
//
//	Routine Description:
//		Handler for IO Control Code XXGDRV_IOCTL_GET_CMD
//
//	Parameters:
//		I - IRP containing IOCTL request
//
//	Return Value:
//		NTSTATUS - Status code indicating success or failure
//
//	Comments:
//		This routine implements the XXGDRV_IOCTL_GET_CMD function.
//		This routine runs at passive level.
//

NTSTATUS XXGDrvDevice::XXGDRV_IOCTL_GET_CMD_Handler(KIrp I)
{
	NTSTATUS status = STATUS_SUCCESS;
	ULONG ulReturned = 0;

	//t << "Entering XXGDrvDevice::XXGDRV_IOCTL_GET_CMD_Handler, " << I << EOL;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER
	if (I.ReadSize() == 0)
	{
		I.Information() = 0;
		return I.PnpComplete(this, STATUS_SUCCESS);
	}

	PUCHAR pBuffer = (PUCHAR) I.BufferedReadDest();

    ULONG dwTotalSize = I.ReadSize(CURRENT);
	ULONG dwMaxSize = m_Endpoint4IN.MaximumTransferSize();	
	if (dwTotalSize > dwMaxSize)
	{
		ASSERT(dwMaxSize);
		dwTotalSize = dwMaxSize;
	}
// TODO:	Handle the the XXGDRV_IOCTL_GET_CMD request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.
	/*
	PURB pUrb = m_Endpoint4IN.BuildBulkTransfer(
			    	pBuffer,      	// Where is data coming from?
					dwTotalSize,  	// How much data to read?
					TRUE,         	// direction (TRUE = IN)
					NULL,			// Link to next URB
					TRUE			// Allow a short transfer
					);      
	*/
	PURB pUrb = m_Endpoint4IN.BuildInterruptTransfer(
			    	pBuffer,      	// Where is data coming from?
					dwTotalSize,  	// How much data to read?
					TRUE,         	// direction (TRUE = IN)
					NULL,			// Link to next URB
					NULL			// Allow a short transfer
					);      
	status = m_Endpoint4IN.SubmitUrb(pUrb, NULL, NULL, 1500L);

	ulReturned = pUrb->UrbBulkOrInterruptTransfer.TransferBufferLength;
	//delete pUrb;
// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
	I.Information() =ulReturned;
	I.Status() = status;

	return status;
}

////////////////////////////////////////////////////////////////////////
//  XXGDrvDevice::XXGDRV_IOCTL_CONTROL_Handler
//
//	Routine Description:
//		Handler for IO Control Code XXGDRV_IOCTL_CONTROL
//
//	Parameters:
//		I - IRP containing IOCTL request
//
//	Return Value:
//		NTSTATUS - Status code indicating success or failure
//
//	Comments:
//		This routine implements the XXGDRV_IOCTL_CONTROL function.
//		This routine runs at passive level.
//

NTSTATUS XXGDrvDevice::XXGDRV_IOCTL_CONTROL_Handler(KIrp I)
{
	NTSTATUS status = STATUS_SUCCESS;
	ULONG ulReturned = 0;

	//t << "Entering XXGDrvDevice::XXGDRV_IOCTL_CONTROL_Handler, " << I << EOL;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER

// TODO:	Handle the the XXGDRV_IOCTL_CONTROL request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.
	PURB pUrb = m_Lower.BuildVendorRequest(
			(unsigned char*)I.IoctlBuffer(),						// transfer buffer
			I.IoctlInputBufferSize(),		// transfer buffer size
			0,								// request reserved bits
			(BYTE)CMD_READ_DATA,			// request
			0,								// Value
			FALSE,							// bIn
			TRUE,							// bShortOk
			NULL,							// Link
			0								// Index
			);

		// transmit
		status = m_Lower.SubmitUrb(pUrb, NULL, NULL, 1500L);
		if(NT_SUCCESS(status)) 
		{
			ulReturned = pUrb->UrbControlVendorClassRequest.TransferBufferLength;
	    }
		//delete pUrb;
// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
		I.Information() = ulReturned;
		I.Status() = status;
		//I.Information() = 0;

	return status;
}

////////////////////////////////////////////////////////////////////////
//  XXGDrvDevice::XXGDRV_IOCTL_ENABLE_ISO_MODE_Handler
//
//	Routine Description:
//		Handler for IO Control Code XXGDRV_IOCTL_ENABLE_ISO_MODE
//
//	Parameters:
//		I - IRP containing IOCTL request
//
//	Return Value:
//		NTSTATUS - Status code indicating success or failure
//
//	Comments:
//		This routine implements the XXGDRV_IOCTL_ENABLE_ISO_MODE function.
//		This routine runs at passive level.
//

NTSTATUS XXGDrvDevice::XXGDRV_IOCTL_ENABLE_ISO_MODE_Handler(KIrp I)
{
	NTSTATUS status = STATUS_SUCCESS;

	//t << "Entering XXGDrvDevice::XXGDRV_IOCTL_ENABLE_ISO_MODE_Handler, " << I << EOL;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER

// TODO:	Handle the the XXGDRV_IOCTL_ENABLE_ISO_MODE request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.

// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
	I.Information() = 0;

	return status;
}

////////////////////////////////////////////////////////////////////////
//  XXGDrvDevice::XXGDRV_IOCTL_READ_WRITE_REGISTER_Handler
//
//	Routine Description:
//		Handler for IO Control Code XXGDRV_IOCTL_READ_WRITE_REGISTER
//
//	Parameters:
//		I - IRP containing IOCTL request
//
//	Return Value:
//		NTSTATUS - Status code indicating success or failure
//
//	Comments:
//		This routine implements the XXGDRV_IOCTL_READ_WRITE_REGISTER function.
//		This routine runs at passive level.
//

NTSTATUS XXGDrvDevice::XXGDRV_IOCTL_READ_WRITE_REGISTER_Handler(KIrp I)
{
	NTSTATUS status = STATUS_SUCCESS;
	ULONG ulReturned = 0;

	//t << "Entering XXGDrvDevice::XXGDRV_IOCTL_READ_WRITE_REGISTER_Handler, " << I << EOL;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER

// TODO:	Handle the the XXGDRV_IOCTL_READ_WRITE_REGISTER request, or 
//			defer the processing of the IRP (i.e. by queuing) and set
//			status to STATUS_PENDING.
	PURB pUrb = m_Lower.BuildVendorRequest(
			(unsigned char*)I.IoctlBuffer(),						// transfer buffer
			I.IoctlInputBufferSize(),		// transfer buffer size
			0,								// request reserved bits
			(BYTE)CMD_READ_WRITE_REGISTER,	// request
			0,								// Value
			FALSE,							// bIn
			TRUE,							// bShortOk
			NULL,							// Link
			0x71							// Index
			);

		// transmit
		status = m_Lower.SubmitUrb(pUrb, NULL, NULL, 1500L);
		if(NT_SUCCESS(status)) 
		{
			ulReturned = pUrb->UrbControlVendorClassRequest.TransferBufferLength;
	    }
		//delete pUrb;
// TODO:	Assuming that the request was handled here. Set I.Information
//			to indicate how much data to copy back to the user.
		I.Information() = ulReturned;
		I.Status() = status;
		//I.Information() = 0;

	return status;
}

//////////////////////////////////////////////////////////////////////////
NTSTATUS XXGDrvDevice::OnQueryCapabilities(KIrp I)
{
	//t << "Entering XXGDrvDevice::OnQueryCapabilities\n";

	I.CopyParametersDown();
	I.SetCompletionRoutine(LinkTo(OnQueryCapabilitiesComplete), this, TRUE, TRUE, TRUE);

	return m_Lower.PnpCall(this, I);
}

NTSTATUS XXGDrvDevice::OnQueryCapabilitiesComplete(KIrp I)
{
	if (I->PendingReturned)
		I.MarkPending();

	if(!m_bSurpriseRemove)
	{
		I.DeviceCapabilities()->SurpriseRemovalOK	= TRUE;
		I.DeviceCapabilities()->Removable			= TRUE;
		I.DeviceCapabilities()->EjectSupported		= TRUE;
		//I.DeviceCapabilities()->WarmEjectSupported	= TRUE;
	}

	return STATUS_SUCCESS;
}