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