github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-25 23:52:08 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

Merge branches 'acpi-battery' and 'acpi-misc'

Browse Source 
Merge ACPI battery driver changes and a generic ACPI watchdog device
driver change for 6.20-rc1/7.0-rc1:

 - Convert the generic ACPI battery driver to a proper platform driver
   using struct platform_driver for device binding (Rafael Wysocki)

 - Fix incorrect charging status when current is zero in the generic
   ACPI battery driver (Ata İlhan Köktürk)

 - Use LIST_HEAD() for initializing a stack-allocated list in the
   generic ACPI watchdog device driver (Can Peng)

* acpi-battery:
  ACPI: battery: fix incorrect charging status when current is zero
  ACPI: battery: Convert the driver to a platform one
  ACPI: battery: Reduce code duplication related to cleanup
  ACPI: battery: Adjust event notification routine

* acpi-misc:
  ACPI: acpi_watchdog: use LIST_HEAD for stack-allocated list
This commit is contained in:
Rafael J. Wysocki 2026-02-05 15:03:47 +01:00
commit 1a91d4e27d
2 changed files with 41 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/acpi/acpi_watchdog.c
View File

@ -103,7 +103,7 @@ void __init acpi_watchdog_init(void)
{
const struct acpi_wdat_entry *entries;
const struct acpi_table_wdat *wdat;
struct list_head resource_list;
LIST_HEAD(resource_list);
struct resource_entry *rentry;
struct platform_device *pdev;
struct resource *resources;
@ -125,8 +125,6 @@ void __init acpi_watchdog_init(void)
wdat->pci_device != 0xff || wdat->pci_function != 0xff)
goto fail_put_wdat;
INIT_LIST_HEAD(&resource_list);
entries = (struct acpi_wdat_entry *)(wdat + 1);
for (i = 0; i < wdat->entries; i++) {
const struct acpi_generic_address *gas;

80
drivers/acpi/battery.c
View File

@ -17,6 +17,7 @@
#include <linux/list.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/suspend.h>
#include <linux/types.h>
@ -211,7 +212,14 @@ static int acpi_battery_get_property(struct power_supply *psy,
if (battery->state & ACPI_BATTERY_STATE_DISCHARGING)
val->intval = acpi_battery_handle_discharging(battery);
else if (battery->state & ACPI_BATTERY_STATE_CHARGING)
val->intval = POWER_SUPPLY_STATUS_CHARGING;
/* Validate the status by checking the current. */
if (battery->rate_now != ACPI_BATTERY_VALUE_UNKNOWN &&
battery->rate_now == 0) {
/* On charge but no current (0W/0mA). */
val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
} else {
val->intval = POWER_SUPPLY_STATUS_CHARGING;
}
else if (battery->state & ACPI_BATTERY_STATE_CHARGE_LIMITING)
val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
else if (acpi_battery_is_charged(battery))
@ -1054,8 +1062,8 @@ static void acpi_battery_refresh(struct acpi_battery *battery)
/* Driver Interface */
static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
{
struct acpi_device *device = data;
struct acpi_battery *battery = acpi_driver_data(device);
struct acpi_battery *battery = data;
struct acpi_device *device = battery->device;
struct power_supply *old;
if (!battery)
@ -1208,26 +1216,26 @@ static void sysfs_battery_cleanup(struct acpi_battery *battery)
sysfs_remove_battery(battery);
}
static int acpi_battery_add(struct acpi_device *device)
static int acpi_battery_probe(struct platform_device *pdev)
{
int result = 0;
struct acpi_device *device = ACPI_COMPANION(&pdev->dev);
struct acpi_battery *battery;
if (!device)
return -EINVAL;
int result;
if (device->dep_unmet)
return -EPROBE_DEFER;
battery = devm_kzalloc(&device->dev, sizeof(*battery), GFP_KERNEL);
battery = devm_kzalloc(&pdev->dev, sizeof(*battery), GFP_KERNEL);
if (!battery)
return -ENOMEM;
platform_set_drvdata(pdev, battery);
battery->device = device;
strscpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
strscpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
device->driver_data = battery;
result = devm_mutex_init(&device->dev, &battery->update_lock);
result = devm_mutex_init(&pdev->dev, &battery->update_lock);
if (result)
return result;
@ -1246,17 +1254,17 @@ static int acpi_battery_add(struct acpi_device *device)
if (result)
goto fail;
device_init_wakeup(&device->dev, 1);
device_init_wakeup(&pdev->dev, true);
result = acpi_dev_install_notify_handler(device, ACPI_ALL_NOTIFY,
acpi_battery_notify, device);
acpi_battery_notify, battery);
if (result)
goto fail_pm;
return 0;
fail_pm:
device_init_wakeup(&device->dev, 0);
device_init_wakeup(&pdev->dev, false);
unregister_pm_notifier(&battery->pm_nb);
fail:
sysfs_battery_cleanup(battery);
@ -1264,35 +1272,28 @@ static int acpi_battery_add(struct acpi_device *device)
return result;
}
static void acpi_battery_remove(struct acpi_device *device)
static void acpi_battery_remove(struct platform_device *pdev)
{
struct acpi_battery *battery;
struct acpi_device *device = ACPI_COMPANION(&pdev->dev);
struct acpi_battery *battery = platform_get_drvdata(pdev);
if (!device || !acpi_driver_data(device))
if (!device || !battery)
return;
battery = acpi_driver_data(device);
acpi_dev_remove_notify_handler(device, ACPI_ALL_NOTIFY,
acpi_battery_notify);
device_init_wakeup(&device->dev, 0);
device_init_wakeup(&pdev->dev, false);
unregister_pm_notifier(&battery->pm_nb);
guard(mutex)(&battery->update_lock);
sysfs_remove_battery(battery);
sysfs_battery_cleanup(battery);
}
/* this is needed to learn about changes made in suspended state */
static int acpi_battery_resume(struct device *dev)
{
struct acpi_battery *battery;
struct acpi_battery *battery = dev_get_drvdata(dev);
if (!dev)
return -EINVAL;
battery = acpi_driver_data(to_acpi_device(dev));
if (!battery)
return -EINVAL;
@ -1306,16 +1307,15 @@ static int acpi_battery_resume(struct device *dev)
static DEFINE_SIMPLE_DEV_PM_OPS(acpi_battery_pm, NULL, acpi_battery_resume);
static struct acpi_driver acpi_battery_driver = {
.name = "battery",
.class = ACPI_BATTERY_CLASS,
.ids = battery_device_ids,
.ops = {
.add = acpi_battery_add,
.remove = acpi_battery_remove,
},
.drv.pm = pm_sleep_ptr(&acpi_battery_pm),
.drv.probe_type = PROBE_PREFER_ASYNCHRONOUS,
static struct platform_driver acpi_battery_driver = {
.probe = acpi_battery_probe,
.remove = acpi_battery_remove,
.driver = {
.name = "acpi-battery",
.acpi_match_table = battery_device_ids,
.pm = pm_sleep_ptr(&acpi_battery_pm),
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
},
};
static int __init acpi_battery_init(void)
@ -1325,12 +1325,12 @@ static int __init acpi_battery_init(void)
dmi_check_system(bat_dmi_table);
return acpi_bus_register_driver(&acpi_battery_driver);
return platform_driver_register(&acpi_battery_driver);
}
static void __exit acpi_battery_exit(void)
{
acpi_bus_unregister_driver(&acpi_battery_driver);
platform_driver_unregister(&acpi_battery_driver);
battery_hook_exit();
}