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