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 find->handle = handle; 105 kfree(info); 106 } 107 return AE_OK; 108 } 109 110 acpi_handle acpi_get_child(acpi_handle parent, u64 address) 111 { 112 struct acpi_find_child find = { NULL, address }; 113 114 if (!parent) 115 return NULL; 116 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 117 1, do_acpi_find_child, NULL, &find, NULL); 118 return find.handle; 119 } 120 121 EXPORT_SYMBOL(acpi_get_child); 122 123 /* Link ACPI devices with physical devices */ 124 static void acpi_glue_data_handler(acpi_handle handle, 125 void *context) 126 { 127 /* we provide an empty handler */ 128 } 129 130 /* Note: a success call will increase reference count by one */ 131 struct device *acpi_get_physical_device(acpi_handle handle) 132 { 133 acpi_status status; 134 struct device *dev; 135 136 status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev); 137 if (ACPI_SUCCESS(status)) 138 return get_device(dev); 139 return NULL; 140 } 141 142 EXPORT_SYMBOL(acpi_get_physical_device); 143 144 static int acpi_bind_one(struct device *dev, acpi_handle handle) 145 { 146 struct acpi_device *acpi_dev; 147 acpi_status status; 148 149 if (dev->archdata.acpi_handle) { 150 dev_warn(dev, "Drivers changed 'acpi_handle'\n"); 151 return -EINVAL; 152 } 153 get_device(dev); 154 status = acpi_attach_data(handle, acpi_glue_data_handler, dev); 155 if (ACPI_FAILURE(status)) { 156 put_device(dev); 157 return -EINVAL; 158 } 159 dev->archdata.acpi_handle = handle; 160 161 status = acpi_bus_get_device(handle, &acpi_dev); 162 if (!ACPI_FAILURE(status)) { 163 int ret; 164 165 ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj, 166 "firmware_node"); 167 ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj, 168 "physical_node"); 169 if (acpi_dev->wakeup.flags.valid) { 170 device_set_wakeup_capable(dev, true); 171 device_set_wakeup_enable(dev, 172 acpi_dev->wakeup.state.enabled); 173 } 174 } 175 176 return 0; 177 } 178 179 static int acpi_unbind_one(struct device *dev) 180 { 181 if (!dev->archdata.acpi_handle) 182 return 0; 183 if (dev == acpi_get_physical_device(dev->archdata.acpi_handle)) { 184 struct acpi_device *acpi_dev; 185 186 /* acpi_get_physical_device increase refcnt by one */ 187 put_device(dev); 188 189 if (!acpi_bus_get_device(dev->archdata.acpi_handle, 190 &acpi_dev)) { 191 sysfs_remove_link(&dev->kobj, "firmware_node"); 192 sysfs_remove_link(&acpi_dev->dev.kobj, "physical_node"); 193 } 194 195 acpi_detach_data(dev->archdata.acpi_handle, 196 acpi_glue_data_handler); 197 dev->archdata.acpi_handle = NULL; 198 /* acpi_bind_one increase refcnt by one */ 199 put_device(dev); 200 } else { 201 dev_err(dev, "Oops, 'acpi_handle' corrupt\n"); 202 } 203 return 0; 204 } 205 206 static int acpi_platform_notify(struct device *dev) 207 { 208 struct acpi_bus_type *type; 209 acpi_handle handle; 210 int ret = -EINVAL; 211 212 if (!dev->bus || !dev->parent) { 213 /* bridge devices genernally haven't bus or parent */ 214 ret = acpi_find_bridge_device(dev, &handle); 215 goto end; 216 } 217 type = acpi_get_bus_type(dev->bus); 218 if (!type) { 219 DBG("No ACPI bus support for %s\n", dev_name(dev)); 220 ret = -EINVAL; 221 goto end; 222 } 223 if ((ret = type->find_device(dev, &handle)) != 0) 224 DBG("Can't get handler for %s\n", dev_name(dev)); 225 end: 226 if (!ret) 227 acpi_bind_one(dev, handle); 228 229 #if ACPI_GLUE_DEBUG 230 if (!ret) { 231 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 232 233 acpi_get_name(dev->archdata.acpi_handle, 234 ACPI_FULL_PATHNAME, &buffer); 235 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer); 236 kfree(buffer.pointer); 237 } else 238 DBG("Device %s -> No ACPI support\n", dev_name(dev)); 239 #endif 240 241 return ret; 242 } 243 244 static int acpi_platform_notify_remove(struct device *dev) 245 { 246 acpi_unbind_one(dev); 247 return 0; 248 } 249 250 int __init init_acpi_device_notify(void) 251 { 252 if (platform_notify || platform_notify_remove) { 253 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 254 return 0; 255 } 256 platform_notify = acpi_platform_notify; 257 platform_notify_remove = acpi_platform_notify_remove; 258 return 0; 259 } 260