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 | { | |
278 | ||
ea5d8ebc | 279 | /* |
55f8f3cc BM |
280 | * Check if the FADT is larger than the largest table that we expect |
281 | * (the ACPI 2.0/3.0 version). If so, truncate the table, and issue | |
282 | * a warning. | |
ea5d8ebc BM |
283 | */ |
284 | if (length > sizeof(struct acpi_table_fadt)) { | |
285 | ACPI_WARNING((AE_INFO, | |
06f55419 BM |
286 | "FADT (revision %u) is longer than ACPI 2.0 version, " |
287 | "truncating length 0x%X to 0x%zX", | |
b0b7eaaf | 288 | table->revision, (unsigned)length, |
ea5d8ebc BM |
289 | sizeof(struct acpi_table_fadt))); |
290 | } | |
95befdb3 | 291 | |
55f8f3cc | 292 | /* Clear the entire local FADT */ |
95befdb3 | 293 | |
ea5d8ebc | 294 | ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt)); |
71392844 | 295 | |
55f8f3cc BM |
296 | /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */ |
297 | ||
95befdb3 BM |
298 | ACPI_MEMCPY(&acpi_gbl_FADT, table, |
299 | ACPI_MIN(length, sizeof(struct acpi_table_fadt))); | |
95befdb3 | 300 | |
531c633d BM |
301 | /* Convert the local copy of the FADT to the common internal format */ |
302 | ||
95befdb3 | 303 | acpi_tb_convert_fadt(); |
531c633d BM |
304 | |
305 | /* Validate FADT values now, before we make any changes */ | |
306 | ||
307 | acpi_tb_validate_fadt(); | |
308 | ||
309 | /* Initialize the global ACPI register structures */ | |
310 | ||
311 | acpi_tb_setup_fadt_registers(); | |
95befdb3 BM |
312 | } |
313 | ||
314 | /******************************************************************************* | |
315 | * | |
316 | * FUNCTION: acpi_tb_convert_fadt | |
317 | * | |
318 | * PARAMETERS: None, uses acpi_gbl_FADT | |
319 | * | |
320 | * RETURN: None | |
321 | * | |
322 | * DESCRIPTION: Converts all versions of the FADT to a common internal format. | |
55f8f3cc | 323 | * Expand all 32-bit addresses to 64-bit. |
95befdb3 | 324 | * |
e56b638b BM |
325 | * NOTE: acpi_gbl_FADT must be of size (struct acpi_table_fadt), |
326 | * and must contain a copy of the actual FADT. | |
95befdb3 BM |
327 | * |
328 | * ACPICA will use the "X" fields of the FADT for all addresses. | |
329 | * | |
330 | * "X" fields are optional extensions to the original V1.0 fields. Even if | |
331 | * they are present in the structure, they can be optionally not used by | |
332 | * setting them to zero. Therefore, we must selectively expand V1.0 fields | |
333 | * if the corresponding X field is zero. | |
334 | * | |
335 | * For ACPI 1.0 FADTs, all address fields are expanded to the corresponding | |
336 | * "X" fields. | |
337 | * | |
338 | * For ACPI 2.0 FADTs, any "X" fields that are NULL are filled in by | |
339 | * expanding the corresponding ACPI 1.0 field. | |
340 | * | |
341 | ******************************************************************************/ | |
342 | ||
71392844 | 343 | static void acpi_tb_convert_fadt(void) |
95befdb3 | 344 | { |
4b67a0e4 | 345 | struct acpi_generic_address *target64; |
67a119f9 | 346 | u32 i; |
95befdb3 | 347 | |
ea5d8ebc BM |
348 | /* Update the local FADT table header length */ |
349 | ||
350 | acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt); | |
351 | ||
c87609f3 BM |
352 | /* |
353 | * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary. | |
354 | * Later code will always use the X 64-bit field. Also, check for an | |
355 | * address mismatch between the 32-bit and 64-bit address fields | |
356 | * (FIRMWARE_CTRL/X_FIRMWARE_CTRL, DSDT/X_DSDT) which would indicate | |
357 | * the presence of two FACS or two DSDT tables. | |
358 | */ | |
95befdb3 BM |
359 | if (!acpi_gbl_FADT.Xfacs) { |
360 | acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs; | |
c87609f3 BM |
361 | } else if (acpi_gbl_FADT.facs && |
362 | (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) { | |
363 | ACPI_WARNING((AE_INFO, | |
364 | "32/64 FACS address mismatch in FADT - two FACS tables!")); | |
95befdb3 BM |
365 | } |
366 | ||
367 | if (!acpi_gbl_FADT.Xdsdt) { | |
368 | acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt; | |
c87609f3 BM |
369 | } else if (acpi_gbl_FADT.dsdt && |
370 | (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) { | |
371 | ACPI_WARNING((AE_INFO, | |
372 | "32/64 DSDT address mismatch in FADT - two DSDT tables!")); | |
95befdb3 BM |
373 | } |
374 | ||
375 | /* | |
55f8f3cc BM |
376 | * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which |
377 | * should be zero are indeed zero. This will workaround BIOSs that | |
378 | * inadvertently place values in these fields. | |
379 | * | |
380 | * The ACPI 1.0 reserved fields that will be zeroed are the bytes located at | |
381 | * offset 45, 55, 95, and the word located at offset 109, 110. | |
382 | */ | |
14a63ba8 | 383 | if (acpi_gbl_FADT.header.revision < FADT2_REVISION_ID) { |
55f8f3cc BM |
384 | acpi_gbl_FADT.preferred_profile = 0; |
385 | acpi_gbl_FADT.pstate_control = 0; | |
386 | acpi_gbl_FADT.cst_control = 0; | |
387 | acpi_gbl_FADT.boot_flags = 0; | |
388 | } | |
389 | ||
390 | /* | |
4b67a0e4 | 391 | * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X" |
392 | * generic address structures as necessary. Later code will always use | |
393 | * the 64-bit address structures. | |
95befdb3 | 394 | */ |
ea5d8ebc | 395 | for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { |
4b67a0e4 | 396 | target64 = |
95befdb3 | 397 | ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT, |
4b67a0e4 | 398 | fadt_info_table[i].address64); |
95befdb3 | 399 | |
4b67a0e4 | 400 | /* Expand only if the 64-bit X target is null */ |
95befdb3 | 401 | |
4b67a0e4 | 402 | if (!target64->address) { |
06f55419 | 403 | |
4b67a0e4 | 404 | /* The space_id is always I/O for the 32-bit legacy address fields */ |
06f55419 | 405 | |
4b67a0e4 | 406 | acpi_tb_init_generic_address(target64, |
06f55419 | 407 | ACPI_ADR_SPACE_SYSTEM_IO, |
95befdb3 BM |
408 | *ACPI_ADD_PTR(u8, |
409 | &acpi_gbl_FADT, | |
ea5d8ebc | 410 | fadt_info_table |
95befdb3 BM |
411 | [i].length), |
412 | (u64) * ACPI_ADD_PTR(u32, | |
413 | &acpi_gbl_FADT, | |
ea5d8ebc | 414 | fadt_info_table |
95befdb3 | 415 | [i]. |
4b67a0e4 | 416 | address32)); |
95befdb3 BM |
417 | } |
418 | } | |
95befdb3 BM |
419 | } |
420 | ||
ec41f193 | 421 | /******************************************************************************* |
95befdb3 BM |
422 | * |
423 | * FUNCTION: acpi_tb_validate_fadt | |
424 | * | |
ea5d8ebc | 425 | * PARAMETERS: Table - Pointer to the FADT to be validated |
95befdb3 | 426 | * |
e56b638b | 427 | * RETURN: None |
95befdb3 | 428 | * |
ea5d8ebc BM |
429 | * DESCRIPTION: Validate various important fields within the FADT. If a problem |
430 | * is found, issue a message, but no status is returned. | |
431 | * Used by both the table manager and the disassembler. | |
432 | * | |
433 | * Possible additional checks: | |
434 | * (acpi_gbl_FADT.pm1_event_length >= 4) | |
435 | * (acpi_gbl_FADT.pm1_control_length >= 2) | |
436 | * (acpi_gbl_FADT.pm_timer_length >= 4) | |
437 | * Gpe block lengths must be multiple of 2 | |
95befdb3 BM |
438 | * |
439 | ******************************************************************************/ | |
440 | ||
71392844 | 441 | static void acpi_tb_validate_fadt(void) |
95befdb3 | 442 | { |
06f55419 | 443 | char *name; |
ea5d8ebc BM |
444 | u32 *address32; |
445 | struct acpi_generic_address *address64; | |
446 | u8 length; | |
67a119f9 | 447 | u32 i; |
95befdb3 | 448 | |
06f55419 BM |
449 | /* |
450 | * Check for FACS and DSDT address mismatches. An address mismatch between | |
451 | * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and | |
452 | * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables. | |
453 | */ | |
454 | if (acpi_gbl_FADT.facs && | |
455 | (acpi_gbl_FADT.Xfacs != (u64) acpi_gbl_FADT.facs)) { | |
456 | ACPI_WARNING((AE_INFO, | |
40774f7a | 457 | "32/64X FACS address mismatch in FADT - " |
06f55419 BM |
458 | "two FACS tables! %8.8X/%8.8X%8.8X", |
459 | acpi_gbl_FADT.facs, | |
460 | ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xfacs))); | |
461 | } | |
ea5d8ebc | 462 | |
06f55419 BM |
463 | if (acpi_gbl_FADT.dsdt && |
464 | (acpi_gbl_FADT.Xdsdt != (u64) acpi_gbl_FADT.dsdt)) { | |
465 | ACPI_WARNING((AE_INFO, | |
40774f7a | 466 | "32/64X DSDT address mismatch in FADT - " |
06f55419 BM |
467 | "two DSDT tables! %8.8X/%8.8X%8.8X", |
468 | acpi_gbl_FADT.dsdt, | |
469 | ACPI_FORMAT_UINT64(acpi_gbl_FADT.Xdsdt))); | |
470 | } | |
ea5d8ebc | 471 | |
06f55419 | 472 | /* Examine all of the 64-bit extended address fields (X fields) */ |
ea5d8ebc | 473 | |
06f55419 BM |
474 | for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { |
475 | /* | |
476 | * Generate pointers to the 32-bit and 64-bit addresses, get the | |
477 | * register length (width), and the register name | |
478 | */ | |
479 | address64 = ACPI_ADD_PTR(struct acpi_generic_address, | |
480 | &acpi_gbl_FADT, | |
4b67a0e4 | 481 | fadt_info_table[i].address64); |
71392844 BM |
482 | address32 = |
483 | ACPI_ADD_PTR(u32, &acpi_gbl_FADT, | |
4b67a0e4 | 484 | fadt_info_table[i].address32); |
71392844 BM |
485 | length = |
486 | *ACPI_ADD_PTR(u8, &acpi_gbl_FADT, | |
487 | fadt_info_table[i].length); | |
06f55419 BM |
488 | name = fadt_info_table[i].name; |
489 | ||
490 | /* | |
491 | * For each extended field, check for length mismatch between the | |
4b67a0e4 | 492 | * legacy length field and the corresponding 64-bit X length field. |
06f55419 | 493 | */ |
aab61b67 BM |
494 | if (address64->address && |
495 | (address64->bit_width != ACPI_MUL_8(length))) { | |
06f55419 | 496 | ACPI_WARNING((AE_INFO, |
40774f7a | 497 | "32/64X length mismatch in %s: %d/%d", |
06f55419 BM |
498 | name, ACPI_MUL_8(length), |
499 | address64->bit_width)); | |
500 | } | |
ea5d8ebc BM |
501 | |
502 | if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) { | |
503 | /* | |
504 | * Field is required (Pm1a_event, Pm1a_control, pm_timer). | |
505 | * Both the address and length must be non-zero. | |
506 | */ | |
507 | if (!address64->address || !length) { | |
508 | ACPI_ERROR((AE_INFO, | |
ec41f193 BM |
509 | "Required field %s has zero address and/or length:" |
510 | " %8.8X%8.8X/%X", | |
06f55419 | 511 | name, |
ea5d8ebc BM |
512 | ACPI_FORMAT_UINT64(address64-> |
513 | address), | |
514 | length)); | |
515 | } | |
516 | } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) { | |
517 | /* | |
518 | * Field is optional (PM2Control, GPE0, GPE1) AND has its own | |
ec41f193 BM |
519 | * length field. If present, both the address and length must |
520 | * be valid. | |
ea5d8ebc | 521 | */ |
ec41f193 BM |
522 | if ((address64->address && !length) || |
523 | (!address64->address && length)) { | |
ea5d8ebc | 524 | ACPI_WARNING((AE_INFO, |
ec41f193 BM |
525 | "Optional field %s has zero address or length: " |
526 | "%8.8X%8.8X/%X", | |
06f55419 | 527 | name, |
ea5d8ebc BM |
528 | ACPI_FORMAT_UINT64(address64-> |
529 | address), | |
530 | length)); | |
531 | } | |
532 | } | |
95befdb3 | 533 | |
ec41f193 BM |
534 | /* |
535 | * If both 32- and 64-bit addresses are valid (non-zero), | |
536 | * they must match | |
537 | */ | |
ea5d8ebc BM |
538 | if (address64->address && *address32 && |
539 | (address64->address != (u64) * address32)) { | |
540 | ACPI_ERROR((AE_INFO, | |
40774f7a | 541 | "32/64X address mismatch in %s: %8.8X/%8.8X%8.8X, using 64X", |
06f55419 | 542 | name, *address32, |
ea5d8ebc BM |
543 | ACPI_FORMAT_UINT64(address64->address))); |
544 | } | |
95befdb3 BM |
545 | } |
546 | } | |
531c633d | 547 | |
ec41f193 | 548 | /******************************************************************************* |
531c633d BM |
549 | * |
550 | * FUNCTION: acpi_tb_setup_fadt_registers | |
551 | * | |
552 | * PARAMETERS: None, uses acpi_gbl_FADT. | |
553 | * | |
554 | * RETURN: None | |
555 | * | |
556 | * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally, | |
557 | * force FADT register definitions to their default lengths. | |
558 | * | |
559 | ******************************************************************************/ | |
560 | ||
561 | static void acpi_tb_setup_fadt_registers(void) | |
562 | { | |
563 | struct acpi_generic_address *target64; | |
564 | struct acpi_generic_address *source64; | |
565 | u8 pm1_register_byte_width; | |
566 | u32 i; | |
567 | ||
568 | /* | |
569 | * Optionally check all register lengths against the default values and | |
570 | * update them if they are incorrect. | |
571 | */ | |
572 | if (acpi_gbl_use_default_register_widths) { | |
573 | for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { | |
574 | target64 = | |
575 | ACPI_ADD_PTR(struct acpi_generic_address, | |
576 | &acpi_gbl_FADT, | |
577 | fadt_info_table[i].address64); | |
578 | ||
579 | /* | |
580 | * If a valid register (Address != 0) and the (default_length > 0) | |
581 | * (Not a GPE register), then check the width against the default. | |
582 | */ | |
583 | if ((target64->address) && | |
584 | (fadt_info_table[i].default_length > 0) && | |
585 | (fadt_info_table[i].default_length != | |
586 | target64->bit_width)) { | |
587 | ACPI_WARNING((AE_INFO, | |
588 | "Invalid length for %s: %d, using default %d", | |
589 | fadt_info_table[i].name, | |
590 | target64->bit_width, | |
591 | fadt_info_table[i]. | |
592 | default_length)); | |
593 | ||
594 | /* Incorrect size, set width to the default */ | |
595 | ||
596 | target64->bit_width = | |
597 | fadt_info_table[i].default_length; | |
598 | } | |
599 | } | |
600 | } | |
601 | ||
602 | /* | |
603 | * Get the length of the individual PM1 registers (enable and status). | |
604 | * Each register is defined to be (event block length / 2). Extra divide | |
605 | * by 8 converts bits to bytes. | |
606 | */ | |
ec41f193 BM |
607 | pm1_register_byte_width = (u8) |
608 | ACPI_DIV_16(acpi_gbl_FADT.xpm1a_event_block.bit_width); | |
531c633d BM |
609 | |
610 | /* | |
611 | * Calculate separate GAS structs for the PM1x (A/B) Status and Enable | |
612 | * registers. These addresses do not appear (directly) in the FADT, so it | |
613 | * is useful to pre-calculate them from the PM1 Event Block definitions. | |
614 | * | |
615 | * The PM event blocks are split into two register blocks, first is the | |
616 | * PM Status Register block, followed immediately by the PM Enable | |
617 | * Register block. Each is of length (pm1_event_length/2) | |
618 | * | |
619 | * Note: The PM1A event block is required by the ACPI specification. | |
620 | * However, the PM1B event block is optional and is rarely, if ever, | |
621 | * used. | |
622 | */ | |
623 | ||
624 | for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) { | |
625 | source64 = | |
626 | ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT, | |
627 | fadt_pm_info_table[i].source); | |
628 | ||
5e053e77 LM |
629 | if (source64->address) { |
630 | acpi_tb_init_generic_address(fadt_pm_info_table[i]. | |
631 | target, source64->space_id, | |
632 | pm1_register_byte_width, | |
633 | source64->address + | |
634 | (fadt_pm_info_table[i]. | |
635 | register_num * | |
636 | pm1_register_byte_width)); | |
637 | } | |
531c633d BM |
638 | } |
639 | } |