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