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