Ros-diffs January 2025

ros-diffs@reactos.org

23 participants
278 discussions

[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

4 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

4 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 */

4 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 */

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

4 weeks

[reactos] 06/15: [COMPBATT] Use the non-constant variant of UNICODE_STRING for the battery name

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=c6bdbefdc42e282b584a3… commit c6bdbefdc42e282b584a3c04a1b0e4fb88cec83d Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 22:09:10 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:07 2025 +0100 [COMPBATT] Use the non-constant variant of UNICODE_STRING for the battery name --- drivers/bus/acpi/compbatt/comppnp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index 31b05030b4f..819badf5843 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -225,7 +225,7 @@ CompBattAddNewBattery( NTSTATUS NTAPI CompBattRemoveBattery( - _In_ PCUNICODE_STRING BatteryName, + _In_ PUNICODE_STRING BatteryName, _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PCOMPBATT_BATTERY_DATA BatteryData;

4 weeks

[reactos] 05/15: [COMPBATT] Assign a memory allocation tag for the I/O remove lock

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=28bb8c6ff7b82b8216dfa… commit 28bb8c6ff7b82b8216dfa6bfb052f1d169959062 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 21:52:24 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:07 2025 +0100 [COMPBATT] Assign a memory allocation tag for the I/O remove lock IoInitializeRemoveLock expects an allocation tag to be provided when it allocates debug data in the kernel. Passing 0 leads to a bunch of ASSERTs in the kernel as such data is allocated by ExAllocatePoolWithTag of which a tag has to be supplied, it's not optional. --- drivers/bus/acpi/compbatt/comppnp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index 7e8523537ae..31b05030b4f 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -177,7 +177,7 @@ CompBattAddNewBattery( ExReleaseFastMutex(&DeviceExtension->Lock); /* Initialize the work item and delete lock */ - IoInitializeRemoveLock(&BatteryData->RemoveLock, 0, 0, 0); + IoInitializeRemoveLock(&BatteryData->RemoveLock, COMPBATT_TAG, 0, 0); ExInitializeWorkItem(&BatteryData->WorkItem, (PVOID)CompBattMonitorIrpCompleteWorker, BatteryData);

4 weeks

[reactos] 04/15: [COMPBATT] Pass NULL for the work item context, not 0

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=3346301777edabab3f947… commit 3346301777edabab3f947d8260e5e0ce10b03043 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 21:43:56 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:06 2025 +0100 [COMPBATT] Pass NULL for the work item context, not 0 It expects an arbitrary pointer, do the right thing! --- drivers/bus/acpi/compbatt/comppnp.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index efc40e9f62e..7e8523537ae 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -183,7 +183,7 @@ CompBattAddNewBattery( BatteryData); /* Setup the IRP work entry */ - CompBattMonitorIrpComplete(BatteryData->DeviceObject, Irp, 0); + CompBattMonitorIrpComplete(BatteryData->DeviceObject, Irp, NULL); Status = STATUS_SUCCESS; } else

4 weeks

[reactos] 03/15: [COMPBATT] Annotate all functions with SAL2

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=8b5423aa601b214532284… commit 8b5423aa601b2145322841d4923bf95e2d06d2be Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 21:36:49 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:06 2025 +0100 [COMPBATT] Annotate all functions with SAL2 --- drivers/bus/acpi/compbatt/compbatt.c | 87 +++++++++++++++++++++--------------- drivers/bus/acpi/compbatt/compmisc.c | 24 +++++----- drivers/bus/acpi/compbatt/comppnp.c | 43 +++++++++++------- 3 files changed, 90 insertions(+), 64 deletions(-) diff --git a/drivers/bus/acpi/compbatt/compbatt.c b/drivers/bus/acpi/compbatt/compbatt.c index 2c947910c29..313780d2d34 100644 --- a/drivers/bus/acpi/compbatt/compbatt.c +++ b/drivers/bus/acpi/compbatt/compbatt.c @@ -20,8 +20,9 @@ ULONG CompBattDebug; NTSTATUS NTAPI -CompBattOpenClose(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) +CompBattOpenClose( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) { PAGED_CODE(); if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING OpenClose\n"); @@ -38,8 +39,9 @@ CompBattOpenClose(IN PDEVICE_OBJECT DeviceObject, NTSTATUS NTAPI -CompBattSystemControl(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) +CompBattSystemControl( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) { PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; NTSTATUS Status; @@ -67,17 +69,19 @@ CompBattSystemControl(IN PDEVICE_OBJECT DeviceObject, NTSTATUS NTAPI -CompBattMonitorIrpComplete(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp, - IN PKEVENT Event) +CompBattMonitorIrpComplete( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp, + _In_ PVOID Context) { UNIMPLEMENTED; return STATUS_NOT_IMPLEMENTED; } -NTSTATUS +VOID NTAPI -CompBattMonitorIrpCompleteWorker(IN PCOMPBATT_BATTERY_DATA BatteryData) +CompBattMonitorIrpCompleteWorker( + _In_ PCOMPBATT_BATTERY_DATA BatteryData) { UNIMPLEMENTED; return STATUS_NOT_IMPLEMENTED; @@ -85,7 +89,8 @@ CompBattMonitorIrpCompleteWorker(IN PCOMPBATT_BATTERY_DATA BatteryData) VOID NTAPI -CompBattRecalculateTag(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattRecalculateTag( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PCOMPBATT_BATTERY_DATA BatteryData; ULONG Tag; @@ -122,8 +127,9 @@ CompBattRecalculateTag(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) NTSTATUS NTAPI -CompBattIoctl(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) +CompBattIoctl( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) { PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; NTSTATUS Status; @@ -146,8 +152,9 @@ CompBattIoctl(IN PDEVICE_OBJECT DeviceObject, NTSTATUS NTAPI -CompBattQueryTag(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, - OUT PULONG Tag) +CompBattQueryTag( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension, + _Out_ PULONG Tag) { NTSTATUS Status; PAGED_CODE(); @@ -181,7 +188,8 @@ CompBattQueryTag(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, NTSTATUS NTAPI -CompBattDisableStatusNotify(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattDisableStatusNotify( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PCOMPBATT_BATTERY_DATA BatteryData; PLIST_ENTRY ListHead, NextEntry; @@ -208,9 +216,10 @@ CompBattDisableStatusNotify(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) NTSTATUS NTAPI -CompBattSetStatusNotify(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, - IN ULONG BatteryTag, - IN PBATTERY_NOTIFY BatteryNotify) +CompBattSetStatusNotify( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension, + _In_ ULONG BatteryTag, + _In_ PBATTERY_NOTIFY BatteryNotify) { UNIMPLEMENTED; return STATUS_NOT_IMPLEMENTED; @@ -218,9 +227,10 @@ CompBattSetStatusNotify(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, NTSTATUS NTAPI -CompBattQueryStatus(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, - IN ULONG Tag, - IN PBATTERY_STATUS BatteryStatus) +CompBattQueryStatus( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension, + _In_ ULONG Tag, + _Out_ PBATTERY_STATUS BatteryStatus) { UNIMPLEMENTED; return STATUS_NOT_IMPLEMENTED; @@ -228,8 +238,9 @@ CompBattQueryStatus(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, NTSTATUS NTAPI -CompBattGetBatteryInformation(OUT PBATTERY_INFORMATION BatteryInfo, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattGetBatteryInformation( + _Out_ PBATTERY_INFORMATION BatteryInfo, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { NTSTATUS Status = STATUS_SUCCESS; BATTERY_QUERY_INFORMATION InputBuffer; @@ -384,8 +395,9 @@ CompBattGetBatteryInformation(OUT PBATTERY_INFORMATION BatteryInfo, NTSTATUS NTAPI -CompBattGetBatteryGranularity(OUT PBATTERY_REPORTING_SCALE ReportingScale, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattGetBatteryGranularity( + _Out_ PBATTERY_REPORTING_SCALE ReportingScale, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { NTSTATUS Status = STATUS_SUCCESS; BATTERY_QUERY_INFORMATION InputBuffer; @@ -470,8 +482,9 @@ CompBattGetBatteryGranularity(OUT PBATTERY_REPORTING_SCALE ReportingScale, NTSTATUS NTAPI -CompBattGetEstimatedTime(OUT PULONG Time, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattGetEstimatedTime( + _Out_ PULONG Time, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { UNIMPLEMENTED; return STATUS_NOT_IMPLEMENTED; @@ -479,13 +492,14 @@ CompBattGetEstimatedTime(OUT PULONG Time, NTSTATUS NTAPI -CompBattQueryInformation(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, - IN ULONG Tag, - IN BATTERY_QUERY_INFORMATION_LEVEL InfoLevel, - IN OPTIONAL LONG AtRate, - IN PVOID Buffer, - IN ULONG BufferLength, - OUT PULONG ReturnedLength) +CompBattQueryInformation( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension, + _In_ ULONG Tag, + _In_ BATTERY_QUERY_INFORMATION_LEVEL InfoLevel, + _In_opt_ LONG AtRate, + _In_ PVOID Buffer, + _In_ ULONG BufferLength, + _Out_ PULONG ReturnedLength) { BATTERY_INFORMATION BatteryInfo; BATTERY_REPORTING_SCALE BatteryGranularity[4]; @@ -593,8 +607,9 @@ CompBattQueryInformation(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, NTSTATUS NTAPI -DriverEntry(IN PDRIVER_OBJECT DriverObject, - IN PUNICODE_STRING RegistryPath) +DriverEntry( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PUNICODE_STRING RegistryPath) { /* Register add device routine */ DriverObject->DriverExtension->AddDevice = CompBattAddDevice; diff --git a/drivers/bus/acpi/compbatt/compmisc.c b/drivers/bus/acpi/compbatt/compmisc.c index e84a2512706..5992273863a 100644 --- a/drivers/bus/acpi/compbatt/compmisc.c +++ b/drivers/bus/acpi/compbatt/compmisc.c @@ -14,13 +14,14 @@ NTSTATUS NTAPI -BatteryIoctl(IN ULONG IoControlCode, - IN PDEVICE_OBJECT DeviceObject, - IN PVOID InputBuffer, - IN ULONG InputBufferLength, - IN PVOID OutputBuffer, - IN ULONG OutputBufferLength, - IN BOOLEAN InternalDeviceIoControl) +BatteryIoctl( + _In_ ULONG IoControlCode, + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PVOID InputBuffer, + _In_ ULONG InputBufferLength, + _Out_ PVOID OutputBuffer, + _Inout_ ULONG OutputBufferLength, + _In_ BOOLEAN InternalDeviceIoControl) { IO_STATUS_BLOCK IoStatusBlock; KEVENT Event; @@ -71,10 +72,11 @@ BatteryIoctl(IN ULONG IoControlCode, NTSTATUS NTAPI -CompBattGetDeviceObjectPointer(IN PUNICODE_STRING DeviceName, - IN ACCESS_MASK DesiredAccess, - OUT PFILE_OBJECT *FileObject, - OUT PDEVICE_OBJECT *DeviceObject) +CompBattGetDeviceObjectPointer( + _In_ PUNICODE_STRING DeviceName, + _In_ ACCESS_MASK DesiredAccess, + _Out_ PFILE_OBJECT *FileObject, + _Out_ PDEVICE_OBJECT *DeviceObject) { NTSTATUS Status; OBJECT_ATTRIBUTES ObjectAttributes; diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index f16bfd2ed3d..efc40e9f62e 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -16,8 +16,9 @@ NTSTATUS NTAPI -CompBattPowerDispatch(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) +CompBattPowerDispatch( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) { PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension; if (CompBattDebug & 1) DbgPrint("CompBatt: PowerDispatch received power IRP.\n"); @@ -32,8 +33,9 @@ CompBattPowerDispatch(IN PDEVICE_OBJECT DeviceObject, PCOMPBATT_BATTERY_DATA NTAPI -RemoveBatteryFromList(IN PCUNICODE_STRING BatteryName, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +RemoveBatteryFromList( + _In_ PCUNICODE_STRING BatteryName, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PLIST_ENTRY ListHead, NextEntry; PCOMPBATT_BATTERY_DATA BatteryData; @@ -74,8 +76,9 @@ RemoveBatteryFromList(IN PCUNICODE_STRING BatteryName, BOOLEAN NTAPI -IsBatteryAlreadyOnList(IN PCUNICODE_STRING BatteryName, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +IsBatteryAlreadyOnList( + _In_ PCUNICODE_STRING BatteryName, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PLIST_ENTRY ListHead, NextEntry; PCOMPBATT_BATTERY_DATA BatteryData; @@ -110,8 +113,9 @@ IsBatteryAlreadyOnList(IN PCUNICODE_STRING BatteryName, NTSTATUS NTAPI -CompBattAddNewBattery(IN PUNICODE_STRING BatteryName, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattAddNewBattery( + _In_ PUNICODE_STRING BatteryName, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { NTSTATUS Status = STATUS_SUCCESS; PCOMPBATT_BATTERY_DATA BatteryData; @@ -220,8 +224,9 @@ CompBattAddNewBattery(IN PUNICODE_STRING BatteryName, NTSTATUS NTAPI -CompBattRemoveBattery(IN PCUNICODE_STRING BatteryName, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattRemoveBattery( + _In_ PCUNICODE_STRING BatteryName, + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PCOMPBATT_BATTERY_DATA BatteryData; if (CompBattDebug & 1) DbgPrint("CompBatt: RemoveBattery\n"); @@ -245,7 +250,8 @@ CompBattRemoveBattery(IN PCUNICODE_STRING BatteryName, NTSTATUS NTAPI -CompBattGetBatteries(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +CompBattGetBatteries( + _In_ PCOMPBATT_DEVICE_EXTENSION DeviceExtension) { PWCHAR p; NTSTATUS Status; @@ -286,8 +292,9 @@ CompBattGetBatteries(IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) NTSTATUS NTAPI -CompBattPnpEventHandler(IN PDEVICE_INTERFACE_CHANGE_NOTIFICATION Notification, - IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension) +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"); @@ -319,8 +326,9 @@ CompBattPnpEventHandler(IN PDEVICE_INTERFACE_CHANGE_NOTIFICATION Notification, NTSTATUS NTAPI -CompBattAddDevice(IN PDRIVER_OBJECT DriverObject, - IN PDEVICE_OBJECT PdoDeviceObject) +CompBattAddDevice( + _In_ PDRIVER_OBJECT DriverObject, + _In_ PDEVICE_OBJECT PdoDeviceObject) { NTSTATUS Status; UNICODE_STRING DeviceName; @@ -402,8 +410,9 @@ CompBattAddDevice(IN PDRIVER_OBJECT DriverObject, NTSTATUS NTAPI -CompBattPnpDispatch(IN PDEVICE_OBJECT DeviceObject, - IN PIRP Irp) +CompBattPnpDispatch( + _In_ PDEVICE_OBJECT DeviceObject, + _In_ PIRP Irp) { PIO_STACK_LOCATION IoStackLocation = IoGetCurrentIrpStackLocation(Irp); NTSTATUS Status;

4 weeks

[reactos] 02/15: [COMPBATT] Remove the useless WaitFlag field in the code which is never used

by George Bișoc

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=f9ea9220d8612368be66d… commit f9ea9220d8612368be66db2182ebb6837ac68306 Author: George Bișoc <george.bisoc(a)reactos.org> AuthorDate: Sat Dec 14 23:07:18 2024 +0100 Commit: George Bișoc <george.bisoc(a)reactos.org> CommitDate: Wed Jan 8 23:20:06 2025 +0100 [COMPBATT] Remove the useless WaitFlag field in the code which is never used --- drivers/bus/acpi/compbatt/comppnp.c | 1 - 1 file changed, 1 deletion(-) diff --git a/drivers/bus/acpi/compbatt/comppnp.c b/drivers/bus/acpi/compbatt/comppnp.c index 141ec2ebbe4..f16bfd2ed3d 100644 --- a/drivers/bus/acpi/compbatt/comppnp.c +++ b/drivers/bus/acpi/compbatt/comppnp.c @@ -165,7 +165,6 @@ CompBattAddNewBattery(IN PUNICODE_STRING BatteryName, /* Set IRP data */ IoSetNextIrpStackLocation(Irp); Irp->IoStatus.Status = STATUS_DEVICE_NOT_CONNECTED; - BatteryData->WaitFlag = 0; /* Insert this battery in the list */ ExAcquireFastMutex(&DeviceExtension->Lock);

4 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 January 2025