blob: a62db6af83c9139ad8ab02871862db6eeef9af90 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
2 *
3 * Module Name: tbxfroot - Find the root ACPI table (RSDT)
4 *
5 *****************************************************************************/
6
7/*
Bob Moore4a90c7e2006-01-13 16:22:00 -05008 * Copyright (C) 2000 - 2006, R. Byron Moore
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
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.
25 *
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.
29 *
30 * NO WARRANTY
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.
42 */
43
44#include <linux/module.h>
45
46#include <acpi/acpi.h>
47#include <acpi/actables.h>
48
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define _COMPONENT ACPI_TABLES
Len Brown4be44fc2005-08-05 00:44:28 -040050ACPI_MODULE_NAME("tbxfroot")
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Robert Moore44f6c012005-04-18 22:49:35 -040052/* Local prototypes */
Robert Moore44f6c012005-04-18 22:49:35 -040053static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -040054acpi_tb_find_rsdp(struct acpi_table_desc *table_info, u32 flags);
Robert Moore44f6c012005-04-18 22:49:35 -040055
Len Brown4be44fc2005-08-05 00:44:28 -040056static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
58/*******************************************************************************
59 *
Robert Mooref9f46012005-07-08 00:00:00 -040060 * FUNCTION: acpi_tb_validate_rsdp
61 *
62 * PARAMETERS: Rsdp - Pointer to unvalidated RSDP
63 *
64 * RETURN: Status
65 *
66 * DESCRIPTION: Validate the RSDP (ptr)
67 *
68 ******************************************************************************/
69
Len Brown4be44fc2005-08-05 00:44:28 -040070acpi_status acpi_tb_validate_rsdp(struct rsdp_descriptor *rsdp)
Robert Mooref9f46012005-07-08 00:00:00 -040071{
Len Brown4be44fc2005-08-05 00:44:28 -040072 ACPI_FUNCTION_ENTRY();
Robert Mooref9f46012005-07-08 00:00:00 -040073
74 /*
75 * The signature and checksum must both be correct
76 */
Len Brown4be44fc2005-08-05 00:44:28 -040077 if (ACPI_STRNCMP((char *)rsdp, RSDP_SIG, sizeof(RSDP_SIG) - 1) != 0) {
Robert Mooref9f46012005-07-08 00:00:00 -040078 /* Nope, BAD Signature */
79
80 return (AE_BAD_SIGNATURE);
81 }
82
83 /* Check the standard checksum */
84
Len Brown4be44fc2005-08-05 00:44:28 -040085 if (acpi_tb_generate_checksum(rsdp, ACPI_RSDP_CHECKSUM_LENGTH) != 0) {
Robert Mooref9f46012005-07-08 00:00:00 -040086 return (AE_BAD_CHECKSUM);
87 }
88
89 /* Check extended checksum if table version >= 2 */
90
91 if ((rsdp->revision >= 2) &&
Len Brown4be44fc2005-08-05 00:44:28 -040092 (acpi_tb_generate_checksum(rsdp, ACPI_RSDP_XCHECKSUM_LENGTH) !=
93 0)) {
Robert Mooref9f46012005-07-08 00:00:00 -040094 return (AE_BAD_CHECKSUM);
95 }
96
97 return (AE_OK);
98}
99
Robert Mooref9f46012005-07-08 00:00:00 -0400100/*******************************************************************************
101 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 * FUNCTION: acpi_tb_find_table
103 *
104 * PARAMETERS: Signature - String with ACPI table signature
105 * oem_id - String with the table OEM ID
Robert Moore44f6c012005-04-18 22:49:35 -0400106 * oem_table_id - String with the OEM Table ID
107 * table_ptr - Where the table pointer is returned
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 *
109 * RETURN: Status
110 *
111 * DESCRIPTION: Find an ACPI table (in the RSDT/XSDT) that matches the
112 * Signature, OEM ID and OEM Table ID.
113 *
114 ******************************************************************************/
115
116acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400117acpi_tb_find_table(char *signature,
118 char *oem_id,
119 char *oem_table_id, struct acpi_table_header ** table_ptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120{
Len Brown4be44fc2005-08-05 00:44:28 -0400121 acpi_status status;
122 struct acpi_table_header *table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Len Brown4be44fc2005-08-05 00:44:28 -0400124 ACPI_FUNCTION_TRACE("tb_find_table");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126 /* Validate string lengths */
127
Len Brown4be44fc2005-08-05 00:44:28 -0400128 if ((ACPI_STRLEN(signature) > ACPI_NAME_SIZE) ||
129 (ACPI_STRLEN(oem_id) > sizeof(table->oem_id)) ||
130 (ACPI_STRLEN(oem_table_id) > sizeof(table->oem_table_id))) {
131 return_ACPI_STATUS(AE_AML_STRING_LIMIT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 }
133
Len Brown4be44fc2005-08-05 00:44:28 -0400134 if (!ACPI_STRNCMP(signature, DSDT_SIG, ACPI_NAME_SIZE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 /*
136 * The DSDT pointer is contained in the FADT, not the RSDT.
137 * This code should suffice, because the only code that would perform
138 * a "find" on the DSDT is the data_table_region() AML opcode -- in
139 * which case, the DSDT is guaranteed to be already loaded.
140 * If this becomes insufficient, the FADT will have to be found first.
141 */
142 if (!acpi_gbl_DSDT) {
Len Brown4be44fc2005-08-05 00:44:28 -0400143 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 table = acpi_gbl_DSDT;
Len Brown4be44fc2005-08-05 00:44:28 -0400146 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 /* Find the table */
148
Len Brown4be44fc2005-08-05 00:44:28 -0400149 status = acpi_get_firmware_table(signature, 1,
150 ACPI_LOGICAL_ADDRESSING,
151 &table);
152 if (ACPI_FAILURE(status)) {
153 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 }
155 }
156
157 /* Check oem_id and oem_table_id */
158
Len Brown4be44fc2005-08-05 00:44:28 -0400159 if ((oem_id[0] && ACPI_STRNCMP(oem_id, table->oem_id,
160 sizeof(table->oem_id))) ||
161 (oem_table_id[0] && ACPI_STRNCMP(oem_table_id, table->oem_table_id,
162 sizeof(table->oem_table_id)))) {
163 return_ACPI_STATUS(AE_AML_NAME_NOT_FOUND);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 }
165
Len Brown4be44fc2005-08-05 00:44:28 -0400166 ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "Found table [%4.4s]\n",
167 table->signature));
Robert Moore44f6c012005-04-18 22:49:35 -0400168
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 *table_ptr = table;
Len Brown4be44fc2005-08-05 00:44:28 -0400170 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173/*******************************************************************************
174 *
175 * FUNCTION: acpi_get_firmware_table
176 *
177 * PARAMETERS: Signature - Any ACPI table signature
178 * Instance - the non zero instance of the table, allows
179 * support for multiple tables of the same type
180 * Flags - Physical/Virtual support
181 * table_pointer - Where a buffer containing the table is
182 * returned
183 *
184 * RETURN: Status
185 *
186 * DESCRIPTION: This function is called to get an ACPI table. A buffer is
187 * allocated for the table and returned in table_pointer.
188 * This table will be a complete table including the header.
189 *
190 ******************************************************************************/
191
192acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400193acpi_get_firmware_table(acpi_string signature,
194 u32 instance,
195 u32 flags, struct acpi_table_header **table_pointer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196{
Len Brown4be44fc2005-08-05 00:44:28 -0400197 acpi_status status;
198 struct acpi_pointer address;
199 struct acpi_table_header *header = NULL;
200 struct acpi_table_desc *table_info = NULL;
201 struct acpi_table_desc *rsdt_info;
202 u32 table_count;
203 u32 i;
204 u32 j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
Len Brown4be44fc2005-08-05 00:44:28 -0400206 ACPI_FUNCTION_TRACE("acpi_get_firmware_table");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
208 /*
209 * Ensure that at least the table manager is initialized. We don't
210 * require that the entire ACPI subsystem is up for this interface.
211 * If we have a buffer, we must have a length too
212 */
Len Brown4be44fc2005-08-05 00:44:28 -0400213 if ((instance == 0) || (!signature) || (!table_pointer)) {
214 return_ACPI_STATUS(AE_BAD_PARAMETER);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 }
216
217 /* Ensure that we have a RSDP */
218
219 if (!acpi_gbl_RSDP) {
220 /* Get the RSDP */
221
Len Brown4be44fc2005-08-05 00:44:28 -0400222 status = acpi_os_get_root_pointer(flags, &address);
223 if (ACPI_FAILURE(status)) {
224 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "RSDP not found\n"));
225 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 }
227
228 /* Map and validate the RSDP */
229
230 if ((flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) {
Len Brown4be44fc2005-08-05 00:44:28 -0400231 status = acpi_os_map_memory(address.pointer.physical,
232 sizeof(struct
233 rsdp_descriptor),
234 (void *)&acpi_gbl_RSDP);
235 if (ACPI_FAILURE(status)) {
236 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 }
Len Brown4be44fc2005-08-05 00:44:28 -0400238 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 acpi_gbl_RSDP = address.pointer.logical;
240 }
241
Robert Mooref9f46012005-07-08 00:00:00 -0400242 /* The RDSP signature and checksum must both be correct */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
Len Brown4be44fc2005-08-05 00:44:28 -0400244 status = acpi_tb_validate_rsdp(acpi_gbl_RSDP);
245 if (ACPI_FAILURE(status)) {
246 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 }
248 }
249
250 /* Get the RSDT address via the RSDP */
251
Len Brown4be44fc2005-08-05 00:44:28 -0400252 acpi_tb_get_rsdt_address(&address);
253 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
Bob Moore50eca3e2005-09-30 19:03:00 -0400254 "RSDP located at %p, RSDT physical=%8.8X%8.8X\n",
Len Brown4be44fc2005-08-05 00:44:28 -0400255 acpi_gbl_RSDP,
256 ACPI_FORMAT_UINT64(address.pointer.value)));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257
258 /* Insert processor_mode flags */
259
260 address.pointer_type |= flags;
261
262 /* Get and validate the RSDT */
263
Len Brown4be44fc2005-08-05 00:44:28 -0400264 rsdt_info = ACPI_MEM_CALLOCATE(sizeof(struct acpi_table_desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 if (!rsdt_info) {
Len Brown4be44fc2005-08-05 00:44:28 -0400266 return_ACPI_STATUS(AE_NO_MEMORY);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 }
268
Len Brown4be44fc2005-08-05 00:44:28 -0400269 status = acpi_tb_get_table(&address, rsdt_info);
270 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 goto cleanup;
272 }
273
Len Brown4be44fc2005-08-05 00:44:28 -0400274 status = acpi_tb_validate_rsdt(rsdt_info->pointer);
275 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 goto cleanup;
277 }
278
279 /* Allocate a scratch table header and table descriptor */
280
Len Brown4be44fc2005-08-05 00:44:28 -0400281 header = ACPI_MEM_ALLOCATE(sizeof(struct acpi_table_header));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 if (!header) {
283 status = AE_NO_MEMORY;
284 goto cleanup;
285 }
286
Len Brown4be44fc2005-08-05 00:44:28 -0400287 table_info = ACPI_MEM_ALLOCATE(sizeof(struct acpi_table_desc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 if (!table_info) {
289 status = AE_NO_MEMORY;
290 goto cleanup;
291 }
292
293 /* Get the number of table pointers within the RSDT */
294
Len Brown4be44fc2005-08-05 00:44:28 -0400295 table_count =
296 acpi_tb_get_table_count(acpi_gbl_RSDP, rsdt_info->pointer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 address.pointer_type = acpi_gbl_table_flags | flags;
298
299 /*
300 * Search the RSDT/XSDT for the correct instance of the
301 * requested table
302 */
303 for (i = 0, j = 0; i < table_count; i++) {
Robert Moore73459f72005-06-24 00:00:00 -0400304 /*
305 * Get the next table pointer, handle RSDT vs. XSDT
306 * RSDT pointers are 32 bits, XSDT pointers are 64 bits
307 */
308 if (acpi_gbl_root_table_type == ACPI_TABLE_TYPE_RSDT) {
Len Brown4be44fc2005-08-05 00:44:28 -0400309 address.pointer.value =
310 (ACPI_CAST_PTR
311 (RSDT_DESCRIPTOR,
312 rsdt_info->pointer))->table_offset_entry[i];
313 } else {
314 address.pointer.value =
315 (ACPI_CAST_PTR
316 (XSDT_DESCRIPTOR,
317 rsdt_info->pointer))->table_offset_entry[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319
320 /* Get the table header */
321
Len Brown4be44fc2005-08-05 00:44:28 -0400322 status = acpi_tb_get_table_header(&address, header);
323 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 goto cleanup;
325 }
326
327 /* Compare table signatures and table instance */
328
Len Brown4be44fc2005-08-05 00:44:28 -0400329 if (!ACPI_STRNCMP(header->signature, signature, ACPI_NAME_SIZE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 /* An instance of the table was found */
331
332 j++;
333 if (j >= instance) {
334 /* Found the correct instance, get the entire table */
335
Len Brown4be44fc2005-08-05 00:44:28 -0400336 status =
337 acpi_tb_get_table_body(&address, header,
338 table_info);
339 if (ACPI_FAILURE(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 goto cleanup;
341 }
342
343 *table_pointer = table_info->pointer;
344 goto cleanup;
345 }
346 }
347 }
348
349 /* Did not find the table */
350
351 status = AE_NOT_EXIST;
352
Len Brown4be44fc2005-08-05 00:44:28 -0400353 cleanup:
Robert Moore88ac00f2005-05-26 00:00:00 -0400354 if (rsdt_info->pointer) {
Len Brown4be44fc2005-08-05 00:44:28 -0400355 acpi_os_unmap_memory(rsdt_info->pointer,
356 (acpi_size) rsdt_info->pointer->length);
Robert Moore88ac00f2005-05-26 00:00:00 -0400357 }
Len Brown4be44fc2005-08-05 00:44:28 -0400358 ACPI_MEM_FREE(rsdt_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
360 if (header) {
Len Brown4be44fc2005-08-05 00:44:28 -0400361 ACPI_MEM_FREE(header);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
363 if (table_info) {
Len Brown4be44fc2005-08-05 00:44:28 -0400364 ACPI_MEM_FREE(table_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 }
Len Brown4be44fc2005-08-05 00:44:28 -0400366 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Len Brown4be44fc2005-08-05 00:44:28 -0400369EXPORT_SYMBOL(acpi_get_firmware_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370
371/* TBD: Move to a new file */
372
373#if ACPI_MACHINE_WIDTH != 16
374
375/*******************************************************************************
376 *
377 * FUNCTION: acpi_find_root_pointer
378 *
Robert Moore44f6c012005-04-18 22:49:35 -0400379 * PARAMETERS: Flags - Logical/Physical addressing
380 * rsdp_address - Where to place the RSDP address
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 *
382 * RETURN: Status, Physical address of the RSDP
383 *
384 * DESCRIPTION: Find the RSDP
385 *
386 ******************************************************************************/
387
Len Brown4be44fc2005-08-05 00:44:28 -0400388acpi_status acpi_find_root_pointer(u32 flags, struct acpi_pointer *rsdp_address)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
Len Brown4be44fc2005-08-05 00:44:28 -0400390 struct acpi_table_desc table_info;
391 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Len Brown4be44fc2005-08-05 00:44:28 -0400393 ACPI_FUNCTION_TRACE("acpi_find_root_pointer");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
395 /* Get the RSDP */
396
Len Brown4be44fc2005-08-05 00:44:28 -0400397 status = acpi_tb_find_rsdp(&table_info, flags);
398 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500399 ACPI_EXCEPTION((AE_INFO, status,
400 "RSDP structure not found - Flags=%X", flags));
Robert Moore44f6c012005-04-18 22:49:35 -0400401
Len Brown4be44fc2005-08-05 00:44:28 -0400402 return_ACPI_STATUS(AE_NO_ACPI_TABLES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 }
404
405 rsdp_address->pointer_type = ACPI_PHYSICAL_POINTER;
406 rsdp_address->pointer.physical = table_info.physical_address;
Len Brown4be44fc2005-08-05 00:44:28 -0400407 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
409
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410/*******************************************************************************
411 *
412 * FUNCTION: acpi_tb_scan_memory_for_rsdp
413 *
414 * PARAMETERS: start_address - Starting pointer for search
415 * Length - Maximum length to search
416 *
417 * RETURN: Pointer to the RSDP if found, otherwise NULL.
418 *
419 * DESCRIPTION: Search a block of memory for the RSDP signature
420 *
421 ******************************************************************************/
422
Len Brown4be44fc2005-08-05 00:44:28 -0400423static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Len Brown4be44fc2005-08-05 00:44:28 -0400425 acpi_status status;
426 u8 *mem_rover;
427 u8 *end_address;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Len Brown4be44fc2005-08-05 00:44:28 -0400429 ACPI_FUNCTION_TRACE("tb_scan_memory_for_rsdp");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430
431 end_address = start_address + length;
432
433 /* Search from given start address for the requested length */
434
435 for (mem_rover = start_address; mem_rover < end_address;
Len Brown4be44fc2005-08-05 00:44:28 -0400436 mem_rover += ACPI_RSDP_SCAN_STEP) {
Robert Mooref9f46012005-07-08 00:00:00 -0400437 /* The RSDP signature and checksum must both be correct */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Len Brown4be44fc2005-08-05 00:44:28 -0400439 status =
440 acpi_tb_validate_rsdp(ACPI_CAST_PTR
441 (struct rsdp_descriptor, mem_rover));
442 if (ACPI_SUCCESS(status)) {
Robert Mooref9f46012005-07-08 00:00:00 -0400443 /* Sig and checksum valid, we have found a real RSDP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Len Brown4be44fc2005-08-05 00:44:28 -0400445 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
446 "RSDP located at physical address %p\n",
447 mem_rover));
448 return_PTR(mem_rover);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
450
Robert Mooref9f46012005-07-08 00:00:00 -0400451 /* No sig match or bad checksum, keep searching */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 }
453
454 /* Searched entire block, no RSDP was found */
455
Len Brown4be44fc2005-08-05 00:44:28 -0400456 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
457 "Searched entire block from %p, valid RSDP was not found\n",
458 start_address));
459 return_PTR(NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460}
461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462/*******************************************************************************
463 *
464 * FUNCTION: acpi_tb_find_rsdp
465 *
Robert Moore44f6c012005-04-18 22:49:35 -0400466 * PARAMETERS: table_info - Where the table info is returned
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 * Flags - Current memory mode (logical vs.
468 * physical addressing)
469 *
470 * RETURN: Status, RSDP physical address
471 *
472 * DESCRIPTION: search lower 1_mbyte of memory for the root system descriptor
473 * pointer structure. If it is found, set *RSDP to point to it.
474 *
475 * NOTE1: The RSDp must be either in the first 1_k of the Extended
476 * BIOS Data Area or between E0000 and FFFFF (From ACPI Spec.)
477 * Only a 32-bit physical address is necessary.
478 *
479 * NOTE2: This function is always available, regardless of the
480 * initialization state of the rest of ACPI.
481 *
482 ******************************************************************************/
483
Robert Moore44f6c012005-04-18 22:49:35 -0400484static acpi_status
Len Brown4be44fc2005-08-05 00:44:28 -0400485acpi_tb_find_rsdp(struct acpi_table_desc *table_info, u32 flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486{
Len Brown4be44fc2005-08-05 00:44:28 -0400487 u8 *table_ptr;
488 u8 *mem_rover;
489 u32 physical_address;
490 acpi_status status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491
Len Brown4be44fc2005-08-05 00:44:28 -0400492 ACPI_FUNCTION_TRACE("tb_find_rsdp");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493
494 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400495 * Scan supports either logical addressing or physical addressing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 */
497 if ((flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) {
Robert Moore44f6c012005-04-18 22:49:35 -0400498 /* 1a) Get the location of the Extended BIOS Data Area (EBDA) */
499
Len Brown4be44fc2005-08-05 00:44:28 -0400500 status = acpi_os_map_memory((acpi_physical_address)
501 ACPI_EBDA_PTR_LOCATION,
502 ACPI_EBDA_PTR_LENGTH,
503 (void *)&table_ptr);
504 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500505 ACPI_ERROR((AE_INFO,
506 "Could not map memory at %8.8X for length %X",
507 ACPI_EBDA_PTR_LOCATION,
508 ACPI_EBDA_PTR_LENGTH));
Robert Moore44f6c012005-04-18 22:49:35 -0400509
Len Brown4be44fc2005-08-05 00:44:28 -0400510 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 }
512
Len Brown4be44fc2005-08-05 00:44:28 -0400513 ACPI_MOVE_16_TO_32(&physical_address, table_ptr);
Robert Moore44f6c012005-04-18 22:49:35 -0400514
515 /* Convert segment part to physical address */
516
517 physical_address <<= 4;
Len Brown4be44fc2005-08-05 00:44:28 -0400518 acpi_os_unmap_memory(table_ptr, ACPI_EBDA_PTR_LENGTH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
520 /* EBDA present? */
521
522 if (physical_address > 0x400) {
523 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400524 * 1b) Search EBDA paragraphs (EBDa is required to be a
525 * minimum of 1_k length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 */
Len Brown4be44fc2005-08-05 00:44:28 -0400527 status = acpi_os_map_memory((acpi_physical_address)
528 physical_address,
529 ACPI_EBDA_WINDOW_SIZE,
530 (void *)&table_ptr);
531 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500532 ACPI_ERROR((AE_INFO,
533 "Could not map memory at %8.8X for length %X",
534 physical_address,
535 ACPI_EBDA_WINDOW_SIZE));
Robert Moore44f6c012005-04-18 22:49:35 -0400536
Len Brown4be44fc2005-08-05 00:44:28 -0400537 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 }
539
Len Brown4be44fc2005-08-05 00:44:28 -0400540 mem_rover = acpi_tb_scan_memory_for_rsdp(table_ptr,
541 ACPI_EBDA_WINDOW_SIZE);
542 acpi_os_unmap_memory(table_ptr, ACPI_EBDA_WINDOW_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543
544 if (mem_rover) {
Robert Mooref9f46012005-07-08 00:00:00 -0400545 /* Return the physical address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Len Brown4be44fc2005-08-05 00:44:28 -0400547 physical_address +=
548 ACPI_PTR_DIFF(mem_rover, table_ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
Robert Moore44f6c012005-04-18 22:49:35 -0400550 table_info->physical_address =
Len Brown4be44fc2005-08-05 00:44:28 -0400551 (acpi_physical_address) physical_address;
552 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
554 }
555
556 /*
557 * 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh
558 */
Len Brown4be44fc2005-08-05 00:44:28 -0400559 status = acpi_os_map_memory((acpi_physical_address)
560 ACPI_HI_RSDP_WINDOW_BASE,
561 ACPI_HI_RSDP_WINDOW_SIZE,
562 (void *)&table_ptr);
Robert Moore44f6c012005-04-18 22:49:35 -0400563
Len Brown4be44fc2005-08-05 00:44:28 -0400564 if (ACPI_FAILURE(status)) {
Bob Mooreb8e4d892006-01-27 16:43:00 -0500565 ACPI_ERROR((AE_INFO,
566 "Could not map memory at %8.8X for length %X",
567 ACPI_HI_RSDP_WINDOW_BASE,
568 ACPI_HI_RSDP_WINDOW_SIZE));
Robert Moore44f6c012005-04-18 22:49:35 -0400569
Len Brown4be44fc2005-08-05 00:44:28 -0400570 return_ACPI_STATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 }
572
Len Brown4be44fc2005-08-05 00:44:28 -0400573 mem_rover =
574 acpi_tb_scan_memory_for_rsdp(table_ptr,
575 ACPI_HI_RSDP_WINDOW_SIZE);
576 acpi_os_unmap_memory(table_ptr, ACPI_HI_RSDP_WINDOW_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577
578 if (mem_rover) {
Robert Mooref9f46012005-07-08 00:00:00 -0400579 /* Return the physical address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Robert Moore44f6c012005-04-18 22:49:35 -0400581 physical_address =
Len Brown4be44fc2005-08-05 00:44:28 -0400582 ACPI_HI_RSDP_WINDOW_BASE + ACPI_PTR_DIFF(mem_rover,
583 table_ptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Robert Moore44f6c012005-04-18 22:49:35 -0400585 table_info->physical_address =
Len Brown4be44fc2005-08-05 00:44:28 -0400586 (acpi_physical_address) physical_address;
587 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 }
589 }
590
591 /*
592 * Physical addressing
593 */
594 else {
Robert Moore44f6c012005-04-18 22:49:35 -0400595 /* 1a) Get the location of the EBDA */
596
Len Brown4be44fc2005-08-05 00:44:28 -0400597 ACPI_MOVE_16_TO_32(&physical_address, ACPI_EBDA_PTR_LOCATION);
598 physical_address <<= 4; /* Convert segment to physical address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600 /* EBDA present? */
601
602 if (physical_address > 0x400) {
603 /*
Robert Moore44f6c012005-04-18 22:49:35 -0400604 * 1b) Search EBDA paragraphs (EBDa is required to be a minimum of
605 * 1_k length)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 */
Len Brown4be44fc2005-08-05 00:44:28 -0400607 mem_rover =
608 acpi_tb_scan_memory_for_rsdp(ACPI_PHYSADDR_TO_PTR
609 (physical_address),
610 ACPI_EBDA_WINDOW_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if (mem_rover) {
Robert Mooref9f46012005-07-08 00:00:00 -0400612 /* Return the physical address */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Len Brown4be44fc2005-08-05 00:44:28 -0400614 table_info->physical_address =
615 ACPI_TO_INTEGER(mem_rover);
616 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
618 }
619
Robert Moore44f6c012005-04-18 22:49:35 -0400620 /* 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh */
621
Len Brown4be44fc2005-08-05 00:44:28 -0400622 mem_rover =
623 acpi_tb_scan_memory_for_rsdp(ACPI_PHYSADDR_TO_PTR
624 (ACPI_HI_RSDP_WINDOW_BASE),
625 ACPI_HI_RSDP_WINDOW_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 if (mem_rover) {
627 /* Found it, return the physical address */
628
Len Brown4be44fc2005-08-05 00:44:28 -0400629 table_info->physical_address =
630 ACPI_TO_INTEGER(mem_rover);
631 return_ACPI_STATUS(AE_OK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 }
633 }
634
Robert Mooref9f46012005-07-08 00:00:00 -0400635 /* A valid RSDP was not found */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
Bob Mooreb8e4d892006-01-27 16:43:00 -0500637 ACPI_ERROR((AE_INFO, "No valid RSDP was found"));
Len Brown4be44fc2005-08-05 00:44:28 -0400638 return_ACPI_STATUS(AE_NOT_FOUND);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639}
640
641#endif