drivers/acpi/glue.c

   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...) do { } while(0)
  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 int unregister_acpi_bus_type(struct acpi_bus_type *type)
  40 {
  41         if (acpi_disabled)
  42                 return 0;
  43         if (type) {
  44                 down_write(&bus_type_sem);
  45                 list_del_init(&type->list);
  46                 up_write(&bus_type_sem);
  47                 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
  48                        type->bus->name);
  49                 return 0;
  50         }
  51         return -ENODEV;
  52 }
  53
  54 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
  55 {
  56         struct acpi_bus_type *tmp, *ret = NULL;
  57
  58         down_read(&bus_type_sem);
  59         list_for_each_entry(tmp, &bus_type_list, list) {
  60                 if (tmp->bus == type) {
  61                         ret = tmp;
  62                         break;
  63                 }
  64         }
  65         up_read(&bus_type_sem);
  66         return ret;
  67 }
  68
  69 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
  70 {
  71         struct acpi_bus_type *tmp;
  72         int ret = -ENODEV;
  73
  74         down_read(&bus_type_sem);
  75         list_for_each_entry(tmp, &bus_type_list, list) {
  76                 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
  77                         ret = 0;
  78                         break;
  79                 }
  80         }
  81         up_read(&bus_type_sem);
  82         return ret;
  83 }
  84
  85 /* Get device's handler per its address under its parent */
  86 struct acpi_find_child {
  87         acpi_handle handle;
  88         acpi_integer address;
  89 };
  90
  91 static acpi_status
  92 do_acpi_find_child(acpi_handle handle, u32 lvl, void *context, void **rv)
  93 {
  94         acpi_status status;
  95         struct acpi_device_info *info;
  96         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
  97         struct acpi_find_child *find = context;
  98
  99         status = acpi_get_object_info(handle, &buffer);
 100         if (ACPI_SUCCESS(status)) {
 101                 info = buffer.pointer;
 102                 if (info->address == find->address)
 103                         find->handle = handle;
 104                 kfree(buffer.pointer);
 105         }
 106         return AE_OK;
 107 }
 108
 109 acpi_handle acpi_get_child(acpi_handle parent, acpi_integer address)
 110 {
 111         struct acpi_find_child find = { NULL, address };
 112
 113         if (!parent)
 114                 return NULL;
 115         acpi_walk_namespace(ACPI_TYPE_DEVICE, parent,
 116                             1, do_acpi_find_child, &find, NULL);
 117         return find.handle;
 118 }
 119
 120 EXPORT_SYMBOL(acpi_get_child);
 121
 122 /* Link ACPI devices with physical devices */
 123 static void acpi_glue_data_handler(acpi_handle handle,
 124                                    u32 function, void *context)
 125 {
 126         /* we provide an empty handler */
 127 }
 128
 129 /* Note: a success call will increase reference count by one */
 130 struct device *acpi_get_physical_device(acpi_handle handle)
 131 {
 132         acpi_status status;
 133         struct device *dev;
 134
 135         status = acpi_get_data(handle, acpi_glue_data_handler, (void **)&dev);
 136         if (ACPI_SUCCESS(status))
 137                 return get_device(dev);
 138         return NULL;
 139 }
 140
 141 EXPORT_SYMBOL(acpi_get_physical_device);
 142
 143 /* ToDo: When a PCI bridge is found, return the PCI device behind the bridge
 144  *       This should work in general, but did not on a Lenovo T61 for the
 145  *       graphics card. But this must be fixed when the PCI device is
 146  *       bound and the kernel device struct is attached to the acpi device
 147  * Note: A success call will increase reference count by one
 148  *       Do call put_device(dev) on the returned device then
 149  */
 150 struct device *acpi_get_physical_pci_device(acpi_handle handle)
 151 {
 152         struct device *dev;
 153         long long device_id;
 154         acpi_status status;
 155
 156         status =
 157                 acpi_evaluate_integer(handle, "_ADR", NULL, &device_id);
 158
 159         if (ACPI_FAILURE(status))
 160                 return NULL;
 161
 162         /* We need to attempt to determine whether the _ADR refers to a
 163            PCI device or not. There's no terribly good way to do this,
 164            so the best we can hope for is to assume that there'll never
 165            be a device in the host bridge */
 166         if (device_id >= 0x10000) {
 167                 /* It looks like a PCI device. Does it exist? */
 168                 dev = acpi_get_physical_device(handle);
 169         } else {
 170                 /* It doesn't look like a PCI device. Does its parent
 171                    exist? */
 172                 acpi_handle phandle;
 173                 if (acpi_get_parent(handle, &phandle))
 174                         return NULL;
 175                 dev = acpi_get_physical_device(phandle);
 176         }
 177         if (!dev)
 178                 return NULL;
 179         return dev;
 180 }
 181 EXPORT_SYMBOL(acpi_get_physical_pci_device);
 182
 183 static int acpi_bind_one(struct device *dev, acpi_handle handle)
 184 {
 185         struct acpi_device *acpi_dev;
 186         acpi_status status;
 187
 188         if (dev->archdata.acpi_handle) {
 189                 dev_warn(dev, "Drivers changed 'acpi_handle'\n");
 190                 return -EINVAL;
 191         }
 192         get_device(dev);
 193         status = acpi_attach_data(handle, acpi_glue_data_handler, dev);
 194         if (ACPI_FAILURE(status)) {
 195                 put_device(dev);
 196                 return -EINVAL;
 197         }
 198         dev->archdata.acpi_handle = handle;
 199
 200         status = acpi_bus_get_device(handle, &acpi_dev);
 201         if (!ACPI_FAILURE(status)) {
 202                 int ret;
 203
 204                 ret = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
 205                                 "firmware_node");
 206                 ret = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
 207                                 "physical_node");
 208                 if (acpi_dev->wakeup.flags.valid) {
 209                         device_set_wakeup_capable(dev, true);
 210                         device_set_wakeup_enable(dev,
 211                                                 acpi_dev->wakeup.state.enabled);
 212                 }
 213         }
 214
 215         return 0;
 216 }
 217
 218 static int acpi_unbind_one(struct device *dev)
 219 {
 220         if (!dev->archdata.acpi_handle)
 221                 return 0;
 222         if (dev == acpi_get_physical_device(dev->archdata.acpi_handle)) {
 223                 struct acpi_device *acpi_dev;
 224
 225                 /* acpi_get_physical_device increase refcnt by one */
 226                 put_device(dev);
 227
 228                 if (!acpi_bus_get_device(dev->archdata.acpi_handle,
 229                                         &acpi_dev)) {
 230                         sysfs_remove_link(&dev->kobj, "firmware_node");
 231                         sysfs_remove_link(&acpi_dev->dev.kobj, "physical_node");
 232                 }
 233
 234                 acpi_detach_data(dev->archdata.acpi_handle,
 235                                  acpi_glue_data_handler);
 236                 dev->archdata.acpi_handle = NULL;
 237                 /* acpi_bind_one increase refcnt by one */
 238                 put_device(dev);
 239         } else {
 240                 dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
 241         }
 242         return 0;
 243 }
 244
 245 static int acpi_platform_notify(struct device *dev)
 246 {
 247         struct acpi_bus_type *type;
 248         acpi_handle handle;
 249         int ret = -EINVAL;
 250
 251         if (!dev->bus || !dev->parent) {
 252                 /* bridge devices genernally haven't bus or parent */
 253                 ret = acpi_find_bridge_device(dev, &handle);
 254                 goto end;
 255         }
 256         type = acpi_get_bus_type(dev->bus);
 257         if (!type) {
 258                 DBG("No ACPI bus support for %s\n", dev_name(dev));
 259                 ret = -EINVAL;
 260                 goto end;
 261         }
 262         if ((ret = type->find_device(dev, &handle)) != 0)
 263                 DBG("Can't get handler for %s\n", dev_name(dev));
 264       end:
 265         if (!ret)
 266                 acpi_bind_one(dev, handle);
 267
 268 #if ACPI_GLUE_DEBUG
 269         if (!ret) {
 270                 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 271
 272                 acpi_get_name(dev->archdata.acpi_handle,
 273                               ACPI_FULL_PATHNAME, &buffer);
 274                 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
 275                 kfree(buffer.pointer);
 276         } else
 277                 DBG("Device %s -> No ACPI support\n", dev_name(dev));
 278 #endif
 279
 280         return ret;
 281 }
 282
 283 static int acpi_platform_notify_remove(struct device *dev)
 284 {
 285         acpi_unbind_one(dev);
 286         return 0;
 287 }
 288
 289 static int __init init_acpi_device_notify(void)
 290 {
 291         if (acpi_disabled)
 292                 return 0;
 293         if (platform_notify || platform_notify_remove) {
 294                 printk(KERN_ERR PREFIX "Can't use platform_notify\n");
 295                 return 0;
 296         }
 297         platform_notify = acpi_platform_notify;
 298         platform_notify_remove = acpi_platform_notify_remove;
 299         return 0;
 300 }
 301
 302 arch_initcall(init_acpi_device_notify);