drivers/acpi/glue.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Link physical devices with ACPI devices support
   4  *
   5  * Copyright (c) 2005 David Shaohua Li <[email protected]>
   6  * Copyright (c) 2005 Intel Corp.
   7  */
   8
   9 #define pr_fmt(fmt) "ACPI: " fmt
  10
  11 #include <linux/acpi_iort.h>
  12 #include <linux/export.h>
  13 #include <linux/init.h>
  14 #include <linux/list.h>
  15 #include <linux/device.h>
  16 #include <linux/slab.h>
  17 #include <linux/rwsem.h>
  18 #include <linux/acpi.h>
  19 #include <linux/dma-mapping.h>
  20 #include <linux/pci.h>
  21 #include <linux/pci-acpi.h>
  22 #include <linux/platform_device.h>
  23
  24 #include "internal.h"
  25
  26 static LIST_HEAD(bus_type_list);
  27 static DECLARE_RWSEM(bus_type_sem);
  28
  29 #define PHYSICAL_NODE_STRING "physical_node"
  30 #define PHYSICAL_NODE_NAME_SIZE (sizeof(PHYSICAL_NODE_STRING) + 10)
  31
  32 int register_acpi_bus_type(struct acpi_bus_type *type)
  33 {
  34         if (acpi_disabled)
  35                 return -ENODEV;
  36         if (type && type->match && type->find_companion) {
  37                 down_write(&bus_type_sem);
  38                 list_add_tail(&type->list, &bus_type_list);
  39                 up_write(&bus_type_sem);
  40                 pr_info("bus type %s registered\n", type->name);
  41                 return 0;
  42         }
  43         return -ENODEV;
  44 }
  45 EXPORT_SYMBOL_GPL(register_acpi_bus_type);
  46
  47 int unregister_acpi_bus_type(struct acpi_bus_type *type)
  48 {
  49         if (acpi_disabled)
  50                 return 0;
  51         if (type) {
  52                 down_write(&bus_type_sem);
  53                 list_del_init(&type->list);
  54                 up_write(&bus_type_sem);
  55                 pr_info("bus type %s unregistered\n", type->name);
  56                 return 0;
  57         }
  58         return -ENODEV;
  59 }
  60 EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
  61
  62 static struct acpi_bus_type *acpi_get_bus_type(struct device *dev)
  63 {
  64         struct acpi_bus_type *tmp, *ret = NULL;
  65
  66         down_read(&bus_type_sem);
  67         list_for_each_entry(tmp, &bus_type_list, list) {
  68                 if (tmp->match(dev)) {
  69                         ret = tmp;
  70                         break;
  71                 }
  72         }
  73         up_read(&bus_type_sem);
  74         return ret;
  75 }
  76
  77 #define FIND_CHILD_MIN_SCORE    1
  78 #define FIND_CHILD_MAX_SCORE    2
  79
  80 static int match_any(struct acpi_device *adev, void *not_used)
  81 {
  82         return 1;
  83 }
  84
  85 static bool acpi_dev_has_children(struct acpi_device *adev)
  86 {
  87         return acpi_dev_for_each_child(adev, match_any, NULL) > 0;
  88 }
  89
  90 static int find_child_checks(struct acpi_device *adev, bool check_children)
  91 {
  92         unsigned long long sta;
  93         acpi_status status;
  94
  95         if (check_children && !acpi_dev_has_children(adev))
  96                 return -ENODEV;
  97
  98         status = acpi_evaluate_integer(adev->handle, "_STA", NULL, &sta);
  99         if (status == AE_NOT_FOUND)
 100                 return FIND_CHILD_MIN_SCORE;
 101
 102         if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED))
 103                 return -ENODEV;
 104
 105         /*
 106          * If the device has a _HID returning a valid ACPI/PNP device ID, it is
 107          * better to make it look less attractive here, so that the other device
 108          * with the same _ADR value (that may not have a valid device ID) can be
 109          * matched going forward.  [This means a second spec violation in a row,
 110          * so whatever we do here is best effort anyway.]
 111          */
 112         if (adev->pnp.type.platform_id)
 113                 return FIND_CHILD_MIN_SCORE;
 114
 115         return FIND_CHILD_MAX_SCORE;
 116 }
 117
 118 struct find_child_walk_data {
 119         struct acpi_device *adev;
 120         u64 address;
 121         int score;
 122         bool check_sta;
 123         bool check_children;
 124 };
 125
 126 static int check_one_child(struct acpi_device *adev, void *data)
 127 {
 128         struct find_child_walk_data *wd = data;
 129         int score;
 130
 131         if (!adev->pnp.type.bus_address || acpi_device_adr(adev) != wd->address)
 132                 return 0;
 133
 134         if (!wd->adev) {
 135                 /*
 136                  * This is the first matching object, so save it.  If it is not
 137                  * necessary to look for any other matching objects, stop the
 138                  * search.
 139                  */
 140                 wd->adev = adev;
 141                 return !(wd->check_sta || wd->check_children);
 142         }
 143
 144         /*
 145          * There is more than one matching device object with the same _ADR
 146          * value.  That really is unexpected, so we are kind of beyond the scope
 147          * of the spec here.  We have to choose which one to return, though.
 148          *
 149          * First, get the score for the previously found object and terminate
 150          * the walk if it is maximum.
 151         */
 152         if (!wd->score) {
 153                 score = find_child_checks(wd->adev, wd->check_children);
 154                 if (score == FIND_CHILD_MAX_SCORE)
 155                         return 1;
 156
 157                 wd->score = score;
 158         }
 159         /*
 160          * Second, if the object that has just been found has a better score,
 161          * replace the previously found one with it and terminate the walk if
 162          * the new score is maximum.
 163          */
 164         score = find_child_checks(adev, wd->check_children);
 165         if (score > wd->score) {
 166                 wd->adev = adev;
 167                 if (score == FIND_CHILD_MAX_SCORE)
 168                         return 1;
 169
 170                 wd->score = score;
 171         }
 172
 173         /* Continue, because there may be better matches. */
 174         return 0;
 175 }
 176
 177 static struct acpi_device *acpi_find_child(struct acpi_device *parent,
 178                                            u64 address, bool check_children,
 179                                            bool check_sta)
 180 {
 181         struct find_child_walk_data wd = {
 182                 .address = address,
 183                 .check_children = check_children,
 184                 .check_sta = check_sta,
 185                 .adev = NULL,
 186                 .score = 0,
 187         };
 188
 189         if (parent)
 190                 acpi_dev_for_each_child(parent, check_one_child, &wd);
 191
 192         return wd.adev;
 193 }
 194
 195 struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
 196                                            u64 address, bool check_children)
 197 {
 198         return acpi_find_child(parent, address, check_children, true);
 199 }
 200 EXPORT_SYMBOL_GPL(acpi_find_child_device);
 201
 202 struct acpi_device *acpi_find_child_by_adr(struct acpi_device *adev,
 203                                            acpi_bus_address adr)
 204 {
 205         return acpi_find_child(adev, adr, false, false);
 206 }
 207 EXPORT_SYMBOL_GPL(acpi_find_child_by_adr);
 208
 209 static void acpi_physnode_link_name(char *buf, unsigned int node_id)
 210 {
 211         if (node_id > 0)
 212                 snprintf(buf, PHYSICAL_NODE_NAME_SIZE,
 213                          PHYSICAL_NODE_STRING "%u", node_id);
 214         else
 215                 strcpy(buf, PHYSICAL_NODE_STRING);
 216 }
 217
 218 int acpi_bind_one(struct device *dev, struct acpi_device *acpi_dev)
 219 {
 220         struct acpi_device_physical_node *physical_node, *pn;
 221         char physical_node_name[PHYSICAL_NODE_NAME_SIZE];
 222         struct list_head *physnode_list;
 223         unsigned int node_id;
 224         int retval = -EINVAL;
 225
 226         if (has_acpi_companion(dev)) {
 227                 if (acpi_dev) {
 228                         dev_warn(dev, "ACPI companion already set\n");
 229                         return -EINVAL;
 230                 } else {
 231                         acpi_dev = ACPI_COMPANION(dev);
 232                 }
 233         }
 234         if (!acpi_dev)
 235                 return -EINVAL;
 236
 237         acpi_dev_get(acpi_dev);
 238         get_device(dev);
 239         physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
 240         if (!physical_node) {
 241                 retval = -ENOMEM;
 242                 goto err;
 243         }
 244
 245         mutex_lock(&acpi_dev->physical_node_lock);
 246
 247         /*
 248          * Keep the list sorted by node_id so that the IDs of removed nodes can
 249          * be recycled easily.
 250          */
 251         physnode_list = &acpi_dev->physical_node_list;
 252         node_id = 0;
 253         list_for_each_entry(pn, &acpi_dev->physical_node_list, node) {
 254                 /* Sanity check. */
 255                 if (pn->dev == dev) {
 256                         mutex_unlock(&acpi_dev->physical_node_lock);
 257
 258                         dev_warn(dev, "Already associated with ACPI node\n");
 259                         kfree(physical_node);
 260                         if (ACPI_COMPANION(dev) != acpi_dev)
 261                                 goto err;
 262
 263                         put_device(dev);
 264                         acpi_dev_put(acpi_dev);
 265                         return 0;
 266                 }
 267                 if (pn->node_id == node_id) {
 268                         physnode_list = &pn->node;
 269                         node_id++;
 270                 }
 271         }
 272
 273         physical_node->node_id = node_id;
 274         physical_node->dev = dev;
 275         list_add(&physical_node->node, physnode_list);
 276         acpi_dev->physical_node_count++;
 277
 278         if (!has_acpi_companion(dev))
 279                 ACPI_COMPANION_SET(dev, acpi_dev);
 280
 281         acpi_physnode_link_name(physical_node_name, node_id);
 282         retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
 283                                    physical_node_name);
 284         if (retval)
 285                 dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n",
 286                         physical_node_name, retval);
 287
 288         retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
 289                                    "firmware_node");
 290         if (retval)
 291                 dev_err(dev, "Failed to create link firmware_node (%d)\n",
 292                         retval);
 293
 294         mutex_unlock(&acpi_dev->physical_node_lock);
 295
 296         if (acpi_dev->wakeup.flags.valid)
 297                 device_set_wakeup_capable(dev, true);
 298
 299         return 0;
 300
 301  err:
 302         ACPI_COMPANION_SET(dev, NULL);
 303         put_device(dev);
 304         acpi_dev_put(acpi_dev);
 305         return retval;
 306 }
 307 EXPORT_SYMBOL_GPL(acpi_bind_one);
 308
 309 int acpi_unbind_one(struct device *dev)
 310 {
 311         struct acpi_device *acpi_dev = ACPI_COMPANION(dev);
 312         struct acpi_device_physical_node *entry;
 313
 314         if (!acpi_dev)
 315                 return 0;
 316
 317         mutex_lock(&acpi_dev->physical_node_lock);
 318
 319         list_for_each_entry(entry, &acpi_dev->physical_node_list, node)
 320                 if (entry->dev == dev) {
 321                         char physnode_name[PHYSICAL_NODE_NAME_SIZE];
 322
 323                         list_del(&entry->node);
 324                         acpi_dev->physical_node_count--;
 325
 326                         acpi_physnode_link_name(physnode_name, entry->node_id);
 327                         sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name);
 328                         sysfs_remove_link(&dev->kobj, "firmware_node");
 329                         ACPI_COMPANION_SET(dev, NULL);
 330                         /* Drop references taken by acpi_bind_one(). */
 331                         put_device(dev);
 332                         acpi_dev_put(acpi_dev);
 333                         kfree(entry);
 334                         break;
 335                 }
 336
 337         mutex_unlock(&acpi_dev->physical_node_lock);
 338         return 0;
 339 }
 340 EXPORT_SYMBOL_GPL(acpi_unbind_one);
 341
 342 void acpi_device_notify(struct device *dev)
 343 {
 344         struct acpi_device *adev;
 345         int ret;
 346
 347         ret = acpi_bind_one(dev, NULL);
 348         if (ret) {
 349                 struct acpi_bus_type *type = acpi_get_bus_type(dev);
 350
 351                 if (!type)
 352                         goto err;
 353
 354                 adev = type->find_companion(dev);
 355                 if (!adev) {
 356                         dev_dbg(dev, "ACPI companion not found\n");
 357                         goto err;
 358                 }
 359                 ret = acpi_bind_one(dev, adev);
 360                 if (ret)
 361                         goto err;
 362
 363                 if (type->setup) {
 364                         type->setup(dev);
 365                         goto done;
 366                 }
 367         } else {
 368                 adev = ACPI_COMPANION(dev);
 369
 370                 if (dev_is_pci(dev)) {
 371                         pci_acpi_setup(dev, adev);
 372                         goto done;
 373                 } else if (dev_is_platform(dev)) {
 374                         acpi_configure_pmsi_domain(dev);
 375                 }
 376         }
 377
 378         if (adev->handler && adev->handler->bind)
 379                 adev->handler->bind(dev);
 380
 381 done:
 382         acpi_handle_debug(ACPI_HANDLE(dev), "Bound to device %s\n",
 383                           dev_name(dev));
 384
 385         return;
 386
 387 err:
 388         dev_dbg(dev, "No ACPI support\n");
 389 }
 390
 391 void acpi_device_notify_remove(struct device *dev)
 392 {
 393         struct acpi_device *adev = ACPI_COMPANION(dev);
 394
 395         if (!adev)
 396                 return;
 397
 398         if (dev_is_pci(dev))
 399                 pci_acpi_cleanup(dev, adev);
 400         else if (adev->handler && adev->handler->unbind)
 401                 adev->handler->unbind(dev);
 402
 403         acpi_unbind_one(dev);
 404 }