drivers/acpi/acpica/tbfadt.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: tbfadt   - FADT table utilities
   5  *
   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_TABLES
  15 ACPI_MODULE_NAME("tbfadt")
  16
  17 /* Local prototypes */
  18 static void
  19 acpi_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
  24 static void acpi_tb_convert_fadt(void);
  25
  26 static void acpi_tb_setup_fadt_registers(void);
  27
  28 static u64
  29 acpi_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
  33 typedef 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          0
  44 #define ACPI_FADT_REQUIRED          1
  45 #define ACPI_FADT_SEPARATE_LENGTH   2
  46 #define ACPI_FADT_GPE_REGISTER      4
  47
  48 static 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
 111 typedef 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
 118 static 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_address
 142  *
 143  * PARAMETERS:  generic_address     - GAS struct to be initialized
 144  *              space_id            - ACPI Space ID for this register
 145  *              byte_width          - Width of this register
 146  *              address             - Address of the register
 147  *              register_name       - ASCII name of the ACPI register
 148  *
 149  * RETURN:      None
 150  *
 151  * DESCRIPTION: Initialize a Generic Address Structure (GAS)
 152  *              See the ACPI specification for a full description and
 153  *              definition of this structure.
 154  *
 155  ******************************************************************************/
 156
 157 static void
 158 acpi_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_width
 173                  * for GPEs, the legacy length (byte_width) is used instead to
 174                  * 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 packed
 189          * 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_address
 204  *
 205  * PARAMETERS:  register_name       - ASCII name of the ACPI register
 206  *              address32           - 32-bit address of the register
 207  *              address64           - 64-bit address of the register
 208  *
 209  * RETURN:      The resolved 64-bit address
 210  *
 211  * DESCRIPTION: Select between 32-bit and 64-bit versions of addresses within
 212  *              the FADT. Used for the FACS and DSDT addresses.
 213  *
 214  * NOTES:
 215  *
 216  * Check for FACS and DSDT address mismatches. An address mismatch between
 217  * the 32-bit and 64-bit address fields (FIRMWARE_CTRL/X_FIRMWARE_CTRL and
 218  * DSDT/X_DSDT) could be a corrupted address field or it might indicate
 219  * 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 is
 223  * used regardless of the value of the 32-bit address. However, this
 224  * behavior can be overridden via the acpi_gbl_use32_bit_fadt_addresses flag.
 225  *
 226  ******************************************************************************/
 227
 228 static u64
 229 acpi_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_fadt
 266  *
 267  * PARAMETERS:  None
 268  *
 269  * RETURN:      None
 270  *
 271  * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
 272  *              (FADT contains the addresses of the DSDT and FACS)
 273  *
 274  ******************************************************************************/
 275
 276 void 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 format
 288          * 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. Ignore
 299          * 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_fadt
 337  *
 338  * PARAMETERS:  table               - Pointer to BIOS FADT
 339  *              length              - Length of the table
 340  *
 341  * RETURN:      None
 342  *
 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
 350 void 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 expect
 354          * (typically the current ACPI specification version). If so, truncate
 355          * 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_fadt
 394  *
 395  * PARAMETERS:  none - acpi_gbl_FADT is used.
 396  *
 397  * RETURN:      None
 398  *
 399  * DESCRIPTION: Converts all versions of the FADT to a common internal format.
 400  *              Expand 32-bit addresses to 64-bit as necessary. Also validate
 401  *              important fields within the FADT.
 402  *
 403  * NOTE:        acpi_gbl_FADT must be of size (struct acpi_table_fadt), and must
 404  *              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 FADT
 412  * V1.0 fields. Even if they are present in the FADT, they are optional and
 413  * are unused if the BIOS sets them to zero. Therefore, we must copy/expand
 414  * 32-bit V1.0 fields to the 64-bit X fields if the 64-bit X field is originally
 415  * zero.
 416  *
 417  * For ACPI 1.0 FADTs (that contain no 64-bit addresses), all 32-bit address
 418  * fields are expanded to the corresponding 64-bit X fields in the internal
 419  * common FADT.
 420  *
 421  * For ACPI 2.0+ FADTs, all valid (non-zero) 32-bit address fields are expanded
 422  * to the corresponding 64-bit X fields, if the 64-bit field is originally
 423  * zero. Adhering to the ACPI specification, we completely ignore the 32-bit
 424  * field if the 64-bit field is valid, regardless of whether the host OS is
 425  * 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 2
 432  *
 433  ******************************************************************************/
 434
 435 static 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 which
 446          * should be zero are indeed zero. This will workaround BIOSs that
 447          * inadvertently place values in these fields.
 448          *
 449          * The ACPI 1.0 reserved fields that will be zeroed are the bytes located
 450          * 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 be
 453          * 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 the
 464          * 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 register
 488                  * 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 use
 508                  * the 64-bit address structures.
 509                  *
 510                  * November 2013:
 511                  * Now always use the 64-bit address if it is valid (non-zero), in
 512                  * accordance with the ACPI specification which states that a 64-bit
 513                  * address supersedes the 32-bit version. This behavior can be
 514                  * 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 Address64
 520                  *
 521                  * No override: if acpi_gbl_use32_bit_fadt_addresses is FALSE, and:
 522                  * Address32 non-zero, Address64 zero       - Copy/use Address32
 523                  * Address32 non-zero == Address64 non-zero - Use Address64
 524                  * Address32 non-zero != Address64 non-zero - Warning, use Address64
 525                  *
 526                  * Override: if acpi_gbl_use32_bit_fadt_addresses is TRUE, and:
 527                  * Address32 non-zero, Address64 zero       - Copy/use Address32
 528                  * Address32 non-zero == Address64 non-zero - Copy/use Address32
 529                  * Address32 non-zero != Address64 non-zero - Warning, copy/use Address32
 530                  *
 531                  * Note: space_id is always I/O for 32-bit legacy address fields
 532                  */
 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_UINT64
 544                                                            (address64->address),
 545                                                            acpi_gbl_use32_bit_fadt_addresses
 546                                                            ? 32 : 64));
 547                                 }
 548
 549                                 /*
 550                                  * For each extended field, check for length mismatch
 551                                  * between the legacy length field and the corresponding
 552                                  * 64-bit X length field.
 553                                  * Note: If the legacy length field is > 0xFF bits, ignore
 554                                  * this check. (GPE registers can be larger than the
 555                                  * 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, the
 574                          * 64-bit fields are always re-initialized so that
 575                          * access_size/bit_width/bit_offset fields can be correctly
 576                          * configured to the values to trigger a 32-bit compatible
 577                          * access mode in the hardware register access code.
 578                          */
 579                         if (!address64->address
 580                             || 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 own
 606                          * length field. If present, both the address and length must
 607                          * 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_UINT64
 619                                                    (address64->address),
 620                                                    length));
 621                         }
 622                 }
 623         }
 624 }
 625
 626 /*******************************************************************************
 627  *
 628  * FUNCTION:    acpi_tb_setup_fadt_registers
 629  *
 630  * PARAMETERS:  None, uses acpi_gbl_FADT.
 631  *
 632  * RETURN:      None
 633  *
 634  * DESCRIPTION: Initialize global ACPI PM1 register definitions. Optionally,
 635  *              force FADT register definitions to their default lengths.
 636  *
 637  ******************************************************************************/
 638
 639 static 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 and
 648          * 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 divide
 683          * 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 Enable
 690          * registers. These addresses do not appear (directly) in the FADT, so it
 691          * 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 the
 694          * PM Status Register block, followed immediately by the PM Enable
 695          * 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 }