1 /****************************************************************************** 2 * 3 * Module Name: pstree - Parser op tree manipulation/traversal/search 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 "acpi.h" 45 #include "accommon.h" 46 #include "acparser.h" 47 #include "amlcode.h" 48 49 #define _COMPONENT ACPI_PARSER 50 ACPI_MODULE_NAME ("pstree") 51 52 /* Local prototypes */ 53 54 #ifdef ACPI_OBSOLETE_FUNCTIONS 55 ACPI_PARSE_OBJECT * 56 AcpiPsGetChild ( 57 ACPI_PARSE_OBJECT *op); 58 #endif 59 60 61 /******************************************************************************* 62 * 63 * FUNCTION: AcpiPsGetArg 64 * 65 * PARAMETERS: Op - Get an argument for this op 66 * Argn - Nth argument to get 67 * 68 * RETURN: The argument (as an Op object). NULL if argument does not exist 69 * 70 * DESCRIPTION: Get the specified op's argument. 71 * 72 ******************************************************************************/ 73 74 ACPI_PARSE_OBJECT * 75 AcpiPsGetArg ( 76 ACPI_PARSE_OBJECT *Op, 77 UINT32 Argn) 78 { 79 ACPI_PARSE_OBJECT *Arg = NULL; 80 const ACPI_OPCODE_INFO *OpInfo; 81 82 83 ACPI_FUNCTION_ENTRY (); 84 85 /* 86 if (Op->Common.AmlOpcode == AML_INT_CONNECTION_OP) 87 { 88 return (Op->Common.Value.Arg); 89 } 90 */ 91 /* Get the info structure for this opcode */ 92 93 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode); 94 if (OpInfo->Class == AML_CLASS_UNKNOWN) 95 { 96 /* Invalid opcode or ASCII character */ 97 98 return (NULL); 99 } 100 101 /* Check if this opcode requires argument sub-objects */ 102 103 if (!(OpInfo->Flags & AML_HAS_ARGS)) 104 { 105 /* Has no linked argument objects */ 106 107 return (NULL); 108 } 109 110 /* Get the requested argument object */ 111 112 Arg = Op->Common.Value.Arg; 113 while (Arg && Argn) 114 { 115 Argn--; 116 Arg = Arg->Common.Next; 117 } 118 119 return (Arg); 120 } 121 122 123 /******************************************************************************* 124 * 125 * FUNCTION: AcpiPsAppendArg 126 * 127 * PARAMETERS: Op - Append an argument to this Op. 128 * Arg - Argument Op to append 129 * 130 * RETURN: None. 131 * 132 * DESCRIPTION: Append an argument to an op's argument list (a NULL arg is OK) 133 * 134 ******************************************************************************/ 135 136 void 137 AcpiPsAppendArg ( 138 ACPI_PARSE_OBJECT *Op, 139 ACPI_PARSE_OBJECT *Arg) 140 { 141 ACPI_PARSE_OBJECT *PrevArg; 142 const ACPI_OPCODE_INFO *OpInfo; 143 144 145 ACPI_FUNCTION_TRACE (PsAppendArg); 146 147 148 if (!Op) 149 { 150 return_VOID; 151 } 152 153 /* Get the info structure for this opcode */ 154 155 OpInfo = AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode); 156 if (OpInfo->Class == AML_CLASS_UNKNOWN) 157 { 158 /* Invalid opcode */ 159 160 ACPI_ERROR ((AE_INFO, "Invalid AML Opcode: 0x%2.2X", 161 Op->Common.AmlOpcode)); 162 return_VOID; 163 } 164 165 /* Check if this opcode requires argument sub-objects */ 166 167 if (!(OpInfo->Flags & AML_HAS_ARGS)) 168 { 169 /* Has no linked argument objects */ 170 171 return_VOID; 172 } 173 174 /* Append the argument to the linked argument list */ 175 176 if (Op->Common.Value.Arg) 177 { 178 /* Append to existing argument list */ 179 180 PrevArg = Op->Common.Value.Arg; 181 while (PrevArg->Common.Next) 182 { 183 PrevArg = PrevArg->Common.Next; 184 } 185 PrevArg->Common.Next = Arg; 186 } 187 else 188 { 189 /* No argument list, this will be the first argument */ 190 191 Op->Common.Value.Arg = Arg; 192 } 193 194 /* Set the parent in this arg and any args linked after it */ 195 196 while (Arg) 197 { 198 Arg->Common.Parent = Op; 199 Arg = Arg->Common.Next; 200 201 Op->Common.ArgListLength++; 202 } 203 204 return_VOID; 205 } 206 207 208 /******************************************************************************* 209 * 210 * FUNCTION: AcpiPsGetDepthNext 211 * 212 * PARAMETERS: Origin - Root of subtree to search 213 * Op - Last (previous) Op that was found 214 * 215 * RETURN: Next Op found in the search. 216 * 217 * DESCRIPTION: Get next op in tree (walking the tree in depth-first order) 218 * Return NULL when reaching "origin" or when walking up from root 219 * 220 ******************************************************************************/ 221 222 ACPI_PARSE_OBJECT * 223 AcpiPsGetDepthNext ( 224 ACPI_PARSE_OBJECT *Origin, 225 ACPI_PARSE_OBJECT *Op) 226 { 227 ACPI_PARSE_OBJECT *Next = NULL; 228 ACPI_PARSE_OBJECT *Parent; 229 ACPI_PARSE_OBJECT *Arg; 230 231 232 ACPI_FUNCTION_ENTRY (); 233 234 235 if (!Op) 236 { 237 return (NULL); 238 } 239 240 /* Look for an argument or child */ 241 242 Next = AcpiPsGetArg (Op, 0); 243 if (Next) 244 { 245 return (Next); 246 } 247 248 /* Look for a sibling */ 249 250 Next = Op->Common.Next; 251 if (Next) 252 { 253 return (Next); 254 } 255 256 /* Look for a sibling of parent */ 257 258 Parent = Op->Common.Parent; 259 260 while (Parent) 261 { 262 Arg = AcpiPsGetArg (Parent, 0); 263 while (Arg && (Arg != Origin) && (Arg != Op)) 264 { 265 Arg = Arg->Common.Next; 266 } 267 268 if (Arg == Origin) 269 { 270 /* Reached parent of origin, end search */ 271 272 return (NULL); 273 } 274 275 if (Parent->Common.Next) 276 { 277 /* Found sibling of parent */ 278 279 return (Parent->Common.Next); 280 } 281 282 Op = Parent; 283 Parent = Parent->Common.Parent; 284 } 285 286 return (Next); 287 } 288 289 290 #ifdef ACPI_OBSOLETE_FUNCTIONS 291 /******************************************************************************* 292 * 293 * FUNCTION: AcpiPsGetChild 294 * 295 * PARAMETERS: Op - Get the child of this Op 296 * 297 * RETURN: Child Op, Null if none is found. 298 * 299 * DESCRIPTION: Get op's children or NULL if none 300 * 301 ******************************************************************************/ 302 303 ACPI_PARSE_OBJECT * 304 AcpiPsGetChild ( 305 ACPI_PARSE_OBJECT *Op) 306 { 307 ACPI_PARSE_OBJECT *Child = NULL; 308 309 310 ACPI_FUNCTION_ENTRY (); 311 312 313 switch (Op->Common.AmlOpcode) 314 { 315 case AML_SCOPE_OP: 316 case AML_ELSE_OP: 317 case AML_DEVICE_OP: 318 case AML_THERMAL_ZONE_OP: 319 case AML_INT_METHODCALL_OP: 320 321 Child = AcpiPsGetArg (Op, 0); 322 break; 323 324 case AML_BUFFER_OP: 325 case AML_PACKAGE_OP: 326 case AML_METHOD_OP: 327 case AML_IF_OP: 328 case AML_WHILE_OP: 329 case AML_FIELD_OP: 330 331 Child = AcpiPsGetArg (Op, 1); 332 break; 333 334 case AML_POWER_RES_OP: 335 case AML_INDEX_FIELD_OP: 336 337 Child = AcpiPsGetArg (Op, 2); 338 break; 339 340 case AML_PROCESSOR_OP: 341 case AML_BANK_FIELD_OP: 342 343 Child = AcpiPsGetArg (Op, 3); 344 break; 345 346 default: 347 348 /* All others have no children */ 349 350 break; 351 } 352 353 return (Child); 354 } 355 #endif 356