719 lines · c
1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.02/******************************************************************************3 *4 * Module Name: tbfadt - FADT table utilities5 *6 * Copyright (C) 2000 - 2023, Intel Corp.7 *8 *****************************************************************************/9 10#include <acpi/acpi.h>11#include "accommon.h"12#include "actables.h"13 14#define _COMPONENT ACPI_TABLES15ACPI_MODULE_NAME("tbfadt")16 17/* Local prototypes */18static void19acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,20 u8 space_id,21 u8 byte_width,22 u64 address, const char *register_name, u8 flags);23 24static void acpi_tb_convert_fadt(void);25 26static void acpi_tb_setup_fadt_registers(void);27 28static u6429acpi_tb_select_address(char *register_name, u32 address32, u64 address64);30 31/* Table for conversion of FADT to common internal format and FADT validation */32 33typedef struct acpi_fadt_info {34 const char *name;35 u16 address64;36 u16 address32;37 u16 length;38 u8 default_length;39 u8 flags;40 41} acpi_fadt_info;42 43#define ACPI_FADT_OPTIONAL 044#define ACPI_FADT_REQUIRED 145#define ACPI_FADT_SEPARATE_LENGTH 246#define ACPI_FADT_GPE_REGISTER 447 48static struct acpi_fadt_info fadt_info_table[] = {49 {"Pm1aEventBlock",50 ACPI_FADT_OFFSET(xpm1a_event_block),51 ACPI_FADT_OFFSET(pm1a_event_block),52 ACPI_FADT_OFFSET(pm1_event_length),53 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */54 ACPI_FADT_REQUIRED},55 56 {"Pm1bEventBlock",57 ACPI_FADT_OFFSET(xpm1b_event_block),58 ACPI_FADT_OFFSET(pm1b_event_block),59 ACPI_FADT_OFFSET(pm1_event_length),60 ACPI_PM1_REGISTER_WIDTH * 2, /* Enable + Status register */61 ACPI_FADT_OPTIONAL},62 63 {"Pm1aControlBlock",64 ACPI_FADT_OFFSET(xpm1a_control_block),65 ACPI_FADT_OFFSET(pm1a_control_block),66 ACPI_FADT_OFFSET(pm1_control_length),67 ACPI_PM1_REGISTER_WIDTH,68 ACPI_FADT_REQUIRED},69 70 {"Pm1bControlBlock",71 ACPI_FADT_OFFSET(xpm1b_control_block),72 ACPI_FADT_OFFSET(pm1b_control_block),73 ACPI_FADT_OFFSET(pm1_control_length),74 ACPI_PM1_REGISTER_WIDTH,75 ACPI_FADT_OPTIONAL},76 77 {"Pm2ControlBlock",78 ACPI_FADT_OFFSET(xpm2_control_block),79 ACPI_FADT_OFFSET(pm2_control_block),80 ACPI_FADT_OFFSET(pm2_control_length),81 ACPI_PM2_REGISTER_WIDTH,82 ACPI_FADT_SEPARATE_LENGTH},83 84 {"PmTimerBlock",85 ACPI_FADT_OFFSET(xpm_timer_block),86 ACPI_FADT_OFFSET(pm_timer_block),87 ACPI_FADT_OFFSET(pm_timer_length),88 ACPI_PM_TIMER_WIDTH,89 ACPI_FADT_SEPARATE_LENGTH}, /* ACPI 5.0A: Timer is optional */90 91 {"Gpe0Block",92 ACPI_FADT_OFFSET(xgpe0_block),93 ACPI_FADT_OFFSET(gpe0_block),94 ACPI_FADT_OFFSET(gpe0_block_length),95 0,96 ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER},97 98 {"Gpe1Block",99 ACPI_FADT_OFFSET(xgpe1_block),100 ACPI_FADT_OFFSET(gpe1_block),101 ACPI_FADT_OFFSET(gpe1_block_length),102 0,103 ACPI_FADT_SEPARATE_LENGTH | ACPI_FADT_GPE_REGISTER}104};105 106#define ACPI_FADT_INFO_ENTRIES \107 (sizeof (fadt_info_table) / sizeof (struct acpi_fadt_info))108 109/* Table used to split Event Blocks into separate status/enable registers */110 111typedef struct acpi_fadt_pm_info {112 struct acpi_generic_address *target;113 u16 source;114 u8 register_num;115 116} acpi_fadt_pm_info;117 118static struct acpi_fadt_pm_info fadt_pm_info_table[] = {119 {&acpi_gbl_xpm1a_status,120 ACPI_FADT_OFFSET(xpm1a_event_block),121 0},122 123 {&acpi_gbl_xpm1a_enable,124 ACPI_FADT_OFFSET(xpm1a_event_block),125 1},126 127 {&acpi_gbl_xpm1b_status,128 ACPI_FADT_OFFSET(xpm1b_event_block),129 0},130 131 {&acpi_gbl_xpm1b_enable,132 ACPI_FADT_OFFSET(xpm1b_event_block),133 1}134};135 136#define ACPI_FADT_PM_INFO_ENTRIES \137 (sizeof (fadt_pm_info_table) / sizeof (struct acpi_fadt_pm_info))138 139/*******************************************************************************140 *141 * FUNCTION: acpi_tb_init_generic_address142 *143 * PARAMETERS: generic_address - GAS struct to be initialized144 * space_id - ACPI Space ID for this register145 * byte_width - Width of this register146 * address - Address of the register147 * register_name - ASCII name of the ACPI register148 *149 * RETURN: None150 *151 * DESCRIPTION: Initialize a Generic Address Structure (GAS)152 * See the ACPI specification for a full description and153 * definition of this structure.154 *155 ******************************************************************************/156 157static void158acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,159 u8 space_id,160 u8 byte_width,161 u64 address, const char *register_name, u8 flags)162{163 u8 bit_width;164 165 /*166 * Bit width field in the GAS is only one byte long, 255 max.167 * Check for bit_width overflow in GAS.168 */169 bit_width = (u8)(byte_width * 8);170 if (byte_width > 31) { /* (31*8)=248, (32*8)=256 */171 /*172 * No error for GPE blocks, because we do not use the bit_width173 * for GPEs, the legacy length (byte_width) is used instead to174 * allow for a large number of GPEs.175 */176 if (!(flags & ACPI_FADT_GPE_REGISTER)) {177 ACPI_ERROR((AE_INFO,178 "%s - 32-bit FADT register is too long (%u bytes, %u bits) "179 "to convert to GAS struct - 255 bits max, truncating",180 register_name, byte_width,181 (byte_width * 8)));182 }183 184 bit_width = 255;185 }186 187 /*188 * The 64-bit Address field is non-aligned in the byte packed189 * GAS struct.190 */191 ACPI_MOVE_64_TO_64(&generic_address->address, &address);192 193 /* All other fields are byte-wide */194 195 generic_address->space_id = space_id;196 generic_address->bit_width = bit_width;197 generic_address->bit_offset = 0;198 generic_address->access_width = 0; /* Access width ANY */199}200 201/*******************************************************************************202 *203 * FUNCTION: acpi_tb_select_address204 *205 * PARAMETERS: register_name - ASCII name of the ACPI register206 * address32 - 32-bit address of the register207 * address64 - 64-bit address of the register208 *209 * RETURN: The resolved 64-bit address210 *211 * DESCRIPTION: Select between 32-bit and 64-bit versions of addresses within212 * the FADT. Used for the FACS and DSDT addresses.213 *214 * NOTES:215 *216 * Check for FACS and DSDT address mismatches. An address mismatch between217 * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and218 * DSDT/X_DSDT) could be a corrupted address field or it might indicate219 * the presence of two FACS or two DSDT tables.220 *221 * November 2013:222 * By default, as per the ACPICA specification, a valid 64-bit address is223 * used regardless of the value of the 32-bit address. However, this224 * behavior can be overridden via the acpi_gbl_use32_bit_fadt_addresses flag.225 *226 ******************************************************************************/227 228static u64229acpi_tb_select_address(char *register_name, u32 address32, u64 address64)230{231 232 if (!address64) {233 234 /* 64-bit address is zero, use 32-bit address */235 236 return ((u64)address32);237 }238 239 if (address32 && (address64 != (u64)address32)) {240 241 /* Address mismatch between 32-bit and 64-bit versions */242 243 ACPI_BIOS_WARNING((AE_INFO,244 "32/64X %s address mismatch in FADT: "245 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",246 register_name, address32,247 ACPI_FORMAT_UINT64(address64),248 acpi_gbl_use32_bit_fadt_addresses ? 32 :249 64));250 251 /* 32-bit address override */252 253 if (acpi_gbl_use32_bit_fadt_addresses) {254 return ((u64)address32);255 }256 }257 258 /* Default is to use the 64-bit address */259 260 return (address64);261}262 263/*******************************************************************************264 *265 * FUNCTION: acpi_tb_parse_fadt266 *267 * PARAMETERS: None268 *269 * RETURN: None270 *271 * DESCRIPTION: Initialize the FADT, DSDT and FACS tables272 * (FADT contains the addresses of the DSDT and FACS)273 *274 ******************************************************************************/275 276void acpi_tb_parse_fadt(void)277{278 u32 length;279 struct acpi_table_header *table;280 struct acpi_table_desc *fadt_desc;281 acpi_status status;282 283 /*284 * The FADT has multiple versions with different lengths,285 * and it contains pointers to both the DSDT and FACS tables.286 *287 * Get a local copy of the FADT and convert it to a common format288 * Map entire FADT, assumed to be smaller than one page.289 */290 fadt_desc = &acpi_gbl_root_table_list.tables[acpi_gbl_fadt_index];291 status = acpi_tb_get_table(fadt_desc, &table);292 if (ACPI_FAILURE(status)) {293 return;294 }295 length = fadt_desc->length;296 297 /*298 * Validate the FADT checksum before we copy the table. Ignore299 * checksum error as we want to try to get the DSDT and FACS.300 */301 (void)acpi_ut_verify_checksum(table, length);302 303 /* Create a local copy of the FADT in common ACPI 2.0+ format */304 305 acpi_tb_create_local_fadt(table, length);306 307 /* All done with the real FADT, unmap it */308 309 acpi_tb_put_table(fadt_desc);310 311 /* Obtain the DSDT and FACS tables via their addresses within the FADT */312 313 acpi_tb_install_standard_table((acpi_physical_address)acpi_gbl_FADT.314 Xdsdt,315 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL,316 NULL, FALSE, TRUE, &acpi_gbl_dsdt_index);317 318 if (acpi_gbl_FADT.facs) {319 acpi_tb_install_standard_table((acpi_physical_address)320 acpi_gbl_FADT.facs,321 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL,322 NULL, FALSE, TRUE,323 &acpi_gbl_facs_index);324 }325 if (acpi_gbl_FADT.Xfacs) {326 acpi_tb_install_standard_table((acpi_physical_address)327 acpi_gbl_FADT.Xfacs,328 ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL,329 NULL, FALSE, TRUE,330 &acpi_gbl_xfacs_index);331 }332}333 334/*******************************************************************************335 *336 * FUNCTION: acpi_tb_create_local_fadt337 *338 * PARAMETERS: table - Pointer to BIOS FADT339 * length - Length of the table340 *341 * RETURN: None342 *343 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.344 * Performs validation on some important FADT fields.345 *346 * NOTE: We create a local copy of the FADT regardless of the version.347 *348 ******************************************************************************/349 350void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)351{352 /*353 * Check if the FADT is larger than the largest table that we expect354 * (typically the current ACPI specification version). If so, truncate355 * the table, and issue a warning.356 */357 if (length > sizeof(struct acpi_table_fadt)) {358 ACPI_BIOS_WARNING((AE_INFO,359 "FADT (revision %u) is longer than %s length, "360 "truncating length %u to %u",361 table->revision, ACPI_FADT_CONFORMANCE,362 length,363 (u32)sizeof(struct acpi_table_fadt)));364 }365 366 /* Clear the entire local FADT */367 368 memset(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt));369 370 /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */371 372 memcpy(&acpi_gbl_FADT, table,373 ACPI_MIN(length, sizeof(struct acpi_table_fadt)));374 375 /* Take a copy of the Hardware Reduced flag */376 377 acpi_gbl_reduced_hardware = FALSE;378 if (acpi_gbl_FADT.flags & ACPI_FADT_HW_REDUCED) {379 acpi_gbl_reduced_hardware = TRUE;380 }381 382 /* Convert the local copy of the FADT to the common internal format */383 384 acpi_tb_convert_fadt();385 386 /* Initialize the global ACPI register structures */387 388 acpi_tb_setup_fadt_registers();389}390 391/*******************************************************************************392 *393 * FUNCTION: acpi_tb_convert_fadt394 *395 * PARAMETERS: none - acpi_gbl_FADT is used.396 *397 * RETURN: None398 *399 * DESCRIPTION: Converts all versions of the FADT to a common internal format.400 * Expand 32-bit addresses to 64-bit as necessary. Also validate401 * important fields within the FADT.402 *403 * NOTE: acpi_gbl_FADT must be of size (struct acpi_table_fadt), and must404 * contain a copy of the actual BIOS-provided FADT.405 *406 * Notes on 64-bit register addresses:407 *408 * After this FADT conversion, later ACPICA code will only use the 64-bit "X"409 * fields of the FADT for all ACPI register addresses.410 *411 * The 64-bit X fields are optional extensions to the original 32-bit FADT412 * V1.0 fields. Even if they are present in the FADT, they are optional and413 * are unused if the BIOS sets them to zero. Therefore, we must copy/expand414 * 32-bit V1.0 fields to the 64-bit X fields if the 64-bit X field is originally415 * zero.416 *417 * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address418 * fields are expanded to the corresponding 64-bit X fields in the internal419 * common FADT.420 *421 * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded422 * to the corresponding 64-bit X fields, if the 64-bit field is originally423 * zero. Adhering to the ACPI specification, we completely ignore the 32-bit424 * field if the 64-bit field is valid, regardless of whether the host OS is425 * 32-bit or 64-bit.426 *427 * Possible additional checks:428 * (acpi_gbl_FADT.pm1_event_length >= 4)429 * (acpi_gbl_FADT.pm1_control_length >= 2)430 * (acpi_gbl_FADT.pm_timer_length >= 4)431 * Gpe block lengths must be multiple of 2432 *433 ******************************************************************************/434 435static void acpi_tb_convert_fadt(void)436{437 const char *name;438 struct acpi_generic_address *address64;439 u32 address32;440 u8 length;441 u8 flags;442 u32 i;443 444 /*445 * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which446 * should be zero are indeed zero. This will workaround BIOSs that447 * inadvertently place values in these fields.448 *449 * The ACPI 1.0 reserved fields that will be zeroed are the bytes located450 * at offset 45, 55, 95, and the word located at offset 109, 110.451 *452 * Note: The FADT revision value is unreliable. Only the length can be453 * trusted.454 */455 if (acpi_gbl_FADT.header.length <= ACPI_FADT_V2_SIZE) {456 acpi_gbl_FADT.preferred_profile = 0;457 acpi_gbl_FADT.pstate_control = 0;458 acpi_gbl_FADT.cst_control = 0;459 acpi_gbl_FADT.boot_flags = 0;460 }461 462 /*463 * Now we can update the local FADT length to the length of the464 * current FADT version as defined by the ACPI specification.465 * Thus, we will have a common FADT internally.466 */467 acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);468 469 /*470 * Expand the 32-bit DSDT addresses to 64-bit as necessary.471 * Later ACPICA code will always use the X 64-bit field.472 */473 acpi_gbl_FADT.Xdsdt = acpi_tb_select_address("DSDT",474 acpi_gbl_FADT.dsdt,475 acpi_gbl_FADT.Xdsdt);476 477 /* If Hardware Reduced flag is set, we are all done */478 479 if (acpi_gbl_reduced_hardware) {480 return;481 }482 483 /* Examine all of the 64-bit extended address fields (X fields) */484 485 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {486 /*487 * Get the 32-bit and 64-bit addresses, as well as the register488 * length and register name.489 */490 address32 = *ACPI_ADD_PTR(u32,491 &acpi_gbl_FADT,492 fadt_info_table[i].address32);493 494 address64 = ACPI_ADD_PTR(struct acpi_generic_address,495 &acpi_gbl_FADT,496 fadt_info_table[i].address64);497 498 length = *ACPI_ADD_PTR(u8,499 &acpi_gbl_FADT,500 fadt_info_table[i].length);501 502 name = fadt_info_table[i].name;503 flags = fadt_info_table[i].flags;504 505 /*506 * Expand the ACPI 1.0 32-bit addresses to the ACPI 2.0 64-bit "X"507 * generic address structures as necessary. Later code will always use508 * the 64-bit address structures.509 *510 * November 2013:511 * Now always use the 64-bit address if it is valid (non-zero), in512 * accordance with the ACPI specification which states that a 64-bit513 * address supersedes the 32-bit version. This behavior can be514 * overridden by the acpi_gbl_use32_bit_fadt_addresses flag.515 *516 * During 64-bit address construction and verification,517 * these cases are handled:518 *519 * Address32 zero, Address64 [don't care] - Use Address64520 *521 * No override: if acpi_gbl_use32_bit_fadt_addresses is FALSE, and:522 * Address32 non-zero, Address64 zero - Copy/use Address32523 * Address32 non-zero == Address64 non-zero - Use Address64524 * Address32 non-zero != Address64 non-zero - Warning, use Address64525 *526 * Override: if acpi_gbl_use32_bit_fadt_addresses is TRUE, and:527 * Address32 non-zero, Address64 zero - Copy/use Address32528 * Address32 non-zero == Address64 non-zero - Copy/use Address32529 * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32530 *531 * Note: space_id is always I/O for 32-bit legacy address fields532 */533 if (address32) {534 if (address64->address) {535 if (address64->address != (u64)address32) {536 537 /* Address mismatch */538 539 ACPI_BIOS_WARNING((AE_INFO,540 "32/64X address mismatch in FADT/%s: "541 "0x%8.8X/0x%8.8X%8.8X, using %u-bit address",542 name, address32,543 ACPI_FORMAT_UINT64544 (address64->address),545 acpi_gbl_use32_bit_fadt_addresses546 ? 32 : 64));547 }548 549 /*550 * For each extended field, check for length mismatch551 * between the legacy length field and the corresponding552 * 64-bit X length field.553 * Note: If the legacy length field is > 0xFF bits, ignore554 * this check. (GPE registers can be larger than the555 * 64-bit GAS structure can accommodate, 0xFF bits).556 */557 if ((ACPI_MUL_8(length) <= ACPI_UINT8_MAX) &&558 (address64->bit_width !=559 ACPI_MUL_8(length))) {560 ACPI_BIOS_WARNING((AE_INFO,561 "32/64X length mismatch in FADT/%s: %u/%u",562 name,563 ACPI_MUL_8(length),564 address64->565 bit_width));566 }567 }568 569 /*570 * Hardware register access code always uses the 64-bit fields.571 * So if the 64-bit field is zero or is to be overridden,572 * initialize it with the 32-bit fields.573 * Note that when the 32-bit address favor is specified, the574 * 64-bit fields are always re-initialized so that575 * access_size/bit_width/bit_offset fields can be correctly576 * configured to the values to trigger a 32-bit compatible577 * access mode in the hardware register access code.578 */579 if (!address64->address580 || acpi_gbl_use32_bit_fadt_addresses) {581 acpi_tb_init_generic_address(address64,582 ACPI_ADR_SPACE_SYSTEM_IO,583 length,584 (u64)address32,585 name, flags);586 }587 }588 589 if (fadt_info_table[i].flags & ACPI_FADT_REQUIRED) {590 /*591 * Field is required (Pm1a_event, Pm1a_control).592 * Both the address and length must be non-zero.593 */594 if (!address64->address || !length) {595 ACPI_BIOS_ERROR((AE_INFO,596 "Required FADT field %s has zero address and/or length: "597 "0x%8.8X%8.8X/0x%X",598 name,599 ACPI_FORMAT_UINT64(address64->600 address),601 length));602 }603 } else if (fadt_info_table[i].flags & ACPI_FADT_SEPARATE_LENGTH) {604 /*605 * Field is optional (Pm2_control, GPE0, GPE1) AND has its own606 * length field. If present, both the address and length must607 * be valid.608 */609 if ((address64->address && !length) ||610 (!address64->address && length)) {611 ACPI_BIOS_WARNING((AE_INFO,612 "Optional FADT field %s has valid %s but zero %s: "613 "0x%8.8X%8.8X/0x%X", name,614 (length ? "Length" :615 "Address"),616 (length ? "Address" :617 "Length"),618 ACPI_FORMAT_UINT64619 (address64->address),620 length));621 }622 }623 }624}625 626/*******************************************************************************627 *628 * FUNCTION: acpi_tb_setup_fadt_registers629 *630 * PARAMETERS: None, uses acpi_gbl_FADT.631 *632 * RETURN: None633 *634 * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally,635 * force FADT register definitions to their default lengths.636 *637 ******************************************************************************/638 639static void acpi_tb_setup_fadt_registers(void)640{641 struct acpi_generic_address *target64;642 struct acpi_generic_address *source64;643 u8 pm1_register_byte_width;644 u32 i;645 646 /*647 * Optionally check all register lengths against the default values and648 * update them if they are incorrect.649 */650 if (acpi_gbl_use_default_register_widths) {651 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {652 target64 =653 ACPI_ADD_PTR(struct acpi_generic_address,654 &acpi_gbl_FADT,655 fadt_info_table[i].address64);656 657 /*658 * If a valid register (Address != 0) and the (default_length > 0)659 * (Not a GPE register), then check the width against the default.660 */661 if ((target64->address) &&662 (fadt_info_table[i].default_length > 0) &&663 (fadt_info_table[i].default_length !=664 target64->bit_width)) {665 ACPI_BIOS_WARNING((AE_INFO,666 "Invalid length for FADT/%s: %u, using default %u",667 fadt_info_table[i].name,668 target64->bit_width,669 fadt_info_table[i].670 default_length));671 672 /* Incorrect size, set width to the default */673 674 target64->bit_width =675 fadt_info_table[i].default_length;676 }677 }678 }679 680 /*681 * Get the length of the individual PM1 registers (enable and status).682 * Each register is defined to be (event block length / 2). Extra divide683 * by 8 converts bits to bytes.684 */685 pm1_register_byte_width = (u8)686 ACPI_DIV_16(acpi_gbl_FADT.xpm1a_event_block.bit_width);687 688 /*689 * Calculate separate GAS structs for the PM1x (A/B) Status and Enable690 * registers. These addresses do not appear (directly) in the FADT, so it691 * is useful to pre-calculate them from the PM1 Event Block definitions.692 *693 * The PM event blocks are split into two register blocks, first is the694 * PM Status Register block, followed immediately by the PM Enable695 * Register block. Each is of length (pm1_event_length/2)696 *697 * Note: The PM1A event block is required by the ACPI specification.698 * However, the PM1B event block is optional and is rarely, if ever,699 * used.700 */701 702 for (i = 0; i < ACPI_FADT_PM_INFO_ENTRIES; i++) {703 source64 =704 ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT,705 fadt_pm_info_table[i].source);706 707 if (source64->address) {708 acpi_tb_init_generic_address(fadt_pm_info_table[i].709 target, source64->space_id,710 pm1_register_byte_width,711 source64->address +712 (fadt_pm_info_table[i].713 register_num *714 pm1_register_byte_width),715 "PmRegisters", 0);716 }717 }718}719