Chinaunix首页 | 论坛 | 博客

xiaobin(veic_2005#163.com)

首页　| 　博文目录　| 　关于我

xiaobin_hlj80

  • 博客访问： 54889
  • 博文数量： 51
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 410
  • 用 户 组： 普通用户
  • 注册时间： 2018-08-26 01:30
文章分类

全部博文（51）

文章存档

2020年（2）

2018年（49）

我的朋友
最近访客
推荐博文
相关博文
Windows 驱动开发 - 7

分类： Windows平台

2018-08-26 02:08:48

在《Windows 驱动开发 - 5》我们所说的读写操作在本篇实现。

    在WDF中实现此功能主要为：EvtIoRead和EvtIoWrite。


首先，在EvtDeviceAdd设置以上两个回调事件。

  1. ioQueueConfig.EvtIoRead = EvtIoRead;
  2. ioQueueConfig.EvtIoWrite = EvtIoWrite;
然后，在EvtDevicePrepareHardware中获取WDFUSBPIPE并测试他。

  1. pDeviceContext->BulkReadPipe = WdfUsbInterfaceGetConfiguredPipe(
  2.                                                   pDeviceContext->UsbInterface,
  3.                                                   BULK_IN_ENDPOINT_INDEX,
  4.                                                   NULL);// pipeInfo

  6.     WdfUsbTargetPipeSetNoMaximumPacketSizeCheck(pDeviceContext->BulkReadPipe);
  7.     
  8.     pDeviceContext->BulkWritePipe = WdfUsbInterfaceGetConfiguredPipe(
  9.                                                   pDeviceContext->UsbInterface,
  10.                                                   BULK_OUT_ENDPOINT_INDEX,
  11.                                                   NULL);// pipeInfo

(1)获取WDFUSBPIPE

使用方法。


  1. WDFUSBPIPE WdfUsbInterfaceGetConfiguredPipe(
  2.   [in] WDFUSBINTERFACE UsbInterface,
  3.   [in] UCHAR PipeIndex,
  4.   [out, optional] PWDF_USB_PIPE_INFORMATION PipeInfo
  5. );

(2) 测试WDFUSBPIPE

使用方法.


  1. VOID WdfUsbTargetPipeSetNoMaximumPacketSizeCheck(
  2.   [in] WDFUSBPIPE Pipe
  3. );

最后，实现以上两个回调事件和他们的完成例程。

1. 获得传输缓存


读：


  1. NTSTATUS WdfRequestRetrieveOutputMemory(
  2.   [in] WDFREQUEST Request,
  3.   [out] WDFMEMORY *Memory
  4. );
写：

  1. NTSTATUS WdfRequestRetrieveInputMemory(
  2.   [in] WDFREQUEST Request,
  3.   [out] WDFMEMORY *Memory
  4. );

2. 格式化并发送一个请求对象到USB驱动程序堆栈


读：


  1. NTSTATUS WdfUsbTargetPipeFormatRequestForRead(
  2.   [in] WDFUSBPIPE Pipe,
  3.   [in] WDFREQUEST Request,
  4.   [in, optional] WDFMEMORY ReadMemory,
  5.   [in, optional] PWDFMEMORY_OFFSET ReadOffset
  6. );
写：

  1. NTSTATUS WdfUsbTargetPipeFormatRequestForWrite(
  2.   [in] WDFUSBPIPE Pipe,
  3.   [in] WDFREQUEST Request,
  4.   [in, optional] WDFMEMORY WriteMemory,
  5.   [in, optional] PWDFMEMORY_OFFSET WriteOffset
  6. );

3. 对请求实现一个完成例程


(1) 设置完成例程

使用方法。


  1. VOID WdfRequestSetCompletionRoutine(
  2.   [in] WDFREQUEST Request,
  3.   [in, optional] PFN_WDF_REQUEST_COMPLETION_ROUTINE CompletionRoutine,
  4.   [in, optional] WDFCONTEXT CompletionContext
  5. );

(2)完成例程

1).检查请求状态


  1. status = CompletionParams->IoStatus.Status;

2). 检查传输的字节数


读完：


  1. bytesRead = usbCompletionParams->Parameters.PipeRead.Length;
写完：

  1. bytesWritten = usbCompletionParams->Parameters.PipeWrite.Length;

3). 检查USBD状态

首先，赋值


  1. usbCompletionParams = CompletionParams->Parameters.Usb.Completion;
最后，获取

  1. usbCompletionParams->UsbdStatus;

注：


读：EvtIoRead

写：EvtIoWrite

读完：EvtRequestReadCompletionRoutine

写完：EvtRequestWriteCompletionRoutine



附：

step4.c


  1. /*++

  3. Step4: This steps shows:
  4.        1) How to register Read and Write events on the default queue.
  5.        2) Retrieve memory from read and write request, format the
  6.           requests and send it to USB target.
  7. --*/

  9. #include "ntddk.h"
  10. #include "wdf.h"
  11. #include "prototypes.h"
  12. #pragma warning(disable:4200) // suppress nameless struct/union warning
  13. #pragma warning(disable:4201) // suppress nameless struct/union warning
  14. #pragma warning(disable:4214) // suppress bit field types other than int warning
  15. #include "usbdi.h"
  16. #pragma warning(default:4200)
  17. #pragma warning(default:4201)
  18. #pragma warning(default:4214)
  19. #include "wdfusb.h"
  20. #include "initguid.h"

  22. DEFINE_GUID(GUID_DEVINTERFACE_OSRUSBFX2, // Generated using guidgen.exe
  23.    0x573e8c73, 0xcb4, 0x4471, 0xa1, 0xbf, 0xfa, 0xb2, 0x6c, 0x31, 0xd3, 0x84);
  24. // {573E8C73-0CB4-4471-A1BF-FAB26C31D384}

  26. #define IOCTL_INDEX 0x800
  27. #define FILE_DEVICE_OSRUSBFX2 0x65500
  28. #define USBFX2LK_SET_BARGRAPH_DISPLAY 0xD8
  29. #define BULK_OUT_ENDPOINT_INDEX 1
  30. #define BULK_IN_ENDPOINT_INDEX 2
  31. #define IOCTL_OSRUSBFX2_SET_BAR_GRAPH_DISPLAY CTL_CODE(FILE_DEVICE_OSRUSBFX2,\
  32.                                                     IOCTL_INDEX + 5, \
  33.                                                     METHOD_BUFFERED, \
  34.                                                     FILE_WRITE_ACCESS)
  35. typedef struct _DEVICE_CONTEXT {
  36.   WDFUSBDEVICE UsbDevice;
  37.   WDFUSBINTERFACE UsbInterface;
  38.   WDFUSBPIPE BulkReadPipe;
  39.   WDFUSBPIPE BulkWritePipe;
  40. } DEVICE_CONTEXT, *PDEVICE_CONTEXT;

  42. WDF_DECLARE_CONTEXT_TYPE_WITH_NAME(DEVICE_CONTEXT, GetDeviceContext)


  45. NTSTATUS
  46. DriverEntry(
  47.     IN PDRIVER_OBJECT DriverObject,
  48.     IN PUNICODE_STRING RegistryPath
  49.     )
  50. {
  51.     WDF_DRIVER_CONFIG config;
  52.     NTSTATUS status;

  54.     KdPrint(("DriverEntry of Step4\n"));

  56.     WDF_DRIVER_CONFIG_INIT(&config, EvtDeviceAdd);

  58.     status = WdfDriverCreate(DriverObject,
  59.                         RegistryPath,
  60.                         WDF_NO_OBJECT_ATTRIBUTES,
  61.                         &config,
  62.                         WDF_NO_HANDLE
  63.                         );

  65.     if (!NT_SUCCESS(status)) {
  66.         KdPrint(("WdfDriverCreate failed 0x%x\n", status));
  67.     }

  69.     return status;
  70. }

  72. NTSTATUS
  73. EvtDeviceAdd(
  74.     IN WDFDRIVER Driver,
  75.     IN PWDFDEVICE_INIT DeviceInit
  76.     )
  77. {
  78.     WDF_OBJECT_ATTRIBUTES attributes;
  79.     NTSTATUS status;
  80.     WDFDEVICE device;
  81.     PDEVICE_CONTEXT pDevContext;
  82.     WDF_PNPPOWER_EVENT_CALLBACKS pnpPowerCallbacks;
  83.     WDF_IO_QUEUE_CONFIG ioQueueConfig;
  84.     
  85.     UNREFERENCED_PARAMETER(Driver);

  87.     WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
  88.     pnpPowerCallbacks.EvtDevicePrepareHardware = EvtDevicePrepareHardware;
  89.     WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);

  91.     WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, DEVICE_CONTEXT);

  93.     status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
  94.     if (!NT_SUCCESS(status)) {
  95.         KdPrint(("WdfDeviceCreate failed 0x%x\n", status));
  96.         return status;
  97.     }

  99.     pDevContext = GetDeviceContext(device);

  101.     status = WdfDeviceCreateDeviceInterface(device,
  102.                                 (LPGUID) &GUID_DEVINTERFACE_OSRUSBFX2,
  103.                                 NULL);// Reference String
  104.     if (!NT_SUCCESS(status)) {
  105.         KdPrint(("WdfDeviceCreateDeviceInterface failed 0x%x\n", status));
  106.         return status;
  107.     }

  109.     WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&ioQueueConfig,
  110.                                     WdfIoQueueDispatchParallel);

  112.     ioQueueConfig.EvtIoDeviceControl = EvtIoDeviceControl;
  113.     ioQueueConfig.EvtIoRead = EvtIoRead;
  114.     ioQueueConfig.EvtIoWrite = EvtIoWrite;

  116.     status = WdfIoQueueCreate(device,
  117.                          &ioQueueConfig,
  118.                          WDF_NO_OBJECT_ATTRIBUTES,
  119.                          WDF_NO_HANDLE);
  120.     if (!NT_SUCCESS(status)) {
  121.         KdPrint(("WdfIoQueueCreate failed %!STATUS!\n", status));
  122.         return status;
  123.     }

  125.     return status;
  126. }


  129. NTSTATUS
  130. EvtDevicePrepareHardware(
  131.     IN WDFDEVICE Device,
  132.     IN WDFCMRESLIST ResourceList,
  133.     IN WDFCMRESLIST ResourceListTranslated
  134.     )
  135. {
  136.     NTSTATUS status;
  137.     PDEVICE_CONTEXT pDeviceContext;
  138.     WDF_USB_DEVICE_SELECT_CONFIG_PARAMS configParams;

  140.     UNREFERENCED_PARAMETER(ResourceList);
  141.     UNREFERENCED_PARAMETER(ResourceListTranslated);

  143.     pDeviceContext = GetDeviceContext(Device);

  145.     //
  146.     // Create the USB device if it is not already created.
  147.     //
  148.     if (pDeviceContext->UsbDevice == NULL) {

  150.         status = WdfUsbTargetDeviceCreate(Device,
  151.                                     WDF_NO_OBJECT_ATTRIBUTES,
  152.                                     &pDeviceContext->UsbDevice);
  153.         if (!NT_SUCCESS(status)) {
  154.             KdPrint(("WdfUsbTargetDeviceCreate failed 0x%x\n", status));
  155.             return status;
  156.         }
  157.     }

  159.     WDF_USB_DEVICE_SELECT_CONFIG_PARAMS_INIT_SINGLE_INTERFACE(&configParams);

  161.     status = WdfUsbTargetDeviceSelectConfig(pDeviceContext->UsbDevice,
  162.                                         WDF_NO_OBJECT_ATTRIBUTES,
  163.                                         &configParams);
  164.     if(!NT_SUCCESS(status)) {
  165.         KdPrint(("WdfUsbTargetDeviceSelectConfig failed 0x%x\n", status));
  166.         return status;
  167.     }

  169.     pDeviceContext->UsbInterface =
  170.                 configParams.Types.SingleInterface.ConfiguredUsbInterface;
  171.     
  172.     pDeviceContext->BulkReadPipe = WdfUsbInterfaceGetConfiguredPipe(
  173.                                                   pDeviceContext->UsbInterface,
  174.                                                   BULK_IN_ENDPOINT_INDEX,
  175.                                                   NULL);// pipeInfo

  177.     WdfUsbTargetPipeSetNoMaximumPacketSizeCheck(pDeviceContext->BulkReadPipe);
  178.     
  179.     pDeviceContext->BulkWritePipe = WdfUsbInterfaceGetConfiguredPipe(
  180.                                                   pDeviceContext->UsbInterface,
  181.                                                   BULK_OUT_ENDPOINT_INDEX,
  182.                                                   NULL);// pipeInfo

  184.     WdfUsbTargetPipeSetNoMaximumPacketSizeCheck(pDeviceContext->BulkWritePipe);
  185.         
  186.     return status;
  187. }

  189. VOID
  190. EvtIoDeviceControl(
  191.     IN WDFQUEUE Queue,
  192.     IN WDFREQUEST Request,
  193.     IN size_t OutputBufferLength,
  194.     IN size_t InputBufferLength,
  195.     IN ULONG IoControlCode
  196.     )
  197. {
  198.     WDFDEVICE device;
  199.     PDEVICE_CONTEXT pDevContext;
  200.     size_t bytesTransferred = 0;
  201.     NTSTATUS status;
  202.     WDF_USB_CONTROL_SETUP_PACKET controlSetupPacket;
  203.     WDF_MEMORY_DESCRIPTOR memDesc;
  204.     WDFMEMORY memory;
  205.     WDF_REQUEST_SEND_OPTIONS sendOptions;
  206.      
  207.     UNREFERENCED_PARAMETER(InputBufferLength);
  208.     UNREFERENCED_PARAMETER(OutputBufferLength);
  209.     
  210.     device = WdfIoQueueGetDevice(Queue);
  211.     pDevContext = GetDeviceContext(device);

  213.     switch(IoControlCode) {

  215.     case IOCTL_OSRUSBFX2_SET_BAR_GRAPH_DISPLAY:

  217.         if(InputBufferLength < sizeof(UCHAR)) {
  218.             status = STATUS_BUFFER_OVERFLOW;
  219.             bytesTransferred = sizeof(UCHAR);
  220.             break;
  221.         }

  223.         status = WdfRequestRetrieveInputMemory(Request, &memory);
  224.         if (!NT_SUCCESS(status)) {
  225.             KdPrint(("WdfRequestRetrieveMemory failed 0x%x", status));
  226.             break;
  227.         }

  229.         WDF_USB_CONTROL_SETUP_PACKET_INIT_VENDOR(&controlSetupPacket,
  230.                                         BmRequestHostToDevice,
  231.                                         BmRequestToDevice,
  232.                                         USBFX2LK_SET_BARGRAPH_DISPLAY, // Request
  233.                                         0, // Value
  234.                                         0); // Index

  236.         WDF_MEMORY_DESCRIPTOR_INIT_HANDLE(&memDesc, memory, NULL);

  238.        //
  239.        // Send the I/O with a timeout to avoid hanging the calling
  240.        // thread indefinitely.
  241.        //
  242.         WDF_REQUEST_SEND_OPTIONS_INIT(&sendOptions,
  243.                                   WDF_REQUEST_SEND_OPTION_TIMEOUT);

  245.         WDF_REQUEST_SEND_OPTIONS_SET_TIMEOUT(&sendOptions,
  246.                                          WDF_REL_TIMEOUT_IN_MS(100));
  247.     
  248.         status = WdfUsbTargetDeviceSendControlTransferSynchronously(
  249.                                         pDevContext->UsbDevice,
  250.                                         NULL, // Optional WDFREQUEST
  251.                                         &sendOptions, // PWDF_REQUEST_SEND_OPTIONS
  252.                                         &controlSetupPacket,
  253.                                         &memDesc,
  254.                                         (PULONG)&bytesTransferred);
  255.         if (!NT_SUCCESS(status)) {
  256.             KdPrint(("SendControlTransfer failed 0x%x", status));
  257.             break;
  258.         }
  259.         break;

  261.     default:
  262.         status = STATUS_INVALID_DEVICE_REQUEST;
  263.         break;
  264.     }

  266.     WdfRequestCompleteWithInformation(Request, status, bytesTransferred);

  268.     return;
  269. }

  271. VOID
  272. EvtIoRead(
  273.     IN WDFQUEUE Queue,
  274.     IN WDFREQUEST Request,
  275.     IN size_t Length
  276.     )
  277. {
  278.     WDFUSBPIPE pipe;
  279.     NTSTATUS status;
  280.     WDFMEMORY reqMemory;
  281.     PDEVICE_CONTEXT pDeviceContext;
  282.     BOOLEAN ret;
  283.     
  284.     UNREFERENCED_PARAMETER(Length);

  286.     pDeviceContext = GetDeviceContext(WdfIoQueueGetDevice(Queue));
  287.     
  288.     pipe = pDeviceContext->BulkReadPipe;
  289.     
  290.     status = WdfRequestRetrieveOutputMemory(Request, &reqMemory);
  291.     if(!NT_SUCCESS(status)){
  292.         goto Exit;
  293.     }
  294.    
  295.     status = WdfUsbTargetPipeFormatRequestForRead(pipe,
  296.                                         Request,
  297.                                         reqMemory,
  298.                                         NULL // Offsets
  299.                                         );
  300.     if (!NT_SUCCESS(status)) {
  301.         goto Exit;
  302.     }

  304.     WdfRequestSetCompletionRoutine(Request,
  305.                             EvtRequestReadCompletionRoutine,
  306.                             pipe);
  307.     ret = WdfRequestSend(Request,
  308.                     WdfUsbTargetPipeGetIoTarget(pipe),
  309.                     WDF_NO_SEND_OPTIONS);
  310.     
  311.     if (ret == FALSE) {
  312.         status = WdfRequestGetStatus(Request);
  313.         goto Exit;
  314.     } else {
  315.         return;
  316.     }
  317.    
  318. Exit:
  319.     WdfRequestCompleteWithInformation(Request, status, 0);

  321.     return;
  322. }

  324. VOID
  325. EvtRequestReadCompletionRoutine(
  326.     IN WDFREQUEST Request,
  327.     IN WDFIOTARGET Target,
  328.     PWDF_REQUEST_COMPLETION_PARAMS CompletionParams,
  329.     IN WDFCONTEXT Context
  330.     )
  331. {
  332.     NTSTATUS status;
  333.     size_t bytesRead = 0;
  334.     PWDF_USB_REQUEST_COMPLETION_PARAMS usbCompletionParams;

  336.     UNREFERENCED_PARAMETER(Target);
  337.     UNREFERENCED_PARAMETER(Context);

  339.     status = CompletionParams->IoStatus.Status;
  340.     
  341.     usbCompletionParams = CompletionParams->Parameters.Usb.Completion;
  342.     
  343.     bytesRead = usbCompletionParams->Parameters.PipeRead.Length;
  344.     
  345.     if (NT_SUCCESS(status)){
  346.         KdPrint(("Number of bytes read: %I64d\n", (INT64)bytesRead));
  347.     } else {
  348.         KdPrint(("Read failed - request status 0x%x UsbdStatus 0x%x\n",
  349.                 status, usbCompletionParams->UsbdStatus));

  351.     }

  353.     WdfRequestCompleteWithInformation(Request, status, bytesRead);

  355.     return;
  356. }

  358. VOID
  359. EvtIoWrite(
  360.     IN WDFQUEUE Queue,
  361.     IN WDFREQUEST Request,
  362.     IN size_t Length
  363.     )
  364. {
  365.     NTSTATUS status;
  366.     WDFUSBPIPE pipe;
  367.     WDFMEMORY reqMemory;
  368.     PDEVICE_CONTEXT pDeviceContext;
  369.     BOOLEAN ret;
  370.     
  371.     UNREFERENCED_PARAMETER(Length);

  373.     pDeviceContext = GetDeviceContext(WdfIoQueueGetDevice(Queue));
  374.     
  375.     pipe = pDeviceContext->BulkWritePipe;

  377.     status = WdfRequestRetrieveInputMemory(Request, &reqMemory);
  378.     if(!NT_SUCCESS(status)){
  379.         goto Exit;
  380.     }

  382.     status = WdfUsbTargetPipeFormatRequestForWrite(pipe,
  383.                                               Request,
  384.                                               reqMemory,
  385.                                               NULL); // Offset
  386.     if (!NT_SUCCESS(status)) {
  387.         goto Exit;
  388.     }

  390.     WdfRequestSetCompletionRoutine(
  391.                             Request,
  392.                             EvtRequestWriteCompletionRoutine,
  393.                             pipe);
  394.     ret = WdfRequestSend(Request,
  395.                     WdfUsbTargetPipeGetIoTarget(pipe),
  396.                     WDF_NO_SEND_OPTIONS);
  397.     if (ret == FALSE) {
  398.         status = WdfRequestGetStatus(Request);
  399.         goto Exit;
  400.     } else {
  401.         return;
  402.     }

  404. Exit:
  405.     WdfRequestCompleteWithInformation(Request, status, 0);

  407.     return;
  408. }

  410. VOID
  411. EvtRequestWriteCompletionRoutine(
  412.     IN WDFREQUEST Request,
  413.     IN WDFIOTARGET Target,
  414.     PWDF_REQUEST_COMPLETION_PARAMS CompletionParams,
  415.     IN WDFCONTEXT Context
  416.     )
  417. {
  418.     NTSTATUS status;
  419.     size_t bytesWritten = 0;
  420.     PWDF_USB_REQUEST_COMPLETION_PARAMS usbCompletionParams;

  422.     UNREFERENCED_PARAMETER(Target);
  423.     UNREFERENCED_PARAMETER(Context);

  425.     status = CompletionParams->IoStatus.Status;

  427.     usbCompletionParams = CompletionParams->Parameters.Usb.Completion;
  428.     
  429.     bytesWritten = usbCompletionParams->Parameters.PipeWrite.Length;
  430.     
  431.     if (NT_SUCCESS(status)){
  432.         KdPrint(("Number of bytes written: %I64d\n", (INT64)bytesWritten));
  433.     } else {
  434.         KdPrint(("Write failed: request Status 0x%x UsbdStatus 0x%x\n",
  435.                 status, usbCompletionParams->UsbdStatus));
  436.     }

  438.     WdfRequestCompleteWithInformation(Request, status, bytesWritten);

  440.     return;
  441. }

参考文章：


    1. 《》 

    2. 《》











阅读(1972) | 评论(0) | 转发(0) |
0

上一篇：Windows 驱动开发 - 8

下一篇：Windows 驱动开发 - 6

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6