sys/contrib/dev/acpica-unix-20050211/utilities/utxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utxface - External interfaces for "global" ACPI functions
   4  *              $Revision: 108 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #define __UTXFACE_C__
 119
 120 #include "acpi.h"
 121 #include "acevents.h"
 122 #include "acnamesp.h"
 123 #include "acparser.h"
 124 #include "acdispat.h"
 125 #include "acdebug.h"
 126
 127 #define _COMPONENT          ACPI_UTILITIES
 128         ACPI_MODULE_NAME    ("utxface")
 129
 130
 131 /*******************************************************************************
 132  *
 133  * FUNCTION:    AcpiInitializeSubsystem
 134  *
 135  * PARAMETERS:  None
 136  *
 137  * RETURN:      Status
 138  *
 139  * DESCRIPTION: Initializes all global variables.  This is the first function
 140  *              called, so any early initialization belongs here.
 141  *
 142  ******************************************************************************/
 143
 144 ACPI_STATUS
 145 AcpiInitializeSubsystem (
 146     void)
 147 {
 148     ACPI_STATUS             Status;
 149
 150     ACPI_FUNCTION_TRACE ("AcpiInitializeSubsystem");
 151
 152
 153     ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ());
 154
 155
 156     /* Initialize all globals used by the subsystem */
 157
 158     AcpiUtInitGlobals ();
 159
 160     /* Initialize the OS-Dependent layer */
 161
 162     Status = AcpiOsInitialize ();
 163     if (ACPI_FAILURE (Status))
 164     {
 165         ACPI_REPORT_ERROR (("OSD failed to initialize, %s\n",
 166             AcpiFormatException (Status)));
 167         return_ACPI_STATUS (Status);
 168     }
 169
 170     /* Create the default mutex objects */
 171
 172     Status = AcpiUtMutexInitialize ();
 173     if (ACPI_FAILURE (Status))
 174     {
 175         ACPI_REPORT_ERROR (("Global mutex creation failure, %s\n",
 176             AcpiFormatException (Status)));
 177         return_ACPI_STATUS (Status);
 178     }
 179
 180     /*
 181      * Initialize the namespace manager and
 182      * the root of the namespace tree
 183      */
 184
 185     Status = AcpiNsRootInitialize ();
 186     if (ACPI_FAILURE (Status))
 187     {
 188         ACPI_REPORT_ERROR (("Namespace initialization failure, %s\n",
 189             AcpiFormatException (Status)));
 190         return_ACPI_STATUS (Status);
 191     }
 192
 193
 194     /* If configured, initialize the AML debugger */
 195
 196     ACPI_DEBUGGER_EXEC (Status = AcpiDbInitialize ());
 197
 198     return_ACPI_STATUS (Status);
 199 }
 200
 201
 202 /*******************************************************************************
 203  *
 204  * FUNCTION:    AcpiEnableSubsystem
 205  *
 206  * PARAMETERS:  Flags           - Init/enable Options
 207  *
 208  * RETURN:      Status
 209  *
 210  * DESCRIPTION: Completes the subsystem initialization including hardware.
 211  *              Puts system into ACPI mode if it isn't already.
 212  *
 213  ******************************************************************************/
 214
 215 ACPI_STATUS
 216 AcpiEnableSubsystem (
 217     UINT32                  Flags)
 218 {
 219     ACPI_STATUS             Status = AE_OK;
 220
 221
 222     ACPI_FUNCTION_TRACE ("AcpiEnableSubsystem");
 223
 224
 225     /*
 226      * We must initialize the hardware before we can enable ACPI.
 227      * The values from the FADT are validated here.
 228      */
 229     if (!(Flags & ACPI_NO_HARDWARE_INIT))
 230     {
 231         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI hardware\n"));
 232
 233         Status = AcpiHwInitialize ();
 234         if (ACPI_FAILURE (Status))
 235         {
 236             return_ACPI_STATUS (Status);
 237         }
 238     }
 239
 240     /* Enable ACPI mode */
 241
 242     if (!(Flags & ACPI_NO_ACPI_ENABLE))
 243     {
 244         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
 245
 246         AcpiGbl_OriginalMode = AcpiHwGetMode();
 247
 248         Status = AcpiEnable ();
 249         if (ACPI_FAILURE (Status))
 250         {
 251             ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "AcpiEnable failed.\n"));
 252             return_ACPI_STATUS (Status);
 253         }
 254     }
 255
 256     /*
 257      * Install the default OpRegion handlers.  These are installed unless
 258      * other handlers have already been installed via the
 259      * InstallAddressSpaceHandler interface.
 260      */
 261     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 262     {
 263         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Installing default address space handlers\n"));
 264
 265         Status = AcpiEvInstallRegionHandlers ();
 266         if (ACPI_FAILURE (Status))
 267         {
 268             return_ACPI_STATUS (Status);
 269         }
 270     }
 271
 272     /*
 273      * Initialize ACPI Event handling (Fixed and General Purpose)
 274      *
 275      * NOTE: We must have the hardware AND events initialized before we can execute
 276      * ANY control methods SAFELY.  Any control method can require ACPI hardware
 277      * support, so the hardware MUST be initialized before execution!
 278      */
 279     if (!(Flags & ACPI_NO_EVENT_INIT))
 280     {
 281         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI events\n"));
 282
 283         Status = AcpiEvInitializeEvents ();
 284         if (ACPI_FAILURE (Status))
 285         {
 286             return_ACPI_STATUS (Status);
 287         }
 288     }
 289
 290     /* Install the SCI handler and Global Lock handler */
 291
 292     if (!(Flags & ACPI_NO_HANDLER_INIT))
 293     {
 294         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Installing SCI/GL handlers\n"));
 295
 296         Status = AcpiEvInstallXruptHandlers ();
 297         if (ACPI_FAILURE (Status))
 298         {
 299             return_ACPI_STATUS (Status);
 300         }
 301     }
 302
 303     return_ACPI_STATUS (Status);
 304 }
 305
 306 /*******************************************************************************
 307  *
 308  * FUNCTION:    AcpiInitializeObjects
 309  *
 310  * PARAMETERS:  Flags           - Init/enable Options
 311  *
 312  * RETURN:      Status
 313  *
 314  * DESCRIPTION: Completes namespace initialization by initializing device
 315  *              objects and executing AML code for Regions, buffers, etc.
 316  *
 317  ******************************************************************************/
 318
 319 ACPI_STATUS
 320 AcpiInitializeObjects (
 321     UINT32                  Flags)
 322 {
 323     ACPI_STATUS             Status = AE_OK;
 324
 325
 326     ACPI_FUNCTION_TRACE ("AcpiInitializeObjects");
 327
 328
 329     /*
 330      * Run all _REG methods
 331      *
 332      * NOTE: Any objects accessed
 333      * by the _REG methods will be automatically initialized, even if they
 334      * contain executable AML (see call to AcpiNsInitializeObjects below).
 335      */
 336     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 337     {
 338         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Executing _REG OpRegion methods\n"));
 339
 340         Status = AcpiEvInitializeOpRegions ();
 341         if (ACPI_FAILURE (Status))
 342         {
 343             return_ACPI_STATUS (Status);
 344         }
 345     }
 346
 347     /*
 348      * Initialize the objects that remain uninitialized.  This
 349      * runs the executable AML that may be part of the declaration of these
 350      * objects: OperationRegions, BufferFields, Buffers, and Packages.
 351      */
 352     if (!(Flags & ACPI_NO_OBJECT_INIT))
 353     {
 354         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Completing Initialization of ACPI Objects\n"));
 355
 356         Status = AcpiNsInitializeObjects ();
 357         if (ACPI_FAILURE (Status))
 358         {
 359             return_ACPI_STATUS (Status);
 360         }
 361     }
 362
 363     /*
 364      * Initialize all device objects in the namespace
 365      * This runs the _STA and _INI methods.
 366      */
 367     if (!(Flags & ACPI_NO_DEVICE_INIT))
 368     {
 369         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Initializing ACPI Devices\n"));
 370
 371         Status = AcpiNsInitializeDevices ();
 372         if (ACPI_FAILURE (Status))
 373         {
 374             return_ACPI_STATUS (Status);
 375         }
 376     }
 377
 378     /*
 379      * Empty the caches (delete the cached objects) on the assumption that
 380      * the table load filled them up more than they will be at runtime --
 381      * thus wasting non-paged memory.
 382      */
 383     Status = AcpiPurgeCachedObjects ();
 384
 385     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 386     return_ACPI_STATUS (Status);
 387 }
 388
 389
 390 /*******************************************************************************
 391  *
 392  * FUNCTION:    AcpiTerminate
 393  *
 394  * PARAMETERS:  None
 395  *
 396  * RETURN:      Status
 397  *
 398  * DESCRIPTION: Shutdown the ACPI subsystem.  Release all resources.
 399  *
 400  ******************************************************************************/
 401
 402 ACPI_STATUS
 403 AcpiTerminate (void)
 404 {
 405     ACPI_STATUS         Status;
 406
 407
 408     ACPI_FUNCTION_TRACE ("AcpiTerminate");
 409
 410
 411     /* Terminate the AML Debugger if present */
 412
 413     ACPI_DEBUGGER_EXEC(AcpiGbl_DbTerminateThreads = TRUE);
 414
 415     /* Shutdown and free all resources */
 416
 417     AcpiUtSubsystemShutdown ();
 418
 419
 420     /* Free the mutex objects */
 421
 422     AcpiUtMutexTerminate ();
 423
 424
 425 #ifdef ACPI_DEBUGGER
 426
 427     /* Shut down the debugger */
 428
 429     AcpiDbTerminate ();
 430 #endif
 431
 432     /* Now we can shutdown the OS-dependent layer */
 433
 434     Status = AcpiOsTerminate ();
 435     return_ACPI_STATUS (Status);
 436 }
 437
 438
 439 /*****************************************************************************
 440  *
 441  * FUNCTION:    AcpiSubsystemStatus
 442  *
 443  * PARAMETERS:  None
 444  *
 445  * RETURN:      Status of the ACPI subsystem
 446  *
 447  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 448  *              before making any other calls, to ensure the subsystem initial-
 449  *              ized successfully.
 450  *
 451  ****************************************************************************/
 452
 453 ACPI_STATUS
 454 AcpiSubsystemStatus (void)
 455 {
 456     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 457     {
 458         return (AE_OK);
 459     }
 460     else
 461     {
 462         return (AE_ERROR);
 463     }
 464 }
 465
 466
 467 /******************************************************************************
 468  *
 469  * FUNCTION:    AcpiGetSystemInfo
 470  *
 471  * PARAMETERS:  OutBuffer       - a pointer to a buffer to receive the
 472  *                                resources for the device
 473  *              BufferLength    - the number of bytes available in the buffer
 474  *
 475  * RETURN:      Status          - the status of the call
 476  *
 477  * DESCRIPTION: This function is called to get information about the current
 478  *              state of the ACPI subsystem.  It will return system information
 479  *              in the OutBuffer.
 480  *
 481  *              If the function fails an appropriate status will be returned
 482  *              and the value of OutBuffer is undefined.
 483  *
 484  ******************************************************************************/
 485
 486 ACPI_STATUS
 487 AcpiGetSystemInfo (
 488     ACPI_BUFFER             *OutBuffer)
 489 {
 490     ACPI_SYSTEM_INFO        *InfoPtr;
 491     UINT32                  i;
 492     ACPI_STATUS             Status;
 493
 494
 495     ACPI_FUNCTION_TRACE ("AcpiGetSystemInfo");
 496
 497
 498     /* Parameter validation */
 499
 500     Status = AcpiUtValidateBuffer (OutBuffer);
 501     if (ACPI_FAILURE (Status))
 502     {
 503         return_ACPI_STATUS (Status);
 504     }
 505
 506     /* Validate/Allocate/Clear caller buffer */
 507
 508     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 509     if (ACPI_FAILURE (Status))
 510     {
 511         return_ACPI_STATUS (Status);
 512     }
 513
 514     /*
 515      * Populate the return buffer
 516      */
 517     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 518
 519     InfoPtr->AcpiCaVersion      = ACPI_CA_VERSION;
 520
 521     /* System flags (ACPI capabilities) */
 522
 523     InfoPtr->Flags              = ACPI_SYS_MODE_ACPI;
 524
 525     /* Timer resolution - 24 or 32 bits  */
 526
 527     if (!AcpiGbl_FADT)
 528     {
 529         InfoPtr->TimerResolution = 0;
 530     }
 531     else if (AcpiGbl_FADT->TmrValExt == 0)
 532     {
 533         InfoPtr->TimerResolution = 24;
 534     }
 535     else
 536     {
 537         InfoPtr->TimerResolution = 32;
 538     }
 539
 540     /* Clear the reserved fields */
 541
 542     InfoPtr->Reserved1          = 0;
 543     InfoPtr->Reserved2          = 0;
 544
 545     /* Current debug levels */
 546
 547     InfoPtr->DebugLayer         = AcpiDbgLayer;
 548     InfoPtr->DebugLevel         = AcpiDbgLevel;
 549
 550     /* Current status of the ACPI tables, per table type */
 551
 552     InfoPtr->NumTableTypes = NUM_ACPI_TABLE_TYPES;
 553     for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++)
 554     {
 555         InfoPtr->TableInfo[i].Count = AcpiGbl_TableLists[i].Count;
 556     }
 557
 558     return_ACPI_STATUS (AE_OK);
 559 }
 560
 561
 562 /*****************************************************************************
 563  *
 564  * FUNCTION:    AcpiInstallInitializationHandler
 565  *
 566  * PARAMETERS:  Handler             - Callback procedure
 567  *
 568  * RETURN:      Status
 569  *
 570  * DESCRIPTION: Install an initialization handler
 571  *
 572  * TBD: When a second function is added, must save the Function also.
 573  *
 574  ****************************************************************************/
 575
 576 ACPI_STATUS
 577 AcpiInstallInitializationHandler (
 578     ACPI_INIT_HANDLER       Handler,
 579     UINT32                  Function)
 580 {
 581
 582     if (!Handler)
 583     {
 584         return (AE_BAD_PARAMETER);
 585     }
 586
 587     if (AcpiGbl_InitHandler)
 588     {
 589         return (AE_ALREADY_EXISTS);
 590     }
 591
 592     AcpiGbl_InitHandler = Handler;
 593     return AE_OK;
 594 }
 595
 596
 597 /*****************************************************************************
 598  *
 599  * FUNCTION:    AcpiPurgeCachedObjects
 600  *
 601  * PARAMETERS:  None
 602  *
 603  * RETURN:      Status
 604  *
 605  * DESCRIPTION: Empty all caches (delete the cached objects)
 606  *
 607  ****************************************************************************/
 608
 609 ACPI_STATUS
 610 AcpiPurgeCachedObjects (void)
 611 {
 612     ACPI_FUNCTION_TRACE ("AcpiPurgeCachedObjects");
 613
 614
 615 #ifdef ACPI_ENABLE_OBJECT_CACHE
 616     AcpiUtDeleteGenericStateCache ();
 617     AcpiUtDeleteObjectCache ();
 618     AcpiDsDeleteWalkStateCache ();
 619     AcpiPsDeleteParseCache ();
 620 #endif
 621
 622     return_ACPI_STATUS (AE_OK);
 623 }