Skip to content

cloud-kernel
cloud-kernel

openanolis / cloud-kernel
大约 2 年 前同步成功

通知 173
Star 36
Fork 7
cloud-kernel
cloud-kernel
提交 0897831b 编写于 作者: B Bob Moore 提交者： Len Brown
浏览文件
操作

[ACPI] ACPICA 20051021 

Implemented support for the EM64T and other x86_64
processors. This essentially entails recognizing
that these processors support non-aligned memory
transfers. Previously, all 64-bit processors were assumed
to lack hardware support for non-aligned transfers.

Completed conversion of the Resource Manager to nearly
full table-driven operation. Specifically, the resource
conversion code (convert AML to internal format and the
reverse) and the debug code to dump internal resource
descriptors are fully table-driven, reducing code and data
size and improving maintainability.

The OSL interfaces for Acquire and Release Lock now use a
64-bit flag word on 64-bit processors instead of a fixed
32-bit word. (Alexey Starikovskiy)

Implemented support within the resource conversion code
for the Type-Specific byte within the various ACPI 3.0
*WordSpace macros.

Fixed some issues within the resource conversion code for
the type-specific flags for both Memory and I/O address
resource descriptors. For Memory, implemented support
for the MTP and TTP flags. For I/O, split the TRS and TTP
flags into two separate fields.
Signed-off-by: NBob Moore <robert.moore@intel.com>
Signed-off-by: NLen Brown <len.brown@intel.com>
上级 50eca3eb
展开全部 隐藏空白更改
内联 并排
Showing with 2275 addition and 2982 deletion
arch/ia64/pci/pci.c
浏览文件 @ 0897831b
...@@ -195,7 +195,7 @@ add_io_space (struct pci_root_info *info, struct acpi_resource_address64 *addr) ...@@ -195,7 +195,7 @@ add_io_space (struct pci_root_info *info, struct acpi_resource_address64 *addr)
min = addr->minimum; min = addr->minimum;
max = min + addr->address_length - 1; max = min + addr->address_length - 1;
if (addr->attribute.io.translation_attribute == ACPI_SPARSE_TRANSLATION) if (addr->info.io.translation_type == ACPI_SPARSE_TRANSLATION)
sparse = 1; sparse = 1;
space_nr = new_space(addr->translation_offset, sparse); space_nr = new_space(addr->translation_offset, sparse);
......
drivers/acpi/events/evgpe.c
浏览文件 @ 0897831b
...@@ -372,14 +372,14 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device, ...@@ -372,14 +372,14 @@ struct acpi_gpe_event_info *acpi_ev_get_gpe_event_info(acpi_handle gpe_device,
u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list) u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info * gpe_xrupt_list)
{ {
acpi_status status;
struct acpi_gpe_block_info *gpe_block;
struct acpi_gpe_register_info *gpe_register_info;
u32 int_status = ACPI_INTERRUPT_NOT_HANDLED; u32 int_status = ACPI_INTERRUPT_NOT_HANDLED;
u8 enabled_status_byte; u8 enabled_status_byte;
struct acpi_gpe_register_info *gpe_register_info;
u32 status_reg; u32 status_reg;
u32 enable_reg; u32 enable_reg;
u32 flags; acpi_native_uint flags;
acpi_status status;
struct acpi_gpe_block_info *gpe_block;
acpi_native_uint i; acpi_native_uint i;
acpi_native_uint j; acpi_native_uint j;
......
drivers/acpi/events/evgpeblk.c
浏览文件 @ 0897831b
...@@ -136,7 +136,7 @@ acpi_status acpi_ev_walk_gpe_list(ACPI_GPE_CALLBACK gpe_walk_callback) ...@@ -136,7 +136,7 @@ acpi_status acpi_ev_walk_gpe_list(ACPI_GPE_CALLBACK gpe_walk_callback)
struct acpi_gpe_block_info *gpe_block; struct acpi_gpe_block_info *gpe_block;
struct acpi_gpe_xrupt_info *gpe_xrupt_info; struct acpi_gpe_xrupt_info *gpe_xrupt_info;
acpi_status status = AE_OK; acpi_status status = AE_OK;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_walk_gpe_list"); ACPI_FUNCTION_TRACE("ev_walk_gpe_list");
...@@ -479,7 +479,7 @@ static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32 ...@@ -479,7 +479,7 @@ static struct acpi_gpe_xrupt_info *acpi_ev_get_gpe_xrupt_block(u32
struct acpi_gpe_xrupt_info *next_gpe_xrupt; struct acpi_gpe_xrupt_info *next_gpe_xrupt;
struct acpi_gpe_xrupt_info *gpe_xrupt; struct acpi_gpe_xrupt_info *gpe_xrupt;
acpi_status status; acpi_status status;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_get_gpe_xrupt_block"); ACPI_FUNCTION_TRACE("ev_get_gpe_xrupt_block");
...@@ -553,7 +553,7 @@ static acpi_status ...@@ -553,7 +553,7 @@ static acpi_status
acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt) acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
{ {
acpi_status status; acpi_status status;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_delete_gpe_xrupt"); ACPI_FUNCTION_TRACE("ev_delete_gpe_xrupt");
...@@ -610,7 +610,7 @@ acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block, ...@@ -610,7 +610,7 @@ acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
struct acpi_gpe_block_info *next_gpe_block; struct acpi_gpe_block_info *next_gpe_block;
struct acpi_gpe_xrupt_info *gpe_xrupt_block; struct acpi_gpe_xrupt_info *gpe_xrupt_block;
acpi_status status; acpi_status status;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_install_gpe_block"); ACPI_FUNCTION_TRACE("ev_install_gpe_block");
...@@ -663,7 +663,7 @@ acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block, ...@@ -663,7 +663,7 @@ acpi_ev_install_gpe_block(struct acpi_gpe_block_info *gpe_block,
acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block) acpi_status acpi_ev_delete_gpe_block(struct acpi_gpe_block_info *gpe_block)
{ {
acpi_status status; acpi_status status;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_install_gpe_block"); ACPI_FUNCTION_TRACE("ev_install_gpe_block");
......
drivers/acpi/events/evxface.c
浏览文件 @ 0897831b
...@@ -562,7 +562,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device, ...@@ -562,7 +562,7 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
struct acpi_gpe_event_info *gpe_event_info; struct acpi_gpe_event_info *gpe_event_info;
struct acpi_handler_info *handler; struct acpi_handler_info *handler;
acpi_status status; acpi_status status;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("acpi_install_gpe_handler"); ACPI_FUNCTION_TRACE("acpi_install_gpe_handler");
...@@ -653,7 +653,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_device, ...@@ -653,7 +653,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
struct acpi_gpe_event_info *gpe_event_info; struct acpi_gpe_event_info *gpe_event_info;
struct acpi_handler_info *handler; struct acpi_handler_info *handler;
acpi_status status; acpi_status status;
u32 flags; acpi_native_uint flags;
ACPI_FUNCTION_TRACE("acpi_remove_gpe_handler"); ACPI_FUNCTION_TRACE("acpi_remove_gpe_handler");
......
drivers/acpi/executer/exmisc.c
浏览文件 @ 0897831b
...@@ -625,9 +625,8 @@ acpi_ex_do_logical_op(u16 opcode, ...@@ -625,9 +625,8 @@ acpi_ex_do_logical_op(u16 opcode,
/* Lexicographic compare: compare the data bytes */ /* Lexicographic compare: compare the data bytes */
compare = ACPI_MEMCMP((const char *)operand0->buffer.pointer, compare = ACPI_MEMCMP(operand0->buffer.pointer,
(const char *)local_operand1->buffer. local_operand1->buffer.pointer,
pointer,
(length0 > length1) ? length1 : length0); (length0 > length1) ? length1 : length0);
switch (opcode) { switch (opcode) {
......
drivers/acpi/executer/exregion.c
浏览文件 @ 0897831b
...@@ -77,7 +77,7 @@ acpi_ex_system_memory_space_handler(u32 function, ...@@ -77,7 +77,7 @@ acpi_ex_system_memory_space_handler(u32 function,
struct acpi_mem_space_context *mem_info = region_context; struct acpi_mem_space_context *mem_info = region_context;
u32 length; u32 length;
acpi_size window_size; acpi_size window_size;
#ifndef ACPI_MISALIGNED_TRANSFERS #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
u32 remainder; u32 remainder;
#endif #endif
...@@ -109,7 +109,7 @@ acpi_ex_system_memory_space_handler(u32 function, ...@@ -109,7 +109,7 @@ acpi_ex_system_memory_space_handler(u32 function,
return_ACPI_STATUS(AE_AML_OPERAND_VALUE); return_ACPI_STATUS(AE_AML_OPERAND_VALUE);
} }
#ifndef ACPI_MISALIGNED_TRANSFERS #ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
/* /*
* Hardware does not support non-aligned data transfers, we must verify * Hardware does not support non-aligned data transfers, we must verify
* the request. * the request.
......
drivers/acpi/osl.c
浏览文件 @ 0897831b
...@@ -1058,11 +1058,9 @@ EXPORT_SYMBOL(max_cstate); ...@@ -1058,11 +1058,9 @@ EXPORT_SYMBOL(max_cstate);
* Acquire a spinlock. * Acquire a spinlock.
* *
* handle is a pointer to the spinlock_t. * handle is a pointer to the spinlock_t.
* flags is *not* the result of save_flags - it is an ACPI-specific flag variable
* that indicates whether we are at interrupt level.
*/ */
unsigned long acpi_os_acquire_lock(acpi_handle handle) acpi_native_uint acpi_os_acquire_lock(acpi_handle handle)
{ {
unsigned long flags; unsigned long flags;
spin_lock_irqsave((spinlock_t *) handle, flags); spin_lock_irqsave((spinlock_t *) handle, flags);
...@@ -1073,7 +1071,7 @@ unsigned long acpi_os_acquire_lock(acpi_handle handle) ...@@ -1073,7 +1071,7 @@ unsigned long acpi_os_acquire_lock(acpi_handle handle)
* Release a spinlock. See above. * Release a spinlock. See above.
*/ */
void acpi_os_release_lock(acpi_handle handle, unsigned long flags) void acpi_os_release_lock(acpi_handle handle, acpi_native_uint flags)
{ {
spin_unlock_irqrestore((spinlock_t *) handle, flags); spin_unlock_irqrestore((spinlock_t *) handle, flags);
} }
......
drivers/acpi/resources/rsaddr.c
浏览文件 @ 0897831b
此差异已折叠。
drivers/acpi/resources/rscalc.c
浏览文件 @ 0897831b
...@@ -52,7 +52,7 @@ ACPI_MODULE_NAME("rscalc") ...@@ -52,7 +52,7 @@ ACPI_MODULE_NAME("rscalc")
/* Local prototypes */ /* Local prototypes */
static u8 acpi_rs_count_set_bits(u16 bit_field); static u8 acpi_rs_count_set_bits(u16 bit_field);
static acpi_size static acpi_rs_length
acpi_rs_struct_option_length(struct acpi_resource_source *resource_source); acpi_rs_struct_option_length(struct acpi_resource_source *resource_source);
static u32 static u32
...@@ -100,7 +100,7 @@ static u8 acpi_rs_count_set_bits(u16 bit_field) ...@@ -100,7 +100,7 @@ static u8 acpi_rs_count_set_bits(u16 bit_field)
* *
******************************************************************************/ ******************************************************************************/
static acpi_size static acpi_rs_length
acpi_rs_struct_option_length(struct acpi_resource_source *resource_source) acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
{ {
ACPI_FUNCTION_ENTRY(); ACPI_FUNCTION_ENTRY();
...@@ -111,7 +111,7 @@ acpi_rs_struct_option_length(struct acpi_resource_source *resource_source) ...@@ -111,7 +111,7 @@ acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
* resource_source_index (1). * resource_source_index (1).
*/ */
if (resource_source->string_ptr) { if (resource_source->string_ptr) {
return ((acpi_size) resource_source->string_length + 1); return ((acpi_rs_length) (resource_source->string_length + 1));
} }
return (0); return (0);
...@@ -184,7 +184,7 @@ acpi_status ...@@ -184,7 +184,7 @@ acpi_status
acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
{ {
acpi_size aml_size_needed = 0; acpi_size aml_size_needed = 0;
acpi_size segment_size; acpi_rs_length total_size;
ACPI_FUNCTION_TRACE("rs_get_aml_length"); ACPI_FUNCTION_TRACE("rs_get_aml_length");
...@@ -199,7 +199,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -199,7 +199,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
/* Get the base size of the (external stream) resource descriptor */ /* Get the base size of the (external stream) resource descriptor */
segment_size = acpi_gbl_aml_resource_sizes[resource->type]; total_size = acpi_gbl_aml_resource_sizes[resource->type];
/* /*
* Augment the base size for descriptors with optional and/or * Augment the base size for descriptors with optional and/or
...@@ -216,13 +216,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -216,13 +216,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
if (resource->data.vendor.byte_length > 7) { if (resource->data.vendor.byte_length > 7) {
/* Base size of a Large resource descriptor */ /* Base size of a Large resource descriptor */
segment_size = total_size =
sizeof(struct aml_resource_large_header); sizeof(struct aml_resource_large_header);
} }
/* Add the size of the vendor-specific data */ /* Add the size of the vendor-specific data */
segment_size += resource->data.vendor.byte_length; total_size = (acpi_rs_length)
(total_size + resource->data.vendor.byte_length);
break; break;
case ACPI_RESOURCE_TYPE_END_TAG: case ACPI_RESOURCE_TYPE_END_TAG:
...@@ -230,7 +231,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -230,7 +231,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* End Tag: * End Tag:
* We are done -- return the accumulated total size. * We are done -- return the accumulated total size.
*/ */
*size_needed = aml_size_needed + segment_size; *size_needed = aml_size_needed + total_size;
/* Normal exit */ /* Normal exit */
...@@ -241,10 +242,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -241,10 +242,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 16-Bit Address Resource: * 16-Bit Address Resource:
* Add the size of the optional resource_source info * Add the size of the optional resource_source info
*/ */
segment_size += total_size = (acpi_rs_length)
acpi_rs_struct_option_length(&resource->data. (total_size +
address16. acpi_rs_struct_option_length(&resource->data.
resource_source); address16.
resource_source));
break; break;
case ACPI_RESOURCE_TYPE_ADDRESS32: case ACPI_RESOURCE_TYPE_ADDRESS32:
...@@ -252,10 +254,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -252,10 +254,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 32-Bit Address Resource: * 32-Bit Address Resource:
* Add the size of the optional resource_source info * Add the size of the optional resource_source info
*/ */
segment_size += total_size = (acpi_rs_length)
acpi_rs_struct_option_length(&resource->data. (total_size +
address32. acpi_rs_struct_option_length(&resource->data.
resource_source); address32.
resource_source));
break; break;
case ACPI_RESOURCE_TYPE_ADDRESS64: case ACPI_RESOURCE_TYPE_ADDRESS64:
...@@ -263,10 +266,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -263,10 +266,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 64-Bit Address Resource: * 64-Bit Address Resource:
* Add the size of the optional resource_source info * Add the size of the optional resource_source info
*/ */
segment_size += total_size = (acpi_rs_length)
acpi_rs_struct_option_length(&resource->data. (total_size +
address64. acpi_rs_struct_option_length(&resource->data.
resource_source); address64.
resource_source));
break; break;
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
...@@ -275,16 +279,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -275,16 +279,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* Add the size of each additional optional interrupt beyond the * Add the size of each additional optional interrupt beyond the
* required 1 (4 bytes for each u32 interrupt number) * required 1 (4 bytes for each u32 interrupt number)
*/ */
segment_size += (((acpi_size) total_size = (acpi_rs_length)
resource->data.extended_irq. (total_size +
interrupt_count - 1) * 4); ((resource->data.extended_irq.interrupt_count -
1) * 4) +
/* Add the size of the optional resource_source info */ /* Add the size of the optional resource_source info */
acpi_rs_struct_option_length(&resource->data.
segment_size += extended_irq.
acpi_rs_struct_option_length(&resource->data. resource_source));
extended_irq.
resource_source);
break; break;
default: default:
...@@ -293,7 +295,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed) ...@@ -293,7 +295,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
/* Update the total */ /* Update the total */
aml_size_needed += segment_size; aml_size_needed += total_size;
/* Point to the next object */ /* Point to the next object */
...@@ -341,7 +343,7 @@ acpi_rs_get_list_length(u8 * aml_buffer, ...@@ -341,7 +343,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
while (bytes_parsed < aml_buffer_length) { while (bytes_parsed < aml_buffer_length) {
/* The next byte in the stream is the resource descriptor type */ /* The next byte in the stream is the resource descriptor type */
resource_type = acpi_rs_get_resource_type(*aml_buffer); resource_type = acpi_ut_get_resource_type(aml_buffer);
/* Get the base stream size and structure sizes for the descriptor */ /* Get the base stream size and structure sizes for the descriptor */
...@@ -352,10 +354,7 @@ acpi_rs_get_list_length(u8 * aml_buffer, ...@@ -352,10 +354,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
/* Get the Length field from the input resource descriptor */ /* Get the Length field from the input resource descriptor */
resource_length = resource_length = acpi_ut_get_resource_length(aml_buffer);
acpi_rs_get_resource_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
/* Augment the size for descriptors with optional fields */ /* Augment the size for descriptors with optional fields */
......
drivers/acpi/resources/rsdump.c
浏览文件 @ 0897831b
此差异已折叠。
drivers/acpi/resources/rsinfo.c
浏览文件 @ 0897831b
...@@ -58,60 +58,60 @@ ACPI_MODULE_NAME("rsinfo") ...@@ -58,60 +58,60 @@ ACPI_MODULE_NAME("rsinfo")
* descriptors are indexed by the acpi_resource_type field. * descriptors are indexed by the acpi_resource_type field.
*/ */
/* Dispatch table for resource-to-AML (Set Resource) conversion functions */ /* Dispatch table for resource-to-AML (Set Resource) conversion functions */
ACPI_SET_RESOURCE_HANDLER acpi_gbl_set_resource_dispatch[] = { struct acpi_rsconvert_info *acpi_gbl_set_resource_dispatch[] = {
acpi_rs_set_irq, /* 0x00, ACPI_RESOURCE_TYPE_IRQ */ acpi_rs_set_irq, /* 0x00, ACPI_RESOURCE_TYPE_IRQ */
acpi_rs_set_dma, /* 0x01, ACPI_RESOURCE_TYPE_DMA */ acpi_rs_convert_dma, /* 0x01, ACPI_RESOURCE_TYPE_DMA */
acpi_rs_set_start_dpf, /* 0x02, ACPI_RESOURCE_TYPE_START_DEPENDENT */ acpi_rs_set_start_dpf, /* 0x02, ACPI_RESOURCE_TYPE_START_DEPENDENT */
acpi_rs_set_end_dpf, /* 0x03, ACPI_RESOURCE_TYPE_END_DEPENDENT */ acpi_rs_convert_end_dpf, /* 0x03, ACPI_RESOURCE_TYPE_END_DEPENDENT */
acpi_rs_set_io, /* 0x04, ACPI_RESOURCE_TYPE_IO */ acpi_rs_convert_io, /* 0x04, ACPI_RESOURCE_TYPE_IO */
acpi_rs_set_fixed_io, /* 0x05, ACPI_RESOURCE_TYPE_FIXED_IO */ acpi_rs_convert_fixed_io, /* 0x05, ACPI_RESOURCE_TYPE_FIXED_IO */
acpi_rs_set_vendor, /* 0x06, ACPI_RESOURCE_TYPE_VENDOR */ acpi_rs_set_vendor, /* 0x06, ACPI_RESOURCE_TYPE_VENDOR */
acpi_rs_set_end_tag, /* 0x07, ACPI_RESOURCE_TYPE_END_TAG */ acpi_rs_convert_end_tag, /* 0x07, ACPI_RESOURCE_TYPE_END_TAG */
acpi_rs_set_memory24, /* 0x08, ACPI_RESOURCE_TYPE_MEMORY24 */ acpi_rs_convert_memory24, /* 0x08, ACPI_RESOURCE_TYPE_MEMORY24 */
acpi_rs_set_memory32, /* 0x09, ACPI_RESOURCE_TYPE_MEMORY32 */ acpi_rs_convert_memory32, /* 0x09, ACPI_RESOURCE_TYPE_MEMORY32 */
acpi_rs_set_fixed_memory32, /* 0x0A, ACPI_RESOURCE_TYPE_FIXED_MEMORY32 */ acpi_rs_convert_fixed_memory32, /* 0x0A, ACPI_RESOURCE_TYPE_FIXED_MEMORY32 */
acpi_rs_set_address16, /* 0x0B, ACPI_RESOURCE_TYPE_ADDRESS16 */ acpi_rs_convert_address16, /* 0x0B, ACPI_RESOURCE_TYPE_ADDRESS16 */
acpi_rs_set_address32, /* 0x0C, ACPI_RESOURCE_TYPE_ADDRESS32 */ acpi_rs_convert_address32, /* 0x0C, ACPI_RESOURCE_TYPE_ADDRESS32 */
acpi_rs_set_address64, /* 0x0D, ACPI_RESOURCE_TYPE_ADDRESS64 */ acpi_rs_convert_address64, /* 0x0D, ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_set_ext_address64, /* 0x0E, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */ acpi_rs_convert_ext_address64, /* 0x0E, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_set_ext_irq, /* 0x0F, ACPI_RESOURCE_TYPE_EXTENDED_IRQ */ acpi_rs_convert_ext_irq, /* 0x0F, ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_set_generic_reg /* 0x10, ACPI_RESOURCE_TYPE_GENERIC_REGISTER */ acpi_rs_convert_generic_reg /* 0x10, ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
}; };
/* Dispatch tables for AML-to-resource (Get Resource) conversion functions */ /* Dispatch tables for AML-to-resource (Get Resource) conversion functions */
ACPI_GET_RESOURCE_HANDLER acpi_gbl_sm_get_resource_dispatch[] = { struct acpi_rsconvert_info *acpi_gbl_sm_get_resource_dispatch[] = {
NULL, /* 0x00, Reserved */ NULL, /* 0x00, Reserved */
NULL, /* 0x01, Reserved */ NULL, /* 0x01, Reserved */
NULL, /* 0x02, Reserved */ NULL, /* 0x02, Reserved */
NULL, /* 0x03, Reserved */ NULL, /* 0x03, Reserved */
acpi_rs_get_irq, /* 0x04, ACPI_RESOURCE_NAME_IRQ */ acpi_rs_get_irq, /* 0x04, ACPI_RESOURCE_NAME_IRQ */
acpi_rs_get_dma, /* 0x05, ACPI_RESOURCE_NAME_DMA */ acpi_rs_convert_dma, /* 0x05, ACPI_RESOURCE_NAME_DMA */
acpi_rs_get_start_dpf, /* 0x06, ACPI_RESOURCE_NAME_START_DEPENDENT */ acpi_rs_get_start_dpf, /* 0x06, ACPI_RESOURCE_NAME_START_DEPENDENT */
acpi_rs_get_end_dpf, /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */ acpi_rs_convert_end_dpf, /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */
acpi_rs_get_io, /* 0x08, ACPI_RESOURCE_NAME_IO */ acpi_rs_convert_io, /* 0x08, ACPI_RESOURCE_NAME_IO */
acpi_rs_get_fixed_io, /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO */ acpi_rs_convert_fixed_io, /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO */
NULL, /* 0x0A, Reserved */ NULL, /* 0x0A, Reserved */
NULL, /* 0x0B, Reserved */ NULL, /* 0x0B, Reserved */
NULL, /* 0x0C, Reserved */ NULL, /* 0x0C, Reserved */
NULL, /* 0x0D, Reserved */ NULL, /* 0x0D, Reserved */
acpi_rs_get_vendor, /* 0x0E, ACPI_RESOURCE_NAME_VENDOR_SMALL */ acpi_rs_get_vendor_small, /* 0x0E, ACPI_RESOURCE_NAME_VENDOR_SMALL */
acpi_rs_get_end_tag /* 0x0F, ACPI_RESOURCE_NAME_END_TAG */ acpi_rs_convert_end_tag /* 0x0F, ACPI_RESOURCE_NAME_END_TAG */
}; };
ACPI_GET_RESOURCE_HANDLER acpi_gbl_lg_get_resource_dispatch[] = { struct acpi_rsconvert_info *acpi_gbl_lg_get_resource_dispatch[] = {
NULL, /* 0x00, Reserved */ NULL, /* 0x00, Reserved */
acpi_rs_get_memory24, /* 0x01, ACPI_RESOURCE_NAME_MEMORY24 */ acpi_rs_convert_memory24, /* 0x01, ACPI_RESOURCE_NAME_MEMORY24 */
acpi_rs_get_generic_reg, /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */ acpi_rs_convert_generic_reg, /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */
NULL, /* 0x03, Reserved */ NULL, /* 0x03, Reserved */
acpi_rs_get_vendor, /* 0x04, ACPI_RESOURCE_NAME_VENDOR_LARGE */ acpi_rs_get_vendor_large, /* 0x04, ACPI_RESOURCE_NAME_VENDOR_LARGE */
acpi_rs_get_memory32, /* 0x05, ACPI_RESOURCE_NAME_MEMORY32 */ acpi_rs_convert_memory32, /* 0x05, ACPI_RESOURCE_NAME_MEMORY32 */
acpi_rs_get_fixed_memory32, /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY32 */ acpi_rs_convert_fixed_memory32, /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY32 */
acpi_rs_get_address32, /* 0x07, ACPI_RESOURCE_NAME_ADDRESS32 */ acpi_rs_convert_address32, /* 0x07, ACPI_RESOURCE_NAME_ADDRESS32 */
acpi_rs_get_address16, /* 0x08, ACPI_RESOURCE_NAME_ADDRESS16 */ acpi_rs_convert_address16, /* 0x08, ACPI_RESOURCE_NAME_ADDRESS16 */
acpi_rs_get_ext_irq, /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_IRQ */ acpi_rs_convert_ext_irq, /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_IRQ */
acpi_rs_get_address64, /* 0x0A, ACPI_RESOURCE_NAME_ADDRESS64 */ acpi_rs_convert_address64, /* 0x0A, ACPI_RESOURCE_NAME_ADDRESS64 */
acpi_rs_get_ext_address64 /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64 */ acpi_rs_convert_ext_address64 /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64 */
}; };
#ifdef ACPI_FUTURE_USAGE #ifdef ACPI_FUTURE_USAGE
...@@ -119,7 +119,7 @@ ACPI_GET_RESOURCE_HANDLER acpi_gbl_lg_get_resource_dispatch[] = { ...@@ -119,7 +119,7 @@ ACPI_GET_RESOURCE_HANDLER acpi_gbl_lg_get_resource_dispatch[] = {
/* Dispatch table for resource dump functions */ /* Dispatch table for resource dump functions */
ACPI_DUMP_RESOURCE_HANDLER acpi_gbl_dump_resource_dispatch[] = { struct acpi_rsdump_info *acpi_gbl_dump_resource_dispatch[] = {
acpi_rs_dump_irq, /* ACPI_RESOURCE_TYPE_IRQ */ acpi_rs_dump_irq, /* ACPI_RESOURCE_TYPE_IRQ */
acpi_rs_dump_dma, /* ACPI_RESOURCE_TYPE_DMA */ acpi_rs_dump_dma, /* ACPI_RESOURCE_TYPE_DMA */
acpi_rs_dump_start_dpf, /* ACPI_RESOURCE_TYPE_START_DEPENDENT */ acpi_rs_dump_start_dpf, /* ACPI_RESOURCE_TYPE_START_DEPENDENT */
...@@ -136,17 +136,17 @@ ACPI_DUMP_RESOURCE_HANDLER acpi_gbl_dump_resource_dispatch[] = { ...@@ -136,17 +136,17 @@ ACPI_DUMP_RESOURCE_HANDLER acpi_gbl_dump_resource_dispatch[] = {
acpi_rs_dump_address64, /* ACPI_RESOURCE_TYPE_ADDRESS64 */ acpi_rs_dump_address64, /* ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_dump_ext_address64, /* ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */ acpi_rs_dump_ext_address64, /* ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_dump_ext_irq, /* ACPI_RESOURCE_TYPE_EXTENDED_IRQ */ acpi_rs_dump_ext_irq, /* ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_dump_generic_reg /* ACPI_RESOURCE_TYPE_GENERIC_REGISTER */ acpi_rs_dump_generic_reg, /* ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
}; };
#endif #endif
#endif /* ACPI_FUTURE_USAGE */ #endif /* ACPI_FUTURE_USAGE */
/* /*
* Base sizes for external AML resource descriptors, indexed by internal type. * Base sizes for external AML resource descriptors, indexed by internal type.
* Includes size of the descriptor header (1 byte for small descriptors, * Includes size of the descriptor header (1 byte for small descriptors,
* 3 bytes for large descriptors) * 3 bytes for large descriptors)
*/ */
u8 acpi_gbl_aml_resource_sizes[] = { const u8 acpi_gbl_aml_resource_sizes[] = {
sizeof(struct aml_resource_irq), /* ACPI_RESOURCE_TYPE_IRQ (optional Byte 3 always created) */ sizeof(struct aml_resource_irq), /* ACPI_RESOURCE_TYPE_IRQ (optional Byte 3 always created) */
sizeof(struct aml_resource_dma), /* ACPI_RESOURCE_TYPE_DMA */ sizeof(struct aml_resource_dma), /* ACPI_RESOURCE_TYPE_DMA */
sizeof(struct aml_resource_start_dependent), /* ACPI_RESOURCE_TYPE_START_DEPENDENT (optional Byte 1 always created) */ sizeof(struct aml_resource_start_dependent), /* ACPI_RESOURCE_TYPE_START_DEPENDENT (optional Byte 1 always created) */
...@@ -168,8 +168,8 @@ u8 acpi_gbl_aml_resource_sizes[] = { ...@@ -168,8 +168,8 @@ u8 acpi_gbl_aml_resource_sizes[] = {
/* Macros used in the tables below */ /* Macros used in the tables below */
#define ACPI_RLARGE(r) sizeof (r) - sizeof (struct aml_resource_large_header) #define ACPI_RLARGE(r) (sizeof (r) - sizeof (struct aml_resource_large_header))
#define ACPI_RSMALL(r) sizeof (r) - sizeof (struct aml_resource_small_header) #define ACPI_RSMALL(r) (sizeof (r) - sizeof (struct aml_resource_small_header))
/* /*
* Base sizes of resource descriptors, both the AML stream resource length * Base sizes of resource descriptors, both the AML stream resource length
...@@ -182,47 +182,46 @@ struct acpi_resource_info acpi_gbl_sm_resource_info[] = { ...@@ -182,47 +182,46 @@ struct acpi_resource_info acpi_gbl_sm_resource_info[] = {
{0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0},
{2, ACPI_RSMALL(struct aml_resource_irq), {2, ACPI_RSMALL(struct aml_resource_irq),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_irq)}, ACPI_RS_SIZE(struct acpi_resource_irq)},
{0, ACPI_RSMALL(struct aml_resource_dma), {0, ACPI_RSMALL(struct aml_resource_dma),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma)}, ACPI_RS_SIZE(struct acpi_resource_dma)},
{2, ACPI_RSMALL(struct aml_resource_start_dependent), {2, ACPI_RSMALL(struct aml_resource_start_dependent),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_start_dependent)}, ACPI_RS_SIZE(struct acpi_resource_start_dependent)},
{0, ACPI_RSMALL(struct aml_resource_end_dependent), {0, ACPI_RSMALL(struct aml_resource_end_dependent), ACPI_RS_SIZE_MIN},
ACPI_RESOURCE_LENGTH},
{0, ACPI_RSMALL(struct aml_resource_io), {0, ACPI_RSMALL(struct aml_resource_io),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_io)}, ACPI_RS_SIZE(struct acpi_resource_io)},
{0, ACPI_RSMALL(struct aml_resource_fixed_io), {0, ACPI_RSMALL(struct aml_resource_fixed_io),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io)}, ACPI_RS_SIZE(struct acpi_resource_fixed_io)},
{0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0},
{0, 0, 0}, {0, 0, 0},
{1, ACPI_RSMALL(struct aml_resource_vendor_small), {1, ACPI_RSMALL(struct aml_resource_vendor_small),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor)}, ACPI_RS_SIZE(struct acpi_resource_vendor)},
{0, ACPI_RSMALL(struct aml_resource_end_tag), ACPI_RESOURCE_LENGTH} {0, ACPI_RSMALL(struct aml_resource_end_tag), ACPI_RS_SIZE_MIN}
}; };
struct acpi_resource_info acpi_gbl_lg_resource_info[] = { struct acpi_resource_info acpi_gbl_lg_resource_info[] = {
{0, 0, 0}, {0, 0, 0},
{0, ACPI_RLARGE(struct aml_resource_memory24), {0, ACPI_RLARGE(struct aml_resource_memory24),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory24)}, ACPI_RS_SIZE(struct acpi_resource_memory24)},
{0, ACPI_RLARGE(struct aml_resource_generic_register), {0, ACPI_RLARGE(struct aml_resource_generic_register),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_generic_register)}, ACPI_RS_SIZE(struct acpi_resource_generic_register)},
{0, 0, 0}, {0, 0, 0},
{1, ACPI_RLARGE(struct aml_resource_vendor_large), {1, ACPI_RLARGE(struct aml_resource_vendor_large),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor)}, ACPI_RS_SIZE(struct acpi_resource_vendor)},
{0, ACPI_RLARGE(struct aml_resource_memory32), {0, ACPI_RLARGE(struct aml_resource_memory32),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory32)}, ACPI_RS_SIZE(struct acpi_resource_memory32)},
{0, ACPI_RLARGE(struct aml_resource_fixed_memory32), {0, ACPI_RLARGE(struct aml_resource_fixed_memory32),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_memory32)}, ACPI_RS_SIZE(struct acpi_resource_fixed_memory32)},
{1, ACPI_RLARGE(struct aml_resource_address32), {1, ACPI_RLARGE(struct aml_resource_address32),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address32)}, ACPI_RS_SIZE(struct acpi_resource_address32)},
{1, ACPI_RLARGE(struct aml_resource_address16), {1, ACPI_RLARGE(struct aml_resource_address16),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address16)}, ACPI_RS_SIZE(struct acpi_resource_address16)},
{1, ACPI_RLARGE(struct aml_resource_extended_irq), {1, ACPI_RLARGE(struct aml_resource_extended_irq),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_irq)}, ACPI_RS_SIZE(struct acpi_resource_extended_irq)},
{1, ACPI_RLARGE(struct aml_resource_address64), {1, ACPI_RLARGE(struct aml_resource_address64),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address64)}, ACPI_RS_SIZE(struct acpi_resource_address64)},
{0, ACPI_RLARGE(struct aml_resource_extended_address64), {0, ACPI_RLARGE(struct aml_resource_extended_address64),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_address64)} ACPI_RS_SIZE(struct acpi_resource_extended_address64)}
}; };
drivers/acpi/resources/rsio.c
浏览文件 @ 0897831b
...@@ -49,269 +49,206 @@ ACPI_MODULE_NAME("rsio") ...@@ -49,269 +49,206 @@ ACPI_MODULE_NAME("rsio")
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_io * acpi_rs_convert_io
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_io[5] = {
acpi_rs_get_io(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IO,
u16 aml_resource_length, struct acpi_resource *resource) ACPI_RS_SIZE(struct acpi_resource_io),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io)},
ACPI_FUNCTION_TRACE("rs_get_io");
/* Get the Decode flag */ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_IO,
sizeof(struct aml_resource_io),
0},
resource->data.io.io_decode = aml->io.information & 0x01; /* Decode flag */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.io.io_decode),
AML_OFFSET(io.flags),
0},
/* /*
* Get the following contiguous fields from the AML descriptor: * These fields are contiguous in both the source and destination:
* Minimum Base Address
* Maximum Base Address
* Address Alignment * Address Alignment
* Length * Length
* Minimum Base Address
* Maximum Base Address
*/ */
ACPI_MOVE_16_TO_32(&resource->data.io.minimum, &aml->io.minimum); {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.io.alignment),
ACPI_MOVE_16_TO_32(&resource->data.io.maximum, &aml->io.maximum); AML_OFFSET(io.alignment),
resource->data.io.alignment = aml->io.alignment; 2},
resource->data.io.address_length = aml->io.address_length;
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_IO; {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.io.minimum),
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_io); AML_OFFSET(io.minimum),
return_ACPI_STATUS(AE_OK); 2}
} };
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_io * acpi_rs_convert_fixed_io
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_fixed_io[4] = {
acpi_rs_set_io(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_IO,
{ ACPI_RS_SIZE(struct acpi_resource_fixed_io),
ACPI_FUNCTION_TRACE("rs_set_io"); ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_io)},
/* I/O Information Byte */
aml->io.information = (u8) (resource->data.io.io_decode & 0x01);
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_IO,
sizeof(struct aml_resource_fixed_io),
0},
/* /*
* Set the following contiguous fields in the AML descriptor: * These fields are contiguous in both the source and destination:
* Minimum Base Address * Base Address
* Maximum Base Address
* Address Alignment
* Length * Length
*/ */
ACPI_MOVE_32_TO_16(&aml->io.minimum, &resource->data.io.minimum); {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.fixed_io.address_length),
ACPI_MOVE_32_TO_16(&aml->io.maximum, &resource->data.io.maximum); AML_OFFSET(fixed_io.address_length),
aml->io.alignment = (u8) resource->data.io.alignment; 1},
aml->io.address_length = (u8) resource->data.io.address_length;
/* Complete the AML descriptor header */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_IO, {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.fixed_io.address),
sizeof(struct aml_resource_io), aml); AML_OFFSET(fixed_io.address),
return_ACPI_STATUS(AE_OK); 1}
} };
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_fixed_io * acpi_rs_convert_generic_reg
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_generic_reg[4] = {
acpi_rs_get_fixed_io(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_GENERIC_REGISTER,
u16 aml_resource_length, struct acpi_resource *resource) ACPI_RS_SIZE(struct acpi_resource_generic_register),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_generic_reg)},
ACPI_FUNCTION_TRACE("rs_get_fixed_io");
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_GENERIC_REGISTER,
sizeof(struct aml_resource_generic_register),
0},
/* /*
* Get the following contiguous fields from the AML descriptor: * These fields are contiguous in both the source and destination:
* Base Address * Address Space ID
* Length * Register Bit Width
* Register Bit Offset
* Access Size
*/ */
ACPI_MOVE_16_TO_32(&resource->data.fixed_io.address, {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.generic_reg.space_id),
&aml->fixed_io.address); AML_OFFSET(generic_reg.address_space_id),
resource->data.fixed_io.address_length = aml->fixed_io.address_length; 4},
/* Complete the resource header */ /* Get the Register Address */
resource->type = ACPI_RESOURCE_TYPE_FIXED_IO; {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.generic_reg.address),
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io); AML_OFFSET(generic_reg.address),
return_ACPI_STATUS(AE_OK); 1}
} };
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_fixed_io * acpi_rs_convert_end_dpf
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
* *
* RETURN: Status ******************************************************************************/
struct acpi_rsconvert_info acpi_rs_convert_end_dpf[2] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_END_DEPENDENT,
ACPI_RS_SIZE_MIN,
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_end_dpf)},
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_END_DEPENDENT,
sizeof(struct aml_resource_end_dependent),
0}
};
/*******************************************************************************
* *
* DESCRIPTION: Convert an internal resource descriptor to the corresponding * acpi_rs_convert_end_tag
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_end_tag[2] = {
acpi_rs_set_fixed_io(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_END_TAG,
{ ACPI_RS_SIZE_MIN,
ACPI_FUNCTION_TRACE("rs_set_fixed_io"); ACPI_RSC_TABLE_SIZE(acpi_rs_convert_end_tag)},
/* /*
* Set the following contiguous fields in the AML descriptor: * Note: The checksum field is set to zero, meaning that the resource
* Base Address * data is treated as if the checksum operation succeeded.
* Length * (ACPI Spec 1.0b Section 6.4.2.8)
*/ */
ACPI_MOVE_32_TO_16(&aml->fixed_io.address, {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_END_TAG,
&resource->data.fixed_io.address); sizeof(struct aml_resource_end_tag),
aml->fixed_io.address_length = 0}
(u8) resource->data.fixed_io.address_length; };
/* Complete the AML descriptor header */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_FIXED_IO,
sizeof(struct aml_resource_fixed_io), aml);
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_dma * acpi_rs_get_start_dpf
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_get_start_dpf[5] = {
acpi_rs_get_dma(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_START_DEPENDENT,
u16 aml_resource_length, struct acpi_resource *resource) ACPI_RS_SIZE(struct acpi_resource_start_dependent),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_get_start_dpf)},
u32 channel_count = 0;
u32 i;
u8 temp8;
ACPI_FUNCTION_TRACE("rs_get_dma"); /* Defaults for Compatibility and Performance priorities */
/* Decode the DMA channel bits */ {ACPI_RSC_SET8, ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
ACPI_ACCEPTABLE_CONFIGURATION,
2},
for (i = 0; i < 8; i++) { /* All done if there is no flag byte present in the descriptor */
if ((aml->dma.dma_channel_mask >> i) & 0x01) {
resource->data.dma.channels[channel_count] = i;
channel_count++;
}
}
resource->length = 0; {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 1},
resource->data.dma.channel_count = channel_count;
/* /* Flag byte is present, get the flags */
* Calculate the structure size based upon the number of channels
* Note: Zero DMA channels is valid
*/
if (channel_count > 0) {
resource->length = (u32) (channel_count - 1) * 4;
}
/* Get the flags: transfer preference, bus mastering, channel speed */
temp8 = aml->dma.flags; {ACPI_RSC_2BITFLAG,
resource->data.dma.transfer = temp8 & 0x03; ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
resource->data.dma.bus_master = (temp8 >> 2) & 0x01; AML_OFFSET(start_dpf.flags),
resource->data.dma.type = (temp8 >> 5) & 0x03; 0},
if (resource->data.dma.transfer == 0x03) { {ACPI_RSC_2BITFLAG,
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
"Invalid DMA.Transfer preference (3)\n")); AML_OFFSET(start_dpf.flags),
return_ACPI_STATUS(AE_BAD_DATA); 2}
} };
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_DMA;
resource->length += ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma);
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_dma * acpi_rs_set_start_dpf
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_set_start_dpf[6] = {
acpi_rs_set_dma(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_START_DEPENDENT,
{ sizeof(struct aml_resource_start_dependent),
u8 i; ACPI_RSC_TABLE_SIZE(acpi_rs_set_start_dpf)},
ACPI_FUNCTION_TRACE("rs_set_dma");
/* Convert channel list to 8-bit DMA channel bitmask */ /* Set the default flag values */
aml->dma.dma_channel_mask = 0; {ACPI_RSC_2BITFLAG,
for (i = 0; i < resource->data.dma.channel_count; i++) { ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
aml->dma.dma_channel_mask |= AML_OFFSET(start_dpf.flags),
(1 << resource->data.dma.channels[i]); 0},
}
/* Set the DMA Flag bits */ {ACPI_RSC_2BITFLAG,
ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
AML_OFFSET(start_dpf.flags),
2},
/*
* All done if flags byte is necessary -- if either priority value
* is not ACPI_ACCEPTABLE_CONFIGURATION
*/
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
ACPI_ACCEPTABLE_CONFIGURATION},
aml->dma.flags = (u8) {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
(((resource->data.dma.type & 0x03) << 5) | ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
((resource->data.dma.bus_master & 0x01) << 2) | ACPI_ACCEPTABLE_CONFIGURATION},
(resource->data.dma.transfer & 0x03));
/* Complete the AML descriptor header */ /* Flag byte is not necessary */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_DMA, {ACPI_RSC_LENGTH, 0, 0,
sizeof(struct aml_resource_dma), aml); sizeof(struct aml_resource_start_dependent_noprio)}
return_ACPI_STATUS(AE_OK); };
}
drivers/acpi/resources/rsirq.c
浏览文件 @ 0897831b
...@@ -49,325 +49,182 @@ ACPI_MODULE_NAME("rsirq") ...@@ -49,325 +49,182 @@ ACPI_MODULE_NAME("rsirq")
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_irq * acpi_rs_get_irq
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_get_irq[7] = {
acpi_rs_get_irq(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IRQ,
u16 aml_resource_length, struct acpi_resource *resource) ACPI_RS_SIZE(struct acpi_resource_irq),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_get_irq)},
u16 temp16 = 0;
u32 interrupt_count = 0;
u32 i;
u32 resource_length;
ACPI_FUNCTION_TRACE("rs_get_irq");
/* Get the IRQ mask (bytes 1:2) */ /* Get the IRQ mask (bytes 1:2) */
ACPI_MOVE_16_TO_16(&temp16, &aml->irq.irq_mask); {ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
AML_OFFSET(irq.irq_mask),
/* Decode the IRQ bits (up to 16 possible) */ ACPI_RS_OFFSET(data.irq.interrupt_count)},
for (i = 0; i < 16; i++) { /* Set default flags (others are zero) */
if ((temp16 >> i) & 0x01) {
resource->data.irq.interrupts[interrupt_count] = i; {ACPI_RSC_SET8, ACPI_RS_OFFSET(data.irq.triggering),
interrupt_count++; ACPI_EDGE_SENSITIVE,
} 1},
}
/* All done if no flag byte present in descriptor */
/* Zero interrupts is valid */
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 3},
resource_length = 0;
resource->data.irq.interrupt_count = interrupt_count; /* Get flags: Triggering[0], Polarity[3], Sharing[4] */
if (interrupt_count > 0) {
/* Calculate the structure size based upon the number of interrupts */ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.triggering),
AML_OFFSET(irq.flags),
resource_length = (u32) (interrupt_count - 1) * 4; 0},
}
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.polarity),
/* Get Flags (Byte 3) if it is used */ AML_OFFSET(irq.flags),
3},
if (aml_resource_length == 3) {
/* Check for HE, LL interrupts */ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.sharable),
AML_OFFSET(irq.flags),
switch (aml->irq.flags & 0x09) { 4}
case 0x01: /* HE */ };
resource->data.irq.triggering = ACPI_EDGE_SENSITIVE;
resource->data.irq.polarity = ACPI_ACTIVE_HIGH;
break;
case 0x08: /* LL */
resource->data.irq.triggering = ACPI_LEVEL_SENSITIVE;
resource->data.irq.polarity = ACPI_ACTIVE_LOW;
break;
default:
/*
* Only _LL and _HE polarity/trigger interrupts
* are allowed (ACPI spec, section "IRQ Format")
* so 0x00 and 0x09 are illegal.
*/
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Invalid interrupt polarity/trigger in resource list, %X\n",
aml->irq.flags));
return_ACPI_STATUS(AE_BAD_DATA);
}
/* Get Sharing flag */
resource->data.irq.sharable = (aml->irq.flags >> 3) & 0x01;
} else {
/*
* Default configuration: assume Edge Sensitive, Active High,
* Non-Sharable as per the ACPI Specification
*/
resource->data.irq.triggering = ACPI_EDGE_SENSITIVE;
resource->data.irq.polarity = ACPI_ACTIVE_HIGH;
resource->data.irq.sharable = ACPI_EXCLUSIVE;
}
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_IRQ;
resource->length =
resource_length + ACPI_SIZEOF_RESOURCE(struct acpi_resource_irq);
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_irq * acpi_rs_set_irq
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_set_irq[9] = {
acpi_rs_set_irq(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_IRQ,
{ sizeof(struct aml_resource_irq),
acpi_size descriptor_length; ACPI_RSC_TABLE_SIZE(acpi_rs_set_irq)},
u16 irq_mask;
u8 i;
ACPI_FUNCTION_TRACE("rs_set_irq");
/* Convert interrupt list to 16-bit IRQ bitmask */ /* Convert interrupt list to 16-bit IRQ bitmask */
irq_mask = 0; {ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
for (i = 0; i < resource->data.irq.interrupt_count; i++) { AML_OFFSET(irq.irq_mask),
irq_mask |= (1 << resource->data.irq.interrupts[i]); ACPI_RS_OFFSET(data.irq.interrupt_count)},
}
/* Set the flags byte by default */
/* Set the interrupt mask */ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.triggering),
AML_OFFSET(irq.flags),
0},
ACPI_MOVE_16_TO_16(&aml->irq.irq_mask, &irq_mask); {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.polarity),
AML_OFFSET(irq.flags),
3},
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.sharable),
AML_OFFSET(irq.flags),
4},
/* /*
* The descriptor field is set based upon whether a third byte is * Check if the flags byte is necessary. Not needed if the flags are:
* needed to contain the IRQ Information. * ACPI_EDGE_SENSITIVE, ACPI_ACTIVE_HIGH, ACPI_EXCLUSIVE
*/ */
if ((resource->data.irq.triggering == ACPI_EDGE_SENSITIVE) && {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
(resource->data.irq.polarity == ACPI_ACTIVE_HIGH) && ACPI_RS_OFFSET(data.irq.triggering),
(resource->data.irq.sharable == ACPI_EXCLUSIVE)) { ACPI_EDGE_SENSITIVE},
/* irq_no_flags() descriptor can be used */
descriptor_length = sizeof(struct aml_resource_irq_noflags);
} else {
/* Irq() descriptor must be used */
descriptor_length = sizeof(struct aml_resource_irq);
/* Set the IRQ Info byte */
aml->irq.flags = (u8) {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
((resource->data.irq.sharable & 0x01) << 4); ACPI_RS_OFFSET(data.irq.polarity),
ACPI_ACTIVE_HIGH},
if (ACPI_LEVEL_SENSITIVE == resource->data.irq.triggering && {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
ACPI_ACTIVE_LOW == resource->data.irq.polarity) { ACPI_RS_OFFSET(data.irq.sharable),
aml->irq.flags |= 0x08; ACPI_EXCLUSIVE},
} else {
aml->irq.flags |= 0x01;
}
}
/* Complete the AML descriptor header */ /* irq_no_flags() descriptor can be used */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_IRQ, descriptor_length, {ACPI_RSC_LENGTH, 0, 0, sizeof(struct aml_resource_irq_noflags)}
aml); };
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_ext_irq * acpi_rs_convert_ext_irq
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_ext_irq[9] = {
acpi_rs_get_ext_irq(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_IRQ,
u16 aml_resource_length, struct acpi_resource *resource) ACPI_RS_SIZE(struct acpi_resource_extended_irq),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_irq)},
char *out_resource_string;
u8 temp8;
ACPI_FUNCTION_TRACE("rs_get_ext_irq");
/* Get the flag bits */
temp8 = aml->extended_irq.flags; {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_IRQ,
resource->data.extended_irq.producer_consumer = temp8 & 0x01; sizeof(struct aml_resource_extended_irq),
resource->data.extended_irq.polarity = (temp8 >> 2) & 0x01; 0},
resource->data.extended_irq.sharable = (temp8 >> 3) & 0x01;
/* /* Flag bits */
* Check for Interrupt Mode
*
* The definition of an Extended IRQ changed between ACPI spec v1.0b
* and ACPI spec 2.0 (section 6.4.3.6 in both).
*
* - Edge/Level are defined opposite in the table vs the headers
*/
resource->data.extended_irq.triggering =
(temp8 & 0x2) ? ACPI_EDGE_SENSITIVE : ACPI_LEVEL_SENSITIVE;
/* Get the IRQ Table length (Byte4) */ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.producer_consumer),
AML_OFFSET(extended_irq.flags),
0},
temp8 = aml->extended_irq.table_length; {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.triggering),
resource->data.extended_irq.interrupt_count = temp8; AML_OFFSET(extended_irq.flags),
if (temp8 < 1) { 1},
/* Must have at least one IRQ */
return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH); {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.polarity),
} AML_OFFSET(extended_irq.flags),
2},
/* {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.sharable),
* Add any additional structure size to properly calculate AML_OFFSET(extended_irq.flags),
* the next pointer at the end of this function 3},
*/
resource->length = (temp8 - 1) * 4;
out_resource_string = ACPI_CAST_PTR(char,
(&resource->data.extended_irq.
interrupts[0] + temp8));
/* Get every IRQ in the table, each is 32 bits */ /* IRQ Table length (Byte4) */
acpi_rs_move_data(resource->data.extended_irq.interrupts, {ACPI_RSC_COUNT, ACPI_RS_OFFSET(data.extended_irq.interrupt_count),
aml->extended_irq.interrupt_number, AML_OFFSET(extended_irq.interrupt_count),
(u16) temp8, ACPI_MOVE_TYPE_32_TO_32); sizeof(u32)}
,
/* Get the optional resource_source (index and string) */ /* Copy every IRQ in the table, each is 32 bits */
resource->length += {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
acpi_rs_get_resource_source(aml_resource_length, AML_OFFSET(extended_irq.interrupts[0]),
(acpi_size) resource->length + 0}
sizeof(struct ,
aml_resource_extended_irq),
&resource->data.extended_irq.
resource_source, aml,
out_resource_string);
/* Complete the resource header */ /* Optional resource_source (Index and String) */
resource->type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ; {ACPI_RSC_SOURCEX, ACPI_RS_OFFSET(data.extended_irq.resource_source),
resource->length += ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_irq); sizeof(struct aml_resource_extended_irq)}
return_ACPI_STATUS(AE_OK); };
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_ext_irq * acpi_rs_convert_dma
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_dma[6] = {
acpi_rs_set_ext_irq(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_DMA,
{ ACPI_RS_SIZE(struct acpi_resource_dma),
acpi_size descriptor_length; ACPI_RSC_TABLE_SIZE(acpi_rs_convert_dma)},
ACPI_FUNCTION_TRACE("rs_set_ext_irq");
/* Set the Interrupt vector flags */
aml->extended_irq.flags = (u8)
((resource->data.extended_irq.producer_consumer & 0x01) |
((resource->data.extended_irq.sharable & 0x01) << 3) |
((resource->data.extended_irq.polarity & 0x1) << 2));
/*
* Set the Interrupt Mode
*
* The definition of an Extended IRQ changed between ACPI spec v1.0b
* and ACPI spec 2.0 (section 6.4.3.6 in both). This code does not
* implement the more restrictive definition of 1.0b
*
* - Edge/Level are defined opposite in the table vs the headers
*/
if (resource->data.extended_irq.triggering == ACPI_EDGE_SENSITIVE) {
aml->extended_irq.flags |= 0x02;
}
/* Set the Interrupt table length */
aml->extended_irq.table_length = (u8)
resource->data.extended_irq.interrupt_count;
descriptor_length = (sizeof(struct aml_resource_extended_irq) - 4) + {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_DMA,
((acpi_size) resource->data.extended_irq.interrupt_count * sizeof(struct aml_resource_dma),
sizeof(u32)); 0},
/* Set each interrupt value */ /* Flags: transfer preference, bus mastering, channel speed */
acpi_rs_move_data(aml->extended_irq.interrupt_number, {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.transfer),
resource->data.extended_irq.interrupts, AML_OFFSET(dma.flags),
(u16) resource->data.extended_irq.interrupt_count, 0},
ACPI_MOVE_TYPE_32_TO_32);
/* Resource Source Index and Resource Source are optional */ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.dma.bus_master),
AML_OFFSET(dma.flags),
2},
descriptor_length = acpi_rs_set_resource_source(aml, descriptor_length, {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.type),
&resource->data. AML_OFFSET(dma.flags),
extended_irq. 5},
resource_source);
/* Complete the AML descriptor header */ /* DMA channel mask bits */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_EXTENDED_IRQ, {ACPI_RSC_BITMASK, ACPI_RS_OFFSET(data.dma.channels[0]),
descriptor_length, aml); AML_OFFSET(dma.dma_channel_mask),
return_ACPI_STATUS(AE_OK); ACPI_RS_OFFSET(data.dma.channel_count)}
} };
drivers/acpi/resources/rslist.c
浏览文件 @ 0897831b
...@@ -48,7 +48,8 @@ ...@@ -48,7 +48,8 @@
ACPI_MODULE_NAME("rslist") ACPI_MODULE_NAME("rslist")
/* Local prototypes */ /* Local prototypes */
static ACPI_GET_RESOURCE_HANDLER acpi_rs_get_resource_handler(u8 resource_type); static struct acpi_rsconvert_info *acpi_rs_get_conversion_info(u8
resource_type);
static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml); static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml);
...@@ -83,7 +84,7 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml) ...@@ -83,7 +84,7 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml)
return (AE_AML_INVALID_RESOURCE_TYPE); return (AE_AML_INVALID_RESOURCE_TYPE);
} }
resource_length = acpi_rs_get_resource_length(aml); resource_length = acpi_ut_get_resource_length(aml);
minimum_aml_resource_length = minimum_aml_resource_length =
resource_info->minimum_aml_resource_length; resource_info->minimum_aml_resource_length;
...@@ -115,18 +116,17 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml) ...@@ -115,18 +116,17 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml)
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_resource_handler * FUNCTION: acpi_rs_get_conversion_info
* *
* PARAMETERS: resource_type - Byte 0 of a resource descriptor * PARAMETERS: resource_type - Byte 0 of a resource descriptor
* *
* RETURN: Pointer to the resource conversion handler * RETURN: Pointer to the resource conversion info table
* *
* DESCRIPTION: Extract the Resource Type/Name from the first byte of * DESCRIPTION: Get the conversion table associated with this resource type
* a resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
static ACPI_GET_RESOURCE_HANDLER acpi_rs_get_resource_handler(u8 resource_type) static struct acpi_rsconvert_info *acpi_rs_get_conversion_info(u8 resource_type)
{ {
ACPI_FUNCTION_ENTRY(); ACPI_FUNCTION_ENTRY();
...@@ -174,33 +174,24 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer, ...@@ -174,33 +174,24 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
acpi_status status; acpi_status status;
acpi_size bytes_parsed = 0; acpi_size bytes_parsed = 0;
struct acpi_resource *resource; struct acpi_resource *resource;
u16 resource_length; acpi_rsdesc_size descriptor_length;
u32 descriptor_length; struct acpi_rsconvert_info *info;
ACPI_GET_RESOURCE_HANDLER handler;
ACPI_FUNCTION_TRACE("rs_convert_aml_to_resources"); ACPI_FUNCTION_TRACE("rs_convert_aml_to_resources");
/* Loop until end-of-buffer or an end_tag is found */ /* Loop until end-of-buffer or an end_tag is found */
while (bytes_parsed < aml_buffer_length) { while (bytes_parsed < aml_buffer_length) {
/* Get the handler associated with this Descriptor Type */ /* Get the conversion table associated with this Descriptor Type */
handler = acpi_rs_get_resource_handler(*aml_buffer); info = acpi_rs_get_conversion_info(*aml_buffer);
if (!handler) { if (!info) {
/* No handler indicates invalid resource type */ /* No table indicates an invalid resource type */
return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
} }
resource_length = descriptor_length = acpi_ut_get_descriptor_length(aml_buffer);
acpi_rs_get_resource_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
descriptor_length =
acpi_rs_get_descriptor_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
/* /*
* Perform limited validation of the resource length, based upon * Perform limited validation of the resource length, based upon
...@@ -214,11 +205,16 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer, ...@@ -214,11 +205,16 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
return_ACPI_STATUS(status); return_ACPI_STATUS(status);
} }
/* Convert a byte stream resource to local resource struct */ /* Convert the AML byte stream resource to a local resource struct */
status = handler(ACPI_CAST_PTR(union aml_resource, aml_buffer), status =
resource_length, acpi_rs_convert_aml_to_resource(ACPI_CAST_PTR
ACPI_CAST_PTR(struct acpi_resource, buffer)); (struct acpi_resource,
buffer),
ACPI_CAST_PTR(union
aml_resource,
aml_buffer),
info);
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Could not convert AML resource (type %X) to resource, %s\n", *aml_buffer, acpi_format_exception(status))); ACPI_REPORT_ERROR(("Could not convert AML resource (type %X) to resource, %s\n", *aml_buffer, acpi_format_exception(status)));
return_ACPI_STATUS(status); return_ACPI_STATUS(status);
...@@ -232,7 +228,7 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer, ...@@ -232,7 +228,7 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
/* Normal exit on completion of an end_tag resource descriptor */ /* Normal exit on completion of an end_tag resource descriptor */
if (acpi_rs_get_resource_type(*aml_buffer) == if (acpi_ut_get_resource_type(aml_buffer) ==
ACPI_RESOURCE_NAME_END_TAG) { ACPI_RESOURCE_NAME_END_TAG) {
return_ACPI_STATUS(AE_OK); return_ACPI_STATUS(AE_OK);
} }
...@@ -276,14 +272,15 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource, ...@@ -276,14 +272,15 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
acpi_size aml_size_needed, u8 * output_buffer) acpi_size aml_size_needed, u8 * output_buffer)
{ {
u8 *aml_buffer = output_buffer; u8 *aml_buffer = output_buffer;
u8 *end_aml_buffer = output_buffer + aml_size_needed;
acpi_status status; acpi_status status;
ACPI_FUNCTION_TRACE("rs_convert_resources_to_aml"); ACPI_FUNCTION_TRACE("rs_convert_resources_to_aml");
/* Convert each resource descriptor in the list */ /* Walk the resource descriptor list, convert each descriptor */
while (1) { while (aml_buffer < end_aml_buffer) {
/* Validate Resource Descriptor Type before dispatch */ /* Validate the Resource Type */
if (resource->type > ACPI_RESOURCE_TYPE_MAX) { if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
...@@ -292,14 +289,14 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource, ...@@ -292,14 +289,14 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
return_ACPI_STATUS(AE_BAD_DATA); return_ACPI_STATUS(AE_BAD_DATA);
} }
/* Perform the conversion per resource type */ /* Perform the conversion */
status = status = acpi_rs_convert_resource_to_aml(resource,
acpi_gbl_set_resource_dispatch[resource->type] (resource, ACPI_CAST_PTR(union
ACPI_CAST_PTR aml_resource,
(union aml_buffer),
aml_resource, acpi_gbl_set_resource_dispatch
aml_buffer)); [resource->type]);
if (ACPI_FAILURE(status)) { if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Could not convert resource (type %X) to AML, %s\n", resource->type, acpi_format_exception(status))); ACPI_REPORT_ERROR(("Could not convert resource (type %X) to AML, %s\n", resource->type, acpi_format_exception(status)));
return_ACPI_STATUS(status); return_ACPI_STATUS(status);
...@@ -323,18 +320,23 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource, ...@@ -323,18 +320,23 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
return_ACPI_STATUS(AE_OK); return_ACPI_STATUS(AE_OK);
} }
/* Extract the total length of the new descriptor */ /*
/* Set the aml_buffer to point to the next (output) resource descriptor */ * Extract the total length of the new descriptor and set the
* aml_buffer to point to the next (output) resource descriptor
aml_buffer += */
acpi_rs_get_descriptor_length(ACPI_CAST_PTR aml_buffer += acpi_ut_get_descriptor_length(aml_buffer);
(union aml_resource,
aml_buffer));
/* Point to the next input resource descriptor */ /* Point to the next input resource descriptor */
resource = resource =
ACPI_PTR_ADD(struct acpi_resource, resource, ACPI_PTR_ADD(struct acpi_resource, resource,
resource->length); resource->length);
/* Check for end-of-list, normal exit */
} }
/* Completed buffer, but did not find an end_tag resource descriptor */
return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);
} }
drivers/acpi/resources/rsmemory.c
浏览文件 @ 0897831b
...@@ -49,260 +49,187 @@ ACPI_MODULE_NAME("rsmemory") ...@@ -49,260 +49,187 @@ ACPI_MODULE_NAME("rsmemory")
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_memory24 * acpi_rs_convert_memory24
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_memory24[4] = {
acpi_rs_get_memory24(union aml_resource * aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY24,
u16 aml_resource_length, struct acpi_resource * resource) ACPI_RS_SIZE(struct acpi_resource_memory24),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_memory24)},
ACPI_FUNCTION_TRACE("rs_get_memory24");
/* Get the Read/Write bit */ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_MEMORY24,
sizeof(struct aml_resource_memory24),
0},
resource->data.memory24.read_write_attribute = /* Read/Write bit */
(aml->memory24.information & 0x01);
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.memory24.write_protect),
AML_OFFSET(memory24.flags),
0},
/* /*
* Get the following contiguous fields from the AML descriptor: * These fields are contiguous in both the source and destination:
* Minimum Base Address * Minimum Base Address
* Maximum Base Address * Maximum Base Address
* Address Base Alignment * Address Base Alignment
* Range Length * Range Length
*/ */
acpi_rs_move_data(&resource->data.memory24.minimum, {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.memory24.minimum),
&aml->memory24.minimum, 4, ACPI_MOVE_TYPE_16_TO_32); AML_OFFSET(memory24.minimum),
4}
/* Complete the resource header */ };
resource->type = ACPI_RESOURCE_TYPE_MEMORY24;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory24);
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_memory24 * acpi_rs_convert_memory32
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_memory32[4] = {
acpi_rs_set_memory24(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY32,
{ ACPI_RS_SIZE(struct acpi_resource_memory32),
ACPI_FUNCTION_TRACE("rs_set_memory24"); ACPI_RSC_TABLE_SIZE(acpi_rs_convert_memory32)},
/* Set the Information Byte */ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_MEMORY32,
sizeof(struct aml_resource_memory32),
0},
aml->memory24.information = (u8) /* Read/Write bit */
(resource->data.memory24.read_write_attribute & 0x01);
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.memory32.write_protect),
AML_OFFSET(memory32.flags),
0},
/* /*
* Set the following contiguous fields in the AML descriptor: * These fields are contiguous in both the source and destination:
* Minimum Base Address * Minimum Base Address
* Maximum Base Address * Maximum Base Address
* Address Base Alignment * Address Base Alignment
* Range Length * Range Length
*/ */
acpi_rs_move_data(&aml->memory24.minimum, {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.memory32.minimum),
&resource->data.memory24.minimum, 4, AML_OFFSET(memory32.minimum),
ACPI_MOVE_TYPE_32_TO_16); 4}
};
/* Complete the AML descriptor header */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_MEMORY24,
sizeof(struct aml_resource_memory24), aml);
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_memory32 * acpi_rs_convert_fixed_memory32
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_convert_fixed_memory32[4] = {
acpi_rs_get_memory32(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_MEMORY32,
u16 aml_resource_length, struct acpi_resource *resource) ACPI_RS_SIZE(struct acpi_resource_fixed_memory32),
{ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_memory32)},
ACPI_FUNCTION_TRACE("rs_get_memory32");
/* Get the Read/Write bit */ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_MEMORY32,
sizeof(struct aml_resource_fixed_memory32),
0},
resource->data.memory32.read_write_attribute = /* Read/Write bit */
(aml->memory32.information & 0x01);
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.fixed_memory32.write_protect),
AML_OFFSET(fixed_memory32.flags),
0},
/* /*
* Get the following contiguous fields from the AML descriptor: * These fields are contiguous in both the source and destination:
* Minimum Base Address * Base Address
* Maximum Base Address
* Address Base Alignment
* Range Length * Range Length
*/ */
acpi_rs_move_data(&resource->data.memory32.minimum, {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.fixed_memory32.address),
&aml->memory32.minimum, 4, ACPI_MOVE_TYPE_32_TO_32); AML_OFFSET(fixed_memory32.address),
2}
/* Complete the resource header */ };
resource->type = ACPI_RESOURCE_TYPE_MEMORY32;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory32);
return_ACPI_STATUS(AE_OK);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_memory32 * acpi_rs_get_vendor_small
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_get_vendor_small[3] = {
acpi_rs_set_memory32(struct acpi_resource *resource, union aml_resource *aml) {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_VENDOR,
{ ACPI_RS_SIZE(struct acpi_resource_vendor),
ACPI_FUNCTION_TRACE("rs_set_memory32"); ACPI_RSC_TABLE_SIZE(acpi_rs_get_vendor_small)},
/* Set the Information Byte */
aml->memory32.information = (u8) /* Length of the vendor data (byte count) */
(resource->data.memory32.read_write_attribute & 0x01);
/* {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
* Set the following contiguous fields in the AML descriptor: 0,
* Minimum Base Address sizeof(u8)}
* Maximum Base Address ,
* Address Base Alignment
* Range Length
*/
acpi_rs_move_data(&aml->memory32.minimum,
&resource->data.memory32.minimum, 4,
ACPI_MOVE_TYPE_32_TO_32);
/* Complete the AML descriptor header */ /* Vendor data */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_MEMORY32, {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
sizeof(struct aml_resource_memory32), aml); sizeof(struct aml_resource_small_header),
return_ACPI_STATUS(AE_OK); 0}
} };
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_fixed_memory32 * acpi_rs_get_vendor_large
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_get_vendor_large[3] = {
acpi_rs_get_fixed_memory32(union aml_resource *aml, {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_VENDOR,
u16 aml_resource_length, ACPI_RS_SIZE(struct acpi_resource_vendor),
struct acpi_resource *resource) ACPI_RSC_TABLE_SIZE(acpi_rs_get_vendor_large)},
{
ACPI_FUNCTION_TRACE("rs_get_fixed_memory32");
/* Get the Read/Write bit */
resource->data.fixed_memory32.read_write_attribute = /* Length of the vendor data (byte count) */
(aml->fixed_memory32.information & 0x01);
/* {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
* Get the following contiguous fields from the AML descriptor: 0,
* Base Address sizeof(u8)}
* Range Length ,
*/
ACPI_MOVE_32_TO_32(&resource->data.fixed_memory32.address,
&aml->fixed_memory32.address);
ACPI_MOVE_32_TO_32(&resource->data.fixed_memory32.address_length,
&aml->fixed_memory32.address_length);
/* Complete the resource header */ /* Vendor data */
resource->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32; {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
resource->length = sizeof(struct aml_resource_large_header),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_memory32); 0}
return_ACPI_STATUS(AE_OK); };
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_set_fixed_memory32 * acpi_rs_set_vendor
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* *
******************************************************************************/ ******************************************************************************/
acpi_status struct acpi_rsconvert_info acpi_rs_set_vendor[7] = {
acpi_rs_set_fixed_memory32(struct acpi_resource *resource, /* Default is a small vendor descriptor */
union aml_resource *aml)
{ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_VENDOR_SMALL,
ACPI_FUNCTION_TRACE("rs_set_fixed_memory32"); sizeof(struct aml_resource_small_header),
ACPI_RSC_TABLE_SIZE(acpi_rs_set_vendor)},
/* Get the length and copy the data */
/* Set the Information Byte */ {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
0,
0},
aml->fixed_memory32.information = (u8) {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
(resource->data.fixed_memory32.read_write_attribute & 0x01); sizeof(struct aml_resource_small_header),
0},
/* /*
* Set the following contiguous fields in the AML descriptor: * All done if the Vendor byte length is 7 or less, meaning that it will
* Base Address * fit within a small descriptor
* Range Length
*/ */
ACPI_MOVE_32_TO_32(&aml->fixed_memory32.address, {ACPI_RSC_EXIT_LE, 0, 0, 7},
&resource->data.fixed_memory32.address);
ACPI_MOVE_32_TO_32(&aml->fixed_memory32.address_length, /* Must create a large vendor descriptor */
&resource->data.fixed_memory32.address_length);
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_VENDOR_LARGE,
/* Complete the AML descriptor header */ sizeof(struct aml_resource_large_header),
0},
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_FIXED_MEMORY32,
sizeof(struct aml_resource_fixed_memory32), {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
aml); 0,
return_ACPI_STATUS(AE_OK); 0},
}
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
sizeof(struct aml_resource_large_header),
0}
};
drivers/acpi/resources/rsmisc.c
浏览文件 @ 0897831b
此差异已折叠。
drivers/acpi/resources/rsutils.c
浏览文件 @ 0897831b
...@@ -48,6 +48,64 @@ ...@@ -48,6 +48,64 @@
#define _COMPONENT ACPI_RESOURCES #define _COMPONENT ACPI_RESOURCES
ACPI_MODULE_NAME("rsutils") ACPI_MODULE_NAME("rsutils")
/*******************************************************************************
*
* FUNCTION: acpi_rs_decode_bitmask
*
* PARAMETERS: Mask - Bitmask to decode
* List - Where the converted list is returned
*
* RETURN: Count of bits set (length of list)
*
* DESCRIPTION: Convert a bit mask into a list of values
*
******************************************************************************/
u8 acpi_rs_decode_bitmask(u16 mask, u8 * list)
{
acpi_native_uint i;
u8 bit_count;
/* Decode the mask bits */
for (i = 0, bit_count = 0; mask; i++) {
if (mask & 0x0001) {
list[bit_count] = (u8) i;
bit_count++;
}
mask >>= 1;
}
return (bit_count);
}
/*******************************************************************************
*
* FUNCTION: acpi_rs_encode_bitmask
*
* PARAMETERS: List - List of values to encode
* Count - Length of list
*
* RETURN: Encoded bitmask
*
* DESCRIPTION: Convert a list of values to an encoded bitmask
*
******************************************************************************/
u16 acpi_rs_encode_bitmask(u8 * list, u8 count)
{
acpi_native_uint i;
u16 mask;
/* Encode the list into a single bitmask */
for (i = 0, mask = 0; i < count; i++) {
mask |= (0x0001 << list[i]);
}
return (mask);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_move_data * FUNCTION: acpi_rs_move_data
...@@ -64,6 +122,7 @@ ACPI_MODULE_NAME("rsutils") ...@@ -64,6 +122,7 @@ ACPI_MODULE_NAME("rsutils")
* via the ACPI_MOVE_* macros. (This is why a memcpy is not used) * via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
* *
******************************************************************************/ ******************************************************************************/
void void
acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type) acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type)
{ {
...@@ -73,22 +132,30 @@ acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type) ...@@ -73,22 +132,30 @@ acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type)
for (i = 0; i < item_count; i++) { for (i = 0; i < item_count; i++) {
switch (move_type) { switch (move_type) {
case ACPI_MOVE_TYPE_16_TO_32: /*
ACPI_MOVE_16_TO_32(&((u32 *) destination)[i], * For the 8-bit case, we can perform the move all at once
&((u16 *) source)[i]); * since there are no alignment or endian issues
break; */
case ACPI_RSC_MOVE8:
ACPI_MEMCPY(destination, source, item_count);
return;
case ACPI_MOVE_TYPE_32_TO_16: /*
ACPI_MOVE_32_TO_16(&((u16 *) destination)[i], * 16-, 32-, and 64-bit cases must use the move macros that perform
&((u32 *) source)[i]); * endian conversion and/or accomodate hardware that cannot perform
* misaligned memory transfers
*/
case ACPI_RSC_MOVE16:
ACPI_MOVE_16_TO_16(&((u16 *) destination)[i],
&((u16 *) source)[i]);
break; break;
case ACPI_MOVE_TYPE_32_TO_32: case ACPI_RSC_MOVE32:
ACPI_MOVE_32_TO_32(&((u32 *) destination)[i], ACPI_MOVE_32_TO_32(&((u32 *) destination)[i],
&((u32 *) source)[i]); &((u32 *) source)[i]);
break; break;
case ACPI_MOVE_TYPE_64_TO_64: case ACPI_RSC_MOVE64:
ACPI_MOVE_64_TO_64(&((u64 *) destination)[i], ACPI_MOVE_64_TO_64(&((u64 *) destination)[i],
&((u64 *) source)[i]); &((u64 *) source)[i]);
break; break;
...@@ -148,80 +215,57 @@ struct acpi_resource_info *acpi_rs_get_resource_info(u8 resource_type) ...@@ -148,80 +215,57 @@ struct acpi_resource_info *acpi_rs_get_resource_info(u8 resource_type)
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_rs_get_resource_length * FUNCTION: acpi_rs_set_resource_length
* *
* PARAMETERS: Aml - Pointer to the raw AML resource descriptor * PARAMETERS: total_length - Length of the AML descriptor, including
* the header and length fields.
* Aml - Pointer to the raw AML descriptor
* *
* RETURN: Byte Length * RETURN: None
* *
* DESCRIPTION: Get the "Resource Length" of a raw AML descriptor. By * DESCRIPTION: Set the resource_length field of an AML
* definition, this does not include the size of the descriptor * resource descriptor, both Large and Small descriptors are
* header or the length field itself. * supported automatically. Note: Descriptor Type field must
* be valid.
* *
******************************************************************************/ ******************************************************************************/
u16 acpi_rs_get_resource_length(union aml_resource * aml) void
acpi_rs_set_resource_length(acpi_rsdesc_size total_length,
union aml_resource *aml)
{ {
u16 resource_length; acpi_rs_length resource_length;
ACPI_FUNCTION_ENTRY(); ACPI_FUNCTION_ENTRY();
/* Determine if this is a small or large resource */ /* Determine if this is a small or large resource */
if (aml->large_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) { if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource type -- bytes 1-2 contain the 16-bit length */ /* Large Resource type -- bytes 1-2 contain the 16-bit length */
ACPI_MOVE_16_TO_16(&resource_length, resource_length = (acpi_rs_length)
&aml->large_header.resource_length); (total_length - sizeof(struct aml_resource_large_header));
/* Insert length into the Large descriptor length field */
ACPI_MOVE_16_TO_16(&aml->large_header.resource_length,
&resource_length);
} else { } else {
/* Small Resource type -- bits 2:0 of byte 0 contain the length */ /* Small Resource type -- bits 2:0 of byte 0 contain the length */
resource_length = (u16) (aml->small_header.descriptor_type & resource_length = (acpi_rs_length)
ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK); (total_length - sizeof(struct aml_resource_small_header));
}
return (resource_length);
}
/******************************************************************************* /* Insert length into the descriptor type byte */
*
* FUNCTION: acpi_rs_get_descriptor_length
*
* PARAMETERS: Aml - Pointer to the raw AML resource descriptor
*
* RETURN: Byte length
*
* DESCRIPTION: Get the total byte length of a raw AML descriptor, including the
* length of the descriptor header and the length field itself.
* Used to walk descriptor lists.
*
******************************************************************************/
u32 acpi_rs_get_descriptor_length(union aml_resource * aml)
{
u32 descriptor_length;
ACPI_FUNCTION_ENTRY();
/* Determine if this is a small or large resource */
if (aml->large_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource type -- bytes 1-2 contain the 16-bit length */
ACPI_MOVE_16_TO_32(&descriptor_length, aml->small_header.descriptor_type = (u8)
&aml->large_header.resource_length);
descriptor_length += sizeof(struct aml_resource_large_header);
} else { /* Clear any existing length, preserving descriptor type bits */
/* Small Resource type -- bits 2:0 of byte 0 contain the length */ ((aml->small_header.
descriptor_type & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
descriptor_length = (u32) (aml->small_header.descriptor_type & | resource_length);
ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
descriptor_length += sizeof(struct aml_resource_small_header);
} }
return (descriptor_length);
} }
/******************************************************************************* /*******************************************************************************
...@@ -243,71 +287,18 @@ u32 acpi_rs_get_descriptor_length(union aml_resource * aml) ...@@ -243,71 +287,18 @@ u32 acpi_rs_get_descriptor_length(union aml_resource * aml)
void void
acpi_rs_set_resource_header(u8 descriptor_type, acpi_rs_set_resource_header(u8 descriptor_type,
acpi_size total_length, union aml_resource *aml) acpi_rsdesc_size total_length,
union aml_resource *aml)
{ {
u16 resource_length;
ACPI_FUNCTION_ENTRY(); ACPI_FUNCTION_ENTRY();
/* Set the descriptor type */ /* Set the Descriptor Type */
aml->small_header.descriptor_type = descriptor_type; aml->small_header.descriptor_type = descriptor_type;
/* Determine if this is a small or large resource */ /* Set the Resource Length */
if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource type -- bytes 1-2 contain the 16-bit length */
resource_length =
(u16) (total_length -
sizeof(struct aml_resource_large_header));
/* Insert length into the Large descriptor length field */
ACPI_MOVE_16_TO_16(&aml->large_header.resource_length,
&resource_length);
} else {
/* Small Resource type -- bits 2:0 of byte 0 contain the length */
resource_length =
(u16) (total_length -
sizeof(struct aml_resource_small_header));
/* Insert length into the descriptor type byte */
aml->small_header.descriptor_type |= (u8) resource_length;
}
}
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_resource_type
*
* PARAMETERS: resource_type - Byte 0 of a resource descriptor
*
* RETURN: The Resource Type with no extraneous bits (except the
* Large/Small descriptor bit -- this is left alone)
*
* DESCRIPTION: Extract the Resource Type/Name from the first byte of
* a resource descriptor.
*
******************************************************************************/
u8 acpi_rs_get_resource_type(u8 resource_type)
{
ACPI_FUNCTION_ENTRY();
/* Determine if this is a small or large resource */ acpi_rs_set_resource_length(total_length, aml);
if (resource_type & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource Type -- bits 6:0 contain the name */
return (resource_type);
} else {
/* Small Resource Type -- bits 6:3 contain the name */
return ((u8) (resource_type & ACPI_RESOURCE_NAME_SMALL_MASK));
}
} }
/******************************************************************************* /*******************************************************************************
...@@ -360,13 +351,13 @@ static u16 acpi_rs_strcpy(char *destination, char *source) ...@@ -360,13 +351,13 @@ static u16 acpi_rs_strcpy(char *destination, char *source)
* *
******************************************************************************/ ******************************************************************************/
u16 acpi_rs_length
acpi_rs_get_resource_source(u16 resource_length, acpi_rs_get_resource_source(acpi_rs_length resource_length,
acpi_size minimum_length, acpi_rs_length minimum_length,
struct acpi_resource_source * resource_source, struct acpi_resource_source * resource_source,
union aml_resource * aml, char *string_ptr) union aml_resource * aml, char *string_ptr)
{ {
acpi_size total_length; acpi_rsdesc_size total_length;
u8 *aml_resource_source; u8 *aml_resource_source;
ACPI_FUNCTION_ENTRY(); ACPI_FUNCTION_ENTRY();
...@@ -382,7 +373,7 @@ acpi_rs_get_resource_source(u16 resource_length, ...@@ -382,7 +373,7 @@ acpi_rs_get_resource_source(u16 resource_length,
* Note: Some resource descriptors will have an additional null, so * Note: Some resource descriptors will have an additional null, so
* we add 1 to the minimum length. * we add 1 to the minimum length.
*/ */
if (total_length > (minimum_length + 1)) { if (total_length > (acpi_rsdesc_size) (minimum_length + 1)) {
/* Get the resource_source_index */ /* Get the resource_source_index */
resource_source->index = aml_resource_source[0]; resource_source->index = aml_resource_source[0];
...@@ -398,20 +389,26 @@ acpi_rs_get_resource_source(u16 resource_length, ...@@ -398,20 +389,26 @@ acpi_rs_get_resource_source(u16 resource_length,
sizeof(struct acpi_resource_source); sizeof(struct acpi_resource_source);
} }
/*
* In order for the struct_size to fall on a 32-bit boundary, calculate
* the length of the string (+1 for the NULL terminator) and expand the
* struct_size to the next 32-bit boundary.
*
* Zero the entire area of the buffer.
*/
total_length =
ACPI_ROUND_UP_to_32_bITS(ACPI_STRLEN
((char *)&aml_resource_source[1]) +
1);
ACPI_MEMSET(resource_source->string_ptr, 0, total_length);
/* Copy the resource_source string to the destination */ /* Copy the resource_source string to the destination */
resource_source->string_length = resource_source->string_length =
acpi_rs_strcpy(resource_source->string_ptr, acpi_rs_strcpy(resource_source->string_ptr,
(char *)&aml_resource_source[1]); (char *)&aml_resource_source[1]);
/* return ((acpi_rs_length) total_length);
* In order for the struct_size to fall on a 32-bit boundary,
* calculate the length of the string and expand the
* struct_size to the next 32-bit boundary.
*/
return ((u16)
ACPI_ROUND_UP_to_32_bITS(resource_source->
string_length));
} else { } else {
/* resource_source is not present */ /* resource_source is not present */
...@@ -434,18 +431,18 @@ acpi_rs_get_resource_source(u16 resource_length, ...@@ -434,18 +431,18 @@ acpi_rs_get_resource_source(u16 resource_length,
* *
* RETURN: Total length of the AML descriptor * RETURN: Total length of the AML descriptor
* *
* DESCRIPTION: Convert an optoinal resource_source from internal format to a * DESCRIPTION: Convert an optional resource_source from internal format to a
* raw AML resource descriptor * raw AML resource descriptor
* *
******************************************************************************/ ******************************************************************************/
acpi_size acpi_rsdesc_size
acpi_rs_set_resource_source(union aml_resource * aml, acpi_rs_set_resource_source(union aml_resource * aml,
acpi_size minimum_length, acpi_rs_length minimum_length,
struct acpi_resource_source * resource_source) struct acpi_resource_source * resource_source)
{ {
u8 *aml_resource_source; u8 *aml_resource_source;
acpi_size descriptor_length; acpi_rsdesc_size descriptor_length;
ACPI_FUNCTION_ENTRY(); ACPI_FUNCTION_ENTRY();
...@@ -472,7 +469,7 @@ acpi_rs_set_resource_source(union aml_resource * aml, ...@@ -472,7 +469,7 @@ acpi_rs_set_resource_source(union aml_resource * aml,
* final descriptor length * final descriptor length
*/ */
descriptor_length += descriptor_length +=
((acpi_size) resource_source->string_length + 1); ((acpi_rsdesc_size) resource_source->string_length + 1);
} }
/* Return the new total length of the AML descriptor */ /* Return the new total length of the AML descriptor */
......
drivers/acpi/resources/rsxface.c
浏览文件 @ 0897831b
...@@ -57,7 +57,7 @@ ACPI_MODULE_NAME("rsxface") ...@@ -57,7 +57,7 @@ ACPI_MODULE_NAME("rsxface")
ACPI_COPY_FIELD(out, in, decode); \ ACPI_COPY_FIELD(out, in, decode); \
ACPI_COPY_FIELD(out, in, min_address_fixed); \ ACPI_COPY_FIELD(out, in, min_address_fixed); \
ACPI_COPY_FIELD(out, in, max_address_fixed); \ ACPI_COPY_FIELD(out, in, max_address_fixed); \
ACPI_COPY_FIELD(out, in, attribute); \ ACPI_COPY_FIELD(out, in, info); \
ACPI_COPY_FIELD(out, in, granularity); \ ACPI_COPY_FIELD(out, in, granularity); \
ACPI_COPY_FIELD(out, in, minimum); \ ACPI_COPY_FIELD(out, in, minimum); \
ACPI_COPY_FIELD(out, in, maximum); \ ACPI_COPY_FIELD(out, in, maximum); \
......
drivers/acpi/tables/tbutils.c
浏览文件 @ 0897831b
...@@ -94,9 +94,8 @@ acpi_status acpi_tb_is_table_installed(struct acpi_table_desc *new_table_desc) ...@@ -94,9 +94,8 @@ acpi_status acpi_tb_is_table_installed(struct acpi_table_desc *new_table_desc)
new_table_desc->pointer->length) new_table_desc->pointer->length)
&& &&
(!ACPI_MEMCMP (!ACPI_MEMCMP
((const char *)table_desc->pointer, (table_desc->pointer, new_table_desc->pointer,
(const char *)new_table_desc->pointer, new_table_desc->pointer->length))) {
(acpi_size) new_table_desc->pointer->length))) {
/* Match: this table is already installed */ /* Match: this table is already installed */
ACPI_DEBUG_PRINT((ACPI_DB_TABLES, ACPI_DEBUG_PRINT((ACPI_DB_TABLES,
......
drivers/acpi/utilities/utalloc.c
浏览文件 @ 0897831b
...@@ -866,7 +866,7 @@ void acpi_ut_dump_allocations(u32 component, char *module) ...@@ -866,7 +866,7 @@ void acpi_ut_dump_allocations(u32 component, char *module)
if (!num_outstanding) { if (!num_outstanding) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"No outstanding allocations.\n")); "No outstanding allocations\n"));
} else { } else {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR, ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"%d(%X) Outstanding allocations\n", "%d(%X) Outstanding allocations\n",
......
drivers/acpi/utilities/utglobal.c
浏览文件 @ 0897831b
...@@ -217,23 +217,23 @@ const char *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STRINGS] = { ...@@ -217,23 +217,23 @@ const char *acpi_gbl_valid_osi_strings[ACPI_NUM_OSI_STRINGS] = {
* 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to * 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
* perform a Notify() operation on it. * perform a Notify() operation on it.
*/ */
const struct acpi_predefined_names acpi_gbl_pre_defined_names[] = const struct acpi_predefined_names acpi_gbl_pre_defined_names[] = {
{ {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL}, {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL}, {"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_SB_", ACPI_TYPE_DEVICE, NULL}, {"_SB_", ACPI_TYPE_DEVICE, NULL},
{"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL}, {"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_TZ_", ACPI_TYPE_THERMAL, NULL}, {"_TZ_", ACPI_TYPE_THERMAL, NULL},
{"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL}, {"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL},
{"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME}, {"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
{"_GL_", ACPI_TYPE_MUTEX, (char *)1}, {"_GL_", ACPI_TYPE_MUTEX, (char *)1},
#if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY) #if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
{"_OSI", ACPI_TYPE_METHOD, (char *)1}, {"_OSI", ACPI_TYPE_METHOD, (char *)1},
#endif #endif
/* Table terminator */ /* Table terminator */
{NULL, ACPI_TYPE_ANY, NULL} {NULL, ACPI_TYPE_ANY, NULL}
}; };
/* /*
...@@ -503,11 +503,13 @@ char *acpi_ut_get_region_name(u8 space_id) ...@@ -503,11 +503,13 @@ char *acpi_ut_get_region_name(u8 space_id)
/* Event type decoding */ /* 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] = {
/*! [Begin] no source code translation (keep these strings as-is) */
"PM_Timer", "PM_Timer",
"global_lock", "GlobalLock",
"power_button", "PowerButton",
"sleep_button", "SleepButton",
"real_time_clock", "RealTimeClock",
/*! [End] no source code translation !*/
}; };
char *acpi_ut_get_event_name(u32 event_id) char *acpi_ut_get_event_name(u32 event_id)
...@@ -545,12 +547,13 @@ static const char acpi_gbl_bad_type[] = "UNDEFINED"; ...@@ -545,12 +547,13 @@ static const char acpi_gbl_bad_type[] = "UNDEFINED";
/* Printable names of the ACPI object types */ /* Printable names of the ACPI object types */
static const char *acpi_gbl_ns_type_names[] = { static const char *acpi_gbl_ns_type_names[] = {
/*! [Begin] no source code translation (keep these strings as-is) */
/* 00 */ "Untyped", /* 00 */ "Untyped",
/* 01 */ "Integer", /* 01 */ "Integer",
/* 02 */ "String", /* 02 */ "String",
/* 03 */ "Buffer", /* 03 */ "Buffer",
/* 04 */ "Package", /* 04 */ "Package",
/* 05 */ "field_unit", /* 05 */ "FieldUnit",
/* 06 */ "Device", /* 06 */ "Device",
/* 07 */ "Event", /* 07 */ "Event",
/* 08 */ "Method", /* 08 */ "Method",
...@@ -559,23 +562,24 @@ static const char *acpi_gbl_ns_type_names[] = { ...@@ -559,23 +562,24 @@ static const char *acpi_gbl_ns_type_names[] = {
/* 11 */ "Power", /* 11 */ "Power",
/* 12 */ "Processor", /* 12 */ "Processor",
/* 13 */ "Thermal", /* 13 */ "Thermal",
/* 14 */ "buffer_field", /* 14 */ "BufferField",
/* 15 */ "ddb_handle", /* 15 */ "DdbHandle",
/* 16 */ "debug_object", /* 16 */ "DebugObject",
/* 17 */ "region_field", /* 17 */ "RegionField",
/* 18 */ "bank_field", /* 18 */ "BankField",
/* 19 */ "index_field", /* 19 */ "IndexField",
/* 20 */ "Reference", /* 20 */ "Reference",
/* 21 */ "Alias", /* 21 */ "Alias",
/* 22 */ "method_alias", /* 22 */ "MethodAlias",
/* 23 */ "Notify", /* 23 */ "Notify",
/* 24 */ "addr_handler", /* 24 */ "AddrHandler",
/* 25 */ "resource_desc", /* 25 */ "ResourceDesc",
/* 26 */ "resource_fld", /* 26 */ "ResourceFld",
/* 27 */ "Scope", /* 27 */ "Scope",
/* 28 */ "Extra", /* 28 */ "Extra",
/* 29 */ "Data", /* 29 */ "Data",
/* 30 */ "Invalid" /* 30 */ "Invalid"
/*! [End] no source code translation !*/
}; };
char *acpi_ut_get_type_name(acpi_object_type type) char *acpi_ut_get_type_name(acpi_object_type type)
...@@ -658,15 +662,16 @@ char *acpi_ut_get_node_name(void *object) ...@@ -658,15 +662,16 @@ char *acpi_ut_get_node_name(void *object)
/* Printable names of object descriptor types */ /* Printable names of object descriptor types */
static const char *acpi_gbl_desc_type_names[] = { static const char *acpi_gbl_desc_type_names[] = {
/*! [Begin] no source code translation (keep these ASL Keywords as-is) */
/* 00 */ "Invalid", /* 00 */ "Invalid",
/* 01 */ "Cached", /* 01 */ "Cached",
/* 02 */ "State-Generic", /* 02 */ "State-Generic",
/* 03 */ "State-Update", /* 03 */ "State-Update",
/* 04 */ "State-Package", /* 04 */ "State-Package",
/* 05 */ "State-Control", /* 05 */ "State-Control",
/* 06 */ "State-root_parse_scope", /* 06 */ "State-RootParseScope",
/* 07 */ "State-parse_scope", /* 07 */ "State-ParseScope",
/* 08 */ "State-walk_scope", /* 08 */ "State-WalkScope",
/* 09 */ "State-Result", /* 09 */ "State-Result",
/* 10 */ "State-Notify", /* 10 */ "State-Notify",
/* 11 */ "State-Thread", /* 11 */ "State-Thread",
...@@ -674,6 +679,7 @@ static const char *acpi_gbl_desc_type_names[] = { ...@@ -674,6 +679,7 @@ static const char *acpi_gbl_desc_type_names[] = {
/* 13 */ "Parser", /* 13 */ "Parser",
/* 14 */ "Operand", /* 14 */ "Operand",
/* 15 */ "Node" /* 15 */ "Node"
/*! [End] no source code translation !*/
}; };
char *acpi_ut_get_descriptor_name(void *object) char *acpi_ut_get_descriptor_name(void *object)
......
drivers/acpi/utilities/utmisc.c
浏览文件 @ 0897831b
...@@ -43,6 +43,7 @@ ...@@ -43,6 +43,7 @@
#include <acpi/acpi.h> #include <acpi/acpi.h>
#include <acpi/acnamesp.h> #include <acpi/acnamesp.h>
#include <acpi/amlresrc.h>
#define _COMPONENT ACPI_UTILITIES #define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME("utmisc") ACPI_MODULE_NAME("utmisc")
...@@ -788,6 +789,113 @@ u8 acpi_ut_generate_checksum(u8 * buffer, u32 length) ...@@ -788,6 +789,113 @@ u8 acpi_ut_generate_checksum(u8 * buffer, u32 length)
return ((u8) (0 - sum)); return ((u8) (0 - sum));
} }
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_resource_type
*
* PARAMETERS: Aml - Pointer to the raw AML resource descriptor
*
* RETURN: The Resource Type with no extraneous bits (except the
* Large/Small descriptor bit -- this is left alone)
*
* DESCRIPTION: Extract the Resource Type/Name from the first byte of
* a resource descriptor.
*
******************************************************************************/
u8 acpi_ut_get_resource_type(void *aml)
{
ACPI_FUNCTION_ENTRY();
/*
* Byte 0 contains the descriptor name (Resource Type)
* Determine if this is a small or large resource
*/
if (*((u8 *) aml) & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource Type -- bits 6:0 contain the name */
return (*((u8 *) aml));
} else {
/* Small Resource Type -- bits 6:3 contain the name */
return ((u8) (*((u8 *) aml) & ACPI_RESOURCE_NAME_SMALL_MASK));
}
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_resource_length
*
* PARAMETERS: Aml - Pointer to the raw AML resource descriptor
*
* RETURN: Byte Length
*
* DESCRIPTION: Get the "Resource Length" of a raw AML descriptor. By
* definition, this does not include the size of the descriptor
* header or the length field itself.
*
******************************************************************************/
u16 acpi_ut_get_resource_length(void *aml)
{
u16 resource_length;
ACPI_FUNCTION_ENTRY();
/*
* Byte 0 contains the descriptor name (Resource Type)
* Determine if this is a small or large resource
*/
if (*((u8 *) aml) & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource type -- bytes 1-2 contain the 16-bit length */
ACPI_MOVE_16_TO_16(&resource_length, &((u8 *) aml)[1]);
} else {
/* Small Resource type -- bits 2:0 of byte 0 contain the length */
resource_length = (u16) (*((u8 *) aml) &
ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
}
return (resource_length);
}
/*******************************************************************************
*
* FUNCTION: acpi_ut_get_descriptor_length
*
* PARAMETERS: Aml - Pointer to the raw AML resource descriptor
*
* RETURN: Byte length
*
* DESCRIPTION: Get the total byte length of a raw AML descriptor, including the
* length of the descriptor header and the length field itself.
* Used to walk descriptor lists.
*
******************************************************************************/
u32 acpi_ut_get_descriptor_length(void *aml)
{
u32 descriptor_length;
ACPI_FUNCTION_ENTRY();
/* First get the Resource Length (Does not include header length) */
descriptor_length = acpi_ut_get_resource_length(aml);
/* Determine if this is a small or large resource */
if (*((u8 *) aml) & ACPI_RESOURCE_NAME_LARGE) {
descriptor_length += sizeof(struct aml_resource_large_header);
} else {
descriptor_length += sizeof(struct aml_resource_small_header);
}
return (descriptor_length);
}
/******************************************************************************* /*******************************************************************************
* *
* FUNCTION: acpi_ut_get_resource_end_tag * FUNCTION: acpi_ut_get_resource_end_tag
...@@ -796,42 +904,34 @@ u8 acpi_ut_generate_checksum(u8 * buffer, u32 length) ...@@ -796,42 +904,34 @@ u8 acpi_ut_generate_checksum(u8 * buffer, u32 length)
* *
* RETURN: Pointer to the end tag * RETURN: Pointer to the end tag
* *
* DESCRIPTION: Find the END_TAG resource descriptor in a resource template * DESCRIPTION: Find the END_TAG resource descriptor in an AML resource template
* *
******************************************************************************/ ******************************************************************************/
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 *aml;
u8 *buffer; u8 *end_aml;
u8 *end_buffer;
buffer = obj_desc->buffer.pointer;
end_buffer = buffer + obj_desc->buffer.length;
while (buffer < end_buffer) { aml = obj_desc->buffer.pointer;
buffer_byte = *buffer; end_aml = aml + obj_desc->buffer.length;
if (buffer_byte & ACPI_RESOURCE_NAME_LARGE) {
/* Large Descriptor - Length is next 2 bytes */
buffer += ((*(buffer + 1) | (*(buffer + 2) << 8)) + 3); /* Walk the resource template, one descriptor per loop */
} else {
/* Small Descriptor. End Tag will be found here */
if ((buffer_byte & ACPI_RESOURCE_NAME_SMALL_MASK) == while (aml < end_aml) {
ACPI_RESOURCE_NAME_END_TAG) { if (acpi_ut_get_resource_type(aml) ==
/* Found the end tag descriptor, all done. */ ACPI_RESOURCE_NAME_END_TAG) {
/* Found the end_tag descriptor, all done */
return (buffer); return (aml);
} }
/* Length is in the header */ /* Point to the next resource descriptor */
buffer += ((buffer_byte & 0x07) + 1); aml += acpi_ut_get_resource_length(aml);
}
} }
/* End tag not found */ /* End tag was not found */
return (NULL); return (NULL);
} }
......
drivers/pnp/pnpacpi/rsparser.c
浏览文件 @ 0897831b
...@@ -401,7 +401,7 @@ pnpacpi_parse_mem24_option(struct pnp_option *option, ...@@ -401,7 +401,7 @@ pnpacpi_parse_mem24_option(struct pnp_option *option,
mem->align = p->alignment; mem->align = p->alignment;
mem->size = p->address_length; mem->size = p->address_length;
mem->flags = (ACPI_READ_WRITE_MEMORY == p->read_write_attribute) ? mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
IORESOURCE_MEM_WRITEABLE : 0; IORESOURCE_MEM_WRITEABLE : 0;
pnp_register_mem_resource(option,mem); pnp_register_mem_resource(option,mem);
...@@ -424,7 +424,7 @@ pnpacpi_parse_mem32_option(struct pnp_option *option, ...@@ -424,7 +424,7 @@ pnpacpi_parse_mem32_option(struct pnp_option *option,
mem->align = p->alignment; mem->align = p->alignment;
mem->size = p->address_length; mem->size = p->address_length;
mem->flags = (ACPI_READ_WRITE_MEMORY == p->read_write_attribute) ? mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
IORESOURCE_MEM_WRITEABLE : 0; IORESOURCE_MEM_WRITEABLE : 0;
pnp_register_mem_resource(option,mem); pnp_register_mem_resource(option,mem);
...@@ -446,7 +446,7 @@ pnpacpi_parse_fixed_mem32_option(struct pnp_option *option, ...@@ -446,7 +446,7 @@ pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
mem->size = p->address_length; mem->size = p->address_length;
mem->align = 0; mem->align = 0;
mem->flags = (ACPI_READ_WRITE_MEMORY == p->read_write_attribute) ? mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
IORESOURCE_MEM_WRITEABLE : 0; IORESOURCE_MEM_WRITEABLE : 0;
pnp_register_mem_resource(option,mem); pnp_register_mem_resource(option,mem);
...@@ -734,7 +734,7 @@ static void pnpacpi_encode_mem24(struct acpi_resource *resource, ...@@ -734,7 +734,7 @@ static void pnpacpi_encode_mem24(struct acpi_resource *resource,
resource->type = ACPI_RESOURCE_TYPE_MEMORY24; resource->type = ACPI_RESOURCE_TYPE_MEMORY24;
resource->length = sizeof(struct acpi_resource); resource->length = sizeof(struct acpi_resource);
/* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */ /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
resource->data.memory24.read_write_attribute = resource->data.memory24.write_protect =
(p->flags & IORESOURCE_MEM_WRITEABLE) ? (p->flags & IORESOURCE_MEM_WRITEABLE) ?
ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
resource->data.memory24.minimum = p->start; resource->data.memory24.minimum = p->start;
...@@ -748,7 +748,7 @@ static void pnpacpi_encode_mem32(struct acpi_resource *resource, ...@@ -748,7 +748,7 @@ static void pnpacpi_encode_mem32(struct acpi_resource *resource,
{ {
resource->type = ACPI_RESOURCE_TYPE_MEMORY32; resource->type = ACPI_RESOURCE_TYPE_MEMORY32;
resource->length = sizeof(struct acpi_resource); resource->length = sizeof(struct acpi_resource);
resource->data.memory32.read_write_attribute = resource->data.memory32.write_protect =
(p->flags & IORESOURCE_MEM_WRITEABLE) ? (p->flags & IORESOURCE_MEM_WRITEABLE) ?
ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
resource->data.memory32.minimum = p->start; resource->data.memory32.minimum = p->start;
...@@ -762,7 +762,7 @@ static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource, ...@@ -762,7 +762,7 @@ static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
{ {
resource->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32; resource->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32;
resource->length = sizeof(struct acpi_resource); resource->length = sizeof(struct acpi_resource);
resource->data.fixed_memory32.read_write_attribute = resource->data.fixed_memory32.write_protect =
(p->flags & IORESOURCE_MEM_WRITEABLE) ? (p->flags & IORESOURCE_MEM_WRITEABLE) ?
ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY; ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
resource->data.fixed_memory32.address = p->start; resource->data.fixed_memory32.address = p->start;
......
include/acpi/acconfig.h
浏览文件 @ 0897831b
...@@ -63,7 +63,7 @@ ...@@ -63,7 +63,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */ /* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20050930 #define ACPI_CA_VERSION 0x20051021
/* /*
* OS name, used for the _OS object. The _OS object is essentially obsolete, * OS name, used for the _OS object. The _OS object is essentially obsolete,
......
include/acpi/acdisasm.h
浏览文件 @ 0897831b
...@@ -60,6 +60,7 @@ extern struct acpi_external_list *acpi_gbl_external_list; ...@@ -60,6 +60,7 @@ extern struct acpi_external_list *acpi_gbl_external_list;
extern const char *acpi_gbl_io_decode[2]; extern const char *acpi_gbl_io_decode[2];
extern const char *acpi_gbl_word_decode[4]; extern const char *acpi_gbl_word_decode[4];
extern const char *acpi_gbl_consume_decode[2]; extern const char *acpi_gbl_consume_decode[2];
extern const char *acpi_gbl_config_decode[4];
extern const char *acpi_gbl_min_decode[2]; extern const char *acpi_gbl_min_decode[2];
extern const char *acpi_gbl_max_decode[2]; extern const char *acpi_gbl_max_decode[2];
extern const char *acpi_gbl_DECdecode[2]; extern const char *acpi_gbl_DECdecode[2];
...@@ -171,11 +172,19 @@ u8 acpi_dm_is_string_buffer(union acpi_parse_object *op); ...@@ -171,11 +172,19 @@ u8 acpi_dm_is_string_buffer(union acpi_parse_object *op);
/* /*
* dmresrc * dmresrc
*/ */
void acpi_dm_dump_integer8(u8 value, char *name);
void acpi_dm_dump_integer16(u16 value, char *name);
void acpi_dm_dump_integer32(u32 value, char *name);
void acpi_dm_dump_integer64(u64 value, char *name);
void void
acpi_dm_resource_descriptor(struct acpi_op_walk_info *info, acpi_dm_resource_template(struct acpi_op_walk_info *info,
u8 * byte_data, u32 byte_count); u8 * byte_data, u32 byte_count);
u8 acpi_dm_is_resource_descriptor(union acpi_parse_object *op); u8 acpi_dm_is_resource_template(union acpi_parse_object *op);
void acpi_dm_indent(u32 level); void acpi_dm_indent(u32 level);
...@@ -223,6 +232,8 @@ void ...@@ -223,6 +232,8 @@ void
acpi_dm_vendor_large_descriptor(union aml_resource *resource, acpi_dm_vendor_large_descriptor(union aml_resource *resource,
u32 length, u32 level); u32 length, u32 level);
void acpi_dm_vendor_common(char *name, u8 * byte_data, u32 length, u32 level);
/* /*
* dmresrcs * dmresrcs
*/ */
......
include/acpi/acmacros.h
浏览文件 @ 0897831b
...@@ -202,7 +202,7 @@ ...@@ -202,7 +202,7 @@
#define ACPI_BUFFER_INDEX(buf_len,buf_offset,byte_gran) (buf_offset) #define ACPI_BUFFER_INDEX(buf_len,buf_offset,byte_gran) (buf_offset)
#ifdef ACPI_MISALIGNED_TRANSFERS #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
/* The hardware supports unaligned transfers, just do the little-endian move */ /* The hardware supports unaligned transfers, just do the little-endian move */
...@@ -563,11 +563,11 @@ ...@@ -563,11 +563,11 @@
return (_s); }) return (_s); })
#define return_UINT8(s) ACPI_DO_WHILE0 ({ \ #define return_UINT8(s) ACPI_DO_WHILE0 ({ \
register u8 _s = (u8) (s); \ register u8 _s = (u8) (s); \
acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, _s); \ acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) _s); \
return (_s); }) return (_s); })
#define return_UINT32(s) ACPI_DO_WHILE0 ({ \ #define return_UINT32(s) ACPI_DO_WHILE0 ({ \
register u32 _s = (u32) (s); \ register u32 _s = (u32) (s); \
acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, _s); \ acpi_ut_value_exit (ACPI_DEBUG_PARAMETERS, (acpi_integer) _s); \
return (_s); }) return (_s); })
#else /* Use original less-safe macros */ #else /* Use original less-safe macros */
......
include/acpi/acpiosxf.h
浏览文件 @ 0897831b
...@@ -108,9 +108,9 @@ acpi_status acpi_os_create_lock(acpi_handle * out_handle); ...@@ -108,9 +108,9 @@ acpi_status acpi_os_create_lock(acpi_handle * out_handle);
void acpi_os_delete_lock(acpi_handle handle); void acpi_os_delete_lock(acpi_handle handle);
unsigned long acpi_os_acquire_lock(acpi_handle handle); acpi_native_uint acpi_os_acquire_lock(acpi_handle handle);
void acpi_os_release_lock(acpi_handle handle, unsigned long flags); void acpi_os_release_lock(acpi_handle handle, acpi_native_uint flags);
/* /*
* Memory allocation and mapping * Memory allocation and mapping
......
include/acpi/acresrc.h
浏览文件 @ 0897831b
此差异已折叠。
include/acpi/actypes.h
浏览文件 @ 0897831b
此差异已折叠。
include/acpi/acutils.h
浏览文件 @ 0897831b
此差异已折叠。
include/acpi/amlresrc.h
浏览文件 @ 0897831b
此差异已折叠。
include/acpi/platform/acenv.h
浏览文件 @ 0897831b
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或