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