tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1
2/******************************************************************************
3 *
4 * Module Name: exoparg1 - AML execution - opcodes with 1 argument
5 *
6 *****************************************************************************/
7
8/*
9 * Copyright (C) 2000 - 2005, R. Byron Moore
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45#include <acpi/acpi.h>
46#include <acpi/acparser.h>
47#include <acpi/acdispat.h>
48#include <acpi/acinterp.h>
49#include <acpi/amlcode.h>
50#include <acpi/acnamesp.h>
51
52#define _COMPONENT ACPI_EXECUTER
53ACPI_MODULE_NAME("exoparg1")
54
55/*!
56 * Naming convention for AML interpreter execution routines.
57 *
58 * The routines that begin execution of AML opcodes are named with a common
59 * convention based upon the number of arguments, the number of target operands,
60 * and whether or not a value is returned:
61 *
62 * AcpiExOpcode_xA_yT_zR
63 *
64 * Where:
65 *
66 * xA - ARGUMENTS: The number of arguments (input operands) that are
67 * required for this opcode type (0 through 6 args).
68 * yT - TARGETS: The number of targets (output operands) that are required
69 * for this opcode type (0, 1, or 2 targets).
70 * zR - RETURN VALUE: Indicates whether this opcode type returns a value
71 * as the function return (0 or 1).
72 *
73 * The AcpiExOpcode* functions are called via the Dispatcher component with
74 * fully resolved operands.
75!*/
76/*******************************************************************************
77 *
78 * FUNCTION: acpi_ex_opcode_0A_0T_1R
79 *
80 * PARAMETERS: walk_state - Current state (contains AML opcode)
81 *
82 * RETURN: Status
83 *
84 * DESCRIPTION: Execute operator with no operands, one return value
85 *
86 ******************************************************************************/
87acpi_status acpi_ex_opcode_0A_0T_1R(struct acpi_walk_state *walk_state)
88{
89 acpi_status status = AE_OK;
90 union acpi_operand_object *return_desc = NULL;
91
92 ACPI_FUNCTION_TRACE_STR("ex_opcode_0A_0T_1R",
93 acpi_ps_get_opcode_name(walk_state->opcode));
94
95 /* Examine the AML opcode */
96
97 switch (walk_state->opcode) {
98 case AML_TIMER_OP: /* Timer () */
99
100 /* Create a return object of type Integer */
101
102 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
103 if (!return_desc) {
104 status = AE_NO_MEMORY;
105 goto cleanup;
106 }
107#if ACPI_MACHINE_WIDTH != 16
108 return_desc->integer.value = acpi_os_get_timer();
109#endif
110 break;
111
112 default: /* Unknown opcode */
113
114 ACPI_REPORT_ERROR(("acpi_ex_opcode_0A_0T_1R: Unknown opcode %X\n", walk_state->opcode));
115 status = AE_AML_BAD_OPCODE;
116 break;
117 }
118
119 cleanup:
120
121 /* Delete return object on error */
122
123 if ((ACPI_FAILURE(status)) || walk_state->result_obj) {
124 acpi_ut_remove_reference(return_desc);
125 } else {
126 /* Save the return value */
127
128 walk_state->result_obj = return_desc;
129 }
130
131 return_ACPI_STATUS(status);
132}
133
134/*******************************************************************************
135 *
136 * FUNCTION: acpi_ex_opcode_1A_0T_0R
137 *
138 * PARAMETERS: walk_state - Current state (contains AML opcode)
139 *
140 * RETURN: Status
141 *
142 * DESCRIPTION: Execute Type 1 monadic operator with numeric operand on
143 * object stack
144 *
145 ******************************************************************************/
146
147acpi_status acpi_ex_opcode_1A_0T_0R(struct acpi_walk_state *walk_state)
148{
149 union acpi_operand_object **operand = &walk_state->operands[0];
150 acpi_status status = AE_OK;
151
152 ACPI_FUNCTION_TRACE_STR("ex_opcode_1A_0T_0R",
153 acpi_ps_get_opcode_name(walk_state->opcode));
154
155 /* Examine the AML opcode */
156
157 switch (walk_state->opcode) {
158 case AML_RELEASE_OP: /* Release (mutex_object) */
159
160 status = acpi_ex_release_mutex(operand[0], walk_state);
161 break;
162
163 case AML_RESET_OP: /* Reset (event_object) */
164
165 status = acpi_ex_system_reset_event(operand[0]);
166 break;
167
168 case AML_SIGNAL_OP: /* Signal (event_object) */
169
170 status = acpi_ex_system_signal_event(operand[0]);
171 break;
172
173 case AML_SLEEP_OP: /* Sleep (msec_time) */
174
175 status = acpi_ex_system_do_suspend(operand[0]->integer.value);
176 break;
177
178 case AML_STALL_OP: /* Stall (usec_time) */
179
180 status =
181 acpi_ex_system_do_stall((u32) operand[0]->integer.value);
182 break;
183
184 case AML_UNLOAD_OP: /* Unload (Handle) */
185
186 status = acpi_ex_unload_table(operand[0]);
187 break;
188
189 default: /* Unknown opcode */
190
191 ACPI_REPORT_ERROR(("acpi_ex_opcode_1A_0T_0R: Unknown opcode %X\n", walk_state->opcode));
192 status = AE_AML_BAD_OPCODE;
193 break;
194 }
195
196 return_ACPI_STATUS(status);
197}
198
199/*******************************************************************************
200 *
201 * FUNCTION: acpi_ex_opcode_1A_1T_0R
202 *
203 * PARAMETERS: walk_state - Current state (contains AML opcode)
204 *
205 * RETURN: Status
206 *
207 * DESCRIPTION: Execute opcode with one argument, one target, and no
208 * return value.
209 *
210 ******************************************************************************/
211
212acpi_status acpi_ex_opcode_1A_1T_0R(struct acpi_walk_state *walk_state)
213{
214 acpi_status status = AE_OK;
215 union acpi_operand_object **operand = &walk_state->operands[0];
216
217 ACPI_FUNCTION_TRACE_STR("ex_opcode_1A_1T_0R",
218 acpi_ps_get_opcode_name(walk_state->opcode));
219
220 /* Examine the AML opcode */
221
222 switch (walk_state->opcode) {
223 case AML_LOAD_OP:
224
225 status = acpi_ex_load_op(operand[0], operand[1], walk_state);
226 break;
227
228 default: /* Unknown opcode */
229
230 ACPI_REPORT_ERROR(("acpi_ex_opcode_1A_1T_0R: Unknown opcode %X\n", walk_state->opcode));
231 status = AE_AML_BAD_OPCODE;
232 goto cleanup;
233 }
234
235 cleanup:
236
237 return_ACPI_STATUS(status);
238}
239
240/*******************************************************************************
241 *
242 * FUNCTION: acpi_ex_opcode_1A_1T_1R
243 *
244 * PARAMETERS: walk_state - Current state (contains AML opcode)
245 *
246 * RETURN: Status
247 *
248 * DESCRIPTION: Execute opcode with one argument, one target, and a
249 * return value.
250 *
251 ******************************************************************************/
252
253acpi_status acpi_ex_opcode_1A_1T_1R(struct acpi_walk_state *walk_state)
254{
255 acpi_status status = AE_OK;
256 union acpi_operand_object **operand = &walk_state->operands[0];
257 union acpi_operand_object *return_desc = NULL;
258 union acpi_operand_object *return_desc2 = NULL;
259 u32 temp32;
260 u32 i;
261 acpi_integer power_of_ten;
262 acpi_integer digit;
263
264 ACPI_FUNCTION_TRACE_STR("ex_opcode_1A_1T_1R",
265 acpi_ps_get_opcode_name(walk_state->opcode));
266
267 /* Examine the AML opcode */
268
269 switch (walk_state->opcode) {
270 case AML_BIT_NOT_OP:
271 case AML_FIND_SET_LEFT_BIT_OP:
272 case AML_FIND_SET_RIGHT_BIT_OP:
273 case AML_FROM_BCD_OP:
274 case AML_TO_BCD_OP:
275 case AML_COND_REF_OF_OP:
276
277 /* Create a return object of type Integer for these opcodes */
278
279 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
280 if (!return_desc) {
281 status = AE_NO_MEMORY;
282 goto cleanup;
283 }
284
285 switch (walk_state->opcode) {
286 case AML_BIT_NOT_OP: /* Not (Operand, Result) */
287
288 return_desc->integer.value = ~operand[0]->integer.value;
289 break;
290
291 case AML_FIND_SET_LEFT_BIT_OP: /* find_set_left_bit (Operand, Result) */
292
293 return_desc->integer.value = operand[0]->integer.value;
294
295 /*
296 * Acpi specification describes Integer type as a little
297 * endian unsigned value, so this boundary condition is valid.
298 */
299 for (temp32 = 0; return_desc->integer.value &&
300 temp32 < ACPI_INTEGER_BIT_SIZE; ++temp32) {
301 return_desc->integer.value >>= 1;
302 }
303
304 return_desc->integer.value = temp32;
305 break;
306
307 case AML_FIND_SET_RIGHT_BIT_OP: /* find_set_right_bit (Operand, Result) */
308
309 return_desc->integer.value = operand[0]->integer.value;
310
311 /*
312 * The Acpi specification describes Integer type as a little
313 * endian unsigned value, so this boundary condition is valid.
314 */
315 for (temp32 = 0; return_desc->integer.value &&
316 temp32 < ACPI_INTEGER_BIT_SIZE; ++temp32) {
317 return_desc->integer.value <<= 1;
318 }
319
320 /* Since the bit position is one-based, subtract from 33 (65) */
321
322 return_desc->integer.value = temp32 == 0 ? 0 :
323 (ACPI_INTEGER_BIT_SIZE + 1) - temp32;
324 break;
325
326 case AML_FROM_BCD_OP: /* from_bcd (BCDValue, Result) */
327
328 /*
329 * The 64-bit ACPI integer can hold 16 4-bit BCD characters
330 * (if table is 32-bit, integer can hold 8 BCD characters)
331 * Convert each 4-bit BCD value
332 */
333 power_of_ten = 1;
334 return_desc->integer.value = 0;
335 digit = operand[0]->integer.value;
336
337 /* Convert each BCD digit (each is one nybble wide) */
338
339 for (i = 0;
340 (i < acpi_gbl_integer_nybble_width) && (digit > 0);
341 i++) {
342 /* Get the least significant 4-bit BCD digit */
343
344 temp32 = ((u32) digit) & 0xF;
345
346 /* Check the range of the digit */
347
348 if (temp32 > 9) {
349 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
350 "BCD digit too large (not decimal): 0x%X\n",
351 temp32));
352
353 status = AE_AML_NUMERIC_OVERFLOW;
354 goto cleanup;
355 }
356
357 /* Sum the digit into the result with the current power of 10 */
358
359 return_desc->integer.value +=
360 (((acpi_integer) temp32) * power_of_ten);
361
362 /* Shift to next BCD digit */
363
364 digit >>= 4;
365
366 /* Next power of 10 */
367
368 power_of_ten *= 10;
369 }
370 break;
371
372 case AML_TO_BCD_OP: /* to_bcd (Operand, Result) */
373
374 return_desc->integer.value = 0;
375 digit = operand[0]->integer.value;
376
377 /* Each BCD digit is one nybble wide */
378
379 for (i = 0;
380 (i < acpi_gbl_integer_nybble_width) && (digit > 0);
381 i++) {
382 (void)acpi_ut_short_divide(digit, 10, &digit,
383 &temp32);
384
385 /*
386 * Insert the BCD digit that resides in the
387 * remainder from above
388 */
389 return_desc->integer.value |=
390 (((acpi_integer) temp32) << ACPI_MUL_4(i));
391 }
392
393 /* Overflow if there is any data left in Digit */
394
395 if (digit > 0) {
396 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
397 "Integer too large to convert to BCD: %8.8X%8.8X\n",
398 ACPI_FORMAT_UINT64(operand
399 [0]->
400 integer.
401 value)));
402 status = AE_AML_NUMERIC_OVERFLOW;
403 goto cleanup;
404 }
405 break;
406
407 case AML_COND_REF_OF_OP: /* cond_ref_of (source_object, Result) */
408
409 /*
410 * This op is a little strange because the internal return value is
411 * different than the return value stored in the result descriptor
412 * (There are really two return values)
413 */
414 if ((struct acpi_namespace_node *)operand[0] ==
415 acpi_gbl_root_node) {
416 /*
417 * This means that the object does not exist in the namespace,
418 * return FALSE
419 */
420 return_desc->integer.value = 0;
421 goto cleanup;
422 }
423
424 /* Get the object reference, store it, and remove our reference */
425
426 status = acpi_ex_get_object_reference(operand[0],
427 &return_desc2,
428 walk_state);
429 if (ACPI_FAILURE(status)) {
430 goto cleanup;
431 }
432
433 status =
434 acpi_ex_store(return_desc2, operand[1], walk_state);
435 acpi_ut_remove_reference(return_desc2);
436
437 /* The object exists in the namespace, return TRUE */
438
439 return_desc->integer.value = ACPI_INTEGER_MAX;
440 goto cleanup;
441
442 default:
443 /* No other opcodes get here */
444 break;
445 }
446 break;
447
448 case AML_STORE_OP: /* Store (Source, Target) */
449
450 /*
451 * A store operand is typically a number, string, buffer or lvalue
452 * Be careful about deleting the source object,
453 * since the object itself may have been stored.
454 */
455 status = acpi_ex_store(operand[0], operand[1], walk_state);
456 if (ACPI_FAILURE(status)) {
457 return_ACPI_STATUS(status);
458 }
459
460 /* It is possible that the Store already produced a return object */
461
462 if (!walk_state->result_obj) {
463 /*
464 * Normally, we would remove a reference on the Operand[0]
465 * parameter; But since it is being used as the internal return
466 * object (meaning we would normally increment it), the two
467 * cancel out, and we simply don't do anything.
468 */
469 walk_state->result_obj = operand[0];
470 walk_state->operands[0] = NULL; /* Prevent deletion */
471 }
472 return_ACPI_STATUS(status);
473
474 /*
475 * ACPI 2.0 Opcodes
476 */
477 case AML_COPY_OP: /* Copy (Source, Target) */
478
479 status =
480 acpi_ut_copy_iobject_to_iobject(operand[0], &return_desc,
481 walk_state);
482 break;
483
484 case AML_TO_DECSTRING_OP: /* to_decimal_string (Data, Result) */
485
486 status = acpi_ex_convert_to_string(operand[0], &return_desc,
487 ACPI_EXPLICIT_CONVERT_DECIMAL);
488 if (return_desc == operand[0]) {
489 /* No conversion performed, add ref to handle return value */
490 acpi_ut_add_reference(return_desc);
491 }
492 break;
493
494 case AML_TO_HEXSTRING_OP: /* to_hex_string (Data, Result) */
495
496 status = acpi_ex_convert_to_string(operand[0], &return_desc,
497 ACPI_EXPLICIT_CONVERT_HEX);
498 if (return_desc == operand[0]) {
499 /* No conversion performed, add ref to handle return value */
500 acpi_ut_add_reference(return_desc);
501 }
502 break;
503
504 case AML_TO_BUFFER_OP: /* to_buffer (Data, Result) */
505
506 status = acpi_ex_convert_to_buffer(operand[0], &return_desc);
507 if (return_desc == operand[0]) {
508 /* No conversion performed, add ref to handle return value */
509 acpi_ut_add_reference(return_desc);
510 }
511 break;
512
513 case AML_TO_INTEGER_OP: /* to_integer (Data, Result) */
514
515 status = acpi_ex_convert_to_integer(operand[0], &return_desc,
516 ACPI_ANY_BASE);
517 if (return_desc == operand[0]) {
518 /* No conversion performed, add ref to handle return value */
519 acpi_ut_add_reference(return_desc);
520 }
521 break;
522
523 case AML_SHIFT_LEFT_BIT_OP: /* shift_left_bit (Source, bit_num) */
524 case AML_SHIFT_RIGHT_BIT_OP: /* shift_right_bit (Source, bit_num) */
525
526 /* These are two obsolete opcodes */
527
528 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
529 "%s is obsolete and not implemented\n",
530 acpi_ps_get_opcode_name(walk_state->opcode)));
531 status = AE_SUPPORT;
532 goto cleanup;
533
534 default: /* Unknown opcode */
535
536 ACPI_REPORT_ERROR(("acpi_ex_opcode_1A_1T_1R: Unknown opcode %X\n", walk_state->opcode));
537 status = AE_AML_BAD_OPCODE;
538 goto cleanup;
539 }
540
541 if (ACPI_SUCCESS(status)) {
542 /* Store the return value computed above into the target object */
543
544 status = acpi_ex_store(return_desc, operand[1], walk_state);
545 }
546
547 cleanup:
548
549 if (!walk_state->result_obj) {
550 walk_state->result_obj = return_desc;
551 }
552
553 /* Delete return object on error */
554
555 if (ACPI_FAILURE(status)) {
556 acpi_ut_remove_reference(return_desc);
557 }
558
559 return_ACPI_STATUS(status);
560}
561
562/*******************************************************************************
563 *
564 * FUNCTION: acpi_ex_opcode_1A_0T_1R
565 *
566 * PARAMETERS: walk_state - Current state (contains AML opcode)
567 *
568 * RETURN: Status
569 *
570 * DESCRIPTION: Execute opcode with one argument, no target, and a return value
571 *
572 ******************************************************************************/
573
574acpi_status acpi_ex_opcode_1A_0T_1R(struct acpi_walk_state *walk_state)
575{
576 union acpi_operand_object **operand = &walk_state->operands[0];
577 union acpi_operand_object *temp_desc;
578 union acpi_operand_object *return_desc = NULL;
579 acpi_status status = AE_OK;
580 u32 type;
581 acpi_integer value;
582
583 ACPI_FUNCTION_TRACE_STR("ex_opcode_1A_0T_1R",
584 acpi_ps_get_opcode_name(walk_state->opcode));
585
586 /* Examine the AML opcode */
587
588 switch (walk_state->opcode) {
589 case AML_LNOT_OP: /* LNot (Operand) */
590
591 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
592 if (!return_desc) {
593 status = AE_NO_MEMORY;
594 goto cleanup;
595 }
596
597 /*
598 * Set result to ONES (TRUE) if Value == 0. Note:
599 * return_desc->Integer.Value is initially == 0 (FALSE) from above.
600 */
601 if (!operand[0]->integer.value) {
602 return_desc->integer.value = ACPI_INTEGER_MAX;
603 }
604 break;
605
606 case AML_DECREMENT_OP: /* Decrement (Operand) */
607 case AML_INCREMENT_OP: /* Increment (Operand) */
608
609 /*
610 * Create a new integer. Can't just get the base integer and
611 * increment it because it may be an Arg or Field.
612 */
613 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
614 if (!return_desc) {
615 status = AE_NO_MEMORY;
616 goto cleanup;
617 }
618
619 /*
620 * Since we are expecting a Reference operand, it can be either a
621 * NS Node or an internal object.
622 */
623 temp_desc = operand[0];
624 if (ACPI_GET_DESCRIPTOR_TYPE(temp_desc) ==
625 ACPI_DESC_TYPE_OPERAND) {
626 /* Internal reference object - prevent deletion */
627
628 acpi_ut_add_reference(temp_desc);
629 }
630
631 /*
632 * Convert the Reference operand to an Integer (This removes a
633 * reference on the Operand[0] object)
634 *
635 * NOTE: We use LNOT_OP here in order to force resolution of the
636 * reference operand to an actual integer.
637 */
638 status =
639 acpi_ex_resolve_operands(AML_LNOT_OP, &temp_desc,
640 walk_state);
641 if (ACPI_FAILURE(status)) {
642 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
643 "%s: bad operand(s) %s\n",
644 acpi_ps_get_opcode_name(walk_state->
645 opcode),
646 acpi_format_exception(status)));
647
648 goto cleanup;
649 }
650
651 /*
652 * temp_desc is now guaranteed to be an Integer object --
653 * Perform the actual increment or decrement
654 */
655 if (walk_state->opcode == AML_INCREMENT_OP) {
656 return_desc->integer.value =
657 temp_desc->integer.value + 1;
658 } else {
659 return_desc->integer.value =
660 temp_desc->integer.value - 1;
661 }
662
663 /* Finished with this Integer object */
664
665 acpi_ut_remove_reference(temp_desc);
666
667 /*
668 * Store the result back (indirectly) through the original
669 * Reference object
670 */
671 status = acpi_ex_store(return_desc, operand[0], walk_state);
672 break;
673
674 case AML_TYPE_OP: /* object_type (source_object) */
675
676 /*
677 * Note: The operand is not resolved at this point because we want to
678 * get the associated object, not its value. For example, we don't
679 * want to resolve a field_unit to its value, we want the actual
680 * field_unit object.
681 */
682
683 /* Get the type of the base object */
684
685 status =
686 acpi_ex_resolve_multiple(walk_state, operand[0], &type,
687 NULL);
688 if (ACPI_FAILURE(status)) {
689 goto cleanup;
690 }
691 /* Allocate a descriptor to hold the type. */
692
693 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
694 if (!return_desc) {
695 status = AE_NO_MEMORY;
696 goto cleanup;
697 }
698
699 return_desc->integer.value = type;
700 break;
701
702 case AML_SIZE_OF_OP: /* size_of (source_object) */
703
704 /*
705 * Note: The operand is not resolved at this point because we want to
706 * get the associated object, not its value.
707 */
708
709 /* Get the base object */
710
711 status = acpi_ex_resolve_multiple(walk_state,
712 operand[0], &type,
713 &temp_desc);
714 if (ACPI_FAILURE(status)) {
715 goto cleanup;
716 }
717
718 /*
719 * The type of the base object must be integer, buffer, string, or
720 * package. All others are not supported.
721 *
722 * NOTE: Integer is not specifically supported by the ACPI spec,
723 * but is supported implicitly via implicit operand conversion.
724 * rather than bother with conversion, we just use the byte width
725 * global (4 or 8 bytes).
726 */
727 switch (type) {
728 case ACPI_TYPE_INTEGER:
729 value = acpi_gbl_integer_byte_width;
730 break;
731
732 case ACPI_TYPE_BUFFER:
733 value = temp_desc->buffer.length;
734 break;
735
736 case ACPI_TYPE_STRING:
737 value = temp_desc->string.length;
738 break;
739
740 case ACPI_TYPE_PACKAGE:
741 value = temp_desc->package.count;
742 break;
743
744 default:
745 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
746 "size_of - Operand is not Buf/Int/Str/Pkg - found type %s\n",
747 acpi_ut_get_type_name(type)));
748 status = AE_AML_OPERAND_TYPE;
749 goto cleanup;
750 }
751
752 /*
753 * Now that we have the size of the object, create a result
754 * object to hold the value
755 */
756 return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
757 if (!return_desc) {
758 status = AE_NO_MEMORY;
759 goto cleanup;
760 }
761
762 return_desc->integer.value = value;
763 break;
764
765 case AML_REF_OF_OP: /* ref_of (source_object) */
766
767 status =
768 acpi_ex_get_object_reference(operand[0], &return_desc,
769 walk_state);
770 if (ACPI_FAILURE(status)) {
771 goto cleanup;
772 }
773 break;
774
775 case AML_DEREF_OF_OP: /* deref_of (obj_reference | String) */
776
777 /* Check for a method local or argument, or standalone String */
778
779 if (ACPI_GET_DESCRIPTOR_TYPE(operand[0]) !=
780 ACPI_DESC_TYPE_NAMED) {
781 switch (ACPI_GET_OBJECT_TYPE(operand[0])) {
782 case ACPI_TYPE_LOCAL_REFERENCE:
783 /*
784 * This is a deref_of (local_x | arg_x)
785 *
786 * Must resolve/dereference the local/arg reference first
787 */
788 switch (operand[0]->reference.opcode) {
789 case AML_LOCAL_OP:
790 case AML_ARG_OP:
791
792 /* Set Operand[0] to the value of the local/arg */
793
794 status =
795 acpi_ds_method_data_get_value
796 (operand[0]->reference.opcode,
797 operand[0]->reference.offset,
798 walk_state, &temp_desc);
799 if (ACPI_FAILURE(status)) {
800 goto cleanup;
801 }
802
803 /*
804 * Delete our reference to the input object and
805 * point to the object just retrieved
806 */
807 acpi_ut_remove_reference(operand[0]);
808 operand[0] = temp_desc;
809 break;
810
811 case AML_REF_OF_OP:
812
813 /* Get the object to which the reference refers */
814
815 temp_desc =
816 operand[0]->reference.object;
817 acpi_ut_remove_reference(operand[0]);
818 operand[0] = temp_desc;
819 break;
820
821 default:
822
823 /* Must be an Index op - handled below */
824 break;
825 }
826 break;
827
828 case ACPI_TYPE_STRING:
829
830 /*
831 * This is a deref_of (String). The string is a reference
832 * to a named ACPI object.
833 *
834 * 1) Find the owning Node
835 * 2) Dereference the node to an actual object. Could be a
836 * Field, so we need to resolve the node to a value.
837 */
838 status =
839 acpi_ns_get_node_by_path(operand[0]->string.
840 pointer,
841 walk_state->
842 scope_info->scope.
843 node,
844 ACPI_NS_SEARCH_PARENT,
845 ACPI_CAST_INDIRECT_PTR
846 (struct
847 acpi_namespace_node,
848 &return_desc));
849 if (ACPI_FAILURE(status)) {
850 goto cleanup;
851 }
852
853 status =
854 acpi_ex_resolve_node_to_value
855 (ACPI_CAST_INDIRECT_PTR
856 (struct acpi_namespace_node, &return_desc),
857 walk_state);
858 goto cleanup;
859
860 default:
861
862 status = AE_AML_OPERAND_TYPE;
863 goto cleanup;
864 }
865 }
866
867 /* Operand[0] may have changed from the code above */
868
869 if (ACPI_GET_DESCRIPTOR_TYPE(operand[0]) ==
870 ACPI_DESC_TYPE_NAMED) {
871 /*
872 * This is a deref_of (object_reference)
873 * Get the actual object from the Node (This is the dereference).
874 * This case may only happen when a local_x or arg_x is
875 * dereferenced above.
876 */
877 return_desc = acpi_ns_get_attached_object((struct
878 acpi_namespace_node
879 *)
880 operand[0]);
881 acpi_ut_add_reference(return_desc);
882 } else {
883 /*
884 * This must be a reference object produced by either the
885 * Index() or ref_of() operator
886 */
887 switch (operand[0]->reference.opcode) {
888 case AML_INDEX_OP:
889
890 /*
891 * The target type for the Index operator must be
892 * either a Buffer or a Package
893 */
894 switch (operand[0]->reference.target_type) {
895 case ACPI_TYPE_BUFFER_FIELD:
896
897 temp_desc =
898 operand[0]->reference.object;
899
900 /*
901 * Create a new object that contains one element of the
902 * buffer -- the element pointed to by the index.
903 *
904 * NOTE: index into a buffer is NOT a pointer to a
905 * sub-buffer of the main buffer, it is only a pointer to a
906 * single element (byte) of the buffer!
907 */
908 return_desc =
909 acpi_ut_create_internal_object
910 (ACPI_TYPE_INTEGER);
911 if (!return_desc) {
912 status = AE_NO_MEMORY;
913 goto cleanup;
914 }
915
916 /*
917 * Since we are returning the value of the buffer at the
918 * indexed location, we don't need to add an additional
919 * reference to the buffer itself.
920 */
921 return_desc->integer.value =
922 temp_desc->buffer.
923 pointer[operand[0]->reference.
924 offset];
925 break;
926
927 case ACPI_TYPE_PACKAGE:
928
929 /*
930 * Return the referenced element of the package. We must
931 * add another reference to the referenced object, however.
932 */
933 return_desc =
934 *(operand[0]->reference.where);
935 if (return_desc) {
936 acpi_ut_add_reference
937 (return_desc);
938 }
939
940 break;
941
942 default:
943
944 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
945 "Unknown Index target_type %X in obj %p\n",
946 operand[0]->reference.
947 target_type,
948 operand[0]));
949 status = AE_AML_OPERAND_TYPE;
950 goto cleanup;
951 }
952 break;
953
954 case AML_REF_OF_OP:
955
956 return_desc = operand[0]->reference.object;
957
958 if (ACPI_GET_DESCRIPTOR_TYPE(return_desc) ==
959 ACPI_DESC_TYPE_NAMED) {
960
961 return_desc =
962 acpi_ns_get_attached_object((struct
963 acpi_namespace_node
964 *)
965 return_desc);
966 }
967
968 /* Add another reference to the object! */
969
970 acpi_ut_add_reference(return_desc);
971 break;
972
973 default:
974 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
975 "Unknown opcode in ref(%p) - %X\n",
976 operand[0],
977 operand[0]->reference.
978 opcode));
979
980 status = AE_TYPE;
981 goto cleanup;
982 }
983 }
984 break;
985
986 default:
987
988 ACPI_REPORT_ERROR(("acpi_ex_opcode_1A_0T_1R: Unknown opcode %X\n", walk_state->opcode));
989 status = AE_AML_BAD_OPCODE;
990 goto cleanup;
991 }
992
993 cleanup:
994
995 /* Delete return object on error */
996
997 if (ACPI_FAILURE(status)) {
998 acpi_ut_remove_reference(return_desc);
999 }
1000
1001 walk_state->result_obj = return_desc;
1002 return_ACPI_STATUS(status);
1003}