usbwirelessdevice.cpp

该程序实现了d12芯片和计算机的驱动连接

// USBWirelessDevice.cpp
// Implementation of USBWirelessDevice device class
//
// Generated by DriverWizard version DriverStudio 3.1.0 (Build 1722)
// Requires Compuware's DriverWorks classes
//

#pragma warning(disable:4065) // Allow switch statement with no cases
		  
#include <vdw.h>
#include <kusb.h>
#include "..\USBWirelessDeviceinterface.h"

#include "USBWireless.h"
#include "USBWirelessDevice.h"
#include "..\USBWirelessioctl.h"

#pragma hdrstop("USBWireless.pch")

extern KTrace t;	// Global driver trace object	

GUID USBWirelessDevice_Guid = USBWirelessDevice_CLASS_GUID;
////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::USBWirelessDevice
//
//	Routine Description:
//		This is the constructor for the Functional Device Object, or FDO.
//		It is derived from KPnpDevice, which builds in automatic
//	    dispatching of subfunctions of IRP_MJ_POWER and IRP_MJ_PNP to
//		virtual member functions.
//
//	Parameters:
//		Pdo - Physical Device Object - this is a pointer to a system
//			device object that represents the physical device.
//
//		Unit - Unit number. This is a number to append to the device's
//			base device name to form the Logical Device Object's name
//
//	Return Value:
//		None   
//
//	Comments:
//		The object being constructed contains a data member (m_Lower) of type
//		KPnpLowerDevice. By initializing it, the driver binds the FDO to the
//		PDO and creates an interface to the upper edge of the system class driver.
//
USBWirelessDevice::USBWirelessDevice(PDEVICE_OBJECT Pdo, ULONG Unit) :
	KPnpDevice(Pdo, &USBWirelessDevice_Guid)
{
	t << "现在进入WirelessDevice::USBWirelessDevice (constructor)\n";


	// Check constructor status
    if ( ! NT_SUCCESS(m_ConstructorStatus) )
	{
	    return;
	}

	// Remember our unit number
	m_Unit = Unit;

	// Initialize the lower device
	m_Lower.Initialize(this, Pdo);

	// Initialize the interface object.  The wizard generates code 
	// to support a single interface.  You may create and add additional 
	// interfaces.  By default, the wizard uses InterfaceNumber 0 (the 
	// first interface descriptor), ConfigurationValue 1 (the first
	// configuration descriptor), and initial interface alternate
	// setting of 0.  If your device has multiple interfaces or alternate
	// settings for an interface, you can add additional KUsbInterface
	// objects or adjust the parameters passed to this function.
	m_Interface.Initialize(
					m_Lower, //KUsbLowerDevice
					0,		 //InterfaceNumber
					1,		 //ConfigurationValue 
					0		 //Initial Interface Alternate Setting
					); 

	// Initialize each Pipe object
	m_Endpoint1IN.Initialize(m_Lower, 0x81, 16); 
	m_Endpoint1OUT.Initialize(m_Lower, 0x1, 16); 

    // Inform the base class of the lower edge device object
	SetLowerDevice(&m_Lower);

	// Initialize the PnP Policy settings to the "standard" policy
	SetPnpPolicy();

// TODO:	Customize the PnP Policy for this device by setting
//			flags in m_Policies.
//			flags in m_Policies.
	m_pItem.Initialize(Pdo);	//初试化工作项
}


////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::~USBWirelessDevice
//
//	Routine Description:
//		This is the destructor for the Functional Device Object, or FDO.
//
//	Parameters:
//		None
//
//	Return Value:
//		None
//
//	Comments:
//		None
//

USBWirelessDevice::~USBWirelessDevice()
{
	t << "进入 USBWirelessDevice::~USBWirelessDevice() (destructor)\n";
}


////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::DefaultPnp
//
//	Routine Description:
//		Default handler for IRP_MJ_PNP
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result returned from lower device
//
//	Comments:
//		This routine just passes the IRP through to the lower device. It is 
//		the default handler for IRP_MJ_PNP. IRPs that correspond to
//		any virtual members of KpnpDevice that handle minor functions of
//		IRP_MJ_PNP and that are not overridden get passed to this routine.
//

NTSTATUS USBWirelessDevice::DefaultPnp(KIrp I) 
{
	t << "Entering USBWirelessDevice::DefaultPnp\n" << I << EOL;

	I.ForceReuseOfCurrentStackLocationInCalldown();
	return m_Lower.PnpCall(this, I);
}

////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::DefaultPower
//
//	Routine Description:
//		Default handler for IRP_MJ_POWER 
//  
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result returned from lower device
//
//	Comments:
//		This routine just passes the IRP through to the lower device. It is 
//		the default handler for IRP_MJ_POWER.
//

NTSTATUS USBWirelessDevice::DefaultPower(KIrp I) 
{
	t << "Entering USBWirelessDevice::DefaultPower\n" << I << EOL;

	I.IndicatePowerIrpProcessed();
	I.CopyParametersDown();
	return m_Lower.PnpPowerCall(this, I);
}

////////////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::SystemControl
//
//	Routine Description:
//		Default handler for IRP_MJ_SYSTEM_CONTROL
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result returned from lower device
//
//	Comments:
//		This routine just passes the IRP through to the next device since this driver
//		is not a WMI provider.
//

NTSTATUS USBWirelessDevice::SystemControl(KIrp I) 
{
	t << "Entering USBWirelessDevice::SystemControl\n";

	I.ForceReuseOfCurrentStackLocationInCalldown();
	return m_Lower.PnpCall(this, I);
}

////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::OnStartDevice
//
//	Routine Description:
//		Handler for IRP_MJ_PNP subfcn IRP_MN_START_DEVICE
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//		Typically, the driver sends a SET CONFIGURATION request for the
//		USB device by using KUsbLowerDevice::ActivateConfiguration with
//		the ConfigurationValue to activate.  The wizard generates code to 
//		support a single configuration.  You may create and add additional 
//		configurations. 
//

NTSTATUS USBWirelessDevice::OnStartDevice(KIrp I)
{
	t << "现在进入WirelessDevice::OnStartDevice\n";

	NTSTATUS status = STATUS_UNSUCCESSFUL;

	AC_STATUS acStatus = AC_SUCCESS;

	I.Information() = 0;

	// The default Pnp policy has already cleared the IRP with the lower device

	//By default, the wizard passes a ConfigurationValue of 1 to 
	//ActivateConfiguration().  This corresponds to the first configuration 
	//that the device reports in its configuration descriptor.  If the device 
	//supports multiple configurations, pass the appropriate
	//ConfigurationValue of the configuration to activate here.
	t << "现在将要配置usb\n";
	acStatus = m_Lower.ActivateConfiguration(
		1	// ConfigurationValue 1 (the first configuration)
		);
	t << "配置usb完毕\n";

	switch (acStatus)
	{
		case AC_SUCCESS:
			t << "USB Configuration OK\n";
			status = STATUS_SUCCESS;
			break;

		case AC_COULD_NOT_LOCATE_INTERFACE:
			t << "Could not locate interface\n";
			break;

		case AC_COULD_NOT_PRECONFIGURE_INTERFACE:
			t << "Could not get configuration descriptor\n";
			break;

		case AC_CONFIGURATION_REQUEST_FAILED:
			t << "Board did not accept configuration URB\n";
			break;

		case AC_FAILED_TO_INITIALIZE_INTERFACE_OBJECT:
			t << "Failed to initialize interface object\n";
			break;

		case AC_FAILED_TO_GET_DESCRIPTOR:
			t << "Failed to get device descriptor\n";
			break;

		case AC_FAILED_TO_OPEN_PIPE_OBJECT:
			//NOTE: this may not be an error.  It could mean that
			//the device has an endpoint for which a KUsbPipe object has
			//not been instanced.  If the intention is to not use this endpoint,
			//then it's likely not a problem.  
			status = STATUS_SUCCESS;
			t << "配置的返回值是Failed to open pipe object\n";
			break;

		default:
			t << "Unexpected error activating USB configuration\n";
			break;
	}
	//////////新添的内容///////////////////
	if ((acStatus == AC_SUCCESS) || (acStatus == AC_FAILED_TO_OPEN_PIPE_OBJECT))
	{
		status = STATUS_SUCCESS;

		GetStringDescriptors();	//调用获取设备描述符例程

		m_kIrp = KIrp::Allocate( m_Lower.StackRequirement() );	//创建IRP
	
		if ( m_kIrp == NULL )
		{
			m_Lower.DeActivateConfiguration();
			m_Lower.ReleaseResources();
			status = STATUS_INSUFFICIENT_RESOURCES;
		}
		else
		{
			// allocate and initialize an URB
			m_pUrbIN = m_Endpoint1IN.BuildInterruptTransfer(
						m_bufferIN,			// transfer buffer
						16,					// transfer buffer size
						TRUE,				// Short Ok
						NULL,				// link urb
						NULL				// new urb
						);	//创建新的中断传输URB

		/*	if ( m_pUrbIN == NULL )
			{
				KIrp::Deallocate(m_kIrp);
				m_Lower.DeActivateConfiguration();
				m_Lower.ReleaseResources();
				status = STATUS_INSUFFICIENT_RESOURCES;
			}*/


			m_pUrbOUT = m_Endpoint1OUT.BuildInterruptTransfer(
						m_bufferOUT,			// transfer buffer
						16,					// transfer buffer size
						TRUE,				// Short Ok
						NULL,				// link urb
						NULL				// new urb
						);	//创建新的中断传输URB

			if (( m_pUrbOUT == NULL ) || ( m_pUrbIN == NULL ))
			{
				KIrp::Deallocate(m_kIrp);
				m_Lower.DeActivateConfiguration();
				m_Lower.ReleaseResources();
				status = STATUS_INSUFFICIENT_RESOURCES;
			}
		t << "在WirelessDevice::OnStartDevice函数中创建了两个urb,正常执行完毕\n";

		}
	}
	////////////////////////////////////////
   return status;  // base class completes the IRP
}


////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::OnStopDevice
//
//	Routine Description:
//		Handler for IRP_MJ_PNP subfcn IRP_MN_STOP_DEVICE
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//		The system calls this when the device is stopped.
//		The driver should release any hardware resources
//		in this routine.
//
//		The base class passes the irp to the lower device.
//

NTSTATUS USBWirelessDevice::OnStopDevice(KIrp I)
{
	NTSTATUS status = STATUS_SUCCESS;

	t << "现在进入WirelessDevice::OnStopDevice\n";

	m_Lower.DeActivateConfiguration();
	t << "停止配置后，现在跳出WirelessDevice::OnStopDevice\n";

// TODO:	Add device-specific code to stop your device   

	return status;
	
	// The following macro simply allows compilation at Warning Level 4
	// If you reference this parameter in the function simply remove the macro.
	//手工去掉RENCED_PARAMETER(I);
}

////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::OnRemoveDevice
//
//	Routine Description:
//		Handler for IRP_MJ_PNP subfcn IRP_MN_REMOVE_DEVICE
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//		The system calls this when the device is removed.
//		Our PnP policy will take care of 
//			(1) giving the IRP to the lower device
//			(2) detaching the PDO
//			(3) deleting the device object
//

NTSTATUS USBWirelessDevice::OnRemoveDevice(KIrp I)
{
	t << "现在进入USBWirelessDevice::OnRemoveDevice\n";
      //删除IRP和URB
	if ( m_kIrp != NULL )	KIrp::Deallocate(m_kIrp);
	if ( m_pUrbIN	!= NULL )	delete m_pUrbIN;
	if ( m_pUrbOUT	!= NULL )	delete m_pUrbOUT;
	// Device removed, release the system resources used by the USB lower device.
	m_Lower.ReleaseResources();


// TODO:	Add device-specific code to remove your device   
	t << "释放完自己申请的资源，现在跳出USBWirelessDevice::OnRemoveDevice\n";
	return STATUS_SUCCESS;

	// The following macro simply allows compilation at Warning Level 4
	// If you reference this parameter in the function simply remove the macro.
	///手工去掉UNREFERENCED_PARAMETER(I);
}

////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::Create
//
//	Routine Description:
//		Handler for IRP_MJ_CREATE
//
//	Parameters:
//		I - Current IRP
//
//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//

NTSTATUS USBWirelessDevice::Create(KIrp I)
{
	NTSTATUS status;

	t << "现在进入USBWirelessDevice::Create\n ";

// TODO: Add driver specific create handling code here

	// Generally a create IRP is targeted at our FDO, so we don't need
	// to pass it down to the PDO.  We have found for some devices, the
	// PDO is not expecting this Irp and returns an error code.
	// The default wizard code, therefore completes the Irp here using
	// PnpComplete().  The following commented code could be used instead
	// of PnpComplete() to pass the Irp to the PDO, which would complete it.
	//
//	I.ForceReuseOfCurrentStackLocationInCalldown();
//	status = m_Lower.PnpCall(this, I);

	status = I.PnpComplete(this, STATUS_SUCCESS, IO_NO_INCREMENT);

	t << "USBWirelessDevice::Create Status " << (ULONG)status << EOL;
		t << "现在跳出USBWirelessDevice::Create\n ";

	return status;
}

////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::Close
//
//	Routine Description:
//		Handler for IRP_MJ_CLOSE
//
//	Parameters:
//		I - Current IRP
//