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 <asm/pgtable.h>
  16
  17 #include "internal.h"
  18
  19 #define _COMPONENT              ACPI_BUS_COMPONENT
  20 ACPI_MODULE_NAME("scan");
  21 extern struct acpi_device *acpi_root;
  22
  23 #define ACPI_BUS_CLASS                  "system_bus"
  24 #define ACPI_BUS_HID                    "LNXSYBUS"
  25 #define ACPI_BUS_DEVICE_NAME            "System Bus"
  26
  27 #define ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)
  28
  29 #define INVALID_ACPI_HANDLE     ((acpi_handle)empty_zero_page)
  30
  31 /*
  32  * If set, devices will be hot-removed even if they cannot be put offline
  33  * gracefully (from the kernel's standpoint).
  34  */
  35 bool acpi_force_hot_remove;
  36
  37 static const char *dummy_hid = "device";
  38
  39 static LIST_HEAD(acpi_dep_list);
  40 static DEFINE_MUTEX(acpi_dep_list_lock);
  41 static LIST_HEAD(acpi_bus_id_list);
  42 static DEFINE_MUTEX(acpi_scan_lock);
  43 static LIST_HEAD(acpi_scan_handlers_list);
  44 DEFINE_MUTEX(acpi_device_lock);
  45 LIST_HEAD(acpi_wakeup_device_list);
  46 static DEFINE_MUTEX(acpi_hp_context_lock);
  47
  48 struct acpi_dep_data {
  49         struct list_head node;
  50         acpi_handle master;
  51         acpi_handle slave;
  52 };
  53
  54 struct acpi_device_bus_id{
  55         char bus_id[15];
  56         unsigned int instance_no;
  57         struct list_head node;
  58 };
  59
  60 void acpi_scan_lock_acquire(void)
  61 {
  62         mutex_lock(&acpi_scan_lock);
  63 }
  64 EXPORT_SYMBOL_GPL(acpi_scan_lock_acquire);
  65
  66 void acpi_scan_lock_release(void)
  67 {
  68         mutex_unlock(&acpi_scan_lock);
  69 }
  70 EXPORT_SYMBOL_GPL(acpi_scan_lock_release);
  71
  72 void acpi_lock_hp_context(void)
  73 {
  74         mutex_lock(&acpi_hp_context_lock);
  75 }
  76
  77 void acpi_unlock_hp_context(void)
  78 {
  79         mutex_unlock(&acpi_hp_context_lock);
  80 }
  81
  82 void acpi_initialize_hp_context(struct acpi_device *adev,
  83                                 struct acpi_hotplug_context *hp,
  84                                 int (*notify)(struct acpi_device *, u32),
  85                                 void (*uevent)(struct acpi_device *, u32))
  86 {
  87         acpi_lock_hp_context();
  88         hp->notify = notify;
  89         hp->uevent = uevent;
  90         acpi_set_hp_context(adev, hp);
  91         acpi_unlock_hp_context();
  92 }
  93 EXPORT_SYMBOL_GPL(acpi_initialize_hp_context);
  94
  95 int acpi_scan_add_handler(struct acpi_scan_handler *handler)
  96 {
  97         if (!handler)
  98                 return -EINVAL;
  99
 100         list_add_tail(&handler->list_node, &acpi_scan_handlers_list);
 101         return 0;
 102 }
 103
 104 int acpi_scan_add_handler_with_hotplug(struct acpi_scan_handler *handler,
 105                                        const char *hotplug_profile_name)
 106 {
 107         int error;
 108
 109         error = acpi_scan_add_handler(handler);
 110         if (error)
 111                 return error;
 112
 113         acpi_sysfs_add_hotplug_profile(&handler->hotplug, hotplug_profile_name);
 114         return 0;
 115 }
 116
 117 /**
 118  * create_pnp_modalias - Create hid/cid(s) string for modalias and uevent
 119  * @acpi_dev: ACPI device object.
 120  * @modalias: Buffer to print into.
 121  * @size: Size of the buffer.
 122  *
 123  * Creates hid/cid(s) string needed for modalias and uevent
 124  * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
 125  * char *modalias: "acpi:IBM0001:ACPI0001"
 126  * Return: 0: no _HID and no _CID
 127  *         -EINVAL: output error
 128  *         -ENOMEM: output is truncated
 129 */
 130 static int create_pnp_modalias(struct acpi_device *acpi_dev, char *modalias,
 131                                int size)
 132 {
 133         int len;
 134         int count;
 135         struct acpi_hardware_id *id;
 136
 137         /*
 138          * Since we skip PRP0001 from the modalias below, 0 should be returned
 139          * if PRP0001 is the only ACPI/PNP ID in the device's list.
 140          */
 141         count = 0;
 142         list_for_each_entry(id, &acpi_dev->pnp.ids, list)
 143                 if (strcmp(id->id, "PRP0001"))
 144                         count++;
 145
 146         if (!count)
 147                 return 0;
 148
 149         len = snprintf(modalias, size, "acpi:");
 150         if (len <= 0)
 151                 return len;
 152
 153         size -= len;
 154
 155         list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
 156                 if (!strcmp(id->id, "PRP0001"))
 157                         continue;
 158
 159                 count = snprintf(&modalias[len], size, "%s:", id->id);
 160                 if (count < 0)
 161                         return -EINVAL;
 162
 163                 if (count >= size)
 164                         return -ENOMEM;
 165
 166                 len += count;
 167                 size -= count;
 168         }
 169         modalias[len] = '\0';
 170         return len;
 171 }
 172
 173 /**
 174  * create_of_modalias - Creates DT compatible string for modalias and uevent
 175  * @acpi_dev: ACPI device object.
 176  * @modalias: Buffer to print into.
 177  * @size: Size of the buffer.
 178  *
 179  * Expose DT compatible modalias as of:NnameTCcompatible.  This function should
 180  * only be called for devices having PRP0001 in their list of ACPI/PNP IDs.
 181  */
 182 static int create_of_modalias(struct acpi_device *acpi_dev, char *modalias,
 183                               int size)
 184 {
 185         struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER };
 186         const union acpi_object *of_compatible, *obj;
 187         int len, count;
 188         int i, nval;
 189         char *c;
 190
 191         acpi_get_name(acpi_dev->handle, ACPI_SINGLE_NAME, &buf);
 192         /* DT strings are all in lower case */
 193         for (c = buf.pointer; *c != '\0'; c++)
 194                 *c = tolower(*c);
 195
 196         len = snprintf(modalias, size, "of:N%sT", (char *)buf.pointer);
 197         ACPI_FREE(buf.pointer);
 198
 199         if (len <= 0)
 200                 return len;
 201
 202         of_compatible = acpi_dev->data.of_compatible;
 203         if (of_compatible->type == ACPI_TYPE_PACKAGE) {
 204                 nval = of_compatible->package.count;
 205                 obj = of_compatible->package.elements;
 206         } else { /* Must be ACPI_TYPE_STRING. */
 207                 nval = 1;
 208                 obj = of_compatible;
 209         }
 210         for (i = 0; i < nval; i++, obj++) {
 211                 count = snprintf(&modalias[len], size, "C%s",
 212                                  obj->string.pointer);
 213                 if (count < 0)
 214                         return -EINVAL;
 215
 216                 if (count >= size)
 217                         return -ENOMEM;
 218
 219                 len += count;
 220                 size -= count;
 221         }
 222         modalias[len] = '\0';
 223         return len;
 224 }
 225
 226 /*
 227  * acpi_companion_match() - Can we match via ACPI companion device
 228  * @dev: Device in question
 229  *
 230  * Check if the given device has an ACPI companion and if that companion has
 231  * a valid list of PNP IDs, and if the device is the first (primary) physical
 232  * device associated with it.  Return the companion pointer if that's the case
 233  * or NULL otherwise.
 234  *
 235  * If multiple physical devices are attached to a single ACPI companion, we need
 236  * to be careful.  The usage scenario for this kind of relationship is that all
 237  * of the physical devices in question use resources provided by the ACPI
 238  * companion.  A typical case is an MFD device where all the sub-devices share
 239  * the parent's ACPI companion.  In such cases we can only allow the primary
 240  * (first) physical device to be matched with the help of the companion's PNP
 241  * IDs.
 242  *
 243  * Additional physical devices sharing the ACPI companion can still use
 244  * resources available from it but they will be matched normally using functions
 245  * provided by their bus types (and analogously for their modalias).
 246  */
 247 static struct acpi_device *acpi_companion_match(const struct device *dev)
 248 {
 249         struct acpi_device *adev;
 250         struct mutex *physical_node_lock;
 251
 252         adev = ACPI_COMPANION(dev);
 253         if (!adev)
 254                 return NULL;
 255
 256         if (list_empty(&adev->pnp.ids))
 257                 return NULL;
 258
 259         physical_node_lock = &adev->physical_node_lock;
 260         mutex_lock(physical_node_lock);
 261         if (list_empty(&adev->physical_node_list)) {
 262                 adev = NULL;
 263         } else {
 264                 const struct acpi_device_physical_node *node;
 265
 266                 node = list_first_entry(&adev->physical_node_list,
 267                                         struct acpi_device_physical_node, node);
 268                 if (node->dev != dev)
 269                         adev = NULL;
 270         }
 271         mutex_unlock(physical_node_lock);
 272
 273         return adev;
 274 }
 275
 276 static int __acpi_device_uevent_modalias(struct acpi_device *adev,
 277                                          struct kobj_uevent_env *env)
 278 {
 279         int len;
 280
 281         if (!adev)
 282                 return -ENODEV;
 283
 284         if (list_empty(&adev->pnp.ids))
 285                 return 0;
 286
 287         if (add_uevent_var(env, "MODALIAS="))
 288                 return -ENOMEM;
 289
 290         len = create_pnp_modalias(adev, &env->buf[env->buflen - 1],
 291                                   sizeof(env->buf) - env->buflen);
 292         if (len < 0)
 293                 return len;
 294
 295         env->buflen += len;
 296         if (!adev->data.of_compatible)
 297                 return 0;
 298
 299         if (len > 0 && add_uevent_var(env, "MODALIAS="))
 300                 return -ENOMEM;
 301
 302         len = create_of_modalias(adev, &env->buf[env->buflen - 1],
 303                                  sizeof(env->buf) - env->buflen);
 304         if (len < 0)
 305                 return len;
 306
 307         env->buflen += len;
 308
 309         return 0;
 310 }
 311
 312 /*
 313  * Creates uevent modalias field for ACPI enumerated devices.
 314  * Because the other buses does not support ACPI HIDs & CIDs.
 315  * e.g. for a device with hid:IBM0001 and cid:ACPI0001 you get:
 316  * "acpi:IBM0001:ACPI0001"
 317  */
 318 int acpi_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env)
 319 {
 320         return __acpi_device_uevent_modalias(acpi_companion_match(dev), env);
 321 }
 322 EXPORT_SYMBOL_GPL(acpi_device_uevent_modalias);
 323
 324 static int __acpi_device_modalias(struct acpi_device *adev, char *buf, int size)
 325 {
 326         int len, count;
 327
 328         if (!adev)
 329                 return -ENODEV;
 330
 331         if (list_empty(&adev->pnp.ids))
 332                 return 0;
 333
 334         len = create_pnp_modalias(adev, buf, size - 1);
 335         if (len < 0) {
 336                 return len;
 337         } else if (len > 0) {
 338                 buf[len++] = '\n';
 339                 size -= len;
 340         }
 341         if (!adev->data.of_compatible)
 342                 return len;
 343
 344         count = create_of_modalias(adev, buf + len, size - 1);
 345         if (count < 0) {
 346                 return count;
 347         } else if (count > 0) {
 348                 len += count;
 349                 buf[len++] = '\n';
 350         }
 351
 352         return len;
 353 }
 354
 355 /*
 356  * Creates modalias sysfs attribute for ACPI enumerated devices.
 357  * Because the other buses does not support ACPI HIDs & CIDs.
 358  * e.g. for a device with hid:IBM0001 and cid:ACPI0001 you get:
 359  * "acpi:IBM0001:ACPI0001"
 360  */
 361 int acpi_device_modalias(struct device *dev, char *buf, int size)
 362 {
 363         return __acpi_device_modalias(acpi_companion_match(dev), buf, size);
 364 }
 365 EXPORT_SYMBOL_GPL(acpi_device_modalias);
 366
 367 static ssize_t
 368 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
 369         return __acpi_device_modalias(to_acpi_device(dev), buf, 1024);
 370 }
 371 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
 372
 373 bool acpi_scan_is_offline(struct acpi_device *adev, bool uevent)
 374 {
 375         struct acpi_device_physical_node *pn;
 376         bool offline = true;
 377
 378         mutex_lock(&adev->physical_node_lock);
 379
 380         list_for_each_entry(pn, &adev->physical_node_list, node)
 381                 if (device_supports_offline(pn->dev) && !pn->dev->offline) {
 382                         if (uevent)
 383                                 kobject_uevent(&pn->dev->kobj, KOBJ_CHANGE);
 384
 385                         offline = false;
 386                         break;
 387                 }
 388
 389         mutex_unlock(&adev->physical_node_lock);
 390         return offline;
 391 }
 392
 393 static acpi_status acpi_bus_offline(acpi_handle handle, u32 lvl, void *data,
 394                                     void **ret_p)
 395 {
 396         struct acpi_device *device = NULL;
 397         struct acpi_device_physical_node *pn;
 398         bool second_pass = (bool)data;
 399         acpi_status status = AE_OK;
 400
 401         if (acpi_bus_get_device(handle, &device))
 402                 return AE_OK;
 403
 404         if (device->handler && !device->handler->hotplug.enabled) {
 405                 *ret_p = &device->dev;
 406                 return AE_SUPPORT;
 407         }
 408
 409         mutex_lock(&device->physical_node_lock);
 410
 411         list_for_each_entry(pn, &device->physical_node_list, node) {
 412                 int ret;
 413
 414                 if (second_pass) {
 415                         /* Skip devices offlined by the first pass. */
 416                         if (pn->put_online)
 417                                 continue;
 418                 } else {
 419                         pn->put_online = false;
 420                 }
 421                 ret = device_offline(pn->dev);
 422                 if (acpi_force_hot_remove)
 423                         continue;
 424
 425                 if (ret >= 0) {
 426                         pn->put_online = !ret;
 427                 } else {
 428                         *ret_p = pn->dev;
 429                         if (second_pass) {
 430                                 status = AE_ERROR;
 431                                 break;
 432                         }
 433                 }
 434         }
 435
 436         mutex_unlock(&device->physical_node_lock);
 437
 438         return status;
 439 }
 440
 441 static acpi_status acpi_bus_online(acpi_handle handle, u32 lvl, void *data,
 442                                    void **ret_p)
 443 {
 444         struct acpi_device *device = NULL;
 445         struct acpi_device_physical_node *pn;
 446
 447         if (acpi_bus_get_device(handle, &device))
 448                 return AE_OK;
 449
 450         mutex_lock(&device->physical_node_lock);
 451
 452         list_for_each_entry(pn, &device->physical_node_list, node)
 453                 if (pn->put_online) {
 454                         device_online(pn->dev);
 455                         pn->put_online = false;
 456                 }
 457
 458         mutex_unlock(&device->physical_node_lock);
 459
 460         return AE_OK;
 461 }
 462
 463 static int acpi_scan_try_to_offline(struct acpi_device *device)
 464 {
 465         acpi_handle handle = device->handle;
 466         struct device *errdev = NULL;
 467         acpi_status status;
 468
 469         /*
 470          * Carry out two passes here and ignore errors in the first pass,
 471          * because if the devices in question are memory blocks and
 472          * CONFIG_MEMCG is set, one of the blocks may hold data structures
 473          * that the other blocks depend on, but it is not known in advance which
 474          * block holds them.
 475          *
 476          * If the first pass is successful, the second one isn't needed, though.
 477          */
 478         status = acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
 479                                      NULL, acpi_bus_offline, (void *)false,
 480                                      (void **)&errdev);
 481         if (status == AE_SUPPORT) {
 482                 dev_warn(errdev, "Offline disabled.\n");
 483                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
 484                                     acpi_bus_online, NULL, NULL, NULL);
 485                 return -EPERM;
 486         }
 487         acpi_bus_offline(handle, 0, (void *)false, (void **)&errdev);
 488         if (errdev) {
 489                 errdev = NULL;
 490                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
 491                                     NULL, acpi_bus_offline, (void *)true,
 492                                     (void **)&errdev);
 493                 if (!errdev || acpi_force_hot_remove)
 494                         acpi_bus_offline(handle, 0, (void *)true,
 495                                          (void **)&errdev);
 496
 497                 if (errdev && !acpi_force_hot_remove) {
 498                         dev_warn(errdev, "Offline failed.\n");
 499                         acpi_bus_online(handle, 0, NULL, NULL);
 500                         acpi_walk_namespace(ACPI_TYPE_ANY, handle,
 501                                             ACPI_UINT32_MAX, acpi_bus_online,
 502                                             NULL, NULL, NULL);
 503                         return -EBUSY;
 504                 }
 505         }
 506         return 0;
 507 }
 508
 509 static int acpi_scan_hot_remove(struct acpi_device *device)
 510 {
 511         acpi_handle handle = device->handle;
 512         unsigned long long sta;
 513         acpi_status status;
 514
 515         if (device->handler && device->handler->hotplug.demand_offline
 516             && !acpi_force_hot_remove) {
 517                 if (!acpi_scan_is_offline(device, true))
 518                         return -EBUSY;
 519         } else {
 520                 int error = acpi_scan_try_to_offline(device);
 521                 if (error)
 522                         return error;
 523         }
 524
 525         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 526                 "Hot-removing device %s...\n", dev_name(&device->dev)));
 527
 528         acpi_bus_trim(device);
 529
 530         acpi_evaluate_lck(handle, 0);
 531         /*
 532          * TBD: _EJD support.
 533          */
 534         status = acpi_evaluate_ej0(handle);
 535         if (status == AE_NOT_FOUND)
 536                 return -ENODEV;
 537         else if (ACPI_FAILURE(status))
 538                 return -EIO;
 539
 540         /*
 541          * Verify if eject was indeed successful.  If not, log an error
 542          * message.  No need to call _OST since _EJ0 call was made OK.
 543          */
 544         status = acpi_evaluate_integer(handle, "_STA", NULL, &sta);
 545         if (ACPI_FAILURE(status)) {
 546                 acpi_handle_warn(handle,
 547                         "Status check after eject failed (0x%x)\n", status);
 548         } else if (sta & ACPI_STA_DEVICE_ENABLED) {
 549                 acpi_handle_warn(handle,
 550                         "Eject incomplete - status 0x%llx\n", sta);
 551         }
 552
 553         return 0;
 554 }
 555
 556 static int acpi_scan_device_not_present(struct acpi_device *adev)
 557 {
 558         if (!acpi_device_enumerated(adev)) {
 559                 dev_warn(&adev->dev, "Still not present\n");
 560                 return -EALREADY;
 561         }
 562         acpi_bus_trim(adev);
 563         return 0;
 564 }
 565
 566 static int acpi_scan_device_check(struct acpi_device *adev)
 567 {
 568         int error;
 569
 570         acpi_bus_get_status(adev);
 571         if (adev->status.present || adev->status.functional) {
 572                 /*
 573                  * This function is only called for device objects for which
 574                  * matching scan handlers exist.  The only situation in which
 575                  * the scan handler is not attached to this device object yet
 576                  * is when the device has just appeared (either it wasn't
 577                  * present at all before or it was removed and then added
 578                  * again).
 579                  */
 580                 if (adev->handler) {
 581                         dev_warn(&adev->dev, "Already enumerated\n");
 582                         return -EALREADY;
 583                 }
 584                 error = acpi_bus_scan(adev->handle);
 585                 if (error) {
 586                         dev_warn(&adev->dev, "Namespace scan failure\n");
 587                         return error;
 588                 }
 589                 if (!adev->handler) {
 590                         dev_warn(&adev->dev, "Enumeration failure\n");
 591                         error = -ENODEV;
 592                 }
 593         } else {
 594                 error = acpi_scan_device_not_present(adev);
 595         }
 596         return error;
 597 }
 598
 599 static int acpi_scan_bus_check(struct acpi_device *adev)
 600 {
 601         struct acpi_scan_handler *handler = adev->handler;
 602         struct acpi_device *child;
 603         int error;
 604
 605         acpi_bus_get_status(adev);
 606         if (!(adev->status.present || adev->status.functional)) {
 607                 acpi_scan_device_not_present(adev);
 608                 return 0;
 609         }
 610         if (handler && handler->hotplug.scan_dependent)
 611                 return handler->hotplug.scan_dependent(adev);
 612
 613         error = acpi_bus_scan(adev->handle);
 614         if (error) {
 615                 dev_warn(&adev->dev, "Namespace scan failure\n");
 616                 return error;
 617         }
 618         list_for_each_entry(child, &adev->children, node) {
 619                 error = acpi_scan_bus_check(child);
 620                 if (error)
 621                         return error;
 622         }
 623         return 0;
 624 }
 625
 626 static int acpi_generic_hotplug_event(struct acpi_device *adev, u32 type)
 627 {
 628         switch (type) {
 629         case ACPI_NOTIFY_BUS_CHECK:
 630                 return acpi_scan_bus_check(adev);
 631         case ACPI_NOTIFY_DEVICE_CHECK:
 632                 return acpi_scan_device_check(adev);
 633         case ACPI_NOTIFY_EJECT_REQUEST:
 634         case ACPI_OST_EC_OSPM_EJECT:
 635                 if (adev->handler && !adev->handler->hotplug.enabled) {
 636                         dev_info(&adev->dev, "Eject disabled\n");
 637                         return -EPERM;
 638                 }
 639                 acpi_evaluate_ost(adev->handle, ACPI_NOTIFY_EJECT_REQUEST,
 640                                   ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
 641                 return acpi_scan_hot_remove(adev);
 642         }
 643         return -EINVAL;
 644 }
 645
 646 void acpi_device_hotplug(struct acpi_device *adev, u32 src)
 647 {
 648         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE;
 649         int error = -ENODEV;
 650
 651         lock_device_hotplug();
 652         mutex_lock(&acpi_scan_lock);
 653
 654         /*
 655          * The device object's ACPI handle cannot become invalid as long as we
 656          * are holding acpi_scan_lock, but it might have become invalid before
 657          * that lock was acquired.
 658          */
 659         if (adev->handle == INVALID_ACPI_HANDLE)
 660                 goto err_out;
 661
 662         if (adev->flags.is_dock_station) {
 663                 error = dock_notify(adev, src);
 664         } else if (adev->flags.hotplug_notify) {
 665                 error = acpi_generic_hotplug_event(adev, src);
 666                 if (error == -EPERM) {
 667                         ost_code = ACPI_OST_SC_EJECT_NOT_SUPPORTED;
 668                         goto err_out;
 669                 }
 670         } else {
 671                 int (*notify)(struct acpi_device *, u32);
 672
 673                 acpi_lock_hp_context();
 674                 notify = adev->hp ? adev->hp->notify : NULL;
 675                 acpi_unlock_hp_context();
 676                 /*
 677                  * There may be additional notify handlers for device objects
 678                  * without the .event() callback, so ignore them here.
 679                  */
 680                 if (notify)
 681                         error = notify(adev, src);
 682                 else
 683                         goto out;
 684         }
 685         if (!error)
 686                 ost_code = ACPI_OST_SC_SUCCESS;
 687
 688  err_out:
 689         acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
 690
 691  out:
 692         acpi_bus_put_acpi_device(adev);
 693         mutex_unlock(&acpi_scan_lock);
 694         unlock_device_hotplug();
 695 }
 696
 697 static ssize_t real_power_state_show(struct device *dev,
 698                                      struct device_attribute *attr, char *buf)
 699 {
 700         struct acpi_device *adev = to_acpi_device(dev);
 701         int state;
 702         int ret;
 703
 704         ret = acpi_device_get_power(adev, &state);
 705         if (ret)
 706                 return ret;
 707
 708         return sprintf(buf, "%s\n", acpi_power_state_string(state));
 709 }
 710
 711 static DEVICE_ATTR(real_power_state, 0444, real_power_state_show, NULL);
 712
 713 static ssize_t power_state_show(struct device *dev,
 714                                 struct device_attribute *attr, char *buf)
 715 {
 716         struct acpi_device *adev = to_acpi_device(dev);
 717
 718         return sprintf(buf, "%s\n", acpi_power_state_string(adev->power.state));
 719 }
 720
 721 static DEVICE_ATTR(power_state, 0444, power_state_show, NULL);
 722
 723 static ssize_t
 724 acpi_eject_store(struct device *d, struct device_attribute *attr,
 725                 const char *buf, size_t count)
 726 {
 727         struct acpi_device *acpi_device = to_acpi_device(d);
 728         acpi_object_type not_used;
 729         acpi_status status;
 730
 731         if (!count || buf[0] != '1')
 732                 return -EINVAL;
 733
 734         if ((!acpi_device->handler || !acpi_device->handler->hotplug.enabled)
 735             && !acpi_device->driver)
 736                 return -ENODEV;
 737
 738         status = acpi_get_type(acpi_device->handle, &not_used);
 739         if (ACPI_FAILURE(status) || !acpi_device->flags.ejectable)
 740                 return -ENODEV;
 741
 742         get_device(&acpi_device->dev);
 743         status = acpi_hotplug_schedule(acpi_device, ACPI_OST_EC_OSPM_EJECT);
 744         if (ACPI_SUCCESS(status))
 745                 return count;
 746
 747         put_device(&acpi_device->dev);
 748         acpi_evaluate_ost(acpi_device->handle, ACPI_OST_EC_OSPM_EJECT,
 749                           ACPI_OST_SC_NON_SPECIFIC_FAILURE, NULL);
 750         return status == AE_NO_MEMORY ? -ENOMEM : -EAGAIN;
 751 }
 752
 753 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
 754
 755 static ssize_t
 756 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
 757         struct acpi_device *acpi_dev = to_acpi_device(dev);
 758
 759         return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
 760 }
 761 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 762
 763 static ssize_t acpi_device_uid_show(struct device *dev,
 764                                     struct device_attribute *attr, char *buf)
 765 {
 766         struct acpi_device *acpi_dev = to_acpi_device(dev);
 767
 768         return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
 769 }
 770 static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
 771
 772 static ssize_t acpi_device_adr_show(struct device *dev,
 773                                     struct device_attribute *attr, char *buf)
 774 {
 775         struct acpi_device *acpi_dev = to_acpi_device(dev);
 776
 777         return sprintf(buf, "0x%08x\n",
 778                        (unsigned int)(acpi_dev->pnp.bus_address));
 779 }
 780 static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
 781
 782 static ssize_t
 783 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
 784         struct acpi_device *acpi_dev = to_acpi_device(dev);
 785         struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
 786         int result;
 787
 788         result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
 789         if (result)
 790                 goto end;
 791
 792         result = sprintf(buf, "%s\n", (char*)path.pointer);
 793         kfree(path.pointer);
 794 end:
 795         return result;
 796 }
 797 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
 798
 799 /* sysfs file that shows description text from the ACPI _STR method */
 800 static ssize_t description_show(struct device *dev,
 801                                 struct device_attribute *attr,
 802                                 char *buf) {
 803         struct acpi_device *acpi_dev = to_acpi_device(dev);
 804         int result;
 805
 806         if (acpi_dev->pnp.str_obj == NULL)
 807                 return 0;
 808
 809         /*
 810          * The _STR object contains a Unicode identifier for a device.
 811          * We need to convert to utf-8 so it can be displayed.
 812          */
 813         result = utf16s_to_utf8s(
 814                 (wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
 815                 acpi_dev->pnp.str_obj->buffer.length,
 816                 UTF16_LITTLE_ENDIAN, buf,
 817                 PAGE_SIZE);
 818
 819         buf[result++] = '\n';
 820
 821         return result;
 822 }
 823 static DEVICE_ATTR(description, 0444, description_show, NULL);
 824
 825 static ssize_t
 826 acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
 827                      char *buf) {
 828         struct acpi_device *acpi_dev = to_acpi_device(dev);
 829         acpi_status status;
 830         unsigned long long sun;
 831
 832         status = acpi_evaluate_integer(acpi_dev->handle, "_SUN", NULL, &sun);
 833         if (ACPI_FAILURE(status))
 834                 return -ENODEV;
 835
 836         return sprintf(buf, "%llu\n", sun);
 837 }
 838 static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
 839
 840 static ssize_t status_show(struct device *dev, struct device_attribute *attr,
 841                                 char *buf) {
 842         struct acpi_device *acpi_dev = to_acpi_device(dev);
 843         acpi_status status;
 844         unsigned long long sta;
 845
 846         status = acpi_evaluate_integer(acpi_dev->handle, "_STA", NULL, &sta);
 847         if (ACPI_FAILURE(status))
 848                 return -ENODEV;
 849
 850         return sprintf(buf, "%llu\n", sta);
 851 }
 852 static DEVICE_ATTR_RO(status);
 853
 854 static int acpi_device_setup_files(struct acpi_device *dev)
 855 {
 856         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 857         acpi_status status;
 858         int result = 0;
 859
 860         /*
 861          * Devices gotten from FADT don't have a "path" attribute
 862          */
 863         if (dev->handle) {
 864                 result = device_create_file(&dev->dev, &dev_attr_path);
 865                 if (result)
 866                         goto end;
 867         }
 868
 869         if (!list_empty(&dev->pnp.ids)) {
 870                 result = device_create_file(&dev->dev, &dev_attr_hid);
 871                 if (result)
 872                         goto end;
 873
 874                 result = device_create_file(&dev->dev, &dev_attr_modalias);
 875                 if (result)
 876                         goto end;
 877         }
 878
 879         /*
 880          * If device has _STR, 'description' file is created
 881          */
 882         if (acpi_has_method(dev->handle, "_STR")) {
 883                 status = acpi_evaluate_object(dev->handle, "_STR",
 884                                         NULL, &buffer);
 885                 if (ACPI_FAILURE(status))
 886                         buffer.pointer = NULL;
 887                 dev->pnp.str_obj = buffer.pointer;
 888                 result = device_create_file(&dev->dev, &dev_attr_description);
 889                 if (result)
 890                         goto end;
 891         }
 892
 893         if (dev->pnp.type.bus_address)
 894                 result = device_create_file(&dev->dev, &dev_attr_adr);
 895         if (dev->pnp.unique_id)
 896                 result = device_create_file(&dev->dev, &dev_attr_uid);
 897
 898         if (acpi_has_method(dev->handle, "_SUN")) {
 899                 result = device_create_file(&dev->dev, &dev_attr_sun);
 900                 if (result)
 901                         goto end;
 902         }
 903
 904         if (acpi_has_method(dev->handle, "_STA")) {
 905                 result = device_create_file(&dev->dev, &dev_attr_status);
 906                 if (result)
 907                         goto end;
 908         }
 909
 910         /*
 911          * If device has _EJ0, 'eject' file is created that is used to trigger
 912          * hot-removal function from userland.
 913          */
 914         if (acpi_has_method(dev->handle, "_EJ0")) {
 915                 result = device_create_file(&dev->dev, &dev_attr_eject);
 916                 if (result)
 917                         return result;
 918         }
 919
 920         if (dev->flags.power_manageable) {
 921                 result = device_create_file(&dev->dev, &dev_attr_power_state);
 922                 if (result)
 923                         return result;
 924
 925                 if (dev->power.flags.power_resources)
 926                         result = device_create_file(&dev->dev,
 927                                                     &dev_attr_real_power_state);
 928         }
 929
 930 end:
 931         return result;
 932 }
 933
 934 static void acpi_device_remove_files(struct acpi_device *dev)
 935 {
 936         if (dev->flags.power_manageable) {
 937                 device_remove_file(&dev->dev, &dev_attr_power_state);
 938                 if (dev->power.flags.power_resources)
 939                         device_remove_file(&dev->dev,
 940                                            &dev_attr_real_power_state);
 941         }
 942
 943         /*
 944          * If device has _STR, remove 'description' file
 945          */
 946         if (acpi_has_method(dev->handle, "_STR")) {
 947                 kfree(dev->pnp.str_obj);
 948                 device_remove_file(&dev->dev, &dev_attr_description);
 949         }
 950         /*
 951          * If device has _EJ0, remove 'eject' file.
 952          */
 953         if (acpi_has_method(dev->handle, "_EJ0"))
 954                 device_remove_file(&dev->dev, &dev_attr_eject);
 955
 956         if (acpi_has_method(dev->handle, "_SUN"))
 957                 device_remove_file(&dev->dev, &dev_attr_sun);
 958
 959         if (dev->pnp.unique_id)
 960                 device_remove_file(&dev->dev, &dev_attr_uid);
 961         if (dev->pnp.type.bus_address)
 962                 device_remove_file(&dev->dev, &dev_attr_adr);
 963         device_remove_file(&dev->dev, &dev_attr_modalias);
 964         device_remove_file(&dev->dev, &dev_attr_hid);
 965         if (acpi_has_method(dev->handle, "_STA"))
 966                 device_remove_file(&dev->dev, &dev_attr_status);
 967         if (dev->handle)
 968                 device_remove_file(&dev->dev, &dev_attr_path);
 969 }
 970 /* --------------------------------------------------------------------------
 971                         ACPI Bus operations
 972    -------------------------------------------------------------------------- */
 973
 974 /**
 975  * acpi_of_match_device - Match device object using the "compatible" property.
 976  * @adev: ACPI device object to match.
 977  * @of_match_table: List of device IDs to match against.
 978  *
 979  * If @dev has an ACPI companion which has the special PRP0001 device ID in its
 980  * list of identifiers and a _DSD object with the "compatible" property, use
 981  * that property to match against the given list of identifiers.
 982  */
 983 static bool acpi_of_match_device(struct acpi_device *adev,
 984                                  const struct of_device_id *of_match_table)
 985 {
 986         const union acpi_object *of_compatible, *obj;
 987         int i, nval;
 988
 989         if (!adev)
 990                 return false;
 991
 992         of_compatible = adev->data.of_compatible;
 993         if (!of_match_table || !of_compatible)
 994                 return false;
 995
 996         if (of_compatible->type == ACPI_TYPE_PACKAGE) {
 997                 nval = of_compatible->package.count;
 998                 obj = of_compatible->package.elements;
 999         } else { /* Must be ACPI_TYPE_STRING. */
1000                 nval = 1;
1001                 obj = of_compatible;
1002         }
1003         /* Now we can look for the driver DT compatible strings */
1004         for (i = 0; i < nval; i++, obj++) {
1005                 const struct of_device_id *id;
1006
1007                 for (id = of_match_table; id->compatible[0]; id++)
1008                         if (!strcasecmp(obj->string.pointer, id->compatible))
1009                                 return true;
1010         }
1011
1012         return false;
1013 }
1014
1015 static const struct acpi_device_id *__acpi_match_device(
1016         struct acpi_device *device,
1017         const struct acpi_device_id *ids,
1018         const struct of_device_id *of_ids)
1019 {
1020         const struct acpi_device_id *id;
1021         struct acpi_hardware_id *hwid;
1022
1023         /*
1024          * If the device is not present, it is unnecessary to load device
1025          * driver for it.
1026          */
1027         if (!device || !device->status.present)
1028                 return NULL;
1029
1030         list_for_each_entry(hwid, &device->pnp.ids, list) {
1031                 /* First, check the ACPI/PNP IDs provided by the caller. */
1032                 for (id = ids; id->id[0]; id++)
1033                         if (!strcmp((char *) id->id, hwid->id))
1034                                 return id;
1035
1036                 /*
1037                  * Next, check the special "PRP0001" ID and try to match the
1038                  * "compatible" property if found.
1039                  *
1040                  * The id returned by the below is not valid, but the only
1041                  * caller passing non-NULL of_ids here is only interested in
1042                  * whether or not the return value is NULL.
1043                  */
1044                 if (!strcmp("PRP0001", hwid->id)
1045                     && acpi_of_match_device(device, of_ids))
1046                         return id;
1047         }
1048         return NULL;
1049 }
1050
1051 /**
1052  * acpi_match_device - Match a struct device against a given list of ACPI IDs
1053  * @ids: Array of struct acpi_device_id object to match against.
1054  * @dev: The device structure to match.
1055  *
1056  * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
1057  * object for that handle and use that object to match against a given list of
1058  * device IDs.
1059  *
1060  * Return a pointer to the first matching ID on success or %NULL on failure.
1061  */
1062 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
1063                                                const struct device *dev)
1064 {
1065         return __acpi_match_device(acpi_companion_match(dev), ids, NULL);
1066 }
1067 EXPORT_SYMBOL_GPL(acpi_match_device);
1068
1069 int acpi_match_device_ids(struct acpi_device *device,
1070                           const struct acpi_device_id *ids)
1071 {
1072         return __acpi_match_device(device, ids, NULL) ? 0 : -ENOENT;
1073 }
1074 EXPORT_SYMBOL(acpi_match_device_ids);
1075
1076 bool acpi_driver_match_device(struct device *dev,
1077                               const struct device_driver *drv)
1078 {
1079         if (!drv->acpi_match_table)
1080                 return acpi_of_match_device(ACPI_COMPANION(dev),
1081                                             drv->of_match_table);
1082
1083         return !!__acpi_match_device(acpi_companion_match(dev),
1084                                      drv->acpi_match_table, drv->of_match_table);
1085 }
1086 EXPORT_SYMBOL_GPL(acpi_driver_match_device);
1087
1088 static void acpi_free_power_resources_lists(struct acpi_device *device)
1089 {
1090         int i;
1091
1092         if (device->wakeup.flags.valid)
1093                 acpi_power_resources_list_free(&device->wakeup.resources);
1094
1095         if (!device->power.flags.power_resources)
1096                 return;
1097
1098         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
1099                 struct acpi_device_power_state *ps = &device->power.states[i];
1100                 acpi_power_resources_list_free(&ps->resources);
1101         }
1102 }
1103
1104 static void acpi_device_release(struct device *dev)
1105 {
1106         struct acpi_device *acpi_dev = to_acpi_device(dev);
1107
1108         acpi_free_properties(acpi_dev);
1109         acpi_free_pnp_ids(&acpi_dev->pnp);
1110         acpi_free_power_resources_lists(acpi_dev);
1111         kfree(acpi_dev);
1112 }
1113
1114 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
1115 {
1116         struct acpi_device *acpi_dev = to_acpi_device(dev);
1117         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
1118
1119         return acpi_dev->flags.match_driver
1120                 && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
1121 }
1122
1123 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
1124 {
1125         return __acpi_device_uevent_modalias(to_acpi_device(dev), env);
1126 }
1127
1128 static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
1129 {
1130         struct acpi_device *device = data;
1131
1132         device->driver->ops.notify(device, event);
1133 }
1134
1135 static void acpi_device_notify_fixed(void *data)
1136 {
1137         struct acpi_device *device = data;
1138
1139         /* Fixed hardware devices have no handles */
1140         acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
1141 }
1142
1143 static u32 acpi_device_fixed_event(void *data)
1144 {
1145         acpi_os_execute(OSL_NOTIFY_HANDLER, acpi_device_notify_fixed, data);
1146         return ACPI_INTERRUPT_HANDLED;
1147 }
1148
1149 static int acpi_device_install_notify_handler(struct acpi_device *device)
1150 {
1151         acpi_status status;
1152
1153         if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
1154                 status =
1155                     acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
1156                                                      acpi_device_fixed_event,
1157                                                      device);
1158         else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
1159                 status =
1160                     acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
1161                                                      acpi_device_fixed_event,
1162                                                      device);
1163         else
1164                 status = acpi_install_notify_handler(device->handle,
1165                                                      ACPI_DEVICE_NOTIFY,
1166                                                      acpi_device_notify,
1167                                                      device);
1168
1169         if (ACPI_FAILURE(status))
1170                 return -EINVAL;
1171         return 0;
1172 }
1173
1174 static void acpi_device_remove_notify_handler(struct acpi_device *device)
1175 {
1176         if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
1177                 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
1178                                                 acpi_device_fixed_event);
1179         else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
1180                 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
1181                                                 acpi_device_fixed_event);
1182         else
1183                 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
1184                                            acpi_device_notify);
1185 }
1186
1187 static int acpi_device_probe(struct device *dev)
1188 {
1189         struct acpi_device *acpi_dev = to_acpi_device(dev);
1190         struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
1191         int ret;
1192
1193         if (acpi_dev->handler && !acpi_is_pnp_device(acpi_dev))
1194                 return -EINVAL;
1195
1196         if (!acpi_drv->ops.add)
1197                 return -ENOSYS;
1198
1199         ret = acpi_drv->ops.add(acpi_dev);
1200         if (ret)
1201                 return ret;
1202
1203         acpi_dev->driver = acpi_drv;
1204         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1205                           "Driver [%s] successfully bound to device [%s]\n",
1206                           acpi_drv->name, acpi_dev->pnp.bus_id));
1207
1208         if (acpi_drv->ops.notify) {
1209                 ret = acpi_device_install_notify_handler(acpi_dev);
1210                 if (ret) {
1211                         if (acpi_drv->ops.remove)
1212                                 acpi_drv->ops.remove(acpi_dev);
1213
1214                         acpi_dev->driver = NULL;
1215                         acpi_dev->driver_data = NULL;
1216                         return ret;
1217                 }
1218         }
1219
1220         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found driver [%s] for device [%s]\n",
1221                           acpi_drv->name, acpi_dev->pnp.bus_id));
1222         get_device(dev);
1223         return 0;
1224 }
1225
1226 static int acpi_device_remove(struct device * dev)
1227 {
1228         struct acpi_device *acpi_dev = to_acpi_device(dev);
1229         struct acpi_driver *acpi_drv = acpi_dev->driver;
1230
1231         if (acpi_drv) {
1232                 if (acpi_drv->ops.notify)
1233                         acpi_device_remove_notify_handler(acpi_dev);
1234                 if (acpi_drv->ops.remove)
1235                         acpi_drv->ops.remove(acpi_dev);
1236         }
1237         acpi_dev->driver = NULL;
1238         acpi_dev->driver_data = NULL;
1239
1240         put_device(dev);
1241         return 0;
1242 }
1243
1244 struct bus_type acpi_bus_type = {
1245         .name           = "acpi",
1246         .match          = acpi_bus_match,
1247         .probe          = acpi_device_probe,
1248         .remove         = acpi_device_remove,
1249         .uevent         = acpi_device_uevent,
1250 };
1251
1252 static void acpi_device_del(struct acpi_device *device)
1253 {
1254         mutex_lock(&acpi_device_lock);
1255         if (device->parent)
1256                 list_del(&device->node);
1257
1258         list_del(&device->wakeup_list);
1259         mutex_unlock(&acpi_device_lock);
1260
1261         acpi_power_add_remove_device(device, false);
1262         acpi_device_remove_files(device);
1263         if (device->remove)
1264                 device->remove(device);
1265
1266         device_del(&device->dev);
1267 }
1268
1269 static LIST_HEAD(acpi_device_del_list);
1270 static DEFINE_MUTEX(acpi_device_del_lock);
1271
1272 static void acpi_device_del_work_fn(struct work_struct *work_not_used)
1273 {
1274         for (;;) {
1275                 struct acpi_device *adev;
1276
1277                 mutex_lock(&acpi_device_del_lock);
1278
1279                 if (list_empty(&acpi_device_del_list)) {
1280                         mutex_unlock(&acpi_device_del_lock);
1281                         break;
1282                 }
1283                 adev = list_first_entry(&acpi_device_del_list,
1284                                         struct acpi_device, del_list);
1285                 list_del(&adev->del_list);
1286
1287                 mutex_unlock(&acpi_device_del_lock);
1288
1289                 acpi_device_del(adev);
1290                 /*
1291                  * Drop references to all power resources that might have been
1292                  * used by the device.
1293                  */
1294                 acpi_power_transition(adev, ACPI_STATE_D3_COLD);
1295                 put_device(&adev->dev);
1296         }
1297 }
1298
1299 /**
1300  * acpi_scan_drop_device - Drop an ACPI device object.
1301  * @handle: Handle of an ACPI namespace node, not used.
1302  * @context: Address of the ACPI device object to drop.
1303  *
1304  * This is invoked by acpi_ns_delete_node() during the removal of the ACPI
1305  * namespace node the device object pointed to by @context is attached to.
1306  *
1307  * The unregistration is carried out asynchronously to avoid running
1308  * acpi_device_del() under the ACPICA's namespace mutex and the list is used to
1309  * ensure the correct ordering (the device objects must be unregistered in the
1310  * same order in which the corresponding namespace nodes are deleted).
1311  */
1312 static void acpi_scan_drop_device(acpi_handle handle, void *context)
1313 {
1314         static DECLARE_WORK(work, acpi_device_del_work_fn);
1315         struct acpi_device *adev = context;
1316
1317         mutex_lock(&acpi_device_del_lock);
1318
1319         /*
1320          * Use the ACPI hotplug workqueue which is ordered, so this work item
1321          * won't run after any hotplug work items submitted subsequently.  That
1322          * prevents attempts to register device objects identical to those being
1323          * deleted from happening concurrently (such attempts result from
1324          * hotplug events handled via the ACPI hotplug workqueue).  It also will
1325          * run after all of the work items submitted previosuly, which helps
1326          * those work items to ensure that they are not accessing stale device
1327          * objects.
1328          */
1329         if (list_empty(&acpi_device_del_list))
1330                 acpi_queue_hotplug_work(&work);
1331
1332         list_add_tail(&adev->del_list, &acpi_device_del_list);
1333         /* Make acpi_ns_validate_handle() return NULL for this handle. */
1334         adev->handle = INVALID_ACPI_HANDLE;
1335
1336         mutex_unlock(&acpi_device_del_lock);
1337 }
1338
1339 static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device,
1340                                 void (*callback)(void *))
1341 {
1342         acpi_status status;
1343
1344         if (!device)
1345                 return -EINVAL;
1346
1347         status = acpi_get_data_full(handle, acpi_scan_drop_device,
1348                                     (void **)device, callback);
1349         if (ACPI_FAILURE(status) || !*device) {
1350                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No context for object [%p]\n",
1351                                   handle));
1352                 return -ENODEV;
1353         }
1354         return 0;
1355 }
1356
1357 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
1358 {
1359         return acpi_get_device_data(handle, device, NULL);
1360 }
1361 EXPORT_SYMBOL(acpi_bus_get_device);
1362
1363 static void get_acpi_device(void *dev)
1364 {
1365         if (dev)
1366                 get_device(&((struct acpi_device *)dev)->dev);
1367 }
1368
1369 struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
1370 {
1371         struct acpi_device *adev = NULL;
1372
1373         acpi_get_device_data(handle, &adev, get_acpi_device);
1374         return adev;
1375 }
1376
1377 void acpi_bus_put_acpi_device(struct acpi_device *adev)
1378 {
1379         put_device(&adev->dev);
1380 }
1381
1382 int acpi_device_add(struct acpi_device *device,
1383                     void (*release)(struct device *))
1384 {
1385         int result;
1386         struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
1387         int found = 0;
1388
1389         if (device->handle) {
1390                 acpi_status status;
1391
1392                 status = acpi_attach_data(device->handle, acpi_scan_drop_device,
1393                                           device);
1394                 if (ACPI_FAILURE(status)) {
1395                         acpi_handle_err(device->handle,
1396                                         "Unable to attach device data\n");
1397                         return -ENODEV;
1398                 }
1399         }
1400
1401         /*
1402          * Linkage
1403          * -------
1404          * Link this device to its parent and siblings.
1405          */
1406         INIT_LIST_HEAD(&device->children);
1407         INIT_LIST_HEAD(&device->node);
1408         INIT_LIST_HEAD(&device->wakeup_list);
1409         INIT_LIST_HEAD(&device->physical_node_list);
1410         INIT_LIST_HEAD(&device->del_list);
1411         mutex_init(&device->physical_node_lock);
1412
1413         new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
1414         if (!new_bus_id) {
1415                 pr_err(PREFIX "Memory allocation error\n");
1416                 result = -ENOMEM;
1417                 goto err_detach;
1418         }
1419
1420         mutex_lock(&acpi_device_lock);
1421         /*
1422          * Find suitable bus_id and instance number in acpi_bus_id_list
1423          * If failed, create one and link it into acpi_bus_id_list
1424          */
1425         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
1426                 if (!strcmp(acpi_device_bus_id->bus_id,
1427                             acpi_device_hid(device))) {
1428                         acpi_device_bus_id->instance_no++;
1429                         found = 1;
1430                         kfree(new_bus_id);
1431                         break;
1432                 }
1433         }
1434         if (!found) {
1435                 acpi_device_bus_id = new_bus_id;
1436                 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
1437                 acpi_device_bus_id->instance_no = 0;
1438                 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
1439         }
1440         dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
1441
1442         if (device->parent)
1443                 list_add_tail(&device->node, &device->parent->children);
1444
1445         if (device->wakeup.flags.valid)
1446                 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
1447         mutex_unlock(&acpi_device_lock);
1448
1449         if (device->parent)
1450                 device->dev.parent = &device->parent->dev;
1451         device->dev.bus = &acpi_bus_type;
1452         device->dev.release = release;
1453         result = device_add(&device->dev);
1454         if (result) {
1455                 dev_err(&device->dev, "Error registering device\n");
1456                 goto err;
1457         }
1458
1459         result = acpi_device_setup_files(device);
1460         if (result)
1461                 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
1462                        dev_name(&device->dev));
1463
1464         return 0;
1465
1466  err:
1467         mutex_lock(&acpi_device_lock);
1468         if (device->parent)
1469                 list_del(&device->node);
1470         list_del(&device->wakeup_list);
1471         mutex_unlock(&acpi_device_lock);
1472
1473  err_detach:
1474         acpi_detach_data(device->handle, acpi_scan_drop_device);
1475         return result;
1476 }
1477
1478 struct acpi_device *acpi_get_next_child(struct device *dev,
1479                                         struct acpi_device *child)
1480 {
1481         struct acpi_device *adev = ACPI_COMPANION(dev);
1482         struct list_head *head, *next;
1483
1484         if (!adev)
1485                 return NULL;
1486
1487         head = &adev->children;
1488         if (list_empty(head))
1489                 return NULL;
1490
1491         if (!child)
1492                 return list_first_entry(head, struct acpi_device, node);
1493
1494         next = child->node.next;
1495         return next == head ? NULL : list_entry(next, struct acpi_device, node);
1496 }
1497
1498 /* --------------------------------------------------------------------------
1499                                  Driver Management
1500    -------------------------------------------------------------------------- */
1501 /**
1502  * acpi_bus_register_driver - register a driver with the ACPI bus
1503  * @driver: driver being registered
1504  *
1505  * Registers a driver with the ACPI bus.  Searches the namespace for all
1506  * devices that match the driver's criteria and binds.  Returns zero for
1507  * success or a negative error status for failure.
1508  */
1509 int acpi_bus_register_driver(struct acpi_driver *driver)
1510 {
1511         int ret;
1512
1513         if (acpi_disabled)
1514                 return -ENODEV;
1515         driver->drv.name = driver->name;
1516         driver->drv.bus = &acpi_bus_type;
1517         driver->drv.owner = driver->owner;
1518
1519         ret = driver_register(&driver->drv);
1520         return ret;
1521 }
1522
1523 EXPORT_SYMBOL(acpi_bus_register_driver);
1524
1525 /**
1526  * acpi_bus_unregister_driver - unregisters a driver with the ACPI bus
1527  * @driver: driver to unregister
1528  *
1529  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
1530  * devices that match the driver's criteria and unbinds.
1531  */
1532 void acpi_bus_unregister_driver(struct acpi_driver *driver)
1533 {
1534         driver_unregister(&driver->drv);
1535 }
1536
1537 EXPORT_SYMBOL(acpi_bus_unregister_driver);
1538
1539 /* --------------------------------------------------------------------------
1540                                  Device Enumeration
1541    -------------------------------------------------------------------------- */
1542 static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
1543 {
1544         struct acpi_device *device = NULL;
1545         acpi_status status;
1546
1547         /*
1548          * Fixed hardware devices do not appear in the namespace and do not
1549          * have handles, but we fabricate acpi_devices for them, so we have
1550          * to deal with them specially.
1551          */
1552         if (!handle)
1553                 return acpi_root;
1554
1555         do {
1556                 status = acpi_get_parent(handle, &handle);
1557                 if (ACPI_FAILURE(status))
1558                         return status == AE_NULL_ENTRY ? NULL : acpi_root;
1559         } while (acpi_bus_get_device(handle, &device));
1560         return device;
1561 }
1562
1563 acpi_status
1564 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
1565 {
1566         acpi_status status;
1567         acpi_handle tmp;
1568         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
1569         union acpi_object *obj;
1570
1571         status = acpi_get_handle(handle, "_EJD", &tmp);
1572         if (ACPI_FAILURE(status))
1573                 return status;
1574
1575         status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
1576         if (ACPI_SUCCESS(status)) {
1577                 obj = buffer.pointer;
1578                 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
1579                                          ejd);
1580                 kfree(buffer.pointer);
1581         }
1582         return status;
1583 }
1584 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
1585
1586 static int acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
1587                                         struct acpi_device_wakeup *wakeup)
1588 {
1589         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1590         union acpi_object *package = NULL;
1591         union acpi_object *element = NULL;
1592         acpi_status status;
1593         int err = -ENODATA;
1594
1595         if (!wakeup)
1596                 return -EINVAL;
1597
1598         INIT_LIST_HEAD(&wakeup->resources);
1599
1600         /* _PRW */
1601         status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
1602         if (ACPI_FAILURE(status)) {
1603                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
1604                 return err;
1605         }
1606
1607         package = (union acpi_object *)buffer.pointer;
1608
1609         if (!package || package->package.count < 2)
1610                 goto out;
1611
1612         element = &(package->package.elements[0]);
1613         if (!element)
1614                 goto out;
1615
1616         if (element->type == ACPI_TYPE_PACKAGE) {
1617                 if ((element->package.count < 2) ||
1618                     (element->package.elements[0].type !=
1619                      ACPI_TYPE_LOCAL_REFERENCE)
1620                     || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
1621                         goto out;
1622
1623                 wakeup->gpe_device =
1624                     element->package.elements[0].reference.handle;
1625                 wakeup->gpe_number =
1626                     (u32) element->package.elements[1].integer.value;
1627         } else if (element->type == ACPI_TYPE_INTEGER) {
1628                 wakeup->gpe_device = NULL;
1629                 wakeup->gpe_number = element->integer.value;
1630         } else {
1631                 goto out;
1632         }
1633
1634         element = &(package->package.elements[1]);
1635         if (element->type != ACPI_TYPE_INTEGER)
1636                 goto out;
1637
1638         wakeup->sleep_state = element->integer.value;
1639
1640         err = acpi_extract_power_resources(package, 2, &wakeup->resources);
1641         if (err)
1642                 goto out;
1643
1644         if (!list_empty(&wakeup->resources)) {
1645                 int sleep_state;
1646
1647                 err = acpi_power_wakeup_list_init(&wakeup->resources,
1648                                                   &sleep_state);
1649                 if (err) {
1650                         acpi_handle_warn(handle, "Retrieving current states "
1651                                          "of wakeup power resources failed\n");
1652                         acpi_power_resources_list_free(&wakeup->resources);
1653                         goto out;
1654                 }
1655                 if (sleep_state < wakeup->sleep_state) {
1656                         acpi_handle_warn(handle, "Overriding _PRW sleep state "
1657                                          "(S%d) by S%d from power resources\n",
1658                                          (int)wakeup->sleep_state, sleep_state);
1659                         wakeup->sleep_state = sleep_state;
1660                 }
1661         }
1662
1663  out:
1664         kfree(buffer.pointer);
1665         return err;
1666 }
1667
1668 static void acpi_wakeup_gpe_init(struct acpi_device *device)
1669 {
1670         struct acpi_device_id button_device_ids[] = {
1671                 {"PNP0C0C", 0},
1672                 {"PNP0C0D", 0},
1673                 {"PNP0C0E", 0},
1674                 {"", 0},
1675         };
1676         struct acpi_device_wakeup *wakeup = &device->wakeup;
1677         acpi_status status;
1678         acpi_event_status event_status;
1679
1680         wakeup->flags.notifier_present = 0;
1681
1682         /* Power button, Lid switch always enable wakeup */
1683         if (!acpi_match_device_ids(device, button_device_ids)) {
1684                 wakeup->flags.run_wake = 1;
1685                 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
1686                         /* Do not use Lid/sleep button for S5 wakeup */
1687                         if (wakeup->sleep_state == ACPI_STATE_S5)
1688                                 wakeup->sleep_state = ACPI_STATE_S4;
1689                 }
1690                 acpi_mark_gpe_for_wake(wakeup->gpe_device, wakeup->gpe_number);
1691                 device_set_wakeup_capable(&device->dev, true);
1692                 return;
1693         }
1694
1695         acpi_setup_gpe_for_wake(device->handle, wakeup->gpe_device,
1696                                 wakeup->gpe_number);
1697         status = acpi_get_gpe_status(wakeup->gpe_device, wakeup->gpe_number,
1698                                      &event_status);
1699         if (ACPI_FAILURE(status))
1700                 return;
1701
1702         wakeup->flags.run_wake = !!(event_status & ACPI_EVENT_FLAG_HAS_HANDLER);
1703 }
1704
1705 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
1706 {
1707         int err;
1708
1709         /* Presence of _PRW indicates wake capable */
1710         if (!acpi_has_method(device->handle, "_PRW"))
1711                 return;
1712
1713         err = acpi_bus_extract_wakeup_device_power_package(device->handle,
1714                                                            &device->wakeup);
1715         if (err) {
1716                 dev_err(&device->dev, "_PRW evaluation error: %d\n", err);
1717                 return;
1718         }
1719
1720         device->wakeup.flags.valid = 1;
1721         device->wakeup.prepare_count = 0;
1722         acpi_wakeup_gpe_init(device);
1723         /* Call _PSW/_DSW object to disable its ability to wake the sleeping
1724          * system for the ACPI device with the _PRW object.
1725          * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
1726          * So it is necessary to call _DSW object first. Only when it is not
1727          * present will the _PSW object used.
1728          */
1729         err = acpi_device_sleep_wake(device, 0, 0, 0);
1730         if (err)
1731                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1732                                 "error in _DSW or _PSW evaluation\n"));
1733 }
1734
1735 static void acpi_bus_init_power_state(struct acpi_device *device, int state)
1736 {
1737         struct acpi_device_power_state *ps = &device->power.states[state];
1738         char pathname[5] = { '_', 'P', 'R', '0' + state, '\0' };
1739         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1740         acpi_status status;
1741
1742         INIT_LIST_HEAD(&ps->resources);
1743
1744         /* Evaluate "_PRx" to get referenced power resources */
1745         status = acpi_evaluate_object(device->handle, pathname, NULL, &buffer);
1746         if (ACPI_SUCCESS(status)) {
1747                 union acpi_object *package = buffer.pointer;
1748
1749                 if (buffer.length && package
1750                     && package->type == ACPI_TYPE_PACKAGE
1751                     && package->package.count) {
1752                         int err = acpi_extract_power_resources(package, 0,
1753                                                                &ps->resources);
1754                         if (!err)
1755                                 device->power.flags.power_resources = 1;
1756                 }
1757                 ACPI_FREE(buffer.pointer);
1758         }
1759
1760         /* Evaluate "_PSx" to see if we can do explicit sets */
1761         pathname[2] = 'S';
1762         if (acpi_has_method(device->handle, pathname))
1763                 ps->flags.explicit_set = 1;
1764
1765         /*
1766          * State is valid if there are means to put the device into it.
1767          * D3hot is only valid if _PR3 present.
1768          */
1769         if (!list_empty(&ps->resources)
1770             || (ps->flags.explicit_set && state < ACPI_STATE_D3_HOT)) {
1771                 ps->flags.valid = 1;
1772                 ps->flags.os_accessible = 1;
1773         }
1774
1775         ps->power = -1;         /* Unknown - driver assigned */
1776         ps->latency = -1;       /* Unknown - driver assigned */
1777 }
1778
1779 static void acpi_bus_get_power_flags(struct acpi_device *device)
1780 {
1781         u32 i;
1782
1783         /* Presence of _PS0|_PR0 indicates 'power manageable' */
1784         if (!acpi_has_method(device->handle, "_PS0") &&
1785             !acpi_has_method(device->handle, "_PR0"))
1786                 return;
1787
1788         device->flags.power_manageable = 1;
1789
1790         /*
1791          * Power Management Flags
1792          */
1793         if (acpi_has_method(device->handle, "_PSC"))
1794                 device->power.flags.explicit_get = 1;
1795
1796         if (acpi_has_method(device->handle, "_IRC"))
1797                 device->power.flags.inrush_current = 1;
1798
1799         if (acpi_has_method(device->handle, "_DSW"))
1800                 device->power.flags.dsw_present = 1;
1801
1802         /*
1803          * Enumerate supported power management states
1804          */
1805         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++)
1806                 acpi_bus_init_power_state(device, i);
1807
1808         INIT_LIST_HEAD(&device->power.states[ACPI_STATE_D3_COLD].resources);
1809
1810         /* Set defaults for D0 and D3 states (always valid) */
1811         device->power.states[ACPI_STATE_D0].flags.valid = 1;
1812         device->power.states[ACPI_STATE_D0].power = 100;
1813         device->power.states[ACPI_STATE_D3_COLD].flags.valid = 1;
1814         device->power.states[ACPI_STATE_D3_COLD].power = 0;
1815
1816         /* Set D3cold's explicit_set flag if _PS3 exists. */
1817         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
1818                 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
1819
1820         /* Presence of _PS3 or _PRx means we can put the device into D3 cold */
1821         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
1822                         device->power.flags.power_resources)
1823                 device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
1824
1825         if (acpi_bus_init_power(device))
1826                 device->flags.power_manageable = 0;
1827 }
1828
1829 static void acpi_bus_get_flags(struct acpi_device *device)
1830 {
1831         /* Presence of _STA indicates 'dynamic_status' */
1832         if (acpi_has_method(device->handle, "_STA"))
1833                 device->flags.dynamic_status = 1;
1834
1835         /* Presence of _RMV indicates 'removable' */
1836         if (acpi_has_method(device->handle, "_RMV"))
1837                 device->flags.removable = 1;
1838
1839         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1840         if (acpi_has_method(device->handle, "_EJD") ||
1841             acpi_has_method(device->handle, "_EJ0"))
1842                 device->flags.ejectable = 1;
1843 }
1844
1845 static void acpi_device_get_busid(struct acpi_device *device)
1846 {
1847         char bus_id[5] = { '?', 0 };
1848         struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1849         int i = 0;
1850
1851         /*
1852          * Bus ID
1853          * ------
1854          * The device's Bus ID is simply the object name.
1855          * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1856          */
1857         if (ACPI_IS_ROOT_DEVICE(device)) {
1858                 strcpy(device->pnp.bus_id, "ACPI");
1859                 return;
1860         }
1861
1862         switch (device->device_type) {
1863         case ACPI_BUS_TYPE_POWER_BUTTON:
1864                 strcpy(device->pnp.bus_id, "PWRF");
1865                 break;
1866         case ACPI_BUS_TYPE_SLEEP_BUTTON:
1867                 strcpy(device->pnp.bus_id, "SLPF");
1868                 break;
1869         default:
1870                 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
1871                 /* Clean up trailing underscores (if any) */
1872                 for (i = 3; i > 1; i--) {
1873                         if (bus_id[i] == '_')
1874                                 bus_id[i] = '\0';
1875                         else
1876                                 break;
1877                 }
1878                 strcpy(device->pnp.bus_id, bus_id);
1879                 break;
1880         }
1881 }
1882
1883 /*
1884  * acpi_ata_match - see if an acpi object is an ATA device
1885  *
1886  * If an acpi object has one of the ACPI ATA methods defined,
1887  * then we can safely call it an ATA device.
1888  */
1889 bool acpi_ata_match(acpi_handle handle)
1890 {
1891         return acpi_has_method(handle, "_GTF") ||
1892                acpi_has_method(handle, "_GTM") ||
1893                acpi_has_method(handle, "_STM") ||
1894                acpi_has_method(handle, "_SDD");
1895 }
1896
1897 /*
1898  * acpi_bay_match - see if an acpi object is an ejectable driver bay
1899  *
1900  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1901  * then we can safely call it an ejectable drive bay
1902  */
1903 bool acpi_bay_match(acpi_handle handle)
1904 {
1905         acpi_handle phandle;
1906
1907         if (!acpi_has_method(handle, "_EJ0"))
1908                 return false;
1909         if (acpi_ata_match(handle))
1910                 return true;
1911         if (ACPI_FAILURE(acpi_get_parent(handle, &phandle)))
1912                 return false;
1913
1914         return acpi_ata_match(phandle);
1915 }
1916
1917 bool acpi_device_is_battery(struct acpi_device *adev)
1918 {
1919         struct acpi_hardware_id *hwid;
1920
1921         list_for_each_entry(hwid, &adev->pnp.ids, list)
1922                 if (!strcmp("PNP0C0A", hwid->id))
1923                         return true;
1924
1925         return false;
1926 }
1927
1928 static bool is_ejectable_bay(struct acpi_device *adev)
1929 {
1930         acpi_handle handle = adev->handle;
1931
1932         if (acpi_has_method(handle, "_EJ0") && acpi_device_is_battery(adev))
1933                 return true;
1934
1935         return acpi_bay_match(handle);
1936 }
1937
1938 /*
1939  * acpi_dock_match - see if an acpi object has a _DCK method
1940  */
1941 bool acpi_dock_match(acpi_handle handle)
1942 {
1943         return acpi_has_method(handle, "_DCK");
1944 }
1945
1946 const char *acpi_device_hid(struct acpi_device *device)
1947 {
1948         struct acpi_hardware_id *hid;
1949
1950         if (list_empty(&device->pnp.ids))
1951                 return dummy_hid;
1952
1953         hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1954         return hid->id;
1955 }
1956 EXPORT_SYMBOL(acpi_device_hid);
1957
1958 static void acpi_add_id(struct acpi_device_pnp *pnp, const char *dev_id)
1959 {
1960         struct acpi_hardware_id *id;
1961
1962         id = kmalloc(sizeof(*id), GFP_KERNEL);
1963         if (!id)
1964                 return;
1965
1966         id->id = kstrdup(dev_id, GFP_KERNEL);
1967         if (!id->id) {
1968                 kfree(id);
1969                 return;
1970         }
1971
1972         list_add_tail(&id->list, &pnp->ids);
1973         pnp->type.hardware_id = 1;
1974 }
1975
1976 /*
1977  * Old IBM workstations have a DSDT bug wherein the SMBus object
1978  * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1979  * prefix.  Work around this.
1980  */
1981 static bool acpi_ibm_smbus_match(acpi_handle handle)
1982 {
1983         char node_name[ACPI_PATH_SEGMENT_LENGTH];
1984         struct acpi_buffer path = { sizeof(node_name), node_name };
1985
1986         if (!dmi_name_in_vendors("IBM"))
1987                 return false;
1988
1989         /* Look for SMBS object */
1990         if (ACPI_FAILURE(acpi_get_name(handle, ACPI_SINGLE_NAME, &path)) ||
1991             strcmp("SMBS", path.pointer))
1992                 return false;
1993
1994         /* Does it have the necessary (but misnamed) methods? */
1995         if (acpi_has_method(handle, "SBI") &&
1996             acpi_has_method(handle, "SBR") &&
1997             acpi_has_method(handle, "SBW"))
1998                 return true;
1999
2000         return false;
2001 }
2002
2003 static bool acpi_object_is_system_bus(acpi_handle handle)
2004 {
2005         acpi_handle tmp;
2006
2007         if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_SB", &tmp)) &&
2008             tmp == handle)
2009                 return true;
2010         if (ACPI_SUCCESS(acpi_get_handle(NULL, "\\_TZ", &tmp)) &&
2011             tmp == handle)
2012                 return true;
2013
2014         return false;
2015 }
2016
2017 static void acpi_set_pnp_ids(acpi_handle handle, struct acpi_device_pnp *pnp,
2018                                 int device_type)
2019 {
2020         acpi_status status;
2021         struct acpi_device_info *info;
2022         struct acpi_pnp_device_id_list *cid_list;
2023         int i;
2024
2025         switch (device_type) {
2026         case ACPI_BUS_TYPE_DEVICE:
2027                 if (handle == ACPI_ROOT_OBJECT) {
2028                         acpi_add_id(pnp, ACPI_SYSTEM_HID);
2029                         break;
2030                 }
2031
2032                 status = acpi_get_object_info(handle, &info);
2033                 if (ACPI_FAILURE(status)) {
2034                         pr_err(PREFIX "%s: Error reading device info\n",
2035                                         __func__);
2036                         return;
2037                 }
2038
2039                 if (info->valid & ACPI_VALID_HID) {
2040                         acpi_add_id(pnp, info->hardware_id.string);
2041                         pnp->type.platform_id = 1;
2042                 }
2043                 if (info->valid & ACPI_VALID_CID) {
2044                         cid_list = &info->compatible_id_list;
2045                         for (i = 0; i < cid_list->count; i++)
2046                                 acpi_add_id(pnp, cid_list->ids[i].string);
2047                 }
2048                 if (info->valid & ACPI_VALID_ADR) {
2049                         pnp->bus_address = info->address;
2050                         pnp->type.bus_address = 1;
2051                 }
2052                 if (info->valid & ACPI_VALID_UID)
2053                         pnp->unique_id = kstrdup(info->unique_id.string,
2054                                                         GFP_KERNEL);
2055
2056                 kfree(info);
2057
2058                 /*
2059                  * Some devices don't reliably have _HIDs & _CIDs, so add
2060                  * synthetic HIDs to make sure drivers can find them.
2061                  */
2062                 if (acpi_is_video_device(handle))
2063                         acpi_add_id(pnp, ACPI_VIDEO_HID);
2064                 else if (acpi_bay_match(handle))
2065                         acpi_add_id(pnp, ACPI_BAY_HID);
2066                 else if (acpi_dock_match(handle))
2067                         acpi_add_id(pnp, ACPI_DOCK_HID);
2068                 else if (acpi_ibm_smbus_match(handle))
2069                         acpi_add_id(pnp, ACPI_SMBUS_IBM_HID);
2070                 else if (list_empty(&pnp->ids) &&
2071                          acpi_object_is_system_bus(handle)) {
2072                         /* \_SB, \_TZ, LNXSYBUS */
2073                         acpi_add_id(pnp, ACPI_BUS_HID);
2074                         strcpy(pnp->device_name, ACPI_BUS_DEVICE_NAME);
2075                         strcpy(pnp->device_class, ACPI_BUS_CLASS);
2076                 }
2077
2078                 break;
2079         case ACPI_BUS_TYPE_POWER:
2080                 acpi_add_id(pnp, ACPI_POWER_HID);
2081                 break;
2082         case ACPI_BUS_TYPE_PROCESSOR:
2083                 acpi_add_id(pnp, ACPI_PROCESSOR_OBJECT_HID);
2084                 break;
2085         case ACPI_BUS_TYPE_THERMAL:
2086                 acpi_add_id(pnp, ACPI_THERMAL_HID);
2087                 break;
2088         case ACPI_BUS_TYPE_POWER_BUTTON:
2089                 acpi_add_id(pnp, ACPI_BUTTON_HID_POWERF);
2090                 break;
2091         case ACPI_BUS_TYPE_SLEEP_BUTTON:
2092                 acpi_add_id(pnp, ACPI_BUTTON_HID_SLEEPF);
2093                 break;
2094         }
2095 }
2096
2097 void acpi_free_pnp_ids(struct acpi_device_pnp *pnp)
2098 {
2099         struct acpi_hardware_id *id, *tmp;
2100
2101         list_for_each_entry_safe(id, tmp, &pnp->ids, list) {
2102                 kfree(id->id);
2103                 kfree(id);
2104         }
2105         kfree(pnp->unique_id);
2106 }
2107
2108 void acpi_init_device_object(struct acpi_device *device, acpi_handle handle,
2109                              int type, unsigned long long sta)
2110 {
2111         INIT_LIST_HEAD(&device->pnp.ids);
2112         device->device_type = type;
2113         device->handle = handle;
2114         device->parent = acpi_bus_get_parent(handle);
2115         device->fwnode.type = FWNODE_ACPI;
2116         acpi_set_device_status(device, sta);
2117         acpi_device_get_busid(device);
2118         acpi_set_pnp_ids(handle, &device->pnp, type);
2119         acpi_init_properties(device);
2120         acpi_bus_get_flags(device);
2121         device->flags.match_driver = false;
2122         device->flags.initialized = true;
2123         device->flags.visited = false;
2124         device_initialize(&device->dev);
2125         dev_set_uevent_suppress(&device->dev, true);
2126 }
2127
2128 void acpi_device_add_finalize(struct acpi_device *device)
2129 {
2130         dev_set_uevent_suppress(&device->dev, false);
2131         kobject_uevent(&device->dev.kobj, KOBJ_ADD);
2132 }
2133
2134 static int acpi_add_single_object(struct acpi_device **child,
2135                                   acpi_handle handle, int type,
2136                                   unsigned long long sta)
2137 {
2138         int result;
2139         struct acpi_device *device;
2140         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
2141
2142         device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
2143         if (!device) {
2144                 printk(KERN_ERR PREFIX "Memory allocation error\n");
2145                 return -ENOMEM;
2146         }
2147
2148         acpi_init_device_object(device, handle, type, sta);
2149         acpi_bus_get_power_flags(device);
2150         acpi_bus_get_wakeup_device_flags(device);
2151
2152         result = acpi_device_add(device, acpi_device_release);
2153         if (result) {
2154                 acpi_device_release(&device->dev);
2155                 return result;
2156         }
2157
2158         acpi_power_add_remove_device(device, true);
2159         acpi_device_add_finalize(device);
2160         acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
2161         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Added %s [%s] parent %s\n",
2162                 dev_name(&device->dev), (char *) buffer.pointer,
2163                 device->parent ? dev_name(&device->parent->dev) : "(null)"));
2164         kfree(buffer.pointer);
2165         *child = device;
2166         return 0;
2167 }
2168
2169 static int acpi_bus_type_and_status(acpi_handle handle, int *type,
2170                                     unsigned long long *sta)
2171 {
2172         acpi_status status;
2173         acpi_object_type acpi_type;
2174
2175         status = acpi_get_type(handle, &acpi_type);
2176         if (ACPI_FAILURE(status))
2177                 return -ENODEV;
2178
2179         switch (acpi_type) {
2180         case ACPI_TYPE_ANY:             /* for ACPI_ROOT_OBJECT */
2181         case ACPI_TYPE_DEVICE:
2182                 *type = ACPI_BUS_TYPE_DEVICE;
2183                 status = acpi_bus_get_status_handle(handle, sta);
2184                 if (ACPI_FAILURE(status))
2185                         return -ENODEV;
2186                 break;
2187         case ACPI_TYPE_PROCESSOR:
2188                 *type = ACPI_BUS_TYPE_PROCESSOR;
2189                 status = acpi_bus_get_status_handle(handle, sta);
2190                 if (ACPI_FAILURE(status))
2191                         return -ENODEV;
2192                 break;
2193         case ACPI_TYPE_THERMAL:
2194                 *type = ACPI_BUS_TYPE_THERMAL;
2195                 *sta = ACPI_STA_DEFAULT;
2196                 break;
2197         case ACPI_TYPE_POWER:
2198                 *type = ACPI_BUS_TYPE_POWER;
2199                 *sta = ACPI_STA_DEFAULT;
2200                 break;
2201         default:
2202                 return -ENODEV;
2203         }
2204
2205         return 0;
2206 }
2207
2208 bool acpi_device_is_present(struct acpi_device *adev)
2209 {
2210         if (adev->status.present || adev->status.functional)
2211                 return true;
2212
2213         adev->flags.initialized = false;
2214         return false;
2215 }
2216
2217 static bool acpi_scan_handler_matching(struct acpi_scan_handler *handler,
2218                                        char *idstr,
2219                                        const struct acpi_device_id **matchid)
2220 {
2221         const struct acpi_device_id *devid;
2222
2223         if (handler->match)
2224                 return handler->match(idstr, matchid);
2225
2226         for (devid = handler->ids; devid->id[0]; devid++)
2227                 if (!strcmp((char *)devid->id, idstr)) {
2228                         if (matchid)
2229                                 *matchid = devid;
2230
2231                         return true;
2232                 }
2233
2234         return false;
2235 }
2236
2237 static struct acpi_scan_handler *acpi_scan_match_handler(char *idstr,
2238                                         const struct acpi_device_id **matchid)
2239 {
2240         struct acpi_scan_handler *handler;
2241
2242         list_for_each_entry(handler, &acpi_scan_handlers_list, list_node)
2243                 if (acpi_scan_handler_matching(handler, idstr, matchid))
2244                         return handler;
2245
2246         return NULL;
2247 }
2248
2249 void acpi_scan_hotplug_enabled(struct acpi_hotplug_profile *hotplug, bool val)
2250 {
2251         if (!!hotplug->enabled == !!val)
2252                 return;
2253
2254         mutex_lock(&acpi_scan_lock);
2255
2256         hotplug->enabled = val;
2257
2258         mutex_unlock(&acpi_scan_lock);
2259 }
2260
2261 static void acpi_scan_init_hotplug(struct acpi_device *adev)
2262 {
2263         struct acpi_hardware_id *hwid;
2264
2265         if (acpi_dock_match(adev->handle) || is_ejectable_bay(adev)) {
2266                 acpi_dock_add(adev);
2267                 return;
2268         }
2269         list_for_each_entry(hwid, &adev->pnp.ids, list) {
2270                 struct acpi_scan_handler *handler;
2271
2272                 handler = acpi_scan_match_handler(hwid->id, NULL);
2273                 if (handler) {
2274                         adev->flags.hotplug_notify = true;
2275                         break;
2276                 }
2277         }
2278 }
2279
2280 static void acpi_device_dep_initialize(struct acpi_device *adev)
2281 {
2282         struct acpi_dep_data *dep;
2283         struct acpi_handle_list dep_devices;
2284         acpi_status status;
2285         int i;
2286
2287         if (!acpi_has_method(adev->handle, "_DEP"))
2288                 return;
2289
2290         status = acpi_evaluate_reference(adev->handle, "_DEP", NULL,
2291                                         &dep_devices);
2292         if (ACPI_FAILURE(status)) {
2293                 dev_dbg(&adev->dev, "Failed to evaluate _DEP.\n");
2294                 return;
2295         }
2296
2297         for (i = 0; i < dep_devices.count; i++) {
2298                 struct acpi_device_info *info;
2299                 int skip;
2300
2301                 status = acpi_get_object_info(dep_devices.handles[i], &info);
2302                 if (ACPI_FAILURE(status)) {
2303                         dev_dbg(&adev->dev, "Error reading _DEP device info\n");
2304                         continue;
2305                 }
2306
2307                 /*
2308                  * Skip the dependency of Windows System Power
2309                  * Management Controller
2310                  */
2311                 skip = info->valid & ACPI_VALID_HID &&
2312                         !strcmp(info->hardware_id.string, "INT3396");
2313
2314                 kfree(info);
2315
2316                 if (skip)
2317                         continue;
2318
2319                 dep = kzalloc(sizeof(struct acpi_dep_data), GFP_KERNEL);
2320                 if (!dep)
2321                         return;
2322
2323                 dep->master = dep_devices.handles[i];
2324                 dep->slave  = adev->handle;
2325                 adev->dep_unmet++;
2326
2327                 mutex_lock(&acpi_dep_list_lock);
2328                 list_add_tail(&dep->node , &acpi_dep_list);
2329                 mutex_unlock(&acpi_dep_list_lock);
2330         }
2331 }
2332
2333 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
2334                                       void *not_used, void **return_value)
2335 {
2336         struct acpi_device *device = NULL;
2337         int type;
2338         unsigned long long sta;
2339         int result;
2340
2341         acpi_bus_get_device(handle, &device);
2342         if (device)
2343                 goto out;
2344
2345         result = acpi_bus_type_and_status(handle, &type, &sta);
2346         if (result)
2347                 return AE_OK;
2348
2349         if (type == ACPI_BUS_TYPE_POWER) {
2350                 acpi_add_power_resource(handle);
2351                 return AE_OK;
2352         }
2353
2354         acpi_add_single_object(&device, handle, type, sta);
2355         if (!device)
2356                 return AE_CTRL_DEPTH;
2357
2358         acpi_scan_init_hotplug(device);
2359         acpi_device_dep_initialize(device);
2360
2361  out:
2362         if (!*return_value)
2363                 *return_value = device;
2364
2365         return AE_OK;
2366 }
2367
2368 static int acpi_check_spi_i2c_slave(struct acpi_resource *ares, void *data)
2369 {
2370         bool *is_spi_i2c_slave_p = data;
2371
2372         if (ares->type != ACPI_RESOURCE_TYPE_SERIAL_BUS)
2373                 return 1;
2374
2375         /*
2376          * devices that are connected to UART still need to be enumerated to
2377          * platform bus
2378          */
2379         if (ares->data.common_serial_bus.type != ACPI_RESOURCE_SERIAL_TYPE_UART)
2380                 *is_spi_i2c_slave_p = true;
2381
2382          /* no need to do more checking */
2383         return -1;
2384 }
2385
2386 static void acpi_default_enumeration(struct acpi_device *device)
2387 {
2388         struct list_head resource_list;
2389         bool is_spi_i2c_slave = false;
2390
2391         if (!device->pnp.type.platform_id || device->handler)
2392                 return;
2393
2394         /*
2395          * Do not enemerate SPI/I2C slaves as they will be enuerated by their
2396          * respective parents.
2397          */
2398         INIT_LIST_HEAD(&resource_list);
2399         acpi_dev_get_resources(device, &resource_list, acpi_check_spi_i2c_slave,
2400                                &is_spi_i2c_slave);
2401         acpi_dev_free_resource_list(&resource_list);
2402         if (!is_spi_i2c_slave)
2403                 acpi_create_platform_device(device);
2404 }
2405
2406 static int acpi_scan_attach_handler(struct acpi_device *device)
2407 {
2408         struct acpi_hardware_id *hwid;
2409         int ret = 0;
2410
2411         list_for_each_entry(hwid, &device->pnp.ids, list) {
2412                 const struct acpi_device_id *devid;
2413                 struct acpi_scan_handler *handler;
2414
2415                 handler = acpi_scan_match_handler(hwid->id, &devid);
2416                 if (handler) {
2417                         if (!handler->attach) {
2418                                 device->pnp.type.platform_id = 0;
2419                                 continue;
2420                         }
2421                         device->handler = handler;
2422                         ret = handler->attach(device, devid);
2423                         if (ret > 0)
2424                                 break;
2425
2426                         device->handler = NULL;
2427                         if (ret < 0)
2428                                 break;
2429                 }
2430         }
2431         if (!ret)
2432                 acpi_default_enumeration(device);
2433
2434         return ret;
2435 }
2436
2437 static void acpi_bus_attach(struct acpi_device *device)
2438 {
2439         struct acpi_device *child;
2440         acpi_handle ejd;
2441         int ret;
2442
2443         if (ACPI_SUCCESS(acpi_bus_get_ejd(device->handle, &ejd)))
2444                 register_dock_dependent_device(device, ejd);
2445
2446         acpi_bus_get_status(device);
2447         /* Skip devices that are not present. */
2448         if (!acpi_device_is_present(device)) {
2449                 device->flags.visited = false;
2450                 device->flags.power_manageable = 0;
2451                 return;
2452         }
2453         if (device->handler)
2454                 goto ok;
2455
2456         if (!device->flags.initialized) {
2457                 device->flags.power_manageable =
2458                         device->power.states[ACPI_STATE_D0].flags.valid;
2459                 if (acpi_bus_init_power(device))
2460                         device->flags.power_manageable = 0;
2461
2462                 device->flags.initialized = true;
2463         }
2464         device->flags.visited = false;
2465         ret = acpi_scan_attach_handler(device);
2466         if (ret < 0)
2467                 return;
2468
2469         device->flags.match_driver = true;
2470         if (!ret) {
2471                 ret = device_attach(&device->dev);
2472                 if (ret < 0)
2473                         return;
2474         }
2475         device->flags.visited = true;
2476
2477  ok:
2478         list_for_each_entry(child, &device->children, node)
2479                 acpi_bus_attach(child);
2480
2481         if (device->handler && device->handler->hotplug.notify_online)
2482                 device->handler->hotplug.notify_online(device);
2483 }
2484
2485 void acpi_walk_dep_device_list(acpi_handle handle)
2486 {
2487         struct acpi_dep_data *dep, *tmp;
2488         struct acpi_device *adev;
2489
2490         mutex_lock(&acpi_dep_list_lock);
2491         list_for_each_entry_safe(dep, tmp, &acpi_dep_list, node) {
2492                 if (dep->master == handle) {
2493                         acpi_bus_get_device(dep->slave, &adev);
2494                         if (!adev)
2495                                 continue;
2496
2497                         adev->dep_unmet--;
2498                         if (!adev->dep_unmet)
2499                                 acpi_bus_attach(adev);
2500                         list_del(&dep->node);
2501                         kfree(dep);
2502                 }
2503         }
2504         mutex_unlock(&acpi_dep_list_lock);
2505 }
2506 EXPORT_SYMBOL_GPL(acpi_walk_dep_device_list);
2507
2508 /**
2509  * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
2510  * @handle: Root of the namespace scope to scan.
2511  *
2512  * Scan a given ACPI tree (probably recently hot-plugged) and create and add
2513  * found devices.
2514  *
2515  * If no devices were found, -ENODEV is returned, but it does not mean that
2516  * there has been a real error.  There just have been no suitable ACPI objects
2517  * in the table trunk from which the kernel could create a device and add an
2518  * appropriate driver.
2519  *
2520  * Must be called under acpi_scan_lock.
2521  */
2522 int acpi_bus_scan(acpi_handle handle)
2523 {
2524         void *device = NULL;
2525
2526         if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
2527                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
2528                                     acpi_bus_check_add, NULL, NULL, &device);
2529
2530         if (device) {
2531                 acpi_bus_attach(device);
2532                 return 0;
2533         }
2534         return -ENODEV;
2535 }
2536 EXPORT_SYMBOL(acpi_bus_scan);
2537
2538 /**
2539  * acpi_bus_trim - Detach scan handlers and drivers from ACPI device objects.
2540  * @adev: Root of the ACPI namespace scope to walk.
2541  *
2542  * Must be called under acpi_scan_lock.
2543  */
2544 void acpi_bus_trim(struct acpi_device *adev)
2545 {
2546         struct acpi_scan_handler *handler = adev->handler;
2547         struct acpi_device *child;
2548
2549         list_for_each_entry_reverse(child, &adev->children, node)
2550                 acpi_bus_trim(child);
2551
2552         adev->flags.match_driver = false;
2553         if (handler) {
2554                 if (handler->detach)
2555                         handler->detach(adev);
2556
2557                 adev->handler = NULL;
2558         } else {
2559                 device_release_driver(&adev->dev);
2560         }
2561         /*
2562          * Most likely, the device is going away, so put it into D3cold before
2563          * that.
2564          */
2565         acpi_device_set_power(adev, ACPI_STATE_D3_COLD);
2566         adev->flags.initialized = false;
2567         adev->flags.visited = false;
2568 }
2569 EXPORT_SYMBOL_GPL(acpi_bus_trim);
2570
2571 static int acpi_bus_scan_fixed(void)
2572 {
2573         int result = 0;
2574
2575         /*
2576          * Enumerate all fixed-feature devices.
2577          */
2578         if (!(acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON)) {
2579                 struct acpi_device *device = NULL;
2580
2581                 result = acpi_add_single_object(&device, NULL,
2582                                                 ACPI_BUS_TYPE_POWER_BUTTON,
2583                                                 ACPI_STA_DEFAULT);
2584                 if (result)
2585                         return result;
2586
2587                 device->flags.match_driver = true;
2588                 result = device_attach(&device->dev);
2589                 if (result < 0)
2590                         return result;
2591
2592                 device_init_wakeup(&device->dev, true);
2593         }
2594
2595         if (!(acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON)) {
2596                 struct acpi_device *device = NULL;
2597
2598                 result = acpi_add_single_object(&device, NULL,
2599                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
2600                                                 ACPI_STA_DEFAULT);
2601                 if (result)
2602                         return result;
2603
2604                 device->flags.match_driver = true;
2605                 result = device_attach(&device->dev);
2606         }
2607
2608         return result < 0 ? result : 0;
2609 }
2610
2611 int __init acpi_scan_init(void)
2612 {
2613         int result;
2614
2615         result = bus_register(&acpi_bus_type);
2616         if (result) {
2617                 /* We don't want to quit even if we failed to add suspend/resume */
2618                 printk(KERN_ERR PREFIX "Could not register bus type\n");
2619         }
2620
2621         acpi_pci_root_init();
2622         acpi_pci_link_init();
2623         acpi_processor_init();
2624         acpi_lpss_init();
2625         acpi_apd_init();
2626         acpi_cmos_rtc_init();
2627         acpi_container_init();
2628         acpi_memory_hotplug_init();
2629         acpi_pnp_init();
2630         acpi_int340x_thermal_init();
2631
2632         mutex_lock(&acpi_scan_lock);
2633         /*
2634          * Enumerate devices in the ACPI namespace.
2635          */
2636         result = acpi_bus_scan(ACPI_ROOT_OBJECT);
2637         if (result)
2638                 goto out;
2639
2640         result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
2641         if (result)
2642                 goto out;
2643
2644         /* Fixed feature devices do not exist on HW-reduced platform */
2645         if (!acpi_gbl_reduced_hardware) {
2646                 result = acpi_bus_scan_fixed();
2647                 if (result) {
2648                         acpi_detach_data(acpi_root->handle,
2649                                          acpi_scan_drop_device);
2650                         acpi_device_del(acpi_root);
2651                         put_device(&acpi_root->dev);
2652                         goto out;
2653                 }
2654         }
2655
2656         acpi_update_all_gpes();
2657
2658  out:
2659         mutex_unlock(&acpi_scan_lock);
2660         return result;
2661 }