Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: tbxfroot - Find the root ACPI table (RSDT) | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
4a90c7e8 | 8 | * Copyright (C) 2000 - 2006, R. Byron Moore |
1da177e4 LT |
9 | * 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 | ||
1da177e4 LT |
44 | #include <acpi/acpi.h> |
45 | #include <acpi/actables.h> | |
46 | ||
1da177e4 | 47 | #define _COMPONENT ACPI_TABLES |
4be44fcd | 48 | ACPI_MODULE_NAME("tbxfroot") |
1da177e4 | 49 | |
44f6c012 | 50 | /* Local prototypes */ |
44f6c012 | 51 | static acpi_status |
4be44fcd | 52 | acpi_tb_find_rsdp(struct acpi_table_desc *table_info, u32 flags); |
44f6c012 | 53 | |
4be44fcd | 54 | static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length); |
1da177e4 | 55 | |
f9f4601f RM |
56 | /******************************************************************************* |
57 | * | |
58 | * FUNCTION: acpi_tb_validate_rsdp | |
59 | * | |
60 | * PARAMETERS: Rsdp - Pointer to unvalidated RSDP | |
61 | * | |
62 | * RETURN: Status | |
63 | * | |
64 | * DESCRIPTION: Validate the RSDP (ptr) | |
65 | * | |
66 | ******************************************************************************/ | |
67 | ||
4be44fcd | 68 | acpi_status acpi_tb_validate_rsdp(struct rsdp_descriptor *rsdp) |
f9f4601f | 69 | { |
4be44fcd | 70 | ACPI_FUNCTION_ENTRY(); |
f9f4601f RM |
71 | |
72 | /* | |
73 | * The signature and checksum must both be correct | |
74 | */ | |
4be44fcd | 75 | if (ACPI_STRNCMP((char *)rsdp, RSDP_SIG, sizeof(RSDP_SIG) - 1) != 0) { |
52fc0b02 | 76 | |
f9f4601f RM |
77 | /* Nope, BAD Signature */ |
78 | ||
79 | return (AE_BAD_SIGNATURE); | |
80 | } | |
81 | ||
82 | /* Check the standard checksum */ | |
83 | ||
793c2388 | 84 | if (acpi_tb_sum_table(rsdp, ACPI_RSDP_CHECKSUM_LENGTH) != 0) { |
f9f4601f RM |
85 | return (AE_BAD_CHECKSUM); |
86 | } | |
87 | ||
88 | /* Check extended checksum if table version >= 2 */ | |
89 | ||
90 | if ((rsdp->revision >= 2) && | |
793c2388 | 91 | (acpi_tb_sum_table(rsdp, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) { |
f9f4601f RM |
92 | return (AE_BAD_CHECKSUM); |
93 | } | |
94 | ||
95 | return (AE_OK); | |
96 | } | |
97 | ||
1da177e4 LT |
98 | /******************************************************************************* |
99 | * | |
100 | * FUNCTION: acpi_tb_find_table | |
101 | * | |
102 | * PARAMETERS: Signature - String with ACPI table signature | |
103 | * oem_id - String with the table OEM ID | |
44f6c012 RM |
104 | * oem_table_id - String with the OEM Table ID |
105 | * table_ptr - Where the table pointer is returned | |
1da177e4 LT |
106 | * |
107 | * RETURN: Status | |
108 | * | |
109 | * DESCRIPTION: Find an ACPI table (in the RSDT/XSDT) that matches the | |
110 | * Signature, OEM ID and OEM Table ID. | |
111 | * | |
112 | ******************************************************************************/ | |
113 | ||
114 | acpi_status | |
4be44fcd LB |
115 | acpi_tb_find_table(char *signature, |
116 | char *oem_id, | |
117 | char *oem_table_id, struct acpi_table_header ** table_ptr) | |
1da177e4 | 118 | { |
4be44fcd LB |
119 | acpi_status status; |
120 | struct acpi_table_header *table; | |
1da177e4 | 121 | |
b229cf92 | 122 | ACPI_FUNCTION_TRACE(tb_find_table); |
1da177e4 LT |
123 | |
124 | /* Validate string lengths */ | |
125 | ||
4be44fcd LB |
126 | if ((ACPI_STRLEN(signature) > ACPI_NAME_SIZE) || |
127 | (ACPI_STRLEN(oem_id) > sizeof(table->oem_id)) || | |
128 | (ACPI_STRLEN(oem_table_id) > sizeof(table->oem_table_id))) { | |
129 | return_ACPI_STATUS(AE_AML_STRING_LIMIT); | |
1da177e4 LT |
130 | } |
131 | ||
b229cf92 | 132 | if (ACPI_COMPARE_NAME(signature, DSDT_SIG)) { |
1da177e4 LT |
133 | /* |
134 | * The DSDT pointer is contained in the FADT, not the RSDT. | |
135 | * This code should suffice, because the only code that would perform | |
136 | * a "find" on the DSDT is the data_table_region() AML opcode -- in | |
137 | * which case, the DSDT is guaranteed to be already loaded. | |
138 | * If this becomes insufficient, the FADT will have to be found first. | |
139 | */ | |
140 | if (!acpi_gbl_DSDT) { | |
4be44fcd | 141 | return_ACPI_STATUS(AE_NO_ACPI_TABLES); |
1da177e4 | 142 | } |
1da177e4 | 143 | table = acpi_gbl_DSDT; |
4be44fcd | 144 | } else { |
1da177e4 LT |
145 | /* Find the table */ |
146 | ||
4be44fcd LB |
147 | status = acpi_get_firmware_table(signature, 1, |
148 | ACPI_LOGICAL_ADDRESSING, | |
149 | &table); | |
150 | if (ACPI_FAILURE(status)) { | |
151 | return_ACPI_STATUS(status); | |
1da177e4 LT |
152 | } |
153 | } | |
154 | ||
155 | /* Check oem_id and oem_table_id */ | |
156 | ||
b229cf92 BM |
157 | if ((oem_id[0] && |
158 | ACPI_STRNCMP(oem_id, table->oem_id, | |
159 | sizeof(table->oem_id))) || | |
160 | (oem_table_id[0] && | |
161 | ACPI_STRNCMP(oem_table_id, table->oem_table_id, | |
162 | sizeof(table->oem_table_id)))) { | |
4be44fcd | 163 | return_ACPI_STATUS(AE_AML_NAME_NOT_FOUND); |
1da177e4 LT |
164 | } |
165 | ||
4be44fcd LB |
166 | ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "Found table [%4.4s]\n", |
167 | table->signature)); | |
44f6c012 | 168 | |
1da177e4 | 169 | *table_ptr = table; |
4be44fcd | 170 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
171 | } |
172 | ||
1da177e4 LT |
173 | /******************************************************************************* |
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 | ||
192 | acpi_status | |
4be44fcd LB |
193 | acpi_get_firmware_table(acpi_string signature, |
194 | u32 instance, | |
195 | u32 flags, struct acpi_table_header **table_pointer) | |
1da177e4 | 196 | { |
4be44fcd LB |
197 | 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; | |
1da177e4 | 205 | |
b229cf92 | 206 | ACPI_FUNCTION_TRACE(acpi_get_firmware_table); |
1da177e4 LT |
207 | |
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 | */ | |
4be44fcd LB |
213 | if ((instance == 0) || (!signature) || (!table_pointer)) { |
214 | return_ACPI_STATUS(AE_BAD_PARAMETER); | |
1da177e4 LT |
215 | } |
216 | ||
217 | /* Ensure that we have a RSDP */ | |
218 | ||
219 | if (!acpi_gbl_RSDP) { | |
52fc0b02 | 220 | |
1da177e4 LT |
221 | /* Get the RSDP */ |
222 | ||
4be44fcd LB |
223 | status = acpi_os_get_root_pointer(flags, &address); |
224 | if (ACPI_FAILURE(status)) { | |
225 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, "RSDP not found\n")); | |
226 | return_ACPI_STATUS(AE_NO_ACPI_TABLES); | |
1da177e4 LT |
227 | } |
228 | ||
229 | /* Map and validate the RSDP */ | |
230 | ||
231 | if ((flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { | |
4be44fcd LB |
232 | status = acpi_os_map_memory(address.pointer.physical, |
233 | sizeof(struct | |
234 | rsdp_descriptor), | |
235 | (void *)&acpi_gbl_RSDP); | |
236 | if (ACPI_FAILURE(status)) { | |
237 | return_ACPI_STATUS(status); | |
1da177e4 | 238 | } |
4be44fcd | 239 | } else { |
1da177e4 LT |
240 | acpi_gbl_RSDP = address.pointer.logical; |
241 | } | |
242 | ||
f9f4601f | 243 | /* The RDSP signature and checksum must both be correct */ |
1da177e4 | 244 | |
4be44fcd LB |
245 | status = acpi_tb_validate_rsdp(acpi_gbl_RSDP); |
246 | if (ACPI_FAILURE(status)) { | |
247 | return_ACPI_STATUS(status); | |
1da177e4 LT |
248 | } |
249 | } | |
250 | ||
251 | /* Get the RSDT address via the RSDP */ | |
252 | ||
4be44fcd LB |
253 | acpi_tb_get_rsdt_address(&address); |
254 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, | |
50eca3eb | 255 | "RSDP located at %p, RSDT physical=%8.8X%8.8X\n", |
4be44fcd LB |
256 | acpi_gbl_RSDP, |
257 | ACPI_FORMAT_UINT64(address.pointer.value))); | |
1da177e4 LT |
258 | |
259 | /* Insert processor_mode flags */ | |
260 | ||
261 | address.pointer_type |= flags; | |
262 | ||
263 | /* Get and validate the RSDT */ | |
264 | ||
8313524a | 265 | rsdt_info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_table_desc)); |
1da177e4 | 266 | if (!rsdt_info) { |
4be44fcd | 267 | return_ACPI_STATUS(AE_NO_MEMORY); |
1da177e4 LT |
268 | } |
269 | ||
4be44fcd LB |
270 | status = acpi_tb_get_table(&address, rsdt_info); |
271 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
272 | goto cleanup; |
273 | } | |
274 | ||
4be44fcd LB |
275 | status = acpi_tb_validate_rsdt(rsdt_info->pointer); |
276 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
277 | goto cleanup; |
278 | } | |
279 | ||
280 | /* Allocate a scratch table header and table descriptor */ | |
281 | ||
8313524a | 282 | header = ACPI_ALLOCATE(sizeof(struct acpi_table_header)); |
1da177e4 LT |
283 | if (!header) { |
284 | status = AE_NO_MEMORY; | |
285 | goto cleanup; | |
286 | } | |
287 | ||
8313524a | 288 | table_info = ACPI_ALLOCATE(sizeof(struct acpi_table_desc)); |
1da177e4 LT |
289 | if (!table_info) { |
290 | status = AE_NO_MEMORY; | |
291 | goto cleanup; | |
292 | } | |
293 | ||
294 | /* Get the number of table pointers within the RSDT */ | |
295 | ||
4be44fcd LB |
296 | table_count = |
297 | acpi_tb_get_table_count(acpi_gbl_RSDP, rsdt_info->pointer); | |
1da177e4 LT |
298 | address.pointer_type = acpi_gbl_table_flags | flags; |
299 | ||
300 | /* | |
301 | * Search the RSDT/XSDT for the correct instance of the | |
302 | * requested table | |
303 | */ | |
304 | for (i = 0, j = 0; i < table_count; i++) { | |
73459f73 RM |
305 | /* |
306 | * Get the next table pointer, handle RSDT vs. XSDT | |
307 | * RSDT pointers are 32 bits, XSDT pointers are 64 bits | |
308 | */ | |
309 | if (acpi_gbl_root_table_type == ACPI_TABLE_TYPE_RSDT) { | |
4be44fcd LB |
310 | address.pointer.value = |
311 | (ACPI_CAST_PTR | |
793c2388 | 312 | (struct rsdt_descriptor, |
4be44fcd LB |
313 | rsdt_info->pointer))->table_offset_entry[i]; |
314 | } else { | |
315 | address.pointer.value = | |
316 | (ACPI_CAST_PTR | |
793c2388 | 317 | (struct xsdt_descriptor, |
4be44fcd | 318 | rsdt_info->pointer))->table_offset_entry[i]; |
1da177e4 LT |
319 | } |
320 | ||
321 | /* Get the table header */ | |
322 | ||
4be44fcd LB |
323 | status = acpi_tb_get_table_header(&address, header); |
324 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
325 | goto cleanup; |
326 | } | |
327 | ||
328 | /* Compare table signatures and table instance */ | |
329 | ||
b229cf92 | 330 | if (ACPI_COMPARE_NAME(header->signature, signature)) { |
52fc0b02 | 331 | |
1da177e4 LT |
332 | /* An instance of the table was found */ |
333 | ||
334 | j++; | |
335 | if (j >= instance) { | |
52fc0b02 | 336 | |
1da177e4 LT |
337 | /* Found the correct instance, get the entire table */ |
338 | ||
4be44fcd LB |
339 | status = |
340 | acpi_tb_get_table_body(&address, header, | |
341 | table_info); | |
342 | if (ACPI_FAILURE(status)) { | |
1da177e4 LT |
343 | goto cleanup; |
344 | } | |
345 | ||
346 | *table_pointer = table_info->pointer; | |
347 | goto cleanup; | |
348 | } | |
349 | } | |
350 | } | |
351 | ||
352 | /* Did not find the table */ | |
353 | ||
354 | status = AE_NOT_EXIST; | |
355 | ||
4be44fcd | 356 | cleanup: |
88ac00f5 | 357 | if (rsdt_info->pointer) { |
4be44fcd LB |
358 | acpi_os_unmap_memory(rsdt_info->pointer, |
359 | (acpi_size) rsdt_info->pointer->length); | |
88ac00f5 | 360 | } |
8313524a | 361 | ACPI_FREE(rsdt_info); |
1da177e4 LT |
362 | |
363 | if (header) { | |
8313524a | 364 | ACPI_FREE(header); |
1da177e4 LT |
365 | } |
366 | if (table_info) { | |
8313524a | 367 | ACPI_FREE(table_info); |
1da177e4 | 368 | } |
4be44fcd | 369 | return_ACPI_STATUS(status); |
1da177e4 | 370 | } |
1da177e4 | 371 | |
8313524a | 372 | ACPI_EXPORT_SYMBOL(acpi_get_firmware_table) |
1da177e4 LT |
373 | |
374 | /* TBD: Move to a new file */ | |
1da177e4 | 375 | #if ACPI_MACHINE_WIDTH != 16 |
1da177e4 LT |
376 | /******************************************************************************* |
377 | * | |
378 | * FUNCTION: acpi_find_root_pointer | |
379 | * | |
44f6c012 RM |
380 | * PARAMETERS: Flags - Logical/Physical addressing |
381 | * rsdp_address - Where to place the RSDP address | |
1da177e4 LT |
382 | * |
383 | * RETURN: Status, Physical address of the RSDP | |
384 | * | |
385 | * DESCRIPTION: Find the RSDP | |
386 | * | |
387 | ******************************************************************************/ | |
4be44fcd | 388 | acpi_status acpi_find_root_pointer(u32 flags, struct acpi_pointer *rsdp_address) |
1da177e4 | 389 | { |
4be44fcd LB |
390 | struct acpi_table_desc table_info; |
391 | acpi_status status; | |
1da177e4 | 392 | |
b229cf92 | 393 | ACPI_FUNCTION_TRACE(acpi_find_root_pointer); |
1da177e4 LT |
394 | |
395 | /* Get the RSDP */ | |
396 | ||
4be44fcd LB |
397 | status = acpi_tb_find_rsdp(&table_info, flags); |
398 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
399 | ACPI_EXCEPTION((AE_INFO, status, |
400 | "RSDP structure not found - Flags=%X", flags)); | |
44f6c012 | 401 | |
4be44fcd | 402 | return_ACPI_STATUS(AE_NO_ACPI_TABLES); |
1da177e4 LT |
403 | } |
404 | ||
405 | rsdp_address->pointer_type = ACPI_PHYSICAL_POINTER; | |
406 | rsdp_address->pointer.physical = table_info.physical_address; | |
4be44fcd | 407 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
408 | } |
409 | ||
8313524a BM |
410 | ACPI_EXPORT_SYMBOL(acpi_find_root_pointer) |
411 | ||
1da177e4 LT |
412 | /******************************************************************************* |
413 | * | |
414 | * FUNCTION: acpi_tb_scan_memory_for_rsdp | |
415 | * | |
416 | * PARAMETERS: start_address - Starting pointer for search | |
417 | * Length - Maximum length to search | |
418 | * | |
419 | * RETURN: Pointer to the RSDP if found, otherwise NULL. | |
420 | * | |
421 | * DESCRIPTION: Search a block of memory for the RSDP signature | |
422 | * | |
423 | ******************************************************************************/ | |
4be44fcd | 424 | static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length) |
1da177e4 | 425 | { |
4be44fcd LB |
426 | acpi_status status; |
427 | u8 *mem_rover; | |
428 | u8 *end_address; | |
1da177e4 | 429 | |
b229cf92 | 430 | ACPI_FUNCTION_TRACE(tb_scan_memory_for_rsdp); |
1da177e4 LT |
431 | |
432 | end_address = start_address + length; | |
433 | ||
434 | /* Search from given start address for the requested length */ | |
435 | ||
436 | for (mem_rover = start_address; mem_rover < end_address; | |
4be44fcd | 437 | mem_rover += ACPI_RSDP_SCAN_STEP) { |
52fc0b02 | 438 | |
f9f4601f | 439 | /* The RSDP signature and checksum must both be correct */ |
1da177e4 | 440 | |
4be44fcd LB |
441 | status = |
442 | acpi_tb_validate_rsdp(ACPI_CAST_PTR | |
443 | (struct rsdp_descriptor, mem_rover)); | |
444 | if (ACPI_SUCCESS(status)) { | |
52fc0b02 | 445 | |
f9f4601f | 446 | /* Sig and checksum valid, we have found a real RSDP */ |
1da177e4 | 447 | |
4be44fcd LB |
448 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
449 | "RSDP located at physical address %p\n", | |
450 | mem_rover)); | |
451 | return_PTR(mem_rover); | |
1da177e4 LT |
452 | } |
453 | ||
f9f4601f | 454 | /* No sig match or bad checksum, keep searching */ |
1da177e4 LT |
455 | } |
456 | ||
457 | /* Searched entire block, no RSDP was found */ | |
458 | ||
4be44fcd LB |
459 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
460 | "Searched entire block from %p, valid RSDP was not found\n", | |
461 | start_address)); | |
462 | return_PTR(NULL); | |
1da177e4 LT |
463 | } |
464 | ||
1da177e4 LT |
465 | /******************************************************************************* |
466 | * | |
467 | * FUNCTION: acpi_tb_find_rsdp | |
468 | * | |
44f6c012 | 469 | * PARAMETERS: table_info - Where the table info is returned |
1da177e4 LT |
470 | * Flags - Current memory mode (logical vs. |
471 | * physical addressing) | |
472 | * | |
473 | * RETURN: Status, RSDP physical address | |
474 | * | |
475 | * DESCRIPTION: search lower 1_mbyte of memory for the root system descriptor | |
476 | * pointer structure. If it is found, set *RSDP to point to it. | |
477 | * | |
478 | * NOTE1: The RSDp must be either in the first 1_k of the Extended | |
479 | * BIOS Data Area or between E0000 and FFFFF (From ACPI Spec.) | |
480 | * Only a 32-bit physical address is necessary. | |
481 | * | |
482 | * NOTE2: This function is always available, regardless of the | |
483 | * initialization state of the rest of ACPI. | |
484 | * | |
485 | ******************************************************************************/ | |
486 | ||
44f6c012 | 487 | static acpi_status |
4be44fcd | 488 | acpi_tb_find_rsdp(struct acpi_table_desc *table_info, u32 flags) |
1da177e4 | 489 | { |
4be44fcd LB |
490 | u8 *table_ptr; |
491 | u8 *mem_rover; | |
492 | u32 physical_address; | |
493 | acpi_status status; | |
1da177e4 | 494 | |
b229cf92 | 495 | ACPI_FUNCTION_TRACE(tb_find_rsdp); |
1da177e4 LT |
496 | |
497 | /* | |
44f6c012 | 498 | * Scan supports either logical addressing or physical addressing |
1da177e4 LT |
499 | */ |
500 | if ((flags & ACPI_MEMORY_MODE) == ACPI_LOGICAL_ADDRESSING) { | |
52fc0b02 | 501 | |
44f6c012 RM |
502 | /* 1a) Get the location of the Extended BIOS Data Area (EBDA) */ |
503 | ||
4be44fcd LB |
504 | status = acpi_os_map_memory((acpi_physical_address) |
505 | ACPI_EBDA_PTR_LOCATION, | |
506 | ACPI_EBDA_PTR_LENGTH, | |
507 | (void *)&table_ptr); | |
508 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
509 | ACPI_ERROR((AE_INFO, |
510 | "Could not map memory at %8.8X for length %X", | |
511 | ACPI_EBDA_PTR_LOCATION, | |
512 | ACPI_EBDA_PTR_LENGTH)); | |
4be44fcd LB |
513 | |
514 | return_ACPI_STATUS(status); | |
1da177e4 LT |
515 | } |
516 | ||
4be44fcd | 517 | ACPI_MOVE_16_TO_32(&physical_address, table_ptr); |
44f6c012 RM |
518 | |
519 | /* Convert segment part to physical address */ | |
520 | ||
521 | physical_address <<= 4; | |
4be44fcd | 522 | acpi_os_unmap_memory(table_ptr, ACPI_EBDA_PTR_LENGTH); |
1da177e4 LT |
523 | |
524 | /* EBDA present? */ | |
525 | ||
526 | if (physical_address > 0x400) { | |
527 | /* | |
44f6c012 RM |
528 | * 1b) Search EBDA paragraphs (EBDa is required to be a |
529 | * minimum of 1_k length) | |
1da177e4 | 530 | */ |
4be44fcd LB |
531 | status = acpi_os_map_memory((acpi_physical_address) |
532 | physical_address, | |
533 | ACPI_EBDA_WINDOW_SIZE, | |
534 | (void *)&table_ptr); | |
535 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
536 | ACPI_ERROR((AE_INFO, |
537 | "Could not map memory at %8.8X for length %X", | |
538 | physical_address, | |
539 | ACPI_EBDA_WINDOW_SIZE)); | |
4be44fcd LB |
540 | |
541 | return_ACPI_STATUS(status); | |
1da177e4 LT |
542 | } |
543 | ||
4be44fcd LB |
544 | mem_rover = acpi_tb_scan_memory_for_rsdp(table_ptr, |
545 | ACPI_EBDA_WINDOW_SIZE); | |
546 | acpi_os_unmap_memory(table_ptr, ACPI_EBDA_WINDOW_SIZE); | |
1da177e4 LT |
547 | |
548 | if (mem_rover) { | |
52fc0b02 | 549 | |
f9f4601f | 550 | /* Return the physical address */ |
1da177e4 | 551 | |
4be44fcd LB |
552 | physical_address += |
553 | ACPI_PTR_DIFF(mem_rover, table_ptr); | |
1da177e4 | 554 | |
44f6c012 | 555 | table_info->physical_address = |
4be44fcd LB |
556 | (acpi_physical_address) physical_address; |
557 | return_ACPI_STATUS(AE_OK); | |
1da177e4 LT |
558 | } |
559 | } | |
560 | ||
561 | /* | |
562 | * 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh | |
563 | */ | |
4be44fcd LB |
564 | status = acpi_os_map_memory((acpi_physical_address) |
565 | ACPI_HI_RSDP_WINDOW_BASE, | |
566 | ACPI_HI_RSDP_WINDOW_SIZE, | |
567 | (void *)&table_ptr); | |
568 | ||
569 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
570 | ACPI_ERROR((AE_INFO, |
571 | "Could not map memory at %8.8X for length %X", | |
572 | ACPI_HI_RSDP_WINDOW_BASE, | |
573 | ACPI_HI_RSDP_WINDOW_SIZE)); | |
4be44fcd LB |
574 | |
575 | return_ACPI_STATUS(status); | |
1da177e4 LT |
576 | } |
577 | ||
4be44fcd LB |
578 | mem_rover = |
579 | acpi_tb_scan_memory_for_rsdp(table_ptr, | |
580 | ACPI_HI_RSDP_WINDOW_SIZE); | |
581 | acpi_os_unmap_memory(table_ptr, ACPI_HI_RSDP_WINDOW_SIZE); | |
1da177e4 LT |
582 | |
583 | if (mem_rover) { | |
52fc0b02 | 584 | |
f9f4601f | 585 | /* Return the physical address */ |
1da177e4 | 586 | |
44f6c012 | 587 | physical_address = |
4be44fcd LB |
588 | ACPI_HI_RSDP_WINDOW_BASE + ACPI_PTR_DIFF(mem_rover, |
589 | table_ptr); | |
1da177e4 | 590 | |
44f6c012 | 591 | table_info->physical_address = |
4be44fcd LB |
592 | (acpi_physical_address) physical_address; |
593 | return_ACPI_STATUS(AE_OK); | |
1da177e4 LT |
594 | } |
595 | } | |
596 | ||
597 | /* | |
598 | * Physical addressing | |
599 | */ | |
600 | else { | |
44f6c012 RM |
601 | /* 1a) Get the location of the EBDA */ |
602 | ||
4be44fcd LB |
603 | ACPI_MOVE_16_TO_32(&physical_address, ACPI_EBDA_PTR_LOCATION); |
604 | physical_address <<= 4; /* Convert segment to physical address */ | |
1da177e4 LT |
605 | |
606 | /* EBDA present? */ | |
607 | ||
608 | if (physical_address > 0x400) { | |
609 | /* | |
44f6c012 RM |
610 | * 1b) Search EBDA paragraphs (EBDa is required to be a minimum of |
611 | * 1_k length) | |
1da177e4 | 612 | */ |
4be44fcd LB |
613 | mem_rover = |
614 | acpi_tb_scan_memory_for_rsdp(ACPI_PHYSADDR_TO_PTR | |
615 | (physical_address), | |
616 | ACPI_EBDA_WINDOW_SIZE); | |
1da177e4 | 617 | if (mem_rover) { |
52fc0b02 | 618 | |
f9f4601f | 619 | /* Return the physical address */ |
1da177e4 | 620 | |
4be44fcd LB |
621 | table_info->physical_address = |
622 | ACPI_TO_INTEGER(mem_rover); | |
623 | return_ACPI_STATUS(AE_OK); | |
1da177e4 LT |
624 | } |
625 | } | |
626 | ||
44f6c012 RM |
627 | /* 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh */ |
628 | ||
4be44fcd LB |
629 | mem_rover = |
630 | acpi_tb_scan_memory_for_rsdp(ACPI_PHYSADDR_TO_PTR | |
631 | (ACPI_HI_RSDP_WINDOW_BASE), | |
632 | ACPI_HI_RSDP_WINDOW_SIZE); | |
1da177e4 | 633 | if (mem_rover) { |
52fc0b02 | 634 | |
1da177e4 LT |
635 | /* Found it, return the physical address */ |
636 | ||
4be44fcd LB |
637 | table_info->physical_address = |
638 | ACPI_TO_INTEGER(mem_rover); | |
639 | return_ACPI_STATUS(AE_OK); | |
1da177e4 LT |
640 | } |
641 | } | |
642 | ||
f9f4601f | 643 | /* A valid RSDP was not found */ |
1da177e4 | 644 | |
b8e4d893 | 645 | ACPI_ERROR((AE_INFO, "No valid RSDP was found")); |
4be44fcd | 646 | return_ACPI_STATUS(AE_NOT_FOUND); |
1da177e4 LT |
647 | } |
648 | ||
649 | #endif |