git.oblomov.eu Git - linux-2.6/blob - 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/kernel.h>
   8 #include <linux/acpi.h>
   9
  10 #include <acpi/acpi_drivers.h>
  11 #include <acpi/acinterp.h>      /* for acpi_ex_eisa_id_to_string() */
  12
  13 #define _COMPONENT              ACPI_BUS_COMPONENT
  14 ACPI_MODULE_NAME("scan");
  15 #define STRUCT_TO_INT(s)        (*((int*)&s))
  16 extern struct acpi_device *acpi_root;
  17
  18 #define ACPI_BUS_CLASS                  "system_bus"
  19 #define ACPI_BUS_HID                    "ACPI_BUS"
  20 #define ACPI_BUS_DEVICE_NAME            "System Bus"
  21
  22 static LIST_HEAD(acpi_device_list);
  23 static LIST_HEAD(acpi_bus_id_list);
  24 DEFINE_SPINLOCK(acpi_device_lock);
  25 LIST_HEAD(acpi_wakeup_device_list);
  26
  27 struct acpi_device_bus_id{
  28         char bus_id[15];
  29         unsigned int instance_no;
  30         struct list_head node;
  31 };
  32 static int acpi_eject_operation(acpi_handle handle, int lockable)
  33 {
  34         struct acpi_object_list arg_list;
  35         union acpi_object arg;
  36         acpi_status status = AE_OK;
  37
  38         /*
  39          * TBD: evaluate _PS3?
  40          */
  41
  42         if (lockable) {
  43                 arg_list.count = 1;
  44                 arg_list.pointer = &arg;
  45                 arg.type = ACPI_TYPE_INTEGER;
  46                 arg.integer.value = 0;
  47                 acpi_evaluate_object(handle, "_LCK", &arg_list, NULL);
  48         }
  49
  50         arg_list.count = 1;
  51         arg_list.pointer = &arg;
  52         arg.type = ACPI_TYPE_INTEGER;
  53         arg.integer.value = 1;
  54
  55         /*
  56          * TBD: _EJD support.
  57          */
  58
  59         status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
  60         if (ACPI_FAILURE(status)) {
  61                 return (-ENODEV);
  62         }
  63
  64         return (0);
  65 }
  66
  67 static ssize_t
  68 acpi_eject_store(struct device *d, struct device_attribute *attr,
  69                 const char *buf, size_t count)
  70 {
  71         int result;
  72         int ret = count;
  73         int islockable;
  74         acpi_status status;
  75         acpi_handle handle;
  76         acpi_object_type type = 0;
  77         struct acpi_device *acpi_device = to_acpi_device(d);
  78
  79         if ((!count) || (buf[0] != '1')) {
  80                 return -EINVAL;
  81         }
  82 #ifndef FORCE_EJECT
  83         if (acpi_device->driver == NULL) {
  84                 ret = -ENODEV;
  85                 goto err;
  86         }
  87 #endif
  88         status = acpi_get_type(acpi_device->handle, &type);
  89         if (ACPI_FAILURE(status) || (!acpi_device->flags.ejectable)) {
  90                 ret = -ENODEV;
  91                 goto err;
  92         }
  93
  94         islockable = acpi_device->flags.lockable;
  95         handle = acpi_device->handle;
  96
  97         result = acpi_bus_trim(acpi_device, 1);
  98
  99         if (!result)
 100                 result = acpi_eject_operation(handle, islockable);
 101
 102         if (result) {
 103                 ret = -EBUSY;
 104         }
 105       err:
 106         return ret;
 107 }
 108
 109 static DEVICE_ATTR(eject, 0200, NULL, acpi_eject_store);
 110
 111 static ssize_t
 112 acpi_device_hid_show(struct device *dev, struct device_attribute *attr, char *buf) {
 113         struct acpi_device *acpi_dev = to_acpi_device(dev);
 114
 115         return sprintf(buf, "%s\n", acpi_dev->pnp.hardware_id);
 116 }
 117 static DEVICE_ATTR(hid, 0444, acpi_device_hid_show, NULL);
 118
 119 static ssize_t
 120 acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *buf) {
 121         struct acpi_device *acpi_dev = to_acpi_device(dev);
 122         struct acpi_buffer path = {ACPI_ALLOCATE_BUFFER, NULL};
 123         int result;
 124
 125         result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
 126         if(result)
 127                 goto end;
 128
 129         result = sprintf(buf, "%s\n", (char*)path.pointer);
 130         kfree(path.pointer);
 131   end:
 132         return result;
 133 }
 134 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
 135
 136 static int acpi_device_setup_files(struct acpi_device *dev)
 137 {
 138         acpi_status status;
 139         acpi_handle temp;
 140         int result = 0;
 141
 142         /*
 143          * Devices gotten from FADT don't have a "path" attribute
 144          */
 145         if(dev->handle) {
 146                 result = device_create_file(&dev->dev, &dev_attr_path);
 147                 if(result)
 148                         goto end;
 149         }
 150
 151         if(dev->flags.hardware_id) {
 152                 result = device_create_file(&dev->dev, &dev_attr_hid);
 153                 if(result)
 154                         goto end;
 155         }
 156
 157         /*
 158          * If device has _EJ0, 'eject' file is created that is used to trigger
 159          * hot-removal function from userland.
 160          */
 161         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
 162         if (ACPI_SUCCESS(status))
 163                 result = device_create_file(&dev->dev, &dev_attr_eject);
 164   end:
 165         return result;
 166 }
 167
 168 static void acpi_device_remove_files(struct acpi_device *dev)
 169 {
 170         acpi_status status;
 171         acpi_handle temp;
 172
 173         /*
 174          * If device has _EJ0, 'eject' file is created that is used to trigger
 175          * hot-removal function from userland.
 176          */
 177         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
 178         if (ACPI_SUCCESS(status))
 179                 device_remove_file(&dev->dev, &dev_attr_eject);
 180
 181         if(dev->flags.hardware_id)
 182                 device_remove_file(&dev->dev, &dev_attr_hid);
 183         if(dev->handle)
 184                 device_remove_file(&dev->dev, &dev_attr_path);
 185 }
 186 /* --------------------------------------------------------------------------
 187                         ACPI Bus operations
 188    -------------------------------------------------------------------------- */
 189 static void acpi_device_release(struct device *dev)
 190 {
 191         struct acpi_device *acpi_dev = to_acpi_device(dev);
 192
 193         kfree(acpi_dev->pnp.cid_list);
 194         kfree(acpi_dev);
 195 }
 196
 197 static int acpi_device_suspend(struct device *dev, pm_message_t state)
 198 {
 199         struct acpi_device *acpi_dev = to_acpi_device(dev);
 200         struct acpi_driver *acpi_drv = acpi_dev->driver;
 201
 202         if (acpi_drv && acpi_drv->ops.suspend)
 203                 return acpi_drv->ops.suspend(acpi_dev, state);
 204         return 0;
 205 }
 206
 207 static int acpi_device_resume(struct device *dev)
 208 {
 209         struct acpi_device *acpi_dev = to_acpi_device(dev);
 210         struct acpi_driver *acpi_drv = acpi_dev->driver;
 211
 212         if (acpi_drv && acpi_drv->ops.resume)
 213                 return acpi_drv->ops.resume(acpi_dev);
 214         return 0;
 215 }
 216
 217 static int acpi_bus_match(struct device *dev, struct device_driver *drv)
 218 {
 219         struct acpi_device *acpi_dev = to_acpi_device(dev);
 220         struct acpi_driver *acpi_drv = to_acpi_driver(drv);
 221
 222         return !acpi_match_ids(acpi_dev, acpi_drv->ids);
 223 }
 224
 225 static int acpi_device_uevent(struct device *dev, char **envp, int num_envp,
 226         char *buffer, int buffer_size)
 227 {
 228         struct acpi_device *acpi_dev = to_acpi_device(dev);
 229         int i = 0, length = 0, ret = 0;
 230
 231         if (acpi_dev->flags.hardware_id)
 232                 ret = add_uevent_var(envp, num_envp, &i,
 233                         buffer, buffer_size, &length,
 234                         "HWID=%s", acpi_dev->pnp.hardware_id);
 235         if (ret)
 236                 return -ENOMEM;
 237         if (acpi_dev->flags.compatible_ids) {
 238                 int j;
 239                 struct acpi_compatible_id_list *cid_list;
 240
 241                 cid_list = acpi_dev->pnp.cid_list;
 242
 243                 for (j = 0; j < cid_list->count; j++) {
 244                         ret = add_uevent_var(envp, num_envp, &i, buffer,
 245                                 buffer_size, &length, "COMPTID=%s",
 246                                 cid_list->id[j].value);
 247                         if (ret)
 248                                 return -ENOMEM;
 249                 }
 250         }
 251
 252         envp[i] = NULL;
 253         return 0;
 254 }
 255
 256 static int acpi_bus_driver_init(struct acpi_device *, struct acpi_driver *);
 257 static int acpi_start_single_object(struct acpi_device *);
 258 static int acpi_device_probe(struct device * dev)
 259 {
 260         struct acpi_device *acpi_dev = to_acpi_device(dev);
 261         struct acpi_driver *acpi_drv = to_acpi_driver(dev->driver);
 262         int ret;
 263
 264         ret = acpi_bus_driver_init(acpi_dev, acpi_drv);
 265         if (!ret) {
 266                 if (acpi_dev->bus_ops.acpi_op_start)
 267                         acpi_start_single_object(acpi_dev);
 268                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 269                         "Found driver [%s] for device [%s]\n",
 270                         acpi_drv->name, acpi_dev->pnp.bus_id));
 271                 get_device(dev);
 272         }
 273         return ret;
 274 }
 275
 276 static int acpi_device_remove(struct device * dev)
 277 {
 278         struct acpi_device *acpi_dev = to_acpi_device(dev);
 279         struct acpi_driver *acpi_drv = acpi_dev->driver;
 280
 281         if (acpi_drv) {
 282                 if (acpi_drv->ops.stop)
 283                         acpi_drv->ops.stop(acpi_dev, acpi_dev->removal_type);
 284                 if (acpi_drv->ops.remove)
 285                         acpi_drv->ops.remove(acpi_dev, acpi_dev->removal_type);
 286         }
 287         acpi_dev->driver = NULL;
 288         acpi_driver_data(dev) = NULL;
 289
 290         put_device(dev);
 291         return 0;
 292 }
 293
 294 static void acpi_device_shutdown(struct device *dev)
 295 {
 296         struct acpi_device *acpi_dev = to_acpi_device(dev);
 297         struct acpi_driver *acpi_drv = acpi_dev->driver;
 298
 299         if (acpi_drv && acpi_drv->ops.shutdown)
 300                 acpi_drv->ops.shutdown(acpi_dev);
 301
 302         return ;
 303 }
 304
 305 struct bus_type acpi_bus_type = {
 306         .name           = "acpi",
 307         .suspend        = acpi_device_suspend,
 308         .resume         = acpi_device_resume,
 309         .shutdown       = acpi_device_shutdown,
 310         .match          = acpi_bus_match,
 311         .probe          = acpi_device_probe,
 312         .remove         = acpi_device_remove,
 313         .uevent         = acpi_device_uevent,
 314 };
 315
 316 static int acpi_device_register(struct acpi_device *device,
 317                                  struct acpi_device *parent)
 318 {
 319         int result;
 320         struct acpi_device_bus_id *acpi_device_bus_id, *new_bus_id;
 321         int found = 0;
 322         /*
 323          * Linkage
 324          * -------
 325          * Link this device to its parent and siblings.
 326          */
 327         INIT_LIST_HEAD(&device->children);
 328         INIT_LIST_HEAD(&device->node);
 329         INIT_LIST_HEAD(&device->g_list);
 330         INIT_LIST_HEAD(&device->wakeup_list);
 331
 332         new_bus_id = kzalloc(sizeof(struct acpi_device_bus_id), GFP_KERNEL);
 333         if (!new_bus_id) {
 334                 printk(KERN_ERR PREFIX "Memory allocation error\n");
 335                 return -ENOMEM;
 336         }
 337
 338         spin_lock(&acpi_device_lock);
 339         /*
 340          * Find suitable bus_id and instance number in acpi_bus_id_list
 341          * If failed, create one and link it into acpi_bus_id_list
 342          */
 343         list_for_each_entry(acpi_device_bus_id, &acpi_bus_id_list, node) {
 344                 if(!strcmp(acpi_device_bus_id->bus_id, device->flags.hardware_id? device->pnp.hardware_id : "device")) {
 345                         acpi_device_bus_id->instance_no ++;
 346                         found = 1;
 347                         kfree(new_bus_id);
 348                         break;
 349                 }
 350         }
 351         if(!found) {
 352                 acpi_device_bus_id = new_bus_id;
 353                 strcpy(acpi_device_bus_id->bus_id, device->flags.hardware_id ? device->pnp.hardware_id : "device");
 354                 acpi_device_bus_id->instance_no = 0;
 355                 list_add_tail(&acpi_device_bus_id->node, &acpi_bus_id_list);
 356         }
 357         sprintf(device->dev.bus_id, "%s:%02x", acpi_device_bus_id->bus_id, acpi_device_bus_id->instance_no);
 358
 359         if (device->parent) {
 360                 list_add_tail(&device->node, &device->parent->children);
 361                 list_add_tail(&device->g_list, &device->parent->g_list);
 362         } else
 363                 list_add_tail(&device->g_list, &acpi_device_list);
 364         if (device->wakeup.flags.valid)
 365                 list_add_tail(&device->wakeup_list, &acpi_wakeup_device_list);
 366         spin_unlock(&acpi_device_lock);
 367
 368         if (device->parent)
 369                 device->dev.parent = &parent->dev;
 370         device->dev.bus = &acpi_bus_type;
 371         device_initialize(&device->dev);
 372         device->dev.release = &acpi_device_release;
 373         result = device_add(&device->dev);
 374         if(result) {
 375                 printk("Error adding device %s", device->dev.bus_id);
 376                 goto end;
 377         }
 378
 379         result = acpi_device_setup_files(device);
 380         if(result)
 381                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error creating sysfs interface for device %s\n", device->dev.bus_id));
 382
 383         device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
 384         return 0;
 385   end:
 386         spin_lock(&acpi_device_lock);
 387         if (device->parent) {
 388                 list_del(&device->node);
 389                 list_del(&device->g_list);
 390         } else
 391                 list_del(&device->g_list);
 392         list_del(&device->wakeup_list);
 393         spin_unlock(&acpi_device_lock);
 394         return result;
 395 }
 396
 397 static void acpi_device_unregister(struct acpi_device *device, int type)
 398 {
 399         spin_lock(&acpi_device_lock);
 400         if (device->parent) {
 401                 list_del(&device->node);
 402                 list_del(&device->g_list);
 403         } else
 404                 list_del(&device->g_list);
 405
 406         list_del(&device->wakeup_list);
 407         spin_unlock(&acpi_device_lock);
 408
 409         acpi_detach_data(device->handle, acpi_bus_data_handler);
 410
 411         acpi_device_remove_files(device);
 412         device_unregister(&device->dev);
 413 }
 414
 415 /* --------------------------------------------------------------------------
 416                                  Driver Management
 417    -------------------------------------------------------------------------- */
 418 /**
 419  * acpi_bus_driver_init - add a device to a driver
 420  * @device: the device to add and initialize
 421  * @driver: driver for the device
 422  *
 423  * Used to initialize a device via its device driver.  Called whenever a
 424  * driver is bound to a device.  Invokes the driver's add() ops.
 425  */
 426 static int
 427 acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
 428 {
 429         int result = 0;
 430
 431
 432         if (!device || !driver)
 433                 return -EINVAL;
 434
 435         if (!driver->ops.add)
 436                 return -ENOSYS;
 437
 438         result = driver->ops.add(device);
 439         if (result) {
 440                 device->driver = NULL;
 441                 acpi_driver_data(device) = NULL;
 442                 return result;
 443         }
 444
 445         device->driver = driver;
 446
 447         /*
 448          * TBD - Configuration Management: Assign resources to device based
 449          * upon possible configuration and currently allocated resources.
 450          */
 451
 452         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 453                           "Driver successfully bound to device\n"));
 454         return 0;
 455 }
 456
 457 static int acpi_start_single_object(struct acpi_device *device)
 458 {
 459         int result = 0;
 460         struct acpi_driver *driver;
 461
 462
 463         if (!(driver = device->driver))
 464                 return 0;
 465
 466         if (driver->ops.start) {
 467                 result = driver->ops.start(device);
 468                 if (result && driver->ops.remove)
 469                         driver->ops.remove(device, ACPI_BUS_REMOVAL_NORMAL);
 470         }
 471
 472         return result;
 473 }
 474
 475 /**
 476  * acpi_bus_register_driver - register a driver with the ACPI bus
 477  * @driver: driver being registered
 478  *
 479  * Registers a driver with the ACPI bus.  Searches the namespace for all
 480  * devices that match the driver's criteria and binds.  Returns zero for
 481  * success or a negative error status for failure.
 482  */
 483 int acpi_bus_register_driver(struct acpi_driver *driver)
 484 {
 485         int ret;
 486
 487         if (acpi_disabled)
 488                 return -ENODEV;
 489         driver->drv.name = driver->name;
 490         driver->drv.bus = &acpi_bus_type;
 491         driver->drv.owner = driver->owner;
 492
 493         ret = driver_register(&driver->drv);
 494         return ret;
 495 }
 496
 497 EXPORT_SYMBOL(acpi_bus_register_driver);
 498
 499 /**
 500  * acpi_bus_unregister_driver - unregisters a driver with the APIC bus
 501  * @driver: driver to unregister
 502  *
 503  * Unregisters a driver with the ACPI bus.  Searches the namespace for all
 504  * devices that match the driver's criteria and unbinds.
 505  */
 506 void acpi_bus_unregister_driver(struct acpi_driver *driver)
 507 {
 508         driver_unregister(&driver->drv);
 509 }
 510
 511 EXPORT_SYMBOL(acpi_bus_unregister_driver);
 512
 513 /* --------------------------------------------------------------------------
 514                                  Device Enumeration
 515    -------------------------------------------------------------------------- */
 516 acpi_status
 517 acpi_bus_get_ejd(acpi_handle handle, acpi_handle *ejd)
 518 {
 519         acpi_status status;
 520         acpi_handle tmp;
 521         struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
 522         union acpi_object *obj;
 523
 524         status = acpi_get_handle(handle, "_EJD", &tmp);
 525         if (ACPI_FAILURE(status))
 526                 return status;
 527
 528         status = acpi_evaluate_object(handle, "_EJD", NULL, &buffer);
 529         if (ACPI_SUCCESS(status)) {
 530                 obj = buffer.pointer;
 531                 status = acpi_get_handle(NULL, obj->string.pointer, ejd);
 532                 kfree(buffer.pointer);
 533         }
 534         return status;
 535 }
 536 EXPORT_SYMBOL_GPL(acpi_bus_get_ejd);
 537
 538 void acpi_bus_data_handler(acpi_handle handle, u32 function, void *context)
 539 {
 540
 541         /* TBD */
 542
 543         return;
 544 }
 545
 546 int acpi_match_ids(struct acpi_device *device, char *ids)
 547 {
 548         if (device->flags.hardware_id)
 549                 if (strstr(ids, device->pnp.hardware_id))
 550                         return 0;
 551
 552         if (device->flags.compatible_ids) {
 553                 struct acpi_compatible_id_list *cid_list = device->pnp.cid_list;
 554                 int i;
 555
 556                 /* compare multiple _CID entries against driver ids */
 557                 for (i = 0; i < cid_list->count; i++) {
 558                         if (strstr(ids, cid_list->id[i].value))
 559                                 return 0;
 560                 }
 561         }
 562         return -ENOENT;
 563 }
 564
 565 static int acpi_bus_get_perf_flags(struct acpi_device *device)
 566 {
 567         device->performance.state = ACPI_STATE_UNKNOWN;
 568         return 0;
 569 }
 570
 571 static acpi_status
 572 acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
 573                                              union acpi_object *package)
 574 {
 575         int i = 0;
 576         union acpi_object *element = NULL;
 577
 578         if (!device || !package || (package->package.count < 2))
 579                 return AE_BAD_PARAMETER;
 580
 581         element = &(package->package.elements[0]);
 582         if (!element)
 583                 return AE_BAD_PARAMETER;
 584         if (element->type == ACPI_TYPE_PACKAGE) {
 585                 if ((element->package.count < 2) ||
 586                     (element->package.elements[0].type !=
 587                      ACPI_TYPE_LOCAL_REFERENCE)
 588                     || (element->package.elements[1].type != ACPI_TYPE_INTEGER))
 589                         return AE_BAD_DATA;
 590                 device->wakeup.gpe_device =
 591                     element->package.elements[0].reference.handle;
 592                 device->wakeup.gpe_number =
 593                     (u32) element->package.elements[1].integer.value;
 594         } else if (element->type == ACPI_TYPE_INTEGER) {
 595                 device->wakeup.gpe_number = element->integer.value;
 596         } else
 597                 return AE_BAD_DATA;
 598
 599         element = &(package->package.elements[1]);
 600         if (element->type != ACPI_TYPE_INTEGER) {
 601                 return AE_BAD_DATA;
 602         }
 603         device->wakeup.sleep_state = element->integer.value;
 604
 605         if ((package->package.count - 2) > ACPI_MAX_HANDLES) {
 606                 return AE_NO_MEMORY;
 607         }
 608         device->wakeup.resources.count = package->package.count - 2;
 609         for (i = 0; i < device->wakeup.resources.count; i++) {
 610                 element = &(package->package.elements[i + 2]);
 611                 if (element->type != ACPI_TYPE_ANY) {
 612                         return AE_BAD_DATA;
 613                 }
 614
 615                 device->wakeup.resources.handles[i] = element->reference.handle;
 616         }
 617
 618         return AE_OK;
 619 }
 620
 621 static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
 622 {
 623         acpi_status status = 0;
 624         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 625         union acpi_object *package = NULL;
 626
 627
 628         /* _PRW */
 629         status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
 630         if (ACPI_FAILURE(status)) {
 631                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PRW"));
 632                 goto end;
 633         }
 634
 635         package = (union acpi_object *)buffer.pointer;
 636         status = acpi_bus_extract_wakeup_device_power_package(device, package);
 637         if (ACPI_FAILURE(status)) {
 638                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _PRW package"));
 639                 goto end;
 640         }
 641
 642         kfree(buffer.pointer);
 643
 644         device->wakeup.flags.valid = 1;
 645         /* Power button, Lid switch always enable wakeup */
 646         if (!acpi_match_ids(device, "PNP0C0D,PNP0C0C,PNP0C0E"))
 647                 device->wakeup.flags.run_wake = 1;
 648
 649       end:
 650         if (ACPI_FAILURE(status))
 651                 device->flags.wake_capable = 0;
 652         return 0;
 653 }
 654
 655 static int acpi_bus_get_power_flags(struct acpi_device *device)
 656 {
 657         acpi_status status = 0;
 658         acpi_handle handle = NULL;
 659         u32 i = 0;
 660
 661
 662         /*
 663          * Power Management Flags
 664          */
 665         status = acpi_get_handle(device->handle, "_PSC", &handle);
 666         if (ACPI_SUCCESS(status))
 667                 device->power.flags.explicit_get = 1;
 668         status = acpi_get_handle(device->handle, "_IRC", &handle);
 669         if (ACPI_SUCCESS(status))
 670                 device->power.flags.inrush_current = 1;
 671
 672         /*
 673          * Enumerate supported power management states
 674          */
 675         for (i = ACPI_STATE_D0; i <= ACPI_STATE_D3; i++) {
 676                 struct acpi_device_power_state *ps = &device->power.states[i];
 677                 char object_name[5] = { '_', 'P', 'R', '0' + i, '\0' };
 678
 679                 /* Evaluate "_PRx" to se if power resources are referenced */
 680                 acpi_evaluate_reference(device->handle, object_name, NULL,
 681                                         &ps->resources);
 682                 if (ps->resources.count) {
 683                         device->power.flags.power_resources = 1;
 684                         ps->flags.valid = 1;
 685                 }
 686
 687                 /* Evaluate "_PSx" to see if we can do explicit sets */
 688                 object_name[2] = 'S';
 689                 status = acpi_get_handle(device->handle, object_name, &handle);
 690                 if (ACPI_SUCCESS(status)) {
 691                         ps->flags.explicit_set = 1;
 692                         ps->flags.valid = 1;
 693                 }
 694
 695                 /* State is valid if we have some power control */
 696                 if (ps->resources.count || ps->flags.explicit_set)
 697                         ps->flags.valid = 1;
 698
 699                 ps->power = -1; /* Unknown - driver assigned */
 700                 ps->latency = -1;       /* Unknown - driver assigned */
 701         }
 702
 703         /* Set defaults for D0 and D3 states (always valid) */
 704         device->power.states[ACPI_STATE_D0].flags.valid = 1;
 705         device->power.states[ACPI_STATE_D0].power = 100;
 706         device->power.states[ACPI_STATE_D3].flags.valid = 1;
 707         device->power.states[ACPI_STATE_D3].power = 0;
 708
 709         /* TBD: System wake support and resource requirements. */
 710
 711         device->power.state = ACPI_STATE_UNKNOWN;
 712
 713         return 0;
 714 }
 715
 716 static int acpi_bus_get_flags(struct acpi_device *device)
 717 {
 718         acpi_status status = AE_OK;
 719         acpi_handle temp = NULL;
 720
 721
 722         /* Presence of _STA indicates 'dynamic_status' */
 723         status = acpi_get_handle(device->handle, "_STA", &temp);
 724         if (ACPI_SUCCESS(status))
 725                 device->flags.dynamic_status = 1;
 726
 727         /* Presence of _CID indicates 'compatible_ids' */
 728         status = acpi_get_handle(device->handle, "_CID", &temp);
 729         if (ACPI_SUCCESS(status))
 730                 device->flags.compatible_ids = 1;
 731
 732         /* Presence of _RMV indicates 'removable' */
 733         status = acpi_get_handle(device->handle, "_RMV", &temp);
 734         if (ACPI_SUCCESS(status))
 735                 device->flags.removable = 1;
 736
 737         /* Presence of _EJD|_EJ0 indicates 'ejectable' */
 738         status = acpi_get_handle(device->handle, "_EJD", &temp);
 739         if (ACPI_SUCCESS(status))
 740                 device->flags.ejectable = 1;
 741         else {
 742                 status = acpi_get_handle(device->handle, "_EJ0", &temp);
 743                 if (ACPI_SUCCESS(status))
 744                         device->flags.ejectable = 1;
 745         }
 746
 747         /* Presence of _LCK indicates 'lockable' */
 748         status = acpi_get_handle(device->handle, "_LCK", &temp);
 749         if (ACPI_SUCCESS(status))
 750                 device->flags.lockable = 1;
 751
 752         /* Presence of _PS0|_PR0 indicates 'power manageable' */
 753         status = acpi_get_handle(device->handle, "_PS0", &temp);
 754         if (ACPI_FAILURE(status))
 755                 status = acpi_get_handle(device->handle, "_PR0", &temp);
 756         if (ACPI_SUCCESS(status))
 757                 device->flags.power_manageable = 1;
 758
 759         /* Presence of _PRW indicates wake capable */
 760         status = acpi_get_handle(device->handle, "_PRW", &temp);
 761         if (ACPI_SUCCESS(status))
 762                 device->flags.wake_capable = 1;
 763
 764         /* TBD: Peformance management */
 765
 766         return 0;
 767 }
 768
 769 static void acpi_device_get_busid(struct acpi_device *device,
 770                                   acpi_handle handle, int type)
 771 {
 772         char bus_id[5] = { '?', 0 };
 773         struct acpi_buffer buffer = { sizeof(bus_id), bus_id };
 774         int i = 0;
 775
 776         /*
 777          * Bus ID
 778          * ------
 779          * The device's Bus ID is simply the object name.
 780          * TBD: Shouldn't this value be unique (within the ACPI namespace)?
 781          */
 782         switch (type) {
 783         case ACPI_BUS_TYPE_SYSTEM:
 784                 strcpy(device->pnp.bus_id, "ACPI");
 785                 break;
 786         case ACPI_BUS_TYPE_POWER_BUTTON:
 787                 strcpy(device->pnp.bus_id, "PWRF");
 788                 break;
 789         case ACPI_BUS_TYPE_SLEEP_BUTTON:
 790                 strcpy(device->pnp.bus_id, "SLPF");
 791                 break;
 792         default:
 793                 acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
 794                 /* Clean up trailing underscores (if any) */
 795                 for (i = 3; i > 1; i--) {
 796                         if (bus_id[i] == '_')
 797                                 bus_id[i] = '\0';
 798                         else
 799                                 break;
 800                 }
 801                 strcpy(device->pnp.bus_id, bus_id);
 802                 break;
 803         }
 804 }
 805
 806 static int
 807 acpi_video_bus_match(struct acpi_device *device)
 808 {
 809         acpi_handle h_dummy1;
 810         acpi_handle h_dummy2;
 811         acpi_handle h_dummy3;
 812
 813
 814         if (!device)
 815                 return -EINVAL;
 816
 817         /* Since there is no HID, CID for ACPI Video drivers, we have
 818          * to check well known required nodes for each feature we support.
 819          */
 820
 821         /* Does this device able to support video switching ? */
 822         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOD", &h_dummy1)) &&
 823             ACPI_SUCCESS(acpi_get_handle(device->handle, "_DOS", &h_dummy2)))
 824                 return 0;
 825
 826         /* Does this device able to retrieve a video ROM ? */
 827         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_ROM", &h_dummy1)))
 828                 return 0;
 829
 830         /* Does this device able to configure which video head to be POSTed ? */
 831         if (ACPI_SUCCESS(acpi_get_handle(device->handle, "_VPO", &h_dummy1)) &&
 832             ACPI_SUCCESS(acpi_get_handle(device->handle, "_GPD", &h_dummy2)) &&
 833             ACPI_SUCCESS(acpi_get_handle(device->handle, "_SPD", &h_dummy3)))
 834                 return 0;
 835
 836         return -ENODEV;
 837 }
 838
 839 /*
 840  * acpi_bay_match - see if a device is an ejectable driver bay
 841  *
 842  * If an acpi object is ejectable and has one of the ACPI ATA methods defined,
 843  * then we can safely call it an ejectable drive bay
 844  */
 845 static int acpi_bay_match(struct acpi_device *device){
 846         acpi_status status;
 847         acpi_handle handle;
 848         acpi_handle tmp;
 849         acpi_handle phandle;
 850
 851         handle = device->handle;
 852
 853         status = acpi_get_handle(handle, "_EJ0", &tmp);
 854         if (ACPI_FAILURE(status))
 855                 return -ENODEV;
 856
 857         if ((ACPI_SUCCESS(acpi_get_handle(handle, "_GTF", &tmp))) ||
 858                 (ACPI_SUCCESS(acpi_get_handle(handle, "_GTM", &tmp))) ||
 859                 (ACPI_SUCCESS(acpi_get_handle(handle, "_STM", &tmp))) ||
 860                 (ACPI_SUCCESS(acpi_get_handle(handle, "_SDD", &tmp))))
 861                 return 0;
 862
 863         if (acpi_get_parent(handle, &phandle))
 864                 return -ENODEV;
 865
 866         if ((ACPI_SUCCESS(acpi_get_handle(phandle, "_GTF", &tmp))) ||
 867                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_GTM", &tmp))) ||
 868                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_STM", &tmp))) ||
 869                 (ACPI_SUCCESS(acpi_get_handle(phandle, "_SDD", &tmp))))
 870                 return 0;
 871
 872         return -ENODEV;
 873 }
 874
 875 static void acpi_device_set_id(struct acpi_device *device,
 876                                struct acpi_device *parent, acpi_handle handle,
 877                                int type)
 878 {
 879         struct acpi_device_info *info;
 880         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 881         char *hid = NULL;
 882         char *uid = NULL;
 883         struct acpi_compatible_id_list *cid_list = NULL;
 884         acpi_status status;
 885
 886         switch (type) {
 887         case ACPI_BUS_TYPE_DEVICE:
 888                 status = acpi_get_object_info(handle, &buffer);
 889                 if (ACPI_FAILURE(status)) {
 890                         printk("%s: Error reading device info\n", __FUNCTION__);
 891                         return;
 892                 }
 893
 894                 info = buffer.pointer;
 895                 if (info->valid & ACPI_VALID_HID)
 896                         hid = info->hardware_id.value;
 897                 if (info->valid & ACPI_VALID_UID)
 898                         uid = info->unique_id.value;
 899                 if (info->valid & ACPI_VALID_CID)
 900                         cid_list = &info->compatibility_id;
 901                 if (info->valid & ACPI_VALID_ADR) {
 902                         device->pnp.bus_address = info->address;
 903                         device->flags.bus_address = 1;
 904                 }
 905
 906                 if(!(info->valid & (ACPI_VALID_HID | ACPI_VALID_CID))){
 907                         status = acpi_video_bus_match(device);
 908                         if(ACPI_SUCCESS(status))
 909                                 hid = ACPI_VIDEO_HID;
 910
 911                         status = acpi_bay_match(device);
 912                         if (ACPI_SUCCESS(status))
 913                                 hid = ACPI_BAY_HID;
 914                 }
 915                 break;
 916         case ACPI_BUS_TYPE_POWER:
 917                 hid = ACPI_POWER_HID;
 918                 break;
 919         case ACPI_BUS_TYPE_PROCESSOR:
 920                 hid = ACPI_PROCESSOR_HID;
 921                 break;
 922         case ACPI_BUS_TYPE_SYSTEM:
 923                 hid = ACPI_SYSTEM_HID;
 924                 break;
 925         case ACPI_BUS_TYPE_THERMAL:
 926                 hid = ACPI_THERMAL_HID;
 927                 break;
 928         case ACPI_BUS_TYPE_POWER_BUTTON:
 929                 hid = ACPI_BUTTON_HID_POWERF;
 930                 break;
 931         case ACPI_BUS_TYPE_SLEEP_BUTTON:
 932                 hid = ACPI_BUTTON_HID_SLEEPF;
 933                 break;
 934         }
 935
 936         /*
 937          * \_SB
 938          * ----
 939          * Fix for the system root bus device -- the only root-level device.
 940          */
 941         if (((acpi_handle)parent == ACPI_ROOT_OBJECT) && (type == ACPI_BUS_TYPE_DEVICE)) {
 942                 hid = ACPI_BUS_HID;
 943                 strcpy(device->pnp.device_name, ACPI_BUS_DEVICE_NAME);
 944                 strcpy(device->pnp.device_class, ACPI_BUS_CLASS);
 945         }
 946
 947         if (hid) {
 948                 strcpy(device->pnp.hardware_id, hid);
 949                 device->flags.hardware_id = 1;
 950         }
 951         if (uid) {
 952                 strcpy(device->pnp.unique_id, uid);
 953                 device->flags.unique_id = 1;
 954         }
 955         if (cid_list) {
 956                 device->pnp.cid_list = kmalloc(cid_list->size, GFP_KERNEL);
 957                 if (device->pnp.cid_list)
 958                         memcpy(device->pnp.cid_list, cid_list, cid_list->size);
 959                 else
 960                         printk(KERN_ERR "Memory allocation error\n");
 961         }
 962
 963         kfree(buffer.pointer);
 964 }
 965
 966 static int acpi_device_set_context(struct acpi_device *device, int type)
 967 {
 968         acpi_status status = AE_OK;
 969         int result = 0;
 970         /*
 971          * Context
 972          * -------
 973          * Attach this 'struct acpi_device' to the ACPI object.  This makes
 974          * resolutions from handle->device very efficient.  Note that we need
 975          * to be careful with fixed-feature devices as they all attach to the
 976          * root object.
 977          */
 978         if (type != ACPI_BUS_TYPE_POWER_BUTTON &&
 979             type != ACPI_BUS_TYPE_SLEEP_BUTTON) {
 980                 status = acpi_attach_data(device->handle,
 981                                           acpi_bus_data_handler, device);
 982
 983                 if (ACPI_FAILURE(status)) {
 984                         printk("Error attaching device data\n");
 985                         result = -ENODEV;
 986                 }
 987         }
 988         return result;
 989 }
 990
 991 static int acpi_bus_remove(struct acpi_device *dev, int rmdevice)
 992 {
 993         if (!dev)
 994                 return -EINVAL;
 995
 996         dev->removal_type = ACPI_BUS_REMOVAL_EJECT;
 997         device_release_driver(&dev->dev);
 998
 999         if (!rmdevice)
1000                 return 0;
1001
1002         /*
1003          * unbind _ADR-Based Devices when hot removal
1004          */
1005         if (dev->flags.bus_address) {
1006                 if ((dev->parent) && (dev->parent->ops.unbind))
1007                         dev->parent->ops.unbind(dev);
1008         }
1009         acpi_device_unregister(dev, ACPI_BUS_REMOVAL_EJECT);
1010
1011         return 0;
1012 }
1013
1014 static int
1015 acpi_add_single_object(struct acpi_device **child,
1016                        struct acpi_device *parent, acpi_handle handle, int type,
1017                         struct acpi_bus_ops *ops)
1018 {
1019         int result = 0;
1020         struct acpi_device *device = NULL;
1021
1022
1023         if (!child)
1024                 return -EINVAL;
1025
1026         device = kzalloc(sizeof(struct acpi_device), GFP_KERNEL);
1027         if (!device) {
1028                 printk(KERN_ERR PREFIX "Memory allocation error\n");
1029                 return -ENOMEM;
1030         }
1031
1032         device->handle = handle;
1033         device->parent = parent;
1034         device->bus_ops = *ops; /* workround for not call .start */
1035
1036
1037         acpi_device_get_busid(device, handle, type);
1038
1039         /*
1040          * Flags
1041          * -----
1042          * Get prior to calling acpi_bus_get_status() so we know whether
1043          * or not _STA is present.  Note that we only look for object
1044          * handles -- cannot evaluate objects until we know the device is
1045          * present and properly initialized.
1046          */
1047         result = acpi_bus_get_flags(device);
1048         if (result)
1049                 goto end;
1050
1051         /*
1052          * Status
1053          * ------
1054          * See if the device is present.  We always assume that non-Device
1055          * and non-Processor objects (e.g. thermal zones, power resources,
1056          * etc.) are present, functioning, etc. (at least when parent object
1057          * is present).  Note that _STA has a different meaning for some
1058          * objects (e.g. power resources) so we need to be careful how we use
1059          * it.
1060          */
1061         switch (type) {
1062         case ACPI_BUS_TYPE_PROCESSOR:
1063         case ACPI_BUS_TYPE_DEVICE:
1064                 result = acpi_bus_get_status(device);
1065                 if (ACPI_FAILURE(result) || !device->status.present) {
1066                         result = -ENOENT;
1067                         goto end;
1068                 }
1069                 break;
1070         default:
1071                 STRUCT_TO_INT(device->status) =
1072                     ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED |
1073                     ACPI_STA_DEVICE_UI      | ACPI_STA_DEVICE_FUNCTIONING;
1074                 break;
1075         }
1076
1077         /*
1078          * Initialize Device
1079          * -----------------
1080          * TBD: Synch with Core's enumeration/initialization process.
1081          */
1082
1083         /*
1084          * Hardware ID, Unique ID, & Bus Address
1085          * -------------------------------------
1086          */
1087         acpi_device_set_id(device, parent, handle, type);
1088
1089         /*
1090          * Power Management
1091          * ----------------
1092          */
1093         if (device->flags.power_manageable) {
1094                 result = acpi_bus_get_power_flags(device);
1095                 if (result)
1096                         goto end;
1097         }
1098
1099         /*
1100          * Wakeup device management
1101          *-----------------------
1102          */
1103         if (device->flags.wake_capable) {
1104                 result = acpi_bus_get_wakeup_device_flags(device);
1105                 if (result)
1106                         goto end;
1107         }
1108
1109         /*
1110          * Performance Management
1111          * ----------------------
1112          */
1113         if (device->flags.performance_manageable) {
1114                 result = acpi_bus_get_perf_flags(device);
1115                 if (result)
1116                         goto end;
1117         }
1118
1119         if ((result = acpi_device_set_context(device, type)))
1120                 goto end;
1121
1122         result = acpi_device_register(device, parent);
1123
1124         /*
1125          * Bind _ADR-Based Devices when hot add
1126          */
1127         if (device->flags.bus_address) {
1128                 if (device->parent && device->parent->ops.bind)
1129                         device->parent->ops.bind(device);
1130         }
1131
1132       end:
1133         if (!result)
1134                 *child = device;
1135         else {
1136                 kfree(device->pnp.cid_list);
1137                 kfree(device);
1138         }
1139
1140         return result;
1141 }
1142
1143 static int acpi_bus_scan(struct acpi_device *start, struct acpi_bus_ops *ops)
1144 {
1145         acpi_status status = AE_OK;
1146         struct acpi_device *parent = NULL;
1147         struct acpi_device *child = NULL;
1148         acpi_handle phandle = NULL;
1149         acpi_handle chandle = NULL;
1150         acpi_object_type type = 0;
1151         u32 level = 1;
1152
1153
1154         if (!start)
1155                 return -EINVAL;
1156
1157         parent = start;
1158         phandle = start->handle;
1159
1160         /*
1161          * Parse through the ACPI namespace, identify all 'devices', and
1162          * create a new 'struct acpi_device' for each.
1163          */
1164         while ((level > 0) && parent) {
1165
1166                 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1167                                               chandle, &chandle);
1168
1169                 /*
1170                  * If this scope is exhausted then move our way back up.
1171                  */
1172                 if (ACPI_FAILURE(status)) {
1173                         level--;
1174                         chandle = phandle;
1175                         acpi_get_parent(phandle, &phandle);
1176                         if (parent->parent)
1177                                 parent = parent->parent;
1178                         continue;
1179                 }
1180
1181                 status = acpi_get_type(chandle, &type);
1182                 if (ACPI_FAILURE(status))
1183                         continue;
1184
1185                 /*
1186                  * If this is a scope object then parse it (depth-first).
1187                  */
1188                 if (type == ACPI_TYPE_LOCAL_SCOPE) {
1189                         level++;
1190                         phandle = chandle;
1191                         chandle = NULL;
1192                         continue;
1193                 }
1194
1195                 /*
1196                  * We're only interested in objects that we consider 'devices'.
1197                  */
1198                 switch (type) {
1199                 case ACPI_TYPE_DEVICE:
1200                         type = ACPI_BUS_TYPE_DEVICE;
1201                         break;
1202                 case ACPI_TYPE_PROCESSOR:
1203                         type = ACPI_BUS_TYPE_PROCESSOR;
1204                         break;
1205                 case ACPI_TYPE_THERMAL:
1206                         type = ACPI_BUS_TYPE_THERMAL;
1207                         break;
1208                 case ACPI_TYPE_POWER:
1209                         type = ACPI_BUS_TYPE_POWER;
1210                         break;
1211                 default:
1212                         continue;
1213                 }
1214
1215                 if (ops->acpi_op_add)
1216                         status = acpi_add_single_object(&child, parent,
1217                                 chandle, type, ops);
1218                 else
1219                         status = acpi_bus_get_device(chandle, &child);
1220
1221                 if (ACPI_FAILURE(status))
1222                         continue;
1223
1224                 if (ops->acpi_op_start && !(ops->acpi_op_add)) {
1225                         status = acpi_start_single_object(child);
1226                         if (ACPI_FAILURE(status))
1227                                 continue;
1228                 }
1229
1230                 /*
1231                  * If the device is present, enabled, and functioning then
1232                  * parse its scope (depth-first).  Note that we need to
1233                  * represent absent devices to facilitate PnP notifications
1234                  * -- but only the subtree head (not all of its children,
1235                  * which will be enumerated when the parent is inserted).
1236                  *
1237                  * TBD: Need notifications and other detection mechanisms
1238                  *      in place before we can fully implement this.
1239                  */
1240                 if (child->status.present) {
1241                         status = acpi_get_next_object(ACPI_TYPE_ANY, chandle,
1242                                                       NULL, NULL);
1243                         if (ACPI_SUCCESS(status)) {
1244                                 level++;
1245                                 phandle = chandle;
1246                                 chandle = NULL;
1247                                 parent = child;
1248                         }
1249                 }
1250         }
1251
1252         return 0;
1253 }
1254
1255 int
1256 acpi_bus_add(struct acpi_device **child,
1257              struct acpi_device *parent, acpi_handle handle, int type)
1258 {
1259         int result;
1260         struct acpi_bus_ops ops;
1261
1262         memset(&ops, 0, sizeof(ops));
1263         ops.acpi_op_add = 1;
1264
1265         result = acpi_add_single_object(child, parent, handle, type, &ops);
1266         if (!result)
1267                 result = acpi_bus_scan(*child, &ops);
1268
1269         return result;
1270 }
1271
1272 EXPORT_SYMBOL(acpi_bus_add);
1273
1274 int acpi_bus_start(struct acpi_device *device)
1275 {
1276         int result;
1277         struct acpi_bus_ops ops;
1278
1279
1280         if (!device)
1281                 return -EINVAL;
1282
1283         result = acpi_start_single_object(device);
1284         if (!result) {
1285                 memset(&ops, 0, sizeof(ops));
1286                 ops.acpi_op_start = 1;
1287                 result = acpi_bus_scan(device, &ops);
1288         }
1289         return result;
1290 }
1291
1292 EXPORT_SYMBOL(acpi_bus_start);
1293
1294 int acpi_bus_trim(struct acpi_device *start, int rmdevice)
1295 {
1296         acpi_status status;
1297         struct acpi_device *parent, *child;
1298         acpi_handle phandle, chandle;
1299         acpi_object_type type;
1300         u32 level = 1;
1301         int err = 0;
1302
1303         parent = start;
1304         phandle = start->handle;
1305         child = chandle = NULL;
1306
1307         while ((level > 0) && parent && (!err)) {
1308                 status = acpi_get_next_object(ACPI_TYPE_ANY, phandle,
1309                                               chandle, &chandle);
1310
1311                 /*
1312                  * If this scope is exhausted then move our way back up.
1313                  */
1314                 if (ACPI_FAILURE(status)) {
1315                         level--;
1316                         chandle = phandle;
1317                         acpi_get_parent(phandle, &phandle);
1318                         child = parent;
1319                         parent = parent->parent;
1320
1321                         if (level == 0)
1322                                 err = acpi_bus_remove(child, rmdevice);
1323                         else
1324                                 err = acpi_bus_remove(child, 1);
1325
1326                         continue;
1327                 }
1328
1329                 status = acpi_get_type(chandle, &type);
1330                 if (ACPI_FAILURE(status)) {
1331                         continue;
1332                 }
1333                 /*
1334                  * If there is a device corresponding to chandle then
1335                  * parse it (depth-first).
1336                  */
1337                 if (acpi_bus_get_device(chandle, &child) == 0) {
1338                         level++;
1339                         phandle = chandle;
1340                         chandle = NULL;
1341                         parent = child;
1342                 }
1343                 continue;
1344         }
1345         return err;
1346 }
1347 EXPORT_SYMBOL_GPL(acpi_bus_trim);
1348
1349
1350 static int acpi_bus_scan_fixed(struct acpi_device *root)
1351 {
1352         int result = 0;
1353         struct acpi_device *device = NULL;
1354         struct acpi_bus_ops ops;
1355
1356         if (!root)
1357                 return -ENODEV;
1358
1359         memset(&ops, 0, sizeof(ops));
1360         ops.acpi_op_add = 1;
1361         ops.acpi_op_start = 1;
1362
1363         /*
1364          * Enumerate all fixed-feature devices.
1365          */
1366         if ((acpi_gbl_FADT.flags & ACPI_FADT_POWER_BUTTON) == 0) {
1367                 result = acpi_add_single_object(&device, acpi_root,
1368                                                 NULL,
1369                                                 ACPI_BUS_TYPE_POWER_BUTTON,
1370                                                 &ops);
1371         }
1372
1373         if ((acpi_gbl_FADT.flags & ACPI_FADT_SLEEP_BUTTON) == 0) {
1374                 result = acpi_add_single_object(&device, acpi_root,
1375                                                 NULL,
1376                                                 ACPI_BUS_TYPE_SLEEP_BUTTON,
1377                                                 &ops);
1378         }
1379
1380         return result;
1381 }
1382
1383 static int __init acpi_scan_init(void)
1384 {
1385         int result;
1386         struct acpi_bus_ops ops;
1387
1388
1389         if (acpi_disabled)
1390                 return 0;
1391
1392         memset(&ops, 0, sizeof(ops));
1393         ops.acpi_op_add = 1;
1394         ops.acpi_op_start = 1;
1395
1396         result = bus_register(&acpi_bus_type);
1397         if (result) {
1398                 /* We don't want to quit even if we failed to add suspend/resume */
1399                 printk(KERN_ERR PREFIX "Could not register bus type\n");
1400         }
1401
1402         /*
1403          * Create the root device in the bus's device tree
1404          */
1405         result = acpi_add_single_object(&acpi_root, NULL, ACPI_ROOT_OBJECT,
1406                                         ACPI_BUS_TYPE_SYSTEM, &ops);
1407         if (result)
1408                 goto Done;
1409
1410         /*
1411          * Enumerate devices in the ACPI namespace.
1412          */
1413         result = acpi_bus_scan_fixed(acpi_root);
1414         if (!result)
1415                 result = acpi_bus_scan(acpi_root, &ops);
1416
1417         if (result)
1418                 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
1419
1420       Done:
1421         return result;
1422 }
1423
1424 subsys_initcall(acpi_scan_init);