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; }