xref: /openbmc/linux/drivers/acpi/acpica/exoparg2.c (revision 4da722ca)
1 /******************************************************************************
2  *
3  * Module Name: exoparg2 - AML execution - opcodes with 2 arguments
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 "acinterp.h"
48 #include "acevents.h"
49 #include "amlcode.h"
50 
51 #define _COMPONENT          ACPI_EXECUTER
52 ACPI_MODULE_NAME("exoparg2")
53 
54 /*!
55  * Naming convention for AML interpreter execution routines.
56  *
57  * The routines that begin execution of AML opcodes are named with a common
58  * convention based upon the number of arguments, the number of target operands,
59  * and whether or not a value is returned:
60  *
61  *      AcpiExOpcode_xA_yT_zR
62  *
63  * Where:
64  *
65  * xA - ARGUMENTS:    The number of arguments (input operands) that are
66  *                    required for this opcode type (1 through 6 args).
67  * yT - TARGETS:      The number of targets (output operands) that are required
68  *                    for this opcode type (0, 1, or 2 targets).
69  * zR - RETURN VALUE: Indicates whether this opcode type returns a value
70  *                    as the function return (0 or 1).
71  *
72  * The AcpiExOpcode* functions are called via the Dispatcher component with
73  * fully resolved operands.
74 !*/
75 /*******************************************************************************
76  *
77  * FUNCTION:    acpi_ex_opcode_2A_0T_0R
78  *
79  * PARAMETERS:  walk_state          - Current walk state
80  *
81  * RETURN:      Status
82  *
83  * DESCRIPTION: Execute opcode with two arguments, no target, and no return
84  *              value.
85  *
86  * ALLOCATION:  Deletes both operands
87  *
88  ******************************************************************************/
89 acpi_status acpi_ex_opcode_2A_0T_0R(struct acpi_walk_state *walk_state)
90 {
91 	union acpi_operand_object **operand = &walk_state->operands[0];
92 	struct acpi_namespace_node *node;
93 	u32 value;
94 	acpi_status status = AE_OK;
95 
96 	ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_0T_0R,
97 				acpi_ps_get_opcode_name(walk_state->opcode));
98 
99 	/* Examine the opcode */
100 
101 	switch (walk_state->opcode) {
102 	case AML_NOTIFY_OP:	/* Notify (notify_object, notify_value) */
103 
104 		/* The first operand is a namespace node */
105 
106 		node = (struct acpi_namespace_node *)operand[0];
107 
108 		/* Second value is the notify value */
109 
110 		value = (u32) operand[1]->integer.value;
111 
112 		/* Are notifies allowed on this object? */
113 
114 		if (!acpi_ev_is_notify_object(node)) {
115 			ACPI_ERROR((AE_INFO,
116 				    "Unexpected notify object type [%s]",
117 				    acpi_ut_get_type_name(node->type)));
118 
119 			status = AE_AML_OPERAND_TYPE;
120 			break;
121 		}
122 
123 		/*
124 		 * Dispatch the notify to the appropriate handler
125 		 * NOTE: the request is queued for execution after this method
126 		 * completes. The notify handlers are NOT invoked synchronously
127 		 * from this thread -- because handlers may in turn run other
128 		 * control methods.
129 		 */
130 		status = acpi_ev_queue_notify_request(node, value);
131 		break;
132 
133 	default:
134 
135 		ACPI_ERROR((AE_INFO, "Unknown AML opcode 0x%X",
136 			    walk_state->opcode));
137 		status = AE_AML_BAD_OPCODE;
138 	}
139 
140 	return_ACPI_STATUS(status);
141 }
142 
143 /*******************************************************************************
144  *
145  * FUNCTION:    acpi_ex_opcode_2A_2T_1R
146  *
147  * PARAMETERS:  walk_state          - Current walk state
148  *
149  * RETURN:      Status
150  *
151  * DESCRIPTION: Execute a dyadic operator (2 operands) with 2 output targets
152  *              and one implicit return value.
153  *
154  ******************************************************************************/
155 
156 acpi_status acpi_ex_opcode_2A_2T_1R(struct acpi_walk_state *walk_state)
157 {
158 	union acpi_operand_object **operand = &walk_state->operands[0];
159 	union acpi_operand_object *return_desc1 = NULL;
160 	union acpi_operand_object *return_desc2 = NULL;
161 	acpi_status status;
162 
163 	ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_2T_1R,
164 				acpi_ps_get_opcode_name(walk_state->opcode));
165 
166 	/* Execute the opcode */
167 
168 	switch (walk_state->opcode) {
169 	case AML_DIVIDE_OP:
170 
171 		/* Divide (Dividend, Divisor, remainder_result quotient_result) */
172 
173 		return_desc1 =
174 		    acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
175 		if (!return_desc1) {
176 			status = AE_NO_MEMORY;
177 			goto cleanup;
178 		}
179 
180 		return_desc2 =
181 		    acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
182 		if (!return_desc2) {
183 			status = AE_NO_MEMORY;
184 			goto cleanup;
185 		}
186 
187 		/* Quotient to return_desc1, remainder to return_desc2 */
188 
189 		status = acpi_ut_divide(operand[0]->integer.value,
190 					operand[1]->integer.value,
191 					&return_desc1->integer.value,
192 					&return_desc2->integer.value);
193 		if (ACPI_FAILURE(status)) {
194 			goto cleanup;
195 		}
196 		break;
197 
198 	default:
199 
200 		ACPI_ERROR((AE_INFO, "Unknown AML opcode 0x%X",
201 			    walk_state->opcode));
202 
203 		status = AE_AML_BAD_OPCODE;
204 		goto cleanup;
205 	}
206 
207 	/* Store the results to the target reference operands */
208 
209 	status = acpi_ex_store(return_desc2, operand[2], walk_state);
210 	if (ACPI_FAILURE(status)) {
211 		goto cleanup;
212 	}
213 
214 	status = acpi_ex_store(return_desc1, operand[3], walk_state);
215 	if (ACPI_FAILURE(status)) {
216 		goto cleanup;
217 	}
218 
219 cleanup:
220 	/*
221 	 * Since the remainder is not returned indirectly, remove a reference to
222 	 * it. Only the quotient is returned indirectly.
223 	 */
224 	acpi_ut_remove_reference(return_desc2);
225 
226 	if (ACPI_FAILURE(status)) {
227 
228 		/* Delete the return object */
229 
230 		acpi_ut_remove_reference(return_desc1);
231 	}
232 
233 	/* Save return object (the remainder) on success */
234 
235 	else {
236 		walk_state->result_obj = return_desc1;
237 	}
238 
239 	return_ACPI_STATUS(status);
240 }
241 
242 /*******************************************************************************
243  *
244  * FUNCTION:    acpi_ex_opcode_2A_1T_1R
245  *
246  * PARAMETERS:  walk_state          - Current walk state
247  *
248  * RETURN:      Status
249  *
250  * DESCRIPTION: Execute opcode with two arguments, one target, and a return
251  *              value.
252  *
253  ******************************************************************************/
254 
255 acpi_status acpi_ex_opcode_2A_1T_1R(struct acpi_walk_state *walk_state)
256 {
257 	union acpi_operand_object **operand = &walk_state->operands[0];
258 	union acpi_operand_object *return_desc = NULL;
259 	u64 index;
260 	acpi_status status = AE_OK;
261 	acpi_size length = 0;
262 
263 	ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_1T_1R,
264 				acpi_ps_get_opcode_name(walk_state->opcode));
265 
266 	/* Execute the opcode */
267 
268 	if (walk_state->op_info->flags & AML_MATH) {
269 
270 		/* All simple math opcodes (add, etc.) */
271 
272 		return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
273 		if (!return_desc) {
274 			status = AE_NO_MEMORY;
275 			goto cleanup;
276 		}
277 
278 		return_desc->integer.value =
279 		    acpi_ex_do_math_op(walk_state->opcode,
280 				       operand[0]->integer.value,
281 				       operand[1]->integer.value);
282 		goto store_result_to_target;
283 	}
284 
285 	switch (walk_state->opcode) {
286 	case AML_MOD_OP:	/* Mod (Dividend, Divisor, remainder_result (ACPI 2.0) */
287 
288 		return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
289 		if (!return_desc) {
290 			status = AE_NO_MEMORY;
291 			goto cleanup;
292 		}
293 
294 		/* return_desc will contain the remainder */
295 
296 		status = acpi_ut_divide(operand[0]->integer.value,
297 					operand[1]->integer.value,
298 					NULL, &return_desc->integer.value);
299 		break;
300 
301 	case AML_CONCATENATE_OP:	/* Concatenate (Data1, Data2, Result) */
302 
303 		status =
304 		    acpi_ex_do_concatenate(operand[0], operand[1], &return_desc,
305 					   walk_state);
306 		break;
307 
308 	case AML_TO_STRING_OP:	/* to_string (Buffer, Length, Result) (ACPI 2.0) */
309 		/*
310 		 * Input object is guaranteed to be a buffer at this point (it may have
311 		 * been converted.)  Copy the raw buffer data to a new object of
312 		 * type String.
313 		 */
314 
315 		/*
316 		 * Get the length of the new string. It is the smallest of:
317 		 * 1) Length of the input buffer
318 		 * 2) Max length as specified in the to_string operator
319 		 * 3) Length of input buffer up to a zero byte (null terminator)
320 		 *
321 		 * NOTE: A length of zero is ok, and will create a zero-length, null
322 		 *       terminated string.
323 		 */
324 		while ((length < operand[0]->buffer.length) &&
325 		       (length < operand[1]->integer.value) &&
326 		       (operand[0]->buffer.pointer[length])) {
327 			length++;
328 		}
329 
330 		/* Allocate a new string object */
331 
332 		return_desc = acpi_ut_create_string_object(length);
333 		if (!return_desc) {
334 			status = AE_NO_MEMORY;
335 			goto cleanup;
336 		}
337 
338 		/*
339 		 * Copy the raw buffer data with no transform.
340 		 * (NULL terminated already)
341 		 */
342 		memcpy(return_desc->string.pointer,
343 		       operand[0]->buffer.pointer, length);
344 		break;
345 
346 	case AML_CONCATENATE_TEMPLATE_OP:
347 
348 		/* concatenate_res_template (Buffer, Buffer, Result) (ACPI 2.0) */
349 
350 		status =
351 		    acpi_ex_concat_template(operand[0], operand[1],
352 					    &return_desc, walk_state);
353 		break;
354 
355 	case AML_INDEX_OP:	/* Index (Source Index Result) */
356 
357 		/* Create the internal return object */
358 
359 		return_desc =
360 		    acpi_ut_create_internal_object(ACPI_TYPE_LOCAL_REFERENCE);
361 		if (!return_desc) {
362 			status = AE_NO_MEMORY;
363 			goto cleanup;
364 		}
365 
366 		/* Initialize the Index reference object */
367 
368 		index = operand[1]->integer.value;
369 		return_desc->reference.value = (u32) index;
370 		return_desc->reference.class = ACPI_REFCLASS_INDEX;
371 
372 		/*
373 		 * At this point, the Source operand is a String, Buffer, or Package.
374 		 * Verify that the index is within range.
375 		 */
376 		switch ((operand[0])->common.type) {
377 		case ACPI_TYPE_STRING:
378 
379 			if (index >= operand[0]->string.length) {
380 				length = operand[0]->string.length;
381 				status = AE_AML_STRING_LIMIT;
382 			}
383 
384 			return_desc->reference.target_type =
385 			    ACPI_TYPE_BUFFER_FIELD;
386 			return_desc->reference.index_pointer =
387 			    &(operand[0]->buffer.pointer[index]);
388 			break;
389 
390 		case ACPI_TYPE_BUFFER:
391 
392 			if (index >= operand[0]->buffer.length) {
393 				length = operand[0]->buffer.length;
394 				status = AE_AML_BUFFER_LIMIT;
395 			}
396 
397 			return_desc->reference.target_type =
398 			    ACPI_TYPE_BUFFER_FIELD;
399 			return_desc->reference.index_pointer =
400 			    &(operand[0]->buffer.pointer[index]);
401 			break;
402 
403 		case ACPI_TYPE_PACKAGE:
404 
405 			if (index >= operand[0]->package.count) {
406 				length = operand[0]->package.count;
407 				status = AE_AML_PACKAGE_LIMIT;
408 			}
409 
410 			return_desc->reference.target_type = ACPI_TYPE_PACKAGE;
411 			return_desc->reference.where =
412 			    &operand[0]->package.elements[index];
413 			break;
414 
415 		default:
416 
417 			status = AE_AML_INTERNAL;
418 			goto cleanup;
419 		}
420 
421 		/* Failure means that the Index was beyond the end of the object */
422 
423 		if (ACPI_FAILURE(status)) {
424 			ACPI_EXCEPTION((AE_INFO, status,
425 					"Index (0x%X%8.8X) is beyond end of object (length 0x%X)",
426 					ACPI_FORMAT_UINT64(index),
427 					(u32)length));
428 			goto cleanup;
429 		}
430 
431 		/*
432 		 * Save the target object and add a reference to it for the life
433 		 * of the index
434 		 */
435 		return_desc->reference.object = operand[0];
436 		acpi_ut_add_reference(operand[0]);
437 
438 		/* Store the reference to the Target */
439 
440 		status = acpi_ex_store(return_desc, operand[2], walk_state);
441 
442 		/* Return the reference */
443 
444 		walk_state->result_obj = return_desc;
445 		goto cleanup;
446 
447 	default:
448 
449 		ACPI_ERROR((AE_INFO, "Unknown AML opcode 0x%X",
450 			    walk_state->opcode));
451 		status = AE_AML_BAD_OPCODE;
452 		break;
453 	}
454 
455 store_result_to_target:
456 
457 	if (ACPI_SUCCESS(status)) {
458 		/*
459 		 * Store the result of the operation (which is now in return_desc) into
460 		 * the Target descriptor.
461 		 */
462 		status = acpi_ex_store(return_desc, operand[2], walk_state);
463 		if (ACPI_FAILURE(status)) {
464 			goto cleanup;
465 		}
466 
467 		if (!walk_state->result_obj) {
468 			walk_state->result_obj = return_desc;
469 		}
470 	}
471 
472 cleanup:
473 
474 	/* Delete return object on error */
475 
476 	if (ACPI_FAILURE(status)) {
477 		acpi_ut_remove_reference(return_desc);
478 		walk_state->result_obj = NULL;
479 	}
480 
481 	return_ACPI_STATUS(status);
482 }
483 
484 /*******************************************************************************
485  *
486  * FUNCTION:    acpi_ex_opcode_2A_0T_1R
487  *
488  * PARAMETERS:  walk_state          - Current walk state
489  *
490  * RETURN:      Status
491  *
492  * DESCRIPTION: Execute opcode with 2 arguments, no target, and a return value
493  *
494  ******************************************************************************/
495 
496 acpi_status acpi_ex_opcode_2A_0T_1R(struct acpi_walk_state *walk_state)
497 {
498 	union acpi_operand_object **operand = &walk_state->operands[0];
499 	union acpi_operand_object *return_desc = NULL;
500 	acpi_status status = AE_OK;
501 	u8 logical_result = FALSE;
502 
503 	ACPI_FUNCTION_TRACE_STR(ex_opcode_2A_0T_1R,
504 				acpi_ps_get_opcode_name(walk_state->opcode));
505 
506 	/* Create the internal return object */
507 
508 	return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
509 	if (!return_desc) {
510 		status = AE_NO_MEMORY;
511 		goto cleanup;
512 	}
513 
514 	/* Execute the Opcode */
515 
516 	if (walk_state->op_info->flags & AML_LOGICAL_NUMERIC) {
517 
518 		/* logical_op (Operand0, Operand1) */
519 
520 		status = acpi_ex_do_logical_numeric_op(walk_state->opcode,
521 						       operand[0]->integer.
522 						       value,
523 						       operand[1]->integer.
524 						       value, &logical_result);
525 		goto store_logical_result;
526 	} else if (walk_state->op_info->flags & AML_LOGICAL) {
527 
528 		/* logical_op (Operand0, Operand1) */
529 
530 		status = acpi_ex_do_logical_op(walk_state->opcode, operand[0],
531 					       operand[1], &logical_result);
532 		goto store_logical_result;
533 	}
534 
535 	switch (walk_state->opcode) {
536 	case AML_ACQUIRE_OP:	/* Acquire (mutex_object, Timeout) */
537 
538 		status =
539 		    acpi_ex_acquire_mutex(operand[1], operand[0], walk_state);
540 		if (status == AE_TIME) {
541 			logical_result = TRUE;	/* TRUE = Acquire timed out */
542 			status = AE_OK;
543 		}
544 		break;
545 
546 	case AML_WAIT_OP:	/* Wait (event_object, Timeout) */
547 
548 		status = acpi_ex_system_wait_event(operand[1], operand[0]);
549 		if (status == AE_TIME) {
550 			logical_result = TRUE;	/* TRUE, Wait timed out */
551 			status = AE_OK;
552 		}
553 		break;
554 
555 	default:
556 
557 		ACPI_ERROR((AE_INFO, "Unknown AML opcode 0x%X",
558 			    walk_state->opcode));
559 
560 		status = AE_AML_BAD_OPCODE;
561 		goto cleanup;
562 	}
563 
564 store_logical_result:
565 	/*
566 	 * Set return value to according to logical_result. logical TRUE (all ones)
567 	 * Default is FALSE (zero)
568 	 */
569 	if (logical_result) {
570 		return_desc->integer.value = ACPI_UINT64_MAX;
571 	}
572 
573 cleanup:
574 
575 	/* Delete return object on error */
576 
577 	if (ACPI_FAILURE(status)) {
578 		acpi_ut_remove_reference(return_desc);
579 	}
580 
581 	/* Save return object on success */
582 
583 	else {
584 		walk_state->result_obj = return_desc;
585 	}
586 
587 	return_ACPI_STATUS(status);
588 }
589