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