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/rwsem.h> 13 #include <linux/acpi.h> 14 15 #define ACPI_GLUE_DEBUG 0 16 #if ACPI_GLUE_DEBUG 17 #define DBG(x...) printk(PREFIX x) 18 #else 19 #define DBG(x...) 20 #endif 21 static LIST_HEAD(bus_type_list); 22 static DECLARE_RWSEM(bus_type_sem); 23 24 int register_acpi_bus_type(struct acpi_bus_type *type) 25 { 26 if (acpi_disabled) 27 return -ENODEV; 28 if (type && type->bus && type->find_device) { 29 down_write(&bus_type_sem); 30 list_add_tail(&type->list, &bus_type_list); 31 up_write(&bus_type_sem); 32 printk(KERN_INFO PREFIX "bus type %s registered\n", 33 type->bus->name); 34 return 0; 35 } 36 return -ENODEV; 37 } 38 39 EXPORT_SYMBOL(register_acpi_bus_type); 40 41 int unregister_acpi_bus_type(struct acpi_bus_type *type) 42 { 43 if (acpi_disabled) 44 return 0; 45 if (type) { 46 down_write(&bus_type_sem); 47 list_del_init(&type->list); 48 up_write(&bus_type_sem); 49 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n", 50 type->bus->name); 51 return 0; 52 } 53 return -ENODEV; 54 } 55 56 EXPORT_SYMBOL(unregister_acpi_bus_type); 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 PCI root bridge's handle from its segment and bus number */ 90 struct acpi_find_pci_root { 91 unsigned int seg; 92 unsigned int bus; 93 acpi_handle handle; 94 }; 95 96 static acpi_status 97 do_root_bridge_busnr_callback(struct acpi_resource *resource, void *data) 98 { 99 unsigned long *busnr = (unsigned long *)data; 100 struct acpi_resource_address64 address; 101 102 if (resource->id != ACPI_RSTYPE_ADDRESS16 && 103 resource->id != ACPI_RSTYPE_ADDRESS32 && 104 resource->id != ACPI_RSTYPE_ADDRESS64) 105 return AE_OK; 106 107 acpi_resource_to_address64(resource, &address); 108 if ((address.address_length > 0) && 109 (address.resource_type == ACPI_BUS_NUMBER_RANGE)) 110 *busnr = address.min_address_range; 111 112 return AE_OK; 113 } 114 115 static int get_root_bridge_busnr(acpi_handle handle) 116 { 117 acpi_status status; 118 unsigned long bus, bbn; 119 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 120 121 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 122 123 status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, NULL, 124 &bbn); 125 if (status == AE_NOT_FOUND) { 126 /* Assume bus = 0 */ 127 printk(KERN_INFO PREFIX 128 "Assume root bridge [%s] bus is 0\n", 129 (char *)buffer.pointer); 130 status = AE_OK; 131 bbn = 0; 132 } 133 if (ACPI_FAILURE(status)) { 134 bbn = -ENODEV; 135 goto exit; 136 } 137 if (bbn > 0) 138 goto exit; 139 140 /* _BBN in some systems return 0 for all root bridges */ 141 bus = -1; 142 status = acpi_walk_resources(handle, METHOD_NAME__CRS, 143 do_root_bridge_busnr_callback, &bus); 144 /* If _CRS failed, we just use _BBN */ 145 if (ACPI_FAILURE(status) || (bus == -1)) 146 goto exit; 147 /* We select _CRS */ 148 if (bbn != bus) { 149 printk(KERN_INFO PREFIX 150 "_BBN and _CRS returns different value for %s. Select _CRS\n", 151 (char *)buffer.pointer); 152 bbn = bus; 153 } 154 exit: 155 acpi_os_free(buffer.pointer); 156 return (int)bbn; 157 } 158 159 static acpi_status 160 find_pci_rootbridge(acpi_handle handle, u32 lvl, void *context, void **rv) 161 { 162 struct acpi_find_pci_root *find = (struct acpi_find_pci_root *)context; 163 unsigned long seg, bus; 164 acpi_status status; 165 int tmp; 166 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 167 168 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); 169 170 status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, &seg); 171 if (status == AE_NOT_FOUND) { 172 /* Assume seg = 0 */ 173 status = AE_OK; 174 seg = 0; 175 } 176 if (ACPI_FAILURE(status)) { 177 status = AE_CTRL_DEPTH; 178 goto exit; 179 } 180 181 tmp = get_root_bridge_busnr(handle); 182 if (tmp < 0) { 183 printk(KERN_ERR PREFIX 184 "Find root bridge failed for %s\n", 185 (char *)buffer.pointer); 186 status = AE_CTRL_DEPTH; 187 goto exit; 188 } 189 bus = tmp; 190 191 if (seg == find->seg && bus == find->bus) 192 find->handle = handle; 193 status = AE_OK; 194 exit: 195 acpi_os_free(buffer.pointer); 196 return status; 197 } 198 199 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus) 200 { 201 struct acpi_find_pci_root find = { seg, bus, NULL }; 202 203 acpi_get_devices(PCI_ROOT_HID_STRING, find_pci_rootbridge, &find, NULL); 204 return find.handle; 205 } 206 207 /* Get device's handler per its address under its parent */ 208 struct acpi_find_child { 209 acpi_handle handle; 210 acpi_integer address; 211 }; 212 213 static acpi_status 214 do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv) 215 { 216 acpi_status status; 217 struct acpi_device_info *info; 218 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 219 struct acpi_find_child *find = (struct acpi_find_child *)context; 220 221 status = acpi_get_object_info(handle, &buffer); 222 if (ACPI_SUCCESS(status)) { 223 info = buffer.pointer; 224 if (info->address == find->address) 225 find->handle = handle; 226 acpi_os_free(buffer.pointer); 227 } 228 return AE_OK; 229 } 230 231 acpi_handle acpi_get_child(acpi_handle parent, acpi_integer address) 232 { 233 struct acpi_find_child find = { NULL, address }; 234 235 if (!parent) 236 return NULL; 237 acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 238 1, do_acpi_find_child, &find, NULL); 239 return find.handle; 240 } 241 242 EXPORT_SYMBOL(acpi_get_child); 243 244 /* Link ACPI devices with physical devices */ 245 static void acpi_glue_data_handler(acpi_handle handle, 246 u32 function, void *context) 247 { 248 /* we provide an empty handler */ 249 } 250 251 /* Note: a success call will increase reference count by one */ 252 struct device *acpi_get_physical_device(acpi_handle handle) 253 { 254 acpi_status status; 255 struct device *dev; 256 257 status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev); 258 if (ACPI_SUCCESS(status)) 259 return get_device(dev); 260 return NULL; 261 } 262 263 EXPORT_SYMBOL(acpi_get_physical_device); 264 265 static int acpi_bind_one(struct device *dev, acpi_handle handle) 266 { 267 acpi_status status; 268 269 if (dev->firmware_data) { 270 printk(KERN_WARNING PREFIX 271 "Drivers changed 'firmware_data' for %s\n", dev->bus_id); 272 return -EINVAL; 273 } 274 get_device(dev); 275 status = acpi_attach_data(handle, acpi_glue_data_handler, dev); 276 if (ACPI_FAILURE(status)) { 277 put_device(dev); 278 return -EINVAL; 279 } 280 dev->firmware_data = handle; 281 282 return 0; 283 } 284 285 static int acpi_unbind_one(struct device *dev) 286 { 287 if (!dev->firmware_data) 288 return 0; 289 if (dev == acpi_get_physical_device(dev->firmware_data)) { 290 /* acpi_get_physical_device increase refcnt by one */ 291 put_device(dev); 292 acpi_detach_data(dev->firmware_data, acpi_glue_data_handler); 293 dev->firmware_data = NULL; 294 /* acpi_bind_one increase refcnt by one */ 295 put_device(dev); 296 } else { 297 printk(KERN_ERR PREFIX 298 "Oops, 'firmware_data' corrupt for %s\n", dev->bus_id); 299 } 300 return 0; 301 } 302 303 static int acpi_platform_notify(struct device *dev) 304 { 305 struct acpi_bus_type *type; 306 acpi_handle handle; 307 int ret = -EINVAL; 308 309 if (!dev->bus || !dev->parent) { 310 /* bridge devices genernally haven't bus or parent */ 311 ret = acpi_find_bridge_device(dev, &handle); 312 goto end; 313 } 314 type = acpi_get_bus_type(dev->bus); 315 if (!type) { 316 DBG("No ACPI bus support for %s\n", dev->bus_id); 317 ret = -EINVAL; 318 goto end; 319 } 320 if ((ret = type->find_device(dev, &handle)) != 0) 321 DBG("Can't get handler for %s\n", dev->bus_id); 322 end: 323 if (!ret) 324 acpi_bind_one(dev, handle); 325 326 #if ACPI_GLUE_DEBUG 327 if (!ret) { 328 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 329 330 acpi_get_name(dev->firmware_data, ACPI_FULL_PATHNAME, &buffer); 331 DBG("Device %s -> %s\n", dev->bus_id, (char *)buffer.pointer); 332 acpi_os_free(buffer.pointer); 333 } else 334 DBG("Device %s -> No ACPI support\n", dev->bus_id); 335 #endif 336 337 return ret; 338 } 339 340 static int acpi_platform_notify_remove(struct device *dev) 341 { 342 acpi_unbind_one(dev); 343 return 0; 344 } 345 346 static int __init init_acpi_device_notify(void) 347 { 348 if (acpi_disabled) 349 return 0; 350 if (platform_notify || platform_notify_remove) { 351 printk(KERN_ERR PREFIX "Can't use platform_notify\n"); 352 return 0; 353 } 354 platform_notify = acpi_platform_notify; 355 platform_notify_remove = acpi_platform_notify_remove; 356 return 0; 357 } 358 359 arch_initcall(init_acpi_device_notify); 360