[ACPICA] Update to version 20171215. CORE-15222
[reactos.git] / drivers / bus / acpi / acpica / dispatcher / dsobject.c
1 /******************************************************************************
2 *
3 * Module Name: dsobject - Dispatcher object management routines
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.h"
45 #include "accommon.h"
46 #include "acparser.h"
47 #include "amlcode.h"
48 #include "acdispat.h"
49 #include "acnamesp.h"
50 #include "acinterp.h"
51
52 #define _COMPONENT ACPI_DISPATCHER
53 ACPI_MODULE_NAME ("dsobject")
54
55
56 #ifndef ACPI_NO_METHOD_EXECUTION
57 /*******************************************************************************
58 *
59 * FUNCTION: AcpiDsBuildInternalObject
60 *
61 * PARAMETERS: WalkState - Current walk state
62 * Op - Parser object to be translated
63 * ObjDescPtr - Where the ACPI internal object is returned
64 *
65 * RETURN: Status
66 *
67 * DESCRIPTION: Translate a parser Op object to the equivalent namespace object
68 * Simple objects are any objects other than a package object!
69 *
70 ******************************************************************************/
71
72 ACPI_STATUS
73 AcpiDsBuildInternalObject (
74 ACPI_WALK_STATE *WalkState,
75 ACPI_PARSE_OBJECT *Op,
76 ACPI_OPERAND_OBJECT **ObjDescPtr)
77 {
78 ACPI_OPERAND_OBJECT *ObjDesc;
79 ACPI_STATUS Status;
80
81
82 ACPI_FUNCTION_TRACE (DsBuildInternalObject);
83
84
85 *ObjDescPtr = NULL;
86 if (Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP)
87 {
88 /*
89 * This is a named object reference. If this name was
90 * previously looked up in the namespace, it was stored in
91 * this op. Otherwise, go ahead and look it up now
92 */
93 if (!Op->Common.Node)
94 {
95 /* Check if we are resolving a named reference within a package */
96
97 if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
98 (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
99 {
100 /*
101 * We won't resolve package elements here, we will do this
102 * after all ACPI tables are loaded into the namespace. This
103 * behavior supports both forward references to named objects
104 * and external references to objects in other tables.
105 */
106 goto CreateNewObject;
107 }
108 else
109 {
110 Status = AcpiNsLookup (WalkState->ScopeInfo,
111 Op->Common.Value.String,
112 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
113 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL,
114 ACPI_CAST_INDIRECT_PTR (
115 ACPI_NAMESPACE_NODE, &(Op->Common.Node)));
116 if (ACPI_FAILURE (Status))
117 {
118 ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo,
119 Op->Common.Value.String, Status);
120 return_ACPI_STATUS (Status);
121 }
122 }
123 }
124 }
125
126 CreateNewObject:
127
128 /* Create and init a new internal ACPI object */
129
130 ObjDesc = AcpiUtCreateInternalObject (
131 (AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode))->ObjectType);
132 if (!ObjDesc)
133 {
134 return_ACPI_STATUS (AE_NO_MEMORY);
135 }
136
137 Status = AcpiDsInitObjectFromOp (
138 WalkState, Op, Op->Common.AmlOpcode, &ObjDesc);
139 if (ACPI_FAILURE (Status))
140 {
141 AcpiUtRemoveReference (ObjDesc);
142 return_ACPI_STATUS (Status);
143 }
144
145 /*
146 * Handling for unresolved package reference elements.
147 * These are elements that are namepaths.
148 */
149 if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
150 (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
151 {
152 ObjDesc->Reference.Resolved = TRUE;
153
154 if ((Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
155 !ObjDesc->Reference.Node)
156 {
157 /*
158 * Name was unresolved above.
159 * Get the prefix node for later lookup
160 */
161 ObjDesc->Reference.Node = WalkState->ScopeInfo->Scope.Node;
162 ObjDesc->Reference.Aml = Op->Common.Aml;
163 ObjDesc->Reference.Resolved = FALSE;
164 }
165 }
166
167 *ObjDescPtr = ObjDesc;
168 return_ACPI_STATUS (Status);
169 }
170
171
172 /*******************************************************************************
173 *
174 * FUNCTION: AcpiDsBuildInternalBufferObj
175 *
176 * PARAMETERS: WalkState - Current walk state
177 * Op - Parser object to be translated
178 * BufferLength - Length of the buffer
179 * ObjDescPtr - Where the ACPI internal object is returned
180 *
181 * RETURN: Status
182 *
183 * DESCRIPTION: Translate a parser Op package object to the equivalent
184 * namespace object
185 *
186 ******************************************************************************/
187
188 ACPI_STATUS
189 AcpiDsBuildInternalBufferObj (
190 ACPI_WALK_STATE *WalkState,
191 ACPI_PARSE_OBJECT *Op,
192 UINT32 BufferLength,
193 ACPI_OPERAND_OBJECT **ObjDescPtr)
194 {
195 ACPI_PARSE_OBJECT *Arg;
196 ACPI_OPERAND_OBJECT *ObjDesc;
197 ACPI_PARSE_OBJECT *ByteList;
198 UINT32 ByteListLength = 0;
199
200
201 ACPI_FUNCTION_TRACE (DsBuildInternalBufferObj);
202
203
204 /*
205 * If we are evaluating a Named buffer object "Name (xxxx, Buffer)".
206 * The buffer object already exists (from the NS node), otherwise it must
207 * be created.
208 */
209 ObjDesc = *ObjDescPtr;
210 if (!ObjDesc)
211 {
212 /* Create a new buffer object */
213
214 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
215 *ObjDescPtr = ObjDesc;
216 if (!ObjDesc)
217 {
218 return_ACPI_STATUS (AE_NO_MEMORY);
219 }
220 }
221
222 /*
223 * Second arg is the buffer data (optional) ByteList can be either
224 * individual bytes or a string initializer. In either case, a
225 * ByteList appears in the AML.
226 */
227 Arg = Op->Common.Value.Arg; /* skip first arg */
228
229 ByteList = Arg->Named.Next;
230 if (ByteList)
231 {
232 if (ByteList->Common.AmlOpcode != AML_INT_BYTELIST_OP)
233 {
234 ACPI_ERROR ((AE_INFO,
235 "Expecting bytelist, found AML opcode 0x%X in op %p",
236 ByteList->Common.AmlOpcode, ByteList));
237
238 AcpiUtRemoveReference (ObjDesc);
239 return (AE_TYPE);
240 }
241
242 ByteListLength = (UINT32) ByteList->Common.Value.Integer;
243 }
244
245 /*
246 * The buffer length (number of bytes) will be the larger of:
247 * 1) The specified buffer length and
248 * 2) The length of the initializer byte list
249 */
250 ObjDesc->Buffer.Length = BufferLength;
251 if (ByteListLength > BufferLength)
252 {
253 ObjDesc->Buffer.Length = ByteListLength;
254 }
255
256 /* Allocate the buffer */
257
258 if (ObjDesc->Buffer.Length == 0)
259 {
260 ObjDesc->Buffer.Pointer = NULL;
261 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
262 "Buffer defined with zero length in AML, creating\n"));
263 }
264 else
265 {
266 ObjDesc->Buffer.Pointer =
267 ACPI_ALLOCATE_ZEROED (ObjDesc->Buffer.Length);
268 if (!ObjDesc->Buffer.Pointer)
269 {
270 AcpiUtDeleteObjectDesc (ObjDesc);
271 return_ACPI_STATUS (AE_NO_MEMORY);
272 }
273
274 /* Initialize buffer from the ByteList (if present) */
275
276 if (ByteList)
277 {
278 memcpy (ObjDesc->Buffer.Pointer, ByteList->Named.Data,
279 ByteListLength);
280 }
281 }
282
283 ObjDesc->Buffer.Flags |= AOPOBJ_DATA_VALID;
284 Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc);
285 return_ACPI_STATUS (AE_OK);
286 }
287
288 /*******************************************************************************
289 *
290 * FUNCTION: AcpiDsCreateNode
291 *
292 * PARAMETERS: WalkState - Current walk state
293 * Node - NS Node to be initialized
294 * Op - Parser object to be translated
295 *
296 * RETURN: Status
297 *
298 * DESCRIPTION: Create the object to be associated with a namespace node
299 *
300 ******************************************************************************/
301
302 ACPI_STATUS
303 AcpiDsCreateNode (
304 ACPI_WALK_STATE *WalkState,
305 ACPI_NAMESPACE_NODE *Node,
306 ACPI_PARSE_OBJECT *Op)
307 {
308 ACPI_STATUS Status;
309 ACPI_OPERAND_OBJECT *ObjDesc;
310
311
312 ACPI_FUNCTION_TRACE_PTR (DsCreateNode, Op);
313
314
315 /*
316 * Because of the execution pass through the non-control-method
317 * parts of the table, we can arrive here twice. Only init
318 * the named object node the first time through
319 */
320 if (AcpiNsGetAttachedObject (Node))
321 {
322 return_ACPI_STATUS (AE_OK);
323 }
324
325 if (!Op->Common.Value.Arg)
326 {
327 /* No arguments, there is nothing to do */
328
329 return_ACPI_STATUS (AE_OK);
330 }
331
332 /* Build an internal object for the argument(s) */
333
334 Status = AcpiDsBuildInternalObject (
335 WalkState, Op->Common.Value.Arg, &ObjDesc);
336 if (ACPI_FAILURE (Status))
337 {
338 return_ACPI_STATUS (Status);
339 }
340
341 /* Re-type the object according to its argument */
342
343 Node->Type = ObjDesc->Common.Type;
344
345 /* Attach obj to node */
346
347 Status = AcpiNsAttachObject (Node, ObjDesc, Node->Type);
348
349 /* Remove local reference to the object */
350
351 AcpiUtRemoveReference (ObjDesc);
352 return_ACPI_STATUS (Status);
353 }
354
355 #endif /* ACPI_NO_METHOD_EXECUTION */
356
357
358 /*******************************************************************************
359 *
360 * FUNCTION: AcpiDsInitObjectFromOp
361 *
362 * PARAMETERS: WalkState - Current walk state
363 * Op - Parser op used to init the internal object
364 * Opcode - AML opcode associated with the object
365 * RetObjDesc - Namespace object to be initialized
366 *
367 * RETURN: Status
368 *
369 * DESCRIPTION: Initialize a namespace object from a parser Op and its
370 * associated arguments. The namespace object is a more compact
371 * representation of the Op and its arguments.
372 *
373 ******************************************************************************/
374
375 ACPI_STATUS
376 AcpiDsInitObjectFromOp (
377 ACPI_WALK_STATE *WalkState,
378 ACPI_PARSE_OBJECT *Op,
379 UINT16 Opcode,
380 ACPI_OPERAND_OBJECT **RetObjDesc)
381 {
382 const ACPI_OPCODE_INFO *OpInfo;
383 ACPI_OPERAND_OBJECT *ObjDesc;
384 ACPI_STATUS Status = AE_OK;
385
386
387 ACPI_FUNCTION_TRACE (DsInitObjectFromOp);
388
389
390 ObjDesc = *RetObjDesc;
391 OpInfo = AcpiPsGetOpcodeInfo (Opcode);
392 if (OpInfo->Class == AML_CLASS_UNKNOWN)
393 {
394 /* Unknown opcode */
395
396 return_ACPI_STATUS (AE_TYPE);
397 }
398
399 /* Perform per-object initialization */
400
401 switch (ObjDesc->Common.Type)
402 {
403 case ACPI_TYPE_BUFFER:
404 /*
405 * Defer evaluation of Buffer TermArg operand
406 */
407 ObjDesc->Buffer.Node = ACPI_CAST_PTR (
408 ACPI_NAMESPACE_NODE, WalkState->Operands[0]);
409 ObjDesc->Buffer.AmlStart = Op->Named.Data;
410 ObjDesc->Buffer.AmlLength = Op->Named.Length;
411 break;
412
413 case ACPI_TYPE_PACKAGE:
414 /*
415 * Defer evaluation of Package TermArg operand and all
416 * package elements. (01/2017): We defer the element
417 * resolution to allow forward references from the package
418 * in order to provide compatibility with other ACPI
419 * implementations.
420 */
421 ObjDesc->Package.Node = ACPI_CAST_PTR (
422 ACPI_NAMESPACE_NODE, WalkState->Operands[0]);
423
424 if (!Op->Named.Data)
425 {
426 return_ACPI_STATUS (AE_OK);
427 }
428
429 ObjDesc->Package.AmlStart = Op->Named.Data;
430 ObjDesc->Package.AmlLength = Op->Named.Length;
431 break;
432
433 case ACPI_TYPE_INTEGER:
434
435 switch (OpInfo->Type)
436 {
437 case AML_TYPE_CONSTANT:
438 /*
439 * Resolve AML Constants here - AND ONLY HERE!
440 * All constants are integers.
441 * We mark the integer with a flag that indicates that it started
442 * life as a constant -- so that stores to constants will perform
443 * as expected (noop). ZeroOp is used as a placeholder for optional
444 * target operands.
445 */
446 ObjDesc->Common.Flags = AOPOBJ_AML_CONSTANT;
447
448 switch (Opcode)
449 {
450 case AML_ZERO_OP:
451
452 ObjDesc->Integer.Value = 0;
453 break;
454
455 case AML_ONE_OP:
456
457 ObjDesc->Integer.Value = 1;
458 break;
459
460 case AML_ONES_OP:
461
462 ObjDesc->Integer.Value = ACPI_UINT64_MAX;
463
464 /* Truncate value if we are executing from a 32-bit ACPI table */
465
466 #ifndef ACPI_NO_METHOD_EXECUTION
467 (void) AcpiExTruncateFor32bitTable (ObjDesc);
468 #endif
469 break;
470
471 case AML_REVISION_OP:
472
473 ObjDesc->Integer.Value = ACPI_CA_VERSION;
474 break;
475
476 default:
477
478 ACPI_ERROR ((AE_INFO,
479 "Unknown constant opcode 0x%X", Opcode));
480 Status = AE_AML_OPERAND_TYPE;
481 break;
482 }
483 break;
484
485 case AML_TYPE_LITERAL:
486
487 ObjDesc->Integer.Value = Op->Common.Value.Integer;
488
489 #ifndef ACPI_NO_METHOD_EXECUTION
490 if (AcpiExTruncateFor32bitTable (ObjDesc))
491 {
492 /* Warn if we found a 64-bit constant in a 32-bit table */
493
494 ACPI_WARNING ((AE_INFO,
495 "Truncated 64-bit constant found in 32-bit table: %8.8X%8.8X => %8.8X",
496 ACPI_FORMAT_UINT64 (Op->Common.Value.Integer),
497 (UINT32) ObjDesc->Integer.Value));
498 }
499 #endif
500 break;
501
502 default:
503
504 ACPI_ERROR ((AE_INFO, "Unknown Integer type 0x%X",
505 OpInfo->Type));
506 Status = AE_AML_OPERAND_TYPE;
507 break;
508 }
509 break;
510
511 case ACPI_TYPE_STRING:
512
513 ObjDesc->String.Pointer = Op->Common.Value.String;
514 ObjDesc->String.Length = (UINT32) strlen (Op->Common.Value.String);
515
516 /*
517 * The string is contained in the ACPI table, don't ever try
518 * to delete it
519 */
520 ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER;
521 break;
522
523 case ACPI_TYPE_METHOD:
524 break;
525
526 case ACPI_TYPE_LOCAL_REFERENCE:
527
528 switch (OpInfo->Type)
529 {
530 case AML_TYPE_LOCAL_VARIABLE:
531
532 /* Local ID (0-7) is (AML opcode - base AML_FIRST_LOCAL_OP) */
533
534 ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_FIRST_LOCAL_OP;
535 ObjDesc->Reference.Class = ACPI_REFCLASS_LOCAL;
536
537 #ifndef ACPI_NO_METHOD_EXECUTION
538 Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_LOCAL,
539 ObjDesc->Reference.Value, WalkState,
540 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE,
541 &ObjDesc->Reference.Object));
542 #endif
543 break;
544
545 case AML_TYPE_METHOD_ARGUMENT:
546
547 /* Arg ID (0-6) is (AML opcode - base AML_FIRST_ARG_OP) */
548
549 ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_FIRST_ARG_OP;
550 ObjDesc->Reference.Class = ACPI_REFCLASS_ARG;
551
552 #ifndef ACPI_NO_METHOD_EXECUTION
553 Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_ARG,
554 ObjDesc->Reference.Value, WalkState,
555 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE,
556 &ObjDesc->Reference.Object));
557 #endif
558 break;
559
560 default: /* Object name or Debug object */
561
562 switch (Op->Common.AmlOpcode)
563 {
564 case AML_INT_NAMEPATH_OP:
565
566 /* Node was saved in Op */
567
568 ObjDesc->Reference.Node = Op->Common.Node;
569 ObjDesc->Reference.Class = ACPI_REFCLASS_NAME;
570 if (Op->Common.Node)
571 {
572 ObjDesc->Reference.Object = Op->Common.Node->Object;
573 }
574 break;
575
576 case AML_DEBUG_OP:
577
578 ObjDesc->Reference.Class = ACPI_REFCLASS_DEBUG;
579 break;
580
581 default:
582
583 ACPI_ERROR ((AE_INFO,
584 "Unimplemented reference type for AML opcode: 0x%4.4X", Opcode));
585 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
586 }
587 break;
588 }
589 break;
590
591 default:
592
593 ACPI_ERROR ((AE_INFO, "Unimplemented data type: 0x%X",
594 ObjDesc->Common.Type));
595
596 Status = AE_AML_OPERAND_TYPE;
597 break;
598 }
599
600 return_ACPI_STATUS (Status);
601 }