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