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