1 /*******************************************************************************
3 * Module Name: rscalc - Calculate stream and list lengths
5 ******************************************************************************/
8 * Copyright (C) 2000 - 2004, R. Byron Moore
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
45 #include <acpi/acpi.h>
46 #include <acpi/acresrc.h>
47 #include <acpi/amlcode.h>
48 #include <acpi/acnamesp.h>
50 #define _COMPONENT ACPI_RESOURCES
51 ACPI_MODULE_NAME ("rscalc")
54 /*******************************************************************************
56 * FUNCTION: acpi_rs_get_byte_stream_length
58 * PARAMETERS: linked_list - Pointer to the resource linked list
59 * size_needed - u32 pointer of the size buffer needed
60 * to properly return the parsed data
64 * DESCRIPTION: Takes the resource byte stream and parses it once, calculating
65 * the size buffer needed to hold the linked list that conveys
68 ******************************************************************************/
71 acpi_rs_get_byte_stream_length (
72 struct acpi_resource *linked_list,
73 acpi_size *size_needed)
75 acpi_size byte_stream_size_needed = 0;
76 acpi_size segment_size;
77 struct acpi_resource_ext_irq *ex_irq = NULL;
81 ACPI_FUNCTION_TRACE ("rs_get_byte_stream_length");
86 * Init the variable that will hold the size to add to the total.
90 switch (linked_list->id) {
94 * For an IRQ Resource, Byte 3, although optional, will
95 * always be created - it holds IRQ information.
100 case ACPI_RSTYPE_DMA:
103 * For this resource the size is static
108 case ACPI_RSTYPE_START_DPF:
110 * Start Dependent Functions Resource
111 * For a start_dependent_functions Resource, Byte 1,
112 * although optional, will always be created.
117 case ACPI_RSTYPE_END_DPF:
119 * End Dependent Functions Resource
120 * For this resource the size is static
128 * For this resource the size is static
133 case ACPI_RSTYPE_FIXED_IO:
135 * Fixed IO Port Resource
136 * For this resource the size is static
141 case ACPI_RSTYPE_VENDOR:
143 * Vendor Defined Resource
144 * For a Vendor Specific resource, if the Length is
145 * between 1 and 7 it will be created as a Small
146 * Resource data type, otherwise it is a Large
147 * Resource data type.
149 if (linked_list->data.vendor_specific.length > 7) {
155 segment_size += linked_list->data.vendor_specific.length;
158 case ACPI_RSTYPE_END_TAG:
161 * For this resource the size is static
167 case ACPI_RSTYPE_MEM24:
169 * 24-Bit Memory Resource
170 * For this resource the size is static
175 case ACPI_RSTYPE_MEM32:
177 * 32-Bit Memory Range Resource
178 * For this resource the size is static
183 case ACPI_RSTYPE_FIXED_MEM32:
185 * 32-Bit Fixed Memory Resource
186 * For this resource the size is static
191 case ACPI_RSTYPE_ADDRESS16:
193 * 16-Bit Address Resource
194 * The base size of this byte stream is 16. If a
195 * Resource Source string is not NULL, add 1 for
196 * the Index + the length of the null terminated
197 * string Resource Source + 1 for the null.
201 if (linked_list->data.address16.resource_source.string_ptr) {
202 segment_size += linked_list->data.address16.resource_source.string_length;
207 case ACPI_RSTYPE_ADDRESS32:
209 * 32-Bit Address Resource
210 * The base size of this byte stream is 26. If a Resource
211 * Source string is not NULL, add 1 for the Index + the
212 * length of the null terminated string Resource Source +
217 if (linked_list->data.address32.resource_source.string_ptr) {
218 segment_size += linked_list->data.address32.resource_source.string_length;
223 case ACPI_RSTYPE_ADDRESS64:
225 * 64-Bit Address Resource
226 * The base size of this byte stream is 46. If a Resource
227 * Source string is not NULL, add 1 for the Index + the
228 * length of the null terminated string Resource Source +
233 if (linked_list->data.address64.resource_source.string_ptr) {
234 segment_size += linked_list->data.address64.resource_source.string_length;
239 case ACPI_RSTYPE_EXT_IRQ:
241 * Extended IRQ Resource
242 * The base size of this byte stream is 9. This is for an
243 * Interrupt table length of 1. For each additional
245 * If a Resource Source string is not NULL, add 1 for the
246 * Index + the length of the null terminated string
247 * Resource Source + 1 for the null.
250 (((acpi_size) linked_list->data.extended_irq.number_of_interrupts - 1) * 4);
252 if (ex_irq && ex_irq->resource_source.string_ptr) {
253 segment_size += linked_list->data.extended_irq.resource_source.string_length;
260 * If we get here, everything is out of sync,
261 * so exit with an error
263 return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
265 } /* switch (linked_list->Id) */
270 byte_stream_size_needed += segment_size;
273 * Point to the next object
275 linked_list = ACPI_PTR_ADD (struct acpi_resource,
276 linked_list, linked_list->length);
280 * This is the data the caller needs
282 *size_needed = byte_stream_size_needed;
283 return_ACPI_STATUS (AE_OK);
287 /*******************************************************************************
289 * FUNCTION: acpi_rs_get_list_length
291 * PARAMETERS: byte_stream_buffer - Pointer to the resource byte stream
292 * byte_stream_buffer_length - Size of byte_stream_buffer
293 * size_needed - u32 pointer of the size buffer
294 * needed to properly return the
299 * DESCRIPTION: Takes the resource byte stream and parses it once, calculating
300 * the size buffer needed to hold the linked list that conveys
303 ******************************************************************************/
306 acpi_rs_get_list_length (
307 u8 *byte_stream_buffer,
308 u32 byte_stream_buffer_length,
309 acpi_size *size_needed)
312 u32 bytes_parsed = 0;
313 u8 number_of_interrupts = 0;
314 u8 number_of_channels = 0;
325 ACPI_FUNCTION_TRACE ("rs_get_list_length");
328 while (bytes_parsed < byte_stream_buffer_length) {
330 * The next byte in the stream is the resource type
332 resource_type = acpi_rs_get_resource_type (*byte_stream_buffer);
334 switch (resource_type) {
335 case ACPI_RDESC_TYPE_MEMORY_24:
337 * 24-Bit Memory Resource
341 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_mem24);
345 case ACPI_RDESC_TYPE_LARGE_VENDOR:
347 * Vendor Defined Resource
349 buffer = byte_stream_buffer;
352 ACPI_MOVE_16_TO_16 (&temp16, buffer);
353 bytes_consumed = temp16 + 3;
356 * Ensure a 32-bit boundary for the structure
358 temp16 = (u16) ACPI_ROUND_UP_to_32_bITS (temp16);
360 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_vendor) +
361 (temp16 * sizeof (u8));
365 case ACPI_RDESC_TYPE_MEMORY_32:
367 * 32-Bit Memory Range Resource
372 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_mem32);
376 case ACPI_RDESC_TYPE_FIXED_MEMORY_32:
378 * 32-Bit Fixed Memory Resource
382 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_fixed_mem32);
386 case ACPI_RDESC_TYPE_QWORD_ADDRESS_SPACE:
388 * 64-Bit Address Resource
390 buffer = byte_stream_buffer;
393 ACPI_MOVE_16_TO_16 (&temp16, buffer);
395 bytes_consumed = temp16 + 3;
398 * Resource Source Index and Resource Source are
399 * optional elements. Check the length of the
400 * Bytestream. If it is greater than 43, that
401 * means that an Index exists and is followed by
402 * a null termininated string. Therefore, set
403 * the temp variable to the length minus the minimum
404 * byte stream length plus the byte for the Index to
405 * determine the size of the NULL terminiated string.
408 temp8 = (u8) (temp16 - 44);
415 * Ensure a 64-bit boundary for the structure
417 temp8 = (u8) ACPI_ROUND_UP_to_64_bITS (temp8);
419 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_address64) +
420 (temp8 * sizeof (u8));
424 case ACPI_RDESC_TYPE_DWORD_ADDRESS_SPACE:
426 * 32-Bit Address Resource
428 buffer = byte_stream_buffer;
431 ACPI_MOVE_16_TO_16 (&temp16, buffer);
433 bytes_consumed = temp16 + 3;
436 * Resource Source Index and Resource Source are
437 * optional elements. Check the length of the
438 * Bytestream. If it is greater than 23, that
439 * means that an Index exists and is followed by
440 * a null termininated string. Therefore, set
441 * the temp variable to the length minus the minimum
442 * byte stream length plus the byte for the Index to
443 * determine the size of the NULL terminiated string.
446 temp8 = (u8) (temp16 - 24);
453 * Ensure a 32-bit boundary for the structure
455 temp8 = (u8) ACPI_ROUND_UP_to_32_bITS (temp8);
457 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_address32) +
458 (temp8 * sizeof (u8));
462 case ACPI_RDESC_TYPE_WORD_ADDRESS_SPACE:
464 * 16-Bit Address Resource
466 buffer = byte_stream_buffer;
469 ACPI_MOVE_16_TO_16 (&temp16, buffer);
471 bytes_consumed = temp16 + 3;
474 * Resource Source Index and Resource Source are
475 * optional elements. Check the length of the
476 * Bytestream. If it is greater than 13, that
477 * means that an Index exists and is followed by
478 * a null termininated string. Therefore, set
479 * the temp variable to the length minus the minimum
480 * byte stream length plus the byte for the Index to
481 * determine the size of the NULL terminiated string.
484 temp8 = (u8) (temp16 - 14);
491 * Ensure a 32-bit boundary for the structure
493 temp8 = (u8) ACPI_ROUND_UP_to_32_bITS (temp8);
495 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_address16) +
496 (temp8 * sizeof (u8));
500 case ACPI_RDESC_TYPE_EXTENDED_XRUPT:
504 buffer = byte_stream_buffer;
507 ACPI_MOVE_16_TO_16 (&temp16, buffer);
509 bytes_consumed = temp16 + 3;
512 * Point past the length field and the
513 * Interrupt vector flags to save off the
514 * Interrupt table length to the Temp8 variable.
520 * To compensate for multiple interrupt numbers, add 4 bytes for
521 * each additional interrupts greater than 1
523 additional_bytes = (u8) ((temp8 - 1) * 4);
526 * Resource Source Index and Resource Source are
527 * optional elements. Check the length of the
528 * Bytestream. If it is greater than 9, that
529 * means that an Index exists and is followed by
530 * a null termininated string. Therefore, set
531 * the temp variable to the length minus the minimum
532 * byte stream length plus the byte for the Index to
533 * determine the size of the NULL terminiated string.
535 if (9 + additional_bytes < temp16) {
536 temp8 = (u8) (temp16 - (9 + additional_bytes));
543 * Ensure a 32-bit boundary for the structure
545 temp8 = (u8) ACPI_ROUND_UP_to_32_bITS (temp8);
547 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_ext_irq) +
548 (additional_bytes * sizeof (u8)) +
549 (temp8 * sizeof (u8));
553 case ACPI_RDESC_TYPE_IRQ_FORMAT:
556 * Determine if it there are two or three trailing bytes
558 buffer = byte_stream_buffer;
569 * Point past the descriptor
574 * Look at the number of bits set
576 ACPI_MOVE_16_TO_16 (&temp16, buffer);
578 for (index = 0; index < 16; index++) {
580 ++number_of_interrupts;
586 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_io) +
587 (number_of_interrupts * sizeof (u32));
591 case ACPI_RDESC_TYPE_DMA_FORMAT:
595 buffer = byte_stream_buffer;
599 * Point past the descriptor
604 * Look at the number of bits set
608 for(index = 0; index < 8; index++) {
610 ++number_of_channels;
616 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_dma) +
617 (number_of_channels * sizeof (u32));
621 case ACPI_RDESC_TYPE_START_DEPENDENT:
623 * Start Dependent Functions Resource
624 * Determine if it there are two or three trailing bytes
626 buffer = byte_stream_buffer;
636 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_start_dpf);
640 case ACPI_RDESC_TYPE_END_DEPENDENT:
642 * End Dependent Functions Resource
645 structure_size = ACPI_RESOURCE_LENGTH;
649 case ACPI_RDESC_TYPE_IO_PORT:
654 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_io);
658 case ACPI_RDESC_TYPE_FIXED_IO_PORT:
660 * Fixed IO Port Resource
663 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_fixed_io);
667 case ACPI_RDESC_TYPE_SMALL_VENDOR:
669 * Vendor Specific Resource
671 buffer = byte_stream_buffer;
674 temp8 = (u8) (temp8 & 0x7);
675 bytes_consumed = temp8 + 1;
678 * Ensure a 32-bit boundary for the structure
680 temp8 = (u8) ACPI_ROUND_UP_to_32_bITS (temp8);
681 structure_size = ACPI_SIZEOF_RESOURCE (struct acpi_resource_vendor) +
682 (temp8 * sizeof (u8));
686 case ACPI_RDESC_TYPE_END_TAG:
691 structure_size = ACPI_RESOURCE_LENGTH;
692 byte_stream_buffer_length = bytes_parsed;
698 * If we get here, everything is out of sync,
701 return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE);
705 * Update the return value and counter
707 buffer_size += (u32) ACPI_ALIGN_RESOURCE_SIZE (structure_size);
708 bytes_parsed += bytes_consumed;
711 * Set the byte stream to point to the next resource
713 byte_stream_buffer += bytes_consumed;
717 * This is the data the caller needs
719 *size_needed = buffer_size;
720 return_ACPI_STATUS (AE_OK);
724 /*******************************************************************************
726 * FUNCTION: acpi_rs_get_pci_routing_table_length
728 * PARAMETERS: package_object - Pointer to the package object
729 * buffer_size_needed - u32 pointer of the size buffer
730 * needed to properly return the
735 * DESCRIPTION: Given a package representing a PCI routing table, this
736 * calculates the size of the corresponding linked list of
739 ******************************************************************************/
742 acpi_rs_get_pci_routing_table_length (
743 union acpi_operand_object *package_object,
744 acpi_size *buffer_size_needed)
746 u32 number_of_elements;
747 acpi_size temp_size_needed = 0;
748 union acpi_operand_object **top_object_list;
750 union acpi_operand_object *package_element;
751 union acpi_operand_object **sub_object_list;
756 ACPI_FUNCTION_TRACE ("rs_get_pci_routing_table_length");
759 number_of_elements = package_object->package.count;
762 * Calculate the size of the return buffer.
763 * The base size is the number of elements * the sizes of the
764 * structures. Additional space for the strings is added below.
765 * The minus one is to subtract the size of the u8 Source[1]
766 * member because it is added below.
768 * But each PRT_ENTRY structure has a pointer to a string and
769 * the size of that string must be found.
771 top_object_list = package_object->package.elements;
773 for (index = 0; index < number_of_elements; index++) {
775 * Dereference the sub-package
777 package_element = *top_object_list;
780 * The sub_object_list will now point to an array of the
781 * four IRQ elements: Address, Pin, Source and source_index
783 sub_object_list = package_element->package.elements;
786 * Scan the irq_table_elements for the Source Name String
790 for (table_index = 0; table_index < 4 && !name_found; table_index++) {
791 if ((ACPI_TYPE_STRING == ACPI_GET_OBJECT_TYPE (*sub_object_list)) ||
792 ((ACPI_TYPE_LOCAL_REFERENCE == ACPI_GET_OBJECT_TYPE (*sub_object_list)) &&
793 ((*sub_object_list)->reference.opcode == AML_INT_NAMEPATH_OP))) {
798 * Look at the next element
804 temp_size_needed += (sizeof (struct acpi_pci_routing_table) - 4);
807 * Was a String type found?
810 if (ACPI_GET_OBJECT_TYPE (*sub_object_list) == ACPI_TYPE_STRING) {
812 * The length String.Length field does not include the
813 * terminating NULL, add 1
815 temp_size_needed += ((acpi_size) (*sub_object_list)->string.length + 1);
818 temp_size_needed += acpi_ns_get_pathname_length (
819 (*sub_object_list)->reference.node);
824 * If no name was found, then this is a NULL, which is
825 * translated as a u32 zero.
827 temp_size_needed += sizeof (u32);
830 /* Round up the size since each element must be aligned */
832 temp_size_needed = ACPI_ROUND_UP_to_64_bITS (temp_size_needed);
835 * Point to the next union acpi_operand_object
841 * Adding an extra element to the end of the list, essentially a NULL terminator
843 *buffer_size_needed = temp_size_needed + sizeof (struct acpi_pci_routing_table);
844 return_ACPI_STATUS (AE_OK);