X-Git-Url: https://git.stricted.de/?a=blobdiff_plain;f=drivers%2Facpi%2Fresources%2Frsaddr.c;h=6f48ebf3304e12caa68694b80ae64d755c4fa410;hb=50eca3eb89d73d9f0aa070b126c7ee6a616016ab;hp=55d264771c4805ac9e2b2da2acc18789f47ed04c;hpb=30beab1491f0b96b2f23d3fb68af01fd921a16d8;p=GitHub%2Fmt8127%2Fandroid_kernel_alcatel_ttab.git diff --git a/drivers/acpi/resources/rsaddr.c b/drivers/acpi/resources/rsaddr.c index 55d264771c48..6f48ebf3304e 100644 --- a/drivers/acpi/resources/rsaddr.c +++ b/drivers/acpi/resources/rsaddr.c @@ -41,1117 +41,689 @@ * POSSIBILITY OF SUCH DAMAGES. */ - #include #include #define _COMPONENT ACPI_RESOURCES - ACPI_MODULE_NAME ("rsaddr") +ACPI_MODULE_NAME("rsaddr") + +/* Local prototypes */ +static void +acpi_rs_decode_general_flags(union acpi_resource_data *resource, u8 flags); + +static u8 acpi_rs_encode_general_flags(union acpi_resource_data *resource); + +static void +acpi_rs_decode_specific_flags(union acpi_resource_data *resource, u8 flags); + +static u8 acpi_rs_encode_specific_flags(union acpi_resource_data *resource); +static void +acpi_rs_set_address_common(union aml_resource *aml, + struct acpi_resource *resource); + +static u8 +acpi_rs_get_address_common(struct acpi_resource *resource, + union aml_resource *aml); /******************************************************************************* * - * FUNCTION: acpi_rs_address16_resource + * FUNCTION: acpi_rs_decode_general_flags * - * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte - * stream - * bytes_consumed - Pointer to where the number of bytes - * consumed the byte_stream_buffer is - * returned - * output_buffer - Pointer to the return data buffer - * structure_size - Pointer to where the number of bytes - * in the return data struct is returned + * PARAMETERS: Resource - Address resource data struct + * Flags - Raw AML flag byte * - * RETURN: Status + * RETURN: Decoded flag bits in resource struct * - * DESCRIPTION: Take the resource byte stream and fill out the appropriate - * structure pointed to by the output_buffer. Return the - * number of bytes consumed from the byte stream. + * DESCRIPTION: Decode a general flag byte to an address resource struct * ******************************************************************************/ -acpi_status -acpi_rs_address16_resource ( - u8 *byte_stream_buffer, - acpi_size *bytes_consumed, - u8 **output_buffer, - acpi_size *structure_size) +static void +acpi_rs_decode_general_flags(union acpi_resource_data *resource, u8 flags) { - u32 index; - u16 temp16; - u8 temp8; - u8 *temp_ptr; - u8 *buffer = byte_stream_buffer; - struct acpi_resource *output_struct = (void *) *output_buffer; - acpi_size struct_size = ACPI_SIZEOF_RESOURCE ( - struct acpi_resource_address16); - - - ACPI_FUNCTION_TRACE ("rs_address16_resource"); + ACPI_FUNCTION_ENTRY(); + /* Producer / Consumer - flag bit[0] */ - /* Point past the Descriptor to get the number of bytes consumed */ + resource->address.producer_consumer = (u32) (flags & 0x01); - buffer += 1; - ACPI_MOVE_16_TO_16 (&temp16, buffer); + /* Decode (_DEC) - flag bit[1] */ - /* Validate minimum descriptor length */ + resource->address.decode = (u32) ((flags >> 1) & 0x01); - if (temp16 < 13) { - return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH); - } - - *bytes_consumed = temp16 + 3; - output_struct->id = ACPI_RSTYPE_ADDRESS16; - - /* Get the Resource Type (Byte3) */ - - buffer += 2; - temp8 = *buffer; - - /* Values 0-2 and 0xC0-0xFF are valid */ + /* Min Address Fixed (_MIF) - flag bit[2] */ - if ((temp8 > 2) && (temp8 < 0xC0)) { - return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE); - } - - output_struct->data.address16.resource_type = temp8; + resource->address.min_address_fixed = (u32) ((flags >> 2) & 0x01); - /* Get the General Flags (Byte4) */ + /* Max Address Fixed (_MAF) - flag bit[3] */ - buffer += 1; - temp8 = *buffer; + resource->address.max_address_fixed = (u32) ((flags >> 3) & 0x01); +} - /* Producer / Consumer */ +/******************************************************************************* + * + * 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 + * + ******************************************************************************/ - output_struct->data.address16.producer_consumer = temp8 & 0x01; +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)) + ); +} - /* Decode */ +/******************************************************************************* + * + * 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. + * + ******************************************************************************/ - output_struct->data.address16.decode = (temp8 >> 1) & 0x01; +static void +acpi_rs_decode_specific_flags(union acpi_resource_data *resource, u8 flags) +{ + ACPI_FUNCTION_ENTRY(); - /* Min Address Fixed */ + if (resource->address.resource_type == ACPI_MEMORY_RANGE) { + /* Write Status (_RW) - flag bit[0] */ - output_struct->data.address16.min_address_fixed = (temp8 >> 2) & 0x01; + resource->address.attribute.memory.read_write_attribute = + (u16) (flags & 0x01); - /* Max Address Fixed */ + /* Memory Attributes (_MEM) - flag bits[2:1] */ - output_struct->data.address16.max_address_fixed = (temp8 >> 3) & 0x01; + 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] */ - /* Get the Type Specific Flags (Byte5) */ + resource->address.attribute.io.range_attribute = + (u16) (flags & 0x03); - buffer += 1; - temp8 = *buffer; + /* Translations (_TTP and _TRS) - flag bits[5:4] */ - if (ACPI_MEMORY_RANGE == output_struct->data.address16.resource_type) { - output_struct->data.address16.attribute.memory.read_write_attribute = - (u16) (temp8 & 0x01); - output_struct->data.address16.attribute.memory.cache_attribute = - (u16) ((temp8 >> 1) & 0x03); + resource->address.attribute.io.translation_attribute = + (u16) ((flags >> 4) & 0x03); } - else { - if (ACPI_IO_RANGE == output_struct->data.address16.resource_type) { - output_struct->data.address16.attribute.io.range_attribute = - (u16) (temp8 & 0x03); - output_struct->data.address16.attribute.io.translation_attribute = - (u16) ((temp8 >> 4) & 0x03); - } - else { - /* BUS_NUMBER_RANGE == Address16.Data->resource_type */ - /* Nothing needs to be filled in */ - } - } - - /* Get Granularity (Bytes 6-7) */ - - buffer += 1; - ACPI_MOVE_16_TO_32 (&output_struct->data.address16.granularity, buffer); - - /* Get min_address_range (Bytes 8-9) */ - - buffer += 2; - ACPI_MOVE_16_TO_32 (&output_struct->data.address16.min_address_range, buffer); - - /* Get max_address_range (Bytes 10-11) */ - - buffer += 2; - ACPI_MOVE_16_TO_32 (&output_struct->data.address16.max_address_range, buffer); - - /* Get address_translation_offset (Bytes 12-13) */ - - buffer += 2; - ACPI_MOVE_16_TO_32 (&output_struct->data.address16.address_translation_offset, - buffer); - - /* Get address_length (Bytes 14-15) */ - - buffer += 2; - ACPI_MOVE_16_TO_32 (&output_struct->data.address16.address_length, buffer); - - /* Resource Source Index (if present) */ - - buffer += 2; - - /* - * This will leave us pointing to the Resource Source Index - * If it is present, then save it off and calculate the - * pointer to where the null terminated string goes: - * Each Interrupt takes 32-bits + the 5 bytes of the - * stream that are default. - * - * Note: Some resource descriptors will have an additional null, so - * we add 1 to the length. - */ - if (*bytes_consumed > (16 + 1)) { - /* Dereference the Index */ - - temp8 = *buffer; - output_struct->data.address16.resource_source.index = (u32) temp8; - - /* Point to the String */ - - buffer += 1; - - /* Point the String pointer to the end of this structure */ - - output_struct->data.address16.resource_source.string_ptr = - (char *)((u8 * )output_struct + struct_size); - - temp_ptr = (u8 *) - output_struct->data.address16.resource_source.string_ptr; - - /* Copy the string into the buffer */ - - index = 0; - - while (0x00 != *buffer) { - *temp_ptr = *buffer; - - temp_ptr += 1; - buffer += 1; - index += 1; - } - - /* Add the terminating null */ - - *temp_ptr = 0x00; +} - output_struct->data.address16.resource_source.string_length = index + 1; +/******************************************************************************* + * + * 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. + * + ******************************************************************************/ - /* - * 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. - */ - temp8 = (u8) (index + 1); - struct_size += ACPI_ROUND_UP_to_32_bITS (temp8); - } - else { - output_struct->data.address16.resource_source.index = 0x00; - output_struct->data.address16.resource_source.string_length = 0; - output_struct->data.address16.resource_source.string_ptr = NULL; +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))); } - /* Set the Length parameter */ - - output_struct->length = (u32) struct_size; - - /* Return the final size of the structure */ - - *structure_size = struct_size; - return_ACPI_STATUS (AE_OK); + return (0); } - /******************************************************************************* * - * FUNCTION: acpi_rs_address16_stream + * FUNCTION: acpi_rs_set_address_common * - * PARAMETERS: linked_list - Pointer to the resource linked list - * output_buffer - Pointer to the user's return buffer - * bytes_consumed - Pointer to where the number of bytes - * used in the output_buffer is returned + * PARAMETERS: Aml - Pointer to the AML resource descriptor + * Resource - Pointer to the internal resource struct * - * RETURN: Status + * RETURN: None * - * DESCRIPTION: Take the linked list resource structure and fills in the - * the appropriate bytes in a byte stream + * DESCRIPTION: Convert common flag fields from a resource descriptor to an + * AML descriptor * ******************************************************************************/ -acpi_status -acpi_rs_address16_stream ( - struct acpi_resource *linked_list, - u8 **output_buffer, - acpi_size *bytes_consumed) +static void +acpi_rs_set_address_common(union aml_resource *aml, + struct acpi_resource *resource) { - u8 *buffer = *output_buffer; - u8 *length_field; - u8 temp8; - char *temp_pointer = NULL; - acpi_size actual_bytes; - + ACPI_FUNCTION_ENTRY(); - ACPI_FUNCTION_TRACE ("rs_address16_stream"); + /* Set the Resource Type (Memory, Io, bus_number, etc.) */ - - /* The descriptor field is static */ - - *buffer = 0x88; - buffer += 1; - - /* Save a pointer to the Length field - to be filled in later */ - - length_field = buffer; - buffer += 2; - - /* Set the Resource Type (Memory, Io, bus_number) */ - - temp8 = (u8) (linked_list->data.address16.resource_type & 0x03); - *buffer = temp8; - buffer += 1; + aml->address.resource_type = (u8) resource->data.address.resource_type; /* Set the general flags */ - temp8 = (u8) (linked_list->data.address16.producer_consumer & 0x01); + aml->address.flags = acpi_rs_encode_general_flags(&resource->data); - temp8 |= (linked_list->data.address16.decode & 0x01) << 1; - temp8 |= (linked_list->data.address16.min_address_fixed & 0x01) << 2; - temp8 |= (linked_list->data.address16.max_address_fixed & 0x01) << 3; + /* Set the type-specific flags */ - *buffer = temp8; - buffer += 1; + aml->address.specific_flags = + acpi_rs_encode_specific_flags(&resource->data); +} - /* Set the type specific flags */ +/******************************************************************************* + * + * 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 + * + ******************************************************************************/ - temp8 = 0; +static u8 +acpi_rs_get_address_common(struct acpi_resource *resource, + union aml_resource *aml) +{ + ACPI_FUNCTION_ENTRY(); - if (ACPI_MEMORY_RANGE == linked_list->data.address16.resource_type) { - temp8 = (u8) - (linked_list->data.address16.attribute.memory.read_write_attribute & - 0x01); + /* Validate resource type */ - temp8 |= - (linked_list->data.address16.attribute.memory.cache_attribute & - 0x03) << 1; + if ((aml->address.resource_type > 2) + && (aml->address.resource_type < 0xC0)) { + return (FALSE); } - else if (ACPI_IO_RANGE == linked_list->data.address16.resource_type) { - temp8 = (u8) - (linked_list->data.address16.attribute.io.range_attribute & - 0x03); - temp8 |= - (linked_list->data.address16.attribute.io.translation_attribute & - 0x03) << 4; - } - - *buffer = temp8; - buffer += 1; - - /* Set the address space granularity */ - - ACPI_MOVE_32_TO_16 (buffer, &linked_list->data.address16.granularity); - buffer += 2; - - /* Set the address range minimum */ - ACPI_MOVE_32_TO_16 (buffer, &linked_list->data.address16.min_address_range); - buffer += 2; + /* Get the Resource Type (Memory, Io, bus_number, etc.) */ - /* Set the address range maximum */ + resource->data.address.resource_type = aml->address.resource_type; - ACPI_MOVE_32_TO_16 (buffer, &linked_list->data.address16.max_address_range); - buffer += 2; + /* Get the General Flags */ - /* Set the address translation offset */ + acpi_rs_decode_general_flags(&resource->data, aml->address.flags); - ACPI_MOVE_32_TO_16 (buffer, - &linked_list->data.address16.address_translation_offset); - buffer += 2; + /* Get the Type-Specific Flags */ - /* Set the address length */ - - ACPI_MOVE_32_TO_16 (buffer, &linked_list->data.address16.address_length); - buffer += 2; - - /* Resource Source Index and Resource Source are optional */ - - if (0 != linked_list->data.address16.resource_source.string_length) { - temp8 = (u8) linked_list->data.address16.resource_source.index; - - *buffer = temp8; - buffer += 1; - - temp_pointer = (char *) buffer; - - /* Copy the string */ - - ACPI_STRCPY (temp_pointer, - linked_list->data.address16.resource_source.string_ptr); - - /* - * Buffer needs to be set to the length of the sting + one for the - * terminating null - */ - buffer += (acpi_size)(ACPI_STRLEN ( - linked_list->data.address16.resource_source.string_ptr) + 1); - } - - /* Return the number of bytes consumed in this operation */ - - actual_bytes = ACPI_PTR_DIFF (buffer, *output_buffer); - *bytes_consumed = actual_bytes; - - /* - * Set the length field to the number of bytes consumed - * minus the header size (3 bytes) - */ - actual_bytes -= 3; - ACPI_MOVE_SIZE_TO_16 (length_field, &actual_bytes); - return_ACPI_STATUS (AE_OK); + acpi_rs_decode_specific_flags(&resource->data, + aml->address.specific_flags); + return (TRUE); } - /******************************************************************************* * - * FUNCTION: acpi_rs_address32_resource + * FUNCTION: acpi_rs_get_address16 * - * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte - * stream - * bytes_consumed - Pointer to where the number of bytes - * consumed the byte_stream_buffer is - * returned - * output_buffer - Pointer to the return data buffer - * structure_size - Pointer to where the number of bytes - * in the return data struct is returned + * 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: Take the resource byte stream and fill out the appropriate - * structure pointed to by the output_buffer. Return the - * number of bytes consumed from the byte stream. + * 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_address32_resource ( - u8 *byte_stream_buffer, - acpi_size *bytes_consumed, - u8 **output_buffer, - acpi_size *structure_size) +acpi_rs_get_address16(union aml_resource * aml, + u16 aml_resource_length, struct acpi_resource * resource) { - u8 *buffer; - struct acpi_resource *output_struct= (void *) *output_buffer; - u16 temp16; - u8 temp8; - u8 *temp_ptr; - acpi_size struct_size; - u32 index; - - - ACPI_FUNCTION_TRACE ("rs_address32_resource"); - - - buffer = byte_stream_buffer; - struct_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_address32); + ACPI_FUNCTION_TRACE("rs_get_address16"); - /* Point past the Descriptor to get the number of bytes consumed */ + /* Get the Resource Type, general flags, and type-specific flags */ - buffer += 1; - ACPI_MOVE_16_TO_16 (&temp16, buffer); - - /* Validate minimum descriptor length */ - - if (temp16 < 23) { - return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH); - } - - *bytes_consumed = temp16 + 3; - output_struct->id = ACPI_RSTYPE_ADDRESS32; - - /* Get the Resource Type (Byte3) */ - - buffer += 2; - temp8 = *buffer; - - /* Values 0-2 and 0xC0-0xFF are valid */ - - if ((temp8 > 2) && (temp8 < 0xC0)) { - return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE); + if (!acpi_rs_get_address_common(resource, aml)) { + return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); } - output_struct->data.address32.resource_type = temp8; - - /* Get the General Flags (Byte4) */ - - buffer += 1; - temp8 = *buffer; - - /* Producer / Consumer */ - - output_struct->data.address32.producer_consumer = temp8 & 0x01; - - /* Decode */ - - output_struct->data.address32.decode = (temp8 >> 1) & 0x01; - - /* Min Address Fixed */ - - output_struct->data.address32.min_address_fixed = (temp8 >> 2) & 0x01; - - /* Max Address Fixed */ - - output_struct->data.address32.max_address_fixed = (temp8 >> 3) & 0x01; - - /* Get the Type Specific Flags (Byte5) */ - - buffer += 1; - temp8 = *buffer; - - if (ACPI_MEMORY_RANGE == output_struct->data.address32.resource_type) { - output_struct->data.address32.attribute.memory.read_write_attribute = - (u16) (temp8 & 0x01); - - output_struct->data.address32.attribute.memory.cache_attribute = - (u16) ((temp8 >> 1) & 0x03); - } - else { - if (ACPI_IO_RANGE == output_struct->data.address32.resource_type) { - output_struct->data.address32.attribute.io.range_attribute = - (u16) (temp8 & 0x03); - output_struct->data.address32.attribute.io.translation_attribute = - (u16) ((temp8 >> 4) & 0x03); - } - else { - /* BUS_NUMBER_RANGE == output_struct->Data.Address32.resource_type */ - /* Nothing needs to be filled in */ - } - } - - /* Get Granularity (Bytes 6-9) */ - - buffer += 1; - ACPI_MOVE_32_TO_32 (&output_struct->data.address32.granularity, buffer); - - /* Get min_address_range (Bytes 10-13) */ - - buffer += 4; - ACPI_MOVE_32_TO_32 (&output_struct->data.address32.min_address_range, buffer); - - /* Get max_address_range (Bytes 14-17) */ - - buffer += 4; - ACPI_MOVE_32_TO_32 (&output_struct->data.address32.max_address_range, buffer); - - /* Get address_translation_offset (Bytes 18-21) */ - - buffer += 4; - ACPI_MOVE_32_TO_32 (&output_struct->data.address32.address_translation_offset, - buffer); - - /* Get address_length (Bytes 22-25) */ - - buffer += 4; - ACPI_MOVE_32_TO_32 (&output_struct->data.address32.address_length, buffer); - - /* Resource Source Index (if present) */ - - buffer += 4; - /* - * This will leave us pointing to the Resource Source Index - * If it is present, then save it off and calculate the - * pointer to where the null terminated string goes: - * - * Note: Some resource descriptors will have an additional null, so - * we add 1 to the length. + * Get the following contiguous fields from the AML descriptor: + * Address Granularity + * Address Range Minimum + * Address Range Maximum + * Address Translation Offset + * Address Length */ - if (*bytes_consumed > (26 + 1)) { - /* Dereference the Index */ - - temp8 = *buffer; - output_struct->data.address32.resource_source.index = - (u32) temp8; - - /* Point to the String */ + acpi_rs_move_data(&resource->data.address16.granularity, + &aml->address16.granularity, 5, + ACPI_MOVE_TYPE_16_TO_32); - buffer += 1; + /* Get the optional resource_source (index and string) */ - /* Point the String pointer to the end of this structure */ + 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); - output_struct->data.address32.resource_source.string_ptr = - (char *)((u8 *)output_struct + struct_size); + /* Complete the resource header */ - temp_ptr = (u8 *) - output_struct->data.address32.resource_source.string_ptr; - - /* Copy the string into the buffer */ - - index = 0; - while (0x00 != *buffer) { - *temp_ptr = *buffer; - - temp_ptr += 1; - buffer += 1; - index += 1; - } - - /* Add the terminating null */ - - *temp_ptr = 0x00; - output_struct->data.address32.resource_source.string_length = index + 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. - */ - temp8 = (u8) (index + 1); - struct_size += ACPI_ROUND_UP_to_32_bITS (temp8); - } - else { - output_struct->data.address32.resource_source.index = 0x00; - output_struct->data.address32.resource_source.string_length = 0; - output_struct->data.address32.resource_source.string_ptr = NULL; - } - - /* Set the Length parameter */ - - output_struct->length = (u32) struct_size; - - /* Return the final size of the structure */ - - *structure_size = struct_size; - return_ACPI_STATUS (AE_OK); + resource->type = ACPI_RESOURCE_TYPE_ADDRESS16; + return_ACPI_STATUS(AE_OK); } - /******************************************************************************* * - * FUNCTION: acpi_rs_address32_stream + * FUNCTION: acpi_rs_set_address16 * - * PARAMETERS: linked_list - Pointer to the resource linked list - * output_buffer - Pointer to the user's return buffer - * bytes_consumed - Pointer to where the number of bytes - * used in the output_buffer is returned + * PARAMETERS: Resource - Pointer to the resource descriptor + * Aml - Where the AML descriptor is returned * * RETURN: Status * - * DESCRIPTION: Take the linked list resource structure and fills in the - * the appropriate bytes in a byte stream + * DESCRIPTION: Convert an internal resource descriptor to the corresponding + * external AML resource descriptor. * ******************************************************************************/ acpi_status -acpi_rs_address32_stream ( - struct acpi_resource *linked_list, - u8 **output_buffer, - acpi_size *bytes_consumed) +acpi_rs_set_address16(struct acpi_resource *resource, union aml_resource *aml) { - u8 *buffer; - u16 *length_field; - u8 temp8; - char *temp_pointer; - - - ACPI_FUNCTION_TRACE ("rs_address32_stream"); + acpi_size descriptor_length; + ACPI_FUNCTION_TRACE("rs_set_address16"); - buffer = *output_buffer; + /* Set the Resource Type, General Flags, and Type-Specific Flags */ - /* The descriptor field is static */ + acpi_rs_set_address_common(aml, resource); - *buffer = 0x87; - buffer += 1; - - /* Set a pointer to the Length field - to be filled in later */ - - length_field = ACPI_CAST_PTR (u16, buffer); - buffer += 2; - - /* Set the Resource Type (Memory, Io, bus_number) */ + /* + * 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); - temp8 = (u8) (linked_list->data.address32.resource_type & 0x03); + /* Resource Source Index and Resource Source are optional */ - *buffer = temp8; - buffer += 1; + descriptor_length = acpi_rs_set_resource_source(aml, + sizeof(struct + aml_resource_address16), + &resource->data. + address16. + resource_source); - /* Set the general flags */ + /* Complete the AML descriptor header */ - temp8 = (u8) (linked_list->data.address32.producer_consumer & 0x01); - temp8 |= (linked_list->data.address32.decode & 0x01) << 1; - temp8 |= (linked_list->data.address32.min_address_fixed & 0x01) << 2; - temp8 |= (linked_list->data.address32.max_address_fixed & 0x01) << 3; + acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_ADDRESS16, + descriptor_length, aml); + return_ACPI_STATUS(AE_OK); +} - *buffer = temp8; - buffer += 1; +/******************************************************************************* + * + * 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. + * + ******************************************************************************/ - /* Set the type specific flags */ +acpi_status +acpi_rs_get_address32(union aml_resource *aml, + u16 aml_resource_length, struct acpi_resource *resource) +{ - temp8 = 0; + ACPI_FUNCTION_TRACE("rs_get_address32"); - if (ACPI_MEMORY_RANGE == linked_list->data.address32.resource_type) { - temp8 = (u8) - (linked_list->data.address32.attribute.memory.read_write_attribute & - 0x01); + /* Get the Resource Type, general flags, and type-specific flags */ - temp8 |= - (linked_list->data.address32.attribute.memory.cache_attribute & - 0x03) << 1; - } - else if (ACPI_IO_RANGE == linked_list->data.address32.resource_type) { - temp8 = (u8) - (linked_list->data.address32.attribute.io.range_attribute & - 0x03); - temp8 |= - (linked_list->data.address32.attribute.io.translation_attribute & - 0x03) << 4; + if (!acpi_rs_get_address_common(resource, (void *)aml)) { + return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); } - *buffer = temp8; - buffer += 1; + /* + * 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); - /* Set the address space granularity */ + /* Get the optional resource_source (index and string) */ - ACPI_MOVE_32_TO_32 (buffer, &linked_list->data.address32.granularity); - buffer += 4; + 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); - /* Set the address range minimum */ + /* Complete the resource header */ - ACPI_MOVE_32_TO_32 (buffer, &linked_list->data.address32.min_address_range); - buffer += 4; + resource->type = ACPI_RESOURCE_TYPE_ADDRESS32; + return_ACPI_STATUS(AE_OK); +} - /* Set the address range maximum */ +/******************************************************************************* + * + * 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_MOVE_32_TO_32 (buffer, &linked_list->data.address32.max_address_range); - buffer += 4; +acpi_status +acpi_rs_set_address32(struct acpi_resource *resource, union aml_resource *aml) +{ + acpi_size descriptor_length; - /* Set the address translation offset */ + ACPI_FUNCTION_TRACE("rs_set_address32"); - ACPI_MOVE_32_TO_32 (buffer, - &linked_list->data.address32.address_translation_offset); - buffer += 4; + /* Set the Resource Type, General Flags, and Type-Specific Flags */ - /* Set the address length */ + acpi_rs_set_address_common(aml, resource); - ACPI_MOVE_32_TO_32 (buffer, &linked_list->data.address32.address_length); - buffer += 4; + /* + * 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 */ - if (0 != linked_list->data.address32.resource_source.string_length) { - temp8 = (u8) linked_list->data.address32.resource_source.index; - - *buffer = temp8; - buffer += 1; + descriptor_length = acpi_rs_set_resource_source(aml, + sizeof(struct + aml_resource_address32), + &resource->data. + address32. + resource_source); - temp_pointer = (char *) buffer; + /* Complete the AML descriptor header */ - /* Copy the string */ - - ACPI_STRCPY (temp_pointer, - linked_list->data.address32.resource_source.string_ptr); - - /* - * Buffer needs to be set to the length of the sting + one for the - * terminating null - */ - buffer += (acpi_size)(ACPI_STRLEN ( - linked_list->data.address32.resource_source.string_ptr) + 1); - } - - /* Return the number of bytes consumed in this operation */ - - *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer); - - /* - * Set the length field to the number of bytes consumed - * minus the header size (3 bytes) - */ - *length_field = (u16) (*bytes_consumed - 3); - return_ACPI_STATUS (AE_OK); + acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_ADDRESS32, + descriptor_length, aml); + return_ACPI_STATUS(AE_OK); } - /******************************************************************************* * - * FUNCTION: acpi_rs_address64_resource + * FUNCTION: acpi_rs_get_address64 * - * PARAMETERS: byte_stream_buffer - Pointer to the resource input byte - * stream - * bytes_consumed - Pointer to where the number of bytes - * consumed the byte_stream_buffer is - * returned - * output_buffer - Pointer to the return data buffer - * structure_size - Pointer to where the number of bytes - * in the return data struct is returned + * 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: Take the resource byte stream and fill out the appropriate - * structure pointed to by the output_buffer. Return the - * number of bytes consumed from the byte stream. + * 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_address64_resource ( - u8 *byte_stream_buffer, - acpi_size *bytes_consumed, - u8 **output_buffer, - acpi_size *structure_size) +acpi_rs_get_address64(union aml_resource *aml, + u16 aml_resource_length, struct acpi_resource *resource) { - u8 *buffer; - struct acpi_resource *output_struct = (void *) *output_buffer; - u16 temp16; - u8 temp8; - u8 resource_type; - u8 *temp_ptr; - acpi_size struct_size; - u32 index; - + ACPI_FUNCTION_TRACE("rs_get_address64"); - ACPI_FUNCTION_TRACE ("rs_address64_resource"); + /* Get the Resource Type, general Flags, and type-specific Flags */ - - buffer = byte_stream_buffer; - struct_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_address64); - resource_type = *buffer; - - /* Point past the Descriptor to get the number of bytes consumed */ - - buffer += 1; - ACPI_MOVE_16_TO_16 (&temp16, buffer); - - /* Validate minimum descriptor length */ - - if (temp16 < 43) { - return_ACPI_STATUS (AE_AML_BAD_RESOURCE_LENGTH); + if (!acpi_rs_get_address_common(resource, aml)) { + return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); } - *bytes_consumed = temp16 + 3; - output_struct->id = ACPI_RSTYPE_ADDRESS64; - - /* Get the Resource Type (Byte3) */ - - buffer += 2; - temp8 = *buffer; + /* + * 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); - /* Values 0-2 and 0xC0-0xFF are valid */ + /* Get the optional resource_source (index and string) */ - if ((temp8 > 2) && (temp8 < 0xC0)) { - return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE); - } + 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); - output_struct->data.address64.resource_type = temp8; + /* Complete the resource header */ - /* Get the General Flags (Byte4) */ + resource->type = ACPI_RESOURCE_TYPE_ADDRESS64; + return_ACPI_STATUS(AE_OK); +} - buffer += 1; - temp8 = *buffer; +/******************************************************************************* + * + * 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. + * + ******************************************************************************/ - /* Producer / Consumer */ +acpi_status +acpi_rs_set_address64(struct acpi_resource *resource, union aml_resource *aml) +{ + acpi_size descriptor_length; - output_struct->data.address64.producer_consumer = temp8 & 0x01; + ACPI_FUNCTION_TRACE("rs_set_address64"); - /* Decode */ + /* Set the Resource Type, General Flags, and Type-Specific Flags */ - output_struct->data.address64.decode = (temp8 >> 1) & 0x01; + acpi_rs_set_address_common(aml, resource); - /* Min Address Fixed */ + /* + * 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); - output_struct->data.address64.min_address_fixed = (temp8 >> 2) & 0x01; + /* Resource Source Index and Resource Source are optional */ - /* Max Address Fixed */ + descriptor_length = acpi_rs_set_resource_source(aml, + sizeof(struct + aml_resource_address64), + &resource->data. + address64. + resource_source); - output_struct->data.address64.max_address_fixed = (temp8 >> 3) & 0x01; + /* Complete the AML descriptor header */ - /* Get the Type Specific Flags (Byte5) */ + acpi_rs_set_resource_header(ACPI_RESOURCE_NAME_ADDRESS64, + descriptor_length, aml); + return_ACPI_STATUS(AE_OK); +} - buffer += 1; - temp8 = *buffer; +/******************************************************************************* + * + * 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. + * + ******************************************************************************/ - if (ACPI_MEMORY_RANGE == output_struct->data.address64.resource_type) { - output_struct->data.address64.attribute.memory.read_write_attribute = - (u16) (temp8 & 0x01); +acpi_status +acpi_rs_get_ext_address64(union aml_resource *aml, + u16 aml_resource_length, + struct acpi_resource *resource) +{ - output_struct->data.address64.attribute.memory.cache_attribute = - (u16) ((temp8 >> 1) & 0x03); - } - else { - if (ACPI_IO_RANGE == output_struct->data.address64.resource_type) { - output_struct->data.address64.attribute.io.range_attribute = - (u16) (temp8 & 0x03); - output_struct->data.address64.attribute.io.translation_attribute = - (u16) ((temp8 >> 4) & 0x03); - } - else { - /* BUS_NUMBER_RANGE == output_struct->Data.Address64.resource_type */ - /* Nothing needs to be filled in */ - } - } + ACPI_FUNCTION_TRACE("rs_get_ext_address64"); - if (resource_type == ACPI_RDESC_TYPE_EXTENDED_ADDRESS_SPACE) { - /* Move past revision_id and Reserved byte */ + /* Get the Resource Type, general flags, and type-specific flags */ - buffer += 2; + if (!acpi_rs_get_address_common(resource, aml)) { + return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE); } - /* Get Granularity (Bytes 6-13) or (Bytes 8-15) */ - - buffer += 1; - ACPI_MOVE_64_TO_64 (&output_struct->data.address64.granularity, buffer); - - /* Get min_address_range (Bytes 14-21) or (Bytes 16-23) */ - - buffer += 8; - ACPI_MOVE_64_TO_64 (&output_struct->data.address64.min_address_range, buffer); - - /* Get max_address_range (Bytes 22-29) or (Bytes 24-31) */ - - buffer += 8; - ACPI_MOVE_64_TO_64 (&output_struct->data.address64.max_address_range, buffer); - - /* Get address_translation_offset (Bytes 30-37) or (Bytes 32-39) */ - - buffer += 8; - ACPI_MOVE_64_TO_64 (&output_struct->data.address64.address_translation_offset, - buffer); - - /* Get address_length (Bytes 38-45) or (Bytes 40-47) */ - - buffer += 8; - ACPI_MOVE_64_TO_64 (&output_struct->data.address64.address_length, buffer); - - output_struct->data.address64.resource_source.index = 0x00; - output_struct->data.address64.resource_source.string_length = 0; - output_struct->data.address64.resource_source.string_ptr = NULL; - - if (resource_type == ACPI_RDESC_TYPE_EXTENDED_ADDRESS_SPACE) { - /* Get type_specific_attribute (Bytes 48-55) */ - - buffer += 8; - ACPI_MOVE_64_TO_64 ( - &output_struct->data.address64.type_specific_attributes, - buffer); - } - else { - output_struct->data.address64.type_specific_attributes = 0; - - /* Resource Source Index (if present) */ - - buffer += 8; - - /* - * This will leave us pointing to the Resource Source Index - * If it is present, then save it off and calculate the - * pointer to where the null terminated string goes: - * Each Interrupt takes 32-bits + the 5 bytes of the - * stream that are default. - * - * Note: Some resource descriptors will have an additional null, so - * we add 1 to the length. - */ - if (*bytes_consumed > (46 + 1)) { - /* Dereference the Index */ - - temp8 = *buffer; - output_struct->data.address64.resource_source.index = - (u32) temp8; - - /* Point to the String */ - - buffer += 1; - - /* Point the String pointer to the end of this structure */ - - output_struct->data.address64.resource_source.string_ptr = - (char *)((u8 *)output_struct + struct_size); - - temp_ptr = (u8 *) - output_struct->data.address64.resource_source.string_ptr; - - /* Copy the string into the buffer */ - - index = 0; - while (0x00 != *buffer) { - *temp_ptr = *buffer; - - temp_ptr += 1; - buffer += 1; - index += 1; - } - - /* - * Add the terminating null - */ - *temp_ptr = 0x00; - output_struct->data.address64.resource_source.string_length = - index + 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. - */ - temp8 = (u8) (index + 1); - struct_size += ACPI_ROUND_UP_to_32_bITS (temp8); - } + /* + * 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); } - /* Set the Length parameter */ - - output_struct->length = (u32) struct_size; + /* + * 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); - /* Return the final size of the structure */ + /* Complete the resource header */ - *structure_size = struct_size; - return_ACPI_STATUS (AE_OK); + 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_address64_stream + * FUNCTION: acpi_rs_set_ext_address64 * - * PARAMETERS: linked_list - Pointer to the resource linked list - * output_buffer - Pointer to the user's return buffer - * bytes_consumed - Pointer to where the number of bytes - * used in the output_buffer is returned + * PARAMETERS: Resource - Pointer to the resource descriptor + * Aml - Where the AML descriptor is returned * * RETURN: Status * - * DESCRIPTION: Take the linked list resource structure and fills in the - * the appropriate bytes in a byte stream + * DESCRIPTION: Convert an internal resource descriptor to the corresponding + * external AML resource descriptor. * ******************************************************************************/ acpi_status -acpi_rs_address64_stream ( - struct acpi_resource *linked_list, - u8 **output_buffer, - acpi_size *bytes_consumed) +acpi_rs_set_ext_address64(struct acpi_resource *resource, + union aml_resource *aml) { - u8 *buffer; - u16 *length_field; - u8 temp8; - char *temp_pointer; - - - ACPI_FUNCTION_TRACE ("rs_address64_stream"); - + ACPI_FUNCTION_TRACE("rs_set_ext_address64"); - buffer = *output_buffer; + /* Set the Resource Type, General Flags, and Type-Specific Flags */ - /* The descriptor field is static */ + acpi_rs_set_address_common(aml, resource); - *buffer = 0x8A; - buffer += 1; + /* Only one Revision ID is currently supported */ - /* Set a pointer to the Length field - to be filled in later */ - - length_field = ACPI_CAST_PTR (u16, buffer); - buffer += 2; - - /* Set the Resource Type (Memory, Io, bus_number) */ - - temp8 = (u8) (linked_list->data.address64.resource_type & 0x03); - - *buffer = temp8; - buffer += 1; - - /* Set the general flags */ - - temp8 = (u8) (linked_list->data.address64.producer_consumer & 0x01); - temp8 |= (linked_list->data.address64.decode & 0x01) << 1; - temp8 |= (linked_list->data.address64.min_address_fixed & 0x01) << 2; - temp8 |= (linked_list->data.address64.max_address_fixed & 0x01) << 3; - - *buffer = temp8; - buffer += 1; - - /* Set the type specific flags */ - - temp8 = 0; - - if (ACPI_MEMORY_RANGE == linked_list->data.address64.resource_type) { - temp8 = (u8) - (linked_list->data.address64.attribute.memory.read_write_attribute & - 0x01); - - temp8 |= - (linked_list->data.address64.attribute.memory.cache_attribute & - 0x03) << 1; - } - else if (ACPI_IO_RANGE == linked_list->data.address64.resource_type) { - temp8 = (u8) - (linked_list->data.address64.attribute.io.range_attribute & - 0x03); - temp8 |= - (linked_list->data.address64.attribute.io.range_attribute & - 0x03) << 4; - } - - *buffer = temp8; - buffer += 1; - - /* Set the address space granularity */ - - ACPI_MOVE_64_TO_64 (buffer, &linked_list->data.address64.granularity); - buffer += 8; - - /* Set the address range minimum */ - - ACPI_MOVE_64_TO_64 (buffer, &linked_list->data.address64.min_address_range); - buffer += 8; - - /* Set the address range maximum */ - - ACPI_MOVE_64_TO_64 (buffer, &linked_list->data.address64.max_address_range); - buffer += 8; - - /* Set the address translation offset */ - - ACPI_MOVE_64_TO_64 (buffer, - &linked_list->data.address64.address_translation_offset); - buffer += 8; - - /* Set the address length */ - - ACPI_MOVE_64_TO_64 (buffer, &linked_list->data.address64.address_length); - buffer += 8; - - /* Resource Source Index and Resource Source are optional */ - - if (0 != linked_list->data.address64.resource_source.string_length) { - temp8 = (u8) linked_list->data.address64.resource_source.index; - - *buffer = temp8; - buffer += 1; - - temp_pointer = (char *) buffer; - - /* Copy the string */ - - ACPI_STRCPY (temp_pointer, - linked_list->data.address64.resource_source.string_ptr); - - /* - * Buffer needs to be set to the length of the sting + one for the - * terminating null - */ - buffer += (acpi_size)(ACPI_STRLEN ( - linked_list->data.address64.resource_source.string_ptr) + 1); - } - - /* Return the number of bytes consumed in this operation */ - - *bytes_consumed = ACPI_PTR_DIFF (buffer, *output_buffer); + aml->ext_address64.revision_iD = AML_RESOURCE_EXTENDED_ADDRESS_REVISION; + aml->ext_address64.reserved = 0; /* - * Set the length field to the number of bytes consumed - * minus the header size (3 bytes) + * 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 */ - *length_field = (u16) (*bytes_consumed - 3); - return_ACPI_STATUS (AE_OK); -} + 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); +}