Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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