v4.19.13 snapshot.
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
new file mode 100644
index 0000000..3be1433
--- /dev/null
+++ b/drivers/acpi/glue.c
@@ -0,0 +1,372 @@
+/*
+ * 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/acpi_iort.h>
+#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 <linux/platform_device.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 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 && !adev->pnp.type.platform_id ?
+ 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;
+
+ 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);
+
+ 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 (dev->bus == &platform_bus_type)
+ acpi_configure_pmsi_domain(dev);
+
+ 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;
+}