status = acpi_ds_initialize_region (obj_handle);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Region %p [%4.4s] - Init failure, %s\n",
- obj_handle, ((struct acpi_namespace_node *) obj_handle)->name.ascii,
+ obj_handle, acpi_ut_get_node_name (obj_handle),
acpi_format_exception (status)));
}
status = acpi_ds_parse_method (obj_handle);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Method %p [%4.4s] - parse failure, %s\n",
- obj_handle, ((struct acpi_namespace_node *) obj_handle)->name.ascii,
+ obj_handle, acpi_ut_get_node_name (obj_handle),
acpi_format_exception (status)));
/* This parse failed, but we will continue parsing more methods */
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "**** Parsing [%4.4s] **** named_obj=%p\n",
- ((struct acpi_namespace_node *) obj_handle)->name.ascii, obj_handle));
+ acpi_ut_get_node_name (obj_handle), obj_handle));
/* Extract the method object from the method Node */
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"**** [%4.4s] Parsed **** named_obj=%p Op=%p\n",
- ((struct acpi_namespace_node *) obj_handle)->name.ascii, obj_handle, op));
+ acpi_ut_get_node_name (obj_handle), obj_handle, op));
acpi_ps_delete_parse_tree (op);
return_ACPI_STATUS (status);
* operand objects of type Reference.
*/
if (ACPI_GET_DESCRIPTOR_TYPE (current_obj_desc) != ACPI_DESC_TYPE_OPERAND) {
- ACPI_REPORT_ERROR (("Invalid descriptor type while storing to method arg: %X\n",
- current_obj_desc->common.type));
+ ACPI_REPORT_ERROR (("Invalid descriptor type while storing to method arg: [%s]\n",
+ acpi_ut_get_descriptor_name (current_obj_desc)));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
if ((current_obj_desc->common.type == ACPI_TYPE_LOCAL_REFERENCE) &&
(current_obj_desc->reference.opcode == AML_REF_OF_OP)) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
- "Arg (%p) is an obj_ref(Node), storing in node %p\n",
- obj_desc, current_obj_desc));
+ "Arg (%p) is an obj_ref(Node), storing in node %p\n",
+ obj_desc, current_obj_desc));
/*
* Store this object to the Node
ACPI_DEBUG_EXEC(acpi_ut_display_init_pathname (ACPI_TYPE_BUFFER_FIELD, node, NULL));
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] buffer_field Arg Init\n",
- node->name.ascii));
+ acpi_ut_get_node_name (node)));
/* Execute the AML code for the term_arg arguments */
ACPI_DEBUG_EXEC (acpi_ut_display_init_pathname (ACPI_TYPE_REGION, node, NULL));
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s] op_region Arg Init at AML %p\n",
- node->name.ascii, extra_desc->extra.aml_start));
+ acpi_ut_get_node_name (node), extra_desc->extra.aml_start));
/* Execute the argument AML */
* after resolution in acpi_ex_resolve_operands().
*/
if (ACPI_GET_DESCRIPTOR_TYPE (result_desc) != ACPI_DESC_TYPE_NAMED) {
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) destination must be a NS Node\n",
- acpi_ps_get_opcode_name (aml_opcode)));
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "(%s) destination not a NS Node [%s]\n",
+ acpi_ps_get_opcode_name (aml_opcode), acpi_ut_get_descriptor_name (result_desc)));
status = AE_AML_OPERAND_TYPE;
goto cleanup;
(8 * (u32) buffer_desc->buffer.length)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Field [%4.4s] size %d exceeds Buffer [%4.4s] size %d (bits)\n",
- ((struct acpi_namespace_node *) result_desc)->name.ascii,
+ acpi_ut_get_node_name (result_desc),
bit_offset + bit_count,
- buffer_desc->buffer.node->name.ascii,
+ acpi_ut_get_node_name (buffer_desc->buffer.node),
8 * (u32) buffer_desc->buffer.length));
status = AE_AML_BUFFER_LIMIT;
goto cleanup;
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "rgn_obj %p Addr %8.8X%8.8X Len %X\n",
obj_desc,
- ACPI_HIDWORD (obj_desc->region.address), ACPI_LODWORD (obj_desc->region.address),
+ ACPI_FORMAT_UINT64 (obj_desc->region.address),
obj_desc->region.length));
/* Now the address and length are valid for this opregion */
status = acpi_gbl_op_type_dispatch [op_type] (walk_state);
}
else {
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
- "[%s]: Could not resolve operands, %s\n",
- acpi_ps_get_opcode_name (walk_state->opcode),
- acpi_format_exception (status)));
+ /*
+ * Treat constructs of the form "Store(local_x,local_x)" as noops when the
+ * Local is uninitialized.
+ */
+ if ((status == AE_AML_UNINITIALIZED_LOCAL) &&
+ (walk_state->opcode == AML_STORE_OP) &&
+ (walk_state->operands[0]->common.type == ACPI_TYPE_LOCAL_REFERENCE) &&
+ (walk_state->operands[1]->common.type == ACPI_TYPE_LOCAL_REFERENCE) &&
+ (walk_state->operands[0]->reference.opcode ==
+ walk_state->operands[1]->reference.opcode)) {
+ status = AE_OK;
+ }
+ else {
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
+ "[%s]: Could not resolve operands, %s\n",
+ acpi_ps_get_opcode_name (walk_state->opcode),
+ acpi_format_exception (status)));
+ }
}
/* Always delete the argument objects and clear the operand stack */
if (old_scope_info) {
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,
"[%4.4s] (%s)",
- old_scope_info->scope.node->name.ascii,
+ acpi_ut_get_node_name (old_scope_info->scope.node),
acpi_ut_get_type_name (old_scope_info->common.value)));
}
else {
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,
", New scope -> [%4.4s] (%s)\n",
- scope_info->scope.node->name.ascii,
+ acpi_ut_get_node_name (scope_info->scope.node),
acpi_ut_get_type_name (scope_info->common.value)));
/* Push new scope object onto stack */
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"[%.2d] Popped scope [%4.4s] (%s), New scope -> ",
(u32) walk_state->scope_depth,
- scope_info->scope.node->name.ascii,
+ acpi_ut_get_node_name (scope_info->scope.node),
acpi_ut_get_type_name (scope_info->common.value)));
new_scope_info = walk_state->scope_info;
if (new_scope_info) {
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_EXEC,
"[%4.4s] (%s)\n",
- new_scope_info->scope.node->name.ascii,
+ acpi_ut_get_node_name (new_scope_info->scope.node),
acpi_ut_get_type_name (new_scope_info->common.value)));
}
else {
{
u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
u8 enabled_status_byte;
- u8 bit_mask;
struct acpi_gpe_register_info *gpe_register_info;
u32 in_value;
acpi_status status;
struct acpi_gpe_block_info *gpe_block;
- u32 gpe_number;
u32 i;
u32 j;
ACPI_DEBUG_PRINT ((ACPI_DB_INTERRUPTS,
"GPE pair: Status %8.8X%8.8X = %02X, Enable %8.8X%8.8X = %02X\n",
- ACPI_HIDWORD (gpe_register_info->status_address.address),
- ACPI_LODWORD (gpe_register_info->status_address.address),
+ ACPI_FORMAT_UINT64 (gpe_register_info->status_address.address),
gpe_register_info->status,
- ACPI_HIDWORD (gpe_register_info->enable_address.address),
- ACPI_LODWORD (gpe_register_info->enable_address.address),
+ ACPI_FORMAT_UINT64 (gpe_register_info->enable_address.address),
gpe_register_info->enable));
/* First check if there is anything active at all in this register */
/* Now look at the individual GPEs in this byte register */
- for (j = 0, bit_mask = 1; j < ACPI_GPE_REGISTER_WIDTH; j++, bit_mask <<= 1) {
+ for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
/* Examine one GPE bit */
- if (enabled_status_byte & bit_mask) {
+ if (enabled_status_byte & acpi_gbl_decode_to8bit[j]) {
/*
* Found an active GPE. Dispatch the event to a handler
* or method.
*/
- gpe_number = (i * ACPI_GPE_REGISTER_WIDTH) + j;
-
int_status |= acpi_ev_gpe_dispatch (
- &gpe_block->event_info[gpe_number],
- gpe_number + gpe_block->register_info[gpe_number].base_gpe_number);
+ &gpe_block->event_info[(i * ACPI_GPE_REGISTER_WIDTH) + j],
+ j + gpe_register_info->base_gpe_number);
}
}
}
if (ACPI_FAILURE (status)) {
ACPI_REPORT_ERROR (("%s while evaluating method [%4.4s] for GPE[%2X]\n",
acpi_format_exception (status),
- local_gpe_event_info.method_node->name.ascii, gpe_number));
+ acpi_ut_get_node_name (local_gpe_event_info.method_node), gpe_number));
}
}
/* Invoke the installed handler (at interrupt level) */
gpe_event_info->handler (gpe_event_info->context);
+
+ /* It is now safe to clear level-triggered events. */
+
+ if (gpe_event_info->flags & ACPI_EVENT_LEVEL_TRIGGERED) {
+ status = acpi_hw_clear_gpe (gpe_event_info);
+ if (ACPI_FAILURE (status)) {
+ ACPI_REPORT_ERROR ((
+ "acpi_ev_gpe_dispatch: Unable to clear GPE[%2X]\n",
+ gpe_number));
+ return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
+ }
+ }
}
else if (gpe_event_info->method_node) {
/*
*/
status = acpi_hw_disable_gpe (gpe_event_info);
if (ACPI_FAILURE (status)) {
- ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to disable GPE[%2X]\n",
+ ACPI_REPORT_ERROR ((
+ "acpi_ev_gpe_dispatch: Unable to disable GPE[%2X]\n",
gpe_number));
return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
}
- /* Execute the method associated with the GPE. */
-
+ /*
+ * Execute the method associated with the GPE
+ * NOTE: Level-triggered GPEs are cleared after the method completes.
+ */
if (ACPI_FAILURE (acpi_os_queue_for_execution (OSD_PRIORITY_GPE,
acpi_ev_asynch_execute_gpe_method,
gpe_event_info))) {
/*
* Disable the GPE. The GPE will remain disabled until the ACPI
- * Core Subsystem is restarted, or the handler is reinstalled.
+ * Core Subsystem is restarted, or a handler is installed.
*/
status = acpi_hw_disable_gpe (gpe_event_info);
if (ACPI_FAILURE (status)) {
- ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to disable GPE[%2X]\n",
- gpe_number));
- return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
- }
- }
-
- /* It is now safe to clear level-triggered events. */
-
- if (gpe_event_info->flags & ACPI_EVENT_LEVEL_TRIGGERED) {
- status = acpi_hw_clear_gpe (gpe_event_info);
- if (ACPI_FAILURE (status)) {
- ACPI_REPORT_ERROR (("acpi_ev_gpe_dispatch: Unable to clear GPE[%2X]\n",
+ ACPI_REPORT_ERROR ((
+ "acpi_ev_gpe_dispatch: Unable to disable GPE[%2X]\n",
gpe_number));
return_VALUE (ACPI_INTERRUPT_NOT_HANDLED);
}
((gpe_block->register_count * ACPI_GPE_REGISTER_WIDTH) -1)),
gpe_device->name.ascii,
gpe_block->register_count,
- ACPI_HIDWORD (gpe_block->block_address.address),
- ACPI_LODWORD (gpe_block->block_address.address),
+ ACPI_FORMAT_UINT64 (gpe_block->block_address.address),
interrupt_level));
/* Find all GPE methods (_Lxx, _Exx) for this block */
/* There is no per-device notify handler for this device */
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
- "No notify handler for [%4.4s] node %p\n", node->name.ascii, node));
+ "No notify handler for [%4.4s] node %p\n",
+ acpi_ut_get_node_name (node), node));
}
return (status);
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Handler %p (@%p) Address %8.8X%8.8X [%s]\n",
®ion_obj->region.address_space->address_space, handler,
- ACPI_HIDWORD (address), ACPI_LODWORD (address),
+ ACPI_FORMAT_UINT64 (address),
acpi_ut_get_region_name (region_obj->region.space_id)));
if (!(handler_desc->address_space.flags & ACPI_ADDR_HANDLER_DEFAULT_INSTALLED)) {
else {
ACPI_REPORT_ERROR ((
"Could not install pci_config handler for Root Bridge %4.4s, %s\n",
- pci_root_node->name.ascii, acpi_format_exception (status)));
+ acpi_ut_get_node_name (pci_root_node), acpi_format_exception (status)));
}
}
break;
ACPI_DEBUG_PRINT ((ACPI_DB_OPREGION,
"Installing address handler for region %s(%X) on Device %4.4s %p(%p)\n",
- acpi_ut_get_region_name (space_id), space_id, node->name.ascii, node, obj_desc));
+ acpi_ut_get_region_name (space_id), space_id,
+ acpi_ut_get_node_name (node), node, obj_desc));
/*
* Install the handler
if (!obj_desc) {
/*
- * This usually indicates that something serious is wrong --
- * since most (if not all)
- * code that dumps the stack expects something to be there!
+ * This usually indicates that something serious is wrong
*/
- acpi_os_printf ("Null stack entry ptr\n");
+ acpi_os_printf ("Null Object Descriptor\n");
return;
}
if (ACPI_GET_DESCRIPTOR_TYPE (obj_desc) == ACPI_DESC_TYPE_NAMED) {
- ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p NS Node: ", obj_desc));
+ ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p is a NS Node: ", obj_desc));
ACPI_DUMP_ENTRY (obj_desc, ACPI_LV_EXEC);
return;
}
if (ACPI_GET_DESCRIPTOR_TYPE (obj_desc) != ACPI_DESC_TYPE_OPERAND) {
- ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p is not a local object\n", obj_desc));
+ ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
+ "%p is not a node or operand object: [%s]\n",
+ obj_desc, acpi_ut_get_descriptor_name (obj_desc)));
ACPI_DUMP_BUFFER (obj_desc, sizeof (union acpi_operand_object));
return;
}
- /* obj_desc is a valid object */
+ /* obj_desc is a valid object */
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "%p ", obj_desc));
obj_desc->reference.offset);
if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_INTEGER) {
- /* Value is a Number */
+ /* Value is an Integer */
acpi_os_printf (" value is [%8.8X%8.8x]",
- ACPI_HIDWORD(obj_desc->integer.value),
- ACPI_LODWORD(obj_desc->integer.value));
+ ACPI_FORMAT_UINT64 (obj_desc->integer.value));
}
acpi_os_printf ("\n");
if (ACPI_GET_OBJECT_TYPE (obj_desc) == ACPI_TYPE_INTEGER) {
- /* Value is a Number */
+ /* Value is an Integer */
acpi_os_printf (" value is [%8.8X%8.8x]",
- ACPI_HIDWORD(obj_desc->integer.value),
- ACPI_LODWORD(obj_desc->integer.value));
+ ACPI_FORMAT_UINT64 (obj_desc->integer.value));
}
acpi_os_printf ("\n");
default:
- /* unknown opcode */
+ /* Unknown opcode */
acpi_os_printf ("Unknown Reference opcode=%X\n",
obj_desc->reference.opcode);
case ACPI_TYPE_INTEGER:
acpi_os_printf ("Integer %8.8X%8.8X\n",
- ACPI_HIDWORD (obj_desc->integer.value),
- ACPI_LODWORD (obj_desc->integer.value));
+ ACPI_FORMAT_UINT64 (obj_desc->integer.value));
break;
}
else {
acpi_os_printf (" base %8.8X%8.8X Length %X\n",
- ACPI_HIDWORD (obj_desc->region.address),
- ACPI_LODWORD (obj_desc->region.address),
+ ACPI_FORMAT_UINT64 (obj_desc->region.address),
obj_desc->region.length);
}
break;
acpi_os_printf ("%20s : %p\n", title, value);
#else
acpi_os_printf ("%20s : %8.8X%8.8X\n", title,
- ACPI_HIDWORD (value), ACPI_LODWORD (value));
+ ACPI_FORMAT_UINT64 (value));
#endif
}
}
}
- acpi_os_printf ("%20s : %4.4s\n", "Name", node->name.ascii);
+ acpi_os_printf ("%20s : %4.4s\n", "Name", acpi_ut_get_node_name (node));
acpi_ex_out_string ("Type", acpi_ut_get_type_name (node->type));
acpi_ex_out_integer ("Flags", node->flags);
acpi_ex_out_integer ("Owner Id", node->owner_id);
}
if (ACPI_GET_DESCRIPTOR_TYPE (obj_desc) != ACPI_DESC_TYPE_OPERAND) {
- acpi_os_printf ("ex_dump_object_descriptor: %p is not a valid ACPI object\n", obj_desc);
+ acpi_os_printf ("ex_dump_object_descriptor: %p is not an ACPI operand object: [%s]\n",
+ obj_desc, acpi_ut_get_descriptor_name (obj_desc));
return_VOID;
}
case ACPI_TYPE_INTEGER:
acpi_os_printf ("%20s : %8.8X%8.8X\n", "Value",
- ACPI_HIDWORD (obj_desc->integer.value),
- ACPI_LODWORD (obj_desc->integer.value));
+ ACPI_FORMAT_UINT64 (obj_desc->integer.value));
break;
*/
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Field [%4.4s] access width (%d bytes) too large for region [%4.4s] (length %X)\n",
- obj_desc->common_field.node->name.ascii, obj_desc->common_field.access_byte_width,
- rgn_desc->region.node->name.ascii, rgn_desc->region.length));
+ acpi_ut_get_node_name (obj_desc->common_field.node),
+ obj_desc->common_field.access_byte_width,
+ acpi_ut_get_node_name (rgn_desc->region.node), rgn_desc->region.length));
}
/*
*/
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Field [%4.4s] Base+Offset+Width %X+%X+%X is beyond end of region [%4.4s] (length %X)\n",
- obj_desc->common_field.node->name.ascii, obj_desc->common_field.base_byte_offset,
+ acpi_ut_get_node_name (obj_desc->common_field.node),
+ obj_desc->common_field.base_byte_offset,
field_datum_byte_offset, obj_desc->common_field.access_byte_width,
- rgn_desc->region.node->name.ascii, rgn_desc->region.length));
+ acpi_ut_get_node_name (rgn_desc->region.node), rgn_desc->region.length));
#ifdef CONFIG_ACPI_RELAXED_AML
{
obj_desc->common_field.access_byte_width,
obj_desc->common_field.base_byte_offset,
field_datum_byte_offset,
- ACPI_HIDWORD (address), ACPI_LODWORD (address)));
+ ACPI_FORMAT_UINT64 (address)));
/* Invoke the appropriate address_space/op_region handler */
if (ACPI_SUCCESS (status)) {
if (read_write == ACPI_READ) {
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Read %8.8X%8.8X, Width %d\n",
- ACPI_HIDWORD (*value), ACPI_LODWORD (*value),
+ ACPI_FORMAT_UINT64 (*value),
obj_desc->common_field.access_byte_width));
}
else {
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Value Written %8.8X%8.8X, Width %d\n",
- ACPI_HIDWORD (*value), ACPI_LODWORD (*value),
+ ACPI_FORMAT_UINT64 (*value),
obj_desc->common_field.access_byte_width));
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
"Mask %8.8X%8.8X, datum_offset %X, Width %X, Value %8.8X%8.8X, merged_value %8.8X%8.8X\n",
- ACPI_HIDWORD (mask), ACPI_LODWORD (mask),
+ ACPI_FORMAT_UINT64 (mask),
field_datum_byte_offset,
obj_desc->common_field.access_byte_width,
- ACPI_HIDWORD (field_value), ACPI_LODWORD (field_value),
- ACPI_HIDWORD (merged_value),ACPI_LODWORD (merged_value)));
+ ACPI_FORMAT_UINT64 (field_value),
+ ACPI_FORMAT_UINT64 (merged_value)));
/* Write the merged value */
{
acpi_status status;
u32 field_datum_byte_offset;
- u32 datum_offset;
- acpi_integer previous_raw_datum;
+ u32 buffer_datum_offset;
+ acpi_integer previous_raw_datum = 0;
acpi_integer this_raw_datum = 0;
acpi_integer merged_datum = 0;
u32 byte_field_length;
u32 datum_count;
+ u32 i;
ACPI_FUNCTION_TRACE ("ex_extract_from_field");
datum_count = ACPI_ROUND_UP_TO (byte_field_length,
obj_desc->common_field.access_byte_width);
+ /*
+ * If the field is not aligned on a datum boundary and does not
+ * fit within a single datum, we must read an extra datum.
+ *
+ * We could just split the aligned and non-aligned cases since the
+ * aligned case is so very simple, but this would require more code.
+ */
+ if ((obj_desc->common_field.end_field_valid_bits != 0) &&
+ (!(obj_desc->common_field.flags & AOPOBJ_SINGLE_DATUM))) {
+ datum_count++;
+ }
+
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD,
"byte_len %X, datum_len %X, byte_gran %X\n",
byte_field_length, datum_count,obj_desc->common_field.access_byte_width));
/*
* Clear the caller's buffer (the whole buffer length as given)
- * This is very important, especially in the cases where a byte is read,
- * but the buffer is really a u32 (4 bytes).
+ * This is very important, especially in the cases where the buffer
+ * is longer than the size of the field.
*/
ACPI_MEMSET (buffer, 0, buffer_length);
- /* Read the first raw datum to prime the loop */
-
field_datum_byte_offset = 0;
- datum_offset= 0;
-
- status = acpi_ex_field_datum_io (obj_desc, field_datum_byte_offset,
- &previous_raw_datum, ACPI_READ);
- if (ACPI_FAILURE (status)) {
- return_ACPI_STATUS (status);
- }
-
+ buffer_datum_offset= 0;
- /* We might actually be done if the request fits in one datum */
+ /* Read the entire field */
- if ((datum_count == 1) &&
- (obj_desc->common_field.flags & AOPOBJ_SINGLE_DATUM)) {
- /* 1) Shift the valid data bits down to start at bit 0 */
+ for (i = 0; i < datum_count; i++) {
+ status = acpi_ex_field_datum_io (obj_desc, field_datum_byte_offset,
+ &this_raw_datum, ACPI_READ);
+ if (ACPI_FAILURE (status)) {
+ return_ACPI_STATUS (status);
+ }
- merged_datum = (previous_raw_datum >> obj_desc->common_field.start_field_bit_offset);
+ /* We might actually be done if the request fits in one datum */
- /* 2) Mask off any upper unused bits (bits not part of the field) */
+ if ((datum_count == 1) &&
+ (obj_desc->common_field.flags & AOPOBJ_SINGLE_DATUM)) {
+ /* 1) Shift the valid data bits down to start at bit 0 */
- if (obj_desc->common_field.end_buffer_valid_bits) {
- merged_datum &= ACPI_MASK_BITS_ABOVE (obj_desc->common_field.end_buffer_valid_bits);
- }
+ merged_datum = (this_raw_datum >> obj_desc->common_field.start_field_bit_offset);
- /* Store the datum to the caller buffer */
+ /* 2) Mask off any upper unused bits (bits not part of the field) */
- acpi_ex_set_buffer_datum (merged_datum, buffer, buffer_length,
- obj_desc->common_field.access_byte_width, datum_offset);
+ if (obj_desc->common_field.end_buffer_valid_bits) {
+ merged_datum &= ACPI_MASK_BITS_ABOVE (obj_desc->common_field.end_buffer_valid_bits);
+ }
- return_ACPI_STATUS (AE_OK);
- }
+ /* Store the datum to the caller buffer */
+ acpi_ex_set_buffer_datum (merged_datum, buffer, buffer_length,
+ obj_desc->common_field.access_byte_width, buffer_datum_offset);
- /* We need to get more raw data to complete one or more field data */
+ return_ACPI_STATUS (AE_OK);
+ }
- while (datum_offset < datum_count) {
- field_datum_byte_offset += obj_desc->common_field.access_byte_width;
+ /* Special handling for the last datum to ignore extra bits */
- /*
- * If the field is aligned on a byte boundary, we don't want
- * to perform a final read, since this would potentially read
- * past the end of the region.
- *
- * We could just split the aligned and non-aligned cases since the
- * aligned case is so very simple, but this would require more code.
- */
- if ((obj_desc->common_field.start_field_bit_offset != 0) ||
- ((obj_desc->common_field.start_field_bit_offset == 0) &&
- (datum_offset < (datum_count -1)))) {
+ if ((i >= (datum_count -1)) &&
+ (obj_desc->common_field.end_field_valid_bits)) {
/*
- * Get the next raw datum, it contains some or all bits
- * of the current field datum
+ * This is the last iteration of the loop. We need to clear
+ * any unused bits (bits that are not part of this field) before
+ * we store the final merged datum into the caller buffer.
*/
- status = acpi_ex_field_datum_io (obj_desc, field_datum_byte_offset,
- &this_raw_datum, ACPI_READ);
- if (ACPI_FAILURE (status)) {
- return_ACPI_STATUS (status);
- }
+ this_raw_datum &=
+ ACPI_MASK_BITS_ABOVE (obj_desc->common_field.end_field_valid_bits);
}
/*
if (obj_desc->common_field.start_field_bit_offset == 0) {
/* Field is not skewed and we can just copy the datum */
- merged_datum = previous_raw_datum;
+ acpi_ex_set_buffer_datum (this_raw_datum, buffer, buffer_length,
+ obj_desc->common_field.access_byte_width, buffer_datum_offset);
+ buffer_datum_offset++;
}
else {
- /*
- * Put together the appropriate bits of the two raw data to make a
- * single complete field datum
- *
- * 1) Normalize the first datum down to bit 0
- */
- merged_datum = (previous_raw_datum >> obj_desc->common_field.start_field_bit_offset);
+ /* Not aligned -- on the first iteration, just save the datum */
- /* 2) Insert the second datum "above" the first datum */
-
- merged_datum |= (this_raw_datum << obj_desc->common_field.datum_valid_bits);
-
- if ((datum_offset >= (datum_count -1))) {
+ if (i != 0) {
/*
- * This is the last iteration of the loop. We need to clear
- * any unused bits (bits that are not part of this field) that
- * came from the last raw datum before we store the final
- * merged datum into the caller buffer.
+ * Put together the appropriate bits of the two raw data to make a
+ * single complete field datum
+ *
+ * 1) Normalize the first datum down to bit 0
*/
- if (obj_desc->common_field.end_buffer_valid_bits) {
- merged_datum &=
- ACPI_MASK_BITS_ABOVE (obj_desc->common_field.end_buffer_valid_bits);
- }
+ merged_datum = (previous_raw_datum >> obj_desc->common_field.start_field_bit_offset);
+
+ /* 2) Insert the second datum "above" the first datum */
+
+ merged_datum |= (this_raw_datum << obj_desc->common_field.datum_valid_bits);
+
+ acpi_ex_set_buffer_datum (merged_datum, buffer, buffer_length,
+ obj_desc->common_field.access_byte_width, buffer_datum_offset);
+ buffer_datum_offset++;
}
+
+ /*
+ * Save the raw datum that was just acquired since it may contain bits
+ * of the *next* field datum
+ */
+ previous_raw_datum = this_raw_datum;
}
- /*
- * Store the merged field datum in the caller's buffer, according to
- * the granularity of the field (size of each datum).
- */
- acpi_ex_set_buffer_datum (merged_datum, buffer, buffer_length,
- obj_desc->common_field.access_byte_width, datum_offset);
+ field_datum_byte_offset += obj_desc->common_field.access_byte_width;
+ }
- /*
- * Save the raw datum that was just acquired since it may contain bits
- * of the *next* field datum. Update offsets
- */
- previous_raw_datum = this_raw_datum;
- datum_offset++;
+ /* For non-aligned case, there is one last datum to insert */
+
+ if (obj_desc->common_field.start_field_bit_offset != 0) {
+ merged_datum = (this_raw_datum >> obj_desc->common_field.start_field_bit_offset);
+
+ acpi_ex_set_buffer_datum (merged_datum, buffer, buffer_length,
+ obj_desc->common_field.access_byte_width, buffer_datum_offset);
}
return_ACPI_STATUS (AE_OK);
default:
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Invalid descriptor type %X in %p\n",
- ACPI_GET_DESCRIPTOR_TYPE (obj_desc), obj_desc));
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p has invalid descriptor [%s]\n",
+ obj_desc, acpi_ut_get_descriptor_name (obj_desc)));
return_ACPI_STATUS (AE_TYPE);
}
*return_desc = reference_obj;
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Object %p Type [%s], returning Reference %p\n",
- obj_desc, acpi_ut_get_object_type_name (obj_desc), *return_desc));
+ obj_desc, acpi_ut_get_object_type_name (obj_desc), *return_desc));
return_ACPI_STATUS (AE_OK);
}
if (!walk_state->thread) {
ACPI_REPORT_ERROR (("Cannot acquire Mutex [%4.4s], null thread info\n",
- obj_desc->mutex.node->name.ascii));
+ acpi_ut_get_node_name (obj_desc->mutex.node)));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
*/
if (walk_state->thread->current_sync_level > obj_desc->mutex.sync_level) {
ACPI_REPORT_ERROR (("Cannot acquire Mutex [%4.4s], incorrect sync_level\n",
- obj_desc->mutex.node->name.ascii));
+ acpi_ut_get_node_name (obj_desc->mutex.node)));
return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
}
if (!obj_desc->mutex.owner_thread) {
ACPI_REPORT_ERROR (("Cannot release Mutex [%4.4s], not acquired\n",
- obj_desc->mutex.node->name.ascii));
+ acpi_ut_get_node_name (obj_desc->mutex.node)));
return_ACPI_STATUS (AE_AML_MUTEX_NOT_ACQUIRED);
}
if (!walk_state->thread) {
ACPI_REPORT_ERROR (("Cannot release Mutex [%4.4s], null thread info\n",
- obj_desc->mutex.node->name.ascii));
+ acpi_ut_get_node_name (obj_desc->mutex.node)));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
ACPI_REPORT_ERROR ((
"Thread %X cannot release Mutex [%4.4s] acquired by thread %X\n",
walk_state->thread->thread_id,
- obj_desc->mutex.node->name.ascii,
+ acpi_ut_get_node_name (obj_desc->mutex.node),
obj_desc->mutex.owner_thread->thread_id));
return_ACPI_STATUS (AE_AML_NOT_OWNER);
}
*/
if (obj_desc->mutex.sync_level > walk_state->thread->current_sync_level) {
ACPI_REPORT_ERROR (("Cannot release Mutex [%4.4s], incorrect sync_level\n",
- obj_desc->mutex.node->name.ascii));
+ acpi_ut_get_node_name (obj_desc->mutex.node)));
return_ACPI_STATUS (AE_AML_MUTEX_ORDER);
}
if (digit > 0) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Integer too large to convert to BCD: %8.8X%8.8X\n",
- ACPI_HIDWORD(operand[0]->integer.value),
- ACPI_LODWORD(operand[0]->integer.value)));
+ ACPI_FORMAT_UINT64 (operand[0]->integer.value)));
status = AE_AML_NUMERIC_OVERFLOW;
goto cleanup;
}
switch (walk_state->opcode) {
-
case AML_FATAL_OP: /* Fatal (fatal_type fatal_code fatal_arg) */
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"fatal_op: Type %X Code %X Arg %X <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n",
- (u32) operand[0]->integer.value, (u32) operand[1]->integer.value,
+ (u32) operand[0]->integer.value,
+ (u32) operand[1]->integer.value,
(u32) operand[2]->integer.value));
-
fatal = ACPI_MEM_ALLOCATE (sizeof (struct acpi_signal_fatal_info));
if (fatal) {
fatal->type = (u32) operand[0]->integer.value;
*/
nearest_byte_address =
ACPI_ROUND_BITS_DOWN_TO_BYTES (field_bit_position);
- obj_desc->common_field.base_byte_offset =
+ obj_desc->common_field.base_byte_offset = (u32)
ACPI_ROUND_DOWN (nearest_byte_address, byte_alignment);
/*
acpi_ns_get_type (info->field_node));
ACPI_DEBUG_PRINT ((ACPI_DB_BFIELD, "Set named_obj %p [%4.4s], obj_desc %p\n",
- info->field_node, info->field_node->name.ascii, obj_desc));
+ info->field_node, acpi_ut_get_node_name (info->field_node), obj_desc));
/* Remove local reference to the object */
(void **) &mem_info->mapped_logical_address);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Could not map memory at %8.8X%8.8X, size %X\n",
- ACPI_HIDWORD (address), ACPI_LODWORD (address), (u32) window_size));
+ ACPI_FORMAT_UINT64 (address), (u32) window_size));
mem_info->mapped_length = 0;
return_ACPI_STATUS (status);
}
((acpi_integer) address - (acpi_integer) mem_info->mapped_physical_address);
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
- "system_memory %d (%d width) Address=%8.8X%8.8X\n", function, bit_width,
- ACPI_HIDWORD (address), ACPI_LODWORD (address)));
+ "system_memory %d (%d width) Address=%8.8X%8.8X\n", function, bit_width,
+ ACPI_FORMAT_UINT64 (address)));
/*
* Perform the memory read or write
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
- "system_iO %d (%d width) Address=%8.8X%8.8X\n", function, bit_width,
- ACPI_HIDWORD (address), ACPI_LODWORD (address)));
+ "system_iO %d (%d width) Address=%8.8X%8.8X\n", function, bit_width,
+ ACPI_FORMAT_UINT64 (address)));
/* Decode the function parameter */
/* All "References" point to a NS node */
if (ACPI_GET_DESCRIPTOR_TYPE (node) != ACPI_DESC_TYPE_NAMED) {
+ ACPI_REPORT_ERROR (("acpi_ex_resolve_multiple: Not a NS node %p [%s]\n",
+ node, acpi_ut_get_descriptor_name (node)));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
/* All "References" point to a NS node */
if (ACPI_GET_DESCRIPTOR_TYPE (node) != ACPI_DESC_TYPE_NAMED) {
- return_ACPI_STATUS (AE_AML_INTERNAL);
+ ACPI_REPORT_ERROR (("acpi_ex_resolve_multiple: Not a NS node %p [%s]\n",
+ node, acpi_ut_get_descriptor_name (node)));
+ return_ACPI_STATUS (AE_AML_INTERNAL);
}
/* Get the attached object */
/* Invalid descriptor */
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
- "Bad descriptor type %X in Obj %p\n",
- ACPI_GET_DESCRIPTOR_TYPE (obj_desc), obj_desc));
+ "Invalid descriptor %p [%s]\n",
+ obj_desc, acpi_ut_get_descriptor_name (obj_desc)));
return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
}
case ACPI_TYPE_INTEGER:
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_DEBUG_OBJECT, "%8.8X%8.8X\n",
- ACPI_HIDWORD (source_desc->integer.value),
- ACPI_LODWORD (source_desc->integer.value)));
+ ACPI_FORMAT_UINT64 (source_desc->integer.value)));
break;
*
* FUNCTION: acpi_ex_system_do_stall
*
- * PARAMETERS: how_long - The amount of time to stall
+ * PARAMETERS: how_long - The amount of time to stall,
+ * in microseconds
*
* RETURN: Status
*
* DESCRIPTION: Suspend running thread for specified amount of time.
+ * Note: ACPI specification requires that Stall() does not
+ * relinquish the processor, and delays longer than 100 usec
+ * should use Sleep() instead. We allow stalls up to 255 usec
+ * for compatibility with other interpreters and existing BIOSs.
*
******************************************************************************/
ACPI_FUNCTION_ENTRY ();
- if (how_long > 100) /* 100 microseconds */ {
+ if (how_long > 255) /* 255 microseconds */ {
/*
- * Longer than 100 usec, use sleep instead
- * (according to ACPI specification)
+ * Longer than 255 usec, this is an error
+ *
+ * (ACPI specifies 100 usec as max, but this gives some slack in
+ * order to support existing BIOSs)
*/
- status = acpi_ex_system_do_suspend ((how_long / 1000) + 1);
+ ACPI_REPORT_ERROR (("Stall: Time parameter is too large (%d)\n", how_long));
+ status = AE_AML_OPERAND_VALUE;
}
else {
acpi_os_stall (how_long);
*
* FUNCTION: acpi_ex_system_do_suspend
*
- * PARAMETERS: how_long - The amount of time to suspend
+ * PARAMETERS: how_long - The amount of time to suspend,
+ * in milliseconds
*
* RETURN: None
*
ACPI_DEBUG_PRINT ((ACPI_DB_IO, "PM2 control: Read %X from %8.8X%8.8X\n",
register_value,
- ACPI_HIDWORD (acpi_gbl_FADT->xpm2_cnt_blk.address),
- ACPI_LODWORD (acpi_gbl_FADT->xpm2_cnt_blk.address)));
+ ACPI_FORMAT_UINT64 (acpi_gbl_FADT->xpm2_cnt_blk.address)));
ACPI_REGISTER_INSERT_VALUE (register_value, bit_reg_info->bit_position,
bit_reg_info->access_bit_mask, value);
ACPI_DEBUG_PRINT ((ACPI_DB_IO, "About to write %4.4X to %8.8X%8.8X\n",
register_value,
- ACPI_HIDWORD (acpi_gbl_FADT->xpm2_cnt_blk.address),
- ACPI_LODWORD (acpi_gbl_FADT->xpm2_cnt_blk.address)));
+ ACPI_FORMAT_UINT64 (acpi_gbl_FADT->xpm2_cnt_blk.address)));
status = acpi_hw_register_write (ACPI_MTX_DO_NOT_LOCK,
ACPI_REGISTER_PM2_CONTROL, (u8) (register_value));
ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Read: %8.8X width %2d from %8.8X%8.8X (%s)\n",
*value, width,
- ACPI_HIDWORD (reg->address),
- ACPI_LODWORD (reg->address),
+ ACPI_FORMAT_UINT64 (reg->address),
acpi_ut_get_region_name (reg->address_space_id)));
return (status);
ACPI_DEBUG_PRINT ((ACPI_DB_IO, "Wrote: %8.8X width %2d to %8.8X%8.8X (%s)\n",
value, width,
- ACPI_HIDWORD (reg->address),
- ACPI_LODWORD (reg->address),
+ ACPI_FORMAT_UINT64 (reg->address),
acpi_ut_get_region_name (reg->address_space_id)));
return (status);
else {
prefix_node = scope_info->scope.node;
if (ACPI_GET_DESCRIPTOR_TYPE (prefix_node) != ACPI_DESC_TYPE_NAMED) {
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "[%p] Not a namespace node\n",
- prefix_node));
+ ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "%p Not a namespace node [%s]\n",
+ prefix_node, acpi_ut_get_descriptor_name (prefix_node)));
return_ACPI_STATUS (AE_AML_INTERNAL);
}
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
"Searching relative to prefix scope [%4.4s] (%p)\n",
- prefix_node->name.ascii, prefix_node));
+ acpi_ut_get_node_name (prefix_node), prefix_node));
/*
* Handle multiple Parent Prefixes (carat) by just getting
if (search_parent_flag == ACPI_NS_NO_UPSEARCH) {
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
"Search scope is [%4.4s], path has %d carat(s)\n",
- this_node->name.ascii, num_carats));
+ acpi_ut_get_node_name (this_node), num_carats));
}
}
* alphabetic placement.
*/
previous_child_node = NULL;
- while (acpi_ns_compare_names (child_node->name.ascii, node->name.ascii) < 0) {
+ while (acpi_ns_compare_names (acpi_ut_get_node_name (child_node), acpi_ut_get_node_name (node)) < 0) {
if (child_node->flags & ANOBJ_END_OF_PEER_LIST) {
/* Last peer; Clear end-of-list flag */
node->type = (u8) type;
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "%4.4s (%s) added to %4.4s (%s) %p at %p\n",
- node->name.ascii, acpi_ut_get_type_name (node->type),
- parent_node->name.ascii, acpi_ut_get_type_name (parent_node->type), parent_node, node));
+ acpi_ut_get_node_name (node), acpi_ut_get_type_name (node->type),
+ acpi_ut_get_node_name (parent_node), acpi_ut_get_type_name (parent_node->type),
+ parent_node, node));
/*
* Increment the reference count(s) of all parents up to
#define _COMPONENT ACPI_NAMESPACE
ACPI_MODULE_NAME ("nsdump")
-#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
+#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
/*******************************************************************************
*
return;
}
- /* Print the entire name */
+ /* Print the entire name */
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "["));
* Now we can print out the pertinent information
*/
acpi_os_printf ("%4.4s %-12s %p ",
- this_node->name.ascii, acpi_ut_get_type_name (type), this_node);
+ acpi_ut_get_node_name (this_node), acpi_ut_get_type_name (type), this_node);
dbg_level = acpi_dbg_level;
acpi_dbg_level = 0;
case ACPI_TYPE_INTEGER:
acpi_os_printf ("= %8.8X%8.8X\n",
- ACPI_HIDWORD (obj_desc->integer.value),
- ACPI_LODWORD (obj_desc->integer.value));
+ ACPI_FORMAT_UINT64 (obj_desc->integer.value));
break;
acpi_os_printf ("[%s]", acpi_ut_get_region_name (obj_desc->region.space_id));
if (obj_desc->region.flags & AOPOBJ_DATA_VALID) {
acpi_os_printf (" Addr %8.8X%8.8X Len %.4X\n",
- ACPI_HIDWORD (obj_desc->region.address),
- ACPI_LODWORD (obj_desc->region.address),
+ ACPI_FORMAT_UINT64 (obj_desc->region.address),
obj_desc->region.length);
}
else {
if (obj_desc->buffer_field.buffer_obj &&
obj_desc->buffer_field.buffer_obj->buffer.node) {
acpi_os_printf ("Buf [%4.4s]",
- obj_desc->buffer_field.buffer_obj->buffer.node->name.ascii);
+ acpi_ut_get_node_name (obj_desc->buffer_field.buffer_obj->buffer.node));
}
break;
case ACPI_TYPE_LOCAL_REGION_FIELD:
acpi_os_printf ("Rgn [%4.4s]",
- obj_desc->common_field.region_obj->region.node->name.ascii);
+ acpi_ut_get_node_name (obj_desc->common_field.region_obj->region.node));
break;
case ACPI_TYPE_LOCAL_BANK_FIELD:
acpi_os_printf ("Rgn [%4.4s] Bnk [%4.4s]",
- obj_desc->common_field.region_obj->region.node->name.ascii,
- obj_desc->bank_field.bank_obj->common_field.node->name.ascii);
+ acpi_ut_get_node_name (obj_desc->common_field.region_obj->region.node),
+ acpi_ut_get_node_name (obj_desc->bank_field.bank_obj->common_field.node));
break;
case ACPI_TYPE_LOCAL_INDEX_FIELD:
acpi_os_printf ("Idx [%4.4s] Dat [%4.4s]",
- obj_desc->index_field.index_obj->common_field.node->name.ascii,
- obj_desc->index_field.data_obj->common_field.node->name.ascii);
+ acpi_ut_get_node_name (obj_desc->index_field.index_obj->common_field.node),
+ acpi_ut_get_node_name (obj_desc->index_field.data_obj->common_field.node));
break;
case ACPI_TYPE_LOCAL_ALIAS:
- acpi_os_printf ("Target %4.4s (%p)\n", ((struct acpi_namespace_node *) obj_desc)->name.ascii, obj_desc);
+ acpi_os_printf ("Target %4.4s (%p)\n", acpi_ut_get_node_name (obj_desc), obj_desc);
break;
default:
case ACPI_TYPE_LOCAL_BANK_FIELD:
case ACPI_TYPE_LOCAL_INDEX_FIELD:
- acpi_os_printf ("Off %.2X Len %.2X Acc %.2hd\n",
+ acpi_os_printf (" Off %.3X Len %.2X Acc %.2hd\n",
(obj_desc->common_field.base_byte_offset * 8)
+ obj_desc->common_field.start_field_bit_offset,
obj_desc->common_field.bit_length,
case ACPI_TYPE_INTEGER:
- acpi_os_printf (" N:%X%X\n", ACPI_HIDWORD(obj_desc->integer.value),
- ACPI_LODWORD(obj_desc->integer.value));
+ acpi_os_printf (" I:%8.8X8.8%X\n",
+ ACPI_FORMAT_UINT64 (obj_desc->integer.value));
break;
case ACPI_TYPE_STRING:
default:
- acpi_os_printf ("(String or Buffer ptr - not an object descriptor)\n");
+ acpi_os_printf ("(String or Buffer ptr - not an object descriptor) [%s]\n",
+ acpi_ut_get_descriptor_name (obj_desc));
bytes_to_dump = 16;
break;
}
info.owner_id = owner_id;
info.display_type = display_type;
-
(void) acpi_ns_walk_namespace (type, start_handle, max_depth,
ACPI_NS_WALK_NO_UNLOCK, acpi_ns_dump_one_object,
(void *) &info, NULL);
ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "\\\n"));
}
-
acpi_ns_dump_objects (ACPI_TYPE_ANY, ACPI_DISPLAY_OBJECTS, max_depth,
ACPI_UINT32_MAX, search_handle);
return_VOID;
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_TABLES, " HID: %s, ADR: %8.8X%8.8X, Status: %X\n",
info->hardware_id.value,
- ACPI_HIDWORD (info->address), ACPI_LODWORD (info->address),
+ ACPI_FORMAT_UINT64 (info->address),
info->current_status));
ACPI_MEM_FREE (info);
}
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "Executing all Device _STA and_INI methods:"));
- /* Walk namespace for all objects of type Device */
+ status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
+ if (ACPI_FAILURE (status)) {
+ return_ACPI_STATUS (status);
+ }
+
+ /* Walk namespace for all objects of type Device or Processor */
- status = acpi_ns_walk_namespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
- ACPI_UINT32_MAX, FALSE, acpi_ns_init_one_device, &info, NULL);
+ status = acpi_ns_walk_namespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
+ ACPI_UINT32_MAX, TRUE, acpi_ns_init_one_device, &info, NULL);
+
+ (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (status)) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "walk_namespace failed! %s\n",
ACPI_DEBUG_PRINT_RAW ((ACPI_DB_ERROR, "\n"));
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Could not execute arguments for [%4.4s] (%s), %s\n",
- node->name.ascii, acpi_ut_get_type_name (type), acpi_format_exception (status)));
+ acpi_ut_get_node_name (node), acpi_ut_get_type_name (type),
+ acpi_format_exception (status)));
}
/* Print a dot for each object unless we are going to print the entire pathname */
ACPI_FUNCTION_TRACE ("ns_init_one_device");
- if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) && (!(acpi_dbg_level & ACPI_LV_INFO))) {
- ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "."));
- }
-
- info->device_count++;
-
- status = acpi_ut_acquire_mutex (ACPI_MTX_NAMESPACE);
- if (ACPI_FAILURE (status)) {
- return_ACPI_STATUS (status);
- }
-
node = acpi_ns_map_handle_to_node (obj_handle);
if (!node) {
- (void) acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
- status = acpi_ut_release_mutex (ACPI_MTX_NAMESPACE);
- if (ACPI_FAILURE (status)) {
- return_ACPI_STATUS (status);
+ /*
+ * We will run _STA/_INI on Devices and Processors only
+ */
+ if ((node->type != ACPI_TYPE_DEVICE) &&
+ (node->type != ACPI_TYPE_PROCESSOR)) {
+ return_ACPI_STATUS (AE_OK);
}
+ if ((acpi_dbg_level <= ACPI_LV_ALL_EXCEPTIONS) && (!(acpi_dbg_level & ACPI_LV_INFO))) {
+ ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INIT, "."));
+ }
+
+ info->device_count++;
+
/*
* Run _STA to determine if we can run _INI on the device.
*/
ACPI_DEBUG_EXEC (acpi_ut_display_init_pathname (ACPI_TYPE_METHOD, node, "_STA"));
status = acpi_ut_execute_STA (node, &flags);
+
if (ACPI_FAILURE (status)) {
- /* Ignore error and move on to next device */
+ if (node->type == ACPI_TYPE_DEVICE) {
+ /* Ignore error and move on to next device */
- return_ACPI_STATUS (AE_OK);
- }
+ return_ACPI_STATUS (AE_OK);
+ }
- info->num_STA++;
+ /* _STA is not required for Processor objects */
+ }
+ else {
+ info->num_STA++;
- if (!(flags & 0x01)) {
- /* don't look at children of a not present device */
+ if (!(flags & 0x01)) {
+ /* Don't look at children of a not present device */
- return_ACPI_STATUS(AE_CTRL_DEPTH);
+ return_ACPI_STATUS(AE_CTRL_DEPTH);
+ }
}
/*
if (ACPI_GET_DESCRIPTOR_TYPE (node) != ACPI_DESC_TYPE_NAMED) {
/* Not a name handle */
- ACPI_REPORT_ERROR (("ns_attach_object: Invalid handle\n"));
+ ACPI_REPORT_ERROR (("ns_attach_object: Invalid handle %p [%s]\n",
+ node, acpi_ut_get_descriptor_name (node)));
return_ACPI_STATUS (AE_BAD_PARAMETER);
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Installing %p into Node %p [%4.4s]\n",
- obj_desc, node, node->name.ascii));
+ obj_desc, node, acpi_ut_get_node_name (node)));
/* Detach an existing attached object if present */
node->type = ACPI_TYPE_ANY;
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES, "Node %p [%4.4s] Object %p\n",
- node, node->name.ascii, obj_desc));
+ node, acpi_ut_get_node_name (node), obj_desc));
/* Remove one reference on the object (and all subobjects) */
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
"Name [%4.4s] (%s) %p found in scope [%4.4s] %p\n",
(char *) &target_name, acpi_ut_get_type_name (next_node->type),
- next_node, node->name.ascii, node));
+ next_node, acpi_ut_get_node_name (node), node));
*return_node = next_node;
return_ACPI_STATUS (AE_OK);
ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
"Name [%4.4s] (%s) not found in search in scope [%4.4s] %p first child %p\n",
(char *) &target_name, acpi_ut_get_type_name (type),
- node->name.ascii, node, node->child));
+ acpi_ut_get_node_name (node), node, node->child));
return_ACPI_STATUS (AE_NOT_FOUND);
}
parent_node = acpi_ns_get_parent_node (child_node);
if (parent_node) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Parent of %p [%4.4s] is %p [%4.4s]\n",
- child_node, child_node->name.ascii,
- parent_node, parent_node->name.ascii));
+ child_node, acpi_ut_get_node_name (child_node),
+ parent_node, acpi_ut_get_node_name (parent_node)));
if (parent_node->name.integer) {
return_VALUE ((acpi_name) parent_node->name.integer);
}
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "unable to find parent of %p (%4.4s)\n",
- child_node, child_node->name.ascii));
+ child_node, acpi_ut_get_node_name (child_node)));
}
return_VALUE (ACPI_UNKNOWN_NAME);
/* Just copy the ACPI name from the Node and zero terminate it */
- ACPI_STRNCPY (buffer->pointer, node->name.ascii,
+ ACPI_STRNCPY (buffer->pointer, acpi_ut_get_node_name (node),
ACPI_NAME_SIZE);
((char *) buffer->pointer) [ACPI_NAME_SIZE] = 0;
status = AE_OK;
acpi_ps_get_next_field (
struct acpi_parse_state *parser_state)
{
- u32 aml_offset = ACPI_PTR_DIFF (parser_state->aml,
+ u32 aml_offset = (u32) ACPI_PTR_DIFF (parser_state->aml,
parser_state->aml_start);
union acpi_parse_object *field;
u16 opcode;
/* Fill in bytelist data */
- arg->common.value.size = ACPI_PTR_DIFF (parser_state->pkg_end,
+ arg->common.value.size = (u32) ACPI_PTR_DIFF (parser_state->pkg_end,
parser_state->aml);
arg->named.data = parser_state->aml;
if (!op) {
/* Get the next opcode from the AML stream */
- walk_state->aml_offset = ACPI_PTR_DIFF (parser_state->aml,
+ walk_state->aml_offset = (u32) ACPI_PTR_DIFF (parser_state->aml,
parser_state->aml_start);
walk_state->opcode = acpi_ps_peek_opcode (parser_state);
while (GET_CURRENT_ARG_TYPE (walk_state->arg_types) &&
!walk_state->arg_count) {
- walk_state->aml_offset = ACPI_PTR_DIFF (parser_state->aml,
+ walk_state->aml_offset = (u32) ACPI_PTR_DIFF (parser_state->aml,
parser_state->aml_start);
status = acpi_ps_get_next_arg (walk_state, parser_state,
GET_CURRENT_ARG_TYPE (walk_state->arg_types), &arg);
default:
/*
* If we get here, everything is out of sync,
- * so exit with an error
+ * exit with an error
*/
return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
}
/*
* Update the return value and counter
*/
- buffer_size += ACPI_ALIGN_RESOURCE_SIZE(structure_size);
+ buffer_size += (u32) ACPI_ALIGN_RESOURCE_SIZE (structure_size);
bytes_parsed += bytes_consumed;
/*
/* Now align the current length */
- user_prt->length = ACPI_ROUND_UP_to_64_bITS (user_prt->length);
+ user_prt->length = (u32) ACPI_ROUND_UP_to_64_bITS (user_prt->length);
/*
* 4) Fourth subobject: Dereference the PRT.source_index
"" : "not ");
acpi_os_printf (" Granularity: %8.8X%8.8X\n",
- ACPI_HIDWORD (address64_data->granularity),
- ACPI_LODWORD (address64_data->granularity));
+ ACPI_FORMAT_UINT64 (address64_data->granularity));
acpi_os_printf (" Address range min: %8.8X%8.8X\n",
- ACPI_HIDWORD (address64_data->min_address_range),
- ACPI_HIDWORD (address64_data->min_address_range));
+ ACPI_FORMAT_UINT64 (address64_data->min_address_range));
acpi_os_printf (" Address range max: %8.8X%8.8X\n",
- ACPI_HIDWORD (address64_data->max_address_range),
- ACPI_HIDWORD (address64_data->max_address_range));
+ ACPI_FORMAT_UINT64 (address64_data->max_address_range));
acpi_os_printf (" Address translation offset: %8.8X%8.8X\n",
- ACPI_HIDWORD (address64_data->address_translation_offset),
- ACPI_HIDWORD (address64_data->address_translation_offset));
+ ACPI_FORMAT_UINT64 (address64_data->address_translation_offset));
acpi_os_printf (" Address Length: %8.8X%8.8X\n",
- ACPI_HIDWORD (address64_data->address_length),
- ACPI_HIDWORD (address64_data->address_length));
+ ACPI_FORMAT_UINT64 (address64_data->address_length));
if(0xFF != address64_data->resource_source.index) {
acpi_os_printf (" Resource Source Index: %X\n",
acpi_os_printf ("PCI IRQ Routing Table structure %X.\n", count++);
acpi_os_printf (" Address: %8.8X%8.8X\n",
- ACPI_HIDWORD (prt_element->address),
- ACPI_LODWORD (prt_element->address));
+ ACPI_FORMAT_UINT64 (prt_element->address));
acpi_os_printf (" Pin: %X\n", prt_element->pin);
* Set the Buffer to the next structure
*/
resource = ACPI_CAST_PTR (struct acpi_resource, buffer);
- resource->length = ACPI_ALIGN_RESOURCE_SIZE(resource->length);
- buffer += ACPI_ALIGN_RESOURCE_SIZE(structure_size);
+ resource->length = (u32) ACPI_ALIGN_RESOURCE_SIZE (resource->length);
+ buffer += ACPI_ALIGN_RESOURCE_SIZE (structure_size);
} /* end while */
(void *) &header);
if (ACPI_FAILURE (status)) {
ACPI_REPORT_ERROR (("Could not map memory at %8.8X%8.8X for length %X\n",
- ACPI_HIDWORD (address->pointer.physical),
- ACPI_LODWORD (address->pointer.physical),
+ ACPI_FORMAT_UINT64 (address->pointer.physical),
sizeof (struct acpi_table_header)));
return_ACPI_STATUS (status);
}
if (ACPI_FAILURE (status)) {
ACPI_REPORT_ERROR (("Could not map memory for table [%4.4s] at %8.8X%8.8X for length %X\n",
header->signature,
- ACPI_HIDWORD (address->pointer.physical),
- ACPI_LODWORD (address->pointer.physical), header->length));
+ ACPI_FORMAT_UINT64 (address->pointer.physical), header->length));
return (status);
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Found table [%4.4s] at %8.8X%8.8X, mapped/copied to %p\n",
full_table->signature,
- ACPI_HIDWORD (address->pointer.physical),
- ACPI_LODWORD (address->pointer.physical), full_table));
+ ACPI_FORMAT_UINT64 (address->pointer.physical), full_table));
return_ACPI_STATUS (status);
}
if ((status != AE_OK) && (status != AE_TABLE_NOT_SUPPORTED)) {
ACPI_REPORT_WARNING (("%s, while getting table at %8.8X%8.8X\n",
acpi_format_exception (status),
- ACPI_HIDWORD (address.pointer.value),
- ACPI_LODWORD (address.pointer.value)));
+ ACPI_FORMAT_UINT64 (address.pointer.value)));
}
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"RSDP located at %p, points to RSDT physical=%8.8X%8.8X \n",
acpi_gbl_RSDP,
- ACPI_HIDWORD (address.pointer.value),
- ACPI_LODWORD (address.pointer.value)));
+ ACPI_FORMAT_UINT64 (address.pointer.value)));
/* Check the RSDT or XSDT signature */
/* Find all tables of the requested type */
table_desc = acpi_gbl_table_lists[table_type].next;
- while (table_desc); {
+ while (table_desc) {
/*
* Delete all namespace entries owned by this table. Note that these
* entries can appear anywhere in the namespace by virtue of the AML
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"RSDP located at %p, RSDT physical=%8.8X%8.8X \n",
acpi_gbl_RSDP,
- ACPI_HIDWORD (address.pointer.value),
- ACPI_LODWORD (address.pointer.value)));
+ ACPI_FORMAT_UINT64 (address.pointer.value)));
/* Insert processor_mode flags */
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 ",
+ acpi_os_printf ("%p Len %04X %9.9s-%d [%s] ",
descriptor, element->size, element->module,
- element->line);
+ element->line, acpi_ut_get_descriptor_name (descriptor));
- /* Most of the elements will be internal objects. */
+ /* Most of the elements will be Operand objects. */
switch (ACPI_GET_DESCRIPTOR_TYPE (descriptor)) {
case ACPI_DESC_TYPE_OPERAND:
- acpi_os_printf ("obj_type %12.12s R%hd",
+ 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 ("parse_obj aml_opcode %04hX",
+ acpi_os_printf ("aml_opcode %04hX",
descriptor->op.asl.aml_opcode);
break;
case ACPI_DESC_TYPE_NAMED:
- acpi_os_printf ("Node %4.4s",
- descriptor->node.name.ascii);
- break;
-
- case ACPI_DESC_TYPE_STATE:
- acpi_os_printf ("Untyped state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_UPDATE:
- acpi_os_printf ("UPDATE state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_PACKAGE:
- acpi_os_printf ("PACKAGE state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_CONTROL:
- acpi_os_printf ("CONTROL state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_RPSCOPE:
- acpi_os_printf ("ROOT-PARSE-SCOPE state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_PSCOPE:
- acpi_os_printf ("PARSE-SCOPE state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_WSCOPE:
- acpi_os_printf ("WALK-SCOPE state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_RESULT:
- acpi_os_printf ("RESULT state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_NOTIFY:
- acpi_os_printf ("NOTIFY state_obj");
- break;
-
- case ACPI_DESC_TYPE_STATE_THREAD:
- acpi_os_printf ("THREAD state_obj");
+ acpi_os_printf ("%4.4s",
+ acpi_ut_get_node_name (&descriptor->node));
break;
default:
- /* All types should appear above */
break;
}
acpi_ut_debug_print (ACPI_LV_FUNCTIONS, line_number, dbg_info,
"%s %8.8X%8.8X\n", acpi_gbl_fn_exit_str,
- ACPI_HIDWORD (value), ACPI_LODWORD (value));
+ ACPI_FORMAT_UINT64 (value));
acpi_gbl_nesting_level--;
}
if (ACPI_FAILURE (status)) {
if (status == AE_NOT_FOUND) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s.%s] was not found\n",
- prefix_node->name.ascii, path));
+ acpi_ut_get_node_name (prefix_node), path));
}
else {
ACPI_REPORT_METHOD_ERROR ("Method execution failed",
if (AE_NOT_FOUND == status) {
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
"_STA on %4.4s was not found, assuming device is present\n",
- device_node->name.ascii));
+ acpi_ut_get_node_name (device_node)));
*flags = 0x0F;
status = AE_OK;
/* 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, 0, 0},
+ /* ACPI_EVENT_RTC */ {ACPI_BITREG_RT_CLOCK_STATUS, ACPI_BITREG_RT_CLOCK_ENABLE, ACPI_BITMASK_RT_CLOCK_STATUS, ACPI_BITMASK_RT_CLOCK_ENABLE},
};
/*****************************************************************************
}
+/*****************************************************************************
+ *
+ * FUNCTION: acpi_ut_get_node_name
+ *
+ * PARAMETERS: Object - A namespace node
+ *
+ * RETURN: Pointer to a string
+ *
+ * DESCRIPTION: Validate the node and return the node's ACPI name.
+ *
+ ****************************************************************************/
+
+char *
+acpi_ut_get_node_name (
+ void *object)
+{
+ struct acpi_namespace_node *node;
+
+
+ if (!object)
+ {
+ return ("NULL NODE");
+ }
+
+ node = (struct acpi_namespace_node *) object;
+
+ if (node->descriptor != ACPI_DESC_TYPE_NAMED)
+ {
+ return ("INVALID NODE");
+ }
+
+ if (!acpi_ut_valid_acpi_name (* (u32 *) node->name.ascii))
+ {
+ return ("INVALID NODE NAME");
+ }
+
+ return (node->name.ascii);
+}
+
+
+/*****************************************************************************
+ *
+ * FUNCTION: acpi_ut_get_descriptor_name
+ *
+ * PARAMETERS: Object - An ACPI object
+ *
+ * RETURN: Pointer to a string
+ *
+ * DESCRIPTION: Validate object and return the descriptor type
+ *
+ ****************************************************************************/
+
+static const char *acpi_gbl_desc_type_names[] = /* printable names of descriptor types */
+{
+ /* 00 */ "Invalid",
+ /* 01 */ "Cached",
+ /* 02 */ "State-Generic",
+ /* 03 */ "State-Update",
+ /* 04 */ "State-Package",
+ /* 05 */ "State-Control",
+ /* 06 */ "State-root_parse_scope",
+ /* 07 */ "State-parse_scope",
+ /* 08 */ "State-walk_scope",
+ /* 09 */ "State-Result",
+ /* 10 */ "State-Notify",
+ /* 11 */ "State-Thread",
+ /* 12 */ "Walk",
+ /* 13 */ "Parser",
+ /* 14 */ "Operand",
+ /* 15 */ "Node"
+};
+
+
+char *
+acpi_ut_get_descriptor_name (
+ void *object)
+{
+
+ if (!object)
+ {
+ return ("NULL OBJECT");
+ }
+
+ 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)]);
+
+}
+
+
#if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER)
/*
* Strings and procedures used for debug only
return (TRUE);
- case ACPI_DESC_TYPE_NAMED:
-
- ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
- "**** Obj %p is a named obj, not ACPI obj\n", object));
- break;
-
- case ACPI_DESC_TYPE_PARSER:
-
- ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
- "**** Obj %p is a parser obj, not ACPI obj\n", object));
- break;
-
- case ACPI_DESC_TYPE_CACHED:
-
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
- "**** Obj %p has already been released to internal cache\n", object));
- break;
-
default:
-
- ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
- "**** Obj %p has unknown descriptor type %X\n", object,
- ACPI_GET_DESCRIPTOR_TYPE (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;
}
if (ACPI_GET_DESCRIPTOR_TYPE (object) != ACPI_DESC_TYPE_OPERAND) {
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
- "Obj %p is not an ACPI object\n", object));
+ "%p is not an ACPI Operand object [%s]\n", object,
+ acpi_ut_get_descriptor_name (object)));
return_VOID;
}
/* Version string */
-#define ACPI_CA_VERSION 0x20031002
+#define ACPI_CA_VERSION 0x20031029
/* Maximum objects in the various object caches */
/*
* Data manipulation macros
*/
-
#define ACPI_LOWORD(l) ((u16)(u32)(l))
#define ACPI_HIWORD(l) ((u16)((((u32)(l)) >> 16) & 0xFFFF))
#define ACPI_LOBYTE(l) ((u8)(u16)(l))
#endif
#endif
- /*
- * Extract a byte of data using a pointer. Any more than a byte and we
- * get into potential aligment issues -- see the STORE macros below
- */
+/*
+ * printf() format helpers
+ */
+
+/* Split 64-bit integer into two 32-bit values. use with %8,8_x%8.8X */
+
+#define ACPI_FORMAT_UINT64(i) ACPI_HIDWORD(i),ACPI_LODWORD(i)
+
+/*
+ * Extract a byte of data using a pointer. Any more than a byte and we
+ * get into potential aligment issues -- see the STORE macros below
+ */
#define ACPI_GET8(addr) (*(u8*)(addr))
/* Pointer arithmetic */
* If the hardware supports the transfer of unaligned data, just do the store.
* Otherwise, we have to move one byte at a time.
*/
-
#ifdef ACPI_BIG_ENDIAN
/*
* Macros for big-endian machines
/*
* Fast power-of-two math macros for non-optimized compilers
*/
-
#define _ACPI_DIV(value,power_of2) ((u32) ((value) >> (power_of2)))
#define _ACPI_MUL(value,power_of2) ((u32) ((value) << (power_of2)))
#define _ACPI_MOD(value,divisor) ((u32) ((value) & ((divisor) -1)))
/*
* Reporting macros that are never compiled out
*/
-
#define ACPI_PARAM_LIST(pl) pl
/*
* _THIS_MODULE gets compiled out when ACPI_DEBUG_OUTPUT isn't defined, only
* use it in debug mode.
*/
-
#ifdef ACPI_DEBUG_OUTPUT
#define ACPI_REPORT_INFO(fp) {acpi_ut_report_info(_THIS_MODULE,__LINE__,_COMPONENT); \
/*
* Debug macros that are conditionally compiled
*/
-
#ifdef ACPI_DEBUG_OUTPUT
#define ACPI_MODULE_NAME(name) static char ACPI_UNUSED_VAR *_THIS_MODULE = name;
* The first parameter should be the procedure name as a quoted string. This is declared
* as a local string ("_proc_name) so that it can be also used by the function exit macros below.
*/
-
#define ACPI_FUNCTION_NAME(a) struct acpi_debug_print_info _dbg; \
_dbg.component_id = _COMPONENT; \
_dbg.proc_name = a; \
/*
* Generate INT3 on ACPI_ERROR (Debug only!)
*/
-
#define ACPI_ERROR_BREAK
#ifdef ACPI_ERROR_BREAK
#define ACPI_BREAK_ON_ERROR(lvl) if ((lvl)&ACPI_ERROR) \
* 1) Debug print for the current component is enabled
* 2) Debug error level or trace level for the print statement is enabled
*/
-
#define ACPI_DEBUG_PRINT(pl) acpi_ut_debug_print ACPI_PARAM_LIST(pl)
#define ACPI_DEBUG_PRINT_RAW(pl) acpi_ut_debug_print_raw ACPI_PARAM_LIST(pl)
* This is the non-debug case -- make everything go away,
* leaving no executable debug code!
*/
-
#define ACPI_MODULE_NAME(name)
#define _THIS_MODULE ""
/*
* Memory allocation tracking (DEBUG ONLY)
*/
-
#ifndef ACPI_DBG_TRACK_ALLOCATIONS
/* Memory allocation */
/* Object descriptor types */
-#define ACPI_DESC_TYPE_CACHED 0x11 /* Used only when object is cached */
-#define ACPI_DESC_TYPE_STATE 0x20
-#define ACPI_DESC_TYPE_STATE_UPDATE 0x21
-#define ACPI_DESC_TYPE_STATE_PACKAGE 0x22
-#define ACPI_DESC_TYPE_STATE_CONTROL 0x23
-#define ACPI_DESC_TYPE_STATE_RPSCOPE 0x24
-#define ACPI_DESC_TYPE_STATE_PSCOPE 0x25
-#define ACPI_DESC_TYPE_STATE_WSCOPE 0x26
-#define ACPI_DESC_TYPE_STATE_RESULT 0x27
-#define ACPI_DESC_TYPE_STATE_NOTIFY 0x28
-#define ACPI_DESC_TYPE_STATE_THREAD 0x29
-#define ACPI_DESC_TYPE_WALK 0x44
-#define ACPI_DESC_TYPE_PARSER 0x66
-#define ACPI_DESC_TYPE_OPERAND 0x88
-#define ACPI_DESC_TYPE_NAMED 0xAA
+#define ACPI_DESC_TYPE_CACHED 0x01 /* Used only when object is cached */
+#define ACPI_DESC_TYPE_STATE 0x02
+#define ACPI_DESC_TYPE_STATE_UPDATE 0x03
+#define ACPI_DESC_TYPE_STATE_PACKAGE 0x04
+#define ACPI_DESC_TYPE_STATE_CONTROL 0x05
+#define ACPI_DESC_TYPE_STATE_RPSCOPE 0x06
+#define ACPI_DESC_TYPE_STATE_PSCOPE 0x07
+#define ACPI_DESC_TYPE_STATE_WSCOPE 0x08
+#define ACPI_DESC_TYPE_STATE_RESULT 0x09
+#define ACPI_DESC_TYPE_STATE_NOTIFY 0x0A
+#define ACPI_DESC_TYPE_STATE_THREAD 0x0B
+#define ACPI_DESC_TYPE_WALK 0x0C
+#define ACPI_DESC_TYPE_PARSER 0x0D
+#define ACPI_DESC_TYPE_OPERAND 0x0E
+#define ACPI_DESC_TYPE_NAMED 0x0F
+#define ACPI_DESC_TYPE_MAX 0x0F
union acpi_descriptor
acpi_ut_get_type_name (
acpi_object_type type);
+char *
+acpi_ut_get_node_name (
+ void *object);
+
+char *
+acpi_ut_get_descriptor_name (
+ void *object);
+
char *
acpi_ut_get_object_type_name (
union acpi_operand_object *obj_desc);
projects / linux / commitdiff