1 /* 2 * Link physical devices with ACPI devices support 3 * 4 * Copyright (c) 2005 David Shaohua Li <shaohua.li@intel.com> 5 * Copyright (c) 2005 Intel Corp. 6 * 7 * This file is released under the GPLv2. 8 */ 9 #include <linux/export.h> 10 #include <linux/init.h> 11 #include <linux/list.h> 12 #include <linux/device.h> 13 #include <linux/slab.h> 14 #include <linux/rwsem.h> 15 #include <linux/acpi.h> 16 17 #include "internal.h" 18 19 #define ACPI_GLUE_DEBUG 0 20 #if ACPI_GLUE_DEBUG 21 #define DBG(fmt, ...) \ 22 printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__) 23 #else 24 #define DBG(fmt, ...) \ 25 do { \ 26 if (0) \ 27 printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__); \ 28 } while (0) 29 #endif 30 static LIST_HEAD(bus_type_list); 31 static DECLARE_RWSEM(bus_type_sem); 32 33 #define PHYSICAL_NODE_STRING "physical_node" 34 #define PHYSICAL_NODE_NAME_SIZE (sizeof(PHYSICAL_NODE_STRING) + 10) 35 36 int register_acpi_bus_type(struct acpi_bus_type *type) 37 { 38 if (acpi_disabled) 39 return -ENODEV; 40 if (type && type->match && type->find_device) { 41 down_write(&bus_type_sem); 42 list_add_tail(&type->list, &bus_type_list); 43 up_write(&bus_type_sem); 44 printk(KERN_INFO PREFIX "bus type %s registered\n", type->name); 45 return 0; 46 } 47 return -ENODEV; 48 } 49 EXPORT_SYMBOL_GPL(register_acpi_bus_type); 50 51 int unregister_acpi_bus_type(struct acpi_bus_type *type) 52 { 53 if (acpi_disabled) 54 return 0; 55 if (type) { 56 down_write(&bus_type_sem); 57 list_del_init(&type->list); 58 up_write(&bus_type_sem); 59 printk(KERN_INFO PREFIX "bus type %s unregistered\n", 60 type->name); 61 return 0; 62 } 63 return -ENODEV; 64 } 65 EXPORT_SYMBOL_GPL(unregister_acpi_bus_type); 66 67 static struct acpi_bus_type *acpi_get_bus_type(struct device *dev) 68 { 69 struct acpi_bus_type *tmp, *ret = NULL; 70 71 down_read(&bus_type_sem); 72 list_for_each_entry(tmp, &bus_type_list, list) { 73 if (tmp->match(dev)) { 74 ret = tmp; 75 break; 76 } 77 } 78 up_read(&bus_type_sem); 79 return ret; 80 } 81 82 static acpi_status acpi_dev_present(acpi_handle handle, u32 lvl_not_used, 83 void *not_used, void **ret_p) 84 { 85 struct acpi_device *adev = NULL; 86 87 acpi_bus_get_device(handle, &adev); 88 if (adev) { 89 *ret_p = handle; 90 return AE_CTRL_TERMINATE; 91 } 92 return AE_OK; 93 } 94 95 static bool acpi_extra_checks_passed(acpi_handle handle, bool is_bridge) 96 { 97 unsigned long long sta; 98 acpi_status status; 99 100 status = acpi_bus_get_status_handle(handle, &sta); 101 if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED)) 102 return false; 103 104 if (is_bridge) { 105 void *test = NULL; 106 107 /* Check if this object has at least one child device. */ 108 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 109 acpi_dev_present, NULL, NULL, &test); 110 return !!test; 111 } 112 return true; 113 } 114 115 struct find_child_context { 116 u64 addr; 117 bool is_bridge; 118 acpi_handle ret; 119 bool ret_checked; 120 }; 121 122 static acpi_status do_find_child(acpi_handle handle, u32 lvl_not_used, 123 void *data, void **not_used) 124 { 125 struct find_child_context *context = data; 126 unsigned long long addr; 127 acpi_status status; 128 129 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr); 130 if (ACPI_FAILURE(status) || addr != context->addr) 131 return AE_OK; 132 133 if (!context->ret) { 134 /* This is the first matching object. Save its handle. */ 135 context->ret = handle; 136 return AE_OK; 137 } 138 /* 139 * There is more than one matching object with the same _ADR value. 140 * That really is unexpected, so we are kind of beyond the scope of the 141 * spec here. We have to choose which one to return, though. 142 * 143 * First, check if the previously found object is good enough and return 144 * its handle if so. Second, check the same for the object that we've 145 * just found. 146 */ 147 if (!context->ret_checked) { 148 if (acpi_extra_checks_passed(context->ret, context->is_bridge)) 149 return AE_CTRL_TERMINATE; 150 else 151 context->ret_checked = true; 152 } 153 if (acpi_extra_checks_passed(handle, context->is_bridge)) { 154 context->ret = handle; 155 return AE_CTRL_TERMINATE; 156 } 157 return AE_OK; 158 } 159 160 acpi_handle acpi_find_child(acpi_handle parent, u64 addr, bool is_bridge) 161 { 162 if (parent) { 163 struct find_child_context context = { 164 .addr = addr, 165 .is_bridge = is_bridge, 166 }; 167 168 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, do_find_child, 169 NULL, &context, NULL); 170 return context.ret; 171 } 172 return NULL; 173 } 174 EXPORT_SYMBOL_GPL(acpi_find_child); 175 176 static void acpi_physnode_link_name(char *buf, unsigned int node_id) 177 { 178 if (node_id > 0) 179 snprintf(buf, PHYSICAL_NODE_NAME_SIZE, 180 PHYSICAL_NODE_STRING "%u", node_id); 181 else 182 strcpy(buf, PHYSICAL_NODE_STRING); 183 } 184 185 int acpi_bind_one(struct device *dev, acpi_handle handle) 186 { 187 struct acpi_device *acpi_dev; 188 acpi_status status; 189 struct acpi_device_physical_node *physical_node, *pn; 190 char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 191 struct list_head *physnode_list; 192 unsigned int node_id; 193 int retval = -EINVAL; 194 195 if (ACPI_HANDLE(dev)) { 196 if (handle) { 197 dev_warn(dev, "ACPI handle is already set\n"); 198 return -EINVAL; 199 } else { 200 handle = ACPI_HANDLE(dev); 201 } 202 } 203 if (!handle) 204 return -EINVAL; 205 206 get_device(dev); 207 status = acpi_bus_get_device(handle, &acpi_dev); 208 if (ACPI_FAILURE(status)) 209 goto err; 210 211 physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL); 212 if (!physical_node) { 213 retval = -ENOMEM; 214 goto err; 215 } 216 217 mutex_lock(&acpi_dev->physical_node_lock); 218 219 /* 220 * Keep the list sorted by node_id so that the IDs of removed nodes can 221 * be recycled easily. 222 */ 223 physnode_list = &acpi_dev->physical_node_list; 224 node_id = 0; 225 list_for_each_entry(pn, &acpi_dev->physical_node_list, node) { 226 /* Sanity check. */ 227 if (pn->dev == dev) { 228 mutex_unlock(&acpi_dev->physical_node_lock); 229 230 dev_warn(dev, "Already associated with ACPI node\n"); 231 kfree(physical_node); 232 if (ACPI_HANDLE(dev) != handle) 233 goto err; 234 235 put_device(dev); 236 return 0; 237 } 238 if (pn->node_id == node_id) { 239 physnode_list = &pn->node; 240 node_id++; 241 } 242 } 243 244 physical_node->node_id = node_id; 245 physical_node->dev = dev; 246 list_add(&physical_node->node, physnode_list); 247 acpi_dev->physical_node_count++; 248 249 if (!ACPI_HANDLE(dev)) 250 ACPI_HANDLE_SET(dev, acpi_dev->handle); 251 252 acpi_physnode_link_name(physical_node_name, node_id); 253 retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 254 physical_node_name); 255 if (retval) 256 dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n", 257 physical_node_name, retval); 258 259 retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 260 "firmware_node"); 261 if (retval) 262 dev_err(dev, "Failed to create link firmware_node (%d)\n", 263 retval); 264 265 mutex_unlock(&acpi_dev->physical_node_lock); 266 267 if (acpi_dev->wakeup.flags.valid) 268 device_set_wakeup_capable(dev, true); 269 270 return 0; 271 272 err: 273 ACPI_HANDLE_SET(dev, NULL); 274 put_device(dev); 275 return retval; 276 } 277 EXPORT_SYMBOL_GPL(acpi_bind_one); 278 279 int acpi_unbind_one(struct device *dev) 280 { 281 struct acpi_device_physical_node *entry; 282 struct acpi_device *acpi_dev; 283 acpi_status status; 284 285 if (!ACPI_HANDLE(dev)) 286 return 0; 287 288 status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev); 289 if (ACPI_FAILURE(status)) { 290 dev_err(dev, "Oops, ACPI handle corrupt in %s()\n", __func__); 291 return -EINVAL; 292 } 293 294 mutex_lock(&acpi_dev->physical_node_lock); 295 296 list_for_each_entry(entry, &acpi_dev->physical_node_list, node) 297 if (entry->dev == dev) { 298 char physnode_name[PHYSICAL_NODE_NAME_SIZE]; 299 300 list_del(&entry->node); 301 acpi_dev->physical_node_count--; 302 303 acpi_physnode_link_name(physnode_name, entry->node_id); 304 sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name); 305 sysfs_remove_link(&dev->kobj, "firmware_node"); 306 ACPI_HANDLE_SET(dev, NULL); 307 /* acpi_bind_one() increase refcnt by one. */ 308 put_device(dev); 309 kfree(entry); 310 break; 311 } 312 313 mutex_unlock(&acpi_dev->physical_node_lock); 314 return 0; 315 } 316 EXPORT_SYMBOL_GPL(acpi_unbind_one); 317 318 static int acpi_platform_notify(struct device *dev) 319 { 320 struct acpi_bus_type *type = acpi_get_bus_type(dev); 321 acpi_handle handle; 322 int ret; 323 324 ret = acpi_bind_one(dev, NULL); 325 if (ret && type) { 326 ret = type->find_device(dev, &handle); 327 if (ret) { 328 DBG("Unable to get handle for %s\n", dev_name(dev)); 329 goto out; 330 } 331 ret = acpi_bind_one(dev, handle); 332 if (ret) 333 goto out; 334 } 335 336 if (type && type->setup) 337 type->setup(dev); 338 339 out: 340 #if ACPI_GLUE_DEBUG 341 if (!ret) { 342 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 343 344 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer); 345 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer); 346 kfree(buffer.pointer); 347 } else 348 DBG("Device %s -> No ACPI support\n", dev_name(dev)); 349 #endif 350 351 return ret; 352 } 353 354 static int acpi_platform_notify_remove(struct device *dev) 355 { 356 struct acpi_bus_type *type; 357 358 type = acpi_get_bus_type(dev); 359 if (type && type->cleanup) 360 type->cleanup(dev); 361 362 acpi_unbind_one(dev); 363 return 0; 364 } 365 366 int __init init_acpi_device_notify(void) 367 { 368 if (platform_notify || platform_notify_remove) { 369 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 370 return 0; 371 } 372 platform_notify = acpi_platform_notify; 373 platform_notify_remove = acpi_platform_notify_remove; 374 return 0; 375 } 376