sys/contrib/dev/acpica-unix-20061109/tables/tbfadt.c

   1 /******************************************************************************
   2  *
   3  * Module Name: tbfadt   - FADT table utilities
   4  *              $Revision: 1.4 $
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2006, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117 #define __TBFADT_C__
 118
 119 #include "acpi.h"
 120 #include "actables.h"
 121
 122 #define _COMPONENT          ACPI_TABLES
 123         ACPI_MODULE_NAME    ("tbfadt")
 124
 125 /* Local prototypes */
 126
 127 static void inline
 128 AcpiTbInitGenericAddress (
 129     ACPI_GENERIC_ADDRESS    *GenericAddress,
 130     UINT8                   BitWidth,
 131     UINT64                  Address);
 132
 133 static void
 134 AcpiTbConvertFadt (
 135     void);
 136
 137 static void
 138 AcpiTbValidateFadt (
 139     void);
 140
 141
 142 /* Table for conversion of FADT to common internal format and FADT validation */
 143
 144 typedef struct acpi_fadt_info
 145 {
 146     char                    *Name;
 147     UINT8                   Target;
 148     UINT8                   Source;
 149     UINT8                   Length;
 150     UINT8                   Type;
 151
 152 } ACPI_FADT_INFO;
 153
 154 #define ACPI_FADT_REQUIRED          1
 155 #define ACPI_FADT_SEPARATE_LENGTH   2
 156
 157 static ACPI_FADT_INFO     FadtInfoTable[] =
 158 {
 159     {"Pm1aEventBlock",      ACPI_FADT_OFFSET (XPm1aEventBlock),
 160                             ACPI_FADT_OFFSET (Pm1aEventBlock),
 161                             ACPI_FADT_OFFSET (Pm1EventLength),      ACPI_FADT_REQUIRED},
 162
 163     {"Pm1bEventBlock",      ACPI_FADT_OFFSET (XPm1bEventBlock),
 164                             ACPI_FADT_OFFSET (Pm1bEventBlock),
 165                             ACPI_FADT_OFFSET (Pm1EventLength),      0},
 166
 167     {"Pm1aControlBlock",    ACPI_FADT_OFFSET (XPm1aControlBlock),
 168                             ACPI_FADT_OFFSET (Pm1aControlBlock),
 169                             ACPI_FADT_OFFSET (Pm1ControlLength),    ACPI_FADT_REQUIRED},
 170
 171     {"Pm1bControlBlock",    ACPI_FADT_OFFSET (XPm1bControlBlock),
 172                             ACPI_FADT_OFFSET (Pm1bControlBlock),
 173                             ACPI_FADT_OFFSET (Pm1ControlLength),    0},
 174
 175     {"Pm2ControlBlock",     ACPI_FADT_OFFSET (XPm2ControlBlock),
 176                             ACPI_FADT_OFFSET (Pm2ControlBlock),
 177                             ACPI_FADT_OFFSET (Pm2ControlLength),    ACPI_FADT_SEPARATE_LENGTH},
 178
 179     {"PmTimerBlock",        ACPI_FADT_OFFSET (XPmTimerBlock),
 180                             ACPI_FADT_OFFSET (PmTimerBlock),
 181                             ACPI_FADT_OFFSET (PmTimerLength),       ACPI_FADT_REQUIRED},
 182
 183     {"Gpe0Block",           ACPI_FADT_OFFSET (XGpe0Block),
 184                             ACPI_FADT_OFFSET (Gpe0Block),
 185                             ACPI_FADT_OFFSET (Gpe0BlockLength),     ACPI_FADT_SEPARATE_LENGTH},
 186
 187     {"Gpe1Block",           ACPI_FADT_OFFSET (XGpe1Block),
 188                             ACPI_FADT_OFFSET (Gpe1Block),
 189                             ACPI_FADT_OFFSET (Gpe1BlockLength),     ACPI_FADT_SEPARATE_LENGTH}
 190 };
 191
 192 #define ACPI_FADT_INFO_ENTRIES        (sizeof (FadtInfoTable) / sizeof (ACPI_FADT_INFO))
 193
 194
 195 /*******************************************************************************
 196  *
 197  * FUNCTION:    AcpiTbInitGenericAddress
 198  *
 199  * PARAMETERS:  GenericAddress      - GAS struct to be initialized
 200  *              BitWidth            - Width of this register
 201  *              Address             - Address of the register
 202  *
 203  * RETURN:      None
 204  *
 205  * DESCRIPTION: Initialize a Generic Address Structure (GAS)
 206  *              See the ACPI specification for a full description and
 207  *              definition of this structure.
 208  *
 209  ******************************************************************************/
 210
 211 static void inline
 212 AcpiTbInitGenericAddress (
 213     ACPI_GENERIC_ADDRESS    *GenericAddress,
 214     UINT8                   BitWidth,
 215     UINT64                  Address)
 216 {
 217
 218     /*
 219      * The 64-bit Address field is non-aligned in the byte packed
 220      * GAS struct.
 221      */
 222     ACPI_MOVE_64_TO_64 (&GenericAddress->Address, &Address);
 223
 224     /* All other fields are byte-wide */
 225
 226     GenericAddress->SpaceId = ACPI_ADR_SPACE_SYSTEM_IO;
 227     GenericAddress->BitWidth = BitWidth;
 228     GenericAddress->BitOffset = 0;
 229     GenericAddress->AccessWidth = 0;
 230 }
 231
 232
 233 /*******************************************************************************
 234  *
 235  * FUNCTION:    AcpiTbParseFadt
 236  *
 237  * PARAMETERS:  TableIndex          - Index for the FADT
 238  *              Flags               - Flags
 239  *
 240  * RETURN:      None
 241  *
 242  * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
 243  *              (FADT contains the addresses of the DSDT and FACS)
 244  *
 245  ******************************************************************************/
 246
 247 void
 248 AcpiTbParseFadt (
 249     ACPI_NATIVE_UINT        TableIndex,
 250     UINT8                   Flags)
 251 {
 252     UINT32                  Length;
 253     ACPI_TABLE_HEADER       *Table;
 254
 255
 256     /*
 257      * The FADT has multiple versions with different lengths,
 258      * and it contains pointers to both the DSDT and FACS tables.
 259      *
 260      * Get a local copy of the FADT and convert it to a common format
 261      * Map entire FADT, assumed to be smaller than one page.
 262      */
 263     Length = AcpiGbl_RootTableList.Tables[TableIndex].Length;
 264
 265     Table = AcpiOsMapMemory (
 266                 AcpiGbl_RootTableList.Tables[TableIndex].Address, Length);
 267     if (!Table)
 268     {
 269         return;
 270     }
 271
 272     /*
 273      * Validate the FADT checksum before we copy the table. Ignore
 274      * checksum error as we want to try to get the DSDT and FACS.
 275      */
 276     (void) AcpiTbVerifyChecksum (Table, Length);
 277
 278     /* Obtain a local copy of the FADT in common ACPI 2.0+ format */
 279
 280     AcpiTbCreateLocalFadt (Table, Length);
 281
 282     /* All done with the real FADT, unmap it */
 283
 284     AcpiOsUnmapMemory (Table, Length);
 285
 286     /* Obtain the DSDT and FACS tables via their addresses within the FADT */
 287
 288     AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XDsdt,
 289         Flags, ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
 290
 291     AcpiTbInstallTable ((ACPI_PHYSICAL_ADDRESS) AcpiGbl_FADT.XFacs,
 292         Flags, ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS);
 293 }
 294
 295
 296 /*******************************************************************************
 297  *
 298  * FUNCTION:    AcpiTbCreateLocalFadt
 299  *
 300  * PARAMETERS:  Table               - Pointer to BIOS FADT
 301  *              Length              - Length of the table
 302  *
 303  * RETURN:      None
 304  *
 305  * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
 306  *              Performs validation on some important FADT fields.
 307  *
 308  ******************************************************************************/
 309
 310 void
 311 AcpiTbCreateLocalFadt (
 312     ACPI_TABLE_HEADER       *Table,
 313     UINT32                  Length)
 314 {
 315
 316     /*
 317      * Check if the FADT is larger than what we know about (ACPI 2.0 version).
 318      * Truncate the table, but make some noise.
 319      */
 320     if (Length > sizeof (ACPI_TABLE_FADT))
 321     {
 322         ACPI_WARNING ((AE_INFO,
 323             "FADT (revision %u) is longer than ACPI 2.0 version, truncating length 0x%X to 0x%X",
 324             Table->Revision, Length, sizeof (ACPI_TABLE_FADT)));
 325     }
 326
 327     /* Copy the entire FADT locally. Zero first for TbConvertFadt */
 328
 329     ACPI_MEMSET (&AcpiGbl_FADT, 0, sizeof (ACPI_TABLE_FADT));
 330
 331     ACPI_MEMCPY (&AcpiGbl_FADT, Table,
 332         ACPI_MIN (Length, sizeof (ACPI_TABLE_FADT)));
 333
 334     /*
 335      * 1) Convert the local copy of the FADT to the common internal format
 336      * 2) Validate some of the important values within the FADT
 337      */
 338     AcpiTbConvertFadt ();
 339     AcpiTbValidateFadt ();
 340 }
 341
 342
 343 /*******************************************************************************
 344  *
 345  * FUNCTION:    AcpiTbConvertFadt
 346  *
 347  * PARAMETERS:  None, uses AcpiGbl_FADT
 348  *
 349  * RETURN:      None
 350  *
 351  * DESCRIPTION: Converts all versions of the FADT to a common internal format.
 352  *              -> Expand all 32-bit addresses to 64-bit.
 353  *
 354  * NOTE:        AcpiGbl_FADT must be of size (ACPI_TABLE_FADT),
 355  *              and must contain a copy of the actual FADT.
 356  *
 357  * ACPICA will use the "X" fields of the FADT for all addresses.
 358  *
 359  * "X" fields are optional extensions to the original V1.0 fields. Even if
 360  * they are present in the structure, they can be optionally not used by
 361  * setting them to zero. Therefore, we must selectively expand V1.0 fields
 362  * if the corresponding X field is zero.
 363  *
 364  * For ACPI 1.0 FADTs, all address fields are expanded to the corresponding
 365  * "X" fields.
 366  *
 367  * For ACPI 2.0 FADTs, any "X" fields that are NULL are filled in by
 368  * expanding the corresponding ACPI 1.0 field.
 369  *
 370  ******************************************************************************/
 371
 372 static void
 373 AcpiTbConvertFadt (
 374     void)
 375 {
 376     UINT8                       Pm1RegisterLength;
 377     ACPI_GENERIC_ADDRESS        *Target;
 378     ACPI_NATIVE_UINT            i;
 379
 380
 381     /* Update the local FADT table header length */
 382
 383     AcpiGbl_FADT.Header.Length = sizeof (ACPI_TABLE_FADT);
 384
 385     /* Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary */
 386
 387     if (!AcpiGbl_FADT.XFacs)
 388     {
 389         AcpiGbl_FADT.XFacs = (UINT64) AcpiGbl_FADT.Facs;
 390     }
 391
 392     if (!AcpiGbl_FADT.XDsdt)
 393     {
 394         AcpiGbl_FADT.XDsdt = (UINT64) AcpiGbl_FADT.Dsdt;
 395     }
 396
 397     /*
 398      * Expand the 32-bit V1.0 addresses to the 64-bit "X" generic address
 399      * structures as necessary.
 400      */
 401     for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++)
 402     {
 403         Target = ACPI_ADD_PTR (
 404             ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT, FadtInfoTable[i].Target);
 405
 406         /* Expand only if the X target is null */
 407
 408         if (!Target->Address)
 409         {
 410             AcpiTbInitGenericAddress (Target,
 411                 *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT, FadtInfoTable[i].Length),
 412                 (UINT64) *ACPI_ADD_PTR (UINT32, &AcpiGbl_FADT, FadtInfoTable[i].Source));
 413         }
 414     }
 415
 416     /*
 417      * Calculate separate GAS structs for the PM1 Enable registers.
 418      * These addresses do not appear (directly) in the FADT, so it is
 419      * useful to calculate them once, here.
 420      *
 421      * The PM event blocks are split into two register blocks, first is the
 422      * PM Status Register block, followed immediately by the PM Enable Register
 423      * block. Each is of length (Pm1EventLength/2)
 424      */
 425     Pm1RegisterLength = (UINT8) ACPI_DIV_2 (AcpiGbl_FADT.Pm1EventLength);
 426
 427     /* The PM1A register block is required */
 428
 429     AcpiTbInitGenericAddress (&AcpiGbl_XPm1aEnable, Pm1RegisterLength,
 430         (AcpiGbl_FADT.XPm1aEventBlock.Address + Pm1RegisterLength));
 431
 432     /* The PM1B register block is optional, ignore if not present */
 433
 434     if (AcpiGbl_FADT.XPm1bEventBlock.Address)
 435     {
 436         AcpiTbInitGenericAddress (&AcpiGbl_XPm1bEnable, Pm1RegisterLength,
 437             (AcpiGbl_FADT.XPm1bEventBlock.Address + Pm1RegisterLength));
 438     }
 439 }
 440
 441
 442 /******************************************************************************
 443  *
 444  * FUNCTION:    AcpiTbValidateFadt
 445  *
 446  * PARAMETERS:  Table           - Pointer to the FADT to be validated
 447  *
 448  * RETURN:      None
 449  *
 450  * DESCRIPTION: Validate various important fields within the FADT. If a problem
 451  *              is found, issue a message, but no status is returned.
 452  *              Used by both the table manager and the disassembler.
 453  *
 454  * Possible additional checks:
 455  * (AcpiGbl_FADT.Pm1EventLength >= 4)
 456  * (AcpiGbl_FADT.Pm1ControlLength >= 2)
 457  * (AcpiGbl_FADT.PmTimerLength >= 4)
 458  * Gpe block lengths must be multiple of 2
 459  *
 460  ******************************************************************************/
 461
 462 static void
 463 AcpiTbValidateFadt (
 464     void)
 465 {
 466     UINT32                  *Address32;
 467     ACPI_GENERIC_ADDRESS    *Address64;
 468     UINT8                   Length;
 469     ACPI_NATIVE_UINT        i;
 470
 471
 472     /* Examine all of the 64-bit extended address fields (X fields) */
 473
 474     for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++)
 475     {
 476         /* Generate pointers to the 32-bit and 64-bit addresses and get the length */
 477
 478         Address64 = ACPI_ADD_PTR (ACPI_GENERIC_ADDRESS, &AcpiGbl_FADT, FadtInfoTable[i].Target);
 479         Address32 = ACPI_ADD_PTR (UINT32, &AcpiGbl_FADT, FadtInfoTable[i].Source);
 480         Length = *ACPI_ADD_PTR (UINT8, &AcpiGbl_FADT, FadtInfoTable[i].Length);
 481
 482         if (FadtInfoTable[i].Type & ACPI_FADT_REQUIRED)
 483         {
 484             /*
 485              * Field is required (PM1aEvent, PM1aControl, PmTimer).
 486              * Both the address and length must be non-zero.
 487              */
 488             if (!Address64->Address || !Length)
 489             {
 490                 ACPI_ERROR ((AE_INFO,
 491                     "Required field \"%s\" has zero address and/or length: %8.8X%8.8X/%X",
 492                     FadtInfoTable[i].Name, ACPI_FORMAT_UINT64 (Address64->Address), Length));
 493             }
 494         }
 495         else if (FadtInfoTable[i].Type & ACPI_FADT_SEPARATE_LENGTH)
 496         {
 497             /*
 498              * Field is optional (PM2Control, GPE0, GPE1) AND has its own
 499              * length field. If present, both the address and length must be valid.
 500              */
 501             if ((Address64->Address && !Length) || (!Address64->Address && Length))
 502             {
 503                 ACPI_WARNING ((AE_INFO,
 504                     "Optional field \"%s\" has zero address or length: %8.8X%8.8X/%X",
 505                     FadtInfoTable[i].Name, ACPI_FORMAT_UINT64 (Address64->Address), Length));
 506             }
 507         }
 508
 509         /* If both 32- and 64-bit addresses are valid (non-zero), they must match */
 510
 511         if (Address64->Address && *Address32 &&
 512            (Address64->Address != (UINT64) *Address32))
 513         {
 514             ACPI_ERROR ((AE_INFO,
 515                 "32/64X address mismatch in \"%s\": [%8.8X] [%8.8X%8.8X], using 64X",
 516                 FadtInfoTable[i].Name, *Address32, ACPI_FORMAT_UINT64 (Address64->Address)));
 517         }
 518     }
 519 }
 520