Kernel/linux-next
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git synced 2025-01-16 21:35:07 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ACPI: scan: Extend acpi_walk_dep_device_list()

Browse Source 
The acpi_walk_dep_device_list() function is not as generic as its
name implies, serving only to decrement the dependency count for each
dependent device of the input.

Extend it to accept a callback which can be applied to all the
dependencies in acpi_dep_list.

Replace all existing calls to the function with calls to a wrapper,
passing a callback that applies the same dependency reduction.

Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Acked-by: Maximilian Luz <luzmaximilian@gmail.com>  # for platform/surface parts
Signed-off-by: Daniel Scally <djrscally@gmail.com>
[ rjw: Changelog edits ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
This commit is contained in:
Daniel Scally 2021-06-03 23:40:02 +01:00 committed by Rafael J. Wysocki
parent 6d27975851
commit a9e10e5873
10 changed files with 90 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/acpi/ec.c
View File

@ -1627,7 +1627,7 @@ static int acpi_ec_add(struct acpi_device *device)
WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
/* Reprobe devices depending on the EC */
acpi_walk_dep_device_list(ec->handle);
acpi_dev_clear_dependencies(device);
acpi_handle_debug(ec->handle, "enumerated.\n");
return 0;

2
drivers/acpi/pmic/intel_pmic_chtdc_ti.c
View File

@ -117,7 +117,7 @@ static int chtdc_ti_pmic_opregion_probe(struct platform_device *pdev)
return err;
/* Re-enumerate devices depending on PMIC */
acpi_walk_dep_device_list(ACPI_HANDLE(pdev->dev.parent));
acpi_dev_clear_dependencies(ACPI_COMPANION(pdev->dev.parent));
return 0;
}

69
drivers/acpi/scan.c
View File

@ -47,12 +47,6 @@ static DEFINE_MUTEX(acpi_hp_context_lock);
*/
static u64 spcr_uart_addr;
struct acpi_dep_data {
struct list_head node;
acpi_handle supplier;
acpi_handle consumer;
};
void acpi_scan_lock_acquire(void)
{
mutex_lock(&acpi_scan_lock);
@ -2107,30 +2101,69 @@ static void acpi_bus_attach(struct acpi_device *device, bool first_pass)
device->handler->hotplug.notify_online(device);
}
void acpi_walk_dep_device_list(acpi_handle handle)
static int acpi_scan_clear_dep(struct acpi_dep_data *dep, void *data)
{
struct acpi_device *adev;
acpi_bus_get_device(dep->consumer, &adev);
if (adev) {
adev->dep_unmet--;
if (!adev->dep_unmet)
acpi_bus_attach(adev, true);
}
list_del(&dep->node);
kfree(dep);
return 0;
}
/**
* acpi_walk_dep_device_list - Apply a callback to every entry in acpi_dep_list
* @handle: The ACPI handle of the supplier device
* @callback: Pointer to the callback function to apply
* @data: Pointer to some data to pass to the callback
*
* The return value of the callback determines this function's behaviour. If 0
* is returned we continue to iterate over acpi_dep_list. If a positive value
* is returned then the loop is broken but this function returns 0. If a
* negative value is returned by the callback then the loop is broken and that
* value is returned as the final error.
*/
int acpi_walk_dep_device_list(acpi_handle handle,
int (*callback)(struct acpi_dep_data *, void *),
void *data)
{
struct acpi_dep_data *dep, *tmp;
struct acpi_device *adev;
int ret;
mutex_lock(&acpi_dep_list_lock);
list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
if (dep->supplier == handle) {
acpi_bus_get_device(dep->consumer, &adev);
if (adev) {
adev->dep_unmet--;
if (!adev->dep_unmet)
acpi_bus_attach(adev, true);
}
list_del(&dep->node);
kfree(dep);
ret = callback(dep, data);
if (ret)
break;
}
}
mutex_unlock(&acpi_dep_list_lock);
return ret > 0 ? 0 : ret;
}
EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
/**
* acpi_dev_clear_dependencies - Inform consumers that the device is now active
* @supplier: Pointer to the supplier &struct acpi_device
*
* Clear dependencies on the given device.
*/
void acpi_dev_clear_dependencies(struct acpi_device *supplier)
{
acpi_walk_dep_device_list(supplier->handle, acpi_scan_clear_dep, NULL);
}
EXPORT_SYMBOL_GPL(acpi_dev_clear_dependencies);
/**
* acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
* @handle: Root of the namespace scope to scan.

10
drivers/gpio/gpiolib-acpi.c
View File

@ -1233,14 +1233,14 @@ static void acpi_gpiochip_scan_gpios(struct acpi_gpio_chip *achip)
void acpi_gpiochip_add(struct gpio_chip *chip)
{
struct acpi_gpio_chip *acpi_gpio;
acpi_handle handle;
struct acpi_device *adev;
acpi_status status;
if (!chip || !chip->parent)
return;
handle = ACPI_HANDLE(chip->parent);
if (!handle)
adev = ACPI_COMPANION(chip->parent);
if (!adev)
return;
acpi_gpio = kzalloc(sizeof(*acpi_gpio), GFP_KERNEL);
@ -1254,7 +1254,7 @@ void acpi_gpiochip_add(struct gpio_chip *chip)
INIT_LIST_HEAD(&acpi_gpio->events);
INIT_LIST_HEAD(&acpi_gpio->deferred_req_irqs_list_entry);
status = acpi_attach_data(handle, acpi_gpio_chip_dh, acpi_gpio);
status = acpi_attach_data(adev->handle, acpi_gpio_chip_dh, acpi_gpio);
if (ACPI_FAILURE(status)) {
dev_err(chip->parent, "Failed to attach ACPI GPIO chip\n");
kfree(acpi_gpio);
@ -1263,7 +1263,7 @@ void acpi_gpiochip_add(struct gpio_chip *chip)
acpi_gpiochip_request_regions(acpi_gpio);
acpi_gpiochip_scan_gpios(acpi_gpio);
acpi_walk_dep_device_list(handle);
acpi_dev_clear_dependencies(adev);
}
void acpi_gpiochip_remove(struct gpio_chip *chip)

8
drivers/i2c/i2c-core-acpi.c
View File

@ -259,8 +259,8 @@ static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
*/
void i2c_acpi_register_devices(struct i2c_adapter *adap)
{
struct acpi_device *adev;
acpi_status status;
acpi_handle handle;
if (!has_acpi_companion(&adap->dev))
return;
@ -275,11 +275,11 @@ void i2c_acpi_register_devices(struct i2c_adapter *adap)
if (!adap->dev.parent)
return;
handle = ACPI_HANDLE(adap->dev.parent);
if (!handle)
adev = ACPI_COMPANION(adap->dev.parent);
if (!adev)
return;
acpi_walk_dep_device_list(handle);
acpi_dev_clear_dependencies(adev);
}
static const struct acpi_device_id i2c_acpi_force_400khz_device_ids[] = {

6
drivers/platform/surface/aggregator/core.c
View File

@ -621,8 +621,8 @@ static const struct acpi_gpio_mapping ssam_acpi_gpios[] = {
static int ssam_serial_hub_probe(struct serdev_device *serdev)
{
struct acpi_device *ssh = ACPI_COMPANION(&serdev->dev);
struct ssam_controller *ctrl;
acpi_handle *ssh = ACPI_HANDLE(&serdev->dev);
acpi_status astatus;
int status;
@ -652,7 +652,7 @@ static int ssam_serial_hub_probe(struct serdev_device *serdev)
if (status)
goto err_devopen;
astatus = ssam_serdev_setup_via_acpi(ssh, serdev);
astatus = ssam_serdev_setup_via_acpi(ssh->handle, serdev);
if (ACPI_FAILURE(astatus)) {
status = -ENXIO;
goto err_devinit;
@ -706,7 +706,7 @@ static int ssam_serial_hub_probe(struct serdev_device *serdev)
* For now let's thus default power/wakeup to false.
*/
device_set_wakeup_capable(&serdev->dev, true);
acpi_walk_dep_device_list(ssh);
acpi_dev_clear_dependencies(ssh);
return 0;

22
drivers/platform/surface/surface3_power.c
View File

@ -446,12 +446,12 @@ mshw0011_space_handler(u32 function, acpi_physical_address command,
static int mshw0011_install_space_handler(struct i2c_client *client)
{
acpi_handle handle;
struct acpi_device *adev;
struct mshw0011_handler_data *data;
acpi_status status;
handle = ACPI_HANDLE(&client->dev);
if (!handle)
adev = ACPI_COMPANION(&client->dev);
if (!adev)
return -ENODEV;
data = kzalloc(sizeof(struct mshw0011_handler_data),
@ -460,25 +460,25 @@ static int mshw0011_install_space_handler(struct i2c_client *client)
return -ENOMEM;
data->client = client;
status = acpi_bus_attach_private_data(handle, (void *)data);
status = acpi_bus_attach_private_data(adev->handle, (void *)data);
if (ACPI_FAILURE(status)) {
kfree(data);
return -ENOMEM;
}
status = acpi_install_address_space_handler(handle,
ACPI_ADR_SPACE_GSBUS,
&mshw0011_space_handler,
NULL,
data);
status = acpi_install_address_space_handler(adev->handle,
ACPI_ADR_SPACE_GSBUS,
&mshw0011_space_handler,
NULL,
data);
if (ACPI_FAILURE(status)) {
dev_err(&client->dev, "Error installing i2c space handler\n");
acpi_bus_detach_private_data(handle);
acpi_bus_detach_private_data(adev->handle);
kfree(data);
return -ENOMEM;
}
acpi_walk_dep_device_list(handle);
acpi_dev_clear_dependencies(adev);
return 0;
}

7
drivers/platform/surface/surface_acpi_notify.c
View File

@ -798,7 +798,7 @@ static int san_consumer_links_setup(struct platform_device *pdev)
static int san_probe(struct platform_device *pdev)
{
acpi_handle san = ACPI_HANDLE(&pdev->dev);
struct acpi_device *san = ACPI_COMPANION(&pdev->dev);
struct ssam_controller *ctrl;
struct san_data *data;
acpi_status astatus;
@ -821,7 +821,8 @@ static int san_probe(struct platform_device *pdev)
platform_set_drvdata(pdev, data);
astatus = acpi_install_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
astatus = acpi_install_address_space_handler(san->handle,
ACPI_ADR_SPACE_GSBUS,
&san_opreg_handler, NULL,
&data->info);
if (ACPI_FAILURE(astatus))
@ -835,7 +836,7 @@ static int san_probe(struct platform_device *pdev)
if (status)
goto err_install_dev;
acpi_walk_dep_device_list(san);
acpi_dev_clear_dependencies(san);
return 0;
err_install_dev:

7
include/acpi/acpi_bus.h
View File

@ -280,6 +280,12 @@ struct acpi_device_power {
struct acpi_device_power_state states[ACPI_D_STATE_COUNT]; /* Power states (D0-D3Cold) */
};
struct acpi_dep_data {
struct list_head node;
acpi_handle supplier;
acpi_handle consumer;
};
/* Performance Management */
struct acpi_device_perf_flags {
@ -685,6 +691,7 @@ static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
bool acpi_dev_hid_uid_match(struct acpi_device *adev, const char *hid2, const char *uid2);
void acpi_dev_clear_dependencies(struct acpi_device *supplier);
struct acpi_device *
acpi_dev_get_next_match_dev(struct acpi_device *adev, const char *hid, const char *uid, s64 hrv);
struct acpi_device *

4
include/linux/acpi.h
View File

@ -666,7 +666,9 @@ extern bool acpi_driver_match_device(struct device *dev,
const struct device_driver *drv);
int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
int acpi_device_modalias(struct device *, char *, int);
void acpi_walk_dep_device_list(acpi_handle handle);
int acpi_walk_dep_device_list(acpi_handle handle,
int (*callback)(struct acpi_dep_data *, void *),
void *data);
struct platform_device *acpi_create_platform_device(struct acpi_device *,
struct property_entry *);