acpi_status
acpi_ut_get_object_size(
acpi_operand_object *internal_object,
u32 *obj_length)
{
acpi_status status;
FUNCTION_ENTRY ();
if ((VALID_DESCRIPTOR_TYPE (internal_object, ACPI_DESC_TYPE_INTERNAL)) &&
(IS_THIS_OBJECT_TYPE (internal_object, ACPI_TYPE_PACKAGE))) {
status = acpi_ut_get_package_object_size (internal_object, obj_length);
}
else {
status = acpi_ut_get_simple_object_size (internal_object, obj_length);
}
return (status);
}
acpi_status
acpi_ut_copy_iobject_to_eobject (
acpi_operand_object *internal_object,
acpi_buffer *ret_buffer)
{
acpi_status status;
FUNCTION_TRACE ("Ut_copy_iobject_to_eobject");
if (IS_THIS_OBJECT_TYPE (internal_object, ACPI_TYPE_PACKAGE)) {
/*
* Package object: Copy all subobjects (including
* nested packages)
*/
status = acpi_ut_copy_ipackage_to_epackage (internal_object,
ret_buffer->pointer, &ret_buffer->length);
}
else {
/*
* Build a simple object (no nested objects)
*/
status = acpi_ut_copy_isimple_to_esimple (internal_object,
(acpi_object *) ret_buffer->pointer,
((u8 *) ret_buffer->pointer +
ROUND_UP_TO_NATIVE_WORD (sizeof (acpi_object))),
&ret_buffer->length);
/*
* build simple does not include the object size in the length
* so we add it in here
*/
ret_buffer->length += sizeof (acpi_object);
}
return_ACPI_STATUS (status);
}
ACPI_STATUS
AcpiUtGetObjectSize(
ACPI_OPERAND_OBJECT *InternalObject,
UINT32 *ObjLength)
{
ACPI_STATUS Status;
FUNCTION_ENTRY ();
if ((VALID_DESCRIPTOR_TYPE (InternalObject, ACPI_DESC_TYPE_INTERNAL)) &&
(IS_THIS_OBJECT_TYPE (InternalObject, ACPI_TYPE_PACKAGE)))
{
Status = AcpiUtGetPackageObjectSize (InternalObject, ObjLength);
}
else
{
Status = AcpiUtGetSimpleObjectSize (InternalObject, ObjLength);
}
return (Status);
}
ACPI_STATUS
acpi_ev_addr_handler_helper (
ACPI_HANDLE obj_handle,
u32 level,
void *context,
void **return_value)
{
ACPI_OPERAND_OBJECT *handler_obj;
ACPI_OPERAND_OBJECT *tmp_obj;
ACPI_OPERAND_OBJECT *obj_desc;
ACPI_NAMESPACE_NODE *node;
ACPI_STATUS status;
handler_obj = (ACPI_OPERAND_OBJECT *) context;
/* Parameter validation */
if (!handler_obj) {
return (AE_OK);
}
/* Convert and validate the device handle */
node = acpi_ns_convert_handle_to_entry (obj_handle);
if (!node) {
return (AE_BAD_PARAMETER);
}
/*
* We only care about regions.and objects
* that can have address handlers
*/
if ((node->type != ACPI_TYPE_DEVICE) &&
(node->type != ACPI_TYPE_REGION) &&
(node != acpi_gbl_root_node))
{
return (AE_OK);
}
/* Check for an existing internal object */
obj_desc = acpi_ns_get_attached_object ((ACPI_HANDLE) node);
if (!obj_desc) {
/*
* The object DNE, we don't care about it
*/
return (AE_OK);
}
/*
* Devices are handled different than regions
*/
if (IS_THIS_OBJECT_TYPE (obj_desc, ACPI_TYPE_DEVICE)) {
/*
* See if this guy has any handlers
*/
tmp_obj = obj_desc->device.addr_handler;
while (tmp_obj) {
/*
* Now let's see if it's for the same address space.
*/
if (tmp_obj->addr_handler.space_id == handler_obj->addr_handler.space_id) {
/*
* It's for the same address space
*/
/*
* Since the object we found it on was a device, then it
* means that someone has already installed a handler for
* the branch of the namespace from this device on. Just
* bail out telling the walk routine to not traverse this
* branch. This preserves the scoping rule for handlers.
*/
return (AE_CTRL_DEPTH);
}
/*
* Move through the linked list of handlers
*/
tmp_obj = tmp_obj->addr_handler.next;
}
/*
* As long as the device didn't have a handler for this
* space we don't care about it. We just ignore it and
* proceed.
*/
return (AE_OK);
}
/*
* Only here if it was a region
*/
ACPI_ASSERT (obj_desc->common.type == ACPI_TYPE_REGION);
if (obj_desc->region.space_id != handler_obj->addr_handler.space_id) {
/*
* This region is for a different address space
* ignore it
*/
return (AE_OK);
}
/*
* Now we have a region and it is for the handler's address
* space type.
*
* First disconnect region for any previous handler (if any)
*/
acpi_ev_disassociate_region_from_handler (obj_desc, FALSE);
/*
* Then connect the region to the new handler
*/
status = acpi_ev_associate_region_and_handler (handler_obj, obj_desc, FALSE);
return (status);
}
acpi_status
acpi_ut_walk_package_tree (
acpi_operand_object *source_object,
void *target_object,
ACPI_PKG_CALLBACK walk_callback,
void *context)
{
acpi_status status = AE_OK;
acpi_generic_state *state_list = NULL;
acpi_generic_state *state;
u32 this_index;
acpi_operand_object *this_source_obj;
FUNCTION_TRACE ("Ut_walk_package_tree");
state = acpi_ut_create_pkg_state (source_object, target_object, 0);
if (!state) {
return_ACPI_STATUS (AE_NO_MEMORY);
}
while (state) {
this_index = state->pkg.index;
this_source_obj = (acpi_operand_object *)
state->pkg.source_object->package.elements[this_index];
/*
* Check for
* 1) An uninitialized package element. It is completely
* legal to declare a package and leave it uninitialized
* 2) Not an internal object - can be a namespace node instead
* 3) Any type other than a package. Packages are handled in else
* case below.
*/
if ((!this_source_obj) ||
(!VALID_DESCRIPTOR_TYPE (
this_source_obj, ACPI_DESC_TYPE_INTERNAL)) ||
(!IS_THIS_OBJECT_TYPE (
this_source_obj, ACPI_TYPE_PACKAGE))) {
status = walk_callback (ACPI_COPY_TYPE_SIMPLE, this_source_obj,
state, context);
if (ACPI_FAILURE (status)) {
/* TBD: must delete package created up to this point */
return_ACPI_STATUS (status);
}
state->pkg.index++;
while (state->pkg.index >= state->pkg.source_object->package.count) {
/*
* We've handled all of the objects at this level, This means
* that we have just completed a package. That package may
* have contained one or more packages itself.
*
* Delete this state and pop the previous state (package).
*/
acpi_ut_delete_generic_state (state);
state = acpi_ut_pop_generic_state (&state_list);
/* Finished when there are no more states */
if (!state) {
/*
* We have handled all of the objects in the top level
* package just add the length of the package objects
* and exit
*/
return_ACPI_STATUS (AE_OK);
}
/*
* Go back up a level and move the index past the just
* completed package object.
*/
state->pkg.index++;
}
}
else {
/* This is a sub-object of type package */
status = walk_callback (ACPI_COPY_TYPE_PACKAGE, this_source_obj,
state, context);
if (ACPI_FAILURE (status)) {
/* TBD: must delete package created up to this point */
return_ACPI_STATUS (status);
}
/*
* The callback above returned a new target package object.
*/
/*
* Push the current state and create a new one
*/
acpi_ut_push_generic_state (&state_list, state);
state = acpi_ut_create_pkg_state (this_source_obj,
state->pkg.this_target_obj, 0);
if (!state) {
/* TBD: must delete package created up to this point */
return_ACPI_STATUS (AE_NO_MEMORY);
}
}
}
/* We should never get here */
return (AE_AML_INTERNAL);
}
ACPI_STATUS
AcpiUtWalkPackageTree (
ACPI_OPERAND_OBJECT *SourceObject,
void *TargetObject,
ACPI_PKG_CALLBACK WalkCallback,
void *Context)
{
ACPI_STATUS Status = AE_OK;
ACPI_GENERIC_STATE *StateList = NULL;
ACPI_GENERIC_STATE *State;
UINT32 ThisIndex;
ACPI_OPERAND_OBJECT *ThisSourceObj;
FUNCTION_TRACE ("UtWalkPackageTree");
State = AcpiUtCreatePkgState (SourceObject, TargetObject, 0);
if (!State)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
while (State)
{
ThisIndex = State->Pkg.Index;
ThisSourceObj = (ACPI_OPERAND_OBJECT *)
State->Pkg.SourceObject->Package.Elements[ThisIndex];
/*
* Check for
* 1) An uninitialized package element. It is completely
* legal to declare a package and leave it uninitialized
* 2) Not an internal object - can be a namespace node instead
* 3) Any type other than a package. Packages are handled in else
* case below.
*/
if ((!ThisSourceObj) ||
(!VALID_DESCRIPTOR_TYPE (
ThisSourceObj, ACPI_DESC_TYPE_INTERNAL)) ||
(!IS_THIS_OBJECT_TYPE (
ThisSourceObj, ACPI_TYPE_PACKAGE)))
{
Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj,
State, Context);
if (ACPI_FAILURE (Status))
{
/* TBD: must delete package created up to this point */
return_ACPI_STATUS (Status);
}
State->Pkg.Index++;
while (State->Pkg.Index >= State->Pkg.SourceObject->Package.Count)
{
/*
* We've handled all of the objects at this level, This means
* that we have just completed a package. That package may
* have contained one or more packages itself.
*
* Delete this state and pop the previous state (package).
*/
AcpiUtDeleteGenericState (State);
State = AcpiUtPopGenericState (&StateList);
/* Finished when there are no more states */
if (!State)
{
/*
* We have handled all of the objects in the top level
* package just add the length of the package objects
* and exit
*/
return_ACPI_STATUS (AE_OK);
}
/*
* Go back up a level and move the index past the just
* completed package object.
*/
State->Pkg.Index++;
}
}
else
{
/* This is a sub-object of type package */
Status = WalkCallback (ACPI_COPY_TYPE_PACKAGE, ThisSourceObj,
State, Context);
if (ACPI_FAILURE (Status))
{
/* TBD: must delete package created up to this point */
return_ACPI_STATUS (Status);
}
/*
* The callback above returned a new target package object.
*/
/*
* Push the current state and create a new one
*/
AcpiUtPushGenericState (&StateList, State);
State = AcpiUtCreatePkgState (ThisSourceObj,
State->Pkg.ThisTargetObj, 0);
if (!State)
{
/* TBD: must delete package created up to this point */
return_ACPI_STATUS (AE_NO_MEMORY);
}
}
}
/* We should never get here */
return (AE_AML_INTERNAL);
}
