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