NTSTATUS DispatchReadWriteFlush(PDEVICE_OBJECT fdo, PIRP Irp)
{
KIRQL OldIrql;
ULONG count;
PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION) fdo->DeviceExtension;
PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation( Irp );
if(stack->MajorFunction == IRP_MJ_WRITE)
{
if(stack->Parameters.Write.Length == 0)
{
return CompleteRequest( Irp, STATUS_SUCCESS, 0 );
}
// write
IoMarkIrpPending(Irp);
StartPacket( &pdx->dqWrite, fdo, Irp, OnCancelWrite );
}
else if(stack->MajorFunction == IRP_MJ_READ)
{
if(stack->Parameters.Read.Length == 0)
{
return CompleteRequest( Irp, STATUS_SUCCESS, 0 );
}
// read
IoAcquireRemoveLock( &pdx->RemoveLock, Irp );
IoMarkIrpPending ( Irp );
IoSetCancelRoutine ( Irp, OnCancelQueuedRead );
KeAcquireSpinLock( &pdx->ReadIrpLock, &OldIrql );
InsertTailList ( &pdx->ReadIrpList, &Irp->Tail.Overlay.ListEntry );
KeReleaseSpinLock( &pdx->ReadIrpLock, OldIrql );
CompleteQueuedReads(pdx);
}
else
{
// flush
IoMarkIrpPending( Irp );
StartPacket ( &pdx->dqWrite, fdo, Irp, OnCancelWrite );
}
return STATUS_PENDING;
}
NTSTATUS
NTAPI
BeepDeviceControl(IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
{
PIO_STACK_LOCATION Stack;
PBEEP_SET_PARAMETERS BeepParam;
NTSTATUS Status;
/* Get the stack location and parameters */
Stack = IoGetCurrentIrpStackLocation(Irp);
BeepParam = (PBEEP_SET_PARAMETERS)Irp->AssociatedIrp.SystemBuffer;
/* We only support one IOCTL */
if (Stack->Parameters.DeviceIoControl.IoControlCode != IOCTL_BEEP_SET)
{
/* Unsupported command */
Status = STATUS_NOT_IMPLEMENTED;
}
else
{
/* Validate the input buffer length */
if (Stack->Parameters.DeviceIoControl.InputBufferLength <
sizeof(BEEP_SET_PARAMETERS))
{
/* Invalid buffer */
Status = STATUS_INVALID_PARAMETER;
}
else if ((BeepParam->Frequency != 0) && !(BeepParam->Duration))
{
/* No duration, return imemdiately */
Status = STATUS_SUCCESS;
}
else
{
/* We'll queue this request */
Status = STATUS_PENDING;
}
}
/* Set packet information */
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
/* Check if we're completing or queuing a packet */
if (Status == STATUS_PENDING)
{
/* Start the queue */
IoMarkIrpPending(Irp);
IoStartPacket(DeviceObject, Irp, NULL, BeepCancel);
}
else
{
/* Complete the request */
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
/* Return */
return Status;
}
static NTSTATUS vboxUsbPwrIoPostDevCompletion(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp, IN PVOID pvContext)
{
PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pvContext;
if (pIrp->PendingReturned)
{
IoMarkIrpPending(pIrp);
}
NTSTATUS Status = pIrp->IoStatus.Status;
Assert(Status == STATUS_SUCCESS);
if (NT_SUCCESS(Status))
{
PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp);
switch (pSl->MinorFunction)
{
case IRP_MN_SET_POWER:
{
pDevExt->DdiState.PwrState.PowerState.DeviceState = pSl->Parameters.Power.State.DeviceState;
PoSetPowerState(pDevExt->pFDO, DevicePowerState, pSl->Parameters.Power.State);
break;
}
default:
{
break;
}
}
}
PoStartNextPowerIrp(pIrp);
vboxUsbDdiStateRelease(pDevExt);
return STATUS_SUCCESS;
}
FORCEINLINE
VOID
FxIrp::MarkIrpPending(
)
{
IoMarkIrpPending(m_Irp);
}
NTSTATUS KBFReadCompleteRoutine(IN PDEVICE_OBJECT aDeviceObjec, IN PIRP aIrp, IN PVOID aContext)
{
PAGED_CODE();
PIO_STACK_LOCATION irpStackLocation;
ULONG_PTR buflen = 0;
PUCHAR buf = NULL;
irpStackLocation = IoGetCurrentIrpStackLocation(aIrp);
if (NT_SUCCESS(aIrp->IoStatus.Status))
{
// 获得读取请求完成后输出的缓冲区
buf = (PUCHAR)aIrp->AssociatedIrp.SystemBuffer;
// 获得缓冲区长度
buflen = aIrp->IoStatus.Information;
for (size_t i = 0; i < buflen; ++i)
{
DbgPrint("wykbflt.sys : %2x\r\n", buf[i]);
}
}
--gC2pKeyCount;
if (aIrp->PendingReturned)
{
IoMarkIrpPending(aIrp);
}
return aIrp->IoStatus.Status;
}
static NTSTATUS DDKAPI
on_query_capabilities_complete(DEVICE_OBJECT *device_object,
IRP *irp, void *context)
{
libusb_device_t *dev = device_object->DeviceExtension;
IO_STACK_LOCATION *stack_location = IoGetCurrentIrpStackLocation(irp);
if(irp->PendingReturned)
{
IoMarkIrpPending(irp);
}
if(NT_SUCCESS(irp->IoStatus.Status))
{
if(!dev->is_filter)
{
/* apply registry setting */
stack_location->Parameters.DeviceCapabilities.Capabilities
->SurpriseRemovalOK = dev->surprise_removal_ok;
}
/* save supported device power states */
memcpy(dev->device_power_states, stack_location
->Parameters.DeviceCapabilities.Capabilities->DeviceState,
sizeof(dev->device_power_states));
}
remove_lock_release(dev);
return STATUS_SUCCESS;
}
static NTSTATUS
Pkt0DispatchWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PIO_WORKITEM work_item;
KIRQL old_irql;
NTSTATUS status;
work_item = IoAllocateWorkItem(DeviceObject);
if (work_item == NULL) {
return Pkt0CompleteIrp(Irp, STATUS_INSUFFICIENT_RESOURCES, 0);
}
KeAcquireSpinLock(&Pkt0ContextLock, &old_irql);
if (Pkt0Context->closing) {
status = Pkt0CompleteIrp(Irp, STATUS_PIPE_CLOSING, 0);
} else {
InsertTailList(&Pkt0Context->irp_write_queue, &Irp->Tail.Overlay.ListEntry);
IoMarkIrpPending(Irp);
status = STATUS_PENDING;
}
KeReleaseSpinLock(&Pkt0ContextLock, old_irql);
if (status == STATUS_PENDING) {
IoQueueWorkItemEx(work_item, Pkt0DeferredWrite, DelayedWorkQueue, NULL);
} else {
IoFreeWorkItem(work_item);
}
return status;
}
NTSTATUS EncryptedIoQueueAddIrp (EncryptedIoQueue *queue, PIRP irp)
{
NTSTATUS status;
InterlockedIncrement (&queue->OutstandingIoCount);
if (queue->StopPending)
{
Dump ("STATUS_DEVICE_NOT_READY out=%d\n", queue->OutstandingIoCount);
status = STATUS_DEVICE_NOT_READY;
goto err;
}
status = IoAcquireRemoveLock (&queue->RemoveLock, irp);
if (!NT_SUCCESS (status))
goto err;
#ifdef TC_TRACE_IO_QUEUE
{
PIO_STACK_LOCATION irpSp = IoGetCurrentIrpStackLocation (irp);
Dump ("* %I64d [%I64d] %c len=%d out=%d\n", irpSp->MajorFunction == IRP_MJ_WRITE ? irpSp->Parameters.Write.ByteOffset : irpSp->Parameters.Read.ByteOffset, GetElapsedTime (&queue->LastPerformanceCounter), irpSp->MajorFunction == IRP_MJ_WRITE ? 'W' : 'R', irpSp->MajorFunction == IRP_MJ_WRITE ? irpSp->Parameters.Write.Length : irpSp->Parameters.Read.Length, queue->OutstandingIoCount);
}
#endif
IoMarkIrpPending (irp);
ExInterlockedInsertTailList (&queue->MainThreadQueue, &irp->Tail.Overlay.ListEntry, &queue->MainThreadQueueLock);
KeSetEvent (&queue->MainThreadQueueNotEmptyEvent, IO_DISK_INCREMENT, FALSE);
return STATUS_PENDING;
err:
DecrementOutstandingIoCount (queue);
return status;
}
NTSTATUS MyIoCompletion(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
{
Debug("Enter MyIoCompletion");
if(NT_SUCCESS(Irp->IoStatus.Status))
{
PKEYBOARD_INPUT_DATA tKeyData = (PKEYBOARD_INPUT_DATA )Irp->AssociatedIrp.SystemBuffer;
if(tKeyData->Flags)
{
g_CurMakeCode = tKeyData->MakeCode;
if(0 != g_ShareEvent && (g_Status & INTERCEPT))
{
KeSetEvent((PRKEVENT)g_ShareEvent,(KPRIORITY)0, false); //弹起
}
}
if(!(g_Status & ENABLE)) //按下与弹起
{
ULONG tBufLen = Irp->IoStatus.Information;
ULONG tNumKeys = tBufLen / sizeof(KEYBOARD_INPUT_DATA);
for(int i=0;i<tNumKeys;++i)
tKeyData[i].MakeCode = 0x00;
}
KdPrint(("扫描码:%x,%s\n",tKeyData->MakeCode,tKeyData->Flags?"弹起":"按下"));
}
if(Irp->PendingReturned)
{
IoMarkIrpPending(Irp);
}
Debug("Leave MyIoCompletion");
return Irp->IoStatus.Status;
}
NTSTATUS NTAPI FinishDevPoUpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
NTSTATUS ntStatus;
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoUpIrp: Entered\n"));
ntStatus = Irp->IoStatus.Status;
if(Irp->PendingReturned)
{
IoMarkIrpPending(Irp);
}
if(!NT_SUCCESS(ntStatus))
{
PoStartNextPowerIrp(Irp);
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoUpIrp::"));
FreeBT_IoDecrement(DeviceExtension);
return STATUS_SUCCESS;
}
SetDeviceFunctional(DeviceObject, Irp, DeviceExtension);
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoUpIrp: Leaving\n"));
return STATUS_MORE_PROCESSING_REQUIRED;
}
static NTSTATUS
Pkt0DispatchRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
struct pkt0_packet *pkt = NULL;
KIRQL old_irql;
PLIST_ENTRY entry;
NTSTATUS status;
KeAcquireSpinLock(&Pkt0ContextLock, &old_irql);
if (Pkt0Context->closing) {
status = Pkt0CompleteIrp(Irp, STATUS_PIPE_CLOSING, 0);
} else if (IsListEmpty(&Pkt0Context->pkt_read_queue)) {
InsertTailList(&Pkt0Context->irp_read_queue, &Irp->Tail.Overlay.ListEntry);
IoMarkIrpPending(Irp);
status = STATUS_PENDING;
} else {
entry = RemoveHeadList(&Pkt0Context->pkt_read_queue);
pkt = CONTAINING_RECORD(entry, struct pkt0_packet, list_entry);
}
KeReleaseSpinLock(&Pkt0ContextLock, old_irql);
if (pkt != NULL) {
status = Pkt0TransferPacketToUser(Irp, pkt);
}
return status;
}
//
// AFSWriteComplete
//
static
NTSTATUS
AFSWriteComplete( IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PVOID Context)
{
UNREFERENCED_PARAMETER(DeviceObject);
UNREFERENCED_PARAMETER(Irp);
UNREFERENCED_PARAMETER(Context);
BOOLEAN bPending = FALSE;
//
// Indicate the library/IRP pair is done with the request
//
AFSClearLibraryRequest();
if (Irp->PendingReturned) {
bPending = TRUE;
IoMarkIrpPending(Irp);
}
AFSDbgTrace(( AFS_SUBSYSTEM_IO_PROCESSING,
AFS_TRACE_LEVEL_VERBOSE,
"AFSWriteComplete Irp %p%s\n",
Irp,
bPending ? " PENDING" : ""));
return STATUS_CONTINUE_COMPLETION;
}
NTSTATUS createcomplete(PDEVICE_OBJECT dev, PIRP irp, PVOID context)
{
UNREFERENCED_PARAMETER(dev);
UNREFERENCED_PARAMETER(irp);
UNREFERENCED_PARAMETER(context);
DbgPrint("enter createcomplete\n");
PIO_STACK_LOCATION sa = IoGetCurrentIrpStackLocation(irp);
PCONTEXTI info = context;
DbgPrint("1\n");
TDI_ADDRESS_INFO *tai = ExAllocatePool(NonPagedPool, sizeof(TDI_ADDRESS_INFO));
DbgPrint("2\n");
PMDL mdl = IoAllocateMdl(tai, sizeof(TDI_ADDRESS_INFO), FALSE, FALSE, info->query_irp);
MmBuildMdlForNonPagedPool(mdl);
info->mdl = mdl;
DbgPrint("3\n");
IoCopyCurrentIrpStackLocationToNext(irp);
TdiBuildQueryInformation(info->query_irp, info->realdev, sa->FileObject, querycom, info, TDI_QUERY_ADDRESS_INFO, mdl);
DbgPrint("4\n");
if (irp->PendingReturned)
{
IoMarkIrpPending(irp);
DbgPrint("pending\n");
}
IoCallDriver(info->realdev, info->query_irp);
DbgPrint("6\n");
IoFreeMdl(info->mdl);
ExFreePool(context);
return STATUS_SUCCESS;
}
//========================================================================================
// Function: CompletionRoutineStartDevice of DispatchPnp
// Purpose: PNP DEVICE USAGE NOTIFICATION irp completion routine
// Return Value:
// NT status code
//========================================================================================
NTSTATUS
CompletionRoutineDevUsgNotify(
IN PDEVICE_OBJECT fido, // fido - pointer to a device object.
IN PIRP irp, // irp - pointer to an I/O Request Packet.
IN PVOID Context // Context - pointer to an event object.
)
{
PDEVICE_EXTENSION dx;
UNREFERENCED_PARAMETER(Context);
dx = (PDEVICE_EXTENSION)fido->DeviceExtension;
if (irp->PendingReturned)
IoMarkIrpPending(irp);
//On the way up, pagable might become clear. Mimic the driver below us.
if (!(dx->lowerdo->Flags & DO_POWER_PAGABLE))
{
fido->Flags &= ~DO_POWER_PAGABLE;
}
IoReleaseRemoveLock(&dx->rmLock, irp);
return STATUS_SUCCESS;
}
NTSTATUS SecLabReceivePacket(PADAPT pAdapt,IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
{
// 某一时刻只有一个读IRP被允许存放在队列中
NdisAcquireSpinLock(&ReadIrpLock);
if(ReadIrp!=NULL /*&& ReadCount!=0*/)
{
NdisReleaseSpinLock(&ReadIrpLock);
return CompleteIrp(Irp,STATUS_UNSUCCESSFUL,0);
}
// 看是否成功取出封包数据
if( PickPacketFromList(pAdapt,Irp))
{
ReadCount=0;
ReadIrp=NULL;
NdisReleaseSpinLock(&ReadIrpLock);
return STATUS_SUCCESS;
}
// 如果队列中没有封包数据，就将此IRP排队
ReadIrp = Irp;
ReadCount=1;
// Mark Irp as pending and set Cancel routine
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = STATUS_PENDING;
IoMarkIrpPending(Irp);
IoSetCancelRoutine(Irp,SecLabCancelIrp);
NdisReleaseSpinLock(&ReadIrpLock);
return STATUS_PENDING;
}
NTSTATUS
FFSQueueRequest(
IN PFFS_IRP_CONTEXT IrpContext)
{
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == FFSICX) &&
(IrpContext->Identifier.Size == sizeof(FFS_IRP_CONTEXT)));
// IsSynchronous means we can block (so we don't requeue it)
IrpContext->IsSynchronous = TRUE;
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_REQUEUED);
IoMarkIrpPending(IrpContext->Irp);
ExInitializeWorkItem(
&IrpContext->WorkQueueItem,
FFSDeQueueRequest,
IrpContext);
ExQueueWorkItem(&IrpContext->WorkQueueItem, CriticalWorkQueue);
return STATUS_PENDING;
}
//========================================================================================
// Function: CompletionRoutineStartDevice of DispatchPnp
// Purpose: The completion routine for plug & play irps that needs to be
// processed first by the lower drivers.
// Return Value:
// NT status code
//========================================================================================
NTSTATUS
CompletionRoutineStartDevice(
IN PDEVICE_OBJECT fido, // fido - pointer to a device object.
IN PIRP irp, // irp - pointer to an I/O Request Packet.
IN PVOID Context // Context - pointer to an event object.
)
{
PDEVICE_EXTENSION dx;
UNREFERENCED_PARAMETER(Context);
dx = (PDEVICE_EXTENSION)fido->DeviceExtension;
//Must do this if we don't return STATUS_MORE_PROCESSING_REQUIRED
if (irp->PendingReturned)
IoMarkIrpPending(irp);
if (NT_SUCCESS(irp->IoStatus.Status))
{
//As we are successfully now back, we will
//first set our state to Started.
SET_NEW_PNP_STATE(dx, Started);
//On the way up inherit FILE_REMOVABLE_MEDIA during Start.
//This characteristic is available only after the driver stack is started!.
if (dx->lowerdo->Characteristics & FILE_REMOVABLE_MEDIA)
{
fido->Characteristics |= FILE_REMOVABLE_MEDIA;
}
}
IoReleaseRemoveLock(&dx->rmLock, irp);
return STATUS_SUCCESS;
}
NTSTATUS
Serenum_FDOPowerComplete (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp,
IN PVOID Context)
/*++
--*/
{
POWER_STATE powerState;
POWER_STATE_TYPE powerType;
PIO_STACK_LOCATION stack;
PFDO_DEVICE_DATA data;
UNREFERENCED_PARAMETER(Context);
if (Irp->PendingReturned) {
IoMarkIrpPending(Irp);
}
data = (PFDO_DEVICE_DATA)DeviceObject->DeviceExtension;
stack = IoGetCurrentIrpStackLocation(Irp);
powerType = stack->Parameters.Power.Type;
powerState = stack->Parameters.Power.State;
switch (stack->MinorFunction) {
case IRP_MN_SET_POWER:
switch (powerType) {
case DevicePowerState:
//
// Powering Up
//
ASSERT(powerState.DeviceState < data->DeviceState);
data->DeviceState = powerState.DeviceState;
PoSetPowerState(data->Self, powerType, powerState);
break;
default:
break;
}
break;
case IRP_MN_QUERY_POWER:
ASSERT(IRP_MN_QUERY_POWER != stack->MinorFunction);
break;
default:
//
// Basically, this is ASSERT(0)
//
ASSERT(0xBADBAD == IRP_MN_QUERY_POWER);
break;
}
PoStartNextPowerIrp(Irp);
Serenum_DecIoCount(data);
return STATUS_SUCCESS; // Continue completion...
}
NTSTATUS
WaitWakeCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This is the IoSet completion routine for the wait wake irp.
Arguments:
DeviceObject - pointer to device object
Irp - I/O request packet
DeviceExtension - pointer to device extension
Return Value:
NT status value
--*/
{
MobiUsb_DbgPrint(3, ("file mobipwr: WaitWakeCompletionRoutine - begins\n"));
if(Irp->PendingReturned) {
IoMarkIrpPending(Irp);
}
//
// Nullify the WaitWakeIrp pointer-the Irp is released
// as part of the completion process. If it's already NULL,
// avoid race with the CancelWaitWake routine.
//
if(InterlockedExchangePointer(&DeviceExtension->WaitWakeIrp, NULL)) {
PoStartNextPowerIrp(Irp);
return STATUS_SUCCESS;
}
//
// CancelWaitWake has run.
// If FlagWWCancel != 0, complete the Irp.
// If FlagWWCancel == 0, CancelWaitWake completes it.
//
if(InterlockedExchange(&DeviceExtension->FlagWWCancel, 1)) {
PoStartNextPowerIrp(Irp);
return STATUS_CANCELLED;
}
MobiUsb_DbgPrint(3, ("file mobipwr: WaitWakeCompletionRoutine - ends\n"));
return STATUS_MORE_PROCESSING_REQUIRED;
}
NTSTATUS Notification_Recieve(NOTIFICATION_QUEUE *queue, PIRP irp) {
PIO_STACK_LOCATION irpstack = IoGetCurrentIrpStackLocation(irp);
KIRQL irq;
if(irpstack->Parameters.DeviceIoControl.OutputBufferLength != sizeof(PGNOTIFICATION)) {
irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
irp->IoStatus.Information = 0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_BUFFER_TOO_SMALL;
}
KeAcquireSpinLock(&queue->lock, &irq);
if(IsListEmpty(&queue->notification_list)) {
PGIRPNODE *irpnode;
KIRQL crirq;
irpnode = ExAllocateFromNPagedLookasideList(&queue->lookaside);
InitializeListHead(&irpnode->entry);
irpnode->irp = irp;
//irp->Tail.Overlay.DriverContext[0] = irpnode;
InsertTailList(&queue->irp_list, &irpnode->entry);
IoMarkIrpPending(irp);
IoAcquireCancelSpinLock(&crirq);
#pragma warning(push)
#pragma warning(disable:4311 4312)
//IoSetCancelRoutine generates warnings in 32-bit due to silly macroisms.
IoSetCancelRoutine(irp, Notification_OnCancel);
#pragma warning(pop)
IoReleaseCancelSpinLock(crirq);
KeReleaseSpinLock(&queue->lock, irq);
return STATUS_PENDING;
}
else {
PGNOTIFYNODE *notifynode = (PGNOTIFYNODE*)RemoveHeadList(&queue->notification_list);
PGNOTIFICATION *notification = irp->AssociatedIrp.SystemBuffer;
RtlCopyMemory(notification, ¬ifynode->notification, sizeof(PGNOTIFICATION));
ExFreeToNPagedLookasideList(&queue->lookaside, notifynode);
--queue->queued;
KeReleaseSpinLock(&queue->lock, irq);
irp->IoStatus.Status = STATUS_SUCCESS;
irp->IoStatus.Information = sizeof(PGNOTIFICATION);
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
}
NTSTATUS MouseFilterInvertorYCompletion(PDEVICE_OBJECT pFiDO, PIRP pIrp, PVOID pContext)
{
ULONG_PTR i = 0;
PMOUSE_INPUT_DATA MouseData = NULL;
ULONG_PTR EventCount = pIrp->IoStatus.Information / sizeof(MOUSE_INPUT_DATA);
DbgPrint("Mouse Filter: Entry in MouseFilterInvertorYCompletion\n");
if (NT_SUCCESS(pIrp->IoStatus.Status)) {
MouseData = (PMOUSE_INPUT_DATA)pIrp->AssociatedIrp.SystemBuffer;
for (i = 0; i < EventCount; ++i) {
if (MouseData[i].Flags & MOUSE_MOVE_ABSOLUTE) {
MouseData[i].LastY = 0xFFFF - MouseData[i].LastY;
} else {
MouseData[i].LastY *= -1;
}
}
}
if (pIrp->PendingReturned) {
IoMarkIrpPending(pIrp);
}
return pIrp->IoStatus.Status;
}
NTSTATUS NTAPI DispatchReadWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
/* According to the cancel sample in the DDK, IoCsqInsertIrp() marks the irp pending */
/* However, I think it's wrong. */
IoMarkIrpPending(Irp);
IoCsqInsertIrp(&Csq, Irp, 0);
return STATUS_PENDING;
}
static NTSTATUS vboxUsbPwrIoPostDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp)
{
IoMarkIrpPending(pIrp);
IoCopyCurrentIrpStackLocationToNext(pIrp);
IoSetCompletionRoutine(pIrp, vboxUsbPwrIoPostDevCompletion, pDevExt, TRUE, TRUE, TRUE);
NTSTATUS Status = PoCallDriver(pDevExt->pLowerDO, pIrp);
Assert(NT_SUCCESS(Status));
return STATUS_PENDING;
}
NTSTATUS
NTAPI
NpSetListeningPipeState(IN PNP_CCB Ccb,
IN PIRP Irp,
IN PLIST_ENTRY List)
{
NTSTATUS Status;
switch (Ccb->NamedPipeState)
{
case FILE_PIPE_DISCONNECTED_STATE:
Status = NpCancelWaiter(&NpVcb->WaitQueue,
&Ccb->Fcb->FullName,
STATUS_SUCCESS,
List);
if (!NT_SUCCESS(Status)) return Status;
//
// Drop down on purpose
//
case FILE_PIPE_LISTENING_STATE:
if (Ccb->CompletionMode[FILE_PIPE_SERVER_END] == FILE_PIPE_COMPLETE_OPERATION)
{
Ccb->NamedPipeState = FILE_PIPE_LISTENING_STATE;
return STATUS_PIPE_LISTENING;
}
IoSetCancelRoutine(Irp, NpCancelListeningQueueIrp);
if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
{
return STATUS_CANCELLED;
}
Ccb->NamedPipeState = FILE_PIPE_LISTENING_STATE;
IoMarkIrpPending(Irp);
InsertTailList(&Ccb->IrpList, &Irp->Tail.Overlay.ListEntry);
return STATUS_PENDING;
case FILE_PIPE_CONNECTED_STATE:
Status = STATUS_PIPE_CONNECTED;
break;
case FILE_PIPE_CLOSING_STATE:
Status = STATUS_PIPE_CLOSING;
break;
default:
NpBugCheck(Ccb->NamedPipeState, 0, 0);
break;
}
return Status;
}
NTSTATUS
FinishDevPoUpIrp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
completion routine for the device power UP irp with minor function
IRP_MN_SET_POWER.
Arguments:
DeviceObject - pointer to device object
Irp - I/O request packet
DeviceExtension - pointer to device extension
Return Value:
NT status value
--*/
{
NTSTATUS ntStatus;
//
// initialize variables
//
ntStatus = Irp->IoStatus.Status;
MobiUsb_DbgPrint(3, ("file mobipwr: FinishDevPoUpIrp - begins\n"));
if(Irp->PendingReturned) {
IoMarkIrpPending(Irp);
}
if(!NT_SUCCESS(ntStatus)) {
PoStartNextPowerIrp(Irp);
MobiUsb_DbgPrint(3, ("file mobipwr: FinishDevPoUpIrp::"));
MobiUsb_IoDecrement(DeviceExtension);
return STATUS_SUCCESS;
}
SetDeviceFunctional(DeviceObject, Irp, DeviceExtension);
MobiUsb_DbgPrint(3, ("file mobipwr: FinishDevPoUpIrp - ends\n"));
return STATUS_MORE_PROCESSING_REQUIRED;
}
static NTSTATUS DDKAPI
on_power_state_complete(DEVICE_OBJECT *device_object,
IRP *irp,
void *context)
{
libusb_device_t *dev = context;
IO_STACK_LOCATION *stack_location = IoGetCurrentIrpStackLocation(irp);
POWER_STATE power_state = stack_location->Parameters.Power.State;
DEVICE_POWER_STATE dev_power_state;
if (irp->PendingReturned)
{
IoMarkIrpPending(irp);
}
if (NT_SUCCESS(irp->IoStatus.Status))
{
if (stack_location->Parameters.Power.Type == SystemPowerState)
{
USBMSG("S%d %s\n",
power_state.SystemState - PowerSystemWorking, dev->device_id);
/* save current system state */
dev->power_state.SystemState = power_state.SystemState;
/* get supported device power state from the array reported by */
/* IRP_MN_QUERY_CAPABILITIES */
dev_power_state = dev->device_power_states[power_state.SystemState];
/* set the device power state, but don't block the thread */
power_set_device_state(dev, dev_power_state, FALSE);
}
else /* DevicePowerState */
{
USBMSG("D%d %s\n",
power_state.DeviceState - PowerDeviceD0, dev->device_id);
if (power_state.DeviceState <= dev->power_state.DeviceState)
{
/* device is powered up, */
/* report device state to Power Manager */
PoSetPowerState(dev->self, DevicePowerState, power_state);
}
/* save current device state */
dev->power_state.DeviceState = power_state.DeviceState;
}
}
else
{
USBMSG0("failed\n");
}
remove_lock_release(dev);
return STATUS_SUCCESS;
}
NTSTATUS UsageNotificationCompletionRoutine(PDEVICE_OBJECT fido, PIRP Irp, PDEVICE_EXTENSION pdx)
{ // UsageNotificationCompletionRoutine
if (Irp->PendingReturned)
IoMarkIrpPending(Irp);
// If lower driver cleared pageable flag, we must do the same
if (!(pdx->LowerDeviceObject->Flags & DO_POWER_PAGABLE))
fido->Flags &= ~DO_POWER_PAGABLE;
IoReleaseRemoveLock(&pdx->RemoveLock, Irp);
return STATUS_SUCCESS;
} // UsageNotificationCompletionRoutine
NTSTATUS StartIrp(
PC0C_IO_PORT pIoPort,
PIRP pIrp,
PC0C_IRP_STATE pState,
PC0C_IRP_QUEUE pQueue,
PLIST_ENTRY pQueueToComplete,
PC0C_FDOPORT_START_ROUTINE pStartRoutine)
{
NTSTATUS status;
pQueue->pCurrent = pIrp;
pState->flags |= C0C_IRP_FLAG_IS_CURRENT;
if (pState->iQueue == C0C_QUEUE_WRITE) {
ULONG length = GetWriteLength(pIrp);
if (length) {
pIoPort->amountInWriteQueue += length;
UpdateTransmitToggle(pIoPort, pQueueToComplete);
}
}
status = pStartRoutine(pIoPort, pQueueToComplete);
if (status == STATUS_PENDING) {
pIrp->IoStatus.Status = STATUS_PENDING;
IoMarkIrpPending(pIrp);
} else {
status = NoPending(pIrp, status);
if (status != STATUS_PENDING) {
PIO_STACK_LOCATION pIrpStack;
if (pState->iQueue == C0C_QUEUE_WRITE) {
pIoPort->amountInWriteQueue -=
GetWriteLength(pIrp) - (ULONG)pIrp->IoStatus.Information;
}
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
if (status == STATUS_CANCELLED ||
(pIrpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
(pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_IMMEDIATE_CHAR ||
pIrpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_SERIAL_XOFF_COUNTER)))
{
pIrp->IoStatus.Information = 0;
}
}
if (pQueue->pCurrent == pIrp)
ShiftQueue(pQueue);
}
return status;
}
static NTSTATUS OnDeviceUsageNotificationCompleted (PDEVICE_OBJECT filterDeviceObject, PIRP Irp, VolumeFilterExtension *Extension)
{
if (Irp->PendingReturned)
IoMarkIrpPending (Irp);
if (!(Extension->LowerDeviceObject->Flags & DO_POWER_PAGABLE))
filterDeviceObject->Flags &= ~DO_POWER_PAGABLE;
IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);
return STATUS_CONTINUE_COMPLETION;
}
static NTSTATUS OnStartDeviceCompleted (PDEVICE_OBJECT filterDeviceObject, PIRP Irp, VolumeFilterExtension *Extension)
{
if (Irp->PendingReturned)
IoMarkIrpPending (Irp);
if (Extension->LowerDeviceObject->Characteristics & FILE_REMOVABLE_MEDIA)
filterDeviceObject->Characteristics |= FILE_REMOVABLE_MEDIA;
IoReleaseRemoveLock (&Extension->Queue.RemoveLock, Irp);
return STATUS_CONTINUE_COMPLETION;
}
