Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux-acpi-2.6

1 files changed, 306 insertions, 525 deletions

diff --git a/drivers/acpi/resources/rscalc.c b/drivers/acpi/resources/rscalc.c
index 378f58390fc1..7d6481d9fbec 100644
--- a/drivers/acpi/resources/rscalc.c
+++ b/drivers/acpi/resources/rscalc.c
@@ -5,7 +5,7 @@
  ******************************************************************************/
 
 /*
- * Copyright (C) 2000 - 2005, R. Byron Moore
+ * Copyright (C) 2000 - 2006, R. Byron Moore
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -49,652 +49,433 @@
 #define _COMPONENT          ACPI_RESOURCES
 ACPI_MODULE_NAME("rscalc")
 
+/* Local prototypes */
+static u8 acpi_rs_count_set_bits(u16 bit_field);
+
+static acpi_rs_length
+acpi_rs_struct_option_length(struct acpi_resource_source *resource_source);
+
+static u32
+acpi_rs_stream_option_length(u32 resource_length, u32 minimum_total_length);
+
 /*******************************************************************************
  *
- * FUNCTION:    acpi_rs_get_byte_stream_length
+ * FUNCTION:    acpi_rs_count_set_bits
  *
- * PARAMETERS:  linked_list         - Pointer to the resource linked list
- *              size_needed         - u32 pointer of the size buffer needed
- *                                    to properly return the parsed data
+ * PARAMETERS:  bit_field       - Field in which to count bits
  *
- * RETURN:      Status
+ * RETURN:      Number of bits set within the field
  *
- * DESCRIPTION: Takes the resource byte stream and parses it once, calculating
- *              the size buffer needed to hold the linked list that conveys
- *              the resource data.
+ * DESCRIPTION: Count the number of bits set in a resource field. Used for
+ *              (Short descriptor) interrupt and DMA lists.
  *
  ******************************************************************************/
-acpi_status
-acpi_rs_get_byte_stream_length(struct acpi_resource *linked_list,
-                               acpi_size * size_needed)
-{
-        acpi_size byte_stream_size_needed = 0;
-        acpi_size segment_size;
-        u8 done = FALSE;
-
-        ACPI_FUNCTION_TRACE("rs_get_byte_stream_length");
-
-        while (!done) {
-                /* Init the variable that will hold the size to add to the total. */
-
-                segment_size = 0;
-
-                switch (linked_list->id) {
-                case ACPI_RSTYPE_IRQ:
-                        /*
-                         * IRQ Resource
-                         * For an IRQ Resource, Byte 3, although optional, will always be
-                         * created - it holds IRQ information.
-                         */
-                        segment_size = 4;
-                        break;
-
-                case ACPI_RSTYPE_DMA:
-                        /*
-                         * DMA Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 3;
-                        break;
-
-                case ACPI_RSTYPE_START_DPF:
-                        /*
-                         * Start Dependent Functions Resource
-                         * For a start_dependent_functions Resource, Byte 1, although
-                         * optional, will always be created.
-                         */
-                        segment_size = 2;
-                        break;
-
-                case ACPI_RSTYPE_END_DPF:
-                        /*
-                         * End Dependent Functions Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 1;
-                        break;
-
-                case ACPI_RSTYPE_IO:
-                        /*
-                         * IO Port Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 8;
-                        break;
 
-                case ACPI_RSTYPE_FIXED_IO:
-                        /*
-                         * Fixed IO Port Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 4;
-                        break;
-
-                case ACPI_RSTYPE_VENDOR:
-                        /*
-                         * Vendor Defined Resource
-                         * For a Vendor Specific resource, if the Length is between 1 and 7
-                         * it will be created as a Small Resource data type, otherwise it
-                         * is a Large Resource data type.
-                         */
-                        if (linked_list->data.vendor_specific.length > 7) {
-                                segment_size = 3;
-                        } else {
-                                segment_size = 1;
-                        }
-                        segment_size +=
-                            linked_list->data.vendor_specific.length;
-                        break;
-
-                case ACPI_RSTYPE_END_TAG:
-                        /*
-                         * End Tag
-                         * For this resource the size is static
-                         */
-                        segment_size = 2;
-                        done = TRUE;
-                        break;
-
-                case ACPI_RSTYPE_MEM24:
-                        /*
-                         * 24-Bit Memory Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 12;
-                        break;
+static u8 acpi_rs_count_set_bits(u16 bit_field)
+{
+        u8 bits_set;
 
-                case ACPI_RSTYPE_MEM32:
-                        /*
-                         * 32-Bit Memory Range Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 20;
-                        break;
+        ACPI_FUNCTION_ENTRY();
 
-                case ACPI_RSTYPE_FIXED_MEM32:
-                        /*
-                         * 32-Bit Fixed Memory Resource
-                         * For this resource the size is static
-                         */
-                        segment_size = 12;
-                        break;
+        for (bits_set = 0; bit_field; bits_set++) {
+                /* Zero the least significant bit that is set */
 
-                case ACPI_RSTYPE_ADDRESS16:
-                        /*
-                         * 16-Bit Address Resource
-                         * The base size of this byte stream is 16. If a Resource Source
-                         * string is not NULL, add 1 for the Index + the length of the null
-                         * terminated string Resource Source + 1 for the null.
-                         */
-                        segment_size = 16;
-
-                        if (linked_list->data.address16.resource_source.
-                            string_ptr) {
-                                segment_size +=
-                                    linked_list->data.address16.resource_source.
-                                    string_length;
-                                segment_size++;
-                        }
-                        break;
+                bit_field &= (bit_field - 1);
+        }
 
-                case ACPI_RSTYPE_ADDRESS32:
-                        /*
-                         * 32-Bit Address Resource
-                         * The base size of this byte stream is 26. If a Resource
-                         * Source string is not NULL, add 1 for the Index + the
-                         * length of the null terminated string Resource Source +
-                         * 1 for the null.
-                         */
-                        segment_size = 26;
-
-                        if (linked_list->data.address32.resource_source.
-                            string_ptr) {
-                                segment_size +=
-                                    linked_list->data.address32.resource_source.
-                                    string_length;
-                                segment_size++;
-                        }
-                        break;
+        return (bits_set);
+}
 
-                case ACPI_RSTYPE_ADDRESS64:
-                        /*
-                         * 64-Bit Address Resource
-                         * The base size of this byte stream is 46. If a resource_source
-                         * string is not NULL, add 1 for the Index + the length of the null
-                         * terminated string Resource Source + 1 for the null.
-                         */
-                        segment_size = 46;
-
-                        if (linked_list->data.address64.resource_source.
-                            string_ptr) {
-                                segment_size +=
-                                    linked_list->data.address64.resource_source.
-                                    string_length;
-                                segment_size++;
-                        }
-                        break;
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_rs_struct_option_length
+ *
+ * PARAMETERS:  resource_source     - Pointer to optional descriptor field
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Common code to handle optional resource_source_index and
+ *              resource_source fields in some Large descriptors. Used during
+ *              list-to-stream conversion
+ *
+ ******************************************************************************/
 
-                case ACPI_RSTYPE_EXT_IRQ:
-                        /*
-                         * Extended IRQ Resource
-                         * The base size of this byte stream is 9. This is for an Interrupt
-                         * table length of 1.  For each additional interrupt, add 4.
-                         * If a Resource Source string is not NULL, add 1 for the
-                         * Index + the length of the null terminated string
-                         * Resource Source + 1 for the null.
-                         */
-                        segment_size = 9 + (((acpi_size)
-                                             linked_list->data.extended_irq.
-                                             number_of_interrupts - 1) * 4);
-
-                        if (linked_list->data.extended_irq.resource_source.
-                            string_ptr) {
-                                segment_size +=
-                                    linked_list->data.extended_irq.
-                                    resource_source.string_length;
-                                segment_size++;
-                        }
-                        break;
+static acpi_rs_length
+acpi_rs_struct_option_length(struct acpi_resource_source *resource_source)
+{
+        ACPI_FUNCTION_ENTRY();
 
-                default:
+        /*
+         * If the resource_source string is valid, return the size of the string
+         * (string_length includes the NULL terminator) plus the size of the
+         * resource_source_index (1).
+         */
+        if (resource_source->string_ptr) {
+                return ((acpi_rs_length) (resource_source->string_length + 1));
+        }
 
-                        /* If we get here, everything is out of sync, exit with error */
+        return (0);
+}
 
-                        return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_rs_stream_option_length
+ *
+ * PARAMETERS:  resource_length     - Length from the resource header
+ *              minimum_total_length - Minimum length of this resource, before
+ *                                    any optional fields. Includes header size
+ *
+ * RETURN:      Length of optional string (0 if no string present)
+ *
+ * DESCRIPTION: Common code to handle optional resource_source_index and
+ *              resource_source fields in some Large descriptors. Used during
+ *              stream-to-list conversion
+ *
+ ******************************************************************************/
 
-                }               /* switch (linked_list->Id) */
+static u32
+acpi_rs_stream_option_length(u32 resource_length,
+                             u32 minimum_aml_resource_length)
+{
+        u32 string_length = 0;
 
-                /* Update the total */
+        ACPI_FUNCTION_ENTRY();
 
-                byte_stream_size_needed += segment_size;
+        /*
+         * The resource_source_index and resource_source are optional elements of some
+         * Large-type resource descriptors.
+         */
 
-                /* Point to the next object */
+        /*
+         * If the length of the actual resource descriptor is greater than the ACPI
+         * spec-defined minimum length, it means that a resource_source_index exists
+         * and is followed by a (required) null terminated string. The string length
+         * (including the null terminator) is the resource length minus the minimum
+         * length, minus one byte for the resource_source_index itself.
+         */
+        if (resource_length > minimum_aml_resource_length) {
+                /* Compute the length of the optional string */
 
-                linked_list = ACPI_PTR_ADD(struct acpi_resource,
-                                           linked_list, linked_list->length);
+                string_length =
+                    resource_length - minimum_aml_resource_length - 1;
         }
 
-        /* This is the data the caller needs */
+        /* Round up length to 32 bits for internal structure alignment */
 
-        *size_needed = byte_stream_size_needed;
-        return_ACPI_STATUS(AE_OK);
+        return (ACPI_ROUND_UP_to_32_bITS(string_length));
 }
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_rs_get_list_length
+ * FUNCTION:    acpi_rs_get_aml_length
  *
- * PARAMETERS:  byte_stream_buffer      - Pointer to the resource byte stream
- *              byte_stream_buffer_length - Size of byte_stream_buffer
- *              size_needed             - u32 pointer of the size buffer
- *                                        needed to properly return the
- *                                        parsed data
+ * PARAMETERS:  Resource            - Pointer to the resource linked list
+ *              size_needed         - Where the required size is returned
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Takes the resource byte stream and parses it once, calculating
- *              the size buffer needed to hold the linked list that conveys
- *              the resource data.
+ * DESCRIPTION: Takes a linked list of internal resource descriptors and
+ *              calculates the size buffer needed to hold the corresponding
+ *              external resource byte stream.
  *
  ******************************************************************************/
 
 acpi_status
-acpi_rs_get_list_length(u8 * byte_stream_buffer,
-                        u32 byte_stream_buffer_length, acpi_size * size_needed)
+acpi_rs_get_aml_length(struct acpi_resource * resource, acpi_size * size_needed)
 {
-        u32 buffer_size = 0;
-        u32 bytes_parsed = 0;
-        u8 number_of_interrupts = 0;
-        u8 number_of_channels = 0;
-        u8 resource_type;
-        u32 structure_size;
-        u32 bytes_consumed;
-        u8 *buffer;
-        u8 temp8;
-        u16 temp16;
-        u8 index;
-        u8 additional_bytes;
-
-        ACPI_FUNCTION_TRACE("rs_get_list_length");
+        acpi_size aml_size_needed = 0;
+        acpi_rs_length total_size;
 
-        while (bytes_parsed < byte_stream_buffer_length) {
-                /* The next byte in the stream is the resource type */
+        ACPI_FUNCTION_TRACE("rs_get_aml_length");
 
-                resource_type = acpi_rs_get_resource_type(*byte_stream_buffer);
+        /* Traverse entire list of internal resource descriptors */
 
-                switch (resource_type) {
-                case ACPI_RDESC_TYPE_MEMORY_24:
-                        /*
-                         * 24-Bit Memory Resource
-                         */
-                        bytes_consumed = 12;
-
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_mem24);
-                        break;
+        while (resource) {
+                /* Validate the descriptor type */
 
-                case ACPI_RDESC_TYPE_LARGE_VENDOR:
-                        /*
-                         * Vendor Defined Resource
-                         */
-                        buffer = byte_stream_buffer;
-                        ++buffer;
-
-                        ACPI_MOVE_16_TO_16(&temp16, buffer);
-                        bytes_consumed = temp16 + 3;
-
-                        /* Ensure a 32-bit boundary for the structure */
+                if (resource->type > ACPI_RESOURCE_TYPE_MAX) {
+                        return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
+                }
 
-                        temp16 = (u16) ACPI_ROUND_UP_to_32_bITS(temp16);
+                /* Get the base size of the (external stream) resource descriptor */
 
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor) +
-                            (temp16 * sizeof(u8));
-                        break;
+                total_size = acpi_gbl_aml_resource_sizes[resource->type];
 
-                case ACPI_RDESC_TYPE_MEMORY_32:
+                /*
+                 * Augment the base size for descriptors with optional and/or
+                 * variable-length fields
+                 */
+                switch (resource->type) {
+                case ACPI_RESOURCE_TYPE_VENDOR:
                         /*
-                         * 32-Bit Memory Range Resource
+                         * Vendor Defined Resource:
+                         * For a Vendor Specific resource, if the Length is between 1 and 7
+                         * it will be created as a Small Resource data type, otherwise it
+                         * is a Large Resource data type.
                          */
-                        bytes_consumed = 20;
+                        if (resource->data.vendor.byte_length > 7) {
+                                /* Base size of a Large resource descriptor */
 
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_mem32);
-                        break;
+                                total_size =
+                                    sizeof(struct aml_resource_large_header);
+                        }
 
-                case ACPI_RDESC_TYPE_FIXED_MEMORY_32:
-                        /*
-                         * 32-Bit Fixed Memory Resource
-                         */
-                        bytes_consumed = 12;
+                        /* Add the size of the vendor-specific data */
 
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct
-                                                 acpi_resource_fixed_mem32);
+                        total_size = (acpi_rs_length)
+                            (total_size + resource->data.vendor.byte_length);
                         break;
 
-                case ACPI_RDESC_TYPE_EXTENDED_ADDRESS_SPACE:
+                case ACPI_RESOURCE_TYPE_END_TAG:
                         /*
-                         * 64-Bit Address Resource
+                         * End Tag:
+                         * We are done -- return the accumulated total size.
                          */
-                        buffer = byte_stream_buffer;
+                        *size_needed = aml_size_needed + total_size;
 
-                        ++buffer;
-                        ACPI_MOVE_16_TO_16(&temp16, buffer);
+                        /* Normal exit */
 
-                        bytes_consumed = temp16 + 3;
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct
-                                                 acpi_resource_address64);
-                        break;
+                        return_ACPI_STATUS(AE_OK);
 
-                case ACPI_RDESC_TYPE_QWORD_ADDRESS_SPACE:
+                case ACPI_RESOURCE_TYPE_ADDRESS16:
                         /*
-                         * 64-Bit Address Resource
+                         * 16-Bit Address Resource:
+                         * Add the size of the optional resource_source info
                          */
-                        buffer = byte_stream_buffer;
-
-                        ++buffer;
-                        ACPI_MOVE_16_TO_16(&temp16, buffer);
-
-                        bytes_consumed = temp16 + 3;
+                        total_size = (acpi_rs_length)
+                            (total_size +
+                             acpi_rs_struct_option_length(&resource->data.
+                                                          address16.
+                                                          resource_source));
+                        break;
 
+                case ACPI_RESOURCE_TYPE_ADDRESS32:
                         /*
-                         * Resource Source Index and Resource Source are optional elements.
-                         * Check the length of the Bytestream.  If it is greater than 43,
-                         * that means that an Index exists and is followed by a null
-                         * terminated string.  Therefore, set the temp variable to the
-                         * length minus the minimum byte stream length plus the byte for
-                         * the Index to determine the size of the NULL terminated string.
+                         * 32-Bit Address Resource:
+                         * Add the size of the optional resource_source info
                          */
-                        if (43 < temp16) {
-                                temp8 = (u8) (temp16 - 44);
-                        } else {
-                                temp8 = 0;
-                        }
-
-                        /* Ensure a 64-bit boundary for the structure */
-
-                        temp8 = (u8) ACPI_ROUND_UP_to_64_bITS(temp8);
-
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_address64)
-                            + (temp8 * sizeof(u8));
+                        total_size = (acpi_rs_length)
+                            (total_size +
+                             acpi_rs_struct_option_length(&resource->data.
+                                                          address32.
+                                                          resource_source));
                         break;
 
-                case ACPI_RDESC_TYPE_DWORD_ADDRESS_SPACE:
+                case ACPI_RESOURCE_TYPE_ADDRESS64:
                         /*
-                         * 32-Bit Address Resource
+                         * 64-Bit Address Resource:
+                         * Add the size of the optional resource_source info
                          */
-                        buffer = byte_stream_buffer;
-
-                        ++buffer;
-                        ACPI_MOVE_16_TO_16(&temp16, buffer);
-
-                        bytes_consumed = temp16 + 3;
+                        total_size = (acpi_rs_length)
+                            (total_size +
+                             acpi_rs_struct_option_length(&resource->data.
+                                                          address64.
+                                                          resource_source));
+                        break;
 
+                case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
                         /*
-                         * Resource Source Index and Resource Source are optional elements.
-                         * Check the length of the Bytestream.  If it is greater than 23,
-                         * that means that an Index exists and is followed by a null
-                         * terminated string.  Therefore, set the temp variable to the
-                         * length minus the minimum byte stream length plus the byte for
-                         * the Index to determine the size of the NULL terminated string.
+                         * Extended IRQ Resource:
+                         * Add the size of each additional optional interrupt beyond the
+                         * required 1 (4 bytes for each u32 interrupt number)
                          */
-                        if (23 < temp16) {
-                                temp8 = (u8) (temp16 - 24);
-                        } else {
-                                temp8 = 0;
-                        }
-
-                        /* Ensure a 32-bit boundary for the structure */
-
-                        temp8 = (u8) ACPI_ROUND_UP_to_32_bITS(temp8);
+                        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;
 
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_address32)
-                            + (temp8 * sizeof(u8));
+                default:
                         break;
+                }
 
-                case ACPI_RDESC_TYPE_WORD_ADDRESS_SPACE:
-                        /*
-                         * 16-Bit Address Resource
-                         */
-                        buffer = byte_stream_buffer;
+                /* Update the total */
 
-                        ++buffer;
-                        ACPI_MOVE_16_TO_16(&temp16, buffer);
+                aml_size_needed += total_size;
 
-                        bytes_consumed = temp16 + 3;
+                /* Point to the next object */
 
-                        /*
-                         * Resource Source Index and Resource Source are optional elements.
-                         * Check the length of the Bytestream.  If it is greater than 13,
-                         * that means that an Index exists and is followed by a null
-                         * terminated string.  Therefore, set the temp variable to the
-                         * length minus the minimum byte stream length plus the byte for
-                         * the Index to determine the size of the NULL terminated string.
-                         */
-                        if (13 < temp16) {
-                                temp8 = (u8) (temp16 - 14);
-                        } else {
-                                temp8 = 0;
-                        }
+                resource =
+                    ACPI_ADD_PTR(struct acpi_resource, resource,
+                                 resource->length);
+        }
 
-                        /* Ensure a 32-bit boundary for the structure */
+        /* Did not find an end_tag resource descriptor */
 
-                        temp8 = (u8) ACPI_ROUND_UP_to_32_bITS(temp8);
+        return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);
+}
 
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_address16)
-                            + (temp8 * sizeof(u8));
-                        break;
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_rs_get_list_length
+ *
+ * PARAMETERS:  aml_buffer          - Pointer to the resource byte stream
+ *              aml_buffer_length   - Size of aml_buffer
+ *              size_needed         - Where the size needed is returned
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Takes an external resource byte stream and calculates the size
+ *              buffer needed to hold the corresponding internal resource
+ *              descriptor linked list.
+ *
+ ******************************************************************************/
 
-                case ACPI_RDESC_TYPE_EXTENDED_XRUPT:
-                        /*
-                         * Extended IRQ
-                         */
-                        buffer = byte_stream_buffer;
+acpi_status
+acpi_rs_get_list_length(u8 * aml_buffer,
+                        u32 aml_buffer_length, acpi_size * size_needed)
+{
+        acpi_status status;
+        u8 *end_aml;
+        u8 *buffer;
+        u32 buffer_size = 0;
+        u16 temp16;
+        u16 resource_length;
+        u32 extra_struct_bytes;
+        u8 resource_index;
+        u8 minimum_aml_resource_length;
 
-                        ++buffer;
-                        ACPI_MOVE_16_TO_16(&temp16, buffer);
+        ACPI_FUNCTION_TRACE("rs_get_list_length");
 
-                        bytes_consumed = temp16 + 3;
+        end_aml = aml_buffer + aml_buffer_length;
 
-                        /*
-                         * Point past the length field and the Interrupt vector flags to
-                         * save off the Interrupt table length to the Temp8 variable.
-                         */
-                        buffer += 3;
-                        temp8 = *buffer;
+        /* Walk the list of AML resource descriptors */
 
-                        /*
-                         * To compensate for multiple interrupt numbers, add 4 bytes for
-                         * each additional interrupts greater than 1
-                         */
-                        additional_bytes = (u8) ((temp8 - 1) * 4);
+        while (aml_buffer < end_aml) {
+                /* Validate the Resource Type and Resource Length */
 
-                        /*
-                         * Resource Source Index and Resource Source are optional elements.
-                         * Check the length of the Bytestream.  If it is greater than 9,
-                         * that means that an Index exists and is followed by a null
-                         * terminated string.  Therefore, set the temp variable to the
-                         * length minus the minimum byte stream length plus the byte for
-                         * the Index to determine the size of the NULL terminated string.
-                         */
-                        if (9 + additional_bytes < temp16) {
-                                temp8 = (u8) (temp16 - (9 + additional_bytes));
-                        } else {
-                                temp8 = 0;
-                        }
+                status = acpi_ut_validate_resource(aml_buffer, &resource_index);
+                if (ACPI_FAILURE(status)) {
+                        return_ACPI_STATUS(status);
+                }
 
-                        /* Ensure a 32-bit boundary for the structure */
+                /* Get the resource length and base (minimum) AML size */
 
-                        temp8 = (u8) ACPI_ROUND_UP_to_32_bITS(temp8);
+                resource_length = acpi_ut_get_resource_length(aml_buffer);
+                minimum_aml_resource_length =
+                    acpi_gbl_resource_aml_sizes[resource_index];
 
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_ext_irq) +
-                            (additional_bytes * sizeof(u8)) +
-                            (temp8 * sizeof(u8));
-                        break;
+                /*
+                 * Augment the size for descriptors with optional
+                 * and/or variable length fields
+                 */
+                extra_struct_bytes = 0;
+                buffer =
+                    aml_buffer + acpi_ut_get_resource_header_length(aml_buffer);
 
-                case ACPI_RDESC_TYPE_IRQ_FORMAT:
+                switch (acpi_ut_get_resource_type(aml_buffer)) {
+                case ACPI_RESOURCE_NAME_IRQ:
                         /*
-                         * IRQ Resource.
-                         * Determine if it there are two or three trailing bytes
+                         * IRQ Resource:
+                         * Get the number of bits set in the 16-bit IRQ mask
                          */
-                        buffer = byte_stream_buffer;
-                        temp8 = *buffer;
-
-                        if (temp8 & 0x01) {
-                                bytes_consumed = 4;
-                        } else {
-                                bytes_consumed = 3;
-                        }
-
-                        /* Point past the descriptor */
-
-                        ++buffer;
-
-                        /* Look at the number of bits set */
-
                         ACPI_MOVE_16_TO_16(&temp16, buffer);
-
-                        for (index = 0; index < 16; index++) {
-                                if (temp16 & 0x1) {
-                                        ++number_of_interrupts;
-                                }
-
-                                temp16 >>= 1;
-                        }
-
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_io) +
-                            (number_of_interrupts * sizeof(u32));
+                        extra_struct_bytes = acpi_rs_count_set_bits(temp16);
                         break;
 
-                case ACPI_RDESC_TYPE_DMA_FORMAT:
+                case ACPI_RESOURCE_NAME_DMA:
                         /*
-                         * DMA Resource
+                         * DMA Resource:
+                         * Get the number of bits set in the 8-bit DMA mask
                          */
-                        buffer = byte_stream_buffer;
-                        bytes_consumed = 3;
-
-                        /* Point past the descriptor */
-
-                        ++buffer;
-
-                        /* Look at the number of bits set */
-
-                        temp8 = *buffer;
-
-                        for (index = 0; index < 8; index++) {
-                                if (temp8 & 0x1) {
-                                        ++number_of_channels;
-                                }
-
-                                temp8 >>= 1;
-                        }
-
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_dma) +
-                            (number_of_channels * sizeof(u32));
+                        extra_struct_bytes = acpi_rs_count_set_bits(*buffer);
                         break;
 
-                case ACPI_RDESC_TYPE_START_DEPENDENT:
+                case ACPI_RESOURCE_NAME_VENDOR_SMALL:
                         /*
-                         * Start Dependent Functions Resource
-                         * Determine if it there are two or three trailing bytes
+                         * Vendor Resource:
+                         * Ensure a 32-bit boundary for the structure
                          */
-                        buffer = byte_stream_buffer;
-                        temp8 = *buffer;
-
-                        if (temp8 & 0x01) {
-                                bytes_consumed = 2;
-                        } else {
-                                bytes_consumed = 1;
-                        }
-
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct
-                                                 acpi_resource_start_dpf);
+                        extra_struct_bytes =
+                            ACPI_ROUND_UP_to_32_bITS(resource_length) -
+                            resource_length;
                         break;
 
-                case ACPI_RDESC_TYPE_END_DEPENDENT:
+                case ACPI_RESOURCE_NAME_END_TAG:
                         /*
-                         * End Dependent Functions Resource
+                         * End Tag: This is the normal exit, add size of end_tag
                          */
-                        bytes_consumed = 1;
-                        structure_size = ACPI_RESOURCE_LENGTH;
-                        break;
+                        *size_needed = buffer_size + ACPI_RS_SIZE_MIN;
+                        return_ACPI_STATUS(AE_OK);
 
-                case ACPI_RDESC_TYPE_IO_PORT:
+                case ACPI_RESOURCE_NAME_VENDOR_LARGE:
                         /*
-                         * IO Port Resource
+                         * Vendor Resource:
+                         * Add vendor data and ensure a 32-bit boundary for the structure
                          */
-                        bytes_consumed = 8;
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_io);
+                        extra_struct_bytes =
+                            ACPI_ROUND_UP_to_32_bITS(resource_length) -
+                            resource_length;
                         break;
 
-                case ACPI_RDESC_TYPE_FIXED_IO_PORT:
+                case ACPI_RESOURCE_NAME_ADDRESS32:
+                case ACPI_RESOURCE_NAME_ADDRESS16:
                         /*
-                         * Fixed IO Port Resource
+                         * 32-Bit or 16-bit Address Resource:
+                         * Add the size of any optional data (resource_source)
                          */
-                        bytes_consumed = 4;
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_fixed_io);
+                        extra_struct_bytes =
+                            acpi_rs_stream_option_length(resource_length,
+                                                         minimum_aml_resource_length);
                         break;
 
-                case ACPI_RDESC_TYPE_SMALL_VENDOR:
+                case ACPI_RESOURCE_NAME_EXTENDED_IRQ:
                         /*
-                         * Vendor Specific Resource
+                         * Extended IRQ:
+                         * Point past the interrupt_vector_flags to get the
+                         * interrupt_table_length.
                          */
-                        buffer = byte_stream_buffer;
+                        buffer++;
 
-                        temp8 = *buffer;
-                        temp8 = (u8) (temp8 & 0x7);
-                        bytes_consumed = temp8 + 1;
-
-                        /* Ensure a 32-bit boundary for the structure */
-
-                        temp8 = (u8) ACPI_ROUND_UP_to_32_bITS(temp8);
-                        structure_size =
-                            ACPI_SIZEOF_RESOURCE(struct acpi_resource_vendor) +
-                            (temp8 * sizeof(u8));
+                        extra_struct_bytes =
+                            /*
+                             * Add 4 bytes for each additional interrupt. Note: at
+                             * least one interrupt is required and is included in
+                             * the minimum descriptor size
+                             */
+                            ((*buffer - 1) * sizeof(u32)) +
+                            /* Add the size of any optional data (resource_source) */
+                            acpi_rs_stream_option_length(resource_length -
+                                                         extra_struct_bytes,
+                                                         minimum_aml_resource_length);
                         break;
 
-                case ACPI_RDESC_TYPE_END_TAG:
+                case ACPI_RESOURCE_NAME_ADDRESS64:
                         /*
-                         * End Tag
+                         * 64-Bit Address Resource:
+                         * Add the size of any optional data (resource_source)
+                         * Ensure a 64-bit boundary for the structure
                          */
-                        bytes_consumed = 2;
-                        structure_size = ACPI_RESOURCE_LENGTH;
-                        byte_stream_buffer_length = bytes_parsed;
+                        extra_struct_bytes =
+                            ACPI_ROUND_UP_to_64_bITS
+                            (acpi_rs_stream_option_length
+                             (resource_length, minimum_aml_resource_length));
                         break;
 
                 default:
-                        /*
-                         * If we get here, everything is out of sync,
-                         * exit with an error
-                         */
-                        return_ACPI_STATUS(AE_AML_INVALID_RESOURCE_TYPE);
+                        break;
                 }
 
-                /* Update the return value and counter */
-
-                buffer_size += (u32) ACPI_ALIGN_RESOURCE_SIZE(structure_size);
-                bytes_parsed += bytes_consumed;
+                /* Update the required buffer size for the internal descriptor structs */
 
-                /* Set the byte stream to point to the next resource */
+                temp16 = (u16) (acpi_gbl_resource_struct_sizes[resource_index] +
+                                extra_struct_bytes);
+                buffer_size += (u32) ACPI_ROUND_UP_TO_NATIVE_WORD(temp16);
 
-                byte_stream_buffer += bytes_consumed;
+                /*
+                 * Point to the next resource within the stream
+                 * using the size of the header plus the length contained in the header
+                 */
+                aml_buffer += acpi_ut_get_descriptor_length(aml_buffer);
         }
 
-        /* This is the data the caller needs */
+        /* Did not find an end_tag resource descriptor */
 
-        *size_needed = buffer_size;
-        return_ACPI_STATUS(AE_OK);
+        return_ACPI_STATUS(AE_AML_NO_RESOURCE_END_TAG);
 }
 
 /*******************************************************************************
@@ -760,13 +541,13 @@ acpi_rs_get_pci_routing_table_length(union acpi_operand_object *package_object,
 
                 for (table_index = 0; table_index < 4 && !name_found;
                      table_index++) {
-                        if ((ACPI_TYPE_STRING ==
-                             ACPI_GET_OBJECT_TYPE(*sub_object_list))
-                            ||
-                            ((ACPI_TYPE_LOCAL_REFERENCE ==
-                              ACPI_GET_OBJECT_TYPE(*sub_object_list))
-                             && ((*sub_object_list)->reference.opcode ==
-                                 AML_INT_NAMEPATH_OP))) {
+                        if (*sub_object_list && /* Null object allowed */
+                            ((ACPI_TYPE_STRING ==
+                              ACPI_GET_OBJECT_TYPE(*sub_object_list)) ||
+                             ((ACPI_TYPE_LOCAL_REFERENCE ==
+                               ACPI_GET_OBJECT_TYPE(*sub_object_list)) &&
+                              ((*sub_object_list)->reference.opcode ==
+                               AML_INT_NAMEPATH_OP)))) {
                                 name_found = TRUE;
                         } else {
                                 /* Look at the next element */