sys/contrib/dev/acpica/utxface.c

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