Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /******************************************************************************
  2.  *
  3.  * Module Name: utglobal - Global variables for the ACPI subsystem
  4.  *
  5.  *****************************************************************************/
  6.  
  7. /******************************************************************************
  8.  *
  9.  * 1. Copyright Notice
  10.  *
  11.  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  12.  * All rights reserved.
  13.  *
  14.  * 2. License
  15.  *
  16.  * 2.1. This is your license from Intel Corp. under its intellectual property
  17.  * rights.  You may have additional license terms from the party that provided
  18.  * you this software, covering your right to use that party's intellectual
  19.  * property rights.
  20.  *
  21.  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22.  * copy of the source code appearing in this file ("Covered Code") an
  23.  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24.  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25.  * make derivatives, distribute, use and display any portion of the Covered
  26.  * Code in any form, with the right to sublicense such rights; and
  27.  *
  28.  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29.  * license (with the right to sublicense), under only those claims of Intel
  30.  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31.  * offer to sell, and import the Covered Code and derivative works thereof
  32.  * solely to the minimum extent necessary to exercise the above copyright
  33.  * license, and in no event shall the patent license extend to any additions
  34.  * to or modifications of the Original Intel Code.  No other license or right
  35.  * is granted directly or by implication, estoppel or otherwise;
  36.  *
  37.  * The above copyright and patent license is granted only if the following
  38.  * conditions are met:
  39.  *
  40.  * 3. Conditions
  41.  *
  42.  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43.  * Redistribution of source code of any substantial portion of the Covered
  44.  * Code or modification with rights to further distribute source must include
  45.  * the above Copyright Notice, the above License, this list of Conditions,
  46.  * and the following Disclaimer and Export Compliance provision.  In addition,
  47.  * Licensee must cause all Covered Code to which Licensee contributes to
  48.  * contain a file documenting the changes Licensee made to create that Covered
  49.  * Code and the date of any change.  Licensee must include in that file the
  50.  * documentation of any changes made by any predecessor Licensee.  Licensee
  51.  * must include a prominent statement that the modification is derived,
  52.  * directly or indirectly, from Original Intel Code.
  53.  *
  54.  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55.  * Redistribution of source code of any substantial portion of the Covered
  56.  * Code or modification without rights to further distribute source must
  57.  * include the following Disclaimer and Export Compliance provision in the
  58.  * documentation and/or other materials provided with distribution.  In
  59.  * addition, Licensee may not authorize further sublicense of source of any
  60.  * portion of the Covered Code, and must include terms to the effect that the
  61.  * license from Licensee to its licensee is limited to the intellectual
  62.  * property embodied in the software Licensee provides to its licensee, and
  63.  * not to intellectual property embodied in modifications its licensee may
  64.  * make.
  65.  *
  66.  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67.  * substantial portion of the Covered Code or modification must reproduce the
  68.  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69.  * provision in the documentation and/or other materials provided with the
  70.  * distribution.
  71.  *
  72.  * 3.4. Intel retains all right, title, and interest in and to the Original
  73.  * Intel Code.
  74.  *
  75.  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76.  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77.  * other dealings in products derived from or relating to the Covered Code
  78.  * without prior written authorization from Intel.
  79.  *
  80.  * 4. Disclaimer and Export Compliance
  81.  *
  82.  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83.  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84.  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85.  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86.  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87.  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88.  * PARTICULAR PURPOSE.
  89.  *
  90.  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91.  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92.  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93.  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94.  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95.  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96.  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97.  * LIMITED REMEDY.
  98.  *
  99.  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  100.  * software or system incorporating such software without first obtaining any
  101.  * required license or other approval from the U. S. Department of Commerce or
  102.  * any other agency or department of the United States Government.  In the
  103.  * event Licensee exports any such software from the United States or
  104.  * re-exports any such software from a foreign destination, Licensee shall
  105.  * ensure that the distribution and export/re-export of the software is in
  106.  * compliance with all laws, regulations, orders, or other restrictions of the
  107.  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  108.  * any of its subsidiaries will export/re-export any technical data, process,
  109.  * software, or service, directly or indirectly, to any country for which the
  110.  * United States government or any agency thereof requires an export license,
  111.  * other governmental approval, or letter of assurance, without first obtaining
  112.  * such license, approval or letter.
  113.  *
  114.  *****************************************************************************/
  115.  
  116. #define __UTGLOBAL_C__
  117. #define DEFINE_ACPI_GLOBALS
  118.  
  119. #include "acpi.h"
  120. #include "accommon.h"
  121. #include "acnamesp.h"
  122.  
  123. #define _COMPONENT          ACPI_UTILITIES
  124.         ACPI_MODULE_NAME    ("utglobal")
  125.  
  126.  
  127. /*******************************************************************************
  128.  *
  129.  * Static global variable initialization.
  130.  *
  131.  ******************************************************************************/
  132.  
  133. /*
  134.  * We want the debug switches statically initialized so they
  135.  * are already set when the debugger is entered.
  136.  */
  137.  
  138. /* Debug switch - level and trace mask */
  139.  
  140. #ifdef ACPI_DEBUG_OUTPUT
  141. UINT32                      AcpiDbgLevel = ACPI_DEBUG_DEFAULT;
  142. #else
  143. UINT32                      AcpiDbgLevel = ACPI_NORMAL_DEFAULT;
  144. #endif
  145.  
  146. /* Debug switch - layer (component) mask */
  147.  
  148. UINT32                      AcpiDbgLayer = ACPI_COMPONENT_DEFAULT;
  149. UINT32                      AcpiGbl_NestingLevel = 0;
  150.  
  151. /* Debugger globals */
  152.  
  153. BOOLEAN                     AcpiGbl_DbTerminateThreads = FALSE;
  154. BOOLEAN                     AcpiGbl_AbortMethod = FALSE;
  155. BOOLEAN                     AcpiGbl_MethodExecuting = FALSE;
  156.  
  157. /* System flags */
  158.  
  159. UINT32                      AcpiGbl_StartupFlags = 0;
  160.  
  161. /* System starts uninitialized */
  162.  
  163. BOOLEAN                     AcpiGbl_Shutdown = TRUE;
  164.  
  165. const char                  *AcpiGbl_SleepStateNames[ACPI_S_STATE_COUNT] =
  166. {
  167.     "\\_S0_",
  168.     "\\_S1_",
  169.     "\\_S2_",
  170.     "\\_S3_",
  171.     "\\_S4_",
  172.     "\\_S5_"
  173. };
  174.  
  175. const char                  *AcpiGbl_LowestDstateNames[ACPI_NUM_SxW_METHODS] =
  176. {
  177.     "_S0W",
  178.     "_S1W",
  179.     "_S2W",
  180.     "_S3W",
  181.     "_S4W"
  182. };
  183.  
  184. const char                  *AcpiGbl_HighestDstateNames[ACPI_NUM_SxD_METHODS] =
  185. {
  186.     "_S1D",
  187.     "_S2D",
  188.     "_S3D",
  189.     "_S4D"
  190. };
  191.  
  192.  
  193. /*******************************************************************************
  194.  *
  195.  * FUNCTION:    AcpiFormatException
  196.  *
  197.  * PARAMETERS:  Status       - The ACPI_STATUS code to be formatted
  198.  *
  199.  * RETURN:      A string containing the exception text. A valid pointer is
  200.  *              always returned.
  201.  *
  202.  * DESCRIPTION: This function translates an ACPI exception into an ASCII string
  203.  *              It is here instead of utxface.c so it is always present.
  204.  *
  205.  ******************************************************************************/
  206.  
  207. const char *
  208. AcpiFormatException (
  209.     ACPI_STATUS             Status)
  210. {
  211.     const char              *Exception = NULL;
  212.  
  213.  
  214.     ACPI_FUNCTION_ENTRY ();
  215.  
  216.  
  217.     Exception = AcpiUtValidateException (Status);
  218.     if (!Exception)
  219.     {
  220.         /* Exception code was not recognized */
  221.  
  222.         ACPI_ERROR ((AE_INFO,
  223.             "Unknown exception code: 0x%8.8X", Status));
  224.  
  225.         Exception = "UNKNOWN_STATUS_CODE";
  226.     }
  227.  
  228.     return (ACPI_CAST_PTR (const char, Exception));
  229. }
  230.  
  231. ACPI_EXPORT_SYMBOL (AcpiFormatException)
  232.  
  233.  
  234. /*******************************************************************************
  235.  *
  236.  * Namespace globals
  237.  *
  238.  ******************************************************************************/
  239.  
  240. /*
  241.  * Predefined ACPI Names (Built-in to the Interpreter)
  242.  *
  243.  * NOTES:
  244.  * 1) _SB_ is defined to be a device to allow \_SB_._INI to be run
  245.  *    during the initialization sequence.
  246.  * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
  247.  *    perform a Notify() operation on it.
  248.  */
  249. const ACPI_PREDEFINED_NAMES     AcpiGbl_PreDefinedNames[] =
  250. {
  251.     {"_GPE",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
  252.     {"_PR_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
  253.     {"_SB_",    ACPI_TYPE_DEVICE,           NULL},
  254.     {"_SI_",    ACPI_TYPE_LOCAL_SCOPE,      NULL},
  255.     {"_TZ_",    ACPI_TYPE_THERMAL,          NULL},
  256.     {"_REV",    ACPI_TYPE_INTEGER,          (char *) ACPI_CA_SUPPORT_LEVEL},
  257.     {"_OS_",    ACPI_TYPE_STRING,           ACPI_OS_NAME},
  258.     {"_GL_",    ACPI_TYPE_MUTEX,            (char *) 1},
  259.  
  260. #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
  261.     {"_OSI",    ACPI_TYPE_METHOD,           (char *) 1},
  262. #endif
  263.  
  264.     /* Table terminator */
  265.  
  266.     {NULL,      ACPI_TYPE_ANY,              NULL}
  267. };
  268.  
  269. /*
  270.  * Properties of the ACPI Object Types, both internal and external.
  271.  * The table is indexed by values of ACPI_OBJECT_TYPE
  272.  */
  273. const UINT8                     AcpiGbl_NsProperties[ACPI_NUM_NS_TYPES] =
  274. {
  275.     ACPI_NS_NORMAL,                     /* 00 Any              */
  276.     ACPI_NS_NORMAL,                     /* 01 Number           */
  277.     ACPI_NS_NORMAL,                     /* 02 String           */
  278.     ACPI_NS_NORMAL,                     /* 03 Buffer           */
  279.     ACPI_NS_NORMAL,                     /* 04 Package          */
  280.     ACPI_NS_NORMAL,                     /* 05 FieldUnit        */
  281.     ACPI_NS_NEWSCOPE,                   /* 06 Device           */
  282.     ACPI_NS_NORMAL,                     /* 07 Event            */
  283.     ACPI_NS_NEWSCOPE,                   /* 08 Method           */
  284.     ACPI_NS_NORMAL,                     /* 09 Mutex            */
  285.     ACPI_NS_NORMAL,                     /* 10 Region           */
  286.     ACPI_NS_NEWSCOPE,                   /* 11 Power            */
  287.     ACPI_NS_NEWSCOPE,                   /* 12 Processor        */
  288.     ACPI_NS_NEWSCOPE,                   /* 13 Thermal          */
  289.     ACPI_NS_NORMAL,                     /* 14 BufferField      */
  290.     ACPI_NS_NORMAL,                     /* 15 DdbHandle        */
  291.     ACPI_NS_NORMAL,                     /* 16 Debug Object     */
  292.     ACPI_NS_NORMAL,                     /* 17 DefField         */
  293.     ACPI_NS_NORMAL,                     /* 18 BankField        */
  294.     ACPI_NS_NORMAL,                     /* 19 IndexField       */
  295.     ACPI_NS_NORMAL,                     /* 20 Reference        */
  296.     ACPI_NS_NORMAL,                     /* 21 Alias            */
  297.     ACPI_NS_NORMAL,                     /* 22 MethodAlias      */
  298.     ACPI_NS_NORMAL,                     /* 23 Notify           */
  299.     ACPI_NS_NORMAL,                     /* 24 Address Handler  */
  300.     ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 25 Resource Desc    */
  301.     ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL,   /* 26 Resource Field   */
  302.     ACPI_NS_NEWSCOPE,                   /* 27 Scope            */
  303.     ACPI_NS_NORMAL,                     /* 28 Extra            */
  304.     ACPI_NS_NORMAL,                     /* 29 Data             */
  305.     ACPI_NS_NORMAL                      /* 30 Invalid          */
  306. };
  307.  
  308.  
  309. /* Hex to ASCII conversion table */
  310.  
  311. static const char           AcpiGbl_HexToAscii[] =
  312. {
  313.     '0','1','2','3','4','5','6','7',
  314.     '8','9','A','B','C','D','E','F'
  315. };
  316.  
  317.  
  318. /*******************************************************************************
  319.  *
  320.  * FUNCTION:    AcpiUtHexToAsciiChar
  321.  *
  322.  * PARAMETERS:  Integer             - Contains the hex digit
  323.  *              Position            - bit position of the digit within the
  324.  *                                    integer (multiple of 4)
  325.  *
  326.  * RETURN:      The converted Ascii character
  327.  *
  328.  * DESCRIPTION: Convert a hex digit to an Ascii character
  329.  *
  330.  ******************************************************************************/
  331.  
  332. char
  333. AcpiUtHexToAsciiChar (
  334.     UINT64                  Integer,
  335.     UINT32                  Position)
  336. {
  337.  
  338.     return (AcpiGbl_HexToAscii[(Integer >> Position) & 0xF]);
  339. }
  340.  
  341.  
  342. /******************************************************************************
  343.  *
  344.  * Event and Hardware globals
  345.  *
  346.  ******************************************************************************/
  347.  
  348. ACPI_BIT_REGISTER_INFO      AcpiGbl_BitRegisterInfo[ACPI_NUM_BITREG] =
  349. {
  350.     /* Name                                     Parent Register             Register Bit Position                   Register Bit Mask       */
  351.  
  352.     /* ACPI_BITREG_TIMER_STATUS         */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_TIMER_STATUS,          ACPI_BITMASK_TIMER_STATUS},
  353.     /* ACPI_BITREG_BUS_MASTER_STATUS    */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_BUS_MASTER_STATUS,     ACPI_BITMASK_BUS_MASTER_STATUS},
  354.     /* ACPI_BITREG_GLOBAL_LOCK_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_STATUS},
  355.     /* ACPI_BITREG_POWER_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_STATUS},
  356.     /* ACPI_BITREG_SLEEP_BUTTON_STATUS  */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_STATUS},
  357.     /* ACPI_BITREG_RT_CLOCK_STATUS      */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_STATUS},
  358.     /* ACPI_BITREG_WAKE_STATUS          */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_WAKE_STATUS,           ACPI_BITMASK_WAKE_STATUS},
  359.     /* ACPI_BITREG_PCIEXP_WAKE_STATUS   */   {ACPI_REGISTER_PM1_STATUS,   ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,    ACPI_BITMASK_PCIEXP_WAKE_STATUS},
  360.  
  361.     /* ACPI_BITREG_TIMER_ENABLE         */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_TIMER_ENABLE,          ACPI_BITMASK_TIMER_ENABLE},
  362.     /* ACPI_BITREG_GLOBAL_LOCK_ENABLE   */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
  363.     /* ACPI_BITREG_POWER_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_POWER_BUTTON_ENABLE,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
  364.     /* ACPI_BITREG_SLEEP_BUTTON_ENABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
  365.     /* ACPI_BITREG_RT_CLOCK_ENABLE      */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_RT_CLOCK_ENABLE,       ACPI_BITMASK_RT_CLOCK_ENABLE},
  366.     /* ACPI_BITREG_PCIEXP_WAKE_DISABLE  */   {ACPI_REGISTER_PM1_ENABLE,   ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,   ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
  367.  
  368.     /* ACPI_BITREG_SCI_ENABLE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SCI_ENABLE,            ACPI_BITMASK_SCI_ENABLE},
  369.     /* ACPI_BITREG_BUS_MASTER_RLD       */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_BUS_MASTER_RLD,        ACPI_BITMASK_BUS_MASTER_RLD},
  370.     /* ACPI_BITREG_GLOBAL_LOCK_RELEASE  */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,   ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
  371.     /* ACPI_BITREG_SLEEP_TYPE           */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_TYPE,            ACPI_BITMASK_SLEEP_TYPE},
  372.     /* ACPI_BITREG_SLEEP_ENABLE         */   {ACPI_REGISTER_PM1_CONTROL,  ACPI_BITPOSITION_SLEEP_ENABLE,          ACPI_BITMASK_SLEEP_ENABLE},
  373.  
  374.     /* ACPI_BITREG_ARB_DIS              */   {ACPI_REGISTER_PM2_CONTROL,  ACPI_BITPOSITION_ARB_DISABLE,           ACPI_BITMASK_ARB_DISABLE}
  375. };
  376.  
  377.  
  378. ACPI_FIXED_EVENT_INFO       AcpiGbl_FixedEventInfo[ACPI_NUM_FIXED_EVENTS] =
  379. {
  380.     /* ACPI_EVENT_PMTIMER       */  {ACPI_BITREG_TIMER_STATUS,          ACPI_BITREG_TIMER_ENABLE,        ACPI_BITMASK_TIMER_STATUS,          ACPI_BITMASK_TIMER_ENABLE},
  381.     /* ACPI_EVENT_GLOBAL        */  {ACPI_BITREG_GLOBAL_LOCK_STATUS,    ACPI_BITREG_GLOBAL_LOCK_ENABLE,  ACPI_BITMASK_GLOBAL_LOCK_STATUS,    ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
  382.     /* ACPI_EVENT_POWER_BUTTON  */  {ACPI_BITREG_POWER_BUTTON_STATUS,   ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS,   ACPI_BITMASK_POWER_BUTTON_ENABLE},
  383.     /* ACPI_EVENT_SLEEP_BUTTON  */  {ACPI_BITREG_SLEEP_BUTTON_STATUS,   ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS,   ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
  384.     /* ACPI_EVENT_RTC           */  {ACPI_BITREG_RT_CLOCK_STATUS,       ACPI_BITREG_RT_CLOCK_ENABLE,     ACPI_BITMASK_RT_CLOCK_STATUS,       ACPI_BITMASK_RT_CLOCK_ENABLE},
  385. };
  386.  
  387. /*******************************************************************************
  388.  *
  389.  * FUNCTION:    AcpiUtGetRegionName
  390.  *
  391.  * PARAMETERS:  None.
  392.  *
  393.  * RETURN:      Status
  394.  *
  395.  * DESCRIPTION: Translate a Space ID into a name string (Debug only)
  396.  *
  397.  ******************************************************************************/
  398.  
  399. /* Region type decoding */
  400.  
  401. const char        *AcpiGbl_RegionTypes[ACPI_NUM_PREDEFINED_REGIONS] =
  402. {
  403.     "SystemMemory",
  404.     "SystemIO",
  405.     "PCI_Config",
  406.     "EmbeddedControl",
  407.     "SMBus",
  408.     "SystemCMOS",
  409.     "PCIBARTarget",
  410.     "IPMI",
  411.     "DataTable"
  412. };
  413.  
  414.  
  415. char *
  416. AcpiUtGetRegionName (
  417.     UINT8                   SpaceId)
  418. {
  419.  
  420.     if (SpaceId >= ACPI_USER_REGION_BEGIN)
  421.     {
  422.         return ("UserDefinedRegion");
  423.     }
  424.     else if (SpaceId >= ACPI_NUM_PREDEFINED_REGIONS)
  425.     {
  426.         return ("InvalidSpaceId");
  427.     }
  428.  
  429.     return (ACPI_CAST_PTR (char, AcpiGbl_RegionTypes[SpaceId]));
  430. }
  431.  
  432.  
  433. /*******************************************************************************
  434.  *
  435.  * FUNCTION:    AcpiUtGetEventName
  436.  *
  437.  * PARAMETERS:  None.
  438.  *
  439.  * RETURN:      Status
  440.  *
  441.  * DESCRIPTION: Translate a Event ID into a name string (Debug only)
  442.  *
  443.  ******************************************************************************/
  444.  
  445. /* Event type decoding */
  446.  
  447. static const char        *AcpiGbl_EventTypes[ACPI_NUM_FIXED_EVENTS] =
  448. {
  449.     "PM_Timer",
  450.     "GlobalLock",
  451.     "PowerButton",
  452.     "SleepButton",
  453.     "RealTimeClock",
  454. };
  455.  
  456.  
  457. char *
  458. AcpiUtGetEventName (
  459.     UINT32                  EventId)
  460. {
  461.  
  462.     if (EventId > ACPI_EVENT_MAX)
  463.     {
  464.         return ("InvalidEventID");
  465.     }
  466.  
  467.     return (ACPI_CAST_PTR (char, AcpiGbl_EventTypes[EventId]));
  468. }
  469.  
  470.  
  471. /*******************************************************************************
  472.  *
  473.  * FUNCTION:    AcpiUtGetTypeName
  474.  *
  475.  * PARAMETERS:  None.
  476.  *
  477.  * RETURN:      Status
  478.  *
  479.  * DESCRIPTION: Translate a Type ID into a name string (Debug only)
  480.  *
  481.  ******************************************************************************/
  482.  
  483. /*
  484.  * Elements of AcpiGbl_NsTypeNames below must match
  485.  * one-to-one with values of ACPI_OBJECT_TYPE
  486.  *
  487.  * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching;
  488.  * when stored in a table it really means that we have thus far seen no
  489.  * evidence to indicate what type is actually going to be stored for this entry.
  490.  */
  491. static const char           AcpiGbl_BadType[] = "UNDEFINED";
  492.  
  493. /* Printable names of the ACPI object types */
  494.  
  495. static const char           *AcpiGbl_NsTypeNames[] =
  496. {
  497.     /* 00 */ "Untyped",
  498.     /* 01 */ "Integer",
  499.     /* 02 */ "String",
  500.     /* 03 */ "Buffer",
  501.     /* 04 */ "Package",
  502.     /* 05 */ "FieldUnit",
  503.     /* 06 */ "Device",
  504.     /* 07 */ "Event",
  505.     /* 08 */ "Method",
  506.     /* 09 */ "Mutex",
  507.     /* 10 */ "Region",
  508.     /* 11 */ "Power",
  509.     /* 12 */ "Processor",
  510.     /* 13 */ "Thermal",
  511.     /* 14 */ "BufferField",
  512.     /* 15 */ "DdbHandle",
  513.     /* 16 */ "DebugObject",
  514.     /* 17 */ "RegionField",
  515.     /* 18 */ "BankField",
  516.     /* 19 */ "IndexField",
  517.     /* 20 */ "Reference",
  518.     /* 21 */ "Alias",
  519.     /* 22 */ "MethodAlias",
  520.     /* 23 */ "Notify",
  521.     /* 24 */ "AddrHandler",
  522.     /* 25 */ "ResourceDesc",
  523.     /* 26 */ "ResourceFld",
  524.     /* 27 */ "Scope",
  525.     /* 28 */ "Extra",
  526.     /* 29 */ "Data",
  527.     /* 30 */ "Invalid"
  528. };
  529.  
  530.  
  531. char *
  532. AcpiUtGetTypeName (
  533.     ACPI_OBJECT_TYPE        Type)
  534. {
  535.  
  536.     if (Type > ACPI_TYPE_INVALID)
  537.     {
  538.         return (ACPI_CAST_PTR (char, AcpiGbl_BadType));
  539.     }
  540.  
  541.     return (ACPI_CAST_PTR (char, AcpiGbl_NsTypeNames[Type]));
  542. }
  543.  
  544.  
  545. char *
  546. AcpiUtGetObjectTypeName (
  547.     ACPI_OPERAND_OBJECT     *ObjDesc)
  548. {
  549.  
  550.     if (!ObjDesc)
  551.     {
  552.         return ("[NULL Object Descriptor]");
  553.     }
  554.  
  555.     return (AcpiUtGetTypeName (ObjDesc->Common.Type));
  556. }
  557.  
  558.  
  559. /*******************************************************************************
  560.  *
  561.  * FUNCTION:    AcpiUtGetNodeName
  562.  *
  563.  * PARAMETERS:  Object               - A namespace node
  564.  *
  565.  * RETURN:      Pointer to a string
  566.  *
  567.  * DESCRIPTION: Validate the node and return the node's ACPI name.
  568.  *
  569.  ******************************************************************************/
  570.  
  571. char *
  572. AcpiUtGetNodeName (
  573.     void                    *Object)
  574. {
  575.     ACPI_NAMESPACE_NODE     *Node = (ACPI_NAMESPACE_NODE *) Object;
  576.  
  577.  
  578.     /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
  579.  
  580.     if (!Object)
  581.     {
  582.         return ("NULL");
  583.     }
  584.  
  585.     /* Check for Root node */
  586.  
  587.     if ((Object == ACPI_ROOT_OBJECT) ||
  588.         (Object == AcpiGbl_RootNode))
  589.     {
  590.         return ("\"\\\" ");
  591.     }
  592.  
  593.     /* Descriptor must be a namespace node */
  594.  
  595.     if (ACPI_GET_DESCRIPTOR_TYPE (Node) != ACPI_DESC_TYPE_NAMED)
  596.     {
  597.         return ("####");
  598.     }
  599.  
  600.     /*
  601.      * Ensure name is valid. The name was validated/repaired when the node
  602.      * was created, but make sure it has not been corrupted.
  603.      */
  604.     AcpiUtRepairName (Node->Name.Ascii);
  605.  
  606.     /* Return the name */
  607.  
  608.     return (Node->Name.Ascii);
  609. }
  610.  
  611.  
  612. /*******************************************************************************
  613.  *
  614.  * FUNCTION:    AcpiUtGetDescriptorName
  615.  *
  616.  * PARAMETERS:  Object               - An ACPI object
  617.  *
  618.  * RETURN:      Pointer to a string
  619.  *
  620.  * DESCRIPTION: Validate object and return the descriptor type
  621.  *
  622.  ******************************************************************************/
  623.  
  624. /* Printable names of object descriptor types */
  625.  
  626. static const char           *AcpiGbl_DescTypeNames[] =
  627. {
  628.     /* 00 */ "Not a Descriptor",
  629.     /* 01 */ "Cached",
  630.     /* 02 */ "State-Generic",
  631.     /* 03 */ "State-Update",
  632.     /* 04 */ "State-Package",
  633.     /* 05 */ "State-Control",
  634.     /* 06 */ "State-RootParseScope",
  635.     /* 07 */ "State-ParseScope",
  636.     /* 08 */ "State-WalkScope",
  637.     /* 09 */ "State-Result",
  638.     /* 10 */ "State-Notify",
  639.     /* 11 */ "State-Thread",
  640.     /* 12 */ "Walk",
  641.     /* 13 */ "Parser",
  642.     /* 14 */ "Operand",
  643.     /* 15 */ "Node"
  644. };
  645.  
  646.  
  647. char *
  648. AcpiUtGetDescriptorName (
  649.     void                    *Object)
  650. {
  651.  
  652.     if (!Object)
  653.     {
  654.         return ("NULL OBJECT");
  655.     }
  656.  
  657.     if (ACPI_GET_DESCRIPTOR_TYPE (Object) > ACPI_DESC_TYPE_MAX)
  658.     {
  659.         return ("Not a Descriptor");
  660.     }
  661.  
  662.     return (ACPI_CAST_PTR (char,
  663.         AcpiGbl_DescTypeNames[ACPI_GET_DESCRIPTOR_TYPE (Object)]));
  664.  
  665. }
  666.  
  667.  
  668. /*******************************************************************************
  669.  *
  670.  * FUNCTION:    AcpiUtGetReferenceName
  671.  *
  672.  * PARAMETERS:  Object               - An ACPI reference object
  673.  *
  674.  * RETURN:      Pointer to a string
  675.  *
  676.  * DESCRIPTION: Decode a reference object sub-type to a string.
  677.  *
  678.  ******************************************************************************/
  679.  
  680. /* Printable names of reference object sub-types */
  681.  
  682. static const char           *AcpiGbl_RefClassNames[] =
  683. {
  684.     /* 00 */ "Local",
  685.     /* 01 */ "Argument",
  686.     /* 02 */ "RefOf",
  687.     /* 03 */ "Index",
  688.     /* 04 */ "DdbHandle",
  689.     /* 05 */ "Named Object",
  690.     /* 06 */ "Debug"
  691. };
  692.  
  693. const char *
  694. AcpiUtGetReferenceName (
  695.     ACPI_OPERAND_OBJECT     *Object)
  696. {
  697.  
  698.     if (!Object)
  699.     {
  700.         return ("NULL Object");
  701.     }
  702.  
  703.     if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
  704.     {
  705.         return ("Not an Operand object");
  706.     }
  707.  
  708.     if (Object->Common.Type != ACPI_TYPE_LOCAL_REFERENCE)
  709.     {
  710.         return ("Not a Reference object");
  711.     }
  712.  
  713.     if (Object->Reference.Class > ACPI_REFCLASS_MAX)
  714.     {
  715.         return ("Unknown Reference class");
  716.     }
  717.  
  718.     return (AcpiGbl_RefClassNames[Object->Reference.Class]);
  719. }
  720.  
  721.  
  722. #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
  723. /*
  724.  * Strings and procedures used for debug only
  725.  */
  726.  
  727. /*******************************************************************************
  728.  *
  729.  * FUNCTION:    AcpiUtGetMutexName
  730.  *
  731.  * PARAMETERS:  MutexId         - The predefined ID for this mutex.
  732.  *
  733.  * RETURN:      String containing the name of the mutex. Always returns a valid
  734.  *              pointer.
  735.  *
  736.  * DESCRIPTION: Translate a mutex ID into a name string (Debug only)
  737.  *
  738.  ******************************************************************************/
  739.  
  740. char *
  741. AcpiUtGetMutexName (
  742.     UINT32                  MutexId)
  743. {
  744.  
  745.     if (MutexId > ACPI_MAX_MUTEX)
  746.     {
  747.         return ("Invalid Mutex ID");
  748.     }
  749.  
  750.     return (AcpiGbl_MutexNames[MutexId]);
  751. }
  752.  
  753.  
  754. /*******************************************************************************
  755.  *
  756.  * FUNCTION:    AcpiUtGetNotifyName
  757.  *
  758.  * PARAMETERS:  NotifyValue     - Value from the Notify() request
  759.  *
  760.  * RETURN:      String corresponding to the Notify Value.
  761.  *
  762.  * DESCRIPTION: Translate a Notify Value to a notify namestring.
  763.  *
  764.  ******************************************************************************/
  765.  
  766. /* Names for Notify() values, used for debug output */
  767.  
  768. static const char        *AcpiGbl_NotifyValueNames[] =
  769. {
  770.     "Bus Check",
  771.     "Device Check",
  772.     "Device Wake",
  773.     "Eject Request",
  774.     "Device Check Light",
  775.     "Frequency Mismatch",
  776.     "Bus Mode Mismatch",
  777.     "Power Fault",
  778.     "Capabilities Check",
  779.     "Device PLD Check",
  780.     "Reserved",
  781.     "System Locality Update"
  782. };
  783.  
  784. const char *
  785. AcpiUtGetNotifyName (
  786.     UINT32                  NotifyValue)
  787. {
  788.  
  789.     if (NotifyValue <= ACPI_NOTIFY_MAX)
  790.     {
  791.         return (AcpiGbl_NotifyValueNames[NotifyValue]);
  792.     }
  793.     else if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
  794.     {
  795.         return ("Reserved");
  796.     }
  797.     else /* Greater or equal to 0x80 */
  798.     {
  799.         return ("**Device Specific**");
  800.     }
  801. }
  802. #endif
  803.  
  804.  
  805. /*******************************************************************************
  806.  *
  807.  * FUNCTION:    AcpiUtValidObjectType
  808.  *
  809.  * PARAMETERS:  Type            - Object type to be validated
  810.  *
  811.  * RETURN:      TRUE if valid object type, FALSE otherwise
  812.  *
  813.  * DESCRIPTION: Validate an object type
  814.  *
  815.  ******************************************************************************/
  816.  
  817. BOOLEAN
  818. AcpiUtValidObjectType (
  819.     ACPI_OBJECT_TYPE        Type)
  820. {
  821.  
  822.     if (Type > ACPI_TYPE_LOCAL_MAX)
  823.     {
  824.         /* Note: Assumes all TYPEs are contiguous (external/local) */
  825.  
  826.         return (FALSE);
  827.     }
  828.  
  829.     return (TRUE);
  830. }
  831.  
  832.  
  833. /*******************************************************************************
  834.  *
  835.  * FUNCTION:    AcpiUtInitGlobals
  836.  *
  837.  * PARAMETERS:  None
  838.  *
  839.  * RETURN:      Status
  840.  *
  841.  * DESCRIPTION: Init library globals.  All globals that require specific
  842.  *              initialization should be initialized here!
  843.  *
  844.  ******************************************************************************/
  845.  
  846. ACPI_STATUS
  847. AcpiUtInitGlobals (
  848.     void)
  849. {
  850.     ACPI_STATUS             Status;
  851.     UINT32                  i;
  852.  
  853.  
  854.     ACPI_FUNCTION_TRACE (UtInitGlobals);
  855.  
  856.  
  857.     /* Create all memory caches */
  858.  
  859.     Status = AcpiUtCreateCaches ();
  860.     if (ACPI_FAILURE (Status))
  861.     {
  862.         return_ACPI_STATUS (Status);
  863.     }
  864.  
  865.     /* Mutex locked flags */
  866.  
  867.     for (i = 0; i < ACPI_NUM_MUTEX; i++)
  868.     {
  869.         AcpiGbl_MutexInfo[i].Mutex          = NULL;
  870.         AcpiGbl_MutexInfo[i].ThreadId       = ACPI_MUTEX_NOT_ACQUIRED;
  871.         AcpiGbl_MutexInfo[i].UseCount       = 0;
  872.     }
  873.  
  874.     for (i = 0; i < ACPI_NUM_OWNERID_MASKS; i++)
  875.     {
  876.         AcpiGbl_OwnerIdMask[i]              = 0;
  877.     }
  878.  
  879.     /* Last OwnerID is never valid */
  880.  
  881.     AcpiGbl_OwnerIdMask[ACPI_NUM_OWNERID_MASKS - 1] = 0x80000000;
  882.  
  883.     /* Event counters */
  884.  
  885.     AcpiMethodCount                     = 0;
  886.     AcpiSciCount                        = 0;
  887.     AcpiGpeCount                        = 0;
  888.  
  889.     for (i = 0; i < ACPI_NUM_FIXED_EVENTS; i++)
  890.     {
  891.         AcpiFixedEventCount[i]              = 0;
  892.     }
  893.  
  894.     /* GPE support */
  895.  
  896.     AcpiGbl_GpeXruptListHead            = NULL;
  897.     AcpiGbl_GpeFadtBlocks[0]            = NULL;
  898.     AcpiGbl_GpeFadtBlocks[1]            = NULL;
  899.     AcpiCurrentGpeCount                 = 0;
  900.  
  901.     /* Global handlers */
  902.  
  903.     AcpiGbl_SystemNotify.Handler        = NULL;
  904.     AcpiGbl_DeviceNotify.Handler        = NULL;
  905.     AcpiGbl_ExceptionHandler            = NULL;
  906.     AcpiGbl_InitHandler                 = NULL;
  907.     AcpiGbl_TableHandler                = NULL;
  908.  
  909.     /* Global Lock support */
  910.  
  911.     AcpiGbl_GlobalLockSemaphore         = NULL;
  912.     AcpiGbl_GlobalLockMutex             = NULL;
  913.     AcpiGbl_GlobalLockAcquired          = FALSE;
  914.     AcpiGbl_GlobalLockHandle            = 0;
  915.     AcpiGbl_GlobalLockPresent           = FALSE;
  916.  
  917.     /* Miscellaneous variables */
  918.  
  919.     AcpiGbl_DSDT                        = NULL;
  920.     AcpiGbl_CmSingleStep                = FALSE;
  921.     AcpiGbl_DbTerminateThreads          = FALSE;
  922.     AcpiGbl_Shutdown                    = FALSE;
  923.     AcpiGbl_NsLookupCount               = 0;
  924.     AcpiGbl_PsFindCount                 = 0;
  925.     AcpiGbl_AcpiHardwarePresent         = TRUE;
  926.     AcpiGbl_LastOwnerIdIndex            = 0;
  927.     AcpiGbl_NextOwnerIdOffset           = 0;
  928.     AcpiGbl_TraceMethodName             = 0;
  929.     AcpiGbl_TraceDbgLevel               = 0;
  930.     AcpiGbl_TraceDbgLayer               = 0;
  931.     AcpiGbl_DebuggerConfiguration       = DEBUGGER_THREADING;
  932.     AcpiGbl_DbOutputFlags               = ACPI_DB_CONSOLE_OUTPUT;
  933.     AcpiGbl_OsiData                     = 0;
  934.  
  935.     /* Hardware oriented */
  936.  
  937.     AcpiGbl_EventsInitialized           = FALSE;
  938.     AcpiGbl_SystemAwakeAndRunning       = TRUE;
  939.  
  940.     /* Namespace */
  941.  
  942.     AcpiGbl_ModuleCodeList              = NULL;
  943.     AcpiGbl_RootNode                    = NULL;
  944.     AcpiGbl_RootNodeStruct.Name.Integer = ACPI_ROOT_NAME;
  945.     AcpiGbl_RootNodeStruct.DescriptorType = ACPI_DESC_TYPE_NAMED;
  946.     AcpiGbl_RootNodeStruct.Type         = ACPI_TYPE_DEVICE;
  947.     AcpiGbl_RootNodeStruct.Parent       = NULL;
  948.     AcpiGbl_RootNodeStruct.Child        = NULL;
  949.     AcpiGbl_RootNodeStruct.Peer         = NULL;
  950.     AcpiGbl_RootNodeStruct.Object       = NULL;
  951.  
  952.  
  953. #ifdef ACPI_DISASSEMBLER
  954.     AcpiGbl_ExternalList                = NULL;
  955. #endif
  956.  
  957. #ifdef ACPI_DEBUG_OUTPUT
  958.     AcpiGbl_LowestStackPointer          = ACPI_CAST_PTR (ACPI_SIZE, ACPI_SIZE_MAX);
  959. #endif
  960.  
  961. #ifdef ACPI_DBG_TRACK_ALLOCATIONS
  962.     AcpiGbl_DisplayFinalMemStats        = FALSE;
  963.     AcpiGbl_DisableMemTracking          = FALSE;
  964. #endif
  965.  
  966.     return_ACPI_STATUS (AE_OK);
  967. }
  968.  
  969. /* Public globals */
  970.  
  971. ACPI_EXPORT_SYMBOL (AcpiGbl_FADT)
  972. ACPI_EXPORT_SYMBOL (AcpiDbgLevel)
  973. ACPI_EXPORT_SYMBOL (AcpiDbgLayer)
  974. ACPI_EXPORT_SYMBOL (AcpiGpeCount)
  975. ACPI_EXPORT_SYMBOL (AcpiCurrentGpeCount)
  976.  
  977.  
  978.