// Bulk管道写操作
//
VOID BulkWrite(IN WDFQUEUE Queue, IN WDFREQUEST Request, IN size_t Length)
{
NTSTATUS status = STATUS_SUCCESS;
WDFMEMORY hMem = NULL;
WDFDEVICE hDevice = NULL;
WDFUSBPIPE BulkOutputPipe = NULL;
UCHAR* lpBuf;
UNREFERENCED_PARAMETER(Length);
KDBG(DPFLTR_INFO_LEVEL, "[BulkWrite] size: %d", Length);
// 获取管道句柄
hDevice = WdfIoQueueGetDevice(Queue);
BulkOutputPipe = GetBulkPipe(FALSE, hDevice);
if(NULL == BulkOutputPipe)
{
KDBG(DPFLTR_ERROR_LEVEL, "BulkOutputPipe = NULL");
WdfRequestComplete(Request, STATUS_UNSUCCESSFUL);
return;
}
status = WdfRequestRetrieveInputMemory(Request, &hMem);
if(!NT_SUCCESS(status))
{
KDBG(DPFLTR_ERROR_LEVEL, "WdfRequestRetrieveInputMemory failed(status = 0x%0.8x)!!!", status);
WdfRequestComplete(Request, status);
return;
}
// 打印出offset值。
// 在写缓冲的前两个字节中存有write offset的值
lpBuf = (UCHAR*)WdfMemoryGetBuffer(hMem, 0);
KDBG(DPFLTR_TRACE_LEVEL, "write offset: %hd", *(WORD*)lpBuf);
// 把当前的Request对象进行重利用，发送给USB总线。
// 格式化Request对象，设置Pipe句柄、完成函数等。
status = WdfUsbTargetPipeFormatRequestForWrite(BulkOutputPipe, Request, hMem, NULL);
if(!NT_SUCCESS(status))
{
KDBG(DPFLTR_ERROR_LEVEL, "WdfUsbTargetPipeFormatRequestForWrite(status 0x%0.8x)!!!", status);
WdfRequestComplete(Request, status);
return;
}
WdfRequestSetCompletionRoutine(Request, BulkWriteComplete, BulkOutputPipe);
if(FALSE == WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(BulkOutputPipe), NULL))
{
status = WdfRequestGetStatus(Request);
KDBG(DPFLTR_ERROR_LEVEL, "WdfRequestSend failed with status 0x%0.8x\n", status);
WdfRequestComplete(Request, status);
}
}
VOID
EvtIoWrite(
IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN size_t Length
)
{
NTSTATUS status;
WDFUSBPIPE pipe;
WDFMEMORY reqMemory;
PDEVICE_CONTEXT pDeviceContext;
BOOLEAN ret;
UNREFERENCED_PARAMETER(Length);
pDeviceContext = GetDeviceContext(WdfIoQueueGetDevice(Queue));
pipe = pDeviceContext->BulkWritePipe;
status = WdfRequestRetrieveInputMemory(Request, &reqMemory);
if(!NT_SUCCESS(status)){
goto Exit;
}
status = WdfUsbTargetPipeFormatRequestForWrite(pipe,
Request,
reqMemory,
NULL); // Offset
if (!NT_SUCCESS(status)) {
goto Exit;
}
WdfRequestSetCompletionRoutine(
Request,
EvtRequestWriteCompletionRoutine,
pipe);
ret = WdfRequestSend(Request,
WdfUsbTargetPipeGetIoTarget(pipe),
WDF_NO_SEND_OPTIONS);
if (ret == FALSE) {
status = WdfRequestGetStatus(Request);
goto Exit;
} else {
return;
}
Exit:
WdfRequestCompleteWithInformation(Request, status, 0);
return;
}
VOID
OsrFxEvtIoWrite(
_In_ WDFQUEUE Queue,
_In_ WDFREQUEST Request,
_In_ size_t Length
)
/*++
Routine Description:
Called by the framework when it receives Read or Write requests.
Arguments:
Queue - Default queue handle
Request - Handle to the read/write request
Lenght - Length of the data buffer associated with the request.
The default property of the queue is to not dispatch
zero lenght read & write requests to the driver and
complete is with status success. So we will never get
a zero length request.
Return Value:
--*/
{
NTSTATUS status;
WDFUSBPIPE pipe;
WDFMEMORY reqMemory;
PDEVICE_CONTEXT pDeviceContext;
GUID activity = RequestToActivityId(Request);
UNREFERENCED_PARAMETER(Queue);
//
// Log write start event, using IRP activity ID if available or request
// handle otherwise.
//
EventWriteWriteStart(&activity, WdfIoQueueGetDevice(Queue), (ULONG)Length);
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_WRITE, "-->OsrFxEvtIoWrite\n");
//
// First validate input parameters.
//
if (Length > TEST_BOARD_TRANSFER_BUFFER_SIZE) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_READ, "Transfer exceeds %d\n",
TEST_BOARD_TRANSFER_BUFFER_SIZE);
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
pDeviceContext = GetDeviceContext(WdfIoQueueGetDevice(Queue));
pipe = pDeviceContext->BulkWritePipe;
status = WdfRequestRetrieveInputMemory(Request, &reqMemory);
if(!NT_SUCCESS(status)){
TraceEvents(TRACE_LEVEL_ERROR, DBG_WRITE, "WdfRequestRetrieveInputBuffer failed\n");
goto Exit;
}
status = WdfUsbTargetPipeFormatRequestForWrite(pipe,
Request,
reqMemory,
NULL); // Offset
if (!NT_SUCCESS(status)) {
TraceEvents(TRACE_LEVEL_ERROR, DBG_WRITE,
"WdfUsbTargetPipeFormatRequest failed 0x%x\n", status);
goto Exit;
}
WdfRequestSetCompletionRoutine(
Request,
EvtRequestWriteCompletionRoutine,
pipe);
//
// Send the request asynchronously.
//
if (WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(pipe), WDF_NO_SEND_OPTIONS) == FALSE) {
//
// Framework couldn't send the request for some reason.
//
TraceEvents(TRACE_LEVEL_ERROR, DBG_WRITE, "WdfRequestSend failed\n");
status = WdfRequestGetStatus(Request);
goto Exit;
}
Exit:
if (!NT_SUCCESS(status)) {
//
// log event write failed
//
EventWriteWriteFail(&activity, WdfIoQueueGetDevice(Queue), status);
WdfRequestCompleteWithInformation(Request, status, 0);
}
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_WRITE, "<-- OsrFxEvtIoWrite\n");
return;
}
///////////////////////////////////////////////////////////////////////////////
//
// BasicUsbEvtWrite
//
// This routine is called by the framework when there is a
// write request for us to process
//
// INPUTS:
//
// Queue - Our default queue
//
// Request - A write request
//
// Length - The length of the write operation
//
// OUTPUTS:
//
// None.
//
// RETURNS:
//
// None.
//
// IRQL:
//
// This routine is called at IRQL == PASSIVE_LEVEL, due to
// our PASSIVE_LEVEL execution level contraint
//
// NOTES:
//
//
///////////////////////////////////////////////////////////////////////////////
VOID
BasicUsbEvtWrite(WDFQUEUE Queue, WDFREQUEST Request, size_t Length)
{
PBASICUSB_DEVICE_CONTEXT devContext;
WDFMEMORY requestMemory;
NTSTATUS status;
WDF_REQUEST_PARAMETERS requestParams;
WDF_REQUEST_SEND_OPTIONS sendOptions;
UNREFERENCED_PARAMETER(Length);
#if DBG
DbgPrint("BasicUsbEvtWrite\n");
#endif
devContext = BasicUsbGetContextFromDevice(
WdfIoQueueGetDevice(Queue) );
//
// The purpose of this routine will be to convert the write
// that we received from the user into a USB request and send
// it to the underlying bus driver.
//
//
// First thing to do is get the input memory associated with the
// request (only because it's a required parameter to
// WdfUsbTargetPipeFormatRequestForWrite)
//
status = WdfRequestRetrieveInputMemory(Request,
&requestMemory);
if(!NT_SUCCESS(status)){
#if DBG
DbgPrint("WdfRequestRetrieveInputMemory failed 0x%0x\n", status);
#endif
WdfRequestComplete(Request, status);
return;
}
//
// Take the user Write request and format it into a Bulk OUT
// request.
//
status = WdfUsbTargetPipeFormatRequestForWrite(devContext->BulkOutPipe,
Request,
requestMemory,
NULL);
if(!NT_SUCCESS(status)){
#if DBG
DbgPrint("WdfUsbTargetPipeFormatRequestForWrite failed 0x%0x\n",
status);
#endif
WdfRequestComplete(Request, status);
return;
}
//
// We'd like to asynchronously send this newly formatted request
// to the underlying bus driver. In order to do that, we *must*
// supply a completion routine that calls WdfRequestComplete.
// Failure to do so is not architecturally defined, which means
// it ain't gonna work.
//
// Note that because we have modified the request, we are not
// allowed to use the WDF_REQUEST_SEND_OPTION_SEND_AND_FORGET
// flag as a cheap shortcut, we MUST supply the completion
// routine.
//
WdfRequestSetCompletionRoutine(Request,
BasicUsbEvtRequestWriteCompletionRoutine,
NULL);
//
// Send the request!
//
if (!WdfRequestSend(Request,
WdfUsbTargetPipeGetIoTarget(devContext->BulkOutPipe),
NULL)) {
//
// Bad news. The target didn't get the request, so get the
// failure status and complete the request ourselves..
//
status = WdfRequestGetStatus(Request);
#if DBG
DbgPrint("WdfRequestSend failed 0x%0x\n", status);
#endif
WdfRequestComplete(Request, status);
return;
}
return;
}
VOID
UsbSamp_EvtReadWriteCompletion(
_In_ WDFREQUEST Request,
_In_ WDFIOTARGET Target,
PWDF_REQUEST_COMPLETION_PARAMS CompletionParams,
_In_ WDFCONTEXT Context
)
/*++
Routine Description:
This is the completion routine for reads/writes
If the irp completes with success, we check if we
need to recirculate this irp for another stage of
transfer.
Arguments:
Context - Driver supplied context
Device - Device handle
Request - Request handle
Params - request completion params
Return Value:
None
--*/
{
WDFUSBPIPE pipe;
ULONG stageLength = 0;
NTSTATUS status;
PREQUEST_CONTEXT rwContext;
ULONG bytesReadWritten;
WDFMEMORY_OFFSET offset;
PCHAR operation;
PWDF_USB_REQUEST_COMPLETION_PARAMS usbCompletionParams;
PPIPE_CONTEXT pipeContext;
WDF_USB_PIPE_INFORMATION pipeInfo;
ULONG maxTransferSize;
PDEVICE_CONTEXT deviceContext;
usbCompletionParams = CompletionParams->Parameters.Usb.Completion;
rwContext = GetRequestContext(Request);
deviceContext = Context;
if (rwContext->Read) {
operation = "Read";
bytesReadWritten = (ULONG)usbCompletionParams->Parameters.PipeRead.Length;
}
else {
operation = "Write";
bytesReadWritten = (ULONG)usbCompletionParams->Parameters.PipeWrite.Length;
}
pipe = (WDFUSBPIPE) Target;
pipeContext = GetPipeContext(pipe);
WDF_USB_PIPE_INFORMATION_INIT(&pipeInfo);
WdfUsbTargetPipeGetInformation(pipe,&pipeInfo);
status = CompletionParams->IoStatus.Status;
if (!NT_SUCCESS(status)){
//
// Queue a workitem to reset the pipe because the completion could be
// running at DISPATCH_LEVEL.
// TODO: preallocate per pipe workitem to avoid allocation failure.
QueuePassiveLevelCallback(WdfIoTargetGetDevice(Target), pipe);
goto End;
}
rwContext->Numxfer += bytesReadWritten;
//
// If there is anything left to transfer.
//
if (rwContext->Length == 0) {
//
// this is the last transfer
//
WdfRequestSetInformation(Request, rwContext->Numxfer);
goto End;
}
//
// Start another transfer
//
UsbSamp_DbgPrint(3, ("Stage next %s transfer...\n", operation));
//
// The transfer request is for totalLength.
// We can perform a max of maxTransfersize in each stage.
//
maxTransferSize = GetMaxTransferSize(pipe, deviceContext);
if (rwContext->Length > maxTransferSize) {
stageLength = maxTransferSize;
}
else
{
stageLength = rwContext->Length;
}
offset.BufferOffset = rwContext->Numxfer;
offset.BufferLength = stageLength;
rwContext->Length -= stageLength;
if (rwContext->Read) {
status = WdfUsbTargetPipeFormatRequestForRead(
pipe,
Request,
usbCompletionParams->Parameters.PipeRead.Buffer,
&offset);
}
else {
status = WdfUsbTargetPipeFormatRequestForWrite(
pipe,
Request,
usbCompletionParams->Parameters.PipeWrite.Buffer,
&offset);
}
if (!NT_SUCCESS(status)) {
UsbSamp_DbgPrint(1, ("WdfUsbTargetPipeFormat%sRequest failed 0x%x\n",
operation, status));
goto End;
}
#if (NTDDI_VERSION >= NTDDI_WIN8)
//
// If the request is for a super speed bulk pipe with streams,
// configure its urb's PipeHandle with its associated stream's PipeHandle
//
if(WdfUsbPipeTypeBulk == pipeInfo.PipeType &&
pipeContext->StreamConfigured == TRUE) {
ConfigureStreamPipeHandleForRequest(Request, pipe);
}
#endif
WdfRequestSetCompletionRoutine(
Request,
UsbSamp_EvtReadWriteCompletion,
deviceContext);
//
// Send the request asynchronously.
//
if (!WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(pipe), WDF_NO_SEND_OPTIONS)) {
UsbSamp_DbgPrint(1, ("WdfRequestSend for %s failed\n", operation));
status = WdfRequestGetStatus(Request);
goto End;
}
//
// Else when the request completes, this completion routine will be
// called again.
//
return;
End:
//
// We are here because the request failed or some other call failed.
// Dump the request context, complete the request and return.
//
DbgPrintRWContext(rwContext);
UsbSamp_DbgPrint(3, ("%s request completed with status 0x%x\n",
operation, status));
WdfRequestComplete(Request, status);
return;
}
VOID
ReadWriteBulkEndPoints(
_In_ WDFQUEUE Queue,
_In_ WDFREQUEST Request,
_In_ ULONG Length,
_In_ WDF_REQUEST_TYPE RequestType
)
/*++
Routine Description:
This callback is invoked when the framework received WdfRequestTypeRead or
RP_MJ_WRITE request. This read/write is performed in stages of
maximum transfer size. Once a stage of transfer is complete, then the
request is circulated again, until the requested length of transfer is
performed.
Arguments:
Queue - Handle to the framework queue object that is associated
with the I/O request.
Request - Handle to a framework request object. This one represents
the WdfRequestTypeRead/WdfRequestTypeWrite IRP received by the framework.
Length - Length of the input/output buffer.
Return Value:
VOID
--*/
{
size_t totalLength = Length;
size_t stageLength = 0;
NTSTATUS status;
PVOID virtualAddress = 0;
PREQUEST_CONTEXT rwContext = NULL;
PFILE_CONTEXT fileContext = NULL;
WDFUSBPIPE pipe;
WDF_USB_PIPE_INFORMATION pipeInfo;
WDFMEMORY reqMemory;
WDFMEMORY_OFFSET offset;
WDF_OBJECT_ATTRIBUTES objectAttribs;
PDEVICE_CONTEXT deviceContext;
PPIPE_CONTEXT pipeContext;
ULONG maxTransferSize;
UsbSamp_DbgPrint(3, ("UsbSamp_DispatchReadWrite - begins\n"));
//
// First validate input parameters.
//
deviceContext = GetDeviceContext(WdfIoQueueGetDevice(Queue));
if (totalLength > deviceContext->MaximumTransferSize) {
UsbSamp_DbgPrint(1, ("Transfer length > circular buffer\n"));
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
if ((RequestType != WdfRequestTypeRead) &&
(RequestType != WdfRequestTypeWrite)) {
UsbSamp_DbgPrint(1, ("RequestType has to be either Read or Write\n"));
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
//
// Get the pipe associate with this request.
//
fileContext = GetFileContext(WdfRequestGetFileObject(Request));
pipe = fileContext->Pipe;
pipeContext = GetPipeContext(pipe);
WDF_USB_PIPE_INFORMATION_INIT(&pipeInfo);
WdfUsbTargetPipeGetInformation(pipe, &pipeInfo);
rwContext = GetRequestContext(Request);
if (RequestType == WdfRequestTypeRead) {
status = WdfRequestRetrieveOutputBuffer(Request, Length, &virtualAddress, &totalLength);
rwContext->Read = TRUE;
}
else { //Write
status = WdfRequestRetrieveInputBuffer(Request, Length, &virtualAddress, &totalLength);
rwContext->Read = FALSE;
}
if (!NT_SUCCESS(status)){
UsbSamp_DbgPrint(1, ("WdfRequestRetrieveInputBuffer failed\n"));
goto Exit;
}
//
// The transfer request is for totalLength.
// We can perform a max of maxTransfersize in each stage.
//
maxTransferSize = GetMaxTransferSize(pipe, deviceContext);
if (totalLength > maxTransferSize) {
stageLength = maxTransferSize;
}
else {
stageLength = totalLength;
}
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttribs);
objectAttribs.ParentObject = Request;
status = WdfMemoryCreatePreallocated(&objectAttribs,
virtualAddress,
totalLength,
&reqMemory);
if (!NT_SUCCESS(status)){
UsbSamp_DbgPrint(1, ("WdfMemoryCreatePreallocated failed\n"));
goto Exit;
}
offset.BufferOffset = 0;
offset.BufferLength = stageLength;
//
// The framework format call validates to make sure that you are reading or
// writing to the right pipe type, sets the appropriate transfer flags,
// creates an URB and initializes the request.
//
if (RequestType == WdfRequestTypeRead) {
UsbSamp_DbgPrint(3, ("Read operation\n"));
status = WdfUsbTargetPipeFormatRequestForRead(pipe,
Request,
reqMemory,
&offset);
}
else {
UsbSamp_DbgPrint(3, ("Write operation\n"));
status = WdfUsbTargetPipeFormatRequestForWrite(pipe,
Request,
reqMemory,
&offset);
}
if (!NT_SUCCESS(status)) {
UsbSamp_DbgPrint(1, ("WdfUsbTargetPipeFormatRequest failed 0x%x\n", status));
goto Exit;
}
#if (NTDDI_VERSION >= NTDDI_WIN8)
//
// If the request is for a super speed bulk pipe with streams,
// configure its urb's PipeHandle with its associated stream's PipeHandle
//
if(WdfUsbPipeTypeBulk == pipeInfo.PipeType &&
pipeContext->StreamConfigured == TRUE) {
ConfigureStreamPipeHandleForRequest(Request, pipe);
}
#endif
WdfRequestSetCompletionRoutine(
Request,
UsbSamp_EvtReadWriteCompletion,
deviceContext);
//
// set REQUEST_CONTEXT parameters.
//
rwContext->Length = (ULONG)totalLength - (ULONG)stageLength;
rwContext->Numxfer = 0;
//
// Send the request asynchronously.
//
if (WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(pipe), WDF_NO_SEND_OPTIONS) == FALSE) {
UsbSamp_DbgPrint(1, ("WdfRequestSend failed\n"));
status = WdfRequestGetStatus(Request);
goto Exit;
}
Exit:
if (!NT_SUCCESS(status)) {
WdfRequestCompleteWithInformation(Request, status, 0);
}
UsbSamp_DbgPrint(3, ("UsbSamp_DispatchReadWrite - ends\n"));
return;
}
VOID
ReadWriteCompletion(
IN WDFREQUEST Request,
IN WDFIOTARGET Target,
PWDF_REQUEST_COMPLETION_PARAMS CompletionParams,
IN WDFCONTEXT Context
)
/*++
Routine Description:
This is the completion routine for reads/writes
If the irp completes with success, we check if we
need to recirculate this irp for another stage of
transfer.
Arguments:
Context - Driver supplied context
Device - Device handle
Request - Request handle
Params - request completion params
Return Value:
None
--*/
{
WDFUSBPIPE pipe;
ULONG stageLength;
NTSTATUS status;
PREQUEST_CONTEXT rwContext;
ULONG bytesReadWritten;
WDFMEMORY_OFFSET offset;
PCHAR operation;
PWDF_USB_REQUEST_COMPLETION_PARAMS usbCompletionParams;
UNREFERENCED_PARAMETER(Context);
rwContext = GetRequestContext(Request);
usbCompletionParams = CompletionParams->Parameters.Usb.Completion;
rwContext = GetRequestContext(Request);
if (rwContext->Read) {
operation = "Read";
bytesReadWritten = usbCompletionParams->Parameters.PipeRead.Length;
} else {
operation = "Write";
bytesReadWritten = usbCompletionParams->Parameters.PipeWrite.Length;
}
pipe = (WDFUSBPIPE) Target;
status = CompletionParams->IoStatus.Status;
if (!NT_SUCCESS(status)){
//
// Queue a workitem to reset the pipe because the completion could be
// running at DISPATCH_LEVEL.
// TODO: preallocate per pipe workitem to avoid allocation failure.
QueuePassiveLevelCallback(WdfIoTargetGetDevice(Target), pipe);
goto End;
}
rwContext->Numxfer += bytesReadWritten;
//
// If there is anything left to transfer.
//
if (rwContext->Length == 0) {
//
// this is the last transfer
//
WdfRequestSetInformation(Request, rwContext->Numxfer);
goto End;
}
//
// Start another transfer
//
kJtag_DbgPrint(3, ("Stage next %s transfer...\n", operation));
if (rwContext->Length > MAX_TRANSFER_SIZE) {
stageLength = MAX_TRANSFER_SIZE;
}
else {
stageLength = rwContext->Length;
}
offset.BufferOffset = rwContext->Numxfer;
offset.BufferLength = stageLength;
rwContext->Length -= stageLength;
if (rwContext->Read) {
status = WdfUsbTargetPipeFormatRequestForRead(
pipe,
Request,
usbCompletionParams->Parameters.PipeRead.Buffer,
&offset);
} else {
status = WdfUsbTargetPipeFormatRequestForWrite(
pipe,
Request,
usbCompletionParams->Parameters.PipeWrite.Buffer,
&offset);
}
if (!NT_SUCCESS(status)) {
kJtag_DbgPrint(1, ("WdfUsbTargetPipeFormat%sRequest failed 0x%x\n",
operation, status));
goto End;
}
WdfRequestSetCompletionRoutine(
Request,
ReadWriteCompletion,
NULL);
//
// Send the request asynchronously.
//
if (!WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(pipe), WDF_NO_SEND_OPTIONS)) {
kJtag_DbgPrint(1, ("WdfRequestSend for %s failed\n", operation));
status = WdfRequestGetStatus(Request);
goto End;
}
//
// Else when the request completes, this completion routine will be
// called again.
//
return;
End:
//
// We are here because the request failed or some other call failed.
// Dump the request context, complete the request and return.
//
DbgPrintRWContext(rwContext);
kJtag_DbgPrint(3, ("%s request completed with status 0x%x\n",
operation, status));
WdfRequestComplete(Request, status);
return;
}
VOID
ReadWriteBulkEndPoints(
IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN ULONG Length,
IN WDF_REQUEST_TYPE RequestType
)
/*++
Routine Description:
This callback is invoked when the framework received WdfRequestTypeRead or
RP_MJ_WRITE request. This read/write is performed in stages of
MAX_TRANSFER_SIZE. Once a stage of transfer is complete, then the
request is circulated again, until the requested length of transfer is
performed.
Arguments:
Queue - Handle to the framework queue object that is associated
with the I/O request.
Request - Handle to a framework request object. This one represents
the WdfRequestTypeRead/WdfRequestTypeWrite IRP received by the framework.
Length - Length of the input/output buffer.
Return Value:
VOID
--*/
{
size_t totalLength = Length;
size_t stageLength = 0;
NTSTATUS status;
PVOID virtualAddress = 0;
PREQUEST_CONTEXT rwContext = NULL;
PFILE_CONTEXT fileContext = NULL;
WDFUSBPIPE pipe;
WDFMEMORY reqMemory;
WDFMEMORY_OFFSET offset;
WDF_OBJECT_ATTRIBUTES objectAttribs;
PDEVICE_CONTEXT deviceContext;
kJtag_DbgPrint(3, ("kJtag_DispatchReadWrite - begins\n"));
//
// First validate input parameters.
//
deviceContext = GetDeviceContext(WdfIoQueueGetDevice(Queue));
if (totalLength > deviceContext->MaximumTransferSize) {
kJtag_DbgPrint(1, ("Transfer length > circular buffer\n"));
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
if ((RequestType != WdfRequestTypeRead) &&
(RequestType != WdfRequestTypeWrite)) {
kJtag_DbgPrint(1, ("RequestType has to be either Read or Write\n"));
status = STATUS_INVALID_PARAMETER;
goto Exit;
}
//
// Get the pipe associate with this request.
//
fileContext = GetFileContext(WdfRequestGetFileObject(Request));
pipe = fileContext->Pipe;
rwContext = GetRequestContext(Request);
if(RequestType == WdfRequestTypeRead) {
status = WdfRequestRetrieveOutputBuffer(Request, Length, &virtualAddress, &totalLength);
rwContext->Read = TRUE;
} else { //Write
status = WdfRequestRetrieveInputBuffer(Request, Length, &virtualAddress, &totalLength);
rwContext->Read = FALSE;
}
if(!NT_SUCCESS(status)){
kJtag_DbgPrint(1, ("WdfRequestRetrieveInputBuffer failed\n"));
goto Exit;
}
//
// If the totalLength exceeds MAX_TRANSFER_SIZE, we will break
// that into multiple transfer of size no more than MAX_TRANSFER_SIZE
// in each stage.
//
if (totalLength > MAX_TRANSFER_SIZE) {
stageLength = MAX_TRANSFER_SIZE;
}
else {
stageLength = totalLength;
}
WDF_OBJECT_ATTRIBUTES_INIT(&objectAttribs);
objectAttribs.ParentObject = Request;
status = WdfMemoryCreatePreallocated(&objectAttribs,
virtualAddress,
totalLength,
&reqMemory);
if(!NT_SUCCESS(status)){
kJtag_DbgPrint(1, ("WdfMemoryCreatePreallocated failed\n"));
goto Exit;
}
offset.BufferOffset = 0;
offset.BufferLength = stageLength;
//
// The framework format call validates to make sure that you are reading or
// writing to the right pipe type, sets the appropriate transfer flags,
// creates an URB and initializes the request.
//
if(RequestType == WdfRequestTypeRead) {
kJtag_DbgPrint(3, ("Read operation\n"));
status = WdfUsbTargetPipeFormatRequestForRead(pipe,
Request,
reqMemory,
&offset);
} else {
kJtag_DbgPrint(3, ("Write operation\n"));
status = WdfUsbTargetPipeFormatRequestForWrite(pipe,
Request,
reqMemory,
&offset);
}
if (!NT_SUCCESS(status)) {
kJtag_DbgPrint(1, ("WdfUsbTargetPipeFormatRequest failed 0x%x\n", status));
goto Exit;
}
WdfRequestSetCompletionRoutine(
Request,
ReadWriteCompletion,
NULL);
//
// set REQUEST_CONTEXT parameters.
//
rwContext->Length = totalLength - stageLength;
rwContext->Numxfer = 0;
//
// Send the request asynchronously.
//
if (WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(pipe), WDF_NO_SEND_OPTIONS) == FALSE) {
kJtag_DbgPrint(1, ("WdfRequestSend failed\n"));
status = WdfRequestGetStatus(Request);
goto Exit;
}
Exit:
if (!NT_SUCCESS(status)) {
WdfRequestCompleteWithInformation(Request, status, 0);
}
kJtag_DbgPrint(3, ("kJtag_DispatchReadWrite - ends\n"));
return;
}
