xref: /linux/drivers/acpi/acpica/exresop.c (revision 1ac731c529cd4d6adbce134754b51ff7d822b145)
1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3  *
4  * Module Name: exresop - AML Interpreter operand/object resolution
5  *
6  * Copyright (C) 2000 - 2023, Intel Corp.
7  *
8  *****************************************************************************/
9 
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12 #include "amlcode.h"
13 #include "acparser.h"
14 #include "acinterp.h"
15 #include "acnamesp.h"
16 
17 #define _COMPONENT          ACPI_EXECUTER
18 ACPI_MODULE_NAME("exresop")
19 
20 /* Local prototypes */
21 static acpi_status
22 acpi_ex_check_object_type(acpi_object_type type_needed,
23 			  acpi_object_type this_type, void *object);
24 
25 /*******************************************************************************
26  *
27  * FUNCTION:    acpi_ex_check_object_type
28  *
29  * PARAMETERS:  type_needed         Object type needed
30  *              this_type           Actual object type
31  *              Object              Object pointer
32  *
33  * RETURN:      Status
34  *
35  * DESCRIPTION: Check required type against actual type
36  *
37  ******************************************************************************/
38 
39 static acpi_status
acpi_ex_check_object_type(acpi_object_type type_needed,acpi_object_type this_type,void * object)40 acpi_ex_check_object_type(acpi_object_type type_needed,
41 			  acpi_object_type this_type, void *object)
42 {
43 	ACPI_FUNCTION_ENTRY();
44 
45 	if (type_needed == ACPI_TYPE_ANY) {
46 
47 		/* All types OK, so we don't perform any typechecks */
48 
49 		return (AE_OK);
50 	}
51 
52 	if (type_needed == ACPI_TYPE_LOCAL_REFERENCE) {
53 		/*
54 		 * Allow the AML "Constant" opcodes (Zero, One, etc.) to be reference
55 		 * objects and thus allow them to be targets. (As per the ACPI
56 		 * specification, a store to a constant is a noop.)
57 		 */
58 		if ((this_type == ACPI_TYPE_INTEGER) &&
59 		    (((union acpi_operand_object *)object)->common.flags &
60 		     AOPOBJ_AML_CONSTANT)) {
61 			return (AE_OK);
62 		}
63 	}
64 
65 	if (type_needed != this_type) {
66 		ACPI_ERROR((AE_INFO,
67 			    "Needed type [%s], found [%s] %p",
68 			    acpi_ut_get_type_name(type_needed),
69 			    acpi_ut_get_type_name(this_type), object));
70 
71 		return (AE_AML_OPERAND_TYPE);
72 	}
73 
74 	return (AE_OK);
75 }
76 
77 /*******************************************************************************
78  *
79  * FUNCTION:    acpi_ex_resolve_operands
80  *
81  * PARAMETERS:  opcode              - Opcode being interpreted
82  *              stack_ptr           - Pointer to the operand stack to be
83  *                                    resolved
84  *              walk_state          - Current state
85  *
86  * RETURN:      Status
87  *
88  * DESCRIPTION: Convert multiple input operands to the types required by the
89  *              target operator.
90  *
91  *      Each 5-bit group in arg_types represents one required
92  *      operand and indicates the required Type. The corresponding operand
93  *      will be converted to the required type if possible, otherwise we
94  *      abort with an exception.
95  *
96  ******************************************************************************/
97 
98 acpi_status
acpi_ex_resolve_operands(u16 opcode,union acpi_operand_object ** stack_ptr,struct acpi_walk_state * walk_state)99 acpi_ex_resolve_operands(u16 opcode,
100 			 union acpi_operand_object **stack_ptr,
101 			 struct acpi_walk_state *walk_state)
102 {
103 	union acpi_operand_object *obj_desc;
104 	acpi_status status = AE_OK;
105 	u8 object_type;
106 	u32 arg_types;
107 	const struct acpi_opcode_info *op_info;
108 	u32 this_arg_type;
109 	acpi_object_type type_needed;
110 	u16 target_op = 0;
111 
112 	ACPI_FUNCTION_TRACE_U32(ex_resolve_operands, opcode);
113 
114 	op_info = acpi_ps_get_opcode_info(opcode);
115 	if (op_info->class == AML_CLASS_UNKNOWN) {
116 		return_ACPI_STATUS(AE_AML_BAD_OPCODE);
117 	}
118 
119 	arg_types = op_info->runtime_args;
120 	if (arg_types == ARGI_INVALID_OPCODE) {
121 		ACPI_ERROR((AE_INFO, "Unknown AML opcode 0x%X", opcode));
122 
123 		return_ACPI_STATUS(AE_AML_INTERNAL);
124 	}
125 
126 	ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
127 			  "Opcode %X [%s] RequiredOperandTypes=%8.8X\n",
128 			  opcode, op_info->name, arg_types));
129 
130 	/*
131 	 * Normal exit is with (arg_types == 0) at end of argument list.
132 	 * Function will return an exception from within the loop upon
133 	 * finding an entry which is not (or cannot be converted
134 	 * to) the required type; if stack underflows; or upon
135 	 * finding a NULL stack entry (which should not happen).
136 	 */
137 	while (GET_CURRENT_ARG_TYPE(arg_types)) {
138 		if (!stack_ptr || !*stack_ptr) {
139 			ACPI_ERROR((AE_INFO, "Null stack entry at %p",
140 				    stack_ptr));
141 
142 			return_ACPI_STATUS(AE_AML_INTERNAL);
143 		}
144 
145 		/* Extract useful items */
146 
147 		obj_desc = *stack_ptr;
148 
149 		/* Decode the descriptor type */
150 
151 		switch (ACPI_GET_DESCRIPTOR_TYPE(obj_desc)) {
152 		case ACPI_DESC_TYPE_NAMED:
153 
154 			/* Namespace Node */
155 
156 			object_type =
157 			    ((struct acpi_namespace_node *)obj_desc)->type;
158 
159 			/*
160 			 * Resolve an alias object. The construction of these objects
161 			 * guarantees that there is only one level of alias indirection;
162 			 * thus, the attached object is always the aliased namespace node
163 			 */
164 			if (object_type == ACPI_TYPE_LOCAL_ALIAS) {
165 				obj_desc = acpi_ns_get_attached_object((struct
166 									acpi_namespace_node
167 									*)
168 								       obj_desc);
169 				*stack_ptr = obj_desc;
170 				object_type =
171 				    ((struct acpi_namespace_node *)obj_desc)->
172 				    type;
173 			}
174 			break;
175 
176 		case ACPI_DESC_TYPE_OPERAND:
177 
178 			/* ACPI internal object */
179 
180 			object_type = obj_desc->common.type;
181 
182 			/* Check for bad acpi_object_type */
183 
184 			if (!acpi_ut_valid_object_type(object_type)) {
185 				ACPI_ERROR((AE_INFO,
186 					    "Bad operand object type [0x%X]",
187 					    object_type));
188 
189 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
190 			}
191 
192 			if (object_type == (u8) ACPI_TYPE_LOCAL_REFERENCE) {
193 
194 				/* Validate the Reference */
195 
196 				switch (obj_desc->reference.class) {
197 				case ACPI_REFCLASS_DEBUG:
198 
199 					target_op = AML_DEBUG_OP;
200 
201 					ACPI_FALLTHROUGH;
202 
203 				case ACPI_REFCLASS_ARG:
204 				case ACPI_REFCLASS_LOCAL:
205 				case ACPI_REFCLASS_INDEX:
206 				case ACPI_REFCLASS_REFOF:
207 				case ACPI_REFCLASS_TABLE:	/* ddb_handle from LOAD_OP or LOAD_TABLE_OP */
208 				case ACPI_REFCLASS_NAME:	/* Reference to a named object */
209 
210 					ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
211 							  "Operand is a Reference, Class [%s] %2.2X\n",
212 							  acpi_ut_get_reference_name
213 							  (obj_desc),
214 							  obj_desc->reference.
215 							  class));
216 					break;
217 
218 				default:
219 
220 					ACPI_ERROR((AE_INFO,
221 						    "Unknown Reference Class 0x%2.2X in %p",
222 						    obj_desc->reference.class,
223 						    obj_desc));
224 
225 					return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
226 				}
227 			}
228 			break;
229 
230 		default:
231 
232 			/* Invalid descriptor */
233 
234 			ACPI_ERROR((AE_INFO, "Invalid descriptor %p [%s]",
235 				    obj_desc,
236 				    acpi_ut_get_descriptor_name(obj_desc)));
237 
238 			return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
239 		}
240 
241 		/* Get one argument type, point to the next */
242 
243 		this_arg_type = GET_CURRENT_ARG_TYPE(arg_types);
244 		INCREMENT_ARG_LIST(arg_types);
245 
246 		/*
247 		 * Handle cases where the object does not need to be
248 		 * resolved to a value
249 		 */
250 		switch (this_arg_type) {
251 		case ARGI_REF_OR_STRING:	/* Can be a String or Reference */
252 
253 			if ((ACPI_GET_DESCRIPTOR_TYPE(obj_desc) ==
254 			     ACPI_DESC_TYPE_OPERAND) &&
255 			    (obj_desc->common.type == ACPI_TYPE_STRING)) {
256 				/*
257 				 * String found - the string references a named object and
258 				 * must be resolved to a node
259 				 */
260 				goto next_operand;
261 			}
262 
263 			/*
264 			 * Else not a string - fall through to the normal Reference
265 			 * case below
266 			 */
267 			ACPI_FALLTHROUGH;
268 
269 		case ARGI_REFERENCE:	/* References: */
270 		case ARGI_INTEGER_REF:
271 		case ARGI_OBJECT_REF:
272 		case ARGI_DEVICE_REF:
273 		case ARGI_TARGETREF:	/* Allows implicit conversion rules before store */
274 		case ARGI_FIXED_TARGET:	/* No implicit conversion before store to target */
275 		case ARGI_SIMPLE_TARGET:	/* Name, Local, or arg - no implicit conversion  */
276 		case ARGI_STORE_TARGET:
277 
278 			/*
279 			 * Need an operand of type ACPI_TYPE_LOCAL_REFERENCE
280 			 * A Namespace Node is OK as-is
281 			 */
282 			if (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) ==
283 			    ACPI_DESC_TYPE_NAMED) {
284 				goto next_operand;
285 			}
286 
287 			status =
288 			    acpi_ex_check_object_type(ACPI_TYPE_LOCAL_REFERENCE,
289 						      object_type, obj_desc);
290 			if (ACPI_FAILURE(status)) {
291 				return_ACPI_STATUS(status);
292 			}
293 			goto next_operand;
294 
295 		case ARGI_DATAREFOBJ:	/* Store operator only */
296 			/*
297 			 * We don't want to resolve index_op reference objects during
298 			 * a store because this would be an implicit de_ref_of operation.
299 			 * Instead, we just want to store the reference object.
300 			 * -- All others must be resolved below.
301 			 */
302 			if ((opcode == AML_STORE_OP) &&
303 			    ((*stack_ptr)->common.type ==
304 			     ACPI_TYPE_LOCAL_REFERENCE)
305 			    && ((*stack_ptr)->reference.class ==
306 				ACPI_REFCLASS_INDEX)) {
307 				goto next_operand;
308 			}
309 			break;
310 
311 		default:
312 
313 			/* All cases covered above */
314 
315 			break;
316 		}
317 
318 		/*
319 		 * Resolve this object to a value
320 		 */
321 		status = acpi_ex_resolve_to_value(stack_ptr, walk_state);
322 		if (ACPI_FAILURE(status)) {
323 			return_ACPI_STATUS(status);
324 		}
325 
326 		/* Get the resolved object */
327 
328 		obj_desc = *stack_ptr;
329 
330 		/*
331 		 * Check the resulting object (value) type
332 		 */
333 		switch (this_arg_type) {
334 			/*
335 			 * For the simple cases, only one type of resolved object
336 			 * is allowed
337 			 */
338 		case ARGI_MUTEX:
339 
340 			/* Need an operand of type ACPI_TYPE_MUTEX */
341 
342 			type_needed = ACPI_TYPE_MUTEX;
343 			break;
344 
345 		case ARGI_EVENT:
346 
347 			/* Need an operand of type ACPI_TYPE_EVENT */
348 
349 			type_needed = ACPI_TYPE_EVENT;
350 			break;
351 
352 		case ARGI_PACKAGE:	/* Package */
353 
354 			/* Need an operand of type ACPI_TYPE_PACKAGE */
355 
356 			type_needed = ACPI_TYPE_PACKAGE;
357 			break;
358 
359 		case ARGI_ANYTYPE:
360 
361 			/* Any operand type will do */
362 
363 			type_needed = ACPI_TYPE_ANY;
364 			break;
365 
366 		case ARGI_DDBHANDLE:
367 
368 			/* Need an operand of type ACPI_TYPE_DDB_HANDLE */
369 
370 			type_needed = ACPI_TYPE_LOCAL_REFERENCE;
371 			break;
372 
373 			/*
374 			 * The more complex cases allow multiple resolved object types
375 			 */
376 		case ARGI_INTEGER:
377 
378 			/*
379 			 * Need an operand of type ACPI_TYPE_INTEGER, but we can
380 			 * implicitly convert from a STRING or BUFFER.
381 			 *
382 			 * Known as "Implicit Source Operand Conversion"
383 			 */
384 			status = acpi_ex_convert_to_integer(obj_desc, stack_ptr,
385 							    ACPI_IMPLICIT_CONVERSION);
386 			if (ACPI_FAILURE(status)) {
387 				if (status == AE_TYPE) {
388 					ACPI_ERROR((AE_INFO,
389 						    "Needed [Integer/String/Buffer], found [%s] %p",
390 						    acpi_ut_get_object_type_name
391 						    (obj_desc), obj_desc));
392 
393 					return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
394 				}
395 
396 				return_ACPI_STATUS(status);
397 			}
398 
399 			if (obj_desc != *stack_ptr) {
400 				acpi_ut_remove_reference(obj_desc);
401 			}
402 			goto next_operand;
403 
404 		case ARGI_BUFFER:
405 			/*
406 			 * Need an operand of type ACPI_TYPE_BUFFER,
407 			 * But we can implicitly convert from a STRING or INTEGER
408 			 * aka - "Implicit Source Operand Conversion"
409 			 */
410 			status = acpi_ex_convert_to_buffer(obj_desc, stack_ptr);
411 			if (ACPI_FAILURE(status)) {
412 				if (status == AE_TYPE) {
413 					ACPI_ERROR((AE_INFO,
414 						    "Needed [Integer/String/Buffer], found [%s] %p",
415 						    acpi_ut_get_object_type_name
416 						    (obj_desc), obj_desc));
417 
418 					return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
419 				}
420 
421 				return_ACPI_STATUS(status);
422 			}
423 
424 			if (obj_desc != *stack_ptr) {
425 				acpi_ut_remove_reference(obj_desc);
426 			}
427 			goto next_operand;
428 
429 		case ARGI_STRING:
430 			/*
431 			 * Need an operand of type ACPI_TYPE_STRING,
432 			 * But we can implicitly convert from a BUFFER or INTEGER
433 			 * aka - "Implicit Source Operand Conversion"
434 			 */
435 			status =
436 			    acpi_ex_convert_to_string(obj_desc, stack_ptr,
437 						      ACPI_IMPLICIT_CONVERT_HEX);
438 			if (ACPI_FAILURE(status)) {
439 				if (status == AE_TYPE) {
440 					ACPI_ERROR((AE_INFO,
441 						    "Needed [Integer/String/Buffer], found [%s] %p",
442 						    acpi_ut_get_object_type_name
443 						    (obj_desc), obj_desc));
444 
445 					return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
446 				}
447 
448 				return_ACPI_STATUS(status);
449 			}
450 
451 			if (obj_desc != *stack_ptr) {
452 				acpi_ut_remove_reference(obj_desc);
453 			}
454 			goto next_operand;
455 
456 		case ARGI_COMPUTEDATA:
457 
458 			/* Need an operand of type INTEGER, STRING or BUFFER */
459 
460 			switch (obj_desc->common.type) {
461 			case ACPI_TYPE_INTEGER:
462 			case ACPI_TYPE_STRING:
463 			case ACPI_TYPE_BUFFER:
464 
465 				/* Valid operand */
466 				break;
467 
468 			default:
469 				ACPI_ERROR((AE_INFO,
470 					    "Needed [Integer/String/Buffer], found [%s] %p",
471 					    acpi_ut_get_object_type_name
472 					    (obj_desc), obj_desc));
473 
474 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
475 			}
476 			goto next_operand;
477 
478 		case ARGI_BUFFER_OR_STRING:
479 
480 			/* Need an operand of type STRING or BUFFER */
481 
482 			switch (obj_desc->common.type) {
483 			case ACPI_TYPE_STRING:
484 			case ACPI_TYPE_BUFFER:
485 
486 				/* Valid operand */
487 				break;
488 
489 			case ACPI_TYPE_INTEGER:
490 
491 				/* Highest priority conversion is to type Buffer */
492 
493 				status =
494 				    acpi_ex_convert_to_buffer(obj_desc,
495 							      stack_ptr);
496 				if (ACPI_FAILURE(status)) {
497 					return_ACPI_STATUS(status);
498 				}
499 
500 				if (obj_desc != *stack_ptr) {
501 					acpi_ut_remove_reference(obj_desc);
502 				}
503 				break;
504 
505 			default:
506 				ACPI_ERROR((AE_INFO,
507 					    "Needed [Integer/String/Buffer], found [%s] %p",
508 					    acpi_ut_get_object_type_name
509 					    (obj_desc), obj_desc));
510 
511 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
512 			}
513 			goto next_operand;
514 
515 		case ARGI_DATAOBJECT:
516 			/*
517 			 * ARGI_DATAOBJECT is only used by the size_of operator.
518 			 * Need a buffer, string, package, or ref_of reference.
519 			 *
520 			 * The only reference allowed here is a direct reference to
521 			 * a namespace node.
522 			 */
523 			switch (obj_desc->common.type) {
524 			case ACPI_TYPE_PACKAGE:
525 			case ACPI_TYPE_STRING:
526 			case ACPI_TYPE_BUFFER:
527 			case ACPI_TYPE_LOCAL_REFERENCE:
528 
529 				/* Valid operand */
530 				break;
531 
532 			default:
533 
534 				ACPI_ERROR((AE_INFO,
535 					    "Needed [Buffer/String/Package/Reference], found [%s] %p",
536 					    acpi_ut_get_object_type_name
537 					    (obj_desc), obj_desc));
538 
539 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
540 			}
541 			goto next_operand;
542 
543 		case ARGI_COMPLEXOBJ:
544 
545 			/* Need a buffer or package or (ACPI 2.0) String */
546 
547 			switch (obj_desc->common.type) {
548 			case ACPI_TYPE_PACKAGE:
549 			case ACPI_TYPE_STRING:
550 			case ACPI_TYPE_BUFFER:
551 
552 				/* Valid operand */
553 				break;
554 
555 			default:
556 
557 				ACPI_ERROR((AE_INFO,
558 					    "Needed [Buffer/String/Package], found [%s] %p",
559 					    acpi_ut_get_object_type_name
560 					    (obj_desc), obj_desc));
561 
562 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
563 			}
564 			goto next_operand;
565 
566 		case ARGI_REGION_OR_BUFFER:	/* Used by Load() only */
567 
568 			/*
569 			 * Need an operand of type REGION or a BUFFER
570 			 * (which could be a resolved region field)
571 			 */
572 			switch (obj_desc->common.type) {
573 			case ACPI_TYPE_BUFFER:
574 			case ACPI_TYPE_REGION:
575 
576 				/* Valid operand */
577 				break;
578 
579 			default:
580 
581 				ACPI_ERROR((AE_INFO,
582 					    "Needed [Region/Buffer], found [%s] %p",
583 					    acpi_ut_get_object_type_name
584 					    (obj_desc), obj_desc));
585 
586 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
587 			}
588 			goto next_operand;
589 
590 		case ARGI_DATAREFOBJ:
591 
592 			/* Used by the Store() operator only */
593 
594 			switch (obj_desc->common.type) {
595 			case ACPI_TYPE_INTEGER:
596 			case ACPI_TYPE_PACKAGE:
597 			case ACPI_TYPE_STRING:
598 			case ACPI_TYPE_BUFFER:
599 			case ACPI_TYPE_BUFFER_FIELD:
600 			case ACPI_TYPE_LOCAL_REFERENCE:
601 			case ACPI_TYPE_LOCAL_REGION_FIELD:
602 			case ACPI_TYPE_LOCAL_BANK_FIELD:
603 			case ACPI_TYPE_LOCAL_INDEX_FIELD:
604 			case ACPI_TYPE_DDB_HANDLE:
605 
606 				/* Valid operand */
607 				break;
608 
609 			default:
610 
611 				if (acpi_gbl_enable_interpreter_slack) {
612 					/*
613 					 * Enable original behavior of Store(), allowing any
614 					 * and all objects as the source operand. The ACPI
615 					 * spec does not allow this, however.
616 					 */
617 					break;
618 				}
619 
620 				if (target_op == AML_DEBUG_OP) {
621 
622 					/* Allow store of any object to the Debug object */
623 
624 					break;
625 				}
626 
627 				ACPI_ERROR((AE_INFO,
628 					    "Needed Integer/Buffer/String/Package/Ref/Ddb]"
629 					    ", found [%s] %p",
630 					    acpi_ut_get_object_type_name
631 					    (obj_desc), obj_desc));
632 
633 				return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
634 			}
635 			goto next_operand;
636 
637 		default:
638 
639 			/* Unknown type */
640 
641 			ACPI_ERROR((AE_INFO,
642 				    "Internal - Unknown ARGI (required operand) type 0x%X",
643 				    this_arg_type));
644 
645 			return_ACPI_STATUS(AE_BAD_PARAMETER);
646 		}
647 
648 		/*
649 		 * Make sure that the original object was resolved to the
650 		 * required object type (Simple cases only).
651 		 */
652 		status =
653 		    acpi_ex_check_object_type(type_needed,
654 					      (*stack_ptr)->common.type,
655 					      *stack_ptr);
656 		if (ACPI_FAILURE(status)) {
657 			return_ACPI_STATUS(status);
658 		}
659 
660 next_operand:
661 		/*
662 		 * If more operands needed, decrement stack_ptr to point
663 		 * to next operand on stack
664 		 */
665 		if (GET_CURRENT_ARG_TYPE(arg_types)) {
666 			stack_ptr--;
667 		}
668 	}
669 
670 	ACPI_DUMP_OPERANDS(walk_state->operands,
671 			   acpi_ps_get_opcode_name(opcode),
672 			   walk_state->num_operands);
673 
674 	return_ACPI_STATUS(status);
675 }
676