lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[ACPI] Lindent all ACPI files

Browse Source 
Signed-off-by: Len Brown <len.brown@intel.com>
This commit is contained in:
Len Brown
2005-08-05 00:44:28 -04:00
parent c65ade4dc8
commit 4be44fcd3b
190 changed files with 24344 additions and 29290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

505
drivers/acpi/utilities/utalloc.c
View File

@@ -41,45 +41,31 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utalloc")
ACPI_MODULE_NAME("utalloc")
/* Local prototypes */
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
static struct acpi_debug_mem_block *
acpi_ut_find_allocation (
void *allocation);
static struct acpi_debug_mem_block *acpi_ut_find_allocation(void *allocation);
static acpi_status
acpi_ut_track_allocation (
struct acpi_debug_mem_block *address,
acpi_size size,
u8 alloc_type,
u32 component,
char *module,
u32 line);
acpi_ut_track_allocation(struct acpi_debug_mem_block *address,
acpi_size size,
u8 alloc_type, u32 component, char *module, u32 line);
static acpi_status
acpi_ut_remove_allocation (
struct acpi_debug_mem_block *address,
u32 component,
char *module,
u32 line);
#endif /* ACPI_DBG_TRACK_ALLOCATIONS */
acpi_ut_remove_allocation(struct acpi_debug_mem_block *address,
u32 component, char *module, u32 line);
#endif /* ACPI_DBG_TRACK_ALLOCATIONS */
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
static acpi_status
acpi_ut_create_list (
char *list_name,
u16 object_size,
struct acpi_memory_list **return_cache);
acpi_ut_create_list(char *list_name,
u16 object_size, struct acpi_memory_list **return_cache);
#endif
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_caches
@@ -92,60 +78,68 @@ acpi_ut_create_list (
*
******************************************************************************/
acpi_status
acpi_ut_create_caches (
void)
acpi_status acpi_ut_create_caches(void)
{
acpi_status status;
acpi_status status;
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
/* Memory allocation lists */
status = acpi_ut_create_list ("Acpi-Global", 0,
&acpi_gbl_global_list);
if (ACPI_FAILURE (status)) {
status = acpi_ut_create_list("Acpi-Global", 0, &acpi_gbl_global_list);
if (ACPI_FAILURE(status)) {
return (status);
}
status = acpi_ut_create_list ("Acpi-Namespace", sizeof (struct acpi_namespace_node),
&acpi_gbl_ns_node_list);
if (ACPI_FAILURE (status)) {
status =
acpi_ut_create_list("Acpi-Namespace",
sizeof(struct acpi_namespace_node),
&acpi_gbl_ns_node_list);
if (ACPI_FAILURE(status)) {
return (status);
}
#endif
/* Object Caches, for frequently used objects */
status = acpi_os_create_cache ("acpi_state", sizeof (union acpi_generic_state),
ACPI_MAX_STATE_CACHE_DEPTH, &acpi_gbl_state_cache);
if (ACPI_FAILURE (status)) {
status =
acpi_os_create_cache("acpi_state", sizeof(union acpi_generic_state),
ACPI_MAX_STATE_CACHE_DEPTH,
&acpi_gbl_state_cache);
if (ACPI_FAILURE(status)) {
return (status);
}
status = acpi_os_create_cache ("acpi_parse", sizeof (struct acpi_parse_obj_common),
ACPI_MAX_PARSE_CACHE_DEPTH, &acpi_gbl_ps_node_cache);
if (ACPI_FAILURE (status)) {
status =
acpi_os_create_cache("acpi_parse",
sizeof(struct acpi_parse_obj_common),
ACPI_MAX_PARSE_CACHE_DEPTH,
&acpi_gbl_ps_node_cache);
if (ACPI_FAILURE(status)) {
return (status);
}
status = acpi_os_create_cache ("acpi_parse_ext", sizeof (struct acpi_parse_obj_named),
ACPI_MAX_EXTPARSE_CACHE_DEPTH, &acpi_gbl_ps_node_ext_cache);
if (ACPI_FAILURE (status)) {
status =
acpi_os_create_cache("acpi_parse_ext",
sizeof(struct acpi_parse_obj_named),
ACPI_MAX_EXTPARSE_CACHE_DEPTH,
&acpi_gbl_ps_node_ext_cache);
if (ACPI_FAILURE(status)) {
return (status);
}
status = acpi_os_create_cache ("acpi_operand", sizeof (union acpi_operand_object),
ACPI_MAX_OBJECT_CACHE_DEPTH, &acpi_gbl_operand_cache);
if (ACPI_FAILURE (status)) {
status =
acpi_os_create_cache("acpi_operand",
sizeof(union acpi_operand_object),
ACPI_MAX_OBJECT_CACHE_DEPTH,
&acpi_gbl_operand_cache);
if (ACPI_FAILURE(status)) {
return (status);
}
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_delete_caches
@@ -158,21 +152,19 @@ acpi_ut_create_caches (
*
******************************************************************************/
acpi_status
acpi_ut_delete_caches (
void)
acpi_status acpi_ut_delete_caches(void)
{
(void) acpi_os_delete_cache (acpi_gbl_state_cache);
(void)acpi_os_delete_cache(acpi_gbl_state_cache);
acpi_gbl_state_cache = NULL;
(void) acpi_os_delete_cache (acpi_gbl_operand_cache);
(void)acpi_os_delete_cache(acpi_gbl_operand_cache);
acpi_gbl_operand_cache = NULL;
(void) acpi_os_delete_cache (acpi_gbl_ps_node_cache);
(void)acpi_os_delete_cache(acpi_gbl_ps_node_cache);
acpi_gbl_ps_node_cache = NULL;
(void) acpi_os_delete_cache (acpi_gbl_ps_node_ext_cache);
(void)acpi_os_delete_cache(acpi_gbl_ps_node_ext_cache);
acpi_gbl_ps_node_ext_cache = NULL;
return (AE_OK);
@@ -190,9 +182,7 @@ acpi_ut_delete_caches (
*
******************************************************************************/
acpi_status
acpi_ut_validate_buffer (
struct acpi_buffer *buffer)
acpi_status acpi_ut_validate_buffer(struct acpi_buffer * buffer)
{
/* Obviously, the structure pointer must be valid */
@@ -203,9 +193,9 @@ acpi_ut_validate_buffer (
/* Special semantics for the length */
if ((buffer->length == ACPI_NO_BUFFER) ||
(buffer->length == ACPI_ALLOCATE_BUFFER) ||
(buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
if ((buffer->length == ACPI_NO_BUFFER) ||
(buffer->length == ACPI_ALLOCATE_BUFFER) ||
(buffer->length == ACPI_ALLOCATE_LOCAL_BUFFER)) {
return (AE_OK);
}
@@ -218,7 +208,6 @@ acpi_ut_validate_buffer (
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_initialize_buffer
@@ -234,12 +223,10 @@ acpi_ut_validate_buffer (
******************************************************************************/
acpi_status
acpi_ut_initialize_buffer (
struct acpi_buffer *buffer,
acpi_size required_length)
acpi_ut_initialize_buffer(struct acpi_buffer * buffer,
acpi_size required_length)
{
acpi_status status = AE_OK;
acpi_status status = AE_OK;
switch (buffer->length) {
case ACPI_NO_BUFFER:
@@ -249,33 +236,30 @@ acpi_ut_initialize_buffer (
status = AE_BUFFER_OVERFLOW;
break;
case ACPI_ALLOCATE_BUFFER:
/* Allocate a new buffer */
buffer->pointer = acpi_os_allocate (required_length);
buffer->pointer = acpi_os_allocate(required_length);
if (!buffer->pointer) {
return (AE_NO_MEMORY);
}
/* Clear the buffer */
ACPI_MEMSET (buffer->pointer, 0, required_length);
ACPI_MEMSET(buffer->pointer, 0, required_length);
break;
case ACPI_ALLOCATE_LOCAL_BUFFER:
/* Allocate a new buffer with local interface to allow tracking */
buffer->pointer = ACPI_MEM_CALLOCATE (required_length);
buffer->pointer = ACPI_MEM_CALLOCATE(required_length);
if (!buffer->pointer) {
return (AE_NO_MEMORY);
}
break;
default:
/* Existing buffer: Validate the size of the buffer */
@@ -287,7 +271,7 @@ acpi_ut_initialize_buffer (
/* Clear the buffer */
ACPI_MEMSET (buffer->pointer, 0, required_length);
ACPI_MEMSET(buffer->pointer, 0, required_length);
break;
}
@@ -295,7 +279,6 @@ acpi_ut_initialize_buffer (
return (status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_allocate
@@ -311,41 +294,34 @@ acpi_ut_initialize_buffer (
*
******************************************************************************/
void *
acpi_ut_allocate (
acpi_size size,
u32 component,
char *module,
u32 line)
void *acpi_ut_allocate(acpi_size size, u32 component, char *module, u32 line)
{
void *allocation;
ACPI_FUNCTION_TRACE_U32 ("ut_allocate", size);
void *allocation;
ACPI_FUNCTION_TRACE_U32("ut_allocate", size);
/* Check for an inadvertent size of zero bytes */
if (!size) {
_ACPI_REPORT_ERROR (module, line, component,
("ut_allocate: Attempt to allocate zero bytes\n"));
_ACPI_REPORT_ERROR(module, line, component,
("ut_allocate: Attempt to allocate zero bytes\n"));
size = 1;
}
allocation = acpi_os_allocate (size);
allocation = acpi_os_allocate(size);
if (!allocation) {
/* Report allocation error */
_ACPI_REPORT_ERROR (module, line, component,
("ut_allocate: Could not allocate size %X\n", (u32) size));
_ACPI_REPORT_ERROR(module, line, component,
("ut_allocate: Could not allocate size %X\n",
(u32) size));
return_PTR (NULL);
return_PTR(NULL);
}
return_PTR (allocation);
return_PTR(allocation);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_callocate
@@ -361,43 +337,36 @@ acpi_ut_allocate (
*
******************************************************************************/
void *
acpi_ut_callocate (
acpi_size size,
u32 component,
char *module,
u32 line)
void *acpi_ut_callocate(acpi_size size, u32 component, char *module, u32 line)
{
void *allocation;
ACPI_FUNCTION_TRACE_U32 ("ut_callocate", size);
void *allocation;
ACPI_FUNCTION_TRACE_U32("ut_callocate", size);
/* Check for an inadvertent size of zero bytes */
if (!size) {
_ACPI_REPORT_ERROR (module, line, component,
("ut_callocate: Attempt to allocate zero bytes\n"));
return_PTR (NULL);
_ACPI_REPORT_ERROR(module, line, component,
("ut_callocate: Attempt to allocate zero bytes\n"));
return_PTR(NULL);
}
allocation = acpi_os_allocate (size);
allocation = acpi_os_allocate(size);
if (!allocation) {
/* Report allocation error */
_ACPI_REPORT_ERROR (module, line, component,
("ut_callocate: Could not allocate size %X\n", (u32) size));
return_PTR (NULL);
_ACPI_REPORT_ERROR(module, line, component,
("ut_callocate: Could not allocate size %X\n",
(u32) size));
return_PTR(NULL);
}
/* Clear the memory block */
ACPI_MEMSET (allocation, 0, size);
return_PTR (allocation);
ACPI_MEMSET(allocation, 0, size);
return_PTR(allocation);
}
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
/*
* These procedures are used for tracking memory leaks in the subsystem, and
@@ -425,29 +394,25 @@ acpi_ut_callocate (
******************************************************************************/
static acpi_status
acpi_ut_create_list (
char *list_name,
u16 object_size,
struct acpi_memory_list **return_cache)
acpi_ut_create_list(char *list_name,
u16 object_size, struct acpi_memory_list **return_cache)
{
struct acpi_memory_list *cache;
struct acpi_memory_list *cache;
cache = acpi_os_allocate (sizeof (struct acpi_memory_list));
cache = acpi_os_allocate(sizeof(struct acpi_memory_list));
if (!cache) {
return (AE_NO_MEMORY);
}
ACPI_MEMSET (cache, 0, sizeof (struct acpi_memory_list));
ACPI_MEMSET(cache, 0, sizeof(struct acpi_memory_list));
cache->list_name = list_name;
cache->list_name = list_name;
cache->object_size = object_size;
*return_cache = cache;
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_allocate_and_track
@@ -463,37 +428,33 @@ acpi_ut_create_list (
*
******************************************************************************/
void *
acpi_ut_allocate_and_track (
acpi_size size,
u32 component,
char *module,
u32 line)
void *acpi_ut_allocate_and_track(acpi_size size,
u32 component, char *module, u32 line)
{
struct acpi_debug_mem_block *allocation;
acpi_status status;
struct acpi_debug_mem_block *allocation;
acpi_status status;
allocation = acpi_ut_allocate (size + sizeof (struct acpi_debug_mem_header),
component, module, line);
allocation =
acpi_ut_allocate(size + sizeof(struct acpi_debug_mem_header),
component, module, line);
if (!allocation) {
return (NULL);
}
status = acpi_ut_track_allocation (allocation, size,
ACPI_MEM_MALLOC, component, module, line);
if (ACPI_FAILURE (status)) {
acpi_os_free (allocation);
status = acpi_ut_track_allocation(allocation, size,
ACPI_MEM_MALLOC, component, module,
line);
if (ACPI_FAILURE(status)) {
acpi_os_free(allocation);
return (NULL);
}
acpi_gbl_global_list->total_allocated++;
acpi_gbl_global_list->current_total_size += (u32) size;
return ((void *) &allocation->user_space);
return ((void *)&allocation->user_space);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_callocate_and_track
@@ -509,41 +470,38 @@ acpi_ut_allocate_and_track (
*
******************************************************************************/
void *
acpi_ut_callocate_and_track (
acpi_size size,
u32 component,
char *module,
u32 line)
void *acpi_ut_callocate_and_track(acpi_size size,
u32 component, char *module, u32 line)
{
struct acpi_debug_mem_block *allocation;
acpi_status status;
struct acpi_debug_mem_block *allocation;
acpi_status status;
allocation = acpi_ut_callocate (size + sizeof (struct acpi_debug_mem_header),
component, module, line);
allocation =
acpi_ut_callocate(size + sizeof(struct acpi_debug_mem_header),
component, module, line);
if (!allocation) {
/* Report allocation error */
_ACPI_REPORT_ERROR (module, line, component,
("ut_callocate: Could not allocate size %X\n", (u32) size));
_ACPI_REPORT_ERROR(module, line, component,
("ut_callocate: Could not allocate size %X\n",
(u32) size));
return (NULL);
}
status = acpi_ut_track_allocation (allocation, size,
ACPI_MEM_CALLOC, component, module, line);
if (ACPI_FAILURE (status)) {
acpi_os_free (allocation);
status = acpi_ut_track_allocation(allocation, size,
ACPI_MEM_CALLOC, component, module,
line);
if (ACPI_FAILURE(status)) {
acpi_os_free(allocation);
return (NULL);
}
acpi_gbl_global_list->total_allocated++;
acpi_gbl_global_list->current_total_size += (u32) size;
return ((void *) &allocation->user_space);
return ((void *)&allocation->user_space);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_free_and_track
@@ -560,47 +518,41 @@ acpi_ut_callocate_and_track (
******************************************************************************/
void
acpi_ut_free_and_track (
void *allocation,
u32 component,
char *module,
u32 line)
acpi_ut_free_and_track(void *allocation, u32 component, char *module, u32 line)
{
struct acpi_debug_mem_block *debug_block;
acpi_status status;
ACPI_FUNCTION_TRACE_PTR ("ut_free", allocation);
struct acpi_debug_mem_block *debug_block;
acpi_status status;
ACPI_FUNCTION_TRACE_PTR("ut_free", allocation);
if (NULL == allocation) {
_ACPI_REPORT_ERROR (module, line, component,
("acpi_ut_free: Attempt to delete a NULL address\n"));
_ACPI_REPORT_ERROR(module, line, component,
("acpi_ut_free: Attempt to delete a NULL address\n"));
return_VOID;
}
debug_block = ACPI_CAST_PTR (struct acpi_debug_mem_block,
(((char *) allocation) - sizeof (struct acpi_debug_mem_header)));
debug_block = ACPI_CAST_PTR(struct acpi_debug_mem_block,
(((char *)allocation) -
sizeof(struct acpi_debug_mem_header)));
acpi_gbl_global_list->total_freed++;
acpi_gbl_global_list->current_total_size -= debug_block->size;
status = acpi_ut_remove_allocation (debug_block,
component, module, line);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not free memory, %s\n",
acpi_format_exception (status)));
status = acpi_ut_remove_allocation(debug_block,
component, module, line);
if (ACPI_FAILURE(status)) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Could not free memory, %s\n",
acpi_format_exception(status)));
}
acpi_os_free (debug_block);
acpi_os_free(debug_block);
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "%p freed\n", allocation));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p freed\n", allocation));
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_find_allocation
@@ -613,15 +565,11 @@ acpi_ut_free_and_track (
*
******************************************************************************/
static struct acpi_debug_mem_block *
acpi_ut_find_allocation (
void *allocation)
static struct acpi_debug_mem_block *acpi_ut_find_allocation(void *allocation)
{
struct acpi_debug_mem_block *element;
ACPI_FUNCTION_ENTRY ();
struct acpi_debug_mem_block *element;
ACPI_FUNCTION_ENTRY();
element = acpi_gbl_global_list->list_head;
@@ -638,7 +586,6 @@ acpi_ut_find_allocation (
return (NULL);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_track_allocation
@@ -657,58 +604,51 @@ acpi_ut_find_allocation (
******************************************************************************/
static acpi_status
acpi_ut_track_allocation (
struct acpi_debug_mem_block *allocation,
acpi_size size,
u8 alloc_type,
u32 component,
char *module,
u32 line)
acpi_ut_track_allocation(struct acpi_debug_mem_block *allocation,
acpi_size size,
u8 alloc_type, u32 component, char *module, u32 line)
{
struct acpi_memory_list *mem_list;
struct acpi_debug_mem_block *element;
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_PTR ("ut_track_allocation", allocation);
struct acpi_memory_list *mem_list;
struct acpi_debug_mem_block *element;
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_PTR("ut_track_allocation", allocation);
mem_list = acpi_gbl_global_list;
status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/*
* Search list for this address to make sure it is not already on the list.
* This will catch several kinds of problems.
*/
element = acpi_ut_find_allocation (allocation);
element = acpi_ut_find_allocation(allocation);
if (element) {
ACPI_REPORT_ERROR ((
"ut_track_allocation: Allocation already present in list! (%p)\n",
allocation));
ACPI_REPORT_ERROR(("ut_track_allocation: Allocation already present in list! (%p)\n", allocation));
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Element %p Address %p\n",
element, allocation));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Element %p Address %p\n",
element, allocation));
goto unlock_and_exit;
}
/* Fill in the instance data. */
allocation->size = (u32) size;
allocation->size = (u32) size;
allocation->alloc_type = alloc_type;
allocation->component = component;
allocation->line = line;
allocation->line = line;
ACPI_STRNCPY (allocation->module, module, ACPI_MAX_MODULE_NAME);
allocation->module[ACPI_MAX_MODULE_NAME-1] = 0;
ACPI_STRNCPY(allocation->module, module, ACPI_MAX_MODULE_NAME);
allocation->module[ACPI_MAX_MODULE_NAME - 1] = 0;
/* Insert at list head */
if (mem_list->list_head) {
((struct acpi_debug_mem_block *)(mem_list->list_head))->previous = allocation;
((struct acpi_debug_mem_block *)(mem_list->list_head))->
previous = allocation;
}
allocation->next = mem_list->list_head;
@@ -716,13 +656,11 @@ acpi_ut_track_allocation (
mem_list->list_head = allocation;
unlock_and_exit:
status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
return_ACPI_STATUS (status);
unlock_and_exit:
status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_remove_allocation
@@ -739,40 +677,34 @@ unlock_and_exit:
******************************************************************************/
static acpi_status
acpi_ut_remove_allocation (
struct acpi_debug_mem_block *allocation,
u32 component,
char *module,
u32 line)
acpi_ut_remove_allocation(struct acpi_debug_mem_block *allocation,
u32 component, char *module, u32 line)
{
struct acpi_memory_list *mem_list;
acpi_status status;
ACPI_FUNCTION_TRACE ("ut_remove_allocation");
struct acpi_memory_list *mem_list;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_remove_allocation");
mem_list = acpi_gbl_global_list;
if (NULL == mem_list->list_head) {
/* No allocations! */
_ACPI_REPORT_ERROR (module, line, component,
("ut_remove_allocation: Empty allocation list, nothing to free!\n"));
_ACPI_REPORT_ERROR(module, line, component,
("ut_remove_allocation: Empty allocation list, nothing to free!\n"));
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
status = acpi_ut_acquire_mutex (ACPI_MTX_MEMORY);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_acquire_mutex(ACPI_MTX_MEMORY);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/* Unlink */
if (allocation->previous) {
(allocation->previous)->next = allocation->next;
}
else {
} else {
mem_list->list_head = allocation->next;
}
@@ -782,16 +714,15 @@ acpi_ut_remove_allocation (
/* Mark the segment as deleted */
ACPI_MEMSET (&allocation->user_space, 0xEA, allocation->size);
ACPI_MEMSET(&allocation->user_space, 0xEA, allocation->size);
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Freeing size 0%X\n",
allocation->size));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Freeing size 0%X\n",
allocation->size));
status = acpi_ut_release_mutex (ACPI_MTX_MEMORY);
return_ACPI_STATUS (status);
status = acpi_ut_release_mutex(ACPI_MTX_MEMORY);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_dump_allocation_info
@@ -805,15 +736,13 @@ acpi_ut_remove_allocation (
******************************************************************************/
#ifdef ACPI_FUTURE_USAGE
void
acpi_ut_dump_allocation_info (
void)
void acpi_ut_dump_allocation_info(void)
{
/*
struct acpi_memory_list *mem_list;
*/
ACPI_FUNCTION_TRACE ("ut_dump_allocation_info");
ACPI_FUNCTION_TRACE("ut_dump_allocation_info");
/*
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
@@ -826,7 +755,6 @@ acpi_ut_dump_allocation_info (
mem_list->max_concurrent_count,
ROUND_UP_TO_1K (mem_list->max_concurrent_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Total (all) internal objects",
running_object_count,
@@ -837,7 +765,6 @@ acpi_ut_dump_allocation_info (
running_alloc_count,
ROUND_UP_TO_1K (running_alloc_size)));
ACPI_DEBUG_PRINT (TRACE_ALLOCATIONS | TRACE_TABLES,
("%30s: %4d (%3d Kb)\n", "Current Nodes",
acpi_gbl_current_node_count,
@@ -851,8 +778,7 @@ acpi_ut_dump_allocation_info (
*/
return_VOID;
}
#endif /* ACPI_FUTURE_USAGE */
#endif /* ACPI_FUTURE_USAGE */
/*******************************************************************************
*
@@ -867,84 +793,87 @@ acpi_ut_dump_allocation_info (
*
******************************************************************************/
void
acpi_ut_dump_allocations (
u32 component,
char *module)
void acpi_ut_dump_allocations(u32 component, char *module)
{
struct acpi_debug_mem_block *element;
union acpi_descriptor *descriptor;
u32 num_outstanding = 0;
ACPI_FUNCTION_TRACE ("ut_dump_allocations");
struct acpi_debug_mem_block *element;
union acpi_descriptor *descriptor;
u32 num_outstanding = 0;
ACPI_FUNCTION_TRACE("ut_dump_allocations");
/*
* Walk the allocation list.
*/
if (ACPI_FAILURE (acpi_ut_acquire_mutex (ACPI_MTX_MEMORY))) {
if (ACPI_FAILURE(acpi_ut_acquire_mutex(ACPI_MTX_MEMORY))) {
return;
}
element = acpi_gbl_global_list->list_head;
while (element) {
if ((element->component & component) &&
((module == NULL) || (0 == ACPI_STRCMP (module, element->module)))) {
((module == NULL)
|| (0 == ACPI_STRCMP(module, element->module)))) {
/* Ignore allocated objects that are in a cache */
descriptor = ACPI_CAST_PTR (union acpi_descriptor, &element->user_space);
descriptor =
ACPI_CAST_PTR(union acpi_descriptor,
&element->user_space);
if (descriptor->descriptor_id != ACPI_DESC_TYPE_CACHED) {
acpi_os_printf ("%p Len %04X %9.9s-%d [%s] ",
descriptor, element->size, element->module,
element->line, acpi_ut_get_descriptor_name (descriptor));
acpi_os_printf("%p Len %04X %9.9s-%d [%s] ",
descriptor, element->size,
element->module, element->line,
acpi_ut_get_descriptor_name
(descriptor));
/* Most of the elements will be Operand objects. */
switch (ACPI_GET_DESCRIPTOR_TYPE (descriptor)) {
switch (ACPI_GET_DESCRIPTOR_TYPE(descriptor)) {
case ACPI_DESC_TYPE_OPERAND:
acpi_os_printf ("%12.12s R%hd",
acpi_ut_get_type_name (descriptor->object.common.type),
descriptor->object.common.reference_count);
acpi_os_printf("%12.12s R%hd",
acpi_ut_get_type_name
(descriptor->object.
common.type),
descriptor->object.
common.reference_count);
break;
case ACPI_DESC_TYPE_PARSER:
acpi_os_printf ("aml_opcode %04hX",
descriptor->op.asl.aml_opcode);
acpi_os_printf("aml_opcode %04hX",
descriptor->op.asl.
aml_opcode);
break;
case ACPI_DESC_TYPE_NAMED:
acpi_os_printf ("%4.4s",
acpi_ut_get_node_name (&descriptor->node));
acpi_os_printf("%4.4s",
acpi_ut_get_node_name
(&descriptor->node));
break;
default:
break;
}
acpi_os_printf ( "\n");
acpi_os_printf("\n");
num_outstanding++;
}
}
element = element->next;
}
(void) acpi_ut_release_mutex (ACPI_MTX_MEMORY);
(void)acpi_ut_release_mutex(ACPI_MTX_MEMORY);
/* Print summary */
if (!num_outstanding) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"No outstanding allocations.\n"));
}
else {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"%d(%X) Outstanding allocations\n",
num_outstanding, num_outstanding));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"No outstanding allocations.\n"));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"%d(%X) Outstanding allocations\n",
num_outstanding, num_outstanding));
}
return_VOID;
}
#endif /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */
#endif /* #ifdef ACPI_DBG_TRACK_ALLOCATIONS */

149
drivers/acpi/utilities/utcache.c
View File

@@ -41,12 +41,10 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utcache")
ACPI_MODULE_NAME("utcache")
#ifdef ACPI_USE_LOCAL_CACHE
/*******************************************************************************
@@ -63,19 +61,14 @@
* DESCRIPTION: Create a cache object
*
******************************************************************************/
acpi_status
acpi_os_create_cache (
char *cache_name,
u16 object_size,
u16 max_depth,
struct acpi_memory_list **return_cache)
acpi_os_create_cache(char *cache_name,
u16 object_size,
u16 max_depth, struct acpi_memory_list **return_cache)
{
struct acpi_memory_list *cache;
ACPI_FUNCTION_ENTRY ();
struct acpi_memory_list *cache;
ACPI_FUNCTION_ENTRY();
if (!cache_name || !return_cache || (object_size < 16)) {
return (AE_BAD_PARAMETER);
@@ -83,24 +76,23 @@ acpi_os_create_cache (
/* Create the cache object */
cache = acpi_os_allocate (sizeof (struct acpi_memory_list));
cache = acpi_os_allocate(sizeof(struct acpi_memory_list));
if (!cache) {
return (AE_NO_MEMORY);
}
/* Populate the cache object and return it */
ACPI_MEMSET (cache, 0, sizeof (struct acpi_memory_list));
ACPI_MEMSET(cache, 0, sizeof(struct acpi_memory_list));
cache->link_offset = 8;
cache->list_name = cache_name;
cache->list_name = cache_name;
cache->object_size = object_size;
cache->max_depth = max_depth;
cache->max_depth = max_depth;
*return_cache = cache;
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_os_purge_cache
@@ -113,15 +105,11 @@ acpi_os_create_cache (
*
******************************************************************************/
acpi_status
acpi_os_purge_cache (
struct acpi_memory_list *cache)
acpi_status acpi_os_purge_cache(struct acpi_memory_list * cache)
{
char *next;
ACPI_FUNCTION_ENTRY ();
char *next;
ACPI_FUNCTION_ENTRY();
if (!cache) {
return (AE_BAD_PARAMETER);
@@ -132,9 +120,11 @@ acpi_os_purge_cache (
while (cache->list_head) {
/* Delete and unlink one cached state object */
next = *(ACPI_CAST_INDIRECT_PTR (char,
&(((char *) cache->list_head)[cache->link_offset])));
ACPI_MEM_FREE (cache->list_head);
next = *(ACPI_CAST_INDIRECT_PTR(char,
&(((char *)cache->
list_head)[cache->
link_offset])));
ACPI_MEM_FREE(cache->list_head);
cache->list_head = next;
cache->current_depth--;
@@ -143,7 +133,6 @@ acpi_os_purge_cache (
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_os_delete_cache
@@ -157,30 +146,25 @@ acpi_os_purge_cache (
*
******************************************************************************/
acpi_status
acpi_os_delete_cache (
struct acpi_memory_list *cache)
acpi_status acpi_os_delete_cache(struct acpi_memory_list * cache)
{
acpi_status status;
acpi_status status;
ACPI_FUNCTION_ENTRY();
ACPI_FUNCTION_ENTRY ();
/* Purge all objects in the cache */
/* Purge all objects in the cache */
status = acpi_os_purge_cache (cache);
if (ACPI_FAILURE (status)) {
status = acpi_os_purge_cache(cache);
if (ACPI_FAILURE(status)) {
return (status);
}
/* Now we can delete the cache object */
acpi_os_free (cache);
acpi_os_free(cache);
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_os_release_object
@@ -196,15 +180,11 @@ acpi_os_delete_cache (
******************************************************************************/
acpi_status
acpi_os_release_object (
struct acpi_memory_list *cache,
void *object)
acpi_os_release_object(struct acpi_memory_list * cache, void *object)
{
acpi_status status;
ACPI_FUNCTION_ENTRY ();
acpi_status status;
ACPI_FUNCTION_ENTRY();
if (!cache || !object) {
return (AE_BAD_PARAMETER);
@@ -213,37 +193,38 @@ acpi_os_release_object (
/* If cache is full, just free this object */
if (cache->current_depth >= cache->max_depth) {
ACPI_MEM_FREE (object);
ACPI_MEM_TRACKING (cache->total_freed++);
ACPI_MEM_FREE(object);
ACPI_MEM_TRACKING(cache->total_freed++);
}
/* Otherwise put this object back into the cache */
else {
status = acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (status)) {
status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
if (ACPI_FAILURE(status)) {
return (status);
}
/* Mark the object as cached */
ACPI_MEMSET (object, 0xCA, cache->object_size);
ACPI_SET_DESCRIPTOR_TYPE (object, ACPI_DESC_TYPE_CACHED);
ACPI_MEMSET(object, 0xCA, cache->object_size);
ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_CACHED);
/* Put the object at the head of the cache list */
* (ACPI_CAST_INDIRECT_PTR (char,
&(((char *) object)[cache->link_offset]))) = cache->list_head;
*(ACPI_CAST_INDIRECT_PTR(char,
&(((char *)object)[cache->
link_offset]))) =
cache->list_head;
cache->list_head = object;
cache->current_depth++;
(void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
(void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
}
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_os_acquire_object
@@ -257,27 +238,23 @@ acpi_os_release_object (
*
******************************************************************************/
void *
acpi_os_acquire_object (
struct acpi_memory_list *cache)
void *acpi_os_acquire_object(struct acpi_memory_list *cache)
{
acpi_status status;
void *object;
ACPI_FUNCTION_NAME ("os_acquire_object");
acpi_status status;
void *object;
ACPI_FUNCTION_NAME("os_acquire_object");
if (!cache) {
return (NULL);
}
status = acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (status)) {
status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
if (ACPI_FAILURE(status)) {
return (NULL);
}
ACPI_MEM_TRACKING (cache->requests++);
ACPI_MEM_TRACKING(cache->requests++);
/* Check the cache first */
@@ -285,37 +262,39 @@ acpi_os_acquire_object (
/* There is an object available, use it */
object = cache->list_head;
cache->list_head = *(ACPI_CAST_INDIRECT_PTR (char,
&(((char *) object)[cache->link_offset])));
cache->list_head = *(ACPI_CAST_INDIRECT_PTR(char,
&(((char *)
object)[cache->
link_offset])));
cache->current_depth--;
ACPI_MEM_TRACKING (cache->hits++);
ACPI_MEM_TRACKING (ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"Object %p from %s cache\n", object, cache->list_name)));
ACPI_MEM_TRACKING(cache->hits++);
ACPI_MEM_TRACKING(ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"Object %p from %s cache\n",
object, cache->list_name)));
status = acpi_ut_release_mutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (status)) {
status = acpi_ut_release_mutex(ACPI_MTX_CACHES);
if (ACPI_FAILURE(status)) {
return (NULL);
}
/* Clear (zero) the previously used Object */
ACPI_MEMSET (object, 0, cache->object_size);
}
else {
ACPI_MEMSET(object, 0, cache->object_size);
} else {
/* The cache is empty, create a new object */
ACPI_MEM_TRACKING (cache->total_allocated++);
ACPI_MEM_TRACKING(cache->total_allocated++);
/* Avoid deadlock with ACPI_MEM_CALLOCATE */
status = acpi_ut_release_mutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (status)) {
status = acpi_ut_release_mutex(ACPI_MTX_CACHES);
if (ACPI_FAILURE(status)) {
return (NULL);
}
object = ACPI_MEM_CALLOCATE (cache->object_size);
object = ACPI_MEM_CALLOCATE(cache->object_size);
if (!object) {
return (NULL);
}
@@ -323,6 +302,4 @@ acpi_os_acquire_object (
return (object);
}
#endif /* ACPI_USE_LOCAL_CACHE */
#endif /* ACPI_USE_LOCAL_CACHE */

556
drivers/acpi/utilities/utcopy.c
View File

File diff suppressed because it is too large Load Diff

330
drivers/acpi/utilities/utdebug.c
View File

@@ -46,21 +46,16 @@
#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utdebug")
ACPI_MODULE_NAME("utdebug")
#ifdef ACPI_DEBUG_OUTPUT
static u32 acpi_gbl_prev_thread_id = 0xFFFFFFFF;
static char *acpi_gbl_fn_entry_str = "----Entry";
static char *acpi_gbl_fn_exit_str = "----Exit-";
static u32 acpi_gbl_prev_thread_id = 0xFFFFFFFF;
static char *acpi_gbl_fn_entry_str = "----Entry";
static char *acpi_gbl_fn_exit_str = "----Exit-";
/* Local prototypes */
static const char *
acpi_ut_trim_function_name (
const char *function_name);
static const char *acpi_ut_trim_function_name(const char *function_name);
/*******************************************************************************
*
@@ -74,17 +69,13 @@ acpi_ut_trim_function_name (
*
******************************************************************************/
void
acpi_ut_init_stack_ptr_trace (
void)
void acpi_ut_init_stack_ptr_trace(void)
{
u32 current_sp;
u32 current_sp;
acpi_gbl_entry_stack_pointer = ACPI_PTR_DIFF (&current_sp, NULL);
acpi_gbl_entry_stack_pointer = ACPI_PTR_DIFF(&current_sp, NULL);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_track_stack_ptr
@@ -97,14 +88,11 @@ acpi_ut_init_stack_ptr_trace (
*
******************************************************************************/
void
acpi_ut_track_stack_ptr (
void)
void acpi_ut_track_stack_ptr(void)
{
acpi_size current_sp;
acpi_size current_sp;
current_sp = ACPI_PTR_DIFF (&current_sp, NULL);
current_sp = ACPI_PTR_DIFF(&current_sp, NULL);
if (current_sp < acpi_gbl_lowest_stack_pointer) {
acpi_gbl_lowest_stack_pointer = current_sp;
@@ -115,7 +103,6 @@ acpi_ut_track_stack_ptr (
}
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_trim_function_name
@@ -130,20 +117,18 @@ acpi_ut_track_stack_ptr (
*
******************************************************************************/
static const char *
acpi_ut_trim_function_name (
const char *function_name)
static const char *acpi_ut_trim_function_name(const char *function_name)
{
/* All Function names are longer than 4 chars, check is safe */
if (*(ACPI_CAST_PTR (u32, function_name)) == ACPI_FUNCTION_PREFIX1) {
if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_FUNCTION_PREFIX1) {
/* This is the case where the original source has not been modified */
return (function_name + 4);
}
if (*(ACPI_CAST_PTR (u32, function_name)) == ACPI_FUNCTION_PREFIX2) {
if (*(ACPI_CAST_PTR(u32, function_name)) == ACPI_FUNCTION_PREFIX2) {
/* This is the case where the source has been 'linuxized' */
return (function_name + 5);
@@ -152,7 +137,6 @@ acpi_ut_trim_function_name (
return (function_name);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_debug_print
@@ -172,38 +156,33 @@ acpi_ut_trim_function_name (
*
******************************************************************************/
void ACPI_INTERNAL_VAR_XFACE
acpi_ut_debug_print (
u32 requested_debug_level,
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
char *format,
...)
void ACPI_INTERNAL_VAR_XFACE
acpi_ut_debug_print(u32 requested_debug_level,
u32 line_number,
const char *function_name,
char *module_name, u32 component_id, char *format, ...)
{
u32 thread_id;
va_list args;
u32 thread_id;
va_list args;
/*
* Stay silent if the debug level or component ID is disabled
*/
if (!(requested_debug_level & acpi_dbg_level) ||
!(component_id & acpi_dbg_layer)) {
!(component_id & acpi_dbg_layer)) {
return;
}
/*
* Thread tracking and context switch notification
*/
thread_id = acpi_os_get_thread_id ();
thread_id = acpi_os_get_thread_id();
if (thread_id != acpi_gbl_prev_thread_id) {
if (ACPI_LV_THREADS & acpi_dbg_level) {
acpi_os_printf (
"\n**** Context Switch from TID %X to TID %X ****\n\n",
acpi_gbl_prev_thread_id, thread_id);
acpi_os_printf
("\n**** Context Switch from TID %X to TID %X ****\n\n",
acpi_gbl_prev_thread_id, thread_id);
}
acpi_gbl_prev_thread_id = thread_id;
@@ -213,17 +192,18 @@ acpi_ut_debug_print (
* Display the module name, current line number, thread ID (if requested),
* current procedure nesting level, and the current procedure name
*/
acpi_os_printf ("%8s-%04ld ", module_name, line_number);
acpi_os_printf("%8s-%04ld ", module_name, line_number);
if (ACPI_LV_THREADS & acpi_dbg_level) {
acpi_os_printf ("[%04lX] ", thread_id);
acpi_os_printf("[%04lX] ", thread_id);
}
acpi_os_printf ("[%02ld] %-22.22s: ",
acpi_gbl_nesting_level, acpi_ut_trim_function_name (function_name));
acpi_os_printf("[%02ld] %-22.22s: ",
acpi_gbl_nesting_level,
acpi_ut_trim_function_name(function_name));
va_start (args, format);
acpi_os_vprintf (format, args);
va_start(args, format);
acpi_os_vprintf(format, args);
}
EXPORT_SYMBOL(acpi_ut_debug_print);
@@ -247,29 +227,24 @@ EXPORT_SYMBOL(acpi_ut_debug_print);
*
******************************************************************************/
void ACPI_INTERNAL_VAR_XFACE
acpi_ut_debug_print_raw (
u32 requested_debug_level,
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
char *format,
...)
void ACPI_INTERNAL_VAR_XFACE
acpi_ut_debug_print_raw(u32 requested_debug_level,
u32 line_number,
const char *function_name,
char *module_name, u32 component_id, char *format, ...)
{
va_list args;
va_list args;
if (!(requested_debug_level & acpi_dbg_level) ||
!(component_id & acpi_dbg_layer)) {
!(component_id & acpi_dbg_layer)) {
return;
}
va_start (args, format);
acpi_os_vprintf (format, args);
va_start(args, format);
acpi_os_vprintf(format, args);
}
EXPORT_SYMBOL(acpi_ut_debug_print_raw);
EXPORT_SYMBOL(acpi_ut_debug_print_raw);
/*******************************************************************************
*
@@ -288,22 +263,19 @@ EXPORT_SYMBOL(acpi_ut_debug_print_raw);
******************************************************************************/
void
acpi_ut_trace (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id)
acpi_ut_trace(u32 line_number,
const char *function_name, char *module_name, u32 component_id)
{
acpi_gbl_nesting_level++;
acpi_ut_track_stack_ptr ();
acpi_ut_track_stack_ptr();
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s\n", acpi_gbl_fn_entry_str);
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s\n", acpi_gbl_fn_entry_str);
}
EXPORT_SYMBOL(acpi_ut_trace);
EXPORT_SYMBOL(acpi_ut_trace);
/*******************************************************************************
*
@@ -323,22 +295,19 @@ EXPORT_SYMBOL(acpi_ut_trace);
******************************************************************************/
void
acpi_ut_trace_ptr (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
void *pointer)
acpi_ut_trace_ptr(u32 line_number,
const char *function_name,
char *module_name, u32 component_id, void *pointer)
{
acpi_gbl_nesting_level++;
acpi_ut_track_stack_ptr ();
acpi_ut_track_stack_ptr();
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s %p\n", acpi_gbl_fn_entry_str, pointer);
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s %p\n", acpi_gbl_fn_entry_str,
pointer);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_trace_str
@@ -357,23 +326,20 @@ acpi_ut_trace_ptr (
******************************************************************************/
void
acpi_ut_trace_str (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
char *string)
acpi_ut_trace_str(u32 line_number,
const char *function_name,
char *module_name, u32 component_id, char *string)
{
acpi_gbl_nesting_level++;
acpi_ut_track_stack_ptr ();
acpi_ut_track_stack_ptr();
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s %s\n", acpi_gbl_fn_entry_str, string);
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s %s\n", acpi_gbl_fn_entry_str,
string);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_trace_u32
@@ -392,23 +358,20 @@ acpi_ut_trace_str (
******************************************************************************/
void
acpi_ut_trace_u32 (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
u32 integer)
acpi_ut_trace_u32(u32 line_number,
const char *function_name,
char *module_name, u32 component_id, u32 integer)
{
acpi_gbl_nesting_level++;
acpi_ut_track_stack_ptr ();
acpi_ut_track_stack_ptr();
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s %08X\n", acpi_gbl_fn_entry_str, integer);
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s %08X\n", acpi_gbl_fn_entry_str,
integer);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_exit
@@ -426,21 +389,18 @@ acpi_ut_trace_u32 (
******************************************************************************/
void
acpi_ut_exit (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id)
acpi_ut_exit(u32 line_number,
const char *function_name, char *module_name, u32 component_id)
{
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s\n", acpi_gbl_fn_exit_str);
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s\n", acpi_gbl_fn_exit_str);
acpi_gbl_nesting_level--;
}
EXPORT_SYMBOL(acpi_ut_exit);
EXPORT_SYMBOL(acpi_ut_exit);
/*******************************************************************************
*
@@ -460,31 +420,29 @@ EXPORT_SYMBOL(acpi_ut_exit);
******************************************************************************/
void
acpi_ut_status_exit (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
acpi_status status)
acpi_ut_status_exit(u32 line_number,
const char *function_name,
char *module_name, u32 component_id, acpi_status status)
{
if (ACPI_SUCCESS (status)) {
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s %s\n", acpi_gbl_fn_exit_str,
acpi_format_exception (status));
}
else {
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s ****Exception****: %s\n", acpi_gbl_fn_exit_str,
acpi_format_exception (status));
if (ACPI_SUCCESS(status)) {
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s %s\n",
acpi_gbl_fn_exit_str,
acpi_format_exception(status));
} else {
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s ****Exception****: %s\n",
acpi_gbl_fn_exit_str,
acpi_format_exception(status));
}
acpi_gbl_nesting_level--;
}
EXPORT_SYMBOL(acpi_ut_status_exit);
EXPORT_SYMBOL(acpi_ut_status_exit);
/*******************************************************************************
*
@@ -504,23 +462,20 @@ EXPORT_SYMBOL(acpi_ut_status_exit);
******************************************************************************/
void
acpi_ut_value_exit (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
acpi_integer value)
acpi_ut_value_exit(u32 line_number,
const char *function_name,
char *module_name, u32 component_id, acpi_integer value)
{
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str,
ACPI_FORMAT_UINT64 (value));
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s %8.8X%8.8X\n",
acpi_gbl_fn_exit_str, ACPI_FORMAT_UINT64(value));
acpi_gbl_nesting_level--;
}
EXPORT_SYMBOL(acpi_ut_value_exit);
EXPORT_SYMBOL(acpi_ut_value_exit);
/*******************************************************************************
*
@@ -540,24 +495,20 @@ EXPORT_SYMBOL(acpi_ut_value_exit);
******************************************************************************/
void
acpi_ut_ptr_exit (
u32 line_number,
const char *function_name,
char *module_name,
u32 component_id,
u8 *ptr)
acpi_ut_ptr_exit(u32 line_number,
const char *function_name,
char *module_name, u32 component_id, u8 * ptr)
{
acpi_ut_debug_print (ACPI_LV_FUNCTIONS,
line_number, function_name, module_name, component_id,
"%s %p\n", acpi_gbl_fn_exit_str, ptr);
acpi_ut_debug_print(ACPI_LV_FUNCTIONS,
line_number, function_name, module_name,
component_id, "%s %p\n", acpi_gbl_fn_exit_str, ptr);
acpi_gbl_nesting_level--;
}
#endif
/*******************************************************************************
*
* FUNCTION: acpi_ut_dump_buffer
@@ -573,23 +524,17 @@ acpi_ut_ptr_exit (
*
******************************************************************************/
void
acpi_ut_dump_buffer (
u8 *buffer,
u32 count,
u32 display,
u32 component_id)
void acpi_ut_dump_buffer(u8 * buffer, u32 count, u32 display, u32 component_id)
{
acpi_native_uint i = 0;
acpi_native_uint j;
u32 temp32;
u8 buf_char;
acpi_native_uint i = 0;
acpi_native_uint j;
u32 temp32;
u8 buf_char;
/* Only dump the buffer if tracing is enabled */
if (!((ACPI_LV_TABLES & acpi_dbg_level) &&
(component_id & acpi_dbg_layer))) {
(component_id & acpi_dbg_layer))) {
return;
}
@@ -602,7 +547,7 @@ acpi_ut_dump_buffer (
while (i < count) {
/* Print current offset */
acpi_os_printf ("%6.4X: ", (u32) i);
acpi_os_printf("%6.4X: ", (u32) i);
/* Print 16 hex chars */
@@ -610,39 +555,36 @@ acpi_ut_dump_buffer (
if (i + j >= count) {
/* Dump fill spaces */
acpi_os_printf ("%*s", ((display * 2) + 1), " ");
acpi_os_printf("%*s", ((display * 2) + 1), " ");
j += (acpi_native_uint) display;
continue;
}
switch (display) {
default: /* Default is BYTE display */
default: /* Default is BYTE display */
acpi_os_printf ("%02X ", buffer[i + j]);
acpi_os_printf("%02X ", buffer[i + j]);
break;
case DB_WORD_DISPLAY:
ACPI_MOVE_16_TO_32 (&temp32, &buffer[i + j]);
acpi_os_printf ("%04X ", temp32);
ACPI_MOVE_16_TO_32(&temp32, &buffer[i + j]);
acpi_os_printf("%04X ", temp32);
break;
case DB_DWORD_DISPLAY:
ACPI_MOVE_32_TO_32 (&temp32, &buffer[i + j]);
acpi_os_printf ("%08X ", temp32);
ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j]);
acpi_os_printf("%08X ", temp32);
break;
case DB_QWORD_DISPLAY:
ACPI_MOVE_32_TO_32 (&temp32, &buffer[i + j]);
acpi_os_printf ("%08X", temp32);
ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j]);
acpi_os_printf("%08X", temp32);
ACPI_MOVE_32_TO_32 (&temp32, &buffer[i + j + 4]);
acpi_os_printf ("%08X ", temp32);
ACPI_MOVE_32_TO_32(&temp32, &buffer[i + j + 4]);
acpi_os_printf("%08X ", temp32);
break;
}
@@ -653,28 +595,26 @@ acpi_ut_dump_buffer (
* Print the ASCII equivalent characters but watch out for the bad
* unprintable ones (printable chars are 0x20 through 0x7E)
*/
acpi_os_printf (" ");
acpi_os_printf(" ");
for (j = 0; j < 16; j++) {
if (i + j >= count) {
acpi_os_printf ("\n");
acpi_os_printf("\n");
return;
}
buf_char = buffer[i + j];
if (ACPI_IS_PRINT (buf_char)) {
acpi_os_printf ("%c", buf_char);
}
else {
acpi_os_printf (".");
if (ACPI_IS_PRINT(buf_char)) {
acpi_os_printf("%c", buf_char);
} else {
acpi_os_printf(".");
}
}
/* Done with that line. */
acpi_os_printf ("\n");
acpi_os_printf("\n");
i += 16;
}
return;
}

325
drivers/acpi/utilities/utdelete.c
View File

@@ -41,7 +41,6 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#include <acpi/acinterp.h>
#include <acpi/acnamesp.h>
@@ -49,19 +48,13 @@
#include <acpi/amlcode.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utdelete")
ACPI_MODULE_NAME("utdelete")
/* Local prototypes */
static void acpi_ut_delete_internal_obj(union acpi_operand_object *object);
static void
acpi_ut_delete_internal_obj (
union acpi_operand_object *object);
static void
acpi_ut_update_ref_count (
union acpi_operand_object *object,
u32 action);
acpi_ut_update_ref_count(union acpi_operand_object *object, u32 action);
/*******************************************************************************
*
@@ -76,18 +69,14 @@ acpi_ut_update_ref_count (
*
******************************************************************************/
static void
acpi_ut_delete_internal_obj (
union acpi_operand_object *object)
static void acpi_ut_delete_internal_obj(union acpi_operand_object *object)
{
void *obj_pointer = NULL;
union acpi_operand_object *handler_desc;
union acpi_operand_object *second_desc;
union acpi_operand_object *next_desc;
ACPI_FUNCTION_TRACE_PTR ("ut_delete_internal_obj", object);
void *obj_pointer = NULL;
union acpi_operand_object *handler_desc;
union acpi_operand_object *second_desc;
union acpi_operand_object *next_desc;
ACPI_FUNCTION_TRACE_PTR("ut_delete_internal_obj", object);
if (!object) {
return_VOID;
@@ -97,11 +86,12 @@ acpi_ut_delete_internal_obj (
* Must delete or free any pointers within the object that are not
* actual ACPI objects (for example, a raw buffer pointer).
*/
switch (ACPI_GET_OBJECT_TYPE (object)) {
switch (ACPI_GET_OBJECT_TYPE(object)) {
case ACPI_TYPE_STRING:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** String %p, ptr %p\n",
object, object->string.pointer));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"**** String %p, ptr %p\n", object,
object->string.pointer));
/* Free the actual string buffer */
@@ -112,11 +102,11 @@ acpi_ut_delete_internal_obj (
}
break;
case ACPI_TYPE_BUFFER:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "**** Buffer %p, ptr %p\n",
object, object->buffer.pointer));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"**** Buffer %p, ptr %p\n", object,
object->buffer.pointer));
/* Free the actual buffer */
@@ -127,11 +117,11 @@ acpi_ut_delete_internal_obj (
}
break;
case ACPI_TYPE_PACKAGE:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, " **** Package of count %X\n",
object->package.count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
" **** Package of count %X\n",
object->package.count));
/*
* Elements of the package are not handled here, they are deleted
@@ -143,11 +133,11 @@ acpi_ut_delete_internal_obj (
obj_pointer = object->package.elements;
break;
case ACPI_TYPE_DEVICE:
if (object->device.gpe_block) {
(void) acpi_ev_delete_gpe_block (object->device.gpe_block);
(void)acpi_ev_delete_gpe_block(object->device.
gpe_block);
}
/* Walk the handler list for this device */
@@ -155,54 +145,51 @@ acpi_ut_delete_internal_obj (
handler_desc = object->device.handler;
while (handler_desc) {
next_desc = handler_desc->address_space.next;
acpi_ut_remove_reference (handler_desc);
acpi_ut_remove_reference(handler_desc);
handler_desc = next_desc;
}
break;
case ACPI_TYPE_MUTEX:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"***** Mutex %p, Semaphore %p\n",
object, object->mutex.semaphore));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"***** Mutex %p, Semaphore %p\n",
object, object->mutex.semaphore));
acpi_ex_unlink_mutex (object);
(void) acpi_os_delete_semaphore (object->mutex.semaphore);
acpi_ex_unlink_mutex(object);
(void)acpi_os_delete_semaphore(object->mutex.semaphore);
break;
case ACPI_TYPE_EVENT:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"***** Event %p, Semaphore %p\n",
object, object->event.semaphore));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"***** Event %p, Semaphore %p\n",
object, object->event.semaphore));
(void) acpi_os_delete_semaphore (object->event.semaphore);
(void)acpi_os_delete_semaphore(object->event.semaphore);
object->event.semaphore = NULL;
break;
case ACPI_TYPE_METHOD:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"***** Method %p\n", object));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"***** Method %p\n", object));
/* Delete the method semaphore if it exists */
if (object->method.semaphore) {
(void) acpi_os_delete_semaphore (object->method.semaphore);
(void)acpi_os_delete_semaphore(object->method.
semaphore);
object->method.semaphore = NULL;
}
break;
case ACPI_TYPE_REGION:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"***** Region %p\n", object));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"***** Region %p\n", object));
second_desc = acpi_ns_get_secondary_object (object);
second_desc = acpi_ns_get_secondary_object(object);
if (second_desc) {
/*
* Free the region_context if and only if the handler is one of the
@@ -211,32 +198,33 @@ acpi_ut_delete_internal_obj (
*/
handler_desc = object->region.handler;
if (handler_desc) {
if (handler_desc->address_space.hflags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) {
obj_pointer = second_desc->extra.region_context;
if (handler_desc->address_space.
hflags &
ACPI_ADDR_HANDLER_DEFAULT_INSTALLED) {
obj_pointer =
second_desc->extra.region_context;
}
acpi_ut_remove_reference (handler_desc);
acpi_ut_remove_reference(handler_desc);
}
/* Now we can free the Extra object */
acpi_ut_delete_object_desc (second_desc);
acpi_ut_delete_object_desc(second_desc);
}
break;
case ACPI_TYPE_BUFFER_FIELD:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"***** Buffer Field %p\n", object));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"***** Buffer Field %p\n", object));
second_desc = acpi_ns_get_secondary_object (object);
second_desc = acpi_ns_get_secondary_object(object);
if (second_desc) {
acpi_ut_delete_object_desc (second_desc);
acpi_ut_delete_object_desc(second_desc);
}
break;
default:
break;
}
@@ -244,21 +232,20 @@ acpi_ut_delete_internal_obj (
/* Free any allocated memory (pointer within the object) found above */
if (obj_pointer) {
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object Subptr %p\n",
obj_pointer));
ACPI_MEM_FREE (obj_pointer);
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Deleting Object Subptr %p\n", obj_pointer));
ACPI_MEM_FREE(obj_pointer);
}
/* Now the object can be safely deleted */
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
object, acpi_ut_get_object_type_name (object)));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "Deleting Object %p [%s]\n",
object, acpi_ut_get_object_type_name(object)));
acpi_ut_delete_object_desc (object);
acpi_ut_delete_object_desc(object);
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_delete_internal_object_list
@@ -272,29 +259,24 @@ acpi_ut_delete_internal_obj (
*
******************************************************************************/
void
acpi_ut_delete_internal_object_list (
union acpi_operand_object **obj_list)
void acpi_ut_delete_internal_object_list(union acpi_operand_object **obj_list)
{
union acpi_operand_object **internal_obj;
ACPI_FUNCTION_TRACE ("ut_delete_internal_object_list");
union acpi_operand_object **internal_obj;
ACPI_FUNCTION_TRACE("ut_delete_internal_object_list");
/* Walk the null-terminated internal list */
for (internal_obj = obj_list; *internal_obj; internal_obj++) {
acpi_ut_remove_reference (*internal_obj);
acpi_ut_remove_reference(*internal_obj);
}
/* Free the combined parameter pointer list and object array */
ACPI_MEM_FREE (obj_list);
ACPI_MEM_FREE(obj_list);
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_update_ref_count
@@ -309,16 +291,12 @@ acpi_ut_delete_internal_object_list (
******************************************************************************/
static void
acpi_ut_update_ref_count (
union acpi_operand_object *object,
u32 action)
acpi_ut_update_ref_count(union acpi_operand_object *object, u32 action)
{
u16 count;
u16 new_count;
ACPI_FUNCTION_NAME ("ut_update_ref_count");
u16 count;
u16 new_count;
ACPI_FUNCTION_NAME("ut_update_ref_count");
if (!object) {
return;
@@ -338,58 +316,55 @@ acpi_ut_update_ref_count (
new_count++;
object->common.reference_count = new_count;
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, [Incremented]\n",
object, new_count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, [Incremented]\n",
object, new_count));
break;
case REF_DECREMENT:
if (count < 1) {
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, can't decrement! (Set to 0)\n",
object, new_count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, can't decrement! (Set to 0)\n",
object, new_count));
new_count = 0;
}
else {
} else {
new_count--;
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, [Decremented]\n",
object, new_count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, [Decremented]\n",
object, new_count));
}
if (ACPI_GET_OBJECT_TYPE (object) == ACPI_TYPE_METHOD) {
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Method Obj %p Refs=%X, [Decremented]\n",
object, new_count));
if (ACPI_GET_OBJECT_TYPE(object) == ACPI_TYPE_METHOD) {
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Method Obj %p Refs=%X, [Decremented]\n",
object, new_count));
}
object->common.reference_count = new_count;
if (new_count == 0) {
acpi_ut_delete_internal_obj (object);
acpi_ut_delete_internal_obj(object);
}
break;
case REF_FORCE_DELETE:
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, Force delete! (Set to 0)\n",
object, count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Obj %p Refs=%X, Force delete! (Set to 0)\n",
object, count));
new_count = 0;
object->common.reference_count = new_count;
acpi_ut_delete_internal_obj (object);
acpi_ut_delete_internal_obj(object);
break;
default:
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unknown action (%X)\n", action));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown action (%X)\n",
action));
break;
}
@@ -399,15 +374,14 @@ acpi_ut_update_ref_count (
*/
if (count > ACPI_MAX_REFERENCE_COUNT) {
ACPI_DEBUG_PRINT ((ACPI_DB_WARN,
"**** Warning **** Large Reference Count (%X) in object %p\n\n",
count, object));
ACPI_DEBUG_PRINT((ACPI_DB_WARN,
"**** Warning **** Large Reference Count (%X) in object %p\n\n",
count, object));
}
return;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_update_object_reference
@@ -431,38 +405,36 @@ acpi_ut_update_ref_count (
******************************************************************************/
acpi_status
acpi_ut_update_object_reference (
union acpi_operand_object *object,
u16 action)
acpi_ut_update_object_reference(union acpi_operand_object * object, u16 action)
{
acpi_status status = AE_OK;
union acpi_generic_state *state_list = NULL;
union acpi_operand_object *next_object = NULL;
union acpi_generic_state *state;
acpi_native_uint i;
ACPI_FUNCTION_TRACE_PTR ("ut_update_object_reference", object);
acpi_status status = AE_OK;
union acpi_generic_state *state_list = NULL;
union acpi_operand_object *next_object = NULL;
union acpi_generic_state *state;
acpi_native_uint i;
ACPI_FUNCTION_TRACE_PTR("ut_update_object_reference", object);
while (object) {
/* Make sure that this isn't a namespace handle */
if (ACPI_GET_DESCRIPTOR_TYPE (object) == ACPI_DESC_TYPE_NAMED) {
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Object %p is NS handle\n", object));
return_ACPI_STATUS (AE_OK);
if (ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED) {
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Object %p is NS handle\n", object));
return_ACPI_STATUS(AE_OK);
}
/*
* All sub-objects must have their reference count incremented also.
* Different object types have different subobjects.
*/
switch (ACPI_GET_OBJECT_TYPE (object)) {
switch (ACPI_GET_OBJECT_TYPE(object)) {
case ACPI_TYPE_DEVICE:
acpi_ut_update_ref_count (object->device.system_notify, action);
acpi_ut_update_ref_count (object->device.device_notify, action);
acpi_ut_update_ref_count(object->device.system_notify,
action);
acpi_ut_update_ref_count(object->device.device_notify,
action);
break;
case ACPI_TYPE_PACKAGE:
@@ -476,9 +448,11 @@ acpi_ut_update_object_reference (
* Note: There can be null elements within the package,
* these are simply ignored
*/
status = acpi_ut_create_update_state_and_push (
object->package.elements[i], action, &state_list);
if (ACPI_FAILURE (status)) {
status =
acpi_ut_create_update_state_and_push
(object->package.elements[i], action,
&state_list);
if (ACPI_FAILURE(status)) {
goto error_exit;
}
}
@@ -497,9 +471,13 @@ acpi_ut_update_object_reference (
case ACPI_TYPE_LOCAL_BANK_FIELD:
next_object = object->bank_field.bank_obj;
status = acpi_ut_create_update_state_and_push (
object->bank_field.region_obj, action, &state_list);
if (ACPI_FAILURE (status)) {
status =
acpi_ut_create_update_state_and_push(object->
bank_field.
region_obj,
action,
&state_list);
if (ACPI_FAILURE(status)) {
goto error_exit;
}
break;
@@ -507,9 +485,13 @@ acpi_ut_update_object_reference (
case ACPI_TYPE_LOCAL_INDEX_FIELD:
next_object = object->index_field.index_obj;
status = acpi_ut_create_update_state_and_push (
object->index_field.data_obj, action, &state_list);
if (ACPI_FAILURE (status)) {
status =
acpi_ut_create_update_state_and_push(object->
index_field.
data_obj,
action,
&state_list);
if (ACPI_FAILURE(status)) {
goto error_exit;
}
break;
@@ -526,7 +508,7 @@ acpi_ut_update_object_reference (
case ACPI_TYPE_REGION:
default:
break;/* No subobjects */
break; /* No subobjects */
}
/*
@@ -534,7 +516,7 @@ acpi_ut_update_object_reference (
* happen after we update the sub-objects in case this causes the
* main object to be deleted.
*/
acpi_ut_update_ref_count (object, action);
acpi_ut_update_ref_count(object, action);
object = NULL;
/* Move on to the next object to be updated */
@@ -542,25 +524,23 @@ acpi_ut_update_object_reference (
if (next_object) {
object = next_object;
next_object = NULL;
}
else if (state_list) {
state = acpi_ut_pop_generic_state (&state_list);
} else if (state_list) {
state = acpi_ut_pop_generic_state(&state_list);
object = state->update.object;
acpi_ut_delete_generic_state (state);
acpi_ut_delete_generic_state(state);
}
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
error_exit:
error_exit:
ACPI_REPORT_ERROR (("Could not update object reference count, %s\n",
acpi_format_exception (status)));
ACPI_REPORT_ERROR(("Could not update object reference count, %s\n",
acpi_format_exception(status)));
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_add_reference
@@ -574,31 +554,27 @@ error_exit:
*
******************************************************************************/
void
acpi_ut_add_reference (
union acpi_operand_object *object)
void acpi_ut_add_reference(union acpi_operand_object *object)
{
ACPI_FUNCTION_TRACE_PTR ("ut_add_reference", object);
ACPI_FUNCTION_TRACE_PTR("ut_add_reference", object);
/* Ensure that we have a valid object */
if (!acpi_ut_valid_internal_object (object)) {
if (!acpi_ut_valid_internal_object(object)) {
return_VOID;
}
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Current Refs=%X [To Be Incremented]\n",
object, object->common.reference_count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Obj %p Current Refs=%X [To Be Incremented]\n",
object, object->common.reference_count));
/* Increment the reference count */
(void) acpi_ut_update_object_reference (object, REF_INCREMENT);
(void)acpi_ut_update_object_reference(object, REF_INCREMENT);
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_remove_reference
@@ -611,13 +587,10 @@ acpi_ut_add_reference (
*
******************************************************************************/
void
acpi_ut_remove_reference (
union acpi_operand_object *object)
void acpi_ut_remove_reference(union acpi_operand_object *object)
{
ACPI_FUNCTION_TRACE_PTR ("ut_remove_reference", object);
ACPI_FUNCTION_TRACE_PTR("ut_remove_reference", object);
/*
* Allow a NULL pointer to be passed in, just ignore it. This saves
@@ -625,27 +598,25 @@ acpi_ut_remove_reference (
*
*/
if (!object ||
(ACPI_GET_DESCRIPTOR_TYPE (object) == ACPI_DESC_TYPE_NAMED)) {
(ACPI_GET_DESCRIPTOR_TYPE(object) == ACPI_DESC_TYPE_NAMED)) {
return_VOID;
}
/* Ensure that we have a valid object */
if (!acpi_ut_valid_internal_object (object)) {
if (!acpi_ut_valid_internal_object(object)) {
return_VOID;
}
ACPI_DEBUG_PRINT ((ACPI_DB_ALLOCATIONS,
"Obj %p Current Refs=%X [To Be Decremented]\n",
object, object->common.reference_count));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS,
"Obj %p Current Refs=%X [To Be Decremented]\n",
object, object->common.reference_count));
/*
* Decrement the reference count, and only actually delete the object
* if the reference count becomes 0. (Must also decrement the ref count
* of all subobjects!)
*/
(void) acpi_ut_update_object_reference (object, REF_DECREMENT);
(void)acpi_ut_update_object_reference(object, REF_DECREMENT);
return_VOID;
}

394
drivers/acpi/utilities/uteval.c
View File

@@ -41,28 +41,20 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#include <acpi/acnamesp.h>
#include <acpi/acinterp.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("uteval")
ACPI_MODULE_NAME("uteval")
/* Local prototypes */
static void
acpi_ut_copy_id_string (
char *destination,
char *source,
acpi_size max_length);
acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length);
static acpi_status
acpi_ut_translate_one_cid (
union acpi_operand_object *obj_desc,
struct acpi_compatible_id *one_cid);
acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
struct acpi_compatible_id *one_cid);
/*******************************************************************************
*
@@ -77,37 +69,33 @@ acpi_ut_translate_one_cid (
*
******************************************************************************/
acpi_status
acpi_ut_osi_implementation (
struct acpi_walk_state *walk_state)
acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state)
{
union acpi_operand_object *string_desc;
union acpi_operand_object *return_desc;
acpi_native_uint i;
ACPI_FUNCTION_TRACE ("ut_osi_implementation");
union acpi_operand_object *string_desc;
union acpi_operand_object *return_desc;
acpi_native_uint i;
ACPI_FUNCTION_TRACE("ut_osi_implementation");
/* Validate the string input argument */
string_desc = walk_state->arguments[0].object;
if (!string_desc || (string_desc->common.type != ACPI_TYPE_STRING)) {
return_ACPI_STATUS (AE_TYPE);
return_ACPI_STATUS(AE_TYPE);
}
/* Create a return object (Default value = 0) */
return_desc = acpi_ut_create_internal_object (ACPI_TYPE_INTEGER);
return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
if (!return_desc) {
return_ACPI_STATUS (AE_NO_MEMORY);
return_ACPI_STATUS(AE_NO_MEMORY);
}
/* Compare input string to table of supported strings */
for (i = 0; i < ACPI_NUM_OSI_STRINGS; i++) {
if (!ACPI_STRCMP (string_desc->string.pointer,
(char *) acpi_gbl_valid_osi_strings[i])) {
if (!ACPI_STRCMP(string_desc->string.pointer,
(char *)acpi_gbl_valid_osi_strings[i])) {
/* This string is supported */
return_desc->integer.value = 0xFFFFFFFF;
@@ -116,10 +104,9 @@ acpi_ut_osi_implementation (
}
walk_state->return_desc = return_desc;
return_ACPI_STATUS (AE_CTRL_TERMINATE);
return_ACPI_STATUS(AE_CTRL_TERMINATE);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_evaluate_object
@@ -140,19 +127,16 @@ acpi_ut_osi_implementation (
******************************************************************************/
acpi_status
acpi_ut_evaluate_object (
struct acpi_namespace_node *prefix_node,
char *path,
u32 expected_return_btypes,
union acpi_operand_object **return_desc)
acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
char *path,
u32 expected_return_btypes,
union acpi_operand_object **return_desc)
{
struct acpi_parameter_info info;
acpi_status status;
u32 return_btype;
ACPI_FUNCTION_TRACE ("ut_evaluate_object");
struct acpi_parameter_info info;
acpi_status status;
u32 return_btype;
ACPI_FUNCTION_TRACE("ut_evaluate_object");
info.node = prefix_node;
info.parameters = NULL;
@@ -160,36 +144,38 @@ acpi_ut_evaluate_object (
/* Evaluate the object/method */
status = acpi_ns_evaluate_relative (path, &info);
if (ACPI_FAILURE (status)) {
status = acpi_ns_evaluate_relative(path, &info);
if (ACPI_FAILURE(status)) {
if (status == AE_NOT_FOUND) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s.%s] was not found\n",
acpi_ut_get_node_name (prefix_node), path));
}
else {
ACPI_REPORT_METHOD_ERROR ("Method execution failed",
prefix_node, path, status);
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[%4.4s.%s] was not found\n",
acpi_ut_get_node_name(prefix_node),
path));
} else {
ACPI_REPORT_METHOD_ERROR("Method execution failed",
prefix_node, path, status);
}
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/* Did we get a return object? */
if (!info.return_object) {
if (expected_return_btypes) {
ACPI_REPORT_METHOD_ERROR ("No object was returned from",
prefix_node, path, AE_NOT_EXIST);
ACPI_REPORT_METHOD_ERROR("No object was returned from",
prefix_node, path,
AE_NOT_EXIST);
return_ACPI_STATUS (AE_NOT_EXIST);
return_ACPI_STATUS(AE_NOT_EXIST);
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
/* Map the return object type to the bitmapped type */
switch (ACPI_GET_OBJECT_TYPE (info.return_object)) {
switch (ACPI_GET_OBJECT_TYPE(info.return_object)) {
case ACPI_TYPE_INTEGER:
return_btype = ACPI_BTYPE_INTEGER;
break;
@@ -211,41 +197,41 @@ acpi_ut_evaluate_object (
break;
}
if ((acpi_gbl_enable_interpreter_slack) &&
(!expected_return_btypes)) {
if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
/*
* We received a return object, but one was not expected. This can
* happen frequently if the "implicit return" feature is enabled.
* Just delete the return object and return AE_OK.
*/
acpi_ut_remove_reference (info.return_object);
return_ACPI_STATUS (AE_OK);
acpi_ut_remove_reference(info.return_object);
return_ACPI_STATUS(AE_OK);
}
/* Is the return object one of the expected types? */
if (!(expected_return_btypes & return_btype)) {
ACPI_REPORT_METHOD_ERROR ("Return object type is incorrect",
prefix_node, path, AE_TYPE);
ACPI_REPORT_METHOD_ERROR("Return object type is incorrect",
prefix_node, path, AE_TYPE);
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Type returned from %s was incorrect: %s, expected Btypes: %X\n",
path, acpi_ut_get_object_type_name (info.return_object),
expected_return_btypes));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Type returned from %s was incorrect: %s, expected Btypes: %X\n",
path,
acpi_ut_get_object_type_name(info.
return_object),
expected_return_btypes));
/* On error exit, we must delete the return object */
acpi_ut_remove_reference (info.return_object);
return_ACPI_STATUS (AE_TYPE);
acpi_ut_remove_reference(info.return_object);
return_ACPI_STATUS(AE_TYPE);
}
/* Object type is OK, return it */
*return_desc = info.return_object;
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_evaluate_numeric_object
@@ -264,22 +250,19 @@ acpi_ut_evaluate_object (
******************************************************************************/
acpi_status
acpi_ut_evaluate_numeric_object (
char *object_name,
struct acpi_namespace_node *device_node,
acpi_integer *address)
acpi_ut_evaluate_numeric_object(char *object_name,
struct acpi_namespace_node *device_node,
acpi_integer * address)
{
union acpi_operand_object *obj_desc;
acpi_status status;
union acpi_operand_object *obj_desc;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_evaluate_numeric_object");
ACPI_FUNCTION_TRACE ("ut_evaluate_numeric_object");
status = acpi_ut_evaluate_object (device_node, object_name,
ACPI_BTYPE_INTEGER, &obj_desc);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_evaluate_object(device_node, object_name,
ACPI_BTYPE_INTEGER, &obj_desc);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/* Get the returned Integer */
@@ -288,11 +271,10 @@ acpi_ut_evaluate_numeric_object (
/* On exit, we must delete the return object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
acpi_ut_remove_reference(obj_desc);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_copy_id_string
@@ -310,10 +292,7 @@ acpi_ut_evaluate_numeric_object (
******************************************************************************/
static void
acpi_ut_copy_id_string (
char *destination,
char *source,
acpi_size max_length)
acpi_ut_copy_id_string(char *destination, char *source, acpi_size max_length)
{
/*
@@ -328,10 +307,9 @@ acpi_ut_copy_id_string (
/* Do the actual copy */
ACPI_STRNCPY (destination, source, max_length);
ACPI_STRNCPY(destination, source, max_length);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_execute_HID
@@ -349,42 +327,39 @@ acpi_ut_copy_id_string (
******************************************************************************/
acpi_status
acpi_ut_execute_HID (
struct acpi_namespace_node *device_node,
struct acpi_device_id *hid)
acpi_ut_execute_HID(struct acpi_namespace_node *device_node,
struct acpi_device_id *hid)
{
union acpi_operand_object *obj_desc;
acpi_status status;
union acpi_operand_object *obj_desc;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_execute_HID");
ACPI_FUNCTION_TRACE ("ut_execute_HID");
status = acpi_ut_evaluate_object (device_node, METHOD_NAME__HID,
ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING, &obj_desc);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_evaluate_object(device_node, METHOD_NAME__HID,
ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
&obj_desc);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_INTEGER) {
if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
/* Convert the Numeric HID to string */
acpi_ex_eisa_id_to_string ((u32) obj_desc->integer.value, hid->value);
}
else {
acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
hid->value);
} else {
/* Copy the String HID from the returned object */
acpi_ut_copy_id_string (hid->value, obj_desc->string.pointer,
sizeof (hid->value));
acpi_ut_copy_id_string(hid->value, obj_desc->string.pointer,
sizeof(hid->value));
}
/* On exit, we must delete the return object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
acpi_ut_remove_reference(obj_desc);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_translate_one_cid
@@ -403,18 +378,17 @@ acpi_ut_execute_HID (
******************************************************************************/
static acpi_status
acpi_ut_translate_one_cid (
union acpi_operand_object *obj_desc,
struct acpi_compatible_id *one_cid)
acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
struct acpi_compatible_id *one_cid)
{
switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
switch (ACPI_GET_OBJECT_TYPE(obj_desc)) {
case ACPI_TYPE_INTEGER:
/* Convert the Numeric CID to string */
acpi_ex_eisa_id_to_string ((u32) obj_desc->integer.value, one_cid->value);
acpi_ex_eisa_id_to_string((u32) obj_desc->integer.value,
one_cid->value);
return (AE_OK);
case ACPI_TYPE_STRING:
@@ -425,8 +399,8 @@ acpi_ut_translate_one_cid (
/* Copy the String CID from the returned object */
acpi_ut_copy_id_string (one_cid->value, obj_desc->string.pointer,
ACPI_MAX_CID_LENGTH);
acpi_ut_copy_id_string(one_cid->value, obj_desc->string.pointer,
ACPI_MAX_CID_LENGTH);
return (AE_OK);
default:
@@ -435,7 +409,6 @@ acpi_ut_translate_one_cid (
}
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_execute_CID
@@ -453,45 +426,42 @@ acpi_ut_translate_one_cid (
******************************************************************************/
acpi_status
acpi_ut_execute_CID (
struct acpi_namespace_node *device_node,
struct acpi_compatible_id_list **return_cid_list)
acpi_ut_execute_CID(struct acpi_namespace_node * device_node,
struct acpi_compatible_id_list ** return_cid_list)
{
union acpi_operand_object *obj_desc;
acpi_status status;
u32 count;
u32 size;
union acpi_operand_object *obj_desc;
acpi_status status;
u32 count;
u32 size;
struct acpi_compatible_id_list *cid_list;
acpi_native_uint i;
ACPI_FUNCTION_TRACE ("ut_execute_CID");
acpi_native_uint i;
ACPI_FUNCTION_TRACE("ut_execute_CID");
/* Evaluate the _CID method for this device */
status = acpi_ut_evaluate_object (device_node, METHOD_NAME__CID,
ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING | ACPI_BTYPE_PACKAGE,
&obj_desc);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_evaluate_object(device_node, METHOD_NAME__CID,
ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING
| ACPI_BTYPE_PACKAGE, &obj_desc);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/* Get the number of _CIDs returned */
count = 1;
if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_PACKAGE) {
if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_PACKAGE) {
count = obj_desc->package.count;
}
/* Allocate a worst-case buffer for the _CIDs */
size = (((count - 1) * sizeof (struct acpi_compatible_id)) +
sizeof (struct acpi_compatible_id_list));
size = (((count - 1) * sizeof(struct acpi_compatible_id)) +
sizeof(struct acpi_compatible_id_list));
cid_list = ACPI_MEM_CALLOCATE ((acpi_size) size);
cid_list = ACPI_MEM_CALLOCATE((acpi_size) size);
if (!cid_list) {
return_ACPI_STATUS (AE_NO_MEMORY);
return_ACPI_STATUS(AE_NO_MEMORY);
}
/* Init CID list */
@@ -508,39 +478,38 @@ acpi_ut_execute_CID (
/* The _CID object can be either a single CID or a package (list) of CIDs */
if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_PACKAGE) {
if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_PACKAGE) {
/* Translate each package element */
for (i = 0; i < count; i++) {
status = acpi_ut_translate_one_cid (obj_desc->package.elements[i],
&cid_list->id[i]);
if (ACPI_FAILURE (status)) {
status =
acpi_ut_translate_one_cid(obj_desc->package.
elements[i],
&cid_list->id[i]);
if (ACPI_FAILURE(status)) {
break;
}
}
}
else {
} else {
/* Only one CID, translate to a string */
status = acpi_ut_translate_one_cid (obj_desc, cid_list->id);
status = acpi_ut_translate_one_cid(obj_desc, cid_list->id);
}
/* Cleanup on error */
if (ACPI_FAILURE (status)) {
ACPI_MEM_FREE (cid_list);
}
else {
if (ACPI_FAILURE(status)) {
ACPI_MEM_FREE(cid_list);
} else {
*return_cid_list = cid_list;
}
/* On exit, we must delete the _CID return object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
acpi_ut_remove_reference(obj_desc);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_execute_UID
@@ -558,42 +527,39 @@ acpi_ut_execute_CID (
******************************************************************************/
acpi_status
acpi_ut_execute_UID (
struct acpi_namespace_node *device_node,
struct acpi_device_id *uid)
acpi_ut_execute_UID(struct acpi_namespace_node *device_node,
struct acpi_device_id *uid)
{
union acpi_operand_object *obj_desc;
acpi_status status;
union acpi_operand_object *obj_desc;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_execute_UID");
ACPI_FUNCTION_TRACE ("ut_execute_UID");
status = acpi_ut_evaluate_object (device_node, METHOD_NAME__UID,
ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING, &obj_desc);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_evaluate_object(device_node, METHOD_NAME__UID,
ACPI_BTYPE_INTEGER | ACPI_BTYPE_STRING,
&obj_desc);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_INTEGER) {
if (ACPI_GET_OBJECT_TYPE(obj_desc) == ACPI_TYPE_INTEGER) {
/* Convert the Numeric UID to string */
acpi_ex_unsigned_integer_to_string (obj_desc->integer.value, uid->value);
}
else {
acpi_ex_unsigned_integer_to_string(obj_desc->integer.value,
uid->value);
} else {
/* Copy the String UID from the returned object */
acpi_ut_copy_id_string (uid->value, obj_desc->string.pointer,
sizeof (uid->value));
acpi_ut_copy_id_string(uid->value, obj_desc->string.pointer,
sizeof(uid->value));
}
/* On exit, we must delete the return object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
acpi_ut_remove_reference(obj_desc);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_execute_STA
@@ -611,30 +577,26 @@ acpi_ut_execute_UID (
******************************************************************************/
acpi_status
acpi_ut_execute_STA (
struct acpi_namespace_node *device_node,
u32 *flags)
acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
{
union acpi_operand_object *obj_desc;
acpi_status status;
union acpi_operand_object *obj_desc;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_execute_STA");
ACPI_FUNCTION_TRACE ("ut_execute_STA");
status = acpi_ut_evaluate_object (device_node, METHOD_NAME__STA,
ACPI_BTYPE_INTEGER, &obj_desc);
if (ACPI_FAILURE (status)) {
status = acpi_ut_evaluate_object(device_node, METHOD_NAME__STA,
ACPI_BTYPE_INTEGER, &obj_desc);
if (ACPI_FAILURE(status)) {
if (AE_NOT_FOUND == status) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"_STA on %4.4s was not found, assuming device is present\n",
acpi_ut_get_node_name (device_node)));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"_STA on %4.4s was not found, assuming device is present\n",
acpi_ut_get_node_name(device_node)));
*flags = 0x0F;
status = AE_OK;
}
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/* Extract the status flags */
@@ -643,11 +605,10 @@ acpi_ut_execute_STA (
/* On exit, we must delete the return object */
acpi_ut_remove_reference (obj_desc);
return_ACPI_STATUS (status);
acpi_ut_remove_reference(obj_desc);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_execute_Sxds
@@ -665,44 +626,45 @@ acpi_ut_execute_STA (
******************************************************************************/
acpi_status
acpi_ut_execute_sxds (
struct acpi_namespace_node *device_node,
u8 *highest)
acpi_ut_execute_sxds(struct acpi_namespace_node *device_node, u8 * highest)
{
union acpi_operand_object *obj_desc;
acpi_status status;
u32 i;
ACPI_FUNCTION_TRACE ("ut_execute_Sxds");
union acpi_operand_object *obj_desc;
acpi_status status;
u32 i;
ACPI_FUNCTION_TRACE("ut_execute_Sxds");
for (i = 0; i < 4; i++) {
highest[i] = 0xFF;
status = acpi_ut_evaluate_object (device_node,
(char *) acpi_gbl_highest_dstate_names[i],
ACPI_BTYPE_INTEGER, &obj_desc);
if (ACPI_FAILURE (status)) {
status = acpi_ut_evaluate_object(device_node,
(char *)
acpi_gbl_highest_dstate_names
[i], ACPI_BTYPE_INTEGER,
&obj_desc);
if (ACPI_FAILURE(status)) {
if (status != AE_NOT_FOUND) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"%s on Device %4.4s, %s\n",
(char *) acpi_gbl_highest_dstate_names[i],
acpi_ut_get_node_name (device_node),
acpi_format_exception (status)));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"%s on Device %4.4s, %s\n",
(char *)
acpi_gbl_highest_dstate_names
[i],
acpi_ut_get_node_name
(device_node),
acpi_format_exception
(status)));
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
}
else {
} else {
/* Extract the Dstate value */
highest[i] = (u8) obj_desc->integer.value;
/* Delete the return object */
acpi_ut_remove_reference (obj_desc);
acpi_ut_remove_reference(obj_desc);
}
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}

551
drivers/acpi/utilities/utglobal.c
View File

@@ -48,8 +48,7 @@
#include <acpi/acnamesp.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utglobal")
ACPI_MODULE_NAME("utglobal")
/*******************************************************************************
*
@@ -63,17 +62,12 @@
* DESCRIPTION: This function translates an ACPI exception into an ASCII string.
*
******************************************************************************/
const char *
acpi_format_exception (
acpi_status status)
const char *acpi_format_exception(acpi_status status)
{
acpi_status sub_status;
const char *exception = NULL;
ACPI_FUNCTION_NAME ("format_exception");
acpi_status sub_status;
const char *exception = NULL;
ACPI_FUNCTION_NAME("format_exception");
sub_status = (status & ~AE_CODE_MASK);
@@ -81,35 +75,39 @@ acpi_format_exception (
case AE_CODE_ENVIRONMENTAL:
if (sub_status <= AE_CODE_ENV_MAX) {
exception = acpi_gbl_exception_names_env [sub_status];
exception = acpi_gbl_exception_names_env[sub_status];
}
break;
case AE_CODE_PROGRAMMER:
if (sub_status <= AE_CODE_PGM_MAX) {
exception = acpi_gbl_exception_names_pgm [sub_status -1];
exception =
acpi_gbl_exception_names_pgm[sub_status - 1];
}
break;
case AE_CODE_ACPI_TABLES:
if (sub_status <= AE_CODE_TBL_MAX) {
exception = acpi_gbl_exception_names_tbl [sub_status -1];
exception =
acpi_gbl_exception_names_tbl[sub_status - 1];
}
break;
case AE_CODE_AML:
if (sub_status <= AE_CODE_AML_MAX) {
exception = acpi_gbl_exception_names_aml [sub_status -1];
exception =
acpi_gbl_exception_names_aml[sub_status - 1];
}
break;
case AE_CODE_CONTROL:
if (sub_status <= AE_CODE_CTRL_MAX) {
exception = acpi_gbl_exception_names_ctrl [sub_status -1];
exception =
acpi_gbl_exception_names_ctrl[sub_status - 1];
}
break;
@@ -120,16 +118,15 @@ acpi_format_exception (
if (!exception) {
/* Exception code was not recognized */
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Unknown exception code: 0x%8.8X\n", status));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Unknown exception code: 0x%8.8X\n", status));
return ((const char *) "UNKNOWN_STATUS_CODE");
return ((const char *)"UNKNOWN_STATUS_CODE");
}
return ((const char *) exception);
return ((const char *)exception);
}
/*******************************************************************************
*
* Static global variable initialization.
@@ -142,34 +139,32 @@ acpi_format_exception (
*/
/* Debug switch - level and trace mask */
u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
u32 acpi_dbg_level = ACPI_DEBUG_DEFAULT;
EXPORT_SYMBOL(acpi_dbg_level);
/* Debug switch - layer (component) mask */
u32 acpi_dbg_layer = ACPI_COMPONENT_DEFAULT | ACPI_ALL_DRIVERS;
u32 acpi_dbg_layer = ACPI_COMPONENT_DEFAULT | ACPI_ALL_DRIVERS;
EXPORT_SYMBOL(acpi_dbg_layer);
u32 acpi_gbl_nesting_level = 0;
u32 acpi_gbl_nesting_level = 0;
/* Debugger globals */
u8 acpi_gbl_db_terminate_threads = FALSE;
u8 acpi_gbl_abort_method = FALSE;
u8 acpi_gbl_method_executing = FALSE;
u8 acpi_gbl_db_terminate_threads = FALSE;
u8 acpi_gbl_abort_method = FALSE;
u8 acpi_gbl_method_executing = FALSE;
/* System flags */
u32 acpi_gbl_startup_flags = 0;
u32 acpi_gbl_startup_flags = 0;
/* System starts uninitialized */
u8 acpi_gbl_shutdown = TRUE;
u8 acpi_gbl_shutdown = TRUE;
const u8 acpi_gbl_decode_to8bit [8] = {1,2,4,8,16,32,64,128};
const u8 acpi_gbl_decode_to8bit[8] = { 1, 2, 4, 8, 16, 32, 64, 128 };
const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] =
{
const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COUNT] = {
"\\_S0_",
"\\_S1_",
"\\_S2_",
@@ -178,8 +173,7 @@ const char *acpi_gbl_sleep_state_names[ACPI_S_STATE_COU
"\\_S5_"
};
const char *acpi_gbl_highest_dstate_names[4] =
{
const char *acpi_gbl_highest_dstate_names[4] = {
"_S1D",
"_S2D",
"_S3D",
@@ -190,8 +184,7 @@ const char *acpi_gbl_highest_dstate_names[4] =
* Strings supported by the _OSI predefined (internal) method.
* When adding strings, be sure to update ACPI_NUM_OSI_STRINGS.
*/
const char *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STRINGS] =
{
const char *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STRINGS] = {
/* Operating System Vendor Strings */
"Linux",
@@ -209,7 +202,6 @@ const char *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STR
"Extended Address Space Descriptor"
};
/*******************************************************************************
*
* Namespace globals
@@ -225,74 +217,70 @@ const char *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STR
* 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
* perform a Notify() operation on it.
*/
const struct acpi_predefined_names acpi_gbl_pre_defined_names[] =
{ {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_SB_", ACPI_TYPE_DEVICE, NULL},
{"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_TZ_", ACPI_TYPE_THERMAL, NULL},
{"_REV", ACPI_TYPE_INTEGER, (char *) ACPI_CA_SUPPORT_LEVEL},
{"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
{"_GL_", ACPI_TYPE_MUTEX, (char *) 1},
const struct acpi_predefined_names acpi_gbl_pre_defined_names[] =
{ {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_SB_", ACPI_TYPE_DEVICE, NULL},
{"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_TZ_", ACPI_TYPE_THERMAL, NULL},
{"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL},
{"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
{"_GL_", ACPI_TYPE_MUTEX, (char *)1},
#if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
{"_OSI", ACPI_TYPE_METHOD, (char *) 1},
{"_OSI", ACPI_TYPE_METHOD, (char *)1},
#endif
/* Table terminator */
{NULL, ACPI_TYPE_ANY, NULL}
{NULL, ACPI_TYPE_ANY, NULL}
};
/*
* Properties of the ACPI Object Types, both internal and external.
* The table is indexed by values of acpi_object_type
*/
const u8 acpi_gbl_ns_properties[] =
{
ACPI_NS_NORMAL, /* 00 Any */
ACPI_NS_NORMAL, /* 01 Number */
ACPI_NS_NORMAL, /* 02 String */
ACPI_NS_NORMAL, /* 03 Buffer */
ACPI_NS_NORMAL, /* 04 Package */
ACPI_NS_NORMAL, /* 05 field_unit */
ACPI_NS_NEWSCOPE, /* 06 Device */
ACPI_NS_NORMAL, /* 07 Event */
ACPI_NS_NEWSCOPE, /* 08 Method */
ACPI_NS_NORMAL, /* 09 Mutex */
ACPI_NS_NORMAL, /* 10 Region */
ACPI_NS_NEWSCOPE, /* 11 Power */
ACPI_NS_NEWSCOPE, /* 12 Processor */
ACPI_NS_NEWSCOPE, /* 13 Thermal */
ACPI_NS_NORMAL, /* 14 buffer_field */
ACPI_NS_NORMAL, /* 15 ddb_handle */
ACPI_NS_NORMAL, /* 16 Debug Object */
ACPI_NS_NORMAL, /* 17 def_field */
ACPI_NS_NORMAL, /* 18 bank_field */
ACPI_NS_NORMAL, /* 19 index_field */
ACPI_NS_NORMAL, /* 20 Reference */
ACPI_NS_NORMAL, /* 21 Alias */
ACPI_NS_NORMAL, /* 22 method_alias */
ACPI_NS_NORMAL, /* 23 Notify */
ACPI_NS_NORMAL, /* 24 Address Handler */
ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
ACPI_NS_NEWSCOPE, /* 27 Scope */
ACPI_NS_NORMAL, /* 28 Extra */
ACPI_NS_NORMAL, /* 29 Data */
ACPI_NS_NORMAL /* 30 Invalid */
const u8 acpi_gbl_ns_properties[] = {
ACPI_NS_NORMAL, /* 00 Any */
ACPI_NS_NORMAL, /* 01 Number */
ACPI_NS_NORMAL, /* 02 String */
ACPI_NS_NORMAL, /* 03 Buffer */
ACPI_NS_NORMAL, /* 04 Package */
ACPI_NS_NORMAL, /* 05 field_unit */
ACPI_NS_NEWSCOPE, /* 06 Device */
ACPI_NS_NORMAL, /* 07 Event */
ACPI_NS_NEWSCOPE, /* 08 Method */
ACPI_NS_NORMAL, /* 09 Mutex */
ACPI_NS_NORMAL, /* 10 Region */
ACPI_NS_NEWSCOPE, /* 11 Power */
ACPI_NS_NEWSCOPE, /* 12 Processor */
ACPI_NS_NEWSCOPE, /* 13 Thermal */
ACPI_NS_NORMAL, /* 14 buffer_field */
ACPI_NS_NORMAL, /* 15 ddb_handle */
ACPI_NS_NORMAL, /* 16 Debug Object */
ACPI_NS_NORMAL, /* 17 def_field */
ACPI_NS_NORMAL, /* 18 bank_field */
ACPI_NS_NORMAL, /* 19 index_field */
ACPI_NS_NORMAL, /* 20 Reference */
ACPI_NS_NORMAL, /* 21 Alias */
ACPI_NS_NORMAL, /* 22 method_alias */
ACPI_NS_NORMAL, /* 23 Notify */
ACPI_NS_NORMAL, /* 24 Address Handler */
ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */
ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */
ACPI_NS_NEWSCOPE, /* 27 Scope */
ACPI_NS_NORMAL, /* 28 Extra */
ACPI_NS_NORMAL, /* 29 Data */
ACPI_NS_NORMAL /* 30 Invalid */
};
/* Hex to ASCII conversion table */
static const char acpi_gbl_hex_to_ascii[] =
{
'0','1','2','3','4','5','6','7',
'8','9','A','B','C','D','E','F'
static const char acpi_gbl_hex_to_ascii[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
/*******************************************************************************
*
* FUNCTION: acpi_ut_hex_to_ascii_char
@@ -307,16 +295,12 @@ static const char acpi_gbl_hex_to_ascii[] =
*
******************************************************************************/
char
acpi_ut_hex_to_ascii_char (
acpi_integer integer,
u32 position)
char acpi_ut_hex_to_ascii_char(acpi_integer integer, u32 position)
{
return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]);
}
/*******************************************************************************
*
* Table name globals
@@ -330,67 +314,139 @@ acpi_ut_hex_to_ascii_char (
*
******************************************************************************/
struct acpi_table_list acpi_gbl_table_lists[NUM_ACPI_TABLE_TYPES];
struct acpi_table_list acpi_gbl_table_lists[NUM_ACPI_TABLE_TYPES];
struct acpi_table_support acpi_gbl_table_data[NUM_ACPI_TABLE_TYPES] =
{
struct acpi_table_support acpi_gbl_table_data[NUM_ACPI_TABLE_TYPES] = {
/*********** Name, Signature, Global typed pointer Signature size, Type How many allowed?, Contains valid AML? */
/* RSDP 0 */ {RSDP_NAME, RSDP_SIG, NULL, sizeof (RSDP_SIG)-1, ACPI_TABLE_ROOT | ACPI_TABLE_SINGLE},
/* DSDT 1 */ {DSDT_SIG, DSDT_SIG, (void *) &acpi_gbl_DSDT, sizeof (DSDT_SIG)-1, ACPI_TABLE_SECONDARY| ACPI_TABLE_SINGLE | ACPI_TABLE_EXECUTABLE},
/* FADT 2 */ {FADT_SIG, FADT_SIG, (void *) &acpi_gbl_FADT, sizeof (FADT_SIG)-1, ACPI_TABLE_PRIMARY | ACPI_TABLE_SINGLE},
/* FACS 3 */ {FACS_SIG, FACS_SIG, (void *) &acpi_gbl_FACS, sizeof (FACS_SIG)-1, ACPI_TABLE_SECONDARY| ACPI_TABLE_SINGLE},
/* PSDT 4 */ {PSDT_SIG, PSDT_SIG, NULL, sizeof (PSDT_SIG)-1, ACPI_TABLE_PRIMARY | ACPI_TABLE_MULTIPLE | ACPI_TABLE_EXECUTABLE},
/* SSDT 5 */ {SSDT_SIG, SSDT_SIG, NULL, sizeof (SSDT_SIG)-1, ACPI_TABLE_PRIMARY | ACPI_TABLE_MULTIPLE | ACPI_TABLE_EXECUTABLE},
/* XSDT 6 */ {XSDT_SIG, XSDT_SIG, NULL, sizeof (RSDT_SIG)-1, ACPI_TABLE_ROOT | ACPI_TABLE_SINGLE},
/* RSDP 0 */ {RSDP_NAME, RSDP_SIG, NULL, sizeof(RSDP_SIG) - 1,
ACPI_TABLE_ROOT | ACPI_TABLE_SINGLE}
,
/* DSDT 1 */ {DSDT_SIG, DSDT_SIG, (void *)&acpi_gbl_DSDT,
sizeof(DSDT_SIG) - 1,
ACPI_TABLE_SECONDARY | ACPI_TABLE_SINGLE |
ACPI_TABLE_EXECUTABLE}
,
/* FADT 2 */ {FADT_SIG, FADT_SIG, (void *)&acpi_gbl_FADT,
sizeof(FADT_SIG) - 1,
ACPI_TABLE_PRIMARY | ACPI_TABLE_SINGLE}
,
/* FACS 3 */ {FACS_SIG, FACS_SIG, (void *)&acpi_gbl_FACS,
sizeof(FACS_SIG) - 1,
ACPI_TABLE_SECONDARY | ACPI_TABLE_SINGLE}
,
/* PSDT 4 */ {PSDT_SIG, PSDT_SIG, NULL, sizeof(PSDT_SIG) - 1,
ACPI_TABLE_PRIMARY | ACPI_TABLE_MULTIPLE |
ACPI_TABLE_EXECUTABLE}
,
/* SSDT 5 */ {SSDT_SIG, SSDT_SIG, NULL, sizeof(SSDT_SIG) - 1,
ACPI_TABLE_PRIMARY | ACPI_TABLE_MULTIPLE |
ACPI_TABLE_EXECUTABLE}
,
/* XSDT 6 */ {XSDT_SIG, XSDT_SIG, NULL, sizeof(RSDT_SIG) - 1,
ACPI_TABLE_ROOT | ACPI_TABLE_SINGLE}
,
};
/******************************************************************************
*
* Event and Hardware globals
*
******************************************************************************/
struct acpi_bit_register_info acpi_gbl_bit_register_info[ACPI_NUM_BITREG] =
{
struct acpi_bit_register_info acpi_gbl_bit_register_info[ACPI_NUM_BITREG] = {
/* Name Parent Register Register Bit Position Register Bit Mask */
/* ACPI_BITREG_TIMER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_TIMER_STATUS, ACPI_BITMASK_TIMER_STATUS},
/* ACPI_BITREG_BUS_MASTER_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_BUS_MASTER_STATUS, ACPI_BITMASK_BUS_MASTER_STATUS},
/* ACPI_BITREG_GLOBAL_LOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_STATUS},
/* ACPI_BITREG_POWER_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_STATUS},
/* ACPI_BITREG_SLEEP_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_STATUS},
/* ACPI_BITREG_RT_CLOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_STATUS},
/* ACPI_BITREG_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_WAKE_STATUS, ACPI_BITMASK_WAKE_STATUS},
/* ACPI_BITREG_PCIEXP_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS, ACPI_BITPOSITION_PCIEXP_WAKE_STATUS, ACPI_BITMASK_PCIEXP_WAKE_STATUS},
/* ACPI_BITREG_TIMER_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_TIMER_STATUS,
ACPI_BITMASK_TIMER_STATUS},
/* ACPI_BITREG_BUS_MASTER_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_BUS_MASTER_STATUS,
ACPI_BITMASK_BUS_MASTER_STATUS},
/* ACPI_BITREG_GLOBAL_LOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_GLOBAL_LOCK_STATUS,
ACPI_BITMASK_GLOBAL_LOCK_STATUS},
/* ACPI_BITREG_POWER_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_POWER_BUTTON_STATUS,
ACPI_BITMASK_POWER_BUTTON_STATUS},
/* ACPI_BITREG_SLEEP_BUTTON_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_SLEEP_BUTTON_STATUS,
ACPI_BITMASK_SLEEP_BUTTON_STATUS},
/* ACPI_BITREG_RT_CLOCK_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_RT_CLOCK_STATUS,
ACPI_BITMASK_RT_CLOCK_STATUS},
/* ACPI_BITREG_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_WAKE_STATUS,
ACPI_BITMASK_WAKE_STATUS},
/* ACPI_BITREG_PCIEXP_WAKE_STATUS */ {ACPI_REGISTER_PM1_STATUS,
ACPI_BITPOSITION_PCIEXP_WAKE_STATUS,
ACPI_BITMASK_PCIEXP_WAKE_STATUS},
/* ACPI_BITREG_TIMER_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_TIMER_ENABLE, ACPI_BITMASK_TIMER_ENABLE},
/* ACPI_BITREG_GLOBAL_LOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
/* ACPI_BITREG_POWER_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_ENABLE},
/* ACPI_BITREG_SLEEP_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
/* ACPI_BITREG_RT_CLOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_ENABLE},
/* ACPI_BITREG_WAKE_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, 0, 0},
/* ACPI_BITREG_PCIEXP_WAKE_DISABLE */ {ACPI_REGISTER_PM1_ENABLE, ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE, ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
/* ACPI_BITREG_TIMER_ENABLE */ {ACPI_REGISTER_PM1_ENABLE,
ACPI_BITPOSITION_TIMER_ENABLE,
ACPI_BITMASK_TIMER_ENABLE},
/* ACPI_BITREG_GLOBAL_LOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE,
ACPI_BITPOSITION_GLOBAL_LOCK_ENABLE,
ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
/* ACPI_BITREG_POWER_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE,
ACPI_BITPOSITION_POWER_BUTTON_ENABLE,
ACPI_BITMASK_POWER_BUTTON_ENABLE},
/* ACPI_BITREG_SLEEP_BUTTON_ENABLE */ {ACPI_REGISTER_PM1_ENABLE,
ACPI_BITPOSITION_SLEEP_BUTTON_ENABLE,
ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
/* ACPI_BITREG_RT_CLOCK_ENABLE */ {ACPI_REGISTER_PM1_ENABLE,
ACPI_BITPOSITION_RT_CLOCK_ENABLE,
ACPI_BITMASK_RT_CLOCK_ENABLE},
/* ACPI_BITREG_WAKE_ENABLE */ {ACPI_REGISTER_PM1_ENABLE, 0, 0},
/* ACPI_BITREG_PCIEXP_WAKE_DISABLE */ {ACPI_REGISTER_PM1_ENABLE,
ACPI_BITPOSITION_PCIEXP_WAKE_DISABLE,
ACPI_BITMASK_PCIEXP_WAKE_DISABLE},
/* ACPI_BITREG_SCI_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SCI_ENABLE, ACPI_BITMASK_SCI_ENABLE},
/* ACPI_BITREG_BUS_MASTER_RLD */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_BUS_MASTER_RLD, ACPI_BITMASK_BUS_MASTER_RLD},
/* ACPI_BITREG_GLOBAL_LOCK_RELEASE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE, ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
/* ACPI_BITREG_SLEEP_TYPE_A */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_TYPE_X, ACPI_BITMASK_SLEEP_TYPE_X},
/* ACPI_BITREG_SLEEP_TYPE_B */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_TYPE_X, ACPI_BITMASK_SLEEP_TYPE_X},
/* ACPI_BITREG_SLEEP_ENABLE */ {ACPI_REGISTER_PM1_CONTROL, ACPI_BITPOSITION_SLEEP_ENABLE, ACPI_BITMASK_SLEEP_ENABLE},
/* ACPI_BITREG_SCI_ENABLE */ {ACPI_REGISTER_PM1_CONTROL,
ACPI_BITPOSITION_SCI_ENABLE,
ACPI_BITMASK_SCI_ENABLE},
/* ACPI_BITREG_BUS_MASTER_RLD */ {ACPI_REGISTER_PM1_CONTROL,
ACPI_BITPOSITION_BUS_MASTER_RLD,
ACPI_BITMASK_BUS_MASTER_RLD},
/* ACPI_BITREG_GLOBAL_LOCK_RELEASE */ {ACPI_REGISTER_PM1_CONTROL,
ACPI_BITPOSITION_GLOBAL_LOCK_RELEASE,
ACPI_BITMASK_GLOBAL_LOCK_RELEASE},
/* ACPI_BITREG_SLEEP_TYPE_A */ {ACPI_REGISTER_PM1_CONTROL,
ACPI_BITPOSITION_SLEEP_TYPE_X,
ACPI_BITMASK_SLEEP_TYPE_X},
/* ACPI_BITREG_SLEEP_TYPE_B */ {ACPI_REGISTER_PM1_CONTROL,
ACPI_BITPOSITION_SLEEP_TYPE_X,
ACPI_BITMASK_SLEEP_TYPE_X},
/* ACPI_BITREG_SLEEP_ENABLE */ {ACPI_REGISTER_PM1_CONTROL,
ACPI_BITPOSITION_SLEEP_ENABLE,
ACPI_BITMASK_SLEEP_ENABLE},
/* ACPI_BITREG_ARB_DIS */ {ACPI_REGISTER_PM2_CONTROL, ACPI_BITPOSITION_ARB_DISABLE, ACPI_BITMASK_ARB_DISABLE}
/* ACPI_BITREG_ARB_DIS */ {ACPI_REGISTER_PM2_CONTROL,
ACPI_BITPOSITION_ARB_DISABLE,
ACPI_BITMASK_ARB_DISABLE}
};
struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] =
{
/* ACPI_EVENT_PMTIMER */ {ACPI_BITREG_TIMER_STATUS, ACPI_BITREG_TIMER_ENABLE, ACPI_BITMASK_TIMER_STATUS, ACPI_BITMASK_TIMER_ENABLE},
/* ACPI_EVENT_GLOBAL */ {ACPI_BITREG_GLOBAL_LOCK_STATUS, ACPI_BITREG_GLOBAL_LOCK_ENABLE, ACPI_BITMASK_GLOBAL_LOCK_STATUS, ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
/* ACPI_EVENT_POWER_BUTTON */ {ACPI_BITREG_POWER_BUTTON_STATUS, ACPI_BITREG_POWER_BUTTON_ENABLE, ACPI_BITMASK_POWER_BUTTON_STATUS, ACPI_BITMASK_POWER_BUTTON_ENABLE},
/* ACPI_EVENT_SLEEP_BUTTON */ {ACPI_BITREG_SLEEP_BUTTON_STATUS, ACPI_BITREG_SLEEP_BUTTON_ENABLE, ACPI_BITMASK_SLEEP_BUTTON_STATUS, ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
/* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS, ACPI_BITREG_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_ENABLE},
struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVENTS] = {
/* ACPI_EVENT_PMTIMER */ {ACPI_BITREG_TIMER_STATUS,
ACPI_BITREG_TIMER_ENABLE,
ACPI_BITMASK_TIMER_STATUS,
ACPI_BITMASK_TIMER_ENABLE},
/* ACPI_EVENT_GLOBAL */ {ACPI_BITREG_GLOBAL_LOCK_STATUS,
ACPI_BITREG_GLOBAL_LOCK_ENABLE,
ACPI_BITMASK_GLOBAL_LOCK_STATUS,
ACPI_BITMASK_GLOBAL_LOCK_ENABLE},
/* ACPI_EVENT_POWER_BUTTON */ {ACPI_BITREG_POWER_BUTTON_STATUS,
ACPI_BITREG_POWER_BUTTON_ENABLE,
ACPI_BITMASK_POWER_BUTTON_STATUS,
ACPI_BITMASK_POWER_BUTTON_ENABLE},
/* ACPI_EVENT_SLEEP_BUTTON */ {ACPI_BITREG_SLEEP_BUTTON_STATUS,
ACPI_BITREG_SLEEP_BUTTON_ENABLE,
ACPI_BITMASK_SLEEP_BUTTON_STATUS,
ACPI_BITMASK_SLEEP_BUTTON_ENABLE},
/* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS,
ACPI_BITREG_RT_CLOCK_ENABLE,
ACPI_BITMASK_RT_CLOCK_STATUS,
ACPI_BITMASK_RT_CLOCK_ENABLE},
};
/*******************************************************************************
@@ -407,8 +463,7 @@ struct acpi_fixed_event_info acpi_gbl_fixed_event_info[ACPI_NUM_FIXED_EVE
/* Region type decoding */
const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] =
{
const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
/*! [Begin] no source code translation (keep these ASL Keywords as-is) */
"SystemMemory",
"SystemIO",
@@ -421,25 +476,18 @@ const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] =
/*! [End] no source code translation !*/
};
char *
acpi_ut_get_region_name (
u8 space_id)
char *acpi_ut_get_region_name(u8 space_id)
{
if (space_id >= ACPI_USER_REGION_BEGIN)
{
if (space_id >= ACPI_USER_REGION_BEGIN) {
return ("user_defined_region");
}
else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS)
{
} else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
return ("invalid_space_id");
}
return ((char *) acpi_gbl_region_types[space_id]);
return ((char *)acpi_gbl_region_types[space_id]);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_event_name
@@ -454,8 +502,7 @@ acpi_ut_get_region_name (
/* Event type decoding */
static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] =
{
static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
"PM_Timer",
"global_lock",
"power_button",
@@ -463,21 +510,16 @@ static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] =
"real_time_clock",
};
char *
acpi_ut_get_event_name (
u32 event_id)
char *acpi_ut_get_event_name(u32 event_id)
{
if (event_id > ACPI_EVENT_MAX)
{
if (event_id > ACPI_EVENT_MAX) {
return ("invalid_event_iD");
}
return ((char *) acpi_gbl_event_types[event_id]);
return ((char *)acpi_gbl_event_types[event_id]);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_type_name
@@ -498,12 +540,11 @@ acpi_ut_get_event_name (
* when stored in a table it really means that we have thus far seen no
* evidence to indicate what type is actually going to be stored for this entry.
*/
static const char acpi_gbl_bad_type[] = "UNDEFINED";
static const char acpi_gbl_bad_type[] = "UNDEFINED";
/* Printable names of the ACPI object types */
static const char *acpi_gbl_ns_type_names[] =
{
static const char *acpi_gbl_ns_type_names[] = {
/* 00 */ "Untyped",
/* 01 */ "Integer",
/* 02 */ "String",
@@ -537,35 +578,26 @@ static const char *acpi_gbl_ns_type_names[] =
/* 30 */ "Invalid"
};
char *
acpi_ut_get_type_name (
acpi_object_type type)
char *acpi_ut_get_type_name(acpi_object_type type)
{
if (type > ACPI_TYPE_INVALID)
{
return ((char *) acpi_gbl_bad_type);
if (type > ACPI_TYPE_INVALID) {
return ((char *)acpi_gbl_bad_type);
}
return ((char *) acpi_gbl_ns_type_names[type]);
return ((char *)acpi_gbl_ns_type_names[type]);
}
char *
acpi_ut_get_object_type_name (
union acpi_operand_object *obj_desc)
char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc)
{
if (!obj_desc)
{
if (!obj_desc) {
return ("[NULL Object Descriptor]");
}
return (acpi_ut_get_type_name (ACPI_GET_OBJECT_TYPE (obj_desc)));
return (acpi_ut_get_type_name(ACPI_GET_OBJECT_TYPE(obj_desc)));
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_node_name
@@ -578,39 +610,31 @@ acpi_ut_get_object_type_name (
*
******************************************************************************/
char *
acpi_ut_get_node_name (
void *object)
char *acpi_ut_get_node_name(void *object)
{
struct acpi_namespace_node *node = (struct acpi_namespace_node *) object;
struct acpi_namespace_node *node = (struct acpi_namespace_node *)object;
/* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */
if (!object)
{
if (!object) {
return ("NULL");
}
/* Check for Root node */
if ((object == ACPI_ROOT_OBJECT) ||
(object == acpi_gbl_root_node))
{
if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) {
return ("\"\\\" ");
}
/* Descriptor must be a namespace node */
if (node->descriptor != ACPI_DESC_TYPE_NAMED)
{
if (node->descriptor != ACPI_DESC_TYPE_NAMED) {
return ("####");
}
/* Name must be a valid ACPI name */
if (!acpi_ut_valid_acpi_name (* (u32 *) node->name.ascii))
{
if (!acpi_ut_valid_acpi_name(*(u32 *) node->name.ascii)) {
return ("????");
}
@@ -619,7 +643,6 @@ acpi_ut_get_node_name (
return (node->name.ascii);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_descriptor_name
@@ -634,8 +657,7 @@ acpi_ut_get_node_name (
/* Printable names of object descriptor types */
static const char *acpi_gbl_desc_type_names[] =
{
static const char *acpi_gbl_desc_type_names[] = {
/* 00 */ "Invalid",
/* 01 */ "Cached",
/* 02 */ "State-Generic",
@@ -654,27 +676,22 @@ static const char *acpi_gbl_desc_type_names[] =
/* 15 */ "Node"
};
char *
acpi_ut_get_descriptor_name (
void *object)
char *acpi_ut_get_descriptor_name(void *object)
{
if (!object)
{
if (!object) {
return ("NULL OBJECT");
}
if (ACPI_GET_DESCRIPTOR_TYPE (object) > ACPI_DESC_TYPE_MAX)
{
return ((char *) acpi_gbl_bad_type);
if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) {
return ((char *)acpi_gbl_bad_type);
}
return ((char *) acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE (object)]);
return ((char *)
acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE(object)]);
}
#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
/*
* Strings and procedures used for debug only
@@ -693,13 +710,10 @@ acpi_ut_get_descriptor_name (
*
******************************************************************************/
char *
acpi_ut_get_mutex_name (
u32 mutex_id)
char *acpi_ut_get_mutex_name(u32 mutex_id)
{
if (mutex_id > MAX_MUTEX)
{
if (mutex_id > MAX_MUTEX) {
return ("Invalid Mutex ID");
}
@@ -707,7 +721,6 @@ acpi_ut_get_mutex_name (
}
#endif
/*******************************************************************************
*
* FUNCTION: acpi_ut_valid_object_type
@@ -720,13 +733,10 @@ acpi_ut_get_mutex_name (
*
******************************************************************************/
u8
acpi_ut_valid_object_type (
acpi_object_type type)
u8 acpi_ut_valid_object_type(acpi_object_type type)
{
if (type > ACPI_TYPE_LOCAL_MAX)
{
if (type > ACPI_TYPE_LOCAL_MAX) {
/* Note: Assumes all TYPEs are contiguous (external/local) */
return (FALSE);
@@ -735,7 +745,6 @@ acpi_ut_valid_object_type (
return (TRUE);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_init_globals
@@ -749,106 +758,96 @@ acpi_ut_valid_object_type (
*
******************************************************************************/
void
acpi_ut_init_globals (
void)
void acpi_ut_init_globals(void)
{
acpi_status status;
u32 i;
ACPI_FUNCTION_TRACE ("ut_init_globals");
acpi_status status;
u32 i;
ACPI_FUNCTION_TRACE("ut_init_globals");
/* Create all memory caches */
status = acpi_ut_create_caches ();
if (ACPI_FAILURE (status))
{
status = acpi_ut_create_caches();
if (ACPI_FAILURE(status)) {
return;
}
/* ACPI table structure */
for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++)
{
acpi_gbl_table_lists[i].next = NULL;
acpi_gbl_table_lists[i].count = 0;
for (i = 0; i < NUM_ACPI_TABLE_TYPES; i++) {
acpi_gbl_table_lists[i].next = NULL;
acpi_gbl_table_lists[i].count = 0;
}
/* Mutex locked flags */
for (i = 0; i < NUM_MUTEX; i++)
{
acpi_gbl_mutex_info[i].mutex = NULL;
acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
acpi_gbl_mutex_info[i].use_count = 0;
for (i = 0; i < NUM_MUTEX; i++) {
acpi_gbl_mutex_info[i].mutex = NULL;
acpi_gbl_mutex_info[i].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
acpi_gbl_mutex_info[i].use_count = 0;
}
/* GPE support */
acpi_gbl_gpe_xrupt_list_head = NULL;
acpi_gbl_gpe_fadt_blocks[0] = NULL;
acpi_gbl_gpe_fadt_blocks[1] = NULL;
acpi_gbl_gpe_xrupt_list_head = NULL;
acpi_gbl_gpe_fadt_blocks[0] = NULL;
acpi_gbl_gpe_fadt_blocks[1] = NULL;
/* Global notify handlers */
acpi_gbl_system_notify.handler = NULL;
acpi_gbl_device_notify.handler = NULL;
acpi_gbl_exception_handler = NULL;
acpi_gbl_init_handler = NULL;
acpi_gbl_system_notify.handler = NULL;
acpi_gbl_device_notify.handler = NULL;
acpi_gbl_exception_handler = NULL;
acpi_gbl_init_handler = NULL;
/* Global "typed" ACPI table pointers */
acpi_gbl_RSDP = NULL;
acpi_gbl_XSDT = NULL;
acpi_gbl_FACS = NULL;
acpi_gbl_FADT = NULL;
acpi_gbl_DSDT = NULL;
acpi_gbl_RSDP = NULL;
acpi_gbl_XSDT = NULL;
acpi_gbl_FACS = NULL;
acpi_gbl_FADT = NULL;
acpi_gbl_DSDT = NULL;
/* Global Lock support */
acpi_gbl_global_lock_acquired = FALSE;
acpi_gbl_global_lock_thread_count = 0;
acpi_gbl_global_lock_handle = 0;
acpi_gbl_global_lock_acquired = FALSE;
acpi_gbl_global_lock_thread_count = 0;
acpi_gbl_global_lock_handle = 0;
/* Miscellaneous variables */
acpi_gbl_table_flags = ACPI_PHYSICAL_POINTER;
acpi_gbl_rsdp_original_location = 0;
acpi_gbl_cm_single_step = FALSE;
acpi_gbl_db_terminate_threads = FALSE;
acpi_gbl_shutdown = FALSE;
acpi_gbl_ns_lookup_count = 0;
acpi_gbl_ps_find_count = 0;
acpi_gbl_acpi_hardware_present = TRUE;
acpi_gbl_owner_id_mask = 0;
acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
acpi_gbl_table_flags = ACPI_PHYSICAL_POINTER;
acpi_gbl_rsdp_original_location = 0;
acpi_gbl_cm_single_step = FALSE;
acpi_gbl_db_terminate_threads = FALSE;
acpi_gbl_shutdown = FALSE;
acpi_gbl_ns_lookup_count = 0;
acpi_gbl_ps_find_count = 0;
acpi_gbl_acpi_hardware_present = TRUE;
acpi_gbl_owner_id_mask = 0;
acpi_gbl_debugger_configuration = DEBUGGER_THREADING;
acpi_gbl_db_output_flags = ACPI_DB_CONSOLE_OUTPUT;
/* Hardware oriented */
acpi_gbl_events_initialized = FALSE;
acpi_gbl_system_awake_and_running = TRUE;
acpi_gbl_events_initialized = FALSE;
acpi_gbl_system_awake_and_running = TRUE;
/* Namespace */
acpi_gbl_root_node = NULL;
acpi_gbl_root_node = NULL;
acpi_gbl_root_node_struct.name.integer = ACPI_ROOT_NAME;
acpi_gbl_root_node_struct.descriptor = ACPI_DESC_TYPE_NAMED;
acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
acpi_gbl_root_node_struct.child = NULL;
acpi_gbl_root_node_struct.peer = NULL;
acpi_gbl_root_node_struct.object = NULL;
acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
acpi_gbl_root_node_struct.type = ACPI_TYPE_DEVICE;
acpi_gbl_root_node_struct.child = NULL;
acpi_gbl_root_node_struct.peer = NULL;
acpi_gbl_root_node_struct.object = NULL;
acpi_gbl_root_node_struct.flags = ANOBJ_END_OF_PEER_LIST;
#ifdef ACPI_DEBUG_OUTPUT
acpi_gbl_lowest_stack_pointer = ACPI_SIZE_MAX;
acpi_gbl_lowest_stack_pointer = ACPI_SIZE_MAX;
#endif
return_VOID;
}

135
drivers/acpi/utilities/utinit.c
View File

@@ -41,25 +41,18 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#include <acpi/acnamesp.h>
#include <acpi/acevents.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utinit")
ACPI_MODULE_NAME("utinit")
/* Local prototypes */
static void
acpi_ut_fadt_register_error (
char *register_name,
u32 value,
acpi_size offset);
static void acpi_ut_terminate (
void);
acpi_ut_fadt_register_error(char *register_name, u32 value, acpi_size offset);
static void acpi_ut_terminate(void);
/*******************************************************************************
*
@@ -76,18 +69,14 @@ static void acpi_ut_terminate (
******************************************************************************/
static void
acpi_ut_fadt_register_error (
char *register_name,
u32 value,
acpi_size offset)
acpi_ut_fadt_register_error(char *register_name, u32 value, acpi_size offset)
{
ACPI_REPORT_WARNING (
("Invalid FADT value %s=%X at offset %X FADT=%p\n",
register_name, value, (u32) offset, acpi_gbl_FADT));
ACPI_REPORT_WARNING(("Invalid FADT value %s=%X at offset %X FADT=%p\n",
register_name, value, (u32) offset,
acpi_gbl_FADT));
}
/******************************************************************************
*
* FUNCTION: acpi_ut_validate_fadt
@@ -100,9 +89,7 @@ acpi_ut_fadt_register_error (
*
******************************************************************************/
acpi_status
acpi_ut_validate_fadt (
void)
acpi_status acpi_ut_validate_fadt(void)
{
/*
@@ -110,64 +97,66 @@ acpi_ut_validate_fadt (
* but don't abort on any problems, just display error
*/
if (acpi_gbl_FADT->pm1_evt_len < 4) {
acpi_ut_fadt_register_error ("PM1_EVT_LEN",
(u32) acpi_gbl_FADT->pm1_evt_len,
ACPI_FADT_OFFSET (pm1_evt_len));
acpi_ut_fadt_register_error("PM1_EVT_LEN",
(u32) acpi_gbl_FADT->pm1_evt_len,
ACPI_FADT_OFFSET(pm1_evt_len));
}
if (!acpi_gbl_FADT->pm1_cnt_len) {
acpi_ut_fadt_register_error ("PM1_CNT_LEN", 0,
ACPI_FADT_OFFSET (pm1_cnt_len));
acpi_ut_fadt_register_error("PM1_CNT_LEN", 0,
ACPI_FADT_OFFSET(pm1_cnt_len));
}
if (!acpi_gbl_FADT->xpm1a_evt_blk.address) {
acpi_ut_fadt_register_error ("X_PM1a_EVT_BLK", 0,
ACPI_FADT_OFFSET (xpm1a_evt_blk.address));
acpi_ut_fadt_register_error("X_PM1a_EVT_BLK", 0,
ACPI_FADT_OFFSET(xpm1a_evt_blk.
address));
}
if (!acpi_gbl_FADT->xpm1a_cnt_blk.address) {
acpi_ut_fadt_register_error ("X_PM1a_CNT_BLK", 0,
ACPI_FADT_OFFSET (xpm1a_cnt_blk.address));
acpi_ut_fadt_register_error("X_PM1a_CNT_BLK", 0,
ACPI_FADT_OFFSET(xpm1a_cnt_blk.
address));
}
if (!acpi_gbl_FADT->xpm_tmr_blk.address) {
acpi_ut_fadt_register_error ("X_PM_TMR_BLK", 0,
ACPI_FADT_OFFSET (xpm_tmr_blk.address));
acpi_ut_fadt_register_error("X_PM_TMR_BLK", 0,
ACPI_FADT_OFFSET(xpm_tmr_blk.
address));
}
if ((acpi_gbl_FADT->xpm2_cnt_blk.address &&
!acpi_gbl_FADT->pm2_cnt_len)) {
acpi_ut_fadt_register_error ("PM2_CNT_LEN",
(u32) acpi_gbl_FADT->pm2_cnt_len,
ACPI_FADT_OFFSET (pm2_cnt_len));
!acpi_gbl_FADT->pm2_cnt_len)) {
acpi_ut_fadt_register_error("PM2_CNT_LEN",
(u32) acpi_gbl_FADT->pm2_cnt_len,
ACPI_FADT_OFFSET(pm2_cnt_len));
}
if (acpi_gbl_FADT->pm_tm_len < 4) {
acpi_ut_fadt_register_error ("PM_TM_LEN",
(u32) acpi_gbl_FADT->pm_tm_len,
ACPI_FADT_OFFSET (pm_tm_len));
acpi_ut_fadt_register_error("PM_TM_LEN",
(u32) acpi_gbl_FADT->pm_tm_len,
ACPI_FADT_OFFSET(pm_tm_len));
}
/* Length of GPE blocks must be a multiple of 2 */
if (acpi_gbl_FADT->xgpe0_blk.address &&
(acpi_gbl_FADT->gpe0_blk_len & 1)) {
acpi_ut_fadt_register_error ("(x)GPE0_BLK_LEN",
(u32) acpi_gbl_FADT->gpe0_blk_len,
ACPI_FADT_OFFSET (gpe0_blk_len));
(acpi_gbl_FADT->gpe0_blk_len & 1)) {
acpi_ut_fadt_register_error("(x)GPE0_BLK_LEN",
(u32) acpi_gbl_FADT->gpe0_blk_len,
ACPI_FADT_OFFSET(gpe0_blk_len));
}
if (acpi_gbl_FADT->xgpe1_blk.address &&
(acpi_gbl_FADT->gpe1_blk_len & 1)) {
acpi_ut_fadt_register_error ("(x)GPE1_BLK_LEN",
(u32) acpi_gbl_FADT->gpe1_blk_len,
ACPI_FADT_OFFSET (gpe1_blk_len));
(acpi_gbl_FADT->gpe1_blk_len & 1)) {
acpi_ut_fadt_register_error("(x)GPE1_BLK_LEN",
(u32) acpi_gbl_FADT->gpe1_blk_len,
ACPI_FADT_OFFSET(gpe1_blk_len));
}
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: acpi_ut_terminate
@@ -180,18 +169,14 @@ acpi_ut_validate_fadt (
*
******************************************************************************/
static void
acpi_ut_terminate (
void)
static void acpi_ut_terminate(void)
{
struct acpi_gpe_block_info *gpe_block;
struct acpi_gpe_block_info *next_gpe_block;
struct acpi_gpe_xrupt_info *gpe_xrupt_info;
struct acpi_gpe_xrupt_info *next_gpe_xrupt_info;
ACPI_FUNCTION_TRACE ("ut_terminate");
struct acpi_gpe_block_info *gpe_block;
struct acpi_gpe_block_info *next_gpe_block;
struct acpi_gpe_xrupt_info *gpe_xrupt_info;
struct acpi_gpe_xrupt_info *next_gpe_xrupt_info;
ACPI_FUNCTION_TRACE("ut_terminate");
/* Free global tables, etc. */
/* Free global GPE blocks and related info structures */
@@ -201,21 +186,20 @@ acpi_ut_terminate (
gpe_block = gpe_xrupt_info->gpe_block_list_head;
while (gpe_block) {
next_gpe_block = gpe_block->next;
ACPI_MEM_FREE (gpe_block->event_info);
ACPI_MEM_FREE (gpe_block->register_info);
ACPI_MEM_FREE (gpe_block);
ACPI_MEM_FREE(gpe_block->event_info);
ACPI_MEM_FREE(gpe_block->register_info);
ACPI_MEM_FREE(gpe_block);
gpe_block = next_gpe_block;
}
next_gpe_xrupt_info = gpe_xrupt_info->next;
ACPI_MEM_FREE (gpe_xrupt_info);
ACPI_MEM_FREE(gpe_xrupt_info);
gpe_xrupt_info = next_gpe_xrupt_info;
}
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_subsystem_shutdown
@@ -229,50 +213,45 @@ acpi_ut_terminate (
*
******************************************************************************/
void
acpi_ut_subsystem_shutdown (
void)
void acpi_ut_subsystem_shutdown(void)
{
ACPI_FUNCTION_TRACE ("ut_subsystem_shutdown");
ACPI_FUNCTION_TRACE("ut_subsystem_shutdown");
/* Just exit if subsystem is already shutdown */
if (acpi_gbl_shutdown) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"ACPI Subsystem is already terminated\n"));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"ACPI Subsystem is already terminated\n"));
return_VOID;
}
/* Subsystem appears active, go ahead and shut it down */
acpi_gbl_shutdown = TRUE;
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Shutting down ACPI Subsystem...\n"));
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Shutting down ACPI Subsystem...\n"));
/* Close the acpi_event Handling */
acpi_ev_terminate ();
acpi_ev_terminate();
/* Close the Namespace */
acpi_ns_terminate ();
acpi_ns_terminate();
/* Close the globals */
acpi_ut_terminate ();
acpi_ut_terminate();
/* Purge the local caches */
(void) acpi_ut_delete_caches ();
(void)acpi_ut_delete_caches();
/* Debug only - display leftover memory allocation, if any */
#ifdef ACPI_DBG_TRACK_ALLOCATIONS
acpi_ut_dump_allocations (ACPI_UINT32_MAX, NULL);
acpi_ut_dump_allocations(ACPI_UINT32_MAX, NULL);
#endif
return_VOID;
}

142
drivers/acpi/utilities/utmath.c
View File

@@ -41,19 +41,16 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utmath")
ACPI_MODULE_NAME("utmath")
/*
* Support for double-precision integer divide. This code is included here
* in order to support kernel environments where the double-precision math
* library is not available.
*/
#ifndef ACPI_USE_NATIVE_DIVIDE
/*******************************************************************************
*
@@ -71,27 +68,22 @@
* 32-bit remainder.
*
******************************************************************************/
acpi_status
acpi_ut_short_divide (
acpi_integer dividend,
u32 divisor,
acpi_integer *out_quotient,
u32 *out_remainder)
acpi_ut_short_divide(acpi_integer dividend,
u32 divisor,
acpi_integer * out_quotient, u32 * out_remainder)
{
union uint64_overlay dividend_ovl;
union uint64_overlay quotient;
u32 remainder32;
ACPI_FUNCTION_TRACE ("ut_short_divide");
union uint64_overlay dividend_ovl;
union uint64_overlay quotient;
u32 remainder32;
ACPI_FUNCTION_TRACE("ut_short_divide");
/* Always check for a zero divisor */
if (divisor == 0) {
ACPI_REPORT_ERROR (("acpi_ut_short_divide: Divide by zero\n"));
return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
ACPI_REPORT_ERROR(("acpi_ut_short_divide: Divide by zero\n"));
return_ACPI_STATUS(AE_AML_DIVIDE_BY_ZERO);
}
dividend_ovl.full = dividend;
@@ -100,9 +92,9 @@ acpi_ut_short_divide (
* The quotient is 64 bits, the remainder is always 32 bits,
* and is generated by the second divide.
*/
ACPI_DIV_64_BY_32 (0, dividend_ovl.part.hi, divisor,
ACPI_DIV_64_BY_32(0, dividend_ovl.part.hi, divisor,
quotient.part.hi, remainder32);
ACPI_DIV_64_BY_32 (remainder32, dividend_ovl.part.lo, divisor,
ACPI_DIV_64_BY_32(remainder32, dividend_ovl.part.lo, divisor,
quotient.part.lo, remainder32);
/* Return only what was requested */
@@ -114,10 +106,9 @@ acpi_ut_short_divide (
*out_remainder = remainder32;
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_divide
@@ -134,34 +125,30 @@ acpi_ut_short_divide (
******************************************************************************/
acpi_status
acpi_ut_divide (
acpi_integer in_dividend,
acpi_integer in_divisor,
acpi_integer *out_quotient,
acpi_integer *out_remainder)
acpi_ut_divide(acpi_integer in_dividend,
acpi_integer in_divisor,
acpi_integer * out_quotient, acpi_integer * out_remainder)
{
union uint64_overlay dividend;
union uint64_overlay divisor;
union uint64_overlay quotient;
union uint64_overlay remainder;
union uint64_overlay normalized_dividend;
union uint64_overlay normalized_divisor;
u32 partial1;
union uint64_overlay partial2;
union uint64_overlay partial3;
ACPI_FUNCTION_TRACE ("ut_divide");
union uint64_overlay dividend;
union uint64_overlay divisor;
union uint64_overlay quotient;
union uint64_overlay remainder;
union uint64_overlay normalized_dividend;
union uint64_overlay normalized_divisor;
u32 partial1;
union uint64_overlay partial2;
union uint64_overlay partial3;
ACPI_FUNCTION_TRACE("ut_divide");
/* Always check for a zero divisor */
if (in_divisor == 0) {
ACPI_REPORT_ERROR (("acpi_ut_divide: Divide by zero\n"));
return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
ACPI_REPORT_ERROR(("acpi_ut_divide: Divide by zero\n"));
return_ACPI_STATUS(AE_AML_DIVIDE_BY_ZERO);
}
divisor.full = in_divisor;
divisor.full = in_divisor;
dividend.full = in_dividend;
if (divisor.part.hi == 0) {
/*
@@ -174,9 +161,9 @@ acpi_ut_divide (
* The quotient is 64 bits, the remainder is always 32 bits,
* and is generated by the second divide.
*/
ACPI_DIV_64_BY_32 (0, dividend.part.hi, divisor.part.lo,
ACPI_DIV_64_BY_32(0, dividend.part.hi, divisor.part.lo,
quotient.part.hi, partial1);
ACPI_DIV_64_BY_32 (partial1, dividend.part.lo, divisor.part.lo,
ACPI_DIV_64_BY_32(partial1, dividend.part.lo, divisor.part.lo,
quotient.part.lo, remainder.part.lo);
}
@@ -185,23 +172,23 @@ acpi_ut_divide (
* 2) The general case where the divisor is a full 64 bits
* is more difficult
*/
quotient.part.hi = 0;
quotient.part.hi = 0;
normalized_dividend = dividend;
normalized_divisor = divisor;
/* Normalize the operands (shift until the divisor is < 32 bits) */
do {
ACPI_SHIFT_RIGHT_64 (normalized_divisor.part.hi,
normalized_divisor.part.lo);
ACPI_SHIFT_RIGHT_64 (normalized_dividend.part.hi,
normalized_dividend.part.lo);
ACPI_SHIFT_RIGHT_64(normalized_divisor.part.hi,
normalized_divisor.part.lo);
ACPI_SHIFT_RIGHT_64(normalized_dividend.part.hi,
normalized_dividend.part.lo);
} while (normalized_divisor.part.hi != 0);
/* Partial divide */
ACPI_DIV_64_BY_32 (normalized_dividend.part.hi,
ACPI_DIV_64_BY_32(normalized_dividend.part.hi,
normalized_dividend.part.lo,
normalized_divisor.part.lo,
quotient.part.lo, partial1);
@@ -210,8 +197,9 @@ acpi_ut_divide (
* The quotient is always 32 bits, and simply requires adjustment.
* The 64-bit remainder must be generated.
*/
partial1 = quotient.part.lo * divisor.part.hi;
partial2.full = (acpi_integer) quotient.part.lo * divisor.part.lo;
partial1 = quotient.part.lo * divisor.part.hi;
partial2.full =
(acpi_integer) quotient.part.lo * divisor.part.lo;
partial3.full = (acpi_integer) partial2.part.hi + partial1;
remainder.part.hi = partial3.part.lo;
@@ -224,16 +212,15 @@ acpi_ut_divide (
quotient.part.lo--;
remainder.full -= divisor.full;
}
}
else {
} else {
quotient.part.lo--;
remainder.full -= divisor.full;
}
}
remainder.full = remainder.full - dividend.full;
remainder.part.hi = (u32) -((s32) remainder.part.hi);
remainder.part.lo = (u32) -((s32) remainder.part.lo);
remainder.full = remainder.full - dividend.full;
remainder.part.hi = (u32) - ((s32) remainder.part.hi);
remainder.part.lo = (u32) - ((s32) remainder.part.lo);
if (remainder.part.lo) {
remainder.part.hi--;
@@ -250,11 +237,10 @@ acpi_ut_divide (
*out_remainder = remainder.full;
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
#else
/*******************************************************************************
*
* FUNCTION: acpi_ut_short_divide, acpi_ut_divide
@@ -269,23 +255,19 @@ acpi_ut_divide (
* perform the divide.
*
******************************************************************************/
acpi_status
acpi_ut_short_divide (
acpi_integer in_dividend,
u32 divisor,
acpi_integer *out_quotient,
u32 *out_remainder)
acpi_ut_short_divide(acpi_integer in_dividend,
u32 divisor,
acpi_integer * out_quotient, u32 * out_remainder)
{
ACPI_FUNCTION_TRACE ("ut_short_divide");
ACPI_FUNCTION_TRACE("ut_short_divide");
/* Always check for a zero divisor */
if (divisor == 0) {
ACPI_REPORT_ERROR (("acpi_ut_short_divide: Divide by zero\n"));
return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
ACPI_REPORT_ERROR(("acpi_ut_short_divide: Divide by zero\n"));
return_ACPI_STATUS(AE_AML_DIVIDE_BY_ZERO);
}
/* Return only what was requested */
@@ -297,27 +279,23 @@ acpi_ut_short_divide (
*out_remainder = (u32) in_dividend % divisor;
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
acpi_status
acpi_ut_divide (
acpi_integer in_dividend,
acpi_integer in_divisor,
acpi_integer *out_quotient,
acpi_integer *out_remainder)
acpi_ut_divide(acpi_integer in_dividend,
acpi_integer in_divisor,
acpi_integer * out_quotient, acpi_integer * out_remainder)
{
ACPI_FUNCTION_TRACE ("ut_divide");
ACPI_FUNCTION_TRACE("ut_divide");
/* Always check for a zero divisor */
if (in_divisor == 0) {
ACPI_REPORT_ERROR (("acpi_ut_divide: Divide by zero\n"));
return_ACPI_STATUS (AE_AML_DIVIDE_BY_ZERO);
ACPI_REPORT_ERROR(("acpi_ut_divide: Divide by zero\n"));
return_ACPI_STATUS(AE_AML_DIVIDE_BY_ZERO);
}
/* Return only what was requested */
if (out_quotient) {
@@ -327,9 +305,7 @@ acpi_ut_divide (
*out_remainder = in_dividend % in_divisor;
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
#endif

431
drivers/acpi/utilities/utmisc.c
View File

@@ -41,14 +41,11 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#include <acpi/acnamesp.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utmisc")
ACPI_MODULE_NAME("utmisc")
/*******************************************************************************
*
@@ -63,23 +60,18 @@
* when the method exits or the table is unloaded.
*
******************************************************************************/
acpi_status
acpi_ut_allocate_owner_id (
acpi_owner_id *owner_id)
acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id)
{
acpi_native_uint i;
acpi_status status;
ACPI_FUNCTION_TRACE ("ut_allocate_owner_id");
acpi_native_uint i;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_allocate_owner_id");
/* Mutex for the global ID mask */
status = acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/* Find a free owner ID */
@@ -101,15 +93,13 @@ acpi_ut_allocate_owner_id (
*/
*owner_id = 0;
status = AE_OWNER_ID_LIMIT;
ACPI_REPORT_ERROR ((
"Could not allocate new owner_id (32 max), AE_OWNER_ID_LIMIT\n"));
ACPI_REPORT_ERROR(("Could not allocate new owner_id (32 max), AE_OWNER_ID_LIMIT\n"));
exit:
(void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
return_ACPI_STATUS (status);
exit:
(void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_release_owner_id
@@ -124,16 +114,12 @@ exit:
*
******************************************************************************/
void
acpi_ut_release_owner_id (
acpi_owner_id *owner_id_ptr)
void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr)
{
acpi_owner_id owner_id = *owner_id_ptr;
acpi_status status;
ACPI_FUNCTION_TRACE ("ut_release_owner_id");
acpi_owner_id owner_id = *owner_id_ptr;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_release_owner_id");
/* Always clear the input owner_id (zero is an invalid ID) */
@@ -142,18 +128,18 @@ acpi_ut_release_owner_id (
/* Zero is not a valid owner_iD */
if ((owner_id == 0) || (owner_id > 32)) {
ACPI_REPORT_ERROR (("Invalid owner_id: %2.2X\n", owner_id));
ACPI_REPORT_ERROR(("Invalid owner_id: %2.2X\n", owner_id));
return_VOID;
}
/* Mutex for the global ID mask */
status = acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
if (ACPI_FAILURE (status)) {
status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
if (ACPI_FAILURE(status)) {
return_VOID;
}
owner_id--; /* Normalize to zero */
owner_id--; /* Normalize to zero */
/* Free the owner ID only if it is valid */
@@ -161,11 +147,10 @@ acpi_ut_release_owner_id (
acpi_gbl_owner_id_mask ^= (1 << owner_id);
}
(void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
(void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_strupr (strupr)
@@ -180,15 +165,11 @@ acpi_ut_release_owner_id (
*
******************************************************************************/
void
acpi_ut_strupr (
char *src_string)
void acpi_ut_strupr(char *src_string)
{
char *string;
ACPI_FUNCTION_ENTRY ();
char *string;
ACPI_FUNCTION_ENTRY();
if (!src_string) {
return;
@@ -197,13 +178,12 @@ acpi_ut_strupr (
/* Walk entire string, uppercasing the letters */
for (string = src_string; *string; string++) {
*string = (char) ACPI_TOUPPER (*string);
*string = (char)ACPI_TOUPPER(*string);
}
return;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_print_string
@@ -218,85 +198,77 @@ acpi_ut_strupr (
*
******************************************************************************/
void
acpi_ut_print_string (
char *string,
u8 max_length)
void acpi_ut_print_string(char *string, u8 max_length)
{
u32 i;
u32 i;
if (!string) {
acpi_os_printf ("<\"NULL STRING PTR\">");
acpi_os_printf("<\"NULL STRING PTR\">");
return;
}
acpi_os_printf ("\"");
acpi_os_printf("\"");
for (i = 0; string[i] && (i < max_length); i++) {
/* Escape sequences */
switch (string[i]) {
case 0x07:
acpi_os_printf ("\\a"); /* BELL */
acpi_os_printf("\\a"); /* BELL */
break;
case 0x08:
acpi_os_printf ("\\b"); /* BACKSPACE */
acpi_os_printf("\\b"); /* BACKSPACE */
break;
case 0x0C:
acpi_os_printf ("\\f"); /* FORMFEED */
acpi_os_printf("\\f"); /* FORMFEED */
break;
case 0x0A:
acpi_os_printf ("\\n"); /* LINEFEED */
acpi_os_printf("\\n"); /* LINEFEED */
break;
case 0x0D:
acpi_os_printf ("\\r"); /* CARRIAGE RETURN*/
acpi_os_printf("\\r"); /* CARRIAGE RETURN */
break;
case 0x09:
acpi_os_printf ("\\t"); /* HORIZONTAL TAB */
acpi_os_printf("\\t"); /* HORIZONTAL TAB */
break;
case 0x0B:
acpi_os_printf ("\\v"); /* VERTICAL TAB */
acpi_os_printf("\\v"); /* VERTICAL TAB */
break;
case '\'': /* Single Quote */
case '\"': /* Double Quote */
case '\\': /* Backslash */
acpi_os_printf ("\\%c", (int) string[i]);
case '\'': /* Single Quote */
case '\"': /* Double Quote */
case '\\': /* Backslash */
acpi_os_printf("\\%c", (int)string[i]);
break;
default:
/* Check for printable character or hex escape */
if (ACPI_IS_PRINT (string[i]))
{
if (ACPI_IS_PRINT(string[i])) {
/* This is a normal character */
acpi_os_printf ("%c", (int) string[i]);
}
else
{
acpi_os_printf("%c", (int)string[i]);
} else {
/* All others will be Hex escapes */
acpi_os_printf ("\\x%2.2X", (s32) string[i]);
acpi_os_printf("\\x%2.2X", (s32) string[i]);
}
break;
}
}
acpi_os_printf ("\"");
acpi_os_printf("\"");
if (i == max_length && string[i]) {
acpi_os_printf ("...");
acpi_os_printf("...");
}
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_dword_byte_swap
@@ -309,22 +281,18 @@ acpi_ut_print_string (
*
******************************************************************************/
u32
acpi_ut_dword_byte_swap (
u32 value)
u32 acpi_ut_dword_byte_swap(u32 value)
{
union {
u32 value;
u8 bytes[4];
u32 value;
u8 bytes[4];
} out;
union {
u32 value;
u8 bytes[4];
u32 value;
u8 bytes[4];
} in;
ACPI_FUNCTION_ENTRY ();
ACPI_FUNCTION_ENTRY();
in.value = value;
@@ -336,7 +304,6 @@ acpi_ut_dword_byte_swap (
return (out.value);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_set_integer_width
@@ -352,24 +319,20 @@ acpi_ut_dword_byte_swap (
*
******************************************************************************/
void
acpi_ut_set_integer_width (
u8 revision)
void acpi_ut_set_integer_width(u8 revision)
{
if (revision <= 1) {
acpi_gbl_integer_bit_width = 32;
acpi_gbl_integer_nybble_width = 8;
acpi_gbl_integer_byte_width = 4;
}
else {
} else {
acpi_gbl_integer_bit_width = 64;
acpi_gbl_integer_nybble_width = 16;
acpi_gbl_integer_byte_width = 8;
}
}
#ifdef ACPI_DEBUG_OUTPUT
/*******************************************************************************
*
@@ -387,17 +350,14 @@ acpi_ut_set_integer_width (
******************************************************************************/
void
acpi_ut_display_init_pathname (
u8 type,
struct acpi_namespace_node *obj_handle,
char *path)
acpi_ut_display_init_pathname(u8 type,
struct acpi_namespace_node *obj_handle,
char *path)
{
acpi_status status;
struct acpi_buffer buffer;
ACPI_FUNCTION_ENTRY ();
acpi_status status;
struct acpi_buffer buffer;
ACPI_FUNCTION_ENTRY();
/* Only print the path if the appropriate debug level is enabled */
@@ -408,8 +368,8 @@ acpi_ut_display_init_pathname (
/* Get the full pathname to the node */
buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
status = acpi_ns_handle_to_pathname (obj_handle, &buffer);
if (ACPI_FAILURE (status)) {
status = acpi_ns_handle_to_pathname(obj_handle, &buffer);
if (ACPI_FAILURE(status)) {
return;
}
@@ -417,31 +377,30 @@ acpi_ut_display_init_pathname (
switch (type) {
case ACPI_TYPE_METHOD:
acpi_os_printf ("Executing ");
acpi_os_printf("Executing ");
break;
default:
acpi_os_printf ("Initializing ");
acpi_os_printf("Initializing ");
break;
}
/* Print the object type and pathname */
acpi_os_printf ("%-12s %s",
acpi_ut_get_type_name (type), (char *) buffer.pointer);
acpi_os_printf("%-12s %s",
acpi_ut_get_type_name(type), (char *)buffer.pointer);
/* Extra path is used to append names like _STA, _INI, etc. */
if (path) {
acpi_os_printf (".%s", path);
acpi_os_printf(".%s", path);
}
acpi_os_printf ("\n");
acpi_os_printf("\n");
ACPI_MEM_FREE (buffer.pointer);
ACPI_MEM_FREE(buffer.pointer);
}
#endif
/*******************************************************************************
*
* FUNCTION: acpi_ut_valid_acpi_name
@@ -457,25 +416,21 @@ acpi_ut_display_init_pathname (
*
******************************************************************************/
u8
acpi_ut_valid_acpi_name (
u32 name)
u8 acpi_ut_valid_acpi_name(u32 name)
{
char *name_ptr = (char *) &name;
char character;
acpi_native_uint i;
ACPI_FUNCTION_ENTRY ();
char *name_ptr = (char *)&name;
char character;
acpi_native_uint i;
ACPI_FUNCTION_ENTRY();
for (i = 0; i < ACPI_NAME_SIZE; i++) {
character = *name_ptr;
name_ptr++;
if (!((character == '_') ||
(character >= 'A' && character <= 'Z') ||
(character >= '0' && character <= '9'))) {
(character >= 'A' && character <= 'Z') ||
(character >= '0' && character <= '9'))) {
return (FALSE);
}
}
@@ -483,7 +438,6 @@ acpi_ut_valid_acpi_name (
return (TRUE);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_valid_acpi_character
@@ -496,19 +450,16 @@ acpi_ut_valid_acpi_name (
*
******************************************************************************/
u8
acpi_ut_valid_acpi_character (
char character)
u8 acpi_ut_valid_acpi_character(char character)
{
ACPI_FUNCTION_ENTRY ();
ACPI_FUNCTION_ENTRY();
return ((u8) ((character == '_') ||
(character >= 'A' && character <= 'Z') ||
(character >= '0' && character <= '9')));
return ((u8) ((character == '_') ||
(character >= 'A' && character <= 'Z') ||
(character >= '0' && character <= '9')));
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_strtoul64
@@ -525,18 +476,13 @@ acpi_ut_valid_acpi_character (
******************************************************************************/
acpi_status
acpi_ut_strtoul64 (
char *string,
u32 base,
acpi_integer *ret_integer)
acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
{
u32 this_digit = 0;
acpi_integer return_value = 0;
acpi_integer quotient;
ACPI_FUNCTION_TRACE ("ut_stroul64");
u32 this_digit = 0;
acpi_integer return_value = 0;
acpi_integer quotient;
ACPI_FUNCTION_TRACE("ut_stroul64");
if ((!string) || !(*string)) {
goto error_exit;
@@ -550,12 +496,12 @@ acpi_ut_strtoul64 (
default:
/* Invalid Base */
return_ACPI_STATUS (AE_BAD_PARAMETER);
return_ACPI_STATUS(AE_BAD_PARAMETER);
}
/* Skip over any white space in the buffer */
while (ACPI_IS_SPACE (*string) || *string == '\t') {
while (ACPI_IS_SPACE(*string) || *string == '\t') {
string++;
}
@@ -564,12 +510,10 @@ acpi_ut_strtoul64 (
* determine if it is decimal or hexadecimal:
*/
if (base == 0) {
if ((*string == '0') &&
(ACPI_TOLOWER (*(string + 1)) == 'x')) {
if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
base = 16;
string += 2;
}
else {
} else {
base = 10;
}
}
@@ -579,8 +523,7 @@ acpi_ut_strtoul64 (
* 0 or 0x, if they are present.
*/
if ((base == 16) &&
(*string == '0') &&
(ACPI_TOLOWER (*(string + 1)) == 'x')) {
(*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
string += 2;
}
@@ -593,25 +536,23 @@ acpi_ut_strtoul64 (
/* Main loop: convert the string to a 64-bit integer */
while (*string) {
if (ACPI_IS_DIGIT (*string)) {
if (ACPI_IS_DIGIT(*string)) {
/* Convert ASCII 0-9 to Decimal value */
this_digit = ((u8) *string) - '0';
}
else {
this_digit = ((u8) * string) - '0';
} else {
if (base == 10) {
/* Digit is out of range */
goto error_exit;
}
this_digit = (u8) ACPI_TOUPPER (*string);
if (ACPI_IS_XDIGIT ((char) this_digit)) {
this_digit = (u8) ACPI_TOUPPER(*string);
if (ACPI_IS_XDIGIT((char)this_digit)) {
/* Convert ASCII Hex char to value */
this_digit = this_digit - 'A' + 10;
}
else {
} else {
/*
* We allow non-hex chars, just stop now, same as end-of-string.
* See ACPI spec, string-to-integer conversion.
@@ -622,8 +563,10 @@ acpi_ut_strtoul64 (
/* Divide the digit into the correct position */
(void) acpi_ut_short_divide ((ACPI_INTEGER_MAX - (acpi_integer) this_digit),
base, &quotient, NULL);
(void)
acpi_ut_short_divide((ACPI_INTEGER_MAX -
(acpi_integer) this_digit), base,
&quotient, NULL);
if (return_value > quotient) {
goto error_exit;
}
@@ -636,21 +579,18 @@ acpi_ut_strtoul64 (
/* All done, normal exit */
*ret_integer = return_value;
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
error_exit:
error_exit:
/* Base was set/validated above */
if (base == 10) {
return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
}
else {
return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT);
} else {
return_ACPI_STATUS(AE_BAD_HEX_CONSTANT);
}
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_update_state_and_push
@@ -666,16 +606,13 @@ error_exit:
******************************************************************************/
acpi_status
acpi_ut_create_update_state_and_push (
union acpi_operand_object *object,
u16 action,
union acpi_generic_state **state_list)
acpi_ut_create_update_state_and_push(union acpi_operand_object *object,
u16 action,
union acpi_generic_state **state_list)
{
union acpi_generic_state *state;
ACPI_FUNCTION_ENTRY ();
union acpi_generic_state *state;
ACPI_FUNCTION_ENTRY();
/* Ignore null objects; these are expected */
@@ -683,16 +620,15 @@ acpi_ut_create_update_state_and_push (
return (AE_OK);
}
state = acpi_ut_create_update_state (object, action);
state = acpi_ut_create_update_state(object, action);
if (!state) {
return (AE_NO_MEMORY);
}
acpi_ut_push_generic_state (state_list, state);
acpi_ut_push_generic_state(state_list, state);
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_walk_package_tree
@@ -709,33 +645,29 @@ acpi_ut_create_update_state_and_push (
******************************************************************************/
acpi_status
acpi_ut_walk_package_tree (
union acpi_operand_object *source_object,
void *target_object,
acpi_pkg_callback walk_callback,
void *context)
acpi_ut_walk_package_tree(union acpi_operand_object * source_object,
void *target_object,
acpi_pkg_callback walk_callback, void *context)
{
acpi_status status = AE_OK;
union acpi_generic_state *state_list = NULL;
union acpi_generic_state *state;
u32 this_index;
union acpi_operand_object *this_source_obj;
acpi_status status = AE_OK;
union acpi_generic_state *state_list = NULL;
union acpi_generic_state *state;
u32 this_index;
union acpi_operand_object *this_source_obj;
ACPI_FUNCTION_TRACE("ut_walk_package_tree");
ACPI_FUNCTION_TRACE ("ut_walk_package_tree");
state = acpi_ut_create_pkg_state (source_object, target_object, 0);
state = acpi_ut_create_pkg_state(source_object, target_object, 0);
if (!state) {
return_ACPI_STATUS (AE_NO_MEMORY);
return_ACPI_STATUS(AE_NO_MEMORY);
}
while (state) {
/* Get one element of the package */
this_index = state->pkg.index;
this_index = state->pkg.index;
this_source_obj = (union acpi_operand_object *)
state->pkg.source_object->package.elements[this_index];
state->pkg.source_object->package.elements[this_index];
/*
* Check for:
@@ -746,16 +678,20 @@ acpi_ut_walk_package_tree (
* case below.
*/
if ((!this_source_obj) ||
(ACPI_GET_DESCRIPTOR_TYPE (this_source_obj) != ACPI_DESC_TYPE_OPERAND) ||
(ACPI_GET_OBJECT_TYPE (this_source_obj) != ACPI_TYPE_PACKAGE)) {
status = walk_callback (ACPI_COPY_TYPE_SIMPLE, this_source_obj,
state, context);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
(ACPI_GET_DESCRIPTOR_TYPE(this_source_obj) !=
ACPI_DESC_TYPE_OPERAND)
|| (ACPI_GET_OBJECT_TYPE(this_source_obj) !=
ACPI_TYPE_PACKAGE)) {
status =
walk_callback(ACPI_COPY_TYPE_SIMPLE,
this_source_obj, state, context);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
state->pkg.index++;
while (state->pkg.index >= state->pkg.source_object->package.count) {
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
@@ -763,8 +699,8 @@ acpi_ut_walk_package_tree (
*
* Delete this state and pop the previous state (package).
*/
acpi_ut_delete_generic_state (state);
state = acpi_ut_pop_generic_state (&state_list);
acpi_ut_delete_generic_state(state);
state = acpi_ut_pop_generic_state(&state_list);
/* Finished when there are no more states */
@@ -774,7 +710,7 @@ acpi_ut_walk_package_tree (
* package just add the length of the package objects
* and exit
*/
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
/*
@@ -783,35 +719,35 @@ acpi_ut_walk_package_tree (
*/
state->pkg.index++;
}
}
else {
} else {
/* This is a subobject of type package */
status = walk_callback (ACPI_COPY_TYPE_PACKAGE, this_source_obj,
state, context);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status =
walk_callback(ACPI_COPY_TYPE_PACKAGE,
this_source_obj, state, context);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/*
* Push the current state and create a new one
* The callback above returned a new target package object.
*/
acpi_ut_push_generic_state (&state_list, state);
state = acpi_ut_create_pkg_state (this_source_obj,
state->pkg.this_target_obj, 0);
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) {
return_ACPI_STATUS (AE_NO_MEMORY);
return_ACPI_STATUS(AE_NO_MEMORY);
}
}
}
/* We should never get here */
return_ACPI_STATUS (AE_AML_INTERNAL);
return_ACPI_STATUS(AE_AML_INTERNAL);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_generate_checksum
@@ -825,23 +761,18 @@ acpi_ut_walk_package_tree (
*
******************************************************************************/
u8
acpi_ut_generate_checksum (
u8 *buffer,
u32 length)
u8 acpi_ut_generate_checksum(u8 * buffer, u32 length)
{
u32 i;
signed char sum = 0;
u32 i;
signed char sum = 0;
for (i = 0; i < length; i++) {
sum = (signed char) (sum + buffer[i]);
sum = (signed char)(sum + buffer[i]);
}
return ((u8) (0 - sum));
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_resource_end_tag
@@ -854,17 +785,13 @@ acpi_ut_generate_checksum (
*
******************************************************************************/
u8 *
acpi_ut_get_resource_end_tag (
union acpi_operand_object *obj_desc)
u8 *acpi_ut_get_resource_end_tag(union acpi_operand_object * obj_desc)
{
u8 buffer_byte;
u8 *buffer;
u8 *end_buffer;
u8 buffer_byte;
u8 *buffer;
u8 *end_buffer;
buffer = obj_desc->buffer.pointer;
buffer = obj_desc->buffer.pointer;
end_buffer = buffer + obj_desc->buffer.length;
while (buffer < end_buffer) {
@@ -872,12 +799,12 @@ acpi_ut_get_resource_end_tag (
if (buffer_byte & ACPI_RDESC_TYPE_MASK) {
/* Large Descriptor - Length is next 2 bytes */
buffer += ((*(buffer+1) | (*(buffer+2) << 8)) + 3);
}
else {
buffer += ((*(buffer + 1) | (*(buffer + 2) << 8)) + 3);
} else {
/* Small Descriptor. End Tag will be found here */
if ((buffer_byte & ACPI_RDESC_SMALL_MASK) == ACPI_RDESC_TYPE_END_TAG) {
if ((buffer_byte & ACPI_RDESC_SMALL_MASK) ==
ACPI_RDESC_TYPE_END_TAG) {
/* Found the end tag descriptor, all done. */
return (buffer);
@@ -894,7 +821,6 @@ acpi_ut_get_resource_end_tag (
return (NULL);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_report_error
@@ -909,17 +835,12 @@ acpi_ut_get_resource_end_tag (
*
******************************************************************************/
void
acpi_ut_report_error (
char *module_name,
u32 line_number,
u32 component_id)
void acpi_ut_report_error(char *module_name, u32 line_number, u32 component_id)
{
acpi_os_printf ("%8s-%04d: *** Error: ", module_name, line_number);
acpi_os_printf("%8s-%04d: *** Error: ", module_name, line_number);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_report_warning
@@ -935,16 +856,12 @@ acpi_ut_report_error (
******************************************************************************/
void
acpi_ut_report_warning (
char *module_name,
u32 line_number,
u32 component_id)
acpi_ut_report_warning(char *module_name, u32 line_number, u32 component_id)
{
acpi_os_printf ("%8s-%04d: *** Warning: ", module_name, line_number);
acpi_os_printf("%8s-%04d: *** Warning: ", module_name, line_number);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_report_info
@@ -959,14 +876,8 @@ acpi_ut_report_warning (
*
******************************************************************************/
void
acpi_ut_report_info (
char *module_name,
u32 line_number,
u32 component_id)
void acpi_ut_report_info(char *module_name, u32 line_number, u32 component_id)
{
acpi_os_printf ("%8s-%04d: *** Info: ", module_name, line_number);
acpi_os_printf("%8s-%04d: *** Info: ", module_name, line_number);
}

218
drivers/acpi/utilities/utmutex.c
View File

@@ -41,22 +41,15 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utmutex")
ACPI_MODULE_NAME("utmutex")
/* Local prototypes */
static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id);
static acpi_status
acpi_ut_create_mutex (
acpi_mutex_handle mutex_id);
static acpi_status
acpi_ut_delete_mutex (
acpi_mutex_handle mutex_id);
static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id);
/*******************************************************************************
*
@@ -70,32 +63,27 @@ acpi_ut_delete_mutex (
*
******************************************************************************/
acpi_status
acpi_ut_mutex_initialize (
void)
acpi_status acpi_ut_mutex_initialize(void)
{
u32 i;
acpi_status status;
ACPI_FUNCTION_TRACE ("ut_mutex_initialize");
u32 i;
acpi_status status;
ACPI_FUNCTION_TRACE("ut_mutex_initialize");
/*
* Create each of the predefined mutex objects
*/
for (i = 0; i < NUM_MUTEX; i++) {
status = acpi_ut_create_mutex (i);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_create_mutex(i);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
status = acpi_os_create_lock (&acpi_gbl_gpe_lock);
return_ACPI_STATUS (status);
status = acpi_os_create_lock(&acpi_gbl_gpe_lock);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_mutex_terminate
@@ -108,28 +96,23 @@ acpi_ut_mutex_initialize (
*
******************************************************************************/
void
acpi_ut_mutex_terminate (
void)
void acpi_ut_mutex_terminate(void)
{
u32 i;
ACPI_FUNCTION_TRACE ("ut_mutex_terminate");
u32 i;
ACPI_FUNCTION_TRACE("ut_mutex_terminate");
/*
* Delete each predefined mutex object
*/
for (i = 0; i < NUM_MUTEX; i++) {
(void) acpi_ut_delete_mutex (i);
(void)acpi_ut_delete_mutex(i);
}
acpi_os_delete_lock (acpi_gbl_gpe_lock);
acpi_os_delete_lock(acpi_gbl_gpe_lock);
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_mutex
@@ -142,31 +125,28 @@ acpi_ut_mutex_terminate (
*
******************************************************************************/
static acpi_status
acpi_ut_create_mutex (
acpi_mutex_handle mutex_id)
static acpi_status acpi_ut_create_mutex(acpi_mutex_handle mutex_id)
{
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_U32 ("ut_create_mutex", mutex_id);
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_U32("ut_create_mutex", mutex_id);
if (mutex_id > MAX_MUTEX) {
return_ACPI_STATUS (AE_BAD_PARAMETER);
return_ACPI_STATUS(AE_BAD_PARAMETER);
}
if (!acpi_gbl_mutex_info[mutex_id].mutex) {
status = acpi_os_create_semaphore (1, 1,
&acpi_gbl_mutex_info[mutex_id].mutex);
acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
status = acpi_os_create_semaphore(1, 1,
&acpi_gbl_mutex_info
[mutex_id].mutex);
acpi_gbl_mutex_info[mutex_id].thread_id =
ACPI_MUTEX_NOT_ACQUIRED;
acpi_gbl_mutex_info[mutex_id].use_count = 0;
}
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_delete_mutex
@@ -179,29 +159,24 @@ acpi_ut_create_mutex (
*
******************************************************************************/
static acpi_status
acpi_ut_delete_mutex (
acpi_mutex_handle mutex_id)
static acpi_status acpi_ut_delete_mutex(acpi_mutex_handle mutex_id)
{
acpi_status status;
ACPI_FUNCTION_TRACE_U32 ("ut_delete_mutex", mutex_id);
acpi_status status;
ACPI_FUNCTION_TRACE_U32("ut_delete_mutex", mutex_id);
if (mutex_id > MAX_MUTEX) {
return_ACPI_STATUS (AE_BAD_PARAMETER);
return_ACPI_STATUS(AE_BAD_PARAMETER);
}
status = acpi_os_delete_semaphore (acpi_gbl_mutex_info[mutex_id].mutex);
status = acpi_os_delete_semaphore(acpi_gbl_mutex_info[mutex_id].mutex);
acpi_gbl_mutex_info[mutex_id].mutex = NULL;
acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_acquire_mutex
@@ -214,26 +189,22 @@ acpi_ut_delete_mutex (
*
******************************************************************************/
acpi_status
acpi_ut_acquire_mutex (
acpi_mutex_handle mutex_id)
acpi_status acpi_ut_acquire_mutex(acpi_mutex_handle mutex_id)
{
acpi_status status;
u32 this_thread_id;
ACPI_FUNCTION_NAME ("ut_acquire_mutex");
acpi_status status;
u32 this_thread_id;
ACPI_FUNCTION_NAME("ut_acquire_mutex");
if (mutex_id > MAX_MUTEX) {
return (AE_BAD_PARAMETER);
}
this_thread_id = acpi_os_get_thread_id ();
this_thread_id = acpi_os_get_thread_id();
#ifdef ACPI_MUTEX_DEBUG
{
u32 i;
u32 i;
/*
* Mutex debug code, for internal debugging only.
*
@@ -245,17 +216,21 @@ acpi_ut_acquire_mutex (
for (i = mutex_id; i < MAX_MUTEX; i++) {
if (acpi_gbl_mutex_info[i].owner_id == this_thread_id) {
if (i == mutex_id) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Mutex [%s] already acquired by this thread [%X]\n",
acpi_ut_get_mutex_name (mutex_id), this_thread_id));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Mutex [%s] already acquired by this thread [%X]\n",
acpi_ut_get_mutex_name
(mutex_id),
this_thread_id));
return (AE_ALREADY_ACQUIRED);
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invalid acquire order: Thread %X owns [%s], wants [%s]\n",
this_thread_id, acpi_ut_get_mutex_name (i),
acpi_ut_get_mutex_name (mutex_id)));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Invalid acquire order: Thread %X owns [%s], wants [%s]\n",
this_thread_id,
acpi_ut_get_mutex_name(i),
acpi_ut_get_mutex_name
(mutex_id)));
return (AE_ACQUIRE_DEADLOCK);
}
@@ -263,30 +238,31 @@ acpi_ut_acquire_mutex (
}
#endif
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
"Thread %X attempting to acquire Mutex [%s]\n",
this_thread_id, acpi_ut_get_mutex_name (mutex_id)));
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
"Thread %X attempting to acquire Mutex [%s]\n",
this_thread_id, acpi_ut_get_mutex_name(mutex_id)));
status = acpi_os_wait_semaphore (acpi_gbl_mutex_info[mutex_id].mutex,
1, ACPI_WAIT_FOREVER);
if (ACPI_SUCCESS (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n",
this_thread_id, acpi_ut_get_mutex_name (mutex_id)));
status = acpi_os_wait_semaphore(acpi_gbl_mutex_info[mutex_id].mutex,
1, ACPI_WAIT_FOREVER);
if (ACPI_SUCCESS(status)) {
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
"Thread %X acquired Mutex [%s]\n",
this_thread_id,
acpi_ut_get_mutex_name(mutex_id)));
acpi_gbl_mutex_info[mutex_id].use_count++;
acpi_gbl_mutex_info[mutex_id].thread_id = this_thread_id;
}
else {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Thread %X could not acquire Mutex [%s] %s\n",
this_thread_id, acpi_ut_get_mutex_name (mutex_id),
acpi_format_exception (status)));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Thread %X could not acquire Mutex [%s] %s\n",
this_thread_id,
acpi_ut_get_mutex_name(mutex_id),
acpi_format_exception(status)));
}
return (status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_release_mutex
@@ -299,21 +275,17 @@ acpi_ut_acquire_mutex (
*
******************************************************************************/
acpi_status
acpi_ut_release_mutex (
acpi_mutex_handle mutex_id)
acpi_status acpi_ut_release_mutex(acpi_mutex_handle mutex_id)
{
acpi_status status;
u32 this_thread_id;
acpi_status status;
u32 this_thread_id;
ACPI_FUNCTION_NAME("ut_release_mutex");
ACPI_FUNCTION_NAME ("ut_release_mutex");
this_thread_id = acpi_os_get_thread_id ();
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
"Thread %X releasing Mutex [%s]\n", this_thread_id,
acpi_ut_get_mutex_name (mutex_id)));
this_thread_id = acpi_os_get_thread_id();
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
"Thread %X releasing Mutex [%s]\n", this_thread_id,
acpi_ut_get_mutex_name(mutex_id)));
if (mutex_id > MAX_MUTEX) {
return (AE_BAD_PARAMETER);
@@ -323,16 +295,15 @@ acpi_ut_release_mutex (
* Mutex must be acquired in order to release it!
*/
if (acpi_gbl_mutex_info[mutex_id].thread_id == ACPI_MUTEX_NOT_ACQUIRED) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Mutex [%s] is not acquired, cannot release\n",
acpi_ut_get_mutex_name (mutex_id)));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Mutex [%s] is not acquired, cannot release\n",
acpi_ut_get_mutex_name(mutex_id)));
return (AE_NOT_ACQUIRED);
}
#ifdef ACPI_MUTEX_DEBUG
{
u32 i;
u32 i;
/*
* Mutex debug code, for internal debugging only.
*
@@ -347,9 +318,11 @@ acpi_ut_release_mutex (
continue;
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invalid release order: owns [%s], releasing [%s]\n",
acpi_ut_get_mutex_name (i), acpi_ut_get_mutex_name (mutex_id)));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Invalid release order: owns [%s], releasing [%s]\n",
acpi_ut_get_mutex_name(i),
acpi_ut_get_mutex_name
(mutex_id)));
return (AE_RELEASE_DEADLOCK);
}
@@ -361,20 +334,21 @@ acpi_ut_release_mutex (
acpi_gbl_mutex_info[mutex_id].thread_id = ACPI_MUTEX_NOT_ACQUIRED;
status = acpi_os_signal_semaphore (acpi_gbl_mutex_info[mutex_id].mutex, 1);
status =
acpi_os_signal_semaphore(acpi_gbl_mutex_info[mutex_id].mutex, 1);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Thread %X could not release Mutex [%s] %s\n",
this_thread_id, acpi_ut_get_mutex_name (mutex_id),
acpi_format_exception (status)));
}
else {
ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X released Mutex [%s]\n",
this_thread_id, acpi_ut_get_mutex_name (mutex_id)));
if (ACPI_FAILURE(status)) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Thread %X could not release Mutex [%s] %s\n",
this_thread_id,
acpi_ut_get_mutex_name(mutex_id),
acpi_format_exception(status)));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_MUTEX,
"Thread %X released Mutex [%s]\n",
this_thread_id,
acpi_ut_get_mutex_name(mutex_id)));
}
return (status);
}

322
drivers/acpi/utilities/utobject.c
View File

@@ -41,34 +41,26 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#include <acpi/acnamesp.h>
#include <acpi/amlcode.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utobject")
ACPI_MODULE_NAME("utobject")
/* Local prototypes */
static acpi_status
acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
acpi_size * obj_length);
static acpi_status
acpi_ut_get_simple_object_size (
union acpi_operand_object *obj,
acpi_size *obj_length);
acpi_ut_get_package_object_size(union acpi_operand_object *obj,
acpi_size * obj_length);
static acpi_status
acpi_ut_get_package_object_size (
union acpi_operand_object *obj,
acpi_size *obj_length);
static acpi_status
acpi_ut_get_element_length (
u8 object_type,
union acpi_operand_object *source_object,
union acpi_generic_state *state,
void *context);
acpi_ut_get_element_length(u8 object_type,
union acpi_operand_object *source_object,
union acpi_generic_state *state, void *context);
/*******************************************************************************
*
@@ -91,26 +83,25 @@ acpi_ut_get_element_length (
*
******************************************************************************/
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 *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));
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);
object =
acpi_ut_allocate_object_desc_dbg(module_name, line_number,
component_id);
if (!object) {
return_PTR (NULL);
return_PTR(NULL);
}
switch (type) {
@@ -119,11 +110,12 @@ acpi_ut_create_internal_object_dbg (
/* These types require a secondary object */
second_object = acpi_ut_allocate_object_desc_dbg (module_name,
line_number, component_id);
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);
acpi_ut_delete_object_desc(object);
return_PTR(NULL);
}
second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
@@ -149,10 +141,9 @@ acpi_ut_create_internal_object_dbg (
/* Any per-type initialization should go here */
return_PTR (object);
return_PTR(object);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_buffer_object
@@ -165,22 +156,18 @@ acpi_ut_create_internal_object_dbg (
*
******************************************************************************/
union acpi_operand_object *
acpi_ut_create_buffer_object (
acpi_size buffer_size)
union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
{
union acpi_operand_object *buffer_desc;
u8 *buffer = NULL;
ACPI_FUNCTION_TRACE_U32 ("ut_create_buffer_object", buffer_size);
union acpi_operand_object *buffer_desc;
u8 *buffer = NULL;
ACPI_FUNCTION_TRACE_U32("ut_create_buffer_object", buffer_size);
/* Create a new Buffer object */
buffer_desc = acpi_ut_create_internal_object (ACPI_TYPE_BUFFER);
buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
if (!buffer_desc) {
return_PTR (NULL);
return_PTR(NULL);
}
/* Create an actual buffer only if size > 0 */
@@ -188,12 +175,11 @@ acpi_ut_create_buffer_object (
if (buffer_size > 0) {
/* Allocate the actual buffer */
buffer = ACPI_MEM_CALLOCATE (buffer_size);
buffer = ACPI_MEM_CALLOCATE(buffer_size);
if (!buffer) {
ACPI_REPORT_ERROR (("create_buffer: could not allocate size %X\n",
(u32) buffer_size));
acpi_ut_remove_reference (buffer_desc);
return_PTR (NULL);
ACPI_REPORT_ERROR(("create_buffer: could not allocate size %X\n", (u32) buffer_size));
acpi_ut_remove_reference(buffer_desc);
return_PTR(NULL);
}
}
@@ -205,10 +191,9 @@ acpi_ut_create_buffer_object (
/* Return the new buffer descriptor */
return_PTR (buffer_desc);
return_PTR(buffer_desc);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_string_object
@@ -223,34 +208,29 @@ acpi_ut_create_buffer_object (
*
******************************************************************************/
union acpi_operand_object *
acpi_ut_create_string_object (
acpi_size string_size)
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);
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);
string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
if (!string_desc) {
return_PTR (NULL);
return_PTR(NULL);
}
/*
* Allocate the actual string buffer -- (Size + 1) for NULL terminator.
* NOTE: Zero-length strings are NULL terminated
*/
string = ACPI_MEM_CALLOCATE (string_size + 1);
string = ACPI_MEM_CALLOCATE(string_size + 1);
if (!string) {
ACPI_REPORT_ERROR (("create_string: could not allocate size %X\n",
(u32) string_size));
acpi_ut_remove_reference (string_desc);
return_PTR (NULL);
ACPI_REPORT_ERROR(("create_string: could not allocate size %X\n", (u32) string_size));
acpi_ut_remove_reference(string_desc);
return_PTR(NULL);
}
/* Complete string object initialization */
@@ -260,10 +240,9 @@ acpi_ut_create_string_object (
/* Return the new string descriptor */
return_PTR (string_desc);
return_PTR(string_desc);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_valid_internal_object
@@ -276,24 +255,21 @@ acpi_ut_create_string_object (
*
******************************************************************************/
u8
acpi_ut_valid_internal_object (
void *object)
u8 acpi_ut_valid_internal_object(void *object)
{
ACPI_FUNCTION_NAME ("ut_valid_internal_object");
ACPI_FUNCTION_NAME("ut_valid_internal_object");
/* Check for a null pointer */
if (!object) {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "**** Null Object Ptr\n"));
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "**** Null Object Ptr\n"));
return (FALSE);
}
/* Check the descriptor type field */
switch (ACPI_GET_DESCRIPTOR_TYPE (object)) {
switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
case ACPI_DESC_TYPE_OPERAND:
/* The object appears to be a valid union acpi_operand_object */
@@ -301,16 +277,15 @@ acpi_ut_valid_internal_object (
return (TRUE);
default:
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"%p is not not an ACPI operand obj [%s]\n",
object, acpi_ut_get_descriptor_name (object)));
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"%p is not not an ACPI operand obj [%s]\n",
object, acpi_ut_get_descriptor_name(object)));
break;
}
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_allocate_object_desc_dbg
@@ -326,37 +301,31 @@ acpi_ut_valid_internal_object (
*
******************************************************************************/
void *
acpi_ut_allocate_object_desc_dbg (
char *module_name,
u32 line_number,
u32 component_id)
void *acpi_ut_allocate_object_desc_dbg(char *module_name,
u32 line_number, u32 component_id)
{
union acpi_operand_object *object;
union acpi_operand_object *object;
ACPI_FUNCTION_TRACE("ut_allocate_object_desc_dbg");
ACPI_FUNCTION_TRACE ("ut_allocate_object_desc_dbg");
object = acpi_os_acquire_object (acpi_gbl_operand_cache);
object = acpi_os_acquire_object(acpi_gbl_operand_cache);
if (!object) {
_ACPI_REPORT_ERROR (module_name, line_number, component_id,
("Could not allocate an object descriptor\n"));
_ACPI_REPORT_ERROR(module_name, line_number, component_id,
("Could not allocate an object descriptor\n"));
return_PTR (NULL);
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_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)));
ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
object, (u32) sizeof(union acpi_operand_object)));
return_PTR (object);
return_PTR(object);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_delete_object_desc
@@ -369,27 +338,23 @@ acpi_ut_allocate_object_desc_dbg (
*
******************************************************************************/
void
acpi_ut_delete_object_desc (
union acpi_operand_object *object)
void acpi_ut_delete_object_desc(union acpi_operand_object *object)
{
ACPI_FUNCTION_TRACE_PTR ("ut_delete_object_desc", object);
ACPI_FUNCTION_TRACE_PTR("ut_delete_object_desc", object);
/* Object must be an union acpi_operand_object */
if (ACPI_GET_DESCRIPTOR_TYPE (object) != ACPI_DESC_TYPE_OPERAND) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"%p is not an ACPI Operand object [%s]\n", object,
acpi_ut_get_descriptor_name (object)));
if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"%p is not an ACPI Operand object [%s]\n",
object, acpi_ut_get_descriptor_name(object)));
return_VOID;
}
(void) acpi_os_release_object (acpi_gbl_operand_cache, object);
(void)acpi_os_release_object(acpi_gbl_operand_cache, object);
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_simple_object_size
@@ -408,16 +373,13 @@ acpi_ut_delete_object_desc (
******************************************************************************/
static acpi_status
acpi_ut_get_simple_object_size (
union acpi_operand_object *internal_object,
acpi_size *obj_length)
acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
acpi_size * obj_length)
{
acpi_size length;
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_PTR ("ut_get_simple_object_size", internal_object);
acpi_size length;
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE_PTR("ut_get_simple_object_size", internal_object);
/*
* Handle a null object (Could be a uninitialized package
@@ -425,18 +387,18 @@ acpi_ut_get_simple_object_size (
*/
if (!internal_object) {
*obj_length = 0;
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
/* Start with the length of the Acpi object */
length = sizeof (union acpi_object);
length = sizeof(union acpi_object);
if (ACPI_GET_DESCRIPTOR_TYPE (internal_object) == ACPI_DESC_TYPE_NAMED) {
if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
/* Object is a named object (reference), just return the length */
*obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD (length);
return_ACPI_STATUS (status);
*obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
return_ACPI_STATUS(status);
}
/*
@@ -445,19 +407,17 @@ acpi_ut_get_simple_object_size (
* must be accessed bytewise or there may be alignment problems on
* certain processors
*/
switch (ACPI_GET_OBJECT_TYPE (internal_object)) {
switch (ACPI_GET_OBJECT_TYPE(internal_object)) {
case ACPI_TYPE_STRING:
length += (acpi_size) internal_object->string.length + 1;
break;
case ACPI_TYPE_BUFFER:
length += (acpi_size) internal_object->buffer.length;
break;
case ACPI_TYPE_INTEGER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_POWER:
@@ -467,7 +427,6 @@ acpi_ut_get_simple_object_size (
*/
break;
case ACPI_TYPE_LOCAL_REFERENCE:
switch (internal_object->reference.opcode) {
@@ -477,8 +436,10 @@ acpi_ut_get_simple_object_size (
* Get the actual length of the full pathname to this object.
* The reference will be converted to the pathname to the object
*/
length += ACPI_ROUND_UP_TO_NATIVE_WORD (
acpi_ns_get_pathname_length (internal_object->reference.node));
length +=
ACPI_ROUND_UP_TO_NATIVE_WORD
(acpi_ns_get_pathname_length
(internal_object->reference.node));
break;
default:
@@ -488,19 +449,21 @@ acpi_ut_get_simple_object_size (
* Notably, Locals and Args are not supported, but this may be
* required eventually.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Unsupported Reference opcode=%X in object %p\n",
internal_object->reference.opcode, internal_object));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Unsupported Reference opcode=%X in object %p\n",
internal_object->reference.opcode,
internal_object));
status = AE_TYPE;
break;
}
break;
default:
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Unsupported type=%X in object %p\n",
ACPI_GET_OBJECT_TYPE (internal_object), internal_object));
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Unsupported type=%X in object %p\n",
ACPI_GET_OBJECT_TYPE(internal_object),
internal_object));
status = AE_TYPE;
break;
}
@@ -511,11 +474,10 @@ acpi_ut_get_simple_object_size (
* on a machine word boundary. (preventing alignment faults on some
* machines.)
*/
*obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD (length);
return_ACPI_STATUS (status);
*obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_element_length
@@ -529,16 +491,13 @@ acpi_ut_get_simple_object_size (
******************************************************************************/
static acpi_status
acpi_ut_get_element_length (
u8 object_type,
union acpi_operand_object *source_object,
union acpi_generic_state *state,
void *context)
acpi_ut_get_element_length(u8 object_type,
union acpi_operand_object *source_object,
union acpi_generic_state *state, void *context)
{
acpi_status status = AE_OK;
struct acpi_pkg_info *info = (struct acpi_pkg_info *) context;
acpi_size object_space;
acpi_status status = AE_OK;
struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
acpi_size object_space;
switch (object_type) {
case ACPI_COPY_TYPE_SIMPLE:
@@ -547,15 +506,16 @@ acpi_ut_get_element_length (
* Simple object - just get the size (Null object/entry is handled
* here also) and sum it into the running package length
*/
status = acpi_ut_get_simple_object_size (source_object, &object_space);
if (ACPI_FAILURE (status)) {
status =
acpi_ut_get_simple_object_size(source_object,
&object_space);
if (ACPI_FAILURE(status)) {
return (status);
}
info->length += object_space;
break;
case ACPI_COPY_TYPE_PACKAGE:
/* Package object - nothing much to do here, let the walk handle it */
@@ -564,7 +524,6 @@ acpi_ut_get_element_length (
state->pkg.this_target_obj = NULL;
break;
default:
/* No other types allowed */
@@ -575,7 +534,6 @@ acpi_ut_get_element_length (
return (status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_package_object_size
@@ -594,25 +552,22 @@ acpi_ut_get_element_length (
******************************************************************************/
static acpi_status
acpi_ut_get_package_object_size (
union acpi_operand_object *internal_object,
acpi_size *obj_length)
acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
acpi_size * obj_length)
{
acpi_status status;
struct acpi_pkg_info info;
acpi_status status;
struct acpi_pkg_info info;
ACPI_FUNCTION_TRACE_PTR("ut_get_package_object_size", internal_object);
ACPI_FUNCTION_TRACE_PTR ("ut_get_package_object_size", internal_object);
info.length = 0;
info.length = 0;
info.object_space = 0;
info.num_packages = 1;
status = acpi_ut_walk_package_tree (internal_object, NULL,
acpi_ut_get_element_length, &info);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_walk_package_tree(internal_object, NULL,
acpi_ut_get_element_length, &info);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/*
@@ -620,16 +575,15 @@ acpi_ut_get_package_object_size (
* just add the length of the package objects themselves.
* Round up to the next machine word.
*/
info.length += ACPI_ROUND_UP_TO_NATIVE_WORD (sizeof (union acpi_object)) *
(acpi_size) info.num_packages;
info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
(acpi_size) info.num_packages;
/* Return the total package length */
*obj_length = info.length;
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_object_size
@@ -645,25 +599,23 @@ acpi_ut_get_package_object_size (
******************************************************************************/
acpi_status
acpi_ut_get_object_size (
union acpi_operand_object *internal_object,
acpi_size *obj_length)
acpi_ut_get_object_size(union acpi_operand_object *internal_object,
acpi_size * obj_length)
{
acpi_status status;
acpi_status status;
ACPI_FUNCTION_ENTRY();
ACPI_FUNCTION_ENTRY ();
if ((ACPI_GET_DESCRIPTOR_TYPE (internal_object) == ACPI_DESC_TYPE_OPERAND) &&
(ACPI_GET_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);
if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
ACPI_DESC_TYPE_OPERAND)
&& (ACPI_GET_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);
}

159
drivers/acpi/utilities/utstate.c
View File

@@ -41,12 +41,10 @@
* POSSIBILITY OF SUCH DAMAGES.
*/
#include <acpi/acpi.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utstate")
ACPI_MODULE_NAME("utstate")
/*******************************************************************************
*
@@ -61,30 +59,26 @@
* DESCRIPTION: Create a new state and push it
*
******************************************************************************/
acpi_status
acpi_ut_create_pkg_state_and_push (
void *internal_object,
void *external_object,
u16 index,
union acpi_generic_state **state_list)
acpi_ut_create_pkg_state_and_push(void *internal_object,
void *external_object,
u16 index,
union acpi_generic_state ** state_list)
{
union acpi_generic_state *state;
union acpi_generic_state *state;
ACPI_FUNCTION_ENTRY();
ACPI_FUNCTION_ENTRY ();
state = acpi_ut_create_pkg_state (internal_object, external_object, index);
state =
acpi_ut_create_pkg_state(internal_object, external_object, index);
if (!state) {
return (AE_NO_MEMORY);
}
acpi_ut_push_generic_state (state_list, state);
acpi_ut_push_generic_state(state_list, state);
return (AE_OK);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_push_generic_state
@@ -99,12 +93,10 @@ acpi_ut_create_pkg_state_and_push (
******************************************************************************/
void
acpi_ut_push_generic_state (
union acpi_generic_state **list_head,
union acpi_generic_state *state)
acpi_ut_push_generic_state(union acpi_generic_state **list_head,
union acpi_generic_state *state)
{
ACPI_FUNCTION_TRACE ("ut_push_generic_state");
ACPI_FUNCTION_TRACE("ut_push_generic_state");
/* Push the state object onto the front of the list (stack) */
@@ -114,7 +106,6 @@ acpi_ut_push_generic_state (
return_VOID;
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_pop_generic_state
@@ -127,15 +118,12 @@ acpi_ut_push_generic_state (
*
******************************************************************************/
union acpi_generic_state *
acpi_ut_pop_generic_state (
union acpi_generic_state **list_head)
union acpi_generic_state *acpi_ut_pop_generic_state(union acpi_generic_state
**list_head)
{
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE ("ut_pop_generic_state");
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE("ut_pop_generic_state");
/* Remove the state object at the head of the list (stack) */
@@ -146,10 +134,9 @@ acpi_ut_pop_generic_state (
*list_head = state->common.next;
}
return_PTR (state);
return_PTR(state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_generic_state
@@ -163,17 +150,13 @@ acpi_ut_pop_generic_state (
*
******************************************************************************/
union acpi_generic_state *
acpi_ut_create_generic_state (
void)
union acpi_generic_state *acpi_ut_create_generic_state(void)
{
union acpi_generic_state *state;
union acpi_generic_state *state;
ACPI_FUNCTION_ENTRY();
ACPI_FUNCTION_ENTRY ();
state = acpi_os_acquire_object (acpi_gbl_state_cache);
state = acpi_os_acquire_object(acpi_gbl_state_cache);
if (state) {
/* Initialize */
memset(state, 0, sizeof(union acpi_generic_state));
@@ -183,7 +166,6 @@ acpi_ut_create_generic_state (
return (state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_thread_state
@@ -197,32 +179,27 @@ acpi_ut_create_generic_state (
*
******************************************************************************/
struct acpi_thread_state *
acpi_ut_create_thread_state (
void)
struct acpi_thread_state *acpi_ut_create_thread_state(void)
{
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE ("ut_create_thread_state");
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE("ut_create_thread_state");
/* Create the generic state object */
state = acpi_ut_create_generic_state ();
state = acpi_ut_create_generic_state();
if (!state) {
return_PTR (NULL);
return_PTR(NULL);
}
/* Init fields specific to the update struct */
state->common.data_type = ACPI_DESC_TYPE_STATE_THREAD;
state->thread.thread_id = acpi_os_get_thread_id ();
state->thread.thread_id = acpi_os_get_thread_id();
return_PTR ((struct acpi_thread_state *) state);
return_PTR((struct acpi_thread_state *)state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_update_state
@@ -238,34 +215,29 @@ acpi_ut_create_thread_state (
*
******************************************************************************/
union acpi_generic_state *
acpi_ut_create_update_state (
union acpi_operand_object *object,
u16 action)
union acpi_generic_state *acpi_ut_create_update_state(union acpi_operand_object
*object, u16 action)
{
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE_PTR ("ut_create_update_state", object);
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE_PTR("ut_create_update_state", object);
/* Create the generic state object */
state = acpi_ut_create_generic_state ();
state = acpi_ut_create_generic_state();
if (!state) {
return_PTR (NULL);
return_PTR(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;
state->update.value = action;
return_PTR (state);
return_PTR(state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_pkg_state
@@ -279,37 +251,32 @@ acpi_ut_create_update_state (
*
******************************************************************************/
union acpi_generic_state *
acpi_ut_create_pkg_state (
void *internal_object,
void *external_object,
u16 index)
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);
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 ();
state = acpi_ut_create_generic_state();
if (!state) {
return_PTR (NULL);
return_PTR(NULL);
}
/* Init fields specific to the update struct */
state->common.data_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.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);
return_PTR(state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_create_control_state
@@ -323,32 +290,27 @@ acpi_ut_create_pkg_state (
*
******************************************************************************/
union acpi_generic_state *
acpi_ut_create_control_state (
void)
union acpi_generic_state *acpi_ut_create_control_state(void)
{
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE ("ut_create_control_state");
union acpi_generic_state *state;
ACPI_FUNCTION_TRACE("ut_create_control_state");
/* Create the generic state object */
state = acpi_ut_create_generic_state ();
state = acpi_ut_create_generic_state();
if (!state) {
return_PTR (NULL);
return_PTR(NULL);
}
/* Init fields specific to the control struct */
state->common.data_type = ACPI_DESC_TYPE_STATE_CONTROL;
state->common.state = ACPI_CONTROL_CONDITIONAL_EXECUTING;
state->common.state = ACPI_CONTROL_CONDITIONAL_EXECUTING;
return_PTR (state);
return_PTR(state);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_delete_generic_state
@@ -362,15 +324,10 @@ acpi_ut_create_control_state (
*
******************************************************************************/
void
acpi_ut_delete_generic_state (
union acpi_generic_state *state)
void acpi_ut_delete_generic_state(union acpi_generic_state *state)
{
ACPI_FUNCTION_TRACE ("ut_delete_generic_state");
ACPI_FUNCTION_TRACE("ut_delete_generic_state");
(void) acpi_os_release_object (acpi_gbl_state_cache, state);
(void)acpi_os_release_object(acpi_gbl_state_cache, state);
return_VOID;
}

267
drivers/acpi/utilities/utxface.c
View File

@@ -49,8 +49,7 @@
#include <acpi/acdebug.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME ("utxface")
ACPI_MODULE_NAME("utxface")
/*******************************************************************************
*
@@ -64,60 +63,54 @@
* called, so any early initialization belongs here.
*
******************************************************************************/
acpi_status
acpi_initialize_subsystem (
void)
acpi_status acpi_initialize_subsystem(void)
{
acpi_status status;
acpi_status status;
ACPI_FUNCTION_TRACE("acpi_initialize_subsystem");
ACPI_FUNCTION_TRACE ("acpi_initialize_subsystem");
ACPI_DEBUG_EXEC (acpi_ut_init_stack_ptr_trace ());
ACPI_DEBUG_EXEC(acpi_ut_init_stack_ptr_trace());
/* Initialize the OS-Dependent layer */
status = acpi_os_initialize ();
if (ACPI_FAILURE (status)) {
ACPI_REPORT_ERROR (("OSD failed to initialize, %s\n",
acpi_format_exception (status)));
return_ACPI_STATUS (status);
status = acpi_os_initialize();
if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("OSD failed to initialize, %s\n",
acpi_format_exception(status)));
return_ACPI_STATUS(status);
}
/* Initialize all globals used by the subsystem */
acpi_ut_init_globals ();
acpi_ut_init_globals();
/* Create the default mutex objects */
status = acpi_ut_mutex_initialize ();
if (ACPI_FAILURE (status)) {
ACPI_REPORT_ERROR (("Global mutex creation failure, %s\n",
acpi_format_exception (status)));
return_ACPI_STATUS (status);
status = acpi_ut_mutex_initialize();
if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Global mutex creation failure, %s\n",
acpi_format_exception(status)));
return_ACPI_STATUS(status);
}
/*
* Initialize the namespace manager and
* the root of the namespace tree
*/
status = acpi_ns_root_initialize ();
if (ACPI_FAILURE (status)) {
ACPI_REPORT_ERROR (("Namespace initialization failure, %s\n",
acpi_format_exception (status)));
return_ACPI_STATUS (status);
status = acpi_ns_root_initialize();
if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Namespace initialization failure, %s\n",
acpi_format_exception(status)));
return_ACPI_STATUS(status);
}
/* If configured, initialize the AML debugger */
ACPI_DEBUGGER_EXEC (status = acpi_db_initialize ());
ACPI_DEBUGGER_EXEC(status = acpi_db_initialize());
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_enable_subsystem
@@ -131,41 +124,39 @@ acpi_initialize_subsystem (
*
******************************************************************************/
acpi_status
acpi_enable_subsystem (
u32 flags)
acpi_status acpi_enable_subsystem(u32 flags)
{
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE ("acpi_enable_subsystem");
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE("acpi_enable_subsystem");
/*
* We must initialize the hardware before we can enable ACPI.
* The values from the FADT are validated here.
*/
if (!(flags & ACPI_NO_HARDWARE_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Initializing ACPI hardware\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Initializing ACPI hardware\n"));
status = acpi_hw_initialize ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_hw_initialize();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
/* Enable ACPI mode */
if (!(flags & ACPI_NO_ACPI_ENABLE)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[Init] Going into ACPI mode\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Going into ACPI mode\n"));
acpi_gbl_original_mode = acpi_hw_get_mode();
status = acpi_enable ();
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_WARN, "acpi_enable failed.\n"));
return_ACPI_STATUS (status);
status = acpi_enable();
if (ACPI_FAILURE(status)) {
ACPI_DEBUG_PRINT((ACPI_DB_WARN,
"acpi_enable failed.\n"));
return_ACPI_STATUS(status);
}
}
@@ -175,12 +166,12 @@ acpi_enable_subsystem (
* install_address_space_handler interface.
*/
if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing default address space handlers\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Installing default address space handlers\n"));
status = acpi_ev_install_region_handlers ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ev_install_region_handlers();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
@@ -193,28 +184,28 @@ acpi_enable_subsystem (
* execution!
*/
if (!(flags & ACPI_NO_EVENT_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Initializing ACPI events\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Initializing ACPI events\n"));
status = acpi_ev_initialize_events ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ev_initialize_events();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
/* Install the SCI handler and Global Lock handler */
if (!(flags & ACPI_NO_HANDLER_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Installing SCI/GL handlers\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Installing SCI/GL handlers\n"));
status = acpi_ev_install_xrupt_handlers ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ev_install_xrupt_handlers();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
@@ -230,15 +221,11 @@ acpi_enable_subsystem (
*
******************************************************************************/
acpi_status
acpi_initialize_objects (
u32 flags)
acpi_status acpi_initialize_objects(u32 flags)
{
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE ("acpi_initialize_objects");
acpi_status status = AE_OK;
ACPI_FUNCTION_TRACE("acpi_initialize_objects");
/*
* Run all _REG methods
@@ -248,12 +235,12 @@ acpi_initialize_objects (
* contain executable AML (see call to acpi_ns_initialize_objects below).
*/
if (!(flags & ACPI_NO_ADDRESS_SPACE_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Executing _REG op_region methods\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Executing _REG op_region methods\n"));
status = acpi_ev_initialize_op_regions ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ev_initialize_op_regions();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
@@ -263,12 +250,12 @@ acpi_initialize_objects (
* objects: operation_regions, buffer_fields, Buffers, and Packages.
*/
if (!(flags & ACPI_NO_OBJECT_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Completing Initialization of ACPI Objects\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Completing Initialization of ACPI Objects\n"));
status = acpi_ns_initialize_objects ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ns_initialize_objects();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
@@ -277,12 +264,12 @@ acpi_initialize_objects (
* This runs the _STA and _INI methods.
*/
if (!(flags & ACPI_NO_DEVICE_INIT)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[Init] Initializing ACPI Devices\n"));
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[Init] Initializing ACPI Devices\n"));
status = acpi_ns_initialize_devices ();
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ns_initialize_devices();
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
}
@@ -291,13 +278,12 @@ acpi_initialize_objects (
* the table load filled them up more than they will be at runtime --
* thus wasting non-paged memory.
*/
status = acpi_purge_cached_objects ();
status = acpi_purge_cached_objects();
acpi_gbl_startup_flags |= ACPI_INITIALIZED_OK;
return_ACPI_STATUS (status);
return_ACPI_STATUS(status);
}
/*******************************************************************************
*
* FUNCTION: acpi_terminate
@@ -310,15 +296,11 @@ acpi_initialize_objects (
*
******************************************************************************/
acpi_status
acpi_terminate (
void)
acpi_status acpi_terminate(void)
{
acpi_status status;
ACPI_FUNCTION_TRACE ("acpi_terminate");
acpi_status status;
ACPI_FUNCTION_TRACE("acpi_terminate");
/* Terminate the AML Debugger if present */
@@ -326,28 +308,25 @@ acpi_terminate (
/* Shutdown and free all resources */
acpi_ut_subsystem_shutdown ();
acpi_ut_subsystem_shutdown();
/* Free the mutex objects */
acpi_ut_mutex_terminate ();
acpi_ut_mutex_terminate();
#ifdef ACPI_DEBUGGER
/* Shut down the debugger */
acpi_db_terminate ();
acpi_db_terminate();
#endif
/* Now we can shutdown the OS-dependent layer */
status = acpi_os_terminate ();
return_ACPI_STATUS (status);
status = acpi_os_terminate();
return_ACPI_STATUS(status);
}
#ifdef ACPI_FUTURE_USAGE
/*******************************************************************************
*
@@ -363,20 +342,16 @@ acpi_terminate (
*
******************************************************************************/
acpi_status
acpi_subsystem_status (
void)
acpi_status acpi_subsystem_status(void)
{
if (acpi_gbl_startup_flags & ACPI_INITIALIZED_OK) {
return (AE_OK);
}
else {
} else {
return (AE_ERROR);
}
}
/*******************************************************************************
*
* FUNCTION: acpi_get_system_info
@@ -395,64 +370,60 @@ acpi_subsystem_status (
*
******************************************************************************/
acpi_status
acpi_get_system_info (
struct acpi_buffer *out_buffer)
acpi_status acpi_get_system_info(struct acpi_buffer * out_buffer)
{
struct acpi_system_info *info_ptr;
acpi_status status;
u32 i;
ACPI_FUNCTION_TRACE ("acpi_get_system_info");
struct acpi_system_info *info_ptr;
acpi_status status;
u32 i;
ACPI_FUNCTION_TRACE("acpi_get_system_info");
/* Parameter validation */
status = acpi_ut_validate_buffer (out_buffer);
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status = acpi_ut_validate_buffer(out_buffer);
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/* Validate/Allocate/Clear caller buffer */
status = acpi_ut_initialize_buffer (out_buffer, sizeof (struct acpi_system_info));
if (ACPI_FAILURE (status)) {
return_ACPI_STATUS (status);
status =
acpi_ut_initialize_buffer(out_buffer,
sizeof(struct acpi_system_info));
if (ACPI_FAILURE(status)) {
return_ACPI_STATUS(status);
}
/*
* Populate the return buffer
*/
info_ptr = (struct acpi_system_info *) out_buffer->pointer;
info_ptr = (struct acpi_system_info *)out_buffer->pointer;
info_ptr->acpi_ca_version = ACPI_CA_VERSION;
info_ptr->acpi_ca_version = ACPI_CA_VERSION;
/* System flags (ACPI capabilities) */
info_ptr->flags = ACPI_SYS_MODE_ACPI;
info_ptr->flags = ACPI_SYS_MODE_ACPI;
/* Timer resolution - 24 or 32 bits */
if (!acpi_gbl_FADT) {
info_ptr->timer_resolution = 0;
}
else if (acpi_gbl_FADT->tmr_val_ext == 0) {
} else if (acpi_gbl_FADT->tmr_val_ext == 0) {
info_ptr->timer_resolution = 24;
}
else {
} else {
info_ptr->timer_resolution = 32;
}
/* Clear the reserved fields */
info_ptr->reserved1 = 0;
info_ptr->reserved2 = 0;
info_ptr->reserved1 = 0;
info_ptr->reserved2 = 0;
/* Current debug levels */
info_ptr->debug_layer = acpi_dbg_layer;
info_ptr->debug_level = acpi_dbg_level;
info_ptr->debug_layer = acpi_dbg_layer;
info_ptr->debug_level = acpi_dbg_level;
/* Current status of the ACPI tables, per table type */
@@ -461,10 +432,10 @@ acpi_get_system_info (
info_ptr->table_info[i].count = acpi_gbl_table_lists[i].count;
}
return_ACPI_STATUS (AE_OK);
return_ACPI_STATUS(AE_OK);
}
EXPORT_SYMBOL(acpi_get_system_info);
EXPORT_SYMBOL(acpi_get_system_info);
/*****************************************************************************
*
@@ -482,9 +453,7 @@ EXPORT_SYMBOL(acpi_get_system_info);
****************************************************************************/
acpi_status
acpi_install_initialization_handler (
acpi_init_handler handler,
u32 function)
acpi_install_initialization_handler(acpi_init_handler handler, u32 function)
{
if (!handler) {
@@ -499,7 +468,7 @@ acpi_install_initialization_handler (
return AE_OK;
}
#endif /* ACPI_FUTURE_USAGE */
#endif /* ACPI_FUTURE_USAGE */
/*****************************************************************************
*
@@ -513,15 +482,13 @@ acpi_install_initialization_handler (
*
****************************************************************************/
acpi_status
acpi_purge_cached_objects (
void)
acpi_status acpi_purge_cached_objects(void)
{
ACPI_FUNCTION_TRACE ("acpi_purge_cached_objects");
ACPI_FUNCTION_TRACE("acpi_purge_cached_objects");
(void) acpi_os_purge_cache (acpi_gbl_state_cache);
(void) acpi_os_purge_cache (acpi_gbl_operand_cache);
(void) acpi_os_purge_cache (acpi_gbl_ps_node_cache);
(void) acpi_os_purge_cache (acpi_gbl_ps_node_ext_cache);
return_ACPI_STATUS (AE_OK);
(void)acpi_os_purge_cache(acpi_gbl_state_cache);
(void)acpi_os_purge_cache(acpi_gbl_operand_cache);
(void)acpi_os_purge_cache(acpi_gbl_ps_node_cache);
(void)acpi_os_purge_cache(acpi_gbl_ps_node_ext_cache);
return_ACPI_STATUS(AE_OK);
}