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 35 int register_acpi_bus_type(struct acpi_bus_type *type) 36 { 37 if (acpi_disabled) 38 return -ENODEV; 39 if (type && type->bus && type->find_device) { 40 down_write(&bus_type_sem); 41 list_add_tail(&type->list, &bus_type_list); 42 up_write(&bus_type_sem); 43 printk(KERN_INFO PREFIX "bus type %s registered\n", 44 type->bus->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 "ACPI bus type %s unregistered\n", 60 type->bus->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 bus_type *type) 68 { 69 struct acpi_bus_type *tmp, *ret = NULL; 70 71 if (!type) 72 return NULL; 73 74 down_read(&bus_type_sem); 75 list_for_each_entry(tmp, &bus_type_list, list) { 76 if (tmp->bus == type) { 77 ret = tmp; 78 break; 79 } 80 } 81 up_read(&bus_type_sem); 82 return ret; 83 } 84 85 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle) 86 { 87 struct acpi_bus_type *tmp; 88 int ret = -ENODEV; 89 90 down_read(&bus_type_sem); 91 list_for_each_entry(tmp, &bus_type_list, list) { 92 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) { 93 ret = 0; 94 break; 95 } 96 } 97 up_read(&bus_type_sem); 98 return ret; 99 } 100 101 static acpi_status do_acpi_find_child(acpi_handle handle, u32 lvl_not_used, 102 void *addr_p, void **ret_p) 103 { 104 unsigned long long addr; 105 acpi_status status; 106 107 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr); 108 if (ACPI_SUCCESS(status) && addr == *((u64 *)addr_p)) { 109 *ret_p = handle; 110 return AE_CTRL_TERMINATE; 111 } 112 return AE_OK; 113 } 114 115 acpi_handle acpi_get_child(acpi_handle parent, u64 address) 116 { 117 void *ret = NULL; 118 119 if (!parent) 120 return NULL; 121 122 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, NULL, 123 do_acpi_find_child, &address, &ret); 124 return (acpi_handle)ret; 125 } 126 EXPORT_SYMBOL(acpi_get_child); 127 128 static int acpi_bind_one(struct device *dev, acpi_handle handle) 129 { 130 struct acpi_device *acpi_dev; 131 acpi_status status; 132 struct acpi_device_physical_node *physical_node, *pn; 133 char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2]; 134 int retval = -EINVAL; 135 136 if (ACPI_HANDLE(dev)) { 137 if (handle) { 138 dev_warn(dev, "ACPI handle is already set\n"); 139 return -EINVAL; 140 } else { 141 handle = ACPI_HANDLE(dev); 142 } 143 } 144 if (!handle) 145 return -EINVAL; 146 147 get_device(dev); 148 status = acpi_bus_get_device(handle, &acpi_dev); 149 if (ACPI_FAILURE(status)) 150 goto err; 151 152 physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL); 153 if (!physical_node) { 154 retval = -ENOMEM; 155 goto err; 156 } 157 158 mutex_lock(&acpi_dev->physical_node_lock); 159 160 /* Sanity check. */ 161 list_for_each_entry(pn, &acpi_dev->physical_node_list, node) 162 if (pn->dev == dev) { 163 dev_warn(dev, "Already associated with ACPI node\n"); 164 goto err_free; 165 } 166 167 /* allocate physical node id according to physical_node_id_bitmap */ 168 physical_node->node_id = 169 find_first_zero_bit(acpi_dev->physical_node_id_bitmap, 170 ACPI_MAX_PHYSICAL_NODE); 171 if (physical_node->node_id >= ACPI_MAX_PHYSICAL_NODE) { 172 retval = -ENOSPC; 173 goto err_free; 174 } 175 176 set_bit(physical_node->node_id, acpi_dev->physical_node_id_bitmap); 177 physical_node->dev = dev; 178 list_add_tail(&physical_node->node, &acpi_dev->physical_node_list); 179 acpi_dev->physical_node_count++; 180 181 mutex_unlock(&acpi_dev->physical_node_lock); 182 183 if (!ACPI_HANDLE(dev)) 184 ACPI_HANDLE_SET(dev, acpi_dev->handle); 185 186 if (!physical_node->node_id) 187 strcpy(physical_node_name, PHYSICAL_NODE_STRING); 188 else 189 sprintf(physical_node_name, 190 "physical_node%d", physical_node->node_id); 191 retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 192 physical_node_name); 193 retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 194 "firmware_node"); 195 196 if (acpi_dev->wakeup.flags.valid) 197 device_set_wakeup_capable(dev, true); 198 199 return 0; 200 201 err: 202 ACPI_HANDLE_SET(dev, NULL); 203 put_device(dev); 204 return retval; 205 206 err_free: 207 mutex_unlock(&acpi_dev->physical_node_lock); 208 kfree(physical_node); 209 goto err; 210 } 211 212 static int acpi_unbind_one(struct device *dev) 213 { 214 struct acpi_device_physical_node *entry; 215 struct acpi_device *acpi_dev; 216 acpi_status status; 217 struct list_head *node, *next; 218 219 if (!ACPI_HANDLE(dev)) 220 return 0; 221 222 status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev); 223 if (ACPI_FAILURE(status)) 224 goto err; 225 226 mutex_lock(&acpi_dev->physical_node_lock); 227 list_for_each_safe(node, next, &acpi_dev->physical_node_list) { 228 char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2]; 229 230 entry = list_entry(node, struct acpi_device_physical_node, 231 node); 232 if (entry->dev != dev) 233 continue; 234 235 list_del(node); 236 clear_bit(entry->node_id, acpi_dev->physical_node_id_bitmap); 237 238 acpi_dev->physical_node_count--; 239 240 if (!entry->node_id) 241 strcpy(physical_node_name, PHYSICAL_NODE_STRING); 242 else 243 sprintf(physical_node_name, 244 "physical_node%d", entry->node_id); 245 246 sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name); 247 sysfs_remove_link(&dev->kobj, "firmware_node"); 248 ACPI_HANDLE_SET(dev, NULL); 249 /* acpi_bind_one increase refcnt by one */ 250 put_device(dev); 251 kfree(entry); 252 } 253 mutex_unlock(&acpi_dev->physical_node_lock); 254 255 return 0; 256 257 err: 258 dev_err(dev, "Oops, 'acpi_handle' corrupt\n"); 259 return -EINVAL; 260 } 261 262 static int acpi_platform_notify(struct device *dev) 263 { 264 struct acpi_bus_type *type; 265 acpi_handle handle; 266 int ret; 267 268 ret = acpi_bind_one(dev, NULL); 269 if (ret && (!dev->bus || !dev->parent)) { 270 /* bridge devices genernally haven't bus or parent */ 271 ret = acpi_find_bridge_device(dev, &handle); 272 if (!ret) { 273 ret = acpi_bind_one(dev, handle); 274 if (ret) 275 goto out; 276 } 277 } 278 279 type = acpi_get_bus_type(dev->bus); 280 if (ret) { 281 if (!type || !type->find_device) { 282 DBG("No ACPI bus support for %s\n", dev_name(dev)); 283 ret = -EINVAL; 284 goto out; 285 } 286 287 ret = type->find_device(dev, &handle); 288 if (ret) { 289 DBG("Unable to get handle for %s\n", dev_name(dev)); 290 goto out; 291 } 292 ret = acpi_bind_one(dev, handle); 293 if (ret) 294 goto out; 295 } 296 297 if (type && type->setup) 298 type->setup(dev); 299 300 out: 301 #if ACPI_GLUE_DEBUG 302 if (!ret) { 303 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 304 305 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer); 306 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer); 307 kfree(buffer.pointer); 308 } else 309 DBG("Device %s -> No ACPI support\n", dev_name(dev)); 310 #endif 311 312 return ret; 313 } 314 315 static int acpi_platform_notify_remove(struct device *dev) 316 { 317 struct acpi_bus_type *type; 318 319 type = acpi_get_bus_type(dev->bus); 320 if (type && type->cleanup) 321 type->cleanup(dev); 322 323 acpi_unbind_one(dev); 324 return 0; 325 } 326 327 int __init init_acpi_device_notify(void) 328 { 329 if (platform_notify || platform_notify_remove) { 330 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 331 return 0; 332 } 333 platform_notify = acpi_platform_notify; 334 platform_notify_remove = acpi_platform_notify_remove; 335 return 0; 336 } 337