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 #define FIND_CHILD_MIN_SCORE 1 83 #define FIND_CHILD_MAX_SCORE 2 84 85 static acpi_status acpi_dev_present(acpi_handle handle, u32 lvl_not_used, 86 void *not_used, void **ret_p) 87 { 88 struct acpi_device *adev = NULL; 89 90 acpi_bus_get_device(handle, &adev); 91 if (adev) { 92 *ret_p = handle; 93 return AE_CTRL_TERMINATE; 94 } 95 return AE_OK; 96 } 97 98 static int do_find_child_checks(acpi_handle handle, bool is_bridge) 99 { 100 bool sta_present = true; 101 unsigned long long sta; 102 acpi_status status; 103 104 status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); 105 if (status == AE_NOT_FOUND) 106 sta_present = false; 107 else if (ACPI_FAILURE(status) || !(sta & ACPI_STA_DEVICE_ENABLED)) 108 return -ENODEV; 109 110 if (is_bridge) { 111 void *test = NULL; 112 113 /* Check if this object has at least one child device. */ 114 acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1, 115 acpi_dev_present, NULL, NULL, &test); 116 if (!test) 117 return -ENODEV; 118 } 119 return sta_present ? FIND_CHILD_MAX_SCORE : FIND_CHILD_MIN_SCORE; 120 } 121 122 struct find_child_context { 123 u64 addr; 124 bool is_bridge; 125 acpi_handle ret; 126 int ret_score; 127 }; 128 129 static acpi_status do_find_child(acpi_handle handle, u32 lvl_not_used, 130 void *data, void **not_used) 131 { 132 struct find_child_context *context = data; 133 unsigned long long addr; 134 acpi_status status; 135 int score; 136 137 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr); 138 if (ACPI_FAILURE(status) || addr != context->addr) 139 return AE_OK; 140 141 if (!context->ret) { 142 /* This is the first matching object. Save its handle. */ 143 context->ret = handle; 144 return AE_OK; 145 } 146 /* 147 * There is more than one matching object with the same _ADR value. 148 * That really is unexpected, so we are kind of beyond the scope of the 149 * spec here. We have to choose which one to return, though. 150 * 151 * First, check if the previously found object is good enough and return 152 * its handle if so. Second, check the same for the object that we've 153 * just found. 154 */ 155 if (!context->ret_score) { 156 score = do_find_child_checks(context->ret, context->is_bridge); 157 if (score == FIND_CHILD_MAX_SCORE) 158 return AE_CTRL_TERMINATE; 159 else 160 context->ret_score = score; 161 } 162 score = do_find_child_checks(handle, context->is_bridge); 163 if (score == FIND_CHILD_MAX_SCORE) { 164 context->ret = handle; 165 return AE_CTRL_TERMINATE; 166 } else if (score > context->ret_score) { 167 context->ret = handle; 168 context->ret_score = score; 169 } 170 return AE_OK; 171 } 172 173 acpi_handle acpi_find_child(acpi_handle parent, u64 addr, bool is_bridge) 174 { 175 if (parent) { 176 struct find_child_context context = { 177 .addr = addr, 178 .is_bridge = is_bridge, 179 }; 180 181 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, do_find_child, 182 NULL, &context, NULL); 183 return context.ret; 184 } 185 return NULL; 186 } 187 EXPORT_SYMBOL_GPL(acpi_find_child); 188 189 static void acpi_physnode_link_name(char *buf, unsigned int node_id) 190 { 191 if (node_id > 0) 192 snprintf(buf, PHYSICAL_NODE_NAME_SIZE, 193 PHYSICAL_NODE_STRING "%u", node_id); 194 else 195 strcpy(buf, PHYSICAL_NODE_STRING); 196 } 197 198 int acpi_bind_one(struct device *dev, acpi_handle handle) 199 { 200 struct acpi_device *acpi_dev = NULL; 201 struct acpi_device_physical_node *physical_node, *pn; 202 char physical_node_name[PHYSICAL_NODE_NAME_SIZE]; 203 struct list_head *physnode_list; 204 unsigned int node_id; 205 int retval = -EINVAL; 206 207 if (ACPI_COMPANION(dev)) { 208 if (handle) { 209 dev_warn(dev, "ACPI companion already set\n"); 210 return -EINVAL; 211 } else { 212 acpi_dev = ACPI_COMPANION(dev); 213 } 214 } else { 215 acpi_bus_get_device(handle, &acpi_dev); 216 } 217 if (!acpi_dev) 218 return -EINVAL; 219 220 get_device(&acpi_dev->dev); 221 get_device(dev); 222 physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL); 223 if (!physical_node) { 224 retval = -ENOMEM; 225 goto err; 226 } 227 228 mutex_lock(&acpi_dev->physical_node_lock); 229 230 /* 231 * Keep the list sorted by node_id so that the IDs of removed nodes can 232 * be recycled easily. 233 */ 234 physnode_list = &acpi_dev->physical_node_list; 235 node_id = 0; 236 list_for_each_entry(pn, &acpi_dev->physical_node_list, node) { 237 /* Sanity check. */ 238 if (pn->dev == dev) { 239 mutex_unlock(&acpi_dev->physical_node_lock); 240 241 dev_warn(dev, "Already associated with ACPI node\n"); 242 kfree(physical_node); 243 if (ACPI_COMPANION(dev) != acpi_dev) 244 goto err; 245 246 put_device(dev); 247 put_device(&acpi_dev->dev); 248 return 0; 249 } 250 if (pn->node_id == node_id) { 251 physnode_list = &pn->node; 252 node_id++; 253 } 254 } 255 256 physical_node->node_id = node_id; 257 physical_node->dev = dev; 258 list_add(&physical_node->node, physnode_list); 259 acpi_dev->physical_node_count++; 260 261 if (!ACPI_COMPANION(dev)) 262 ACPI_COMPANION_SET(dev, acpi_dev); 263 264 acpi_physnode_link_name(physical_node_name, node_id); 265 retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 266 physical_node_name); 267 if (retval) 268 dev_err(&acpi_dev->dev, "Failed to create link %s (%d)\n", 269 physical_node_name, retval); 270 271 retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 272 "firmware_node"); 273 if (retval) 274 dev_err(dev, "Failed to create link firmware_node (%d)\n", 275 retval); 276 277 mutex_unlock(&acpi_dev->physical_node_lock); 278 279 if (acpi_dev->wakeup.flags.valid) 280 device_set_wakeup_capable(dev, true); 281 282 return 0; 283 284 err: 285 ACPI_COMPANION_SET(dev, NULL); 286 put_device(dev); 287 put_device(&acpi_dev->dev); 288 return retval; 289 } 290 EXPORT_SYMBOL_GPL(acpi_bind_one); 291 292 int acpi_unbind_one(struct device *dev) 293 { 294 struct acpi_device *acpi_dev = ACPI_COMPANION(dev); 295 struct acpi_device_physical_node *entry; 296 297 if (!acpi_dev) 298 return 0; 299 300 mutex_lock(&acpi_dev->physical_node_lock); 301 302 list_for_each_entry(entry, &acpi_dev->physical_node_list, node) 303 if (entry->dev == dev) { 304 char physnode_name[PHYSICAL_NODE_NAME_SIZE]; 305 306 list_del(&entry->node); 307 acpi_dev->physical_node_count--; 308 309 acpi_physnode_link_name(physnode_name, entry->node_id); 310 sysfs_remove_link(&acpi_dev->dev.kobj, physnode_name); 311 sysfs_remove_link(&dev->kobj, "firmware_node"); 312 ACPI_COMPANION_SET(dev, NULL); 313 /* Drop references taken by acpi_bind_one(). */ 314 put_device(dev); 315 put_device(&acpi_dev->dev); 316 kfree(entry); 317 break; 318 } 319 320 mutex_unlock(&acpi_dev->physical_node_lock); 321 return 0; 322 } 323 EXPORT_SYMBOL_GPL(acpi_unbind_one); 324 325 void acpi_preset_companion(struct device *dev, acpi_handle parent, u64 addr) 326 { 327 struct acpi_device *adev; 328 329 if (!acpi_bus_get_device(acpi_get_child(parent, addr), &adev)) 330 ACPI_COMPANION_SET(dev, adev); 331 } 332 EXPORT_SYMBOL_GPL(acpi_preset_companion); 333 334 static int acpi_platform_notify(struct device *dev) 335 { 336 struct acpi_bus_type *type = acpi_get_bus_type(dev); 337 acpi_handle handle; 338 int ret; 339 340 ret = acpi_bind_one(dev, NULL); 341 if (ret && type) { 342 ret = type->find_device(dev, &handle); 343 if (ret) { 344 DBG("Unable to get handle for %s\n", dev_name(dev)); 345 goto out; 346 } 347 ret = acpi_bind_one(dev, handle); 348 if (ret) 349 goto out; 350 } 351 352 if (type && type->setup) 353 type->setup(dev); 354 355 out: 356 #if ACPI_GLUE_DEBUG 357 if (!ret) { 358 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 359 360 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer); 361 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer); 362 kfree(buffer.pointer); 363 } else 364 DBG("Device %s -> No ACPI support\n", dev_name(dev)); 365 #endif 366 367 return ret; 368 } 369 370 static int acpi_platform_notify_remove(struct device *dev) 371 { 372 struct acpi_bus_type *type; 373 374 type = acpi_get_bus_type(dev); 375 if (type && type->cleanup) 376 type->cleanup(dev); 377 378 acpi_unbind_one(dev); 379 return 0; 380 } 381 382 int __init init_acpi_device_notify(void) 383 { 384 if (platform_notify || platform_notify_remove) { 385 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 386 return 0; 387 } 388 platform_notify = acpi_platform_notify; 389 platform_notify_remove = acpi_platform_notify_remove; 390 return 0; 391 } 392