#include "fbtusr.h"
// Handle power events
-NTSTATUS FreeBT_DispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+NTSTATUS NTAPI FreeBT_DispatchPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
- NTSTATUS ntStatus;
+ NTSTATUS ntStatus = STATUS_SUCCESS;
PIO_STACK_LOCATION irpStack;
- PUNICODE_STRING tagString;
+ //PUNICODE_STRING tagString;
PDEVICE_EXTENSION deviceExtension;
irpStack = IoGetCurrentIrpStackLocation(Irp);
// it should return STATUS_PENDING and queue all incoming
// IRPs until the IRP completes.
if (Removed == deviceExtension->DeviceState)
- {
+ {
// Even if a driver fails the IRP, it must nevertheless call
// PoStartNextPowerIrp to inform the Power Manager that it
}
if (NotStarted == deviceExtension->DeviceState)
- {
+ {
// if the device is not started yet, pass it down
PoStartNextPowerIrp(Irp);
IoSkipCurrentIrpStackLocation(Irp);
FreeBT_IoIncrement(deviceExtension);
switch(irpStack->MinorFunction)
- {
+ {
case IRP_MN_SET_POWER:
// The Power Manager sends this IRP for one of the
// following reasons:
IoMarkIrpPending(Irp);
switch(irpStack->Parameters.Power.Type)
- {
+ {
case SystemPowerState:
HandleSystemSetPower(DeviceObject, Irp);
ntStatus = STATUS_PENDING;
IoMarkIrpPending(Irp);
switch(irpStack->Parameters.Power.Type)
- {
+ {
case SystemPowerState:
HandleSystemQueryPower(DeviceObject, Irp);
ntStatus = STATUS_PENDING;
PoStartNextPowerIrp(Irp);
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
if(!NT_SUCCESS(ntStatus))
- {
+ {
FreeBT_DbgPrint(1, ("FBTUSB: Lower drivers failed the wait-wake Irp\n"));
}
IoSkipCurrentIrpStackLocation(Irp);
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
if(!NT_SUCCESS(ntStatus))
- {
+ {
FreeBT_DbgPrint(1, ("FBTUSB: FreeBT_DispatchPower: Lower drivers failed this Irp\n"));
}
}
-NTSTATUS HandleSystemQueryPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+NTSTATUS NTAPI HandleSystemQueryPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
NTSTATUS ntStatus;
PDEVICE_EXTENSION deviceExtension;
// 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);
// if querying for a lower S-state, issue a wait-wake
if((systemState > deviceExtension->SysPower) && (deviceExtension->WaitWakeEnable))
- {
+ {
IssueWaitWake(deviceExtension);
}
}
-NTSTATUS HandleSystemSetPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
+NTSTATUS NTAPI HandleSystemSetPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp )
{
NTSTATUS ntStatus;
PDEVICE_EXTENSION deviceExtension;
}
-NTSTATUS HandleDeviceQueryPower(PDEVICE_OBJECT DeviceObject, PIRP Irp)
+NTSTATUS NTAPI HandleDeviceQueryPower(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{
NTSTATUS ntStatus;
PDEVICE_EXTENSION deviceExtension;
deviceExtension->DevPower - 1));
if (deviceExtension->WaitWakeEnable && deviceState > deviceExtension->DeviceCapabilities.DeviceWake)
- {
+ {
PoStartNextPowerIrp(Irp);
Irp->IoStatus.Status = ntStatus = STATUS_INVALID_DEVICE_STATE;
Irp->IoStatus.Information = 0;
}
if (deviceState < deviceExtension->DevPower)
- {
+ {
ntStatus = STATUS_SUCCESS;
}
else
- {
+ {
ntStatus = HoldIoRequests(DeviceObject, Irp);
if(STATUS_PENDING == ntStatus)
- {
+ {
return ntStatus;
}
Irp->IoStatus.Status = ntStatus;
Irp->IoStatus.Information = 0;
if(!NT_SUCCESS(ntStatus))
- {
+ {
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
else
- {
+ {
IoSkipCurrentIrpStackLocation(Irp);
ntStatus=PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
}
-NTSTATUS SysPoCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
+NTSTATUS NTAPI SysPoCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
NTSTATUS ntStatus;
- PIO_STACK_LOCATION irpStack;
+ PIO_STACK_LOCATION irpStack;
ntStatus = Irp->IoStatus.Status;
irpStack = IoGetCurrentIrpStackLocation(Irp);
// lower drivers failed this Irp
if(!NT_SUCCESS(ntStatus))
- {
+ {
PoStartNextPowerIrp(Irp);
FreeBT_DbgPrint(3, ("FBTUSB: SysPoCompletionRoutine::"));
FreeBT_IoDecrement(DeviceExtension);
// ..otherwise update the cached system power state (IRP_MN_SET_POWER)
if(irpStack->MinorFunction == IRP_MN_SET_POWER)
- {
+ {
DeviceExtension->SysPower = irpStack->Parameters.Power.State.SystemState;
}
}
-VOID SendDeviceIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP SIrp )
+VOID NTAPI SendDeviceIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP SIrp )
{
NTSTATUS ntStatus;
POWER_STATE powState;
powerContext = (PPOWER_COMPLETION_CONTEXT) ExAllocatePool(NonPagedPool, sizeof(POWER_COMPLETION_CONTEXT));
if (!powerContext)
- {
+ {
FreeBT_DbgPrint(1, ("FBTUSB: SendDeviceIrp: Failed to alloc memory for powerContext\n"));
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
else
- {
+ {
powerContext->DeviceObject = DeviceObject;
powerContext->SIrp = SIrp;
}
if (!NT_SUCCESS(ntStatus))
- {
+ {
if (powerContext)
- {
+ {
ExFreePool(powerContext);
}
}
-VOID DevPoCompletionRoutine(
+VOID NTAPI DevPoCompletionRoutine(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR MinorFunction,
IN POWER_STATE PowerState,
}
-NTSTATUS HandleDeviceSetPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+NTSTATUS NTAPI HandleDeviceSetPower(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
KIRQL oldIrql;
NTSTATUS ntStatus;
deviceExtension->DevPower - 1));
if (newDevState < oldDevState)
- {
+ {
FreeBT_DbgPrint(3, ("FBTUSB: HandleDeviceSetPower: Adding power to the device\n"));
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
- }
+ }
else
- {
+ {
// newDevState >= oldDevState
// hold I/O if transition from D0 -> DX (X = 1, 2, 3)
// if transition from D1 or D2 to deeper sleep states,
// I/O queue is already on hold.
if(PowerDeviceD0 == oldDevState && newDevState > oldDevState)
- {
+ {
// D0 -> DX transition
FreeBT_DbgPrint(3, ("FBTUSB: HandleDeviceSetPower: Removing power from the device\n"));
ntStatus = HoldIoRequests(DeviceObject, Irp);
if (!NT_SUCCESS(ntStatus))
- {
+ {
PoStartNextPowerIrp(Irp);
Irp->IoStatus.Status = ntStatus;
Irp->IoStatus.Information = 0;
}
else
- {
+ {
goto HandleDeviceSetPower_Exit;
}
}
else if (PowerDeviceD0 == oldDevState && PowerDeviceD0 == newDevState)
- {
+ {
// D0 -> D0
// unblock the queue which may have been blocked processing
// query irp
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, Irp);
if(!NT_SUCCESS(ntStatus))
- {
+ {
FreeBT_DbgPrint(1, ("FBTUSB: HandleDeviceSetPower: Lower drivers failed a power Irp\n"));
}
}
-NTSTATUS FinishDevPoUpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
+NTSTATUS NTAPI FinishDevPoUpIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
NTSTATUS ntStatus;
ntStatus = Irp->IoStatus.Status;
if(Irp->PendingReturned)
- {
+ {
IoMarkIrpPending(Irp);
}
if(!NT_SUCCESS(ntStatus))
- {
+ {
PoStartNextPowerIrp(Irp);
FreeBT_DbgPrint(3, ("FBTUSB: FinishDevPoUpIrp::"));
}
-NTSTATUS SetDeviceFunctional(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
+NTSTATUS NTAPI SetDeviceFunctional(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
KIRQL oldIrql;
NTSTATUS ntStatus;
// save/restore.
PoSetPowerState(DeviceObject, DevicePowerState, newState);
if(PowerDeviceD0 == newDevState)
- {
+ {
KeAcquireSpinLock(&DeviceExtension->DevStateLock, &oldIrql);
DeviceExtension->QueueState = AllowRequests;
KeReleaseSpinLock(&DeviceExtension->DevStateLock, oldIrql);
}
-NTSTATUS FinishDevPoDnIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
+NTSTATUS NTAPI FinishDevPoDnIrp(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
NTSTATUS ntStatus;
POWER_STATE newState;
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);
}
-NTSTATUS HoldIoRequests(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+NTSTATUS NTAPI HoldIoRequests(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
NTSTATUS ntStatus;
context = (PWORKER_THREAD_CONTEXT) ExAllocatePool(NonPagedPool, sizeof(WORKER_THREAD_CONTEXT));
if(context)
- {
+ {
item = IoAllocateWorkItem(DeviceObject);
context->Irp = Irp;
context->WorkItem = item;
if (item)
- {
+ {
IoMarkIrpPending(Irp);
IoQueueWorkItem(item, HoldIoRequestsWorkerRoutine, DelayedWorkQueue, context);
ntStatus = STATUS_PENDING;
}
else
- {
+ {
FreeBT_DbgPrint(3, ("FBTUSB: HoldIoRequests: Failed to allocate memory for workitem\n"));
ExFreePool(context);
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
else
- {
+ {
FreeBT_DbgPrint(1, ("FBTUSB: HoldIoRequests: Failed to alloc memory for worker thread context\n"));
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
-VOID HoldIoRequestsWorkerRoutine(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
+VOID NTAPI HoldIoRequestsWorkerRoutine(IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
{
PIRP irp;
NTSTATUS ntStatus;
// now send the Irp down
IoCopyCurrentIrpStackLocationToNext(irp);
IoSetCompletionRoutine(
- irp,
- (PIO_COMPLETION_ROUTINE) FinishDevPoDnIrp,
- deviceExtension,
- TRUE,
- TRUE,
- TRUE);
+ irp,
+ (PIO_COMPLETION_ROUTINE) FinishDevPoDnIrp,
+ deviceExtension,
+ TRUE,
+ TRUE,
+ TRUE);
ntStatus = PoCallDriver(deviceExtension->TopOfStackDeviceObject, irp);
if(!NT_SUCCESS(ntStatus))
- {
+ {
FreeBT_DbgPrint(1, ("FBTUSB: HoldIoRequestsWorkerRoutine: Lower driver fail a power Irp\n"));
}
}
-NTSTATUS QueueRequest(IN OUT PDEVICE_EXTENSION DeviceExtension, IN PIRP Irp)
+NTSTATUS NTAPI QueueRequest(IN OUT PDEVICE_EXTENSION DeviceExtension, IN PIRP Irp)
{
KIRQL oldIrql;
NTSTATUS ntStatus;
}
-VOID CancelQueued(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
+VOID NTAPI CancelQueued(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
PDEVICE_EXTENSION deviceExtension;
KIRQL oldIrql;
}
-NTSTATUS IssueWaitWake(IN PDEVICE_EXTENSION DeviceExtension)
+NTSTATUS NTAPI IssueWaitWake(IN PDEVICE_EXTENSION DeviceExtension)
{
POWER_STATE poState;
NTSTATUS ntStatus;
FreeBT_DbgPrint(3, ("FBTUSB: IssueWaitWake: Entered\n"));
if(InterlockedExchange(&DeviceExtension->FlagWWOutstanding, 1))
- {
+ {
return STATUS_DEVICE_BUSY;
}
&DeviceExtension->WaitWakeIrp);
if(!NT_SUCCESS(ntStatus))
- {
+ {
InterlockedExchange(&DeviceExtension->FlagWWOutstanding, 0);
}
}
-VOID CancelWaitWake(IN PDEVICE_EXTENSION DeviceExtension)
+VOID NTAPI CancelWaitWake(IN PDEVICE_EXTENSION DeviceExtension)
{
PIRP Irp;
Irp = (PIRP) InterlockedExchangePointer(&DeviceExtension->WaitWakeIrp, NULL);
if(Irp)
- {
+ {
IoCancelIrp(Irp);
if(InterlockedExchange(&DeviceExtension->FlagWWCancel, 1))
- {
+ {
PoStartNextPowerIrp(Irp);
Irp->IoStatus.Status = STATUS_CANCELLED;
Irp->IoStatus.Information = 0;
}
-NTSTATUS WaitWakeCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
+NTSTATUS NTAPI WaitWakeCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_EXTENSION DeviceExtension)
{
FreeBT_DbgPrint(3, ("FBTUSB: WaitWakeCompletionRoutine: Entered\n"));
if(Irp->PendingReturned)
- {
+ {
IoMarkIrpPending(Irp);
}
// 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;
// If FlagWWCancel != 0, complete the Irp.
// If FlagWWCancel == 0, CancelWaitWake completes it.
if(InterlockedExchange(&DeviceExtension->FlagWWCancel, 1))
- {
+ {
PoStartNextPowerIrp(Irp);
return STATUS_CANCELLED;
}
-VOID WaitWakeCallback(
+VOID NTAPI WaitWakeCallback(
IN PDEVICE_OBJECT DeviceObject,
IN UCHAR MinorFunction,
IN POWER_STATE PowerState,
InterlockedExchange(&deviceExtension->FlagWWOutstanding, 0);
if(!NT_SUCCESS(IoStatus->Status))
- {
+ {
return;
}
// wake up the device
if(deviceExtension->DevPower == PowerDeviceD0)
- {
+ {
FreeBT_DbgPrint(3, ("FBTUSB: WaitWakeCallback: Device already powered up...\n"));
return;
NULL);
if(deviceExtension->WaitWakeEnable)
- {
+ {
IssueWaitWake(deviceExtension);
}
}
-PCHAR PowerMinorFunctionString (IN UCHAR MinorFunction)
+PCHAR NTAPI PowerMinorFunctionString (IN UCHAR MinorFunction)
{
switch (MinorFunction)
- {
+ {
case IRP_MN_SET_POWER:
return "IRP_MN_SET_POWER\n";
projects / reactos.git / blobdiff