1 /****************************************************************************** 2 * 3 * Module Name: tbfadt - FADT table utilities 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2016, Intel Corp. 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> 45 #include "accommon.h" 46 #include "actables.h" 47 48 #define _COMPONENT ACPI_TABLES 49 ACPI_MODULE_NAME("tbfadt") 50 51 /* Local prototypes */ 52 static void 53 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address, 54 u8 space_id, 55 u8 byte_width, 56 u64 address, const char *register_name, u8 flags); 57 58 static void acpi_tb_convert_fadt(void); 59 60 static void acpi_tb_setup_fadt_registers(void); 61 62 static u64 63 acpi_tb_select_address(char *register_name, u32 address32, u64 address64); 64 65 /* Table for conversion of FADT to common internal format and FADT validation */ 66 67 typedef struct acpi_fadt_info { 68 const char *name; 69 u16 address64; 70 u16 address32; 71 u16 length; 72 u8 default_length; 73 u8 flags; 74 75 } acpi_fadt_info; 76 77 #define ACPI_FADT_OPTIONAL 0 78 #define ACPI_FADT_REQUIRED 1 79 #define ACPI_FADT_SEPARATE_LENGTH 2 80 #define ACPI_FADT_GPE_REGISTER 4 81 82 static struct acpi_fadt_info fadt_info_table[] = { 83 {"Pm1aEventBlock", 84 ACPI_FADT_OFFSET(xpm1a_event_block), 85 ACPI_FADT_OFFSET(pm1a_event_block), 86 ACPI_FADT_OFFSET(pm1_event_length), 87 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ 88 ACPI_FADT_REQUIRED}, 89 90 {"Pm1bEventBlock", 91 ACPI_FADT_OFFSET(xpm1b_event_block), 92 ACPI_FADT_OFFSET(pm1b_event_block), 93 ACPI_FADT_OFFSET(pm1_event_length), 94 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ 95 ACPI_FADT_OPTIONAL}, 96 97 {"Pm1aControlBlock", 98 ACPI_FADT_OFFSET(xpm1a_control_block), 99 ACPI_FADT_OFFSET(pm1a_control_block), 100 ACPI_FADT_OFFSET(pm1_control_length), 101 ACPI_PM1_REGISTER_WIDTH, 102 ACPI_FADT_REQUIRED}, 103 104 {"Pm1bControlBlock", 105 ACPI_FADT_OFFSET(xpm1b_control_block), 106 ACPI_FADT_OFFSET(pm1b_control_block), 107 ACPI_FADT_OFFSET(pm1_control_length), 108 ACPI_PM1_REGISTER_WIDTH, 109 ACPI_FADT_OPTIONAL}, 110 111 {"Pm2ControlBlock", 112 ACPI_FADT_OFFSET(xpm2_control_block), 113 ACPI_FADT_OFFSET(pm2_control_block), 114 ACPI_FADT_OFFSET(pm2_control_length), 115 ACPI_PM2_REGISTER_WIDTH, 116 ACPI_FADT_SEPARATE_LENGTH}, 117 118 {"PmTimerBlock", 119 ACPI_FADT_OFFSET(xpm_timer_block), 120 ACPI_FADT_OFFSET(pm_timer_block), 121 ACPI_FADT_OFFSET(pm_timer_length), 122 ACPI_PM_TIMER_WIDTH, 123 ACPI_FADT_SEPARATE_LENGTH}, /* ACPI 5.0A: Timer is optional */ 124 125 {"Gpe0Block", 126 ACPI_FADT_OFFSET(xgpe0_block), 127 ACPI_FADT_OFFSET(gpe0_block), 128 ACPI_FADT_OFFSET(gpe0_block_length), 129 0, 130 ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER}, 131 132 {"Gpe1Block", 133 ACPI_FADT_OFFSET(xgpe1_block), 134 ACPI_FADT_OFFSET(gpe1_block), 135 ACPI_FADT_OFFSET(gpe1_block_length), 136 0, 137 ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER} 138 }; 139 140 #define ACPI_FADT_INFO_ENTRIES \ 141 (sizeof (fadt_info_table) / sizeof (struct acpi_fadt_info)) 142 143 /* Table used to split Event Blocks into separate status/enable registers */ 144 145 typedef struct acpi_fadt_pm_info { 146 struct acpi_generic_address *target; 147 u16 source; 148 u8 register_num; 149 150 } acpi_fadt_pm_info; 151 152 static struct acpi_fadt_pm_info fadt_pm_info_table[] = { 153 {&acpi_gbl_xpm1a_status, 154 ACPI_FADT_OFFSET(xpm1a_event_block), 155 0}, 156 157 {&acpi_gbl_xpm1a_enable, 158 ACPI_FADT_OFFSET(xpm1a_event_block), 159 1}, 160 161 {&acpi_gbl_xpm1b_status, 162 ACPI_FADT_OFFSET(xpm1b_event_block), 163 0}, 164 165 {&acpi_gbl_xpm1b_enable, 166 ACPI_FADT_OFFSET(xpm1b_event_block), 167 1} 168 }; 169 170 #define ACPI_FADT_PM_INFO_ENTRIES \ 171 (sizeof (fadt_pm_info_table) / sizeof (struct acpi_fadt_pm_info)) 172 173 /******************************************************************************* 174 * 175 * FUNCTION: acpi_tb_init_generic_address 176 * 177 * PARAMETERS: generic_address - GAS struct to be initialized 178 * space_id - ACPI Space ID for this register 179 * byte_width - Width of this register 180 * address - Address of the register 181 * register_name - ASCII name of the ACPI register 182 * 183 * RETURN: None 184 * 185 * DESCRIPTION: Initialize a Generic Address Structure (GAS) 186 * See the ACPI specification for a full description and 187 * definition of this structure. 188 * 189 ******************************************************************************/ 190 191 static void 192 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address, 193 u8 space_id, 194 u8 byte_width, 195 u64 address, const char *register_name, u8 flags) 196 { 197 u8 bit_width; 198 199 /* 200 * Bit width field in the GAS is only one byte long, 255 max. 201 * Check for bit_width overflow in GAS. 202 */ 203 bit_width = (u8)(byte_width * 8); 204 if (byte_width > 31) { /* (31*8)=248, (32*8)=256 */ 205 /* 206 * No error for GPE blocks, because we do not use the bit_width 207 * for GPEs, the legacy length (byte_width) is used instead to 208 * allow for a large number of GPEs. 209 */ 210 if (!(flags & ACPI_FADT_GPE_REGISTER)) { 211 ACPI_ERROR((AE_INFO, 212 "%s - 32-bit FADT register is too long (%u bytes, %u bits) " 213 "to convert to GAS struct - 255 bits max, truncating", 214 register_name, byte_width, 215 (byte_width * 8))); 216 } 217 218 bit_width = 255; 219 } 220 221 /* 222 * The 64-bit Address field is non-aligned in the byte packed 223 * GAS struct. 224 */ 225 ACPI_MOVE_64_TO_64(&generic_address->address, &address); 226 227 /* All other fields are byte-wide */ 228 229 generic_address->space_id = space_id; 230 generic_address->bit_width = bit_width; 231 generic_address->bit_offset = 0; 232 generic_address->access_width = 0; /* Access width ANY */ 233 } 234 235 /******************************************************************************* 236 * 237 * FUNCTION: acpi_tb_select_address 238 * 239 * PARAMETERS: register_name - ASCII name of the ACPI register 240 * address32 - 32-bit address of the register 241 * address64 - 64-bit address of the register 242 * 243 * RETURN: The resolved 64-bit address 244 * 245 * DESCRIPTION: Select between 32-bit and 64-bit versions of addresses within 246 * the FADT. Used for the FACS and DSDT addresses. 247 * 248 * NOTES: 249 * 250 * Check for FACS and DSDT address mismatches. An address mismatch between 251 * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and 252 * DSDT/X_DSDT) could be a corrupted address field or it might indicate 253 * the presence of two FACS or two DSDT tables. 254 * 255 * November 2013: 256 * By default, as per the ACPICA specification, a valid 64-bit address is 257 * used regardless of the value of the 32-bit address. However, this 258 * behavior can be overridden via the acpi_gbl_use32_bit_fadt_addresses flag. 259 * 260 ******************************************************************************/ 261 262 static u64 263 acpi_tb_select_address(char *register_name, u32 address32, u64 address64) 264 { 265 266 if (!address64) { 267 268 /* 64-bit address is zero, use 32-bit address */ 269 270 return ((u64)address32); 271 } 272 273 if (address32 && (address64 != (u64)address32)) { 274 275 /* Address mismatch between 32-bit and 64-bit versions */ 276 277 ACPI_BIOS_WARNING((AE_INFO, 278 "32/64X %s address mismatch in FADT: " 279 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address", 280 register_name, address32, 281 ACPI_FORMAT_UINT64(address64), 282 acpi_gbl_use32_bit_fadt_addresses ? 32 : 283 64)); 284 285 /* 32-bit address override */ 286 287 if (acpi_gbl_use32_bit_fadt_addresses) { 288 return ((u64)address32); 289 } 290 } 291 292 /* Default is to use the 64-bit address */ 293 294 return (address64); 295 } 296 297 /******************************************************************************* 298 * 299 * FUNCTION: acpi_tb_parse_fadt 300 * 301 * PARAMETERS: None 302 * 303 * RETURN: None 304 * 305 * DESCRIPTION: Initialize the FADT, DSDT and FACS tables 306 * (FADT contains the addresses of the DSDT and FACS) 307 * 308 ******************************************************************************/ 309 310 void acpi_tb_parse_fadt(void) 311 { 312 u32 length; 313 struct acpi_table_header *table; 314 315 /* 316 * The FADT has multiple versions with different lengths, 317 * and it contains pointers to both the DSDT and FACS tables. 318 * 319 * Get a local copy of the FADT and convert it to a common format 320 * Map entire FADT, assumed to be smaller than one page. 321 */ 322 length = acpi_gbl_root_table_list.tables[acpi_gbl_fadt_index].length; 323 324 table = 325 acpi_os_map_memory(acpi_gbl_root_table_list. 326 tables[acpi_gbl_fadt_index].address, length); 327 if (!table) { 328 return; 329 } 330 331 /* 332 * Validate the FADT checksum before we copy the table. Ignore 333 * checksum error as we want to try to get the DSDT and FACS. 334 */ 335 (void)acpi_tb_verify_checksum(table, length); 336 337 /* Create a local copy of the FADT in common ACPI 2.0+ format */ 338 339 acpi_tb_create_local_fadt(table, length); 340 341 /* All done with the real FADT, unmap it */ 342 343 acpi_os_unmap_memory(table, length); 344 345 /* Obtain the DSDT and FACS tables via their addresses within the FADT */ 346 347 acpi_tb_install_standard_table((acpi_physical_address)acpi_gbl_FADT. 348 Xdsdt, 349 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, 350 FALSE, TRUE, &acpi_gbl_dsdt_index); 351 352 /* If Hardware Reduced flag is set, there is no FACS */ 353 354 if (!acpi_gbl_reduced_hardware) { 355 if (acpi_gbl_FADT.facs) { 356 acpi_tb_install_standard_table((acpi_physical_address) 357 acpi_gbl_FADT.facs, 358 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, 359 FALSE, TRUE, 360 &acpi_gbl_facs_index); 361 } 362 if (acpi_gbl_FADT.Xfacs) { 363 acpi_tb_install_standard_table((acpi_physical_address) 364 acpi_gbl_FADT.Xfacs, 365 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL, 366 FALSE, TRUE, 367 &acpi_gbl_xfacs_index); 368 } 369 } 370 } 371 372 /******************************************************************************* 373 * 374 * FUNCTION: acpi_tb_create_local_fadt 375 * 376 * PARAMETERS: table - Pointer to BIOS FADT 377 * length - Length of the table 378 * 379 * RETURN: None 380 * 381 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format. 382 * Performs validation on some important FADT fields. 383 * 384 * NOTE: We create a local copy of the FADT regardless of the version. 385 * 386 ******************************************************************************/ 387 388 void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length) 389 { 390 /* 391 * Check if the FADT is larger than the largest table that we expect 392 * (typically the current ACPI specification version). If so, truncate 393 * the table, and issue a warning. 394 */ 395 if (length > sizeof(struct acpi_table_fadt)) { 396 ACPI_BIOS_WARNING((AE_INFO, 397 "FADT (revision %u) is longer than %s length, " 398 "truncating length %u to %u", 399 table->revision, ACPI_FADT_CONFORMANCE, 400 length, 401 (u32)sizeof(struct acpi_table_fadt))); 402 } 403 404 /* Clear the entire local FADT */ 405 406 memset(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt)); 407 408 /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */ 409 410 memcpy(&acpi_gbl_FADT, table, 411 ACPI_MIN(length, sizeof(struct acpi_table_fadt))); 412 413 /* Take a copy of the Hardware Reduced flag */ 414 415 acpi_gbl_reduced_hardware = FALSE; 416 if (acpi_gbl_FADT.flags & ACPI_FADT_HW_REDUCED) { 417 acpi_gbl_reduced_hardware = TRUE; 418 } 419 420 /* Convert the local copy of the FADT to the common internal format */ 421 422 acpi_tb_convert_fadt(); 423 424 /* Initialize the global ACPI register structures */ 425 426 acpi_tb_setup_fadt_registers(); 427 } 428 429 /******************************************************************************* 430 * 431 * FUNCTION: acpi_tb_convert_fadt 432 * 433 * PARAMETERS: none - acpi_gbl_FADT is used. 434 * 435 * RETURN: None 436 * 437 * DESCRIPTION: Converts all versions of the FADT to a common internal format. 438 * Expand 32-bit addresses to 64-bit as necessary. Also validate 439 * important fields within the FADT. 440 * 441 * NOTE: acpi_gbl_FADT must be of size (struct acpi_table_fadt), and must 442 * contain a copy of the actual BIOS-provided FADT. 443 * 444 * Notes on 64-bit register addresses: 445 * 446 * After this FADT conversion, later ACPICA code will only use the 64-bit "X" 447 * fields of the FADT for all ACPI register addresses. 448 * 449 * The 64-bit X fields are optional extensions to the original 32-bit FADT 450 * V1.0 fields. Even if they are present in the FADT, they are optional and 451 * are unused if the BIOS sets them to zero. Therefore, we must copy/expand 452 * 32-bit V1.0 fields to the 64-bit X fields if the the 64-bit X field is 453 * originally zero. 454 * 455 * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address 456 * fields are expanded to the corresponding 64-bit X fields in the internal 457 * common FADT. 458 * 459 * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded 460 * to the corresponding 64-bit X fields, if the 64-bit field is originally 461 * zero. Adhering to the ACPI specification, we completely ignore the 32-bit 462 * field if the 64-bit field is valid, regardless of whether the host OS is 463 * 32-bit or 64-bit. 464 * 465 * Possible additional checks: 466 * (acpi_gbl_FADT.pm1_event_length >= 4) 467 * (acpi_gbl_FADT.pm1_control_length >= 2) 468 * (acpi_gbl_FADT.pm_timer_length >= 4) 469 * Gpe block lengths must be multiple of 2 470 * 471 ******************************************************************************/ 472 473 static void acpi_tb_convert_fadt(void) 474 { 475 const char *name; 476 struct acpi_generic_address *address64; 477 u32 address32; 478 u8 length; 479 u8 flags; 480 u32 i; 481 482 /* 483 * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which 484 * should be zero are indeed zero. This will workaround BIOSs that 485 * inadvertently place values in these fields. 486 * 487 * The ACPI 1.0 reserved fields that will be zeroed are the bytes located 488 * at offset 45, 55, 95, and the word located at offset 109, 110. 489 * 490 * Note: The FADT revision value is unreliable. Only the length can be 491 * trusted. 492 */ 493 if (acpi_gbl_FADT.header.length <= ACPI_FADT_V2_SIZE) { 494 acpi_gbl_FADT.preferred_profile = 0; 495 acpi_gbl_FADT.pstate_control = 0; 496 acpi_gbl_FADT.cst_control = 0; 497 acpi_gbl_FADT.boot_flags = 0; 498 } 499 500 /* 501 * Now we can update the local FADT length to the length of the 502 * current FADT version as defined by the ACPI specification. 503 * Thus, we will have a common FADT internally. 504 */ 505 acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt); 506 507 /* 508 * Expand the 32-bit DSDT addresses to 64-bit as necessary. 509 * Later ACPICA code will always use the X 64-bit field. 510 */ 511 acpi_gbl_FADT.Xdsdt = acpi_tb_select_address("DSDT", 512 acpi_gbl_FADT.dsdt, 513 acpi_gbl_FADT.Xdsdt); 514 515 /* If Hardware Reduced flag is set, we are all done */ 516 517 if (acpi_gbl_reduced_hardware) { 518 return; 519 } 520 521 /* Examine all of the 64-bit extended address fields (X fields) */ 522 523 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { 524 /* 525 * Get the 32-bit and 64-bit addresses, as well as the register 526 * length and register name. 527 */ 528 address32 = *ACPI_ADD_PTR(u32, 529 &acpi_gbl_FADT, 530 fadt_info_table[i].address32); 531 532 address64 = ACPI_ADD_PTR(struct acpi_generic_address, 533 &acpi_gbl_FADT, 534 fadt_info_table[i].address64); 535 536 length = *ACPI_ADD_PTR(u8, 537 &acpi_gbl_FADT, 538 fadt_info_table[i].length); 539 540 name = fadt_info_table[i].name; 541 flags = fadt_info_table[i].flags; 542 543 /* 544 * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X" 545 * generic address structures as necessary. Later code will always use 546 * the 64-bit address structures. 547 * 548 * November 2013: 549 * Now always use the 64-bit address if it is valid (non-zero), in 550 * accordance with the ACPI specification which states that a 64-bit 551 * address supersedes the 32-bit version. This behavior can be 552 * overridden by the acpi_gbl_use32_bit_fadt_addresses flag. 553 * 554 * During 64-bit address construction and verification, 555 * these cases are handled: 556 * 557 * Address32 zero, Address64 [don't care] - Use Address64 558 * 559 * No override: if acpi_gbl_use32_bit_fadt_addresses is FALSE, and: 560 * Address32 non-zero, Address64 zero - Copy/use Address32 561 * Address32 non-zero == Address64 non-zero - Use Address64 562 * Address32 non-zero != Address64 non-zero - Warning, use Address64 563 * 564 * Override: if acpi_gbl_use32_bit_fadt_addresses is TRUE, and: 565 * Address32 non-zero, Address64 zero - Copy/use Address32 566 * Address32 non-zero == Address64 non-zero - Copy/use Address32 567 * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32 568 * 569 * Note: space_id is always I/O for 32-bit legacy address fields 570 */ 571 if (address32) { 572 if (address64->address) { 573 if (address64->address != (u64)address32) { 574 575 /* Address mismatch */ 576 577 ACPI_BIOS_WARNING((AE_INFO, 578 "32/64X address mismatch in FADT/%s: " 579 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address", 580 name, address32, 581 ACPI_FORMAT_UINT64 582 (address64->address), 583 acpi_gbl_use32_bit_fadt_addresses 584 ? 32 : 64)); 585 } 586 587 /* 588 * For each extended field, check for length mismatch 589 * between the legacy length field and the corresponding 590 * 64-bit X length field. 591 * Note: If the legacy length field is > 0xFF bits, ignore 592 * this check. (GPE registers can be larger than the 593 * 64-bit GAS structure can accomodate, 0xFF bits). 594 */ 595 if ((ACPI_MUL_8(length) <= ACPI_UINT8_MAX) && 596 (address64->bit_width != 597 ACPI_MUL_8(length))) { 598 ACPI_BIOS_WARNING((AE_INFO, 599 "32/64X length mismatch in FADT/%s: %u/%u", 600 name, 601 ACPI_MUL_8(length), 602 address64-> 603 bit_width)); 604 } 605 } 606 607 /* 608 * Hardware register access code always uses the 64-bit fields. 609 * So if the 64-bit field is zero or is to be overridden, 610 * initialize it with the 32-bit fields. 611 * Note that when the 32-bit address favor is specified, the 612 * 64-bit fields are always re-initialized so that 613 * access_size/bit_width/bit_offset fields can be correctly 614 * configured to the values to trigger a 32-bit compatible 615 * access mode in the hardware register access code. 616 */ 617 if (!address64->address 618 || acpi_gbl_use32_bit_fadt_addresses) { 619 acpi_tb_init_generic_address(address64, 620 ACPI_ADR_SPACE_SYSTEM_IO, 621 length, 622 (u64)address32, 623 name, flags); 624 } 625 } 626 627 if (fadt_info_table[i].flags & ACPI_FADT_REQUIRED) { 628 /* 629 * Field is required (Pm1a_event, Pm1a_control). 630 * Both the address and length must be non-zero. 631 */ 632 if (!address64->address || !length) { 633 ACPI_BIOS_ERROR((AE_INFO, 634 "Required FADT field %s has zero address and/or length: " 635 "0x%8.8X%8.8X/0x%X", 636 name, 637 ACPI_FORMAT_UINT64(address64-> 638 address), 639 length)); 640 } 641 } else if (fadt_info_table[i].flags & ACPI_FADT_SEPARATE_LENGTH) { 642 /* 643 * Field is optional (Pm2_control, GPE0, GPE1) AND has its own 644 * length field. If present, both the address and length must 645 * be valid. 646 */ 647 if ((address64->address && !length) || 648 (!address64->address && length)) { 649 ACPI_BIOS_WARNING((AE_INFO, 650 "Optional FADT field %s has valid %s but zero %s: " 651 "0x%8.8X%8.8X/0x%X", name, 652 (length ? "Length" : 653 "Address"), 654 (length ? "Address" : 655 "Length"), 656 ACPI_FORMAT_UINT64 657 (address64->address), 658 length)); 659 } 660 } 661 } 662 } 663 664 /******************************************************************************* 665 * 666 * FUNCTION: acpi_tb_setup_fadt_registers 667 * 668 * PARAMETERS: None, uses acpi_gbl_FADT. 669 * 670 * RETURN: None 671 * 672 * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally, 673 * force FADT register definitions to their default lengths. 674 * 675 ******************************************************************************/ 676 677 static void acpi_tb_setup_fadt_registers(void) 678 { 679 struct acpi_generic_address *target64; 680 struct acpi_generic_address *source64; 681 u8 pm1_register_byte_width; 682 u32 i; 683 684 /* 685 * Optionally check all register lengths against the default values and 686 * update them if they are incorrect. 687 */ 688 if (acpi_gbl_use_default_register_widths) { 689 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { 690 target64 = 691 ACPI_ADD_PTR(struct acpi_generic_address, 692 &acpi_gbl_FADT, 693 fadt_info_table[i].address64); 694 695 /* 696 * If a valid register (Address != 0) and the (default_length > 0) 697 * (Not a GPE register), then check the width against the default. 698 */ 699 if ((target64->address) && 700 (fadt_info_table[i].default_length > 0) && 701 (fadt_info_table[i].default_length != 702 target64->bit_width)) { 703 ACPI_BIOS_WARNING((AE_INFO, 704 "Invalid length for FADT/%s: %u, using default %u", 705 fadt_info_table[i].name, 706 target64->bit_width, 707 fadt_info_table[i]. 708 default_length)); 709 710 /* Incorrect size, set width to the default */ 711 712 target64->bit_width = 713 fadt_info_table[i].default_length; 714 } 715 } 716 } 717 718 /* 719 * Get the length of the individual PM1 registers (enable and status). 720 * Each register is defined to be (event block length / 2). Extra divide 721 * by 8 converts bits to bytes. 722 */ 723 pm1_register_byte_width = (u8) 724 ACPI_DIV_16(acpi_gbl_FADT.xpm1a_event_block.bit_width); 725 726 /* 727 * Calculate separate GAS structs for the PM1x (A/B) Status and Enable 728 * registers. These addresses do not appear (directly) in the FADT, so it 729 * is useful to pre-calculate them from the PM1 Event Block definitions. 730 * 731 * The PM event blocks are split into two register blocks, first is the 732 * PM Status Register block, followed immediately by the PM Enable 733 * Register block. Each is of length (pm1_event_length/2) 734 * 735 * Note: The PM1A event block is required by the ACPI specification. 736 * However, the PM1B event block is optional and is rarely, if ever, 737 * used. 738 */ 739 740 for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) { 741 source64 = 742 ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT, 743 fadt_pm_info_table[i].source); 744 745 if (source64->address) { 746 acpi_tb_init_generic_address(fadt_pm_info_table[i]. 747 target, source64->space_id, 748 pm1_register_byte_width, 749 source64->address + 750 (fadt_pm_info_table[i]. 751 register_num * 752 pm1_register_byte_width), 753 "PmRegisters", 0); 754 } 755 } 756 } 757