Commit | Line | Data |
---|---|---|
95befdb3 BM |
1 | /****************************************************************************** |
2 | * | |
3 | * Module Name: tbfadt - FADT table utilities | |
4 | * | |
5 | *****************************************************************************/ | |
6 | ||
7 | /* | |
75a44ce0 | 8 | * Copyright (C) 2000 - 2008, Intel Corp. |
95befdb3 BM |
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 | ||
44 | #include <acpi/acpi.h> | |
e2f7a777 LB |
45 | #include "accommon.h" |
46 | #include "actables.h" | |
95befdb3 BM |
47 | |
48 | #define _COMPONENT ACPI_TABLES | |
49 | ACPI_MODULE_NAME("tbfadt") | |
50 | ||
51 | /* Local prototypes */ | |
6de4048a | 52 | static inline void |
ea5d8ebc | 53 | acpi_tb_init_generic_address(struct acpi_generic_address *generic_address, |
06f55419 | 54 | u8 space_id, u8 byte_width, u64 address); |
95befdb3 | 55 | |
71392844 BM |
56 | static void acpi_tb_convert_fadt(void); |
57 | ||
58 | static void acpi_tb_validate_fadt(void); | |
59 | ||
531c633d BM |
60 | static void acpi_tb_setup_fadt_registers(void); |
61 | ||
ea5d8ebc | 62 | /* Table for conversion of FADT to common internal format and FADT validation */ |
95befdb3 | 63 | |
ea5d8ebc BM |
64 | typedef struct acpi_fadt_info { |
65 | char *name; | |
4b67a0e4 | 66 | u8 address64; |
67 | u8 address32; | |
95befdb3 | 68 | u8 length; |
4b67a0e4 | 69 | u8 default_length; |
ea5d8ebc | 70 | u8 type; |
95befdb3 | 71 | |
ea5d8ebc | 72 | } acpi_fadt_info; |
95befdb3 | 73 | |
ea5d8ebc BM |
74 | #define ACPI_FADT_REQUIRED 1 |
75 | #define ACPI_FADT_SEPARATE_LENGTH 2 | |
76 | ||
77 | static struct acpi_fadt_info fadt_info_table[] = { | |
4b67a0e4 | 78 | {"Pm1aEventBlock", |
79 | ACPI_FADT_OFFSET(xpm1a_event_block), | |
95befdb3 | 80 | ACPI_FADT_OFFSET(pm1a_event_block), |
4b67a0e4 | 81 | ACPI_FADT_OFFSET(pm1_event_length), |
82 | ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ | |
83 | ACPI_FADT_REQUIRED}, | |
ea5d8ebc | 84 | |
4b67a0e4 | 85 | {"Pm1bEventBlock", |
86 | ACPI_FADT_OFFSET(xpm1b_event_block), | |
95befdb3 | 87 | ACPI_FADT_OFFSET(pm1b_event_block), |
4b67a0e4 | 88 | ACPI_FADT_OFFSET(pm1_event_length), |
89 | ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ | |
90 | 0}, | |
ea5d8ebc | 91 | |
4b67a0e4 | 92 | {"Pm1aControlBlock", |
93 | ACPI_FADT_OFFSET(xpm1a_control_block), | |
95befdb3 | 94 | ACPI_FADT_OFFSET(pm1a_control_block), |
4b67a0e4 | 95 | ACPI_FADT_OFFSET(pm1_control_length), |
96 | ACPI_PM1_REGISTER_WIDTH, | |
97 | ACPI_FADT_REQUIRED}, | |
ea5d8ebc | 98 | |
4b67a0e4 | 99 | {"Pm1bControlBlock", |
100 | ACPI_FADT_OFFSET(xpm1b_control_block), | |
95befdb3 | 101 | ACPI_FADT_OFFSET(pm1b_control_block), |
4b67a0e4 | 102 | ACPI_FADT_OFFSET(pm1_control_length), |
103 | ACPI_PM1_REGISTER_WIDTH, | |
104 | 0}, | |
ea5d8ebc | 105 | |
4b67a0e4 | 106 | {"Pm2ControlBlock", |
107 | ACPI_FADT_OFFSET(xpm2_control_block), | |
95befdb3 | 108 | ACPI_FADT_OFFSET(pm2_control_block), |
4b67a0e4 | 109 | ACPI_FADT_OFFSET(pm2_control_length), |
110 | ACPI_PM2_REGISTER_WIDTH, | |
111 | ACPI_FADT_SEPARATE_LENGTH}, | |
ea5d8ebc | 112 | |
4b67a0e4 | 113 | {"PmTimerBlock", |
114 | ACPI_FADT_OFFSET(xpm_timer_block), | |
ea5d8ebc | 115 | ACPI_FADT_OFFSET(pm_timer_block), |
4b67a0e4 | 116 | ACPI_FADT_OFFSET(pm_timer_length), |
117 | ACPI_PM_TIMER_WIDTH, | |
118 | ACPI_FADT_REQUIRED}, | |
ea5d8ebc | 119 | |
4b67a0e4 | 120 | {"Gpe0Block", |
121 | ACPI_FADT_OFFSET(xgpe0_block), | |
ea5d8ebc | 122 | ACPI_FADT_OFFSET(gpe0_block), |
4b67a0e4 | 123 | ACPI_FADT_OFFSET(gpe0_block_length), |
124 | 0, | |
125 | ACPI_FADT_SEPARATE_LENGTH}, | |
ea5d8ebc | 126 | |
4b67a0e4 | 127 | {"Gpe1Block", |
128 | ACPI_FADT_OFFSET(xgpe1_block), | |
ea5d8ebc | 129 | ACPI_FADT_OFFSET(gpe1_block), |
4b67a0e4 | 130 | ACPI_FADT_OFFSET(gpe1_block_length), |
131 | 0, | |
132 | ACPI_FADT_SEPARATE_LENGTH} | |
95befdb3 BM |
133 | }; |
134 | ||
ec41f193 BM |
135 | #define ACPI_FADT_INFO_ENTRIES \ |
136 | (sizeof (fadt_info_table) / sizeof (struct acpi_fadt_info)) | |
95befdb3 | 137 | |
531c633d BM |
138 | /* Table used to split Event Blocks into separate status/enable registers */ |
139 | ||
140 | typedef struct acpi_fadt_pm_info { | |
141 | struct acpi_generic_address *target; | |
142 | u8 source; | |
143 | u8 register_num; | |
144 | ||
145 | } acpi_fadt_pm_info; | |
146 | ||
147 | static struct acpi_fadt_pm_info fadt_pm_info_table[] = { | |
148 | {&acpi_gbl_xpm1a_status, | |
149 | ACPI_FADT_OFFSET(xpm1a_event_block), | |
150 | 0}, | |
151 | ||
152 | {&acpi_gbl_xpm1a_enable, | |
153 | ACPI_FADT_OFFSET(xpm1a_event_block), | |
154 | 1}, | |
155 | ||
156 | {&acpi_gbl_xpm1b_status, | |
157 | ACPI_FADT_OFFSET(xpm1b_event_block), | |
158 | 0}, | |
159 | ||
160 | {&acpi_gbl_xpm1b_enable, | |
161 | ACPI_FADT_OFFSET(xpm1b_event_block), | |
162 | 1} | |
163 | }; | |
164 | ||
ec41f193 BM |
165 | #define ACPI_FADT_PM_INFO_ENTRIES \ |
166 | (sizeof (fadt_pm_info_table) / sizeof (struct acpi_fadt_pm_info)) | |
531c633d | 167 | |
95befdb3 BM |
168 | /******************************************************************************* |
169 | * | |
170 | * FUNCTION: acpi_tb_init_generic_address | |
171 | * | |
ea5d8ebc | 172 | * PARAMETERS: generic_address - GAS struct to be initialized |
fcea94ba | 173 | * byte_width - Width of this register |
95befdb3 BM |
174 | * Address - Address of the register |
175 | * | |
176 | * RETURN: None | |
177 | * | |
ea5d8ebc BM |
178 | * DESCRIPTION: Initialize a Generic Address Structure (GAS) |
179 | * See the ACPI specification for a full description and | |
180 | * definition of this structure. | |
95befdb3 BM |
181 | * |
182 | ******************************************************************************/ | |
183 | ||
6de4048a | 184 | static inline void |
ea5d8ebc | 185 | acpi_tb_init_generic_address(struct acpi_generic_address *generic_address, |
06f55419 | 186 | u8 space_id, u8 byte_width, u64 address) |
95befdb3 BM |
187 | { |
188 | ||
ea5d8ebc BM |
189 | /* |
190 | * The 64-bit Address field is non-aligned in the byte packed | |
191 | * GAS struct. | |
192 | */ | |
193 | ACPI_MOVE_64_TO_64(&generic_address->address, &address); | |
194 | ||
195 | /* All other fields are byte-wide */ | |
196 | ||
06f55419 BM |
197 | generic_address->space_id = space_id; |
198 | generic_address->bit_width = (u8)ACPI_MUL_8(byte_width); | |
ea5d8ebc | 199 | generic_address->bit_offset = 0; |
06f55419 | 200 | generic_address->access_width = 0; /* Access width ANY */ |
95befdb3 BM |
201 | } |
202 | ||
203 | /******************************************************************************* | |
204 | * | |
205 | * FUNCTION: acpi_tb_parse_fadt | |
206 | * | |
207 | * PARAMETERS: table_index - Index for the FADT | |
95befdb3 BM |
208 | * |
209 | * RETURN: None | |
210 | * | |
211 | * DESCRIPTION: Initialize the FADT, DSDT and FACS tables | |
212 | * (FADT contains the addresses of the DSDT and FACS) | |
213 | * | |
214 | ******************************************************************************/ | |
215 | ||
97cbb7d1 | 216 | void acpi_tb_parse_fadt(u32 table_index) |
95befdb3 BM |
217 | { |
218 | u32 length; | |
219 | struct acpi_table_header *table; | |
220 | ||
221 | /* | |
ea5d8ebc BM |
222 | * The FADT has multiple versions with different lengths, |
223 | * and it contains pointers to both the DSDT and FACS tables. | |
95befdb3 BM |
224 | * |
225 | * Get a local copy of the FADT and convert it to a common format | |
226 | * Map entire FADT, assumed to be smaller than one page. | |
227 | */ | |
228 | length = acpi_gbl_root_table_list.tables[table_index].length; | |
229 | ||
230 | table = | |
231 | acpi_os_map_memory(acpi_gbl_root_table_list.tables[table_index]. | |
232 | address, length); | |
233 | if (!table) { | |
234 | return; | |
235 | } | |
236 | ||
237 | /* | |
238 | * Validate the FADT checksum before we copy the table. Ignore | |
239 | * checksum error as we want to try to get the DSDT and FACS. | |
240 | */ | |
241 | (void)acpi_tb_verify_checksum(table, length); | |
242 | ||
531c633d | 243 | /* Create a local copy of the FADT in common ACPI 2.0+ format */ |
71392844 BM |
244 | |
245 | acpi_tb_create_local_fadt(table, length); | |
246 | ||
247 | /* All done with the real FADT, unmap it */ | |
248 | ||
249 | acpi_os_unmap_memory(table, length); | |
250 | ||
251 | /* Obtain the DSDT and FACS tables via their addresses within the FADT */ | |
252 | ||
253 | acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt, | |
97cbb7d1 | 254 | ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT); |
71392844 BM |
255 | |
256 | acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xfacs, | |
97cbb7d1 | 257 | ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS); |
71392844 BM |
258 | } |
259 | ||
260 | /******************************************************************************* | |
261 | * | |
262 | * FUNCTION: acpi_tb_create_local_fadt | |
263 | * | |
264 | * PARAMETERS: Table - Pointer to BIOS FADT | |
265 | * Length - Length of the table | |
266 | * | |
267 | * RETURN: None | |
268 | * | |
269 | * DESCRIPTION: Get a local copy of the FADT and convert it to a common format. | |
270 | * Performs validation on some important FADT fields. | |
271 | * | |
55f8f3cc BM |
272 | * NOTE: We create a local copy of the FADT regardless of the version. |
273 | * | |
71392844 BM |
274 | ******************************************************************************/ |
275 | ||
276 | void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length) | |
277 | { | |
ea5d8ebc | 278 | /* |
55f8f3cc BM |
279 | * Check if the FADT is larger than the largest table that we expect |
280 | * (the ACPI 2.0/3.0 version). If so, truncate the table, and issue | |
281 | * a warning. | |
ea5d8ebc BM |
282 | */ |
283 | if (length > sizeof(struct acpi_table_fadt)) { | |
284 | ACPI_WARNING((AE_INFO, | |
06f55419 | 285 | "FADT (revision %u) is longer than ACPI 2.0 version, " |
b21245a8 BM |
286 | "truncating length 0x%X to 0x%X", |
287 | table->revision, length, | |
288 | (u32)sizeof(struct acpi_table_fadt))); | |
ea5d8ebc | 289 | } |
95befdb3 | 290 | |
55f8f3cc | 291 | /* Clear the entire local FADT */ |
95befdb3 | 292 | |
ea5d8ebc | 293 | ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt)); |
71392844 | 294 | |
55f8f3cc BM |
295 | /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */ |
296 | ||
95befdb3 BM |
297 | ACPI_MEMCPY(&acpi_gbl_FADT, table, |
298 | ACPI_MIN(length, sizeof(struct acpi_table_fadt))); | |
95befdb3 | 299 | |
531c633d BM |
300 | /* Convert the local copy of the FADT to the common internal format */ |
301 | ||
95befdb3 | 302 | acpi_tb_convert_fadt(); |
531c633d BM |
303 | |
304 | /* Validate FADT values now, before we make any changes */ | |
305 | ||
306 | acpi_tb_validate_fadt(); | |
307 | ||
308 | /* Initialize the global ACPI register structures */ | |
309 | ||
310 | acpi_tb_setup_fadt_registers(); | |
95befdb3 BM |
311 | } |
312 | ||
313 | /******************************************************************************* | |
314 | * | |
315 | * FUNCTION: acpi_tb_convert_fadt | |
316 | * | |
317 | * PARAMETERS: None, uses acpi_gbl_FADT | |
318 | * | |
319 | * RETURN: None | |
320 | * | |
321 | * DESCRIPTION: Converts all versions of the FADT to a common internal format. | |
31fbc073 | 322 | * Expand 32-bit addresses to 64-bit as necessary. |
95befdb3 | 323 | * |
e56b638b BM |
324 | * NOTE: acpi_gbl_FADT must be of size (struct acpi_table_fadt), |
325 | * and must contain a copy of the actual FADT. | |
95befdb3 | 326 | * |
31fbc073 | 327 | * Notes on 64-bit register addresses: |
95befdb3 | 328 | * |
31fbc073 BM |
329 | * After this FADT conversion, later ACPICA code will only use the 64-bit "X" |
330 | * fields of the FADT for all ACPI register addresses. | |
95befdb3 | 331 | * |
31fbc073 BM |
332 | * The 64-bit "X" fields are optional extensions to the original 32-bit FADT |
333 | * V1.0 fields. Even if they are present in the FADT, they are optional and | |
334 | * are unused if the BIOS sets them to zero. Therefore, we must copy/expand | |
335 | * 32-bit V1.0 fields if the corresponding X field is zero. | |
95befdb3 | 336 | * |
31fbc073 BM |
337 | * For ACPI 1.0 FADTs, all 32-bit address fields are expanded to the |
338 | * corresponding "X" fields in the internal FADT. | |
339 | * | |
340 | * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded | |
341 | * to the corresponding 64-bit X fields. For compatibility with other ACPI | |
342 | * implementations, we ignore the 64-bit field if the 32-bit field is valid, | |
343 | * regardless of whether the host OS is 32-bit or 64-bit. | |
95befdb3 BM |
344 | * |
345 | ******************************************************************************/ | |
346 | ||
71392844 | 347 | static void acpi_tb_convert_fadt(void) |
95befdb3 | 348 | { |
31fbc073 BM |
349 | struct acpi_generic_address *address64; |
350 | u32 address32; | |
67a119f9 | 351 | u32 i; |
95befdb3 | 352 | |
ea5d8ebc BM |
353 | /* Update the local FADT table header length */ |
354 | ||
355 | acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt); | |
356 | ||
c87609f3 BM |
357 | /* |
358 | * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary. | |
359 | * Later code will always use the X 64-bit field. Also, check for an | |
360 | * address mismatch between the 32-bit and 64-bit address fields | |
361 | * (FIRMWARE_CTRL/X_FIRMWARE_CTRL, DSDT/X_DSDT) which would indicate | |
362 | * the presence of two FACS or two DSDT tables. | |
363 | */ | |
95befdb3 BM |
364 | if (!acpi_gbl_FADT.Xfacs) { |
365 | acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs; | |
c87609f3 BM |
366 | } else if (acpi_gbl_FADT.facs && |
367 | (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) { | |
368 | ACPI_WARNING((AE_INFO, | |
369 | "32/64 FACS address mismatch in FADT - two FACS tables!")); | |
95befdb3 BM |
370 | } |
371 | ||
372 | if (!acpi_gbl_FADT.Xdsdt) { | |
373 | acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt; | |
c87609f3 BM |
374 | } else if (acpi_gbl_FADT.dsdt && |
375 | (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) { | |
376 | ACPI_WARNING((AE_INFO, | |
377 | "32/64 DSDT address mismatch in FADT - two DSDT tables!")); | |
95befdb3 BM |
378 | } |
379 | ||
380 | /* | |
55f8f3cc BM |
381 | * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which |
382 | * should be zero are indeed zero. This will workaround BIOSs that | |
383 | * inadvertently place values in these fields. | |
384 | * | |
385 | * The ACPI 1.0 reserved fields that will be zeroed are the bytes located at | |
386 | * offset 45, 55, 95, and the word located at offset 109, 110. | |
387 | */ | |
14a63ba8 | 388 | if (acpi_gbl_FADT.header.revision < FADT2_REVISION_ID) { |
55f8f3cc BM |
389 | acpi_gbl_FADT.preferred_profile = 0; |
390 | acpi_gbl_FADT.pstate_control = 0; | |
391 | acpi_gbl_FADT.cst_control = 0; | |
392 | acpi_gbl_FADT.boot_flags = 0; | |
393 | } | |
394 | ||
395 | /* | |
4b67a0e4 | 396 | * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X" |
397 | * generic address structures as necessary. Later code will always use | |
398 | * the 64-bit address structures. | |
31fbc073 BM |
399 | * |
400 | * March 2009: | |
401 | * We now always use the 32-bit address if it is valid (non-null). This | |
402 | * is not in accordance with the ACPI specification which states that | |
403 | * the 64-bit address supersedes the 32-bit version, but we do this for | |
404 | * compatibility with other ACPI implementations. Most notably, in the | |
405 | * case where both the 32 and 64 versions are non-null, we use the 32-bit | |
406 | * version. This is the only address that is guaranteed to have been | |
407 | * tested by the BIOS manufacturer. | |
95befdb3 | 408 | */ |
ea5d8ebc | 409 | for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { |
31fbc073 BM |
410 | address32 = *ACPI_ADD_PTR(u32, |
411 | &acpi_gbl_FADT, | |
412 | fadt_info_table[i].address32); | |
95befdb3 | 413 | |
31fbc073 BM |
414 | address64 = ACPI_ADD_PTR(struct acpi_generic_address, |
415 | &acpi_gbl_FADT, | |
416 | fadt_info_table[i].address64); | |
95befdb3 | 417 | |
31fbc073 BM |
418 | /* |
419 | * If both 32- and 64-bit addresses are valid (non-zero), | |
420 | * they must match. | |
421 | */ | |
422 | if (address64->address && address32 && | |
423 | (address64->address != (u64) address32)) { | |
424 | ACPI_ERROR((AE_INFO, | |
425 | "32/64X address mismatch in %s: %8.8X/%8.8X%8.8X, using 32", | |
426 | fadt_info_table[i].name, address32, | |
427 | ACPI_FORMAT_UINT64(address64->address))); | |
428 | } | |
06f55419 | 429 | |
31fbc073 | 430 | /* Always use 32-bit address if it is valid (non-null) */ |
06f55419 | 431 | |
31fbc073 BM |
432 | if (address32) { |
433 | /* | |
434 | * Copy the 32-bit address to the 64-bit GAS structure. The | |
435 | * Space ID is always I/O for 32-bit legacy address fields | |
436 | */ | |
437 | acpi_tb_init_generic_address(address64, | |
06f55419 | 438 | ACPI_ADR_SPACE_SYSTEM_IO, |
95befdb3 BM |
439 | *ACPI_ADD_PTR(u8, |
440 | &acpi_gbl_FADT, | |
ea5d8ebc | 441 | fadt_info_table |
95befdb3 | 442 | [i].length), |
e4c1ebfc | 443 | (u64) address32); |
95befdb3 BM |
444 | } |
445 | } | |
95befdb3 BM |
446 | } |
447 | ||
ec41f193 | 448 | /******************************************************************************* |
95befdb3 BM |
449 | * |
450 | * FUNCTION: acpi_tb_validate_fadt | |
451 | * | |
ea5d8ebc | 452 | * PARAMETERS: Table - Pointer to the FADT to be validated |
95befdb3 | 453 | * |
e56b638b | 454 | * RETURN: None |
95befdb3 | 455 | * |
ea5d8ebc BM |
456 | * DESCRIPTION: Validate various important fields within the FADT. If a problem |
457 | * is found, issue a message, but no status is returned. | |
458 | * Used by both the table manager and the disassembler. | |
459 | * | |
460 | * Possible additional checks: | |
461 | * (acpi_gbl_FADT.pm1_event_length >= 4) | |
462 | * (acpi_gbl_FADT.pm1_control_length >= 2) | |
463 | * (acpi_gbl_FADT.pm_timer_length >= 4) | |
464 | * Gpe block lengths must be multiple of 2 | |
95befdb3 BM |
465 | * |
466 | ******************************************************************************/ | |
467 | ||
71392844 | 468 | static void acpi_tb_validate_fadt(void) |
95befdb3 | 469 | { |
06f55419 | 470 | char *name; |
ea5d8ebc BM |
471 | struct acpi_generic_address *address64; |
472 | u8 length; | |
67a119f9 | 473 | u32 i; |
95befdb3 | 474 | |
06f55419 BM |
475 | /* |
476 | * Check for FACS and DSDT address mismatches. An address mismatch between | |
477 | * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and | |
478 | * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables. | |
479 | */ | |
480 | if (acpi_gbl_FADT.facs && | |
481 | (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) { | |
482 | ACPI_WARNING((AE_INFO, | |
40774f7a | 483 | "32/64X FACS address mismatch in FADT - " |
f6556306 | 484 | "%8.8X/%8.8X%8.8X, using 32", |
06f55419 BM |
485 | acpi_gbl_FADT.facs, |
486 | ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xfacs))); | |
f6556306 BM |
487 | |
488 | acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs; | |
06f55419 | 489 | } |
ea5d8ebc | 490 | |
06f55419 BM |
491 | if (acpi_gbl_FADT.dsdt && |
492 | (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) { | |
493 | ACPI_WARNING((AE_INFO, | |
40774f7a | 494 | "32/64X DSDT address mismatch in FADT - " |
f6556306 | 495 | "%8.8X/%8.8X%8.8X, using 32", |
06f55419 BM |
496 | acpi_gbl_FADT.dsdt, |
497 | ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xdsdt))); | |
f6556306 BM |
498 | |
499 | acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt; | |
06f55419 | 500 | } |
ea5d8ebc | 501 | |
06f55419 | 502 | /* Examine all of the 64-bit extended address fields (X fields) */ |
ea5d8ebc | 503 | |
06f55419 BM |
504 | for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { |
505 | /* | |
e4c1ebfc BM |
506 | * Generate pointer to the 64-bit address, get the register |
507 | * length (width) and the register name | |
06f55419 BM |
508 | */ |
509 | address64 = ACPI_ADD_PTR(struct acpi_generic_address, | |
510 | &acpi_gbl_FADT, | |
4b67a0e4 | 511 | fadt_info_table[i].address64); |
71392844 BM |
512 | length = |
513 | *ACPI_ADD_PTR(u8, &acpi_gbl_FADT, | |
514 | fadt_info_table[i].length); | |
06f55419 BM |
515 | name = fadt_info_table[i].name; |
516 | ||
517 | /* | |
518 | * For each extended field, check for length mismatch between the | |
4b67a0e4 | 519 | * legacy length field and the corresponding 64-bit X length field. |
06f55419 | 520 | */ |
aab61b67 BM |
521 | if (address64->address && |
522 | (address64->bit_width != ACPI_MUL_8(length))) { | |
06f55419 | 523 | ACPI_WARNING((AE_INFO, |
40774f7a | 524 | "32/64X length mismatch in %s: %d/%d", |
06f55419 BM |
525 | name, ACPI_MUL_8(length), |
526 | address64->bit_width)); | |
527 | } | |
ea5d8ebc BM |
528 | |
529 | if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) { | |
530 | /* | |
531 | * Field is required (Pm1a_event, Pm1a_control, pm_timer). | |
532 | * Both the address and length must be non-zero. | |
533 | */ | |
534 | if (!address64->address || !length) { | |
535 | ACPI_ERROR((AE_INFO, | |
ec41f193 BM |
536 | "Required field %s has zero address and/or length:" |
537 | " %8.8X%8.8X/%X", | |
06f55419 | 538 | name, |
ea5d8ebc BM |
539 | ACPI_FORMAT_UINT64(address64-> |
540 | address), | |
541 | length)); | |
542 | } | |
543 | } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) { | |
544 | /* | |
545 | * Field is optional (PM2Control, GPE0, GPE1) AND has its own | |
ec41f193 BM |
546 | * length field. If present, both the address and length must |
547 | * be valid. | |
ea5d8ebc | 548 | */ |
ec41f193 BM |
549 | if ((address64->address && !length) || |
550 | (!address64->address && length)) { | |
ea5d8ebc | 551 | ACPI_WARNING((AE_INFO, |
ec41f193 BM |
552 | "Optional field %s has zero address or length: " |
553 | "%8.8X%8.8X/%X", | |
06f55419 | 554 | name, |
ea5d8ebc BM |
555 | ACPI_FORMAT_UINT64(address64-> |
556 | address), | |
557 | length)); | |
558 | } | |
559 | } | |
95befdb3 BM |
560 | } |
561 | } | |
531c633d | 562 | |
ec41f193 | 563 | /******************************************************************************* |
531c633d BM |
564 | * |
565 | * FUNCTION: acpi_tb_setup_fadt_registers | |
566 | * | |
567 | * PARAMETERS: None, uses acpi_gbl_FADT. | |
568 | * | |
569 | * RETURN: None | |
570 | * | |
571 | * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally, | |
572 | * force FADT register definitions to their default lengths. | |
573 | * | |
574 | ******************************************************************************/ | |
575 | ||
576 | static void acpi_tb_setup_fadt_registers(void) | |
577 | { | |
578 | struct acpi_generic_address *target64; | |
579 | struct acpi_generic_address *source64; | |
580 | u8 pm1_register_byte_width; | |
581 | u32 i; | |
582 | ||
583 | /* | |
584 | * Optionally check all register lengths against the default values and | |
585 | * update them if they are incorrect. | |
586 | */ | |
587 | if (acpi_gbl_use_default_register_widths) { | |
588 | for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { | |
589 | target64 = | |
590 | ACPI_ADD_PTR(struct acpi_generic_address, | |
591 | &acpi_gbl_FADT, | |
592 | fadt_info_table[i].address64); | |
593 | ||
594 | /* | |
595 | * If a valid register (Address != 0) and the (default_length > 0) | |
596 | * (Not a GPE register), then check the width against the default. | |
597 | */ | |
598 | if ((target64->address) && | |
599 | (fadt_info_table[i].default_length > 0) && | |
600 | (fadt_info_table[i].default_length != | |
601 | target64->bit_width)) { | |
602 | ACPI_WARNING((AE_INFO, | |
603 | "Invalid length for %s: %d, using default %d", | |
604 | fadt_info_table[i].name, | |
605 | target64->bit_width, | |
606 | fadt_info_table[i]. | |
607 | default_length)); | |
608 | ||
609 | /* Incorrect size, set width to the default */ | |
610 | ||
611 | target64->bit_width = | |
612 | fadt_info_table[i].default_length; | |
613 | } | |
614 | } | |
615 | } | |
616 | ||
617 | /* | |
618 | * Get the length of the individual PM1 registers (enable and status). | |
619 | * Each register is defined to be (event block length / 2). Extra divide | |
620 | * by 8 converts bits to bytes. | |
621 | */ | |
ec41f193 BM |
622 | pm1_register_byte_width = (u8) |
623 | ACPI_DIV_16(acpi_gbl_FADT.xpm1a_event_block.bit_width); | |
531c633d BM |
624 | |
625 | /* | |
626 | * Calculate separate GAS structs for the PM1x (A/B) Status and Enable | |
627 | * registers. These addresses do not appear (directly) in the FADT, so it | |
628 | * is useful to pre-calculate them from the PM1 Event Block definitions. | |
629 | * | |
630 | * The PM event blocks are split into two register blocks, first is the | |
631 | * PM Status Register block, followed immediately by the PM Enable | |
632 | * Register block. Each is of length (pm1_event_length/2) | |
633 | * | |
634 | * Note: The PM1A event block is required by the ACPI specification. | |
635 | * However, the PM1B event block is optional and is rarely, if ever, | |
636 | * used. | |
637 | */ | |
638 | ||
639 | for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) { | |
640 | source64 = | |
641 | ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT, | |
642 | fadt_pm_info_table[i].source); | |
643 | ||
5e053e77 LM |
644 | if (source64->address) { |
645 | acpi_tb_init_generic_address(fadt_pm_info_table[i]. | |
646 | target, source64->space_id, | |
647 | pm1_register_byte_width, | |
648 | source64->address + | |
649 | (fadt_pm_info_table[i]. | |
650 | register_num * | |
651 | pm1_register_byte_width)); | |
652 | } | |
531c633d BM |
653 | } |
654 | } |