drivers/acpi/scan.c

   1 /*
   2  * scan.c - support for transforming the ACPI namespace into individual objects
   3  */
   4
   5 #include <linux/module.h>
   6 #include <linux/init.h>
   7 #include <linux/slab.h>
   8 #include <linux/kernel.h>
   9 #include <linux/acpi.h>
  10 #include <linux/signal.h>
  11 #include <linux/kthread.h>
  12 #include <linux/dmi.h>
  13 #include <linux/nls.h>
  14
  15 #include <acpi/acpi_drivers.h>
  16
  17 #include "internal.h"
  18
  19 #define _COMPONENT              ACPI_BUS_COMPONENT
  20 ACPI_MODULE_NAME("scan");
  21 #define STRUCT_TO_INT(s)        (*((int*)&s))
  22 extern struct acpi_device *acpi_root;
  23
  24 #define ACPI_BUS_CLASS                  "system_bus"
  25 #define ACPI_BUS_HID                    "LNXSYBUS"
  26 #define ACPI_BUS_DEVICE_NAME            "System Bus"
  27
  28 #define ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)
  29
  30 /*
  31  * If set, devices will be hot-removed even if they cannot be put offline
  32  * gracefully (from the kernel's standpoint).
  33  */
  34 bool acpi_force_hot_remove;
  35
  36 static const char *dummy_hid = "device";
  37
  38 static LIST_HEAD(acpi_bus_id_list);
  39 static DEFINE_MUTEX(acpi_scan_lock);
  40 static LIST_HEAD(acpi_scan_handlers_list);
  41 DEFINE_MUTEX(acpi_device_lock);
  42 LIST_HEAD(acpi_wakeup_device_list);
  43
  44 struct acpi_device_bus_id{
  45         char bus_id[15];
  46         unsigned int instance_no;
  47         struct list_head node;
  48 };
  49
  50 void acpi_scan_lock_acquire(void)
  51 {
  52         mutex_lock(&acpi_scan_lock);
  53 }
  54 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
  55
  56 void acpi_scan_lock_release(void)
  57 {
  58         mutex_unlock(&acpi_scan_lock);
  59 }
  60 EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
  61
  62 int acpi_scan_add_handler(struct acpi_scan_handler *handler)
  63 {
  64         if (!handler || !handler->attach)
  65                 return -EINVAL;
  66
  67         list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
  68         return 0;
  69 }
  70
  71 int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
  72                                        const char *hotplug_profile_name)
  73 {
  74         int error;
  75
  76         error = acpi_scan_add_handler(handler);
  77         if (error)
  78                 return error;
  79
  80         acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
  81         return 0;
  82 }
  83
  84 /*
  85  * Creates hid/cid(s) string needed for modalias and uevent
  86  * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
  87  * char *modalias: "acpi:IBM0001:ACPI0001"
  88 */
  89 static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
  90                            int size)
  91 {
  92         int len;
  93         int count;
  94         struct acpi_hardware_id *id;
  95
  96         if (list_empty(&acpi_dev->pnp.ids))
  97                 return 0;
  98
  99         len = snprintf(modalias, size, "acpi:");
 100         size -= len;
 101
 102         list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
 103                 count = snprintf(&modalias[len], size, "%s:", id->id);
 104                 if (count < 0 || count >= size)
 105                         return -EINVAL;
 106                 len += count;
 107                 size -= count;
 108         }
 109
 110         modalias[len] = '\0';
 111         return len;
 112 }
 113
 114 static ssize_t
 115 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
 116         struct acpi_device *acpi_dev = to_acpi_device(dev);
 117         int len;
 118
 119         /* Device has no HID and no CID or string is >1024 */
 120         len = create_modalias(acpi_dev, buf, 1024);
 121         if (len <= 0)
 122                 return 0;
 123         buf[len++] = '\n';
 124         return len;
 125 }
 126 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
 127
 128 static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
 129                                     void **ret_p)
 130 {
 131         struct acpi_device *device = NULL;
 132         struct acpi_device_physical_node *pn;
 133         bool second_pass = (bool)data;
 134         acpi_status status = AE_OK;
 135
 136         if (acpi_bus_get_device(handle, &device))
 137                 return AE_OK;
 138
 139         if (device->handler && !device->handler->hotplug.enabled) {
 140                 *ret_p = &device->dev;
 141                 return AE_SUPPORT;
 142         }
 143
 144         mutex_lock(&device->physical_node_lock);
 145
 146         list_for_each_entry(pn, &device->physical_node_list, node) {
 147                 int ret;
 148
 149                 if (second_pass) {
 150                         /* Skip devices offlined by the first pass. */
 151                         if (pn->put_online)
 152                                 continue;
 153                 } else {
 154                         pn->put_online = false;
 155                 }
 156                 ret = device_offline(pn->dev);
 157                 if (acpi_force_hot_remove)
 158                         continue;
 159
 160                 if (ret >= 0) {
 161                         pn->put_online = !ret;
 162                 } else {
 163                         *ret_p = pn->dev;
 164                         if (second_pass) {
 165                                 status = AE_ERROR;
 166                                 break;
 167                         }
 168                 }
 169         }
 170
 171         mutex_unlock(&device->physical_node_lock);
 172
 173         return status;
 174 }
 175
 176 static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
 177                                    void **ret_p)
 178 {
 179         struct acpi_device *device = NULL;
 180         struct acpi_device_physical_node *pn;
 181
 182         if (acpi_bus_get_device(handle, &device))
 183                 return AE_OK;
 184
 185         mutex_lock(&device->physical_node_lock);
 186
 187         list_for_each_entry(pn, &device->physical_node_list, node)
 188                 if (pn->put_online) {
 189                         device_online(pn->dev);
 190                         pn->put_online = false;
 191                 }
 192
 193         mutex_unlock(&device->physical_node_lock);
 194
 195         return AE_OK;
 196 }
 197
 198 static int acpi_scan_hot_remove(struct acpi_device *device)
 199 {
 200         acpi_handle handle = device->handle;
 201         struct device *errdev;
 202         acpi_status status;
 203         unsigned long long sta;
 204
 205         /* If there is no handle, the device node has been unregistered. */
 206         if (!handle) {
 207                 dev_dbg(&device->dev, "ACPI handle missing\n");
 208                 put_device(&device->dev);
 209                 return -EINVAL;
 210         }
 211
 212         /*
 213          * Carry out two passes here and ignore errors in the first pass,
 214          * because if the devices in question are memory blocks and
 215          * CONFIG_MEMCG is set, one of the blocks may hold data structures
 216          * that the other blocks depend on, but it is not known in advance which
 217          * block holds them.
 218          *
 219          * If the first pass is successful, the second one isn't needed, though.
 220          */
 221         errdev = NULL;
 222         status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
 223                                      NULL, acpi_bus_offline, (void *)false,
 224                                      (void **)&errdev);
 225         if (status == AE_SUPPORT) {
 226                 dev_warn(errdev, "Offline disabled.\n");
 227                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
 228                                     acpi_bus_online, NULL, NULL, NULL);
 229                 put_device(&device->dev);
 230                 return -EPERM;
 231         }
 232         acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
 233         if (errdev) {
 234                 errdev = NULL;
 235                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
 236                                     NULL, acpi_bus_offline, (void *)true,
 237                                     (void **)&errdev);
 238                 if (!errdev || acpi_force_hot_remove)
 239                         acpi_bus_offline(handle, 0, (void *)true,
 240                                          (void **)&errdev);
 241
 242                 if (errdev && !acpi_force_hot_remove) {
 243                         dev_warn(errdev, "Offline failed.\n");
 244                         acpi_bus_online(handle, 0, NULL, NULL);
 245                         acpi_walk_namespace(ACPI_TYPE_ANY, handle,
 246                                             ACPI_UINT32_MAX, acpi_bus_online,
 247                                             NULL, NULL, NULL);
 248                         put_device(&device->dev);
 249                         return -EBUSY;
 250                 }
 251         }
 252
 253         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 254                 "Hot-removing device %s...\n", dev_name(&device->dev)));
 255
 256         acpi_bus_trim(device);
 257
 258         /* Device node has been unregistered. */
 259         put_device(&device->dev);
 260         device = NULL;
 261
 262         acpi_evaluate_lck(handle, 0);
 263         /*
 264          * TBD: _EJD support.
 265          */
 266         status = acpi_evaluate_ej0(handle);
 267         if (status == AE_NOT_FOUND)
 268                 return -ENODEV;
 269         else if (ACPI_FAILURE(status))
 270                 return -EIO;
 271
 272         /*
 273          * Verify if eject was indeed successful.  If not, log an error
 274          * message.  No need to call _OST since _EJ0 call was made OK.
 275          */
 276         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
 277         if (ACPI_FAILURE(status)) {
 278                 acpi_handle_warn(handle,
 279                         "Status check after eject failed (0x%x)\n", status);
 280         } else if (sta & ACPI_STA_DEVICE_ENABLED) {
 281                 acpi_handle_warn(handle,
 282                         "Eject incomplete - status 0x%llx\n", sta);
 283         }
 284
 285         return 0;
 286 }
 287
 288 static void acpi_bus_device_eject(struct acpi_device *device, u32 ost_src)
 289 {
 290         acpi_handle handle = device->handle;
 291         struct acpi_scan_handler *handler;
 292         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
 293         int error;
 294
 295         lock_device_hotplug();
 296         mutex_lock(&acpi_scan_lock);
 297
 298         handler = device->handler;
 299         if (!handler || !handler->hotplug.enabled) {
 300                 put_device(&device->dev);
 301                 goto err_support;
 302         }
 303
 304         if (ost_src == ACPI_NOTIFY_EJECT_REQUEST)
 305                 acpi_evaluate_hotplug_ost(handle, ACPI_NOTIFY_EJECT_REQUEST,
 306                                           ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
 307
 308         if (handler->hotplug.mode == AHM_CONTAINER)
 309                 kobject_uevent(&device->dev.kobj, KOBJ_OFFLINE);
 310
 311         error = acpi_scan_hot_remove(device);
 312         if (error == -EPERM) {
 313                 goto err_support;
 314         } else if (error) {
 315                 goto err_out;
 316         }
 317
 318  out:
 319         mutex_unlock(&acpi_scan_lock);
 320         unlock_device_hotplug();
 321         return;
 322
 323  err_support:
 324         ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
 325  err_out:
 326         acpi_evaluate_hotplug_ost(handle, ost_src, ost_code, NULL);
 327         goto out;
 328 }
 329
 330 static void acpi_scan_bus_device_check(acpi_handle handle, u32 ost_source)
 331 {
 332         struct acpi_device *device = NULL;
 333         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
 334         int error;
 335
 336         lock_device_hotplug();
 337         mutex_lock(&acpi_scan_lock);
 338
 339         if (ost_source != ACPI_NOTIFY_BUS_CHECK) {
 340                 acpi_bus_get_device(handle, &device);
 341                 if (device) {
 342                         dev_warn(&device->dev, "Attempt to re-insert\n");
 343                         goto out;
 344                 }
 345         }
 346         acpi_evaluate_hotplug_ost(handle, ost_source,
 347                                   ACPI_OST_SC_INSERT_IN_PROGRESS, NULL);
 348         error = acpi_bus_scan(handle);
 349         if (error) {
 350                 acpi_handle_warn(handle, "Namespace scan failure\n");
 351                 goto out;
 352         }
 353         error = acpi_bus_get_device(handle, &device);
 354         if (error) {
 355                 acpi_handle_warn(handle, "Missing device node object\n");
 356                 goto out;
 357         }
 358         ost_code = ACPI_OST_SC_SUCCESS;
 359         if (device->handler && device->handler->hotplug.mode == AHM_CONTAINER)
 360                 kobject_uevent(&device->dev.kobj, KOBJ_ONLINE);
 361
 362  out:
 363         acpi_evaluate_hotplug_ost(handle, ost_source, ost_code, NULL);
 364         mutex_unlock(&acpi_scan_lock);
 365         unlock_device_hotplug();
 366 }
 367
 368 static void acpi_scan_bus_check(void *context)
 369 {
 370         acpi_scan_bus_device_check((acpi_handle)context,
 371                                    ACPI_NOTIFY_BUS_CHECK);
 372 }
 373
 374 static void acpi_scan_device_check(void *context)
 375 {
 376         acpi_scan_bus_device_check((acpi_handle)context,
 377                                    ACPI_NOTIFY_DEVICE_CHECK);
 378 }
 379
 380 static void acpi_hotplug_unsupported(acpi_handle handle, u32 type)
 381 {
 382         u32 ost_status;
 383
 384         switch (type) {
 385         case ACPI_NOTIFY_BUS_CHECK:
 386                 acpi_handle_debug(handle,
 387                         "ACPI_NOTIFY_BUS_CHECK event: unsupported\n");
 388                 ost_status = ACPI_OST_SC_INSERT_NOT_SUPPORTED;
 389                 break;
 390         case ACPI_NOTIFY_DEVICE_CHECK:
 391                 acpi_handle_debug(handle,
 392                         "ACPI_NOTIFY_DEVICE_CHECK event: unsupported\n");
 393                 ost_status = ACPI_OST_SC_INSERT_NOT_SUPPORTED;
 394                 break;
 395         case ACPI_NOTIFY_EJECT_REQUEST:
 396                 acpi_handle_debug(handle,
 397                         "ACPI_NOTIFY_EJECT_REQUEST event: unsupported\n");
 398                 ost_status = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
 399                 break;
 400         default:
 401                 /* non-hotplug event; possibly handled by other handler */
 402                 return;
 403         }
 404
 405         acpi_evaluate_hotplug_ost(handle, type, ost_status, NULL);
 406 }
 407
 408 /**
 409  * acpi_bus_hot_remove_device: Hot-remove a device and its children.
 410  * @context: Address of the ACPI device object to hot-remove.
 411  */
 412 void acpi_bus_hot_remove_device(void *context)
 413 {
 414         acpi_bus_device_eject(context, ACPI_NOTIFY_EJECT_REQUEST);
 415 }
 416
 417 static void acpi_hotplug_notify_cb(acpi_handle handle, u32 type, void *data)
 418 {
 419         acpi_osd_exec_callback callback;
 420         struct acpi_scan_handler *handler = data;
 421         struct acpi_device *adev;
 422         acpi_status status;
 423
 424         if (!handler->hotplug.enabled)
 425                 return acpi_hotplug_unsupported(handle, type);
 426
 427         switch (type) {
 428         case ACPI_NOTIFY_BUS_CHECK:
 429                 acpi_handle_debug(handle, "ACPI_NOTIFY_BUS_CHECK event\n");
 430                 callback = acpi_scan_bus_check;
 431                 break;
 432         case ACPI_NOTIFY_DEVICE_CHECK:
 433                 acpi_handle_debug(handle, "ACPI_NOTIFY_DEVICE_CHECK event\n");
 434                 callback = acpi_scan_device_check;
 435                 break;
 436         case ACPI_NOTIFY_EJECT_REQUEST:
 437                 acpi_handle_debug(handle, "ACPI_NOTIFY_EJECT_REQUEST event\n");
 438                 status = acpi_bus_get_device(handle, &adev);
 439                 if (ACPI_FAILURE(status))
 440                         goto err_out;
 441
 442                 get_device(&adev->dev);
 443                 callback = acpi_bus_hot_remove_device;
 444                 status = acpi_os_hotplug_execute(callback, adev);
 445                 if (ACPI_SUCCESS(status))
 446                         return;
 447
 448                 put_device(&adev->dev);
 449                 goto err_out;
 450         default:
 451                 /* non-hotplug event; possibly handled by other handler */
 452                 return;
 453         }
 454         status = acpi_os_hotplug_execute(callback, handle);
 455         if (ACPI_SUCCESS(status))
 456                 return;
 457
 458  err_out:
 459         acpi_evaluate_hotplug_ost(handle, type,
 460                                   ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
 461 }
 462
 463 static ssize_t real_power_state_show(struct device *dev,
 464                                      struct device_attribute *attr, char *buf)
 465 {
 466         struct acpi_device *adev = to_acpi_device(dev);
 467         int state;
 468         int ret;
 469
 470         ret = acpi_device_get_power(adev, &state);
 471         if (ret)
 472                 return ret;
 473
 474         return sprintf(buf, "%s\n", acpi_power_state_string(state));
 475 }
 476
 477 static DEVICE_ATTR(real_power_state, 0444, real_power_state_show, NULL);
 478
 479 static ssize_t power_state_show(struct device *dev,
 480                                 struct device_attribute *attr, char *buf)
 481 {
 482         struct acpi_device *adev = to_acpi_device(dev);
 483
 484         return sprintf(buf, "%s\n", acpi_power_state_string(adev->power.state));
 485 }
 486
 487 static DEVICE_ATTR(power_state, 0444, power_state_show, NULL);
 488
 489 static void acpi_eject_store_work(void *context)
 490 {
 491         acpi_bus_device_eject(context, ACPI_OST_EC_OSPM_EJECT);
 492 }
 493
 494 static ssize_t
 495 acpi_eject_store(struct device *d, struct device_attribute *attr,
 496                 const char *buf, size_t count)
 497 {
 498         struct acpi_device *acpi_device = to_acpi_device(d);
 499         acpi_object_type not_used;
 500         acpi_status status;
 501
 502         if (!count || buf[0] != '1')
 503                 return -EINVAL;
 504
 505         if ((!acpi_device->handler || !acpi_device->handler->hotplug.enabled)
 506             && !acpi_device->driver)
 507                 return -ENODEV;
 508
 509         status = acpi_get_type(acpi_device->handle, &not_used);
 510         if (ACPI_FAILURE(status) || !acpi_device->flags.ejectable)
 511                 return -ENODEV;
 512
 513         acpi_evaluate_hotplug_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
 514                                   ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
 515         get_device(&acpi_device->dev);
 516         status = acpi_os_hotplug_execute(acpi_eject_store_work, acpi_device);
 517         if (ACPI_SUCCESS(status))
 518                 return count;
 519
 520         put_device(&acpi_device->dev);
 521         acpi_evaluate_hotplug_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
 522                                   ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
 523         return status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
 524 }
 525
 526 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
 527
 528 static ssize_t
 529 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
 530         struct acpi_device *acpi_dev = to_acpi_device(dev);
 531
 532         return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
 533 }
 534 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 535
 536 static ssize_t acpi_device_uid_show(struct device *dev,
 537                                     struct device_attribute *attr, char *buf)
 538 {
 539         struct acpi_device *acpi_dev = to_acpi_device(dev);
 540
 541         return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
 542 }
 543 static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
 544
 545 static ssize_t acpi_device_adr_show(struct device *dev,
 546                                     struct device_attribute *attr, char *buf)
 547 {
 548         struct acpi_device *acpi_dev = to_acpi_device(dev);
 549
 550         return sprintf(buf, "0x%08x\n",
 551                        (unsigned int)(acpi_dev->pnp.bus_address));
 552 }
 553 static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
 554
 555 static ssize_t
 556 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
 557         struct acpi_device *acpi_dev = to_acpi_device(dev);
 558         struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
 559         int result;
 560
 561         result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
 562         if (result)
 563                 goto end;
 564
 565         result = sprintf(buf, "%s\n", (char*)path.pointer);
 566         kfree(path.pointer);
 567 end:
 568         return result;
 569 }
 570 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
 571
 572 /* sysfs file that shows description text from the ACPI _STR method */
 573 static ssize_t description_show(struct device *dev,
 574                                 struct device_attribute *attr,
 575                                 char *buf) {
 576         struct acpi_device *acpi_dev = to_acpi_device(dev);
 577         int result;
 578
 579         if (acpi_dev->pnp.str_obj == NULL)
 580                 return 0;
 581
 582         /*
 583          * The _STR object contains a Unicode identifier for a device.
 584          * We need to convert to utf-8 so it can be displayed.
 585          */
 586         result = utf16s_to_utf8s(
 587                 (wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
 588                 acpi_dev->pnp.str_obj->buffer.length,
 589                 UTF16_LITTLE_ENDIAN, buf,
 590                 PAGE_SIZE);
 591
 592         buf[result++] = '\n';
 593
 594         return result;
 595 }
 596 static DEVICE_ATTR(description, 0444, description_show, NULL);
 597
 598 static ssize_t
 599 acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
 600                      char *buf) {
 601         struct acpi_device *acpi_dev = to_acpi_device(dev);
 602
 603         return sprintf(buf, "%lu\n", acpi_dev->pnp.sun);
 604 }
 605 static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
 606
 607 static int acpi_device_setup_files(struct acpi_device *dev)
 608 {
 609         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 610         acpi_status status;
 611         unsigned long long sun;
 612         int result = 0;
 613
 614         /*
 615          * Devices gotten from FADT don't have a "path" attribute
 616          */
 617         if (dev->handle) {
 618                 result = device_create_file(&dev->dev, &dev_attr_path);
 619                 if (result)
 620                         goto end;
 621         }
 622
 623         if (!list_empty(&dev->pnp.ids)) {
 624                 result = device_create_file(&dev->dev, &dev_attr_hid);
 625                 if (result)
 626                         goto end;
 627
 628                 result = device_create_file(&dev->dev, &dev_attr_modalias);
 629                 if (result)
 630                         goto end;
 631         }
 632
 633         /*
 634          * If device has _STR, 'description' file is created
 635          */
 636         if (acpi_has_method(dev->handle, "_STR")) {
 637                 status = acpi_evaluate_object(dev->handle, "_STR",
 638                                         NULL, &buffer);
 639                 if (ACPI_FAILURE(status))
 640                         buffer.pointer = NULL;
 641                 dev->pnp.str_obj = buffer.pointer;
 642                 result = device_create_file(&dev->dev, &dev_attr_description);
 643                 if (result)
 644                         goto end;
 645         }
 646
 647         if (dev->pnp.type.bus_address)
 648                 result = device_create_file(&dev->dev, &dev_attr_adr);
 649         if (dev->pnp.unique_id)
 650                 result = device_create_file(&dev->dev, &dev_attr_uid);
 651
 652         status = acpi_evaluate_integer(dev->handle, "_SUN", NULL, &sun);
 653         if (ACPI_SUCCESS(status)) {
 654                 dev->pnp.sun = (unsigned long)sun;
 655                 result = device_create_file(&dev->dev, &dev_attr_sun);
 656                 if (result)
 657                         goto end;
 658         } else {
 659                 dev->pnp.sun = (unsigned long)-1;
 660         }
 661
 662         /*
 663          * If device has _EJ0, 'eject' file is created that is used to trigger
 664          * hot-removal function from userland.
 665          */
 666         if (acpi_has_method(dev->handle, "_EJ0")) {
 667                 result = device_create_file(&dev->dev, &dev_attr_eject);
 668                 if (result)
 669                         return result;
 670         }
 671
 672         if (dev->flags.power_manageable) {
 673                 result = device_create_file(&dev->dev, &dev_attr_power_state);
 674                 if (result)
 675                         return result;
 676
 677                 if (dev->power.flags.power_resources)
 678                         result = device_create_file(&dev->dev,
 679                                                     &dev_attr_real_power_state);
 680         }
 681
 682 end:
 683         return result;
 684 }
 685
 686 static void acpi_device_remove_files(struct acpi_device *dev)
 687 {
 688         if (dev->flags.power_manageable) {
 689                 device_remove_file(&dev->dev, &dev_attr_power_state);
 690                 if (dev->power.flags.power_resources)
 691                         device_remove_file(&dev->dev,
 692                                            &dev_attr_real_power_state);
 693         }
 694
 695         /*
 696          * If device has _STR, remove 'description' file
 697          */
 698         if (acpi_has_method(dev->handle, "_STR")) {
 699                 kfree(dev->pnp.str_obj);
 700                 device_remove_file(&dev->dev, &dev_attr_description);
 701         }
 702         /*
 703          * If device has _EJ0, remove 'eject' file.
 704          */
 705         if (acpi_has_method(dev->handle, "_EJ0"))
 706                 device_remove_file(&dev->dev, &dev_attr_eject);
 707
 708         if (acpi_has_method(dev->handle, "_SUN"))
 709                 device_remove_file(&dev->dev, &dev_attr_sun);
 710
 711         if (dev->pnp.unique_id)
 712                 device_remove_file(&dev->dev, &dev_attr_uid);
 713         if (dev->pnp.type.bus_address)
 714                 device_remove_file(&dev->dev, &dev_attr_adr);
 715         device_remove_file(&dev->dev, &dev_attr_modalias);
 716         device_remove_file(&dev->dev, &dev_attr_hid);
 717         if (dev->handle)
 718                 device_remove_file(&dev->dev, &dev_attr_path);
 719 }
 720 /* --------------------------------------------------------------------------
 721                         ACPI Bus operations
 722    -------------------------------------------------------------------------- */
 723
 724 static const struct acpi_device_id *__acpi_match_device(
 725         struct acpi_device *device, const struct acpi_device_id *ids)
 726 {
 727         const struct acpi_device_id *id;
 728         struct acpi_hardware_id *hwid;
 729
 730         /*
 731          * If the device is not present, it is unnecessary to load device
 732          * driver for it.
 733          */
 734         if (!device->status.present)
 735                 return NULL;
 736
 737         for (id = ids; id->id[0]; id++)
 738                 list_for_each_entry(hwid, &device->pnp.ids, list)
 739                         if (!strcmp((char *) id->id, hwid->id))
 740                                 return id;
 741
 742         return NULL;
 743 }
 744
 745 /**
 746  * acpi_match_device - Match a struct device against a given list of ACPI IDs
 747  * @ids: Array of struct acpi_device_id object to match against.
 748  * @dev: The device structure to match.
 749  *
 750  * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
 751  * object for that handle and use that object to match against a given list of
 752  * device IDs.
 753  *
 754  * Return a pointer to the first matching ID on success or %NULL on failure.
 755  */
 756 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
 757                                                const struct device *dev)
 758 {
 759         struct acpi_device *adev;
 760         acpi_handle handle = ACPI_HANDLE(dev);
 761
 762         if (!ids || !handle || acpi_bus_get_device(handle, &adev))
 763                 return NULL;
 764
 765         return __acpi_match_device(adev, ids);
 766 }
 767 EXPORT_SYMBOL_GPL(acpi_match_device);
 768
 769 int acpi_match_device_ids(struct acpi_device *device,
 770                           const struct acpi_device_id *ids)
 771 {
 772         return __acpi_match_device(device, ids) ? 0 : -ENOENT;
 773 }
 774 EXPORT_SYMBOL(acpi_match_device_ids);
 775
 776 static void acpi_free_power_resources_lists(struct acpi_device *device)
 777 {
 778         int i;
 779
 780         if (device->wakeup.flags.valid)
 781                 acpi_power_resources_list_free(&device->wakeup.resources);
 782
 783         if (!device->flags.power_manageable)
 784                 return;
 785
 786         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
 787                 struct acpi_device_power_state *ps = &device->power.states[i];
 788                 acpi_power_resources_list_free(&ps->resources);
 789         }
 790 }
 791
 792 static void acpi_device_release(struct device *dev)
 793 {
 794         struct acpi_device *acpi_dev = to_acpi_device(dev);
 795
 796         acpi_free_pnp_ids(&acpi_dev->pnp);
 797         acpi_free_power_resources_lists(acpi_dev);
 798         kfree(acpi_dev);
 799 }
 800
 801 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 802 {
 803         struct acpi_device *acpi_dev = to_acpi_device(dev);
 804         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 805
 806         return acpi_dev->flags.match_driver
 807                 && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 808 }
 809
 810 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 811 {
 812         struct acpi_device *acpi_dev = to_acpi_device(dev);
 813         int len;
 814
 815         if (list_empty(&acpi_dev->pnp.ids))
 816                 return 0;
 817
 818         if (add_uevent_var(env, "MODALIAS="))
 819                 return -ENOMEM;
 820         len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
 821                               sizeof(env->buf) - env->buflen);
 822         if (len >= (sizeof(env->buf) - env->buflen))
 823                 return -ENOMEM;
 824         env->buflen += len;
 825         return 0;
 826 }
 827
 828 static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
 829 {
 830         struct acpi_device *device = data;
 831
 832         device->driver->ops.notify(device, event);
 833 }
 834
 835 static acpi_status acpi_device_notify_fixed(void *data)
 836 {
 837         struct acpi_device *device = data;
 838
 839         /* Fixed hardware devices have no handles */
 840         acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
 841         return AE_OK;
 842 }
 843
 844 static int acpi_device_install_notify_handler(struct acpi_device *device)
 845 {
 846         acpi_status status;
 847
 848         if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
 849                 status =
 850                     acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
 851                                                      acpi_device_notify_fixed,
 852                                                      device);
 853         else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
 854                 status =
 855                     acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
 856                                                      acpi_device_notify_fixed,
 857                                                      device);
 858         else
 859                 status = acpi_install_notify_handler(device->handle,
 860                                                      ACPI_DEVICE_NOTIFY,
 861                                                      acpi_device_notify,
 862                                                      device);
 863
 864         if (ACPI_FAILURE(status))
 865                 return -EINVAL;
 866         return 0;
 867 }
 868
 869 static void acpi_device_remove_notify_handler(struct acpi_device *device)
 870 {
 871         if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
 872                 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
 873                                                 acpi_device_notify_fixed);
 874         else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
 875                 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
 876                                                 acpi_device_notify_fixed);
 877         else
 878                 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
 879                                            acpi_device_notify);
 880 }
 881
 882 static int acpi_device_probe(struct device *dev)
 883 {
 884         struct acpi_device *acpi_dev = to_acpi_device(dev);
 885         struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
 886         int ret;
 887
 888         if (acpi_dev->handler)
 889                 return -EINVAL;
 890
 891         if (!acpi_drv->ops.add)
 892                 return -ENOSYS;
 893
 894         ret = acpi_drv->ops.add(acpi_dev);
 895         if (ret)
 896                 return ret;
 897
 898         acpi_dev->driver = acpi_drv;
 899         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 900                           "Driver [%s] successfully bound to device [%s]\n",
 901                           acpi_drv->name, acpi_dev->pnp.bus_id));
 902
 903         if (acpi_drv->ops.notify) {
 904                 ret = acpi_device_install_notify_handler(acpi_dev);
 905                 if (ret) {
 906                         if (acpi_drv->ops.remove)
 907                                 acpi_drv->ops.remove(acpi_dev);
 908
 909                         acpi_dev->driver = NULL;
 910                         acpi_dev->driver_data = NULL;
 911                         return ret;
 912                 }
 913         }
 914
 915         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
 916                           acpi_drv->name, acpi_dev->pnp.bus_id));
 917         get_device(dev);
 918         return 0;
 919 }
 920
 921 static int acpi_device_remove(struct device * dev)
 922 {
 923         struct acpi_device *acpi_dev = to_acpi_device(dev);
 924         struct acpi_driver *acpi_drv = acpi_dev->driver;
 925
 926         if (acpi_drv) {
 927                 if (acpi_drv->ops.notify)
 928                         acpi_device_remove_notify_handler(acpi_dev);
 929                 if (acpi_drv->ops.remove)
 930                         acpi_drv->ops.remove(acpi_dev);
 931         }
 932         acpi_dev->driver = NULL;
 933         acpi_dev->driver_data = NULL;
 934
 935         put_device(dev);
 936         return 0;
 937 }
 938
 939 struct bus_type acpi_bus_type = {
 940         .name           = "acpi",
 941         .match          = acpi_bus_match,
 942         .probe          = acpi_device_probe,
 943         .remove         = acpi_device_remove,
 944         .uevent         = acpi_device_uevent,
 945 };
 946
 947 static void acpi_bus_data_handler(acpi_handle handle, void *context)
 948 {
 949         /* Intentionally empty. */
 950 }
 951
 952 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
 953 {
 954         acpi_status status;
 955
 956         if (!device)
 957                 return -EINVAL;
 958
 959         status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
 960         if (ACPI_FAILURE(status) || !*device) {
 961                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
 962                                   handle));
 963                 return -ENODEV;
 964         }
 965         return 0;
 966 }
 967 EXPORT_SYMBOL_GPL(acpi_bus_get_device);
 968
 969 int acpi_device_add(struct acpi_device *device,
 970                     void (*release)(struct device *))
 971 {
 972         int result;
 973         struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
 974         int found = 0;
 975
 976         if (device->handle) {
 977                 acpi_status status;
 978
 979                 status = acpi_attach_data(device->handle, acpi_bus_data_handler,
 980                                           device);
 981                 if (ACPI_FAILURE(status)) {
 982                         acpi_handle_err(device->handle,
 983                                         "Unable to attach device data\n");
 984                         return -ENODEV;
 985                 }
 986         }
 987
 988         /*
 989          * Linkage
 990          * -------
 991          * Link this device to its parent and siblings.
 992          */
 993         INIT_LIST_HEAD(&device->children);
 994         INIT_LIST_HEAD(&device->node);
 995         INIT_LIST_HEAD(&device->wakeup_list);
 996         INIT_LIST_HEAD(&device->physical_node_list);
 997         mutex_init(&device->physical_node_lock);
 998         INIT_LIST_HEAD(&device->power_dependent);
 999
1000         new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
1001         if (!new_bus_id) {
1002                 pr_err(PREFIX "Memory allocation error\n");
1003                 result = -ENOMEM;
1004                 goto err_detach;
1005         }
1006
1007         mutex_lock(&acpi_device_lock);
1008         /*
1009          * Find suitable bus_id and instance number in acpi_bus_id_list
1010          * If failed, create one and link it into acpi_bus_id_list
1011          */
1012         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
1013                 if (!strcmp(acpi_device_bus_id->bus_id,
1014                             acpi_device_hid(device))) {
1015                         acpi_device_bus_id->instance_no++;
1016                         found = 1;
1017                         kfree(new_bus_id);
1018                         break;
1019                 }
1020         }
1021         if (!found) {
1022                 acpi_device_bus_id = new_bus_id;
1023                 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
1024                 acpi_device_bus_id->instance_no = 0;
1025                 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
1026         }
1027         dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
1028
1029         if (device->parent)
1030                 list_add_tail(&device->node, &device->parent->children);
1031
1032         if (device->wakeup.flags.valid)
1033                 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
1034         mutex_unlock(&acpi_device_lock);
1035
1036         if (device->parent)
1037                 device->dev.parent = &device->parent->dev;
1038         device->dev.bus = &acpi_bus_type;
1039         device->dev.release = release;
1040         result = device_add(&device->dev);
1041         if (result) {
1042                 dev_err(&device->dev, "Error registering device\n");
1043                 goto err;
1044         }
1045
1046         result = acpi_device_setup_files(device);
1047         if (result)
1048                 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
1049                        dev_name(&device->dev));
1050
1051         return 0;
1052
1053  err:
1054         mutex_lock(&acpi_device_lock);
1055         if (device->parent)
1056                 list_del(&device->node);
1057         list_del(&device->wakeup_list);
1058         mutex_unlock(&acpi_device_lock);
1059
1060  err_detach:
1061         acpi_detach_data(device->handle, acpi_bus_data_handler);
1062         return result;
1063 }
1064
1065 static void acpi_device_unregister(struct acpi_device *device)
1066 {
1067         mutex_lock(&acpi_device_lock);
1068         if (device->parent)
1069                 list_del(&device->node);
1070
1071         list_del(&device->wakeup_list);
1072         mutex_unlock(&acpi_device_lock);
1073
1074         acpi_detach_data(device->handle, acpi_bus_data_handler);
1075
1076         acpi_power_add_remove_device(device, false);
1077         acpi_device_remove_files(device);
1078         if (device->remove)
1079                 device->remove(device);
1080
1081         device_del(&device->dev);
1082         /*
1083          * Transition the device to D3cold to drop the reference counts of all
1084          * power resources the device depends on and turn off the ones that have
1085          * no more references.
1086          */
1087         acpi_device_set_power(device, ACPI_STATE_D3_COLD);
1088         device->handle = NULL;
1089         put_device(&device->dev);
1090 }
1091
1092 /* --------------------------------------------------------------------------
1093                                  Driver Management
1094    -------------------------------------------------------------------------- */
1095 /**
1096  * acpi_bus_register_driver - register a driver with the ACPI bus
1097  * @driver: driver being registered
1098  *
1099  * Registers a driver with the ACPI bus.  Searches the namespace for all
1100  * devices that match the driver's criteria and binds.  Returns zero for
1101  * success or a negative error status for failure.
1102  */
1103 int acpi_bus_register_driver(struct acpi_driver *driver)
1104 {
1105         int ret;
1106
1107         if (acpi_disabled)
1108                 return -ENODEV;
1109         driver->drv.name = driver->name;
1110         driver->drv.bus = &acpi_bus_type;
1111         driver->drv.owner = driver->owner;
1112
1113         ret = driver_register(&driver->drv);
1114         return ret;
1115 }
1116
1117 EXPORT_SYMBOL(acpi_bus_register_driver);
1118
1119 /**
1120  * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
1121  * @driver: driver to unregister
1122  *
1123  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
1124  * devices that match the driver's criteria and unbinds.
1125  */
1126 void acpi_bus_unregister_driver(struct acpi_driver *driver)
1127 {
1128         driver_unregister(&driver->drv);
1129 }
1130
1131 EXPORT_SYMBOL(acpi_bus_unregister_driver);
1132
1133 /* --------------------------------------------------------------------------
1134                                  Device Enumeration
1135    -------------------------------------------------------------------------- */
1136 static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
1137 {
1138         struct acpi_device *device = NULL;
1139         acpi_status status;
1140
1141         /*
1142          * Fixed hardware devices do not appear in the namespace and do not
1143          * have handles, but we fabricate acpi_devices for them, so we have
1144          * to deal with them specially.
1145          */
1146         if (!handle)
1147                 return acpi_root;
1148
1149         do {
1150                 status = acpi_get_parent(handle, &handle);
1151                 if (ACPI_FAILURE(status))
1152                         return status == AE_NULL_ENTRY ? NULL : acpi_root;
1153         } while (acpi_bus_get_device(handle, &device));
1154         return device;
1155 }
1156
1157 acpi_status
1158 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
1159 {
1160         acpi_status status;
1161         acpi_handle tmp;
1162         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1163         union acpi_object *obj;
1164
1165         status = acpi_get_handle(handle, "_EJD", &tmp);
1166         if (ACPI_FAILURE(status))
1167                 return status;
1168
1169         status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
1170         if (ACPI_SUCCESS(status)) {
1171                 obj = buffer.pointer;
1172                 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
1173                                          ejd);
1174                 kfree(buffer.pointer);
1175         }
1176         return status;
1177 }
1178 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
1179
1180 static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
1181                                         struct acpi_device_wakeup *wakeup)
1182 {
1183         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1184         union acpi_object *package = NULL;
1185         union acpi_object *element = NULL;
1186         acpi_status status;
1187         int err = -ENODATA;
1188
1189         if (!wakeup)
1190                 return -EINVAL;
1191
1192         INIT_LIST_HEAD(&wakeup->resources);
1193
1194         /* _PRW */
1195         status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
1196         if (ACPI_FAILURE(status)) {
1197                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
1198                 return err;
1199         }
1200
1201         package = (union acpi_object *)buffer.pointer;
1202
1203         if (!package || package->package.count < 2)
1204                 goto out;
1205
1206         element = &(package->package.elements[0]);
1207         if (!element)
1208                 goto out;
1209
1210         if (element->type == ACPI_TYPE_PACKAGE) {
1211                 if ((element->package.count < 2) ||
1212                     (element->package.elements[0].type !=
1213                      ACPI_TYPE_LOCAL_REFERENCE)
1214                     || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
1215                         goto out;
1216
1217                 wakeup->gpe_device =
1218                     element->package.elements[0].reference.handle;
1219                 wakeup->gpe_number =
1220                     (u32) element->package.elements[1].integer.value;
1221         } else if (element->type == ACPI_TYPE_INTEGER) {
1222                 wakeup->gpe_device = NULL;
1223                 wakeup->gpe_number = element->integer.value;
1224         } else {
1225                 goto out;
1226         }
1227
1228         element = &(package->package.elements[1]);
1229         if (element->type != ACPI_TYPE_INTEGER)
1230                 goto out;
1231
1232         wakeup->sleep_state = element->integer.value;
1233
1234         err = acpi_extract_power_resources(package, 2, &wakeup->resources);
1235         if (err)
1236                 goto out;
1237
1238         if (!list_empty(&wakeup->resources)) {
1239                 int sleep_state;
1240
1241                 err = acpi_power_wakeup_list_init(&wakeup->resources,
1242                                                   &sleep_state);
1243                 if (err) {
1244                         acpi_handle_warn(handle, "Retrieving current states "
1245                                          "of wakeup power resources failed\n");
1246                         acpi_power_resources_list_free(&wakeup->resources);
1247                         goto out;
1248                 }
1249                 if (sleep_state < wakeup->sleep_state) {
1250                         acpi_handle_warn(handle, "Overriding _PRW sleep state "
1251                                          "(S%d) by S%d from power resources\n",
1252                                          (int)wakeup->sleep_state, sleep_state);
1253                         wakeup->sleep_state = sleep_state;
1254                 }
1255         }
1256         acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number);
1257
1258  out:
1259         kfree(buffer.pointer);
1260         return err;
1261 }
1262
1263 static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
1264 {
1265         struct acpi_device_id button_device_ids[] = {
1266                 {"PNP0C0C", 0},
1267                 {"PNP0C0D", 0},
1268                 {"PNP0C0E", 0},
1269                 {"", 0},
1270         };
1271         acpi_status status;
1272         acpi_event_status event_status;
1273
1274         device->wakeup.flags.notifier_present = 0;
1275
1276         /* Power button, Lid switch always enable wakeup */
1277         if (!acpi_match_device_ids(device, button_device_ids)) {
1278                 device->wakeup.flags.run_wake = 1;
1279                 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
1280                         /* Do not use Lid/sleep button for S5 wakeup */
1281                         if (device->wakeup.sleep_state == ACPI_STATE_S5)
1282                                 device->wakeup.sleep_state = ACPI_STATE_S4;
1283                 }
1284                 device_set_wakeup_capable(&device->dev, true);
1285                 return;
1286         }
1287
1288         status = acpi_get_gpe_status(device->wakeup.gpe_device,
1289                                         device->wakeup.gpe_number,
1290                                                 &event_status);
1291         if (status == AE_OK)
1292                 device->wakeup.flags.run_wake =
1293                                 !!(event_status & ACPI_EVENT_FLAG_HANDLE);
1294 }
1295
1296 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
1297 {
1298         int err;
1299
1300         /* Presence of _PRW indicates wake capable */
1301         if (!acpi_has_method(device->handle, "_PRW"))
1302                 return;
1303
1304         err = acpi_bus_extract_wakeup_device_power_package(device->handle,
1305                                                            &device->wakeup);
1306         if (err) {
1307                 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
1308                 return;
1309         }
1310
1311         device->wakeup.flags.valid = 1;
1312         device->wakeup.prepare_count = 0;
1313         acpi_bus_set_run_wake_flags(device);
1314         /* Call _PSW/_DSW object to disable its ability to wake the sleeping
1315          * system for the ACPI device with the _PRW object.
1316          * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
1317          * So it is necessary to call _DSW object first. Only when it is not
1318          * present will the _PSW object used.
1319          */
1320         err = acpi_device_sleep_wake(device, 0, 0, 0);
1321         if (err)
1322                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1323                                 "error in _DSW or _PSW evaluation\n"));
1324 }
1325
1326 static void acpi_bus_init_power_state(struct acpi_device *device, int state)
1327 {
1328         struct acpi_device_power_state *ps = &device->power.states[state];
1329         char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
1330         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1331         acpi_status status;
1332
1333         INIT_LIST_HEAD(&ps->resources);
1334
1335         /* Evaluate "_PRx" to get referenced power resources */
1336         status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
1337         if (ACPI_SUCCESS(status)) {
1338                 union acpi_object *package = buffer.pointer;
1339
1340                 if (buffer.length && package
1341                     && package->type == ACPI_TYPE_PACKAGE
1342                     && package->package.count) {
1343                         int err = acpi_extract_power_resources(package, 0,
1344                                                                &ps->resources);
1345                         if (!err)
1346                                 device->power.flags.power_resources = 1;
1347                 }
1348                 ACPI_FREE(buffer.pointer);
1349         }
1350
1351         /* Evaluate "_PSx" to see if we can do explicit sets */
1352         pathname[2] = 'S';
1353         if (acpi_has_method(device->handle, pathname))
1354                 ps->flags.explicit_set = 1;
1355
1356         /*
1357          * State is valid if there are means to put the device into it.
1358          * D3hot is only valid if _PR3 present.
1359          */
1360         if (!list_empty(&ps->resources)
1361             || (ps->flags.explicit_set && state < ACPI_STATE_D3_HOT)) {
1362                 ps->flags.valid = 1;
1363                 ps->flags.os_accessible = 1;
1364         }
1365
1366         ps->power = -1;         /* Unknown - driver assigned */
1367         ps->latency = -1;       /* Unknown - driver assigned */
1368 }
1369
1370 static void acpi_bus_get_power_flags(struct acpi_device *device)
1371 {
1372         u32 i;
1373
1374         /* Presence of _PS0|_PR0 indicates 'power manageable' */
1375         if (!acpi_has_method(device->handle, "_PS0") &&
1376             !acpi_has_method(device->handle, "_PR0"))
1377                 return;
1378
1379         device->flags.power_manageable = 1;
1380
1381         /*
1382          * Power Management Flags
1383          */
1384         if (acpi_has_method(device->handle, "_PSC"))
1385                 device->power.flags.explicit_get = 1;
1386         if (acpi_has_method(device->handle, "_IRC"))
1387                 device->power.flags.inrush_current = 1;
1388
1389         /*
1390          * Enumerate supported power management states
1391          */
1392         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
1393                 acpi_bus_init_power_state(device, i);
1394
1395         INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
1396
1397         /* Set defaults for D0 and D3 states (always valid) */
1398         device->power.states[ACPI_STATE_D0].flags.valid = 1;
1399         device->power.states[ACPI_STATE_D0].power = 100;
1400         device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
1401         device->power.states[ACPI_STATE_D3_COLD].power = 0;
1402
1403         /* Set D3cold's explicit_set flag if _PS3 exists. */
1404         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
1405                 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
1406
1407         /* Presence of _PS3 or _PRx means we can put the device into D3 cold */
1408         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
1409                         device->power.flags.power_resources)
1410                 device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
1411
1412         if (acpi_bus_init_power(device)) {
1413                 acpi_free_power_resources_lists(device);
1414                 device->flags.power_manageable = 0;
1415         }
1416 }
1417
1418 static void acpi_bus_get_flags(struct acpi_device *device)
1419 {
1420         /* Presence of _STA indicates 'dynamic_status' */
1421         if (acpi_has_method(device->handle, "_STA"))
1422                 device->flags.dynamic_status = 1;
1423
1424         /* Presence of _RMV indicates 'removable' */
1425         if (acpi_has_method(device->handle, "_RMV"))
1426                 device->flags.removable = 1;
1427
1428         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1429         if (acpi_has_method(device->handle, "_EJD") ||
1430             acpi_has_method(device->handle, "_EJ0"))
1431                 device->flags.ejectable = 1;
1432 }
1433
1434 static void acpi_device_get_busid(struct acpi_device *device)
1435 {
1436         char bus_id[5] = { '?', 0 };
1437         struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1438         int i = 0;
1439
1440         /*
1441          * Bus ID
1442          * ------
1443          * The device's Bus ID is simply the object name.
1444          * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1445          */
1446         if (ACPI_IS_ROOT_DEVICE(device)) {
1447                 strcpy(device->pnp.bus_id, "ACPI");
1448                 return;
1449         }
1450
1451         switch (device->device_type) {
1452         case ACPI_BUS_TYPE_POWER_BUTTON:
1453                 strcpy(device->pnp.bus_id, "PWRF");
1454                 break;
1455         case ACPI_BUS_TYPE_SLEEP_BUTTON:
1456                 strcpy(device->pnp.bus_id, "SLPF");
1457                 break;
1458         default:
1459                 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
1460                 /* Clean up trailing underscores (if any) */
1461                 for (i = 3; i > 1; i--) {
1462                         if (bus_id[i] == '_')
1463                                 bus_id[i] = '\0';
1464                         else
1465                                 break;
1466                 }
1467                 strcpy(device->pnp.bus_id, bus_id);
1468                 break;
1469         }
1470 }
1471
1472 /*
1473  * acpi_ata_match - see if an acpi object is an ATA device
1474  *
1475  * If an acpi object has one of the ACPI ATA methods defined,
1476  * then we can safely call it an ATA device.
1477  */
1478 bool acpi_ata_match(acpi_handle handle)
1479 {
1480         return acpi_has_method(handle, "_GTF") ||
1481                acpi_has_method(handle, "_GTM") ||
1482                acpi_has_method(handle, "_STM") ||
1483                acpi_has_method(handle, "_SDD");
1484 }
1485
1486 /*
1487  * acpi_bay_match - see if an acpi object is an ejectable driver bay
1488  *
1489  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1490  * then we can safely call it an ejectable drive bay
1491  */
1492 bool acpi_bay_match(acpi_handle handle)
1493 {
1494         acpi_handle phandle;
1495
1496         if (!acpi_has_method(handle, "_EJ0"))
1497                 return false;
1498         if (acpi_ata_match(handle))
1499                 return true;
1500         if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1501                 return false;
1502
1503         return acpi_ata_match(phandle);
1504 }
1505
1506 /*
1507  * acpi_dock_match - see if an acpi object has a _DCK method
1508  */
1509 bool acpi_dock_match(acpi_handle handle)
1510 {
1511         return acpi_has_method(handle, "_DCK");
1512 }
1513
1514 const char *acpi_device_hid(struct acpi_device *device)
1515 {
1516         struct acpi_hardware_id *hid;
1517
1518         if (list_empty(&device->pnp.ids))
1519                 return dummy_hid;
1520
1521         hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1522         return hid->id;
1523 }
1524 EXPORT_SYMBOL(acpi_device_hid);
1525
1526 static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
1527 {
1528         struct acpi_hardware_id *id;
1529
1530         id = kmalloc(sizeof(*id), GFP_KERNEL);
1531         if (!id)
1532                 return;
1533
1534         id->id = kstrdup(dev_id, GFP_KERNEL);
1535         if (!id->id) {
1536                 kfree(id);
1537                 return;
1538         }
1539
1540         list_add_tail(&id->list, &pnp->ids);
1541         pnp->type.hardware_id = 1;
1542 }
1543
1544 /*
1545  * Old IBM workstations have a DSDT bug wherein the SMBus object
1546  * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1547  * prefix.  Work around this.
1548  */
1549 static bool acpi_ibm_smbus_match(acpi_handle handle)
1550 {
1551         char node_name[ACPI_PATH_SEGMENT_LENGTH];
1552         struct acpi_buffer path = { sizeof(node_name), node_name };
1553
1554         if (!dmi_name_in_vendors("IBM"))
1555                 return false;
1556
1557         /* Look for SMBS object */
1558         if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1559             strcmp("SMBS", path.pointer))
1560                 return false;
1561
1562         /* Does it have the necessary (but misnamed) methods? */
1563         if (acpi_has_method(handle, "SBI") &&
1564             acpi_has_method(handle, "SBR") &&
1565             acpi_has_method(handle, "SBW"))
1566                 return true;
1567
1568         return false;
1569 }
1570
1571 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
1572                                 int device_type)
1573 {
1574         acpi_status status;
1575         struct acpi_device_info *info;
1576         struct acpi_pnp_device_id_list *cid_list;
1577         int i;
1578
1579         switch (device_type) {
1580         case ACPI_BUS_TYPE_DEVICE:
1581                 if (handle == ACPI_ROOT_OBJECT) {
1582                         acpi_add_id(pnp, ACPI_SYSTEM_HID);
1583                         break;
1584                 }
1585
1586                 status = acpi_get_object_info(handle, &info);
1587                 if (ACPI_FAILURE(status)) {
1588                         pr_err(PREFIX "%s: Error reading device info\n",
1589                                         __func__);
1590                         return;
1591                 }
1592
1593                 if (info->valid & ACPI_VALID_HID)
1594                         acpi_add_id(pnp, info->hardware_id.string);
1595                 if (info->valid & ACPI_VALID_CID) {
1596                         cid_list = &info->compatible_id_list;
1597                         for (i = 0; i < cid_list->count; i++)
1598                                 acpi_add_id(pnp, cid_list->ids[i].string);
1599                 }
1600                 if (info->valid & ACPI_VALID_ADR) {
1601                         pnp->bus_address = info->address;
1602                         pnp->type.bus_address = 1;
1603                 }
1604                 if (info->valid & ACPI_VALID_UID)
1605                         pnp->unique_id = kstrdup(info->unique_id.string,
1606                                                         GFP_KERNEL);
1607
1608                 kfree(info);
1609
1610                 /*
1611                  * Some devices don't reliably have _HIDs & _CIDs, so add
1612                  * synthetic HIDs to make sure drivers can find them.
1613                  */
1614                 if (acpi_is_video_device(handle))
1615                         acpi_add_id(pnp, ACPI_VIDEO_HID);
1616                 else if (acpi_bay_match(handle))
1617                         acpi_add_id(pnp, ACPI_BAY_HID);
1618                 else if (acpi_dock_match(handle))
1619                         acpi_add_id(pnp, ACPI_DOCK_HID);
1620                 else if (acpi_ibm_smbus_match(handle))
1621                         acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
1622                 else if (list_empty(&pnp->ids) && handle == ACPI_ROOT_OBJECT) {
1623                         acpi_add_id(pnp, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
1624                         strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
1625                         strcpy(pnp->device_class, ACPI_BUS_CLASS);
1626                 }
1627
1628                 break;
1629         case ACPI_BUS_TYPE_POWER:
1630                 acpi_add_id(pnp, ACPI_POWER_HID);
1631                 break;
1632         case ACPI_BUS_TYPE_PROCESSOR:
1633                 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
1634                 break;
1635         case ACPI_BUS_TYPE_THERMAL:
1636                 acpi_add_id(pnp, ACPI_THERMAL_HID);
1637                 break;
1638         case ACPI_BUS_TYPE_POWER_BUTTON:
1639                 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
1640                 break;
1641         case ACPI_BUS_TYPE_SLEEP_BUTTON:
1642                 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
1643                 break;
1644         }
1645 }
1646
1647 void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
1648 {
1649         struct acpi_hardware_id *id, *tmp;
1650
1651         list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
1652                 kfree(id->id);
1653                 kfree(id);
1654         }
1655         kfree(pnp->unique_id);
1656 }
1657
1658 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
1659                              int type, unsigned long long sta)
1660 {
1661         INIT_LIST_HEAD(&device->pnp.ids);
1662         device->device_type = type;
1663         device->handle = handle;
1664         device->parent = acpi_bus_get_parent(handle);
1665         STRUCT_TO_INT(device->status) = sta;
1666         acpi_device_get_busid(device);
1667         acpi_set_pnp_ids(handle, &device->pnp, type);
1668         acpi_bus_get_flags(device);
1669         device->flags.match_driver = false;
1670         device_initialize(&device->dev);
1671         dev_set_uevent_suppress(&device->dev, true);
1672 }
1673
1674 void acpi_device_add_finalize(struct acpi_device *device)
1675 {
1676         dev_set_uevent_suppress(&device->dev, false);
1677         kobject_uevent(&device->dev.kobj, KOBJ_ADD);
1678 }
1679
1680 static int acpi_add_single_object(struct acpi_device **child,
1681                                   acpi_handle handle, int type,
1682                                   unsigned long long sta)
1683 {
1684         int result;
1685         struct acpi_device *device;
1686         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1687
1688         device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1689         if (!device) {
1690                 printk(KERN_ERR PREFIX "Memory allocation error\n");
1691                 return -ENOMEM;
1692         }
1693
1694         acpi_init_device_object(device, handle, type, sta);
1695         acpi_bus_get_power_flags(device);
1696         acpi_bus_get_wakeup_device_flags(device);
1697
1698         result = acpi_device_add(device, acpi_device_release);
1699         if (result) {
1700                 acpi_device_release(&device->dev);
1701                 return result;
1702         }
1703
1704         acpi_power_add_remove_device(device, true);
1705         acpi_device_add_finalize(device);
1706         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1707         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
1708                 dev_name(&device->dev), (char *) buffer.pointer,
1709                 device->parent ? dev_name(&device->parent->dev) : "(null)"));
1710         kfree(buffer.pointer);
1711         *child = device;
1712         return 0;
1713 }
1714
1715 static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1716                                     unsigned long long *sta)
1717 {
1718         acpi_status status;
1719         acpi_object_type acpi_type;
1720
1721         status = acpi_get_type(handle, &acpi_type);
1722         if (ACPI_FAILURE(status))
1723                 return -ENODEV;
1724
1725         switch (acpi_type) {
1726         case ACPI_TYPE_ANY:             /* for ACPI_ROOT_OBJECT */
1727         case ACPI_TYPE_DEVICE:
1728                 *type = ACPI_BUS_TYPE_DEVICE;
1729                 status = acpi_bus_get_status_handle(handle, sta);
1730                 if (ACPI_FAILURE(status))
1731                         return -ENODEV;
1732                 break;
1733         case ACPI_TYPE_PROCESSOR:
1734                 *type = ACPI_BUS_TYPE_PROCESSOR;
1735                 status = acpi_bus_get_status_handle(handle, sta);
1736                 if (ACPI_FAILURE(status))
1737                         return -ENODEV;
1738                 break;
1739         case ACPI_TYPE_THERMAL:
1740                 *type = ACPI_BUS_TYPE_THERMAL;
1741                 *sta = ACPI_STA_DEFAULT;
1742                 break;
1743         case ACPI_TYPE_POWER:
1744                 *type = ACPI_BUS_TYPE_POWER;
1745                 *sta = ACPI_STA_DEFAULT;
1746                 break;
1747         default:
1748                 return -ENODEV;
1749         }
1750
1751         return 0;
1752 }
1753
1754 static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
1755                                        char *idstr,
1756                                        const struct acpi_device_id **matchid)
1757 {
1758         const struct acpi_device_id *devid;
1759
1760         for (devid = handler->ids; devid->id[0]; devid++)
1761                 if (!strcmp((char *)devid->id, idstr)) {
1762                         if (matchid)
1763                                 *matchid = devid;
1764
1765                         return true;
1766                 }
1767
1768         return false;
1769 }
1770
1771 static struct acpi_scan_handler *acpi_scan_match_handler(char *idstr,
1772                                         const struct acpi_device_id **matchid)
1773 {
1774         struct acpi_scan_handler *handler;
1775
1776         list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
1777                 if (acpi_scan_handler_matching(handler, idstr, matchid))
1778                         return handler;
1779
1780         return NULL;
1781 }
1782
1783 void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
1784 {
1785         if (!!hotplug->enabled == !!val)
1786                 return;
1787
1788         mutex_lock(&acpi_scan_lock);
1789
1790         hotplug->enabled = val;
1791
1792         mutex_unlock(&acpi_scan_lock);
1793 }
1794
1795 static void acpi_scan_init_hotplug(acpi_handle handle, int type)
1796 {
1797         struct acpi_device_pnp pnp = {};
1798         struct acpi_hardware_id *hwid;
1799         struct acpi_scan_handler *handler;
1800
1801         INIT_LIST_HEAD(&pnp.ids);
1802         acpi_set_pnp_ids(handle, &pnp, type);
1803
1804         if (!pnp.type.hardware_id)
1805                 goto out;
1806
1807         /*
1808          * This relies on the fact that acpi_install_notify_handler() will not
1809          * install the same notify handler routine twice for the same handle.
1810          */
1811         list_for_each_entry(hwid, &pnp.ids, list) {
1812                 handler = acpi_scan_match_handler(hwid->id, NULL);
1813                 if (handler) {
1814                         acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1815                                         acpi_hotplug_notify_cb, handler);
1816                         break;
1817                 }
1818         }
1819
1820 out:
1821         acpi_free_pnp_ids(&pnp);
1822 }
1823
1824 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
1825                                       void *not_used, void **return_value)
1826 {
1827         struct acpi_device *device = NULL;
1828         int type;
1829         unsigned long long sta;
1830         int result;
1831
1832         acpi_bus_get_device(handle, &device);
1833         if (device)
1834                 goto out;
1835
1836         result = acpi_bus_type_and_status(handle, &type, &sta);
1837         if (result)
1838                 return AE_OK;
1839
1840         if (type == ACPI_BUS_TYPE_POWER) {
1841                 acpi_add_power_resource(handle);
1842                 return AE_OK;
1843         }
1844
1845         acpi_scan_init_hotplug(handle, type);
1846
1847         if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
1848             !(sta & ACPI_STA_DEVICE_FUNCTIONING)) {
1849                 struct acpi_device_wakeup wakeup;
1850
1851                 if (acpi_has_method(handle, "_PRW")) {
1852                         acpi_bus_extract_wakeup_device_power_package(handle,
1853                                                                      &wakeup);
1854                         acpi_power_resources_list_free(&wakeup.resources);
1855                 }
1856                 return AE_CTRL_DEPTH;
1857         }
1858
1859         acpi_add_single_object(&device, handle, type, sta);
1860         if (!device)
1861                 return AE_CTRL_DEPTH;
1862
1863  out:
1864         if (!*return_value)
1865                 *return_value = device;
1866
1867         return AE_OK;
1868 }
1869
1870 static int acpi_scan_attach_handler(struct acpi_device *device)
1871 {
1872         struct acpi_hardware_id *hwid;
1873         int ret = 0;
1874
1875         list_for_each_entry(hwid, &device->pnp.ids, list) {
1876                 const struct acpi_device_id *devid;
1877                 struct acpi_scan_handler *handler;
1878
1879                 handler = acpi_scan_match_handler(hwid->id, &devid);
1880                 if (handler) {
1881                         ret = handler->attach(device, devid);
1882                         if (ret > 0) {
1883                                 device->handler = handler;
1884                                 break;
1885                         } else if (ret < 0) {
1886                                 break;
1887                         }
1888                 }
1889         }
1890         return ret;
1891 }
1892
1893 static acpi_status acpi_bus_device_attach(acpi_handle handle, u32 lvl_not_used,
1894                                           void *not_used, void **ret_not_used)
1895 {
1896         struct acpi_device *device;
1897         unsigned long long sta_not_used;
1898         int ret;
1899
1900         /*
1901          * Ignore errors ignored by acpi_bus_check_add() to avoid terminating
1902          * namespace walks prematurely.
1903          */
1904         if (acpi_bus_type_and_status(handle, &ret, &sta_not_used))
1905                 return AE_OK;
1906
1907         if (acpi_bus_get_device(handle, &device))
1908                 return AE_CTRL_DEPTH;
1909
1910         if (device->handler)
1911                 return AE_OK;
1912
1913         ret = acpi_scan_attach_handler(device);
1914         if (ret < 0)
1915                 return AE_CTRL_DEPTH;
1916
1917         device->flags.match_driver = true;
1918         if (ret > 0)
1919                 return AE_OK;
1920
1921         ret = device_attach(&device->dev);
1922         return ret >= 0 ? AE_OK : AE_CTRL_DEPTH;
1923 }
1924
1925 /**
1926  * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
1927  * @handle: Root of the namespace scope to scan.
1928  *
1929  * Scan a given ACPI tree (probably recently hot-plugged) and create and add
1930  * found devices.
1931  *
1932  * If no devices were found, -ENODEV is returned, but it does not mean that
1933  * there has been a real error.  There just have been no suitable ACPI objects
1934  * in the table trunk from which the kernel could create a device and add an
1935  * appropriate driver.
1936  *
1937  * Must be called under acpi_scan_lock.
1938  */
1939 int acpi_bus_scan(acpi_handle handle)
1940 {
1941         void *device = NULL;
1942         int error = 0;
1943
1944         if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
1945                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
1946                                     acpi_bus_check_add, NULL, NULL, &device);
1947
1948         if (!device)
1949                 error = -ENODEV;
1950         else if (ACPI_SUCCESS(acpi_bus_device_attach(handle, 0, NULL, NULL)))
1951                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
1952                                     acpi_bus_device_attach, NULL, NULL, NULL);
1953
1954         return error;
1955 }
1956 EXPORT_SYMBOL(acpi_bus_scan);
1957
1958 static acpi_status acpi_bus_device_detach(acpi_handle handle, u32 lvl_not_used,
1959                                           void *not_used, void **ret_not_used)
1960 {
1961         struct acpi_device *device = NULL;
1962
1963         if (!acpi_bus_get_device(handle, &device)) {
1964                 struct acpi_scan_handler *dev_handler = device->handler;
1965
1966                 if (dev_handler) {
1967                         if (dev_handler->detach)
1968                                 dev_handler->detach(device);
1969
1970                         device->handler = NULL;
1971                 } else {
1972                         device_release_driver(&device->dev);
1973                 }
1974         }
1975         return AE_OK;
1976 }
1977
1978 static acpi_status acpi_bus_remove(acpi_handle handle, u32 lvl_not_used,
1979                                    void *not_used, void **ret_not_used)
1980 {
1981         struct acpi_device *device = NULL;
1982
1983         if (!acpi_bus_get_device(handle, &device))
1984                 acpi_device_unregister(device);
1985
1986         return AE_OK;
1987 }
1988
1989 /**
1990  * acpi_bus_trim - Remove ACPI device node and all of its descendants
1991  * @start: Root of the ACPI device nodes subtree to remove.
1992  *
1993  * Must be called under acpi_scan_lock.
1994  */
1995 void acpi_bus_trim(struct acpi_device *start)
1996 {
1997         /*
1998          * Execute acpi_bus_device_detach() as a post-order callback to detach
1999          * all ACPI drivers from the device nodes being removed.
2000          */
2001         acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
2002                             acpi_bus_device_detach, NULL, NULL);
2003         acpi_bus_device_detach(start->handle, 0, NULL, NULL);
2004         /*
2005          * Execute acpi_bus_remove() as a post-order callback to remove device
2006          * nodes in the given namespace scope.
2007          */
2008         acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
2009                             acpi_bus_remove, NULL, NULL);
2010         acpi_bus_remove(start->handle, 0, NULL, NULL);
2011 }
2012 EXPORT_SYMBOL_GPL(acpi_bus_trim);
2013
2014 static int acpi_bus_scan_fixed(void)
2015 {
2016         int result = 0;
2017
2018         /*
2019          * Enumerate all fixed-feature devices.
2020          */
2021         if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
2022                 struct acpi_device *device = NULL;
2023
2024                 result = acpi_add_single_object(&device, NULL,
2025                                                 ACPI_BUS_TYPE_POWER_BUTTON,
2026                                                 ACPI_STA_DEFAULT);
2027                 if (result)
2028                         return result;
2029
2030                 result = device_attach(&device->dev);
2031                 if (result < 0)
2032                         return result;
2033
2034                 device_init_wakeup(&device->dev, true);
2035         }
2036
2037         if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
2038                 struct acpi_device *device = NULL;
2039
2040                 result = acpi_add_single_object(&device, NULL,
2041                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
2042                                                 ACPI_STA_DEFAULT);
2043                 if (result)
2044                         return result;
2045
2046                 result = device_attach(&device->dev);
2047         }
2048
2049         return result < 0 ? result : 0;
2050 }
2051
2052 int __init acpi_scan_init(void)
2053 {
2054         int result;
2055
2056         result = bus_register(&acpi_bus_type);
2057         if (result) {
2058                 /* We don't want to quit even if we failed to add suspend/resume */
2059                 printk(KERN_ERR PREFIX "Could not register bus type\n");
2060         }
2061
2062         acpi_pci_root_init();
2063         acpi_pci_link_init();
2064         acpi_processor_init();
2065         acpi_platform_init();
2066         acpi_lpss_init();
2067         acpi_cmos_rtc_init();
2068         acpi_container_init();
2069         acpi_memory_hotplug_init();
2070         acpi_dock_init();
2071
2072         mutex_lock(&acpi_scan_lock);
2073         /*
2074          * Enumerate devices in the ACPI namespace.
2075          */
2076         result = acpi_bus_scan(ACPI_ROOT_OBJECT);
2077         if (result)
2078                 goto out;
2079
2080         result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
2081         if (result)
2082                 goto out;
2083
2084         result = acpi_bus_scan_fixed();
2085         if (result) {
2086                 acpi_device_unregister(acpi_root);
2087                 goto out;
2088         }
2089
2090         acpi_update_all_gpes();
2091
2092         acpi_pci_root_hp_init();
2093
2094  out:
2095         mutex_unlock(&acpi_scan_lock);
2096         return result;
2097 }