Skip to content

K
Kernel

openeuler / Kernel
接近 2 年 前同步成功

通知 8
Star 0
Fork 0
K
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)
min = addr->minimum;
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;
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,
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;
u8 enabled_status_byte;
struct acpi_gpe_register_info *gpe_register_info;
u32 status_reg;
u32 enable_reg;
u32 flags;
acpi_status status;
struct acpi_gpe_block_info *gpe_block;
acpi_native_uint flags;
acpi_native_uint i;
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)
struct acpi_gpe_block_info *gpe_block;
struct acpi_gpe_xrupt_info *gpe_xrupt_info;
acpi_status status = AE_OK;
u32 flags;
acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_walk_gpe_list");
......@@ -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 *gpe_xrupt;
acpi_status status;
u32 flags;
acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_get_gpe_xrupt_block");
......@@ -553,7 +553,7 @@ static acpi_status
acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
{
acpi_status status;
u32 flags;
acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_delete_gpe_xrupt");
......@@ -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_xrupt_info *gpe_xrupt_block;
acpi_status status;
u32 flags;
acpi_native_uint flags;
ACPI_FUNCTION_TRACE("ev_install_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 status;
u32 flags;
acpi_native_uint flags;
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,
struct acpi_gpe_event_info *gpe_event_info;
struct acpi_handler_info *handler;
acpi_status status;
u32 flags;
acpi_native_uint flags;
ACPI_FUNCTION_TRACE("acpi_install_gpe_handler");
......@@ -653,7 +653,7 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
struct acpi_gpe_event_info *gpe_event_info;
struct acpi_handler_info *handler;
acpi_status status;
u32 flags;
acpi_native_uint flags;
ACPI_FUNCTION_TRACE("acpi_remove_gpe_handler");
......
drivers/acpi/executer/exmisc.c
浏览文件 @ 0897831b
......@@ -625,9 +625,8 @@ acpi_ex_do_logical_op(u16 opcode,
/* Lexicographic compare: compare the data bytes */
compare = ACPI_MEMCMP((const char *)operand0->buffer.pointer,
(const char *)local_operand1->buffer.
pointer,
compare = ACPI_MEMCMP(operand0->buffer.pointer,
local_operand1->buffer.pointer,
(length0 > length1) ? length1 : length0);
switch (opcode) {
......
drivers/acpi/executer/exregion.c
浏览文件 @ 0897831b
......@@ -77,7 +77,7 @@ acpi_ex_system_memory_space_handler(u32 function,
struct acpi_mem_space_context *mem_info = region_context;
u32 length;
acpi_size window_size;
#ifndef ACPI_MISALIGNED_TRANSFERS
#ifdef ACPI_MISALIGNMENT_NOT_SUPPORTED
u32 remainder;
#endif
......@@ -109,7 +109,7 @@ acpi_ex_system_memory_space_handler(u32 function,
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
* the request.
......
drivers/acpi/osl.c
浏览文件 @ 0897831b
......@@ -1058,11 +1058,9 @@ EXPORT_SYMBOL(max_cstate);
* Acquire a spinlock.
*
* 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;
spin_lock_irqsave((spinlock_t *) handle, flags);
......@@ -1073,7 +1071,7 @@ unsigned long acpi_os_acquire_lock(acpi_handle handle)
* 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);
}
......
drivers/acpi/resources/rsaddr.c
浏览文件 @ 0897831b
此差异已折叠。
drivers/acpi/resources/rscalc.c
浏览文件 @ 0897831b
......@@ -52,7 +52,7 @@ ACPI_MODULE_NAME("rscalc")
/* Local prototypes */
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);
static u32
......@@ -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_FUNCTION_ENTRY();
......@@ -111,7 +111,7 @@ acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
* resource_source_index (1).
*/
if (resource_source->string_ptr) {
return ((acpi_size) resource_source->string_length + 1);
return ((acpi_rs_length) (resource_source->string_length + 1));
}
return (0);
......@@ -184,7 +184,7 @@ acpi_status
acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
{
acpi_size aml_size_needed = 0;
acpi_size segment_size;
acpi_rs_length total_size;
ACPI_FUNCTION_TRACE("rs_get_aml_length");
......@@ -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 */
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
......@@ -216,13 +216,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
if (resource->data.vendor.byte_length > 7) {
/* Base size of a Large resource descriptor */
segment_size =
total_size =
sizeof(struct aml_resource_large_header);
}
/* 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;
case ACPI_RESOURCE_TYPE_END_TAG:
......@@ -230,7 +231,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* End Tag:
* We are done -- return the accumulated total size.
*/
*size_needed = aml_size_needed + segment_size;
*size_needed = aml_size_needed + total_size;
/* Normal exit */
......@@ -241,10 +242,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 16-Bit Address Resource:
* Add the size of the optional resource_source info
*/
segment_size +=
acpi_rs_struct_option_length(&resource->data.
address16.
resource_source);
total_size = (acpi_rs_length)
(total_size +
acpi_rs_struct_option_length(&resource->data.
address16.
resource_source));
break;
case ACPI_RESOURCE_TYPE_ADDRESS32:
......@@ -252,10 +254,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 32-Bit Address Resource:
* Add the size of the optional resource_source info
*/
segment_size +=
acpi_rs_struct_option_length(&resource->data.
address32.
resource_source);
total_size = (acpi_rs_length)
(total_size +
acpi_rs_struct_option_length(&resource->data.
address32.
resource_source));
break;
case ACPI_RESOURCE_TYPE_ADDRESS64:
......@@ -263,10 +266,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 64-Bit Address Resource:
* Add the size of the optional resource_source info
*/
segment_size +=
acpi_rs_struct_option_length(&resource->data.
address64.
resource_source);
total_size = (acpi_rs_length)
(total_size +
acpi_rs_struct_option_length(&resource->data.
address64.
resource_source));
break;
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
......@@ -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
* required 1 (4 bytes for each u32 interrupt number)
*/
segment_size += (((acpi_size)
resource->data.extended_irq.
interrupt_count - 1) * 4);
/* Add the size of the optional resource_source info */
segment_size +=
acpi_rs_struct_option_length(&resource->data.
extended_irq.
resource_source);
total_size = (acpi_rs_length)
(total_size +
((resource->data.extended_irq.interrupt_count -
1) * 4) +
/* Add the size of the optional resource_source info */
acpi_rs_struct_option_length(&resource->data.
extended_irq.
resource_source));
break;
default:
......@@ -293,7 +295,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
/* Update the total */
aml_size_needed += segment_size;
aml_size_needed += total_size;
/* Point to the next object */
......@@ -341,7 +343,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
while (bytes_parsed < aml_buffer_length) {
/* 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 */
......@@ -352,10 +354,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
/* Get the Length field from the input resource descriptor */
resource_length =
acpi_rs_get_resource_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
resource_length = acpi_ut_get_resource_length(aml_buffer);
/* 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")
* descriptors are indexed by the acpi_resource_type field.
*/
/* 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_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_end_dpf, /* 0x03, ACPI_RESOURCE_TYPE_END_DEPENDENT */
acpi_rs_set_io, /* 0x04, ACPI_RESOURCE_TYPE_IO */
acpi_rs_set_fixed_io, /* 0x05, ACPI_RESOURCE_TYPE_FIXED_IO */
acpi_rs_convert_end_dpf, /* 0x03, ACPI_RESOURCE_TYPE_END_DEPENDENT */
acpi_rs_convert_io, /* 0x04, ACPI_RESOURCE_TYPE_IO */
acpi_rs_convert_fixed_io, /* 0x05, ACPI_RESOURCE_TYPE_FIXED_IO */
acpi_rs_set_vendor, /* 0x06, ACPI_RESOURCE_TYPE_VENDOR */
acpi_rs_set_end_tag, /* 0x07, ACPI_RESOURCE_TYPE_END_TAG */
acpi_rs_set_memory24, /* 0x08, ACPI_RESOURCE_TYPE_MEMORY24 */
acpi_rs_set_memory32, /* 0x09, ACPI_RESOURCE_TYPE_MEMORY32 */
acpi_rs_set_fixed_memory32, /* 0x0A, ACPI_RESOURCE_TYPE_FIXED_MEMORY32 */
acpi_rs_set_address16, /* 0x0B, ACPI_RESOURCE_TYPE_ADDRESS16 */
acpi_rs_set_address32, /* 0x0C, ACPI_RESOURCE_TYPE_ADDRESS32 */
acpi_rs_set_address64, /* 0x0D, ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_set_ext_address64, /* 0x0E, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_set_ext_irq, /* 0x0F, ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_set_generic_reg /* 0x10, ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
acpi_rs_convert_end_tag, /* 0x07, ACPI_RESOURCE_TYPE_END_TAG */
acpi_rs_convert_memory24, /* 0x08, ACPI_RESOURCE_TYPE_MEMORY24 */
acpi_rs_convert_memory32, /* 0x09, ACPI_RESOURCE_TYPE_MEMORY32 */
acpi_rs_convert_fixed_memory32, /* 0x0A, ACPI_RESOURCE_TYPE_FIXED_MEMORY32 */
acpi_rs_convert_address16, /* 0x0B, ACPI_RESOURCE_TYPE_ADDRESS16 */
acpi_rs_convert_address32, /* 0x0C, ACPI_RESOURCE_TYPE_ADDRESS32 */
acpi_rs_convert_address64, /* 0x0D, ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_convert_ext_address64, /* 0x0E, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_convert_ext_irq, /* 0x0F, ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_convert_generic_reg /* 0x10, ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
};
/* 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, /* 0x01, Reserved */
NULL, /* 0x02, Reserved */
NULL, /* 0x03, Reserved */
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_end_dpf, /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */
acpi_rs_get_io, /* 0x08, ACPI_RESOURCE_NAME_IO */
acpi_rs_get_fixed_io, /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO */
acpi_rs_convert_end_dpf, /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */
acpi_rs_convert_io, /* 0x08, ACPI_RESOURCE_NAME_IO */
acpi_rs_convert_fixed_io, /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO */
NULL, /* 0x0A, Reserved */
NULL, /* 0x0B, Reserved */
NULL, /* 0x0C, Reserved */
NULL, /* 0x0D, Reserved */
acpi_rs_get_vendor, /* 0x0E, ACPI_RESOURCE_NAME_VENDOR_SMALL */
acpi_rs_get_end_tag /* 0x0F, ACPI_RESOURCE_NAME_END_TAG */
acpi_rs_get_vendor_small, /* 0x0E, ACPI_RESOURCE_NAME_VENDOR_SMALL */
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 */
acpi_rs_get_memory24, /* 0x01, ACPI_RESOURCE_NAME_MEMORY24 */
acpi_rs_get_generic_reg, /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */
acpi_rs_convert_memory24, /* 0x01, ACPI_RESOURCE_NAME_MEMORY24 */
acpi_rs_convert_generic_reg, /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */
NULL, /* 0x03, Reserved */
acpi_rs_get_vendor, /* 0x04, ACPI_RESOURCE_NAME_VENDOR_LARGE */
acpi_rs_get_memory32, /* 0x05, ACPI_RESOURCE_NAME_MEMORY32 */
acpi_rs_get_fixed_memory32, /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY32 */
acpi_rs_get_address32, /* 0x07, ACPI_RESOURCE_NAME_ADDRESS32 */
acpi_rs_get_address16, /* 0x08, ACPI_RESOURCE_NAME_ADDRESS16 */
acpi_rs_get_ext_irq, /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_IRQ */
acpi_rs_get_address64, /* 0x0A, ACPI_RESOURCE_NAME_ADDRESS64 */
acpi_rs_get_ext_address64 /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64 */
acpi_rs_get_vendor_large, /* 0x04, ACPI_RESOURCE_NAME_VENDOR_LARGE */
acpi_rs_convert_memory32, /* 0x05, ACPI_RESOURCE_NAME_MEMORY32 */
acpi_rs_convert_fixed_memory32, /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY32 */
acpi_rs_convert_address32, /* 0x07, ACPI_RESOURCE_NAME_ADDRESS32 */
acpi_rs_convert_address16, /* 0x08, ACPI_RESOURCE_NAME_ADDRESS16 */
acpi_rs_convert_ext_irq, /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_IRQ */
acpi_rs_convert_address64, /* 0x0A, ACPI_RESOURCE_NAME_ADDRESS64 */
acpi_rs_convert_ext_address64 /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64 */
};
#ifdef ACPI_FUTURE_USAGE
......@@ -119,7 +119,7 @@ ACPI_GET_RESOURCE_HANDLER acpi_gbl_lg_get_resource_dispatch[] = {
/* 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_dma, /* ACPI_RESOURCE_TYPE_DMA */
acpi_rs_dump_start_dpf, /* ACPI_RESOURCE_TYPE_START_DEPENDENT */
......@@ -136,17 +136,17 @@ ACPI_DUMP_RESOURCE_HANDLER acpi_gbl_dump_resource_dispatch[] = {
acpi_rs_dump_address64, /* ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_dump_ext_address64, /* ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
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 /* ACPI_FUTURE_USAGE */
/*
* Base sizes for external AML resource descriptors, indexed by internal type.
* Includes size of the descriptor header (1 byte for small 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_dma), /* ACPI_RESOURCE_TYPE_DMA */
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[] = {
/* Macros used in the tables below */
#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_RLARGE(r) (sizeof (r) - sizeof (struct aml_resource_large_header))
#define ACPI_RSMALL(r) (sizeof (r) - sizeof (struct aml_resource_small_header))
/*
* Base sizes of resource descriptors, both the AML stream resource length
......@@ -182,47 +182,46 @@ struct acpi_resource_info acpi_gbl_sm_resource_info[] = {
{0, 0, 0},
{0, 0, 0},
{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),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma)},
ACPI_RS_SIZE(struct acpi_resource_dma)},
{2, ACPI_RSMALL(struct aml_resource_start_dependent),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_start_dependent)},
{0, ACPI_RSMALL(struct aml_resource_end_dependent),
ACPI_RESOURCE_LENGTH},
ACPI_RS_SIZE(struct acpi_resource_start_dependent)},
{0, ACPI_RSMALL(struct aml_resource_end_dependent), ACPI_RS_SIZE_MIN},
{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),
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},
{1, ACPI_RSMALL(struct aml_resource_vendor_small),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor)},
{0, ACPI_RSMALL(struct aml_resource_end_tag), ACPI_RESOURCE_LENGTH}
ACPI_RS_SIZE(struct acpi_resource_vendor)},
{0, ACPI_RSMALL(struct aml_resource_end_tag), ACPI_RS_SIZE_MIN}
};
struct acpi_resource_info acpi_gbl_lg_resource_info[] = {
{0, 0, 0},
{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),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_generic_register)},
ACPI_RS_SIZE(struct acpi_resource_generic_register)},
{0, 0, 0},
{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),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory32)},
ACPI_RS_SIZE(struct acpi_resource_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),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address32)},
ACPI_RS_SIZE(struct acpi_resource_address32)},
{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),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_irq)},
ACPI_RS_SIZE(struct acpi_resource_extended_irq)},
{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),
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")
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_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_rs_convert_io
*
******************************************************************************/
acpi_status
acpi_rs_get_io(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
ACPI_FUNCTION_TRACE("rs_get_io");
struct acpi_rsconvert_info acpi_rs_convert_io[5] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IO,
ACPI_RS_SIZE(struct acpi_resource_io),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_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:
* Minimum Base Address
* Maximum Base Address
* These fields are contiguous in both the source and destination:
* Address Alignment
* Length
* Minimum Base Address
* Maximum Base Address
*/
ACPI_MOVE_16_TO_32(&resource->data.io.minimum, &aml->io.minimum);
ACPI_MOVE_16_TO_32(&resource->data.io.maximum, &aml->io.maximum);
resource->data.io.alignment = aml->io.alignment;
resource->data.io.address_length = aml->io.address_length;
/* Complete the resource header */
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.io.alignment),
AML_OFFSET(io.alignment),
2},
resource->type = ACPI_RESOURCE_TYPE_IO;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_io);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.io.minimum),
AML_OFFSET(io.minimum),
2}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_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_rs_convert_fixed_io
*
******************************************************************************/
acpi_status
acpi_rs_set_io(struct acpi_resource *resource, union aml_resource *aml)
{
ACPI_FUNCTION_TRACE("rs_set_io");
/* I/O Information Byte */
aml->io.information = (u8) (resource->data.io.io_decode & 0x01);
struct acpi_rsconvert_info acpi_rs_convert_fixed_io[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_IO,
ACPI_RS_SIZE(struct acpi_resource_fixed_io),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_io)},
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_IO,
sizeof(struct aml_resource_fixed_io),
0},
/*
* Set the following contiguous fields in the AML descriptor:
* Minimum Base Address
* Maximum Base Address
* Address Alignment
* These fields are contiguous in both the source and destination:
* Base Address
* Length
*/
ACPI_MOVE_32_TO_16(&aml->io.minimum, &resource->data.io.minimum);
ACPI_MOVE_32_TO_16(&aml->io.maximum, &resource->data.io.maximum);
aml->io.alignment = (u8) resource->data.io.alignment;
aml->io.address_length = (u8) resource->data.io.address_length;
/* Complete the AML descriptor header */
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.fixed_io.address_length),
AML_OFFSET(fixed_io.address_length),
1},
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_IO,
sizeof(struct aml_resource_io), aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.fixed_io.address),
AML_OFFSET(fixed_io.address),
1}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_fixed_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_rs_convert_generic_reg
*
******************************************************************************/
acpi_status
acpi_rs_get_fixed_io(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
ACPI_FUNCTION_TRACE("rs_get_fixed_io");
struct acpi_rsconvert_info acpi_rs_convert_generic_reg[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_GENERIC_REGISTER,
ACPI_RS_SIZE(struct acpi_resource_generic_register),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_generic_reg)},
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_GENERIC_REGISTER,
sizeof(struct aml_resource_generic_register),
0},
/*
* Get the following contiguous fields from the AML descriptor:
* Base Address
* Length
* These fields are contiguous in both the source and destination:
* Address Space ID
* Register Bit Width
* Register Bit Offset
* Access Size
*/
ACPI_MOVE_16_TO_32(&resource->data.fixed_io.address,
&aml->fixed_io.address);
resource->data.fixed_io.address_length = aml->fixed_io.address_length;
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.generic_reg.space_id),
AML_OFFSET(generic_reg.address_space_id),
4},
/* Complete the resource header */
/* Get the Register Address */
resource->type = ACPI_RESOURCE_TYPE_FIXED_IO;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.generic_reg.address),
AML_OFFSET(generic_reg.address),
1}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_fixed_io
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
* acpi_rs_convert_end_dpf
*
* 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
* external AML resource descriptor.
* acpi_rs_convert_end_tag
*
******************************************************************************/
acpi_status
acpi_rs_set_fixed_io(struct acpi_resource *resource, union aml_resource *aml)
{
ACPI_FUNCTION_TRACE("rs_set_fixed_io");
struct acpi_rsconvert_info acpi_rs_convert_end_tag[2] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_END_TAG,
ACPI_RS_SIZE_MIN,
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_end_tag)},
/*
* Set the following contiguous fields in the AML descriptor:
* Base Address
* Length
* Note: The checksum field is set to zero, meaning that the resource
* data is treated as if the checksum operation succeeded.
* (ACPI Spec 1.0b Section 6.4.2.8)
*/
ACPI_MOVE_32_TO_16(&aml->fixed_io.address,
&resource->data.fixed_io.address);
aml->fixed_io.address_length =
(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);
}
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_END_TAG,
sizeof(struct aml_resource_end_tag),
0}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_dma
*
* 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_rs_get_start_dpf
*
******************************************************************************/
acpi_status
acpi_rs_get_dma(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
u32 channel_count = 0;
u32 i;
u8 temp8;
struct acpi_rsconvert_info acpi_rs_get_start_dpf[5] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_START_DEPENDENT,
ACPI_RS_SIZE(struct acpi_resource_start_dependent),
ACPI_RSC_TABLE_SIZE(acpi_rs_get_start_dpf)},
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++) {
if ((aml->dma.dma_channel_mask >> i) & 0x01) {
resource->data.dma.channels[channel_count] = i;
channel_count++;
}
}
/* All done if there is no flag byte present in the descriptor */
resource->length = 0;
resource->data.dma.channel_count = channel_count;
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 1},
/*
* 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 */
/* Flag byte is present, get the flags */
temp8 = aml->dma.flags;
resource->data.dma.transfer = temp8 & 0x03;
resource->data.dma.bus_master = (temp8 >> 2) & 0x01;
resource->data.dma.type = (temp8 >> 5) & 0x03;
{ACPI_RSC_2BITFLAG,
ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
AML_OFFSET(start_dpf.flags),
0},
if (resource->data.dma.transfer == 0x03) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Invalid DMA.Transfer preference (3)\n"));
return_ACPI_STATUS(AE_BAD_DATA);
}
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_DMA;
resource->length += ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_2BITFLAG,
ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
AML_OFFSET(start_dpf.flags),
2}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_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_rs_set_start_dpf
*
******************************************************************************/
acpi_status
acpi_rs_set_dma(struct acpi_resource *resource, union aml_resource *aml)
{
u8 i;
ACPI_FUNCTION_TRACE("rs_set_dma");
struct acpi_rsconvert_info acpi_rs_set_start_dpf[6] = {
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_START_DEPENDENT,
sizeof(struct aml_resource_start_dependent),
ACPI_RSC_TABLE_SIZE(acpi_rs_set_start_dpf)},
/* Convert channel list to 8-bit DMA channel bitmask */
/* Set the default flag values */
aml->dma.dma_channel_mask = 0;
for (i = 0; i < resource->data.dma.channel_count; i++) {
aml->dma.dma_channel_mask |=
(1 << resource->data.dma.channels[i]);
}
{ACPI_RSC_2BITFLAG,
ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
AML_OFFSET(start_dpf.flags),
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)
(((resource->data.dma.type & 0x03) << 5) |
((resource->data.dma.bus_master & 0x01) << 2) |
(resource->data.dma.transfer & 0x03));
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
ACPI_ACCEPTABLE_CONFIGURATION},
/* Complete the AML descriptor header */
/* Flag byte is not necessary */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_DMA,
sizeof(struct aml_resource_dma), aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_LENGTH, 0, 0,
sizeof(struct aml_resource_start_dependent_noprio)}
};
drivers/acpi/resources/rsirq.c
浏览文件 @ 0897831b
......@@ -49,325 +49,182 @@ ACPI_MODULE_NAME("rsirq")
/*******************************************************************************
*
* FUNCTION: 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_rs_get_irq
*
******************************************************************************/
acpi_status
acpi_rs_get_irq(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
u16 temp16 = 0;
u32 interrupt_count = 0;
u32 i;
u32 resource_length;
ACPI_FUNCTION_TRACE("rs_get_irq");
struct acpi_rsconvert_info acpi_rs_get_irq[7] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IRQ,
ACPI_RS_SIZE(struct acpi_resource_irq),
ACPI_RSC_TABLE_SIZE(acpi_rs_get_irq)},
/* Get the IRQ mask (bytes 1:2) */
ACPI_MOVE_16_TO_16(&temp16, &aml->irq.irq_mask);
/* Decode the IRQ bits (up to 16 possible) */
for (i = 0; i < 16; i++) {
if ((temp16 >> i) & 0x01) {
resource->data.irq.interrupts[interrupt_count] = i;
interrupt_count++;
}
}
/* Zero interrupts is valid */
resource_length = 0;
resource->data.irq.interrupt_count = interrupt_count;
if (interrupt_count > 0) {
/* Calculate the structure size based upon the number of interrupts */
resource_length = (u32) (interrupt_count - 1) * 4;
}
/* Get Flags (Byte 3) if it is used */
if (aml_resource_length == 3) {
/* Check for HE, LL interrupts */
switch (aml->irq.flags & 0x09) {
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);
}
{ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
AML_OFFSET(irq.irq_mask),
ACPI_RS_OFFSET(data.irq.interrupt_count)},
/* Set default flags (others are zero) */
{ACPI_RSC_SET8, ACPI_RS_OFFSET(data.irq.triggering),
ACPI_EDGE_SENSITIVE,
1},
/* All done if no flag byte present in descriptor */
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 3},
/* Get flags: Triggering[0], Polarity[3], Sharing[4] */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.triggering),
AML_OFFSET(irq.flags),
0},
{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}
};
/*******************************************************************************
*
* FUNCTION: 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_rs_set_irq
*
******************************************************************************/
acpi_status
acpi_rs_set_irq(struct acpi_resource *resource, union aml_resource *aml)
{
acpi_size descriptor_length;
u16 irq_mask;
u8 i;
ACPI_FUNCTION_TRACE("rs_set_irq");
struct acpi_rsconvert_info acpi_rs_set_irq[9] = {
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_IRQ,
sizeof(struct aml_resource_irq),
ACPI_RSC_TABLE_SIZE(acpi_rs_set_irq)},
/* Convert interrupt list to 16-bit IRQ bitmask */
irq_mask = 0;
for (i = 0; i < resource->data.irq.interrupt_count; i++) {
irq_mask |= (1 << resource->data.irq.interrupts[i]);
}
{ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
AML_OFFSET(irq.irq_mask),
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
* needed to contain the IRQ Information.
* Check if the flags byte is necessary. Not needed if the flags are:
* ACPI_EDGE_SENSITIVE, ACPI_ACTIVE_HIGH, ACPI_EXCLUSIVE
*/
if ((resource->data.irq.triggering == ACPI_EDGE_SENSITIVE) &&
(resource->data.irq.polarity == ACPI_ACTIVE_HIGH) &&
(resource->data.irq.sharable == ACPI_EXCLUSIVE)) {
/* 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 */
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
ACPI_RS_OFFSET(data.irq.triggering),
ACPI_EDGE_SENSITIVE},
aml->irq.flags = (u8)
((resource->data.irq.sharable & 0x01) << 4);
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
ACPI_RS_OFFSET(data.irq.polarity),
ACPI_ACTIVE_HIGH},
if (ACPI_LEVEL_SENSITIVE == resource->data.irq.triggering &&
ACPI_ACTIVE_LOW == resource->data.irq.polarity) {
aml->irq.flags |= 0x08;
} else {
aml->irq.flags |= 0x01;
}
}
{ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
ACPI_RS_OFFSET(data.irq.sharable),
ACPI_EXCLUSIVE},
/* Complete the AML descriptor header */
/* irq_no_flags() descriptor can be used */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_IRQ, descriptor_length,
aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_LENGTH, 0, 0, sizeof(struct aml_resource_irq_noflags)}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_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_rs_convert_ext_irq
*
******************************************************************************/
acpi_status
acpi_rs_get_ext_irq(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
char *out_resource_string;
u8 temp8;
ACPI_FUNCTION_TRACE("rs_get_ext_irq");
/* Get the flag bits */
struct acpi_rsconvert_info acpi_rs_convert_ext_irq[9] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_IRQ,
ACPI_RS_SIZE(struct acpi_resource_extended_irq),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_irq)},
temp8 = aml->extended_irq.flags;
resource->data.extended_irq.producer_consumer = temp8 & 0x01;
resource->data.extended_irq.polarity = (temp8 >> 2) & 0x01;
resource->data.extended_irq.sharable = (temp8 >> 3) & 0x01;
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_IRQ,
sizeof(struct aml_resource_extended_irq),
0},
/*
* 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;
/* Flag bits */
/* 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;
resource->data.extended_irq.interrupt_count = temp8;
if (temp8 < 1) {
/* Must have at least one IRQ */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.triggering),
AML_OFFSET(extended_irq.flags),
1},
return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
}
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.polarity),
AML_OFFSET(extended_irq.flags),
2},
/*
* Add any additional structure size to properly calculate
* the next pointer at the end of this function
*/
resource->length = (temp8 - 1) * 4;
out_resource_string = ACPI_CAST_PTR(char,
(&resource->data.extended_irq.
interrupts[0] + temp8));
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.sharable),
AML_OFFSET(extended_irq.flags),
3},
/* Get every IRQ in the table, each is 32 bits */
/* IRQ Table length (Byte4) */
acpi_rs_move_data(resource->data.extended_irq.interrupts,
aml->extended_irq.interrupt_number,
(u16) temp8, ACPI_MOVE_TYPE_32_TO_32);
{ACPI_RSC_COUNT, ACPI_RS_OFFSET(data.extended_irq.interrupt_count),
AML_OFFSET(extended_irq.interrupt_count),
sizeof(u32)}
,
/* Get the optional resource_source (index and string) */
/* Copy every IRQ in the table, each is 32 bits */
resource->length +=
acpi_rs_get_resource_source(aml_resource_length,
(acpi_size) resource->length +
sizeof(struct
aml_resource_extended_irq),
&resource->data.extended_irq.
resource_source, aml,
out_resource_string);
{ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
AML_OFFSET(extended_irq.interrupts[0]),
0}
,
/* Complete the resource header */
/* Optional resource_source (Index and String) */
resource->type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
resource->length +=
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_irq);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_SOURCEX, ACPI_RS_OFFSET(data.extended_irq.resource_source),
ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
sizeof(struct aml_resource_extended_irq)}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_ext_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_rs_convert_dma
*
******************************************************************************/
acpi_status
acpi_rs_set_ext_irq(struct acpi_resource *resource, union aml_resource *aml)
{
acpi_size descriptor_length;
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;
struct acpi_rsconvert_info acpi_rs_convert_dma[6] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_DMA,
ACPI_RS_SIZE(struct acpi_resource_dma),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_dma)},
descriptor_length = (sizeof(struct aml_resource_extended_irq) - 4) +
((acpi_size) resource->data.extended_irq.interrupt_count *
sizeof(u32));
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_DMA,
sizeof(struct aml_resource_dma),
0},
/* Set each interrupt value */
/* Flags: transfer preference, bus mastering, channel speed */
acpi_rs_move_data(aml->extended_irq.interrupt_number,
resource->data.extended_irq.interrupts,
(u16) resource->data.extended_irq.interrupt_count,
ACPI_MOVE_TYPE_32_TO_32);
{ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.transfer),
AML_OFFSET(dma.flags),
0},
/* 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,
&resource->data.
extended_irq.
resource_source);
{ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.type),
AML_OFFSET(dma.flags),
5},
/* Complete the AML descriptor header */
/* DMA channel mask bits */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_EXTENDED_IRQ,
descriptor_length, aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_BITMASK, ACPI_RS_OFFSET(data.dma.channels[0]),
AML_OFFSET(dma.dma_channel_mask),
ACPI_RS_OFFSET(data.dma.channel_count)}
};
drivers/acpi/resources/rslist.c
浏览文件 @ 0897831b
......@@ -48,7 +48,8 @@
ACPI_MODULE_NAME("rslist")
/* 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);
......@@ -83,7 +84,7 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml)
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 =
resource_info->minimum_aml_resource_length;
......@@ -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
*
* 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
* a resource descriptor.
* DESCRIPTION: Get the conversion table associated with this resource type
*
******************************************************************************/
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();
......@@ -174,33 +174,24 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
acpi_status status;
acpi_size bytes_parsed = 0;
struct acpi_resource *resource;
u16 resource_length;
u32 descriptor_length;
ACPI_GET_RESOURCE_HANDLER handler;
acpi_rsdesc_size descriptor_length;
struct acpi_rsconvert_info *info;
ACPI_FUNCTION_TRACE("rs_convert_aml_to_resources");
/* Loop until end-of-buffer or an end_tag is found */
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);
if (!handler) {
/* No handler indicates invalid resource type */
info = acpi_rs_get_conversion_info(*aml_buffer);
if (!info) {
/* No table indicates an invalid resource type */
return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
}
resource_length =
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));
descriptor_length = acpi_ut_get_descriptor_length(aml_buffer);
/*
* Perform limited validation of the resource length, based upon
......@@ -214,11 +205,16 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
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),
resource_length,
ACPI_CAST_PTR(struct acpi_resource, buffer));
status =
acpi_rs_convert_aml_to_resource(ACPI_CAST_PTR
(struct acpi_resource,
buffer),
ACPI_CAST_PTR(union
aml_resource,
aml_buffer),
info);
if (ACPI_FAILURE(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);
......@@ -232,7 +228,7 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
/* 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) {
return_ACPI_STATUS(AE_OK);
}
......@@ -276,14 +272,15 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
acpi_size aml_size_needed, u8 * output_buffer)
{
u8 *aml_buffer = output_buffer;
u8 *end_aml_buffer = output_buffer + aml_size_needed;
acpi_status status;
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) {
/* Validate Resource Descriptor Type before dispatch */
while (aml_buffer < end_aml_buffer) {
/* Validate the Resource Type */
if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
......@@ -292,14 +289,14 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
return_ACPI_STATUS(AE_BAD_DATA);
}
/* Perform the conversion per resource type */
/* Perform the conversion */
status =
acpi_gbl_set_resource_dispatch[resource->type] (resource,
ACPI_CAST_PTR
(union
aml_resource,
aml_buffer));
status = acpi_rs_convert_resource_to_aml(resource,
ACPI_CAST_PTR(union
aml_resource,
aml_buffer),
acpi_gbl_set_resource_dispatch
[resource->type]);
if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Could not convert resource (type %X) to AML, %s\n", resource->type, acpi_format_exception(status)));
return_ACPI_STATUS(status);
......@@ -323,18 +320,23 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
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 */
aml_buffer +=
acpi_rs_get_descriptor_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
/*
* Extract the total length of the new descriptor and set the
* aml_buffer to point to the next (output) resource descriptor
*/
aml_buffer += acpi_ut_get_descriptor_length(aml_buffer);
/* Point to the next input resource descriptor */
resource =
ACPI_PTR_ADD(struct acpi_resource, resource,
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")
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_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_rs_convert_memory24
*
******************************************************************************/
acpi_status
acpi_rs_get_memory24(union aml_resource * aml,
u16 aml_resource_length, struct acpi_resource * resource)
{
ACPI_FUNCTION_TRACE("rs_get_memory24");
struct acpi_rsconvert_info acpi_rs_convert_memory24[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY24,
ACPI_RS_SIZE(struct acpi_resource_memory24),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_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 =
(aml->memory24.information & 0x01);
/* Read/Write bit */
{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
* Maximum Base Address
* Address Base Alignment
* Range Length
*/
acpi_rs_move_data(&resource->data.memory24.minimum,
&aml->memory24.minimum, 4, ACPI_MOVE_TYPE_16_TO_32);
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_MEMORY24;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory24);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.memory24.minimum),
AML_OFFSET(memory24.minimum),
4}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_memory24
*
* 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_rs_convert_memory32
*
******************************************************************************/
acpi_status
acpi_rs_set_memory24(struct acpi_resource *resource, union aml_resource *aml)
{
ACPI_FUNCTION_TRACE("rs_set_memory24");
struct acpi_rsconvert_info acpi_rs_convert_memory32[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY32,
ACPI_RS_SIZE(struct acpi_resource_memory32),
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)
(resource->data.memory24.read_write_attribute & 0x01);
/* Read/Write bit */
{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
* Maximum Base Address
* Address Base Alignment
* Range Length
*/
acpi_rs_move_data(&aml->memory24.minimum,
&resource->data.memory24.minimum, 4,
ACPI_MOVE_TYPE_32_TO_16);
/* 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);
}
{ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.memory32.minimum),
AML_OFFSET(memory32.minimum),
4}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_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_rs_convert_fixed_memory32
*
******************************************************************************/
acpi_status
acpi_rs_get_memory32(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
ACPI_FUNCTION_TRACE("rs_get_memory32");
struct acpi_rsconvert_info acpi_rs_convert_fixed_memory32[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_MEMORY32,
ACPI_RS_SIZE(struct acpi_resource_fixed_memory32),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_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 =
(aml->memory32.information & 0x01);
/* Read/Write bit */
{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:
* Minimum Base Address
* Maximum Base Address
* Address Base Alignment
* These fields are contiguous in both the source and destination:
* Base Address
* Range Length
*/
acpi_rs_move_data(&resource->data.memory32.minimum,
&aml->memory32.minimum, 4, ACPI_MOVE_TYPE_32_TO_32);
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_MEMORY32;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory32);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.fixed_memory32.address),
AML_OFFSET(fixed_memory32.address),
2}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_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_rs_get_vendor_small
*
******************************************************************************/
acpi_status
acpi_rs_set_memory32(struct acpi_resource *resource, union aml_resource *aml)
{
ACPI_FUNCTION_TRACE("rs_set_memory32");
/* Set the Information Byte */
struct acpi_rsconvert_info acpi_rs_get_vendor_small[3] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_VENDOR,
ACPI_RS_SIZE(struct acpi_resource_vendor),
ACPI_RSC_TABLE_SIZE(acpi_rs_get_vendor_small)},
aml->memory32.information = (u8)
(resource->data.memory32.read_write_attribute & 0x01);
/* Length of the vendor data (byte count) */
/*
* Set the following contiguous fields in the AML descriptor:
* Minimum Base Address
* 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);
{ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
0,
sizeof(u8)}
,
/* Complete the AML descriptor header */
/* Vendor data */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_MEMORY32,
sizeof(struct aml_resource_memory32), aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
sizeof(struct aml_resource_small_header),
0}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_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_rs_get_vendor_large
*
******************************************************************************/
acpi_status
acpi_rs_get_fixed_memory32(union aml_resource *aml,
u16 aml_resource_length,
struct acpi_resource *resource)
{
ACPI_FUNCTION_TRACE("rs_get_fixed_memory32");
/* Get the Read/Write bit */
struct acpi_rsconvert_info acpi_rs_get_vendor_large[3] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_VENDOR,
ACPI_RS_SIZE(struct acpi_resource_vendor),
ACPI_RSC_TABLE_SIZE(acpi_rs_get_vendor_large)},
resource->data.fixed_memory32.read_write_attribute =
(aml->fixed_memory32.information & 0x01);
/* Length of the vendor data (byte count) */
/*
* Get the following contiguous fields from the AML descriptor:
* Base Address
* 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);
{ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
0,
sizeof(u8)}
,
/* Complete the resource header */
/* Vendor data */
resource->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32;
resource->length =
ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_memory32);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
sizeof(struct aml_resource_large_header),
0}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_fixed_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_rs_set_vendor
*
******************************************************************************/
acpi_status
acpi_rs_set_fixed_memory32(struct acpi_resource *resource,
union aml_resource *aml)
{
ACPI_FUNCTION_TRACE("rs_set_fixed_memory32");
struct acpi_rsconvert_info acpi_rs_set_vendor[7] = {
/* Default is a small vendor descriptor */
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_VENDOR_SMALL,
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)
(resource->data.fixed_memory32.read_write_attribute & 0x01);
{ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
sizeof(struct aml_resource_small_header),
0},
/*
* Set the following contiguous fields in the AML descriptor:
* Base Address
* Range Length
* All done if the Vendor byte length is 7 or less, meaning that it will
* fit within a small descriptor
*/
ACPI_MOVE_32_TO_32(&aml->fixed_memory32.address,
&resource->data.fixed_memory32.address);
ACPI_MOVE_32_TO_32(&aml->fixed_memory32.address_length,
&resource->data.fixed_memory32.address_length);
/* Complete the AML descriptor header */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_FIXED_MEMORY32,
sizeof(struct aml_resource_fixed_memory32),
aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_EXIT_LE, 0, 0, 7},
/* Must create a large vendor descriptor */
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_VENDOR_LARGE,
sizeof(struct aml_resource_large_header),
0},
{ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
0,
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 @@
#define _COMPONENT ACPI_RESOURCES
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
......@@ -64,6 +122,7 @@ ACPI_MODULE_NAME("rsutils")
* via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
*
******************************************************************************/
void
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++) {
switch (move_type) {
case ACPI_MOVE_TYPE_16_TO_32:
ACPI_MOVE_16_TO_32(&((u32 *) destination)[i],
&((u16 *) source)[i]);
break;
/*
* For the 8-bit case, we can perform the move all at once
* since there are no alignment or endian issues
*/
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],
&((u32 *) source)[i]);
/*
* 16-, 32-, and 64-bit cases must use the move macros that perform
* 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;
case ACPI_MOVE_TYPE_32_TO_32:
case ACPI_RSC_MOVE32:
ACPI_MOVE_32_TO_32(&((u32 *) destination)[i],
&((u32 *) source)[i]);
break;
case ACPI_MOVE_TYPE_64_TO_64:
case ACPI_RSC_MOVE64:
ACPI_MOVE_64_TO_64(&((u64 *) destination)[i],
&((u64 *) source)[i]);
break;
......@@ -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
* definition, this does not include the size of the descriptor
* header or the length field itself.
* DESCRIPTION: Set the resource_length field of an AML
* resource descriptor, both Large and Small descriptors are
* 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();
/* 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 */
ACPI_MOVE_16_TO_16(&resource_length,
&aml->large_header.resource_length);
resource_length = (acpi_rs_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 {
/* Small Resource type -- bits 2:0 of byte 0 contain the length */
resource_length = (u16) (aml->small_header.descriptor_type &
ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
}
return (resource_length);
}
resource_length = (acpi_rs_length)
(total_length - sizeof(struct aml_resource_small_header));
/*******************************************************************************
*
* 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 */
/* Insert length into the descriptor type byte */
ACPI_MOVE_16_TO_32(&descriptor_length,
&aml->large_header.resource_length);
descriptor_length += sizeof(struct aml_resource_large_header);
aml->small_header.descriptor_type = (u8)
} else {
/* Small Resource type -- bits 2:0 of byte 0 contain the length */
/* Clear any existing length, preserving descriptor type bits */
((aml->small_header.
descriptor_type & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
descriptor_length = (u32) (aml->small_header.descriptor_type &
ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
descriptor_length += sizeof(struct aml_resource_small_header);
| resource_length);
}
return (descriptor_length);
}
/*******************************************************************************
......@@ -243,71 +287,18 @@ u32 acpi_rs_get_descriptor_length(union aml_resource * aml)
void
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();
/* Set the descriptor type */
/* Set the Descriptor Type */
aml->small_header.descriptor_type = descriptor_type;
/* Determine if this is a small or large resource */
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();
/* Set the Resource Length */
/* Determine if this is a small or large resource */
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));
}
acpi_rs_set_resource_length(total_length, aml);
}
/*******************************************************************************
......@@ -360,13 +351,13 @@ static u16 acpi_rs_strcpy(char *destination, char *source)
*
******************************************************************************/
u16
acpi_rs_get_resource_source(u16 resource_length,
acpi_size minimum_length,
acpi_rs_length
acpi_rs_get_resource_source(acpi_rs_length resource_length,
acpi_rs_length minimum_length,
struct acpi_resource_source * resource_source,
union aml_resource * aml, char *string_ptr)
{
acpi_size total_length;
acpi_rsdesc_size total_length;
u8 *aml_resource_source;
ACPI_FUNCTION_ENTRY();
......@@ -382,7 +373,7 @@ acpi_rs_get_resource_source(u16 resource_length,
* Note: Some resource descriptors will have an additional null, so
* 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 */
resource_source->index = aml_resource_source[0];
......@@ -398,20 +389,26 @@ acpi_rs_get_resource_source(u16 resource_length,
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 */
resource_source->string_length =
acpi_rs_strcpy(resource_source->string_ptr,
(char *)&aml_resource_source[1]);
/*
* 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));
return ((acpi_rs_length) total_length);
} else {
/* resource_source is not present */
......@@ -434,18 +431,18 @@ acpi_rs_get_resource_source(u16 resource_length,
*
* 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
*
******************************************************************************/
acpi_size
acpi_rsdesc_size
acpi_rs_set_resource_source(union aml_resource * aml,
acpi_size minimum_length,
acpi_rs_length minimum_length,
struct acpi_resource_source * resource_source)
{
u8 *aml_resource_source;
acpi_size descriptor_length;
acpi_rsdesc_size descriptor_length;
ACPI_FUNCTION_ENTRY();
......@@ -472,7 +469,7 @@ acpi_rs_set_resource_source(union aml_resource * aml,
* final 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 */
......
drivers/acpi/resources/rsxface.c
浏览文件 @ 0897831b
......@@ -57,7 +57,7 @@ ACPI_MODULE_NAME("rsxface")
ACPI_COPY_FIELD(out, in, decode); \
ACPI_COPY_FIELD(out, in, min_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, minimum); \
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)
new_table_desc->pointer->length)
&&
(!ACPI_MEMCMP
((const char *)table_desc->pointer,
(const char *)new_table_desc->pointer,
(acpi_size) new_table_desc->pointer->length))) {
(table_desc->pointer, new_table_desc->pointer,
new_table_desc->pointer->length))) {
/* Match: this table is already installed */
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)
if (!num_outstanding) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"No outstanding allocations.\n"));
"No outstanding allocations\n"));
} else {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"%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] = {
* 2) _TZ_ is defined to be a thermal zone in order to allow ASL code to
* perform a Notify() operation on it.
*/
const struct acpi_predefined_names acpi_gbl_pre_defined_names[] =
{ {"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_SB_", ACPI_TYPE_DEVICE, NULL},
{"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_TZ_", ACPI_TYPE_THERMAL, NULL},
{"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL},
{"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
{"_GL_", ACPI_TYPE_MUTEX, (char *)1},
const struct acpi_predefined_names acpi_gbl_pre_defined_names[] = {
{"_GPE", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_PR_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_SB_", ACPI_TYPE_DEVICE, NULL},
{"_SI_", ACPI_TYPE_LOCAL_SCOPE, NULL},
{"_TZ_", ACPI_TYPE_THERMAL, NULL},
{"_REV", ACPI_TYPE_INTEGER, (char *)ACPI_CA_SUPPORT_LEVEL},
{"_OS_", ACPI_TYPE_STRING, ACPI_OS_NAME},
{"_GL_", ACPI_TYPE_MUTEX, (char *)1},
#if !defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY)
{"_OSI", ACPI_TYPE_METHOD, (char *)1},
{"_OSI", ACPI_TYPE_METHOD, (char *)1},
#endif
/* Table terminator */
{NULL, ACPI_TYPE_ANY, NULL}
{NULL, ACPI_TYPE_ANY, NULL}
};
/*
......@@ -503,11 +503,13 @@ char *acpi_ut_get_region_name(u8 space_id)
/* Event type decoding */
static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = {
/*! [Begin] no source code translation (keep these strings as-is) */
"PM_Timer",
"global_lock",
"power_button",
"sleep_button",
"real_time_clock",
"GlobalLock",
"PowerButton",
"SleepButton",
"RealTimeClock",
/*! [End] no source code translation !*/
};
char *acpi_ut_get_event_name(u32 event_id)
......@@ -545,12 +547,13 @@ static const char acpi_gbl_bad_type[] = "UNDEFINED";
/* Printable names of the ACPI object types */
static const char *acpi_gbl_ns_type_names[] = {
/*! [Begin] no source code translation (keep these strings as-is) */
/* 00 */ "Untyped",
/* 01 */ "Integer",
/* 02 */ "String",
/* 03 */ "Buffer",
/* 04 */ "Package",
/* 05 */ "field_unit",
/* 05 */ "FieldUnit",
/* 06 */ "Device",
/* 07 */ "Event",
/* 08 */ "Method",
......@@ -559,23 +562,24 @@ static const char *acpi_gbl_ns_type_names[] = {
/* 11 */ "Power",
/* 12 */ "Processor",
/* 13 */ "Thermal",
/* 14 */ "buffer_field",
/* 15 */ "ddb_handle",
/* 16 */ "debug_object",
/* 17 */ "region_field",
/* 18 */ "bank_field",
/* 19 */ "index_field",
/* 14 */ "BufferField",
/* 15 */ "DdbHandle",
/* 16 */ "DebugObject",
/* 17 */ "RegionField",
/* 18 */ "BankField",
/* 19 */ "IndexField",
/* 20 */ "Reference",
/* 21 */ "Alias",
/* 22 */ "method_alias",
/* 22 */ "MethodAlias",
/* 23 */ "Notify",
/* 24 */ "addr_handler",
/* 25 */ "resource_desc",
/* 26 */ "resource_fld",
/* 24 */ "AddrHandler",
/* 25 */ "ResourceDesc",
/* 26 */ "ResourceFld",
/* 27 */ "Scope",
/* 28 */ "Extra",
/* 29 */ "Data",
/* 30 */ "Invalid"
/*! [End] no source code translation !*/
};
char *acpi_ut_get_type_name(acpi_object_type type)
......@@ -658,15 +662,16 @@ char *acpi_ut_get_node_name(void *object)
/* Printable names of object descriptor types */
static const char *acpi_gbl_desc_type_names[] = {
/*! [Begin] no source code translation (keep these ASL Keywords as-is) */
/* 00 */ "Invalid",
/* 01 */ "Cached",
/* 02 */ "State-Generic",
/* 03 */ "State-Update",
/* 04 */ "State-Package",
/* 05 */ "State-Control",
/* 06 */ "State-root_parse_scope",
/* 07 */ "State-parse_scope",
/* 08 */ "State-walk_scope",
/* 06 */ "State-RootParseScope",
/* 07 */ "State-ParseScope",
/* 08 */ "State-WalkScope",
/* 09 */ "State-Result",
/* 10 */ "State-Notify",
/* 11 */ "State-Thread",
......@@ -674,6 +679,7 @@ static const char *acpi_gbl_desc_type_names[] = {
/* 13 */ "Parser",
/* 14 */ "Operand",
/* 15 */ "Node"
/*! [End] no source code translation !*/
};
char *acpi_ut_get_descriptor_name(void *object)
......
drivers/acpi/utilities/utmisc.c
浏览文件 @ 0897831b
......@@ -43,6 +43,7 @@
#include <acpi/acpi.h>
#include <acpi/acnamesp.h>
#include <acpi/amlresrc.h>
#define _COMPONENT ACPI_UTILITIES
ACPI_MODULE_NAME("utmisc")
......@@ -788,6 +789,113 @@ u8 acpi_ut_generate_checksum(u8 * buffer, u32 length)
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
......@@ -796,42 +904,34 @@ u8 acpi_ut_generate_checksum(u8 * buffer, u32 length)
*
* 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 buffer_byte;
u8 *buffer;
u8 *end_buffer;
buffer = obj_desc->buffer.pointer;
end_buffer = buffer + obj_desc->buffer.length;
u8 *aml;
u8 *end_aml;
while (buffer < end_buffer) {
buffer_byte = *buffer;
if (buffer_byte & ACPI_RESOURCE_NAME_LARGE) {
/* Large Descriptor - Length is next 2 bytes */
aml = obj_desc->buffer.pointer;
end_aml = aml + obj_desc->buffer.length;
buffer += ((*(buffer + 1) | (*(buffer + 2) << 8)) + 3);
} else {
/* Small Descriptor. End Tag will be found here */
/* Walk the resource template, one descriptor per loop */
if ((buffer_byte & ACPI_RESOURCE_NAME_SMALL_MASK) ==
ACPI_RESOURCE_NAME_END_TAG) {
/* Found the end tag descriptor, all done. */
while (aml < end_aml) {
if (acpi_ut_get_resource_type(aml) ==
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);
}
......
drivers/pnp/pnpacpi/rsparser.c
浏览文件 @ 0897831b
......@@ -401,7 +401,7 @@ pnpacpi_parse_mem24_option(struct pnp_option *option,
mem->align = p->alignment;
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;
pnp_register_mem_resource(option,mem);
......@@ -424,7 +424,7 @@ pnpacpi_parse_mem32_option(struct pnp_option *option,
mem->align = p->alignment;
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;
pnp_register_mem_resource(option,mem);
......@@ -446,7 +446,7 @@ pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
mem->size = p->address_length;
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;
pnp_register_mem_resource(option,mem);
......@@ -734,7 +734,7 @@ static void pnpacpi_encode_mem24(struct acpi_resource *resource,
resource->type = ACPI_RESOURCE_TYPE_MEMORY24;
resource->length = sizeof(struct acpi_resource);
/* 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) ?
ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
resource->data.memory24.minimum = p->start;
......@@ -748,7 +748,7 @@ static void pnpacpi_encode_mem32(struct acpi_resource *resource,
{
resource->type = ACPI_RESOURCE_TYPE_MEMORY32;
resource->length = sizeof(struct acpi_resource);
resource->data.memory32.read_write_attribute =
resource->data.memory32.write_protect =
(p->flags & IORESOURCE_MEM_WRITEABLE) ?
ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
resource->data.memory32.minimum = p->start;
......@@ -762,7 +762,7 @@ static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
{
resource->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32;
resource->length = sizeof(struct acpi_resource);
resource->data.fixed_memory32.read_write_attribute =
resource->data.fixed_memory32.write_protect =
(p->flags & IORESOURCE_MEM_WRITEABLE) ?
ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
resource->data.fixed_memory32.address = p->start;
......
include/acpi/acconfig.h
浏览文件 @ 0897831b
......@@ -63,7 +63,7 @@
/* 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,
......
include/acpi/acdisasm.h
浏览文件 @ 0897831b
......@@ -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_word_decode[4];
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_max_decode[2];
extern const char *acpi_gbl_DECdecode[2];
......@@ -171,11 +172,19 @@ u8 acpi_dm_is_string_buffer(union acpi_parse_object *op);
/*
* 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
acpi_dm_resource_descriptor(struct acpi_op_walk_info *info,
u8 * byte_data, u32 byte_count);
acpi_dm_resource_template(struct acpi_op_walk_info *info,
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);
......@@ -223,6 +232,8 @@ void
acpi_dm_vendor_large_descriptor(union aml_resource *resource,
u32 length, u32 level);
void acpi_dm_vendor_common(char *name, u8 * byte_data, u32 length, u32 level);
/*
* dmresrcs
*/
......
include/acpi/acmacros.h
浏览文件 @ 0897831b
......@@ -202,7 +202,7 @@
#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 */
......@@ -563,11 +563,11 @@
return (_s); })
#define return_UINT8(s) ACPI_DO_WHILE0 ({ \
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); })
#define return_UINT32(s) ACPI_DO_WHILE0 ({ \
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); })
#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);
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
......
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.
先完成此消息的编辑！
想要评论请 注册 或