acpi_status acpi_rs_calculate_list_length ( u8 *byte_stream_buffer, u32 byte_stream_buffer_length, u32 *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; FUNCTION_TRACE ("Rs_calculate_list_length"); while (bytes_parsed < byte_stream_buffer_length) { /* * The next byte in the stream is the resource type */ resource_type = acpi_rs_get_resource_type (*byte_stream_buffer); switch (resource_type) { case RESOURCE_DESC_MEMORY_24: /* * 24-Bit Memory Resource */ bytes_consumed = 12; structure_size = SIZEOF_RESOURCE (acpi_resource_mem24); break; case RESOURCE_DESC_LARGE_VENDOR: /* * Vendor Defined Resource */ buffer = byte_stream_buffer; ++buffer; MOVE_UNALIGNED16_TO_16 (&temp16, buffer); bytes_consumed = temp16 + 3; /* * Ensure a 32-bit boundary for the structure */ temp16 = (u16) ROUND_UP_TO_32_bITS (temp16); structure_size = SIZEOF_RESOURCE (acpi_resource_vendor) + (temp16 * sizeof (u8)); break; case RESOURCE_DESC_MEMORY_32: /* * 32-Bit Memory Range Resource */ bytes_consumed = 20; structure_size = SIZEOF_RESOURCE (acpi_resource_mem32); break; case RESOURCE_DESC_FIXED_MEMORY_32: /* * 32-Bit Fixed Memory Resource */ bytes_consumed = 12; structure_size = SIZEOF_RESOURCE (acpi_resource_fixed_mem32); break; case RESOURCE_DESC_QWORD_ADDRESS_SPACE: /* * 64-Bit Address Resource */ buffer = byte_stream_buffer; ++buffer; MOVE_UNALIGNED16_TO_16 (&temp16, buffer); bytes_consumed = temp16 + 3; /* * 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 termininated 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 terminiated string. */ if (43 < temp16) { temp8 = (u8) (temp16 - 44); } else { temp8 = 0; } /* * Ensure a 64-bit boundary for the structure */ temp8 = (u8) ROUND_UP_TO_64_bITS (temp8); structure_size = SIZEOF_RESOURCE (acpi_resource_address64) + (temp8 * sizeof (u8)); break; case RESOURCE_DESC_DWORD_ADDRESS_SPACE: /* * 32-Bit Address Resource */ buffer = byte_stream_buffer; ++buffer; MOVE_UNALIGNED16_TO_16 (&temp16, buffer); bytes_consumed = temp16 + 3; /* * 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 termininated 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 terminiated string. */ if (23 < temp16) { temp8 = (u8) (temp16 - 24); } else { temp8 = 0; } /* * Ensure a 32-bit boundary for the structure */ temp8 = (u8) ROUND_UP_TO_32_bITS (temp8); structure_size = SIZEOF_RESOURCE (acpi_resource_address32) + (temp8 * sizeof (u8)); break; case RESOURCE_DESC_WORD_ADDRESS_SPACE: /* * 16-Bit Address Resource */ buffer = byte_stream_buffer; ++buffer; MOVE_UNALIGNED16_TO_16 (&temp16, buffer); bytes_consumed = temp16 + 3; /* * 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 termininated 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 terminiated string. */ if (13 < temp16) { temp8 = (u8) (temp16 - 14); } else { temp8 = 0; } /* * Ensure a 32-bit boundary for the structure */ temp8 = (u8) ROUND_UP_TO_32_bITS (temp8); structure_size = SIZEOF_RESOURCE (acpi_resource_address16) + (temp8 * sizeof (u8)); break; case RESOURCE_DESC_EXTENDED_XRUPT: /* * Extended IRQ */ buffer = byte_stream_buffer; ++buffer; MOVE_UNALIGNED16_TO_16 (&temp16, buffer); bytes_consumed = temp16 + 3; /* * 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; /* * To compensate for multiple interrupt numbers, add 4 bytes for * each additional interrupts greater than 1 */ additional_bytes = (u8) ((temp8 - 1) * 4); /* * 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 termininated 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 terminiated string. */ if (9 + additional_bytes < temp16) { temp8 = (u8) (temp16 - (9 + additional_bytes)); } else { temp8 = 0; } /* * Ensure a 32-bit boundary for the structure */ temp8 = (u8) ROUND_UP_TO_32_bITS (temp8); structure_size = SIZEOF_RESOURCE (acpi_resource_ext_irq) + (additional_bytes * sizeof (u8)) + (temp8 * sizeof (u8)); break; case RESOURCE_DESC_IRQ_FORMAT: /* * IRQ Resource. * Determine if it there are two or three trailing bytes */ 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 */ MOVE_UNALIGNED16_TO_16 (&temp16, buffer); for (index = 0; index < 16; index++) { if (temp16 & 0x1) { ++number_of_interrupts; } temp16 >>= 1; } structure_size = SIZEOF_RESOURCE (acpi_resource_io) + (number_of_interrupts * sizeof (u32)); break; case RESOURCE_DESC_DMA_FORMAT: /* * DMA Resource */ 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 = SIZEOF_RESOURCE (acpi_resource_dma) + (number_of_channels * sizeof (u32)); break; case RESOURCE_DESC_START_DEPENDENT: /* * Start Dependent Functions Resource * Determine if it there are two or three trailing bytes */ buffer = byte_stream_buffer; temp8 = *buffer; if(temp8 & 0x01) { bytes_consumed = 2; } else { bytes_consumed = 1; } structure_size = SIZEOF_RESOURCE (acpi_resource_start_dpf); break; case RESOURCE_DESC_END_DEPENDENT: /* * End Dependent Functions Resource */ bytes_consumed = 1; structure_size = ACPI_RESOURCE_LENGTH; break; case RESOURCE_DESC_IO_PORT: /* * IO Port Resource */ bytes_consumed = 8; structure_size = SIZEOF_RESOURCE (acpi_resource_io); break; case RESOURCE_DESC_FIXED_IO_PORT: /* * Fixed IO Port Resource */ bytes_consumed = 4; structure_size = SIZEOF_RESOURCE (acpi_resource_fixed_io); break; case RESOURCE_DESC_SMALL_VENDOR: /* * Vendor Specific Resource */ buffer = byte_stream_buffer; temp8 = *buffer; temp8 = (u8) (temp8 & 0x7); bytes_consumed = temp8 + 1; /* * Ensure a 32-bit boundary for the structure */ temp8 = (u8) ROUND_UP_TO_32_bITS (temp8); structure_size = SIZEOF_RESOURCE (acpi_resource_vendor) + (temp8 * sizeof (u8)); break; case RESOURCE_DESC_END_TAG: /* * End Tag */ bytes_consumed = 2; structure_size = ACPI_RESOURCE_LENGTH; byte_stream_buffer_length = bytes_parsed; break; default: /* * If we get here, everything is out of sync, * so exit with an error */ return_ACPI_STATUS (AE_AML_INVALID_RESOURCE_TYPE); break; } /* * Update the return value and counter */ buffer_size += structure_size; bytes_parsed += bytes_consumed; /* * Set the byte stream to point to the next resource */ byte_stream_buffer += bytes_consumed; } /* * This is the data the caller needs */ *size_needed = buffer_size; return_ACPI_STATUS (AE_OK); }
acpi_status acpi_rs_calculate_pci_routing_table_length ( acpi_operand_object *package_object, u32 *buffer_size_needed) { u32 number_of_elements; u32 temp_size_needed = 0; acpi_operand_object **top_object_list; u32 index; acpi_operand_object *package_element; acpi_operand_object **sub_object_list; u8 name_found; u32 table_index; FUNCTION_TRACE ("Rs_calculate_pci_routing_table_length"); number_of_elements = package_object->package.count; /* * Calculate the size of the return buffer. * The base size is the number of elements * the sizes of the * structures. Additional space for the strings is added below. * The minus one is to subtract the size of the u8 Source[1] * member because it is added below. * * But each PRT_ENTRY structure has a pointer to a string and * the size of that string must be found. */ top_object_list = package_object->package.elements; for (index = 0; index < number_of_elements; index++) { /* * Dereference the sub-package */ package_element = *top_object_list; /* * The Sub_object_list will now point to an array of the * four IRQ elements: Address, Pin, Source and Source_index */ sub_object_list = package_element->package.elements; /* * Scan the Irq_table_elements for the Source Name String */ name_found = FALSE; for (table_index = 0; table_index < 4 && !name_found; table_index++) { if ((ACPI_TYPE_STRING == (*sub_object_list)->common.type) || ((INTERNAL_TYPE_REFERENCE == (*sub_object_list)->common.type) && ((*sub_object_list)->reference.opcode == AML_INT_NAMEPATH_OP))) { name_found = TRUE; } else { /* * Look at the next element */ sub_object_list++; } } temp_size_needed += (sizeof (pci_routing_table) - 4); /* * Was a String type found? */ if (TRUE == name_found) { if (ACPI_TYPE_STRING == (*sub_object_list)->common.type) { /* * The length String.Length field includes the * terminating NULL */ temp_size_needed += (*sub_object_list)->string.length; } else { temp_size_needed += acpi_ns_get_pathname_length ( (*sub_object_list)->reference.node); } } else { /* * If no name was found, then this is a NULL, which is * translated as a u32 zero. */ temp_size_needed += sizeof (u32); } /* Round up the size since each element must be aligned */ temp_size_needed = ROUND_UP_TO_64_bITS (temp_size_needed); /* * Point to the next acpi_operand_object */ top_object_list++; } /* * Adding an extra element to the end of the list, essentially a NULL terminator */ *buffer_size_needed = temp_size_needed + sizeof (pci_routing_table); return_ACPI_STATUS (AE_OK); }
acpi_status acpi_rs_create_pci_routing_table ( acpi_operand_object *package_object, u8 *output_buffer, u32 *output_buffer_length) { u8 *buffer = output_buffer; acpi_operand_object **top_object_list = NULL; acpi_operand_object **sub_object_list = NULL; acpi_operand_object *package_element = NULL; u32 buffer_size_needed = 0; u32 number_of_elements = 0; u32 index = 0; pci_routing_table *user_prt = NULL; acpi_namespace_node *node; acpi_status status; FUNCTION_TRACE ("Rs_create_pci_routing_table"); /* * Params already validated, so we don't re-validate here */ status = acpi_rs_calculate_pci_routing_table_length (package_object, &buffer_size_needed); if (!ACPI_SUCCESS(status)) { return_ACPI_STATUS (status); } ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Buffer_size_needed = %X\n", buffer_size_needed)); /* * If the data will fit into the available buffer * call to fill in the list */ if (buffer_size_needed <= *output_buffer_length) { /* * Zero out the return buffer before proceeding */ MEMSET (output_buffer, 0x00, *output_buffer_length); /* * Loop through the ACPI_INTERNAL_OBJECTS - Each object should * contain a u32 Address, a u8 Pin, a Name and a u8 * Source_index. */ top_object_list = package_object->package.elements; number_of_elements = package_object->package.count; user_prt = (pci_routing_table *) buffer; buffer = ROUND_PTR_UP_TO_8 (buffer, u8); for (index = 0; index < number_of_elements; index++) { /* * Point User_prt past this current structure * * NOTE: On the first iteration, User_prt->Length will * be zero because we cleared the return buffer earlier */ buffer += user_prt->length; user_prt = (pci_routing_table *) buffer; /* * Fill in the Length field with the information we * have at this point. * The minus four is to subtract the size of the * u8 Source[4] member because it is added below. */ user_prt->length = (sizeof (pci_routing_table) -4); /* * Dereference the sub-package */ package_element = *top_object_list; /* * The Sub_object_list will now point to an array of * the four IRQ elements: Address, Pin, Source and * Source_index */ sub_object_list = package_element->package.elements; /* * 1) First subobject: Dereference the Address */ if (ACPI_TYPE_INTEGER == (*sub_object_list)->common.type) { user_prt->address = (*sub_object_list)->integer.value; } else { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", acpi_ut_get_type_name ((*sub_object_list)->common.type))); return_ACPI_STATUS (AE_BAD_DATA); } /* * 2) Second subobject: Dereference the Pin */ sub_object_list++; if (ACPI_TYPE_INTEGER == (*sub_object_list)->common.type) { user_prt->pin = (u32) (*sub_object_list)->integer.value; } else { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", acpi_ut_get_type_name ((*sub_object_list)->common.type))); return_ACPI_STATUS (AE_BAD_DATA); } /* * 3) Third subobject: Dereference the Source Name */ sub_object_list++; switch ((*sub_object_list)->common.type) { case INTERNAL_TYPE_REFERENCE: if ((*sub_object_list)->reference.opcode != AML_INT_NAMEPATH_OP) { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need name, found reference op %X\n", (*sub_object_list)->reference.opcode)); return_ACPI_STATUS (AE_BAD_DATA); } node = (*sub_object_list)->reference.node; /* TBD: use *remaining* length of the buffer! */ status = acpi_ns_handle_to_pathname ((acpi_handle *) node, output_buffer_length, user_prt->source); user_prt->length += STRLEN (user_prt->source) + 1; /* include null terminator */ break; case ACPI_TYPE_STRING: STRCPY (user_prt->source, (*sub_object_list)->string.pointer); /* * Add to the Length field the length of the string */ user_prt->length += (*sub_object_list)->string.length; break; case ACPI_TYPE_INTEGER: /* * If this is a number, then the Source Name * is NULL, since the entire buffer was zeroed * out, we can leave this alone. */ /* * Add to the Length field the length of * the u32 NULL */ user_prt->length += sizeof (u32); break; default: ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", acpi_ut_get_type_name ((*sub_object_list)->common.type))); return_ACPI_STATUS (AE_BAD_DATA); break; } /* Now align the current length */ user_prt->length = ROUND_UP_TO_64_bITS (user_prt->length); /* * 4) Fourth subobject: Dereference the Source Index */ sub_object_list++; if (ACPI_TYPE_INTEGER == (*sub_object_list)->common.type) { user_prt->source_index = (u32) (*sub_object_list)->integer.value; } else { ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Need Integer, found %s\n", acpi_ut_get_type_name ((*sub_object_list)->common.type))); return_ACPI_STATUS (AE_BAD_DATA); } /* * Point to the next acpi_operand_object */ top_object_list++; } ACPI_DEBUG_PRINT ((ACPI_DB_INFO, "Output_buffer = %p\n", output_buffer)); } else { *output_buffer_length = buffer_size_needed; return_ACPI_STATUS (AE_BUFFER_OVERFLOW); } /* * Report the amount of buffer used */ *output_buffer_length = buffer_size_needed; return_ACPI_STATUS (AE_OK); }