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/init.h> 10 #include <linux/list.h> 11 #include <linux/device.h> 12 #include <linux/slab.h> 13 #include <linux/rwsem.h> 14 #include <linux/acpi.h> 15 16 #include "internal.h" 17 18 #define ACPI_GLUE_DEBUG 0 19 #if ACPI_GLUE_DEBUG 20 #define DBG(x...) printk(PREFIX x) 21 #else 22 #define DBG(x...) do { } while(0) 23 #endif 24 static LIST_HEAD(bus_type_list); 25 static DECLARE_RWSEM(bus_type_sem); 26 27 int register_acpi_bus_type(struct acpi_bus_type *type) 28 { 29 if (acpi_disabled) 30 return -ENODEV; 31 if (type && type->bus && type->find_device) { 32 down_write(&bus_type_sem); 33 list_add_tail(&type->list, &bus_type_list); 34 up_write(&bus_type_sem); 35 printk(KERN_INFO PREFIX "bus type %s registered\n", 36 type->bus->name); 37 return 0; 38 } 39 return -ENODEV; 40 } 41 42 int unregister_acpi_bus_type(struct acpi_bus_type *type) 43 { 44 if (acpi_disabled) 45 return 0; 46 if (type) { 47 down_write(&bus_type_sem); 48 list_del_init(&type->list); 49 up_write(&bus_type_sem); 50 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n", 51 type->bus->name); 52 return 0; 53 } 54 return -ENODEV; 55 } 56 57 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type) 58 { 59 struct acpi_bus_type *tmp, *ret = NULL; 60 61 down_read(&bus_type_sem); 62 list_for_each_entry(tmp, &bus_type_list, list) { 63 if (tmp->bus == type) { 64 ret = tmp; 65 break; 66 } 67 } 68 up_read(&bus_type_sem); 69 return ret; 70 } 71 72 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle) 73 { 74 struct acpi_bus_type *tmp; 75 int ret = -ENODEV; 76 77 down_read(&bus_type_sem); 78 list_for_each_entry(tmp, &bus_type_list, list) { 79 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) { 80 ret = 0; 81 break; 82 } 83 } 84 up_read(&bus_type_sem); 85 return ret; 86 } 87 88 /* Get device's handler per its address under its parent */ 89 struct acpi_find_child { 90 acpi_handle handle; 91 u64 address; 92 }; 93 94 static acpi_status 95 do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv) 96 { 97 acpi_status status; 98 struct acpi_device_info *info; 99 struct acpi_find_child *find = context; 100 101 status = acpi_get_object_info(handle, &info); 102 if (ACPI_SUCCESS(status)) { 103 if ((info->address == find->address) 104 && (info->valid & ACPI_VALID_ADR)) 105 find->handle = handle; 106 kfree(info); 107 } 108 return AE_OK; 109 } 110 111 acpi_handle acpi_get_child(acpi_handle parent, u64 address) 112 { 113 struct acpi_find_child find = { NULL, address }; 114 115 if (!parent) 116 return NULL; 117 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 118 1, do_acpi_find_child, NULL, &find, NULL); 119 return find.handle; 120 } 121 122 EXPORT_SYMBOL(acpi_get_child); 123 124 /* Link ACPI devices with physical devices */ 125 static void acpi_glue_data_handler(acpi_handle handle, 126 void *context) 127 { 128 /* we provide an empty handler */ 129 } 130 131 /* Note: a success call will increase reference count by one */ 132 struct device *acpi_get_physical_device(acpi_handle handle) 133 { 134 acpi_status status; 135 struct device *dev; 136 137 status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev); 138 if (ACPI_SUCCESS(status)) 139 return get_device(dev); 140 return NULL; 141 } 142 143 EXPORT_SYMBOL(acpi_get_physical_device); 144 145 static int acpi_bind_one(struct device *dev, acpi_handle handle) 146 { 147 struct acpi_device *acpi_dev; 148 acpi_status status; 149 150 if (dev->archdata.acpi_handle) { 151 dev_warn(dev, "Drivers changed 'acpi_handle'\n"); 152 return -EINVAL; 153 } 154 get_device(dev); 155 status = acpi_attach_data(handle, acpi_glue_data_handler, dev); 156 if (ACPI_FAILURE(status)) { 157 put_device(dev); 158 return -EINVAL; 159 } 160 dev->archdata.acpi_handle = handle; 161 162 status = acpi_bus_get_device(handle, &acpi_dev); 163 if (!ACPI_FAILURE(status)) { 164 int ret; 165 166 ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 167 "firmware_node"); 168 ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 169 "physical_node"); 170 if (acpi_dev->wakeup.flags.valid) { 171 device_set_wakeup_capable(dev, true); 172 device_set_wakeup_enable(dev, 173 acpi_dev->wakeup.state.enabled); 174 } 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