VOID
XenUsb_EvtRequestCancelPvUrb(WDFREQUEST request) {
WDFDEVICE device = WdfIoQueueGetDevice(WdfRequestGetIoQueue(request));
PXENUSB_DEVICE_DATA xudd = GetXudd(device);
WDF_REQUEST_PARAMETERS wrp;
partial_pvurb_t *partial_pvurb;
pvurb_t *pvurb;
KIRQL old_irql;
FUNCTION_ENTER();
FUNCTION_MSG("cancelling request %p\n", request);
WDF_REQUEST_PARAMETERS_INIT(&wrp);
KeAcquireSpinLock(&xudd->urb_ring_lock, &old_irql);
WdfRequestGetParameters(request, &wrp);
pvurb = (pvurb_t *)wrp.Parameters.Others.Arg1;
FUNCTION_MSG("pvurb = %p\n", pvurb);
ASSERT(pvurb);
partial_pvurb = (partial_pvurb_t *)xudd->partial_pvurb_queue.Flink;
while (partial_pvurb != (partial_pvurb_t *)&xudd->partial_pvurb_queue) {
partial_pvurb_t *next_partial_pvurb = (partial_pvurb_t *)partial_pvurb->entry.Flink;
ASSERT(!partial_pvurb->on_ring);
FUNCTION_MSG("partial_pvurb = %p is not yet on ring\n", partial_pvurb);
RemoveEntryList(&partial_pvurb->entry);
ExFreePoolWithTag(partial_pvurb, XENUSB_POOL_TAG);
pvurb->ref--;
partial_pvurb = next_partial_pvurb;
}
partial_pvurb = (partial_pvurb_t *)xudd->partial_pvurb_ring.Flink;
while (partial_pvurb != (partial_pvurb_t *)&xudd->partial_pvurb_ring) {
partial_pvurb_t *next_partial_pvurb = (partial_pvurb_t *)partial_pvurb->entry.Flink;
partial_pvurb_t *partial_pvurb_cancel;
FUNCTION_MSG("partial_pvurb = %p is on ring\n", partial_pvurb);
ASSERT(partial_pvurb->on_ring);
partial_pvurb_cancel = ExAllocatePoolWithTag(NonPagedPool, sizeof(*partial_pvurb_cancel), XENUSB_POOL_TAG); /* todo - use lookaside */
ASSERT(partial_pvurb_cancel); /* what would we do if this failed? */
partial_pvurb_cancel->req = partial_pvurb->req;
partial_pvurb_cancel->req.pipe = usbif_setunlink_pipe(partial_pvurb_cancel->req.pipe);
partial_pvurb_cancel->req.u.unlink.unlink_id = partial_pvurb->req.id;
partial_pvurb_cancel->pvurb = pvurb;
partial_pvurb_cancel->mdl = NULL;
partial_pvurb_cancel->other_partial_pvurb = partial_pvurb;
partial_pvurb->other_partial_pvurb = partial_pvurb_cancel;
partial_pvurb_cancel->on_ring = FALSE;
pvurb->ref++;
InsertHeadList(&xudd->partial_pvurb_queue, &partial_pvurb_cancel->entry);
partial_pvurb = next_partial_pvurb;
}
if (pvurb->ref) {
PutRequestsOnRing(xudd);
KeReleaseSpinLock(&xudd->urb_ring_lock, old_irql);
} else {
KeReleaseSpinLock(&xudd->urb_ring_lock, old_irql);
WdfRequestComplete(request, STATUS_CANCELLED);
}
FUNCTION_EXIT();
}
NTSTATUS PciDtfDeviceReadWriteReg(IN WDFDEVICE Device, IN WDFREQUEST Request,
IN BOOLEAN Read)
{
PCIDTF_REG_DATA *ReqData;
PREG_SPACE_DATA RegSpaceData;
WDFOBJECT RegSpace;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PCIDTF_REG_DATA),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
Status = PciDtfRegSpaceGet(Device, ReqData->bar, &RegSpace);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfRegSpaceGet", Status);
__leave;
}
RegSpaceData = GetRegSpaceData(RegSpace);
if (Read) {
Status = WdfRequestRetrieveOutputBuffer(Request,
sizeof
(PCIDTF_REG_DATA),
(PVOID *) &
ReqData, NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveOutputBuffer",
Status);
__leave;
}
Status = PciDtfRegSpaceRead(RegSpaceData,
ReqData->off, ReqData->len,
&ReqData->val);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfRegSpaceRead", Status);
__leave;
}
WdfRequestSetInformation(Request,
sizeof(PCIDTF_REG_DATA));
} else {
Status = PciDtfRegSpaceWrite(RegSpaceData,
ReqData->off, ReqData->len,
ReqData->val);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfRegSpaceWrite", Status);
__leave;
}
}
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
//
// Internal Function: UartCtlSetChars
//
VOID
UartCtlSetChars(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_CHARS pSpecialChars = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveInputBuffer(Request,
sizeof(SERIAL_CHARS),
(PVOID*)(& pSpecialChars),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve input buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
//
// Software flow control and in-band signaling
// have not been implemented in this sample. Characters
// are not checked for valid range or values.
//
pDevExt->SpecialChars.EofChar = pSpecialChars->EofChar;
pDevExt->SpecialChars.ErrorChar = pSpecialChars->ErrorChar;
pDevExt->SpecialChars.BreakChar = pSpecialChars->BreakChar;
pDevExt->SpecialChars.EventChar = pSpecialChars->EventChar;
pDevExt->SpecialChars.XonChar = pSpecialChars->XonChar;
pDevExt->SpecialChars.XoffChar = pSpecialChars->XoffChar;
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
// Called when NfcCx has an NCI packet it wishes to sent to the device.
void
DeviceContext::WriteNciPacket(
_In_ WDFREQUEST Request
)
{
TRACE_FUNCTION_ENTRY(LEVEL_VERBOSE);
NTSTATUS status;
// Get NCI packet.
void* nciBuffer;
size_t nciLength;
status = WdfRequestRetrieveInputBuffer(Request, 0, &nciBuffer, &nciLength);
if (!NT_SUCCESS(status))
{
TRACE_LINE(LEVEL_ERROR, "Failed to read input buffer. %!STATUS!", status);
WdfRequestComplete(Request, status);
return;
}
WdfWaitLockAcquire(_ClientLock, nullptr);
if (_NciWriteRequest != nullptr)
{
status = STATUS_INVALID_DEVICE_STATE;
TRACE_LINE(LEVEL_ERROR, "A pending NCI write already exists. %!STATUS!", status);
WdfWaitLockRelease(_ClientLock);
WdfRequestComplete(Request, status);
return;
}
// Post NCI write callback.
status = _ApiCallbacksManager.PostNciWriteCallback(nciBuffer, nciLength);
if (!NT_SUCCESS(status))
{
TRACE_LINE(LEVEL_ERROR, "CallbacksManager::PostNciWriteCallback failed. %!STATUS!", status);
WdfWaitLockRelease(_ClientLock);
WdfRequestComplete(Request, status);
return;
}
_NciWriteRequest = Request;
WdfWaitLockRelease(_ClientLock);
TRACE_FUNCTION_SUCCESS(LEVEL_VERBOSE);
}
VOID
DefaultQueue_EvtIoDeviceControl(
_In_ WDFQUEUE Queue,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength,
_In_ ULONG IoControlCode
)
/*++
Routine Description:
EvtIoDeviceControl handler for the default Queue
Arguments:
Queue - Handle to the framework queue object that is associated with the
I/O request.
Request - Handle to a framework request object.
OutputBufferLength - Size of the output buffer in bytes
InputBufferLength - Size of the input buffer in bytes
IoControlCode - I/O control code.
--*/
{
WDFDEVICE WdfDevice;
PCONTROLLER_CONTEXT ControllerContext;
BOOLEAN HandledbyUfx;
TraceEntry();
TraceVerbose("Queue 0x%p, Request 0x%p, OutputBufferLength %d, "
"InputBufferLength %d, IoControlCode %d",
Queue, Request, (int) OutputBufferLength,
(int) InputBufferLength, IoControlCode);
WdfDevice = WdfIoQueueGetDevice(Queue);
ControllerContext = DeviceGetControllerContext(WdfDevice);
HandledbyUfx = UfxDeviceIoControl(
ControllerContext->UfxDevice,
Request,
OutputBufferLength,
InputBufferLength,
IoControlCode);
if (!HandledbyUfx) {
TraceError("Recieved an unsupported IOCTL");
WdfRequestComplete(Request, STATUS_INVALID_DEVICE_REQUEST);
}
TraceExit();
}
void AndroidUsbFileObject::OnEvtIoDeviceControl(WDFREQUEST request,
size_t output_buf_len,
size_t input_buf_len,
ULONG ioctl_code) {
ASSERT_IRQL_LOW_OR_DISPATCH();
ASSERT(WdfRequestGetFileObject(request) == wdf_file());
WdfRequestComplete(request, STATUS_INVALID_DEVICE_REQUEST);
}
VOID
NfcCxSCPresentAbsentDispatcherRequestCanceled(
_In_ WDFREQUEST Request
)
/*++
Routine Description:
Called when a pending request has been canceled.
Arguments:
Request - The request
Return Value:
NTSTATUS
--*/
{
TRACE_FUNCTION_ENTRY(LEVEL_VERBOSE);
WDFFILEOBJECT fileObject = WdfRequestGetFileObject(Request);
WDFDEVICE device = WdfFileObjectGetDevice(fileObject);
PNFCCX_FILE_CONTEXT fileContext = NfcCxFileGetContext(fileObject);
PNFCCX_FDO_CONTEXT fdoContext = NfcCxFdoGetContext(device);
PNFCCX_SC_REQUEST_CONTEXT requestContext = NfcCxSCGetRequestContext(Request);
PNFCCX_SC_PRESENT_ABSENT_DISPATCHER dispatcher = requestContext->Dispatcher;
// Remove this request from the dispatcher
void* previousRequest = InterlockedCompareExchangePointer((void**)&dispatcher->CurrentRequest, /*exchange*/ nullptr, /*compare*/ Request);
// Check if another thread has already completed the request.
if (previousRequest != Request)
{
// Request already completed by a different thread.
// Nothing to do.
goto Done;
}
// Release power reference (if required).
if (dispatcher->PowerManaged)
{
NfcCxPowerFileRemoveReference(fdoContext->Power, fileContext, NfcCxPowerReferenceType_Proximity);
}
// Complete the request.
TRACE_LINE(LEVEL_ERROR, "Smartcard Present/Absent request canceled. %!STATUS!", STATUS_CANCELLED);
WdfRequestComplete(Request, STATUS_CANCELLED);
Done:
// Release the cancel callback's extra ref-count
WdfObjectDereference(Request);
TRACE_FUNCTION_EXIT(LEVEL_VERBOSE);
}
VOID PVPanicEvtDeviceFileCreate(IN WDFDEVICE Device,
IN WDFREQUEST Request,
IN WDFFILEOBJECT FileObject)
{
UNREFERENCED_PARAMETER(Device);
UNREFERENCED_PARAMETER(FileObject);
WdfRequestComplete(Request, STATUS_ACCESS_DENIED);
}
// Bulk管道读操作
//
VOID BulkRead(IN WDFQUEUE Queue, IN WDFREQUEST Request, IN size_t Length)
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_CONTEXT pContext = NULL;
WDFUSBPIPE BulkInputPipe;
WDFMEMORY hMem;
WDFDEVICE hDevice = WdfIoQueueGetDevice(Queue);
KDBG(DPFLTR_INFO_LEVEL, "[BulkRead] size: %d", Length);
// 取管道
pContext = GetDeviceContext(hDevice);
BulkInputPipe = GetBulkPipe(TRUE, hDevice);
if(NULL == BulkInputPipe){
WdfRequestComplete(Request, STATUS_UNSUCCESSFUL);
return;
}
status = WdfRequestRetrieveOutputMemory(Request, &hMem);
if(!NT_SUCCESS(status))
{
KDBG(DPFLTR_INFO_LEVEL, "WdfRequestRetrieveOutputMemory failed with status 0x%0.8x!!!", status);
WdfRequestComplete(Request, status);
return;
}
// 和写一样，仍然是对Request对象的重利用
// 除了重利用外，也可以新建一个Request对象。新建的方法在本工程其他地方用得较多。
status = WdfUsbTargetPipeFormatRequestForRead(BulkInputPipe, Request, hMem, NULL);
if(!NT_SUCCESS(status))
{
KDBG(DPFLTR_INFO_LEVEL, "WdfUsbTargetPipeFormatRequestForRead failed with status 0x%08x\n", status);
WdfRequestComplete(Request, status);
return;
}
WdfRequestSetCompletionRoutine(Request, BulkReadComplete, BulkInputPipe);
if(FALSE == WdfRequestSend(Request, WdfUsbTargetPipeGetIoTarget(pContext->UsbBulkInPipe), NULL))
{
status = WdfRequestGetStatus(Request);
KDBG(DPFLTR_INFO_LEVEL, "WdfRequestSend failed with status 0x%08x\n", status);
WdfRequestComplete(Request, status);
}
}
VOID
OnTopLevelIoDefault(
_In_ WDFQUEUE FxQueue,
_In_ WDFREQUEST FxRequest
)
/*++
Routine Description:
Accepts all incoming requests and pends or forwards appropriately.
Arguments:
FxQueue - Handle to the framework queue object that is associated with the
I/O request.
FxRequest - Handle to a framework request object.
Return Value:
None.
--*/
{
FuncEntry(TRACE_FLAG_SPBAPI);
UNREFERENCED_PARAMETER(FxQueue);
WDFDEVICE device;
PDEVICE_CONTEXT pDevice;
WDF_REQUEST_PARAMETERS params;
NTSTATUS status;
device = WdfIoQueueGetDevice(FxQueue);
pDevice = GetDeviceContext(device);
WDF_REQUEST_PARAMETERS_INIT(¶ms);
WdfRequestGetParameters(FxRequest, ¶ms);
status = WdfRequestForwardToIoQueue(FxRequest, pDevice->SpbQueue);
if (!NT_SUCCESS(status))
{
CyapaPrint(
DEBUG_LEVEL_ERROR,
DBG_IOCTL,
"Failed to forward WDFREQUEST %p to SPB queue %p - %!STATUS!",
FxRequest,
pDevice->SpbQueue,
status);
WdfRequestComplete(FxRequest, status);
}
FuncExit(TRACE_FLAG_SPBAPI);
}
void AndroidUsbDeviceObject::OnEvtIoWrite(WDFREQUEST request,
size_t length) {
ASSERT_IRQL_LOW_OR_DISPATCH();
ASSERT(IsInterfaceSelected());
if (!IsInterfaceSelected()) {
WdfRequestComplete(request, STATUS_INVALID_DEVICE_STATE);
return;
}
// Get our file extension and dispatch this event to its handler
AndroidUsbFileObject* wdf_file_ext =
GetAndroidUsbFileObjectForRequest(request);
ASSERT(NULL != wdf_file_ext);
if (NULL != wdf_file_ext) {
wdf_file_ext->OnEvtIoWrite(request, length);
} else {
WdfRequestComplete(request, STATUS_INVALID_DEVICE_REQUEST);
}
}
// 读回调
VOID EvtIoRead( IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN size_t Length )
{
NTSTATUS status;
PVOID outBuf; // 输出缓冲区
size_t bufLength; // 输出缓冲区大小
ULONG_PTR bytesRead = 0; // 实际读取的字节数
// 获取输出缓冲区地址
status = WdfRequestRetrieveOutputBuffer(Request, 0, &outBuf, &bufLength);
if( !NT_SUCCESS(status) )
{
KdPrint(("[EvtIoRead] WdfRequestRetrieveOutputBuffer failed!"));
WdfRequestComplete(Request, status);
return ;
}
// 实际读取的字节数与文件指针有关
bytesRead = ((IO_BUFFER_SIZE - gFilePointer) < Length ) ?
IO_BUFFER_SIZE - gFilePointer : Length;
// 检查参数
if( bufLength < bytesRead )
{
WdfRequestComplete(Request, STATUS_INVALID_PARAMETER);
return;
}
// 文件指针已经到末尾
if( 0 == bytesRead )
{
WdfRequestCompleteWithInformation(Request, STATUS_SUCCESS, 0);
return;
}
// 拷贝内容到输出缓冲区
RtlCopyMemory(outBuf, gFileBuffer+gFilePointer, bytesRead);
WdfRequestCompleteWithInformation(Request, STATUS_SUCCESS, bytesRead);
}
// Create
VOID EvtDeviceFileCreate( IN WDFDEVICE Device,
IN WDFREQUEST Request,
IN WDFFILEOBJECT FileObject )
{
// 在非分页内存上分配缓冲区
if( NULL == gFileBuffer )
{
gFileBuffer = (PCHAR)ExAllocatePoolWithTag(NonPagedPool, IO_BUFFER_SIZE, TAG_IO_BUFFER);
}
// 分配失败
if( NULL == gFileBuffer )
{
KdPrint(("[EvtDriverDeviceAdd] WdfMemoryCreate failed!"));
WdfRequestComplete(Request, STATUS_UNSUCCESSFUL);
}
WdfRequestComplete(Request, STATUS_SUCCESS);
}
VOID
EvtIoDeviceControl(IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN size_t OutputBufferLength,
IN size_t InputBufferLength, IN ULONG IoControlCode)
{
WDFDEVICE Device = WdfIoQueueGetDevice(Queue);
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
switch (IoControlCode) {
case IOCTL_PCIDTF_GET_INFO:
PciDtfDeviceGetInfo(Device, Request);
break;
case IOCTL_PCIDTF_READ_CFG:
PciDtfDeviceReadWriteCfg(Device, Request, TRUE);
break;
case IOCTL_PCIDTF_WRITE_CFG:
PciDtfDeviceReadWriteCfg(Device, Request, FALSE);
break;
case IOCTL_PCIDTF_GET_REG:
PciDtfDeviceGetReg(Device, Request);
break;
case IOCTL_PCIDTF_READ_REG:
PciDtfDeviceReadWriteReg(Device, Request, TRUE);
break;
case IOCTL_PCIDTF_WRITE_REG:
PciDtfDeviceReadWriteReg(Device, Request, FALSE);
break;
case IOCTL_PCIDTF_ALLOC_DMA:
PciDtfDeviceAllocDma(Device, Request);
break;
case IOCTL_PCIDTF_FREE_DMA:
PciDtfDeviceFreeDma(Device, Request);
break;
case IOCTL_PCIDTF_READ_DMA:
PciDtfDeviceReadWriteDma(Device, Request, TRUE);
break;
case IOCTL_PCIDTF_WRITE_DMA:
PciDtfDeviceReadWriteDma(Device, Request, FALSE);
break;
case IOCTL_PCIDTF_GET_DMA_INFO:
PciDtfDeviceGetDma(Device, Request);
break;
default:
TRACE_MSG(TRACE_LEVEL_ERROR, TRACE_FLAG_QUEUE,
"Unsupported I/O control code=0x%X (0x%X)\n",
IoControlCode,
IoGetFunctionCodeFromCtlCode(IoControlCode));
WdfRequestComplete(Request, STATUS_INVALID_DEVICE_REQUEST);
break;
}
}
static VOID
XenPci_IoWatch(char *path, PVOID context)
{
NTSTATUS status;
watch_context_t *watch_context = context;
WDFFILEOBJECT file_object = watch_context->file_object;
PXENPCI_DEVICE_INTERFACE_DATA xpdid = GetXpdid(file_object);
KIRQL old_irql;
struct xsd_sockmsg *rep;
xenbus_read_queue_item_t *list_entry;
size_t remaining;
WDFREQUEST request;
FUNCTION_ENTER();
KeAcquireSpinLock(&xpdid->lock, &old_irql);
remaining = sizeof(struct xsd_sockmsg) + strlen(path) + 1 + strlen(watch_context->token) + 1;
rep = ExAllocatePoolWithTag(NonPagedPool, sizeof(struct xsd_sockmsg) + strlen(path) + 1 + strlen(watch_context->token) + 1, XENPCI_POOL_TAG);
rep->type = XS_WATCH_EVENT;
rep->req_id = 0;
rep->tx_id = 0;
rep->len = (ULONG)(strlen(path) + 1 + strlen(watch_context->token) + 1);
remaining -= sizeof(struct xsd_sockmsg);
RtlStringCbCopyA((PCHAR)(rep + 1), remaining, path);
remaining -= strlen(path) + 1;
RtlStringCbCopyA((PCHAR)(rep + 1) + strlen(path) + 1, remaining, watch_context->token);
list_entry = (xenbus_read_queue_item_t *)ExAllocatePoolWithTag(NonPagedPool, sizeof(xenbus_read_queue_item_t), XENPCI_POOL_TAG);
list_entry->data = rep;
list_entry->length = sizeof(*rep) + rep->len;
list_entry->offset = 0;
InsertTailList(&xpdid->xenbus.read_list_head, (PLIST_ENTRY)list_entry);
status = WdfIoQueueRetrieveNextRequest(xpdid->xenbus.io_queue, &request);
if (NT_SUCCESS(status))
{
WDF_REQUEST_PARAMETERS parameters;
WDF_REQUEST_PARAMETERS_INIT(¶meters);
WdfRequestGetParameters(request, ¶meters);
KdPrint((__DRIVER_NAME " found pending read - MinorFunction = %d, length = %d\n", (ULONG)parameters.MinorFunction, (ULONG)parameters.Parameters.Read.Length));
XenBus_ProcessReadRequest(xpdid->xenbus.io_queue, request, parameters.Parameters.Read.Length);
KeReleaseSpinLock(&xpdid->lock, old_irql);
WdfRequestComplete(request, STATUS_SUCCESS);
}
else
{
KdPrint((__DRIVER_NAME " no pending read (%08x)\n", status));
KeReleaseSpinLock(&xpdid->lock, old_irql);
}
FUNCTION_EXIT();
}
VOID
KbFilterRequestCompletionRoutine(
WDFREQUEST Request,
WDFIOTARGET Target,
PWDF_REQUEST_COMPLETION_PARAMS CompletionParams,
WDFCONTEXT Context
)
/*++
Routine Description:
Completion Routine
Arguments:
Target - Target handle
Request - Request handle
Params - request completion params
Context - Driver supplied context
Return Value:
VOID
--*/
{
WDFMEMORY buffer = CompletionParams->Parameters.Ioctl.Output.Buffer;
NTSTATUS status = CompletionParams->IoStatus.Status;
UNREFERENCED_PARAMETER(Target);
//
// Save the keyboard attributes in our context area so that we can return
// them to the app later.
//
if (NT_SUCCESS(status) &&
CompletionParams->Type == WdfRequestTypeDeviceControlInternal &&
CompletionParams->Parameters.Ioctl.IoControlCode == IOCTL_KEYBOARD_QUERY_ATTRIBUTES) {
if( CompletionParams->Parameters.Ioctl.Output.Length >= sizeof(KEYBOARD_ATTRIBUTES)) {
status = WdfMemoryCopyToBuffer(buffer,
CompletionParams->Parameters.Ioctl.Output.Offset,
&((PDEVICE_EXTENSION)Context)->KeyboardAttributes,
sizeof(KEYBOARD_ATTRIBUTES)
);
}
}
WdfRequestComplete(Request, status);
return;
}
VOID VirtRngEvtIoRead(IN WDFQUEUE Queue,
IN WDFREQUEST Request,
IN size_t Length)
{
PDEVICE_CONTEXT context = GetDeviceContext(WdfIoQueueGetDevice(Queue));
NTSTATUS status;
PVOID buffer;
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_READ,
"--> %!FUNC! Queue: %p Request: %p Length: %d",
Queue, Request, (ULONG)Length);
status = WdfRequestRetrieveOutputBuffer(Request, Length, &buffer, NULL);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_READ,
"WdfRequestRetrieveOutputBuffer failed: %!STATUS!", status);
WdfRequestComplete(Request, status);
return;
}
status = WdfRequestMarkCancelableEx(Request, VirtRngEvtRequestCancel);
if (!NT_SUCCESS(status))
{
TraceEvents(TRACE_LEVEL_ERROR, DBG_READ,
"WdfRequestMarkCancelableEx failed: %!STATUS!", status);
WdfRequestComplete(Request, status);
return;
}
status = VirtQueueAddBuffer(context, Request, Length);
if (!NT_SUCCESS(status))
{
if (WdfRequestUnmarkCancelable(Request) != STATUS_CANCELLED)
{
WdfRequestComplete(Request, status);
}
}
TraceEvents(TRACE_LEVEL_VERBOSE, DBG_READ, "<-- %!FUNC!");
}
void AndroidUsbFileObject::OnEvtIoWrite(WDFREQUEST request,
size_t length) {
ASSERT_IRQL_LOW_OR_DISPATCH();
ASSERT(WdfRequestGetFileObject(request) == wdf_file());
// Complete zero writes with success
if (0 == length) {
WdfRequestCompleteWithInformation(request, STATUS_SUCCESS, 0);
return;
}
WdfRequestComplete(request, STATUS_INVALID_DEVICE_REQUEST);
}
//
// Internal Function: UartCtlGetDtrrts
//
VOID
UartCtlGetDtrrts(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PULONG pBuffer;
UCHAR regModemControl;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(ULONG),
(PVOID*)(& pBuffer),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl &= SERIAL_DTR_STATE | SERIAL_RTS_STATE;
*pBuffer = regModemControl;
WdfRequestSetInformation(Request, sizeof(ULONG));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetBaudRate
//
VOID
UartCtlGetBaudRate(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_BAUD_RATE pBaudRate = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_BAUD_RATE),
(PVOID*)(& pBaudRate),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and retrieves the current baud rate.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
pBaudRate->BaudRate = pDevExt->CurrentBaud;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(SERIAL_BAUD_RATE));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
//
// Internal Function: UartCtlGetModemControl
//
VOID
UartCtlGetModemControl(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PULONG pBuffer;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(ULONG),
(PVOID*)(&pBuffer),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and reads the modem control register.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
*pBuffer = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(ULONG));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
SimSensorIoInternalDeviceControl (
WDFQUEUE Queue,
WDFREQUEST Request,
size_t OutputBufferLength,
size_t InputBufferLength,
ULONG IoControlCode)
/*++
Description:
The system uses IoInternalDeviceControl requests to communicate with the
ACPI driver on the device stack. For proper operation of thermal zones,
these requests must be forwarded unless the driver knows how to handle
them.
--*/
{
WDF_REQUEST_SEND_OPTIONS RequestSendOptions;
BOOLEAN Return;
NTSTATUS Status;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
UNREFERENCED_PARAMETER(IoControlCode);
DebugEnter();
WdfRequestFormatRequestUsingCurrentType(Request);
WDF_REQUEST_SEND_OPTIONS_INIT(
&RequestSendOptions,
WDF_REQUEST_SEND_OPTION_SEND_AND_FORGET);
Return = WdfRequestSend(
Request,
WdfDeviceGetIoTarget(WdfIoQueueGetDevice(Queue)),
&RequestSendOptions);
if (Return == FALSE) {
Status = WdfRequestGetStatus(Request);
DebugPrint(SIMSENSOR_WARN,
"WdfRequestSend() Failed. Request Status=0x%x\n",
Status);
WdfRequestComplete(Request, Status);
}
DebugExit();
}
VOID
bareflankEvtIoStop(
_In_ WDFQUEUE Queue,
_In_ WDFREQUEST Request,
_In_ ULONG ActionFlags
)
{
UNREFERENCED_PARAMETER(Queue);
UNREFERENCED_PARAMETER(ActionFlags);
WdfRequestComplete(Request, STATUS_SUCCESS);
return;
}
void AndroidUsbDeviceObject::EvtDeviceFileCreateEntry(
WDFDEVICE wdf_dev,
WDFREQUEST request,
WDFFILEOBJECT wdf_fo) {
ASSERT_IRQL_PASSIVE();
ASSERT(NULL != wdf_fo);
if (NULL == wdf_fo) {
WdfRequestComplete(request, STATUS_INVALID_PARAMETER);
return;
}
// Get our wrapper for the device and redirect event to its handler
AndroidUsbDeviceObject* wdf_device_ext =
GetAndroidUsbDeviceObjectFromHandle(wdf_dev);
ASSERT(NULL != wdf_device_ext);
if (NULL != wdf_device_ext) {
wdf_device_ext->OnEvtDeviceFileCreate(request, wdf_fo);
} else {
WdfRequestComplete(request, STATUS_INVALID_DEVICE_REQUEST);
}
}
//
// Internal Function: UartCtlGetStats
//
VOID
UartCtlGetStats(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIALPERF_STATS pStats = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIALPERF_STATS),
(PVOID*)(& pStats),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
*pStats = pDevExt->PerfStats;
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
WdfRequestSetInformation(Request, sizeof(SERIALPERF_STATS));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
NTSTATUS PciDtfDeviceReadWriteCfg(IN WDFDEVICE Device, IN WDFREQUEST Request,
IN BOOLEAN Read)
{
PDEVICE_DATA DeviceData = GetDeviceData(Device);
PCIDTF_CFG_DATA *ReqData;
NTSTATUS Status = STATUS_SUCCESS;
__try {
Status = WdfRequestRetrieveInputBuffer(Request,
sizeof(PCIDTF_CFG_DATA),
(PVOID *) & ReqData,
NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveInputBuffer", Status);
__leave;
}
if (Read) {
Status = WdfRequestRetrieveOutputBuffer(Request,
sizeof
(PCIDTF_CFG_DATA),
(PVOID *) &
ReqData, NULL);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("WdfRequestRetrieveOutputBuffer",
Status);
__leave;
}
Status =
PciDtfConfigRead(&DeviceData->BusIntf, ReqData->off,
ReqData->len, &ReqData->val);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfConfigRead", Status);
__leave;
}
WdfRequestSetInformation(Request,
sizeof(PCIDTF_CFG_DATA));
} else {
Status = PciDtfConfigWrite(&DeviceData->BusIntf,
ReqData->off, ReqData->len,
ReqData->val);
if (!NT_SUCCESS(Status)) {
TRACE_ERR("PciDtfConfigWrite", Status);
__leave;
}
}
}
__finally {
WdfRequestComplete(Request, Status);
}
return Status;
}
//
// Internal Function: UartCtlClrRts
//
VOID
UartCtlClrRts(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
UCHAR regModemControl;
NTSTATUS status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
if (((pDevExt->HandFlow.FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_RTS_HANDSHAKE) ||
((pDevExt->HandFlow.FlowReplace & SERIAL_RTS_MASK) ==
SERIAL_TRANSMIT_TOGGLE))
{
status = STATUS_INVALID_PARAMETER;
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"RTS cannot be cleared when automatic RTS flow control or "
"transmit toggling is used - %!STATUS!",
status);
}
if (NT_SUCCESS(status))
{
// Acquires the interrupt lock and sets the MCR.
WdfInterruptAcquireLock(pDevExt->WdfInterrupt);
regModemControl = READ_MODEM_CONTROL(pDevExt, pDevExt->Controller);
regModemControl &= ~SERIAL_MCR_RTS;
WRITE_MODEM_CONTROL(pDevExt, pDevExt->Controller, regModemControl);
WdfInterruptReleaseLock(pDevExt->WdfInterrupt);
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
VOID
SerialEvtDeviceFileCreate (
IN WDFDEVICE Device,
IN WDFREQUEST Request,
IN WDFFILEOBJECT FileObject
)
/*++
Routine Description:
The framework calls a driver's EvtDeviceFileCreate callback
when the framework receives an IRP_MJ_CREATE request.
The system sends this request when a user application opens the
device to perform an I/O operation, such as reading or writing a file.
This callback is called synchronously, in the context of the thread
that created the IRP_MJ_CREATE request.
Arguments:
Device - Handle to a framework device object.
FileObject - Pointer to fileobject that represents the open handle.
CreateParams - Copy of the Create IO_STACK_LOCATION
Return Value:
VOID.
--*/
{
NTSTATUS status;
PSERIAL_DEVICE_EXTENSION extension = SerialGetDeviceExtension (Device);
UNREFERENCED_PARAMETER(FileObject);
PAGED_CODE();
SerialDbgPrintEx(TRACE_LEVEL_INFORMATION, DBG_CREATE_CLOSE,
"SerialEvtDeviceFileCreate %wZ\n", &extension->DeviceName);
status = SerialDeviceFileCreateWorker(Device);
//
// Complete the WDF request.
//
WdfRequestComplete(Request, status);
return;
}
//
// Internal Function: UartCtlGetHandflow
//
VOID
UartCtlGetHandflow(
_In_ WDFDEVICE Device,
_In_ WDFREQUEST Request,
_In_ size_t OutputBufferLength,
_In_ size_t InputBufferLength
)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUART_DEVICE_EXTENSION pDevExt = UartGetDeviceExtension(Device);
PSERIAL_HANDFLOW pHandFlow = NULL;
UNREFERENCED_PARAMETER(OutputBufferLength);
UNREFERENCED_PARAMETER(InputBufferLength);
FuncEntry(TRACE_FLAG_CONTROL);
status = WdfRequestRetrieveOutputBuffer(Request,
sizeof(SERIAL_HANDFLOW),
(PVOID*)(& pHandFlow),
NULL);
if (!NT_SUCCESS(status))
{
TraceMessage(
TRACE_LEVEL_ERROR,
TRACE_FLAG_CONTROL,
"Failed to retrieve output buffer for WDFREQUEST %p - "
"%!STATUS!",
Request,
status);
}
if (NT_SUCCESS(status))
{
*pHandFlow = pDevExt->HandFlow;
WdfRequestSetInformation(Request, sizeof(SERIAL_HANDFLOW));
}
TraceMessage(TRACE_LEVEL_INFORMATION,
TRACE_FLAG_CONTROL,
"WdfRequestComplete( %!HANDLE! => %!STATUS! )",
Request,
status);
WdfRequestComplete(Request, status);
FuncExit(TRACE_FLAG_CONTROL);
}
/*++
Routine Description:
The framework calls a driver's EvtDeviceFileCreate callback
when the framework receives an IRP_MJ_CREATE request.
The system sends this request when a user application opens the
device to perform an I/O operation, such as reading or writing a file.
This callback is called synchronously, in the context of the thread
that created the IRP_MJ_CREATE request.
Arguments:
Device - Handle to a framework device object.
FileObject - Pointer to fileobject that represents the open handle.
CreateParams - copy of the create IO_STACK_LOCATION
Return Value:
NT status code
--*/
VOID PSDrv_EvtDeviceFileCreate(IN WDFDEVICE Device, IN WDFREQUEST Request, IN WDFFILEOBJECT FileObject)
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PUNICODE_STRING fileName;
PFILE_CONTEXT pFileContext;
PDEVICE_CONTEXT pDevContext;
WDFUSBPIPE pipe;
PSDrv_DbgPrint(3, ("PSDrv_EvtDeviceFileCreate - begins\n"));
PAGED_CODE();
// initialize variables
pDevContext = GetDeviceContext(Device);
pFileContext = GetFileContext(FileObject);
fileName = WdfFileObjectGetFileName(FileObject);
if (0 == fileName->Length)
{
// opening a device as opposed to pipe.
status = STATUS_SUCCESS;
}
else {
pipe = GetPipeFromName(pDevContext, fileName);
// Does the pipe exists?
if (pipe != NULL)
{
pFileContext->Pipe = pipe;
WdfUsbTargetPipeSetNoMaximumPacketSizeCheck(pipe);
// Set the default timeout
pFileContext->nTimeOut = PSUSBDRV_DEFAULT_TIMEOUT;
status = STATUS_SUCCESS;
}
else
{
status = STATUS_INVALID_DEVICE_REQUEST;
}
}
WdfRequestComplete(Request, status);
PSDrv_DbgPrint(3, ("PSDrv_EvtDeviceFileCreate - ends\n"));
return;
}
