void *acpi_ut_allocate_object_desc_dbg(char *module_name,
u32 line_number, u32 component_id)
{
union acpi_operand_object *object;
ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
object = acpi_os_acquire_object(acpi_gbl_operand_cache);
if (!object) {
ACPI_ERROR((module_name, line_number,
"Could not allocate an object descriptor"));
return_PTR(NULL);
}
/* Mark the descriptor type */
memset(object, 0, sizeof(union acpi_operand_object));
ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
object, (u32) sizeof(union acpi_operand_object)));
return_PTR(object);
}
union acpi_operand_object *acpi_ut_create_internal_object_dbg(char *module_name,
u32 line_number,
u32 component_id,
acpi_object_type
type)
{
union acpi_operand_object *object;
union acpi_operand_object *second_object;
ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
acpi_ut_get_type_name(type));
/* Allocate the raw object descriptor */
object =
acpi_ut_allocate_object_desc_dbg(module_name, line_number,
component_id);
if (!object) {
return_PTR(NULL);
}
switch (type) {
case ACPI_TYPE_REGION:
case ACPI_TYPE_BUFFER_FIELD:
/* These types require a secondary object */
second_object = acpi_ut_allocate_object_desc_dbg(module_name,
line_number,
component_id);
if (!second_object) {
acpi_ut_delete_object_desc(object);
return_PTR(NULL);
}
second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
second_object->common.reference_count = 1;
/* Link the second object to the first */
object->common.next_object = second_object;
break;
default:
/* All others have no secondary object */
break;
}
/* Save the object type in the object descriptor */
object->common.type = (u8) type;
/* Init the reference count */
object->common.reference_count = 1;
/* Any per-type initialization should go here */
return_PTR(object);
}
union acpi_generic_state *acpi_ut_create_pkg_state(void *internal_object,
void *external_object,
u16 index)
{
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE_PTR(ut_create_pkg_state, internal_object);
/* Create the generic state object */
state = acpi_ut_create_generic_state();
if (!state) {
return_PTR(NULL);
}
/* Init fields specific to the update struct */
state->common.descriptor_type = ACPI_DESC_TYPE_STATE_PACKAGE;
state->pkg.source_object = (union acpi_operand_object *)internal_object;
state->pkg.dest_object = external_object;
state->pkg.index = index;
state->pkg.num_packages = 1;
return_PTR(state);
}
char *acpi_ns_get_external_pathname(struct acpi_namespace_node *node)
{
acpi_status status;
char *name_buffer;
acpi_size size;
ACPI_FUNCTION_TRACE_PTR(ns_get_external_pathname, node);
size = acpi_ns_get_pathname_length(node);
if (!size) {
return_PTR(NULL);
}
name_buffer = ACPI_ALLOCATE_ZEROED(size);
if (!name_buffer) {
ACPI_ERROR((AE_INFO, "Could not allocate %u bytes", (u32)size));
return_PTR(NULL);
}
status = acpi_ns_build_external_path(node, size, name_buffer);
if (ACPI_FAILURE(status)) {
ACPI_FREE(name_buffer);
return_PTR(NULL);
}
return_PTR(name_buffer);
}
ACPI_OPERAND_OBJECT *
AcpiUtCreateInternalObjectDbg (
NATIVE_CHAR *ModuleName,
UINT32 LineNumber,
UINT32 ComponentId,
ACPI_OBJECT_TYPE8 Type)
{
ACPI_OPERAND_OBJECT *Object;
FUNCTION_TRACE_STR ("UtCreateInternalObjectDbg", AcpiUtGetTypeName (Type));
/* Allocate the raw object descriptor */
Object = AcpiUtAllocateObjectDescDbg (ModuleName, LineNumber, ComponentId);
if (!Object)
{
/* Allocation failure */
return_PTR (NULL);
}
/* Save the object type in the object descriptor */
Object->Common.Type = Type;
/* Init the reference count */
Object->Common.ReferenceCount = 1;
/* Any per-type initialization should go here */
return_PTR (Object);
}
struct acpi_thread_state *acpi_ut_create_thread_state(void)
{
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE(ut_create_thread_state);
/* Create the generic state object */
state = acpi_ut_create_generic_state();
if (!state) {
return_PTR(NULL);
}
/* Init fields specific to the update struct */
state->common.descriptor_type = ACPI_DESC_TYPE_STATE_THREAD;
state->thread.thread_id = acpi_os_get_thread_id();
/* Check for invalid thread ID - zero is very bad, it will break things */
if (!state->thread.thread_id) {
ACPI_ERROR((AE_INFO, "Invalid zero ID from AcpiOsGetThreadId"));
state->thread.thread_id = (acpi_thread_id) 1;
}
return_PTR((struct acpi_thread_state *)state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ns_create_node
*
* PARAMETERS: Name - Name of the new node (4 char ACPI name)
*
* RETURN: New namespace node (Null on failure)
*
* DESCRIPTION: Create a namespace node
*
******************************************************************************/
struct acpi_namespace_node *acpi_ns_create_node(u32 name)
{
struct acpi_namespace_node *node;
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
u32 temp;
#endif
ACPI_FUNCTION_TRACE(ns_create_node);
node = acpi_os_acquire_object(acpi_gbl_namespace_cache);
if (!node) {
return_PTR(NULL);
}
ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_allocated++);
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
temp = acpi_gbl_ns_node_list->total_allocated -
acpi_gbl_ns_node_list->total_freed;
if (temp > acpi_gbl_ns_node_list->max_occupied) {
acpi_gbl_ns_node_list->max_occupied = temp;
}
#endif
node->name.integer = name;
ACPI_SET_DESCRIPTOR_TYPE(node, ACPI_DESC_TYPE_NAMED);
return_PTR(node);
}
void *
AcpiUtAllocateObjectDescDbg (
NATIVE_CHAR *ModuleName,
UINT32 LineNumber,
UINT32 ComponentId)
{
ACPI_OPERAND_OBJECT *Object;
FUNCTION_TRACE ("UtAllocateObjectDescDbg");
Object = AcpiUtAcquireFromCache (ACPI_MEM_LIST_OPERAND);
if (!Object)
{
_REPORT_ERROR (ModuleName, LineNumber, ComponentId,
("Could not allocate an object descriptor\n"));
return_PTR (NULL);
}
/* Mark the descriptor type */
Object->Common.DataType = ACPI_DESC_TYPE_INTERNAL;
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
Object, sizeof (ACPI_OPERAND_OBJECT)));
return_PTR (Object);
}
void *
AcpiUtAllocate (
ACPI_SIZE Size,
UINT32 Component,
const char *Module,
UINT32 Line)
{
void *Allocation;
ACPI_FUNCTION_TRACE_U32 (UtAllocate, Size);
/* Check for an inadvertent size of zero bytes */
if (!Size)
{
ACPI_WARNING ((Module, Line,
"Attempt to allocate zero bytes, allocating 1 byte"));
Size = 1;
}
Allocation = AcpiOsAllocate (Size);
if (!Allocation)
{
/* Report allocation error */
ACPI_WARNING ((Module, Line,
"Could not allocate size %u", (UINT32) Size));
return_PTR (NULL);
}
return_PTR (Allocation);
}
char *
acpi_ns_get_external_pathname (
struct acpi_namespace_node *node)
{
char *name_buffer;
acpi_size size;
ACPI_FUNCTION_TRACE_PTR ("ns_get_external_pathname", node);
/* Calculate required buffer size based on depth below root */
size = acpi_ns_get_pathname_length (node);
/* Allocate a buffer to be returned to caller */
name_buffer = ACPI_MEM_CALLOCATE (size);
if (!name_buffer) {
ACPI_REPORT_ERROR (("ns_get_table_pathname: allocation failure\n"));
return_PTR (NULL);
}
/* Build the path in the allocated buffer */
acpi_ns_build_external_path (node, size, name_buffer);
return_PTR (name_buffer);
}
void *acpi_ut_allocate(acpi_size size,
u32 component, const char *module, u32 line)
{
void *allocation;
ACPI_FUNCTION_TRACE_U32(ut_allocate, size);
/* Check for an inadvertent size of zero bytes */
if (!size) {
ACPI_WARNING((module, line,
"Attempt to allocate zero bytes, allocating 1 byte"));
size = 1;
}
allocation = acpi_os_allocate(size);
if (!allocation) {
/* Report allocation error */
ACPI_WARNING((module, line,
"Could not allocate size %u", (u32) size));
return_PTR(NULL);
}
return_PTR(allocation);
}
union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
{
union acpi_operand_object *string_desc;
char *string;
ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
/* Create a new String object */
string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
if (!string_desc) {
return_PTR(NULL);
}
/*
* Allocate the actual string buffer -- (Size + 1) for NULL terminator.
* NOTE: Zero-length strings are NULL terminated
*/
string = ACPI_ALLOCATE_ZEROED(string_size + 1);
if (!string) {
ACPI_ERROR((AE_INFO, "Could not allocate size %X",
(u32) string_size));
acpi_ut_remove_reference(string_desc);
return_PTR(NULL);
}
/* Complete string object initialization */
string_desc->string.pointer = string;
string_desc->string.length = (u32) string_size;
/* Return the new string descriptor */
return_PTR(string_desc);
}
acpi_table_desc *
acpi_tb_uninstall_table (
acpi_table_desc *table_desc)
{
acpi_table_desc *next_desc;
FUNCTION_TRACE_PTR ("Tb_delete_single_table", table_desc);
if (!table_desc) {
return_PTR (NULL);
}
/* Unlink the descriptor */
if (table_desc->prev) {
table_desc->prev->next = table_desc->next;
}
if (table_desc->next) {
table_desc->next->prev = table_desc->prev;
}
/* Free the memory allocated for the table itself */
acpi_tb_delete_single_table (table_desc);
/* Free the table descriptor (Don't delete the list head, tho) */
if ((table_desc->prev) == (table_desc->next)) {
next_desc = NULL;
/* Clear the list head */
table_desc->pointer = NULL;
table_desc->length = 0;
table_desc->count = 0;
}
else {
/* Free the table descriptor */
next_desc = table_desc->next;
ACPI_MEM_FREE (table_desc);
}
return_PTR (next_desc);
}
ACPI_TABLE_DESC *
AcpiTbUninstallTable (
ACPI_TABLE_DESC *TableDesc)
{
ACPI_TABLE_DESC *NextDesc;
ACPI_FUNCTION_TRACE_PTR (TbUninstallTable, TableDesc);
if (!TableDesc)
{
return_PTR (NULL);
}
/* Unlink the descriptor from the doubly linked list */
if (TableDesc->Prev)
{
TableDesc->Prev->Next = TableDesc->Next;
}
else
{
/* Is first on list, update list head */
AcpiGbl_TableLists[TableDesc->Type].Next = TableDesc->Next;
}
if (TableDesc->Next)
{
TableDesc->Next->Prev = TableDesc->Prev;
}
/* Free the memory allocated for the table itself */
AcpiTbDeleteSingleTable (TableDesc);
/* Free the owner ID associated with this table */
AcpiUtReleaseOwnerId (&TableDesc->OwnerId);
/* Free the table descriptor */
NextDesc = TableDesc->Next;
ACPI_FREE (TableDesc);
/* Return pointer to the next descriptor */
return_PTR (NextDesc);
}
ACPI_NAMESPACE_NODE *
AcpiDsMethodDataGetNode (
UINT16 Opcode,
UINT32 Index,
ACPI_WALK_STATE *WalkState)
{
ACPI_NAMESPACE_NODE *Node = NULL;
FUNCTION_TRACE ("DsMethodDataGetNode");
switch (Opcode)
{
case AML_LOCAL_OP:
if (Index > MTH_MAX_LOCAL)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Local index %d is invalid (max %d)\n",
Index, MTH_MAX_LOCAL));
return_PTR (Node);
}
Node = &WalkState->LocalVariables[Index];
break;
case AML_ARG_OP:
if (Index > MTH_MAX_ARG)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Arg index %d is invalid (max %d)\n",
Index, MTH_MAX_ARG));
return_PTR (Node);
}
Node = &WalkState->Arguments[Index];
break;
default:
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Opcode %d is invalid\n", Opcode));
break;
}
return_PTR (Node);
}
void *
AcpiUtAllocate (
UINT32 Size,
UINT32 Component,
NATIVE_CHAR *Module,
UINT32 Line)
{
ACPI_DEBUG_MEM_BLOCK *Address;
ACPI_STATUS Status;
FUNCTION_TRACE_U32 ("UtAllocate", Size);
/* Check for an inadvertent size of zero bytes */
if (!Size)
{
_REPORT_ERROR (Module, Line, Component,
("UtAllocate: Attempt to allocate zero bytes\n"));
Size = 1;
}
Address = AcpiOsAllocate (Size + sizeof (ACPI_DEBUG_MEM_BLOCK));
if (!Address)
{
/* Report allocation error */
_REPORT_ERROR (Module, Line, Component,
("UtAllocate: Could not allocate size %X\n", Size));
return_PTR (NULL);
}
Status = AcpiUtAddElementToAllocList (ACPI_MEM_LIST_GLOBAL, Address, Size,
MEM_MALLOC, Component, Module, Line);
if (ACPI_FAILURE (Status))
{
AcpiOsFree (Address);
return_PTR (NULL);
}
AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].TotalAllocated++;
AcpiGbl_MemoryLists[ACPI_MEM_LIST_GLOBAL].CurrentTotalSize += Size;
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p Size %X\n", Address, Size));
return_PTR ((void *) &Address->UserSpace);
}
ACPI_GENERIC_STATE *
AcpiUtCreateUpdateState (
ACPI_OPERAND_OBJECT *Object,
UINT16 Action)
{
ACPI_GENERIC_STATE *State;
FUNCTION_TRACE_PTR ("UtCreateUpdateState", Object);
/* Create the generic state object */
State = AcpiUtCreateGenericState ();
if (!State)
{
return (NULL);
}
/* Init fields specific to the update struct */
State->Update.Object = Object;
State->Update.Value = Action;
return_PTR (State);
}
ACPI_GENERIC_STATE *
AcpiUtCreatePkgState (
void *InternalObject,
void *ExternalObject,
UINT16 Index)
{
ACPI_GENERIC_STATE *State;
FUNCTION_TRACE_PTR ("UtCreatePkgState", InternalObject);
/* Create the generic state object */
State = AcpiUtCreateGenericState ();
if (!State)
{
return (NULL);
}
/* Init fields specific to the update struct */
State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject;
State->Pkg.DestObject = ExternalObject;
State->Pkg.Index = Index;
State->Pkg.NumPackages = 1;
return_PTR (State);
}
ACPI_GENERIC_STATE *
AcpiUtCreateControlState (
void)
{
ACPI_GENERIC_STATE *State;
FUNCTION_TRACE ("UtCreateControlState");
/* Create the generic state object */
State = AcpiUtCreateGenericState ();
if (!State)
{
return (NULL);
}
/* Init fields specific to the control struct */
State->Common.State = CONTROL_CONDITIONAL_EXECUTING;
return_PTR (State);
}
union acpi_operand_object *
acpi_ns_get_secondary_object (
union acpi_operand_object *obj_desc)
{
ACPI_FUNCTION_TRACE_PTR ("ns_get_secondary_object", obj_desc);
if ((!obj_desc) ||
(ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_LOCAL_DATA) ||
(!obj_desc->common.next_object) ||
(ACPI_GET_OBJECT_TYPE (obj_desc->common.next_object) == ACPI_TYPE_LOCAL_DATA)) {
return_PTR (NULL);
}
return_PTR (obj_desc->common.next_object);
}
acpi_generic_state *
acpi_ut_create_update_state (
acpi_operand_object *object,
u16 action)
{
acpi_generic_state *state;
FUNCTION_TRACE_PTR ("Ut_create_update_state", object);
/* Create the generic state object */
state = acpi_ut_create_generic_state ();
if (!state) {
return (NULL);
}
/* Init fields specific to the update struct */
state->common.data_type = ACPI_DESC_TYPE_STATE_UPDATE;
state->update.object = object;
state->update.value = action;
return_PTR (state);
}
union acpi_operand_object *acpi_ns_get_secondary_object(union
acpi_operand_object
*obj_desc)
{
ACPI_FUNCTION_TRACE_PTR(ns_get_secondary_object, obj_desc);
if ((!obj_desc) ||
(obj_desc->common.type == ACPI_TYPE_LOCAL_DATA) ||
(!obj_desc->common.next_object) ||
((obj_desc->common.next_object)->common.type ==
ACPI_TYPE_LOCAL_DATA)) {
return_PTR(NULL);
}
return_PTR(obj_desc->common.next_object);
}
acpi_generic_state *
acpi_ut_create_control_state (
void)
{
acpi_generic_state *state;
FUNCTION_TRACE ("Ut_create_control_state");
/* Create the generic state object */
state = acpi_ut_create_generic_state ();
if (!state) {
return (NULL);
}
/* Init fields specific to the control struct */
state->common.data_type = ACPI_DESC_TYPE_STATE_CONTROL;
state->common.state = CONTROL_CONDITIONAL_EXECUTING;
return_PTR (state);
}
ACPI_WALK_STATE *
AcpiDsPopWalkState (
ACPI_THREAD_STATE *Thread)
{
ACPI_WALK_STATE *WalkState;
ACPI_FUNCTION_TRACE (DsPopWalkState);
WalkState = Thread->WalkStateList;
if (WalkState)
{
/* Next walk state becomes the current walk state */
Thread->WalkStateList = WalkState->Next;
/*
* Don't clear the NEXT field, this serves as an indicator
* that there is a parent WALK STATE
* Do Not: WalkState->Next = NULL;
*/
}
return_PTR (WalkState);
}
union acpi_operand_object *acpi_ut_create_integer_object(u64 initial_value)
{
union acpi_operand_object *integer_desc;
ACPI_FUNCTION_TRACE(ut_create_integer_object);
/* Create and initialize a new integer object */
integer_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
if (!integer_desc) {
return_PTR(NULL);
}
integer_desc->integer.value = initial_value;
return_PTR(integer_desc);
}
/**ltl
* 功能: 创建命名空间对象
* 参数:
* 返回值:
* 说明: 为命名空间名字赋值，同时设定标志ACPI_DESC_TYPE_NAMED
*/
struct acpi_namespace_node *acpi_ns_create_node(u32 name)
{
struct acpi_namespace_node *node;
ACPI_FUNCTION_TRACE(ns_create_node);
node = acpi_os_acquire_object(acpi_gbl_namespace_cache);
if (!node) {
return_PTR(NULL);
}
ACPI_MEM_TRACKING(acpi_gbl_ns_node_list->total_allocated++);
node->name.integer = name;
ACPI_SET_DESCRIPTOR_TYPE(node, ACPI_DESC_TYPE_NAMED);
return_PTR(node);
}
ACPI_OPERAND_OBJECT *
AcpiNsGetSecondaryObject (
ACPI_OPERAND_OBJECT *ObjDesc)
{
ACPI_FUNCTION_TRACE_PTR (NsGetSecondaryObject, ObjDesc);
if ((!ObjDesc) ||
(ObjDesc->Common.Type== ACPI_TYPE_LOCAL_DATA) ||
(!ObjDesc->Common.NextObject) ||
((ObjDesc->Common.NextObject)->Common.Type == ACPI_TYPE_LOCAL_DATA))
{
return_PTR (NULL);
}
return_PTR (ObjDesc->Common.NextObject);
}
acpi_namespace_node *
acpi_ds_method_data_get_node (
u16 opcode,
u32 index,
acpi_walk_state *walk_state)
{
acpi_namespace_node *node = NULL;
FUNCTION_TRACE ("Ds_method_data_get_node");
switch (opcode) {
case AML_LOCAL_OP:
if (index > MTH_MAX_LOCAL) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Local index %d is invalid (max %d)\n",
index, MTH_MAX_LOCAL));
return_PTR (node);
}
node = &walk_state->local_variables[index];
break;
case AML_ARG_OP:
if (index > MTH_MAX_ARG) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Arg index %d is invalid (max %d)\n",
index, MTH_MAX_ARG));
return_PTR (node);
}
node = &walk_state->arguments[index];
break;
default:
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Opcode %d is invalid\n", opcode));
break;
}
return_PTR (node);
}
ACPI_OPERAND_OBJECT *
AcpiUtCreateBufferObject (
ACPI_SIZE BufferSize)
{
ACPI_OPERAND_OBJECT *BufferDesc;
UINT8 *Buffer = NULL;
ACPI_FUNCTION_TRACE_U32 (UtCreateBufferObject, BufferSize);
/* Create a new Buffer object */
BufferDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
if (!BufferDesc)
{
return_PTR (NULL);
}
/* Create an actual buffer only if size > 0 */
if (BufferSize > 0)
{
/* Allocate the actual buffer */
Buffer = ACPI_ALLOCATE_ZEROED (BufferSize);
if (!Buffer)
{
ACPI_ERROR ((AE_INFO, "Could not allocate size %u",
(UINT32) BufferSize));
AcpiUtRemoveReference (BufferDesc);
return_PTR (NULL);
}
}
/* Complete buffer object initialization */
BufferDesc->Buffer.Flags |= AOPOBJ_DATA_VALID;
BufferDesc->Buffer.Pointer = Buffer;
BufferDesc->Buffer.Length = (UINT32) BufferSize;
/* Return the new buffer descriptor */
return_PTR (BufferDesc);
}
/**ltl
* 功能: 创建walk state对象
* 参数: owner_id ->ID号
* origin ->
* method_desc->
* thread ->
* 返回值:
* 说明:
*/
struct acpi_walk_state *acpi_ds_create_walk_state(acpi_owner_id owner_id,
union acpi_parse_object *origin,
union acpi_operand_object *method_desc,
struct acpi_thread_state *thread)
{
struct acpi_walk_state *walk_state;
acpi_status status;
ACPI_FUNCTION_TRACE(ds_create_walk_state);
/* 分配内存空间 */
walk_state = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_walk_state));
if (!walk_state) {
return_PTR(NULL);
}
walk_state->descriptor_type = ACPI_DESC_TYPE_WALK;
walk_state->method_desc = method_desc;
walk_state->owner_id = owner_id;
walk_state->origin = origin;
walk_state->thread = thread;
walk_state->parser_state.start_op = origin;
/* Init the method args/local */
#if (!defined (ACPI_NO_METHOD_EXECUTION) && !defined (ACPI_CONSTANT_EVAL_ONLY))
acpi_ds_method_data_init(walk_state);
#endif
/* Create an initial result stack entry */
status = acpi_ds_result_stack_push(walk_state);
if (ACPI_FAILURE(status)) {
ACPI_FREE(walk_state);
return_PTR(NULL);
}
/* Put the new state at the head of the walk list */
if (thread) {
acpi_ds_push_walk_state(walk_state, thread);
}
return_PTR(walk_state);
}