DECLHIDDEN(NTSTATUS) vboxUsbDispatchPower(IN PDEVICE_OBJECT pDeviceObject, IN PIRP pIrp)
{
PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pDeviceObject->DeviceExtension;
ENMVBOXUSB_PNPSTATE enmState = vboxUsbDdiStateRetainIfNotRemoved(pDevExt);
switch (enmState)
{
case ENMVBOXUSB_PNPSTATE_REMOVED:
{
PoStartNextPowerIrp(pIrp);
pIrp->IoStatus.Status = STATUS_DELETE_PENDING;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
vboxUsbDdiStateRelease(pDevExt);
return STATUS_DELETE_PENDING;
}
case ENMVBOXUSB_PNPSTATE_START_PENDING:
{
PoStartNextPowerIrp(pIrp);
IoSkipCurrentIrpStackLocation(pIrp);
vboxUsbDdiStateRelease(pDevExt);
return PoCallDriver(pDevExt->pLowerDO, pIrp);
}
default:
{
return vboxUsbPwrDispatch(pDevExt, pIrp);
}
}
}
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
NTAPI
USBSTOR_DispatchPower(
PDEVICE_OBJECT DeviceObject,
PIRP Irp)
{
PFDO_DEVICE_EXTENSION DeviceExtension;
// get common device extension
DeviceExtension = (PFDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
if (DeviceExtension->Common.IsFDO)
{
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(DeviceExtension->LowerDeviceObject, Irp);
}
else
{
PoStartNextPowerIrp(Irp);
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
}
NTSTATUS PPJoy_Power (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PDEVICE_EXTENSION DeviceExtension;
NTSTATUS ntStatus;
POWER_STATE PowerState;
POWER_STATE_TYPE PowerType;
PIO_STACK_LOCATION Stack;
PAGED_CODE ();
PPJOY_DBGPRINT (FILE_POWER | PPJOY_FENTRY, ("Enter PPJoy_Power(DeviceObject=0x%p,Irp=0x%p)",DeviceObject,Irp) );
DeviceExtension = GET_MINIDRIVER_DEVICE_EXTENSION (DeviceObject);
ntStatus= PPJoy_EnterRequest (DeviceExtension);
if (NT_SUCCESS(ntStatus))
{
Stack= IoGetCurrentIrpStackLocation (Irp);
PowerType= Stack->Parameters.Power.Type;
PowerState= Stack->Parameters.Power.State;
if ((Stack->MinorFunction==IRP_MN_SET_POWER)&&
(PowerType==DevicePowerState)&&
(PowerState.DeviceState==PowerDeviceD0))
{
PPJOY_DBGPRINT (FILE_POWER|PPJOY_BABBLE, ("We got a device D0 power state request for our device. Set parallel port mode again") );
/* Set the parallel port mode. */
PPJoy_InitPortAndInterface (DeviceObject);
}
/* Must be called before IoSkipCurrentIrpStackLocation, else bugcheck */
PoStartNextPowerIrp (Irp);
/* Prepare IRP stack for next driver */
IoSkipCurrentIrpStackLocation (Irp);
/* We call PoCallDriver since this is a Power IRP */
ntStatus= PoCallDriver (GET_NEXT_DEVICE_OBJECT (DeviceObject),Irp);
}
else
{
/* Must be called even when the device is removed */
PoStartNextPowerIrp (Irp);
Irp->IoStatus.Information= 0;
Irp->IoStatus.Status= ntStatus;
IoCompleteRequest (Irp,IO_NO_INCREMENT);
}
PPJoy_LeaveRequest (DeviceExtension);
PPJOY_EXITPROC (FILE_POWER|PPJOY_FEXIT, "PPJOY_Power",ntStatus);
return ntStatus;
}
NTSTATUS
XenM2BPdoPower(PDEVICE_OBJECT pDeviceObject, PIRP pIrp)
{
PXENM2B_PDO_EXTENSION pPdoExt = (PXENM2B_PDO_EXTENSION)pDeviceObject->DeviceExtension;
PIO_STACK_LOCATION pIrpStack;
POWER_STATE PowerState;
POWER_STATE_TYPE PowerType;
NTSTATUS Status = STATUS_SUCCESS;
pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
PowerType = pIrpStack->Parameters.Power.Type;
PowerState = pIrpStack->Parameters.Power.State;
switch (pIrpStack->MinorFunction) {
case IRP_MN_SET_POWER:
TraceDebug(("%s: IRP_MN_SET_POWER\n", __FUNCTION__));
if (PowerType == DevicePowerState) {
TraceDebug(("%s: IRP_MN_SET_POWER DevicePowerState:%x\n", __FUNCTION__, PowerState.DeviceState));
PoSetPowerState(pPdoExt->pDevice, DevicePowerState, PowerState);
pPdoExt->DevicePowerState = PowerState.DeviceState;
}
else if (PowerType == SystemPowerState) {
TraceDebug(("%s: IRP_MN_SET_POWER SystemPowerState:%x\n", __FUNCTION__, PowerState.SystemState));
pPdoExt->SystemPowerState = PowerState.SystemState;
}
PoStartNextPowerIrp(pIrp);
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
break;
case IRP_MN_QUERY_POWER:
TraceDebug(("%s: IRP_MN_QUERY_POWER\n", __FUNCTION__));
PoStartNextPowerIrp(pIrp);
pIrp->IoStatus.Status = Status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
break;
case IRP_MN_WAIT_WAKE:
case IRP_MN_POWER_SEQUENCE:
default:
PoStartNextPowerIrp(pIrp);
Status = pIrp->IoStatus.Status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
break;
}
return Status;
}
static
NTSTATUS dc_process_power_irp(dev_hook *hook, PIRP irp)
{
NTSTATUS status;
PIO_STACK_LOCATION irp_sp;
int no_pass = 0;
irp_sp = IoGetCurrentIrpStackLocation(irp);
if ( (irp_sp->MinorFunction == IRP_MN_SET_POWER) &&
(irp_sp->Parameters.Power.Type == SystemPowerState) )
{
wait_object_infinity(&hook->busy_lock);
if (irp_sp->Parameters.Power.State.SystemState == PowerSystemHibernate)
{
/* prevent device encryption to sync device and memory state */
hook->flags |= F_PREVENT_ENC;
dc_send_sync_packet(hook->dev_name, S_OP_SYNC, 0);
}
if (irp_sp->Parameters.Power.State.SystemState == PowerSystemWorking) {
/* allow encryption requests */
hook->flags &= ~F_PREVENT_ENC;
}
KeReleaseMutex(&hook->busy_lock, FALSE);
}
if ( (irp_sp->MinorFunction == IRP_MN_QUERY_POWER) &&
(irp_sp->Parameters.Power.Type == SystemPowerState) &&
(irp_sp->Parameters.Power.State.SystemState == PowerSystemHibernate) )
{
if ( (dc_is_vista_or_later == 0) && (dump_is_pverent_hibernate() != 0) ) {
PoStartNextPowerIrp(irp);
status = dc_complete_irp(irp, STATUS_UNSUCCESSFUL, 0);
no_pass = 1;
}
}
if (no_pass == 0) {
PoStartNextPowerIrp(irp);
IoSkipCurrentIrpStackLocation(irp);
status = PoCallDriver(hook->orig_dev, irp);
}
IoReleaseRemoveLock(&hook->remv_lock, irp);
return status;
}
FORCEINLINE
VOID
FxIrp::StartNextPowerIrp(
)
{
PoStartNextPowerIrp(m_Irp);
}
NTSTATUS c0cPowerDispatch(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp)
{
NTSTATUS status;
PC0C_COMMON_EXTENSION pDevExt = pDevObj->DeviceExtension;
HALT_UNLESS2(IoGetCurrentIrpStackLocation(pIrp)->MajorFunction == IRP_MJ_POWER,
IoGetCurrentIrpStackLocation(pIrp)->MajorFunction,
IoGetCurrentIrpStackLocation(pIrp)->MinorFunction);
TraceIrp("POWER", pIrp, NULL, TRACE_FLAG_PARAMS);
switch (pDevExt->doType) {
case C0C_DOTYPE_FB:
case C0C_DOTYPE_FP:
PoStartNextPowerIrp(pIrp);
IoSkipCurrentIrpStackLocation(pIrp);
status = PoCallDriver(((PC0C_COMMON_FDO_EXTENSION)pDevExt)->pLowDevObj, pIrp);
break;
case C0C_DOTYPE_PP:
status = PdoPortPower((PC0C_PDOPORT_EXTENSION)pDevExt, pIrp);
break;
default:
status = STATUS_NO_SUCH_DEVICE;
pIrp->IoStatus.Status = status;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
}
return status;
}
NTSTATUS PPJoyBus_Power (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
NTSTATUS ntStatus;
PCOMMON_DATA CommonData;
PAGED_CODE ();
PPJOY_DBGPRINT (FILE_PPJOYBUS|PPJOY_FENTRY, ("PPJoyBus_Power(DeviceObject=0x%p,Irp=0x%p)",DeviceObject,Irp) );
CommonData= DeviceObject->DeviceExtension;
ntStatus= PPJoyBus_EnterRequest(CommonData);
if (!NT_SUCCESS(ntStatus))
{
/* Must always call PoStartNextPowerIrp()!!! */
PoStartNextPowerIrp (Irp);
/* Set status in IRP and complete the request */
Irp->IoStatus.Status= ntStatus;
IoCompleteRequest (Irp,IO_NO_INCREMENT);
goto Exit;
}
if (CommonData->Flags&PPJFLAGS_ISBUSDEV)
ntStatus= PPJoyBus_Power_Bus (DeviceObject,Irp);
else
ntStatus= PPJoyBus_Power_Joy (DeviceObject,Irp);
Exit:
PPJoyBus_LeaveRequest(CommonData);
PPJOY_EXITPROC (FILE_PPJOYBUS|PPJOY_FEXIT_STATUSOK, "PPJoyBus_Power",ntStatus);
return ntStatus;
}
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...
}
//----------------------------------------------------------------------------------------------
// SendAndWaitPowerRequest
//----------------------------------------------------------------------------------------------
NTSTATUS SendAndWaitPowerRequest(
IN PDEVICE_OBJECT DeviceObject
,IN PIRP Irp )
{
// 変数宣言
NTSTATUS Status;
KEVENT WaitEvent;
// 下位ドライバに I/O 要求を発行する
KeInitializeEvent( &WaitEvent, NotificationEvent, FALSE );
PoStartNextPowerIrp( Irp );
IoCopyCurrentIrpStackLocationToNext( Irp );
IoSetCompletionRoutine(
Irp
,(PIO_COMPLETION_ROUTINE)IoCompletionRoutine
,(PVOID)&WaitEvent
,TRUE
,TRUE
,TRUE );
#if (NTDDI_VERSION < NTDDI_LONGHORN)
Status = PoCallDriver( GET_NEXT_DEVICE_OBJECT( DeviceObject ), Irp );
#else
Status = IoCallDriver( GET_NEXT_DEVICE_OBJECT( DeviceObject ), Irp );
#endif
// 下位ドライバの処理が完了するまで待機する
if( Status == STATUS_PENDING )
{
KeWaitForSingleObject( &WaitEvent, Executive, KernelMode, FALSE, NULL );
Status = Irp->IoStatus.Status;
}
return( Status );
}
/*++////////////////////////////////////////////////////////////////////////////
ClassDispatchPower()
Routine Description:
This routine acquires the removelock for the irp and then calls the
appropriate power callback.
Arguments:
DeviceObject -
Irp -
Return Value:
--*/
NTSTATUS
NTAPI
ClassDispatchPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
ULONG isRemoved;
//
// NOTE: This code may be called at PASSIVE or DISPATCH, depending
// upon the device object it is being called for.
// don't do anything that would break under either circumstance.
//
isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
if(isRemoved) {
ClassReleaseRemoveLock(DeviceObject, Irp);
Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
PoStartNextPowerIrp(Irp);
ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
return STATUS_DEVICE_DOES_NOT_EXIST;
}
return commonExtension->DevInfo->ClassPowerDevice(DeviceObject, Irp);
} // end ClassDispatchPower()
static NTSTATUS vboxUsbPwrSetPowerDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp)
{
PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp);
DEVICE_POWER_STATE enmDevPState = pSl->Parameters.Power.State.DeviceState;
DEVICE_POWER_STATE enmCurDevPState = pDevExt->DdiState.PwrState.PowerState.DeviceState;
NTSTATUS Status = STATUS_SUCCESS;
if (enmDevPState > enmCurDevPState && enmCurDevPState == PowerDeviceD0)
{
Status = vboxUsbPwrIoWaitCompletionAndPostAsync(pDevExt, pIrp);
Assert(NT_SUCCESS(Status));
if (NT_SUCCESS(Status))
return Status;
}
PoStartNextPowerIrp(pIrp);
if (NT_SUCCESS(Status))
{
IoCopyCurrentIrpStackLocationToNext(pIrp);
IoSetCompletionRoutine(pIrp, vboxUsbPwrIoPostDevCompletion, pDevExt, TRUE, TRUE, TRUE);
Status = PoCallDriver(pDevExt->pLowerDO, pIrp);
}
else
{
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
IoCompleteRequest(pIrp, IO_NO_INCREMENT);
vboxUsbDdiStateRelease(pDevExt);
}
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;
}
static NTSTATUS vboxUsbPwrIoPostSysCompletion(IN PDEVICE_OBJECT pDevObj, IN PIRP pIrp, IN PVOID pvContext)
{
PVBOXUSBDEV_EXT pDevExt = (PVBOXUSBDEV_EXT)pvContext;
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.SystemState = pSl->Parameters.Power.State.SystemState;
break;
}
default:
{
break;
}
}
return vboxUsbPwrIoRequestDev(pDevExt, pIrp);
}
PoStartNextPowerIrp(pIrp);
vboxUsbDdiStateRelease(pDevExt);
return STATUS_SUCCESS;
}
NTSTATUS
NTAPI
PciPassIrpFromFdoToPdo(IN PPCI_FDO_EXTENSION DeviceExtension,
IN PIRP Irp)
{
PIO_STACK_LOCATION IoStackLocation;
NTSTATUS Status;
DPRINT1("Pci PassIrp ...\n");
/* Get the stack location to check which function this is */
IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
if (IoStackLocation->MajorFunction == IRP_MJ_POWER)
{
/* Power IRPs are special since we have to notify the Power Manager */
IoCopyCurrentIrpStackLocationToNext(Irp);
PoStartNextPowerIrp(Irp);
Status = PoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
}
else
{
/* For a normal IRP, just call the next driver in the stack */
IoSkipCurrentIrpStackLocation(Irp);
Status = IoCallDriver(DeviceExtension->AttachedDeviceObject, Irp);
}
/* Return the status back to the caller */
return Status;
}
NTSTATUS
HidUmdfPowerPassThrough(
_In_ PDEVICE_OBJECT DeviceObject,
_Inout_ PIRP Irp
)
/*++
Routine Description:
Pass through routine for power IRPs .
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
PoStartNextPowerIrp(Irp);
IoCopyCurrentIrpStackLocationToNext(Irp);
return PoCallDriver(GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
}
VOID
CALLBACK
PwrCompletionFunction(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR MinorFunction,
IN POWER_STATE PowerState,
IN PVOID Context,
IN PIO_STATUS_BLOCK IoStatus)
{
NTSTATUS Status;
PQUERY_POWER_CONTEXT PwrContext = (PQUERY_POWER_CONTEXT)Context;
if (NT_SUCCESS(IoStatus->Status))
{
// forward request to lower device object
Status = PcForwardIrpSynchronous(PwrContext->DeviceObject, PwrContext->Irp);
}
else
{
// failed
Status = IoStatus->Status;
}
// start next power irp
PoStartNextPowerIrp(PwrContext->Irp);
// complete request
PwrContext->Irp->IoStatus.Status = Status;
IoCompleteRequest(PwrContext->Irp, IO_NO_INCREMENT);
// free context
FreeItem(PwrContext, TAG_PORTCLASS);
}
static NTSTATUS vboxUsbPwrIoRequestDev(IN PVBOXUSBDEV_EXT pDevExt, IN PIRP pIrp)
{
PIO_STACK_LOCATION pSl = IoGetCurrentIrpStackLocation(pIrp);
POWER_STATE PwrState;
PwrState.SystemState = pSl->Parameters.Power.State.SystemState;
PwrState.DeviceState = pDevExt->DdiState.DevCaps.DeviceState[PwrState.SystemState];
NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
PVBOXUSB_PWRDEV_CTX pDevCtx = (PVBOXUSB_PWRDEV_CTX)vboxUsbMemAlloc(sizeof (*pDevCtx));
Assert(pDevCtx);
if (pDevCtx)
{
pDevCtx->pDevExt = pDevExt;
pDevCtx->pIrp = pIrp;
Status = PoRequestPowerIrp(pDevExt->pPDO, pSl->MinorFunction, PwrState,
vboxUsbPwrIoDeviceCompletion, pDevCtx, NULL);
Assert(NT_SUCCESS(Status));
if (NT_SUCCESS(Status))
{
return STATUS_MORE_PROCESSING_REQUIRED;
}
vboxUsbMemFree(pDevCtx);
}
PoStartNextPowerIrp(pIrp);
pIrp->IoStatus.Status = Status;
pIrp->IoStatus.Information = 0;
vboxUsbDdiStateRelease(pDevExt);
/* the "real" Status is stored in pIrp->IoStatus.Status,
* return success here to complete the Io */
return STATUS_SUCCESS;
}
//========================================================================================
// Function: DispatchPower
// Purpose: This routine is the dispatch routine for power irps.
// Does nothing except forwarding the IRP to the next device in the stack.
// Return Value:
// NT status code
//========================================================================================
NTSTATUS
DispatchPower(
IN PDEVICE_OBJECT fido, // fido - Pointer to the device object.
IN PIRP irp // Irp - Pointer to the request packet.
)
{
PDEVICE_EXTENSION dx;
NTSTATUS ntStatus;
dx = (PDEVICE_EXTENSION)fido->DeviceExtension;
PoStartNextPowerIrp(irp);
//acquire remove lock
ntStatus=IoAcquireRemoveLock(&dx->rmLock, irp);
if (!NT_SUCCESS(ntStatus))
{
//complete irp if cannot acquire remove lock
irp->IoStatus.Status=ntStatus;
irp->IoStatus.Information=0;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return ntStatus;
}
IoSkipCurrentIrpStackLocation(irp);
ntStatus = PoCallDriver(dx->lowerdo, irp);
IoReleaseRemoveLock(&dx->rmLock, irp);
return ntStatus;
}
NTSTATUS
DF_DispatchPower(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
PDF_DEVICE_EXTENSION DevExt;
PIO_STACK_LOCATION IrpSp;
PAGED_CODE();
DevExt = (PDF_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
IrpSp = IoGetCurrentIrpStackLocation(Irp);
DBG_PRINT(DBG_TRACE_ROUTINES, ("%s: ", __FUNCTION__));
if (IrpSp->Parameters.Power.Type == SystemPowerState)
{
DBG_PRINT(DBG_TRACE_OPS, ("SystemPowerState...\n"));
if (PowerSystemShutdown == IrpSp->Parameters.Power.State.SystemState)
{
DBG_PRINT(DBG_TRACE_OPS, ("%d-%d: Stopping Device...\n", DevExt->DiskNumber, DevExt->PartitionNumber));
StopDevice(DeviceObject);
DBG_PRINT(DBG_TRACE_OPS, ("%d-%d: Device Stopped.\n", DevExt->DiskNumber, DevExt->PartitionNumber));
}
}
else if (IrpSp->Parameters.Power.Type == DevicePowerState)
DBG_PRINT(DBG_TRACE_OPS, ("DevicePowerState...\n"));
else
DBG_PRINT(DBG_TRACE_OPS, ("\n"));
#if WINVER < _WIN32_WINNT_VISTA
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(DevExt->LowerDeviceObject, Irp);
#else
IoSkipCurrentIrpStackLocation(Irp);
return IoCallDriver(DevExt->LowerDeviceObject, Irp);
#endif
}
NTSTATUS
HidKmdfPowerPassThrough(
__in PDEVICE_OBJECT DeviceObject,
__in PIRP Irp
)
/*++
Routine Description:
Pass through routine for power IRPs .
Arguments:
DeviceObject - pointer to a device object.
Irp - pointer to an I/O Request Packet.
Return Value:
NT status code
--*/
{
//
// Must start the next power irp before skipping to the next stack location
//
PoStartNextPowerIrp(Irp);
//
// Copy current stack to next instead of skipping. We do this to preserve
// current stack information provided by hidclass driver to the minidriver
//
IoCopyCurrentIrpStackLocationToNext(Irp);
return PoCallDriver(GET_NEXT_DEVICE_OBJECT(DeviceObject), Irp);
}
NTSTATUS
YtDispatchFilterPower(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PDEVICE_EXTENSION deviceExtension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
NTSTATUS status;
if (KeGetCurrentIrql() <= DISPATCH_LEVEL)
{
status = IoAcquireRemoveLock(&deviceExtension->RemoveLock, Irp);
if(!NT_SUCCESS(status))
{
Irp->IoStatus.Status = status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return status;
}
}
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
status = PoCallDriver(deviceExtension->TargetDeviceObject, Irp);
if (KeGetCurrentIrql() <= DISPATCH_LEVEL)
IoReleaseRemoveLock(&deviceExtension->RemoveLock, NULL);
return status;
}
NTSTATUS
MouFilter_Power(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
/*++
Routine Description:
This routine is the dispatch routine for power irps Does nothing except
record the state of the device.
Arguments:
DeviceObject - Pointer to the device object.
Irp - Pointer to the request packet.
Return Value:
Status is returned.
--*/
{
PIO_STACK_LOCATION irpStack;
PDEVICE_EXTENSION devExt;
POWER_STATE powerState;
POWER_STATE_TYPE powerType;
PAGED_CODE();
DbgPrint(("MouFilter_Power() called\n"));
devExt = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
irpStack = IoGetCurrentIrpStackLocation(Irp);
powerType = irpStack->Parameters.Power.Type;
powerState = irpStack->Parameters.Power.State;
switch (irpStack->MinorFunction) {
case IRP_MN_SET_POWER:
if (powerType == DevicePowerState) {
devExt->DeviceState = powerState.DeviceState;
}
case IRP_MN_QUERY_POWER:
case IRP_MN_WAIT_WAKE:
case IRP_MN_POWER_SEQUENCE:
default:
break;
}
// The PoStartNextPowerIrp routine signals the power manager that the driver is ready to handle the next power IRP.
// This routine must be called by every driver in the device stack - from the April 2005 MSDN Library
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
return PoCallDriver(devExt->TopOfStack, Irp);
}
NTSTATUS NTAPI FinishDevPoDnIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
NTSTATUS ntStatus;
POWER_STATE newState;
PIO_STACK_LOCATION irpStack;
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoDnIrp: Entered\n"));
ntStatus = Irp->IoStatus.Status;
irpStack = IoGetCurrentIrpStackLocation(Irp);
newState = irpStack->Parameters.Power.State;
if (NT_SUCCESS(ntStatus) && irpStack->MinorFunction == IRP_MN_SET_POWER)
{
FreeBT_DbgPrint(3, ("FBTUSB: updating cache..\n"));
DeviceExtension->DevPower = newState.DeviceState;
PoSetPowerState(DeviceObject, DevicePowerState, newState);
}
PoStartNextPowerIrp(Irp);
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoDnIrp::"));
FreeBT_IoDecrement(DeviceExtension);
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoDnIrp: Leaving\n"));
return STATUS_SUCCESS;
}
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;
}
VOID NTAPI DevPoCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR MinorFunction,
IN POWER_STATE PowerState,
IN PVOID Context,
IN PIO_STATUS_BLOCK IoStatus
)
{
PIRP sIrp;
PDEVICE_EXTENSION deviceExtension;
PPOWER_COMPLETION_CONTEXT powerContext;
powerContext = (PPOWER_COMPLETION_CONTEXT) Context;
sIrp = powerContext->SIrp;
deviceExtension = (PDEVICE_EXTENSION) powerContext->DeviceObject->DeviceExtension;
FreeBT_DbgPrint(3, ("FBTUSB: DevPoCompletionRoutine: Entered\n"));
sIrp->IoStatus.Status = IoStatus->Status;
PoStartNextPowerIrp(sIrp);
sIrp->IoStatus.Information = 0;
IoCompleteRequest(sIrp, IO_NO_INCREMENT);
FreeBT_DbgPrint(3, ("FBTUSB: DevPoCompletionRoutine::"));
FreeBT_IoDecrement(deviceExtension);
ExFreePool(powerContext);
FreeBT_DbgPrint(3, ("FBTUSB: DevPoCompletionRoutine: Leaving\n"));
}
NTSTATUS
NTAPI
USBH_PdoPower(IN PUSBHUB_PORT_PDO_EXTENSION PortExtension,
IN PIRP Irp,
IN UCHAR Minor)
{
NTSTATUS Status = Irp->IoStatus.Status;
DPRINT_PWR("USBH_FdoPower: PortExtension - %p, Irp - %p, Minor - %X\n",
PortExtension,
Irp,
Minor);
switch (Minor)
{
case IRP_MN_WAIT_WAKE:
DPRINT_PWR("USBHUB_PdoPower: IRP_MN_WAIT_WAKE\n");
PoStartNextPowerIrp(Irp);
break;
case IRP_MN_POWER_SEQUENCE:
DPRINT_PWR("USBHUB_PdoPower: IRP_MN_POWER_SEQUENCE\n");
PoStartNextPowerIrp(Irp);
break;
case IRP_MN_SET_POWER:
DPRINT_PWR("USBHUB_PdoPower: IRP_MN_SET_POWER\n");
PoStartNextPowerIrp(Irp);
break;
case IRP_MN_QUERY_POWER:
DPRINT_PWR("USBHUB_PdoPower: IRP_MN_QUERY_POWER\n");
PoStartNextPowerIrp(Irp);
break;
default:
DPRINT1("USBHUB_PdoPower: unknown IRP_MN_POWER!\n");
PoStartNextPowerIrp(Irp);
break;
}
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
NTSTATUS
FinishDevPoDnIrp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp,
IN PDEVICE_EXTENSION DeviceExtension
)
/*++
Routine Description:
This routine is the completion routine for device power DOWN irp.
Arguments:
DeviceObject - pointer to device object
Irp - I/O request packet
DeviceExtension - pointer to device extension
Return Value:
NT status value
--*/
{
NTSTATUS ntStatus;
POWER_STATE newState;
PIO_STACK_LOCATION irpStack;
//
// initialize variables
//
ntStatus = Irp->IoStatus.Status;
irpStack = IoGetCurrentIrpStackLocation(Irp);
newState = irpStack->Parameters.Power.State;
MobiUsb_DbgPrint(3, ("file mobipwr: FinishDevPoDnIrp - begins\n"));
if(NT_SUCCESS(ntStatus) && irpStack->MinorFunction == IRP_MN_SET_POWER) {
//
// update the cache;
//
MobiUsb_DbgPrint(3, ("file mobipwr: updating cache..\n"));
DeviceExtension->DevPower = newState.DeviceState;
PoSetPowerState(DeviceObject, DevicePowerState, newState);
}
PoStartNextPowerIrp(Irp);
MobiUsb_DbgPrint(3, ("file mobipwr: FinishDevPoDnIrp::"));
MobiUsb_IoDecrement(DeviceExtension);
MobiUsb_DbgPrint(3, ("file mobipwr: FinishDevPoDnIrp - ends\n"));
return STATUS_SUCCESS;
}
NTSTATUS NTAPI HandleSystemQueryPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
NTSTATUS ntStatus;
PDEVICE_EXTENSION deviceExtension;
SYSTEM_POWER_STATE systemState;
PIO_STACK_LOCATION irpStack;
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemQueryPower: Entered\n"));
// initialize variables
deviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
irpStack = IoGetCurrentIrpStackLocation(Irp);
systemState = irpStack->Parameters.Power.State.SystemState;
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemQueryPower: Query for system power state S%X\n"
"FBTUSB: HandleSystemQueryPower: Current system power state S%X\n",
systemState - 1,
deviceExtension->SysPower - 1));
// Fail a query for a power state incompatible with waking up the system
if ((deviceExtension->WaitWakeEnable) && (systemState > deviceExtension->DeviceCapabilities.SystemWake))
{
FreeBT_DbgPrint(1, ("FBTUSB: HandleSystemQueryPower: Query for an incompatible system power state\n"));
PoStartNextPowerIrp(Irp);
Irp->IoStatus.Status = ntStatus = STATUS_INVALID_DEVICE_STATE;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemQueryPower::"));
FreeBT_IoDecrement(deviceExtension);
return ntStatus;
}
// if querying for a lower S-state, issue a wait-wake
if((systemState > deviceExtension->SysPower) && (deviceExtension->WaitWakeEnable))
{
IssueWaitWake(deviceExtension);
}
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(
Irp,
(PIO_COMPLETION_ROUTINE)SysPoCompletionRoutine,
deviceExtension,
TRUE,
TRUE,
TRUE);
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
FreeBT_DbgPrint(3, ("FBTUSB: HandleSystemQueryPower: Leaving\n"));
return STATUS_PENDING;
}
