1 /****************************************************************************** 2 * 3 * Module Name: pstree - Parser op tree manipulation/traversal/search 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 #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_ENTRY(); 133 134 if (!op) { 135 return; 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; 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; 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 186 #ifdef ACPI_FUTURE_USAGE 187 /******************************************************************************* 188 * 189 * FUNCTION: acpi_ps_get_depth_next 190 * 191 * PARAMETERS: origin - Root of subtree to search 192 * op - Last (previous) Op that was found 193 * 194 * RETURN: Next Op found in the search. 195 * 196 * DESCRIPTION: Get next op in tree (walking the tree in depth-first order) 197 * Return NULL when reaching "origin" or when walking up from root 198 * 199 ******************************************************************************/ 200 201 union acpi_parse_object *acpi_ps_get_depth_next(union acpi_parse_object *origin, 202 union acpi_parse_object *op) 203 { 204 union acpi_parse_object *next = NULL; 205 union acpi_parse_object *parent; 206 union acpi_parse_object *arg; 207 208 ACPI_FUNCTION_ENTRY(); 209 210 if (!op) { 211 return (NULL); 212 } 213 214 /* Look for an argument or child */ 215 216 next = acpi_ps_get_arg(op, 0); 217 if (next) { 218 return (next); 219 } 220 221 /* Look for a sibling */ 222 223 next = op->common.next; 224 if (next) { 225 return (next); 226 } 227 228 /* Look for a sibling of parent */ 229 230 parent = op->common.parent; 231 232 while (parent) { 233 arg = acpi_ps_get_arg(parent, 0); 234 while (arg && (arg != origin) && (arg != op)) { 235 arg = arg->common.next; 236 } 237 238 if (arg == origin) { 239 240 /* Reached parent of origin, end search */ 241 242 return (NULL); 243 } 244 245 if (parent->common.next) { 246 247 /* Found sibling of parent */ 248 249 return (parent->common.next); 250 } 251 252 op = parent; 253 parent = parent->common.parent; 254 } 255 256 return (next); 257 } 258 259 #ifdef ACPI_OBSOLETE_FUNCTIONS 260 /******************************************************************************* 261 * 262 * FUNCTION: acpi_ps_get_child 263 * 264 * PARAMETERS: op - Get the child of this Op 265 * 266 * RETURN: Child Op, Null if none is found. 267 * 268 * DESCRIPTION: Get op's children or NULL if none 269 * 270 ******************************************************************************/ 271 272 union acpi_parse_object *acpi_ps_get_child(union acpi_parse_object *op) 273 { 274 union acpi_parse_object *child = NULL; 275 276 ACPI_FUNCTION_ENTRY(); 277 278 switch (op->common.aml_opcode) { 279 case AML_SCOPE_OP: 280 case AML_ELSE_OP: 281 case AML_DEVICE_OP: 282 case AML_THERMAL_ZONE_OP: 283 case AML_INT_METHODCALL_OP: 284 285 child = acpi_ps_get_arg(op, 0); 286 break; 287 288 case AML_BUFFER_OP: 289 case AML_PACKAGE_OP: 290 case AML_METHOD_OP: 291 case AML_IF_OP: 292 case AML_WHILE_OP: 293 case AML_FIELD_OP: 294 295 child = acpi_ps_get_arg(op, 1); 296 break; 297 298 case AML_POWER_RES_OP: 299 case AML_INDEX_FIELD_OP: 300 301 child = acpi_ps_get_arg(op, 2); 302 break; 303 304 case AML_PROCESSOR_OP: 305 case AML_BANK_FIELD_OP: 306 307 child = acpi_ps_get_arg(op, 3); 308 break; 309 310 default: 311 312 /* All others have no children */ 313 314 break; 315 } 316 317 return (child); 318 } 319 #endif 320 #endif /* ACPI_FUTURE_USAGE */ 321