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