/*++
Routine Description:
This helper routine reads the configuration descriptor
for the device in couple of steps.
Arguments:
Device - Handle to a framework device
Return Value:
NTSTATUS - NT status value
--*/
NTSTATUS ConfigureDevice(IN WDFDEVICE Device)
{
USHORT size = 0;
NTSTATUS status;
PDEVICE_CONTEXT pDeviceContext;
PUSB_CONFIGURATION_DESCRIPTOR configurationDescriptor;
WDF_OBJECT_ATTRIBUTES attributes;
WDFMEMORY memory;
PAGED_CODE();
//
// initialize the variables
//
configurationDescriptor = NULL;
pDeviceContext = GetDeviceContext(Device);
// Read the first configuration descriptor
// This requires two steps:
// 1. Ask the WDFUSBDEVICE how big it is
// 2. Allocate it and get it from the WDFUSBDEVICE
status = WdfUsbTargetDeviceRetrieveConfigDescriptor(pDeviceContext->WdfUsbTargetDevice, NULL, &size);
if (status != STATUS_BUFFER_TOO_SMALL || size == 0)
{
PSDrv_DbgPrint(3, ("WdfUsbTargetDeviceRetrieveConfigDescriptor failed! (Status = %x)\n", status));
return status;
}
// Create a memory object and specify usbdevice as the parent so that it will be freed automatically.
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = pDeviceContext->WdfUsbTargetDevice;
status = WdfMemoryCreate(&attributes, NonPagedPool, POOL_TAG, size, &memory, &configurationDescriptor);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(3, ("WdfMemoryCreate for configurationDescriptor failed! (Status = %x)\n", status));
return status;
}
status = WdfUsbTargetDeviceRetrieveConfigDescriptor(pDeviceContext->WdfUsbTargetDevice, configurationDescriptor, &size);
if (!NT_SUCCESS(status))
{
PSDrv_DbgPrint(3, ("WdfUsbTargetDeviceRetrieveConfigDescriptor failed! (Status = %x)\n", status));
return status;
}
pDeviceContext->UsbConfigurationDescriptor = configurationDescriptor;
status = SelectInterfaces(Device);
return status;
}
NTSTATUS AndroidUsbDeviceObject::ConfigureDevice() {
ASSERT_IRQL_PASSIVE();
ASSERT(IsTaretDeviceCreated());
if (!IsTaretDeviceCreated())
return STATUS_INTERNAL_ERROR;
// In order to get the configuration descriptor we must first query for its
// size (by supplying NULL for the descriptor's address), allocate enough
// memory and then retrieve the descriptor.
USHORT size = 0;
// Query descriptor size first
NTSTATUS status =
WdfUsbTargetDeviceRetrieveConfigDescriptor(wdf_target_device(),
WDF_NO_HANDLE,
&size);
ASSERT((status == STATUS_BUFFER_TOO_SMALL) || !NT_SUCCESS(status));
if (status != STATUS_BUFFER_TOO_SMALL)
return status;
// Create a memory object and specify our device as the parent so that
// it will be freed automatically along with our device.
WDFMEMORY memory = NULL;
WDF_OBJECT_ATTRIBUTES attributes;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = wdf_device();
status = WdfMemoryCreate(&attributes,
NonPagedPool,
GANDR_POOL_TAG_DEV_CFG_DESC,
size,
&memory,
reinterpret_cast<PVOID*>(&configuration_descriptor_));
ASSERT(NT_SUCCESS(status));
if (!NT_SUCCESS(status))
return status;
// Now retrieve configuration descriptor
status =
WdfUsbTargetDeviceRetrieveConfigDescriptor(wdf_target_device(),
configuration_descriptor_,
&size);
ASSERT(NT_SUCCESS(status) && (NULL != configuration_descriptor_));
if (!NT_SUCCESS(status))
return status;
#if DBG
PrintConfigDescriptor(configuration_descriptor(), size);
#endif // DBG
return status;
}
static NTSTATUS UsbChief_ConfigureDevice(IN WDFDEVICE Device)
{
USHORT Size = 0;
NTSTATUS Status;
PDEVICE_CONTEXT pDeviceContext;
PUSB_CONFIGURATION_DESCRIPTOR configurationDescriptor = NULL;
WDF_OBJECT_ATTRIBUTES attributes;
WDFMEMORY memory;
PAGED_CODE();
pDeviceContext = GetDeviceContext(Device);
Status = WdfUsbTargetDeviceRetrieveConfigDescriptor(pDeviceContext->WdfUsbTargetDevice,
NULL, &Size);
if (Status != STATUS_BUFFER_TOO_SMALL || Size == 0)
return Status;
WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
attributes.ParentObject = pDeviceContext->WdfUsbTargetDevice;
Status = WdfMemoryCreate(&attributes,
NonPagedPool,
POOL_TAG,
Size,
&memory,
&configurationDescriptor);
if (!NT_SUCCESS(Status))
return Status;
Status = WdfUsbTargetDeviceRetrieveConfigDescriptor(pDeviceContext->WdfUsbTargetDevice,
configurationDescriptor,
&Size);
if (!NT_SUCCESS(Status))
return Status;
pDeviceContext->UsbConfigurationDescriptor = configurationDescriptor;
return UsbChief_SelectInterfaces(Device);
}
VOID
OsrFxEvtIoDeviceControl(
_In_ WDFQUEUE Queue,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength,
_In_ ULONG IoControlCode
)
/*++
Routine Description:
This event is called when the framework receives IRP_MJ_DEVICE_CONTROL
requests from the system.
Arguments:
Queue - Handle to the framework queue object that is associated
with the I/O request.
Request - Handle to a framework request object.
OutputBufferLength - length of the request's output buffer,
if an output buffer is available.
InputBufferLength - length of the request's input buffer,
if an input buffer is available.
IoControlCode - the driver-defined or system-defined I/O control code
(IOCTL) that is associated with the request.
Return Value:
VOID
--*/
{
WDFDEVICE device;
PDEVICE_CONTEXT pDevContext;
size_t bytesReturned = 0;
PBAR_GRAPH_STATE barGraphState = NULL;
PSWITCH_STATE switchState = NULL;
PUCHAR sevenSegment = NULL;
BOOLEAN requestPending = FALSE;
NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;
UNREFERENCED_PARAMETER(InputBufferLength);
UNREFERENCED_PARAMETER(OutputBufferLength);
PAGED_CODE();
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_IOCTL, "--> OsrFxEvtIoDeviceControl\n");
//
// initialize variables
//
device = WdfIoQueueGetDevice(Queue);
pDevContext = GetDeviceContext(device);
switch(IoControlCode) {
case IOCTL_OSRUSBFX2_GET_CONFIG_DESCRIPTOR: {
PUSB_CONFIGURATION_DESCRIPTOR configurationDescriptor = NULL;
USHORT requiredSize = 0;
//
// First get the size of the config descriptor
//
status = WdfUsbTargetDeviceRetrieveConfigDescriptor(
pDevContext->UsbDevice,
NULL,
&requiredSize);
if (status != STATUS_BUFFER_TOO_SMALL) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"WdfUsbTargetDeviceRetrieveConfigDescriptor failed 0x%x\n", status);
break;
}
//
// Get the buffer - make sure the buffer is big enough
//
status = WdfRequestRetrieveOutputBuffer(Request,
(size_t)requiredSize, // MinimumRequired
&configurationDescriptor,
NULL);
if(!NT_SUCCESS(status)){
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"WdfRequestRetrieveOutputBuffer failed 0x%x\n", status);
break;
}
status = WdfUsbTargetDeviceRetrieveConfigDescriptor(
pDevContext->UsbDevice,
configurationDescriptor,
&requiredSize);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"WdfUsbTargetDeviceRetrieveConfigDescriptor failed 0x%x\n", status);
break;
}
bytesReturned = requiredSize;
}
break;
case IOCTL_OSRUSBFX2_RESET_DEVICE:
status = ResetDevice(device);
break;
case IOCTL_OSRUSBFX2_REENUMERATE_DEVICE:
//
// Otherwise, call our function to reenumerate the
// device
//
status = ReenumerateDevice(pDevContext);
bytesReturned = 0;
break;
case IOCTL_OSRUSBFX2_GET_BAR_GRAPH_DISPLAY:
//
// Make sure the caller's output buffer is large enough
// to hold the state of the bar graph
//
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(BAR_GRAPH_STATE),
&barGraphState,
NULL);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"User's output buffer is too small for this IOCTL, expecting an BAR_GRAPH_STATE\n");
break;
}
//
// Call our function to get the bar graph state
//
status = GetBarGraphState(pDevContext, barGraphState);
//
// If we succeeded return the user their data
//
if (NT_SUCCESS(status)) {
bytesReturned = sizeof(BAR_GRAPH_STATE);
} else {
bytesReturned = 0;
}
break;
case IOCTL_OSRUSBFX2_SET_BAR_GRAPH_DISPLAY:
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(BAR_GRAPH_STATE),
&barGraphState,
NULL);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"User's input buffer is too small for this IOCTL, expecting an BAR_GRAPH_STATE\n");
break;
}
//
// Call our routine to set the bar graph state
//
status = SetBarGraphState(pDevContext, barGraphState);
//
// There's no data returned for this call
//
bytesReturned = 0;
break;
case IOCTL_OSRUSBFX2_GET_7_SEGMENT_DISPLAY:
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(UCHAR),
&sevenSegment,
NULL);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"User's output buffer is too small for this IOCTL, expecting an UCHAR\n");
break;
}
//
// Call our function to get the 7 segment state
//
status = GetSevenSegmentState(pDevContext, sevenSegment);
//
// If we succeeded return the user their data
//
if (NT_SUCCESS(status)) {
bytesReturned = sizeof(UCHAR);
} else {
bytesReturned = 0;
}
break;
case IOCTL_OSRUSBFX2_SET_7_SEGMENT_DISPLAY:
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(UCHAR),
&sevenSegment,
NULL);
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"User's input buffer is too small for this IOCTL, expecting an UCHAR\n");
bytesReturned = sizeof(UCHAR);
break;
}
//
// Call our routine to set the 7 segment state
//
status = SetSevenSegmentState(pDevContext, sevenSegment);
//
// There's no data returned for this call
//
bytesReturned = 0;
break;
case IOCTL_OSRUSBFX2_READ_SWITCHES:
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SWITCH_STATE),
&switchState,
NULL);// BufferLength
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_IOCTL,
"User's output buffer is too small for this IOCTL, expecting a SWITCH_STATE\n");
bytesReturned = sizeof(SWITCH_STATE);
break;
}
//
// Call our routine to get the state of the switches
//
status = GetSwitchState(pDevContext, switchState);
//
// If successful, return the user their data
//
if (NT_SUCCESS(status)) {
bytesReturned = sizeof(SWITCH_STATE);
} else {
//
// Don't return any data
//
bytesReturned = 0;
}
break;
case IOCTL_OSRUSBFX2_GET_INTERRUPT_MESSAGE:
//
// Forward the request to an interrupt message queue and dont complete
// the request until an interrupt from the USB device occurs.
//
status = WdfRequestForwardToIoQueue(Request, pDevContext->InterruptMsgQueue);
if (NT_SUCCESS(status)) {
requestPending = TRUE;
}
break;
default :
status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
if (requestPending == FALSE) {
WdfRequestCompleteWithInformation(Request, status, bytesReturned);
}
TraceEvents(TRACE_LEVEL_INFORMATION, DBG_IOCTL, "<-- OsrFxEvtIoDeviceControl\n");
return;
}
// 并行处理
VOID CY001Drv::DeviceIoControlParallel(IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN size_t OutputBufferLength,
IN size_t InputBufferLength,
IN ULONG IoControlCode)
{
NTSTATUS status = STATUS_SUCCESS;
ULONG ulRetLen = 0;
size_t size = 0;
void* pBufferInput = NULL;
void* pBufferOutput = NULL;
KDBG(DPFLTR_INFO_LEVEL, "[DeviceIoControlParallel] CtlCode:0x%0.8X", IoControlCode);
// 取得输入缓冲区，判断其有效性
if(InputBufferLength){
status = WdfRequestRetrieveInputBuffer(Request, InputBufferLength, &pBufferInput, &size);
if(status != STATUS_SUCCESS || pBufferInput == NULL || size < InputBufferLength){
WdfRequestComplete(Request, STATUS_INVALID_PARAMETER);
return;
}
}
// 取得输出缓冲区，判断其有效性
if(OutputBufferLength){
status = WdfRequestRetrieveOutputBuffer(Request, OutputBufferLength, &pBufferOutput, &size);
if(status != STATUS_SUCCESS || pBufferOutput == NULL || size < OutputBufferLength){
WdfRequestComplete(Request, STATUS_INVALID_PARAMETER);
return;
}
}
//
// 下面是主处理过程。
//
switch(IoControlCode)
{
// 取得驱动的版本信息
case IOCTL_GET_DRIVER_VERSION:
{
PDRIVER_VERSION pVersion = (PDRIVER_VERSION)pBufferOutput;
ULONG length;
char tcsBuffer[120];
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_GET_DRIVER_VERSION");
if(OutputBufferLength < sizeof(DRIVER_VERSION)){
status = STATUS_BUFFER_TOO_SMALL;
break;
}
pVersion->DriverType = DR_WDF;
pVersion->FirmwareType = FW_NOT_CY001;
ulRetLen = sizeof(DRIVER_VERSION);// 告示返回长度
// 根据String描述符，判断Firmware代码是否已经被加载。
GetStringDes(2, 0, tcsBuffer, 120, &length);
if(length){
WCHAR* pCyName = L"CY001 V";
size_t len;
int nIndex;
if(length < 8)
break;
RtlStringCchLengthW(pCyName, 7, &len);
for(nIndex = 0; nIndex < len; nIndex++){
if(pCyName[nIndex] != ((WCHAR*)tcsBuffer)[nIndex])
break;
}
if(nIndex == len)
pVersion->FirmwareType = FW_CY001; // 完全相符，说明新版Firmware已经加载到开发板。
}
break;
}
// 收到App发送过来的一个同步Request，我们应该把它保存到同步Queue中，等到有同步事件发生的时候再从Queue中取出并完成。
case IOCTL_USB_SYNC:
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_SYNC");
status = WdfRequestForwardToIoQueue(Request, m_hAppSyncManualQueue);
// 直接返回，不调用WdfRequestComplete函数。
// 请求者将不会为此而等待；请求的完成在将来的某个时刻。
// 这就是所谓的异步处理之要义了。
if(NT_SUCCESS(status))
return;
break;
// 清空同步队列中的所有请求
case IOCTL_USB_SYNC_RELEASE:
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_SYNC");
ClearSyncQueue();
break;
// 应用程序退出，取消所有被阻塞的请求。
case IOCTL_APP_EXIT_CANCEL:
// 取消USB设备的所有IO操作。它将连带取消所有Pipe的IO操作。
//WdfIoTargetStop(WdfUsbTargetDeviceGetIoTarget(m_hUsbDevice), WdfIoTargetCancelSentIo);
break;
// 取得当前的配置号.总是设置为0,因为在WDF框架中,0以外的配置是不被支持的。
case IOCTL_USB_GET_CURRENT_CONFIG:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_GET_CURRENT_CONFIG");
if(InputBufferLength < 4){
status = STATUS_INVALID_PARAMETER;
break;
}
*(PULONG)pBufferInput = 0;// 直接赋值0，即总是选择0号配置。也可以发送URB到总线获取当前配置选项。
ulRetLen = sizeof(ULONG);
break;
}
case IOCTL_USB_ABORTPIPE:
{
ULONG pipenum = *((PULONG) pBufferOutput);
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_ABORTPIPE");
status = AbortPipe(pipenum);
}
break;
// 获取Pipe信息
case IOCTL_USB_GET_PIPE_INFO:
{
// 遍历获取Pipe信息，复制到输出缓冲中。
BYTE byCurSettingIndex = 0;
BYTE byPipeNum = 0;
BYTE index;
USB_INTERFACE_DESCRIPTOR interfaceDescriptor;
WDF_USB_PIPE_INFORMATION pipeInfor;
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_GET_PIPE_INFO");
// 取得Pipe数。根据Pipe数计算缓冲区长度
byCurSettingIndex = WdfUsbInterfaceGetConfiguredSettingIndex(m_hUsbInterface);
WdfUsbInterfaceGetDescriptor(m_hUsbInterface, byCurSettingIndex, &interfaceDescriptor);
byPipeNum = WdfUsbInterfaceGetNumConfiguredPipes(m_hUsbInterface);
if(OutputBufferLength < byPipeNum * sizeof(pipeInfor)){
status = STATUS_BUFFER_TOO_SMALL; // 缓冲区不足
}else{
ulRetLen = byPipeNum*sizeof(pipeInfor);
// 遍历获取全部管道信息，拷贝到输出缓冲中。
// 应用程序得到输出缓冲的时候，也应该使用WDF_USB_PIPE_INFORMATION结构体解析缓冲区。
for(index = 0; index < byPipeNum; index++)
{
WDF_USB_PIPE_INFORMATION_INIT(&pipeInfor);
WdfUsbInterfaceGetEndpointInformation(m_hUsbInterface, byCurSettingIndex, index, &pipeInfor);
RtlCopyMemory((PUCHAR)pBufferOutput + index*pipeInfor.Size, &pipeInfor, sizeof(pipeInfor));
}
}
}
break;
// 获取设备描述符
case IOCTL_USB_GET_DEVICE_DESCRIPTOR:
{
USB_DEVICE_DESCRIPTOR UsbDeviceDescriptor;
WdfUsbTargetDeviceGetDeviceDescriptor(m_hUsbDevice, &UsbDeviceDescriptor);
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_GET_DEVICE_DESCRIPTOR");
// 判断输入缓冲区的长度是否足够长
if(OutputBufferLength < UsbDeviceDescriptor.bLength)
status = STATUS_BUFFER_TOO_SMALL;
else{
RtlCopyMemory(pBufferOutput, &UsbDeviceDescriptor, UsbDeviceDescriptor.bLength);
ulRetLen = UsbDeviceDescriptor.bLength;
}
break;
}
// 获取字符串描述符
case IOCTL_USB_GET_STRING_DESCRIPTOR:
{
PGET_STRING_DESCRIPTOR Input = (PGET_STRING_DESCRIPTOR)pBufferInput;
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_GET_STRING_DESCRIPTOR");
status = GetStringDes(Input->Index, Input->LanguageId, pBufferOutput, OutputBufferLength, &ulRetLen);
// 由字符长度调整为字节长度
if(NT_SUCCESS(status) && ulRetLen > 0)
ulRetLen *= (sizeof(WCHAR)/sizeof(char));
break;
}
// 获取配置描述信息。
case IOCTL_USB_GET_CONFIGURATION_DESCRIPTOR:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_GET_CONFIGURATION_DESCRIPTOR");
// 首先获得配置描述符的长度。
status = WdfUsbTargetDeviceRetrieveConfigDescriptor(m_hUsbDevice, NULL, (USHORT*)&size);
if(!NT_SUCCESS(status) && status != STATUS_BUFFER_TOO_SMALL)
break;
// 输出缓冲区不够长
if(OutputBufferLength < size)
break;
// 正式取得配置描述符。
status = WdfUsbTargetDeviceRetrieveConfigDescriptor(m_hUsbDevice, pBufferOutput, (USHORT*)&size);
if(!NT_SUCCESS(status))
break;
ulRetLen = size;
break;
}
// 根据可选值配置接口
case IOCTL_USB_SET_INTERFACE:
{
BYTE byAlterSetting = *(BYTE*)pBufferInput;
BYTE byCurSetting = WdfUsbInterfaceGetConfiguredSettingIndex(m_hUsbInterface); // 当前Alternate值
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_SETINTERFACE");
if(InputBufferLength < 1 || OutputBufferLength < 1)
{
status = STATUS_BUFFER_TOO_SMALL;
break;
}
// 如果传入的可选值与当前的不同，则重新配置接口；
// 否则直接返回。
if(byCurSetting != byAlterSetting)
{
WDF_USB_INTERFACE_SELECT_SETTING_PARAMS par;
WDF_USB_INTERFACE_SELECT_SETTING_PARAMS_INIT_SETTING(&par, byAlterSetting);
status = WdfUsbInterfaceSelectSetting(m_hUsbInterface, NULL, &par);
}
*(BYTE*)pBufferOutput = byCurSetting;
break;
}
// 固件Rest。自定义命令，与Port Rest是两码事。
case IOCTL_USB_FIRMWRAE_RESET:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_FIRMWRAE_RESET");
if(InputBufferLength < 1 || pBufferInput == NULL)
status = STATUS_INVALID_PARAMETER;
else
status = FirmwareReset(*(char*)pBufferInput);
break;
}
// 重置USB总线端口
case IOCTL_USB_PORT_RESET:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_PORT_RESET");
WdfUsbTargetDeviceResetPortSynchronously(m_hUsbDevice);
break;
}
// 管道重置
case IOCTL_USB_PIPE_RESET:
{
UCHAR uchPipe;
WDFUSBPIPE pipe = NULL;
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_PIPE_RESET");
if(InputBufferLength < 1){
status = STATUS_INVALID_PARAMETER;
break;
}
// 根据ID找到对应的Pipe
uchPipe = *(UCHAR*)pBufferInput;
pipe = WdfUsbInterfaceGetConfiguredPipe(m_hUsbInterface, uchPipe, NULL);
if(pipe == NULL){
status = STATUS_INVALID_PARAMETER;
break;
}
status = WdfUsbTargetPipeResetSynchronously(pipe, NULL, NULL);
break;
}
// 中断管道，放弃管道当前正在进行的操作
case IOCTL_USB_PIPE_ABORT:
{
UCHAR uchPipe;
WDFUSBPIPE pipe = NULL;
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_PIPE_ABORT");
if(InputBufferLength < 1){
status = STATUS_INVALID_PARAMETER;
break;
}
// 根据ID找到对应的Pipe
uchPipe = *(UCHAR*)pBufferInput;
pipe = WdfUsbInterfaceGetConfiguredPipe(m_hUsbInterface, uchPipe, NULL);
if(pipe == NULL){
status = STATUS_INVALID_PARAMETER;
break;
}
status = WdfUsbTargetPipeAbortSynchronously(pipe, NULL, NULL);
break;
}
// 取得驱动错误信息，驱动总是把最后一次发现的错误保存在设备对象的环境块中。
// 这个逻辑虽然实现了，但目前的版本中，应用程序并没有利用这个接口。
case IOCTL_USB_GET_LAST_ERROR:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_GET_LAST_ERROR");
if (OutputBufferLength >= sizeof(ULONG))
*((PULONG)pBufferOutput) = m_ulLastUSBErrorStatusValue;
else
status = STATUS_BUFFER_TOO_SMALL;
ulRetLen = sizeof(ULONG);
break;
}
// Clear feature命令
case IOCTL_USB_SET_CLEAR_FEATURE:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_USB_SET_CLEAR_FEATURE");
status = UsbSetOrClearFeature(Request);
break;
}
// 为USB设备加载固件程序。带有偏移量参数，用这个分支；不带偏移量，可用下一个分支。
// 带偏移量的情况下，固件代码是一段一段地加载；
// 不带偏移量的情况，固件代码作为一整块一次性被加载。
case IOCTL_FIRMWARE_UPLOAD_OFFSET:
{
void* pData = pBufferOutput;
WORD offset = 0;
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_FIRMWARE_UPLOAD_OFFSET");
if(InputBufferLength < sizeof(WORD)){
status = STATUS_INVALID_PARAMETER;
break;
}
offset = *(WORD*)pBufferInput;
status = FirmwareUpload((PUCHAR)pData, OutputBufferLength, offset);
break;
}
// 为USB设备加载固件程序。
case IOCTL_FIRMWARE_UPLOAD:
{
void* pData = pBufferOutput;
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_FIRMWARE_UPLOAD");
status = FirmwareUpload((PUCHAR)pData, InputBufferLength, 0);
break;
}
// 读取开发板设备的RAM内容。RAM也就是内存。
// 每次从同一地址读取的内容可能不尽相同，开发板中固件程序在不断运行，RAM被用来储数据（包括临时数据）。
case IOCTL_FIRMWARE_READ_RAM:
{
KDBG(DPFLTR_INFO_LEVEL, "IOCTL_FIRMWARE_READ_RAM");
status = ReadRAM(Request, &ulRetLen);// inforVal中保存读取的长度
break;
}
// 其他的请求
default:
{
// 一律转发到SerialQueue中去。
WdfRequestForwardToIoQueue(Request, m_hIoCtlSerialQueue);
// 命令转发之后，这里必须直接返回，千万不可调用WdfRequestComplete函数。
// 否则会导致一个Request被完成两次的错误。
return;
}
}
// 完成请求
WdfRequestCompleteWithInformation(Request, status, ulRetLen);
}
