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 int register_acpi_bus_type(struct acpi_bus_type *type) 29 { 30 if (acpi_disabled) 31 return -ENODEV; 32 if (type && type->bus && type->find_device) { 33 down_write(&bus_type_sem); 34 list_add_tail(&type->list, &bus_type_list); 35 up_write(&bus_type_sem); 36 printk(KERN_INFO PREFIX "bus type %s registered\n", 37 type->bus->name); 38 return 0; 39 } 40 return -ENODEV; 41 } 42 EXPORT_SYMBOL_GPL(register_acpi_bus_type); 43 44 int unregister_acpi_bus_type(struct acpi_bus_type *type) 45 { 46 if (acpi_disabled) 47 return 0; 48 if (type) { 49 down_write(&bus_type_sem); 50 list_del_init(&type->list); 51 up_write(&bus_type_sem); 52 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n", 53 type->bus->name); 54 return 0; 55 } 56 return -ENODEV; 57 } 58 EXPORT_SYMBOL_GPL(unregister_acpi_bus_type); 59 60 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type) 61 { 62 struct acpi_bus_type *tmp, *ret = NULL; 63 64 down_read(&bus_type_sem); 65 list_for_each_entry(tmp, &bus_type_list, list) { 66 if (tmp->bus == type) { 67 ret = tmp; 68 break; 69 } 70 } 71 up_read(&bus_type_sem); 72 return ret; 73 } 74 75 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle) 76 { 77 struct acpi_bus_type *tmp; 78 int ret = -ENODEV; 79 80 down_read(&bus_type_sem); 81 list_for_each_entry(tmp, &bus_type_list, list) { 82 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) { 83 ret = 0; 84 break; 85 } 86 } 87 up_read(&bus_type_sem); 88 return ret; 89 } 90 91 /* Get device's handler per its address under its parent */ 92 struct acpi_find_child { 93 acpi_handle handle; 94 u64 address; 95 }; 96 97 static acpi_status 98 do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv) 99 { 100 acpi_status status; 101 struct acpi_device_info *info; 102 struct acpi_find_child *find = context; 103 104 status = acpi_get_object_info(handle, &info); 105 if (ACPI_SUCCESS(status)) { 106 if ((info->address == find->address) 107 && (info->valid & ACPI_VALID_ADR)) 108 find->handle = handle; 109 kfree(info); 110 } 111 return AE_OK; 112 } 113 114 acpi_handle acpi_get_child(acpi_handle parent, u64 address) 115 { 116 struct acpi_find_child find = { NULL, address }; 117 118 if (!parent) 119 return NULL; 120 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 121 1, do_acpi_find_child, NULL, &find, NULL); 122 return find.handle; 123 } 124 125 EXPORT_SYMBOL(acpi_get_child); 126 127 /* Link ACPI devices with physical devices */ 128 static void acpi_glue_data_handler(acpi_handle handle, 129 void *context) 130 { 131 /* we provide an empty handler */ 132 } 133 134 /* Note: a success call will increase reference count by one */ 135 struct device *acpi_get_physical_device(acpi_handle handle) 136 { 137 acpi_status status; 138 struct device *dev; 139 140 status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev); 141 if (ACPI_SUCCESS(status)) 142 return get_device(dev); 143 return NULL; 144 } 145 146 EXPORT_SYMBOL(acpi_get_physical_device); 147 148 static int acpi_bind_one(struct device *dev, acpi_handle handle) 149 { 150 struct acpi_device *acpi_dev; 151 acpi_status status; 152 153 if (dev->archdata.acpi_handle) { 154 dev_warn(dev, "Drivers changed 'acpi_handle'\n"); 155 return -EINVAL; 156 } 157 get_device(dev); 158 status = acpi_attach_data(handle, acpi_glue_data_handler, dev); 159 if (ACPI_FAILURE(status)) { 160 put_device(dev); 161 return -EINVAL; 162 } 163 dev->archdata.acpi_handle = handle; 164 165 status = acpi_bus_get_device(handle, &acpi_dev); 166 if (!ACPI_FAILURE(status)) { 167 int ret; 168 169 ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 170 "firmware_node"); 171 ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 172 "physical_node"); 173 if (acpi_dev->wakeup.flags.valid) 174 device_set_wakeup_capable(dev, true); 175 } 176 177 return 0; 178 } 179 180 static int acpi_unbind_one(struct device *dev) 181 { 182 if (!dev->archdata.acpi_handle) 183 return 0; 184 if (dev == acpi_get_physical_device(dev->archdata.acpi_handle)) { 185 struct acpi_device *acpi_dev; 186 187 /* acpi_get_physical_device increase refcnt by one */ 188 put_device(dev); 189 190 if (!acpi_bus_get_device(dev->archdata.acpi_handle, 191 &acpi_dev)) { 192 sysfs_remove_link(&dev->kobj, "firmware_node"); 193 sysfs_remove_link(&acpi_dev->dev.kobj, "physical_node"); 194 } 195 196 acpi_detach_data(dev->archdata.acpi_handle, 197 acpi_glue_data_handler); 198 dev->archdata.acpi_handle = NULL; 199 /* acpi_bind_one increase refcnt by one */ 200 put_device(dev); 201 } else { 202 dev_err(dev, "Oops, 'acpi_handle' corrupt\n"); 203 } 204 return 0; 205 } 206 207 static int acpi_platform_notify(struct device *dev) 208 { 209 struct acpi_bus_type *type; 210 acpi_handle handle; 211 int ret = -EINVAL; 212 213 if (!dev->bus || !dev->parent) { 214 /* bridge devices genernally haven't bus or parent */ 215 ret = acpi_find_bridge_device(dev, &handle); 216 goto end; 217 } 218 type = acpi_get_bus_type(dev->bus); 219 if (!type) { 220 DBG("No ACPI bus support for %s\n", dev_name(dev)); 221 ret = -EINVAL; 222 goto end; 223 } 224 if ((ret = type->find_device(dev, &handle)) != 0) 225 DBG("Can't get handler for %s\n", dev_name(dev)); 226 end: 227 if (!ret) 228 acpi_bind_one(dev, handle); 229 230 #if ACPI_GLUE_DEBUG 231 if (!ret) { 232 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 233 234 acpi_get_name(dev->archdata.acpi_handle, 235 ACPI_FULL_PATHNAME, &buffer); 236 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer); 237 kfree(buffer.pointer); 238 } else 239 DBG("Device %s -> No ACPI support\n", dev_name(dev)); 240 #endif 241 242 return ret; 243 } 244 245 static int acpi_platform_notify_remove(struct device *dev) 246 { 247 acpi_unbind_one(dev); 248 return 0; 249 } 250 251 int __init init_acpi_device_notify(void) 252 { 253 if (platform_notify || platform_notify_remove) { 254 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 255 return 0; 256 } 257 platform_notify = acpi_platform_notify; 258 platform_notify_remove = acpi_platform_notify_remove; 259 return 0; 260 } 261