Ros-diffs

ros-diffs@reactos.org

81390 discussions

[reactos] 01/01: [PSDK] Fix BATTERY_UNKNOWN_TIME value constant

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=02032b71068c9d5808f20… commit 02032b71068c9d5808f20dbd7401674b84cb1a2f Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Wed Jan 8 23:49:15 2025 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:49:15 2025 +0100 [PSDK] Fix BATTERY_UNKNOWN_TIME value constant Windows SDKs define this constant to 0xFFFFFFFF but we define it to 0x80000000. As a result, when our COMPBATT driver is being tested on Windows (namely XP, Vista and 7), BATTERY_UNKNOWN_TIME is not interpreted as UNKNOWN TIME but entirely something else. CORE-18969 CORE-19452 --- sdk/include/psdk/batclass.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk/include/psdk/batclass.h b/sdk/include/psdk/batclass.h index f97140d9b05..02641a65f86 100644 --- a/sdk/include/psdk/batclass.h +++ b/sdk/include/psdk/batclass.h @@ -65,7 +65,7 @@ DEFINE_GUID(BATTERY_TAG_CHANGE_WMI_GUID, #define BATTERY_UNKNOWN_CAPACITY 0xFFFFFFFF /* BatteryEstimatedTime constant */ -#define BATTERY_UNKNOWN_TIME 0x80000000 +#define BATTERY_UNKNOWN_TIME 0xFFFFFFFF #define MAX_BATTERY_STRING_SIZE 128

5 months, 3 weeks

[reactos] 15/15: [COMPBATT] Document COMPBATT_BATTERY_DATA and COMPBATT_DEVICE_EXTENSION structures

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=13b394c1a7e0df384443a… commit 13b394c1a7e0df384443a7c1caacf95ec13858a9 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Mon Dec 16 17:20:33 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:09 2025 +0100 [COMPBATT] Document COMPBATT_BATTERY_DATA and COMPBATT_DEVICE_EXTENSION structures CORE-18969 CORE-19452 CORE-19888 --- drivers/bus/acpi/compbatt/compbatt.h | 92 ++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/drivers/bus/acpi/compbatt/compbatt.h b/drivers/bus/acpi/compbatt/compbatt.h index 66307defbc4..58f812c5fd7 100644 --- a/drivers/bus/acpi/compbatt/compbatt.h +++ b/drivers/bus/acpi/compbatt/compbatt.h @@ -78,24 +78,73 @@ // typedef struct _COMPBATT_BATTERY_DATA { + /* The linked battery with the Composite Battery */ LIST_ENTRY BatteryLink; + + /* I/O remove lock which protects the battery from being removed */ IO_REMOVE_LOCK RemoveLock; + + /* + * The associated device object (usually CMBATT) and the I/O battery packet + * which is used to transport and gather battery data. + */ PDEVICE_OBJECT DeviceObject; PIRP Irp; + + /* + * The Executive work item, which serves as a worker item for the + * IRP battery monitor worker. + */ WORK_QUEUE_ITEM WorkItem; + + /* + * Execution state mode of the individual battery. Only two modes are valid: + * + * COMPBATT_QUERY_TAG - The battery is currently waiting for a tag to get assigned; + * COMPBATT_READ_STATUS - The battery is querying battery status. + */ UCHAR Mode; + + /* + * The battery wait configuration settings, set up by the SetStatusNotify method. + * These values are used to instruct CMBATT when the battery status should be retrieved. + */ BATTERY_WAIT_STATUS WaitStatus; + + /* + * A union that serves as the buffer which holds battery monitor IRP data, specifically + * managed by CompBattMonitorIrpCompleteWorker, to avoid allocating separate memory pools. + */ union { BATTERY_WAIT_STATUS WorkerWaitStatus; BATTERY_STATUS WorkerStatus; ULONG WorkerTag; } WorkerBuffer; + + /* The ID of the battery that associates the identification of this battery */ ULONG Tag; + + /* + * The battery flags that govern the behavior of the battery. The valid flags are: + * + * COMPBATT_BATTERY_INFORMATION_PRESENT - The static battery information ha been + * queried. Re-querying such information is not needed. + * + * COMPBATT_STATUS_NOTIFY_SET - The current notification wait settings are valid. + * + * COMPBATT_TAG_ASSIGNED - The battery has a tag assigned and it can be read. + */ ULONG Flags; + + /* The static battery information and battery status */ BATTERY_INFORMATION BatteryInformation; BATTERY_STATUS BatteryStatus; + + /* The interrupt time of which the battery status was last read */ ULONGLONG InterruptTime; + + /* A uniquely given name of the battery that associates it */ UNICODE_STRING BatteryName; } COMPBATT_BATTERY_DATA, *PCOMPBATT_BATTERY_DATA; @@ -104,18 +153,61 @@ typedef struct _COMPBATT_BATTERY_DATA // typedef struct _COMPBATT_DEVICE_EXTENSION { + /* + * The class data initialized and used by Battery Class. It contains information + * such as miniport data used for registration and communication between the + * Composite Battery and Battery Class, wait and context events, etc. + */ PVOID ClassData; + + /* + * The successor computed tag. This field is used when there are more upcoming + * batteries to be connected with the Composite Battery, of which the tag is + * incremented by 1 by each new battery that is connected. + */ ULONG NextTag; + + /* A list of linked batteries connected with the Composite Battery */ LIST_ENTRY BatteryList; + + /* A mutex lock which ensures proper synchronization of Composite Battery operations */ FAST_MUTEX Lock; + + /* The ID of the Composite Battery */ ULONG Tag; + + /* + * The battery flags that govern the behavior of the battery. The valid flags are: + * + * COMPBATT_BATTERY_INFORMATION_PRESENT - The static battery information has been + * queried. Re-querying such information is not needed. + * + * COMPBATT_STATUS_NOTIFY_SET - The current notification wait settings are valid. + * + * COMPBATT_TAG_ASSIGNED - The battery has a tag assigned and it can be read. + */ ULONG Flags; + + /* + * The Composite Battery static information, status and wait status settings. + * Note that both the battery information and status are combined, based upon + * the individual information and status of each linked battery. + */ BATTERY_INFORMATION BatteryInformation; BATTERY_STATUS BatteryStatus; BATTERY_WAIT_STATUS WaitNotifyStatus; + + /* The interrupt time of which the battery status was last read */ ULONGLONG InterruptTime; + + /* + * The physical device object that associates the Composite Battery and + * the attached device, typically the ACPI driver. + */ PDEVICE_OBJECT AttachedDevice; PDEVICE_OBJECT DeviceObject; + + /* The notification entry that identifies the registered I/O PnP notification */ PVOID NotificationEntry; } COMPBATT_DEVICE_EXTENSION, *PCOMPBATT_DEVICE_EXTENSION;

5 months, 3 weeks

[reactos] 14/15: [COMPBATT] Document the newly added code

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f58f37e944c54942eaf65… commit f58f37e944c54942eaf65db674362ed2275ed9a5 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Mon Dec 16 00:40:54 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:09 2025 +0100 [COMPBATT] Document the newly added code --- drivers/bus/acpi/compbatt/compbatt.c | 144 +++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 533c32e4991..3edb3fb78a8 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -67,6 +67,26 @@ CompBattSystemControl( return Status; } +/** + * @brief + * Queues a work item thread worker which is bound to the individual + * CM (Control Method) ACPI battery to handle the IRP. + * + * @param[in] DeviceObject + * A pointer to a device object, this parameter is unused. + * + * @param[in] Irp + * A pointer to an I/O request packet. It is used to gather the I/O stack + * location which contains the data of the individual battery. + * + * @param[in] Context + * An aribtrary pointer that points to context data, this paramater + * is unused. + * + * @return + * Returns STATUS_MORE_PROCESSING_REQUIRED to indicate the I/O request + * is still in action, therefore the IRP is not freed. + */ NTSTATUS NTAPI CompBattMonitorIrpComplete( @@ -89,6 +109,17 @@ CompBattMonitorIrpComplete( return STATUS_MORE_PROCESSING_REQUIRED; } +/** + * @brief + * The brains of the battery IRP worker. It monitors the state of the + * IRP as well as sends the IRP down the device stack to gather battery + * related data, such tag and status. It also serves as the I/O + * completion routine of which it elaborates the gathered data. + * + * @param[in] BatteryData + * A pointer to battery data of an individual battery that contains + * the IRP to be send down the device stack. + */ VOID NTAPI CompBattMonitorIrpCompleteWorker( @@ -481,6 +512,29 @@ CompBattDisableStatusNotify( return STATUS_SUCCESS; } +/** + * @brief + * Calculates the total discharging/charging rate flow of each individual + * battery linked with the composite battery and determines whether at + * least one battery is behaving improperly. + * + * @param[in] DeviceExtension + * A pointer to a device extension which describes the composite battery + * itself. It is used to gather each connected battery in the list with + * the composite battery. + * + * @param[out] TotalRate + * A pointer returned to caller that describes the total accumulated + * rate flow of all batteries. + * + * @param[out] BatteriesCount + * A pointer returned to caller that describes the batteries present. + * + * @return + * Returns TRUE if at least one battery is behaving improperly, FALSE + * otherwise. This is determined by the fact if a battery has a negative + * rate but is charging, or if it has a positive rate but is discharging. + */ static BOOLEAN CompBattCalculateTotalRateAndLinkedBatteries( @@ -590,6 +644,33 @@ CompBattCalculateTotalRateAndLinkedBatteries( return BadBattery; } +/** + * @brief + * Sets a new configuration battery wait status settings of each battery. + * The purpose of this is so that the composite battery gets notified + * of new battery status as if it was a single battery. + * + * @param[in] DeviceExtension + * A pointer to a device extension which describes the composite battery + * itself. It is used to gather each connected battery in the list with + * the composite battery. + * + * @param[in] BatteryTag + * A battery tag supplied by the caller. This is typically the tag of + * the composite battery which is used to check against the cached tag + * of the composite battery if it has changed or not. + * + * @param[in] BatteryNotify + * A pointer to a structure filled with battery notification settings, + * supplied by the caller. It is used as the new values for the + * configuration wait settings. + * + * @return + * Returns STATUS_NO_SUCH_DEVICE if the supplied battery tag does not match + * with that of the cached composite battery's tag or if the composite + * battery currently does not have a tag assigned. Otherwise STATUS_SUCCESS + * is returned. + */ NTSTATUS NTAPI CompBattSetStatusNotify( @@ -819,6 +900,33 @@ CompBattSetStatusNotify( return STATUS_SUCCESS; } +/** + * @brief + * Queries the battery status of each individiual connected battery with + * the composite battery and combines all the retrieved data as one + * single battery status for the composite battery. + * + * @param[in] DeviceExtension + * A pointer to a device extension which describes the composite battery + * itself. It is used to gather each connected battery in the list with + * the composite battery. + * + * @param[in] Tag + * A battery tag supplied by the caller. This is typically the tag of + * the composite battery which is used to check against the cached tag + * of the composite battery if it has changed or not. + * + * @param[out] BatteryStatus + * A pointer to a battery status that contains the combined data, returned + * to the caller. It serves as the battery status for the composite battery. + * + * @return + * Returns STATUS_NO_SUCH_DEVICE if the supplied battery tag does not match + * with that of the cached composite battery's tag or if the composite + * battery currently does not have a tag assigned. Otherwise STATUS_SUCCESS + * is returned, which it will also return success if the composite battery's + * cached battery status is fresh which indicates it has already been computed. + */ NTSTATUS NTAPI CompBattQueryStatus( @@ -1282,6 +1390,20 @@ CompBattGetBatteryGranularity( return STATUS_SUCCESS; } +/** + * @brief + * Calculates the "At Rate" flow of the composite battery based on the + * sum of all connected batteries, in order to retrieve the precise + * battery time estimation. + * + * @param[in] DeviceExtension + * A pointer to a device extension which describes the composite battery + * itself. It is used to gather each connected battery in the list with + * the composite battery. + * + * @return + * Returns the computed "At Rate" flow to the caller. + */ static LONG CompBattCalculateAtRateTime( @@ -1351,6 +1473,28 @@ CompBattCalculateAtRateTime( return ComputedAtRate; } +/** + * @brief + * Retrieves the estimated time of the composite battery based on the + * power drain rate of all the batteries present in the system. + * + * @param[out] Time + * A pointer to the computed estimated time of the composite battery, + * returned to caller. Note that if there are not any batteries that + * are draining power, or if the system is powered by external AC source, + * the estimated time is unknown + * + * @param[in] DeviceExtension + * A pointer to a device extension which describes the composite battery + * itself. It is used to gather each connected battery in the list with + * the composite battery. + * + * @return + * Returns STATUS_NO_SUCH_DEVICE if the supplied battery tag does not match + * with that of the cached composite battery's tag or if the composite + * battery currently does not have a tag assigned. Otherwise STATUS_SUCCESS + * is returned. + */ NTSTATUS NTAPI CompBattGetEstimatedTime(

5 months, 3 weeks

[reactos] 13/15: [COMPBATT] Update the top headers and relicense the driver as MIT

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=65b29fe533099ce1f2599… commit 65b29fe533099ce1f2599755dc9447d90bba6493 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:59:38 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:09 2025 +0100 [COMPBATT] Update the top headers and relicense the driver as MIT --- drivers/bus/acpi/compbatt/compbatt.c | 10 +++++----- drivers/bus/acpi/compbatt/compbatt.h | 4 ++-- drivers/bus/acpi/compbatt/compmisc.c | 9 ++++----- drivers/bus/acpi/compbatt/comppnp.c | 9 ++++----- 4 files changed, 15 insertions(+), 17 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 740f1f18cb4..533c32e4991 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -1,9 +1,9 @@ /* - * PROJECT: ReactOS Composite Battery Driver - * LICENSE: BSD - See COPYING.ARM in the top level directory - * FILE: boot/drivers/bus/acpi/compbatt/compbatt.c - * PURPOSE: Main Initialization Code and IRP Handling - * PROGRAMMERS: ReactOS Portable Systems Group + * PROJECT: ReactOS Composite Battery Driver + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: Main Initialization Code and IRP Handling + * COPYRIGHT: Copyright 2010 ReactOS Portable Systems Group <ros.arm(a)reactos.org> + * Copyright 2024 George Bișoc <george.bisoc(a)reactos.org> */ /* INCLUDES *******************************************************************/ diff --git a/drivers/bus/acpi/compbatt/compbatt.h b/drivers/bus/acpi/compbatt/compbatt.h index 1b8c1fb49d1..66307defbc4 100644 --- a/drivers/bus/acpi/compbatt/compbatt.h +++ b/drivers/bus/acpi/compbatt/compbatt.h @@ -1,8 +1,8 @@ /* * PROJECT: ReactOS Composite Battery Driver - * LICENSE: BSD - See COPYING.ARM in the top level directory + * LICENSE: MIT (https://spdx.org/licenses/MIT) * PURPOSE: Composite battery main header file - * COPYRIGHT: Copyright 2010 ReactOS Portable Systems Group + * COPYRIGHT: Copyright 2010 ReactOS Portable Systems Group <ros.arm(a)reactos.org> * Copyright 2024 George Bișoc <george.bisoc(a)reactos.org> */ diff --git a/drivers/bus/acpi/compbatt/compmisc.c b/drivers/bus/acpi/compbatt/compmisc.c index 328628ee578..6a6cec14056 100644 --- a/drivers/bus/acpi/compbatt/compmisc.c +++ b/drivers/bus/acpi/compbatt/compmisc.c @@ -1,9 +1,8 @@ /* - * PROJECT: ReactOS Composite Battery Driver - * LICENSE: BSD - See COPYING.ARM in the top level directory - * FILE: boot/drivers/bus/acpi/compbatt/compmisc.c - * PURPOSE: Miscellaneous Support Routines - * PROGRAMMERS: ReactOS Portable Systems Group + * PROJECT: ReactOS Composite Battery Driver + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: Miscellaneous Support Routines + * COPYRIGHT: Copyright 2010 ReactOS Portable Systems Group <ros.arm(a)reactos.org> */ /* INCLUDES *******************************************************************/ diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index 7fd3725e61f..4e456d065f8 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -1,9 +1,8 @@ /* - * PROJECT: ReactOS Composite Battery Driver - * LICENSE: BSD - See COPYING.ARM in the top level directory - * FILE: boot/drivers/bus/acpi/compbatt/comppnp.c - * PURPOSE: Plug-and-Play IOCTL/IRP Handling - * PROGRAMMERS: ReactOS Portable Systems Group + * PROJECT: ReactOS Composite Battery Driver + * LICENSE: MIT (https://spdx.org/licenses/MIT) + * PURPOSE: Plug-and-Play IOCTL/IRP Handling + * COPYRIGHT: Copyright 2010 ReactOS Portable Systems Group <ros.arm(a)reactos.org> */ /* INCLUDES *******************************************************************/

5 months, 3 weeks

[reactos] 12/15: [COMPBATT] Implement CompBattGetEstimatedTime

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c439c5849b60920d9aec1… commit c439c5849b60920d9aec198e4f5234339ef7c9a5 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:52:58 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:08 2025 +0100 [COMPBATT] Implement CompBattGetEstimatedTime --- drivers/bus/acpi/compbatt/compbatt.c | 219 ++++++++++++++++++++++++++++++++++- 1 file changed, 217 insertions(+), 2 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 7e55887be60..740f1f18cb4 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -1282,14 +1282,229 @@ CompBattGetBatteryGranularity( return STATUS_SUCCESS; } +static +LONG +CompBattCalculateAtRateTime( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +{ + NTSTATUS Status; + PCOMPBATT_BATTERY_DATA BatteryData; + BATTERY_QUERY_INFORMATION QueryInformation; + PLIST_ENTRY ListHead, NextEntry; + ULONG Time; + LONG ComputedAtRate = 0; + + /* Walk over the linked batteries list to poll for "At Rate" value of each battery */ + ExAcquireFastMutex(&DeviceExtension->Lock); + ListHead = &DeviceExtension->BatteryList; + for (NextEntry = ListHead->Flink; + NextEntry != ListHead; + NextEntry = NextEntry->Flink) + { + /* Acquire the remove lock so this battery does not disappear under us */ + BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); + if (!NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) + continue; + + /* Now release the device lock since the battery can't go away */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Build the necessary information in order to query the battery estimated time */ + QueryInformation.BatteryTag = BatteryData->Tag; + QueryInformation.InformationLevel = BatteryEstimatedTime; + QueryInformation.AtRate = 0; + + /* Make sure this battery has a valid tag before issuing the IOCTL */ + if (BatteryData->Tag != BATTERY_TAG_INVALID) + { + /* + * Now it is time to issue the IOCTL to the battery device. + * We are calculating the "At Rate" counter based on each linked + * battery that is discharging, one at a time. This ensures + * that when we will actually retrieve the estimation time of each + * individual battery and sum it all up as one time for the composite + * battery, that the estimated time is accurate enough. + */ + Status = BatteryIoctl(IOCTL_BATTERY_QUERY_INFORMATION, + BatteryData->DeviceObject, + &QueryInformation, + sizeof(QueryInformation), + &Time, + sizeof(Time), + FALSE); + if (NT_SUCCESS(Status)) + { + if ((Time != 0) && (Time != BATTERY_UNKNOWN_TIME)) + { + ComputedAtRate -= COMPUTE_ATRATE_DRAIN(BatteryData, Time); + } + } + } + + /* We are done with this battery */ + ExAcquireFastMutex(&DeviceExtension->Lock); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + } + + /* Release the lock as we are no longer poking through the batteries list */ + ExReleaseFastMutex(&DeviceExtension->Lock); + return ComputedAtRate; +} + NTSTATUS NTAPI CompBattGetEstimatedTime( _Out_ PULONG Time, _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + NTSTATUS Status; + PCOMPBATT_BATTERY_DATA BatteryData; + BATTERY_STATUS BatteryStatus; + BATTERY_QUERY_INFORMATION QueryInformation; + PLIST_ENTRY ListHead, NextEntry; + ULONG ReturnedTime; + LONG ComputedAtRate; + + /* Assume the battery time is not estimated yet */ + *Time = BATTERY_UNKNOWN_TIME; + + /* + * Before we are querying the composite estimated battery time we must + * refresh the battery status cache if we have not done it so. + */ + Status = CompBattQueryStatus(DeviceExtension, + DeviceExtension->Tag, + &BatteryStatus); + if (!NT_SUCCESS(Status)) + { + if (CompBattDebug & COMPBATT_DEBUG_ERR) + DbgPrint("CompBatt: Failed to refresh composite battery's status (Status 0x%08lx)\n", Status); + + return Status; + } + + /* Print out battery status data that has been polled */ + if (CompBattDebug & COMPBATT_DEBUG_INFO) + DbgPrint("CompBatt: Latest composite battery status (when querying for estimated time)\n" + " PowerState -> 0x%lx\n" + " Capacity -> %u\n" + " Voltage -> %u\n" + " Rate -> %d\n", + BatteryStatus.PowerState, + BatteryStatus.Capacity, + BatteryStatus.Voltage, + BatteryStatus.Rate); + + /* + * If the batteries are not being discharged and the system is directly + * being powered by external AC source then it makes no sense to + * compute the battery estimated time because that construct is for + * WHEN the system is powered directly from batteries and it drains power. + */ + if (DeviceExtension->BatteryStatus.PowerState & BATTERY_POWER_ON_LINE) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + { + DbgPrint("CompBatt: The system is powered by AC source, estimated time is not available\n"); + } + + return STATUS_SUCCESS; + } + + /* Determine the draining "At Rate" counter for all batteries */ + ComputedAtRate = CompBattCalculateAtRateTime(DeviceExtension); + + /* + * A rate of 0 indicates none of the batteries that are linked with + * the composite are being drained therefore we cannot estimate the + * run time of the composite as it is not discharging. + */ + if (ComputedAtRate == 0) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: No battery is discharging and no power is being drained, cannot estimate the run time\n"); + + return STATUS_SUCCESS; + } + + /* Walk over the linked batteries list and determine the exact estimated time */ + ExAcquireFastMutex(&DeviceExtension->Lock); + ListHead = &DeviceExtension->BatteryList; + for (NextEntry = ListHead->Flink; + NextEntry != ListHead; + NextEntry = NextEntry->Flink) + { + /* Acquire the remove lock so this battery does not disappear under us */ + BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); + if (!NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) + continue; + + /* Now release the device lock since the battery can't go away */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Build the necessary information in order to query the battery estimated time */ + QueryInformation.BatteryTag = BatteryData->Tag; + QueryInformation.InformationLevel = BatteryEstimatedTime; + QueryInformation.AtRate = ComputedAtRate; + + /* Make sure this battery has a valid tag before issuing the IOCTL */ + if (BatteryData->Tag != BATTERY_TAG_INVALID) + { + Status = BatteryIoctl(IOCTL_BATTERY_QUERY_INFORMATION, + BatteryData->DeviceObject, + &QueryInformation, + sizeof(QueryInformation), + &ReturnedTime, + sizeof(ReturnedTime), + FALSE); + if (!NT_SUCCESS(Status)) + { + /* + * If the device is being suddenly removed then we must invalidate + * both this battery and composite tags. + */ + if (Status == STATUS_DEVICE_REMOVED) + { + Status = STATUS_NO_SUCH_DEVICE; + } + + ExAcquireFastMutex(&DeviceExtension->Lock); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + + /* + * In other places we are ceasing the execution of the loop but + * here we want to continue looking for other linked batteries. + * This is because we are querying for the estimated battery time + * at the time the last battery status was valid. Also bear in + * mind IOCTL_BATTERY_QUERY_INFORMATION with InformationLevel as + * BatteryEstimatedTime might not be a valid request supported + * by this battery. + */ + continue; + } + + /* Now sum up the estimated battery time */ + if (ReturnedTime != BATTERY_UNKNOWN_TIME) + { + if (*Time != BATTERY_UNKNOWN_TIME) + { + *Time += ReturnedTime; + } + else + { + *Time = ReturnedTime; + } + } + } + + /* We are done with this battery */ + ExAcquireFastMutex(&DeviceExtension->Lock); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + } + + /* Release the lock as we are no longer poking through the batteries list */ + ExReleaseFastMutex(&DeviceExtension->Lock); + return Status; } NTSTATUS

5 months, 3 weeks

[reactos] 11/15: [COMPBATT] Implement CompBattQueryStatus and CompBattSetStatusNotify

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=a6d4998c6c89abfb51cb5… commit a6d4998c6c89abfb51cb561ce19f1f5aabc1bbe3 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:48:52 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:08 2025 +0100 [COMPBATT] Implement CompBattQueryStatus and CompBattSetStatusNotify --- drivers/bus/acpi/compbatt/compbatt.c | 543 ++++++++++++++++++++++++++++++++++- 1 file changed, 539 insertions(+), 4 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 9e0e5d3a782..7e55887be60 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -481,6 +481,115 @@ CompBattDisableStatusNotify( return STATUS_SUCCESS; } +static +BOOLEAN +CompBattCalculateTotalRateAndLinkedBatteries( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension, + _Out_ PULONG TotalRate, + _Out_ PULONG BatteriesCount) +{ + PCOMPBATT_BATTERY_DATA BatteryData; + PLIST_ENTRY ListHead, NextEntry; + BOOLEAN BadBattery = FALSE; + ULONG LinkedBatteries = 0; + ULONG BadBatteriesCount = 0; + ULONG ComputedRate = 0; + + /* Loop over the linked batteries and sum up the total capacity rate */ + ExAcquireFastMutex(&DeviceExtension->Lock); + ListHead = &DeviceExtension->BatteryList; + for (NextEntry = ListHead->Flink; + NextEntry != ListHead; + NextEntry = NextEntry->Flink) + { + /* Acquire the remove lock so this battery does not disappear under us */ + BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); + if (!NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) + continue; + + /* + * Ensure this battery has a valid tag and that its rate capacity + * is not unknown. Reject unknown rates when calculating the total rate. + */ + if ((BatteryData->Tag != BATTERY_TAG_INVALID) && + (BatteryData->BatteryStatus.Rate != BATTERY_UNKNOWN_RATE)) + { + /* + * Now the ultimate judgement for this battery is to determine + * if the battery behaves optimally based on its current power + * state it is and the rate flow of the battery. + * + * If the rate flow is positive the battery is receiving power + * which increases the chemical potential energy as electrons + * move around, THIS MEANS the battery is CHARGING. If the rate + * flow is negative the battery cells are producing way less + * electrical energy, thus the battery is DISCHARGING. + * + * A consistent battery is a battery of which power state matches + * the rate flow. If that were the case, then we have found a bad + * battery. The worst case is that a battery is physically damanged. + */ + if ((BatteryData->BatteryStatus.PowerState & BATTERY_DISCHARGING) && + (BatteryData->BatteryStatus.Rate >= 0)) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: The battery is discharging but in reality it is charging... (Rate %d)\n", + BatteryData->BatteryStatus.Rate); + + BadBattery = TRUE; + BadBatteriesCount++; + } + + if ((BatteryData->BatteryStatus.PowerState & BATTERY_CHARGING) && + (BatteryData->BatteryStatus.Rate <= 0)) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: The battery is charging but in reality it is discharging... (Rate %d)\n", + BatteryData->BatteryStatus.Rate); + + BadBattery = TRUE; + BadBatteriesCount++; + } + + if (((BatteryData->BatteryStatus.PowerState & (BATTERY_CHARGING | BATTERY_DISCHARGING)) == 0) && + (BatteryData->BatteryStatus.Rate != 0)) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: The battery is neither charging or discharging but has a contradicting rate... (Rate %d)\n", + BatteryData->BatteryStatus.Rate); + + BadBattery = TRUE; + BadBatteriesCount++; + } + + /* + * Sum up the rate of this battery to make up the total, even if that means + * the battery may have incosistent rate. This is because it is still a linked + * battery to the composite battery and it is used to power up the system nonetheless. + */ + ComputedRate += BatteryData->BatteryStatus.Rate; + } + + /* We are done with this individual battery */ + LinkedBatteries++; + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + } + + /* Release the lock as we are no longer poking through the batteries list */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Print out the total count of bad batteries we have found */ + if (BadBatteriesCount > 0) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: %lu bad batteries have been found!\n", BadBatteriesCount); + } + + *TotalRate = ComputedRate; + *BatteriesCount = LinkedBatteries; + return BadBattery; +} + NTSTATUS NTAPI CompBattSetStatusNotify( @@ -488,8 +597,226 @@ CompBattSetStatusNotify( _In_ ULONG BatteryTag, _In_ PBATTERY_NOTIFY BatteryNotify) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + NTSTATUS Status; + BOOLEAN BadBattery; + ULONG TotalRate; + ULONG BatteriesCount; + ULONG HighestCapacity; + ULONG LowCapDifference, HighCapDifference, LowDelta, HighDelta; + BATTERY_STATUS BatteryStatus; + PCOMPBATT_BATTERY_DATA BatteryData; + PLIST_ENTRY ListHead, NextEntry; + + /* + * The caller wants to set new status notification settings but the composite + * battery does not have a valid tag assigned, or the tag does not actually match. + */ + if (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED) || + (DeviceExtension->Tag != BatteryTag)) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Composite battery tag not assigned or not matching (Tag -> %lu, Composite Tag -> %lu)\n", + BatteryTag, DeviceExtension->Tag); + + return STATUS_NO_SUCH_DEVICE; + } + + /* + * Before we are setting up new status wait notification points we need to + * refresh the composite status so that we get to know what values should be + * set for the current notification wait status. + */ + Status = CompBattQueryStatus(DeviceExtension, + BatteryTag, + &BatteryStatus); + if (!NT_SUCCESS(Status)) + { + if (CompBattDebug & COMPBATT_DEBUG_ERR) + DbgPrint("CompBatt: Failed to refresh composite battery's status (Status 0x%08lx)\n", Status); + + return Status; + } + + /* Print out battery status data that has been polled */ + if (CompBattDebug & COMPBATT_DEBUG_INFO) + DbgPrint("CompBatt: Latest composite battery status (when setting notify status)\n" + " PowerState -> 0x%lx\n" + " Capacity -> %u\n" + " Voltage -> %u\n" + " Rate -> %d\n", + BatteryStatus.PowerState, + BatteryStatus.Capacity, + BatteryStatus.Voltage, + BatteryStatus.Rate); + + /* Calculate the high and low capacity differences based on the real summed capacity of the composite */ + LowCapDifference = DeviceExtension->BatteryStatus.Capacity - BatteryNotify->LowCapacity; + HighCapDifference = BatteryNotify->HighCapacity - DeviceExtension->BatteryStatus.Capacity; + + /* Cache the notification parameters provided for later usage when polling for battery status */ + DeviceExtension->WaitNotifyStatus.PowerState = BatteryNotify->PowerState; + DeviceExtension->WaitNotifyStatus.LowCapacity = BatteryNotify->LowCapacity; + DeviceExtension->WaitNotifyStatus.HighCapacity = BatteryNotify->HighCapacity; + + /* Toggle the valid notify flag as these are the newer notification settings */ + DeviceExtension->Flags |= COMPBATT_STATUS_NOTIFY_SET; + + /* + * Get the number of currently linked batteries to composite and total rate, + * we will use these counters later to determine the wait values for each + * individual battery. + */ + BadBattery = CompBattCalculateTotalRateAndLinkedBatteries(DeviceExtension, + &TotalRate, + &BatteriesCount); + + /* + * Of course we have to be sure that we have at least one battery linked + * with the composite battery at this time of getting invoked to set new + * notification wait settings. + */ + ASSERT(BatteriesCount != 0); + + /* Walk over the linked batteries list and set up new wait configuration settings */ + ExAcquireFastMutex(&DeviceExtension->Lock); + ListHead = &DeviceExtension->BatteryList; + for (NextEntry = ListHead->Flink; + NextEntry != ListHead; + NextEntry = NextEntry->Flink) + { + /* Acquire the remove lock so this battery does not disappear under us */ + BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); + if (!NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) + continue; + + /* Now release the device lock since the battery can't go away */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Make sure this battery has a tag before setting new wait values */ + if (BatteryData->Tag != BATTERY_TAG_INVALID) + { + /* + * And also make sure this battery does not have an unknown + * capacity, we cannot set up new configuration wait settings + * based on that. Default the low and high wait capacities. + */ + if (BatteryData->BatteryStatus.Capacity != BATTERY_UNKNOWN_CAPACITY) + { + /* + * Calculate the low capacity wait setting. If at least one + * bad battery was found while we computed the total composite + * rate, then divide the difference between the total batteries. + * Otherwise compute the battery deltas of the composite based + * on total summed capacity rate. Otherwise if the total rate + * is 0, then the real wait low and high capacities will be on + * par with the real capacity. + */ + if (BadBattery) + { + LowDelta = LowCapDifference / BatteriesCount; + HighDelta = HighCapDifference / BatteriesCount; + } + else + { + if (TotalRate) + { + LowDelta = COMPUTE_BATT_CAP_DELTA(LowCapDifference, BatteryData, TotalRate); + HighDelta = COMPUTE_BATT_CAP_DELTA(HighCapDifference, BatteryData, TotalRate); + } + else + { + LowDelta = 0; + HighDelta = 0; + } + } + + /* + * Assign the wait low capacity setting ONLY if the battery delta + * is not high. Otherwise it has overflowed and we cannot use that + * for low capacity, of which we have to default it to 0. + */ + if (BatteryData->BatteryStatus.Capacity > LowDelta) + { + BatteryData->WaitStatus.LowCapacity = BatteryData->BatteryStatus.Capacity - LowDelta; + } + else + { + BatteryData->WaitStatus.LowCapacity = COMPBATT_WAIT_MIN_LOW_CAPACITY; + } + + /* + * Assign the wait high capacity setting ONLY if the real capacity + * is not above the maximum highest capacity constant. + */ + HighestCapacity = COMPBATT_WAIT_MAX_HIGH_CAPACITY - HighDelta; + if (HighestCapacity < BatteryData->BatteryStatus.Capacity) + { + BatteryData->WaitStatus.HighCapacity = HighestCapacity; + } + else + { + BatteryData->WaitStatus.HighCapacity = BatteryData->BatteryStatus.Capacity + HighDelta; + } + + /* + * We have set up the wait values but they are in conflict with the + * ones set up by the IRP complete worker. We have to cancel the IRP + * so the worker will copy our wait configuration values. + */ + if ((BatteryData->Mode == COMPBATT_READ_STATUS) && + (BatteryData->WaitStatus.PowerState != BatteryData->WorkerBuffer.WorkerWaitStatus.PowerState || + BatteryData->WaitStatus.LowCapacity != BatteryData->WorkerBuffer.WorkerWaitStatus.LowCapacity || + BatteryData->WaitStatus.HighCapacity != BatteryData->WorkerBuffer.WorkerWaitStatus.HighCapacity)) + { + if (CompBattDebug & COMPBATT_DEBUG_INFO) + DbgPrint("CompBatt: Configuration wait values are in conflict\n" + " BatteryData->WaitStatus.PowerState -> 0x%lx\n" + " BatteryData->WorkerBuffer.WorkerWaitStatus.PowerState -> 0x%lx\n" + " BatteryData->WaitStatus.LowCapacity -> %u\n" + " BatteryData->WorkerBuffer.WorkerWaitStatus.LowCapacity -> %u\n" + " BatteryData->WaitStatus.HighCapacity -> %u\n" + " BatteryData->WorkerBuffer.WorkerWaitStatus.HighCapacity -> %u\n", + BatteryData->WaitStatus.PowerState, + BatteryData->WorkerBuffer.WorkerWaitStatus.PowerState, + BatteryData->WaitStatus.LowCapacity, + BatteryData->WorkerBuffer.WorkerWaitStatus.LowCapacity, + BatteryData->WaitStatus.HighCapacity, + BatteryData->WorkerBuffer.WorkerWaitStatus.HighCapacity); + + IoCancelIrp(BatteryData->Irp); + } + } + else + { + BatteryData->WaitStatus.LowCapacity = BATTERY_UNKNOWN_CAPACITY; + BatteryData->WaitStatus.HighCapacity = BATTERY_UNKNOWN_CAPACITY; + } + } + + /* We are done with this battery */ + ExAcquireFastMutex(&DeviceExtension->Lock); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + } + + /* Release the lock as we are no longer poking through the batteries list */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Ensure the composite battery did not incur in drastic changes of tag */ + if (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED) || + (DeviceExtension->Tag != BatteryTag)) + { + /* + * Either the last battery was removed (in this case the composite is no + * longer existing) or a battery was removed of which the whole battery + * information must be recomputed and such. + */ + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Last battery or a battery was removed, the whole composite data must be recomputed\n"); + + return STATUS_NO_SUCH_DEVICE; + } + + return STATUS_SUCCESS; } NTSTATUS @@ -499,8 +826,216 @@ CompBattQueryStatus( _In_ ULONG Tag, _Out_ PBATTERY_STATUS BatteryStatus) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PCOMPBATT_BATTERY_DATA BatteryData; + BATTERY_WAIT_STATUS Wait; + PLIST_ENTRY ListHead, NextEntry; + ULONGLONG LastReadTime, CurrentReadTime; + NTSTATUS Status = STATUS_SUCCESS; + + /* + * The caller wants to update the composite battery status but the composite + * itself does not have a valid tag assigned, or the tag does not actually match. + */ + if (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED) || + (DeviceExtension->Tag != Tag)) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Composite battery tag not assigned or not matching (Tag -> %lu, Composite Tag -> %lu)\n", + Tag, DeviceExtension->Tag); + + return STATUS_NO_SUCH_DEVICE; + } + + /* Initialize the status and wait fields with zeros */ + RtlZeroMemory(BatteryStatus, sizeof(*BatteryStatus)); + RtlZeroMemory(&Wait, sizeof(Wait)); + + /* + * The battery status was already updated when the caller queried for new + * status. We do not need to update the status again for no reason. + * Just give them the data outright. + */ + CurrentReadTime = KeQueryInterruptTime(); + LastReadTime = CurrentReadTime - DeviceExtension->InterruptTime; + if (LastReadTime < COMPBATT_FRESH_STATUS_TIME) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Composite battery status data is fresh, no need to update it again\n"); + + RtlCopyMemory(BatteryStatus, &DeviceExtension->BatteryStatus, sizeof(BATTERY_STATUS)); + return STATUS_SUCCESS; + } + + /* + * Initialize the battery status context with unknown defaults, until we get + * to retrieve the real data from each battery and compute the exact status. + * Assume the system is powered by AC source for now until we find out it is + * not the case. + */ + BatteryStatus->PowerState = BATTERY_POWER_ON_LINE; + BatteryStatus->Capacity = BATTERY_UNKNOWN_CAPACITY; + BatteryStatus->Voltage = BATTERY_UNKNOWN_VOLTAGE; + BatteryStatus->Rate = BATTERY_UNKNOWN_RATE; + + /* Iterate over all the present linked batteries and retrieve their status */ + ExAcquireFastMutex(&DeviceExtension->Lock); + ListHead = &DeviceExtension->BatteryList; + for (NextEntry = ListHead->Flink; + NextEntry != ListHead; + NextEntry = NextEntry->Flink) + { + /* Acquire the remove lock so this battery does not disappear under us */ + BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); + if (!NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) + continue; + + /* Now release the device lock since the battery can't go away */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Setup the battery tag for the status wait which is needed to send off the IOCTL */ + Wait.BatteryTag = BatteryData->Tag; + + /* Make sure this battery has a tag before we send off the IOCTL */ + if (BatteryData->Tag != BATTERY_TAG_INVALID) + { + /* Only query new battery status data if it is no longer fresh */ + LastReadTime = CurrentReadTime - BatteryData->InterruptTime; + if (LastReadTime > COMPBATT_FRESH_STATUS_TIME) + { + RtlZeroMemory(&BatteryData->BatteryStatus, + sizeof(BatteryData->BatteryStatus)); + Status = BatteryIoctl(IOCTL_BATTERY_QUERY_STATUS, + BatteryData->DeviceObject, + &Wait, + sizeof(Wait), + &BatteryData->BatteryStatus, + sizeof(BatteryData->BatteryStatus), + FALSE); + if (!NT_SUCCESS(Status)) + { + /* + * If the device is being suddenly removed then we must invalidate + * both this battery and composite tags. + */ + if (Status == STATUS_DEVICE_REMOVED) + { + Status = STATUS_NO_SUCH_DEVICE; + } + + ExAcquireFastMutex(&DeviceExtension->Lock); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + break; + } + + /* Update the timestamp of the current read of battery status */ + BatteryData->InterruptTime = CurrentReadTime; + } + + /* + * Now it is time to combine the data into the composite status. + * The battery is either charging or discharging. AC is present + * only if the charger supplies current to all batteries. And + * the composite is deemed as critical if at least one battery + * is discharging and it is in crtitical state. + */ + BatteryStatus->PowerState |= (BatteryData->BatteryStatus.PowerState & (BATTERY_CHARGING | BATTERY_DISCHARGING)); + BatteryStatus->PowerState &= (BatteryData->BatteryStatus.PowerState | ~BATTERY_POWER_ON_LINE); + if ((BatteryData->BatteryStatus.PowerState & BATTERY_CRITICAL) && + (BatteryData->BatteryStatus.PowerState & BATTERY_DISCHARGING)) + { + BatteryStatus->PowerState |= BATTERY_CRITICAL; + } + + /* Add up the battery capacity if it is not unknown */ + if (BatteryData->BatteryStatus.Capacity != BATTERY_UNKNOWN_CAPACITY) + { + if (BatteryStatus->Capacity != BATTERY_UNKNOWN_CAPACITY) + { + BatteryStatus->Capacity += BatteryData->BatteryStatus.Capacity; + } + else + { + BatteryStatus->Capacity = BatteryData->BatteryStatus.Capacity; + } + } + + /* Always pick up the greatest voltage for the composite battery */ + if (BatteryData->BatteryStatus.Voltage != BATTERY_UNKNOWN_VOLTAGE) + { + if (BatteryStatus->Voltage != BATTERY_UNKNOWN_VOLTAGE) + { + BatteryStatus->Voltage = max(BatteryStatus->Voltage, + BatteryData->BatteryStatus.Voltage); + } + else + { + BatteryStatus->Voltage = BatteryData->BatteryStatus.Voltage; + } + } + + /* Add up the battery discharge rate if it is not unknown */ + if (BatteryData->BatteryStatus.Rate != BATTERY_UNKNOWN_RATE) + { + if (BatteryStatus->Rate != BATTERY_UNKNOWN_RATE) + { + BatteryStatus->Rate += BatteryData->BatteryStatus.Rate; + } + else + { + BatteryStatus->Rate = BatteryData->BatteryStatus.Rate; + } + } + } + + /* We are done combining data from this battery */ + ExAcquireFastMutex(&DeviceExtension->Lock); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); + } + + /* Release the lock as we are no longer poking through the batteries list */ + ExReleaseFastMutex(&DeviceExtension->Lock); + + /* Ensure the composite battery did not incur in drastic changes of tag */ + if (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED) || + (DeviceExtension->Tag != Tag)) + { + /* + * Either the last battery was removed (in this case the composite is no + * longer existing) or a battery was removed of which the whole battery + * information must be recomputed and such. + */ + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Last battery or a battery was removed, the whole composite data must be recomputed\n"); + + return STATUS_NO_SUCH_DEVICE; + } + + /* + * If there is a battery that is charging while another one discharging, + * then tell the caller the composite battery is actually discharging. + * This is less likely to happen on a multi-battery system like laptops + * as the charger would provide electricity to all the batteries. + * Perhaps the most likely case scenario would be if the system were + * to be powered by a UPS. + */ + if ((BatteryStatus->PowerState & BATTERY_CHARGING) && + (BatteryStatus->PowerState & BATTERY_DISCHARGING)) + { + BatteryStatus->PowerState &= ~BATTERY_CHARGING; + } + + /* Copy the combined status information to the composite battery */ + if (NT_SUCCESS(Status)) + { + RtlCopyMemory(&DeviceExtension->BatteryStatus, + BatteryStatus, + sizeof(DeviceExtension->BatteryStatus)); + + /* Update the last read battery status timestamp as well */ + DeviceExtension->InterruptTime = CurrentReadTime; + } + + return Status; } NTSTATUS

5 months, 3 weeks

[reactos] 10/15: [COMPBATT] Implement the battery monitor IRP worker

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=ee9914c71211175b1df88… commit ee9914c71211175b1df887baf5eaf0bba14351d1 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:40:36 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:08 2025 +0100 [COMPBATT] Implement the battery monitor IRP worker --- drivers/bus/acpi/compbatt/compbatt.c | 275 ++++++++++++++++++++++++++++++++++- 1 file changed, 271 insertions(+), 4 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index ea1e287ece0..9e0e5d3a782 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -74,8 +74,19 @@ CompBattMonitorIrpComplete( _In_ PIRP Irp, _In_ PVOID Context) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + PIO_STACK_LOCATION IoStackLocation; + PCOMPBATT_BATTERY_DATA BatteryData; + + /* We do not care about the device object */ + UNREFERENCED_PARAMETER(DeviceObject); + + /* Grab the composite battery data from the I/O stack packet */ + IoStackLocation = IoGetCurrentIrpStackLocation(Irp); + BatteryData = IoStackLocation->Parameters.Others.Argument2; + + /* Request the IRP complete worker to do the deed */ + ExQueueWorkItem(&BatteryData->WorkItem, DelayedWorkQueue); + return STATUS_MORE_PROCESSING_REQUIRED; } VOID @@ -83,8 +94,264 @@ NTAPI CompBattMonitorIrpCompleteWorker( _In_ PCOMPBATT_BATTERY_DATA BatteryData) { - UNIMPLEMENTED; - return STATUS_NOT_IMPLEMENTED; + NTSTATUS Status; + PIRP Irp; + UCHAR Mode; + ULONG PrevPowerState; + PDEVICE_OBJECT DeviceObject; + BATTERY_STATUS BatteryStatus; + PIO_STACK_LOCATION IoStackLocation; + PCOMPBATT_DEVICE_EXTENSION DeviceExtension; + + /* Cache the necessary battery data */ + Irp = BatteryData->Irp; + DeviceObject = BatteryData->DeviceObject; + IoStackLocation = IoGetCurrentIrpStackLocation(Irp); + DeviceExtension = IoStackLocation->Parameters.Others.Argument1; + + /* Switch to the next stack as we have to setup the control function data there */ + IoStackLocation = IoGetNextIrpStackLocation(Irp); + + /* Has the I/O composite battery request succeeded? */ + Status = Irp->IoStatus.Status; + if (!NT_SUCCESS(Status) && Status != STATUS_CANCELLED) + { + /* + * This battery is being removed from the composite, perform + * cleanups and do not inquire I/O requests again on this battery. + */ + if (Status == STATUS_DEVICE_REMOVED) + { + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Battery (0x%p) is being removed from composite battery\n", BatteryData); + + IoFreeIrp(Irp); + CompBattRemoveBattery(&BatteryData->BatteryName, DeviceExtension); + return; + } + + /* + * This is the first time a battery is being added into the composite + * (we understand that if Status was STATUS_DEVICE_NOT_CONNECTED). + * We must invalidate the composite tag and request a recalculation + * of the battery tag. + */ + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Battery arrived for first time or disappeared (Status 0x%08lx)\n", Status); + + BatteryData->Tag = BATTERY_TAG_INVALID; + + /* + * Invalidate the last read status interrupt time as well since the last + * battery status data no longer applies. Same for the composite battery + * as well. + */ + BatteryData->InterruptTime = 0; + DeviceExtension->InterruptTime = 0; + + /* Notify Battery Class the battery status incurs in a change */ + BatteryClassStatusNotify(DeviceExtension->ClassData); + + /* Setup the necessary I/O data to query the battery tag */ + IoStackLocation->Parameters.DeviceIoControl.IoControlCode = IOCTL_BATTERY_QUERY_TAG; + IoStackLocation->Parameters.DeviceIoControl.InputBufferLength = sizeof(ULONG); + IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength = sizeof(ULONG); + BatteryData->Mode = COMPBATT_QUERY_TAG; + BatteryData->WorkerBuffer.WorkerTag = 0xFFFFFFFF; + + /* Dispatch our request now to the battery's driver */ + goto DispatchRequest; + } + + /* Our I/O request has been completed successfully, check what did we get */ + Mode = BatteryData->Mode; + switch (Mode) + { + case COMPBATT_QUERY_TAG: + { + /* + * This battery has just gotten a tag, acknowledge the composite battery + * about that so it can recalculate its own composite tag. + */ + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Battery (Device 0x%p) has a tag of %lu\n", DeviceObject, BatteryData->WorkerBuffer.WorkerTag); + + /* Ensure the battery tag is not bogus, getting a tag of 0 is illegal */ + ASSERT(BatteryData->WorkerBuffer.WorkerTag != 0); + + /* Assign the battery tag */ + BatteryData->Tag = BatteryData->WorkerBuffer.WorkerTag; + BatteryData->Flags |= COMPBATT_TAG_ASSIGNED; + + /* Punt the composite battery flags, as the previous cached data no longer applies */ + DeviceExtension->Flags = 0; + + /* Notify the Battery Class driver this battery has got a tag */ + BatteryClassStatusNotify(DeviceExtension->ClassData); + break; + } + + case COMPBATT_READ_STATUS: + { + /* + * Read the battery status only if the IRP has not been cancelled, + * otherwise the request must be re-issued again. This typically + * happens if the wait values are in conflict which it might + * end up in inconsistent battery status results. + */ + if (Status != STATUS_CANCELLED && !Irp->Cancel) + { + /* + * If we reach here then the battery has entered into a change of + * power state or its charge capacity has changed. + */ + if (CompBattDebug & COMPBATT_DEBUG_WARN) + DbgPrint("CompBatt: Battery state (Device 0x%p) has changed\n", DeviceObject); + + /* Copy the battery status of this battery */ + RtlCopyMemory(&BatteryData->BatteryStatus, + &BatteryData->WorkerBuffer.WorkerStatus, + sizeof(BatteryData->BatteryStatus)); + + /* Update the interrupt time as this is the most recent read of the battery status */ + BatteryData->InterruptTime = KeQueryInterruptTime(); + + /* + * Ensure we have not gotten unknown capacities while we waited for new + * battery status. The battery might have malfunctioned or something. + */ + if (BatteryData->WorkerBuffer.WorkerStatus.Capacity == BATTERY_UNKNOWN_CAPACITY) + { + /* We do not know the capacity of this battery, default the low and high capacities */ + BatteryData->WaitStatus.LowCapacity = BATTERY_UNKNOWN_CAPACITY; + BatteryData->WaitStatus.HighCapacity = BATTERY_UNKNOWN_CAPACITY; + } + else + { + /* We know the capacity, adjust the low and high capacities accordingly */ + if (BatteryData->WaitStatus.LowCapacity > + BatteryData->WorkerBuffer.WorkerStatus.Capacity) + { + BatteryData->WaitStatus.LowCapacity = BatteryData->WorkerBuffer.WorkerStatus.Capacity; + } + + if (BatteryData->WaitStatus.HighCapacity < + BatteryData->WorkerBuffer.WorkerStatus.Capacity) + { + BatteryData->WaitStatus.HighCapacity = BatteryData->WorkerBuffer.WorkerStatus.Capacity; + } + } + + /* Copy the current last read power state for the next wait */ + BatteryData->WaitStatus.PowerState = BatteryData->WorkerBuffer.WorkerStatus.PowerState; + + /* + * Cache the previous power state of the composite battery and invalidate + * the last computed battery status interrupt time. This is because, + * logically, this specific battery incurred in a state change therefore + * the previous composite status is no longer consistent. + */ + PrevPowerState = DeviceExtension->BatteryStatus.PowerState; + DeviceExtension->InterruptTime = 0; + + /* Compute a new battery status for the composite battery */ + Status = CompBattQueryStatus(DeviceExtension, + DeviceExtension->Tag, + &BatteryStatus); + + /* Print out the current battery status of the composite to the debugger */ + if ((CompBattDebug & COMPBATT_DEBUG_INFO) && NT_SUCCESS(Status)) + DbgPrint("CompBatt: Latest composite battery status\n" + " PowerState -> 0x%lx\n" + " Capacity -> %u\n" + " Voltage -> %u\n" + " Rate -> %d\n", + BatteryStatus.PowerState, + BatteryStatus.Capacity, + BatteryStatus.Voltage, + BatteryStatus.Rate); + + /* + * Now determine whether should we notify the Battery Class driver due to + * changes in power state settings in the composite battery. This could + * happen in two following conditions: + * + * 1. The status notify flag was set for the respective power notification + * settings, and the composite battery incurred in a change of such + * settings. In this case we have to probe the current settings that + * they have changed. + * + * 2. The status notify flag was not set, therefore we do not know the + * exact configuration of the notification settings. We only care that + * the power state has changed at this point. + * + * Why do we have to do this is because we have to warn the Battery Class + * about the data that has changed. + */ + if (!(DeviceExtension->Flags & COMPBATT_STATUS_NOTIFY_SET)) + { + if (PrevPowerState != DeviceExtension->BatteryStatus.PowerState) + { + /* The previous power state is no longer valid, notify Battery Class */ + BatteryClassStatusNotify(DeviceExtension->ClassData); + } + } + else + { + /* + * Unlike the condition above, we check for power state change against + * the current notify wait set since the notify set flag bit is assigned. + */ + if (DeviceExtension->WaitNotifyStatus.PowerState != DeviceExtension->BatteryStatus.PowerState || + DeviceExtension->WaitNotifyStatus.LowCapacity > DeviceExtension->BatteryStatus.Capacity || + DeviceExtension->WaitNotifyStatus.HighCapacity < DeviceExtension->BatteryStatus.Capacity) + { + /* The following configuration settings have changed, notify Battery Class */ + BatteryClassStatusNotify(DeviceExtension->ClassData); + } + } + } + + break; + } + + default: + { + ASSERTMSG("CompBatt: BAD!!! WE SHOULD NOT BE HERE!\n", FALSE); + UNREACHABLE; + } + } + + /* Setup the necessary data to read battery status */ + BatteryData->WaitStatus.BatteryTag = BatteryData->Tag; + BatteryData->WaitStatus.Timeout = 3000; // FIXME: Hardcoded (wait for 3 seconds) because we do not have ACPI notifications implemented yet... + + RtlCopyMemory(&BatteryData->WorkerBuffer.WorkerWaitStatus, + &BatteryData->WaitStatus, + sizeof(BatteryData->WaitStatus)); + + IoStackLocation->Parameters.DeviceIoControl.IoControlCode = IOCTL_BATTERY_QUERY_STATUS; + IoStackLocation->Parameters.DeviceIoControl.InputBufferLength = sizeof(BatteryData->WorkerBuffer.WorkerWaitStatus); + IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength = sizeof(BatteryData->WorkerBuffer.WorkerStatus); + BatteryData->Mode = COMPBATT_READ_STATUS; + +DispatchRequest: + /* Setup the system buffer to that of the battery data which it will hold the returned data */ + IoStackLocation->MajorFunction = IRP_MJ_DEVICE_CONTROL; + Irp->AssociatedIrp.SystemBuffer = &BatteryData->WorkerBuffer; + Irp->Cancel = FALSE; + Irp->PendingReturned = FALSE; + + /* Setup the worker completion routine which it will invoke the worker later on */ + IoSetCompletionRoutine(Irp, + CompBattMonitorIrpComplete, + NULL, + TRUE, + TRUE, + TRUE); + + /* Dispatch the I/O request now */ + IoCallDriver(DeviceObject, Irp); } VOID

5 months, 3 weeks

[reactos] 09/15: [COMPBATT] Use FALSE for BOOLEANs on BatteryIoctl, not integers

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=6a06db09cac016fcc90dd… commit 6a06db09cac016fcc90dd654570add0c6b30f288 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:34:22 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:08 2025 +0100 [COMPBATT] Use FALSE for BOOLEANs on BatteryIoctl, not integers --- drivers/bus/acpi/compbatt/compbatt.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 76e339e1ee6..ea1e287ece0 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -286,7 +286,7 @@ CompBattGetBatteryInformation( sizeof(InputBuffer), &BatteryData->BatteryInformation, sizeof(BatteryData->BatteryInformation), - 0); + FALSE); if (!NT_SUCCESS(Status)) { /* Fail if the query had a problem */ @@ -442,7 +442,7 @@ CompBattGetBatteryGranularity( sizeof(InputBuffer), &BatteryScale, sizeof(BatteryScale), - 0); + FALSE); if (!NT_SUCCESS(Status)) { /* Fail if the query had a problem */

5 months, 3 weeks

[reactos] 08/15: [COMPBATT] Use the allocated battery IRPs as tags when acquiring I/O remove lock

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c944116833d2981b489ca… commit c944116833d2981b489ca4304aa605482b966107 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:33:02 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:07 2025 +0100 [COMPBATT] Use the allocated battery IRPs as tags when acquiring I/O remove lock --- drivers/bus/acpi/compbatt/compbatt.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 6100edf8aff..76e339e1ee6 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -261,7 +261,7 @@ CompBattGetBatteryInformation( { /* Try to acquire the remove lock */ BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); - if (NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, 0))) + if (NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) { /* Now release the device lock since the battery can't go away */ ExReleaseFastMutex(&DeviceExtension->Lock); @@ -292,7 +292,7 @@ CompBattGetBatteryInformation( /* Fail if the query had a problem */ if (Status == STATUS_DEVICE_REMOVED) Status = STATUS_NO_SUCH_DEVICE; ExAcquireFastMutex(&DeviceExtension->Lock); - IoReleaseRemoveLock(&BatteryData->RemoveLock, 0); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); break; } @@ -346,7 +346,7 @@ CompBattGetBatteryInformation( /* Re-acquire the device extension lock and release the remove lock */ ExAcquireFastMutex(&DeviceExtension->Lock); - IoReleaseRemoveLock(&BatteryData->RemoveLock, 0); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); } /* Next entry */ @@ -421,7 +421,7 @@ CompBattGetBatteryGranularity( { /* Try to acquire the remove lock */ BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink); - if (NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, 0))) + if (NT_SUCCESS(IoAcquireRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp))) { /* Now release the device lock since the battery can't go away */ ExReleaseFastMutex(&DeviceExtension->Lock); @@ -447,7 +447,7 @@ CompBattGetBatteryGranularity( { /* Fail if the query had a problem */ ExAcquireFastMutex(&DeviceExtension->Lock); - IoReleaseRemoveLock(&BatteryData->RemoveLock, 0); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); break; } @@ -467,7 +467,7 @@ CompBattGetBatteryGranularity( /* Re-acquire the device extension lock and release the remove lock */ ExAcquireFastMutex(&DeviceExtension->Lock); - IoReleaseRemoveLock(&BatteryData->RemoveLock, 0); + IoReleaseRemoveLock(&BatteryData->RemoveLock, BatteryData->Irp); } /* Next entry */

5 months, 3 weeks

[reactos] 07/15: [COMPBATT] Use the documented debug switches

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=95f062bf0d896a25e6522… commit 95f062bf0d896a25e6522012453f134034f3f4da Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:27:07 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:07 2025 +0100 [COMPBATT] Use the documented debug switches Use the debug switches that are documented and have a name rather than some cryptic values with no meaning or some shit. --- drivers/bus/acpi/compbatt/compbatt.c | 38 +++++++++++++------------- drivers/bus/acpi/compbatt/compmisc.c | 8 +++--- drivers/bus/acpi/compbatt/comppnp.c | 52 ++++++++++++++++++------------------ 3 files changed, 49 insertions(+), 49 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 313780d2d34..6100edf8aff 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -25,7 +25,7 @@ CompBattOpenClose( _In_ PIRP Irp) { PAGED_CODE(); - if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING OpenClose\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING OpenClose\n"); /* Complete the IRP with success */ Irp->IoStatus.Status = STATUS_SUCCESS; @@ -33,7 +33,7 @@ CompBattOpenClose( IoCompleteRequest(Irp, IO_NO_INCREMENT); /* Return success */ - if (CompBattDebug & 0x100) DbgPrint("CompBatt: Exiting OpenClose\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: Exiting OpenClose\n"); return STATUS_SUCCESS; } @@ -46,7 +46,7 @@ CompBattSystemControl( PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; NTSTATUS Status; PAGED_CODE(); - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING System Control\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING System Control\n"); /* Are we attached yet? */ if (DeviceExtension->AttachedDevice) @@ -95,7 +95,7 @@ CompBattRecalculateTag( PCOMPBATT_BATTERY_DATA BatteryData; ULONG Tag; PLIST_ENTRY ListHead, NextEntry; - if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING CompBattRecalculateTag\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING CompBattRecalculateTag\n"); /* Loop the battery list */ ExAcquireFastMutex(&DeviceExtension->Lock); @@ -122,7 +122,7 @@ CompBattRecalculateTag( /* We're done */ ExReleaseFastMutex(&DeviceExtension->Lock); - if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING CompBattRecalculateTag\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING CompBattRecalculateTag\n"); } NTSTATUS @@ -133,7 +133,7 @@ CompBattIoctl( { PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; NTSTATUS Status; - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING Ioctl\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING Ioctl\n"); /* Let the class driver handle it */ Status = BatteryClassIoctl(DeviceExtension->ClassData, Irp); @@ -146,7 +146,7 @@ CompBattIoctl( } /* Return status */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING Ioctl\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING Ioctl\n"); return Status; } @@ -158,7 +158,7 @@ CompBattQueryTag( { NTSTATUS Status; PAGED_CODE(); - if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING QueryTag\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING QueryTag\n"); /* Was a tag assigned? */ if (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED)) @@ -182,7 +182,7 @@ CompBattQueryTag( } /* Return status */ - if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING QueryTag\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING QueryTag\n"); return Status; } @@ -193,7 +193,7 @@ CompBattDisableStatusNotify( { PCOMPBATT_BATTERY_DATA BatteryData; PLIST_ENTRY ListHead, NextEntry; - if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING DisableStatusNotify\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING DisableStatusNotify\n"); /* Loop the battery list */ ExAcquireFastMutex(&DeviceExtension->Lock); @@ -210,7 +210,7 @@ CompBattDisableStatusNotify( /* Done */ ExReleaseFastMutex(&DeviceExtension->Lock); - if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING DisableStatusNotify\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING DisableStatusNotify\n"); return STATUS_SUCCESS; } @@ -246,7 +246,7 @@ CompBattGetBatteryInformation( BATTERY_QUERY_INFORMATION InputBuffer; PCOMPBATT_BATTERY_DATA BatteryData; PLIST_ENTRY ListHead, NextEntry; - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING GetBatteryInformation\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING GetBatteryInformation\n"); /* Set defaults */ BatteryInfo->DefaultAlert1 = 0; @@ -298,7 +298,7 @@ CompBattGetBatteryInformation( /* Next time we can use the static copy */ BatteryData->Flags |= COMPBATT_BATTERY_INFORMATION_PRESENT; - if (CompBattDebug & 2) + if (CompBattDebug & COMPBATT_DEBUG_INFO) DbgPrint("CompBattGetBatteryInformation: Read individual BATTERY_INFORMATION\n" "-------- Capabilities = %x\n-------- Technology = %x\n" "-------- Chemistry[4] = %x\n-------- DesignedCapacity = %x\n" @@ -364,7 +364,7 @@ CompBattGetBatteryInformation( } /* Print out final combined data */ - if (CompBattDebug & 2) + if (CompBattDebug & COMPBATT_DEBUG_INFO) DbgPrint("CompBattGetBatteryInformation: Returning BATTERY_INFORMATION\n" "-------- Capabilities = %x\n-------- Technology = %x\n" "-------- Chemistry[4] = %x\n-------- DesignedCapacity = %x\n" @@ -389,7 +389,7 @@ CompBattGetBatteryInformation( } /* We are done */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING GetBatteryInformation\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING GetBatteryInformation\n"); return Status; } @@ -405,7 +405,7 @@ CompBattGetBatteryGranularity( BATTERY_REPORTING_SCALE BatteryScale[4]; PLIST_ENTRY ListHead, NextEntry; ULONG i; - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING GetBatteryGranularity\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING GetBatteryGranularity\n"); /* Set defaults */ ReportingScale[0].Granularity = -1; @@ -476,7 +476,7 @@ CompBattGetBatteryGranularity( /* All done */ ExReleaseFastMutex(&DeviceExtension->Lock); - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING GetBatteryGranularity\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING GetBatteryGranularity\n"); return STATUS_SUCCESS; } @@ -510,7 +510,7 @@ CompBattQueryInformation( ULONG QueryLength = 0; NTSTATUS Status = STATUS_SUCCESS; PAGED_CODE(); - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING QueryInformation\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING QueryInformation\n"); /* Check for valid/correct tag */ if ((Tag != DeviceExtension->Tag) || @@ -601,7 +601,7 @@ CompBattQueryInformation( if ((NT_SUCCESS(Status)) && (QueryData)) RtlCopyMemory(Buffer, QueryData, QueryLength); /* Return function result */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING QueryInformation\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING QueryInformation\n"); return Status; } diff --git a/drivers/bus/acpi/compbatt/compmisc.c b/drivers/bus/acpi/compbatt/compmisc.c index 5992273863a..328628ee578 100644 --- a/drivers/bus/acpi/compbatt/compmisc.c +++ b/drivers/bus/acpi/compbatt/compmisc.c @@ -28,7 +28,7 @@ BatteryIoctl( NTSTATUS Status; PIRP Irp; PAGED_CODE(); - if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING BatteryIoctl\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING BatteryIoctl\n"); /* Initialize the event and IRP */ KeInitializeEvent(&Event, SynchronizationEvent, 0); @@ -53,16 +53,16 @@ BatteryIoctl( } /* Print failure */ - if (!(NT_SUCCESS(Status)) && (CompBattDebug & 8)) + if (!(NT_SUCCESS(Status)) && (CompBattDebug & COMPBATT_DEBUG_ERR)) DbgPrint("BatteryIoctl: Irp failed - %x\n", Status); /* Done */ - if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING BatteryIoctl\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING BatteryIoctl\n"); } else { /* Out of memory */ - if (CompBattDebug & 8) DbgPrint("BatteryIoctl: couldn't create Irp\n"); + if (CompBattDebug & COMPBATT_DEBUG_ERR) DbgPrint("BatteryIoctl: couldn't create Irp\n"); Status = STATUS_INSUFFICIENT_RESOURCES; } diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index 819badf5843..7fd3725e61f 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -21,7 +21,7 @@ CompBattPowerDispatch( _In_ PIRP Irp) { PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; - if (CompBattDebug & 1) DbgPrint("CompBatt: PowerDispatch received power IRP.\n"); + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: PowerDispatch received power IRP.\n"); /* Start the next IRP */ PoStartNextPowerIrp(Irp); @@ -39,7 +39,7 @@ RemoveBatteryFromList( { PLIST_ENTRY ListHead, NextEntry; PCOMPBATT_BATTERY_DATA BatteryData; - if (CompBattDebug & 1) + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING RemoveBatteryFromList\n"); /* Loop the battery list */ @@ -70,7 +70,7 @@ RemoveBatteryFromList( /* Done */ ExReleaseFastMutex(&DeviceExtension->Lock); - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING RemoveBatteryFromList\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING RemoveBatteryFromList\n"); return NULL; } @@ -83,7 +83,7 @@ IsBatteryAlreadyOnList( PLIST_ENTRY ListHead, NextEntry; PCOMPBATT_BATTERY_DATA BatteryData; BOOLEAN Found = FALSE; - if (CompBattDebug & 1) + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING IsBatteryAlreadyOnList\n"); /* Loop the battery list */ @@ -107,7 +107,7 @@ IsBatteryAlreadyOnList( /* Release the lock and return search status */ ExReleaseFastMutex(&DeviceExtension->Lock); - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING IsBatteryAlreadyOnList\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING IsBatteryAlreadyOnList\n"); return Found; } @@ -123,7 +123,7 @@ CompBattAddNewBattery( PIO_STACK_LOCATION IoStackLocation; PFILE_OBJECT FileObject; PAGED_CODE(); - if (CompBattDebug & 1) + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: ENTERING AddNewBattery \"%w\" \n", BatteryName->Buffer); /* Is this a new battery? */ @@ -189,13 +189,13 @@ CompBattAddNewBattery( else { /* Fail, no memory */ - if (CompBattDebug & 8) + if (CompBattDebug & COMPBATT_DEBUG_ERR) DbgPrint("CompBatt: Couldn't allocate new battery Irp\n"); Status = STATUS_INSUFFICIENT_RESOURCES; ObDereferenceObject(BatteryData->DeviceObject); } } - else if (CompBattDebug & 8) + else if (CompBattDebug & COMPBATT_DEBUG_ERR) { /* Fail */ DbgPrint("CompBattAddNewBattery: Failed to get device Object. status = %lx\n", @@ -211,14 +211,14 @@ CompBattAddNewBattery( else { /* Fail, no memory */ - if (CompBattDebug & 8) + if (CompBattDebug & COMPBATT_DEBUG_ERR) DbgPrint("CompBatt: Couldn't allocate new battery node\n"); Status = STATUS_INSUFFICIENT_RESOURCES; } } /* We're done */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING AddNewBattery\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING AddNewBattery\n"); return Status; } @@ -229,7 +229,7 @@ CompBattRemoveBattery( _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PCOMPBATT_BATTERY_DATA BatteryData; - if (CompBattDebug & 1) DbgPrint("CompBatt: RemoveBattery\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: RemoveBattery\n"); /* Remove the entry */ BatteryData = RemoveBatteryFromList(BatteryName, DeviceExtension); @@ -257,7 +257,7 @@ CompBattGetBatteries( NTSTATUS Status; PWCHAR LinkList; UNICODE_STRING LinkString; - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING GetBatteries\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING GetBatteries\n"); /* Get all battery links */ Status = IoGetDeviceInterfaces(&GUID_DEVICE_BATTERY, NULL, 0, &LinkList); @@ -279,14 +279,14 @@ CompBattGetBatteries( /* Parsing complete, clean up buffer */ ExFreePool(LinkList); } - else if (CompBattDebug & 8) + else if (CompBattDebug & COMPBATT_DEBUG_ERR) { /* Fail */ DbgPrint("CompBatt: Couldn't get list of batteries\n"); } /* Done */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING GetBatteries\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING GetBatteries\n"); return Status; } @@ -296,31 +296,31 @@ CompBattPnpEventHandler( _In_ PDEVICE_INTERFACE_CHANGE_NOTIFICATION Notification, _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING PnpEventHandler\n"); - if (CompBattDebug & 2) DbgPrint("CompBatt: Received device interface change notification\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING PnpEventHandler\n"); + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: Received device interface change notification\n"); /* Check what happened */ if (IsEqualGUIDAligned(&Notification->Event, &GUID_DEVICE_INTERFACE_ARRIVAL)) { /* Add the new battery */ - if (CompBattDebug & 2) + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: Received notification of battery arrival\n"); CompBattAddNewBattery(Notification->SymbolicLinkName, DeviceExtension); } else if (IsEqualGUIDAligned(&Notification->Event, &GUID_DEVICE_INTERFACE_REMOVAL)) { /* Don't do anything */ - if (CompBattDebug & 2) + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: Received notification of battery removal\n"); } else { /* Shouldn't happen */ - if (CompBattDebug & 2) DbgPrint("CompBatt: Received unhandled PnP event\n"); + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: Received unhandled PnP event\n"); } /* Done, return success */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING PnpEventHandler\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING PnpEventHandler\n"); return STATUS_SUCCESS; } @@ -336,7 +336,7 @@ CompBattAddDevice( PDEVICE_OBJECT DeviceObject; UNICODE_STRING SymbolicLinkName; BATTERY_MINIPORT_INFO MiniportInfo; - if (CompBattDebug & 2) DbgPrint("CompBatt: Got an AddDevice - %x\n", PdoDeviceObject); + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: Got an AddDevice - %x\n", PdoDeviceObject); /* Create the device */ RtlInitUnicodeString(&DeviceName, L"\\Device\\CompositeBattery"); @@ -364,7 +364,7 @@ CompBattAddDevice( if (!DeviceExtension->AttachedDevice) { /* Fail */ - if (CompBattDebug & 8) + if (CompBattDebug & COMPBATT_DEBUG_ERR) DbgPrint("CompBattAddDevice: Could not attach to LowerDevice.\n"); IoDeleteDevice(DeviceObject); return STATUS_UNSUCCESSFUL; @@ -417,7 +417,7 @@ CompBattPnpDispatch( PIO_STACK_LOCATION IoStackLocation = IoGetCurrentIrpStackLocation(Irp); NTSTATUS Status; PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; - if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING PnpDispatch\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: ENTERING PnpDispatch\n"); /* Set default error */ Status = STATUS_NOT_SUPPORTED; @@ -438,14 +438,14 @@ CompBattPnpDispatch( if (NT_SUCCESS(Status)) { /* Now go get the batteries */ - if (CompBattDebug & 2) + if (CompBattDebug & COMPBATT_DEBUG_WARN) DbgPrint("CompBatt: Successfully registered for PnP notification\n"); Status = CompBattGetBatteries(DeviceExtension); } else { /* We failed */ - if (CompBattDebug & 8) + if (CompBattDebug & COMPBATT_DEBUG_ERR) DbgPrint("CompBatt: Couldn't register for PnP notification - %x\n", Status); } @@ -499,7 +499,7 @@ CompBattPnpDispatch( } /* Release the remove lock and return status */ - if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING PnpDispatch\n"); + if (CompBattDebug & COMPBATT_DEBUG_TRACE) DbgPrint("CompBatt: EXITING PnpDispatch\n"); return Status; }

5 months, 3 weeks

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs