1 /******************************************************************************
3 * Module Name: utobject - ACPI object create/delete/size/cache routines
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2014, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #define __UTOBJECT_C__
46 #include <contrib/dev/acpica/include/acpi.h>
47 #include <contrib/dev/acpica/include/accommon.h>
48 #include <contrib/dev/acpica/include/acnamesp.h>
51 #define _COMPONENT ACPI_UTILITIES
52 ACPI_MODULE_NAME ("utobject")
54 /* Local prototypes */
57 AcpiUtGetSimpleObjectSize (
58 ACPI_OPERAND_OBJECT *Obj,
59 ACPI_SIZE *ObjLength);
62 AcpiUtGetPackageObjectSize (
63 ACPI_OPERAND_OBJECT *Obj,
64 ACPI_SIZE *ObjLength);
67 AcpiUtGetElementLength (
69 ACPI_OPERAND_OBJECT *SourceObject,
70 ACPI_GENERIC_STATE *State,
74 /*******************************************************************************
76 * FUNCTION: AcpiUtCreateInternalObjectDbg
78 * PARAMETERS: ModuleName - Source file name of caller
79 * LineNumber - Line number of caller
80 * ComponentId - Component type of caller
81 * Type - ACPI Type of the new object
83 * RETURN: A new internal object, null on failure
85 * DESCRIPTION: Create and initialize a new internal object.
87 * NOTE: We always allocate the worst-case object descriptor because
88 * these objects are cached, and we want them to be
89 * one-size-satisifies-any-request. This in itself may not be
90 * the most memory efficient, but the efficiency of the object
91 * cache should more than make up for this!
93 ******************************************************************************/
96 AcpiUtCreateInternalObjectDbg (
97 const char *ModuleName,
100 ACPI_OBJECT_TYPE Type)
102 ACPI_OPERAND_OBJECT *Object;
103 ACPI_OPERAND_OBJECT *SecondObject;
106 ACPI_FUNCTION_TRACE_STR (UtCreateInternalObjectDbg,
107 AcpiUtGetTypeName (Type));
110 /* Allocate the raw object descriptor */
112 Object = AcpiUtAllocateObjectDescDbg (ModuleName, LineNumber, ComponentId);
120 case ACPI_TYPE_REGION:
121 case ACPI_TYPE_BUFFER_FIELD:
122 case ACPI_TYPE_LOCAL_BANK_FIELD:
124 /* These types require a secondary object */
126 SecondObject = AcpiUtAllocateObjectDescDbg (ModuleName,
127 LineNumber, ComponentId);
130 AcpiUtDeleteObjectDesc (Object);
134 SecondObject->Common.Type = ACPI_TYPE_LOCAL_EXTRA;
135 SecondObject->Common.ReferenceCount = 1;
137 /* Link the second object to the first */
139 Object->Common.NextObject = SecondObject;
144 /* All others have no secondary object */
148 /* Save the object type in the object descriptor */
150 Object->Common.Type = (UINT8) Type;
152 /* Init the reference count */
154 Object->Common.ReferenceCount = 1;
156 /* Any per-type initialization should go here */
162 /*******************************************************************************
164 * FUNCTION: AcpiUtCreatePackageObject
166 * PARAMETERS: Count - Number of package elements
168 * RETURN: Pointer to a new Package object, null on failure
170 * DESCRIPTION: Create a fully initialized package object
172 ******************************************************************************/
174 ACPI_OPERAND_OBJECT *
175 AcpiUtCreatePackageObject (
178 ACPI_OPERAND_OBJECT *PackageDesc;
179 ACPI_OPERAND_OBJECT **PackageElements;
182 ACPI_FUNCTION_TRACE_U32 (UtCreatePackageObject, Count);
185 /* Create a new Package object */
187 PackageDesc = AcpiUtCreateInternalObject (ACPI_TYPE_PACKAGE);
194 * Create the element array. Count+1 allows the array to be null
197 PackageElements = ACPI_ALLOCATE_ZEROED (
198 ((ACPI_SIZE) Count + 1) * sizeof (void *));
199 if (!PackageElements)
201 ACPI_FREE (PackageDesc);
205 PackageDesc->Package.Count = Count;
206 PackageDesc->Package.Elements = PackageElements;
207 return_PTR (PackageDesc);
211 /*******************************************************************************
213 * FUNCTION: AcpiUtCreateIntegerObject
215 * PARAMETERS: InitialValue - Initial value for the integer
217 * RETURN: Pointer to a new Integer object, null on failure
219 * DESCRIPTION: Create an initialized integer object
221 ******************************************************************************/
223 ACPI_OPERAND_OBJECT *
224 AcpiUtCreateIntegerObject (
227 ACPI_OPERAND_OBJECT *IntegerDesc;
230 ACPI_FUNCTION_TRACE (UtCreateIntegerObject);
233 /* Create and initialize a new integer object */
235 IntegerDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
241 IntegerDesc->Integer.Value = InitialValue;
242 return_PTR (IntegerDesc);
246 /*******************************************************************************
248 * FUNCTION: AcpiUtCreateBufferObject
250 * PARAMETERS: BufferSize - Size of buffer to be created
252 * RETURN: Pointer to a new Buffer object, null on failure
254 * DESCRIPTION: Create a fully initialized buffer object
256 ******************************************************************************/
258 ACPI_OPERAND_OBJECT *
259 AcpiUtCreateBufferObject (
260 ACPI_SIZE BufferSize)
262 ACPI_OPERAND_OBJECT *BufferDesc;
263 UINT8 *Buffer = NULL;
266 ACPI_FUNCTION_TRACE_U32 (UtCreateBufferObject, BufferSize);
269 /* Create a new Buffer object */
271 BufferDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
277 /* Create an actual buffer only if size > 0 */
281 /* Allocate the actual buffer */
283 Buffer = ACPI_ALLOCATE_ZEROED (BufferSize);
286 ACPI_ERROR ((AE_INFO, "Could not allocate size %u",
287 (UINT32) BufferSize));
288 AcpiUtRemoveReference (BufferDesc);
293 /* Complete buffer object initialization */
295 BufferDesc->Buffer.Flags |= AOPOBJ_DATA_VALID;
296 BufferDesc->Buffer.Pointer = Buffer;
297 BufferDesc->Buffer.Length = (UINT32) BufferSize;
299 /* Return the new buffer descriptor */
301 return_PTR (BufferDesc);
305 /*******************************************************************************
307 * FUNCTION: AcpiUtCreateStringObject
309 * PARAMETERS: StringSize - Size of string to be created. Does not
310 * include NULL terminator, this is added
313 * RETURN: Pointer to a new String object
315 * DESCRIPTION: Create a fully initialized string object
317 ******************************************************************************/
319 ACPI_OPERAND_OBJECT *
320 AcpiUtCreateStringObject (
321 ACPI_SIZE StringSize)
323 ACPI_OPERAND_OBJECT *StringDesc;
327 ACPI_FUNCTION_TRACE_U32 (UtCreateStringObject, StringSize);
330 /* Create a new String object */
332 StringDesc = AcpiUtCreateInternalObject (ACPI_TYPE_STRING);
339 * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
340 * NOTE: Zero-length strings are NULL terminated
342 String = ACPI_ALLOCATE_ZEROED (StringSize + 1);
345 ACPI_ERROR ((AE_INFO, "Could not allocate size %u",
346 (UINT32) StringSize));
347 AcpiUtRemoveReference (StringDesc);
351 /* Complete string object initialization */
353 StringDesc->String.Pointer = String;
354 StringDesc->String.Length = (UINT32) StringSize;
356 /* Return the new string descriptor */
358 return_PTR (StringDesc);
362 /*******************************************************************************
364 * FUNCTION: AcpiUtValidInternalObject
366 * PARAMETERS: Object - Object to be validated
368 * RETURN: TRUE if object is valid, FALSE otherwise
370 * DESCRIPTION: Validate a pointer to be of type ACPI_OPERAND_OBJECT
372 ******************************************************************************/
375 AcpiUtValidInternalObject (
379 ACPI_FUNCTION_NAME (UtValidInternalObject);
382 /* Check for a null pointer */
386 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "**** Null Object Ptr\n"));
390 /* Check the descriptor type field */
392 switch (ACPI_GET_DESCRIPTOR_TYPE (Object))
394 case ACPI_DESC_TYPE_OPERAND:
396 /* The object appears to be a valid ACPI_OPERAND_OBJECT */
402 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
403 "%p is not an ACPI operand obj [%s]\n",
404 Object, AcpiUtGetDescriptorName (Object)));
412 /*******************************************************************************
414 * FUNCTION: AcpiUtAllocateObjectDescDbg
416 * PARAMETERS: ModuleName - Caller's module name (for error output)
417 * LineNumber - Caller's line number (for error output)
418 * ComponentId - Caller's component ID (for error output)
420 * RETURN: Pointer to newly allocated object descriptor. Null on error
422 * DESCRIPTION: Allocate a new object descriptor. Gracefully handle
425 ******************************************************************************/
428 AcpiUtAllocateObjectDescDbg (
429 const char *ModuleName,
433 ACPI_OPERAND_OBJECT *Object;
436 ACPI_FUNCTION_TRACE (UtAllocateObjectDescDbg);
439 Object = AcpiOsAcquireObject (AcpiGbl_OperandCache);
442 ACPI_ERROR ((ModuleName, LineNumber,
443 "Could not allocate an object descriptor"));
448 /* Mark the descriptor type */
450 ACPI_SET_DESCRIPTOR_TYPE (Object, ACPI_DESC_TYPE_OPERAND);
452 ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
453 Object, (UINT32) sizeof (ACPI_OPERAND_OBJECT)));
459 /*******************************************************************************
461 * FUNCTION: AcpiUtDeleteObjectDesc
463 * PARAMETERS: Object - An Acpi internal object to be deleted
467 * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
469 ******************************************************************************/
472 AcpiUtDeleteObjectDesc (
473 ACPI_OPERAND_OBJECT *Object)
475 ACPI_FUNCTION_TRACE_PTR (UtDeleteObjectDesc, Object);
478 /* Object must be of type ACPI_OPERAND_OBJECT */
480 if (ACPI_GET_DESCRIPTOR_TYPE (Object) != ACPI_DESC_TYPE_OPERAND)
482 ACPI_ERROR ((AE_INFO,
483 "%p is not an ACPI Operand object [%s]", Object,
484 AcpiUtGetDescriptorName (Object)));
488 (void) AcpiOsReleaseObject (AcpiGbl_OperandCache, Object);
493 /*******************************************************************************
495 * FUNCTION: AcpiUtGetSimpleObjectSize
497 * PARAMETERS: InternalObject - An ACPI operand object
498 * ObjLength - Where the length is returned
502 * DESCRIPTION: This function is called to determine the space required to
503 * contain a simple object for return to an external user.
505 * The length includes the object structure plus any additional
508 ******************************************************************************/
511 AcpiUtGetSimpleObjectSize (
512 ACPI_OPERAND_OBJECT *InternalObject,
513 ACPI_SIZE *ObjLength)
517 ACPI_STATUS Status = AE_OK;
520 ACPI_FUNCTION_TRACE_PTR (UtGetSimpleObjectSize, InternalObject);
523 /* Start with the length of the (external) Acpi object */
525 Length = sizeof (ACPI_OBJECT);
527 /* A NULL object is allowed, can be a legal uninitialized package element */
532 * Object is NULL, just return the length of ACPI_OBJECT
533 * (A NULL ACPI_OBJECT is an object of all zeroes.)
535 *ObjLength = ACPI_ROUND_UP_TO_NATIVE_WORD (Length);
536 return_ACPI_STATUS (AE_OK);
539 /* A Namespace Node should never appear here */
541 if (ACPI_GET_DESCRIPTOR_TYPE (InternalObject) == ACPI_DESC_TYPE_NAMED)
543 /* A namespace node should never get here */
545 return_ACPI_STATUS (AE_AML_INTERNAL);
549 * The final length depends on the object type
550 * Strings and Buffers are packed right up against the parent object and
551 * must be accessed bytewise or there may be alignment problems on
554 switch (InternalObject->Common.Type)
556 case ACPI_TYPE_STRING:
558 Length += (ACPI_SIZE) InternalObject->String.Length + 1;
561 case ACPI_TYPE_BUFFER:
563 Length += (ACPI_SIZE) InternalObject->Buffer.Length;
566 case ACPI_TYPE_INTEGER:
567 case ACPI_TYPE_PROCESSOR:
568 case ACPI_TYPE_POWER:
570 /* No extra data for these types */
574 case ACPI_TYPE_LOCAL_REFERENCE:
576 switch (InternalObject->Reference.Class)
578 case ACPI_REFCLASS_NAME:
580 * Get the actual length of the full pathname to this object.
581 * The reference will be converted to the pathname to the object
583 Size = AcpiNsGetPathnameLength (InternalObject->Reference.Node);
586 return_ACPI_STATUS (AE_BAD_PARAMETER);
589 Length += ACPI_ROUND_UP_TO_NATIVE_WORD (Size);
594 * No other reference opcodes are supported.
595 * Notably, Locals and Args are not supported, but this may be
596 * required eventually.
598 ACPI_ERROR ((AE_INFO, "Cannot convert to external object - "
599 "unsupported Reference Class [%s] 0x%X in object %p",
600 AcpiUtGetReferenceName (InternalObject),
601 InternalObject->Reference.Class, InternalObject));
609 ACPI_ERROR ((AE_INFO, "Cannot convert to external object - "
610 "unsupported type [%s] 0x%X in object %p",
611 AcpiUtGetObjectTypeName (InternalObject),
612 InternalObject->Common.Type, InternalObject));
618 * Account for the space required by the object rounded up to the next
619 * multiple of the machine word size. This keeps each object aligned
620 * on a machine word boundary. (preventing alignment faults on some
623 *ObjLength = ACPI_ROUND_UP_TO_NATIVE_WORD (Length);
624 return_ACPI_STATUS (Status);
628 /*******************************************************************************
630 * FUNCTION: AcpiUtGetElementLength
632 * PARAMETERS: ACPI_PKG_CALLBACK
636 * DESCRIPTION: Get the length of one package element.
638 ******************************************************************************/
641 AcpiUtGetElementLength (
643 ACPI_OPERAND_OBJECT *SourceObject,
644 ACPI_GENERIC_STATE *State,
647 ACPI_STATUS Status = AE_OK;
648 ACPI_PKG_INFO *Info = (ACPI_PKG_INFO *) Context;
649 ACPI_SIZE ObjectSpace;
654 case ACPI_COPY_TYPE_SIMPLE:
656 * Simple object - just get the size (Null object/entry is handled
657 * here also) and sum it into the running package length
659 Status = AcpiUtGetSimpleObjectSize (SourceObject, &ObjectSpace);
660 if (ACPI_FAILURE (Status))
665 Info->Length += ObjectSpace;
668 case ACPI_COPY_TYPE_PACKAGE:
670 /* Package object - nothing much to do here, let the walk handle it */
673 State->Pkg.ThisTargetObj = NULL;
678 /* No other types allowed */
680 return (AE_BAD_PARAMETER);
687 /*******************************************************************************
689 * FUNCTION: AcpiUtGetPackageObjectSize
691 * PARAMETERS: InternalObject - An ACPI internal object
692 * ObjLength - Where the length is returned
696 * DESCRIPTION: This function is called to determine the space required to
697 * contain a package object for return to an external user.
699 * This is moderately complex since a package contains other
700 * objects including packages.
702 ******************************************************************************/
705 AcpiUtGetPackageObjectSize (
706 ACPI_OPERAND_OBJECT *InternalObject,
707 ACPI_SIZE *ObjLength)
713 ACPI_FUNCTION_TRACE_PTR (UtGetPackageObjectSize, InternalObject);
717 Info.ObjectSpace = 0;
718 Info.NumPackages = 1;
720 Status = AcpiUtWalkPackageTree (InternalObject, NULL,
721 AcpiUtGetElementLength, &Info);
722 if (ACPI_FAILURE (Status))
724 return_ACPI_STATUS (Status);
728 * We have handled all of the objects in all levels of the package.
729 * just add the length of the package objects themselves.
730 * Round up to the next machine word.
732 Info.Length += ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (ACPI_OBJECT)) *
733 (ACPI_SIZE) Info.NumPackages;
735 /* Return the total package length */
737 *ObjLength = Info.Length;
738 return_ACPI_STATUS (Status);
742 /*******************************************************************************
744 * FUNCTION: AcpiUtGetObjectSize
746 * PARAMETERS: InternalObject - An ACPI internal object
747 * ObjLength - Where the length will be returned
751 * DESCRIPTION: This function is called to determine the space required to
752 * contain an object for return to an API user.
754 ******************************************************************************/
757 AcpiUtGetObjectSize (
758 ACPI_OPERAND_OBJECT *InternalObject,
759 ACPI_SIZE *ObjLength)
764 ACPI_FUNCTION_ENTRY ();
767 if ((ACPI_GET_DESCRIPTOR_TYPE (InternalObject) == ACPI_DESC_TYPE_OPERAND) &&
768 (InternalObject->Common.Type == ACPI_TYPE_PACKAGE))
770 Status = AcpiUtGetPackageObjectSize (InternalObject, ObjLength);
774 Status = AcpiUtGetSimpleObjectSize (InternalObject, ObjLength);