[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: Bob Moore <robert.moore@intel.com>
Signed-off-by: Len Brown <len.brown@intel.com>
diff --git a/drivers/acpi/resources/rsaddr.c b/drivers/acpi/resources/rsaddr.c
index 6f48ebf..4ac942b 100644
--- a/drivers/acpi/resources/rsaddr.c
+++ b/drivers/acpi/resources/rsaddr.c
@@ -47,171 +47,295 @@
#define _COMPONENT ACPI_RESOURCES
ACPI_MODULE_NAME("rsaddr")
-/* Local prototypes */
-static void
-acpi_rs_decode_general_flags(union acpi_resource_data *resource, u8 flags);
+/*******************************************************************************
+ *
+ * acpi_rs_convert_address16 - All WORD (16-bit) address resources
+ *
+ ******************************************************************************/
+struct acpi_rsconvert_info acpi_rs_convert_address16[5] = {
+ {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS16,
+ ACPI_RS_SIZE(struct acpi_resource_address16),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address16)},
-static u8 acpi_rs_encode_general_flags(union acpi_resource_data *resource);
+ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS16,
+ sizeof(struct aml_resource_address16),
+ 0},
-static void
-acpi_rs_decode_specific_flags(union acpi_resource_data *resource, u8 flags);
+ /* Resource Type, General Flags, and Type-Specific Flags */
-static u8 acpi_rs_encode_specific_flags(union acpi_resource_data *resource);
+ {ACPI_RSC_ADDRESS, 0, 0, 0},
-static void
-acpi_rs_set_address_common(union aml_resource *aml,
- struct acpi_resource *resource);
+ /*
+ * These fields are contiguous in both the source and destination:
+ * Address Granularity
+ * Address Range Minimum
+ * Address Range Maximum
+ * Address Translation Offset
+ * Address Length
+ */
+ {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.address16.granularity),
+ AML_OFFSET(address16.granularity),
+ 5},
-static u8
+ /* Optional resource_source (Index and String) */
+
+ {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address16.resource_source),
+ 0,
+ sizeof(struct aml_resource_address16)}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_address32 - All DWORD (32-bit) address resources
+ *
+ ******************************************************************************/
+
+struct acpi_rsconvert_info acpi_rs_convert_address32[5] = {
+ {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS32,
+ ACPI_RS_SIZE(struct acpi_resource_address32),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address32)},
+
+ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS32,
+ sizeof(struct aml_resource_address32),
+ 0},
+
+ /* Resource Type, General Flags, and Type-Specific Flags */
+
+ {ACPI_RSC_ADDRESS, 0, 0, 0},
+
+ /*
+ * These fields are contiguous in both the source and destination:
+ * Address Granularity
+ * Address Range Minimum
+ * Address Range Maximum
+ * Address Translation Offset
+ * Address Length
+ */
+ {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.address32.granularity),
+ AML_OFFSET(address32.granularity),
+ 5},
+
+ /* Optional resource_source (Index and String) */
+
+ {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address32.resource_source),
+ 0,
+ sizeof(struct aml_resource_address32)}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_address64 - All QWORD (64-bit) address resources
+ *
+ ******************************************************************************/
+
+struct acpi_rsconvert_info acpi_rs_convert_address64[5] = {
+ {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_ADDRESS64,
+ ACPI_RS_SIZE(struct acpi_resource_address64),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_address64)},
+
+ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_ADDRESS64,
+ sizeof(struct aml_resource_address64),
+ 0},
+
+ /* Resource Type, General Flags, and Type-Specific Flags */
+
+ {ACPI_RSC_ADDRESS, 0, 0, 0},
+
+ /*
+ * These fields are contiguous in both the source and destination:
+ * Address Granularity
+ * Address Range Minimum
+ * Address Range Maximum
+ * Address Translation Offset
+ * Address Length
+ */
+ {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.address64.granularity),
+ AML_OFFSET(address64.granularity),
+ 5},
+
+ /* Optional resource_source (Index and String) */
+
+ {ACPI_RSC_SOURCE, ACPI_RS_OFFSET(data.address64.resource_source),
+ 0,
+ sizeof(struct aml_resource_address64)}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_ext_address64 - All Extended (64-bit) address resources
+ *
+ ******************************************************************************/
+
+struct acpi_rsconvert_info acpi_rs_convert_ext_address64[5] = {
+ {ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64,
+ ACPI_RS_SIZE(struct acpi_resource_extended_address64),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_ext_address64)},
+
+ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
+ sizeof(struct aml_resource_extended_address64),
+ 0},
+
+ /* Resource Type, General Flags, and Type-Specific Flags */
+
+ {ACPI_RSC_ADDRESS, 0, 0, 0},
+
+ /* Revision ID */
+
+ {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.ext_address64.revision_iD),
+ AML_OFFSET(ext_address64.revision_iD),
+ 1},
+ /*
+ * These fields are contiguous in both the source and destination:
+ * Address Granularity
+ * Address Range Minimum
+ * Address Range Maximum
+ * Address Translation Offset
+ * Address Length
+ * Type-Specific Attribute
+ */
+ {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.ext_address64.granularity),
+ AML_OFFSET(ext_address64.granularity),
+ 6}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_general_flags - Flags common to all address descriptors
+ *
+ ******************************************************************************/
+
+static struct acpi_rsconvert_info acpi_rs_convert_general_flags[6] = {
+ {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.flags),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_general_flags)},
+
+ /* Resource Type (Memory, Io, bus_number, etc.) */
+
+ {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.address.resource_type),
+ AML_OFFSET(address.resource_type),
+ 1},
+
+ /* General Flags - Consume, Decode, min_fixed, max_fixed */
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.producer_consumer),
+ AML_OFFSET(address.flags),
+ 0},
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.decode),
+ AML_OFFSET(address.flags),
+ 1},
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.min_address_fixed),
+ AML_OFFSET(address.flags),
+ 2},
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.max_address_fixed),
+ AML_OFFSET(address.flags),
+ 3}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_mem_flags - Flags common to Memory address descriptors
+ *
+ ******************************************************************************/
+
+static struct acpi_rsconvert_info acpi_rs_convert_mem_flags[5] = {
+ {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_mem_flags)},
+
+ /* Memory-specific flags */
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.write_protect),
+ AML_OFFSET(address.specific_flags),
+ 0},
+
+ {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.caching),
+ AML_OFFSET(address.specific_flags),
+ 1},
+
+ {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.range_type),
+ AML_OFFSET(address.specific_flags),
+ 3},
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.mem.translation),
+ AML_OFFSET(address.specific_flags),
+ 5}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_io_flags - Flags common to I/O address descriptors
+ *
+ ******************************************************************************/
+
+static struct acpi_rsconvert_info acpi_rs_convert_io_flags[4] = {
+ {ACPI_RSC_FLAGINIT, 0, AML_OFFSET(address.specific_flags),
+ ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io_flags)},
+
+ /* I/O-specific flags */
+
+ {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.address.info.io.range_type),
+ AML_OFFSET(address.specific_flags),
+ 0},
+
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.address.info.io.translation),
+ AML_OFFSET(address.specific_flags),
+ 4},
+
+ {ACPI_RSC_1BITFLAG,
+ ACPI_RS_OFFSET(data.address.info.io.translation_type),
+ AML_OFFSET(address.specific_flags),
+ 5}
+};
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_get_address_common
+ *
+ * PARAMETERS: Resource - Pointer to the internal resource struct
+ * Aml - Pointer to the AML resource descriptor
+ *
+ * RETURN: TRUE if the resource_type field is OK, FALSE otherwise
+ *
+ * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
+ * to an internal resource descriptor
+ *
+ ******************************************************************************/
+
+u8
acpi_rs_get_address_common(struct acpi_resource *resource,
- union aml_resource *aml);
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_decode_general_flags
- *
- * PARAMETERS: Resource - Address resource data struct
- * Flags - Raw AML flag byte
- *
- * RETURN: Decoded flag bits in resource struct
- *
- * DESCRIPTION: Decode a general flag byte to an address resource struct
- *
- ******************************************************************************/
-
-static void
-acpi_rs_decode_general_flags(union acpi_resource_data *resource, u8 flags)
+ union aml_resource *aml)
{
ACPI_FUNCTION_ENTRY();
- /* Producer / Consumer - flag bit[0] */
+ /* Validate the Resource Type */
- resource->address.producer_consumer = (u32) (flags & 0x01);
-
- /* Decode (_DEC) - flag bit[1] */
-
- resource->address.decode = (u32) ((flags >> 1) & 0x01);
-
- /* Min Address Fixed (_MIF) - flag bit[2] */
-
- resource->address.min_address_fixed = (u32) ((flags >> 2) & 0x01);
-
- /* Max Address Fixed (_MAF) - flag bit[3] */
-
- resource->address.max_address_fixed = (u32) ((flags >> 3) & 0x01);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_encode_general_flags
- *
- * PARAMETERS: Resource - Address resource data struct
- *
- * RETURN: Encoded general flag byte
- *
- * DESCRIPTION: Construct a general flag byte from an address resource struct
- *
- ******************************************************************************/
-
-static u8 acpi_rs_encode_general_flags(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- return ((u8)
-
- /* Producer / Consumer - flag bit[0] */
- ((resource->address.producer_consumer & 0x01) |
- /* Decode (_DEC) - flag bit[1] */
- ((resource->address.decode & 0x01) << 1) |
- /* Min Address Fixed (_MIF) - flag bit[2] */
- ((resource->address.min_address_fixed & 0x01) << 2) |
- /* Max Address Fixed (_MAF) - flag bit[3] */
- ((resource->address.max_address_fixed & 0x01) << 3))
- );
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_decode_specific_flags
- *
- * PARAMETERS: Resource - Address resource data struct
- * Flags - Raw AML flag byte
- *
- * RETURN: Decoded flag bits in attribute struct
- *
- * DESCRIPTION: Decode a type-specific flag byte to an attribute struct.
- * Type-specific flags are only defined for the Memory and IO
- * resource types.
- *
- ******************************************************************************/
-
-static void
-acpi_rs_decode_specific_flags(union acpi_resource_data *resource, u8 flags)
-{
- ACPI_FUNCTION_ENTRY();
-
- if (resource->address.resource_type == ACPI_MEMORY_RANGE) {
- /* Write Status (_RW) - flag bit[0] */
-
- resource->address.attribute.memory.read_write_attribute =
- (u16) (flags & 0x01);
-
- /* Memory Attributes (_MEM) - flag bits[2:1] */
-
- resource->address.attribute.memory.cache_attribute =
- (u16) ((flags >> 1) & 0x03);
- } else if (resource->address.resource_type == ACPI_IO_RANGE) {
- /* Ranges (_RNG) - flag bits[1:0] */
-
- resource->address.attribute.io.range_attribute =
- (u16) (flags & 0x03);
-
- /* Translations (_TTP and _TRS) - flag bits[5:4] */
-
- resource->address.attribute.io.translation_attribute =
- (u16) ((flags >> 4) & 0x03);
- }
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_encode_specific_flags
- *
- * PARAMETERS: Resource - Address resource data struct
- *
- * RETURN: Encoded type-specific flag byte
- *
- * DESCRIPTION: Construct a type-specific flag byte from an attribute struct.
- * Type-specific flags are only defined for the Memory and IO
- * resource types.
- *
- ******************************************************************************/
-
-static u8 acpi_rs_encode_specific_flags(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- if (resource->address.resource_type == ACPI_MEMORY_RANGE) {
- return ((u8)
-
- /* Write Status (_RW) - flag bit[0] */
- ((resource->address.attribute.memory.
- read_write_attribute & 0x01) |
- /* Memory Attributes (_MEM) - flag bits[2:1] */
- ((resource->address.attribute.memory.
- cache_attribute & 0x03) << 1)));
- } else if (resource->address.resource_type == ACPI_IO_RANGE) {
- return ((u8)
-
- /* Ranges (_RNG) - flag bits[1:0] */
- ((resource->address.attribute.io.
- range_attribute & 0x03) |
- /* Translations (_TTP and _TRS) - flag bits[5:4] */
- ((resource->address.attribute.io.
- translation_attribute & 0x03) << 4)));
+ if ((aml->address.resource_type > 2)
+ && (aml->address.resource_type < 0xC0)) {
+ return (FALSE);
}
- return (0);
+ /* Get the Resource Type and General Flags */
+
+ (void)acpi_rs_convert_aml_to_resource(resource, aml,
+ acpi_rs_convert_general_flags);
+
+ /* Get the Type-Specific Flags (Memory and I/O descriptors only) */
+
+ if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
+ (void)acpi_rs_convert_aml_to_resource(resource, aml,
+ acpi_rs_convert_mem_flags);
+ } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
+ (void)acpi_rs_convert_aml_to_resource(resource, aml,
+ acpi_rs_convert_io_flags);
+ } else {
+ /* Generic resource type, just grab the type_specific byte */
+
+ resource->data.address.info.type_specific =
+ aml->address.specific_flags;
+ }
+
+ return (TRUE);
}
/*******************************************************************************
@@ -228,502 +352,29 @@
*
******************************************************************************/
-static void
+void
acpi_rs_set_address_common(union aml_resource *aml,
struct acpi_resource *resource)
{
ACPI_FUNCTION_ENTRY();
- /* Set the Resource Type (Memory, Io, bus_number, etc.) */
+ /* Set the Resource Type and General Flags */
- aml->address.resource_type = (u8) resource->data.address.resource_type;
+ (void)acpi_rs_convert_resource_to_aml(resource, aml,
+ acpi_rs_convert_general_flags);
- /* Set the general flags */
+ /* Set the Type-Specific Flags (Memory and I/O descriptors only) */
- aml->address.flags = acpi_rs_encode_general_flags(&resource->data);
+ if (resource->data.address.resource_type == ACPI_MEMORY_RANGE) {
+ (void)acpi_rs_convert_resource_to_aml(resource, aml,
+ acpi_rs_convert_mem_flags);
+ } else if (resource->data.address.resource_type == ACPI_IO_RANGE) {
+ (void)acpi_rs_convert_resource_to_aml(resource, aml,
+ acpi_rs_convert_io_flags);
+ } else {
+ /* Generic resource type, just copy the type_specific byte */
- /* Set the type-specific flags */
-
- aml->address.specific_flags =
- acpi_rs_encode_specific_flags(&resource->data);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_address_common
- *
- * PARAMETERS: Resource - Pointer to the internal resource struct
- * Aml - Pointer to the AML resource descriptor
- *
- * RETURN: TRUE if the resource_type field is OK, FALSE otherwise
- *
- * DESCRIPTION: Convert common flag fields from a raw AML resource descriptor
- * to an internal resource descriptor
- *
- ******************************************************************************/
-
-static u8
-acpi_rs_get_address_common(struct acpi_resource *resource,
- union aml_resource *aml)
-{
- ACPI_FUNCTION_ENTRY();
-
- /* Validate resource type */
-
- if ((aml->address.resource_type > 2)
- && (aml->address.resource_type < 0xC0)) {
- return (FALSE);
+ aml->address.specific_flags =
+ resource->data.address.info.type_specific;
}
-
- /* Get the Resource Type (Memory, Io, bus_number, etc.) */
-
- resource->data.address.resource_type = aml->address.resource_type;
-
- /* Get the General Flags */
-
- acpi_rs_decode_general_flags(&resource->data, aml->address.flags);
-
- /* Get the Type-Specific Flags */
-
- acpi_rs_decode_specific_flags(&resource->data,
- aml->address.specific_flags);
- return (TRUE);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_address16
- *
- * 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
-acpi_rs_get_address16(union aml_resource * aml,
- u16 aml_resource_length, struct acpi_resource * resource)
-{
- ACPI_FUNCTION_TRACE("rs_get_address16");
-
- /* Get the Resource Type, general flags, and type-specific flags */
-
- if (!acpi_rs_get_address_common(resource, aml)) {
- return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
- }
-
- /*
- * Get the following contiguous fields from the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- */
- acpi_rs_move_data(&resource->data.address16.granularity,
- &aml->address16.granularity, 5,
- ACPI_MOVE_TYPE_16_TO_32);
-
- /* Get the optional resource_source (index and string) */
-
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_address16) +
- acpi_rs_get_resource_source(aml_resource_length,
- sizeof(struct aml_resource_address16),
- &resource->data.address16.
- resource_source, aml, NULL);
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_ADDRESS16;
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_address16
- *
- * 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
-acpi_rs_set_address16(struct acpi_resource *resource, union aml_resource *aml)
-{
- acpi_size descriptor_length;
-
- ACPI_FUNCTION_TRACE("rs_set_address16");
-
- /* Set the Resource Type, General Flags, and Type-Specific Flags */
-
- acpi_rs_set_address_common(aml, resource);
-
- /*
- * Set the following contiguous fields in the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- */
- acpi_rs_move_data(&aml->address16.granularity,
- &resource->data.address16.granularity, 5,
- ACPI_MOVE_TYPE_32_TO_16);
-
- /* Resource Source Index and Resource Source are optional */
-
- descriptor_length = acpi_rs_set_resource_source(aml,
- sizeof(struct
- aml_resource_address16),
- &resource->data.
- address16.
- resource_source);
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_ADDRESS16,
- descriptor_length, aml);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_address32
- *
- * 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
-acpi_rs_get_address32(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
-
- ACPI_FUNCTION_TRACE("rs_get_address32");
-
- /* Get the Resource Type, general flags, and type-specific flags */
-
- if (!acpi_rs_get_address_common(resource, (void *)aml)) {
- return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
- }
-
- /*
- * Get the following contiguous fields from the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- */
- acpi_rs_move_data(&resource->data.address32.granularity,
- &aml->address32.granularity, 5,
- ACPI_MOVE_TYPE_32_TO_32);
-
- /* Get the optional resource_source (index and string) */
-
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_address32) +
- acpi_rs_get_resource_source(aml_resource_length,
- sizeof(struct aml_resource_address32),
- &resource->data.address32.
- resource_source, aml, NULL);
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_ADDRESS32;
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_address32
- *
- * 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
-acpi_rs_set_address32(struct acpi_resource *resource, union aml_resource *aml)
-{
- acpi_size descriptor_length;
-
- ACPI_FUNCTION_TRACE("rs_set_address32");
-
- /* Set the Resource Type, General Flags, and Type-Specific Flags */
-
- acpi_rs_set_address_common(aml, resource);
-
- /*
- * Set the following contiguous fields in the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- */
- acpi_rs_move_data(&aml->address32.granularity,
- &resource->data.address32.granularity, 5,
- ACPI_MOVE_TYPE_32_TO_32);
-
- /* Resource Source Index and Resource Source are optional */
-
- descriptor_length = acpi_rs_set_resource_source(aml,
- sizeof(struct
- aml_resource_address32),
- &resource->data.
- address32.
- resource_source);
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_ADDRESS32,
- descriptor_length, aml);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_address64
- *
- * 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
-acpi_rs_get_address64(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
- ACPI_FUNCTION_TRACE("rs_get_address64");
-
- /* Get the Resource Type, general Flags, and type-specific Flags */
-
- if (!acpi_rs_get_address_common(resource, aml)) {
- return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
- }
-
- /*
- * Get the following contiguous fields from the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- */
- acpi_rs_move_data(&resource->data.address64.granularity,
- &aml->address64.granularity, 5,
- ACPI_MOVE_TYPE_64_TO_64);
-
- /* Get the optional resource_source (index and string) */
-
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_address64) +
- acpi_rs_get_resource_source(aml_resource_length,
- sizeof(struct aml_resource_address64),
- &resource->data.address64.
- resource_source, aml, NULL);
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_ADDRESS64;
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_address64
- *
- * 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
-acpi_rs_set_address64(struct acpi_resource *resource, union aml_resource *aml)
-{
- acpi_size descriptor_length;
-
- ACPI_FUNCTION_TRACE("rs_set_address64");
-
- /* Set the Resource Type, General Flags, and Type-Specific Flags */
-
- acpi_rs_set_address_common(aml, resource);
-
- /*
- * Set the following contiguous fields in the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- */
- acpi_rs_move_data(&aml->address64.granularity,
- &resource->data.address64.granularity, 5,
- ACPI_MOVE_TYPE_64_TO_64);
-
- /* Resource Source Index and Resource Source are optional */
-
- descriptor_length = acpi_rs_set_resource_source(aml,
- sizeof(struct
- aml_resource_address64),
- &resource->data.
- address64.
- resource_source);
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_ADDRESS64,
- descriptor_length, aml);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_ext_address64
- *
- * 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
-acpi_rs_get_ext_address64(union aml_resource *aml,
- u16 aml_resource_length,
- struct acpi_resource *resource)
-{
-
- ACPI_FUNCTION_TRACE("rs_get_ext_address64");
-
- /* Get the Resource Type, general flags, and type-specific flags */
-
- if (!acpi_rs_get_address_common(resource, aml)) {
- return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
- }
-
- /*
- * Get and validate the Revision ID
- * Note: Only one revision ID is currently supported
- */
- resource->data.ext_address64.revision_iD =
- aml->ext_address64.revision_iD;
- if (aml->ext_address64.revision_iD !=
- AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
- return_ACPI_STATUS(AE_SUPPORT);
- }
-
- /*
- * Get the following contiguous fields from the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- * Type-Specific Attribute
- */
- acpi_rs_move_data(&resource->data.ext_address64.granularity,
- &aml->ext_address64.granularity, 6,
- ACPI_MOVE_TYPE_64_TO_64);
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64;
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_address64);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_ext_address64
- *
- * 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
-acpi_rs_set_ext_address64(struct acpi_resource *resource,
- union aml_resource *aml)
-{
- ACPI_FUNCTION_TRACE("rs_set_ext_address64");
-
- /* Set the Resource Type, General Flags, and Type-Specific Flags */
-
- acpi_rs_set_address_common(aml, resource);
-
- /* Only one Revision ID is currently supported */
-
- aml->ext_address64.revision_iD = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
- aml->ext_address64.reserved = 0;
-
- /*
- * Set the following contiguous fields in the AML descriptor:
- * Address Granularity
- * Address Range Minimum
- * Address Range Maximum
- * Address Translation Offset
- * Address Length
- * Type-Specific Attribute
- */
- acpi_rs_move_data(&aml->ext_address64.granularity,
- &resource->data.address64.granularity, 6,
- ACPI_MOVE_TYPE_64_TO_64);
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64,
- sizeof(struct
- aml_resource_extended_address64),
- aml);
- return_ACPI_STATUS(AE_OK);
}
diff --git a/drivers/acpi/resources/rscalc.c b/drivers/acpi/resources/rscalc.c
index d170dee..c29d3a4 100644
--- a/drivers/acpi/resources/rscalc.c
+++ b/drivers/acpi/resources/rscalc.c
@@ -52,7 +52,7 @@
/* 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 acpi_size
+static acpi_rs_length
acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
{
ACPI_FUNCTION_ENTRY();
@@ -111,7 +111,7 @@
* 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_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 @@
/* 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 @@
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 @@
* 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 @@
* 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 @@
* 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 @@
* 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 @@
* 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 @@
/* Update the total */
- aml_size_needed += segment_size;
+ aml_size_needed += total_size;
/* Point to the next object */
@@ -341,7 +343,7 @@
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 @@
/* 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 */
diff --git a/drivers/acpi/resources/rsdump.c b/drivers/acpi/resources/rsdump.c
index 2f89908..27172a3 100644
--- a/drivers/acpi/resources/rsdump.c
+++ b/drivers/acpi/resources/rsdump.c
@@ -43,6 +43,7 @@
#include <acpi/acpi.h>
#include <acpi/acresrc.h>
+#include <acpi/acdisasm.h>
#define _COMPONENT ACPI_RESOURCES
ACPI_MODULE_NAME("rsdump")
@@ -61,17 +62,621 @@
static void acpi_rs_out_title(char *title);
-static void acpi_rs_dump_byte_list(u32 length, u8 * data);
+static void acpi_rs_dump_byte_list(u16 length, u8 * data);
-static void acpi_rs_dump_dword_list(u32 length, u32 * data);
+static void acpi_rs_dump_dword_list(u8 length, u32 * data);
-static void acpi_rs_dump_short_byte_list(u32 length, u32 * data);
+static void acpi_rs_dump_short_byte_list(u8 length, u8 * data);
static void
acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source);
static void acpi_rs_dump_address_common(union acpi_resource_data *resource);
+static void
+acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table);
+
+#define ACPI_RSD_OFFSET(f) (u8) ACPI_OFFSET (union acpi_resource_data,f)
+#define ACPI_PRT_OFFSET(f) (u8) ACPI_OFFSET (struct acpi_pci_routing_table,f)
+#define ACPI_RSD_TABLE_SIZE(name) (sizeof(name) / sizeof (struct acpi_rsdump_info))
+
+/*******************************************************************************
+ *
+ * Resource Descriptor info tables
+ *
+ * Note: The first table entry must be a Title or Literal and must contain
+ * the table length (number of table entries)
+ *
+ ******************************************************************************/
+
+struct acpi_rsdump_info acpi_rs_dump_irq[6] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_irq), "IRQ", NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(irq.triggering), "Triggering",
+ acpi_gbl_HEdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(irq.polarity), "Polarity",
+ acpi_gbl_LLdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(irq.sharable), "Sharing",
+ acpi_gbl_SHRdecode},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(irq.interrupt_count),
+ "Interrupt Count", NULL},
+ {ACPI_RSD_SHORTLIST, ACPI_RSD_OFFSET(irq.interrupts[0]),
+ "Interrupt List", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_dma[6] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_dma), "DMA", NULL},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(dma.type), "Speed",
+ acpi_gbl_TYPdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(dma.bus_master), "Mastering",
+ acpi_gbl_BMdecode},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(dma.transfer), "Transfer Type",
+ acpi_gbl_SIZdecode},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(dma.channel_count), "Channel Count",
+ NULL},
+ {ACPI_RSD_SHORTLIST, ACPI_RSD_OFFSET(dma.channels[0]), "Channel List",
+ NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_start_dpf[3] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_start_dpf),
+ "Start-Dependent-Functions", NULL},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(start_dpf.compatibility_priority),
+ "Compatibility Priority", acpi_gbl_config_decode},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(start_dpf.performance_robustness),
+ "Performance/Robustness", acpi_gbl_config_decode}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_end_dpf[1] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_end_dpf),
+ "End-Dependent-Functions", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_io[6] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_io), "I/O", NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(io.io_decode), "Address Decoding",
+ acpi_gbl_io_decode},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(io.minimum), "Address Minimum", NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(io.maximum), "Address Maximum", NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(io.alignment), "Alignment", NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(io.address_length), "Address Length",
+ NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_fixed_io[3] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_fixed_io),
+ "Fixed I/O", NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(fixed_io.address), "Address", NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(fixed_io.address_length),
+ "Address Length", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_vendor[3] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_vendor),
+ "Vendor Specific", NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(vendor.byte_length), "Length", NULL},
+ {ACPI_RSD_LONGLIST, ACPI_RSD_OFFSET(vendor.byte_data[0]), "Vendor Data",
+ NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_end_tag[1] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_end_tag), "end_tag",
+ NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_memory24[6] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_memory24),
+ "24-Bit Memory Range", NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(memory24.write_protect),
+ "Write Protect", acpi_gbl_RWdecode},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.minimum), "Address Minimum",
+ NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.maximum), "Address Maximum",
+ NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.alignment), "Alignment",
+ NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(memory24.address_length),
+ "Address Length", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_memory32[6] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_memory32),
+ "32-Bit Memory Range", NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(memory32.write_protect),
+ "Write Protect", acpi_gbl_RWdecode},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.minimum), "Address Minimum",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.maximum), "Address Maximum",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.alignment), "Alignment",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(memory32.address_length),
+ "Address Length", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_fixed_memory32[4] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_fixed_memory32),
+ "32-Bit Fixed Memory Range", NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(fixed_memory32.write_protect),
+ "Write Protect", acpi_gbl_RWdecode},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(fixed_memory32.address), "Address",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(fixed_memory32.address_length),
+ "Address Length", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_address16[8] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_address16),
+ "16-Bit WORD Address Space", NULL},
+ {ACPI_RSD_ADDRESS, 0, NULL, NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.granularity), "Granularity",
+ NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.minimum), "Address Minimum",
+ NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.maximum), "Address Maximum",
+ NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.translation_offset),
+ "Translation Offset", NULL},
+ {ACPI_RSD_UINT16, ACPI_RSD_OFFSET(address16.address_length),
+ "Address Length", NULL},
+ {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(address16.resource_source), NULL, NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_address32[8] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_address32),
+ "32-Bit DWORD Address Space", NULL},
+ {ACPI_RSD_ADDRESS, 0, NULL, NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.granularity), "Granularity",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.minimum), "Address Minimum",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.maximum), "Address Maximum",
+ NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.translation_offset),
+ "Translation Offset", NULL},
+ {ACPI_RSD_UINT32, ACPI_RSD_OFFSET(address32.address_length),
+ "Address Length", NULL},
+ {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(address32.resource_source), NULL, NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_address64[8] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_address64),
+ "64-Bit QWORD Address Space", NULL},
+ {ACPI_RSD_ADDRESS, 0, NULL, NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.granularity), "Granularity",
+ NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.minimum), "Address Minimum",
+ NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.maximum), "Address Maximum",
+ NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.translation_offset),
+ "Translation Offset", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(address64.address_length),
+ "Address Length", NULL},
+ {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(address64.resource_source), NULL, NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_ext_address64[8] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_ext_address64),
+ "64-Bit Extended Address Space", NULL},
+ {ACPI_RSD_ADDRESS, 0, NULL, NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.granularity),
+ "Granularity", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.minimum),
+ "Address Minimum", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.maximum),
+ "Address Maximum", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.translation_offset),
+ "Translation Offset", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.address_length),
+ "Address Length", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(ext_address64.type_specific),
+ "Type-Specific Attribute", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_ext_irq[8] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_ext_irq),
+ "Extended IRQ", NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.producer_consumer),
+ "Type", acpi_gbl_consume_decode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.triggering),
+ "Triggering", acpi_gbl_HEdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.polarity), "Polarity",
+ acpi_gbl_LLdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(extended_irq.sharable), "Sharing",
+ acpi_gbl_SHRdecode},
+ {ACPI_RSD_SOURCE, ACPI_RSD_OFFSET(extended_irq.resource_source), NULL,
+ NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(extended_irq.interrupt_count),
+ "Interrupt Count", NULL},
+ {ACPI_RSD_DWORDLIST, ACPI_RSD_OFFSET(extended_irq.interrupts[0]),
+ "Interrupt List", NULL}
+};
+
+struct acpi_rsdump_info acpi_rs_dump_generic_reg[6] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_generic_reg),
+ "Generic Register", NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.space_id), "Space ID",
+ NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.bit_width), "Bit Width",
+ NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.bit_offset), "Bit Offset",
+ NULL},
+ {ACPI_RSD_UINT8, ACPI_RSD_OFFSET(generic_reg.access_size),
+ "Access Size", NULL},
+ {ACPI_RSD_UINT64, ACPI_RSD_OFFSET(generic_reg.address), "Address", NULL}
+};
+
+/*
+ * Tables used for common address descriptor flag fields
+ */
+static struct acpi_rsdump_info acpi_rs_dump_general_flags[5] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_general_flags), NULL,
+ NULL},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.producer_consumer),
+ "Consumer/Producer", acpi_gbl_consume_decode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.decode), "Address Decode",
+ acpi_gbl_DECdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.min_address_fixed),
+ "Min Relocatability", acpi_gbl_min_decode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.max_address_fixed),
+ "Max Relocatability", acpi_gbl_max_decode}
+};
+
+static struct acpi_rsdump_info acpi_rs_dump_memory_flags[5] = {
+ {ACPI_RSD_LITERAL, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_memory_flags),
+ "Resource Type", "Memory Range"},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.mem.write_protect),
+ "Write Protect", acpi_gbl_RWdecode},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(address.info.mem.caching),
+ "Caching", acpi_gbl_MEMdecode},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(address.info.mem.range_type),
+ "Range Type", acpi_gbl_MTPdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.mem.translation),
+ "Translation", acpi_gbl_TTPdecode}
+};
+
+static struct acpi_rsdump_info acpi_rs_dump_io_flags[4] = {
+ {ACPI_RSD_LITERAL, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_io_flags),
+ "Resource Type", "I/O Range"},
+ {ACPI_RSD_2BITFLAG, ACPI_RSD_OFFSET(address.info.io.range_type),
+ "Range Type", acpi_gbl_RNGdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.io.translation),
+ "Translation", acpi_gbl_TTPdecode},
+ {ACPI_RSD_1BITFLAG, ACPI_RSD_OFFSET(address.info.io.translation_type),
+ "Translation Type", acpi_gbl_TRSdecode}
+};
+
+/*
+ * Table used to dump _PRT contents
+ */
+static struct acpi_rsdump_info acpi_rs_dump_prt[5] = {
+ {ACPI_RSD_TITLE, ACPI_RSD_TABLE_SIZE(acpi_rs_dump_prt), NULL, NULL},
+ {ACPI_RSD_UINT64, ACPI_PRT_OFFSET(address), "Address", NULL},
+ {ACPI_RSD_UINT32, ACPI_PRT_OFFSET(pin), "Pin", NULL},
+ {ACPI_RSD_STRING, ACPI_PRT_OFFSET(source[0]), "Source", NULL},
+ {ACPI_RSD_UINT32, ACPI_PRT_OFFSET(source_index), "Source Index", NULL}
+};
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_dump_descriptor
+ *
+ * PARAMETERS: Resource
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION:
+ *
+ ******************************************************************************/
+
+static void
+acpi_rs_dump_descriptor(void *resource, struct acpi_rsdump_info *table)
+{
+ void *target = NULL;
+ void *previous_target;
+ char *name;
+ u8 count;
+
+ /* First table entry must contain the table length (# of table entries) */
+
+ count = table->offset;
+
+ while (count) {
+ previous_target = target;
+ target = ((u8 *) resource) + table->offset;
+ name = table->name;
+
+ switch (table->opcode) {
+ case ACPI_RSD_TITLE:
+ /*
+ * Optional resource title
+ */
+ if (table->name) {
+ acpi_os_printf("%s Resource\n", name);
+ }
+ break;
+
+ /* Strings */
+
+ case ACPI_RSD_LITERAL:
+ acpi_rs_out_string(name, (char *)table->pointer);
+ break;
+
+ case ACPI_RSD_STRING:
+ acpi_rs_out_string(name, (char *)target);
+ break;
+
+ /* Data items, 8/16/32/64 bit */
+
+ case ACPI_RSD_UINT8:
+ acpi_rs_out_integer8(name, *(u8 *) target);
+ break;
+
+ case ACPI_RSD_UINT16:
+ acpi_rs_out_integer16(name, *(u16 *) target);
+ break;
+
+ case ACPI_RSD_UINT32:
+ acpi_rs_out_integer32(name, *(u32 *) target);
+ break;
+
+ case ACPI_RSD_UINT64:
+ acpi_rs_out_integer64(name, *(u64 *) target);
+ break;
+
+ /* Flags: 1-bit and 2-bit flags supported */
+
+ case ACPI_RSD_1BITFLAG:
+ acpi_rs_out_string(name, (char *)
+ ((const char **)table->
+ pointer)[(*(u8 *) target) & 0x01]);
+ break;
+
+ case ACPI_RSD_2BITFLAG:
+ acpi_rs_out_string(name, (char *)
+ ((const char **)table->
+ pointer)[(*(u8 *) target) & 0x03]);
+ break;
+
+ case ACPI_RSD_SHORTLIST:
+ /*
+ * Short byte list (single line output) for DMA and IRQ resources
+ * Note: The list length is obtained from the previous table entry
+ */
+ if (previous_target) {
+ acpi_rs_out_title(name);
+ acpi_rs_dump_short_byte_list(*
+ ((u8 *)
+ previous_target),
+ (u8 *) target);
+ }
+ break;
+
+ case ACPI_RSD_LONGLIST:
+ /*
+ * Long byte list for Vendor resource data
+ * Note: The list length is obtained from the previous table entry
+ */
+ if (previous_target) {
+ acpi_rs_dump_byte_list(*
+ ((u16 *)
+ previous_target),
+ (u8 *) target);
+ }
+ break;
+
+ case ACPI_RSD_DWORDLIST:
+ /*
+ * Dword list for Extended Interrupt resources
+ * Note: The list length is obtained from the previous table entry
+ */
+ if (previous_target) {
+ acpi_rs_dump_dword_list(*
+ ((u8 *)
+ previous_target),
+ (u32 *) target);
+ }
+ break;
+
+ case ACPI_RSD_ADDRESS:
+ /*
+ * Common flags for all Address resources
+ */
+ acpi_rs_dump_address_common((union acpi_resource_data *)
+ target);
+ break;
+
+ case ACPI_RSD_SOURCE:
+ /*
+ * Optional resource_source for Address resources
+ */
+ acpi_rs_dump_resource_source((struct
+ acpi_resource_source *)
+ target);
+ break;
+
+ default:
+ acpi_os_printf("**** Invalid table opcode [%X] ****\n",
+ table->opcode);
+ return;
+ }
+
+ table++;
+ count--;
+ }
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_dump_resource_source
+ *
+ * PARAMETERS: resource_source - Pointer to a Resource Source struct
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Common routine for dumping the optional resource_source and the
+ * corresponding resource_source_index.
+ *
+ ******************************************************************************/
+
+static void
+acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source)
+{
+ ACPI_FUNCTION_ENTRY();
+
+ if (resource_source->index == 0xFF) {
+ return;
+ }
+
+ acpi_rs_out_integer8("Resource Source Index", resource_source->index);
+
+ acpi_rs_out_string("Resource Source",
+ resource_source->string_ptr ?
+ resource_source->string_ptr : "[Not Specified]");
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_dump_address_common
+ *
+ * PARAMETERS: Resource - Pointer to an internal resource descriptor
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Dump the fields that are common to all Address resource
+ * descriptors
+ *
+ ******************************************************************************/
+
+static void acpi_rs_dump_address_common(union acpi_resource_data *resource)
+{
+ ACPI_FUNCTION_ENTRY();
+
+ /* Decode the type-specific flags */
+
+ switch (resource->address.resource_type) {
+ case ACPI_MEMORY_RANGE:
+
+ acpi_rs_dump_descriptor(resource, acpi_rs_dump_memory_flags);
+ break;
+
+ case ACPI_IO_RANGE:
+
+ acpi_rs_dump_descriptor(resource, acpi_rs_dump_io_flags);
+ break;
+
+ case ACPI_BUS_NUMBER_RANGE:
+
+ acpi_rs_out_string("Resource Type", "Bus Number Range");
+ break;
+
+ default:
+
+ acpi_rs_out_integer8("Resource Type",
+ (u8) resource->address.resource_type);
+ break;
+ }
+
+ /* Decode the general flags */
+
+ acpi_rs_dump_descriptor(resource, acpi_rs_dump_general_flags);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_dump_resource_list
+ *
+ * PARAMETERS: resource_list - Pointer to a resource descriptor list
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Dispatches the structure to the correct dump routine.
+ *
+ ******************************************************************************/
+
+void acpi_rs_dump_resource_list(struct acpi_resource *resource_list)
+{
+ u32 count = 0;
+ u32 type;
+
+ ACPI_FUNCTION_ENTRY();
+
+ if (!(acpi_dbg_level & ACPI_LV_RESOURCES)
+ || !(_COMPONENT & acpi_dbg_layer)) {
+ return;
+ }
+
+ /* Walk list and dump all resource descriptors (END_TAG terminates) */
+
+ do {
+ acpi_os_printf("\n[%02X] ", count);
+ count++;
+
+ /* Validate Type before dispatch */
+
+ type = resource_list->type;
+ if (type > ACPI_RESOURCE_TYPE_MAX) {
+ acpi_os_printf
+ ("Invalid descriptor type (%X) in resource list\n",
+ resource_list->type);
+ return;
+ }
+
+ /* Dump the resource descriptor */
+
+ acpi_rs_dump_descriptor(&resource_list->data,
+ acpi_gbl_dump_resource_dispatch[type]);
+
+ /* Point to the next resource structure */
+
+ resource_list =
+ ACPI_PTR_ADD(struct acpi_resource, resource_list,
+ resource_list->length);
+
+ /* Exit when END_TAG descriptor is reached */
+
+ } while (type != ACPI_RESOURCE_TYPE_END_TAG);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_dump_irq_list
+ *
+ * PARAMETERS: route_table - Pointer to the routing table to dump.
+ *
+ * RETURN: None
+ *
+ * DESCRIPTION: Print IRQ routing table
+ *
+ ******************************************************************************/
+
+void acpi_rs_dump_irq_list(u8 * route_table)
+{
+ struct acpi_pci_routing_table *prt_element;
+ u8 count;
+
+ ACPI_FUNCTION_ENTRY();
+
+ if (!(acpi_dbg_level & ACPI_LV_RESOURCES)
+ || !(_COMPONENT & acpi_dbg_layer)) {
+ return;
+ }
+
+ prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table, route_table);
+
+ /* Dump all table elements, Exit on zero length element */
+
+ for (count = 0; prt_element->length; count++) {
+ acpi_os_printf("\n[%02X] PCI IRQ Routing Table Package\n",
+ count);
+ acpi_rs_dump_descriptor(prt_element, acpi_rs_dump_prt);
+
+ prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table,
+ ((u8 *) prt_element) +
+ prt_element->length);
+ }
+}
+
/*******************************************************************************
*
* FUNCTION: acpi_rs_out*
@@ -129,27 +734,18 @@
*
******************************************************************************/
-static void acpi_rs_dump_byte_list(u32 length, u8 * data)
+static void acpi_rs_dump_byte_list(u16 length, u8 * data)
{
- u32 i;
+ u8 i;
for (i = 0; i < length; i++) {
acpi_os_printf("%25s%2.2X : %2.2X\n", "Byte", i, data[i]);
}
}
-static void acpi_rs_dump_dword_list(u32 length, u32 * data)
+static void acpi_rs_dump_short_byte_list(u8 length, u8 * data)
{
- u32 i;
-
- for (i = 0; i < length; i++) {
- acpi_os_printf("%25s%2.2X : %8.8X\n", "Dword", i, data[i]);
- }
-}
-
-static void acpi_rs_dump_short_byte_list(u32 length, u32 * data)
-{
- u32 i;
+ u8 i;
for (i = 0; i < length; i++) {
acpi_os_printf("%X ", data[i]);
@@ -157,859 +753,12 @@
acpi_os_printf("\n");
}
-static void acpi_rs_dump_memory_attribute(u32 read_write_attribute)
+static void acpi_rs_dump_dword_list(u8 length, u32 * data)
{
+ u8 i;
- acpi_rs_out_string("Read/Write Attribute",
- ACPI_READ_WRITE_MEMORY == read_write_attribute ?
- "Read/Write" : "Read-Only");
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_resource_source
- *
- * PARAMETERS: resource_source - Pointer to a Resource Source struct
- *
- * RETURN: None
- *
- * DESCRIPTION: Common routine for dumping the optional resource_source and the
- * corresponding resource_source_index.
- *
- ******************************************************************************/
-
-static void
-acpi_rs_dump_resource_source(struct acpi_resource_source *resource_source)
-{
- ACPI_FUNCTION_ENTRY();
-
- if (resource_source->index == 0xFF) {
- return;
- }
-
- acpi_rs_out_integer8("Resource Source Index",
- (u8) resource_source->index);
-
- acpi_rs_out_string("Resource Source",
- resource_source->string_ptr ?
- resource_source->string_ptr : "[Not Specified]");
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_address_common
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the fields that are common to all Address resource
- * descriptors
- *
- ******************************************************************************/
-
-static void acpi_rs_dump_address_common(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- /* Decode the type-specific flags */
-
- switch (resource->address.resource_type) {
- case ACPI_MEMORY_RANGE:
-
- acpi_rs_out_string("Resource Type", "Memory Range");
-
- acpi_rs_out_title("Type-Specific Flags");
-
- switch (resource->address.attribute.memory.cache_attribute) {
- case ACPI_NON_CACHEABLE_MEMORY:
- acpi_os_printf("Noncacheable memory\n");
- break;
-
- case ACPI_CACHABLE_MEMORY:
- acpi_os_printf("Cacheable memory\n");
- break;
-
- case ACPI_WRITE_COMBINING_MEMORY:
- acpi_os_printf("Write-combining memory\n");
- break;
-
- case ACPI_PREFETCHABLE_MEMORY:
- acpi_os_printf("Prefetchable memory\n");
- break;
-
- default:
- acpi_os_printf("Invalid cache attribute\n");
- break;
- }
-
- acpi_rs_dump_memory_attribute(resource->address.attribute.
- memory.read_write_attribute);
- break;
-
- case ACPI_IO_RANGE:
-
- acpi_rs_out_string("Resource Type", "I/O Range");
-
- acpi_rs_out_title("Type-Specific Flags");
-
- switch (resource->address.attribute.io.range_attribute) {
- case ACPI_NON_ISA_ONLY_RANGES:
- acpi_os_printf("Non-ISA I/O Addresses\n");
- break;
-
- case ACPI_ISA_ONLY_RANGES:
- acpi_os_printf("ISA I/O Addresses\n");
- break;
-
- case ACPI_ENTIRE_RANGE:
- acpi_os_printf("ISA and non-ISA I/O Addresses\n");
- break;
-
- default:
- acpi_os_printf("Invalid range attribute\n");
- break;
- }
-
- acpi_rs_out_string("Translation Attribute",
- ACPI_SPARSE_TRANSLATION ==
- resource->address.attribute.io.
- translation_attribute ? "Sparse Translation"
- : "Dense Translation");
- break;
-
- case ACPI_BUS_NUMBER_RANGE:
-
- acpi_rs_out_string("Resource Type", "Bus Number Range");
- break;
-
- default:
-
- acpi_rs_out_integer8("Resource Type",
- (u8) resource->address.resource_type);
- break;
- }
-
- /* Decode the general flags */
-
- acpi_rs_out_string("Resource",
- ACPI_CONSUMER ==
- resource->address.
- producer_consumer ? "Consumer" : "Producer");
-
- acpi_rs_out_string("Decode",
- ACPI_SUB_DECODE == resource->address.decode ?
- "Subtractive" : "Positive");
-
- acpi_rs_out_string("Min Address",
- ACPI_ADDRESS_FIXED ==
- resource->address.
- min_address_fixed ? "Fixed" : "Not Fixed");
-
- acpi_rs_out_string("Max Address",
- ACPI_ADDRESS_FIXED ==
- resource->address.
- max_address_fixed ? "Fixed" : "Not Fixed");
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_resource_list
- *
- * PARAMETERS: resource_list - Pointer to a resource descriptor list
- *
- * RETURN: None
- *
- * DESCRIPTION: Dispatches the structure to the correct dump routine.
- *
- ******************************************************************************/
-
-void acpi_rs_dump_resource_list(struct acpi_resource *resource_list)
-{
- u32 count = 0;
-
- ACPI_FUNCTION_ENTRY();
-
- if (!(acpi_dbg_level & ACPI_LV_RESOURCES)
- || !(_COMPONENT & acpi_dbg_layer)) {
- return;
- }
-
- /* Dump all resource descriptors in the list */
-
- while (resource_list) {
- acpi_os_printf("\n[%02X] ", count);
-
- /* Validate Type before dispatch */
-
- if (resource_list->type > ACPI_RESOURCE_TYPE_MAX) {
- acpi_os_printf
- ("Invalid descriptor type (%X) in resource list\n",
- resource_list->type);
- return;
- }
-
- /* Dump the resource descriptor */
-
- acpi_gbl_dump_resource_dispatch[resource_list->
- type] (&resource_list->data);
-
- /* Exit on end tag */
-
- if (resource_list->type == ACPI_RESOURCE_TYPE_END_TAG) {
- return;
- }
-
- /* Get the next resource structure */
-
- resource_list =
- ACPI_PTR_ADD(struct acpi_resource, resource_list,
- resource_list->length);
- count++;
- }
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_irq
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_irq(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("IRQ Resource\n");
-
- acpi_rs_out_string("Triggering",
- ACPI_LEVEL_SENSITIVE ==
- resource->irq.triggering ? "Level" : "Edge");
-
- acpi_rs_out_string("Active",
- ACPI_ACTIVE_LOW ==
- resource->irq.polarity ? "Low" : "High");
-
- acpi_rs_out_string("Sharing",
- ACPI_SHARED ==
- resource->irq.sharable ? "Shared" : "Exclusive");
-
- acpi_rs_out_integer8("Interrupt Count",
- (u8) resource->irq.interrupt_count);
-
- acpi_rs_out_title("Interrupt List");
- acpi_rs_dump_short_byte_list(resource->irq.interrupt_count,
- resource->irq.interrupts);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_dma
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_dma(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("DMA Resource\n");
-
- acpi_rs_out_title("DMA Type");
- switch (resource->dma.type) {
- case ACPI_COMPATIBILITY:
- acpi_os_printf("Compatibility mode\n");
- break;
-
- case ACPI_TYPE_A:
- acpi_os_printf("Type A\n");
- break;
-
- case ACPI_TYPE_B:
- acpi_os_printf("Type B\n");
- break;
-
- case ACPI_TYPE_F:
- acpi_os_printf("Type F\n");
- break;
-
- default:
- acpi_os_printf("**** Invalid DMA type\n");
- break;
- }
-
- acpi_rs_out_string("Bus Master",
- ACPI_BUS_MASTER ==
- resource->dma.bus_master ? "Yes" : "No");
-
- acpi_rs_out_title("Transfer Type");
- switch (resource->dma.transfer) {
- case ACPI_TRANSFER_8:
- acpi_os_printf("8-bit transfers only\n");
- break;
-
- case ACPI_TRANSFER_8_16:
- acpi_os_printf("8-bit and 16-bit transfers\n");
- break;
-
- case ACPI_TRANSFER_16:
- acpi_os_printf("16-bit transfers only\n");
- break;
-
- default:
- acpi_os_printf("**** Invalid transfer preference\n");
- break;
- }
-
- acpi_rs_out_integer8("DMA Channel Count",
- (u8) resource->dma.channel_count);
-
- acpi_rs_out_title("Channel List");
- acpi_rs_dump_short_byte_list(resource->dma.channel_count,
- resource->dma.channels);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_start_dpf
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_start_dpf(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("Start Dependent Functions Resource\n");
-
- acpi_rs_out_title("Compatibility Priority");
- switch (resource->start_dpf.compatibility_priority) {
- case ACPI_GOOD_CONFIGURATION:
- acpi_os_printf("Good configuration\n");
- break;
-
- case ACPI_ACCEPTABLE_CONFIGURATION:
- acpi_os_printf("Acceptable configuration\n");
- break;
-
- case ACPI_SUB_OPTIMAL_CONFIGURATION:
- acpi_os_printf("Sub-optimal configuration\n");
- break;
-
- default:
- acpi_os_printf("**** Invalid compatibility priority\n");
- break;
- }
-
- acpi_rs_out_title("Performance/Robustness");
- switch (resource->start_dpf.performance_robustness) {
- case ACPI_GOOD_CONFIGURATION:
- acpi_os_printf("Good configuration\n");
- break;
-
- case ACPI_ACCEPTABLE_CONFIGURATION:
- acpi_os_printf("Acceptable configuration\n");
- break;
-
- case ACPI_SUB_OPTIMAL_CONFIGURATION:
- acpi_os_printf("Sub-optimal configuration\n");
- break;
-
- default:
- acpi_os_printf
- ("**** Invalid performance robustness preference\n");
- break;
- }
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_io
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_io(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("I/O Resource\n");
-
- acpi_rs_out_string("Decode",
- ACPI_DECODE_16 ==
- resource->io.io_decode ? "16-bit" : "10-bit");
-
- acpi_rs_out_integer32("Address Minimum", resource->io.minimum);
-
- acpi_rs_out_integer32("Address Maximum", resource->io.maximum);
-
- acpi_rs_out_integer32("Alignment", resource->io.alignment);
-
- acpi_rs_out_integer32("Address Length", resource->io.address_length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_fixed_io
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_fixed_io(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("Fixed I/O Resource\n");
-
- acpi_rs_out_integer32("Address", resource->fixed_io.address);
-
- acpi_rs_out_integer32("Address Length",
- resource->fixed_io.address_length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_vendor
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_vendor(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("Vendor Specific Resource\n");
-
- acpi_rs_out_integer16("Length", (u16) resource->vendor.byte_length);
-
- acpi_rs_dump_byte_list(resource->vendor.byte_length,
- resource->vendor.byte_data);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_memory24
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_memory24(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("24-Bit Memory Range Resource\n");
-
- acpi_rs_dump_memory_attribute(resource->memory24.read_write_attribute);
-
- acpi_rs_out_integer16("Address Minimum",
- (u16) resource->memory24.minimum);
-
- acpi_rs_out_integer16("Address Maximum",
- (u16) resource->memory24.maximum);
-
- acpi_rs_out_integer16("Alignment", (u16) resource->memory24.alignment);
-
- acpi_rs_out_integer16("Address Length",
- (u16) resource->memory24.address_length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_memory32
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_memory32(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("32-Bit Memory Range Resource\n");
-
- acpi_rs_dump_memory_attribute(resource->memory32.read_write_attribute);
-
- acpi_rs_out_integer32("Address Minimum", resource->memory32.minimum);
-
- acpi_rs_out_integer32("Address Maximum", resource->memory32.maximum);
-
- acpi_rs_out_integer32("Alignment", resource->memory32.alignment);
-
- acpi_rs_out_integer32("Address Length",
- resource->memory32.address_length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_fixed_memory32
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN:
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_fixed_memory32(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("32-Bit Fixed Location Memory Range Resource\n");
-
- acpi_rs_dump_memory_attribute(resource->fixed_memory32.
- read_write_attribute);
-
- acpi_rs_out_integer32("Address", resource->fixed_memory32.address);
-
- acpi_rs_out_integer32("Address Length",
- resource->fixed_memory32.address_length);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_address16
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_address16(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("16-Bit WORD Address Space Resource\n");
-
- acpi_rs_dump_address_common(resource);
-
- acpi_rs_out_integer16("Granularity",
- (u16) resource->address16.granularity);
-
- acpi_rs_out_integer16("Address Minimum",
- (u16) resource->address16.minimum);
-
- acpi_rs_out_integer16("Address Maximum",
- (u16) resource->address16.maximum);
-
- acpi_rs_out_integer16("Translation Offset",
- (u16) resource->address16.translation_offset);
-
- acpi_rs_out_integer16("Address Length",
- (u16) resource->address16.address_length);
-
- acpi_rs_dump_resource_source(&resource->address16.resource_source);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_address32
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_address32(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("32-Bit DWORD Address Space Resource\n");
-
- acpi_rs_dump_address_common(resource);
-
- acpi_rs_out_integer32("Granularity", resource->address32.granularity);
-
- acpi_rs_out_integer32("Address Minimum", resource->address32.minimum);
-
- acpi_rs_out_integer32("Address Maximum", resource->address32.maximum);
-
- acpi_rs_out_integer32("Translation Offset",
- resource->address32.translation_offset);
-
- acpi_rs_out_integer32("Address Length",
- resource->address32.address_length);
-
- acpi_rs_dump_resource_source(&resource->address32.resource_source);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_address64
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_address64(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("64-Bit QWORD Address Space Resource\n");
-
- acpi_rs_dump_address_common(resource);
-
- acpi_rs_out_integer64("Granularity", resource->address64.granularity);
-
- acpi_rs_out_integer64("Address Minimum", resource->address64.minimum);
-
- acpi_rs_out_integer64("Address Maximum", resource->address64.maximum);
-
- acpi_rs_out_integer64("Translation Offset",
- resource->address64.translation_offset);
-
- acpi_rs_out_integer64("Address Length",
- resource->address64.address_length);
-
- acpi_rs_dump_resource_source(&resource->address64.resource_source);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_ext_address64
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_ext_address64(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("64-Bit Extended Address Space Resource\n");
-
- acpi_rs_dump_address_common(resource);
-
- acpi_rs_out_integer64("Granularity",
- resource->ext_address64.granularity);
-
- acpi_rs_out_integer64("Address Minimum",
- resource->ext_address64.minimum);
-
- acpi_rs_out_integer64("Address Maximum",
- resource->ext_address64.maximum);
-
- acpi_rs_out_integer64("Translation Offset",
- resource->ext_address64.translation_offset);
-
- acpi_rs_out_integer64("Address Length",
- resource->ext_address64.address_length);
-
- acpi_rs_out_integer64("Type-Specific Attribute",
- resource->ext_address64.type_specific_attributes);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_ext_irq
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_ext_irq(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("Extended IRQ Resource\n");
-
- acpi_rs_out_string("Resource",
- ACPI_CONSUMER ==
- resource->extended_irq.
- producer_consumer ? "Consumer" : "Producer");
-
- acpi_rs_out_string("Triggering",
- ACPI_LEVEL_SENSITIVE ==
- resource->extended_irq.
- triggering ? "Level" : "Edge");
-
- acpi_rs_out_string("Active",
- ACPI_ACTIVE_LOW == resource->extended_irq.polarity ?
- "Low" : "High");
-
- acpi_rs_out_string("Sharing",
- ACPI_SHARED == resource->extended_irq.sharable ?
- "Shared" : "Exclusive");
-
- acpi_rs_dump_resource_source(&resource->extended_irq.resource_source);
-
- acpi_rs_out_integer8("Interrupts",
- (u8) resource->extended_irq.interrupt_count);
-
- acpi_rs_dump_dword_list(resource->extended_irq.interrupt_count,
- resource->extended_irq.interrupts);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_generic_reg
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Dump the field names and values of the resource descriptor
- *
- ******************************************************************************/
-
-void acpi_rs_dump_generic_reg(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("Generic Register Resource\n");
-
- acpi_rs_out_integer8("Space ID", (u8) resource->generic_reg.space_id);
-
- acpi_rs_out_integer8("Bit Width", (u8) resource->generic_reg.bit_width);
-
- acpi_rs_out_integer8("Bit Offset",
- (u8) resource->generic_reg.bit_offset);
-
- acpi_rs_out_integer8("Access Size",
- (u8) resource->generic_reg.access_size);
-
- acpi_rs_out_integer64("Address", resource->generic_reg.address);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_end_dpf
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Print type, no data.
- *
- ******************************************************************************/
-
-void acpi_rs_dump_end_dpf(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("end_dependent_functions Resource\n");
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_end_tag
- *
- * PARAMETERS: Resource - Pointer to an internal resource descriptor
- *
- * RETURN: None
- *
- * DESCRIPTION: Print type, no data.
- *
- ******************************************************************************/
-
-void acpi_rs_dump_end_tag(union acpi_resource_data *resource)
-{
- ACPI_FUNCTION_ENTRY();
-
- acpi_os_printf("end_tag Resource\n");
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_dump_irq_list
- *
- * PARAMETERS: route_table - Pointer to the routing table to dump.
- *
- * RETURN: None
- *
- * DESCRIPTION: Print IRQ routing table
- *
- ******************************************************************************/
-
-void acpi_rs_dump_irq_list(u8 * route_table)
-{
- u8 *buffer = route_table;
- u8 count = 0;
- struct acpi_pci_routing_table *prt_element;
-
- ACPI_FUNCTION_ENTRY();
-
- if (!(acpi_dbg_level & ACPI_LV_RESOURCES)
- || !(_COMPONENT & acpi_dbg_layer)) {
- return;
- }
-
- prt_element = ACPI_CAST_PTR(struct acpi_pci_routing_table, buffer);
-
- /* Dump all table elements, Exit on null length element */
-
- while (prt_element->length) {
- acpi_os_printf("\n[%02X] PCI IRQ Routing Table Package\n",
- count);
-
- acpi_rs_out_integer64("Address", prt_element->address);
-
- acpi_rs_out_integer32("Pin", prt_element->pin);
- acpi_rs_out_string("Source", prt_element->source);
- acpi_rs_out_integer32("Source Index",
- prt_element->source_index);
-
- buffer += prt_element->length;
- prt_element =
- ACPI_CAST_PTR(struct acpi_pci_routing_table, buffer);
- count++;
+ for (i = 0; i < length; i++) {
+ acpi_os_printf("%25s%2.2X : %8.8X\n", "Dword", i, data[i]);
}
}
diff --git a/drivers/acpi/resources/rsinfo.c b/drivers/acpi/resources/rsinfo.c
index b31cb33..973fc28 100644
--- a/drivers/acpi/resources/rsinfo.c
+++ b/drivers/acpi/resources/rsinfo.c
@@ -58,60 +58,60 @@
* 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 @@
/* 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_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 @@
/* 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 @@
{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)}
};
diff --git a/drivers/acpi/resources/rsio.c b/drivers/acpi/resources/rsio.c
index 0dab8cd..ef24ba1 100644
--- a/drivers/acpi/resources/rsio.c
+++ b/drivers/acpi/resources/rsio.c
@@ -49,269 +49,206 @@
/*******************************************************************************
*
- * 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;
+ {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.io.alignment),
+ AML_OFFSET(io.alignment),
+ 2},
- /* Complete the resource header */
-
- 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");
+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)},
- /* 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:
- * Minimum Base Address
- * Maximum Base Address
- * Address Alignment
- * 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_rs_set_resource_header(ACPI_RESOURCE_NAME_IO,
- sizeof(struct aml_resource_io), aml);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * 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_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");
-
- /*
- * Get the following contiguous fields from the AML descriptor:
+ * These fields are contiguous in both the source and destination:
* Base Address
* Length
*/
- 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.fixed_io.address_length),
+ AML_OFFSET(fixed_io.address_length),
+ 1},
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_FIXED_IO;
- resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io);
- return_ACPI_STATUS(AE_OK);
-}
+ {ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.fixed_io.address),
+ AML_OFFSET(fixed_io.address),
+ 1}
+};
/*******************************************************************************
*
- * FUNCTION: acpi_rs_set_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_rs_convert_generic_reg
*
******************************************************************************/
-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_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},
+ /*
+ * These fields are contiguous in both the source and destination:
+ * Address Space ID
+ * Register Bit Width
+ * Register Bit Offset
+ * Access Size
+ */
+ {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.generic_reg.space_id),
+ AML_OFFSET(generic_reg.address_space_id),
+ 4},
+
+ /* Get the Register Address */
+
+ {ACPI_RSC_MOVE64, ACPI_RS_OFFSET(data.generic_reg.address),
+ AML_OFFSET(generic_reg.address),
+ 1}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_end_dpf
+ *
+ ******************************************************************************/
+
+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}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_convert_end_tag
+ *
+ ******************************************************************************/
+
+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},
+ /* Flag byte is present, get the flags */
+
+ {ACPI_RSC_2BITFLAG,
+ ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
+ AML_OFFSET(start_dpf.flags),
+ 0},
+
+ {ACPI_RSC_2BITFLAG,
+ ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
+ AML_OFFSET(start_dpf.flags),
+ 2}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_set_start_dpf
+ *
+ ******************************************************************************/
+
+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)},
+
+ /* Set the default flag values */
+
+ {ACPI_RSC_2BITFLAG,
+ ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
+ AML_OFFSET(start_dpf.flags),
+ 0},
+
+ {ACPI_RSC_2BITFLAG,
+ ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
+ AML_OFFSET(start_dpf.flags),
+ 2},
/*
- * Calculate the structure size based upon the number of channels
- * Note: Zero DMA channels is valid
+ * All done if flags byte is necessary -- if either priority value
+ * is not ACPI_ACCEPTABLE_CONFIGURATION
*/
- if (channel_count > 0) {
- resource->length = (u32) (channel_count - 1) * 4;
- }
+ {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
+ ACPI_RS_OFFSET(data.start_dpf.compatibility_priority),
+ ACPI_ACCEPTABLE_CONFIGURATION},
- /* Get the flags: transfer preference, bus mastering, channel speed */
+ {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
+ ACPI_RS_OFFSET(data.start_dpf.performance_robustness),
+ ACPI_ACCEPTABLE_CONFIGURATION},
- 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;
+ /* Flag byte is not necessary */
- 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);
-}
-
-/*******************************************************************************
- *
- * 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_status
-acpi_rs_set_dma(struct acpi_resource *resource, union aml_resource *aml)
-{
- u8 i;
-
- ACPI_FUNCTION_TRACE("rs_set_dma");
-
- /* Convert channel list to 8-bit DMA channel bitmask */
-
- 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]);
- }
-
- /* Set the DMA Flag bits */
-
- aml->dma.flags = (u8)
- (((resource->data.dma.type & 0x03) << 5) |
- ((resource->data.dma.bus_master & 0x01) << 2) |
- (resource->data.dma.transfer & 0x03));
-
- /* Complete the AML descriptor header */
-
- 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)}
+};
diff --git a/drivers/acpi/resources/rsirq.c b/drivers/acpi/resources/rsirq.c
index 4e854ba..79e7125 100644
--- a/drivers/acpi/resources/rsirq.c
+++ b/drivers/acpi/resources/rsirq.c
@@ -49,325 +49,182 @@
/*******************************************************************************
*
- * 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);
+ {ACPI_RSC_BITMASK16, ACPI_RS_OFFSET(data.irq.interrupts[0]),
+ AML_OFFSET(irq.irq_mask),
+ ACPI_RS_OFFSET(data.irq.interrupt_count)},
- /* Decode the IRQ bits (up to 16 possible) */
+ /* Set default flags (others are zero) */
- for (i = 0; i < 16; i++) {
- if ((temp16 >> i) & 0x01) {
- resource->data.irq.interrupts[interrupt_count] = i;
- interrupt_count++;
- }
- }
+ {ACPI_RSC_SET8, ACPI_RS_OFFSET(data.irq.triggering),
+ ACPI_EDGE_SENSITIVE,
+ 1},
- /* Zero interrupts is valid */
+ /* All done if no flag byte present in descriptor */
- resource_length = 0;
- resource->data.irq.interrupt_count = interrupt_count;
- if (interrupt_count > 0) {
- /* Calculate the structure size based upon the number of interrupts */
+ {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_AML_LENGTH, 0, 3},
- resource_length = (u32) (interrupt_count - 1) * 4;
- }
+ /* Get flags: Triggering[0], Polarity[3], Sharing[4] */
- /* Get Flags (Byte 3) if it is used */
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.triggering),
+ AML_OFFSET(irq.flags),
+ 0},
- if (aml_resource_length == 3) {
- /* Check for HE, LL interrupts */
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.irq.polarity),
+ AML_OFFSET(irq.flags),
+ 3},
- 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_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 interrupt mask */
+ /* Set the flags byte by default */
- ACPI_MOVE_16_TO_16(&aml->irq.irq_mask, &irq_mask);
+ {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},
/*
- * 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 */
+ {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
+ ACPI_RS_OFFSET(data.irq.triggering),
+ ACPI_EDGE_SENSITIVE},
- descriptor_length = sizeof(struct aml_resource_irq_noflags);
- } else {
- /* Irq() descriptor must be used */
+ {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
+ ACPI_RS_OFFSET(data.irq.polarity),
+ ACPI_ACTIVE_HIGH},
- descriptor_length = sizeof(struct aml_resource_irq);
+ {ACPI_RSC_EXIT_NE, ACPI_RSC_COMPARE_VALUE,
+ ACPI_RS_OFFSET(data.irq.sharable),
+ ACPI_EXCLUSIVE},
- /* Set the IRQ Info byte */
+ /* irq_no_flags() descriptor can be used */
- aml->irq.flags = (u8)
- ((resource->data.irq.sharable & 0x01) << 4);
-
- if (ACPI_LEVEL_SENSITIVE == resource->data.irq.triggering &&
- ACPI_ACTIVE_LOW == resource->data.irq.polarity) {
- aml->irq.flags |= 0x08;
- } else {
- aml->irq.flags |= 0x01;
- }
- }
-
- /* Complete the AML descriptor header */
-
- 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;
+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)},
- ACPI_FUNCTION_TRACE("rs_get_ext_irq");
+ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_EXTENDED_IRQ,
+ sizeof(struct aml_resource_extended_irq),
+ 0},
- /* Get the flag bits */
+ /* Flag bits */
- 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_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.producer_consumer),
+ AML_OFFSET(extended_irq.flags),
+ 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;
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.triggering),
+ AML_OFFSET(extended_irq.flags),
+ 1},
- /* Get the IRQ Table length (Byte4) */
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.extended_irq.polarity),
+ AML_OFFSET(extended_irq.flags),
+ 2},
- 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.sharable),
+ AML_OFFSET(extended_irq.flags),
+ 3},
- return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
- }
+ /* IRQ Table length (Byte4) */
- /*
- * 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_COUNT, ACPI_RS_OFFSET(data.extended_irq.interrupt_count),
+ AML_OFFSET(extended_irq.interrupt_count),
+ sizeof(u32)}
+ ,
- /* Get every IRQ in the table, each is 32 bits */
+ /* Copy every IRQ in the table, each is 32 bits */
- acpi_rs_move_data(resource->data.extended_irq.interrupts,
- aml->extended_irq.interrupt_number,
- (u16) temp8, ACPI_MOVE_TYPE_32_TO_32);
+ {ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.extended_irq.interrupts[0]),
+ AML_OFFSET(extended_irq.interrupts[0]),
+ 0}
+ ,
- /* Get the optional resource_source (index and string) */
+ /* Optional resource_source (Index and String) */
- 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);
-
- /* Complete the resource header */
-
- 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;
+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)},
- ACPI_FUNCTION_TRACE("rs_set_ext_irq");
+ {ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_DMA,
+ sizeof(struct aml_resource_dma),
+ 0},
- /* Set the Interrupt vector flags */
+ /* Flags: transfer preference, bus mastering, channel speed */
- 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));
+ {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.transfer),
+ AML_OFFSET(dma.flags),
+ 0},
- /*
- * 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;
- }
+ {ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.dma.bus_master),
+ AML_OFFSET(dma.flags),
+ 2},
- /* Set the Interrupt table length */
+ {ACPI_RSC_2BITFLAG, ACPI_RS_OFFSET(data.dma.type),
+ AML_OFFSET(dma.flags),
+ 5},
- aml->extended_irq.table_length = (u8)
- resource->data.extended_irq.interrupt_count;
+ /* DMA channel mask bits */
- descriptor_length = (sizeof(struct aml_resource_extended_irq) - 4) +
- ((acpi_size) resource->data.extended_irq.interrupt_count *
- sizeof(u32));
-
- /* Set each interrupt value */
-
- 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);
-
- /* Resource Source Index and Resource Source are optional */
-
- descriptor_length = acpi_rs_set_resource_source(aml, descriptor_length,
- &resource->data.
- extended_irq.
- resource_source);
-
- /* Complete the AML descriptor header */
-
- 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)}
+};
diff --git a/drivers/acpi/resources/rslist.c b/drivers/acpi/resources/rslist.c
index f72d42e..ee17ef3 100644
--- a/drivers/acpi/resources/rslist.c
+++ b/drivers/acpi/resources/rslist.c
@@ -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 @@
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 @@
/*******************************************************************************
*
- * 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_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 @@
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 @@
/* 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_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 @@
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 @@
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);
}
diff --git a/drivers/acpi/resources/rsmemory.c b/drivers/acpi/resources/rsmemory.c
index 47e979e..418a3fb 100644
--- a/drivers/acpi/resources/rsmemory.c
+++ b/drivers/acpi/resources/rsmemory.c
@@ -49,260 +49,187 @@
/*******************************************************************************
*
- * 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
- * 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);
-}
-
-/*******************************************************************************
- *
- * 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_status
-acpi_rs_set_memory32(struct acpi_resource *resource, union aml_resource *aml)
-{
- ACPI_FUNCTION_TRACE("rs_set_memory32");
-
- /* Set the Information Byte */
-
- aml->memory32.information = (u8)
- (resource->data.memory32.read_write_attribute & 0x01);
-
- /*
- * 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);
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_MEMORY32,
- sizeof(struct aml_resource_memory32), aml);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * 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_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 */
-
- resource->data.fixed_memory32.read_write_attribute =
- (aml->fixed_memory32.information & 0x01);
-
- /*
- * Get the following contiguous fields from the AML descriptor:
+ * These fields are contiguous in both the source and destination:
* 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);
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_FIXED_MEMORY32;
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_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_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_get_vendor_small
*
******************************************************************************/
-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_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)},
- /* Set the Information Byte */
+ /* Length of the vendor data (byte count) */
- aml->fixed_memory32.information = (u8)
- (resource->data.fixed_memory32.read_write_attribute & 0x01);
+ {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
+ 0,
+ sizeof(u8)}
+ ,
+
+ /* Vendor data */
+
+ {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
+ sizeof(struct aml_resource_small_header),
+ 0}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_get_vendor_large
+ *
+ ******************************************************************************/
+
+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)},
+
+ /* Length of the vendor data (byte count) */
+
+ {ACPI_RSC_COUNT16, ACPI_RS_OFFSET(data.vendor.byte_length),
+ 0,
+ sizeof(u8)}
+ ,
+
+ /* Vendor data */
+
+ {ACPI_RSC_MOVE8, ACPI_RS_OFFSET(data.vendor.byte_data[0]),
+ sizeof(struct aml_resource_large_header),
+ 0}
+};
+
+/*******************************************************************************
+ *
+ * acpi_rs_set_vendor
+ *
+ ******************************************************************************/
+
+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 */
+
+ {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_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);
+ {ACPI_RSC_EXIT_LE, 0, 0, 7},
- /* Complete the AML descriptor header */
+ /* Must create a large vendor descriptor */
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_FIXED_MEMORY32,
- sizeof(struct aml_resource_fixed_memory32),
- aml);
- return_ACPI_STATUS(AE_OK);
-}
+ {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}
+};
diff --git a/drivers/acpi/resources/rsmisc.c b/drivers/acpi/resources/rsmisc.c
index 337a0f0..16ad3bf 100644
--- a/drivers/acpi/resources/rsmisc.c
+++ b/drivers/acpi/resources/rsmisc.c
@@ -47,434 +47,506 @@
#define _COMPONENT ACPI_RESOURCES
ACPI_MODULE_NAME("rsmisc")
+#define INIT_RESOURCE_TYPE(i) i->resource_offset
+#define INIT_RESOURCE_LENGTH(i) i->aml_offset
+#define INIT_TABLE_LENGTH(i) i->value
+#define COMPARE_OPCODE(i) i->resource_offset
+#define COMPARE_TARGET(i) i->aml_offset
+#define COMPARE_VALUE(i) i->value
/*******************************************************************************
*
- * FUNCTION: acpi_rs_get_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
-acpi_rs_get_generic_reg(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
- ACPI_FUNCTION_TRACE("rs_get_generic_reg");
-
- /*
- * Get the following fields from the AML descriptor:
- * Address Space ID
- * Register Bit Width
- * Register Bit Offset
- * Access Size
- * Register Address
- */
- resource->data.generic_reg.space_id = aml->generic_reg.address_space_id;
- resource->data.generic_reg.bit_width = aml->generic_reg.bit_width;
- resource->data.generic_reg.bit_offset = aml->generic_reg.bit_offset;
- resource->data.generic_reg.access_size = aml->generic_reg.access_size;
- ACPI_MOVE_64_TO_64(&resource->data.generic_reg.address,
- &aml->generic_reg.address);
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_GENERIC_REGISTER;
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_generic_register);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_generic_reg
+ * FUNCTION: acpi_rs_convert_aml_to_resource
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
+ * Info - Pointer to appropriate conversion table
*
* RETURN: Status
*
- * DESCRIPTION: Convert an internal resource descriptor to the corresponding
- * external AML resource descriptor.
+ * DESCRIPTION: Convert an external AML resource descriptor to the corresponding
+ * internal resource descriptor
*
******************************************************************************/
-
acpi_status
-acpi_rs_set_generic_reg(struct acpi_resource *resource, union aml_resource *aml)
+acpi_rs_convert_aml_to_resource(struct acpi_resource *resource,
+ union aml_resource *aml,
+ struct acpi_rsconvert_info *info)
{
- ACPI_FUNCTION_TRACE("rs_set_generic_reg");
+ acpi_rs_length aml_resource_length;
+ void *source;
+ void *destination;
+ char *target;
+ u8 count;
+ u8 flags_mode = FALSE;
+ u16 item_count = 0;
+ u16 temp16 = 0;
- /*
- * Set the following fields in the AML descriptor:
- * Address Space ID
- * Register Bit Width
- * Register Bit Offset
- * Access Size
- * Register Address
- */
- aml->generic_reg.address_space_id =
- (u8) resource->data.generic_reg.space_id;
- aml->generic_reg.bit_width = (u8) resource->data.generic_reg.bit_width;
- aml->generic_reg.bit_offset =
- (u8) resource->data.generic_reg.bit_offset;
- aml->generic_reg.access_size =
- (u8) resource->data.generic_reg.access_size;
- ACPI_MOVE_64_TO_64(&aml->generic_reg.address,
- &resource->data.generic_reg.address);
+ ACPI_FUNCTION_TRACE("rs_get_resource");
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_GENERIC_REGISTER,
- sizeof(struct
- aml_resource_generic_register), aml);
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_vendor
- *
- * 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
-acpi_rs_get_vendor(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
- u8 *aml_byte_data;
-
- ACPI_FUNCTION_TRACE("rs_get_vendor");
-
- /* Determine if this is a large or small vendor specific item */
-
- if (aml->large_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
- /* Large item, Point to the first vendor byte */
-
- aml_byte_data =
- ((u8 *) aml) + sizeof(struct aml_resource_large_header);
- } else {
- /* Small item, Point to the first vendor byte */
-
- aml_byte_data =
- ((u8 *) aml) + sizeof(struct aml_resource_small_header);
+ if (((acpi_native_uint) resource) & 0x3) {
+ acpi_os_printf
+ ("**** GET: Misaligned resource pointer: %p Type %2.2X Len %X\n",
+ resource, resource->type, resource->length);
}
- /* Copy the vendor-specific bytes */
+ /* Extract the resource Length field (does not include header length) */
- ACPI_MEMCPY(resource->data.vendor.byte_data,
- aml_byte_data, aml_resource_length);
- resource->data.vendor.byte_length = aml_resource_length;
+ aml_resource_length = acpi_ut_get_resource_length(aml);
/*
- * In order for the struct_size to fall on a 32-bit boundary,
- * calculate the length of the vendor string and expand the
- * struct_size to the next 32-bit boundary.
+ * First table entry must be ACPI_RSC_INITxxx and must contain the
+ * table length (# of table entries)
*/
- resource->type = ACPI_RESOURCE_TYPE_VENDOR;
- resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor) +
- ACPI_ROUND_UP_to_32_bITS(aml_resource_length);
- return_ACPI_STATUS(AE_OK);
-}
+ count = INIT_TABLE_LENGTH(info);
-/*******************************************************************************
- *
- * FUNCTION: 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.
- *
- ******************************************************************************/
+ while (count) {
+ /*
+ * Source is the external AML byte stream buffer,
+ * destination is the internal resource descriptor
+ */
+ source = ((u8 *) aml) + info->aml_offset;
+ destination = ((u8 *) resource) + info->resource_offset;
-acpi_status
-acpi_rs_set_vendor(struct acpi_resource *resource, union aml_resource *aml)
-{
- u32 resource_length;
- u8 *source;
- u8 *destination;
+ switch (info->opcode) {
+ case ACPI_RSC_INITGET:
+ /*
+ * Get the resource type and the initial (minimum) length
+ */
+ ACPI_MEMSET(resource, 0, INIT_RESOURCE_LENGTH(info));
+ resource->type = INIT_RESOURCE_TYPE(info);
+ resource->length = INIT_RESOURCE_LENGTH(info);
+ break;
- ACPI_FUNCTION_TRACE("rs_set_vendor");
+ case ACPI_RSC_INITSET:
+ break;
- resource_length = resource->data.vendor.byte_length;
- source = ACPI_CAST_PTR(u8, resource->data.vendor.byte_data);
+ case ACPI_RSC_FLAGINIT:
- /* Length determines if this is a large or small resource */
+ flags_mode = TRUE;
+ break;
- if (resource_length > 7) {
- /* Large item, get pointer to the data part of the descriptor */
+ case ACPI_RSC_1BITFLAG:
+ /*
+ * Mask and shift the flag bit
+ */
+ *((u8 *) destination) = (u8)
+ ((*((u8 *) source) >> info->value) & 0x01);
+ break;
- destination =
- ((u8 *) aml) + sizeof(struct aml_resource_large_header);
+ case ACPI_RSC_2BITFLAG:
+ /*
+ * Mask and shift the flag bits
+ */
+ *((u8 *) destination) = (u8)
+ ((*((u8 *) source) >> info->value) & 0x03);
+ break;
- /* Complete the AML descriptor header */
+ case ACPI_RSC_COUNT:
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_VENDOR_LARGE,
- (u32) (resource_length +
- sizeof(struct
- aml_resource_large_header)),
- aml);
- } else {
- /* Small item, get pointer to the data part of the descriptor */
+ item_count = *((u8 *) source);
+ *((u8 *) destination) = (u8) item_count;
- destination =
- ((u8 *) aml) + sizeof(struct aml_resource_small_header);
+ resource->length = resource->length +
+ (info->value * (item_count - 1));
+ break;
- /* Complete the AML descriptor header */
+ case ACPI_RSC_COUNT16:
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_VENDOR_SMALL,
- (u32) (resource_length +
- sizeof(struct
- aml_resource_small_header)),
- aml);
- }
+ item_count = aml_resource_length;
+ *((u16 *) destination) = item_count;
- /* Copy the vendor-specific bytes */
+ resource->length = resource->length +
+ (info->value * (item_count - 1));
+ break;
- ACPI_MEMCPY(destination, source, resource_length);
- return_ACPI_STATUS(AE_OK);
-}
+ case ACPI_RSC_LENGTH:
-/*******************************************************************************
- *
- * FUNCTION: 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.
- *
- ******************************************************************************/
+ resource->length = resource->length + info->value;
+ break;
-acpi_status
-acpi_rs_get_start_dpf(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
- ACPI_FUNCTION_TRACE("rs_get_start_dpf");
+ case ACPI_RSC_MOVE8:
+ case ACPI_RSC_MOVE16:
+ case ACPI_RSC_MOVE32:
+ case ACPI_RSC_MOVE64:
+ /*
+ * Raw data move. Use the Info value field unless item_count has
+ * been previously initialized via a COUNT opcode
+ */
+ if (info->value) {
+ item_count = info->value;
+ }
+ acpi_rs_move_data(destination, source, item_count,
+ info->opcode);
+ break;
- /* Get the flags byte if present */
+ case ACPI_RSC_SET8:
- if (aml_resource_length == 1) {
- /* Get the Compatibility priority */
+ ACPI_MEMSET(destination, info->aml_offset, info->value);
+ break;
- resource->data.start_dpf.compatibility_priority =
- (aml->start_dpf.flags & 0x03);
+ case ACPI_RSC_DATA8:
- if (resource->data.start_dpf.compatibility_priority >= 3) {
- return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
+ target = ((char *)resource) + info->value;
+ ACPI_MEMCPY(destination, source,
+ *(ACPI_CAST_PTR(u16, target)));
+ break;
+
+ case ACPI_RSC_ADDRESS:
+ /*
+ * Common handler for address descriptor flags
+ */
+ if (!acpi_rs_get_address_common(resource, aml)) {
+ return_ACPI_STATUS
+ (AE_AML_INVALID_RESOURCE_TYPE);
+ }
+ break;
+
+ case ACPI_RSC_SOURCE:
+ /*
+ * Optional resource_source (Index and String)
+ */
+ resource->length +=
+ acpi_rs_get_resource_source(aml_resource_length,
+ info->value,
+ destination, aml, NULL);
+ break;
+
+ case ACPI_RSC_SOURCEX:
+ /*
+ * Optional resource_source (Index and String). This is the more
+ * complicated case used by the Interrupt() macro
+ */
+ target =
+ ((char *)resource) + info->aml_offset +
+ (item_count * 4);
+
+ resource->length +=
+ acpi_rs_get_resource_source(aml_resource_length,
+ (acpi_rs_length) (((item_count - 1) * sizeof(u32)) + info->value), destination, aml, target);
+ break;
+
+ case ACPI_RSC_BITMASK:
+ /*
+ * 8-bit encoded bitmask (DMA macro)
+ */
+ item_count =
+ acpi_rs_decode_bitmask(*((u8 *) source),
+ destination);
+ if (item_count) {
+ resource->length +=
+ resource->length + (item_count - 1);
+ }
+
+ target = ((char *)resource) + info->value;
+ *((u8 *) target) = (u8) item_count;
+ break;
+
+ case ACPI_RSC_BITMASK16:
+ /*
+ * 16-bit encoded bitmask (IRQ macro)
+ */
+ ACPI_MOVE_16_TO_16(&temp16, source);
+
+ item_count =
+ acpi_rs_decode_bitmask(temp16, destination);
+ if (item_count) {
+ resource->length =
+ resource->length + (item_count - 1);
+ }
+
+ target = ((char *)resource) + info->value;
+ *((u8 *) target) = (u8) item_count;
+ break;
+
+ case ACPI_RSC_EXIT_NE:
+ /*
+ * Control - Exit conversion if not equal
+ */
+ switch (info->resource_offset) {
+ case ACPI_RSC_COMPARE_AML_LENGTH:
+ if (aml_resource_length != info->value) {
+ goto exit;
+ }
+ break;
+
+ case ACPI_RSC_COMPARE_VALUE:
+ if (*((u8 *) source) != info->value) {
+ goto exit;
+ }
+ break;
+
+ default:
+ acpi_os_printf
+ ("*** Invalid conversion sub-opcode\n");
+ return_ACPI_STATUS(AE_BAD_PARAMETER);
+ }
+ break;
+
+ default:
+
+ acpi_os_printf("*** Invalid conversion opcode\n");
+ return_ACPI_STATUS(AE_BAD_PARAMETER);
}
- /* Get the Performance/Robustness preference */
+ count--;
+ info++;
+ }
- resource->data.start_dpf.performance_robustness =
- ((aml->start_dpf.flags >> 2) & 0x03);
+ exit:
+ if (!flags_mode) {
+ /* Round the resource struct length up to the next 32-bit boundary */
- if (resource->data.start_dpf.performance_robustness >= 3) {
- return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
+ resource->length = ACPI_ROUND_UP_to_32_bITS(resource->length);
+ }
+ return_ACPI_STATUS(AE_OK);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION: acpi_rs_convert_resource_to_aml
+ *
+ * PARAMETERS: Resource - Pointer to the resource descriptor
+ * Aml - Where the AML descriptor is returned
+ * Info - Pointer to appropriate conversion table
+ *
+ * RETURN: Status
+ *
+ * DESCRIPTION: Convert an internal resource descriptor to the corresponding
+ * external AML resource descriptor.
+ *
+ ******************************************************************************/
+
+acpi_status
+acpi_rs_convert_resource_to_aml(struct acpi_resource *resource,
+ union aml_resource *aml,
+ struct acpi_rsconvert_info *info)
+{
+ void *source = NULL;
+ void *destination;
+ acpi_rsdesc_size aml_length = 0;
+ u8 count;
+ u16 temp16 = 0;
+ u16 item_count = 0;
+
+ ACPI_FUNCTION_TRACE("rs_convert_resource_to_aml");
+
+ /* Validate the Resource pointer, must be 32-bit aligned */
+
+ if (((acpi_native_uint) resource) & 0x3) {
+ acpi_os_printf
+ ("**** SET: Misaligned resource pointer: %p Type %2.2X Len %X\n",
+ resource, resource->type, resource->length);
+ }
+
+ /*
+ * First table entry must be ACPI_RSC_INITxxx and must contain the
+ * table length (# of table entries)
+ */
+ count = INIT_TABLE_LENGTH(info);
+
+ while (count) {
+ /*
+ * Source is the internal resource descriptor,
+ * destination is the external AML byte stream buffer
+ */
+ source = ((u8 *) resource) + info->resource_offset;
+ destination = ((u8 *) aml) + info->aml_offset;
+
+ switch (info->opcode) {
+ case ACPI_RSC_INITSET:
+
+ ACPI_MEMSET(aml, 0, INIT_RESOURCE_LENGTH(info));
+ aml_length = INIT_RESOURCE_LENGTH(info);
+ acpi_rs_set_resource_header(INIT_RESOURCE_TYPE(info),
+ aml_length, aml);
+ break;
+
+ case ACPI_RSC_INITGET:
+ break;
+
+ case ACPI_RSC_FLAGINIT:
+ /*
+ * Clear the flag byte
+ */
+ *((u8 *) destination) = 0;
+ break;
+
+ case ACPI_RSC_1BITFLAG:
+ /*
+ * Mask and shift the flag bit
+ */
+ *((u8 *) destination) |= (u8)
+ ((*((u8 *) source) & 0x01) << info->value);
+ break;
+
+ case ACPI_RSC_2BITFLAG:
+ /*
+ * Mask and shift the flag bits
+ */
+ *((u8 *) destination) |= (u8)
+ ((*((u8 *) source) & 0x03) << info->value);
+ break;
+
+ case ACPI_RSC_COUNT:
+
+ item_count = *((u8 *) source);
+ *((u8 *) destination) = (u8) item_count;
+
+ aml_length = (u16) (aml_length +
+ (info->value * (item_count - 1)));
+ break;
+
+ case ACPI_RSC_COUNT16:
+
+ item_count = *((u16 *) source);
+ aml_length = (u16) (aml_length + item_count);
+ acpi_rs_set_resource_length(aml_length, aml);
+ break;
+
+ case ACPI_RSC_LENGTH:
+
+ acpi_rs_set_resource_length(info->value, aml);
+ break;
+
+ case ACPI_RSC_MOVE8:
+ case ACPI_RSC_MOVE16:
+ case ACPI_RSC_MOVE32:
+ case ACPI_RSC_MOVE64:
+
+ if (info->value) {
+ item_count = info->value;
+ }
+ acpi_rs_move_data(destination, source, item_count,
+ info->opcode);
+ break;
+
+ case ACPI_RSC_ADDRESS:
+
+ /* Set the Resource Type, General Flags, and Type-Specific Flags */
+
+ acpi_rs_set_address_common(aml, resource);
+ break;
+
+ case ACPI_RSC_SOURCEX:
+ /*
+ * Optional resource_source (Index and String)
+ */
+ aml_length =
+ acpi_rs_set_resource_source(aml,
+ (acpi_rs_length)
+ aml_length, source);
+ acpi_rs_set_resource_length(aml_length, aml);
+ break;
+
+ case ACPI_RSC_SOURCE:
+ /*
+ * Optional resource_source (Index and String). This is the more
+ * complicated case used by the Interrupt() macro
+ */
+ aml_length =
+ acpi_rs_set_resource_source(aml, info->value,
+ source);
+ acpi_rs_set_resource_length(aml_length, aml);
+ break;
+
+ case ACPI_RSC_BITMASK:
+ /*
+ * 8-bit encoded bitmask (DMA macro)
+ */
+ *((u8 *) destination) = (u8)
+ acpi_rs_encode_bitmask(source,
+ *(((u8 *) resource) +
+ info->value));
+ break;
+
+ case ACPI_RSC_BITMASK16:
+ /*
+ * 16-bit encoded bitmask (IRQ macro)
+ */
+ temp16 =
+ acpi_rs_encode_bitmask(source,
+ *(((u8 *) resource) +
+ info->value));
+ ACPI_MOVE_16_TO_16(destination, &temp16);
+ break;
+
+ case ACPI_RSC_EXIT_LE:
+ /*
+ * Control - Exit conversion if less than or equal
+ */
+ if (item_count <= info->value) {
+ goto exit;
+ }
+ break;
+
+ case ACPI_RSC_EXIT_NE:
+ /*
+ * Control - Exit conversion if not equal
+ */
+ switch (COMPARE_OPCODE(info)) {
+ case ACPI_RSC_COMPARE_VALUE:
+ if (*
+ ((u8 *) (((u8 *) resource) +
+ COMPARE_TARGET(info))) !=
+ COMPARE_VALUE(info)) {
+ goto exit;
+ }
+ break;
+
+ default:
+ acpi_os_printf
+ ("*** Invalid conversion sub-opcode\n");
+ return_ACPI_STATUS(AE_BAD_PARAMETER);
+ }
+ break;
+
+ default:
+
+ acpi_os_printf("*** Invalid conversion opcode\n");
+ return_ACPI_STATUS(AE_BAD_PARAMETER);
}
- } else {
- /* start_dependent_no_pri(), no flags byte, set defaults */
- resource->data.start_dpf.compatibility_priority =
- ACPI_ACCEPTABLE_CONFIGURATION;
-
- resource->data.start_dpf.performance_robustness =
- ACPI_ACCEPTABLE_CONFIGURATION;
+ count--;
+ info++;
}
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_START_DEPENDENT;
- resource->length =
- ACPI_SIZEOF_RESOURCE(struct acpi_resource_start_dependent);
+ exit:
return_ACPI_STATUS(AE_OK);
}
-/*******************************************************************************
- *
- * FUNCTION: 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.
- *
- ******************************************************************************/
+#if 0
+/* Previous resource validations */
-acpi_status
-acpi_rs_set_start_dpf(struct acpi_resource *resource, union aml_resource *aml)
-{
- ACPI_FUNCTION_TRACE("rs_set_start_dpf");
+if (aml->ext_address64.revision_iD != AML_RESOURCE_EXTENDED_ADDRESS_REVISION) {
+ return_ACPI_STATUS(AE_SUPPORT);
+}
+if (resource->data.start_dpf.performance_robustness >= 3) {
+ return_ACPI_STATUS(AE_AML_BAD_RESOURCE_VALUE);
+}
+
+if (((aml->irq.flags & 0x09) == 0x00) || ((aml->irq.flags & 0x09) == 0x09)) {
/*
- * The descriptor type field is set based upon whether a byte is needed
- * to contain Priority data.
+ * Only [active_high, edge_sensitive] or [active_low, level_sensitive]
+ * polarity/trigger interrupts are allowed (ACPI spec, section
+ * "IRQ Format"), so 0x00 and 0x09 are illegal.
*/
- if (ACPI_ACCEPTABLE_CONFIGURATION ==
- resource->data.start_dpf.compatibility_priority &&
- ACPI_ACCEPTABLE_CONFIGURATION ==
- resource->data.start_dpf.performance_robustness) {
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_START_DEPENDENT,
- sizeof(struct
- aml_resource_start_dependent_noprio),
- aml);
- } else {
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_START_DEPENDENT,
- sizeof(struct
- aml_resource_start_dependent),
- aml);
-
- /* Set the Flags byte */
-
- aml->start_dpf.flags = (u8)
- (((resource->data.start_dpf.
- performance_robustness & 0x03) << 2) | (resource->data.
- start_dpf.
- compatibility_priority
- & 0x03));
- }
- return_ACPI_STATUS(AE_OK);
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Invalid interrupt polarity/trigger in resource list, %X\n",
+ aml->irq.flags));
+ return_ACPI_STATUS(AE_BAD_DATA);
}
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_end_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.
- *
- ******************************************************************************/
+resource->data.extended_irq.interrupt_count = temp8;
+if (temp8 < 1) {
+ /* Must have at least one IRQ */
-acpi_status
-acpi_rs_get_end_dpf(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
- ACPI_FUNCTION_TRACE("rs_get_end_dpf");
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_END_DEPENDENT;
- resource->length = (u32) ACPI_RESOURCE_LENGTH;
- return_ACPI_STATUS(AE_OK);
+ return_ACPI_STATUS(AE_AML_BAD_RESOURCE_LENGTH);
}
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_end_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
-acpi_rs_set_end_dpf(struct acpi_resource *resource, union aml_resource *aml)
-{
- ACPI_FUNCTION_TRACE("rs_set_end_dpf");
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_END_DEPENDENT,
- sizeof(struct aml_resource_end_dependent),
- aml);
- return_ACPI_STATUS(AE_OK);
+if (resource->data.dma.transfer == 0x03) {
+ ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
+ "Invalid DMA.Transfer preference (3)\n"));
+ return_ACPI_STATUS(AE_BAD_DATA);
}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_get_end_tag
- *
- * 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
-acpi_rs_get_end_tag(union aml_resource *aml,
- u16 aml_resource_length, struct acpi_resource *resource)
-{
- ACPI_FUNCTION_TRACE("rs_get_end_tag");
-
- /* Complete the resource header */
-
- resource->type = ACPI_RESOURCE_TYPE_END_TAG;
- resource->length = ACPI_RESOURCE_LENGTH;
- return_ACPI_STATUS(AE_OK);
-}
-
-/*******************************************************************************
- *
- * FUNCTION: acpi_rs_set_end_tag
- *
- * 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
-acpi_rs_set_end_tag(struct acpi_resource *resource, union aml_resource *aml)
-{
- ACPI_FUNCTION_TRACE("rs_set_end_tag");
-
- /*
- * Set the Checksum - zero means that the resource data is treated as if
- * the checksum operation succeeded (ACPI Spec 1.0b Section 6.4.2.8)
- */
- aml->end_tag.checksum = 0;
-
- /* Complete the AML descriptor header */
-
- acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_END_TAG,
- sizeof(struct aml_resource_end_tag), aml);
- return_ACPI_STATUS(AE_OK);
-}
+#endif
diff --git a/drivers/acpi/resources/rsutils.c b/drivers/acpi/resources/rsutils.c
index 9d503de..7613033 100644
--- a/drivers/acpi/resources/rsutils.c
+++ b/drivers/acpi/resources/rsutils.c
@@ -50,6 +50,64 @@
/*******************************************************************************
*
+ * 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
*
* PARAMETERS: Destination - Pointer to the destination descriptor
@@ -64,6 +122,7 @@
* 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 @@
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],
+ /*
+ * 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;
+
+ /*
+ * 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_16:
- ACPI_MOVE_32_TO_16(&((u16 *) destination)[i],
- &((u32 *) 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 @@
/*******************************************************************************
*
- * 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);
+ resource_length = (acpi_rs_length)
+ (total_length - sizeof(struct aml_resource_small_header));
+
+ /* Insert length into the descriptor type byte */
+
+ aml->small_header.descriptor_type = (u8)
+
+ /* Clear any existing length, preserving descriptor type bits */
+ ((aml->small_header.
+ descriptor_type & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
+
+ | resource_length);
}
-
- return (resource_length);
-}
-
-/*******************************************************************************
- *
- * 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->large_header.resource_length);
- descriptor_length += sizeof(struct aml_resource_large_header);
-
- } else {
- /* Small Resource type -- bits 2:0 of byte 0 contain the length */
-
- descriptor_length = (u32) (aml->small_header.descriptor_type &
- ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
- descriptor_length += sizeof(struct aml_resource_small_header);
- }
-
- return (descriptor_length);
}
/*******************************************************************************
@@ -243,71 +287,18 @@
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 */
+ /* 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 */
-
- 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 @@
*
******************************************************************************/
-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 @@
* 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 @@
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 @@
*
* 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 @@
* 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 */
diff --git a/drivers/acpi/resources/rsxface.c b/drivers/acpi/resources/rsxface.c
index 9d179be..09d250a 100644
--- a/drivers/acpi/resources/rsxface.c
+++ b/drivers/acpi/resources/rsxface.c
@@ -57,7 +57,7 @@
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); \