1 /******************************************************************************
3 * Module Name: tbget - ACPI Table get* routines
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2005, 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.
44 #include <acpi/acpi.h>
45 #include <acpi/actables.h>
47 #define _COMPONENT ACPI_TABLES
48 ACPI_MODULE_NAME("tbget")
50 /* Local prototypes */
52 acpi_tb_get_this_table(struct acpi_pointer *address,
53 struct acpi_table_header *header,
54 struct acpi_table_desc *table_info);
57 acpi_tb_table_override(struct acpi_table_header *header,
58 struct acpi_table_desc *table_info);
60 /*******************************************************************************
62 * FUNCTION: acpi_tb_get_table
64 * PARAMETERS: Address - Address of table to retrieve. Can be
66 * table_info - Where table info is returned
70 * DESCRIPTION: Get entire table of unknown size.
72 ******************************************************************************/
75 acpi_tb_get_table(struct acpi_pointer *address,
76 struct acpi_table_desc *table_info)
79 struct acpi_table_header header;
81 ACPI_FUNCTION_TRACE("tb_get_table");
83 /* Get the header in order to get signature and table size */
85 status = acpi_tb_get_table_header(address, &header);
86 if (ACPI_FAILURE(status)) {
87 return_ACPI_STATUS(status);
90 /* Get the entire table */
92 status = acpi_tb_get_table_body(address, &header, table_info);
93 if (ACPI_FAILURE(status)) {
94 ACPI_REPORT_ERROR(("Could not get ACPI table (size %X), %s\n",
96 acpi_format_exception(status)));
97 return_ACPI_STATUS(status);
100 return_ACPI_STATUS(AE_OK);
103 /*******************************************************************************
105 * FUNCTION: acpi_tb_get_table_header
107 * PARAMETERS: Address - Address of table to retrieve. Can be
108 * Logical or Physical
109 * return_header - Where the table header is returned
113 * DESCRIPTION: Get an ACPI table header. Works in both physical or virtual
114 * addressing mode. Works with both physical or logical pointers.
115 * Table is either copied or mapped, depending on the pointer
116 * type and mode of the processor.
118 ******************************************************************************/
121 acpi_tb_get_table_header(struct acpi_pointer *address,
122 struct acpi_table_header *return_header)
124 acpi_status status = AE_OK;
125 struct acpi_table_header *header = NULL;
127 ACPI_FUNCTION_TRACE("tb_get_table_header");
130 * Flags contains the current processor mode (Virtual or Physical
131 * addressing) The pointer_type is either Logical or Physical
133 switch (address->pointer_type) {
134 case ACPI_PHYSMODE_PHYSPTR:
135 case ACPI_LOGMODE_LOGPTR:
137 /* Pointer matches processor mode, copy the header */
139 ACPI_MEMCPY(return_header, address->pointer.logical,
140 sizeof(struct acpi_table_header));
143 case ACPI_LOGMODE_PHYSPTR:
145 /* Create a logical address for the physical pointer */
147 status = acpi_os_map_memory(address->pointer.physical,
148 sizeof(struct acpi_table_header),
150 if (ACPI_FAILURE(status)) {
151 ACPI_REPORT_ERROR(("Could not map memory at %8.8X%8.8X for length %X\n", ACPI_FORMAT_UINT64(address->pointer.physical), sizeof(struct acpi_table_header)));
152 return_ACPI_STATUS(status);
155 /* Copy header and delete mapping */
157 ACPI_MEMCPY(return_header, header,
158 sizeof(struct acpi_table_header));
159 acpi_os_unmap_memory(header, sizeof(struct acpi_table_header));
164 ACPI_REPORT_ERROR(("Invalid address flags %X\n",
165 address->pointer_type));
166 return_ACPI_STATUS(AE_BAD_PARAMETER);
169 ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "Table Signature: [%4.4s]\n",
170 return_header->signature));
172 return_ACPI_STATUS(AE_OK);
175 /*******************************************************************************
177 * FUNCTION: acpi_tb_get_table_body
179 * PARAMETERS: Address - Address of table to retrieve. Can be
180 * Logical or Physical
181 * Header - Header of the table to retrieve
182 * table_info - Where the table info is returned
186 * DESCRIPTION: Get an entire ACPI table with support to allow the host OS to
187 * replace the table with a newer version (table override.)
188 * Works in both physical or virtual
189 * addressing mode. Works with both physical or logical pointers.
190 * Table is either copied or mapped, depending on the pointer
191 * type and mode of the processor.
193 ******************************************************************************/
196 acpi_tb_get_table_body(struct acpi_pointer *address,
197 struct acpi_table_header *header,
198 struct acpi_table_desc *table_info)
202 ACPI_FUNCTION_TRACE("tb_get_table_body");
204 if (!table_info || !address) {
205 return_ACPI_STATUS(AE_BAD_PARAMETER);
208 /* Attempt table override. */
210 status = acpi_tb_table_override(header, table_info);
211 if (ACPI_SUCCESS(status)) {
212 /* Table was overridden by the host OS */
214 return_ACPI_STATUS(status);
217 /* No override, get the original table */
219 status = acpi_tb_get_this_table(address, header, table_info);
220 return_ACPI_STATUS(status);
223 /*******************************************************************************
225 * FUNCTION: acpi_tb_table_override
227 * PARAMETERS: Header - Pointer to table header
228 * table_info - Return info if table is overridden
232 * DESCRIPTION: Attempts override of current table with a new one if provided
235 ******************************************************************************/
238 acpi_tb_table_override(struct acpi_table_header *header,
239 struct acpi_table_desc *table_info)
241 struct acpi_table_header *new_table;
243 struct acpi_pointer address;
245 ACPI_FUNCTION_TRACE("tb_table_override");
248 * The OSL will examine the header and decide whether to override this
249 * table. If it decides to override, a table will be returned in new_table,
250 * which we will then copy.
252 status = acpi_os_table_override(header, &new_table);
253 if (ACPI_FAILURE(status)) {
254 /* Some severe error from the OSL, but we basically ignore it */
256 ACPI_REPORT_ERROR(("Could not override ACPI table, %s\n",
257 acpi_format_exception(status)));
258 return_ACPI_STATUS(status);
262 /* No table override */
264 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
268 * We have a new table to override the old one. Get a copy of
269 * the new one. We know that the new table has a logical pointer.
271 address.pointer_type = ACPI_LOGICAL_POINTER | ACPI_LOGICAL_ADDRESSING;
272 address.pointer.logical = new_table;
274 status = acpi_tb_get_this_table(&address, new_table, table_info);
275 if (ACPI_FAILURE(status)) {
276 ACPI_REPORT_ERROR(("Could not copy override ACPI table, %s\n",
277 acpi_format_exception(status)));
278 return_ACPI_STATUS(status);
281 /* Copy the table info */
283 ACPI_REPORT_INFO(("Table [%4.4s] replaced by host OS\n",
284 table_info->pointer->signature));
286 return_ACPI_STATUS(AE_OK);
289 /*******************************************************************************
291 * FUNCTION: acpi_tb_get_this_table
293 * PARAMETERS: Address - Address of table to retrieve. Can be
294 * Logical or Physical
295 * Header - Header of the table to retrieve
296 * table_info - Where the table info is returned
300 * DESCRIPTION: Get an entire ACPI table. Works in both physical or virtual
301 * addressing mode. Works with both physical or logical pointers.
302 * Table is either copied or mapped, depending on the pointer
303 * type and mode of the processor.
305 ******************************************************************************/
308 acpi_tb_get_this_table(struct acpi_pointer *address,
309 struct acpi_table_header *header,
310 struct acpi_table_desc *table_info)
312 struct acpi_table_header *full_table = NULL;
314 acpi_status status = AE_OK;
316 ACPI_FUNCTION_TRACE("tb_get_this_table");
319 * Flags contains the current processor mode (Virtual or Physical
320 * addressing) The pointer_type is either Logical or Physical
322 switch (address->pointer_type) {
323 case ACPI_PHYSMODE_PHYSPTR:
324 case ACPI_LOGMODE_LOGPTR:
326 /* Pointer matches processor mode, copy the table to a new buffer */
328 full_table = ACPI_MEM_ALLOCATE(header->length);
330 ACPI_REPORT_ERROR(("Could not allocate table memory for [%4.4s] length %X\n", header->signature, header->length));
331 return_ACPI_STATUS(AE_NO_MEMORY);
334 /* Copy the entire table (including header) to the local buffer */
336 ACPI_MEMCPY(full_table, address->pointer.logical,
339 /* Save allocation type */
341 allocation = ACPI_MEM_ALLOCATED;
344 case ACPI_LOGMODE_PHYSPTR:
347 * Just map the table's physical memory
348 * into our address space.
350 status = acpi_os_map_memory(address->pointer.physical,
351 (acpi_size) header->length,
352 (void *)&full_table);
353 if (ACPI_FAILURE(status)) {
354 ACPI_REPORT_ERROR(("Could not map memory for table [%4.4s] at %8.8X%8.8X for length %X\n", header->signature, ACPI_FORMAT_UINT64(address->pointer.physical), header->length));
358 /* Save allocation type */
360 allocation = ACPI_MEM_MAPPED;
365 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid address flags %X\n",
366 address->pointer_type));
367 return_ACPI_STATUS(AE_BAD_PARAMETER);
371 * Validate checksum for _most_ tables,
372 * even the ones whose signature we don't recognize
374 if (table_info->type != ACPI_TABLE_FACS) {
375 status = acpi_tb_verify_table_checksum(full_table);
377 #if (!ACPI_CHECKSUM_ABORT)
378 if (ACPI_FAILURE(status)) {
379 /* Ignore the error if configuration says so */
388 table_info->pointer = full_table;
389 table_info->length = (acpi_size) header->length;
390 table_info->allocation = allocation;
392 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
393 "Found table [%4.4s] at %8.8X%8.8X, mapped/copied to %p\n",
394 full_table->signature,
395 ACPI_FORMAT_UINT64(address->pointer.physical),
398 return_ACPI_STATUS(status);
401 /*******************************************************************************
403 * FUNCTION: acpi_tb_get_table_ptr
405 * PARAMETERS: table_type - one of the defined table types
406 * Instance - Which table of this type
407 * table_ptr_loc - pointer to location to place the pointer for
412 * DESCRIPTION: This function is called to get the pointer to an ACPI table.
414 ******************************************************************************/
417 acpi_tb_get_table_ptr(acpi_table_type table_type,
418 u32 instance, struct acpi_table_header **table_ptr_loc)
420 struct acpi_table_desc *table_desc;
423 ACPI_FUNCTION_TRACE("tb_get_table_ptr");
425 if (!acpi_gbl_DSDT) {
426 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
429 if (table_type > ACPI_TABLE_MAX) {
430 return_ACPI_STATUS(AE_BAD_PARAMETER);
434 * For all table types (Single/Multiple), the first
435 * instance is always in the list head.
440 *table_ptr_loc = NULL;
441 if (acpi_gbl_table_lists[table_type].next) {
443 acpi_gbl_table_lists[table_type].next->pointer;
445 return_ACPI_STATUS(AE_OK);
448 /* Check for instance out of range */
450 if (instance > acpi_gbl_table_lists[table_type].count) {
451 return_ACPI_STATUS(AE_NOT_EXIST);
454 /* Walk the list to get the desired table
455 * Since the if (Instance == 1) check above checked for the
456 * first table, setting table_desc equal to the .Next member
457 * is actually pointing to the second table. Therefore, we
458 * need to walk from the 2nd table until we reach the Instance
459 * that the user is looking for and return its table pointer.
461 table_desc = acpi_gbl_table_lists[table_type].next;
462 for (i = 2; i < instance; i++) {
463 table_desc = table_desc->next;
466 /* We are now pointing to the requested table's descriptor */
468 *table_ptr_loc = table_desc->pointer;
470 return_ACPI_STATUS(AE_OK);