1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: exresolv - AML Interpreter object resolution 5 * 6 * Copyright (C) 2000 - 2022, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 #include "amlcode.h" 13 #include "acdispat.h" 14 #include "acinterp.h" 15 #include "acnamesp.h" 16 17 #define _COMPONENT ACPI_EXECUTER 18 ACPI_MODULE_NAME("exresolv") 19 20 /* Local prototypes */ 21 static acpi_status 22 acpi_ex_resolve_object_to_value(union acpi_operand_object **stack_ptr, 23 struct acpi_walk_state *walk_state); 24 25 /******************************************************************************* 26 * 27 * FUNCTION: acpi_ex_resolve_to_value 28 * 29 * PARAMETERS: **stack_ptr - Points to entry on obj_stack, which can 30 * be either an (union acpi_operand_object *) 31 * or an acpi_handle. 32 * walk_state - Current method state 33 * 34 * RETURN: Status 35 * 36 * DESCRIPTION: Convert Reference objects to values 37 * 38 ******************************************************************************/ 39 40 acpi_status 41 acpi_ex_resolve_to_value(union acpi_operand_object **stack_ptr, 42 struct acpi_walk_state *walk_state) 43 { 44 acpi_status status; 45 46 ACPI_FUNCTION_TRACE_PTR(ex_resolve_to_value, stack_ptr); 47 48 if (!stack_ptr || !*stack_ptr) { 49 ACPI_ERROR((AE_INFO, "Internal - null pointer")); 50 return_ACPI_STATUS(AE_AML_NO_OPERAND); 51 } 52 53 /* 54 * The entity pointed to by the stack_ptr can be either 55 * 1) A valid union acpi_operand_object, or 56 * 2) A struct acpi_namespace_node (named_obj) 57 */ 58 if (ACPI_GET_DESCRIPTOR_TYPE(*stack_ptr) == ACPI_DESC_TYPE_OPERAND) { 59 status = acpi_ex_resolve_object_to_value(stack_ptr, walk_state); 60 if (ACPI_FAILURE(status)) { 61 return_ACPI_STATUS(status); 62 } 63 64 if (!*stack_ptr) { 65 ACPI_ERROR((AE_INFO, "Internal - null pointer")); 66 return_ACPI_STATUS(AE_AML_NO_OPERAND); 67 } 68 } 69 70 /* 71 * Object on the stack may have changed if acpi_ex_resolve_object_to_value() 72 * was called (i.e., we can't use an _else_ here.) 73 */ 74 if (ACPI_GET_DESCRIPTOR_TYPE(*stack_ptr) == ACPI_DESC_TYPE_NAMED) { 75 status = 76 acpi_ex_resolve_node_to_value(ACPI_CAST_INDIRECT_PTR 77 (struct acpi_namespace_node, 78 stack_ptr), walk_state); 79 if (ACPI_FAILURE(status)) { 80 return_ACPI_STATUS(status); 81 } 82 } 83 84 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Resolved object %p\n", *stack_ptr)); 85 return_ACPI_STATUS(AE_OK); 86 } 87 88 /******************************************************************************* 89 * 90 * FUNCTION: acpi_ex_resolve_object_to_value 91 * 92 * PARAMETERS: stack_ptr - Pointer to an internal object 93 * walk_state - Current method state 94 * 95 * RETURN: Status 96 * 97 * DESCRIPTION: Retrieve the value from an internal object. The Reference type 98 * uses the associated AML opcode to determine the value. 99 * 100 ******************************************************************************/ 101 102 static acpi_status 103 acpi_ex_resolve_object_to_value(union acpi_operand_object **stack_ptr, 104 struct acpi_walk_state *walk_state) 105 { 106 acpi_status status = AE_OK; 107 union acpi_operand_object *stack_desc; 108 union acpi_operand_object *obj_desc = NULL; 109 u8 ref_type; 110 111 ACPI_FUNCTION_TRACE(ex_resolve_object_to_value); 112 113 stack_desc = *stack_ptr; 114 115 /* This is an object of type union acpi_operand_object */ 116 117 switch (stack_desc->common.type) { 118 case ACPI_TYPE_LOCAL_REFERENCE: 119 120 ref_type = stack_desc->reference.class; 121 122 switch (ref_type) { 123 case ACPI_REFCLASS_LOCAL: 124 case ACPI_REFCLASS_ARG: 125 /* 126 * Get the local from the method's state info 127 * Note: this increments the local's object reference count 128 */ 129 status = acpi_ds_method_data_get_value(ref_type, 130 stack_desc-> 131 reference.value, 132 walk_state, 133 &obj_desc); 134 if (ACPI_FAILURE(status)) { 135 return_ACPI_STATUS(status); 136 } 137 138 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 139 "[Arg/Local %X] ValueObj is %p\n", 140 stack_desc->reference.value, 141 obj_desc)); 142 143 /* 144 * Now we can delete the original Reference Object and 145 * replace it with the resolved value 146 */ 147 acpi_ut_remove_reference(stack_desc); 148 *stack_ptr = obj_desc; 149 break; 150 151 case ACPI_REFCLASS_INDEX: 152 153 switch (stack_desc->reference.target_type) { 154 case ACPI_TYPE_BUFFER_FIELD: 155 156 /* Just return - do not dereference */ 157 break; 158 159 case ACPI_TYPE_PACKAGE: 160 161 /* If method call or copy_object - do not dereference */ 162 163 if ((walk_state->opcode == 164 AML_INT_METHODCALL_OP) 165 || (walk_state->opcode == 166 AML_COPY_OBJECT_OP)) { 167 break; 168 } 169 170 /* Otherwise, dereference the package_index to a package element */ 171 172 obj_desc = *stack_desc->reference.where; 173 if (obj_desc) { 174 /* 175 * Valid object descriptor, copy pointer to return value 176 * (i.e., dereference the package index) 177 * Delete the ref object, increment the returned object 178 */ 179 acpi_ut_add_reference(obj_desc); 180 *stack_ptr = obj_desc; 181 } else { 182 /* 183 * A NULL object descriptor means an uninitialized element of 184 * the package, can't dereference it 185 */ 186 ACPI_ERROR((AE_INFO, 187 "Attempt to dereference an Index to " 188 "NULL package element Idx=%p", 189 stack_desc)); 190 status = AE_AML_UNINITIALIZED_ELEMENT; 191 } 192 break; 193 194 default: 195 196 /* Invalid reference object */ 197 198 ACPI_ERROR((AE_INFO, 199 "Unknown TargetType 0x%X in Index/Reference object %p", 200 stack_desc->reference.target_type, 201 stack_desc)); 202 status = AE_AML_INTERNAL; 203 break; 204 } 205 break; 206 207 case ACPI_REFCLASS_REFOF: 208 case ACPI_REFCLASS_DEBUG: 209 case ACPI_REFCLASS_TABLE: 210 211 /* Just leave the object as-is, do not dereference */ 212 213 break; 214 215 case ACPI_REFCLASS_NAME: /* Reference to a named object */ 216 217 /* Dereference the name */ 218 219 if ((stack_desc->reference.node->type == 220 ACPI_TYPE_DEVICE) 221 || (stack_desc->reference.node->type == 222 ACPI_TYPE_THERMAL)) { 223 224 /* These node types do not have 'real' subobjects */ 225 226 *stack_ptr = (void *)stack_desc->reference.node; 227 } else { 228 /* Get the object pointed to by the namespace node */ 229 230 *stack_ptr = 231 (stack_desc->reference.node)->object; 232 acpi_ut_add_reference(*stack_ptr); 233 } 234 235 acpi_ut_remove_reference(stack_desc); 236 break; 237 238 default: 239 240 ACPI_ERROR((AE_INFO, 241 "Unknown Reference type 0x%X in %p", 242 ref_type, stack_desc)); 243 status = AE_AML_INTERNAL; 244 break; 245 } 246 break; 247 248 case ACPI_TYPE_BUFFER: 249 250 status = acpi_ds_get_buffer_arguments(stack_desc); 251 break; 252 253 case ACPI_TYPE_PACKAGE: 254 255 status = acpi_ds_get_package_arguments(stack_desc); 256 break; 257 258 case ACPI_TYPE_BUFFER_FIELD: 259 case ACPI_TYPE_LOCAL_REGION_FIELD: 260 case ACPI_TYPE_LOCAL_BANK_FIELD: 261 case ACPI_TYPE_LOCAL_INDEX_FIELD: 262 263 ACPI_DEBUG_PRINT((ACPI_DB_EXEC, 264 "FieldRead SourceDesc=%p Type=%X\n", 265 stack_desc, stack_desc->common.type)); 266 267 status = 268 acpi_ex_read_data_from_field(walk_state, stack_desc, 269 &obj_desc); 270 271 /* Remove a reference to the original operand, then override */ 272 273 acpi_ut_remove_reference(*stack_ptr); 274 *stack_ptr = (void *)obj_desc; 275 break; 276 277 default: 278 279 break; 280 } 281 282 return_ACPI_STATUS(status); 283 } 284 285 /******************************************************************************* 286 * 287 * FUNCTION: acpi_ex_resolve_multiple 288 * 289 * PARAMETERS: walk_state - Current state (contains AML opcode) 290 * operand - Starting point for resolution 291 * return_type - Where the object type is returned 292 * return_desc - Where the resolved object is returned 293 * 294 * RETURN: Status 295 * 296 * DESCRIPTION: Return the base object and type. Traverse a reference list if 297 * necessary to get to the base object. 298 * 299 ******************************************************************************/ 300 301 acpi_status 302 acpi_ex_resolve_multiple(struct acpi_walk_state *walk_state, 303 union acpi_operand_object *operand, 304 acpi_object_type *return_type, 305 union acpi_operand_object **return_desc) 306 { 307 union acpi_operand_object *obj_desc = ACPI_CAST_PTR(void, operand); 308 struct acpi_namespace_node *node = 309 ACPI_CAST_PTR(struct acpi_namespace_node, operand); 310 acpi_object_type type; 311 acpi_status status; 312 313 ACPI_FUNCTION_TRACE(acpi_ex_resolve_multiple); 314 315 /* Operand can be either a namespace node or an operand descriptor */ 316 317 switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) { 318 case ACPI_DESC_TYPE_OPERAND: 319 320 type = obj_desc->common.type; 321 break; 322 323 case ACPI_DESC_TYPE_NAMED: 324 325 type = ((struct acpi_namespace_node *)obj_desc)->type; 326 obj_desc = acpi_ns_get_attached_object(node); 327 328 /* If we had an Alias node, use the attached object for type info */ 329 330 if (type == ACPI_TYPE_LOCAL_ALIAS) { 331 type = ((struct acpi_namespace_node *)obj_desc)->type; 332 obj_desc = acpi_ns_get_attached_object((struct 333 acpi_namespace_node 334 *)obj_desc); 335 } 336 337 switch (type) { 338 case ACPI_TYPE_DEVICE: 339 case ACPI_TYPE_THERMAL: 340 341 /* These types have no attached subobject */ 342 break; 343 344 default: 345 346 /* All other types require a subobject */ 347 348 if (!obj_desc) { 349 ACPI_ERROR((AE_INFO, 350 "[%4.4s] Node is unresolved or uninitialized", 351 acpi_ut_get_node_name(node))); 352 return_ACPI_STATUS(AE_AML_UNINITIALIZED_NODE); 353 } 354 break; 355 } 356 break; 357 358 default: 359 return_ACPI_STATUS(AE_AML_OPERAND_TYPE); 360 } 361 362 /* If type is anything other than a reference, we are done */ 363 364 if (type != ACPI_TYPE_LOCAL_REFERENCE) { 365 goto exit; 366 } 367 368 /* 369 * For reference objects created via the ref_of, Index, or Load/load_table 370 * operators, we need to get to the base object (as per the ACPI 371 * specification of the object_type and size_of operators). This means 372 * traversing the list of possibly many nested references. 373 */ 374 while (obj_desc->common.type == ACPI_TYPE_LOCAL_REFERENCE) { 375 switch (obj_desc->reference.class) { 376 case ACPI_REFCLASS_REFOF: 377 case ACPI_REFCLASS_NAME: 378 379 /* Dereference the reference pointer */ 380 381 if (obj_desc->reference.class == ACPI_REFCLASS_REFOF) { 382 node = obj_desc->reference.object; 383 } else { /* AML_INT_NAMEPATH_OP */ 384 385 node = obj_desc->reference.node; 386 } 387 388 /* All "References" point to a NS node */ 389 390 if (ACPI_GET_DESCRIPTOR_TYPE(node) != 391 ACPI_DESC_TYPE_NAMED) { 392 ACPI_ERROR((AE_INFO, 393 "Not a namespace node %p [%s]", 394 node, 395 acpi_ut_get_descriptor_name(node))); 396 return_ACPI_STATUS(AE_AML_INTERNAL); 397 } 398 399 /* Get the attached object */ 400 401 obj_desc = acpi_ns_get_attached_object(node); 402 if (!obj_desc) { 403 404 /* No object, use the NS node type */ 405 406 type = acpi_ns_get_type(node); 407 goto exit; 408 } 409 410 /* Check for circular references */ 411 412 if (obj_desc == operand) { 413 return_ACPI_STATUS(AE_AML_CIRCULAR_REFERENCE); 414 } 415 break; 416 417 case ACPI_REFCLASS_INDEX: 418 419 /* Get the type of this reference (index into another object) */ 420 421 type = obj_desc->reference.target_type; 422 if (type != ACPI_TYPE_PACKAGE) { 423 goto exit; 424 } 425 426 /* 427 * The main object is a package, we want to get the type 428 * of the individual package element that is referenced by 429 * the index. 430 * 431 * This could of course in turn be another reference object. 432 */ 433 obj_desc = *(obj_desc->reference.where); 434 if (!obj_desc) { 435 436 /* NULL package elements are allowed */ 437 438 type = 0; /* Uninitialized */ 439 goto exit; 440 } 441 break; 442 443 case ACPI_REFCLASS_TABLE: 444 445 type = ACPI_TYPE_DDB_HANDLE; 446 goto exit; 447 448 case ACPI_REFCLASS_LOCAL: 449 case ACPI_REFCLASS_ARG: 450 451 if (return_desc) { 452 status = 453 acpi_ds_method_data_get_value(obj_desc-> 454 reference. 455 class, 456 obj_desc-> 457 reference. 458 value, 459 walk_state, 460 &obj_desc); 461 if (ACPI_FAILURE(status)) { 462 return_ACPI_STATUS(status); 463 } 464 acpi_ut_remove_reference(obj_desc); 465 } else { 466 status = 467 acpi_ds_method_data_get_node(obj_desc-> 468 reference. 469 class, 470 obj_desc-> 471 reference. 472 value, 473 walk_state, 474 &node); 475 if (ACPI_FAILURE(status)) { 476 return_ACPI_STATUS(status); 477 } 478 479 obj_desc = acpi_ns_get_attached_object(node); 480 if (!obj_desc) { 481 type = ACPI_TYPE_ANY; 482 goto exit; 483 } 484 } 485 break; 486 487 case ACPI_REFCLASS_DEBUG: 488 489 /* The Debug Object is of type "DebugObject" */ 490 491 type = ACPI_TYPE_DEBUG_OBJECT; 492 goto exit; 493 494 default: 495 496 ACPI_ERROR((AE_INFO, 497 "Unknown Reference Class 0x%2.2X", 498 obj_desc->reference.class)); 499 return_ACPI_STATUS(AE_AML_INTERNAL); 500 } 501 } 502 503 /* 504 * Now we are guaranteed to have an object that has not been created 505 * via the ref_of or Index operators. 506 */ 507 type = obj_desc->common.type; 508 509 exit: 510 /* Convert internal types to external types */ 511 512 switch (type) { 513 case ACPI_TYPE_LOCAL_REGION_FIELD: 514 case ACPI_TYPE_LOCAL_BANK_FIELD: 515 case ACPI_TYPE_LOCAL_INDEX_FIELD: 516 517 type = ACPI_TYPE_FIELD_UNIT; 518 break; 519 520 case ACPI_TYPE_LOCAL_SCOPE: 521 522 /* Per ACPI Specification, Scope is untyped */ 523 524 type = ACPI_TYPE_ANY; 525 break; 526 527 default: 528 529 /* No change to Type required */ 530 531 break; 532 } 533 534 *return_type = type; 535 if (return_desc) { 536 *return_desc = obj_desc; 537 } 538 return_ACPI_STATUS(AE_OK); 539 } 540