Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: tbget - ACPI Table get* routines | |
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("tbget") |
1da177e4 | 49 | |
44f6c012 | 50 | /* Local prototypes */ |
44f6c012 | 51 | static acpi_status |
4be44fcd LB |
52 | acpi_tb_get_this_table(struct acpi_pointer *address, |
53 | struct acpi_table_header *header, | |
54 | struct acpi_table_desc *table_info); | |
44f6c012 RM |
55 | |
56 | static acpi_status | |
4be44fcd LB |
57 | acpi_tb_table_override(struct acpi_table_header *header, |
58 | struct acpi_table_desc *table_info); | |
1da177e4 LT |
59 | |
60 | /******************************************************************************* | |
61 | * | |
62 | * FUNCTION: acpi_tb_get_table | |
63 | * | |
64 | * PARAMETERS: Address - Address of table to retrieve. Can be | |
65 | * Logical or Physical | |
66 | * table_info - Where table info is returned | |
67 | * | |
68 | * RETURN: None | |
69 | * | |
70 | * DESCRIPTION: Get entire table of unknown size. | |
71 | * | |
72 | ******************************************************************************/ | |
73 | ||
74 | acpi_status | |
4be44fcd LB |
75 | acpi_tb_get_table(struct acpi_pointer *address, |
76 | struct acpi_table_desc *table_info) | |
1da177e4 | 77 | { |
4be44fcd LB |
78 | acpi_status status; |
79 | struct acpi_table_header header; | |
1da177e4 | 80 | |
4be44fcd | 81 | ACPI_FUNCTION_TRACE("tb_get_table"); |
1da177e4 | 82 | |
44f6c012 RM |
83 | /* Get the header in order to get signature and table size */ |
84 | ||
4be44fcd LB |
85 | status = acpi_tb_get_table_header(address, &header); |
86 | if (ACPI_FAILURE(status)) { | |
87 | return_ACPI_STATUS(status); | |
1da177e4 LT |
88 | } |
89 | ||
90 | /* Get the entire table */ | |
91 | ||
4be44fcd LB |
92 | status = acpi_tb_get_table_body(address, &header, table_info); |
93 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
94 | ACPI_EXCEPTION((AE_INFO, status, |
95 | "Could not get ACPI table (size %X)", | |
96 | header.length)); | |
4be44fcd | 97 | return_ACPI_STATUS(status); |
1da177e4 LT |
98 | } |
99 | ||
4be44fcd | 100 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
101 | } |
102 | ||
1da177e4 LT |
103 | /******************************************************************************* |
104 | * | |
105 | * FUNCTION: acpi_tb_get_table_header | |
106 | * | |
107 | * PARAMETERS: Address - Address of table to retrieve. Can be | |
108 | * Logical or Physical | |
109 | * return_header - Where the table header is returned | |
110 | * | |
111 | * RETURN: Status | |
112 | * | |
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. | |
117 | * | |
118 | ******************************************************************************/ | |
119 | ||
120 | acpi_status | |
4be44fcd LB |
121 | acpi_tb_get_table_header(struct acpi_pointer *address, |
122 | struct acpi_table_header *return_header) | |
1da177e4 | 123 | { |
4be44fcd LB |
124 | acpi_status status = AE_OK; |
125 | struct acpi_table_header *header = NULL; | |
1da177e4 | 126 | |
4be44fcd | 127 | ACPI_FUNCTION_TRACE("tb_get_table_header"); |
1da177e4 LT |
128 | |
129 | /* | |
44f6c012 RM |
130 | * Flags contains the current processor mode (Virtual or Physical |
131 | * addressing) The pointer_type is either Logical or Physical | |
1da177e4 LT |
132 | */ |
133 | switch (address->pointer_type) { | |
134 | case ACPI_PHYSMODE_PHYSPTR: | |
135 | case ACPI_LOGMODE_LOGPTR: | |
136 | ||
137 | /* Pointer matches processor mode, copy the header */ | |
138 | ||
4be44fcd LB |
139 | ACPI_MEMCPY(return_header, address->pointer.logical, |
140 | sizeof(struct acpi_table_header)); | |
1da177e4 LT |
141 | break; |
142 | ||
1da177e4 LT |
143 | case ACPI_LOGMODE_PHYSPTR: |
144 | ||
4be44fcd | 145 | /* Create a logical address for the physical pointer */ |
1da177e4 | 146 | |
4be44fcd LB |
147 | status = acpi_os_map_memory(address->pointer.physical, |
148 | sizeof(struct acpi_table_header), | |
149 | (void *)&header); | |
150 | if (ACPI_FAILURE(status)) { | |
52fc0b02 BM |
151 | ACPI_ERROR((AE_INFO, |
152 | "Could not map memory at %8.8X%8.8X for table header", | |
153 | ACPI_FORMAT_UINT64(address->pointer. | |
154 | physical))); | |
4be44fcd | 155 | return_ACPI_STATUS(status); |
1da177e4 LT |
156 | } |
157 | ||
158 | /* Copy header and delete mapping */ | |
159 | ||
4be44fcd LB |
160 | ACPI_MEMCPY(return_header, header, |
161 | sizeof(struct acpi_table_header)); | |
162 | acpi_os_unmap_memory(header, sizeof(struct acpi_table_header)); | |
1da177e4 LT |
163 | break; |
164 | ||
1da177e4 LT |
165 | default: |
166 | ||
b8e4d893 BM |
167 | ACPI_ERROR((AE_INFO, "Invalid address flags %X", |
168 | address->pointer_type)); | |
4be44fcd | 169 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
170 | } |
171 | ||
4be44fcd LB |
172 | ACPI_DEBUG_PRINT((ACPI_DB_TABLES, "Table Signature: [%4.4s]\n", |
173 | return_header->signature)); | |
1da177e4 | 174 | |
4be44fcd | 175 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
176 | } |
177 | ||
1da177e4 LT |
178 | /******************************************************************************* |
179 | * | |
180 | * FUNCTION: acpi_tb_get_table_body | |
181 | * | |
182 | * PARAMETERS: Address - Address of table to retrieve. Can be | |
183 | * Logical or Physical | |
184 | * Header - Header of the table to retrieve | |
185 | * table_info - Where the table info is returned | |
186 | * | |
187 | * RETURN: Status | |
188 | * | |
189 | * DESCRIPTION: Get an entire ACPI table with support to allow the host OS to | |
190 | * replace the table with a newer version (table override.) | |
191 | * Works in both physical or virtual | |
192 | * addressing mode. Works with both physical or logical pointers. | |
193 | * Table is either copied or mapped, depending on the pointer | |
194 | * type and mode of the processor. | |
195 | * | |
196 | ******************************************************************************/ | |
197 | ||
198 | acpi_status | |
4be44fcd LB |
199 | acpi_tb_get_table_body(struct acpi_pointer *address, |
200 | struct acpi_table_header *header, | |
201 | struct acpi_table_desc *table_info) | |
1da177e4 | 202 | { |
4be44fcd | 203 | acpi_status status; |
1da177e4 | 204 | |
4be44fcd | 205 | ACPI_FUNCTION_TRACE("tb_get_table_body"); |
1da177e4 LT |
206 | |
207 | if (!table_info || !address) { | |
4be44fcd | 208 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
209 | } |
210 | ||
44f6c012 RM |
211 | /* Attempt table override. */ |
212 | ||
4be44fcd LB |
213 | status = acpi_tb_table_override(header, table_info); |
214 | if (ACPI_SUCCESS(status)) { | |
52fc0b02 | 215 | |
1da177e4 LT |
216 | /* Table was overridden by the host OS */ |
217 | ||
4be44fcd | 218 | return_ACPI_STATUS(status); |
1da177e4 LT |
219 | } |
220 | ||
221 | /* No override, get the original table */ | |
222 | ||
4be44fcd LB |
223 | status = acpi_tb_get_this_table(address, header, table_info); |
224 | return_ACPI_STATUS(status); | |
1da177e4 LT |
225 | } |
226 | ||
1da177e4 LT |
227 | /******************************************************************************* |
228 | * | |
229 | * FUNCTION: acpi_tb_table_override | |
230 | * | |
231 | * PARAMETERS: Header - Pointer to table header | |
232 | * table_info - Return info if table is overridden | |
233 | * | |
234 | * RETURN: None | |
235 | * | |
236 | * DESCRIPTION: Attempts override of current table with a new one if provided | |
237 | * by the host OS. | |
238 | * | |
239 | ******************************************************************************/ | |
240 | ||
44f6c012 | 241 | static acpi_status |
4be44fcd LB |
242 | acpi_tb_table_override(struct acpi_table_header *header, |
243 | struct acpi_table_desc *table_info) | |
1da177e4 | 244 | { |
4be44fcd LB |
245 | struct acpi_table_header *new_table; |
246 | acpi_status status; | |
247 | struct acpi_pointer address; | |
1da177e4 | 248 | |
4be44fcd | 249 | ACPI_FUNCTION_TRACE("tb_table_override"); |
1da177e4 LT |
250 | |
251 | /* | |
252 | * The OSL will examine the header and decide whether to override this | |
253 | * table. If it decides to override, a table will be returned in new_table, | |
254 | * which we will then copy. | |
255 | */ | |
4be44fcd LB |
256 | status = acpi_os_table_override(header, &new_table); |
257 | if (ACPI_FAILURE(status)) { | |
52fc0b02 | 258 | |
1da177e4 LT |
259 | /* Some severe error from the OSL, but we basically ignore it */ |
260 | ||
b8e4d893 BM |
261 | ACPI_EXCEPTION((AE_INFO, status, |
262 | "Could not override ACPI table")); | |
4be44fcd | 263 | return_ACPI_STATUS(status); |
1da177e4 LT |
264 | } |
265 | ||
266 | if (!new_table) { | |
52fc0b02 | 267 | |
1da177e4 LT |
268 | /* No table override */ |
269 | ||
4be44fcd | 270 | return_ACPI_STATUS(AE_NO_ACPI_TABLES); |
1da177e4 LT |
271 | } |
272 | ||
273 | /* | |
274 | * We have a new table to override the old one. Get a copy of | |
275 | * the new one. We know that the new table has a logical pointer. | |
276 | */ | |
4be44fcd | 277 | address.pointer_type = ACPI_LOGICAL_POINTER | ACPI_LOGICAL_ADDRESSING; |
1da177e4 LT |
278 | address.pointer.logical = new_table; |
279 | ||
4be44fcd LB |
280 | status = acpi_tb_get_this_table(&address, new_table, table_info); |
281 | if (ACPI_FAILURE(status)) { | |
b8e4d893 | 282 | ACPI_EXCEPTION((AE_INFO, status, "Could not copy ACPI table")); |
4be44fcd | 283 | return_ACPI_STATUS(status); |
1da177e4 LT |
284 | } |
285 | ||
286 | /* Copy the table info */ | |
287 | ||
b8e4d893 BM |
288 | ACPI_INFO((AE_INFO, "Table [%4.4s] replaced by host OS", |
289 | table_info->pointer->signature)); | |
1da177e4 | 290 | |
4be44fcd | 291 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
292 | } |
293 | ||
1da177e4 LT |
294 | /******************************************************************************* |
295 | * | |
296 | * FUNCTION: acpi_tb_get_this_table | |
297 | * | |
298 | * PARAMETERS: Address - Address of table to retrieve. Can be | |
299 | * Logical or Physical | |
300 | * Header - Header of the table to retrieve | |
301 | * table_info - Where the table info is returned | |
302 | * | |
303 | * RETURN: Status | |
304 | * | |
305 | * DESCRIPTION: Get an entire ACPI table. Works in both physical or virtual | |
306 | * addressing mode. Works with both physical or logical pointers. | |
307 | * Table is either copied or mapped, depending on the pointer | |
308 | * type and mode of the processor. | |
309 | * | |
310 | ******************************************************************************/ | |
311 | ||
44f6c012 | 312 | static acpi_status |
4be44fcd LB |
313 | acpi_tb_get_this_table(struct acpi_pointer *address, |
314 | struct acpi_table_header *header, | |
315 | struct acpi_table_desc *table_info) | |
1da177e4 | 316 | { |
4be44fcd LB |
317 | struct acpi_table_header *full_table = NULL; |
318 | u8 allocation; | |
319 | acpi_status status = AE_OK; | |
1da177e4 | 320 | |
4be44fcd | 321 | ACPI_FUNCTION_TRACE("tb_get_this_table"); |
1da177e4 LT |
322 | |
323 | /* | |
44f6c012 RM |
324 | * Flags contains the current processor mode (Virtual or Physical |
325 | * addressing) The pointer_type is either Logical or Physical | |
1da177e4 LT |
326 | */ |
327 | switch (address->pointer_type) { | |
328 | case ACPI_PHYSMODE_PHYSPTR: | |
329 | case ACPI_LOGMODE_LOGPTR: | |
330 | ||
331 | /* Pointer matches processor mode, copy the table to a new buffer */ | |
332 | ||
4be44fcd | 333 | full_table = ACPI_MEM_ALLOCATE(header->length); |
1da177e4 | 334 | if (!full_table) { |
b8e4d893 BM |
335 | ACPI_ERROR((AE_INFO, |
336 | "Could not allocate table memory for [%4.4s] length %X", | |
337 | header->signature, header->length)); | |
4be44fcd | 338 | return_ACPI_STATUS(AE_NO_MEMORY); |
1da177e4 LT |
339 | } |
340 | ||
341 | /* Copy the entire table (including header) to the local buffer */ | |
342 | ||
4be44fcd LB |
343 | ACPI_MEMCPY(full_table, address->pointer.logical, |
344 | header->length); | |
1da177e4 LT |
345 | |
346 | /* Save allocation type */ | |
347 | ||
348 | allocation = ACPI_MEM_ALLOCATED; | |
349 | break; | |
350 | ||
1da177e4 LT |
351 | case ACPI_LOGMODE_PHYSPTR: |
352 | ||
353 | /* | |
354 | * Just map the table's physical memory | |
355 | * into our address space. | |
356 | */ | |
4be44fcd LB |
357 | status = acpi_os_map_memory(address->pointer.physical, |
358 | (acpi_size) header->length, | |
359 | (void *)&full_table); | |
360 | if (ACPI_FAILURE(status)) { | |
b8e4d893 BM |
361 | ACPI_ERROR((AE_INFO, |
362 | "Could not map memory for table [%4.4s] at %8.8X%8.8X for length %X", | |
363 | header->signature, | |
364 | ACPI_FORMAT_UINT64(address->pointer. | |
365 | physical), | |
366 | header->length)); | |
1da177e4 LT |
367 | return (status); |
368 | } | |
369 | ||
370 | /* Save allocation type */ | |
371 | ||
372 | allocation = ACPI_MEM_MAPPED; | |
373 | break; | |
374 | ||
1da177e4 LT |
375 | default: |
376 | ||
b8e4d893 BM |
377 | ACPI_ERROR((AE_INFO, "Invalid address flags %X", |
378 | address->pointer_type)); | |
4be44fcd | 379 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
380 | } |
381 | ||
382 | /* | |
383 | * Validate checksum for _most_ tables, | |
384 | * even the ones whose signature we don't recognize | |
385 | */ | |
386 | if (table_info->type != ACPI_TABLE_FACS) { | |
4be44fcd | 387 | status = acpi_tb_verify_table_checksum(full_table); |
1da177e4 LT |
388 | |
389 | #if (!ACPI_CHECKSUM_ABORT) | |
4be44fcd | 390 | if (ACPI_FAILURE(status)) { |
52fc0b02 | 391 | |
1da177e4 LT |
392 | /* Ignore the error if configuration says so */ |
393 | ||
394 | status = AE_OK; | |
395 | } | |
396 | #endif | |
397 | } | |
398 | ||
399 | /* Return values */ | |
400 | ||
4be44fcd LB |
401 | table_info->pointer = full_table; |
402 | table_info->length = (acpi_size) header->length; | |
403 | table_info->allocation = allocation; | |
1da177e4 | 404 | |
4be44fcd LB |
405 | ACPI_DEBUG_PRINT((ACPI_DB_INFO, |
406 | "Found table [%4.4s] at %8.8X%8.8X, mapped/copied to %p\n", | |
407 | full_table->signature, | |
408 | ACPI_FORMAT_UINT64(address->pointer.physical), | |
409 | full_table)); | |
1da177e4 | 410 | |
4be44fcd | 411 | return_ACPI_STATUS(status); |
1da177e4 LT |
412 | } |
413 | ||
1da177e4 LT |
414 | /******************************************************************************* |
415 | * | |
416 | * FUNCTION: acpi_tb_get_table_ptr | |
417 | * | |
418 | * PARAMETERS: table_type - one of the defined table types | |
419 | * Instance - Which table of this type | |
420 | * table_ptr_loc - pointer to location to place the pointer for | |
421 | * return | |
422 | * | |
423 | * RETURN: Status | |
424 | * | |
425 | * DESCRIPTION: This function is called to get the pointer to an ACPI table. | |
426 | * | |
427 | ******************************************************************************/ | |
428 | ||
429 | acpi_status | |
4be44fcd LB |
430 | acpi_tb_get_table_ptr(acpi_table_type table_type, |
431 | u32 instance, struct acpi_table_header **table_ptr_loc) | |
1da177e4 | 432 | { |
4be44fcd LB |
433 | struct acpi_table_desc *table_desc; |
434 | u32 i; | |
1da177e4 | 435 | |
4be44fcd | 436 | ACPI_FUNCTION_TRACE("tb_get_table_ptr"); |
1da177e4 LT |
437 | |
438 | if (!acpi_gbl_DSDT) { | |
4be44fcd | 439 | return_ACPI_STATUS(AE_NO_ACPI_TABLES); |
1da177e4 LT |
440 | } |
441 | ||
442 | if (table_type > ACPI_TABLE_MAX) { | |
4be44fcd | 443 | return_ACPI_STATUS(AE_BAD_PARAMETER); |
1da177e4 LT |
444 | } |
445 | ||
446 | /* | |
447 | * For all table types (Single/Multiple), the first | |
448 | * instance is always in the list head. | |
449 | */ | |
450 | if (instance == 1) { | |
52fc0b02 | 451 | |
1da177e4 LT |
452 | /* Get the first */ |
453 | ||
454 | *table_ptr_loc = NULL; | |
455 | if (acpi_gbl_table_lists[table_type].next) { | |
4be44fcd LB |
456 | *table_ptr_loc = |
457 | acpi_gbl_table_lists[table_type].next->pointer; | |
1da177e4 | 458 | } |
4be44fcd | 459 | return_ACPI_STATUS(AE_OK); |
1da177e4 LT |
460 | } |
461 | ||
44f6c012 RM |
462 | /* Check for instance out of range */ |
463 | ||
1da177e4 | 464 | if (instance > acpi_gbl_table_lists[table_type].count) { |
4be44fcd | 465 | return_ACPI_STATUS(AE_NOT_EXIST); |
1da177e4 LT |
466 | } |
467 | ||
468 | /* Walk the list to get the desired table | |
469 | * Since the if (Instance == 1) check above checked for the | |
470 | * first table, setting table_desc equal to the .Next member | |
471 | * is actually pointing to the second table. Therefore, we | |
472 | * need to walk from the 2nd table until we reach the Instance | |
473 | * that the user is looking for and return its table pointer. | |
474 | */ | |
475 | table_desc = acpi_gbl_table_lists[table_type].next; | |
476 | for (i = 2; i < instance; i++) { | |
477 | table_desc = table_desc->next; | |
478 | } | |
479 | ||
480 | /* We are now pointing to the requested table's descriptor */ | |
481 | ||
482 | *table_ptr_loc = table_desc->pointer; | |
483 | ||
4be44fcd | 484 | return_ACPI_STATUS(AE_OK); |
1da177e4 | 485 | } |