You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2010 lines
63 KiB
2010 lines
63 KiB
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
bsrv.c
|
|
|
|
Abstract:
|
|
|
|
Service battery class device
|
|
|
|
Author:
|
|
|
|
Ken Reneris
|
|
|
|
Environment:
|
|
|
|
Notes:
|
|
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "battcp.h"
|
|
|
|
VOID
|
|
BattCIoctl (
|
|
IN PBATT_INFO BattInfo,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp
|
|
);
|
|
|
|
VOID
|
|
BattCCheckTagQueue (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN PBATT_INFO BattInfo
|
|
);
|
|
|
|
VOID
|
|
BattCCheckStatusQueue (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN PBATT_INFO BattInfo
|
|
);
|
|
|
|
VOID
|
|
BattCWmi (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN PBATT_INFO BattInfo,
|
|
IN PBATT_WMI_REQUEST WmiRequest
|
|
);
|
|
|
|
VOID
|
|
BattCMiniportStatus (
|
|
IN PBATT_INFO BattInfo,
|
|
IN NTSTATUS Status
|
|
);
|
|
|
|
VOID
|
|
BattCCompleteIrpQueue (
|
|
IN PLIST_ENTRY Queue,
|
|
IN NTSTATUS Status
|
|
);
|
|
|
|
VOID
|
|
BattCCompleteWmiQueue (
|
|
IN PLIST_ENTRY Queue,
|
|
IN NTSTATUS Status
|
|
);
|
|
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(PAGE,BattCCheckStatusQueue)
|
|
#pragma alloc_text(PAGE,BattCCheckTagQueue)
|
|
#pragma alloc_text(PAGE,BattCWorkerThread)
|
|
#pragma alloc_text(PAGE,BattCIoctl)
|
|
#endif
|
|
|
|
VOID
|
|
BattCWorkerDpc (
|
|
IN struct _KDPC *Dpc,
|
|
IN PVOID DeferredContext,
|
|
IN PVOID SystemArgument1,
|
|
IN PVOID SystemArgument2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
DPC used to get worker thread when status needs to be checked.
|
|
|
|
Arguments:
|
|
|
|
Dpc - the worker dpc
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PBATT_NP_INFO BattNPInfo;
|
|
|
|
BattNPInfo = (PBATT_NP_INFO) DeferredContext;
|
|
BattCQueueWorker (BattNPInfo, TRUE);
|
|
// Release Removal Lock
|
|
if (0 == InterlockedDecrement(&BattNPInfo->InUseCount)) {
|
|
KeSetEvent (&BattNPInfo->ReadyToRemove, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
BattPrint ((BATT_LOCK), ("BattCWorkerDpc: Released remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
BattCTagDpc (
|
|
IN struct _KDPC *Dpc,
|
|
IN PVOID DeferredContext,
|
|
IN PVOID SystemArgument1,
|
|
IN PVOID SystemArgument2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
DPC used to get worker thread when status needs to be checked.
|
|
|
|
Arguments:
|
|
|
|
Dpc - the worker dpc
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PBATT_NP_INFO BattNPInfo;
|
|
|
|
BattNPInfo = (PBATT_NP_INFO) DeferredContext;
|
|
InterlockedExchange(&BattNPInfo->CheckTag, 1);
|
|
BattCQueueWorker (BattNPInfo, FALSE);
|
|
// Release Removal Lock
|
|
if (0 == InterlockedDecrement(&BattNPInfo->InUseCount)) {
|
|
KeSetEvent (&BattNPInfo->ReadyToRemove, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
BattPrint ((BATT_LOCK), ("BattCTagDpc: Released remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
BattCCancelStatus (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queued status IRP is being canceled
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Device object of the miniport. Not useful to the
|
|
class driver - ignored.
|
|
|
|
Irp - Irp being cancelled
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION IrpNextSp;
|
|
PBATT_NP_INFO BattNPInfo;
|
|
|
|
//
|
|
// IRP is flagged as needing cancled, cause a check status which will
|
|
// complete any pending cancled irps
|
|
//
|
|
|
|
IrpNextSp = IoGetNextIrpStackLocation(Irp);
|
|
BattNPInfo = (PBATT_NP_INFO) IrpNextSp->Parameters.Others.Argument4;
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BatteryCCancelStatus. Irp - %08x\n", BattNPInfo->DeviceNum, Irp));
|
|
|
|
BattCQueueWorker (BattNPInfo, TRUE);
|
|
|
|
//
|
|
// The cancel Spinlock must be released after attempting to queue the
|
|
// worker thread so that there is no timeing problems on remove.
|
|
//
|
|
IoReleaseCancelSpinLock(Irp->CancelIrql);
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
BattCCancelTag (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Queued tag IRP is being canceled
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Device object of the miniport. Not useful to the
|
|
class driver - ignored.
|
|
|
|
Irp - Irp being cancelled
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PIO_STACK_LOCATION IrpNextSp;
|
|
PBATT_NP_INFO BattNPInfo;
|
|
|
|
//
|
|
// IRP is flagged as needing canceled. Cause a check tag which will
|
|
// complete any pending cancled irps
|
|
//
|
|
|
|
IrpNextSp = IoGetNextIrpStackLocation(Irp);
|
|
BattNPInfo = (PBATT_NP_INFO) IrpNextSp->Parameters.Others.Argument4;
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BatteryCCancelTag. Irp - %08x\n", BattNPInfo->DeviceNum, Irp));
|
|
|
|
InterlockedExchange(&BattNPInfo->CheckTag, 1);
|
|
BattCQueueWorker (BattNPInfo, FALSE);
|
|
|
|
//
|
|
// The cancel Spinlock must be released after attempting to queue the
|
|
// worker thread so that there is no timeing problems on remove.
|
|
//
|
|
IoReleaseCancelSpinLock(Irp->CancelIrql);
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
BattCQueueWorker (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN BOOLEAN CheckStatus
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get worker thread to check the battery state (IoQueue). The
|
|
battery IOs are serialized here as only one worker thread is
|
|
used to process the battery IOs. If the worker thread is already
|
|
running, it is flagged to loop are re-check the state. If the
|
|
worker thread is not running, one is queued.
|
|
|
|
If CheckStatus is set, the worker thread is informed that the
|
|
batteries current status is read and the pending status queue
|
|
is checked.
|
|
|
|
Arguments:
|
|
|
|
BattNPInfo - Battery to check
|
|
|
|
CheckStatus - Whether or not the status also needs checked
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PBATT_INFO BattInfo = BattNPInfo->BattInfo;
|
|
|
|
//
|
|
// Add 1 to the WorkerActive value, if this is the first count
|
|
// queue a worker thread
|
|
//
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BatteryCQueueWorker.\n", BattNPInfo->DeviceNum));
|
|
|
|
if (CheckStatus) {
|
|
InterlockedExchange(&BattNPInfo->CheckStatus, 1);
|
|
InterlockedExchange (&BattNPInfo->CheckTag, 1);
|
|
}
|
|
|
|
//
|
|
// Increment WorkerActive count. If the worker thread is already running,
|
|
// there is no need to requeue it.
|
|
//
|
|
if (InterlockedIncrement(&BattNPInfo->WorkerActive) == 1) {
|
|
// Removal lock.
|
|
if ((BattNPInfo->WantToRemove == TRUE) && (KeGetCurrentIrql() == PASSIVE_LEVEL)) {
|
|
// Check Irql to make sure this wasn't called by an ISR. If so,
|
|
// queue the worker rather than complete the requests in this thread.
|
|
|
|
//
|
|
// Empty IRP queues.
|
|
//
|
|
BattCCompleteIrpQueue(&(BattInfo->IoQueue), STATUS_DEVICE_REMOVED);
|
|
BattCCompleteIrpQueue(&(BattInfo->TagQueue), STATUS_DEVICE_REMOVED);
|
|
BattCCompleteIrpQueue(&(BattInfo->StatusQueue), STATUS_DEVICE_REMOVED);
|
|
BattCCompleteIrpQueue(&(BattInfo->WmiQueue), STATUS_DEVICE_REMOVED);
|
|
|
|
//
|
|
// Remove lock and trigger Remove function if necessary.
|
|
//
|
|
if (0 == InterlockedDecrement(&BattNPInfo->InUseCount)) {
|
|
KeSetEvent (&BattNPInfo->ReadyToRemove, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
BattPrint ((BATT_LOCK), ("BattCQueueWorker: Released remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
|
|
} else {
|
|
ExQueueWorkItem (&BattNPInfo->WorkerThread, DelayedWorkQueue);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
BattCWorkerThread (
|
|
IN PVOID Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Battery IO worker thread entry point.
|
|
|
|
N.B. There is only one worker thread handling the battery at any one time
|
|
|
|
Arguments:
|
|
|
|
Context - BattInfo. Battery to check
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
PBATT_INFO BattInfo;
|
|
PBATT_NP_INFO BattNPInfo;
|
|
PLIST_ENTRY Entry;
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
ULONG i;
|
|
|
|
|
|
PAGED_CODE();
|
|
|
|
BattNPInfo = (PBATT_NP_INFO) Context;
|
|
BattInfo = BattNPInfo->BattInfo;
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BatteryCWorkerThread entered.\n", BattNPInfo->DeviceNum));
|
|
|
|
|
|
//
|
|
// Loop while there is work to check
|
|
//
|
|
|
|
for (; ;) {
|
|
// Removal code. This makes sure that the structures aren't freed in the middle of
|
|
// processing. All Irp Queues will be emptied by BatteryClassUnload.
|
|
if (BattNPInfo->WantToRemove == TRUE) {
|
|
//
|
|
// Empty IRP queues.
|
|
//
|
|
BattCCompleteIrpQueue(&(BattInfo->IoQueue), STATUS_DEVICE_REMOVED);
|
|
BattCCompleteIrpQueue(&(BattInfo->TagQueue), STATUS_DEVICE_REMOVED);
|
|
BattCCompleteIrpQueue(&(BattInfo->StatusQueue), STATUS_DEVICE_REMOVED);
|
|
BattCCompleteIrpQueue(&(BattInfo->WmiQueue), STATUS_DEVICE_REMOVED);
|
|
//
|
|
// Signal BatteryClassUnload that it is safe to return.
|
|
//
|
|
if (0 == InterlockedDecrement(&BattNPInfo->InUseCount)) {
|
|
KeSetEvent (&BattNPInfo->ReadyToRemove, IO_NO_INCREMENT, FALSE);
|
|
}
|
|
BattPrint ((BATT_LOCK), ("BattCWorkerThread: Released remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Acquire queue locks
|
|
//
|
|
|
|
ExAcquireFastMutex (&BattNPInfo->Mutex);
|
|
|
|
//
|
|
// While there are IRPs in the IoQueue handle them
|
|
//
|
|
|
|
while (!IsListEmpty(&BattInfo->IoQueue)) {
|
|
|
|
//
|
|
// Remove entry from IoQueue and drop device lock
|
|
//
|
|
|
|
Entry = RemoveHeadList(&BattInfo->IoQueue);
|
|
ExReleaseFastMutex (&BattNPInfo->Mutex);
|
|
|
|
|
|
//
|
|
// Handle this entry
|
|
//
|
|
|
|
Irp = CONTAINING_RECORD (
|
|
Entry,
|
|
IRP,
|
|
Tail.Overlay.ListEntry
|
|
);
|
|
|
|
BattPrint (BATT_IOCTL, ("BattC (%d): WorkerThread, Got Irp - %x\n", BattNPInfo->DeviceNum, Irp));
|
|
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
|
|
if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_BATTERY_QUERY_STATUS &&
|
|
IrpSp->Parameters.DeviceIoControl.InputBufferLength == sizeof (BATTERY_WAIT_STATUS) &&
|
|
IrpSp->Parameters.DeviceIoControl.OutputBufferLength == sizeof (BATTERY_STATUS)) {
|
|
|
|
BattPrint (BATT_IOCTL,
|
|
("BattC (%d): Received QueryStatus Irp - %x, timeout - %x\n",
|
|
BattNPInfo->DeviceNum,
|
|
Irp,
|
|
((PBATTERY_WAIT_STATUS)Irp->AssociatedIrp.SystemBuffer)->Timeout));
|
|
|
|
//
|
|
// Valid query status irp, put it on the StatusQueue and handle later
|
|
//
|
|
|
|
InterlockedExchange (&BattNPInfo->CheckStatus, 1);
|
|
IrpSp = IoGetNextIrpStackLocation(Irp);
|
|
IrpSp->Parameters.Others.Argument1 = (PVOID) 0;
|
|
IrpSp->Parameters.Others.Argument2 = (PVOID) 0;
|
|
IrpSp->Parameters.Others.Argument3 = NULL;
|
|
IrpSp->Parameters.Others.Argument4 = BattNPInfo;
|
|
|
|
//
|
|
// Set IRPs cancel routine
|
|
//
|
|
|
|
IoSetCancelRoutine (Irp, BattCCancelStatus);
|
|
|
|
//
|
|
// Queue it
|
|
//
|
|
|
|
InsertTailList (
|
|
&BattInfo->StatusQueue,
|
|
&Irp->Tail.Overlay.ListEntry
|
|
);
|
|
|
|
} else if (IrpSp->Parameters.DeviceIoControl.IoControlCode == IOCTL_BATTERY_QUERY_TAG &&
|
|
(IrpSp->Parameters.DeviceIoControl.InputBufferLength == sizeof (ULONG) ||
|
|
IrpSp->Parameters.DeviceIoControl.InputBufferLength == 0) &&
|
|
IrpSp->Parameters.DeviceIoControl.OutputBufferLength == sizeof (ULONG)) {
|
|
|
|
BattPrint (BATT_IOCTL,
|
|
("BattC (%d): Received QueryTag with timeout %x\n",
|
|
BattNPInfo->DeviceNum,
|
|
*((PULONG) Irp->AssociatedIrp.SystemBuffer))
|
|
);
|
|
|
|
//
|
|
// Valid query tag irp, put it on the TagQueue and handle later
|
|
//
|
|
|
|
InterlockedExchange (&BattNPInfo->CheckTag, 1);
|
|
IrpSp = IoGetNextIrpStackLocation(Irp);
|
|
IrpSp->Parameters.Others.Argument1 = (PVOID) 0;
|
|
IrpSp->Parameters.Others.Argument2 = (PVOID) 0;
|
|
IrpSp->Parameters.Others.Argument3 = NULL;
|
|
IrpSp->Parameters.Others.Argument4 = BattNPInfo;
|
|
|
|
|
|
//
|
|
// Set IRPs cancel routine
|
|
//
|
|
|
|
IoSetCancelRoutine (Irp, BattCCancelTag);
|
|
|
|
InsertTailList (
|
|
&BattInfo->TagQueue,
|
|
&Irp->Tail.Overlay.ListEntry
|
|
);
|
|
|
|
} else {
|
|
//
|
|
// Handle IRP now
|
|
//
|
|
|
|
BattPrint (BATT_IOCTL, ("BattC (%d): Calling BattCIoctl with irp %x\n", BattNPInfo->DeviceNum, Irp));
|
|
BattCIoctl (BattInfo, Irp, IrpSp);
|
|
}
|
|
|
|
//
|
|
// Acquire IoQueue lock and check for anything else in the IoQueueu
|
|
//
|
|
|
|
ExAcquireFastMutex (&BattNPInfo->Mutex);
|
|
}
|
|
|
|
//
|
|
// Done with the IoQueue
|
|
//
|
|
|
|
ExReleaseFastMutex (&BattNPInfo->Mutex);
|
|
|
|
//
|
|
// Check pending status queue
|
|
//
|
|
|
|
if (BattNPInfo->CheckStatus) {
|
|
BattCCheckStatusQueue (BattNPInfo, BattInfo);
|
|
}
|
|
|
|
|
|
//
|
|
// Check pending tag queue
|
|
//
|
|
|
|
if (BattNPInfo->CheckTag) {
|
|
BattCCheckTagQueue (BattNPInfo, BattInfo);
|
|
}
|
|
|
|
|
|
//
|
|
// Acquire queue locks
|
|
//
|
|
|
|
ExAcquireFastMutex (&BattNPInfo->Mutex);
|
|
|
|
//
|
|
// While there are outstanding WMI requests handle them
|
|
//
|
|
|
|
while (!IsListEmpty(&BattInfo->WmiQueue)) {
|
|
PBATT_WMI_REQUEST WmiRequest;
|
|
|
|
//
|
|
// Remove entry from WmiQueue and drop device lock
|
|
//
|
|
|
|
Entry = RemoveHeadList(&BattInfo->WmiQueue);
|
|
ExReleaseFastMutex (&BattNPInfo->Mutex);
|
|
|
|
|
|
//
|
|
// Handle this entry
|
|
//
|
|
|
|
WmiRequest = CONTAINING_RECORD (
|
|
Entry,
|
|
BATT_WMI_REQUEST,
|
|
ListEntry
|
|
);
|
|
|
|
BattPrint (BATT_WMI, ("BattC (%d): WorkerThread, Got WMI Rewest - %x\n", BattNPInfo->DeviceNum, WmiRequest));
|
|
|
|
//
|
|
// Process the request here.
|
|
//
|
|
|
|
BattCWmi (BattNPInfo, BattInfo, WmiRequest);
|
|
|
|
//
|
|
// Acquire IoQueue lock and check for anything else in the IoQueueu
|
|
//
|
|
|
|
ExAcquireFastMutex (&BattNPInfo->Mutex);
|
|
}
|
|
|
|
//
|
|
// Done with the IoQueue
|
|
//
|
|
|
|
ExReleaseFastMutex (&BattNPInfo->Mutex);
|
|
|
|
//
|
|
// See if we need to recheck
|
|
//
|
|
|
|
i = InterlockedDecrement(&BattNPInfo->WorkerActive);
|
|
BattPrint (BATT_TRACE, ("BattC (%d): WorkerActive count=%x\n", BattNPInfo->DeviceNum, i));
|
|
|
|
|
|
if (i == 0) {
|
|
// done
|
|
BattPrint (BATT_TRACE, ("BattC (%d): WorkerActive count is zero!\n", BattNPInfo->DeviceNum));
|
|
break;
|
|
}
|
|
|
|
//
|
|
// No need to loop multiple times, if count is not one lower it
|
|
//
|
|
|
|
if (i != 1) {
|
|
BattPrint (BATT_TRACE, ("BattC (%d): WorkerActive set to 1\n", BattNPInfo->DeviceNum));
|
|
InterlockedExchange(&BattNPInfo->WorkerActive, 1);
|
|
}
|
|
}
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BatteryCWorkerThread exiting.\n", BattNPInfo->DeviceNum));
|
|
|
|
}
|
|
|
|
VOID
|
|
BattCIoctl (
|
|
IN PBATT_INFO BattInfo,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Completes the battery IOCTL request.
|
|
|
|
N.B. must be invoked from the non-rentrant worker thread
|
|
|
|
Arguments:
|
|
|
|
BattInfo - Battery
|
|
|
|
Irp - IOCTL request
|
|
|
|
IrpSp - Current stack location
|
|
|
|
|
|
Return Value:
|
|
|
|
IRP has been completed
|
|
|
|
--*/
|
|
{
|
|
ULONG InputLen, OutputLen;
|
|
PVOID IOBuffer;
|
|
NTSTATUS Status;
|
|
PBATTERY_QUERY_INFORMATION QueryInfo;
|
|
PBATTERY_SET_INFORMATION SetInformation;
|
|
#if DEBUG
|
|
BATTERY_QUERY_INFORMATION_LEVEL inflevel;
|
|
#endif
|
|
|
|
PAGED_CODE();
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BattCIoctl called\n", BattInfo->BattNPInfo->DeviceNum));
|
|
|
|
IOBuffer = Irp->AssociatedIrp.SystemBuffer;
|
|
InputLen = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
|
|
OutputLen = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
|
|
|
|
//
|
|
// Dispatch IOCtl request to proper miniport function
|
|
//
|
|
|
|
Status = STATUS_INVALID_BUFFER_SIZE;
|
|
switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
|
|
case IOCTL_BATTERY_QUERY_TAG:
|
|
//
|
|
// Query tag only gets here if the input or output buffer lengths are
|
|
// wrong. Return STATUS_INVALID_BUFFER_SIZE
|
|
//
|
|
break;
|
|
|
|
case IOCTL_BATTERY_QUERY_INFORMATION:
|
|
if (InputLen != sizeof (BATTERY_QUERY_INFORMATION)) {
|
|
//
|
|
// Don't check size of the output buffer since it is variable size.
|
|
// This is checked in Mp.QueryInformation
|
|
//
|
|
// Return STATUS_INVALID_BUFFER_SIZE
|
|
//
|
|
break;
|
|
}
|
|
QueryInfo = (PBATTERY_QUERY_INFORMATION) IOBuffer;
|
|
|
|
#if DEBUG
|
|
inflevel = QueryInfo->InformationLevel;
|
|
#endif
|
|
|
|
Status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
QueryInfo->BatteryTag,
|
|
QueryInfo->InformationLevel,
|
|
QueryInfo->AtRate,
|
|
IOBuffer,
|
|
OutputLen,
|
|
&OutputLen
|
|
);
|
|
#if DEBUG
|
|
if (inflevel == BatteryInformation) {
|
|
BattInfo->FullChargedCap = ((PBATTERY_INFORMATION)IOBuffer)->FullChargedCapacity;
|
|
}
|
|
#endif
|
|
BattPrint ((BATT_MP_DATA), ("BattC (%d): Mp.QueryInformation status = %08x, Level = %d\n",
|
|
BattInfo->BattNPInfo->DeviceNum, Status, QueryInfo->InformationLevel));
|
|
break;
|
|
|
|
case IOCTL_BATTERY_QUERY_STATUS:
|
|
|
|
//
|
|
// Query status only gets here if the input or output buffer lengths are
|
|
// wrong. Return STATUS_INVALID_BUFFER_SIZE
|
|
//
|
|
break;
|
|
|
|
case IOCTL_BATTERY_SET_INFORMATION:
|
|
if ((InputLen < sizeof(BATTERY_SET_INFORMATION)) || (OutputLen != 0)) {
|
|
// Make Sure InputLen is at least the minimum size. It may be
|
|
// depending on the InformationLevel.
|
|
//
|
|
// This is checked in Mp.QueryInformation
|
|
break;
|
|
}
|
|
|
|
SetInformation = (PBATTERY_SET_INFORMATION) IOBuffer;
|
|
if (BattInfo->Mp.SetInformation != NULL) {
|
|
Status = BattInfo->Mp.SetInformation (
|
|
BattInfo->Mp.Context,
|
|
SetInformation->BatteryTag,
|
|
SetInformation->InformationLevel,
|
|
SetInformation->Buffer
|
|
);
|
|
BattPrint ((BATT_MP_DATA), ("BattC (%d): Mp.SetInformation status = %08x, Level = %d\n",
|
|
BattInfo->BattNPInfo->DeviceNum, Status, SetInformation->InformationLevel));
|
|
} else {
|
|
Status = STATUS_NOT_SUPPORTED;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
Status = STATUS_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
BattCMiniportStatus (BattInfo, Status);
|
|
Irp->IoStatus.Status = Status;
|
|
Irp->IoStatus.Information = OutputLen;
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
VOID
|
|
BattCCheckStatusQueue (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN PBATT_INFO BattInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the batteries current status, and checks the pending
|
|
status queue for possible IRP completion. Resets the miniport
|
|
notification settings if needed.
|
|
|
|
N.B. Must be invoked from the non-rentrant worker thread.
|
|
BattNPInfo->CheckStatus must be non-zero.
|
|
|
|
Arguments:
|
|
|
|
BattNPInfo - Battery
|
|
|
|
BattInfo - Battery
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
PBATTERY_WAIT_STATUS BatteryWaitStatus;
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IrpSp, IrpNextSp;
|
|
BATTERY_NOTIFY Notify;
|
|
LARGE_INTEGER NextTime;
|
|
LARGE_INTEGER CurrentTime;
|
|
LARGE_INTEGER li;
|
|
ULONG TimeIncrement;
|
|
BOOLEAN ReturnCurrentStatus;
|
|
NTSTATUS Status;
|
|
BOOLEAN StatusNotified = FALSE;
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BattCCheckStatusQueue called\n", BattInfo->BattNPInfo->DeviceNum));
|
|
|
|
PAGED_CODE();
|
|
TimeIncrement = KeQueryTimeIncrement();
|
|
|
|
//
|
|
// Loop while status needs checked, check pending status IRPs
|
|
//
|
|
|
|
while (InterlockedExchange(&BattNPInfo->CheckStatus, 0)) {
|
|
|
|
Notify.PowerState = BattInfo->Status.PowerState;
|
|
Notify.LowCapacity = 0;
|
|
Notify.HighCapacity = (ULONG) -1;
|
|
|
|
//
|
|
// Set to recheck no later than MIN_STATUS_POLL_RATE (3 min) from now.
|
|
//
|
|
|
|
NextTime.QuadPart = MIN_STATUS_POLL_RATE;
|
|
|
|
|
|
//
|
|
// If the StatusQueue is empty, the status doesn't need to be read
|
|
// at this time. BattNPInfo->StatusNotified is not modified
|
|
// so the next time an IRP comes through, we'll re-read the status.
|
|
// The local value of StatusNotified needs to be set correctly to
|
|
// disable notifications if necessary.
|
|
//
|
|
|
|
if (IsListEmpty (&BattInfo->StatusQueue)) {
|
|
StatusNotified = (BOOLEAN)BattNPInfo->StatusNotified;
|
|
break;
|
|
}
|
|
|
|
StatusNotified = FALSE;
|
|
|
|
//
|
|
// Pickup status notified flag
|
|
//
|
|
|
|
if (BattNPInfo->StatusNotified) {
|
|
|
|
InterlockedExchange (&BattNPInfo->StatusNotified, 0);
|
|
StatusNotified = TRUE;
|
|
|
|
// Reset the invalid data retry count when we get a notification.
|
|
#if DEBUG
|
|
if (BattInfo->InvalidRetryCount != 0) {
|
|
BattPrint (BATT_DEBUG, ("BattC (%d) Reset InvalidRetryCount\n", BattNPInfo->DeviceNum));
|
|
}
|
|
#endif
|
|
BattInfo->InvalidRetryCount = 0;
|
|
}
|
|
|
|
KeQueryTickCount (&CurrentTime);
|
|
CurrentTime.QuadPart = CurrentTime.QuadPart * TimeIncrement;
|
|
|
|
if (StatusNotified ||
|
|
CurrentTime.QuadPart - BattInfo->StatusTime > STATUS_VALID_TIME) {
|
|
|
|
//
|
|
// Get the batteries current status
|
|
//
|
|
|
|
Status = BattInfo->Mp.QueryStatus (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
&BattInfo->Status
|
|
);
|
|
|
|
if (!NT_SUCCESS(Status)) {
|
|
//
|
|
// Battery status is not valid, complete all pending status irps
|
|
//
|
|
|
|
BattPrint ((BATT_MP_ERROR), ("BattC (%d) CheckStatus: Status read err = %x\n", BattNPInfo->DeviceNum, Status));
|
|
|
|
BattCCompleteIrpQueue (&(BattInfo->StatusQueue), Status);
|
|
break;
|
|
}
|
|
|
|
BattPrint ((BATT_MP_DATA), ("BattC (%d) MP.QueryStatus: st[%08X] Cap[%08X] V[%08x] R[%08x]\n",
|
|
BattNPInfo->DeviceNum,
|
|
BattInfo->Status.PowerState,
|
|
BattInfo->Status.Capacity,
|
|
BattInfo->Status.Voltage,
|
|
BattInfo->Status.Rate
|
|
));
|
|
|
|
Notify.PowerState = BattInfo->Status.PowerState;
|
|
|
|
//
|
|
// Get the current time to compute timeouts on status query requests
|
|
//
|
|
|
|
KeQueryTickCount (&CurrentTime);
|
|
CurrentTime.QuadPart = CurrentTime.QuadPart * TimeIncrement;
|
|
BattInfo->StatusTime = CurrentTime.QuadPart;
|
|
}
|
|
|
|
//
|
|
// Check each pending Status IRP
|
|
//
|
|
|
|
BattPrint ((BATT_IOCTL_QUEUE), ("BattC (%d) Processing StatusQueue\n", BattNPInfo->DeviceNum));
|
|
|
|
Entry = BattInfo->StatusQueue.Flink;
|
|
while (Entry != &BattInfo->StatusQueue) {
|
|
|
|
//
|
|
// Get IRP to check
|
|
//
|
|
|
|
Irp = CONTAINING_RECORD (
|
|
Entry,
|
|
IRP,
|
|
Tail.Overlay.ListEntry
|
|
);
|
|
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
IrpNextSp = IoGetNextIrpStackLocation(Irp);
|
|
BatteryWaitStatus = (PBATTERY_WAIT_STATUS) Irp->AssociatedIrp.SystemBuffer;
|
|
|
|
#if DEBUG
|
|
if (BattInfo->FullChargedCap == 0) {
|
|
BattInfo->FullChargedCap = 1000;
|
|
}
|
|
#endif
|
|
BattPrint ((BATT_IOCTL_QUEUE), ("BattC (%d) StatusQueue: 0x%08x=%d -- 0x%08x=%d time=%08x, st=%08x\n",
|
|
BattNPInfo->DeviceNum,
|
|
BatteryWaitStatus->HighCapacity, (ULONG) (((LONGLONG) BatteryWaitStatus->HighCapacity * 1000) / BattInfo->FullChargedCap),
|
|
BatteryWaitStatus->LowCapacity, (ULONG) (((LONGLONG) BatteryWaitStatus->LowCapacity * 1000) / BattInfo->FullChargedCap),
|
|
BatteryWaitStatus->Timeout,
|
|
BatteryWaitStatus->PowerState));
|
|
|
|
//
|
|
// Get next request
|
|
//
|
|
|
|
Entry = Entry->Flink;
|
|
|
|
//
|
|
// If status is in error, or tag no longer matches abort the
|
|
// request accordingly
|
|
//
|
|
|
|
if (BattInfo->Tag != BatteryWaitStatus->BatteryTag) {
|
|
Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
|
|
}
|
|
|
|
//
|
|
// If IRP is flagged as cancelled, complete it
|
|
//
|
|
|
|
if (Irp->Cancel) {
|
|
Irp->IoStatus.Status = STATUS_CANCELLED;
|
|
}
|
|
|
|
//
|
|
// If request is still pending, check it
|
|
//
|
|
|
|
if (Irp->IoStatus.Status == STATUS_PENDING) {
|
|
|
|
ReturnCurrentStatus = FALSE;
|
|
|
|
if (BattInfo->Status.PowerState != BatteryWaitStatus->PowerState ||
|
|
BattInfo->Status.Capacity < BatteryWaitStatus->LowCapacity ||
|
|
BattInfo->Status.Capacity > BatteryWaitStatus->HighCapacity) {
|
|
|
|
BattPrint((BATT_IOCTL_DATA), ("BattC (%d) CheckStatusQueue, Returning Current Status, Asked For:\n"
|
|
"----------- Irp.PowerState = %x\n"
|
|
"----------- Irp.LowCapacity = %x\n"
|
|
"----------- Irp.HighCapacity = %x\n"
|
|
"----------- BattInfo.PowerState = %x\n"
|
|
"----------- BattInfo.Capacity = %x\n",
|
|
BattNPInfo->DeviceNum,
|
|
BatteryWaitStatus->PowerState,
|
|
BatteryWaitStatus->LowCapacity,
|
|
BatteryWaitStatus->HighCapacity,
|
|
BattInfo->Status.PowerState,
|
|
BattInfo->Status.Capacity)
|
|
);
|
|
|
|
//
|
|
// Complete this IRP with the current status
|
|
//
|
|
|
|
ReturnCurrentStatus = TRUE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Compute time when the request expires
|
|
//
|
|
|
|
BattPrint ((BATT_IOCTL_DATA), ("BattC (%d) CheckStatusQueue: Status Request %x Waiting For:\n"
|
|
"----------- Timeout = %x\n"
|
|
"----------- Irp.PowerState = %x\n"
|
|
"----------- Irp.LowCapacity = %x\n"
|
|
"----------- Irp.HighCapacity = %x\n",
|
|
BattNPInfo->DeviceNum,
|
|
Irp,
|
|
BatteryWaitStatus->Timeout,
|
|
BatteryWaitStatus->PowerState,
|
|
BatteryWaitStatus->LowCapacity,
|
|
BatteryWaitStatus->HighCapacity)
|
|
);
|
|
|
|
if (BatteryWaitStatus->Timeout &&
|
|
IrpNextSp->Parameters.Others.Argument1 == NULL &&
|
|
IrpNextSp->Parameters.Others.Argument2 == NULL) {
|
|
|
|
// initialize it
|
|
li.QuadPart = CurrentTime.QuadPart +
|
|
((ULONGLONG) BatteryWaitStatus->Timeout * NTMS);
|
|
|
|
IrpNextSp->Parameters.Others.Argument1 = (PVOID)((ULONG_PTR)li.LowPart);
|
|
IrpNextSp->Parameters.Others.Argument2 = (PVOID)((ULONG_PTR)li.HighPart);
|
|
}
|
|
|
|
li.LowPart = (ULONG)((ULONG_PTR)IrpNextSp->Parameters.Others.Argument1);
|
|
li.HighPart = (ULONG)((ULONG_PTR)IrpNextSp->Parameters.Others.Argument2);
|
|
li.QuadPart -= CurrentTime.QuadPart;
|
|
|
|
if (li.QuadPart <= 0) {
|
|
|
|
//
|
|
// Time's up, complete it
|
|
//
|
|
|
|
ReturnCurrentStatus = TRUE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// If waiting forever, no need to set a timer
|
|
//
|
|
if (BatteryWaitStatus->Timeout != 0xFFFFFFFF) {
|
|
|
|
//
|
|
// Check if this will be the next timeout time -- we will use
|
|
// the minimum timeout of the pending requests.
|
|
//
|
|
|
|
if (li.QuadPart < NextTime.QuadPart) {
|
|
NextTime.QuadPart = li.QuadPart;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!ReturnCurrentStatus) {
|
|
|
|
//
|
|
// IRP is still pending, calculate LCD of all waiting IRPs
|
|
//
|
|
|
|
if (BatteryWaitStatus->LowCapacity > Notify.LowCapacity) {
|
|
Notify.LowCapacity = BatteryWaitStatus->LowCapacity;
|
|
}
|
|
|
|
if (BatteryWaitStatus->HighCapacity < Notify.HighCapacity) {
|
|
Notify.HighCapacity = BatteryWaitStatus->HighCapacity;
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Return current battery status
|
|
//
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = sizeof(BattInfo->Status);
|
|
RtlCopyMemory (
|
|
Irp->AssociatedIrp.SystemBuffer,
|
|
&BattInfo->Status,
|
|
sizeof(BattInfo->Status)
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// If this request is no longer pending, complete it
|
|
//
|
|
|
|
if (Irp->IoStatus.Status != STATUS_PENDING) {
|
|
BattPrint (BATT_IOCTL,
|
|
("BattC (%d): completing QueryStatus irp - %x, status - %x\n",
|
|
BattNPInfo->DeviceNum,
|
|
Irp,
|
|
Irp->IoStatus.Status));
|
|
|
|
RemoveEntryList (&Irp->Tail.Overlay.ListEntry);
|
|
IoSetCancelRoutine (Irp, NULL);
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Status check complete
|
|
//
|
|
|
|
if (IsListEmpty (&BattInfo->StatusQueue)) {
|
|
|
|
//
|
|
// Nothing pending, if being notified disable the notifications
|
|
//
|
|
|
|
if (StatusNotified) {
|
|
BattInfo->Mp.DisableStatusNotify (BattInfo->Mp.Context);
|
|
BattInfo->StatusTime = 0;
|
|
BattPrint ((BATT_MP_DATA), ("BattC (%d) CheckStatus: called Mp.DisableStatusNotify\n", BattNPInfo->DeviceNum));
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Set notification setting
|
|
//
|
|
|
|
Status = BattInfo->Mp.SetStatusNotify (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
&Notify
|
|
);
|
|
|
|
if (NT_SUCCESS(Status)) {
|
|
|
|
//
|
|
// New notification set, remember it
|
|
//
|
|
|
|
BattPrint (BATT_MP_DATA, ("BattC (%d) Mp.SetStatusNotify: Notify set for: State=%x, Low=%x, High=%x\n",
|
|
BattNPInfo->DeviceNum,
|
|
Notify.PowerState,
|
|
Notify.LowCapacity,
|
|
Notify.HighCapacity
|
|
));
|
|
|
|
} else {
|
|
|
|
//
|
|
// Could not set notification, handle error
|
|
//
|
|
|
|
BattPrint (BATT_MP_ERROR, ("BattC (%d) Mp.SetStatusNotify: failed (%x), will poll\n", BattNPInfo->DeviceNum, Status));
|
|
BattCMiniportStatus (BattInfo, Status);
|
|
|
|
//
|
|
// Compute poll time
|
|
//
|
|
|
|
li.QuadPart = MIN_STATUS_POLL_RATE;
|
|
if (BattInfo->Status.Capacity == BATTERY_UNKNOWN_CAPACITY) {
|
|
// Retry 10 times at a polling rate of 1 second.
|
|
// Then revert to the slow polling rate.
|
|
if (BattInfo->InvalidRetryCount < INVALID_DATA_MAX_RETRY) {
|
|
BattInfo->InvalidRetryCount++;
|
|
li.QuadPart = INVALID_DATA_POLL_RATE;
|
|
BattPrint (BATT_DEBUG, ("BattC (%d) InvalidRetryCount = %d\n",
|
|
BattNPInfo->DeviceNum, BattInfo->InvalidRetryCount));
|
|
} else {
|
|
BattPrint (BATT_DEBUG, ("BattC (%d) InvalidRetryCount = %d. Using slow polling rate.\n",
|
|
BattNPInfo->DeviceNum, BattInfo->InvalidRetryCount));
|
|
li.QuadPart = MIN_STATUS_POLL_RATE;
|
|
}
|
|
} else if ((BattInfo->Status.Rate != 0) && (BattInfo->Status.Rate != BATTERY_UNKNOWN_RATE)) {
|
|
|
|
if (BattInfo->Status.Rate > 0) {
|
|
|
|
li.QuadPart = Notify.HighCapacity - BattInfo->Status.Capacity;
|
|
|
|
} else if (BattInfo->Status.Rate < 0) {
|
|
|
|
li.QuadPart = Notify.LowCapacity - BattInfo->Status.Capacity;
|
|
}
|
|
|
|
// convert to 3/4 its target time
|
|
|
|
li.QuadPart = li.QuadPart * ((ULONGLONG) NTMIN * 45);
|
|
li.QuadPart = li.QuadPart / (LONGLONG)(BattInfo->Status.Rate);
|
|
|
|
//
|
|
// Bound it
|
|
//
|
|
|
|
if (li.QuadPart > MIN_STATUS_POLL_RATE) {
|
|
// poll at least this fast
|
|
li.QuadPart = MIN_STATUS_POLL_RATE;
|
|
} else if (li.QuadPart < MAX_STATUS_POLL_RATE) {
|
|
// but not faster then this
|
|
li.QuadPart = MAX_STATUS_POLL_RATE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If sooner then NextTime, adjust NextTime
|
|
//
|
|
|
|
if (li.QuadPart < NextTime.QuadPart) {
|
|
NextTime.QuadPart = li.QuadPart;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If there's a NextTime, queue the timer to recheck
|
|
//
|
|
|
|
if (NextTime.QuadPart) {
|
|
NextTime.QuadPart = -NextTime.QuadPart;
|
|
|
|
//
|
|
// Acquire a remove lock.
|
|
//
|
|
|
|
InterlockedIncrement (&BattNPInfo->InUseCount);
|
|
BattPrint ((BATT_LOCK), ("BattCCheckStatusQueue: Aqcuired remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
|
|
if (BattNPInfo->WantToRemove == TRUE) {
|
|
//
|
|
// If BatteryClassUnload is waiting to remove the device:
|
|
// Don't set the timer.
|
|
// Release the remove lock just acquired.
|
|
// No need to notify BatteryclassUnload because
|
|
// at this point there is at least one other lock held.
|
|
//
|
|
|
|
InterlockedDecrement(&BattNPInfo->InUseCount);
|
|
BattPrint (BATT_NOTE,
|
|
("BattC (%d) CheckStatus: Poll cancel because of device removal.\n",
|
|
BattNPInfo->DeviceNum));
|
|
BattPrint ((BATT_LOCK), ("BattCCheckStatusQueue: Released remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
|
|
} else {
|
|
if (KeSetTimer (&BattNPInfo->WorkerTimer, NextTime, &BattNPInfo->WorkerDpc)) {
|
|
//
|
|
// If the timer was already set, we need to release a remove lock since
|
|
// there was already one aquired the last time this timer was set.
|
|
//
|
|
|
|
InterlockedDecrement(&BattNPInfo->InUseCount);
|
|
BattPrint ((BATT_LOCK), ("BattCCheckStatusQueue: Released extra remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
}
|
|
#if DEBUG
|
|
NextTime.QuadPart = (-NextTime.QuadPart) / (ULONGLONG) NTSEC;
|
|
BattPrint (BATT_NOTE, ("BattC (%d) CheckStatus: Poll in %d seconds (%d minutes)\n",
|
|
BattNPInfo->DeviceNum, NextTime.LowPart, NextTime.LowPart/60));
|
|
#endif
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// There should always be a NextTime.
|
|
//
|
|
ASSERT(FALSE);
|
|
}
|
|
} // if (IsListEmpty (&BattInfo->StatusQueue)) {...} else
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
VOID
|
|
BattCCheckTagQueue (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN PBATT_INFO BattInfo
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Gets the batteries current tag, and checks the pending
|
|
tag queue for possible IRP completion. Resets the miniport
|
|
notification settings if needed.
|
|
|
|
N.B. must be invoked from the non-reentrant worker thread
|
|
|
|
Arguments:
|
|
|
|
BattNPInfo - Battery
|
|
|
|
BattInfo - Battery
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
PIRP Irp;
|
|
PIO_STACK_LOCATION IrpSp, IrpNextSp;
|
|
LARGE_INTEGER NextTime;
|
|
LARGE_INTEGER CurrentTime;
|
|
LARGE_INTEGER li;
|
|
ULONG TimeIncrement;
|
|
BOOLEAN ReturnCurrentStatus;
|
|
NTSTATUS Status;
|
|
ULONG batteryTimeout;
|
|
BOOLEAN TagNotified;
|
|
|
|
ULONG tmpTag = BATTERY_TAG_INVALID;
|
|
|
|
BattPrint ((BATT_TRACE), ("BattC (%d): BattCCheckTagQueue called\n", BattInfo->BattNPInfo->DeviceNum));
|
|
|
|
PAGED_CODE();
|
|
TimeIncrement = KeQueryTimeIncrement();
|
|
|
|
//
|
|
// Loop while tag needs checked, check pending tag IRPs
|
|
//
|
|
|
|
while (InterlockedExchange(&BattNPInfo->CheckTag, 0)) {
|
|
NextTime.QuadPart = 0;
|
|
|
|
//
|
|
// If the Tag Queue is empty, done
|
|
// but we need to make sure that we leave TagNotified set to TRUE
|
|
// so the next time an IRP comes through,we'll re-read the tag.
|
|
//
|
|
|
|
if (IsListEmpty (&BattInfo->TagQueue)) {
|
|
break;
|
|
}
|
|
|
|
TagNotified = FALSE;
|
|
|
|
//
|
|
// Pickup tag notified flag
|
|
//
|
|
|
|
if (BattNPInfo->TagNotified) {
|
|
InterlockedExchange (&BattNPInfo->TagNotified, 0);
|
|
TagNotified = TRUE;
|
|
}
|
|
|
|
KeQueryTickCount (&CurrentTime);
|
|
CurrentTime.QuadPart = CurrentTime.QuadPart * TimeIncrement;
|
|
|
|
if (TagNotified ||
|
|
CurrentTime.QuadPart - BattInfo->TagTime > STATUS_VALID_TIME) {
|
|
|
|
//
|
|
// Get the battery's current tag
|
|
//
|
|
|
|
tmpTag = 0;
|
|
Status = BattInfo->Mp.QueryTag (
|
|
BattInfo->Mp.Context,
|
|
&tmpTag
|
|
);
|
|
|
|
|
|
if (!NT_SUCCESS(Status) && (Status != STATUS_NO_SUCH_DEVICE)) {
|
|
//
|
|
// Something went wrong, complete all pending tag irps
|
|
//
|
|
|
|
BattPrint (BATT_MP_ERROR, ("BattC (%d) CheckTag: Tag read err = %x\n", BattNPInfo->DeviceNum, Status));
|
|
BattCMiniportStatus (BattInfo, Status);
|
|
break;
|
|
}
|
|
BattPrint (BATT_MP_DATA, ("BattC (%d) MP.QueryTag: Status = %08x, Tag = %08x\n",
|
|
BattNPInfo->DeviceNum, Status, tmpTag));
|
|
|
|
|
|
if (Status == STATUS_NO_SUCH_DEVICE) {
|
|
//
|
|
// Get the current time to compute timeouts on tag query requests
|
|
//
|
|
|
|
KeQueryTickCount (&CurrentTime);
|
|
CurrentTime.QuadPart = CurrentTime.QuadPart * TimeIncrement;
|
|
BattInfo->TagTime = CurrentTime.QuadPart;
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check each pending Tag IRP
|
|
//
|
|
|
|
Entry = BattInfo->TagQueue.Flink;
|
|
while (Entry != &BattInfo->TagQueue) {
|
|
|
|
//
|
|
// Get IRP to check
|
|
//
|
|
|
|
Irp = CONTAINING_RECORD (
|
|
Entry,
|
|
IRP,
|
|
Tail.Overlay.ListEntry
|
|
);
|
|
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
IrpNextSp = IoGetNextIrpStackLocation(Irp);
|
|
if (IrpSp->Parameters.DeviceIoControl.InputBufferLength == 0) {
|
|
//
|
|
// If no input was given, then use timeout of 0.
|
|
//
|
|
batteryTimeout = 0;
|
|
} else {
|
|
batteryTimeout = *((PULONG) Irp->AssociatedIrp.SystemBuffer);
|
|
}
|
|
|
|
//
|
|
// Get next request
|
|
//
|
|
|
|
Entry = Entry->Flink;
|
|
|
|
|
|
//
|
|
// If IRP is flagged as cancelled, complete it
|
|
//
|
|
|
|
if (Irp->Cancel) {
|
|
BattPrint (BATT_IOCTL, ("BattC (%d): QueryTag irp cancelled - %x\n", BattNPInfo->DeviceNum, Irp));
|
|
Irp->IoStatus.Status = STATUS_CANCELLED;
|
|
}
|
|
|
|
|
|
//
|
|
// If request is still pending, check it
|
|
//
|
|
|
|
if (Irp->IoStatus.Status == STATUS_PENDING) {
|
|
|
|
ReturnCurrentStatus = FALSE;
|
|
if (tmpTag != BATTERY_TAG_INVALID) {
|
|
|
|
//
|
|
// Complete this IRP with the current tag
|
|
//
|
|
|
|
ReturnCurrentStatus = TRUE;
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
} else {
|
|
|
|
//
|
|
// Compute time when the request expires, the battery tag
|
|
// is an input parameter that holds the timeout.
|
|
//
|
|
|
|
if (batteryTimeout &&
|
|
IrpNextSp->Parameters.Others.Argument1 == NULL &&
|
|
IrpNextSp->Parameters.Others.Argument2 == NULL) {
|
|
|
|
// initialize it
|
|
li.QuadPart = CurrentTime.QuadPart + ((ULONGLONG) batteryTimeout * NTMS);
|
|
|
|
IrpNextSp->Parameters.Others.Argument1 = (PVOID)((ULONG_PTR)li.LowPart);
|
|
IrpNextSp->Parameters.Others.Argument2 = (PVOID)((ULONG_PTR)li.HighPart);
|
|
|
|
}
|
|
|
|
li.LowPart = (ULONG)((ULONG_PTR)IrpNextSp->Parameters.Others.Argument1);
|
|
li.HighPart = (ULONG)((ULONG_PTR)IrpNextSp->Parameters.Others.Argument2);
|
|
li.QuadPart -= CurrentTime.QuadPart;
|
|
|
|
if (li.QuadPart <= 0) {
|
|
|
|
//
|
|
// Time's up, complete it
|
|
//
|
|
|
|
BattPrint ((BATT_NOTE | BATT_IOCTL), ("BattC (%d): QueryTag irp timeout - %x\n", BattNPInfo->DeviceNum, Irp));
|
|
ReturnCurrentStatus = TRUE;
|
|
Irp->IoStatus.Status = STATUS_NO_SUCH_DEVICE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// If waiting forever, no need to set a timer
|
|
//
|
|
if (batteryTimeout != 0xFFFFFFFF) {
|
|
|
|
//
|
|
// Check if this is the next timeout time
|
|
//
|
|
|
|
if (NextTime.QuadPart == 0 || li.QuadPart < NextTime.QuadPart) {
|
|
NextTime.QuadPart = li.QuadPart;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ReturnCurrentStatus) {
|
|
|
|
//
|
|
// Return current battery status
|
|
//
|
|
|
|
*((PULONG) Irp->AssociatedIrp.SystemBuffer) = tmpTag;
|
|
Irp->IoStatus.Information = sizeof(ULONG);
|
|
if (BattInfo->Tag != tmpTag) {
|
|
|
|
//
|
|
// This is a new battery tag, capture tag
|
|
//
|
|
|
|
BattInfo->Tag = tmpTag;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If this request is no longer pending, complete it
|
|
//
|
|
|
|
if (Irp->IoStatus.Status != STATUS_PENDING) {
|
|
RemoveEntryList (&Irp->Tail.Overlay.ListEntry);
|
|
IoSetCancelRoutine (Irp, NULL);
|
|
|
|
BattPrint (
|
|
(BATT_IOCTL),
|
|
("BattC (%d): CheckTag completing request, IRP = %x, status = %x\n",
|
|
BattNPInfo->DeviceNum,
|
|
Irp,
|
|
Irp->IoStatus.Status)
|
|
);
|
|
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If there's a NextTime, queue the timer to recheck.
|
|
// This means there is a tag request with a timout other than 0 or -1.
|
|
//
|
|
|
|
if (NextTime.QuadPart) {
|
|
NextTime.QuadPart = -NextTime.QuadPart;
|
|
|
|
//
|
|
// Acquire a remove lock.
|
|
//
|
|
|
|
InterlockedIncrement (&BattNPInfo->InUseCount);
|
|
BattPrint ((BATT_LOCK), ("BattCCheckTagQueue: Aqcuired remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
|
|
if (BattNPInfo->WantToRemove == TRUE) {
|
|
//
|
|
// If BatteryClassUnload is waiting to remove the device:
|
|
// Don't set the timer.
|
|
// Release the remove lock just acquired.
|
|
// No need to notify BatteryclassUnload because
|
|
// at this point there is at least one other lock held.
|
|
//
|
|
|
|
InterlockedDecrement(&BattNPInfo->InUseCount);
|
|
BattPrint (BATT_NOTE,
|
|
("BattC (%d) CheckTag: Poll cancel because of device removal.\n",
|
|
BattNPInfo->DeviceNum));
|
|
BattPrint ((BATT_LOCK), ("BattCCheckTagQueue: Released remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
} else {
|
|
if (KeSetTimer (&BattNPInfo->TagTimer, NextTime, &BattNPInfo->TagDpc)){
|
|
//
|
|
// If the timer was already set, we need to release a remove lock since
|
|
// there was already one aquired the last time this timer was set.
|
|
//
|
|
|
|
InterlockedDecrement(&BattNPInfo->InUseCount);
|
|
BattPrint ((BATT_LOCK), ("BattCCheckTagQueue: Released extra remove lock %d (count = %d)\n", BattNPInfo->DeviceNum, BattNPInfo->InUseCount));
|
|
}
|
|
#if DEBUG
|
|
NextTime.QuadPart = NextTime.QuadPart / -NTSEC;
|
|
BattPrint (BATT_NOTE, ("BattC (%d) CheckTag: Poll in %x seconds\n", BattNPInfo->DeviceNum, NextTime.LowPart));
|
|
#endif
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
BattCWmi (
|
|
IN PBATT_NP_INFO BattNPInfo,
|
|
IN PBATT_INFO BattInfo,
|
|
IN PBATT_WMI_REQUEST WmiRequest
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Processes a single WMI request.
|
|
|
|
N.B. must be invoked from the non-reentrant worker thread
|
|
|
|
Arguments:
|
|
|
|
BattNPInfo - Battery
|
|
|
|
BattInfo - Battery
|
|
|
|
WmiRequest - Wmi Request to process
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
|
|
NTSTATUS status = STATUS_SUCCESS;
|
|
ULONG size = 0;
|
|
ULONG OutputLen;
|
|
BATTERY_INFORMATION batteryInformation;
|
|
PWCHAR tempString;
|
|
|
|
BattPrint((BATT_WMI), ("BattCWmi (%d): GuidIndex = 0x%x\n",
|
|
BattNPInfo->DeviceNum, WmiRequest->GuidIndex));
|
|
|
|
switch (WmiRequest->GuidIndex) {
|
|
case BattWmiStatusId:
|
|
size = sizeof (BATTERY_WMI_STATUS);
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->Tag = BattInfo->Tag;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->RemainingCapacity = BattInfo->Status.Capacity;
|
|
if (BattInfo->Status.Rate < 0) {
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->ChargeRate = 0;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->DischargeRate = -BattInfo->Status.Rate;
|
|
} else {
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->ChargeRate = BattInfo->Status.Rate;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->DischargeRate = 0;
|
|
}
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->Voltage = BattInfo->Status.Voltage;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->PowerOnline =
|
|
(BattInfo->Status.PowerState & BATTERY_POWER_ON_LINE) ? TRUE : FALSE;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->Charging =
|
|
(BattInfo->Status.PowerState & BATTERY_CHARGING) ? TRUE : FALSE;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->Discharging =
|
|
(BattInfo->Status.PowerState & BATTERY_DISCHARGING) ? TRUE : FALSE;
|
|
((PBATTERY_WMI_STATUS) WmiRequest->Buffer)->Critical =
|
|
(BattInfo->Status.PowerState & BATTERY_CRITICAL) ? TRUE : FALSE;
|
|
BattPrint((BATT_WMI), ("BattCWmi (%d): BatteryStatus\n",
|
|
BattNPInfo->DeviceNum));
|
|
break;
|
|
case BattWmiRuntimeId:
|
|
size = sizeof (BATTERY_WMI_RUNTIME);
|
|
((PBATTERY_WMI_RUNTIME) WmiRequest->Buffer)->Tag = BattInfo->Tag;
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryEstimatedTime,
|
|
0,
|
|
&((PBATTERY_WMI_RUNTIME) WmiRequest->Buffer)->EstimatedRuntime,
|
|
sizeof(ULONG),
|
|
&OutputLen
|
|
);
|
|
|
|
BattPrint((BATT_WMI), ("BattCWmi (%d): EstimateRuntime = %08x, Status = 0x%08x\n",
|
|
BattNPInfo->DeviceNum, &((PBATTERY_WMI_RUNTIME) WmiRequest->Buffer)->EstimatedRuntime, status));
|
|
break;
|
|
case BattWmiTemperatureId:
|
|
size = sizeof (BATTERY_WMI_TEMPERATURE);
|
|
((PBATTERY_WMI_TEMPERATURE) WmiRequest->Buffer)->Tag = BattInfo->Tag;
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryTemperature,
|
|
0,
|
|
&((PBATTERY_WMI_TEMPERATURE) WmiRequest->Buffer)->Temperature,
|
|
sizeof(ULONG),
|
|
&OutputLen
|
|
);
|
|
|
|
BattPrint((BATT_WMI), ("BattCWmi (%d): Temperature = %08x, Status = 0x%08x\n",
|
|
BattNPInfo->DeviceNum, &((PBATTERY_WMI_TEMPERATURE) WmiRequest->Buffer)->Temperature, status));
|
|
break;
|
|
case BattWmiFullChargedCapacityId:
|
|
size = sizeof (BATTERY_WMI_FULL_CHARGED_CAPACITY);
|
|
((PBATTERY_WMI_FULL_CHARGED_CAPACITY) WmiRequest->Buffer)->Tag = BattInfo->Tag;
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryInformation,
|
|
0,
|
|
&batteryInformation,
|
|
sizeof(BATTERY_INFORMATION),
|
|
&OutputLen
|
|
);
|
|
((PBATTERY_WMI_FULL_CHARGED_CAPACITY) WmiRequest->Buffer)->FullChargedCapacity =
|
|
batteryInformation.FullChargedCapacity;
|
|
|
|
BattPrint((BATT_WMI), ("BattCWmi (%d): FullChargedCapacity = %08x, Status = 0x%08x\n",
|
|
BattNPInfo->DeviceNum, ((PBATTERY_WMI_FULL_CHARGED_CAPACITY) WmiRequest->Buffer)->FullChargedCapacity, status));
|
|
break;
|
|
case BattWmiCycleCountId:
|
|
size = sizeof (BATTERY_WMI_CYCLE_COUNT);
|
|
((PBATTERY_WMI_CYCLE_COUNT) WmiRequest->Buffer)->Tag = BattInfo->Tag;
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryInformation,
|
|
0,
|
|
&batteryInformation,
|
|
sizeof(BATTERY_INFORMATION),
|
|
&OutputLen
|
|
);
|
|
((PBATTERY_WMI_CYCLE_COUNT) WmiRequest->Buffer)->CycleCount =
|
|
batteryInformation.CycleCount;
|
|
|
|
BattPrint((BATT_WMI), ("BattCWmi (%d): CycleCount = %08x, Status = 0x%08x\n",
|
|
BattNPInfo->DeviceNum, ((PBATTERY_WMI_CYCLE_COUNT) WmiRequest->Buffer)->CycleCount, status));
|
|
break;
|
|
case BattWmiStaticDataId:
|
|
size = sizeof(BATTERY_WMI_STATIC_DATA)+4*MAX_BATTERY_STRING_SIZE*sizeof(WCHAR);
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Tag = BattInfo->Tag;
|
|
// ((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->ManufacturerDate[0] =
|
|
// ((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Granularity =
|
|
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryInformation,
|
|
0,
|
|
&batteryInformation,
|
|
sizeof(BATTERY_INFORMATION),
|
|
&OutputLen
|
|
);
|
|
|
|
if (NT_SUCCESS(status)) {
|
|
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Capabilities =
|
|
batteryInformation.Capabilities;
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Technology =
|
|
batteryInformation.Technology;
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Chemistry =
|
|
*(PULONG)batteryInformation.Chemistry;
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->DesignedCapacity =
|
|
batteryInformation.DesignedCapacity;
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->DefaultAlert1 =
|
|
batteryInformation.DefaultAlert1;
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->DefaultAlert2 =
|
|
batteryInformation.DefaultAlert2;
|
|
((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->CriticalBias =
|
|
batteryInformation.CriticalBias;
|
|
|
|
tempString = ((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Strings;
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryDeviceName,
|
|
0,
|
|
&tempString[1],
|
|
MAX_BATTERY_STRING_SIZE,
|
|
&OutputLen
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
// Some batteries may not support some types of Information Queries
|
|
// Don't fail request, simply leave this one blank.
|
|
OutputLen = 0;
|
|
}
|
|
|
|
tempString[0] = (USHORT) OutputLen;
|
|
|
|
tempString = (PWCHAR) ((PCHAR) &tempString[1] + tempString[0]);
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryManufactureName,
|
|
0,
|
|
&tempString[1],
|
|
MAX_BATTERY_STRING_SIZE,
|
|
&OutputLen
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
// Some batteries may not support some types of Information Queries
|
|
// Don't fail request, simply leave this one blank.
|
|
OutputLen = 0;
|
|
}
|
|
|
|
tempString[0] = (USHORT) OutputLen;
|
|
|
|
tempString = (PWCHAR) ((PCHAR) &tempString[1] + tempString[0]);
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatterySerialNumber,
|
|
0,
|
|
&tempString[1],
|
|
MAX_BATTERY_STRING_SIZE,
|
|
&OutputLen
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
// Some batteries may not support some types of Information Queries
|
|
// Don't fail request, simply leave this one blank.
|
|
OutputLen = 0;
|
|
}
|
|
|
|
tempString[0] = (USHORT) OutputLen;
|
|
|
|
tempString = (PWCHAR) ((PCHAR) &tempString[1] + tempString[0]);
|
|
status = BattInfo->Mp.QueryInformation (
|
|
BattInfo->Mp.Context,
|
|
BattInfo->Tag,
|
|
BatteryUniqueID,
|
|
0,
|
|
&tempString[1],
|
|
MAX_BATTERY_STRING_SIZE,
|
|
&OutputLen
|
|
);
|
|
if (!NT_SUCCESS(status)) {
|
|
// Some batteries may not support some types of Information Queries
|
|
// Don't fail request, simply leave this one blank.
|
|
OutputLen = 0;
|
|
status = STATUS_SUCCESS;
|
|
}
|
|
|
|
tempString[0] = (USHORT) OutputLen;
|
|
|
|
tempString = (PWCHAR) ((PCHAR) &tempString[1] + tempString[0]);
|
|
size = (ULONG)(sizeof(BATTERY_WMI_STATIC_DATA)+(tempString - ((PBATTERY_WMI_STATIC_DATA) WmiRequest->Buffer)->Strings));
|
|
}
|
|
|
|
break;
|
|
default:
|
|
status = STATUS_WMI_GUID_NOT_FOUND;
|
|
}
|
|
|
|
*WmiRequest->InstanceLengthArray = size;
|
|
status = WmiCompleteRequest(WmiRequest->DeviceObject,
|
|
WmiRequest->Irp,
|
|
status,
|
|
size,
|
|
IO_NO_INCREMENT);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
VOID
|
|
BattCMiniportStatus (
|
|
IN PBATT_INFO BattInfo,
|
|
IN NTSTATUS Status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Function to return status from miniport. If the battery tag has gone
|
|
invalid the pending statuses are aborted.
|
|
|
|
N.B. must be invoked from the non-rentrant worker thread
|
|
|
|
Arguments:
|
|
|
|
BattInfo - Battery
|
|
|
|
Status - Status from miniport.
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
if (NT_SUCCESS(Status)) {
|
|
return ;
|
|
}
|
|
|
|
switch (Status) {
|
|
#if DEBUG
|
|
case STATUS_SUCCESS:
|
|
case STATUS_NOT_IMPLEMENTED:
|
|
case STATUS_BUFFER_TOO_SMALL:
|
|
case STATUS_INVALID_BUFFER_SIZE:
|
|
case STATUS_NOT_SUPPORTED:
|
|
case STATUS_INVALID_PARAMETER:
|
|
case STATUS_OBJECT_NAME_NOT_FOUND:
|
|
case STATUS_INVALID_DEVICE_REQUEST:
|
|
// no action
|
|
break;
|
|
|
|
default:
|
|
BattPrint (BATT_ERROR, ("BattCMiniportStatus: unknown status from miniport: %x BattInfo %x\n",
|
|
Status, BattInfo));
|
|
break;
|
|
|
|
#endif
|
|
case STATUS_NO_SUCH_DEVICE:
|
|
|
|
//
|
|
// Our battery tag is wrong. Cancel any queued status irps
|
|
//
|
|
|
|
BattCCompleteIrpQueue (&(BattInfo->StatusQueue), Status);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
BattCCompleteIrpQueue (
|
|
IN PLIST_ENTRY Queue,
|
|
IN NTSTATUS Status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Complete all pending Irps in the IoQueue, TagQueue, or StatusQueue.
|
|
|
|
N.B. must be invoked from the non-rentrant worker thread
|
|
|
|
Arguments:
|
|
|
|
BattInfo - Battery
|
|
|
|
Status - Error status to complete pending status request with
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
PIRP Irp;
|
|
|
|
ASSERT (!NT_SUCCESS(Status));
|
|
|
|
BattPrint (BATT_TRACE, ("BattC: ENTERING BattCCompleteIrpQueue\n"));
|
|
|
|
while (!IsListEmpty(Queue)) {
|
|
Entry = RemoveHeadList (Queue);
|
|
|
|
Irp = CONTAINING_RECORD (
|
|
Entry,
|
|
IRP,
|
|
Tail.Overlay.ListEntry
|
|
);
|
|
|
|
//
|
|
// Use Cancel Spinlock to make sure that Completion routine isn't being called
|
|
//
|
|
|
|
IoAcquireCancelSpinLock (&Irp->CancelIrql);
|
|
IoSetCancelRoutine (Irp, NULL);
|
|
IoReleaseCancelSpinLock(Irp->CancelIrql);
|
|
|
|
BattPrint (BATT_NOTE, ("BattC: Completing IRP 0x%0lx at IRQL %d.\n", Irp, KeGetCurrentIrql()));
|
|
Irp->IoStatus.Status = Status;
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
BattPrint (BATT_TRACE, ("BattC: EXITING BattCCompleteIrpQueue\n"));
|
|
}
|
|
|
|
|
|
VOID
|
|
BattCCompleteWmiQueue (
|
|
IN PLIST_ENTRY Queue,
|
|
IN NTSTATUS Status
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Complete all pending Irps in the IoQueue, TagQueue, or StatusQueue.
|
|
|
|
N.B. must be invoked from the non-rentrant worker thread
|
|
|
|
Arguments:
|
|
|
|
BattInfo - Battery
|
|
|
|
Status - Error status to complete pending status request with
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
PLIST_ENTRY Entry;
|
|
PBATT_WMI_REQUEST WmiRequest;
|
|
|
|
ASSERT (!NT_SUCCESS(Status));
|
|
|
|
BattPrint (BATT_TRACE, ("BattC: ENTERING BattCCompleteWmiQueue\n"));
|
|
|
|
while (!IsListEmpty(Queue)) {
|
|
Entry = RemoveHeadList (Queue);
|
|
|
|
WmiRequest = CONTAINING_RECORD (
|
|
Entry,
|
|
BATT_WMI_REQUEST,
|
|
ListEntry
|
|
);
|
|
|
|
BattPrint (BATT_NOTE, ("BattC: Completing Wmi Request 0x%0lx at IRQL %d.\n", WmiRequest, KeGetCurrentIrql()));
|
|
|
|
*WmiRequest->InstanceLengthArray = 0;
|
|
WmiCompleteRequest(WmiRequest->DeviceObject,
|
|
WmiRequest->Irp,
|
|
Status,
|
|
0,
|
|
IO_NO_INCREMENT);
|
|
|
|
|
|
}
|
|
|
|
BattPrint (BATT_TRACE, ("BattC: EXITING BattCCompleteWmiQueue\n"));
|
|
}
|
|
|