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 int acpi_bind_one(struct device *dev, acpi_handle handle) 177 { 178 struct acpi_device *acpi_dev; 179 acpi_status status; 180 struct acpi_device_physical_node *physical_node, *pn; 181 char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 182 struct list_head *physnode_list; 183 unsigned int node_id; 184 int retval = -EINVAL; 185 186 if (ACPI_HANDLE(dev)) { 187 if (handle) { 188 dev_warn(dev, "ACPI handle is already set\n"); 189 return -EINVAL; 190 } else { 191 handle = ACPI_HANDLE(dev); 192 } 193 } 194 if (!handle) 195 return -EINVAL; 196 197 get_device(dev); 198 status = acpi_bus_get_device(handle, &acpi_dev); 199 if (ACPI_FAILURE(status)) 200 goto err; 201 202 physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL); 203 if (!physical_node) { 204 retval = -ENOMEM; 205 goto err; 206 } 207 208 mutex_lock(&acpi_dev->physical_node_lock); 209 210 /* 211 * Keep the list sorted by node_id so that the IDs of removed nodes can 212 * be recycled easily. 213 */ 214 physnode_list = &acpi_dev->physical_node_list; 215 node_id = 0; 216 list_for_each_entry(pn, &acpi_dev->physical_node_list, node) { 217 /* Sanity check. */ 218 if (pn->dev == dev) { 219 dev_warn(dev, "Already associated with ACPI node\n"); 220 goto err_free; 221 } 222 if (pn->node_id == node_id) { 223 physnode_list = &pn->node; 224 node_id++; 225 } 226 } 227 228 physical_node->node_id = node_id; 229 physical_node->dev = dev; 230 list_add(&physical_node->node, physnode_list); 231 acpi_dev->physical_node_count++; 232 233 mutex_unlock(&acpi_dev->physical_node_lock); 234 235 if (!ACPI_HANDLE(dev)) 236 ACPI_HANDLE_SET(dev, acpi_dev->handle); 237 238 if (!physical_node->node_id) 239 strcpy(physical_node_name, PHYSICAL_NODE_STRING); 240 else 241 sprintf(physical_node_name, 242 "physical_node%d", physical_node->node_id); 243 retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 244 physical_node_name); 245 retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 246 "firmware_node"); 247 248 if (acpi_dev->wakeup.flags.valid) 249 device_set_wakeup_capable(dev, true); 250 251 return 0; 252 253 err: 254 ACPI_HANDLE_SET(dev, NULL); 255 put_device(dev); 256 return retval; 257 258 err_free: 259 mutex_unlock(&acpi_dev->physical_node_lock); 260 kfree(physical_node); 261 goto err; 262 } 263 EXPORT_SYMBOL_GPL(acpi_bind_one); 264 265 int acpi_unbind_one(struct device *dev) 266 { 267 struct acpi_device_physical_node *entry; 268 struct acpi_device *acpi_dev; 269 acpi_status status; 270 struct list_head *node, *next; 271 272 if (!ACPI_HANDLE(dev)) 273 return 0; 274 275 status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev); 276 if (ACPI_FAILURE(status)) 277 goto err; 278 279 mutex_lock(&acpi_dev->physical_node_lock); 280 list_for_each_safe(node, next, &acpi_dev->physical_node_list) { 281 char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 282 283 entry = list_entry(node, struct acpi_device_physical_node, 284 node); 285 if (entry->dev != dev) 286 continue; 287 288 list_del(node); 289 290 acpi_dev->physical_node_count--; 291 292 if (!entry->node_id) 293 strcpy(physical_node_name, PHYSICAL_NODE_STRING); 294 else 295 sprintf(physical_node_name, 296 "physical_node%d", entry->node_id); 297 298 sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name); 299 sysfs_remove_link(&dev->kobj, "firmware_node"); 300 ACPI_HANDLE_SET(dev, NULL); 301 /* acpi_bind_one increase refcnt by one */ 302 put_device(dev); 303 kfree(entry); 304 } 305 mutex_unlock(&acpi_dev->physical_node_lock); 306 307 return 0; 308 309 err: 310 dev_err(dev, "Oops, 'acpi_handle' corrupt\n"); 311 return -EINVAL; 312 } 313 EXPORT_SYMBOL_GPL(acpi_unbind_one); 314 315 static int acpi_platform_notify(struct device *dev) 316 { 317 struct acpi_bus_type *type = acpi_get_bus_type(dev); 318 acpi_handle handle; 319 int ret; 320 321 ret = acpi_bind_one(dev, NULL); 322 if (ret && type) { 323 ret = type->find_device(dev, &handle); 324 if (ret) { 325 DBG("Unable to get handle for %s\n", dev_name(dev)); 326 goto out; 327 } 328 ret = acpi_bind_one(dev, handle); 329 if (ret) 330 goto out; 331 } 332 333 if (type && type->setup) 334 type->setup(dev); 335 336 out: 337 #if ACPI_GLUE_DEBUG 338 if (!ret) { 339 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 340 341 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer); 342 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer); 343 kfree(buffer.pointer); 344 } else 345 DBG("Device %s -> No ACPI support\n", dev_name(dev)); 346 #endif 347 348 return ret; 349 } 350 351 static int acpi_platform_notify_remove(struct device *dev) 352 { 353 struct acpi_bus_type *type; 354 355 type = acpi_get_bus_type(dev); 356 if (type && type->cleanup) 357 type->cleanup(dev); 358 359 acpi_unbind_one(dev); 360 return 0; 361 } 362 363 int __init init_acpi_device_notify(void) 364 { 365 if (platform_notify || platform_notify_remove) { 366 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 367 return 0; 368 } 369 platform_notify = acpi_platform_notify; 370 platform_notify_remove = acpi_platform_notify_remove; 371 return 0; 372 } 373