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