arch/all-pc/acpica/source/components/utilities/utstate.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utstate - state object support procedures
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #define __UTSTATE_C__
  46
  47 #include "acpi.h"
  48 #include "accommon.h"
  49
  50 #define _COMPONENT          ACPI_UTILITIES
  51         ACPI_MODULE_NAME    ("utstate")
  52
  53
  54 /*******************************************************************************
  55  *
  56  * FUNCTION:    AcpiUtCreatePkgStateAndPush
  57  *
  58  * PARAMETERS:  Object          - Object to be added to the new state
  59  *              Action          - Increment/Decrement
  60  *              StateList       - List the state will be added to
  61  *
  62  * RETURN:      Status
  63  *
  64  * DESCRIPTION: Create a new state and push it
  65  *
  66  ******************************************************************************/
  67
  68 ACPI_STATUS
  69 AcpiUtCreatePkgStateAndPush (
  70     void                    *InternalObject,
  71     void                    *ExternalObject,
  72     UINT16                  Index,
  73     ACPI_GENERIC_STATE      **StateList)
  74 {
  75     ACPI_GENERIC_STATE       *State;
  76
  77
  78     ACPI_FUNCTION_ENTRY ();
  79
  80
  81     State = AcpiUtCreatePkgState (InternalObject, ExternalObject, Index);
  82     if (!State)
  83     {
  84         return (AE_NO_MEMORY);
  85     }
  86
  87     AcpiUtPushGenericState (StateList, State);
  88     return (AE_OK);
  89 }
  90
  91
  92 /*******************************************************************************
  93  *
  94  * FUNCTION:    AcpiUtPushGenericState
  95  *
  96  * PARAMETERS:  ListHead            - Head of the state stack
  97  *              State               - State object to push
  98  *
  99  * RETURN:      None
 100  *
 101  * DESCRIPTION: Push a state object onto a state stack
 102  *
 103  ******************************************************************************/
 104
 105 void
 106 AcpiUtPushGenericState (
 107     ACPI_GENERIC_STATE      **ListHead,
 108     ACPI_GENERIC_STATE      *State)
 109 {
 110     ACPI_FUNCTION_ENTRY ();
 111
 112
 113     /* Push the state object onto the front of the list (stack) */
 114
 115     State->Common.Next = *ListHead;
 116     *ListHead = State;
 117     return;
 118 }
 119
 120
 121 /*******************************************************************************
 122  *
 123  * FUNCTION:    AcpiUtPopGenericState
 124  *
 125  * PARAMETERS:  ListHead            - Head of the state stack
 126  *
 127  * RETURN:      The popped state object
 128  *
 129  * DESCRIPTION: Pop a state object from a state stack
 130  *
 131  ******************************************************************************/
 132
 133 ACPI_GENERIC_STATE *
 134 AcpiUtPopGenericState (
 135     ACPI_GENERIC_STATE      **ListHead)
 136 {
 137     ACPI_GENERIC_STATE      *State;
 138
 139
 140     ACPI_FUNCTION_ENTRY ();
 141
 142
 143     /* Remove the state object at the head of the list (stack) */
 144
 145     State = *ListHead;
 146     if (State)
 147     {
 148         /* Update the list head */
 149
 150         *ListHead = State->Common.Next;
 151     }
 152
 153     return (State);
 154 }
 155
 156
 157 /*******************************************************************************
 158  *
 159  * FUNCTION:    AcpiUtCreateGenericState
 160  *
 161  * PARAMETERS:  None
 162  *
 163  * RETURN:      The new state object. NULL on failure.
 164  *
 165  * DESCRIPTION: Create a generic state object. Attempt to obtain one from
 166  *              the global state cache;  If none available, create a new one.
 167  *
 168  ******************************************************************************/
 169
 170 ACPI_GENERIC_STATE *
 171 AcpiUtCreateGenericState (
 172     void)
 173 {
 174     ACPI_GENERIC_STATE      *State;
 175
 176
 177     ACPI_FUNCTION_ENTRY ();
 178
 179
 180     State = AcpiOsAcquireObject (AcpiGbl_StateCache);
 181     if (State)
 182     {
 183         /* Initialize */
 184         State->Common.DescriptorType = ACPI_DESC_TYPE_STATE;
 185     }
 186
 187     return (State);
 188 }
 189
 190
 191 /*******************************************************************************
 192  *
 193  * FUNCTION:    AcpiUtCreateThreadState
 194  *
 195  * PARAMETERS:  None
 196  *
 197  * RETURN:      New Thread State. NULL on failure
 198  *
 199  * DESCRIPTION: Create a "Thread State" - a flavor of the generic state used
 200  *              to track per-thread info during method execution
 201  *
 202  ******************************************************************************/
 203
 204 ACPI_THREAD_STATE *
 205 AcpiUtCreateThreadState (
 206     void)
 207 {
 208     ACPI_GENERIC_STATE      *State;
 209
 210
 211     ACPI_FUNCTION_ENTRY ();
 212
 213
 214     /* Create the generic state object */
 215
 216     State = AcpiUtCreateGenericState ();
 217     if (!State)
 218     {
 219         return (NULL);
 220     }
 221
 222     /* Init fields specific to the update struct */
 223
 224     State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_THREAD;
 225     State->Thread.ThreadId = AcpiOsGetThreadId ();
 226
 227     /* Check for invalid thread ID - zero is very bad, it will break things */
 228
 229     if (!State->Thread.ThreadId)
 230     {
 231         ACPI_ERROR ((AE_INFO, "Invalid zero ID from AcpiOsGetThreadId"));
 232         State->Thread.ThreadId = (ACPI_THREAD_ID) 1;
 233     }
 234
 235     return ((ACPI_THREAD_STATE *) State);
 236 }
 237
 238
 239 /*******************************************************************************
 240  *
 241  * FUNCTION:    AcpiUtCreateUpdateState
 242  *
 243  * PARAMETERS:  Object          - Initial Object to be installed in the state
 244  *              Action          - Update action to be performed
 245  *
 246  * RETURN:      New state object, null on failure
 247  *
 248  * DESCRIPTION: Create an "Update State" - a flavor of the generic state used
 249  *              to update reference counts and delete complex objects such
 250  *              as packages.
 251  *
 252  ******************************************************************************/
 253
 254 ACPI_GENERIC_STATE *
 255 AcpiUtCreateUpdateState (
 256     ACPI_OPERAND_OBJECT     *Object,
 257     UINT16                  Action)
 258 {
 259     ACPI_GENERIC_STATE      *State;
 260
 261
 262     ACPI_FUNCTION_ENTRY ();
 263
 264
 265     /* Create the generic state object */
 266
 267     State = AcpiUtCreateGenericState ();
 268     if (!State)
 269     {
 270         return (NULL);
 271     }
 272
 273     /* Init fields specific to the update struct */
 274
 275     State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_UPDATE;
 276     State->Update.Object = Object;
 277     State->Update.Value = Action;
 278     return (State);
 279 }
 280
 281
 282 /*******************************************************************************
 283  *
 284  * FUNCTION:    AcpiUtCreatePkgState
 285  *
 286  * PARAMETERS:  Object          - Initial Object to be installed in the state
 287  *              Action          - Update action to be performed
 288  *
 289  * RETURN:      New state object, null on failure
 290  *
 291  * DESCRIPTION: Create a "Package State"
 292  *
 293  ******************************************************************************/
 294
 295 ACPI_GENERIC_STATE *
 296 AcpiUtCreatePkgState (
 297     void                    *InternalObject,
 298     void                    *ExternalObject,
 299     UINT16                  Index)
 300 {
 301     ACPI_GENERIC_STATE      *State;
 302
 303
 304     ACPI_FUNCTION_ENTRY ();
 305
 306
 307     /* Create the generic state object */
 308
 309     State = AcpiUtCreateGenericState ();
 310     if (!State)
 311     {
 312         return (NULL);
 313     }
 314
 315     /* Init fields specific to the update struct */
 316
 317     State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PACKAGE;
 318     State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject;
 319     State->Pkg.DestObject = ExternalObject;
 320     State->Pkg.Index= Index;
 321     State->Pkg.NumPackages = 1;
 322     return (State);
 323 }
 324
 325
 326 /*******************************************************************************
 327  *
 328  * FUNCTION:    AcpiUtCreateControlState
 329  *
 330  * PARAMETERS:  None
 331  *
 332  * RETURN:      New state object, null on failure
 333  *
 334  * DESCRIPTION: Create a "Control State" - a flavor of the generic state used
 335  *              to support nested IF/WHILE constructs in the AML.
 336  *
 337  ******************************************************************************/
 338
 339 ACPI_GENERIC_STATE *
 340 AcpiUtCreateControlState (
 341     void)
 342 {
 343     ACPI_GENERIC_STATE      *State;
 344
 345
 346     ACPI_FUNCTION_ENTRY ();
 347
 348
 349     /* Create the generic state object */
 350
 351     State = AcpiUtCreateGenericState ();
 352     if (!State)
 353     {
 354         return (NULL);
 355     }
 356
 357     /* Init fields specific to the control struct */
 358
 359     State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_CONTROL;
 360     State->Common.State = ACPI_CONTROL_CONDITIONAL_EXECUTING;
 361     return (State);
 362 }
 363
 364
 365 /*******************************************************************************
 366  *
 367  * FUNCTION:    AcpiUtDeleteGenericState
 368  *
 369  * PARAMETERS:  State               - The state object to be deleted
 370  *
 371  * RETURN:      None
 372  *
 373  * DESCRIPTION: Release a state object to the state cache. NULL state objects
 374  *              are ignored.
 375  *
 376  ******************************************************************************/
 377
 378 void
 379 AcpiUtDeleteGenericState (
 380     ACPI_GENERIC_STATE      *State)
 381 {
 382     ACPI_FUNCTION_ENTRY ();
 383
 384
 385     /* Ignore null state */
 386
 387     if (State)
 388     {
 389         (void) AcpiOsReleaseObject (AcpiGbl_StateCache, State);
 390     }
 391     return;
 392 }