1 /******************************************************************************* 2 * 3 * Module Name: utstate - state object support procedures 4 * 5 ******************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, 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 #include <contrib/dev/acpica/include/acpi.h> 45 #include <contrib/dev/acpica/include/accommon.h> 46 47 #define _COMPONENT ACPI_UTILITIES 48 ACPI_MODULE_NAME ("utstate") 49 50 51 /******************************************************************************* 52 * 53 * FUNCTION: AcpiUtPushGenericState 54 * 55 * PARAMETERS: ListHead - Head of the state stack 56 * State - State object to push 57 * 58 * RETURN: None 59 * 60 * DESCRIPTION: Push a state object onto a state stack 61 * 62 ******************************************************************************/ 63 64 void 65 AcpiUtPushGenericState ( 66 ACPI_GENERIC_STATE **ListHead, 67 ACPI_GENERIC_STATE *State) 68 { 69 ACPI_FUNCTION_ENTRY (); 70 71 72 /* Push the state object onto the front of the list (stack) */ 73 74 State->Common.Next = *ListHead; 75 *ListHead = State; 76 return; 77 } 78 79 80 /******************************************************************************* 81 * 82 * FUNCTION: AcpiUtPopGenericState 83 * 84 * PARAMETERS: ListHead - Head of the state stack 85 * 86 * RETURN: The popped state object 87 * 88 * DESCRIPTION: Pop a state object from a state stack 89 * 90 ******************************************************************************/ 91 92 ACPI_GENERIC_STATE * 93 AcpiUtPopGenericState ( 94 ACPI_GENERIC_STATE **ListHead) 95 { 96 ACPI_GENERIC_STATE *State; 97 98 99 ACPI_FUNCTION_ENTRY (); 100 101 102 /* Remove the state object at the head of the list (stack) */ 103 104 State = *ListHead; 105 if (State) 106 { 107 /* Update the list head */ 108 109 *ListHead = State->Common.Next; 110 } 111 112 return (State); 113 } 114 115 116 /******************************************************************************* 117 * 118 * FUNCTION: AcpiUtCreateGenericState 119 * 120 * PARAMETERS: None 121 * 122 * RETURN: The new state object. NULL on failure. 123 * 124 * DESCRIPTION: Create a generic state object. Attempt to obtain one from 125 * the global state cache; If none available, create a new one. 126 * 127 ******************************************************************************/ 128 129 ACPI_GENERIC_STATE * 130 AcpiUtCreateGenericState ( 131 void) 132 { 133 ACPI_GENERIC_STATE *State; 134 135 136 ACPI_FUNCTION_ENTRY (); 137 138 139 State = AcpiOsAcquireObject (AcpiGbl_StateCache); 140 if (State) 141 { 142 /* Initialize */ 143 State->Common.DescriptorType = ACPI_DESC_TYPE_STATE; 144 } 145 146 return (State); 147 } 148 149 150 /******************************************************************************* 151 * 152 * FUNCTION: AcpiUtCreateThreadState 153 * 154 * PARAMETERS: None 155 * 156 * RETURN: New Thread State. NULL on failure 157 * 158 * DESCRIPTION: Create a "Thread State" - a flavor of the generic state used 159 * to track per-thread info during method execution 160 * 161 ******************************************************************************/ 162 163 ACPI_THREAD_STATE * 164 AcpiUtCreateThreadState ( 165 void) 166 { 167 ACPI_GENERIC_STATE *State; 168 169 170 ACPI_FUNCTION_ENTRY (); 171 172 173 /* Create the generic state object */ 174 175 State = AcpiUtCreateGenericState (); 176 if (!State) 177 { 178 return (NULL); 179 } 180 181 /* Init fields specific to the update struct */ 182 183 State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_THREAD; 184 State->Thread.ThreadId = AcpiOsGetThreadId (); 185 186 /* Check for invalid thread ID - zero is very bad, it will break things */ 187 188 if (!State->Thread.ThreadId) 189 { 190 ACPI_ERROR ((AE_INFO, "Invalid zero ID from AcpiOsGetThreadId")); 191 State->Thread.ThreadId = (ACPI_THREAD_ID) 1; 192 } 193 194 return ((ACPI_THREAD_STATE *) State); 195 } 196 197 198 /******************************************************************************* 199 * 200 * FUNCTION: AcpiUtCreateUpdateState 201 * 202 * PARAMETERS: Object - Initial Object to be installed in the state 203 * Action - Update action to be performed 204 * 205 * RETURN: New state object, null on failure 206 * 207 * DESCRIPTION: Create an "Update State" - a flavor of the generic state used 208 * to update reference counts and delete complex objects such 209 * as packages. 210 * 211 ******************************************************************************/ 212 213 ACPI_GENERIC_STATE * 214 AcpiUtCreateUpdateState ( 215 ACPI_OPERAND_OBJECT *Object, 216 UINT16 Action) 217 { 218 ACPI_GENERIC_STATE *State; 219 220 221 ACPI_FUNCTION_ENTRY (); 222 223 224 /* Create the generic state object */ 225 226 State = AcpiUtCreateGenericState (); 227 if (!State) 228 { 229 return (NULL); 230 } 231 232 /* Init fields specific to the update struct */ 233 234 State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_UPDATE; 235 State->Update.Object = Object; 236 State->Update.Value = Action; 237 return (State); 238 } 239 240 241 /******************************************************************************* 242 * 243 * FUNCTION: AcpiUtCreatePkgState 244 * 245 * PARAMETERS: Object - Initial Object to be installed in the state 246 * Action - Update action to be performed 247 * 248 * RETURN: New state object, null on failure 249 * 250 * DESCRIPTION: Create a "Package State" 251 * 252 ******************************************************************************/ 253 254 ACPI_GENERIC_STATE * 255 AcpiUtCreatePkgState ( 256 void *InternalObject, 257 void *ExternalObject, 258 UINT16 Index) 259 { 260 ACPI_GENERIC_STATE *State; 261 262 263 ACPI_FUNCTION_ENTRY (); 264 265 266 /* Create the generic state object */ 267 268 State = AcpiUtCreateGenericState (); 269 if (!State) 270 { 271 return (NULL); 272 } 273 274 /* Init fields specific to the update struct */ 275 276 State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PACKAGE; 277 State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject; 278 State->Pkg.DestObject = ExternalObject; 279 State->Pkg.Index= Index; 280 State->Pkg.NumPackages = 1; 281 282 return (State); 283 } 284 285 286 /******************************************************************************* 287 * 288 * FUNCTION: AcpiUtCreateControlState 289 * 290 * PARAMETERS: None 291 * 292 * RETURN: New state object, null on failure 293 * 294 * DESCRIPTION: Create a "Control State" - a flavor of the generic state used 295 * to support nested IF/WHILE constructs in the AML. 296 * 297 ******************************************************************************/ 298 299 ACPI_GENERIC_STATE * 300 AcpiUtCreateControlState ( 301 void) 302 { 303 ACPI_GENERIC_STATE *State; 304 305 306 ACPI_FUNCTION_ENTRY (); 307 308 309 /* Create the generic state object */ 310 311 State = AcpiUtCreateGenericState (); 312 if (!State) 313 { 314 return (NULL); 315 } 316 317 /* Init fields specific to the control struct */ 318 319 State->Common.DescriptorType = ACPI_DESC_TYPE_STATE_CONTROL; 320 State->Common.State = ACPI_CONTROL_CONDITIONAL_EXECUTING; 321 322 return (State); 323 } 324 325 326 /******************************************************************************* 327 * 328 * FUNCTION: AcpiUtDeleteGenericState 329 * 330 * PARAMETERS: State - The state object to be deleted 331 * 332 * RETURN: None 333 * 334 * DESCRIPTION: Release a state object to the state cache. NULL state objects 335 * are ignored. 336 * 337 ******************************************************************************/ 338 339 void 340 AcpiUtDeleteGenericState ( 341 ACPI_GENERIC_STATE *State) 342 { 343 ACPI_FUNCTION_ENTRY (); 344 345 346 /* Ignore null state */ 347 348 if (State) 349 { 350 (void) AcpiOsReleaseObject (AcpiGbl_StateCache, State); 351 } 352 353 return; 354 } 355