1 /****************************************************************************** 2 * 3 * Module Name: tbfadt - FADT table utilities 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, 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 #define __TBFADT_C__ 45 46 #include <contrib/dev/acpica/include/acpi.h> 47 #include <contrib/dev/acpica/include/accommon.h> 48 #include <contrib/dev/acpica/include/actables.h> 49 50 #define _COMPONENT ACPI_TABLES 51 ACPI_MODULE_NAME ("tbfadt") 52 53 /* Local prototypes */ 54 55 static void 56 AcpiTbInitGenericAddress ( 57 ACPI_GENERIC_ADDRESS *GenericAddress, 58 UINT8 SpaceId, 59 UINT8 ByteWidth, 60 UINT64 Address, 61 char *RegisterName); 62 63 static void 64 AcpiTbConvertFadt ( 65 void); 66 67 static void 68 AcpiTbValidateFadt ( 69 void); 70 71 static void 72 AcpiTbSetupFadtRegisters ( 73 void); 74 75 76 /* Table for conversion of FADT to common internal format and FADT validation */ 77 78 typedef struct acpi_fadt_info 79 { 80 char *Name; 81 UINT16 Address64; 82 UINT16 Address32; 83 UINT16 Length; 84 UINT8 DefaultLength; 85 UINT8 Type; 86 87 } ACPI_FADT_INFO; 88 89 #define ACPI_FADT_OPTIONAL 0 90 #define ACPI_FADT_REQUIRED 1 91 #define ACPI_FADT_SEPARATE_LENGTH 2 92 93 static ACPI_FADT_INFO FadtInfoTable[] = 94 { 95 {"Pm1aEventBlock", 96 ACPI_FADT_OFFSET (XPm1aEventBlock), 97 ACPI_FADT_OFFSET (Pm1aEventBlock), 98 ACPI_FADT_OFFSET (Pm1EventLength), 99 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ 100 ACPI_FADT_REQUIRED}, 101 102 {"Pm1bEventBlock", 103 ACPI_FADT_OFFSET (XPm1bEventBlock), 104 ACPI_FADT_OFFSET (Pm1bEventBlock), 105 ACPI_FADT_OFFSET (Pm1EventLength), 106 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */ 107 ACPI_FADT_OPTIONAL}, 108 109 {"Pm1aControlBlock", 110 ACPI_FADT_OFFSET (XPm1aControlBlock), 111 ACPI_FADT_OFFSET (Pm1aControlBlock), 112 ACPI_FADT_OFFSET (Pm1ControlLength), 113 ACPI_PM1_REGISTER_WIDTH, 114 ACPI_FADT_REQUIRED}, 115 116 {"Pm1bControlBlock", 117 ACPI_FADT_OFFSET (XPm1bControlBlock), 118 ACPI_FADT_OFFSET (Pm1bControlBlock), 119 ACPI_FADT_OFFSET (Pm1ControlLength), 120 ACPI_PM1_REGISTER_WIDTH, 121 ACPI_FADT_OPTIONAL}, 122 123 {"Pm2ControlBlock", 124 ACPI_FADT_OFFSET (XPm2ControlBlock), 125 ACPI_FADT_OFFSET (Pm2ControlBlock), 126 ACPI_FADT_OFFSET (Pm2ControlLength), 127 ACPI_PM2_REGISTER_WIDTH, 128 ACPI_FADT_SEPARATE_LENGTH}, 129 130 {"PmTimerBlock", 131 ACPI_FADT_OFFSET (XPmTimerBlock), 132 ACPI_FADT_OFFSET (PmTimerBlock), 133 ACPI_FADT_OFFSET (PmTimerLength), 134 ACPI_PM_TIMER_WIDTH, 135 ACPI_FADT_SEPARATE_LENGTH}, /* ACPI 5.0A: Timer is optional */ 136 137 {"Gpe0Block", 138 ACPI_FADT_OFFSET (XGpe0Block), 139 ACPI_FADT_OFFSET (Gpe0Block), 140 ACPI_FADT_OFFSET (Gpe0BlockLength), 141 0, 142 ACPI_FADT_SEPARATE_LENGTH}, 143 144 {"Gpe1Block", 145 ACPI_FADT_OFFSET (XGpe1Block), 146 ACPI_FADT_OFFSET (Gpe1Block), 147 ACPI_FADT_OFFSET (Gpe1BlockLength), 148 0, 149 ACPI_FADT_SEPARATE_LENGTH} 150 }; 151 152 #define ACPI_FADT_INFO_ENTRIES \ 153 (sizeof (FadtInfoTable) / sizeof (ACPI_FADT_INFO)) 154 155 156 /* Table used to split Event Blocks into separate status/enable registers */ 157 158 typedef struct acpi_fadt_pm_info 159 { 160 ACPI_GENERIC_ADDRESS *Target; 161 UINT16 Source; 162 UINT8 RegisterNum; 163 164 } ACPI_FADT_PM_INFO; 165 166 static ACPI_FADT_PM_INFO FadtPmInfoTable[] = 167 { 168 {&AcpiGbl_XPm1aStatus, 169 ACPI_FADT_OFFSET (XPm1aEventBlock), 170 0}, 171 172 {&AcpiGbl_XPm1aEnable, 173 ACPI_FADT_OFFSET (XPm1aEventBlock), 174 1}, 175 176 {&AcpiGbl_XPm1bStatus, 177 ACPI_FADT_OFFSET (XPm1bEventBlock), 178 0}, 179 180 {&AcpiGbl_XPm1bEnable, 181 ACPI_FADT_OFFSET (XPm1bEventBlock), 182 1} 183 }; 184 185 #define ACPI_FADT_PM_INFO_ENTRIES \ 186 (sizeof (FadtPmInfoTable) / sizeof (ACPI_FADT_PM_INFO)) 187 188 189 /******************************************************************************* 190 * 191 * FUNCTION: AcpiTbInitGenericAddress 192 * 193 * PARAMETERS: GenericAddress - GAS struct to be initialized 194 * SpaceId - ACPI Space ID for this register 195 * ByteWidth - Width of this register 196 * Address - Address of the register 197 * 198 * RETURN: None 199 * 200 * DESCRIPTION: Initialize a Generic Address Structure (GAS) 201 * See the ACPI specification for a full description and 202 * definition of this structure. 203 * 204 ******************************************************************************/ 205 206 static void 207 AcpiTbInitGenericAddress ( 208 ACPI_GENERIC_ADDRESS *GenericAddress, 209 UINT8 SpaceId, 210 UINT8 ByteWidth, 211 UINT64 Address, 212 char *RegisterName) 213 { 214 UINT8 BitWidth; 215 216 217 /* Bit width field in the GAS is only one byte long, 255 max */ 218 219 BitWidth = (UINT8) (ByteWidth * 8); 220 221 if (ByteWidth > 31) /* (31*8)=248 */ 222 { 223 ACPI_ERROR ((AE_INFO, 224 "%s - 32-bit FADT register is too long (%u bytes, %u bits) " 225 "to convert to GAS struct - 255 bits max, truncating", 226 RegisterName, ByteWidth, (ByteWidth * 8))); 227 228 BitWidth = 255; 229 } 230 231 /* 232 * The 64-bit Address field is non-aligned in the byte packed 233 * GAS struct. 234 */ 235 ACPI_MOVE_64_TO_64 (&GenericAddress->Address, &Address); 236 237 /* All other fields are byte-wide */ 238 239 GenericAddress->SpaceId = SpaceId; 240 GenericAddress->BitWidth = BitWidth; 241 GenericAddress->BitOffset = 0; 242 GenericAddress->AccessWidth = 0; /* Access width ANY */ 243 } 244 245 246 /******************************************************************************* 247 * 248 * FUNCTION: AcpiTbParseFadt 249 * 250 * PARAMETERS: TableIndex - Index for the FADT 251 * 252 * RETURN: None 253 * 254 * DESCRIPTION: Initialize the FADT, DSDT and FACS tables 255 * (FADT contains the addresses of the DSDT and FACS) 256 * 257 ******************************************************************************/ 258 259 void 260 AcpiTbParseFadt ( 261 UINT32 TableIndex) 262 { 263 UINT32 Length; 264 ACPI_TABLE_HEADER *Table; 265 266 267 /* 268 * The FADT has multiple versions with different lengths, 269 * and it contains pointers to both the DSDT and FACS tables. 270 * 271 * Get a local copy of the FADT and convert it to a common format 272 * Map entire FADT, assumed to be smaller than one page. 273 */ 274 Length = AcpiGbl_RootTableList.Tables[TableIndex].Length; 275 276 Table = AcpiOsMapMemory ( 277 AcpiGbl_RootTableList.Tables[TableIndex].Address, Length); 278 if (!Table) 279 { 280 return; 281 } 282 283 /* 284 * Validate the FADT checksum before we copy the table. Ignore 285 * checksum error as we want to try to get the DSDT and FACS. 286 */ 287 (void) AcpiTbVerifyChecksum (Table, Length); 288 289 /* Create a local copy of the FADT in common ACPI 2.0+ format */ 290 291 AcpiTbCreateLocalFadt (Table, Length); 292 293 /* All done with the real FADT, unmap it */ 294 295 AcpiOsUnmapMemory (Table, Length); 296 297 /* Obtain the DSDT and FACS tables via their addresses within the FADT */ 298 299 AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt, 300 ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT); 301 302 /* If Hardware Reduced flag is set, there is no FACS */ 303 304 if (!AcpiGbl_ReducedHardware) 305 { 306 AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs, 307 ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS); 308 } 309 } 310 311 312 /******************************************************************************* 313 * 314 * FUNCTION: AcpiTbCreateLocalFadt 315 * 316 * PARAMETERS: Table - Pointer to BIOS FADT 317 * Length - Length of the table 318 * 319 * RETURN: None 320 * 321 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format. 322 * Performs validation on some important FADT fields. 323 * 324 * NOTE: We create a local copy of the FADT regardless of the version. 325 * 326 ******************************************************************************/ 327 328 void 329 AcpiTbCreateLocalFadt ( 330 ACPI_TABLE_HEADER *Table, 331 UINT32 Length) 332 { 333 334 /* 335 * Check if the FADT is larger than the largest table that we expect 336 * (the ACPI 5.0 version). If so, truncate the table, and issue 337 * a warning. 338 */ 339 if (Length > sizeof (ACPI_TABLE_FADT)) 340 { 341 ACPI_BIOS_WARNING ((AE_INFO, 342 "FADT (revision %u) is longer than ACPI 5.0 version, " 343 "truncating length %u to %u", 344 Table->Revision, Length, (UINT32) sizeof (ACPI_TABLE_FADT))); 345 } 346 347 /* Clear the entire local FADT */ 348 349 ACPI_MEMSET (&AcpiGbl_FADT, 0, sizeof (ACPI_TABLE_FADT)); 350 351 /* Copy the original FADT, up to sizeof (ACPI_TABLE_FADT) */ 352 353 ACPI_MEMCPY (&AcpiGbl_FADT, Table, 354 ACPI_MIN (Length, sizeof (ACPI_TABLE_FADT))); 355 356 /* Take a copy of the Hardware Reduced flag */ 357 358 AcpiGbl_ReducedHardware = FALSE; 359 if (AcpiGbl_FADT.Flags & ACPI_FADT_HW_REDUCED) 360 { 361 AcpiGbl_ReducedHardware = TRUE; 362 } 363 364 /* Convert the local copy of the FADT to the common internal format */ 365 366 AcpiTbConvertFadt (); 367 368 /* Validate FADT values now, before we make any changes */ 369 370 AcpiTbValidateFadt (); 371 372 /* Initialize the global ACPI register structures */ 373 374 AcpiTbSetupFadtRegisters (); 375 } 376 377 378 /******************************************************************************* 379 * 380 * FUNCTION: AcpiTbConvertFadt 381 * 382 * PARAMETERS: None, uses AcpiGbl_FADT 383 * 384 * RETURN: None 385 * 386 * DESCRIPTION: Converts all versions of the FADT to a common internal format. 387 * Expand 32-bit addresses to 64-bit as necessary. 388 * 389 * NOTE: AcpiGbl_FADT must be of size (ACPI_TABLE_FADT), 390 * and must contain a copy of the actual FADT. 391 * 392 * Notes on 64-bit register addresses: 393 * 394 * After this FADT conversion, later ACPICA code will only use the 64-bit "X" 395 * fields of the FADT for all ACPI register addresses. 396 * 397 * The 64-bit "X" fields are optional extensions to the original 32-bit FADT 398 * V1.0 fields. Even if they are present in the FADT, they are optional and 399 * are unused if the BIOS sets them to zero. Therefore, we must copy/expand 400 * 32-bit V1.0 fields if the corresponding X field is zero. 401 * 402 * For ACPI 1.0 FADTs, all 32-bit address fields are expanded to the 403 * corresponding "X" fields in the internal FADT. 404 * 405 * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded 406 * to the corresponding 64-bit X fields. For compatibility with other ACPI 407 * implementations, we ignore the 64-bit field if the 32-bit field is valid, 408 * regardless of whether the host OS is 32-bit or 64-bit. 409 * 410 ******************************************************************************/ 411 412 static void 413 AcpiTbConvertFadt ( 414 void) 415 { 416 ACPI_GENERIC_ADDRESS *Address64; 417 UINT32 Address32; 418 UINT32 i; 419 420 421 /* 422 * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary. 423 * Later code will always use the X 64-bit field. 424 */ 425 if (!AcpiGbl_FADT.XFacs) 426 { 427 AcpiGbl_FADT.XFacs = (UINT64) AcpiGbl_FADT.Facs; 428 } 429 if (!AcpiGbl_FADT.XDsdt) 430 { 431 AcpiGbl_FADT.XDsdt = (UINT64) AcpiGbl_FADT.Dsdt; 432 } 433 434 /* 435 * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which 436 * should be zero are indeed zero. This will workaround BIOSs that 437 * inadvertently place values in these fields. 438 * 439 * The ACPI 1.0 reserved fields that will be zeroed are the bytes located 440 * at offset 45, 55, 95, and the word located at offset 109, 110. 441 * 442 * Note: The FADT revision value is unreliable. Only the length can be 443 * trusted. 444 */ 445 if (AcpiGbl_FADT.Header.Length <= ACPI_FADT_V2_SIZE) 446 { 447 AcpiGbl_FADT.PreferredProfile = 0; 448 AcpiGbl_FADT.PstateControl = 0; 449 AcpiGbl_FADT.CstControl = 0; 450 AcpiGbl_FADT.BootFlags = 0; 451 } 452 453 /* 454 * Now we can update the local FADT length to the length of the 455 * current FADT version as defined by the ACPI specification. 456 * Thus, we will have a common FADT internally. 457 */ 458 AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT); 459 460 /* 461 * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X" 462 * generic address structures as necessary. Later code will always use 463 * the 64-bit address structures. 464 * 465 * March 2009: 466 * We now always use the 32-bit address if it is valid (non-null). This 467 * is not in accordance with the ACPI specification which states that 468 * the 64-bit address supersedes the 32-bit version, but we do this for 469 * compatibility with other ACPI implementations. Most notably, in the 470 * case where both the 32 and 64 versions are non-null, we use the 32-bit 471 * version. This is the only address that is guaranteed to have been 472 * tested by the BIOS manufacturer. 473 */ 474 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) 475 { 476 Address32 = *ACPI_ADD_PTR (UINT32, 477 &AcpiGbl_FADT, FadtInfoTable[i].Address32); 478 479 Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, 480 &AcpiGbl_FADT, FadtInfoTable[i].Address64); 481 482 /* 483 * If both 32- and 64-bit addresses are valid (non-zero), 484 * they must match. 485 */ 486 if (Address64->Address && Address32 && 487 (Address64->Address != (UINT64) Address32)) 488 { 489 ACPI_BIOS_ERROR ((AE_INFO, 490 "32/64X address mismatch in FADT/%s: " 491 "0x%8.8X/0x%8.8X%8.8X, using 32", 492 FadtInfoTable[i].Name, Address32, 493 ACPI_FORMAT_UINT64 (Address64->Address))); 494 } 495 496 /* Always use 32-bit address if it is valid (non-null) */ 497 498 if (Address32) 499 { 500 /* 501 * Copy the 32-bit address to the 64-bit GAS structure. The 502 * Space ID is always I/O for 32-bit legacy address fields 503 */ 504 AcpiTbInitGenericAddress (Address64, ACPI_ADR_SPACE_SYSTEM_IO, 505 *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT, FadtInfoTable[i].Length), 506 (UINT64) Address32, FadtInfoTable[i].Name); 507 } 508 } 509 } 510 511 512 /******************************************************************************* 513 * 514 * FUNCTION: AcpiTbValidateFadt 515 * 516 * PARAMETERS: Table - Pointer to the FADT to be validated 517 * 518 * RETURN: None 519 * 520 * DESCRIPTION: Validate various important fields within the FADT. If a problem 521 * is found, issue a message, but no status is returned. 522 * Used by both the table manager and the disassembler. 523 * 524 * Possible additional checks: 525 * (AcpiGbl_FADT.Pm1EventLength >= 4) 526 * (AcpiGbl_FADT.Pm1ControlLength >= 2) 527 * (AcpiGbl_FADT.PmTimerLength >= 4) 528 * Gpe block lengths must be multiple of 2 529 * 530 ******************************************************************************/ 531 532 static void 533 AcpiTbValidateFadt ( 534 void) 535 { 536 char *Name; 537 ACPI_GENERIC_ADDRESS *Address64; 538 UINT8 Length; 539 UINT32 i; 540 541 542 /* 543 * Check for FACS and DSDT address mismatches. An address mismatch between 544 * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and 545 * DSDT/X_DSDT) would indicate the presence of two FACS or two DSDT tables. 546 */ 547 if (AcpiGbl_FADT.Facs && 548 (AcpiGbl_FADT.XFacs != (UINT64) AcpiGbl_FADT.Facs)) 549 { 550 ACPI_BIOS_WARNING ((AE_INFO, 551 "32/64X FACS address mismatch in FADT - " 552 "0x%8.8X/0x%8.8X%8.8X, using 32", 553 AcpiGbl_FADT.Facs, ACPI_FORMAT_UINT64 (AcpiGbl_FADT.XFacs))); 554 555 AcpiGbl_FADT.XFacs = (UINT64) AcpiGbl_FADT.Facs; 556 } 557 558 if (AcpiGbl_FADT.Dsdt && 559 (AcpiGbl_FADT.XDsdt != (UINT64) AcpiGbl_FADT.Dsdt)) 560 { 561 ACPI_BIOS_WARNING ((AE_INFO, 562 "32/64X DSDT address mismatch in FADT - " 563 "0x%8.8X/0x%8.8X%8.8X, using 32", 564 AcpiGbl_FADT.Dsdt, ACPI_FORMAT_UINT64 (AcpiGbl_FADT.XDsdt))); 565 566 AcpiGbl_FADT.XDsdt = (UINT64) AcpiGbl_FADT.Dsdt; 567 } 568 569 /* If Hardware Reduced flag is set, we are all done */ 570 571 if (AcpiGbl_ReducedHardware) 572 { 573 return; 574 } 575 576 /* Examine all of the 64-bit extended address fields (X fields) */ 577 578 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) 579 { 580 /* 581 * Generate pointer to the 64-bit address, get the register 582 * length (width) and the register name 583 */ 584 Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, 585 &AcpiGbl_FADT, FadtInfoTable[i].Address64); 586 Length = *ACPI_ADD_PTR (UINT8, 587 &AcpiGbl_FADT, FadtInfoTable[i].Length); 588 Name = FadtInfoTable[i].Name; 589 590 /* 591 * For each extended field, check for length mismatch between the 592 * legacy length field and the corresponding 64-bit X length field. 593 * Note: If the legacy length field is > 0xFF bits, ignore this 594 * check. (GPE registers can be larger than the 64-bit GAS structure 595 * can accomodate, 0xFF bits). 596 */ 597 if (Address64->Address && 598 (ACPI_MUL_8 (Length) <= ACPI_UINT8_MAX) && 599 (Address64->BitWidth != ACPI_MUL_8 (Length))) 600 { 601 ACPI_BIOS_WARNING ((AE_INFO, 602 "32/64X length mismatch in FADT/%s: %u/%u", 603 Name, ACPI_MUL_8 (Length), Address64->BitWidth)); 604 } 605 606 if (FadtInfoTable[i].Type & ACPI_FADT_REQUIRED) 607 { 608 /* 609 * Field is required (PM1aEvent, PM1aControl). 610 * Both the address and length must be non-zero. 611 */ 612 if (!Address64->Address || !Length) 613 { 614 ACPI_BIOS_ERROR ((AE_INFO, 615 "Required FADT field %s has zero address and/or length: " 616 "0x%8.8X%8.8X/0x%X", 617 Name, ACPI_FORMAT_UINT64 (Address64->Address), Length)); 618 } 619 } 620 else if (FadtInfoTable[i].Type & ACPI_FADT_SEPARATE_LENGTH) 621 { 622 /* 623 * Field is optional (PM2Control, GPE0, GPE1) AND has its own 624 * length field. If present, both the address and length must 625 * be valid. 626 */ 627 if ((Address64->Address && !Length) || 628 (!Address64->Address && Length)) 629 { 630 ACPI_BIOS_WARNING ((AE_INFO, 631 "Optional FADT field %s has zero address or length: " 632 "0x%8.8X%8.8X/0x%X", 633 Name, ACPI_FORMAT_UINT64 (Address64->Address), Length)); 634 } 635 } 636 } 637 } 638 639 640 /******************************************************************************* 641 * 642 * FUNCTION: AcpiTbSetupFadtRegisters 643 * 644 * PARAMETERS: None, uses AcpiGbl_FADT. 645 * 646 * RETURN: None 647 * 648 * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally, 649 * force FADT register definitions to their default lengths. 650 * 651 ******************************************************************************/ 652 653 static void 654 AcpiTbSetupFadtRegisters ( 655 void) 656 { 657 ACPI_GENERIC_ADDRESS *Target64; 658 ACPI_GENERIC_ADDRESS *Source64; 659 UINT8 Pm1RegisterByteWidth; 660 UINT32 i; 661 662 663 /* 664 * Optionally check all register lengths against the default values and 665 * update them if they are incorrect. 666 */ 667 if (AcpiGbl_UseDefaultRegisterWidths) 668 { 669 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) 670 { 671 Target64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT, 672 FadtInfoTable[i].Address64); 673 674 /* 675 * If a valid register (Address != 0) and the (DefaultLength > 0) 676 * (Not a GPE register), then check the width against the default. 677 */ 678 if ((Target64->Address) && 679 (FadtInfoTable[i].DefaultLength > 0) && 680 (FadtInfoTable[i].DefaultLength != Target64->BitWidth)) 681 { 682 ACPI_BIOS_WARNING ((AE_INFO, 683 "Invalid length for FADT/%s: %u, using default %u", 684 FadtInfoTable[i].Name, Target64->BitWidth, 685 FadtInfoTable[i].DefaultLength)); 686 687 /* Incorrect size, set width to the default */ 688 689 Target64->BitWidth = FadtInfoTable[i].DefaultLength; 690 } 691 } 692 } 693 694 /* 695 * Get the length of the individual PM1 registers (enable and status). 696 * Each register is defined to be (event block length / 2). Extra divide 697 * by 8 converts bits to bytes. 698 */ 699 Pm1RegisterByteWidth = (UINT8) 700 ACPI_DIV_16 (AcpiGbl_FADT.XPm1aEventBlock.BitWidth); 701 702 /* 703 * Calculate separate GAS structs for the PM1x (A/B) Status and Enable 704 * registers. These addresses do not appear (directly) in the FADT, so it 705 * is useful to pre-calculate them from the PM1 Event Block definitions. 706 * 707 * The PM event blocks are split into two register blocks, first is the 708 * PM Status Register block, followed immediately by the PM Enable 709 * Register block. Each is of length (Pm1EventLength/2) 710 * 711 * Note: The PM1A event block is required by the ACPI specification. 712 * However, the PM1B event block is optional and is rarely, if ever, 713 * used. 714 */ 715 716 for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) 717 { 718 Source64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT, 719 FadtPmInfoTable[i].Source); 720 721 if (Source64->Address) 722 { 723 AcpiTbInitGenericAddress (FadtPmInfoTable[i].Target, 724 Source64->SpaceId, Pm1RegisterByteWidth, 725 Source64->Address + 726 (FadtPmInfoTable[i].RegisterNum * Pm1RegisterByteWidth), 727 "PmRegisters"); 728 } 729 } 730 } 731