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