drivers/acpi/scan.c

   1 /*
   2  * scan.c - support for transforming the ACPI namespace into individual objects
   3  */
   4
   5 #include <linux/module.h>
   6 #include <linux/init.h>
   7 #include <linux/slab.h>
   8 #include <linux/kernel.h>
   9 #include <linux/acpi.h>
  10 #include <linux/signal.h>
  11 #include <linux/kthread.h>
  12 #include <linux/dmi.h>
  13 #include <linux/nls.h>
  14
  15 #include <acpi/acpi_drivers.h>
  16
  17 #include "internal.h"
  18
  19 #define _COMPONENT              ACPI_BUS_COMPONENT
  20 ACPI_MODULE_NAME("scan");
  21 #define STRUCT_TO_INT(s)        (*((int*)&s))
  22 extern struct acpi_device *acpi_root;
  23
  24 #define ACPI_BUS_CLASS                  "system_bus"
  25 #define ACPI_BUS_HID                    "LNXSYBUS"
  26 #define ACPI_BUS_DEVICE_NAME            "System Bus"
  27
  28 #define ACPI_IS_ROOT_DEVICE(device)    (!(device)->parent)
  29
  30 static const char *dummy_hid = "device";
  31
  32 /*
  33  * The following ACPI IDs are known to be suitable for representing as
  34  * platform devices.
  35  */
  36 static const struct acpi_device_id acpi_platform_device_ids[] = {
  37
  38         { "PNP0D40" },
  39
  40         /* Haswell LPSS devices */
  41         { "INT33C0", 0 },
  42         { "INT33C1", 0 },
  43         { "INT33C2", 0 },
  44         { "INT33C3", 0 },
  45         { "INT33C4", 0 },
  46         { "INT33C5", 0 },
  47         { "INT33C6", 0 },
  48         { "INT33C7", 0 },
  49
  50         { }
  51 };
  52
  53 static LIST_HEAD(acpi_device_list);
  54 static LIST_HEAD(acpi_bus_id_list);
  55 static DEFINE_MUTEX(acpi_scan_lock);
  56 DEFINE_MUTEX(acpi_device_lock);
  57 LIST_HEAD(acpi_wakeup_device_list);
  58
  59 struct acpi_device_bus_id{
  60         char bus_id[15];
  61         unsigned int instance_no;
  62         struct list_head node;
  63 };
  64
  65 /*
  66  * Creates hid/cid(s) string needed for modalias and uevent
  67  * e.g. on a device with hid:IBM0001 and cid:ACPI0001 you get:
  68  * char *modalias: "acpi:IBM0001:ACPI0001"
  69 */
  70 static int create_modalias(struct acpi_device *acpi_dev, char *modalias,
  71                            int size)
  72 {
  73         int len;
  74         int count;
  75         struct acpi_hardware_id *id;
  76
  77         if (list_empty(&acpi_dev->pnp.ids))
  78                 return 0;
  79
  80         len = snprintf(modalias, size, "acpi:");
  81         size -= len;
  82
  83         list_for_each_entry(id, &acpi_dev->pnp.ids, list) {
  84                 count = snprintf(&modalias[len], size, "%s:", id->id);
  85                 if (count < 0 || count >= size)
  86                         return -EINVAL;
  87                 len += count;
  88                 size -= count;
  89         }
  90
  91         modalias[len] = '\0';
  92         return len;
  93 }
  94
  95 static ssize_t
  96 acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, char *buf) {
  97         struct acpi_device *acpi_dev = to_acpi_device(dev);
  98         int len;
  99
 100         /* Device has no HID and no CID or string is >1024 */
 101         len = create_modalias(acpi_dev, buf, 1024);
 102         if (len <= 0)
 103                 return 0;
 104         buf[len++] = '\n';
 105         return len;
 106 }
 107 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
 108
 109 /**
 110  * acpi_bus_hot_remove_device: hot-remove a device and its children
 111  * @context: struct acpi_eject_event pointer (freed in this func)
 112  *
 113  * Hot-remove a device and its children. This function frees up the
 114  * memory space passed by arg context, so that the caller may call
 115  * this function asynchronously through acpi_os_hotplug_execute().
 116  */
 117 void acpi_bus_hot_remove_device(void *context)
 118 {
 119         struct acpi_eject_event *ej_event = (struct acpi_eject_event *) context;
 120         struct acpi_device *device = ej_event->device;
 121         acpi_handle handle = device->handle;
 122         acpi_handle temp;
 123         struct acpi_object_list arg_list;
 124         union acpi_object arg;
 125         acpi_status status = AE_OK;
 126         u32 ost_code = ACPI_OST_SC_NON_SPECIFIC_FAILURE; /* default */
 127
 128         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 129                 "Hot-removing device %s...\n", dev_name(&device->dev)));
 130
 131         acpi_bus_trim(device);
 132         /* Device node has been released. */
 133         device = NULL;
 134
 135         /* power off device */
 136         status = acpi_evaluate_object(handle, "_PS3", NULL, NULL);
 137         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND)
 138                 printk(KERN_WARNING PREFIX
 139                                 "Power-off device failed\n");
 140
 141         if (ACPI_SUCCESS(acpi_get_handle(handle, "_LCK", &temp))) {
 142                 arg_list.count = 1;
 143                 arg_list.pointer = &arg;
 144                 arg.type = ACPI_TYPE_INTEGER;
 145                 arg.integer.value = 0;
 146                 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
 147         }
 148
 149         arg_list.count = 1;
 150         arg_list.pointer = &arg;
 151         arg.type = ACPI_TYPE_INTEGER;
 152         arg.integer.value = 1;
 153
 154         /*
 155          * TBD: _EJD support.
 156          */
 157         status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
 158         if (ACPI_FAILURE(status)) {
 159                 if (status != AE_NOT_FOUND)
 160                         printk(KERN_WARNING PREFIX
 161                                         "Eject device failed\n");
 162                 goto err_out;
 163         }
 164
 165         kfree(context);
 166         return;
 167
 168 err_out:
 169         /* Inform firmware the hot-remove operation has completed w/ error */
 170         (void) acpi_evaluate_hotplug_ost(handle,
 171                                 ej_event->event, ost_code, NULL);
 172         kfree(context);
 173         return;
 174 }
 175 EXPORT_SYMBOL(acpi_bus_hot_remove_device);
 176
 177 static ssize_t
 178 acpi_eject_store(struct device *d, struct device_attribute *attr,
 179                 const char *buf, size_t count)
 180 {
 181         int ret = count;
 182         acpi_status status;
 183         acpi_object_type type = 0;
 184         struct acpi_device *acpi_device = to_acpi_device(d);
 185         struct acpi_eject_event *ej_event;
 186
 187         if ((!count) || (buf[0] != '1')) {
 188                 return -EINVAL;
 189         }
 190 #ifndef FORCE_EJECT
 191         if (acpi_device->driver == NULL) {
 192                 ret = -ENODEV;
 193                 goto err;
 194         }
 195 #endif
 196         status = acpi_get_type(acpi_device->handle, &type);
 197         if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
 198                 ret = -ENODEV;
 199                 goto err;
 200         }
 201
 202         ej_event = kmalloc(sizeof(*ej_event), GFP_KERNEL);
 203         if (!ej_event) {
 204                 ret = -ENOMEM;
 205                 goto err;
 206         }
 207
 208         ej_event->device = acpi_device;
 209         if (acpi_device->flags.eject_pending) {
 210                 /* event originated from ACPI eject notification */
 211                 ej_event->event = ACPI_NOTIFY_EJECT_REQUEST;
 212                 acpi_device->flags.eject_pending = 0;
 213         } else {
 214                 /* event originated from user */
 215                 ej_event->event = ACPI_OST_EC_OSPM_EJECT;
 216                 (void) acpi_evaluate_hotplug_ost(acpi_device->handle,
 217                         ej_event->event, ACPI_OST_SC_EJECT_IN_PROGRESS, NULL);
 218         }
 219
 220         acpi_os_hotplug_execute(acpi_bus_hot_remove_device, (void *)ej_event);
 221 err:
 222         return ret;
 223 }
 224
 225 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
 226
 227 static ssize_t
 228 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
 229         struct acpi_device *acpi_dev = to_acpi_device(dev);
 230
 231         return sprintf(buf, "%s\n", acpi_device_hid(acpi_dev));
 232 }
 233 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 234
 235 static ssize_t acpi_device_uid_show(struct device *dev,
 236                                     struct device_attribute *attr, char *buf)
 237 {
 238         struct acpi_device *acpi_dev = to_acpi_device(dev);
 239
 240         return sprintf(buf, "%s\n", acpi_dev->pnp.unique_id);
 241 }
 242 static DEVICE_ATTR(uid, 0444, acpi_device_uid_show, NULL);
 243
 244 static ssize_t acpi_device_adr_show(struct device *dev,
 245                                     struct device_attribute *attr, char *buf)
 246 {
 247         struct acpi_device *acpi_dev = to_acpi_device(dev);
 248
 249         return sprintf(buf, "0x%08x\n",
 250                        (unsigned int)(acpi_dev->pnp.bus_address));
 251 }
 252 static DEVICE_ATTR(adr, 0444, acpi_device_adr_show, NULL);
 253
 254 static ssize_t
 255 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
 256         struct acpi_device *acpi_dev = to_acpi_device(dev);
 257         struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
 258         int result;
 259
 260         result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
 261         if (result)
 262                 goto end;
 263
 264         result = sprintf(buf, "%s\n", (char*)path.pointer);
 265         kfree(path.pointer);
 266 end:
 267         return result;
 268 }
 269 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
 270
 271 /* sysfs file that shows description text from the ACPI _STR method */
 272 static ssize_t description_show(struct device *dev,
 273                                 struct device_attribute *attr,
 274                                 char *buf) {
 275         struct acpi_device *acpi_dev = to_acpi_device(dev);
 276         int result;
 277
 278         if (acpi_dev->pnp.str_obj == NULL)
 279                 return 0;
 280
 281         /*
 282          * The _STR object contains a Unicode identifier for a device.
 283          * We need to convert to utf-8 so it can be displayed.
 284          */
 285         result = utf16s_to_utf8s(
 286                 (wchar_t *)acpi_dev->pnp.str_obj->buffer.pointer,
 287                 acpi_dev->pnp.str_obj->buffer.length,
 288                 UTF16_LITTLE_ENDIAN, buf,
 289                 PAGE_SIZE);
 290
 291         buf[result++] = '\n';
 292
 293         return result;
 294 }
 295 static DEVICE_ATTR(description, 0444, description_show, NULL);
 296
 297 static ssize_t
 298 acpi_device_sun_show(struct device *dev, struct device_attribute *attr,
 299                      char *buf) {
 300         struct acpi_device *acpi_dev = to_acpi_device(dev);
 301
 302         return sprintf(buf, "%lu\n", acpi_dev->pnp.sun);
 303 }
 304 static DEVICE_ATTR(sun, 0444, acpi_device_sun_show, NULL);
 305
 306 static int acpi_device_setup_files(struct acpi_device *dev)
 307 {
 308         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 309         acpi_status status;
 310         acpi_handle temp;
 311         unsigned long long sun;
 312         int result = 0;
 313
 314         /*
 315          * Devices gotten from FADT don't have a "path" attribute
 316          */
 317         if (dev->handle) {
 318                 result = device_create_file(&dev->dev, &dev_attr_path);
 319                 if (result)
 320                         goto end;
 321         }
 322
 323         if (!list_empty(&dev->pnp.ids)) {
 324                 result = device_create_file(&dev->dev, &dev_attr_hid);
 325                 if (result)
 326                         goto end;
 327
 328                 result = device_create_file(&dev->dev, &dev_attr_modalias);
 329                 if (result)
 330                         goto end;
 331         }
 332
 333         /*
 334          * If device has _STR, 'description' file is created
 335          */
 336         status = acpi_get_handle(dev->handle, "_STR", &temp);
 337         if (ACPI_SUCCESS(status)) {
 338                 status = acpi_evaluate_object(dev->handle, "_STR",
 339                                         NULL, &buffer);
 340                 if (ACPI_FAILURE(status))
 341                         buffer.pointer = NULL;
 342                 dev->pnp.str_obj = buffer.pointer;
 343                 result = device_create_file(&dev->dev, &dev_attr_description);
 344                 if (result)
 345                         goto end;
 346         }
 347
 348         if (dev->flags.bus_address)
 349                 result = device_create_file(&dev->dev, &dev_attr_adr);
 350         if (dev->pnp.unique_id)
 351                 result = device_create_file(&dev->dev, &dev_attr_uid);
 352
 353         status = acpi_evaluate_integer(dev->handle, "_SUN", NULL, &sun);
 354         if (ACPI_SUCCESS(status)) {
 355                 dev->pnp.sun = (unsigned long)sun;
 356                 result = device_create_file(&dev->dev, &dev_attr_sun);
 357                 if (result)
 358                         goto end;
 359         } else {
 360                 dev->pnp.sun = (unsigned long)-1;
 361         }
 362
 363         /*
 364          * If device has _EJ0, 'eject' file is created that is used to trigger
 365          * hot-removal function from userland.
 366          */
 367         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
 368         if (ACPI_SUCCESS(status))
 369                 result = device_create_file(&dev->dev, &dev_attr_eject);
 370 end:
 371         return result;
 372 }
 373
 374 static void acpi_device_remove_files(struct acpi_device *dev)
 375 {
 376         acpi_status status;
 377         acpi_handle temp;
 378
 379         /*
 380          * If device has _STR, remove 'description' file
 381          */
 382         status = acpi_get_handle(dev->handle, "_STR", &temp);
 383         if (ACPI_SUCCESS(status)) {
 384                 kfree(dev->pnp.str_obj);
 385                 device_remove_file(&dev->dev, &dev_attr_description);
 386         }
 387         /*
 388          * If device has _EJ0, remove 'eject' file.
 389          */
 390         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
 391         if (ACPI_SUCCESS(status))
 392                 device_remove_file(&dev->dev, &dev_attr_eject);
 393
 394         status = acpi_get_handle(dev->handle, "_SUN", &temp);
 395         if (ACPI_SUCCESS(status))
 396                 device_remove_file(&dev->dev, &dev_attr_sun);
 397
 398         if (dev->pnp.unique_id)
 399                 device_remove_file(&dev->dev, &dev_attr_uid);
 400         if (dev->flags.bus_address)
 401                 device_remove_file(&dev->dev, &dev_attr_adr);
 402         device_remove_file(&dev->dev, &dev_attr_modalias);
 403         device_remove_file(&dev->dev, &dev_attr_hid);
 404         if (dev->handle)
 405                 device_remove_file(&dev->dev, &dev_attr_path);
 406 }
 407 /* --------------------------------------------------------------------------
 408                         ACPI Bus operations
 409    -------------------------------------------------------------------------- */
 410
 411 static const struct acpi_device_id *__acpi_match_device(
 412         struct acpi_device *device, const struct acpi_device_id *ids)
 413 {
 414         const struct acpi_device_id *id;
 415         struct acpi_hardware_id *hwid;
 416
 417         /*
 418          * If the device is not present, it is unnecessary to load device
 419          * driver for it.
 420          */
 421         if (!device->status.present)
 422                 return NULL;
 423
 424         for (id = ids; id->id[0]; id++)
 425                 list_for_each_entry(hwid, &device->pnp.ids, list)
 426                         if (!strcmp((char *) id->id, hwid->id))
 427                                 return id;
 428
 429         return NULL;
 430 }
 431
 432 /**
 433  * acpi_match_device - Match a struct device against a given list of ACPI IDs
 434  * @ids: Array of struct acpi_device_id object to match against.
 435  * @dev: The device structure to match.
 436  *
 437  * Check if @dev has a valid ACPI handle and if there is a struct acpi_device
 438  * object for that handle and use that object to match against a given list of
 439  * device IDs.
 440  *
 441  * Return a pointer to the first matching ID on success or %NULL on failure.
 442  */
 443 const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
 444                                                const struct device *dev)
 445 {
 446         struct acpi_device *adev;
 447         acpi_handle handle = ACPI_HANDLE(dev);
 448
 449         if (!ids || !handle || acpi_bus_get_device(handle, &adev))
 450                 return NULL;
 451
 452         return __acpi_match_device(adev, ids);
 453 }
 454 EXPORT_SYMBOL_GPL(acpi_match_device);
 455
 456 int acpi_match_device_ids(struct acpi_device *device,
 457                           const struct acpi_device_id *ids)
 458 {
 459         return __acpi_match_device(device, ids) ? 0 : -ENOENT;
 460 }
 461 EXPORT_SYMBOL(acpi_match_device_ids);
 462
 463 static void acpi_free_ids(struct acpi_device *device)
 464 {
 465         struct acpi_hardware_id *id, *tmp;
 466
 467         list_for_each_entry_safe(id, tmp, &device->pnp.ids, list) {
 468                 kfree(id->id);
 469                 kfree(id);
 470         }
 471 }
 472
 473 static void acpi_device_release(struct device *dev)
 474 {
 475         struct acpi_device *acpi_dev = to_acpi_device(dev);
 476
 477         acpi_free_ids(acpi_dev);
 478         kfree(acpi_dev->pnp.unique_id);
 479         kfree(acpi_dev);
 480 }
 481
 482 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 483 {
 484         struct acpi_device *acpi_dev = to_acpi_device(dev);
 485         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 486
 487         return acpi_dev->flags.match_driver
 488                 && !acpi_match_device_ids(acpi_dev, acpi_drv->ids);
 489 }
 490
 491 static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 492 {
 493         struct acpi_device *acpi_dev = to_acpi_device(dev);
 494         int len;
 495
 496         if (list_empty(&acpi_dev->pnp.ids))
 497                 return 0;
 498
 499         if (add_uevent_var(env, "MODALIAS="))
 500                 return -ENOMEM;
 501         len = create_modalias(acpi_dev, &env->buf[env->buflen - 1],
 502                               sizeof(env->buf) - env->buflen);
 503         if (len >= (sizeof(env->buf) - env->buflen))
 504                 return -ENOMEM;
 505         env->buflen += len;
 506         return 0;
 507 }
 508
 509 static void acpi_device_notify(acpi_handle handle, u32 event, void *data)
 510 {
 511         struct acpi_device *device = data;
 512
 513         device->driver->ops.notify(device, event);
 514 }
 515
 516 static acpi_status acpi_device_notify_fixed(void *data)
 517 {
 518         struct acpi_device *device = data;
 519
 520         /* Fixed hardware devices have no handles */
 521         acpi_device_notify(NULL, ACPI_FIXED_HARDWARE_EVENT, device);
 522         return AE_OK;
 523 }
 524
 525 static int acpi_device_install_notify_handler(struct acpi_device *device)
 526 {
 527         acpi_status status;
 528
 529         if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
 530                 status =
 531                     acpi_install_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
 532                                                      acpi_device_notify_fixed,
 533                                                      device);
 534         else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
 535                 status =
 536                     acpi_install_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
 537                                                      acpi_device_notify_fixed,
 538                                                      device);
 539         else
 540                 status = acpi_install_notify_handler(device->handle,
 541                                                      ACPI_DEVICE_NOTIFY,
 542                                                      acpi_device_notify,
 543                                                      device);
 544
 545         if (ACPI_FAILURE(status))
 546                 return -EINVAL;
 547         return 0;
 548 }
 549
 550 static void acpi_device_remove_notify_handler(struct acpi_device *device)
 551 {
 552         if (device->device_type == ACPI_BUS_TYPE_POWER_BUTTON)
 553                 acpi_remove_fixed_event_handler(ACPI_EVENT_POWER_BUTTON,
 554                                                 acpi_device_notify_fixed);
 555         else if (device->device_type == ACPI_BUS_TYPE_SLEEP_BUTTON)
 556                 acpi_remove_fixed_event_handler(ACPI_EVENT_SLEEP_BUTTON,
 557                                                 acpi_device_notify_fixed);
 558         else
 559                 acpi_remove_notify_handler(device->handle, ACPI_DEVICE_NOTIFY,
 560                                            acpi_device_notify);
 561 }
 562
 563 static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
 564 static int acpi_device_probe(struct device * dev)
 565 {
 566         struct acpi_device *acpi_dev = to_acpi_device(dev);
 567         struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
 568         int ret;
 569
 570         ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
 571         if (!ret) {
 572                 if (acpi_drv->ops.notify) {
 573                         ret = acpi_device_install_notify_handler(acpi_dev);
 574                         if (ret) {
 575                                 if (acpi_drv->ops.remove)
 576                                         acpi_drv->ops.remove(acpi_dev,
 577                                                      acpi_dev->removal_type);
 578                                 return ret;
 579                         }
 580                 }
 581
 582                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 583                         "Found driver [%s] for device [%s]\n",
 584                         acpi_drv->name, acpi_dev->pnp.bus_id));
 585                 get_device(dev);
 586         }
 587         return ret;
 588 }
 589
 590 static int acpi_device_remove(struct device * dev)
 591 {
 592         struct acpi_device *acpi_dev = to_acpi_device(dev);
 593         struct acpi_driver *acpi_drv = acpi_dev->driver;
 594
 595         if (acpi_drv) {
 596                 if (acpi_drv->ops.notify)
 597                         acpi_device_remove_notify_handler(acpi_dev);
 598                 if (acpi_drv->ops.remove)
 599                         acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
 600         }
 601         acpi_dev->driver = NULL;
 602         acpi_dev->driver_data = NULL;
 603
 604         put_device(dev);
 605         return 0;
 606 }
 607
 608 struct bus_type acpi_bus_type = {
 609         .name           = "acpi",
 610         .match          = acpi_bus_match,
 611         .probe          = acpi_device_probe,
 612         .remove         = acpi_device_remove,
 613         .uevent         = acpi_device_uevent,
 614 };
 615
 616 static int acpi_device_register(struct acpi_device *device)
 617 {
 618         int result;
 619         struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
 620         int found = 0;
 621
 622         /*
 623          * Linkage
 624          * -------
 625          * Link this device to its parent and siblings.
 626          */
 627         INIT_LIST_HEAD(&device->children);
 628         INIT_LIST_HEAD(&device->node);
 629         INIT_LIST_HEAD(&device->wakeup_list);
 630         INIT_LIST_HEAD(&device->physical_node_list);
 631         mutex_init(&device->physical_node_lock);
 632
 633         new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
 634         if (!new_bus_id) {
 635                 printk(KERN_ERR PREFIX "Memory allocation error\n");
 636                 return -ENOMEM;
 637         }
 638
 639         mutex_lock(&acpi_device_lock);
 640         /*
 641          * Find suitable bus_id and instance number in acpi_bus_id_list
 642          * If failed, create one and link it into acpi_bus_id_list
 643          */
 644         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
 645                 if (!strcmp(acpi_device_bus_id->bus_id,
 646                             acpi_device_hid(device))) {
 647                         acpi_device_bus_id->instance_no++;
 648                         found = 1;
 649                         kfree(new_bus_id);
 650                         break;
 651                 }
 652         }
 653         if (!found) {
 654                 acpi_device_bus_id = new_bus_id;
 655                 strcpy(acpi_device_bus_id->bus_id, acpi_device_hid(device));
 656                 acpi_device_bus_id->instance_no = 0;
 657                 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
 658         }
 659         dev_set_name(&device->dev, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
 660
 661         if (device->parent)
 662                 list_add_tail(&device->node, &device->parent->children);
 663
 664         if (device->wakeup.flags.valid)
 665                 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
 666         mutex_unlock(&acpi_device_lock);
 667
 668         if (device->parent)
 669                 device->dev.parent = &device->parent->dev;
 670         device->dev.bus = &acpi_bus_type;
 671         device->dev.release = &acpi_device_release;
 672         result = device_register(&device->dev);
 673         if (result) {
 674                 dev_err(&device->dev, "Error registering device\n");
 675                 goto end;
 676         }
 677
 678         result = acpi_device_setup_files(device);
 679         if (result)
 680                 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
 681                        dev_name(&device->dev));
 682
 683         device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
 684         return 0;
 685 end:
 686         mutex_lock(&acpi_device_lock);
 687         if (device->parent)
 688                 list_del(&device->node);
 689         list_del(&device->wakeup_list);
 690         mutex_unlock(&acpi_device_lock);
 691         return result;
 692 }
 693
 694 static void acpi_device_unregister(struct acpi_device *device)
 695 {
 696         mutex_lock(&acpi_device_lock);
 697         if (device->parent)
 698                 list_del(&device->node);
 699
 700         list_del(&device->wakeup_list);
 701         mutex_unlock(&acpi_device_lock);
 702
 703         acpi_detach_data(device->handle, acpi_bus_data_handler);
 704
 705         acpi_device_remove_files(device);
 706         device_unregister(&device->dev);
 707 }
 708
 709 /* --------------------------------------------------------------------------
 710                                  Driver Management
 711    -------------------------------------------------------------------------- */
 712 /**
 713  * acpi_bus_driver_init - add a device to a driver
 714  * @device: the device to add and initialize
 715  * @driver: driver for the device
 716  *
 717  * Used to initialize a device via its device driver.  Called whenever a
 718  * driver is bound to a device.  Invokes the driver's add() ops.
 719  */
 720 static int
 721 acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
 722 {
 723         int result = 0;
 724
 725         if (!device || !driver)
 726                 return -EINVAL;
 727
 728         if (!driver->ops.add)
 729                 return -ENOSYS;
 730
 731         result = driver->ops.add(device);
 732         if (result) {
 733                 device->driver = NULL;
 734                 device->driver_data = NULL;
 735                 return result;
 736         }
 737
 738         device->driver = driver;
 739
 740         /*
 741          * TBD - Configuration Management: Assign resources to device based
 742          * upon possible configuration and currently allocated resources.
 743          */
 744
 745         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 746                           "Driver successfully bound to device\n"));
 747         return 0;
 748 }
 749
 750 /**
 751  * acpi_bus_register_driver - register a driver with the ACPI bus
 752  * @driver: driver being registered
 753  *
 754  * Registers a driver with the ACPI bus.  Searches the namespace for all
 755  * devices that match the driver's criteria and binds.  Returns zero for
 756  * success or a negative error status for failure.
 757  */
 758 int acpi_bus_register_driver(struct acpi_driver *driver)
 759 {
 760         int ret;
 761
 762         if (acpi_disabled)
 763                 return -ENODEV;
 764         driver->drv.name = driver->name;
 765         driver->drv.bus = &acpi_bus_type;
 766         driver->drv.owner = driver->owner;
 767
 768         ret = driver_register(&driver->drv);
 769         return ret;
 770 }
 771
 772 EXPORT_SYMBOL(acpi_bus_register_driver);
 773
 774 /**
 775  * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
 776  * @driver: driver to unregister
 777  *
 778  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
 779  * devices that match the driver's criteria and unbinds.
 780  */
 781 void acpi_bus_unregister_driver(struct acpi_driver *driver)
 782 {
 783         driver_unregister(&driver->drv);
 784 }
 785
 786 EXPORT_SYMBOL(acpi_bus_unregister_driver);
 787
 788 /* --------------------------------------------------------------------------
 789                                  Device Enumeration
 790    -------------------------------------------------------------------------- */
 791 static struct acpi_device *acpi_bus_get_parent(acpi_handle handle)
 792 {
 793         acpi_status status;
 794         int ret;
 795         struct acpi_device *device;
 796
 797         /*
 798          * Fixed hardware devices do not appear in the namespace and do not
 799          * have handles, but we fabricate acpi_devices for them, so we have
 800          * to deal with them specially.
 801          */
 802         if (handle == NULL)
 803                 return acpi_root;
 804
 805         do {
 806                 status = acpi_get_parent(handle, &handle);
 807                 if (status == AE_NULL_ENTRY)
 808                         return NULL;
 809                 if (ACPI_FAILURE(status))
 810                         return acpi_root;
 811
 812                 ret = acpi_bus_get_device(handle, &device);
 813                 if (ret == 0)
 814                         return device;
 815         } while (1);
 816 }
 817
 818 acpi_status
 819 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
 820 {
 821         acpi_status status;
 822         acpi_handle tmp;
 823         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 824         union acpi_object *obj;
 825
 826         status = acpi_get_handle(handle, "_EJD", &tmp);
 827         if (ACPI_FAILURE(status))
 828                 return status;
 829
 830         status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
 831         if (ACPI_SUCCESS(status)) {
 832                 obj = buffer.pointer;
 833                 status = acpi_get_handle(ACPI_ROOT_OBJECT, obj->string.pointer,
 834                                          ejd);
 835                 kfree(buffer.pointer);
 836         }
 837         return status;
 838 }
 839 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
 840
 841 void acpi_bus_data_handler(acpi_handle handle, void *context)
 842 {
 843
 844         /* TBD */
 845
 846         return;
 847 }
 848
 849 static int acpi_bus_get_perf_flags(struct acpi_device *device)
 850 {
 851         device->performance.state = ACPI_STATE_UNKNOWN;
 852         return 0;
 853 }
 854
 855 static acpi_status
 856 acpi_bus_extract_wakeup_device_power_package(acpi_handle handle,
 857                                              struct acpi_device_wakeup *wakeup)
 858 {
 859         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 860         union acpi_object *package = NULL;
 861         union acpi_object *element = NULL;
 862         acpi_status status;
 863         int i = 0;
 864
 865         if (!wakeup)
 866                 return AE_BAD_PARAMETER;
 867
 868         /* _PRW */
 869         status = acpi_evaluate_object(handle, "_PRW", NULL, &buffer);
 870         if (ACPI_FAILURE(status)) {
 871                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
 872                 return status;
 873         }
 874
 875         package = (union acpi_object *)buffer.pointer;
 876
 877         if (!package || (package->package.count < 2)) {
 878                 status = AE_BAD_DATA;
 879                 goto out;
 880         }
 881
 882         element = &(package->package.elements[0]);
 883         if (!element) {
 884                 status = AE_BAD_DATA;
 885                 goto out;
 886         }
 887         if (element->type == ACPI_TYPE_PACKAGE) {
 888                 if ((element->package.count < 2) ||
 889                     (element->package.elements[0].type !=
 890                      ACPI_TYPE_LOCAL_REFERENCE)
 891                     || (element->package.elements[1].type != ACPI_TYPE_INTEGER)) {
 892                         status = AE_BAD_DATA;
 893                         goto out;
 894                 }
 895                 wakeup->gpe_device =
 896                     element->package.elements[0].reference.handle;
 897                 wakeup->gpe_number =
 898                     (u32) element->package.elements[1].integer.value;
 899         } else if (element->type == ACPI_TYPE_INTEGER) {
 900                 wakeup->gpe_device = NULL;
 901                 wakeup->gpe_number = element->integer.value;
 902         } else {
 903                 status = AE_BAD_DATA;
 904                 goto out;
 905         }
 906
 907         element = &(package->package.elements[1]);
 908         if (element->type != ACPI_TYPE_INTEGER) {
 909                 status = AE_BAD_DATA;
 910                 goto out;
 911         }
 912         wakeup->sleep_state = element->integer.value;
 913
 914         if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
 915                 status = AE_NO_MEMORY;
 916                 goto out;
 917         }
 918         wakeup->resources.count = package->package.count - 2;
 919         for (i = 0; i < wakeup->resources.count; i++) {
 920                 element = &(package->package.elements[i + 2]);
 921                 if (element->type != ACPI_TYPE_LOCAL_REFERENCE) {
 922                         status = AE_BAD_DATA;
 923                         goto out;
 924                 }
 925
 926                 wakeup->resources.handles[i] = element->reference.handle;
 927         }
 928
 929         acpi_setup_gpe_for_wake(handle, wakeup->gpe_device, wakeup->gpe_number);
 930
 931  out:
 932         kfree(buffer.pointer);
 933
 934         return status;
 935 }
 936
 937 static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
 938 {
 939         struct acpi_device_id button_device_ids[] = {
 940                 {"PNP0C0C", 0},
 941                 {"PNP0C0D", 0},
 942                 {"PNP0C0E", 0},
 943                 {"", 0},
 944         };
 945         acpi_status status;
 946         acpi_event_status event_status;
 947
 948         device->wakeup.flags.notifier_present = 0;
 949
 950         /* Power button, Lid switch always enable wakeup */
 951         if (!acpi_match_device_ids(device, button_device_ids)) {
 952                 device->wakeup.flags.run_wake = 1;
 953                 if (!acpi_match_device_ids(device, &button_device_ids[1])) {
 954                         /* Do not use Lid/sleep button for S5 wakeup */
 955                         if (device->wakeup.sleep_state == ACPI_STATE_S5)
 956                                 device->wakeup.sleep_state = ACPI_STATE_S4;
 957                 }
 958                 device_set_wakeup_capable(&device->dev, true);
 959                 return;
 960         }
 961
 962         status = acpi_get_gpe_status(device->wakeup.gpe_device,
 963                                         device->wakeup.gpe_number,
 964                                                 &event_status);
 965         if (status == AE_OK)
 966                 device->wakeup.flags.run_wake =
 967                                 !!(event_status & ACPI_EVENT_FLAG_HANDLE);
 968 }
 969
 970 static void acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
 971 {
 972         acpi_handle temp;
 973         acpi_status status = 0;
 974         int psw_error;
 975
 976         /* Presence of _PRW indicates wake capable */
 977         status = acpi_get_handle(device->handle, "_PRW", &temp);
 978         if (ACPI_FAILURE(status))
 979                 return;
 980
 981         status = acpi_bus_extract_wakeup_device_power_package(device->handle,
 982                                                               &device->wakeup);
 983         if (ACPI_FAILURE(status)) {
 984                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
 985                 return;
 986         }
 987
 988         device->wakeup.flags.valid = 1;
 989         device->wakeup.prepare_count = 0;
 990         acpi_bus_set_run_wake_flags(device);
 991         /* Call _PSW/_DSW object to disable its ability to wake the sleeping
 992          * system for the ACPI device with the _PRW object.
 993          * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
 994          * So it is necessary to call _DSW object first. Only when it is not
 995          * present will the _PSW object used.
 996          */
 997         psw_error = acpi_device_sleep_wake(device, 0, 0, 0);
 998         if (psw_error)
 999                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1000                                 "error in _DSW or _PSW evaluation\n"));
1001 }
1002
1003 static void acpi_bus_add_power_resource(acpi_handle handle);
1004
1005 static int acpi_bus_get_power_flags(struct acpi_device *device)
1006 {
1007         acpi_status status = 0;
1008         acpi_handle handle = NULL;
1009         u32 i = 0;
1010
1011
1012         /*
1013          * Power Management Flags
1014          */
1015         status = acpi_get_handle(device->handle, "_PSC", &handle);
1016         if (ACPI_SUCCESS(status))
1017                 device->power.flags.explicit_get = 1;
1018         status = acpi_get_handle(device->handle, "_IRC", &handle);
1019         if (ACPI_SUCCESS(status))
1020                 device->power.flags.inrush_current = 1;
1021
1022         /*
1023          * Enumerate supported power management states
1024          */
1025         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3_HOT; i++) {
1026                 struct acpi_device_power_state *ps = &device->power.states[i];
1027                 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
1028
1029                 /* Evaluate "_PRx" to se if power resources are referenced */
1030                 acpi_evaluate_reference(device->handle, object_name, NULL,
1031                                         &ps->resources);
1032                 if (ps->resources.count) {
1033                         int j;
1034
1035                         device->power.flags.power_resources = 1;
1036                         for (j = 0; j < ps->resources.count; j++)
1037                                 acpi_bus_add_power_resource(ps->resources.handles[j]);
1038                 }
1039
1040                 /* Evaluate "_PSx" to see if we can do explicit sets */
1041                 object_name[2] = 'S';
1042                 status = acpi_get_handle(device->handle, object_name, &handle);
1043                 if (ACPI_SUCCESS(status))
1044                         ps->flags.explicit_set = 1;
1045
1046                 /*
1047                  * State is valid if there are means to put the device into it.
1048                  * D3hot is only valid if _PR3 present.
1049                  */
1050                 if (ps->resources.count ||
1051                     (ps->flags.explicit_set && i < ACPI_STATE_D3_HOT)) {
1052                         ps->flags.valid = 1;
1053                         ps->flags.os_accessible = 1;
1054                 }
1055
1056                 ps->power = -1; /* Unknown - driver assigned */
1057                 ps->latency = -1;       /* Unknown - driver assigned */
1058         }
1059
1060         /* Set defaults for D0 and D3 states (always valid) */
1061         device->power.states[ACPI_STATE_D0].flags.valid = 1;
1062         device->power.states[ACPI_STATE_D0].power = 100;
1063         device->power.states[ACPI_STATE_D3].flags.valid = 1;
1064         device->power.states[ACPI_STATE_D3].power = 0;
1065
1066         /* Set D3cold's explicit_set flag if _PS3 exists. */
1067         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set)
1068                 device->power.states[ACPI_STATE_D3_COLD].flags.explicit_set = 1;
1069
1070         /* Presence of _PS3 or _PRx means we can put the device into D3 cold */
1071         if (device->power.states[ACPI_STATE_D3_HOT].flags.explicit_set ||
1072                         device->power.flags.power_resources)
1073                 device->power.states[ACPI_STATE_D3_COLD].flags.os_accessible = 1;
1074
1075         acpi_bus_init_power(device);
1076
1077         return 0;
1078 }
1079
1080 static int acpi_bus_get_flags(struct acpi_device *device)
1081 {
1082         acpi_status status = AE_OK;
1083         acpi_handle temp = NULL;
1084
1085
1086         /* Presence of _STA indicates 'dynamic_status' */
1087         status = acpi_get_handle(device->handle, "_STA", &temp);
1088         if (ACPI_SUCCESS(status))
1089                 device->flags.dynamic_status = 1;
1090
1091         /* Presence of _RMV indicates 'removable' */
1092         status = acpi_get_handle(device->handle, "_RMV", &temp);
1093         if (ACPI_SUCCESS(status))
1094                 device->flags.removable = 1;
1095
1096         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
1097         status = acpi_get_handle(device->handle, "_EJD", &temp);
1098         if (ACPI_SUCCESS(status))
1099                 device->flags.ejectable = 1;
1100         else {
1101                 status = acpi_get_handle(device->handle, "_EJ0", &temp);
1102                 if (ACPI_SUCCESS(status))
1103                         device->flags.ejectable = 1;
1104         }
1105
1106         /* Power resources cannot be power manageable. */
1107         if (device->device_type == ACPI_BUS_TYPE_POWER)
1108                 return 0;
1109
1110         /* Presence of _PS0|_PR0 indicates 'power manageable' */
1111         status = acpi_get_handle(device->handle, "_PS0", &temp);
1112         if (ACPI_FAILURE(status))
1113                 status = acpi_get_handle(device->handle, "_PR0", &temp);
1114         if (ACPI_SUCCESS(status))
1115                 device->flags.power_manageable = 1;
1116
1117         /* TBD: Performance management */
1118
1119         return 0;
1120 }
1121
1122 static void acpi_device_get_busid(struct acpi_device *device)
1123 {
1124         char bus_id[5] = { '?', 0 };
1125         struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
1126         int i = 0;
1127
1128         /*
1129          * Bus ID
1130          * ------
1131          * The device's Bus ID is simply the object name.
1132          * TBD: Shouldn't this value be unique (within the ACPI namespace)?
1133          */
1134         if (ACPI_IS_ROOT_DEVICE(device)) {
1135                 strcpy(device->pnp.bus_id, "ACPI");
1136                 return;
1137         }
1138
1139         switch (device->device_type) {
1140         case ACPI_BUS_TYPE_POWER_BUTTON:
1141                 strcpy(device->pnp.bus_id, "PWRF");
1142                 break;
1143         case ACPI_BUS_TYPE_SLEEP_BUTTON:
1144                 strcpy(device->pnp.bus_id, "SLPF");
1145                 break;
1146         default:
1147                 acpi_get_name(device->handle, ACPI_SINGLE_NAME, &buffer);
1148                 /* Clean up trailing underscores (if any) */
1149                 for (i = 3; i > 1; i--) {
1150                         if (bus_id[i] == '_')
1151                                 bus_id[i] = '\0';
1152                         else
1153                                 break;
1154                 }
1155                 strcpy(device->pnp.bus_id, bus_id);
1156                 break;
1157         }
1158 }
1159
1160 /*
1161  * acpi_bay_match - see if a device is an ejectable driver bay
1162  *
1163  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
1164  * then we can safely call it an ejectable drive bay
1165  */
1166 static int acpi_bay_match(struct acpi_device *device){
1167         acpi_status status;
1168         acpi_handle handle;
1169         acpi_handle tmp;
1170         acpi_handle phandle;
1171
1172         handle = device->handle;
1173
1174         status = acpi_get_handle(handle, "_EJ0", &tmp);
1175         if (ACPI_FAILURE(status))
1176                 return -ENODEV;
1177
1178         if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
1179                 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
1180                 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
1181                 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
1182                 return 0;
1183
1184         if (acpi_get_parent(handle, &phandle))
1185                 return -ENODEV;
1186
1187         if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
1188                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
1189                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
1190                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
1191                 return 0;
1192
1193         return -ENODEV;
1194 }
1195
1196 /*
1197  * acpi_dock_match - see if a device has a _DCK method
1198  */
1199 static int acpi_dock_match(struct acpi_device *device)
1200 {
1201         acpi_handle tmp;
1202         return acpi_get_handle(device->handle, "_DCK", &tmp);
1203 }
1204
1205 const char *acpi_device_hid(struct acpi_device *device)
1206 {
1207         struct acpi_hardware_id *hid;
1208
1209         if (list_empty(&device->pnp.ids))
1210                 return dummy_hid;
1211
1212         hid = list_first_entry(&device->pnp.ids, struct acpi_hardware_id, list);
1213         return hid->id;
1214 }
1215 EXPORT_SYMBOL(acpi_device_hid);
1216
1217 static void acpi_add_id(struct acpi_device *device, const char *dev_id)
1218 {
1219         struct acpi_hardware_id *id;
1220
1221         id = kmalloc(sizeof(*id), GFP_KERNEL);
1222         if (!id)
1223                 return;
1224
1225         id->id = kstrdup(dev_id, GFP_KERNEL);
1226         if (!id->id) {
1227                 kfree(id);
1228                 return;
1229         }
1230
1231         list_add_tail(&id->list, &device->pnp.ids);
1232 }
1233
1234 /*
1235  * Old IBM workstations have a DSDT bug wherein the SMBus object
1236  * lacks the SMBUS01 HID and the methods do not have the necessary "_"
1237  * prefix.  Work around this.
1238  */
1239 static int acpi_ibm_smbus_match(struct acpi_device *device)
1240 {
1241         acpi_handle h_dummy;
1242         struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
1243         int result;
1244
1245         if (!dmi_name_in_vendors("IBM"))
1246                 return -ENODEV;
1247
1248         /* Look for SMBS object */
1249         result = acpi_get_name(device->handle, ACPI_SINGLE_NAME, &path);
1250         if (result)
1251                 return result;
1252
1253         if (strcmp("SMBS", path.pointer)) {
1254                 result = -ENODEV;
1255                 goto out;
1256         }
1257
1258         /* Does it have the necessary (but misnamed) methods? */
1259         result = -ENODEV;
1260         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "SBI", &h_dummy)) &&
1261             ACPI_SUCCESS(acpi_get_handle(device->handle, "SBR", &h_dummy)) &&
1262             ACPI_SUCCESS(acpi_get_handle(device->handle, "SBW", &h_dummy)))
1263                 result = 0;
1264 out:
1265         kfree(path.pointer);
1266         return result;
1267 }
1268
1269 static void acpi_device_set_id(struct acpi_device *device)
1270 {
1271         acpi_status status;
1272         struct acpi_device_info *info;
1273         struct acpi_pnp_device_id_list *cid_list;
1274         int i;
1275
1276         switch (device->device_type) {
1277         case ACPI_BUS_TYPE_DEVICE:
1278                 if (ACPI_IS_ROOT_DEVICE(device)) {
1279                         acpi_add_id(device, ACPI_SYSTEM_HID);
1280                         break;
1281                 }
1282
1283                 status = acpi_get_object_info(device->handle, &info);
1284                 if (ACPI_FAILURE(status)) {
1285                         printk(KERN_ERR PREFIX "%s: Error reading device info\n", __func__);
1286                         return;
1287                 }
1288
1289                 if (info->valid & ACPI_VALID_HID)
1290                         acpi_add_id(device, info->hardware_id.string);
1291                 if (info->valid & ACPI_VALID_CID) {
1292                         cid_list = &info->compatible_id_list;
1293                         for (i = 0; i < cid_list->count; i++)
1294                                 acpi_add_id(device, cid_list->ids[i].string);
1295                 }
1296                 if (info->valid & ACPI_VALID_ADR) {
1297                         device->pnp.bus_address = info->address;
1298                         device->flags.bus_address = 1;
1299                 }
1300                 if (info->valid & ACPI_VALID_UID)
1301                         device->pnp.unique_id = kstrdup(info->unique_id.string,
1302                                                         GFP_KERNEL);
1303
1304                 kfree(info);
1305
1306                 /*
1307                  * Some devices don't reliably have _HIDs & _CIDs, so add
1308                  * synthetic HIDs to make sure drivers can find them.
1309                  */
1310                 if (acpi_is_video_device(device))
1311                         acpi_add_id(device, ACPI_VIDEO_HID);
1312                 else if (ACPI_SUCCESS(acpi_bay_match(device)))
1313                         acpi_add_id(device, ACPI_BAY_HID);
1314                 else if (ACPI_SUCCESS(acpi_dock_match(device)))
1315                         acpi_add_id(device, ACPI_DOCK_HID);
1316                 else if (!acpi_ibm_smbus_match(device))
1317                         acpi_add_id(device, ACPI_SMBUS_IBM_HID);
1318                 else if (list_empty(&device->pnp.ids) &&
1319                          ACPI_IS_ROOT_DEVICE(device->parent)) {
1320                         acpi_add_id(device, ACPI_BUS_HID); /* \_SB, LNXSYBUS */
1321                         strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
1322                         strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
1323                 }
1324
1325                 break;
1326         case ACPI_BUS_TYPE_POWER:
1327                 acpi_add_id(device, ACPI_POWER_HID);
1328                 break;
1329         case ACPI_BUS_TYPE_PROCESSOR:
1330                 acpi_add_id(device, ACPI_PROCESSOR_OBJECT_HID);
1331                 break;
1332         case ACPI_BUS_TYPE_THERMAL:
1333                 acpi_add_id(device, ACPI_THERMAL_HID);
1334                 break;
1335         case ACPI_BUS_TYPE_POWER_BUTTON:
1336                 acpi_add_id(device, ACPI_BUTTON_HID_POWERF);
1337                 break;
1338         case ACPI_BUS_TYPE_SLEEP_BUTTON:
1339                 acpi_add_id(device, ACPI_BUTTON_HID_SLEEPF);
1340                 break;
1341         }
1342 }
1343
1344 static int acpi_device_set_context(struct acpi_device *device)
1345 {
1346         acpi_status status;
1347
1348         /*
1349          * Context
1350          * -------
1351          * Attach this 'struct acpi_device' to the ACPI object.  This makes
1352          * resolutions from handle->device very efficient.  Fixed hardware
1353          * devices have no handles, so we skip them.
1354          */
1355         if (!device->handle)
1356                 return 0;
1357
1358         status = acpi_attach_data(device->handle,
1359                                   acpi_bus_data_handler, device);
1360         if (ACPI_SUCCESS(status))
1361                 return 0;
1362
1363         printk(KERN_ERR PREFIX "Error attaching device data\n");
1364         return -ENODEV;
1365 }
1366
1367 static int acpi_add_single_object(struct acpi_device **child,
1368                                   acpi_handle handle, int type,
1369                                   unsigned long long sta, bool match_driver)
1370 {
1371         int result;
1372         struct acpi_device *device;
1373         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1374
1375         device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1376         if (!device) {
1377                 printk(KERN_ERR PREFIX "Memory allocation error\n");
1378                 return -ENOMEM;
1379         }
1380
1381         INIT_LIST_HEAD(&device->pnp.ids);
1382         device->device_type = type;
1383         device->handle = handle;
1384         device->parent = acpi_bus_get_parent(handle);
1385         STRUCT_TO_INT(device->status) = sta;
1386
1387         acpi_device_get_busid(device);
1388
1389         /*
1390          * Flags
1391          * -----
1392          * Note that we only look for object handles -- cannot evaluate objects
1393          * until we know the device is present and properly initialized.
1394          */
1395         result = acpi_bus_get_flags(device);
1396         if (result)
1397                 goto end;
1398
1399         /*
1400          * Initialize Device
1401          * -----------------
1402          * TBD: Synch with Core's enumeration/initialization process.
1403          */
1404         acpi_device_set_id(device);
1405
1406         /*
1407          * Power Management
1408          * ----------------
1409          */
1410         if (device->flags.power_manageable) {
1411                 result = acpi_bus_get_power_flags(device);
1412                 if (result)
1413                         goto end;
1414         }
1415
1416         /*
1417          * Wakeup device management
1418          *-----------------------
1419          */
1420         acpi_bus_get_wakeup_device_flags(device);
1421
1422         /*
1423          * Performance Management
1424          * ----------------------
1425          */
1426         if (device->flags.performance_manageable) {
1427                 result = acpi_bus_get_perf_flags(device);
1428                 if (result)
1429                         goto end;
1430         }
1431
1432         if ((result = acpi_device_set_context(device)))
1433                 goto end;
1434
1435         device->flags.match_driver = match_driver;
1436         result = acpi_device_register(device);
1437
1438 end:
1439         if (!result) {
1440                 acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer);
1441                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
1442                         "Adding %s [%s] parent %s\n", dev_name(&device->dev),
1443                          (char *) buffer.pointer,
1444                          device->parent ? dev_name(&device->parent->dev) :
1445                                           "(null)"));
1446                 kfree(buffer.pointer);
1447                 *child = device;
1448         } else
1449                 acpi_device_release(&device->dev);
1450
1451         return result;
1452 }
1453
1454 #define ACPI_STA_DEFAULT (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | \
1455                           ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING)
1456
1457 static void acpi_bus_add_power_resource(acpi_handle handle)
1458 {
1459         struct acpi_device *device = NULL;
1460
1461         acpi_bus_get_device(handle, &device);
1462         if (!device)
1463                 acpi_add_single_object(&device, handle, ACPI_BUS_TYPE_POWER,
1464                                         ACPI_STA_DEFAULT, true);
1465 }
1466
1467 static int acpi_bus_type_and_status(acpi_handle handle, int *type,
1468                                     unsigned long long *sta)
1469 {
1470         acpi_status status;
1471         acpi_object_type acpi_type;
1472
1473         status = acpi_get_type(handle, &acpi_type);
1474         if (ACPI_FAILURE(status))
1475                 return -ENODEV;
1476
1477         switch (acpi_type) {
1478         case ACPI_TYPE_ANY:             /* for ACPI_ROOT_OBJECT */
1479         case ACPI_TYPE_DEVICE:
1480                 *type = ACPI_BUS_TYPE_DEVICE;
1481                 status = acpi_bus_get_status_handle(handle, sta);
1482                 if (ACPI_FAILURE(status))
1483                         return -ENODEV;
1484                 break;
1485         case ACPI_TYPE_PROCESSOR:
1486                 *type = ACPI_BUS_TYPE_PROCESSOR;
1487                 status = acpi_bus_get_status_handle(handle, sta);
1488                 if (ACPI_FAILURE(status))
1489                         return -ENODEV;
1490                 break;
1491         case ACPI_TYPE_THERMAL:
1492                 *type = ACPI_BUS_TYPE_THERMAL;
1493                 *sta = ACPI_STA_DEFAULT;
1494                 break;
1495         case ACPI_TYPE_POWER:
1496                 *type = ACPI_BUS_TYPE_POWER;
1497                 *sta = ACPI_STA_DEFAULT;
1498                 break;
1499         default:
1500                 return -ENODEV;
1501         }
1502
1503         return 0;
1504 }
1505
1506 static acpi_status acpi_bus_check_add(acpi_handle handle, u32 lvl_not_used,
1507                                       void *not_used, void **return_value)
1508 {
1509         struct acpi_device *device = NULL;
1510         int type;
1511         unsigned long long sta;
1512         acpi_status status;
1513         int result;
1514
1515         acpi_bus_get_device(handle, &device);
1516         if (device)
1517                 goto out;
1518
1519         result = acpi_bus_type_and_status(handle, &type, &sta);
1520         if (result)
1521                 return AE_OK;
1522
1523         if (!(sta & ACPI_STA_DEVICE_PRESENT) &&
1524             !(sta & ACPI_STA_DEVICE_FUNCTIONING)) {
1525                 struct acpi_device_wakeup wakeup;
1526                 acpi_handle temp;
1527
1528                 status = acpi_get_handle(handle, "_PRW", &temp);
1529                 if (ACPI_SUCCESS(status))
1530                         acpi_bus_extract_wakeup_device_power_package(handle,
1531                                                                      &wakeup);
1532                 return AE_CTRL_DEPTH;
1533         }
1534
1535         acpi_add_single_object(&device, handle, type, sta,
1536                                type == ACPI_BUS_TYPE_POWER);
1537         if (!device)
1538                 return AE_CTRL_DEPTH;
1539
1540         device->flags.match_driver = true;
1541
1542  out:
1543         if (!*return_value)
1544                 *return_value = device;
1545
1546         return AE_OK;
1547 }
1548
1549 static acpi_status acpi_bus_device_attach(acpi_handle handle, u32 lvl_not_used,
1550                                           void *not_used, void **ret_not_used)
1551 {
1552         acpi_status status = AE_OK;
1553         struct acpi_device *device;
1554         unsigned long long sta_not_used;
1555         int type_not_used;
1556
1557         /*
1558          * Ignore errors ignored by acpi_bus_check_add() to avoid terminating
1559          * namespace walks prematurely.
1560          */
1561         if (acpi_bus_type_and_status(handle, &type_not_used, &sta_not_used))
1562                 return AE_OK;
1563
1564         if (acpi_bus_get_device(handle, &device))
1565                 return AE_CTRL_DEPTH;
1566
1567         if (!acpi_match_device_ids(device, acpi_platform_device_ids)) {
1568                 /* This is a known good platform device. */
1569                 acpi_create_platform_device(device);
1570         } else if (device_attach(&device->dev) < 0) {
1571                 status = AE_CTRL_DEPTH;
1572         }
1573         return status;
1574 }
1575
1576 /**
1577  * acpi_bus_scan - Add ACPI device node objects in a given namespace scope.
1578  * @handle: Root of the namespace scope to scan.
1579  *
1580  * Scan a given ACPI tree (probably recently hot-plugged) and create and add
1581  * found devices.
1582  *
1583  * If no devices were found, -ENODEV is returned, but it does not mean that
1584  * there has been a real error.  There just have been no suitable ACPI objects
1585  * in the table trunk from which the kernel could create a device and add an
1586  * appropriate driver.
1587  */
1588 int acpi_bus_scan(acpi_handle handle)
1589 {
1590         void *device = NULL;
1591         int error = 0;
1592
1593         mutex_lock(&acpi_scan_lock);
1594
1595         if (ACPI_SUCCESS(acpi_bus_check_add(handle, 0, NULL, &device)))
1596                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
1597                                     acpi_bus_check_add, NULL, NULL, &device);
1598
1599         if (!device)
1600                 error = -ENODEV;
1601         else if (ACPI_SUCCESS(acpi_bus_device_attach(handle, 0, NULL, NULL)))
1602                 acpi_walk_namespace(ACPI_TYPE_ANY, handle, ACPI_UINT32_MAX,
1603                                     acpi_bus_device_attach, NULL, NULL, NULL);
1604
1605         mutex_unlock(&acpi_scan_lock);
1606         return error;
1607 }
1608 EXPORT_SYMBOL(acpi_bus_scan);
1609
1610 static acpi_status acpi_bus_device_detach(acpi_handle handle, u32 lvl_not_used,
1611                                           void *not_used, void **ret_not_used)
1612 {
1613         struct acpi_device *device = NULL;
1614
1615         if (!acpi_bus_get_device(handle, &device)) {
1616                 device->removal_type = ACPI_BUS_REMOVAL_EJECT;
1617                 device_release_driver(&device->dev);
1618         }
1619         return AE_OK;
1620 }
1621
1622 static acpi_status acpi_bus_remove(acpi_handle handle, u32 lvl_not_used,
1623                                    void *not_used, void **ret_not_used)
1624 {
1625         struct acpi_device *device = NULL;
1626
1627         if (!acpi_bus_get_device(handle, &device))
1628                 acpi_device_unregister(device);
1629
1630         return AE_OK;
1631 }
1632
1633 void acpi_bus_trim(struct acpi_device *start)
1634 {
1635         mutex_lock(&acpi_scan_lock);
1636
1637         /*
1638          * Execute acpi_bus_device_detach() as a post-order callback to detach
1639          * all ACPI drivers from the device nodes being removed.
1640          */
1641         acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
1642                             acpi_bus_device_detach, NULL, NULL);
1643         acpi_bus_device_detach(start->handle, 0, NULL, NULL);
1644         /*
1645          * Execute acpi_bus_remove() as a post-order callback to remove device
1646          * nodes in the given namespace scope.
1647          */
1648         acpi_walk_namespace(ACPI_TYPE_ANY, start->handle, ACPI_UINT32_MAX, NULL,
1649                             acpi_bus_remove, NULL, NULL);
1650         acpi_bus_remove(start->handle, 0, NULL, NULL);
1651
1652         mutex_unlock(&acpi_scan_lock);
1653 }
1654 EXPORT_SYMBOL_GPL(acpi_bus_trim);
1655
1656 static int acpi_bus_scan_fixed(void)
1657 {
1658         int result = 0;
1659         struct acpi_device *device = NULL;
1660
1661         /*
1662          * Enumerate all fixed-feature devices.
1663          */
1664         if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
1665                 result = acpi_add_single_object(&device, NULL,
1666                                                 ACPI_BUS_TYPE_POWER_BUTTON,
1667                                                 ACPI_STA_DEFAULT, true);
1668                 device_init_wakeup(&device->dev, true);
1669         }
1670
1671         if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
1672                 result = acpi_add_single_object(&device, NULL,
1673                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
1674                                                 ACPI_STA_DEFAULT, true);
1675         }
1676
1677         return result;
1678 }
1679
1680 int __init acpi_scan_init(void)
1681 {
1682         int result;
1683
1684         result = bus_register(&acpi_bus_type);
1685         if (result) {
1686                 /* We don't want to quit even if we failed to add suspend/resume */
1687                 printk(KERN_ERR PREFIX "Could not register bus type\n");
1688         }
1689
1690         acpi_power_init();
1691         acpi_pci_root_init();
1692
1693         /*
1694          * Enumerate devices in the ACPI namespace.
1695          */
1696         result = acpi_bus_scan(ACPI_ROOT_OBJECT);
1697         if (result)
1698                 return result;
1699
1700         result = acpi_bus_get_device(ACPI_ROOT_OBJECT, &acpi_root);
1701         if (result)
1702                 return result;
1703
1704         result = acpi_bus_scan_fixed();
1705         if (result) {
1706                 acpi_device_unregister(acpi_root);
1707                 return result;
1708         }
1709
1710         acpi_update_all_gpes();
1711         return 0;
1712 }