xiaomi-sm8450/android_kernel_xiaomi_sm8450
1
0
派生 0
代码 工单 合并请求 工作流 软件包 项目 发布 百科 活动

[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>
这个提交包含在：
Bob Moore
2005-10-21 00:00:00 -04:00
提交者 Len Brown
父节点 50eca3eb89
当前提交 0897831bb5
共修改 32 个文件，包含 2541 行新增和 3248 行删除
下载 Patch 文件 下载 Diff 文件 展开所有文件 折叠所有文件

933
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 u8 acpi_rs_encode_specific_flags(union acpi_resource_data *resource)
*
******************************************************************************/
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);
}

71
drivers/acpi/resources/rscalc.c
查看文件

@@ -52,7 +52,7 @@ ACPI_MODULE_NAME("rscalc")
/* Local prototypes */
static u8 acpi_rs_count_set_bits(u16 bit_field);
static acpi_size
static acpi_rs_length
acpi_rs_struct_option_length(struct acpi_resource_source *resource_source);
static u32
@@ -100,7 +100,7 @@ static u8 acpi_rs_count_set_bits(u16 bit_field)
*
******************************************************************************/
static acpi_size
static acpi_rs_length
acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
{
ACPI_FUNCTION_ENTRY();
@@ -111,7 +111,7 @@ acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
* resource_source_index (1).
*/
if (resource_source->string_ptr) {
return ((acpi_size) resource_source->string_length + 1);
return ((acpi_rs_length) (resource_source->string_length + 1));
}
return (0);
@@ -184,7 +184,7 @@ acpi_status
acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
{
acpi_size aml_size_needed = 0;
acpi_size segment_size;
acpi_rs_length total_size;
ACPI_FUNCTION_TRACE("rs_get_aml_length");
@@ -199,7 +199,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
/* Get the base size of the (external stream) resource descriptor */
segment_size = acpi_gbl_aml_resource_sizes[resource->type];
total_size = acpi_gbl_aml_resource_sizes[resource->type];
/*
* Augment the base size for descriptors with optional and/or
@@ -216,13 +216,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
if (resource->data.vendor.byte_length > 7) {
/* Base size of a Large resource descriptor */
segment_size =
total_size =
sizeof(struct aml_resource_large_header);
}
/* Add the size of the vendor-specific data */
segment_size += resource->data.vendor.byte_length;
total_size = (acpi_rs_length)
(total_size + resource->data.vendor.byte_length);
break;
case ACPI_RESOURCE_TYPE_END_TAG:
@@ -230,7 +231,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* End Tag:
* We are done -- return the accumulated total size.
*/
*size_needed = aml_size_needed + segment_size;
*size_needed = aml_size_needed + total_size;
/* Normal exit */
@@ -241,10 +242,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 16-Bit Address Resource:
* Add the size of the optional resource_source info
*/
segment_size +=
acpi_rs_struct_option_length(&resource->data.
address16.
resource_source);
total_size = (acpi_rs_length)
(total_size +
acpi_rs_struct_option_length(&resource->data.
address16.
resource_source));
break;
case ACPI_RESOURCE_TYPE_ADDRESS32:
@@ -252,10 +254,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 32-Bit Address Resource:
* Add the size of the optional resource_source info
*/
segment_size +=
acpi_rs_struct_option_length(&resource->data.
address32.
resource_source);
total_size = (acpi_rs_length)
(total_size +
acpi_rs_struct_option_length(&resource->data.
address32.
resource_source));
break;
case ACPI_RESOURCE_TYPE_ADDRESS64:
@@ -263,10 +266,11 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* 64-Bit Address Resource:
* Add the size of the optional resource_source info
*/
segment_size +=
acpi_rs_struct_option_length(&resource->data.
address64.
resource_source);
total_size = (acpi_rs_length)
(total_size +
acpi_rs_struct_option_length(&resource->data.
address64.
resource_source));
break;
case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
@@ -275,16 +279,14 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
* Add the size of each additional optional interrupt beyond the
* required 1 (4 bytes for each u32 interrupt number)
*/
segment_size += (((acpi_size)
resource->data.extended_irq.
interrupt_count - 1) * 4);
/* Add the size of the optional resource_source info */
segment_size +=
acpi_rs_struct_option_length(&resource->data.
extended_irq.
resource_source);
total_size = (acpi_rs_length)
(total_size +
((resource->data.extended_irq.interrupt_count -
1) * 4) +
/* Add the size of the optional resource_source info */
acpi_rs_struct_option_length(&resource->data.
extended_irq.
resource_source));
break;
default:
@@ -293,7 +295,7 @@ acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
/* Update the total */
aml_size_needed += segment_size;
aml_size_needed += total_size;
/* Point to the next object */
@@ -341,7 +343,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
while (bytes_parsed < aml_buffer_length) {
/* The next byte in the stream is the resource descriptor type */
resource_type = acpi_rs_get_resource_type(*aml_buffer);
resource_type = acpi_ut_get_resource_type(aml_buffer);
/* Get the base stream size and structure sizes for the descriptor */
@@ -352,10 +354,7 @@ acpi_rs_get_list_length(u8 * aml_buffer,
/* Get the Length field from the input resource descriptor */
resource_length =
acpi_rs_get_resource_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
resource_length = acpi_ut_get_resource_length(aml_buffer);
/* Augment the size for descriptors with optional fields */

1483
drivers/acpi/resources/rsdump.c
查看文件

文件差异内容过多而无法显示 加载差异

115
drivers/acpi/resources/rsinfo.c
查看文件

@@ -58,60 +58,60 @@ ACPI_MODULE_NAME("rsinfo")
* descriptors are indexed by the acpi_resource_type field.
*/
/* Dispatch table for resource-to-AML (Set Resource) conversion functions */
ACPI_SET_RESOURCE_HANDLER acpi_gbl_set_resource_dispatch[] = {
struct acpi_rsconvert_info *acpi_gbl_set_resource_dispatch[] = {
acpi_rs_set_irq, /* 0x00, ACPI_RESOURCE_TYPE_IRQ */
acpi_rs_set_dma, /* 0x01, ACPI_RESOURCE_TYPE_DMA */
acpi_rs_convert_dma, /* 0x01, ACPI_RESOURCE_TYPE_DMA */
acpi_rs_set_start_dpf, /* 0x02, ACPI_RESOURCE_TYPE_START_DEPENDENT */
acpi_rs_set_end_dpf, /* 0x03, ACPI_RESOURCE_TYPE_END_DEPENDENT */
acpi_rs_set_io, /* 0x04, ACPI_RESOURCE_TYPE_IO */
acpi_rs_set_fixed_io, /* 0x05, ACPI_RESOURCE_TYPE_FIXED_IO */
acpi_rs_convert_end_dpf, /* 0x03, ACPI_RESOURCE_TYPE_END_DEPENDENT */
acpi_rs_convert_io, /* 0x04, ACPI_RESOURCE_TYPE_IO */
acpi_rs_convert_fixed_io, /* 0x05, ACPI_RESOURCE_TYPE_FIXED_IO */
acpi_rs_set_vendor, /* 0x06, ACPI_RESOURCE_TYPE_VENDOR */
acpi_rs_set_end_tag, /* 0x07, ACPI_RESOURCE_TYPE_END_TAG */
acpi_rs_set_memory24, /* 0x08, ACPI_RESOURCE_TYPE_MEMORY24 */
acpi_rs_set_memory32, /* 0x09, ACPI_RESOURCE_TYPE_MEMORY32 */
acpi_rs_set_fixed_memory32, /* 0x0A, ACPI_RESOURCE_TYPE_FIXED_MEMORY32 */
acpi_rs_set_address16, /* 0x0B, ACPI_RESOURCE_TYPE_ADDRESS16 */
acpi_rs_set_address32, /* 0x0C, ACPI_RESOURCE_TYPE_ADDRESS32 */
acpi_rs_set_address64, /* 0x0D, ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_set_ext_address64, /* 0x0E, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_set_ext_irq, /* 0x0F, ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_set_generic_reg /* 0x10, ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
acpi_rs_convert_end_tag, /* 0x07, ACPI_RESOURCE_TYPE_END_TAG */
acpi_rs_convert_memory24, /* 0x08, ACPI_RESOURCE_TYPE_MEMORY24 */
acpi_rs_convert_memory32, /* 0x09, ACPI_RESOURCE_TYPE_MEMORY32 */
acpi_rs_convert_fixed_memory32, /* 0x0A, ACPI_RESOURCE_TYPE_FIXED_MEMORY32 */
acpi_rs_convert_address16, /* 0x0B, ACPI_RESOURCE_TYPE_ADDRESS16 */
acpi_rs_convert_address32, /* 0x0C, ACPI_RESOURCE_TYPE_ADDRESS32 */
acpi_rs_convert_address64, /* 0x0D, ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_convert_ext_address64, /* 0x0E, ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_convert_ext_irq, /* 0x0F, ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_convert_generic_reg /* 0x10, ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
};
/* Dispatch tables for AML-to-resource (Get Resource) conversion functions */
ACPI_GET_RESOURCE_HANDLER acpi_gbl_sm_get_resource_dispatch[] = {
struct acpi_rsconvert_info *acpi_gbl_sm_get_resource_dispatch[] = {
NULL, /* 0x00, Reserved */
NULL, /* 0x01, Reserved */
NULL, /* 0x02, Reserved */
NULL, /* 0x03, Reserved */
acpi_rs_get_irq, /* 0x04, ACPI_RESOURCE_NAME_IRQ */
acpi_rs_get_dma, /* 0x05, ACPI_RESOURCE_NAME_DMA */
acpi_rs_convert_dma, /* 0x05, ACPI_RESOURCE_NAME_DMA */
acpi_rs_get_start_dpf, /* 0x06, ACPI_RESOURCE_NAME_START_DEPENDENT */
acpi_rs_get_end_dpf, /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */
acpi_rs_get_io, /* 0x08, ACPI_RESOURCE_NAME_IO */
acpi_rs_get_fixed_io, /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO */
acpi_rs_convert_end_dpf, /* 0x07, ACPI_RESOURCE_NAME_END_DEPENDENT */
acpi_rs_convert_io, /* 0x08, ACPI_RESOURCE_NAME_IO */
acpi_rs_convert_fixed_io, /* 0x09, ACPI_RESOURCE_NAME_FIXED_IO */
NULL, /* 0x0A, Reserved */
NULL, /* 0x0B, Reserved */
NULL, /* 0x0C, Reserved */
NULL, /* 0x0D, Reserved */
acpi_rs_get_vendor, /* 0x0E, ACPI_RESOURCE_NAME_VENDOR_SMALL */
acpi_rs_get_end_tag /* 0x0F, ACPI_RESOURCE_NAME_END_TAG */
acpi_rs_get_vendor_small, /* 0x0E, ACPI_RESOURCE_NAME_VENDOR_SMALL */
acpi_rs_convert_end_tag /* 0x0F, ACPI_RESOURCE_NAME_END_TAG */
};
ACPI_GET_RESOURCE_HANDLER acpi_gbl_lg_get_resource_dispatch[] = {
struct acpi_rsconvert_info *acpi_gbl_lg_get_resource_dispatch[] = {
NULL, /* 0x00, Reserved */
acpi_rs_get_memory24, /* 0x01, ACPI_RESOURCE_NAME_MEMORY24 */
acpi_rs_get_generic_reg, /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */
acpi_rs_convert_memory24, /* 0x01, ACPI_RESOURCE_NAME_MEMORY24 */
acpi_rs_convert_generic_reg, /* 0x02, ACPI_RESOURCE_NAME_GENERIC_REGISTER */
NULL, /* 0x03, Reserved */
acpi_rs_get_vendor, /* 0x04, ACPI_RESOURCE_NAME_VENDOR_LARGE */
acpi_rs_get_memory32, /* 0x05, ACPI_RESOURCE_NAME_MEMORY32 */
acpi_rs_get_fixed_memory32, /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY32 */
acpi_rs_get_address32, /* 0x07, ACPI_RESOURCE_NAME_ADDRESS32 */
acpi_rs_get_address16, /* 0x08, ACPI_RESOURCE_NAME_ADDRESS16 */
acpi_rs_get_ext_irq, /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_IRQ */
acpi_rs_get_address64, /* 0x0A, ACPI_RESOURCE_NAME_ADDRESS64 */
acpi_rs_get_ext_address64 /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64 */
acpi_rs_get_vendor_large, /* 0x04, ACPI_RESOURCE_NAME_VENDOR_LARGE */
acpi_rs_convert_memory32, /* 0x05, ACPI_RESOURCE_NAME_MEMORY32 */
acpi_rs_convert_fixed_memory32, /* 0x06, ACPI_RESOURCE_NAME_FIXED_MEMORY32 */
acpi_rs_convert_address32, /* 0x07, ACPI_RESOURCE_NAME_ADDRESS32 */
acpi_rs_convert_address16, /* 0x08, ACPI_RESOURCE_NAME_ADDRESS16 */
acpi_rs_convert_ext_irq, /* 0x09, ACPI_RESOURCE_NAME_EXTENDED_IRQ */
acpi_rs_convert_address64, /* 0x0A, ACPI_RESOURCE_NAME_ADDRESS64 */
acpi_rs_convert_ext_address64 /* 0x0B, ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64 */
};
#ifdef ACPI_FUTURE_USAGE
@@ -119,7 +119,7 @@ ACPI_GET_RESOURCE_HANDLER acpi_gbl_lg_get_resource_dispatch[] = {
/* Dispatch table for resource dump functions */
ACPI_DUMP_RESOURCE_HANDLER acpi_gbl_dump_resource_dispatch[] = {
struct acpi_rsdump_info *acpi_gbl_dump_resource_dispatch[] = {
acpi_rs_dump_irq, /* ACPI_RESOURCE_TYPE_IRQ */
acpi_rs_dump_dma, /* ACPI_RESOURCE_TYPE_DMA */
acpi_rs_dump_start_dpf, /* ACPI_RESOURCE_TYPE_START_DEPENDENT */
@@ -136,17 +136,17 @@ ACPI_DUMP_RESOURCE_HANDLER acpi_gbl_dump_resource_dispatch[] = {
acpi_rs_dump_address64, /* ACPI_RESOURCE_TYPE_ADDRESS64 */
acpi_rs_dump_ext_address64, /* ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64 */
acpi_rs_dump_ext_irq, /* ACPI_RESOURCE_TYPE_EXTENDED_IRQ */
acpi_rs_dump_generic_reg /* ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
acpi_rs_dump_generic_reg, /* ACPI_RESOURCE_TYPE_GENERIC_REGISTER */
};
#endif
#endif /* ACPI_FUTURE_USAGE */
/*
* Base sizes for external AML resource descriptors, indexed by internal type.
* Includes size of the descriptor header (1 byte for small descriptors,
* 3 bytes for large descriptors)
*/
u8 acpi_gbl_aml_resource_sizes[] = {
const u8 acpi_gbl_aml_resource_sizes[] = {
sizeof(struct aml_resource_irq), /* ACPI_RESOURCE_TYPE_IRQ (optional Byte 3 always created) */
sizeof(struct aml_resource_dma), /* ACPI_RESOURCE_TYPE_DMA */
sizeof(struct aml_resource_start_dependent), /* ACPI_RESOURCE_TYPE_START_DEPENDENT (optional Byte 1 always created) */
@@ -168,8 +168,8 @@ u8 acpi_gbl_aml_resource_sizes[] = {
/* Macros used in the tables below */
#define ACPI_RLARGE(r) sizeof (r) - sizeof (struct aml_resource_large_header)
#define ACPI_RSMALL(r) sizeof (r) - sizeof (struct aml_resource_small_header)
#define ACPI_RLARGE(r) (sizeof (r) - sizeof (struct aml_resource_large_header))
#define ACPI_RSMALL(r) (sizeof (r) - sizeof (struct aml_resource_small_header))
/*
* Base sizes of resource descriptors, both the AML stream resource length
@@ -182,47 +182,46 @@ struct acpi_resource_info acpi_gbl_sm_resource_info[] = {
{0, 0, 0},
{0, 0, 0},
{2, ACPI_RSMALL(struct aml_resource_irq),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_irq)},
ACPI_RS_SIZE(struct acpi_resource_irq)},
{0, ACPI_RSMALL(struct aml_resource_dma),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma)},
ACPI_RS_SIZE(struct acpi_resource_dma)},
{2, ACPI_RSMALL(struct aml_resource_start_dependent),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_start_dependent)},
{0, ACPI_RSMALL(struct aml_resource_end_dependent),
ACPI_RESOURCE_LENGTH},
ACPI_RS_SIZE(struct acpi_resource_start_dependent)},
{0, ACPI_RSMALL(struct aml_resource_end_dependent), ACPI_RS_SIZE_MIN},
{0, ACPI_RSMALL(struct aml_resource_io),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_io)},
ACPI_RS_SIZE(struct acpi_resource_io)},
{0, ACPI_RSMALL(struct aml_resource_fixed_io),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io)},
ACPI_RS_SIZE(struct acpi_resource_fixed_io)},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{1, ACPI_RSMALL(struct aml_resource_vendor_small),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor)},
{0, ACPI_RSMALL(struct aml_resource_end_tag), ACPI_RESOURCE_LENGTH}
ACPI_RS_SIZE(struct acpi_resource_vendor)},
{0, ACPI_RSMALL(struct aml_resource_end_tag), ACPI_RS_SIZE_MIN}
};
struct acpi_resource_info acpi_gbl_lg_resource_info[] = {
{0, 0, 0},
{0, ACPI_RLARGE(struct aml_resource_memory24),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory24)},
ACPI_RS_SIZE(struct acpi_resource_memory24)},
{0, ACPI_RLARGE(struct aml_resource_generic_register),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_generic_register)},
ACPI_RS_SIZE(struct acpi_resource_generic_register)},
{0, 0, 0},
{1, ACPI_RLARGE(struct aml_resource_vendor_large),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor)},
ACPI_RS_SIZE(struct acpi_resource_vendor)},
{0, ACPI_RLARGE(struct aml_resource_memory32),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory32)},
ACPI_RS_SIZE(struct acpi_resource_memory32)},
{0, ACPI_RLARGE(struct aml_resource_fixed_memory32),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_memory32)},
ACPI_RS_SIZE(struct acpi_resource_fixed_memory32)},
{1, ACPI_RLARGE(struct aml_resource_address32),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address32)},
ACPI_RS_SIZE(struct acpi_resource_address32)},
{1, ACPI_RLARGE(struct aml_resource_address16),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address16)},
ACPI_RS_SIZE(struct acpi_resource_address16)},
{1, ACPI_RLARGE(struct aml_resource_extended_irq),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_irq)},
ACPI_RS_SIZE(struct acpi_resource_extended_irq)},
{1, ACPI_RLARGE(struct aml_resource_address64),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_address64)},
ACPI_RS_SIZE(struct acpi_resource_address64)},
{0, ACPI_RLARGE(struct aml_resource_extended_address64),
ACPI_SIZEOF_RESOURCE(struct acpi_resource_extended_address64)}
ACPI_RS_SIZE(struct acpi_resource_extended_address64)}
};

375
drivers/acpi/resources/rsio.c
查看文件

@@ -49,269 +49,206 @@ ACPI_MODULE_NAME("rsio")
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_io
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* acpi_rs_convert_io
*
******************************************************************************/
acpi_status
acpi_rs_get_io(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
ACPI_FUNCTION_TRACE("rs_get_io");
struct acpi_rsconvert_info acpi_rs_convert_io[5] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IO,
ACPI_RS_SIZE(struct acpi_resource_io),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_io)},
/* Get the Decode flag */
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_IO,
sizeof(struct aml_resource_io),
0},
resource->data.io.io_decode = aml->io.information & 0x01;
/* Decode flag */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.io.io_decode),
AML_OFFSET(io.flags),
0},
/*
* Get the following contiguous fields from the AML descriptor:
* Minimum Base Address
* Maximum Base Address
* These fields are contiguous in both the source and destination:
* Address Alignment
* Length
* Minimum Base Address
* Maximum Base Address
*/
ACPI_MOVE_16_TO_32(&resource->data.io.minimum, &aml->io.minimum);
ACPI_MOVE_16_TO_32(&resource->data.io.maximum, &aml->io.maximum);
resource->data.io.alignment = aml->io.alignment;
resource->data.io.address_length = aml->io.address_length;
{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");
/* I/O Information Byte */
aml->io.information = (u8) (resource->data.io.io_decode & 0x01);
struct acpi_rsconvert_info acpi_rs_convert_fixed_io[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_IO,
ACPI_RS_SIZE(struct acpi_resource_fixed_io),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_io)},
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_IO,
sizeof(struct aml_resource_fixed_io),
0},
/*
* Set the following contiguous fields in the AML descriptor:
* Minimum Base Address
* Maximum Base Address
* Address Alignment
* 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)}
};

377
drivers/acpi/resources/rsirq.c
查看文件

@@ -49,325 +49,182 @@ ACPI_MODULE_NAME("rsirq")
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_irq
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* acpi_rs_get_irq
*
******************************************************************************/
acpi_status
acpi_rs_get_irq(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
u16 temp16 = 0;
u32 interrupt_count = 0;
u32 i;
u32 resource_length;
ACPI_FUNCTION_TRACE("rs_get_irq");
struct acpi_rsconvert_info acpi_rs_get_irq[7] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_IRQ,
ACPI_RS_SIZE(struct acpi_resource_irq),
ACPI_RSC_TABLE_SIZE(acpi_rs_get_irq)},
/* Get the IRQ mask (bytes 1:2) */
ACPI_MOVE_16_TO_16(&temp16, &aml->irq.irq_mask);
{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)}
};

92
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 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml)
return (AE_AML_INVALID_RESOURCE_TYPE);
}
resource_length = acpi_rs_get_resource_length(aml);
resource_length = acpi_ut_get_resource_length(aml);
minimum_aml_resource_length =
resource_info->minimum_aml_resource_length;
@@ -115,18 +116,17 @@ static acpi_status acpi_rs_validate_resource_length(union aml_resource *aml)
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_resource_handler
* FUNCTION: acpi_rs_get_conversion_info
*
* PARAMETERS: resource_type - Byte 0 of a resource descriptor
*
* RETURN: Pointer to the resource conversion handler
* RETURN: Pointer to the resource conversion info table
*
* DESCRIPTION: Extract the Resource Type/Name from the first byte of
* a resource descriptor.
* DESCRIPTION: Get the conversion table associated with this resource type
*
******************************************************************************/
static ACPI_GET_RESOURCE_HANDLER acpi_rs_get_resource_handler(u8 resource_type)
static struct acpi_rsconvert_info *acpi_rs_get_conversion_info(u8 resource_type)
{
ACPI_FUNCTION_ENTRY();
@@ -174,33 +174,24 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
acpi_status status;
acpi_size bytes_parsed = 0;
struct acpi_resource *resource;
u16 resource_length;
u32 descriptor_length;
ACPI_GET_RESOURCE_HANDLER handler;
acpi_rsdesc_size descriptor_length;
struct acpi_rsconvert_info *info;
ACPI_FUNCTION_TRACE("rs_convert_aml_to_resources");
/* Loop until end-of-buffer or an end_tag is found */
while (bytes_parsed < aml_buffer_length) {
/* Get the handler associated with this Descriptor Type */
/* Get the conversion table associated with this Descriptor Type */
handler = acpi_rs_get_resource_handler(*aml_buffer);
if (!handler) {
/* No handler indicates invalid resource type */
info = acpi_rs_get_conversion_info(*aml_buffer);
if (!info) {
/* No table indicates an invalid resource type */
return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
}
resource_length =
acpi_rs_get_resource_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
descriptor_length =
acpi_rs_get_descriptor_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
descriptor_length = acpi_ut_get_descriptor_length(aml_buffer);
/*
* Perform limited validation of the resource length, based upon
@@ -214,11 +205,16 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
return_ACPI_STATUS(status);
}
/* Convert a byte stream resource to local resource struct */
/* Convert the AML byte stream resource to a local resource struct */
status = handler(ACPI_CAST_PTR(union aml_resource, aml_buffer),
resource_length,
ACPI_CAST_PTR(struct acpi_resource, buffer));
status =
acpi_rs_convert_aml_to_resource(ACPI_CAST_PTR
(struct acpi_resource,
buffer),
ACPI_CAST_PTR(union
aml_resource,
aml_buffer),
info);
if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Could not convert AML resource (type %X) to resource, %s\n", *aml_buffer, acpi_format_exception(status)));
return_ACPI_STATUS(status);
@@ -232,7 +228,7 @@ acpi_rs_convert_aml_to_resources(u8 * aml_buffer,
/* Normal exit on completion of an end_tag resource descriptor */
if (acpi_rs_get_resource_type(*aml_buffer) ==
if (acpi_ut_get_resource_type(aml_buffer) ==
ACPI_RESOURCE_NAME_END_TAG) {
return_ACPI_STATUS(AE_OK);
}
@@ -276,14 +272,15 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
acpi_size aml_size_needed, u8 * output_buffer)
{
u8 *aml_buffer = output_buffer;
u8 *end_aml_buffer = output_buffer + aml_size_needed;
acpi_status status;
ACPI_FUNCTION_TRACE("rs_convert_resources_to_aml");
/* Convert each resource descriptor in the list */
/* Walk the resource descriptor list, convert each descriptor */
while (1) {
/* Validate Resource Descriptor Type before dispatch */
while (aml_buffer < end_aml_buffer) {
/* Validate the Resource Type */
if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
@@ -292,14 +289,14 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
return_ACPI_STATUS(AE_BAD_DATA);
}
/* Perform the conversion per resource type */
/* Perform the conversion */
status =
acpi_gbl_set_resource_dispatch[resource->type] (resource,
ACPI_CAST_PTR
(union
aml_resource,
aml_buffer));
status = acpi_rs_convert_resource_to_aml(resource,
ACPI_CAST_PTR(union
aml_resource,
aml_buffer),
acpi_gbl_set_resource_dispatch
[resource->type]);
if (ACPI_FAILURE(status)) {
ACPI_REPORT_ERROR(("Could not convert resource (type %X) to AML, %s\n", resource->type, acpi_format_exception(status)));
return_ACPI_STATUS(status);
@@ -323,18 +320,23 @@ acpi_rs_convert_resources_to_aml(struct acpi_resource *resource,
return_ACPI_STATUS(AE_OK);
}
/* Extract the total length of the new descriptor */
/* Set the aml_buffer to point to the next (output) resource descriptor */
aml_buffer +=
acpi_rs_get_descriptor_length(ACPI_CAST_PTR
(union aml_resource,
aml_buffer));
/*
* Extract the total length of the new descriptor and set the
* aml_buffer to point to the next (output) resource descriptor
*/
aml_buffer += acpi_ut_get_descriptor_length(aml_buffer);
/* Point to the next input resource descriptor */
resource =
ACPI_PTR_ADD(struct acpi_resource, resource,
resource->length);
/* Check for end-of-list, normal exit */
}
/* Completed buffer, but did not find an end_tag resource descriptor */
return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);
}

337
drivers/acpi/resources/rsmemory.c
查看文件

@@ -49,260 +49,187 @@ ACPI_MODULE_NAME("rsmemory")
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_memory24
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* acpi_rs_convert_memory24
*
******************************************************************************/
acpi_status
acpi_rs_get_memory24(union aml_resource * aml,
u16 aml_resource_length, struct acpi_resource * resource)
{
ACPI_FUNCTION_TRACE("rs_get_memory24");
struct acpi_rsconvert_info acpi_rs_convert_memory24[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY24,
ACPI_RS_SIZE(struct acpi_resource_memory24),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_memory24)},
/* Get the Read/Write bit */
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_MEMORY24,
sizeof(struct aml_resource_memory24),
0},
resource->data.memory24.read_write_attribute =
(aml->memory24.information & 0x01);
/* Read/Write bit */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.memory24.write_protect),
AML_OFFSET(memory24.flags),
0},
/*
* Get the following contiguous fields from the AML descriptor:
* These fields are contiguous in both the source and destination:
* Minimum Base Address
* Maximum Base Address
* Address Base Alignment
* Range Length
*/
acpi_rs_move_data(&resource->data.memory24.minimum,
&aml->memory24.minimum, 4, ACPI_MOVE_TYPE_16_TO_32);
/* Complete the resource header */
resource->type = ACPI_RESOURCE_TYPE_MEMORY24;
resource->length = ACPI_SIZEOF_RESOURCE(struct acpi_resource_memory24);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE16, ACPI_RS_OFFSET(data.memory24.minimum),
AML_OFFSET(memory24.minimum),
4}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_set_memory24
*
* PARAMETERS: Resource - Pointer to the resource descriptor
* Aml - Where the AML descriptor is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert an internal resource descriptor to the corresponding
* external AML resource descriptor.
* acpi_rs_convert_memory32
*
******************************************************************************/
acpi_status
acpi_rs_set_memory24(struct acpi_resource *resource, union aml_resource *aml)
{
ACPI_FUNCTION_TRACE("rs_set_memory24");
struct acpi_rsconvert_info acpi_rs_convert_memory32[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_MEMORY32,
ACPI_RS_SIZE(struct acpi_resource_memory32),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_memory32)},
/* Set the Information Byte */
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_MEMORY32,
sizeof(struct aml_resource_memory32),
0},
aml->memory24.information = (u8)
(resource->data.memory24.read_write_attribute & 0x01);
/* Read/Write bit */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.memory32.write_protect),
AML_OFFSET(memory32.flags),
0},
/*
* Set the following contiguous fields in the AML descriptor:
* These fields are contiguous in both the source and destination:
* Minimum Base Address
* Maximum Base Address
* Address Base Alignment
* Range Length
*/
acpi_rs_move_data(&aml->memory24.minimum,
&resource->data.memory24.minimum, 4,
ACPI_MOVE_TYPE_32_TO_16);
/* Complete the AML descriptor header */
acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_MEMORY24,
sizeof(struct aml_resource_memory24), aml);
return_ACPI_STATUS(AE_OK);
}
{ACPI_RSC_MOVE32, ACPI_RS_OFFSET(data.memory32.minimum),
AML_OFFSET(memory32.minimum),
4}
};
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_memory32
*
* PARAMETERS: Aml - Pointer to the AML resource descriptor
* aml_resource_length - Length of the resource from the AML header
* Resource - Where the internal resource is returned
*
* RETURN: Status
*
* DESCRIPTION: Convert a raw AML resource descriptor to the corresponding
* internal resource descriptor, simplifying bitflags and handling
* alignment and endian issues if necessary.
* acpi_rs_convert_fixed_memory32
*
******************************************************************************/
acpi_status
acpi_rs_get_memory32(union aml_resource *aml,
u16 aml_resource_length, struct acpi_resource *resource)
{
ACPI_FUNCTION_TRACE("rs_get_memory32");
struct acpi_rsconvert_info acpi_rs_convert_fixed_memory32[4] = {
{ACPI_RSC_INITGET, ACPI_RESOURCE_TYPE_FIXED_MEMORY32,
ACPI_RS_SIZE(struct acpi_resource_fixed_memory32),
ACPI_RSC_TABLE_SIZE(acpi_rs_convert_fixed_memory32)},
/* Get the Read/Write bit */
{ACPI_RSC_INITSET, ACPI_RESOURCE_NAME_FIXED_MEMORY32,
sizeof(struct aml_resource_fixed_memory32),
0},
resource->data.memory32.read_write_attribute =
(aml->memory32.information & 0x01);
/* Read/Write bit */
{ACPI_RSC_1BITFLAG, ACPI_RS_OFFSET(data.fixed_memory32.write_protect),
AML_OFFSET(fixed_memory32.flags),
0},
/*
* Get the following contiguous fields from the AML descriptor:
* Minimum Base Address
* Maximum Base Address
* Address Base Alignment
* 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}
};

812
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);
}
/*******************************************************************************
*
* 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);
if (resource->data.dma.transfer == 0x03) {
ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
"Invalid DMA.Transfer preference (3)\n"));
return_ACPI_STATUS(AE_BAD_DATA);
}
#endif

277
drivers/acpi/resources/rsutils.c
查看文件

@@ -48,6 +48,64 @@
#define _COMPONENT ACPI_RESOURCES
ACPI_MODULE_NAME("rsutils")
/*******************************************************************************
*
* FUNCTION: acpi_rs_decode_bitmask
*
* PARAMETERS: Mask - Bitmask to decode
* List - Where the converted list is returned
*
* RETURN: Count of bits set (length of list)
*
* DESCRIPTION: Convert a bit mask into a list of values
*
******************************************************************************/
u8 acpi_rs_decode_bitmask(u16 mask, u8 * list)
{
acpi_native_uint i;
u8 bit_count;
/* Decode the mask bits */
for (i = 0, bit_count = 0; mask; i++) {
if (mask & 0x0001) {
list[bit_count] = (u8) i;
bit_count++;
}
mask >>= 1;
}
return (bit_count);
}
/*******************************************************************************
*
* FUNCTION: acpi_rs_encode_bitmask
*
* PARAMETERS: List - List of values to encode
* Count - Length of list
*
* RETURN: Encoded bitmask
*
* DESCRIPTION: Convert a list of values to an encoded bitmask
*
******************************************************************************/
u16 acpi_rs_encode_bitmask(u8 * list, u8 count)
{
acpi_native_uint i;
u16 mask;
/* Encode the list into a single bitmask */
for (i = 0, mask = 0; i < count; i++) {
mask |= (0x0001 << list[i]);
}
return (mask);
}
/*******************************************************************************
*
* FUNCTION: acpi_rs_move_data
@@ -64,6 +122,7 @@ ACPI_MODULE_NAME("rsutils")
* via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
*
******************************************************************************/
void
acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type)
{
@@ -73,22 +132,30 @@ acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type)
for (i = 0; i < item_count; i++) {
switch (move_type) {
case ACPI_MOVE_TYPE_16_TO_32:
ACPI_MOVE_16_TO_32(&((u32 *) destination)[i],
/*
* 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 @@ struct acpi_resource_info *acpi_rs_get_resource_info(u8 resource_type)
/*******************************************************************************
*
* FUNCTION: acpi_rs_get_resource_length
* FUNCTION: acpi_rs_set_resource_length
*
* PARAMETERS: Aml - Pointer to the raw AML resource descriptor
* PARAMETERS: total_length - Length of the AML descriptor, including
* the header and length fields.
* Aml - Pointer to the raw AML descriptor
*
* RETURN: Byte Length
* RETURN: None
*
* DESCRIPTION: Get the "Resource Length" of a raw AML descriptor. By
* definition, this does not include the size of the descriptor
* header or the length field itself.
* DESCRIPTION: Set the resource_length field of an AML
* resource descriptor, both Large and Small descriptors are
* supported automatically. Note: Descriptor Type field must
* be valid.
*
******************************************************************************/
u16 acpi_rs_get_resource_length(union aml_resource * aml)
void
acpi_rs_set_resource_length(acpi_rsdesc_size total_length,
union aml_resource *aml)
{
u16 resource_length;
acpi_rs_length resource_length;
ACPI_FUNCTION_ENTRY();
/* Determine if this is a small or large resource */
if (aml->large_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
/* Large Resource type -- bytes 1-2 contain the 16-bit length */
ACPI_MOVE_16_TO_16(&resource_length,
&aml->large_header.resource_length);
resource_length = (acpi_rs_length)
(total_length - sizeof(struct aml_resource_large_header));
/* Insert length into the Large descriptor length field */
ACPI_MOVE_16_TO_16(&aml->large_header.resource_length,
&resource_length);
} else {
/* Small Resource type -- bits 2:0 of byte 0 contain the length */
resource_length = (u16) (aml->small_header.descriptor_type &
ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK);
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 @@ u32 acpi_rs_get_descriptor_length(union aml_resource * aml)
void
acpi_rs_set_resource_header(u8 descriptor_type,
acpi_size total_length, union aml_resource *aml)
acpi_rsdesc_size total_length,
union aml_resource *aml)
{
u16 resource_length;
ACPI_FUNCTION_ENTRY();
/* Set the descriptor type */
/* Set the Descriptor Type */
aml->small_header.descriptor_type = descriptor_type;
/* Determine if this is a small or large resource */
/* 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 @@ static u16 acpi_rs_strcpy(char *destination, char *source)
*
******************************************************************************/
u16
acpi_rs_get_resource_source(u16 resource_length,
acpi_size minimum_length,
acpi_rs_length
acpi_rs_get_resource_source(acpi_rs_length resource_length,
acpi_rs_length minimum_length,
struct acpi_resource_source * resource_source,
union aml_resource * aml, char *string_ptr)
{
acpi_size total_length;
acpi_rsdesc_size total_length;
u8 *aml_resource_source;
ACPI_FUNCTION_ENTRY();
@@ -382,7 +373,7 @@ acpi_rs_get_resource_source(u16 resource_length,
* Note: Some resource descriptors will have an additional null, so
* we add 1 to the minimum length.
*/
if (total_length > (minimum_length + 1)) {
if (total_length > (acpi_rsdesc_size) (minimum_length + 1)) {
/* Get the resource_source_index */
resource_source->index = aml_resource_source[0];
@@ -398,20 +389,26 @@ acpi_rs_get_resource_source(u16 resource_length,
sizeof(struct acpi_resource_source);
}
/*
* In order for the struct_size to fall on a 32-bit boundary, calculate
* the length of the string (+1 for the NULL terminator) and expand the
* struct_size to the next 32-bit boundary.
*
* Zero the entire area of the buffer.
*/
total_length =
ACPI_ROUND_UP_to_32_bITS(ACPI_STRLEN
((char *)&aml_resource_source[1]) +
1);
ACPI_MEMSET(resource_source->string_ptr, 0, total_length);
/* Copy the resource_source string to the destination */
resource_source->string_length =
acpi_rs_strcpy(resource_source->string_ptr,
(char *)&aml_resource_source[1]);
/*
* In order for the struct_size to fall on a 32-bit boundary,
* calculate the length of the string and expand the
* struct_size to the next 32-bit boundary.
*/
return ((u16)
ACPI_ROUND_UP_to_32_bITS(resource_source->
string_length));
return ((acpi_rs_length) total_length);
} else {
/* resource_source is not present */
@@ -434,18 +431,18 @@ acpi_rs_get_resource_source(u16 resource_length,
*
* RETURN: Total length of the AML descriptor
*
* DESCRIPTION: Convert an optoinal resource_source from internal format to a
* DESCRIPTION: Convert an optional resource_source from internal format to a
* raw AML resource descriptor
*
******************************************************************************/
acpi_size
acpi_rsdesc_size
acpi_rs_set_resource_source(union aml_resource * aml,
acpi_size minimum_length,
acpi_rs_length minimum_length,
struct acpi_resource_source * resource_source)
{
u8 *aml_resource_source;
acpi_size descriptor_length;
acpi_rsdesc_size descriptor_length;
ACPI_FUNCTION_ENTRY();
@@ -472,7 +469,7 @@ acpi_rs_set_resource_source(union aml_resource * aml,
* final descriptor length
*/
descriptor_length +=
((acpi_size) resource_source->string_length + 1);
((acpi_rsdesc_size) resource_source->string_length + 1);
}
/* Return the new total length of the AML descriptor */

2
drivers/acpi/resources/rsxface.c
查看文件

@@ -57,7 +57,7 @@ ACPI_MODULE_NAME("rsxface")
ACPI_COPY_FIELD(out, in, decode); \
ACPI_COPY_FIELD(out, in, min_address_fixed); \
ACPI_COPY_FIELD(out, in, max_address_fixed); \
ACPI_COPY_FIELD(out, in, attribute); \
ACPI_COPY_FIELD(out, in, info); \
ACPI_COPY_FIELD(out, in, granularity); \
ACPI_COPY_FIELD(out, in, minimum); \
ACPI_COPY_FIELD(out, in, maximum); \