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