sys/contrib/dev/acpica/utxface.c

   1 /******************************************************************************
   2  *
   3  * Module Name: utxface - External interfaces for "global" ACPI functions
   4  *              $Revision: 1.112 $
   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 <contrib/dev/acpica/acpi.h>
 121 #include <contrib/dev/acpica/acevents.h>
 122 #include <contrib/dev/acpica/acnamesp.h>
 123 #include <contrib/dev/acpica/acdebug.h>
 124
 125 #define _COMPONENT          ACPI_UTILITIES
 126         ACPI_MODULE_NAME    ("utxface")
 127
 128
 129 /*******************************************************************************
 130  *
 131  * FUNCTION:    AcpiInitializeSubsystem
 132  *
 133  * PARAMETERS:  None
 134  *
 135  * RETURN:      Status
 136  *
 137  * DESCRIPTION: Initializes all global variables.  This is the first function
 138  *              called, so any early initialization belongs here.
 139  *
 140  ******************************************************************************/
 141
 142 ACPI_STATUS
 143 AcpiInitializeSubsystem (
 144     void)
 145 {
 146     ACPI_STATUS             Status;
 147
 148
 149     ACPI_FUNCTION_TRACE ("AcpiInitializeSubsystem");
 150
 151
 152     ACPI_DEBUG_EXEC (AcpiUtInitStackPtrTrace ());
 153
 154     /* Initialize the OS-Dependent layer */
 155
 156     Status = AcpiOsInitialize ();
 157     if (ACPI_FAILURE (Status))
 158     {
 159         ACPI_REPORT_ERROR (("OSD failed to initialize, %s\n",
 160             AcpiFormatException (Status)));
 161         return_ACPI_STATUS (Status);
 162     }
 163
 164     /* Initialize all globals used by the subsystem */
 165
 166     AcpiUtInitGlobals ();
 167
 168     /* Create the default mutex objects */
 169
 170     Status = AcpiUtMutexInitialize ();
 171     if (ACPI_FAILURE (Status))
 172     {
 173         ACPI_REPORT_ERROR (("Global mutex creation failure, %s\n",
 174             AcpiFormatException (Status)));
 175         return_ACPI_STATUS (Status);
 176     }
 177
 178     /*
 179      * Initialize the namespace manager and
 180      * the root of the namespace tree
 181      */
 182     Status = AcpiNsRootInitialize ();
 183     if (ACPI_FAILURE (Status))
 184     {
 185         ACPI_REPORT_ERROR (("Namespace initialization failure, %s\n",
 186             AcpiFormatException (Status)));
 187         return_ACPI_STATUS (Status);
 188     }
 189
 190     /* If configured, initialize the AML debugger */
 191
 192     ACPI_DEBUGGER_EXEC (Status = AcpiDbInitialize ());
 193
 194     return_ACPI_STATUS (Status);
 195 }
 196
 197
 198 /*******************************************************************************
 199  *
 200  * FUNCTION:    AcpiEnableSubsystem
 201  *
 202  * PARAMETERS:  Flags           - Init/enable Options
 203  *
 204  * RETURN:      Status
 205  *
 206  * DESCRIPTION: Completes the subsystem initialization including hardware.
 207  *              Puts system into ACPI mode if it isn't already.
 208  *
 209  ******************************************************************************/
 210
 211 ACPI_STATUS
 212 AcpiEnableSubsystem (
 213     UINT32                  Flags)
 214 {
 215     ACPI_STATUS             Status = AE_OK;
 216
 217
 218     ACPI_FUNCTION_TRACE ("AcpiEnableSubsystem");
 219
 220
 221     /*
 222      * We must initialize the hardware before we can enable ACPI.
 223      * The values from the FADT are validated here.
 224      */
 225     if (!(Flags & ACPI_NO_HARDWARE_INIT))
 226     {
 227         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 228             "[Init] Initializing ACPI hardware\n"));
 229
 230         Status = AcpiHwInitialize ();
 231         if (ACPI_FAILURE (Status))
 232         {
 233             return_ACPI_STATUS (Status);
 234         }
 235     }
 236
 237     /* Enable ACPI mode */
 238
 239     if (!(Flags & ACPI_NO_ACPI_ENABLE))
 240     {
 241         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
 242
 243         AcpiGbl_OriginalMode = AcpiHwGetMode();
 244
 245         Status = AcpiEnable ();
 246         if (ACPI_FAILURE (Status))
 247         {
 248             ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "AcpiEnable failed.\n"));
 249             return_ACPI_STATUS (Status);
 250         }
 251     }
 252
 253     /*
 254      * Install the default OpRegion handlers.  These are installed unless
 255      * other handlers have already been installed via the
 256      * InstallAddressSpaceHandler interface.
 257      */
 258     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 259     {
 260         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 261             "[Init] Installing default address space handlers\n"));
 262
 263         Status = AcpiEvInstallRegionHandlers ();
 264         if (ACPI_FAILURE (Status))
 265         {
 266             return_ACPI_STATUS (Status);
 267         }
 268     }
 269
 270     /*
 271      * Initialize ACPI Event handling (Fixed and General Purpose)
 272      *
 273      * NOTE: We must have the hardware AND events initialized before we can
 274      * execute ANY control methods SAFELY.  Any control method can require
 275      * ACPI hardware support, so the hardware MUST be initialized before
 276      * execution!
 277      */
 278     if (!(Flags & ACPI_NO_EVENT_INIT))
 279     {
 280         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 281             "[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,
 295             "[Init] Installing SCI/GL handlers\n"));
 296
 297         Status = AcpiEvInstallXruptHandlers ();
 298         if (ACPI_FAILURE (Status))
 299         {
 300             return_ACPI_STATUS (Status);
 301         }
 302     }
 303
 304     return_ACPI_STATUS (Status);
 305 }
 306
 307 /*******************************************************************************
 308  *
 309  * FUNCTION:    AcpiInitializeObjects
 310  *
 311  * PARAMETERS:  Flags           - Init/enable Options
 312  *
 313  * RETURN:      Status
 314  *
 315  * DESCRIPTION: Completes namespace initialization by initializing device
 316  *              objects and executing AML code for Regions, buffers, etc.
 317  *
 318  ******************************************************************************/
 319
 320 ACPI_STATUS
 321 AcpiInitializeObjects (
 322     UINT32                  Flags)
 323 {
 324     ACPI_STATUS             Status = AE_OK;
 325
 326
 327     ACPI_FUNCTION_TRACE ("AcpiInitializeObjects");
 328
 329
 330     /*
 331      * Run all _REG methods
 332      *
 333      * NOTE: Any objects accessed
 334      * by the _REG methods will be automatically initialized, even if they
 335      * contain executable AML (see call to AcpiNsInitializeObjects below).
 336      */
 337     if (!(Flags & ACPI_NO_ADDRESS_SPACE_INIT))
 338     {
 339         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 340             "[Init] Executing _REG OpRegion methods\n"));
 341
 342         Status = AcpiEvInitializeOpRegions ();
 343         if (ACPI_FAILURE (Status))
 344         {
 345             return_ACPI_STATUS (Status);
 346         }
 347     }
 348
 349     /*
 350      * Initialize the objects that remain uninitialized.  This
 351      * runs the executable AML that may be part of the declaration of these
 352      * objects: OperationRegions, BufferFields, Buffers, and Packages.
 353      */
 354     if (!(Flags & ACPI_NO_OBJECT_INIT))
 355     {
 356         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 357             "[Init] Completing Initialization of ACPI Objects\n"));
 358
 359         Status = AcpiNsInitializeObjects ();
 360         if (ACPI_FAILURE (Status))
 361         {
 362             return_ACPI_STATUS (Status);
 363         }
 364     }
 365
 366     /*
 367      * Initialize all device objects in the namespace
 368      * This runs the _STA and _INI methods.
 369      */
 370     if (!(Flags & ACPI_NO_DEVICE_INIT))
 371     {
 372         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 373             "[Init] Initializing ACPI Devices\n"));
 374
 375         Status = AcpiNsInitializeDevices ();
 376         if (ACPI_FAILURE (Status))
 377         {
 378             return_ACPI_STATUS (Status);
 379         }
 380     }
 381
 382     /*
 383      * Empty the caches (delete the cached objects) on the assumption that
 384      * the table load filled them up more than they will be at runtime --
 385      * thus wasting non-paged memory.
 386      */
 387     Status = AcpiPurgeCachedObjects ();
 388
 389     AcpiGbl_StartupFlags |= ACPI_INITIALIZED_OK;
 390     return_ACPI_STATUS (Status);
 391 }
 392
 393
 394 /*******************************************************************************
 395  *
 396  * FUNCTION:    AcpiTerminate
 397  *
 398  * PARAMETERS:  None
 399  *
 400  * RETURN:      Status
 401  *
 402  * DESCRIPTION: Shutdown the ACPI subsystem.  Release all resources.
 403  *
 404  ******************************************************************************/
 405
 406 ACPI_STATUS
 407 AcpiTerminate (
 408     void)
 409 {
 410     ACPI_STATUS         Status;
 411
 412
 413     ACPI_FUNCTION_TRACE ("AcpiTerminate");
 414
 415
 416     /* Terminate the AML Debugger if present */
 417
 418     ACPI_DEBUGGER_EXEC(AcpiGbl_DbTerminateThreads = TRUE);
 419
 420     /* Shutdown and free all resources */
 421
 422     AcpiUtSubsystemShutdown ();
 423
 424
 425     /* Free the mutex objects */
 426
 427     AcpiUtMutexTerminate ();
 428
 429
 430 #ifdef ACPI_DEBUGGER
 431
 432     /* Shut down the debugger */
 433
 434     AcpiDbTerminate ();
 435 #endif
 436
 437     /* Now we can shutdown the OS-dependent layer */
 438
 439     Status = AcpiOsTerminate ();
 440     return_ACPI_STATUS (Status);
 441 }
 442
 443
 444 /*******************************************************************************
 445  *
 446  * FUNCTION:    AcpiSubsystemStatus
 447  *
 448  * PARAMETERS:  None
 449  *
 450  * RETURN:      Status of the ACPI subsystem
 451  *
 452  * DESCRIPTION: Other drivers that use the ACPI subsystem should call this
 453  *              before making any other calls, to ensure the subsystem
 454  *              initialized successfully.
 455  *
 456  ******************************************************************************/
 457
 458 ACPI_STATUS
 459 AcpiSubsystemStatus (
 460     void)
 461 {
 462
 463     if (AcpiGbl_StartupFlags & ACPI_INITIALIZED_OK)
 464     {
 465         return (AE_OK);
 466     }
 467     else
 468     {
 469         return (AE_ERROR);
 470     }
 471 }
 472
 473
 474 /*******************************************************************************
 475  *
 476  * FUNCTION:    AcpiGetSystemInfo
 477  *
 478  * PARAMETERS:  OutBuffer       - A buffer to receive the resources for the
 479  *                                device
 480  *
 481  * RETURN:      Status          - the status of the call
 482  *
 483  * DESCRIPTION: This function is called to get information about the current
 484  *              state of the ACPI subsystem.  It will return system information
 485  *              in the OutBuffer.
 486  *
 487  *              If the function fails an appropriate status will be returned
 488  *              and the value of OutBuffer is undefined.
 489  *
 490  ******************************************************************************/
 491
 492 ACPI_STATUS
 493 AcpiGetSystemInfo (
 494     ACPI_BUFFER             *OutBuffer)
 495 {
 496     ACPI_SYSTEM_INFO        *InfoPtr;
 497     ACPI_STATUS             Status;
 498     UINT32                  i;
 499
 500
 501     ACPI_FUNCTION_TRACE ("AcpiGetSystemInfo");
 502
 503
 504     /* Parameter validation */
 505
 506     Status = AcpiUtValidateBuffer (OutBuffer);
 507     if (ACPI_FAILURE (Status))
 508     {
 509         return_ACPI_STATUS (Status);
 510     }
 511
 512     /* Validate/Allocate/Clear caller buffer */
 513
 514     Status = AcpiUtInitializeBuffer (OutBuffer, sizeof (ACPI_SYSTEM_INFO));
 515     if (ACPI_FAILURE (Status))
 516     {
 517         return_ACPI_STATUS (Status);
 518     }
 519
 520     /*
 521      * Populate the return buffer
 522      */
 523     InfoPtr = (ACPI_SYSTEM_INFO *) OutBuffer->Pointer;
 524
 525     InfoPtr->AcpiCaVersion      = ACPI_CA_VERSION;
 526
 527     /* System flags (ACPI capabilities) */
 528
 529     InfoPtr->Flags              = ACPI_SYS_MODE_ACPI;
 530
 531     /* Timer resolution - 24 or 32 bits  */
 532
 533     if (!AcpiGbl_FADT)
 534     {
 535         InfoPtr->TimerResolution = 0;
 536     }
 537     else if (AcpiGbl_FADT->TmrValExt == 0)
 538     {
 539         InfoPtr->TimerResolution = 24;
 540     }
 541     else
 542     {
 543         InfoPtr->TimerResolution = 32;
 544     }
 545
 546     /* Clear the reserved fields */
 547
 548     InfoPtr->Reserved1          = 0;
 549     InfoPtr->Reserved2          = 0;
 550
 551     /* Current debug levels */
 552
 553     InfoPtr->DebugLayer         = AcpiDbgLayer;
 554     InfoPtr->DebugLevel         = AcpiDbgLevel;
 555
 556     /* Current status of the ACPI tables, per table type */
 557
 558     InfoPtr->NumTableTypes = NUM_ACPI_TABLE_TYPES;
 559     for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++)
 560     {
 561         InfoPtr->TableInfo[i].Count = AcpiGbl_TableLists[i].Count;
 562     }
 563
 564     return_ACPI_STATUS (AE_OK);
 565 }
 566
 567
 568 /*****************************************************************************
 569  *
 570  * FUNCTION:    AcpiInstallInitializationHandler
 571  *
 572  * PARAMETERS:  Handler             - Callback procedure
 573  *              Function            - Not (currently) used, see below
 574  *
 575  * RETURN:      Status
 576  *
 577  * DESCRIPTION: Install an initialization handler
 578  *
 579  * TBD: When a second function is added, must save the Function also.
 580  *
 581  ****************************************************************************/
 582
 583 ACPI_STATUS
 584 AcpiInstallInitializationHandler (
 585     ACPI_INIT_HANDLER       Handler,
 586     UINT32                  Function)
 587 {
 588
 589     if (!Handler)
 590     {
 591         return (AE_BAD_PARAMETER);
 592     }
 593
 594     if (AcpiGbl_InitHandler)
 595     {
 596         return (AE_ALREADY_EXISTS);
 597     }
 598
 599     AcpiGbl_InitHandler = Handler;
 600     return AE_OK;
 601 }
 602
 603
 604 /*****************************************************************************
 605  *
 606  * FUNCTION:    AcpiPurgeCachedObjects
 607  *
 608  * PARAMETERS:  None
 609  *
 610  * RETURN:      Status
 611  *
 612  * DESCRIPTION: Empty all caches (delete the cached objects)
 613  *
 614  ****************************************************************************/
 615
 616 ACPI_STATUS
 617 AcpiPurgeCachedObjects (
 618     void)
 619 {
 620     ACPI_FUNCTION_TRACE ("AcpiPurgeCachedObjects");
 621
 622     (void) AcpiOsPurgeCache (AcpiGbl_StateCache);
 623     (void) AcpiOsPurgeCache (AcpiGbl_OperandCache);
 624     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeCache);
 625     (void) AcpiOsPurgeCache (AcpiGbl_PsNodeExtCache);
 626     return_ACPI_STATUS (AE_OK);
 627 }