From patchwork Sat Dec 23 10:52:58 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ognjen Galic X-Patchwork-Id: 10131469 Return-Path: Received: from mail.wl.linuxfoundation.org (pdx-wl-mail.web.codeaurora.org [172.30.200.125]) by pdx-korg-patchwork.web.codeaurora.org (Postfix) with ESMTP id 837CF6056E for ; Sat, 23 Dec 2017 10:53:09 +0000 (UTC) Received: from mail.wl.linuxfoundation.org (localhost [127.0.0.1]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 61C8E28E3C for ; Sat, 23 Dec 2017 10:53:09 +0000 (UTC) Received: by mail.wl.linuxfoundation.org (Postfix, from userid 486) id 547EA29A49; Sat, 23 Dec 2017 10:53:09 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on pdx-wl-mail.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-6.8 required=2.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED, DKIM_SIGNED, FREEMAIL_FROM, RCVD_IN_DNSWL_HI, T_DKIM_INVALID autolearn=ham version=3.3.1 Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.wl.linuxfoundation.org (Postfix) with ESMTP id 7980428E3C for ; Sat, 23 Dec 2017 10:53:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1750752AbdLWKxF (ORCPT ); Sat, 23 Dec 2017 05:53:05 -0500 Received: from mail-wr0-f195.google.com ([209.85.128.195]:39212 "EHLO mail-wr0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750713AbdLWKxD (ORCPT ); Sat, 23 Dec 2017 05:53:03 -0500 Received: by mail-wr0-f195.google.com with SMTP id o101so1190666wrb.6; Sat, 23 Dec 2017 02:53:02 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=date:from:to:subject:message-id:mime-version:content-disposition :user-agent; bh=eAIRS/c3LKszJ6PNaNGOJKULOMC0ej/Y8oR4SDzugFg=; b=l3KA+6ClK3lfinE5eJtztfKFCy+CSn5q9iNdo8Qpe2Xs0ZRn04wkrhXOmSiYwhF3Mu rwoQr4l8BGvSuMtYYXqS2VXq/iGlDWk26DJ7iiS1VL6KujI+WSMfJmDSSHxjmkFTPI6p mEpdotROoFYyS8XuD/izQoQZraFj07NtEliv1HRX5CpnPH5CQhaU+YNukQafFKC7HUoj wpMi+KuBozmqloOOnkjKj9nGCoKYkqsFPkCXzZme5mURLHa8LPMb0qfWfwHC6xPPAVq5 DcqbPWucu5MiJrWRIYU4bDSxLhJfhO1V7yRE4XcwU9ItFmVo2e4KIUGCusImKzuAdBa+ TXtQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:subject:message-id:mime-version :content-disposition:user-agent; bh=eAIRS/c3LKszJ6PNaNGOJKULOMC0ej/Y8oR4SDzugFg=; b=EuMNZ8+ukSwHNQdwlL3iNWgmzBC97YDoTddDSVhzBx0hnCFJeZHGvwmw+8VOLVwmd4 SJ0rNu8w50z+FAoJKN9WdcDIK4mCxhFNlK6wUeJgb8mYWmjtCbNqxvalZ5CVgLm9DX1C /M945K7QEcqqBpG0sEFDd4YpuHzCFuonTsbIFuP1Z6R0gIyCx4YkGyZsPxCDggKVw4KL 6zA5JvvfwoWl0QsXFiKSVPD1eXsSV1VzgY3TFE8wj5u0T163NHQoY5zDiiaGo3S0tZBC mMBa6X2vdk9oofqBc2VB4M04cgqiPFE7LODZkbIcj1tE47VCfkmVfFwsvSnSCmBgSRL7 3zRg== X-Gm-Message-State: AKGB3mICZg5OtCFFmY4Evkae0W9a2awemS2705MpoaHc/3Pa66FUalw6 Qk1NxCny8O161UDpm6CZn24= X-Google-Smtp-Source: ACJfBot8ApsaDDbOIagt6vSxv8LgYRKzUxVYHXIk/4+3XnMbhexp2Co8q8rj+rd7uORQAcd02EXdrA== X-Received: by 10.223.151.205 with SMTP id t13mr16357138wrb.271.1514026381149; Sat, 23 Dec 2017 02:53:01 -0800 (PST) Received: from thinkpad (pppoe-46-239-10-236.teol.net. [46.239.10.236]) by smtp.gmail.com with ESMTPSA id g78sm17301749wmc.30.2017.12.23.02.52.59 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sat, 23 Dec 2017 02:52:59 -0800 (PST) Date: Sat, 23 Dec 2017 11:52:58 +0100 From: Ognjen Galic To: Andy Shevchenko , "Rafael J. Wysocki" , Ognjen =?utf-8?B?R2FsacSH?= , "Rafael J. Wysocki" , Len Brown , Robert Moore , Lv Zheng , ACPI Devel Maling List , devel@acpica.org, Darren Hart , Andy Shevchenko , Henrique de Moraes Holschuh , Sebastian Reichel , Platform Driver , ibm-acpi-devel@lists.sourceforge.net, Linux PM , Christoph =?iso-8859-1?Q?B=F6hmwalder?= , Kevin Locke Subject: [PATCH v10 1/4] battery: Add the battery hooking API Message-ID: <20171223105258.GA4334@thinkpad> MIME-Version: 1.0 Content-Disposition: inline User-Agent: Mutt/1.5.24 (2015-08-30) Sender: linux-acpi-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-acpi@vger.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP This is a patch that implements a generic hooking API for the generic ACPI battery driver. With this new generic API, drivers can expose platform specific behaviour via sysfs attributes in /sys/class/power_supply/BATn/ in a generic way. A perfect example of the need for this API are Lenovo ThinkPads. Lenovo ThinkPads have a ACPI extension that allows the setting of start and stop charge thresholds in the EC and battery firmware via ACPI. The thinkpad_acpi module can use this API to expose sysfs attributes that it controls inside the ACPI battery driver sysfs tree, under /sys/class/power_supply/BATN/. The file drivers/acpi/battery.h has been moved to include/acpi/battery.h and the includes inside ac.c, sbs.c, and battery.c have been adjusted to reflect that. When drivers hooks into the API, the API calls add_battery() for each battery in the system that passes it a acpi_battery struct. Then, the drivers can use device_create_file() to create new sysfs attributes with that struct and identify the batteries for per-battery attributes. --- v7: * Implemented mutual exclusion for hooking methods and battery callbacks * Fixed a BUG where errors in other modules would occur when the modules that depend on battery get unloaded v8: * Use list_for_each_safe instead of list_for_each for the module exit function where deletion of nodes occurs v9: * No changes in this patch in v9 v10: * Fix compiler warnings in Intel's 0-day CI Signed-off-by: Ognjen Galic --- drivers/acpi/ac.c | 2 +- drivers/acpi/battery.c | 179 ++++++++++++++++++++++++++++++++++++++++++++++++- drivers/acpi/battery.h | 11 --- drivers/acpi/sbs.c | 2 +- include/acpi/battery.h | 21 ++++++ 5 files changed, 199 insertions(+), 16 deletions(-) delete mode 100644 drivers/acpi/battery.h create mode 100644 include/acpi/battery.h diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c index 47a7ed5..2d8de2f 100644 --- a/drivers/acpi/ac.c +++ b/drivers/acpi/ac.c @@ -33,7 +33,7 @@ #include #include #include -#include "battery.h" +#include #define PREFIX "ACPI: " diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c index 13e7b56..c86b373 100644 --- a/drivers/acpi/battery.c +++ b/drivers/acpi/battery.c @@ -23,6 +23,7 @@ #include #include +#include #include #include #include @@ -30,6 +31,7 @@ #include #include #include +#include #include #include @@ -42,7 +44,7 @@ #include #include -#include "battery.h" +#include #define PREFIX "ACPI: " @@ -124,6 +126,7 @@ struct acpi_battery { struct power_supply_desc bat_desc; struct acpi_device *device; struct notifier_block pm_nb; + struct list_head list; unsigned long update_time; int revision; int rate_now; @@ -626,6 +629,172 @@ static const struct device_attribute alarm_attr = { .store = acpi_battery_alarm_store, }; +/* + * The Battery Hooking API + * + * This API is used inside other drivers that need to expose + * platform-specific behaviour within the generic driver in a + * generic way. + * + */ + +LIST_HEAD(acpi_battery_list); +LIST_HEAD(battery_hook_list); +DEFINE_MUTEX(hook_mutex); + +void __battery_hook_unregister(struct acpi_battery_hook *hook, int force) +{ + struct list_head *position; + struct acpi_battery *battery; + + /* + * In order to remove a hook, we first need to + * de-register all the batteries that are registered. + */ + + if (!force) + mutex_lock(&hook_mutex); + + list_for_each(position, &acpi_battery_list) { + battery = list_entry(position, struct acpi_battery, list); + hook->remove_battery(battery->bat); + } + + /* Then, just remove the hook */ + + list_del(&hook->list); + + if (!force) + mutex_unlock(&hook_mutex); + + pr_info("battery: extension unregistered: %s\n", hook->name); +} + +void battery_hook_unregister(struct acpi_battery_hook *hook) +{ + __battery_hook_unregister(hook, 0); +} +EXPORT_SYMBOL_GPL(battery_hook_unregister); + +void battery_hook_register(struct acpi_battery_hook *hook) +{ + struct list_head *position; + struct acpi_battery *battery; + + mutex_lock(&hook_mutex); + INIT_LIST_HEAD(&hook->list); + list_add(&hook->list, &battery_hook_list); + + /* + * Now that the driver is registered, we need + * to notify the hook that a battery is available + * for each battery, so that the driver may add + * its attributes. + */ + list_for_each(position, &acpi_battery_list) { + battery = list_entry(position, struct acpi_battery, list); + if (hook->add_battery(battery->bat)) { + + /* + * If a add-battery returns non-zero, + * the registration of the extension has failed, + * and we will not add it to the list of loaded + * hooks. + */ + pr_err("battery: extension failed to load: %s", + hook->name); + __battery_hook_unregister(hook, 1); + return; + + } + } + + pr_info("battery: new extension: %s\n", hook->name); + mutex_unlock(&hook_mutex); +} +EXPORT_SYMBOL_GPL(battery_hook_register); + +static void battery_hook_add_battery(struct acpi_battery *battery) +{ + + /* + * This function gets called right after the battery sysfs + * attributes have been added, so that the drivers that + * define custom sysfs attributes can add their own. + */ + + struct list_head *position; + struct acpi_battery_hook *hook_node; + + mutex_lock(&hook_mutex); + INIT_LIST_HEAD(&battery->list); + list_add(&battery->list, &acpi_battery_list); + + /* + * Since we added a new battery to the list, we need to + * iterate over the hooks and call add_battery for each + * hook that was registered. This usually happens + * when a battery gets hotplugged or initialized + * during the battery module initialization. + */ + + list_for_each(position, &battery_hook_list) { + hook_node = list_entry(position, struct acpi_battery_hook, list); + if (hook_node->add_battery(battery->bat)) { + + /* + * The notification of the extensions has failed, to + * prevent further errors we will unload the extension. + */ + __battery_hook_unregister(hook_node, 1); + pr_err("battery: error in extension, unloading: %s", + hook_node->name); + } + } + + mutex_unlock(&hook_mutex); +} + +static void battery_hook_remove_battery(struct acpi_battery *battery) +{ + struct list_head *position; + struct acpi_battery_hook *hook; + + mutex_lock(&hook_mutex); + /* + * Before removing the hook, we need to remove all + * custom attributes from the battery. + */ + list_for_each(position, &battery_hook_list) { + hook = list_entry(position, struct acpi_battery_hook, list); + hook->remove_battery(battery->bat); + } + + /* Then, just remove the battery from the list */ + + list_del(&battery->list); + mutex_unlock(&hook_mutex); +} + +static void __exit battery_hook_exit(void) +{ + struct list_head *position; + struct list_head *temp; + struct acpi_battery_hook *hook; + + /* + * At this point, the acpi_bus_unregister_driver + * has called remove for all batteries. We just + * need to remove the hooks. + */ + list_for_each_safe(position, temp, &battery_hook_list) { + hook = list_entry(position, struct acpi_battery_hook, list); + __battery_hook_unregister(hook, 0); + } + + mutex_destroy(&hook_mutex); +} + static int sysfs_add_battery(struct acpi_battery *battery) { struct power_supply_config psy_cfg = { .drv_data = battery, }; @@ -647,6 +816,8 @@ static int sysfs_add_battery(struct acpi_battery *battery) battery->bat = power_supply_register_no_ws(&battery->device->dev, &battery->bat_desc, &psy_cfg); + battery_hook_add_battery(battery); + if (IS_ERR(battery->bat)) { int result = PTR_ERR(battery->bat); @@ -663,7 +834,7 @@ static void sysfs_remove_battery(struct acpi_battery *battery) mutex_unlock(&battery->sysfs_lock); return; } - + battery_hook_remove_battery(battery); device_remove_file(&battery->bat->dev, &alarm_attr); power_supply_unregister(battery->bat); battery->bat = NULL; @@ -1359,8 +1530,10 @@ static int __init acpi_battery_init(void) static void __exit acpi_battery_exit(void) { async_synchronize_cookie(async_cookie + 1); - if (battery_driver_registered) + if (battery_driver_registered) { acpi_bus_unregister_driver(&acpi_battery_driver); + battery_hook_exit(); + } #ifdef CONFIG_ACPI_PROCFS_POWER if (acpi_battery_dir) acpi_unlock_battery_dir(acpi_battery_dir); diff --git a/drivers/acpi/battery.h b/drivers/acpi/battery.h deleted file mode 100644 index 225f493..0000000 --- a/drivers/acpi/battery.h +++ /dev/null @@ -1,11 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef __ACPI_BATTERY_H -#define __ACPI_BATTERY_H - -#define ACPI_BATTERY_CLASS "battery" - -#define ACPI_BATTERY_NOTIFY_STATUS 0x80 -#define ACPI_BATTERY_NOTIFY_INFO 0x81 -#define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82 - -#endif diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c index a2428e9..295b592 100644 --- a/drivers/acpi/sbs.c +++ b/drivers/acpi/sbs.c @@ -32,9 +32,9 @@ #include #include #include +#include #include "sbshc.h" -#include "battery.h" #define PREFIX "ACPI: " diff --git a/include/acpi/battery.h b/include/acpi/battery.h new file mode 100644 index 0000000..5d8f5d9 --- /dev/null +++ b/include/acpi/battery.h @@ -0,0 +1,21 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ACPI_BATTERY_H +#define __ACPI_BATTERY_H + +#define ACPI_BATTERY_CLASS "battery" + +#define ACPI_BATTERY_NOTIFY_STATUS 0x80 +#define ACPI_BATTERY_NOTIFY_INFO 0x81 +#define ACPI_BATTERY_NOTIFY_THRESHOLD 0x82 + +struct acpi_battery_hook { + const char *name; + int (*add_battery)(struct power_supply *battery); + int (*remove_battery)(struct power_supply *battery); + struct list_head list; +}; + +void battery_hook_register(struct acpi_battery_hook *hook); +void battery_hook_unregister(struct acpi_battery_hook *hook); + +#endif