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/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(fmt, ...)                                           \
  22         printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__)
  23 #else
  24 #define DBG(fmt, ...)                                           \
  25 do {                                                            \
  26         if (0)                                                  \
  27                 printk(KERN_DEBUG PREFIX fmt, ##__VA_ARGS__);   \
  28 } while (0)
  29 #endif
  30 static LIST_HEAD(bus_type_list);
  31 static DECLARE_RWSEM(bus_type_sem);
  32
  33 #define PHYSICAL_NODE_STRING "physical_node"
  34
  35 int register_acpi_bus_type(struct acpi_bus_type *type)
  36 {
  37         if (acpi_disabled)
  38                 return -ENODEV;
  39         if (type && type->bus && type->find_device) {
  40                 down_write(&bus_type_sem);
  41                 list_add_tail(&type->list, &bus_type_list);
  42                 up_write(&bus_type_sem);
  43                 printk(KERN_INFO PREFIX "bus type %s registered\n",
  44                        type->bus->name);
  45                 return 0;
  46         }
  47         return -ENODEV;
  48 }
  49 EXPORT_SYMBOL_GPL(register_acpi_bus_type);
  50
  51 int unregister_acpi_bus_type(struct acpi_bus_type *type)
  52 {
  53         if (acpi_disabled)
  54                 return 0;
  55         if (type) {
  56                 down_write(&bus_type_sem);
  57                 list_del_init(&type->list);
  58                 up_write(&bus_type_sem);
  59                 printk(KERN_INFO PREFIX "ACPI bus type %s unregistered\n",
  60                        type->bus->name);
  61                 return 0;
  62         }
  63         return -ENODEV;
  64 }
  65 EXPORT_SYMBOL_GPL(unregister_acpi_bus_type);
  66
  67 static struct acpi_bus_type *acpi_get_bus_type(struct bus_type *type)
  68 {
  69         struct acpi_bus_type *tmp, *ret = NULL;
  70
  71         if (!type)
  72                 return NULL;
  73
  74         down_read(&bus_type_sem);
  75         list_for_each_entry(tmp, &bus_type_list, list) {
  76                 if (tmp->bus == type) {
  77                         ret = tmp;
  78                         break;
  79                 }
  80         }
  81         up_read(&bus_type_sem);
  82         return ret;
  83 }
  84
  85 static int acpi_find_bridge_device(struct device *dev, acpi_handle * handle)
  86 {
  87         struct acpi_bus_type *tmp;
  88         int ret = -ENODEV;
  89
  90         down_read(&bus_type_sem);
  91         list_for_each_entry(tmp, &bus_type_list, list) {
  92                 if (tmp->find_bridge && !tmp->find_bridge(dev, handle)) {
  93                         ret = 0;
  94                         break;
  95                 }
  96         }
  97         up_read(&bus_type_sem);
  98         return ret;
  99 }
 100
 101 static acpi_status do_acpi_find_child(acpi_handle handle, u32 lvl_not_used,
 102                                       void *addr_p, void **ret_p)
 103 {
 104         unsigned long long addr;
 105         acpi_status status;
 106
 107         status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &addr);
 108         if (ACPI_SUCCESS(status) && addr == *((u64 *)addr_p)) {
 109                 *ret_p = handle;
 110                 return AE_CTRL_TERMINATE;
 111         }
 112         return AE_OK;
 113 }
 114
 115 acpi_handle acpi_get_child(acpi_handle parent, u64 address)
 116 {
 117         void *ret = NULL;
 118
 119         if (!parent)
 120                 return NULL;
 121
 122         acpi_walk_namespace(ACPI_TYPE_DEVICE, parent, 1, NULL,
 123                             do_acpi_find_child, &address, &ret);
 124         return (acpi_handle)ret;
 125 }
 126 EXPORT_SYMBOL(acpi_get_child);
 127
 128 static int acpi_bind_one(struct device *dev, acpi_handle handle)
 129 {
 130         struct acpi_device *acpi_dev;
 131         acpi_status status;
 132         struct acpi_device_physical_node *physical_node, *pn;
 133         char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
 134         int retval = -EINVAL;
 135
 136         if (ACPI_HANDLE(dev)) {
 137                 if (handle) {
 138                         dev_warn(dev, "ACPI handle is already set\n");
 139                         return -EINVAL;
 140                 } else {
 141                         handle = ACPI_HANDLE(dev);
 142                 }
 143         }
 144         if (!handle)
 145                 return -EINVAL;
 146
 147         get_device(dev);
 148         status = acpi_bus_get_device(handle, &acpi_dev);
 149         if (ACPI_FAILURE(status))
 150                 goto err;
 151
 152         physical_node = kzalloc(sizeof(*physical_node), GFP_KERNEL);
 153         if (!physical_node) {
 154                 retval = -ENOMEM;
 155                 goto err;
 156         }
 157
 158         mutex_lock(&acpi_dev->physical_node_lock);
 159
 160         /* Sanity check. */
 161         list_for_each_entry(pn, &acpi_dev->physical_node_list, node)
 162                 if (pn->dev == dev) {
 163                         dev_warn(dev, "Already associated with ACPI node\n");
 164                         goto err_free;
 165                 }
 166
 167         /* allocate physical node id according to physical_node_id_bitmap */
 168         physical_node->node_id =
 169                 find_first_zero_bit(acpi_dev->physical_node_id_bitmap,
 170                 ACPI_MAX_PHYSICAL_NODE);
 171         if (physical_node->node_id >= ACPI_MAX_PHYSICAL_NODE) {
 172                 retval = -ENOSPC;
 173                 goto err_free;
 174         }
 175
 176         set_bit(physical_node->node_id, acpi_dev->physical_node_id_bitmap);
 177         physical_node->dev = dev;
 178         list_add_tail(&physical_node->node, &acpi_dev->physical_node_list);
 179         acpi_dev->physical_node_count++;
 180
 181         mutex_unlock(&acpi_dev->physical_node_lock);
 182
 183         if (!ACPI_HANDLE(dev))
 184                 ACPI_HANDLE_SET(dev, acpi_dev->handle);
 185
 186         if (!physical_node->node_id)
 187                 strcpy(physical_node_name, PHYSICAL_NODE_STRING);
 188         else
 189                 sprintf(physical_node_name,
 190                         "physical_node%d", physical_node->node_id);
 191         retval = sysfs_create_link(&acpi_dev->dev.kobj, &dev->kobj,
 192                         physical_node_name);
 193         retval = sysfs_create_link(&dev->kobj, &acpi_dev->dev.kobj,
 194                 "firmware_node");
 195
 196         if (acpi_dev->wakeup.flags.valid)
 197                 device_set_wakeup_capable(dev, true);
 198
 199         return 0;
 200
 201  err:
 202         ACPI_HANDLE_SET(dev, NULL);
 203         put_device(dev);
 204         return retval;
 205
 206  err_free:
 207         mutex_unlock(&acpi_dev->physical_node_lock);
 208         kfree(physical_node);
 209         goto err;
 210 }
 211
 212 static int acpi_unbind_one(struct device *dev)
 213 {
 214         struct acpi_device_physical_node *entry;
 215         struct acpi_device *acpi_dev;
 216         acpi_status status;
 217         struct list_head *node, *next;
 218
 219         if (!ACPI_HANDLE(dev))
 220                 return 0;
 221
 222         status = acpi_bus_get_device(ACPI_HANDLE(dev), &acpi_dev);
 223         if (ACPI_FAILURE(status))
 224                 goto err;
 225
 226         mutex_lock(&acpi_dev->physical_node_lock);
 227         list_for_each_safe(node, next, &acpi_dev->physical_node_list) {
 228                 char physical_node_name[sizeof(PHYSICAL_NODE_STRING) + 2];
 229
 230                 entry = list_entry(node, struct acpi_device_physical_node,
 231                         node);
 232                 if (entry->dev != dev)
 233                         continue;
 234
 235                 list_del(node);
 236                 clear_bit(entry->node_id, acpi_dev->physical_node_id_bitmap);
 237
 238                 acpi_dev->physical_node_count--;
 239
 240                 if (!entry->node_id)
 241                         strcpy(physical_node_name, PHYSICAL_NODE_STRING);
 242                 else
 243                         sprintf(physical_node_name,
 244                                 "physical_node%d", entry->node_id);
 245
 246                 sysfs_remove_link(&acpi_dev->dev.kobj, physical_node_name);
 247                 sysfs_remove_link(&dev->kobj, "firmware_node");
 248                 ACPI_HANDLE_SET(dev, NULL);
 249                 /* acpi_bind_one increase refcnt by one */
 250                 put_device(dev);
 251                 kfree(entry);
 252         }
 253         mutex_unlock(&acpi_dev->physical_node_lock);
 254
 255         return 0;
 256
 257 err:
 258         dev_err(dev, "Oops, 'acpi_handle' corrupt\n");
 259         return -EINVAL;
 260 }
 261
 262 static int acpi_platform_notify(struct device *dev)
 263 {
 264         struct acpi_bus_type *type;
 265         acpi_handle handle;
 266         int ret;
 267
 268         ret = acpi_bind_one(dev, NULL);
 269         if (ret && (!dev->bus || !dev->parent)) {
 270                 /* bridge devices genernally haven't bus or parent */
 271                 ret = acpi_find_bridge_device(dev, &handle);
 272                 if (!ret) {
 273                         ret = acpi_bind_one(dev, handle);
 274                         if (ret)
 275                                 goto out;
 276                 }
 277         }
 278
 279         type = acpi_get_bus_type(dev->bus);
 280         if (ret) {
 281                 if (!type || !type->find_device) {
 282                         DBG("No ACPI bus support for %s\n", dev_name(dev));
 283                         ret = -EINVAL;
 284                         goto out;
 285                 }
 286
 287                 ret = type->find_device(dev, &handle);
 288                 if (ret) {
 289                         DBG("Unable to get handle for %s\n", dev_name(dev));
 290                         goto out;
 291                 }
 292                 ret = acpi_bind_one(dev, handle);
 293                 if (ret)
 294                         goto out;
 295         }
 296
 297         if (type && type->setup)
 298                 type->setup(dev);
 299
 300  out:
 301 #if ACPI_GLUE_DEBUG
 302         if (!ret) {
 303                 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 304
 305                 acpi_get_name(ACPI_HANDLE(dev), ACPI_FULL_PATHNAME, &buffer);
 306                 DBG("Device %s -> %s\n", dev_name(dev), (char *)buffer.pointer);
 307                 kfree(buffer.pointer);
 308         } else
 309                 DBG("Device %s -> No ACPI support\n", dev_name(dev));
 310 #endif
 311
 312         return ret;
 313 }
 314
 315 static int acpi_platform_notify_remove(struct device *dev)
 316 {
 317         struct acpi_bus_type *type;
 318
 319         type = acpi_get_bus_type(dev->bus);
 320         if (type && type->cleanup)
 321                 type->cleanup(dev);
 322
 323         acpi_unbind_one(dev);
 324         return 0;
 325 }
 326
 327 int __init init_acpi_device_notify(void)
 328 {
 329         if (platform_notify || platform_notify_remove) {
 330                 printk(KERN_ERR PREFIX "Can't use platform_notify\n");
 331                 return 0;
 332         }
 333         platform_notify = acpi_platform_notify;
 334         platform_notify_remove = acpi_platform_notify_remove;
 335         return 0;
 336 }