mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-28 11:49:32 +00:00
![Rafael J. Wysocki](/assets/img/avatar_default.png)
The way acpi_find_child_device() works currently is that, if there are two (or more) devices with the same _ADR value in the same namespace scope (which is not specifically allowed by the spec and the OS behavior in that case is not defined), the first one of them found to be present (with the help of _STA) will be returned. This covers the majority of cases, but is not sufficient if some of the devices in question have a _HID (or _CID) returning some valid ACPI/PNP device IDs (which is disallowed by the spec) and the ASL writers' expectation appears to be that the OS will match devices without a valid ACPI/PNP device ID against a given bus address first. To cover this special case as well, modify find_child_checks() to prefer devices without ACPI/PNP device IDs over devices that have them. Suggested-by: Mika Westerberg <mika.westerberg@linux.intel.com> Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com> Tested-by: Hans de Goede <hdegoede@redhat.com>
371 lines
9 KiB
C
371 lines
9 KiB
C
/*
|
|
* Link physical devices with ACPI devices support
|
|
*
|
|
* Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com>
|
|
* Copyright (c) 2005 Intel Corp.
|
|
*
|
|
* This file is released under the GPLv2.
|
|
*/
|
|
#include <linux/export.h>
|
|
#include <linux/init.h>
|
|
#include <linux/list.h>
|
|
#include <linux/device.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/rwsem.h>
|
|
#include <linux/acpi.h>
|
|
#include <linux/dma-mapping.h>
|
|
|
|
#include "internal.h"
|
|
|
|
#define ACPI_GLUE_DEBUG 0
|
|
#if ACPI_GLUE_DEBUG
|
|
#define DBG(fmt, ...) \
|
|
printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__)
|
|
#else
|
|
#define DBG(fmt, ...) \
|
|
do { \
|
|
if (0) \
|
|
printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__); \
|
|
} while (0)
|
|
#endif
|
|
static LIST_HEAD(bus_type_list);
|
|
static DECLARE_RWSEM(bus_type_sem);
|
|
|
|
#define PHYSICAL_NODE_STRING "physical_node"
|
|
#define PHYSICAL_NODE_NAME_SIZE (sizeof(PHYSICAL_NODE_STRING) + 10)
|
|
|
|
int register_acpi_bus_type(struct acpi_bus_type *type)
|
|
{
|
|
if (acpi_disabled)
|
|
return -ENODEV;
|
|
if (type && type->match && type->find_companion) {
|
|
down_write(&bus_type_sem);
|
|
list_add_tail(&type->list, &bus_type_list);
|
|
up_write(&bus_type_sem);
|
|
printk(KERN_INFO PREFIX "bus type %s registered\n", type->name);
|
|
return 0;
|
|
}
|
|
return -ENODEV;
|
|
}
|
|
EXPORT_SYMBOL_GPL(register_acpi_bus_type);
|
|
|
|
int unregister_acpi_bus_type(struct acpi_bus_type *type)
|
|
{
|
|
if (acpi_disabled)
|
|
return 0;
|
|
if (type) {
|
|
down_write(&bus_type_sem);
|
|
list_del_init(&type->list);
|
|
up_write(&bus_type_sem);
|
|
printk(KERN_INFO PREFIX "bus type %s unregistered\n",
|
|
type->name);
|
|
return 0;
|
|
}
|
|
return -ENODEV;
|
|
}
|
|
EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
|
|
|
|
static struct acpi_bus_type *acpi_get_bus_type(struct device *dev)
|
|
{
|
|
struct acpi_bus_type *tmp, *ret = NULL;
|
|
|
|
down_read(&bus_type_sem);
|
|
list_for_each_entry(tmp, &bus_type_list, list) {
|
|
if (tmp->match(dev)) {
|
|
ret = tmp;
|
|
break;
|
|
}
|
|
}
|
|
up_read(&bus_type_sem);
|
|
return ret;
|
|
}
|
|
|
|
#define FIND_CHILD_MIN_SCORE 1
|
|
#define FIND_CHILD_MAX_SCORE 2
|
|
|
|
static int find_child_checks(struct acpi_device *adev, bool check_children)
|
|
{
|
|
bool sta_present = true;
|
|
unsigned long long sta;
|
|
acpi_status status;
|
|
|
|
status = acpi_evaluate_integer(adev->handle, "_STA", NULL, &sta);
|
|
if (status == AE_NOT_FOUND)
|
|
sta_present = false;
|
|
else if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED))
|
|
return -ENODEV;
|
|
|
|
if (check_children && list_empty(&adev->children))
|
|
return -ENODEV;
|
|
|
|
/*
|
|
* If the device has a _HID (or _CID) returning a valid ACPI/PNP
|
|
* device ID, it is better to make it look less attractive here, so that
|
|
* the other device with the same _ADR value (that may not have a valid
|
|
* device ID) can be matched going forward. [This means a second spec
|
|
* violation in a row, so whatever we do here is best effort anyway.]
|
|
*/
|
|
return sta_present && list_empty(&adev->pnp.ids) ?
|
|
FIND_CHILD_MAX_SCORE : FIND_CHILD_MIN_SCORE;
|
|
}
|
|
|
|
struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
|
|
u64 address, bool check_children)
|
|
{
|
|
struct acpi_device *adev, *ret = NULL;
|
|
int ret_score = 0;
|
|
|
|
if (!parent)
|
|
return NULL;
|
|
|
|
list_for_each_entry(adev, &parent->children, node) {
|
|
unsigned long long addr;
|
|
acpi_status status;
|
|
int score;
|
|
|
|
status = acpi_evaluate_integer(adev->handle, METHOD_NAME__ADR,
|
|
NULL, &addr);
|
|
if (ACPI_FAILURE(status) || addr != address)
|
|
continue;
|
|
|
|
if (!ret) {
|
|
/* This is the first matching object. Save it. */
|
|
ret = adev;
|
|
continue;
|
|
}
|
|
/*
|
|
* There is more than one matching device object with the same
|
|
* _ADR value. That really is unexpected, so we are kind of
|
|
* beyond the scope of the spec here. We have to choose which
|
|
* one to return, though.
|
|
*
|
|
* First, check if the previously found object is good enough
|
|
* and return it if so. Second, do the same for the object that
|
|
* we've just found.
|
|
*/
|
|
if (!ret_score) {
|
|
ret_score = find_child_checks(ret, check_children);
|
|
if (ret_score == FIND_CHILD_MAX_SCORE)
|
|
return ret;
|
|
}
|
|
score = find_child_checks(adev, check_children);
|
|
if (score == FIND_CHILD_MAX_SCORE) {
|
|
return adev;
|
|
} else if (score > ret_score) {
|
|
ret = adev;
|
|
ret_score = score;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(acpi_find_child_device);
|
|
|
|
static void acpi_physnode_link_name(char *buf, unsigned int node_id)
|
|
{
|
|
if (node_id > 0)
|
|
snprintf(buf, PHYSICAL_NODE_NAME_SIZE,
|
|
PHYSICAL_NODE_STRING "%u", node_id);
|
|
else
|
|
strcpy(buf, PHYSICAL_NODE_STRING);
|
|
}
|
|
|
|
int acpi_bind_one(struct device *dev, struct acpi_device *acpi_dev)
|
|
{
|
|
struct acpi_device_physical_node *physical_node, *pn;
|
|
char physical_node_name[PHYSICAL_NODE_NAME_SIZE];
|
|
struct list_head *physnode_list;
|
|
unsigned int node_id;
|
|
int retval = -EINVAL;
|
|
enum dev_dma_attr attr;
|
|
|
|
if (has_acpi_companion(dev)) {
|
|
if (acpi_dev) {
|
|
dev_warn(dev, "ACPI companion already set\n");
|
|
return -EINVAL;
|
|
} else {
|
|
acpi_dev = ACPI_COMPANION(dev);
|
|
}
|
|
}
|
|
if (!acpi_dev)
|
|
return -EINVAL;
|
|
|
|
get_device(&acpi_dev->dev);
|
|
get_device(dev);
|
|
physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
|
|
if (!physical_node) {
|
|
retval = -ENOMEM;
|
|
goto err;
|
|
}
|
|
|
|
mutex_lock(&acpi_dev->physical_node_lock);
|
|
|
|
/*
|
|
* Keep the list sorted by node_id so that the IDs of removed nodes can
|
|
* be recycled easily.
|
|
*/
|
|
physnode_list = &acpi_dev->physical_node_list;
|
|
node_id = 0;
|
|
list_for_each_entry(pn, &acpi_dev->physical_node_list, node) {
|
|
/* Sanity check. */
|
|
if (pn->dev == dev) {
|
|
mutex_unlock(&acpi_dev->physical_node_lock);
|
|
|
|
dev_warn(dev, "Already associated with ACPI node\n");
|
|
kfree(physical_node);
|
|
if (ACPI_COMPANION(dev) != acpi_dev)
|
|
goto err;
|
|
|
|
put_device(dev);
|
|
put_device(&acpi_dev->dev);
|
|
return 0;
|
|
}
|
|
if (pn->node_id == node_id) {
|
|
physnode_list = &pn->node;
|
|
node_id++;
|
|
}
|
|
}
|
|
|
|
physical_node->node_id = node_id;
|
|
physical_node->dev = dev;
|
|
list_add(&physical_node->node, physnode_list);
|
|
acpi_dev->physical_node_count++;
|
|
|
|
if (!has_acpi_companion(dev))
|
|
ACPI_COMPANION_SET(dev, acpi_dev);
|
|
|
|
attr = acpi_get_dma_attr(acpi_dev);
|
|
if (attr != DEV_DMA_NOT_SUPPORTED)
|
|
acpi_dma_configure(dev, attr);
|
|
|
|
acpi_physnode_link_name(physical_node_name, node_id);
|
|
retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
|
|
physical_node_name);
|
|
if (retval)
|
|
dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n",
|
|
physical_node_name, retval);
|
|
|
|
retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
|
|
"firmware_node");
|
|
if (retval)
|
|
dev_err(dev, "Failed to create link firmware_node (%d)\n",
|
|
retval);
|
|
|
|
mutex_unlock(&acpi_dev->physical_node_lock);
|
|
|
|
if (acpi_dev->wakeup.flags.valid)
|
|
device_set_wakeup_capable(dev, true);
|
|
|
|
return 0;
|
|
|
|
err:
|
|
ACPI_COMPANION_SET(dev, NULL);
|
|
put_device(dev);
|
|
put_device(&acpi_dev->dev);
|
|
return retval;
|
|
}
|
|
EXPORT_SYMBOL_GPL(acpi_bind_one);
|
|
|
|
int acpi_unbind_one(struct device *dev)
|
|
{
|
|
struct acpi_device *acpi_dev = ACPI_COMPANION(dev);
|
|
struct acpi_device_physical_node *entry;
|
|
|
|
if (!acpi_dev)
|
|
return 0;
|
|
|
|
mutex_lock(&acpi_dev->physical_node_lock);
|
|
|
|
list_for_each_entry(entry, &acpi_dev->physical_node_list, node)
|
|
if (entry->dev == dev) {
|
|
char physnode_name[PHYSICAL_NODE_NAME_SIZE];
|
|
|
|
list_del(&entry->node);
|
|
acpi_dev->physical_node_count--;
|
|
|
|
acpi_physnode_link_name(physnode_name, entry->node_id);
|
|
sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name);
|
|
sysfs_remove_link(&dev->kobj, "firmware_node");
|
|
ACPI_COMPANION_SET(dev, NULL);
|
|
/* Drop references taken by acpi_bind_one(). */
|
|
put_device(dev);
|
|
put_device(&acpi_dev->dev);
|
|
kfree(entry);
|
|
break;
|
|
}
|
|
|
|
mutex_unlock(&acpi_dev->physical_node_lock);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(acpi_unbind_one);
|
|
|
|
static int acpi_platform_notify(struct device *dev)
|
|
{
|
|
struct acpi_bus_type *type = acpi_get_bus_type(dev);
|
|
struct acpi_device *adev;
|
|
int ret;
|
|
|
|
ret = acpi_bind_one(dev, NULL);
|
|
if (ret && type) {
|
|
struct acpi_device *adev;
|
|
|
|
adev = type->find_companion(dev);
|
|
if (!adev) {
|
|
DBG("Unable to get handle for %s\n", dev_name(dev));
|
|
ret = -ENODEV;
|
|
goto out;
|
|
}
|
|
ret = acpi_bind_one(dev, adev);
|
|
if (ret)
|
|
goto out;
|
|
}
|
|
adev = ACPI_COMPANION(dev);
|
|
if (!adev)
|
|
goto out;
|
|
|
|
if (type && type->setup)
|
|
type->setup(dev);
|
|
else if (adev->handler && adev->handler->bind)
|
|
adev->handler->bind(dev);
|
|
|
|
out:
|
|
#if ACPI_GLUE_DEBUG
|
|
if (!ret) {
|
|
struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer);
|
|
DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
|
|
kfree(buffer.pointer);
|
|
} else
|
|
DBG("Device %s -> No ACPI support\n", dev_name(dev));
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int acpi_platform_notify_remove(struct device *dev)
|
|
{
|
|
struct acpi_device *adev = ACPI_COMPANION(dev);
|
|
struct acpi_bus_type *type;
|
|
|
|
if (!adev)
|
|
return 0;
|
|
|
|
type = acpi_get_bus_type(dev);
|
|
if (type && type->cleanup)
|
|
type->cleanup(dev);
|
|
else if (adev->handler && adev->handler->unbind)
|
|
adev->handler->unbind(dev);
|
|
|
|
acpi_unbind_one(dev);
|
|
return 0;
|
|
}
|
|
|
|
void __init init_acpi_device_notify(void)
|
|
{
|
|
if (platform_notify || platform_notify_remove) {
|
|
printk(KERN_ERR PREFIX "Can't use platform_notify\n");
|
|
return;
|
|
}
|
|
platform_notify = acpi_platform_notify;
|
|
platform_notify_remove = acpi_platform_notify_remove;
|
|
}
|