drivers/acpi/bus.c

   1 /*
   2  *  acpi_bus.c - ACPI Bus Driver ($Revision: 80 $)
   3  *
   4  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   5  *
   6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or (at
  11  *  your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful, but
  14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21  *
  22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23  */
  24
  25 #include <linux/module.h>
  26 #include <linux/init.h>
  27 #include <linux/ioport.h>
  28 #include <linux/kernel.h>
  29 #include <linux/list.h>
  30 #include <linux/sched.h>
  31 #include <linux/pm.h>
  32 #include <linux/pm_legacy.h>
  33 #include <linux/device.h>
  34 #include <linux/proc_fs.h>
  35 #ifdef CONFIG_X86
  36 #include <asm/mpspec.h>
  37 #endif
  38 #include <acpi/acpi_bus.h>
  39 #include <acpi/acpi_drivers.h>
  40
  41 #define _COMPONENT              ACPI_BUS_COMPONENT
  42 ACPI_MODULE_NAME("acpi_bus")
  43 #ifdef  CONFIG_X86
  44 extern void __init acpi_pic_sci_set_trigger(unsigned int irq, u16 trigger);
  45 #endif
  46
  47 struct fadt_descriptor acpi_fadt;
  48 EXPORT_SYMBOL(acpi_fadt);
  49
  50 struct acpi_device *acpi_root;
  51 struct proc_dir_entry *acpi_root_dir;
  52 EXPORT_SYMBOL(acpi_root_dir);
  53
  54 #define STRUCT_TO_INT(s)        (*((int*)&s))
  55
  56 /* --------------------------------------------------------------------------
  57                                 Device Management
  58    -------------------------------------------------------------------------- */
  59
  60 int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device)
  61 {
  62         acpi_status status = AE_OK;
  63
  64
  65         if (!device)
  66                 return -EINVAL;
  67
  68         /* TBD: Support fixed-feature devices */
  69
  70         status = acpi_get_data(handle, acpi_bus_data_handler, (void **)device);
  71         if (ACPI_FAILURE(status) || !*device) {
  72                 ACPI_EXCEPTION((AE_INFO, status, "No context for object [%p]", handle));
  73                 return -ENODEV;
  74         }
  75
  76         return 0;
  77 }
  78
  79 EXPORT_SYMBOL(acpi_bus_get_device);
  80
  81 int acpi_bus_get_status(struct acpi_device *device)
  82 {
  83         acpi_status status = AE_OK;
  84         unsigned long sta = 0;
  85
  86
  87         if (!device)
  88                 return -EINVAL;
  89
  90         /*
  91          * Evaluate _STA if present.
  92          */
  93         if (device->flags.dynamic_status) {
  94                 status =
  95                     acpi_evaluate_integer(device->handle, "_STA", NULL, &sta);
  96                 if (ACPI_FAILURE(status))
  97                         return -ENODEV;
  98                 STRUCT_TO_INT(device->status) = (int)sta;
  99         }
 100
 101         /*
 102          * Otherwise we assume the status of our parent (unless we don't
 103          * have one, in which case status is implied).
 104          */
 105         else if (device->parent)
 106                 device->status = device->parent->status;
 107         else
 108                 STRUCT_TO_INT(device->status) = 0x0F;
 109
 110         if (device->status.functional && !device->status.present) {
 111                 printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: "
 112                        "functional but not present; setting present\n",
 113                        device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status));
 114                 device->status.present = 1;
 115         }
 116
 117         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n",
 118                           device->pnp.bus_id,
 119                           (u32) STRUCT_TO_INT(device->status)));
 120
 121         return 0;
 122 }
 123
 124 EXPORT_SYMBOL(acpi_bus_get_status);
 125
 126 /* --------------------------------------------------------------------------
 127                                  Power Management
 128    -------------------------------------------------------------------------- */
 129
 130 int acpi_bus_get_power(acpi_handle handle, int *state)
 131 {
 132         int result = 0;
 133         acpi_status status = 0;
 134         struct acpi_device *device = NULL;
 135         unsigned long psc = 0;
 136
 137
 138         result = acpi_bus_get_device(handle, &device);
 139         if (result)
 140                 return result;
 141
 142         *state = ACPI_STATE_UNKNOWN;
 143
 144         if (!device->flags.power_manageable) {
 145                 /* TBD: Non-recursive algorithm for walking up hierarchy */
 146                 if (device->parent)
 147                         *state = device->parent->power.state;
 148                 else
 149                         *state = ACPI_STATE_D0;
 150         } else {
 151                 /*
 152                  * Get the device's power state either directly (via _PSC) or
 153                  * indirectly (via power resources).
 154                  */
 155                 if (device->power.flags.explicit_get) {
 156                         status = acpi_evaluate_integer(device->handle, "_PSC",
 157                                                        NULL, &psc);
 158                         if (ACPI_FAILURE(status))
 159                                 return -ENODEV;
 160                         device->power.state = (int)psc;
 161                 } else if (device->power.flags.power_resources) {
 162                         result = acpi_power_get_inferred_state(device);
 163                         if (result)
 164                                 return result;
 165                 }
 166
 167                 *state = device->power.state;
 168         }
 169
 170         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n",
 171                           device->pnp.bus_id, device->power.state));
 172
 173         return 0;
 174 }
 175
 176 EXPORT_SYMBOL(acpi_bus_get_power);
 177
 178 int acpi_bus_set_power(acpi_handle handle, int state)
 179 {
 180         int result = 0;
 181         acpi_status status = AE_OK;
 182         struct acpi_device *device = NULL;
 183         char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
 184
 185
 186         result = acpi_bus_get_device(handle, &device);
 187         if (result)
 188                 return result;
 189
 190         if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
 191                 return -EINVAL;
 192
 193         /* Make sure this is a valid target state */
 194
 195         if (!device->flags.power_manageable) {
 196                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable",
 197                                 device->kobj.name));
 198                 return -ENODEV;
 199         }
 200         /*
 201          * Get device's current power state if it's unknown
 202          * This means device power state isn't initialized or previous setting failed
 203          */
 204         if (!device->flags.force_power_state) {
 205                 if (device->power.state == ACPI_STATE_UNKNOWN)
 206                         acpi_bus_get_power(device->handle, &device->power.state);
 207                 if (state == device->power.state) {
 208                         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n",
 209                                           state));
 210                         return 0;
 211                 }
 212         }
 213         if (!device->power.states[state].flags.valid) {
 214                 printk(KERN_WARNING PREFIX "Device does not support D%d\n", state);
 215                 return -ENODEV;
 216         }
 217         if (device->parent && (state < device->parent->power.state)) {
 218                 printk(KERN_WARNING PREFIX
 219                               "Cannot set device to a higher-powered"
 220                               " state than parent\n");
 221                 return -ENODEV;
 222         }
 223
 224         /*
 225          * Transition Power
 226          * ----------------
 227          * On transitions to a high-powered state we first apply power (via
 228          * power resources) then evalute _PSx.  Conversly for transitions to
 229          * a lower-powered state.
 230          */
 231         if (state < device->power.state) {
 232                 if (device->power.flags.power_resources) {
 233                         result = acpi_power_transition(device, state);
 234                         if (result)
 235                                 goto end;
 236                 }
 237                 if (device->power.states[state].flags.explicit_set) {
 238                         status = acpi_evaluate_object(device->handle,
 239                                                       object_name, NULL, NULL);
 240                         if (ACPI_FAILURE(status)) {
 241                                 result = -ENODEV;
 242                                 goto end;
 243                         }
 244                 }
 245         } else {
 246                 if (device->power.states[state].flags.explicit_set) {
 247                         status = acpi_evaluate_object(device->handle,
 248                                                       object_name, NULL, NULL);
 249                         if (ACPI_FAILURE(status)) {
 250                                 result = -ENODEV;
 251                                 goto end;
 252                         }
 253                 }
 254                 if (device->power.flags.power_resources) {
 255                         result = acpi_power_transition(device, state);
 256                         if (result)
 257                                 goto end;
 258                 }
 259         }
 260
 261       end:
 262         if (result)
 263                 printk(KERN_WARNING PREFIX
 264                               "Transitioning device [%s] to D%d\n",
 265                               device->pnp.bus_id, state);
 266         else
 267                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 268                                   "Device [%s] transitioned to D%d\n",
 269                                   device->pnp.bus_id, state));
 270
 271         return result;
 272 }
 273
 274 EXPORT_SYMBOL(acpi_bus_set_power);
 275
 276 /* --------------------------------------------------------------------------
 277                                 Event Management
 278    -------------------------------------------------------------------------- */
 279
 280 static DEFINE_SPINLOCK(acpi_bus_event_lock);
 281
 282 LIST_HEAD(acpi_bus_event_list);
 283 DECLARE_WAIT_QUEUE_HEAD(acpi_bus_event_queue);
 284
 285 extern int event_is_open;
 286
 287 int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
 288 {
 289         struct acpi_bus_event *event = NULL;
 290         unsigned long flags = 0;
 291
 292
 293         if (!device)
 294                 return -EINVAL;
 295
 296         /* drop event on the floor if no one's listening */
 297         if (!event_is_open)
 298                 return 0;
 299
 300         event = kmalloc(sizeof(struct acpi_bus_event), GFP_ATOMIC);
 301         if (!event)
 302                 return -ENOMEM;
 303
 304         strcpy(event->device_class, device->pnp.device_class);
 305         strcpy(event->bus_id, device->pnp.bus_id);
 306         event->type = type;
 307         event->data = data;
 308
 309         spin_lock_irqsave(&acpi_bus_event_lock, flags);
 310         list_add_tail(&event->node, &acpi_bus_event_list);
 311         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
 312
 313         wake_up_interruptible(&acpi_bus_event_queue);
 314
 315         return 0;
 316 }
 317
 318 EXPORT_SYMBOL(acpi_bus_generate_event);
 319
 320 int acpi_bus_receive_event(struct acpi_bus_event *event)
 321 {
 322         unsigned long flags = 0;
 323         struct acpi_bus_event *entry = NULL;
 324
 325         DECLARE_WAITQUEUE(wait, current);
 326
 327
 328         if (!event)
 329                 return -EINVAL;
 330
 331         if (list_empty(&acpi_bus_event_list)) {
 332
 333                 set_current_state(TASK_INTERRUPTIBLE);
 334                 add_wait_queue(&acpi_bus_event_queue, &wait);
 335
 336                 if (list_empty(&acpi_bus_event_list))
 337                         schedule();
 338
 339                 remove_wait_queue(&acpi_bus_event_queue, &wait);
 340                 set_current_state(TASK_RUNNING);
 341
 342                 if (signal_pending(current))
 343                         return -ERESTARTSYS;
 344         }
 345
 346         spin_lock_irqsave(&acpi_bus_event_lock, flags);
 347         entry =
 348             list_entry(acpi_bus_event_list.next, struct acpi_bus_event, node);
 349         if (entry)
 350                 list_del(&entry->node);
 351         spin_unlock_irqrestore(&acpi_bus_event_lock, flags);
 352
 353         if (!entry)
 354                 return -ENODEV;
 355
 356         memcpy(event, entry, sizeof(struct acpi_bus_event));
 357
 358         kfree(entry);
 359
 360         return 0;
 361 }
 362
 363 EXPORT_SYMBOL(acpi_bus_receive_event);
 364
 365 /* --------------------------------------------------------------------------
 366                              Notification Handling
 367    -------------------------------------------------------------------------- */
 368
 369 static int
 370 acpi_bus_check_device(struct acpi_device *device, int *status_changed)
 371 {
 372         acpi_status status = 0;
 373         struct acpi_device_status old_status;
 374
 375
 376         if (!device)
 377                 return -EINVAL;
 378
 379         if (status_changed)
 380                 *status_changed = 0;
 381
 382         old_status = device->status;
 383
 384         /*
 385          * Make sure this device's parent is present before we go about
 386          * messing with the device.
 387          */
 388         if (device->parent && !device->parent->status.present) {
 389                 device->status = device->parent->status;
 390                 if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
 391                         if (status_changed)
 392                                 *status_changed = 1;
 393                 }
 394                 return 0;
 395         }
 396
 397         status = acpi_bus_get_status(device);
 398         if (ACPI_FAILURE(status))
 399                 return -ENODEV;
 400
 401         if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
 402                 return 0;
 403
 404         if (status_changed)
 405                 *status_changed = 1;
 406
 407         /*
 408          * Device Insertion/Removal
 409          */
 410         if ((device->status.present) && !(old_status.present)) {
 411                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device insertion detected\n"));
 412                 /* TBD: Handle device insertion */
 413         } else if (!(device->status.present) && (old_status.present)) {
 414                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
 415                 /* TBD: Handle device removal */
 416         }
 417
 418         return 0;
 419 }
 420
 421 static int acpi_bus_check_scope(struct acpi_device *device)
 422 {
 423         int result = 0;
 424         int status_changed = 0;
 425
 426
 427         if (!device)
 428                 return -EINVAL;
 429
 430         /* Status Change? */
 431         result = acpi_bus_check_device(device, &status_changed);
 432         if (result)
 433                 return result;
 434
 435         if (!status_changed)
 436                 return 0;
 437
 438         /*
 439          * TBD: Enumerate child devices within this device's scope and
 440          *       run acpi_bus_check_device()'s on them.
 441          */
 442
 443         return 0;
 444 }
 445
 446 /**
 447  * acpi_bus_notify
 448  * ---------------
 449  * Callback for all 'system-level' device notifications (values 0x00-0x7F).
 450  */
 451 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
 452 {
 453         int result = 0;
 454         struct acpi_device *device = NULL;
 455
 456
 457         if (acpi_bus_get_device(handle, &device))
 458                 return;
 459
 460         switch (type) {
 461
 462         case ACPI_NOTIFY_BUS_CHECK:
 463                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 464                                   "Received BUS CHECK notification for device [%s]\n",
 465                                   device->pnp.bus_id));
 466                 result = acpi_bus_check_scope(device);
 467                 /*
 468                  * TBD: We'll need to outsource certain events to non-ACPI
 469                  *      drivers via the device manager (device.c).
 470                  */
 471                 break;
 472
 473         case ACPI_NOTIFY_DEVICE_CHECK:
 474                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 475                                   "Received DEVICE CHECK notification for device [%s]\n",
 476                                   device->pnp.bus_id));
 477                 result = acpi_bus_check_device(device, NULL);
 478                 /*
 479                  * TBD: We'll need to outsource certain events to non-ACPI
 480                  *      drivers via the device manager (device.c).
 481                  */
 482                 break;
 483
 484         case ACPI_NOTIFY_DEVICE_WAKE:
 485                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 486                                   "Received DEVICE WAKE notification for device [%s]\n",
 487                                   device->pnp.bus_id));
 488                 /* TBD */
 489                 break;
 490
 491         case ACPI_NOTIFY_EJECT_REQUEST:
 492                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 493                                   "Received EJECT REQUEST notification for device [%s]\n",
 494                                   device->pnp.bus_id));
 495                 /* TBD */
 496                 break;
 497
 498         case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
 499                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 500                                   "Received DEVICE CHECK LIGHT notification for device [%s]\n",
 501                                   device->pnp.bus_id));
 502                 /* TBD: Exactly what does 'light' mean? */
 503                 break;
 504
 505         case ACPI_NOTIFY_FREQUENCY_MISMATCH:
 506                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 507                                   "Received FREQUENCY MISMATCH notification for device [%s]\n",
 508                                   device->pnp.bus_id));
 509                 /* TBD */
 510                 break;
 511
 512         case ACPI_NOTIFY_BUS_MODE_MISMATCH:
 513                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 514                                   "Received BUS MODE MISMATCH notification for device [%s]\n",
 515                                   device->pnp.bus_id));
 516                 /* TBD */
 517                 break;
 518
 519         case ACPI_NOTIFY_POWER_FAULT:
 520                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 521                                   "Received POWER FAULT notification for device [%s]\n",
 522                                   device->pnp.bus_id));
 523                 /* TBD */
 524                 break;
 525
 526         default:
 527                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 528                                   "Received unknown/unsupported notification [%08x]\n",
 529                                   type));
 530                 break;
 531         }
 532
 533         return;
 534 }
 535
 536 /* --------------------------------------------------------------------------
 537                              Initialization/Cleanup
 538    -------------------------------------------------------------------------- */
 539
 540 static int __init acpi_bus_init_irq(void)
 541 {
 542         acpi_status status = AE_OK;
 543         union acpi_object arg = { ACPI_TYPE_INTEGER };
 544         struct acpi_object_list arg_list = { 1, &arg };
 545         char *message = NULL;
 546
 547
 548         /*
 549          * Let the system know what interrupt model we are using by
 550          * evaluating the \_PIC object, if exists.
 551          */
 552
 553         switch (acpi_irq_model) {
 554         case ACPI_IRQ_MODEL_PIC:
 555                 message = "PIC";
 556                 break;
 557         case ACPI_IRQ_MODEL_IOAPIC:
 558                 message = "IOAPIC";
 559                 break;
 560         case ACPI_IRQ_MODEL_IOSAPIC:
 561                 message = "IOSAPIC";
 562                 break;
 563         default:
 564                 printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n");
 565                 return -ENODEV;
 566         }
 567
 568         printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message);
 569
 570         arg.integer.value = acpi_irq_model;
 571
 572         status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL);
 573         if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) {
 574                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PIC"));
 575                 return -ENODEV;
 576         }
 577
 578         return 0;
 579 }
 580
 581 void __init acpi_early_init(void)
 582 {
 583         acpi_status status = AE_OK;
 584         struct acpi_buffer buffer = { sizeof(acpi_fadt), &acpi_fadt };
 585
 586
 587         if (acpi_disabled)
 588                 return;
 589
 590         printk(KERN_INFO PREFIX "Core revision %08x\n", ACPI_CA_VERSION);
 591
 592         /* enable workarounds, unless strict ACPI spec. compliance */
 593         if (!acpi_strict)
 594                 acpi_gbl_enable_interpreter_slack = TRUE;
 595
 596         status = acpi_initialize_subsystem();
 597         if (ACPI_FAILURE(status)) {
 598                 printk(KERN_ERR PREFIX
 599                        "Unable to initialize the ACPI Interpreter\n");
 600                 goto error0;
 601         }
 602
 603         status = acpi_load_tables();
 604         if (ACPI_FAILURE(status)) {
 605                 printk(KERN_ERR PREFIX
 606                        "Unable to load the System Description Tables\n");
 607                 goto error0;
 608         }
 609
 610         /*
 611          * Get a separate copy of the FADT for use by other drivers.
 612          */
 613         status = acpi_get_table(ACPI_TABLE_ID_FADT, 1, &buffer);
 614         if (ACPI_FAILURE(status)) {
 615                 printk(KERN_ERR PREFIX "Unable to get the FADT\n");
 616                 goto error0;
 617         }
 618 #ifdef CONFIG_X86
 619         if (!acpi_ioapic) {
 620                 extern acpi_interrupt_flags acpi_sci_flags;
 621
 622                 /* compatible (0) means level (3) */
 623                 if (acpi_sci_flags.trigger == 0)
 624                         acpi_sci_flags.trigger = 3;
 625
 626                 /* Set PIC-mode SCI trigger type */
 627                 acpi_pic_sci_set_trigger(acpi_fadt.sci_int,
 628                                          acpi_sci_flags.trigger);
 629         } else {
 630                 extern int acpi_sci_override_gsi;
 631                 /*
 632                  * now that acpi_fadt is initialized,
 633                  * update it with result from INT_SRC_OVR parsing
 634                  */
 635                 acpi_fadt.sci_int = acpi_sci_override_gsi;
 636         }
 637 #endif
 638
 639         status =
 640             acpi_enable_subsystem(~
 641                                   (ACPI_NO_HARDWARE_INIT |
 642                                    ACPI_NO_ACPI_ENABLE));
 643         if (ACPI_FAILURE(status)) {
 644                 printk(KERN_ERR PREFIX "Unable to enable ACPI\n");
 645                 goto error0;
 646         }
 647
 648         return;
 649
 650       error0:
 651         disable_acpi();
 652         return;
 653 }
 654
 655 static int __init acpi_bus_init(void)
 656 {
 657         int result = 0;
 658         acpi_status status = AE_OK;
 659         extern acpi_status acpi_os_initialize1(void);
 660
 661
 662         status = acpi_os_initialize1();
 663
 664         status =
 665             acpi_enable_subsystem(ACPI_NO_HARDWARE_INIT | ACPI_NO_ACPI_ENABLE);
 666         if (ACPI_FAILURE(status)) {
 667                 printk(KERN_ERR PREFIX
 668                        "Unable to start the ACPI Interpreter\n");
 669                 goto error1;
 670         }
 671
 672         if (ACPI_FAILURE(status)) {
 673                 printk(KERN_ERR PREFIX
 674                        "Unable to initialize ACPI OS objects\n");
 675                 goto error1;
 676         }
 677 #ifdef CONFIG_ACPI_EC
 678         /*
 679          * ACPI 2.0 requires the EC driver to be loaded and work before
 680          * the EC device is found in the namespace (i.e. before acpi_initialize_objects()
 681          * is called).
 682          *
 683          * This is accomplished by looking for the ECDT table, and getting
 684          * the EC parameters out of that.
 685          */
 686         status = acpi_ec_ecdt_probe();
 687         /* Ignore result. Not having an ECDT is not fatal. */
 688 #endif
 689
 690         status = acpi_initialize_objects(ACPI_FULL_INITIALIZATION);
 691         if (ACPI_FAILURE(status)) {
 692                 printk(KERN_ERR PREFIX "Unable to initialize ACPI objects\n");
 693                 goto error1;
 694         }
 695
 696         printk(KERN_INFO PREFIX "Interpreter enabled\n");
 697
 698         /*
 699          * Get the system interrupt model and evaluate \_PIC.
 700          */
 701         result = acpi_bus_init_irq();
 702         if (result)
 703                 goto error1;
 704
 705         /*
 706          * Register the for all standard device notifications.
 707          */
 708         status =
 709             acpi_install_notify_handler(ACPI_ROOT_OBJECT, ACPI_SYSTEM_NOTIFY,
 710                                         &acpi_bus_notify, NULL);
 711         if (ACPI_FAILURE(status)) {
 712                 printk(KERN_ERR PREFIX
 713                        "Unable to register for device notifications\n");
 714                 goto error1;
 715         }
 716
 717         /*
 718          * Create the top ACPI proc directory
 719          */
 720         acpi_root_dir = proc_mkdir(ACPI_BUS_FILE_ROOT, NULL);
 721
 722         return 0;
 723
 724         /* Mimic structured exception handling */
 725       error1:
 726         acpi_terminate();
 727         return -ENODEV;
 728 }
 729
 730 decl_subsys(acpi, NULL, NULL);
 731
 732 static int __init acpi_init(void)
 733 {
 734         int result = 0;
 735
 736
 737         if (acpi_disabled) {
 738                 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
 739                 return -ENODEV;
 740         }
 741
 742         result = firmware_register(&acpi_subsys);
 743         if (result < 0)
 744                 printk(KERN_WARNING "%s: firmware_register error: %d\n",
 745                         __FUNCTION__, result);
 746
 747         result = acpi_bus_init();
 748
 749         if (!result) {
 750 #ifdef CONFIG_PM_LEGACY
 751                 if (!PM_IS_ACTIVE())
 752                         pm_active = 1;
 753                 else {
 754                         printk(KERN_INFO PREFIX
 755                                "APM is already active, exiting\n");
 756                         disable_acpi();
 757                         result = -ENODEV;
 758                 }
 759 #endif
 760         } else
 761                 disable_acpi();
 762
 763         return result;
 764 }
 765
 766 subsys_initcall(acpi_init);