/*++ 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)) { 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; 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")); }