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 <shaohua.li@intel.com> 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 find_child_checks(struct acpi_device *adev, bool check_children) 81 { 82 unsigned long long sta; 83 acpi_status status; 84 85 if (check_children && list_empty(&adev->children)) 86 return -ENODEV; 87 88 status = acpi_evaluate_integer(adev->handle, "_STA", NULL, &sta); 89 if (status == AE_NOT_FOUND) 90 return FIND_CHILD_MIN_SCORE; 91 92 if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED)) 93 return -ENODEV; 94 95 /* 96 * If the device has a _HID returning a valid ACPI/PNP device ID, it is 97 * better to make it look less attractive here, so that the other device 98 * with the same _ADR value (that may not have a valid device ID) can be 99 * matched going forward. [This means a second spec violation in a row, 100 * so whatever we do here is best effort anyway.] 101 */ 102 if (adev->pnp.type.platform_id) 103 return FIND_CHILD_MIN_SCORE; 104 105 return FIND_CHILD_MAX_SCORE; 106 } 107 108 struct acpi_device *acpi_find_child_device(struct acpi_device *parent, 109 u64 address, bool check_children) 110 { 111 struct acpi_device *adev, *ret = NULL; 112 int ret_score = 0; 113 114 if (!parent) 115 return NULL; 116 117 list_for_each_entry(adev, &parent->children, node) { 118 acpi_bus_address addr = acpi_device_adr(adev); 119 int score; 120 121 if (!adev->pnp.type.bus_address || addr != address) 122 continue; 123 124 if (!ret) { 125 /* This is the first matching object. Save it. */ 126 ret = adev; 127 continue; 128 } 129 /* 130 * There is more than one matching device object with the same 131 * _ADR value. That really is unexpected, so we are kind of 132 * beyond the scope of the spec here. We have to choose which 133 * one to return, though. 134 * 135 * First, check if the previously found object is good enough 136 * and return it if so. Second, do the same for the object that 137 * we've just found. 138 */ 139 if (!ret_score) { 140 ret_score = find_child_checks(ret, check_children); 141 if (ret_score == FIND_CHILD_MAX_SCORE) 142 return ret; 143 } 144 score = find_child_checks(adev, check_children); 145 if (score == FIND_CHILD_MAX_SCORE) { 146 return adev; 147 } else if (score > ret_score) { 148 ret = adev; 149 ret_score = score; 150 } 151 } 152 return ret; 153 } 154 EXPORT_SYMBOL_GPL(acpi_find_child_device); 155 156 static void acpi_physnode_link_name(char *buf, unsigned int node_id) 157 { 158 if (node_id > 0) 159 snprintf(buf, PHYSICAL_NODE_NAME_SIZE, 160 PHYSICAL_NODE_STRING "%u", node_id); 161 else 162 strcpy(buf, PHYSICAL_NODE_STRING); 163 } 164 165 int acpi_bind_one(struct device *dev, struct acpi_device *acpi_dev) 166 { 167 struct acpi_device_physical_node *physical_node, *pn; 168 char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 169 struct list_head *physnode_list; 170 unsigned int node_id; 171 int retval = -EINVAL; 172 173 if (has_acpi_companion(dev)) { 174 if (acpi_dev) { 175 dev_warn(dev, "ACPI companion already set\n"); 176 return -EINVAL; 177 } else { 178 acpi_dev = ACPI_COMPANION(dev); 179 } 180 } 181 if (!acpi_dev) 182 return -EINVAL; 183 184 acpi_dev_get(acpi_dev); 185 get_device(dev); 186 physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL); 187 if (!physical_node) { 188 retval = -ENOMEM; 189 goto err; 190 } 191 192 mutex_lock(&acpi_dev->physical_node_lock); 193 194 /* 195 * Keep the list sorted by node_id so that the IDs of removed nodes can 196 * be recycled easily. 197 */ 198 physnode_list = &acpi_dev->physical_node_list; 199 node_id = 0; 200 list_for_each_entry(pn, &acpi_dev->physical_node_list, node) { 201 /* Sanity check. */ 202 if (pn->dev == dev) { 203 mutex_unlock(&acpi_dev->physical_node_lock); 204 205 dev_warn(dev, "Already associated with ACPI node\n"); 206 kfree(physical_node); 207 if (ACPI_COMPANION(dev) != acpi_dev) 208 goto err; 209 210 put_device(dev); 211 acpi_dev_put(acpi_dev); 212 return 0; 213 } 214 if (pn->node_id == node_id) { 215 physnode_list = &pn->node; 216 node_id++; 217 } 218 } 219 220 physical_node->node_id = node_id; 221 physical_node->dev = dev; 222 list_add(&physical_node->node, physnode_list); 223 acpi_dev->physical_node_count++; 224 225 if (!has_acpi_companion(dev)) 226 ACPI_COMPANION_SET(dev, acpi_dev); 227 228 acpi_physnode_link_name(physical_node_name, node_id); 229 retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 230 physical_node_name); 231 if (retval) 232 dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n", 233 physical_node_name, retval); 234 235 retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 236 "firmware_node"); 237 if (retval) 238 dev_err(dev, "Failed to create link firmware_node (%d)\n", 239 retval); 240 241 mutex_unlock(&acpi_dev->physical_node_lock); 242 243 if (acpi_dev->wakeup.flags.valid) 244 device_set_wakeup_capable(dev, true); 245 246 return 0; 247 248 err: 249 ACPI_COMPANION_SET(dev, NULL); 250 put_device(dev); 251 acpi_dev_put(acpi_dev); 252 return retval; 253 } 254 EXPORT_SYMBOL_GPL(acpi_bind_one); 255 256 int acpi_unbind_one(struct device *dev) 257 { 258 struct acpi_device *acpi_dev = ACPI_COMPANION(dev); 259 struct acpi_device_physical_node *entry; 260 261 if (!acpi_dev) 262 return 0; 263 264 mutex_lock(&acpi_dev->physical_node_lock); 265 266 list_for_each_entry(entry, &acpi_dev->physical_node_list, node) 267 if (entry->dev == dev) { 268 char physnode_name[PHYSICAL_NODE_NAME_SIZE]; 269 270 list_del(&entry->node); 271 acpi_dev->physical_node_count--; 272 273 acpi_physnode_link_name(physnode_name, entry->node_id); 274 sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name); 275 sysfs_remove_link(&dev->kobj, "firmware_node"); 276 ACPI_COMPANION_SET(dev, NULL); 277 /* Drop references taken by acpi_bind_one(). */ 278 put_device(dev); 279 acpi_dev_put(acpi_dev); 280 kfree(entry); 281 break; 282 } 283 284 mutex_unlock(&acpi_dev->physical_node_lock); 285 return 0; 286 } 287 EXPORT_SYMBOL_GPL(acpi_unbind_one); 288 289 void acpi_device_notify(struct device *dev) 290 { 291 struct acpi_device *adev; 292 int ret; 293 294 ret = acpi_bind_one(dev, NULL); 295 if (ret) { 296 struct acpi_bus_type *type = acpi_get_bus_type(dev); 297 298 if (!type) 299 goto err; 300 301 adev = type->find_companion(dev); 302 if (!adev) { 303 dev_dbg(dev, "ACPI companion not found\n"); 304 goto err; 305 } 306 ret = acpi_bind_one(dev, adev); 307 if (ret) 308 goto err; 309 310 if (type->setup) { 311 type->setup(dev); 312 goto done; 313 } 314 } else { 315 adev = ACPI_COMPANION(dev); 316 317 if (dev_is_pci(dev)) { 318 pci_acpi_setup(dev, adev); 319 goto done; 320 } else if (dev_is_platform(dev)) { 321 acpi_configure_pmsi_domain(dev); 322 } 323 } 324 325 if (adev->handler && adev->handler->bind) 326 adev->handler->bind(dev); 327 328 done: 329 acpi_handle_debug(ACPI_HANDLE(dev), "Bound to device %s\n", 330 dev_name(dev)); 331 332 return; 333 334 err: 335 dev_dbg(dev, "No ACPI support\n"); 336 } 337 338 void acpi_device_notify_remove(struct device *dev) 339 { 340 struct acpi_device *adev = ACPI_COMPANION(dev); 341 342 if (!adev) 343 return; 344 345 if (dev_is_pci(dev)) 346 pci_acpi_cleanup(dev, adev); 347 else if (adev->handler && adev->handler->unbind) 348 adev->handler->unbind(dev); 349 350 acpi_unbind_one(dev); 351 } 352