usbwirelessdevice.cpp

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

//	Return Value:
//		NTSTATUS - Result code
//
//	Comments:
//

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

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

// TODO: Add driver specific close handling code here

	// Generally a close 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::Close Status " << (ULONG)status << EOL;

    return status;
}

////////////////////////////////////////////////////////////////////////
//  USBWirelessDevice::DeviceControl
//
//	Routine Description:
//		Handler for IRP_MJ_DEVICE_CONTROL
//
//	Parameters:
//		I - Current IRP
// 
//	Return Value:
//		None
//
//	Comments:
//		This routine is the first handler for Device Control requests.
//		The KPnpDevice class handles restricting IRP flow
//		if the device is stopping or being removed.
//

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

	t << "现在进入USBWirelessDevice::Device Control\n ";
	switch (I.IoctlCode())
	{
		case USBWIRELESS_IOCTL_800_1IN:
			status = USBWIRELESS_IOCTL_800_1IN_Handler(I);
			break;

		case USBWIRELESS_IOCTL_801_1OUT:
			status = USBWIRELESS_IOCTL_801_1OUT_Handler(I);
			break;

		default:
			// Unrecognized IOCTL request
			status = STATUS_INVALID_PARAMETER;
			break;
	}

	// If the IRP's IOCTL handler deferred processing using some driver
	// specific scheme, the status variable is set to STATUS_PENDING.
	// In this case we simply return that status, and the IRP will be
	// completed later.  Otherwise, complete the IRP using the status
	// returned by the IOCTL handler.
	if (status == STATUS_PENDING)
	{
		return status;
	}
	else
	{
		return I.PnpComplete(this, status);
	}
}

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

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

	t << "现在进入USBWirelessDevice::USBWIRELESS_IOCTL_800_1IN_Handler	1\n" ;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER

// TODO:	Handle the the RWB_IOCTL_800 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;

	t << "USBWIRELESS_IOCTL_800_1IN_Handler:将要获取应用程序传过来的数据\n" ;

	PUCHAR IrpBuffer = PUCHAR (I.IoctlBuffer());

    for(char i=0;i<16;i++) m_bufferOUT[i] = IrpBuffer[i];

	t << "USBWIRELESS_IOCTL_800_1IN_Handler:已经获取应用程序传过来的数据\n" ;

	//m_bufferOUT 里面的数据将会传送给单片机，所以应用程序传过来的数据应该赋给m_bufferOUT
	////////////////////////////////////////////////////
	//自己添加的

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


	if ( m_pUrbOUT == NULL )
	{
		return STATUS_INSUFFICIENT_RESOURCES;;
	}

	PVOID CI = InterlockedCompareExchangePointer( (PVOID*)&CurrentIrp(), PVOID( PIRP(I)), NULL);

	// Allow only one request at a time	
	if ( CI != NULL ) return STATUS_DEVICE_BUSY;

	CancelSpinLock::Acquire();
	if ( I.WasCanceled() )
	{
		CurrentIrp() = NULL;
		CancelSpinLock::Release();
		return STATUS_CANCELLED;
	}

	I.SetCancelRoutine( LinkTo(Cancel) );
	CancelSpinLock::Release();
	I.MarkPending();

	t << "Submit OUT URB\n";
	// submit the URB to USBD
	m_Endpoint1OUT.SubmitUrb(m_kIrp, m_pUrbOUT, LinkTo(USBWIRELESS_IOCTL_800_HandlerComplete), this);
	//将URB发送给系统USB总线驱动程序进行处理，并设置完成例程
	
//	m_Endpoint1OUT.SubmitUrb(m_pUrbOUT);
	////////////////////////////////////////////////////

	return STATUS_PENDING;
}

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

	t << "现在进入USBWIRELESS_IOCTL_800_HandlerComplete例程e\n";

	KIrp Current( CurrentIrp() );

	// If there is no current IRP, just release resources and return
	if ( !Current.IsNull() )
	{
		CancelSpinLock::Acquire();
		if ( Current.WasCanceled() )
		{
			CancelSpinLock::Release();
		}
		else
		{
			Current.SetCancelRoutine(NULL);
			CancelSpinLock::Release();
			CurrentIrp() = NULL;

			if ( I.Status() != STATUS_SUCCESS )
			{	//URB传输错误
				t << "URB传输错误\n";
				status = I.Status();
			}
			else
			{	//URB传输正确
				t << "800 URB传输正确\n";
				status = STATUS_SUCCESS;
				// find the buffer pointer in the URB
 				//PUCHAR buffer = (PUCHAR)m_pUrb->UrbBulkOrInterruptTransfer.TransferBuffer;
				//源数据

				// Dump the buffer		
				//PUCHAR IrpBuffer = PUCHAR(Current.IoctlBuffer());
				//目的数据
				//IrpBuffer[0] = buffer[0];	//拷贝数据
				Current.Information() = 16;
			}
			Current.PnpComplete(this, status);
		}
	}

		t << "现在跳出800 Complete例程\n";

	//DecrementOutstandingRequestCount();
	// return indicates that system is to quit processing IRP completion
	return STATUS_MORE_PROCESSING_REQUIRED;
	
}

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

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

	t << "现在进入USBWirelessDevice::USBWIRELESS_IOCTL_801_1OUT_Handler\n" ;
// TODO:	Verify that the input parameters are correct
//			If not, return STATUS_INVALID_PARAMETER

// TODO:	Handle the the USBWIRELESS_IOCTL_801_1OUT 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;

////////////////////////////////////////////////////
	//自己添加的

	m_pUrbIN = m_Endpoint1IN.BuildInterruptTransfer(
				m_bufferIN,						// transfer buffer
				16,								// transfer buffer size
				TRUE,							// Short Ok
				NULL,							// link urb
				m_pUrbIN//,							// urb
				//FALSE
				);	//创建中断传输URB，原来的m_pUrbOUT


	if ( m_pUrbIN == NULL )
	{
		return STATUS_INSUFFICIENT_RESOURCES;;
	}
	t << "现在m_pUrbIN被创建了\n" ;

	PVOID CI = InterlockedCompareExchangePointer( (PVOID*)&CurrentIrp(), PVOID( PIRP(I)), NULL);

	// Allow only one request at a time	
	if ( CI != NULL ) return STATUS_DEVICE_BUSY;

	CancelSpinLock::Acquire();
	if ( I.WasCanceled() )
	{
		CurrentIrp() = NULL;
		CancelSpinLock::Release();
		return STATUS_CANCELLED;
	}

	I.SetCancelRoutine( LinkTo(Cancel) );
	CancelSpinLock::Release();
	I.MarkPending();

	t << "Submit IN URB\n";
	// submit the URB to USBD
	m_Endpoint1IN.SubmitUrb(m_kIrp, m_pUrbIN, LinkTo(USBWIRELESS_IOCTL_801_HandlerComplete), this);
	//将URB发送给系统USB总线驱动程序进行处理，并设置完成例程
	
//	m_Endpoint1OUT.SubmitUrb(m_pUrbOUT);
	////////////////////////////////////////////////////
	t << "现在跳出USBWirelessDevice::USBWIRELESS_IOCTL_801_1OUT_Handler\n" ;

	return STATUS_PENDING;
}


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

	t << "进入 801 Completion例程\n";

	KIrp Current( CurrentIrp() );

	// If there is no current IRP, just release resources and return
	if ( !Current.IsNull() )
	{
		CancelSpinLock::Acquire();
		if ( Current.WasCanceled() )
		{
			CancelSpinLock::Release();
		}
		else
		{
			Current.SetCancelRoutine(NULL);
			CancelSpinLock::Release();
			CurrentIrp() = NULL;

			if ( I.Status() != STATUS_SUCCESS )
			{	//URB传输错误
				t << "URB传输错误\n";
				status = I.Status();
			}
			else
			{	//URB传输正确
				t << "801 URB传输正确\n";
				status = STATUS_SUCCESS;
			///*	// find the buffer pointer in the URB
 				PUCHAR buffer = (PUCHAR)m_pUrbIN->UrbBulkOrInterruptTransfer.TransferBuffer;
				//源数据

				// Dump the buffer		
				PUCHAR IrpBuffer = PUCHAR(Current.IoctlBuffer());
				//目的数据
				//IrpBuffer[0] = buffer[0];	//拷贝数据*/
				for(char i=0;i<16;i++)  IrpBuffer[i] = buffer[i];
				Current.Information() = 16;
			}
			Current.PnpComplete(this, status);
		}
	}

	t << "跳出801 Complete例程\n";

	//DecrementOutstandingRequestCount();
	// return indicates that system is to quit processing IRP completion
	return STATUS_MORE_PROCESSING_REQUIRED;
	
}


////////////////////自己加载的函数///////////////////
VOID USBWirelessDevice::Cancel(KIrp I)
{
	if ( (PIRP)I == CurrentIrp() )
	{
		CurrentIrp() = NULL;
		CancelSpinLock::Release(I.CancelIrql());
		I.Information() = 0;
		I.PnpComplete(this, STATUS_CANCELLED);
		IncrementOutstandingRequestCount();
		m_pItem.Queue(LinkTo(Workitem), this);	//排队工作项
	}
	else
		CancelSpinLock::Release(I.CancelIrql());
}

void USBWirelessDevice::GetStringDescriptors(void)
{
	NTSTATUS status = STATUS_SUCCESS;

	//PWCHAR String = (PWCHAR) new (NonPagedPool) WCHAR[MAXIMUM_USB_STRING_LENGTH];

//	if(NULL == String)
//	{
		//error during allocation
	//	t << "ERROR: Memory allocation error in GetStringDescriptors().\n";
	//	return;
//	}

	USB_DEVICE_DESCRIPTOR desc;
	status = m_Lower.GetDeviceDescriptor( &desc );	//获取设备描述符
	if ( !NT_SUCCESS(status) )
	{
		t << "ERROR: Could not get Device Descriptor.\n";
		//delete String;
		return;
	}

	//下面显示设备描述符信息
	t << "idVendor = "	<< desc.idVendor 		<< "\n";
	t << "idProduct = "	<< desc.idProduct 			<< "\n";
	t << "DeviceProtocol = " << desc.bDeviceProtocol		<< "\n";
	t << "Number of configurations = "		<< desc.bNumConfigurations	<< "\n";
	//t << "Index of configuration string = " << m_Lower.m_Config->iConfiguration << "\n";

/*	t << "*****  USB Counter String Descriptors  *****\n";

	for(UCHAR i = 0; i <= NUM_STRING_DESCRIPTORS; i++)
	{
		RtlZeroMemory(String, MAXIMUM_USB_STRING_LENGTH * sizeof(WCHAR));

		if(NT_SUCCESS(status = m_Lower.GetStringDescriptor(
														i, 
														String, 
														MAXIMUM_USB_STRING_LENGTH, 
														0x109)))
		{
			if (i==0)
			{
				PUSHORT languageid = (PUSHORT)String;
				t << "String " << i << ": " << *languageid << "\n";
			}
			else
				t << "String " << i << ": " << String << "\n";
		}
		else
		{
			t << "GetStringDescriptor returns status = " << ULONG(status) << "\n";
		}
	}*/

	//delete String;
}

NTSTATUS USBWirelessDevice::OnQueryCapabilities(KIrp I)
{
	I.CopyParametersDown();
	I.SetCompletionRoutine(LinkTo(OnQueryCapabilitiesComplete), this);
	return m_Lower.PnpCall(this, I);
}

NTSTATUS USBWirelessDevice::OnQueryCapabilitiesComplete(KIrp I)
{
	if (I->PendingReturned)	I.MarkPending();
  	I.DeviceCapabilities()->SurpriseRemovalOK = TRUE;
	//当USB设备被意外拔去后，系统便不再出现警示界面提示

	return STATUS_SUCCESS;
}

VOID USBWirelessDevice::Workitem()
{
	m_Endpoint1IN.Abort();	//放弃中断传输
	DecrementOutstandingRequestCount();
	m_Endpoint1OUT.Abort();	//放弃中断传输
	DecrementOutstandingRequestCount();

}