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 #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, 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 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, 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: table_index - Index for the FADT 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(u32 table_index) 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[table_index].length; 323 324 table = 325 acpi_os_map_memory(acpi_gbl_root_table_list.tables[table_index]. 326 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_fixed_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt, 348 ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT); 349 350 /* If Hardware Reduced flag is set, there is no FACS */ 351 352 if (!acpi_gbl_reduced_hardware) { 353 acpi_tb_install_fixed_table((acpi_physical_address) 354 acpi_gbl_FADT.Xfacs, ACPI_SIG_FACS, 355 ACPI_TABLE_INDEX_FACS); 356 } 357 } 358 359 /******************************************************************************* 360 * 361 * FUNCTION: acpi_tb_create_local_fadt 362 * 363 * PARAMETERS: table - Pointer to BIOS FADT 364 * length - Length of the table 365 * 366 * RETURN: None 367 * 368 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format. 369 * Performs validation on some important FADT fields. 370 * 371 * NOTE: We create a local copy of the FADT regardless of the version. 372 * 373 ******************************************************************************/ 374 375 void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length) 376 { 377 /* 378 * Check if the FADT is larger than the largest table that we expect 379 * (the ACPI 5.0 version). If so, truncate the table, and issue 380 * a warning. 381 */ 382 if (length > sizeof(struct acpi_table_fadt)) { 383 ACPI_BIOS_WARNING((AE_INFO, 384 "FADT (revision %u) is longer than ACPI 5.0 version, " 385 "truncating length %u to %u", 386 table->revision, length, 387 (u32)sizeof(struct acpi_table_fadt))); 388 } 389 390 /* Clear the entire local FADT */ 391 392 ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt)); 393 394 /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */ 395 396 ACPI_MEMCPY(&acpi_gbl_FADT, table, 397 ACPI_MIN(length, sizeof(struct acpi_table_fadt))); 398 399 /* Take a copy of the Hardware Reduced flag */ 400 401 acpi_gbl_reduced_hardware = FALSE; 402 if (acpi_gbl_FADT.flags & ACPI_FADT_HW_REDUCED) { 403 acpi_gbl_reduced_hardware = TRUE; 404 } 405 406 /* Convert the local copy of the FADT to the common internal format */ 407 408 acpi_tb_convert_fadt(); 409 410 /* Initialize the global ACPI register structures */ 411 412 acpi_tb_setup_fadt_registers(); 413 } 414 415 /******************************************************************************* 416 * 417 * FUNCTION: acpi_tb_convert_fadt 418 * 419 * PARAMETERS: none - acpi_gbl_FADT is used. 420 * 421 * RETURN: None 422 * 423 * DESCRIPTION: Converts all versions of the FADT to a common internal format. 424 * Expand 32-bit addresses to 64-bit as necessary. Also validate 425 * important fields within the FADT. 426 * 427 * NOTE: acpi_gbl_FADT must be of size (struct acpi_table_fadt), and must 428 * contain a copy of the actual BIOS-provided FADT. 429 * 430 * Notes on 64-bit register addresses: 431 * 432 * After this FADT conversion, later ACPICA code will only use the 64-bit "X" 433 * fields of the FADT for all ACPI register addresses. 434 * 435 * The 64-bit X fields are optional extensions to the original 32-bit FADT 436 * V1.0 fields. Even if they are present in the FADT, they are optional and 437 * are unused if the BIOS sets them to zero. Therefore, we must copy/expand 438 * 32-bit V1.0 fields to the 64-bit X fields if the the 64-bit X field is 439 * originally zero. 440 * 441 * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address 442 * fields are expanded to the corresponding 64-bit X fields in the internal 443 * common FADT. 444 * 445 * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded 446 * to the corresponding 64-bit X fields, if the 64-bit field is originally 447 * zero. Adhering to the ACPI specification, we completely ignore the 32-bit 448 * field if the 64-bit field is valid, regardless of whether the host OS is 449 * 32-bit or 64-bit. 450 * 451 * Possible additional checks: 452 * (acpi_gbl_FADT.pm1_event_length >= 4) 453 * (acpi_gbl_FADT.pm1_control_length >= 2) 454 * (acpi_gbl_FADT.pm_timer_length >= 4) 455 * Gpe block lengths must be multiple of 2 456 * 457 ******************************************************************************/ 458 459 static void acpi_tb_convert_fadt(void) 460 { 461 char *name; 462 struct acpi_generic_address *address64; 463 u32 address32; 464 u8 length; 465 u8 flags; 466 u32 i; 467 468 /* 469 * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which 470 * should be zero are indeed zero. This will workaround BIOSs that 471 * inadvertently place values in these fields. 472 * 473 * The ACPI 1.0 reserved fields that will be zeroed are the bytes located 474 * at offset 45, 55, 95, and the word located at offset 109, 110. 475 * 476 * Note: The FADT revision value is unreliable. Only the length can be 477 * trusted. 478 */ 479 if (acpi_gbl_FADT.header.length <= ACPI_FADT_V2_SIZE) { 480 acpi_gbl_FADT.preferred_profile = 0; 481 acpi_gbl_FADT.pstate_control = 0; 482 acpi_gbl_FADT.cst_control = 0; 483 acpi_gbl_FADT.boot_flags = 0; 484 } 485 486 /* 487 * Now we can update the local FADT length to the length of the 488 * current FADT version as defined by the ACPI specification. 489 * Thus, we will have a common FADT internally. 490 */ 491 acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt); 492 493 /* 494 * Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary. 495 * Later ACPICA code will always use the X 64-bit field. 496 */ 497 acpi_gbl_FADT.Xfacs = acpi_tb_select_address("FACS", 498 acpi_gbl_FADT.facs, 499 acpi_gbl_FADT.Xfacs); 500 501 acpi_gbl_FADT.Xdsdt = acpi_tb_select_address("DSDT", 502 acpi_gbl_FADT.dsdt, 503 acpi_gbl_FADT.Xdsdt); 504 505 /* If Hardware Reduced flag is set, we are all done */ 506 507 if (acpi_gbl_reduced_hardware) { 508 return; 509 } 510 511 /* Examine all of the 64-bit extended address fields (X fields) */ 512 513 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { 514 /* 515 * Get the 32-bit and 64-bit addresses, as well as the register 516 * length and register name. 517 */ 518 address32 = *ACPI_ADD_PTR(u32, 519 &acpi_gbl_FADT, 520 fadt_info_table[i].address32); 521 522 address64 = ACPI_ADD_PTR(struct acpi_generic_address, 523 &acpi_gbl_FADT, 524 fadt_info_table[i].address64); 525 526 length = *ACPI_ADD_PTR(u8, 527 &acpi_gbl_FADT, 528 fadt_info_table[i].length); 529 530 name = fadt_info_table[i].name; 531 flags = fadt_info_table[i].flags; 532 533 /* 534 * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X" 535 * generic address structures as necessary. Later code will always use 536 * the 64-bit address structures. 537 * 538 * November 2013: 539 * Now always use the 64-bit address if it is valid (non-zero), in 540 * accordance with the ACPI specification which states that a 64-bit 541 * address supersedes the 32-bit version. This behavior can be 542 * overridden by the acpi_gbl_use32_bit_fadt_addresses flag. 543 * 544 * During 64-bit address construction and verification, 545 * these cases are handled: 546 * 547 * Address32 zero, Address64 [don't care] - Use Address64 548 * 549 * Address32 non-zero, Address64 zero - Copy/use Address32 550 * Address32 non-zero == Address64 non-zero - Use Address64 551 * Address32 non-zero != Address64 non-zero - Warning, use Address64 552 * 553 * Override: if acpi_gbl_use32_bit_fadt_addresses is TRUE, and: 554 * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32 555 * 556 * Note: space_id is always I/O for 32-bit legacy address fields 557 */ 558 if (address32) { 559 if (!address64->address) { 560 561 /* 64-bit address is zero, use 32-bit address */ 562 563 acpi_tb_init_generic_address(address64, 564 ACPI_ADR_SPACE_SYSTEM_IO, 565 *ACPI_ADD_PTR(u8, 566 &acpi_gbl_FADT, 567 fadt_info_table 568 [i]. 569 length), 570 (u64)address32, 571 name, flags); 572 } else if (address64->address != (u64)address32) { 573 574 /* Address mismatch */ 575 576 ACPI_BIOS_WARNING((AE_INFO, 577 "32/64X address mismatch in FADT/%s: " 578 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address", 579 name, address32, 580 ACPI_FORMAT_UINT64 581 (address64->address), 582 acpi_gbl_use32_bit_fadt_addresses 583 ? 32 : 64)); 584 585 if (acpi_gbl_use32_bit_fadt_addresses) { 586 587 /* 32-bit address override */ 588 589 acpi_tb_init_generic_address(address64, 590 ACPI_ADR_SPACE_SYSTEM_IO, 591 *ACPI_ADD_PTR 592 (u8, 593 &acpi_gbl_FADT, 594 fadt_info_table 595 [i]. 596 length), 597 (u64) 598 address32, 599 name, 600 flags); 601 } 602 } 603 } 604 605 /* 606 * For each extended field, check for length mismatch between the 607 * legacy length field and the corresponding 64-bit X length field. 608 * Note: If the legacy length field is > 0xFF bits, ignore this 609 * check. (GPE registers can be larger than the 64-bit GAS structure 610 * can accomodate, 0xFF bits). 611 */ 612 if (address64->address && 613 (ACPI_MUL_8(length) <= ACPI_UINT8_MAX) && 614 (address64->bit_width != ACPI_MUL_8(length))) { 615 ACPI_BIOS_WARNING((AE_INFO, 616 "32/64X length mismatch in FADT/%s: %u/%u", 617 name, ACPI_MUL_8(length), 618 address64->bit_width)); 619 } 620 621 if (fadt_info_table[i].flags & ACPI_FADT_REQUIRED) { 622 /* 623 * Field is required (Pm1a_event, Pm1a_control). 624 * Both the address and length must be non-zero. 625 */ 626 if (!address64->address || !length) { 627 ACPI_BIOS_ERROR((AE_INFO, 628 "Required FADT field %s has zero address and/or length: " 629 "0x%8.8X%8.8X/0x%X", 630 name, 631 ACPI_FORMAT_UINT64(address64-> 632 address), 633 length)); 634 } 635 } else if (fadt_info_table[i].flags & ACPI_FADT_SEPARATE_LENGTH) { 636 /* 637 * Field is optional (Pm2_control, GPE0, GPE1) AND has its own 638 * length field. If present, both the address and length must 639 * be valid. 640 */ 641 if ((address64->address && !length) || 642 (!address64->address && length)) { 643 ACPI_BIOS_WARNING((AE_INFO, 644 "Optional FADT field %s has zero address or length: " 645 "0x%8.8X%8.8X/0x%X", 646 name, 647 ACPI_FORMAT_UINT64 648 (address64->address), 649 length)); 650 } 651 } 652 } 653 } 654 655 /******************************************************************************* 656 * 657 * FUNCTION: acpi_tb_setup_fadt_registers 658 * 659 * PARAMETERS: None, uses acpi_gbl_FADT. 660 * 661 * RETURN: None 662 * 663 * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally, 664 * force FADT register definitions to their default lengths. 665 * 666 ******************************************************************************/ 667 668 static void acpi_tb_setup_fadt_registers(void) 669 { 670 struct acpi_generic_address *target64; 671 struct acpi_generic_address *source64; 672 u8 pm1_register_byte_width; 673 u32 i; 674 675 /* 676 * Optionally check all register lengths against the default values and 677 * update them if they are incorrect. 678 */ 679 if (acpi_gbl_use_default_register_widths) { 680 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) { 681 target64 = 682 ACPI_ADD_PTR(struct acpi_generic_address, 683 &acpi_gbl_FADT, 684 fadt_info_table[i].address64); 685 686 /* 687 * If a valid register (Address != 0) and the (default_length > 0) 688 * (Not a GPE register), then check the width against the default. 689 */ 690 if ((target64->address) && 691 (fadt_info_table[i].default_length > 0) && 692 (fadt_info_table[i].default_length != 693 target64->bit_width)) { 694 ACPI_BIOS_WARNING((AE_INFO, 695 "Invalid length for FADT/%s: %u, using default %u", 696 fadt_info_table[i].name, 697 target64->bit_width, 698 fadt_info_table[i]. 699 default_length)); 700 701 /* Incorrect size, set width to the default */ 702 703 target64->bit_width = 704 fadt_info_table[i].default_length; 705 } 706 } 707 } 708 709 /* 710 * Get the length of the individual PM1 registers (enable and status). 711 * Each register is defined to be (event block length / 2). Extra divide 712 * by 8 converts bits to bytes. 713 */ 714 pm1_register_byte_width = (u8) 715 ACPI_DIV_16(acpi_gbl_FADT.xpm1a_event_block.bit_width); 716 717 /* 718 * Calculate separate GAS structs for the PM1x (A/B) Status and Enable 719 * registers. These addresses do not appear (directly) in the FADT, so it 720 * is useful to pre-calculate them from the PM1 Event Block definitions. 721 * 722 * The PM event blocks are split into two register blocks, first is the 723 * PM Status Register block, followed immediately by the PM Enable 724 * Register block. Each is of length (pm1_event_length/2) 725 * 726 * Note: The PM1A event block is required by the ACPI specification. 727 * However, the PM1B event block is optional and is rarely, if ever, 728 * used. 729 */ 730 731 for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) { 732 source64 = 733 ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT, 734 fadt_pm_info_table[i].source); 735 736 if (source64->address) { 737 acpi_tb_init_generic_address(fadt_pm_info_table[i]. 738 target, source64->space_id, 739 pm1_register_byte_width, 740 source64->address + 741 (fadt_pm_info_table[i]. 742 register_num * 743 pm1_register_byte_width), 744 "PmRegisters", 0); 745 } 746 } 747 } 748