1 /****************************************************************************** 2 * 3 * Name: actbl1.h - Additional ACPI table definitions 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2016, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 *****************************************************************************/ 115 116 #ifndef __ACTBL1_H__ 117 #define __ACTBL1_H__ 118 119 120 /******************************************************************************* 121 * 122 * Additional ACPI Tables (1) 123 * 124 * These tables are not consumed directly by the ACPICA subsystem, but are 125 * included here to support device drivers and the AML disassembler. 126 * 127 * The tables in this file are fully defined within the ACPI specification. 128 * 129 ******************************************************************************/ 130 131 132 /* 133 * Values for description table header signatures for tables defined in this 134 * file. Useful because they make it more difficult to inadvertently type in 135 * the wrong signature. 136 */ 137 #define ACPI_SIG_BERT "BERT" /* Boot Error Record Table */ 138 #define ACPI_SIG_CPEP "CPEP" /* Corrected Platform Error Polling table */ 139 #define ACPI_SIG_ECDT "ECDT" /* Embedded Controller Boot Resources Table */ 140 #define ACPI_SIG_EINJ "EINJ" /* Error Injection table */ 141 #define ACPI_SIG_ERST "ERST" /* Error Record Serialization Table */ 142 #define ACPI_SIG_HEST "HEST" /* Hardware Error Source Table */ 143 #define ACPI_SIG_MADT "APIC" /* Multiple APIC Description Table */ 144 #define ACPI_SIG_MSCT "MSCT" /* Maximum System Characteristics Table */ 145 #define ACPI_SIG_SBST "SBST" /* Smart Battery Specification Table */ 146 #define ACPI_SIG_SLIT "SLIT" /* System Locality Distance Information Table */ 147 #define ACPI_SIG_SRAT "SRAT" /* System Resource Affinity Table */ 148 #define ACPI_SIG_NFIT "NFIT" /* NVDIMM Firmware Interface Table */ 149 150 151 /* 152 * All tables must be byte-packed to match the ACPI specification, since 153 * the tables are provided by the system BIOS. 154 */ 155 #pragma pack(1) 156 157 /* 158 * Note: C bitfields are not used for this reason: 159 * 160 * "Bitfields are great and easy to read, but unfortunately the C language 161 * does not specify the layout of bitfields in memory, which means they are 162 * essentially useless for dealing with packed data in on-disk formats or 163 * binary wire protocols." (Or ACPI tables and buffers.) "If you ask me, 164 * this decision was a design error in C. Ritchie could have picked an order 165 * and stuck with it." Norman Ramsey. 166 * See http://stackoverflow.com/a/1053662/41661 167 */ 168 169 170 /******************************************************************************* 171 * 172 * Common subtable headers 173 * 174 ******************************************************************************/ 175 176 /* Generic subtable header (used in MADT, SRAT, etc.) */ 177 178 typedef struct acpi_subtable_header 179 { 180 UINT8 Type; 181 UINT8 Length; 182 183 } ACPI_SUBTABLE_HEADER; 184 185 186 /* Subtable header for WHEA tables (EINJ, ERST, WDAT) */ 187 188 typedef struct acpi_whea_header 189 { 190 UINT8 Action; 191 UINT8 Instruction; 192 UINT8 Flags; 193 UINT8 Reserved; 194 ACPI_GENERIC_ADDRESS RegisterRegion; 195 UINT64 Value; /* Value used with Read/Write register */ 196 UINT64 Mask; /* Bitmask required for this register instruction */ 197 198 } ACPI_WHEA_HEADER; 199 200 201 /******************************************************************************* 202 * 203 * BERT - Boot Error Record Table (ACPI 4.0) 204 * Version 1 205 * 206 ******************************************************************************/ 207 208 typedef struct acpi_table_bert 209 { 210 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 211 UINT32 RegionLength; /* Length of the boot error region */ 212 UINT64 Address; /* Physical address of the error region */ 213 214 } ACPI_TABLE_BERT; 215 216 217 /* Boot Error Region (not a subtable, pointed to by Address field above) */ 218 219 typedef struct acpi_bert_region 220 { 221 UINT32 BlockStatus; /* Type of error information */ 222 UINT32 RawDataOffset; /* Offset to raw error data */ 223 UINT32 RawDataLength; /* Length of raw error data */ 224 UINT32 DataLength; /* Length of generic error data */ 225 UINT32 ErrorSeverity; /* Severity code */ 226 227 } ACPI_BERT_REGION; 228 229 /* Values for BlockStatus flags above */ 230 231 #define ACPI_BERT_UNCORRECTABLE (1) 232 #define ACPI_BERT_CORRECTABLE (1<<1) 233 #define ACPI_BERT_MULTIPLE_UNCORRECTABLE (1<<2) 234 #define ACPI_BERT_MULTIPLE_CORRECTABLE (1<<3) 235 #define ACPI_BERT_ERROR_ENTRY_COUNT (0xFF<<4) /* 8 bits, error count */ 236 237 /* Values for ErrorSeverity above */ 238 239 enum AcpiBertErrorSeverity 240 { 241 ACPI_BERT_ERROR_CORRECTABLE = 0, 242 ACPI_BERT_ERROR_FATAL = 1, 243 ACPI_BERT_ERROR_CORRECTED = 2, 244 ACPI_BERT_ERROR_NONE = 3, 245 ACPI_BERT_ERROR_RESERVED = 4 /* 4 and greater are reserved */ 246 }; 247 248 /* 249 * Note: The generic error data that follows the ErrorSeverity field above 250 * uses the ACPI_HEST_GENERIC_DATA defined under the HEST table below 251 */ 252 253 254 /******************************************************************************* 255 * 256 * CPEP - Corrected Platform Error Polling table (ACPI 4.0) 257 * Version 1 258 * 259 ******************************************************************************/ 260 261 typedef struct acpi_table_cpep 262 { 263 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 264 UINT64 Reserved; 265 266 } ACPI_TABLE_CPEP; 267 268 269 /* Subtable */ 270 271 typedef struct acpi_cpep_polling 272 { 273 ACPI_SUBTABLE_HEADER Header; 274 UINT8 Id; /* Processor ID */ 275 UINT8 Eid; /* Processor EID */ 276 UINT32 Interval; /* Polling interval (msec) */ 277 278 } ACPI_CPEP_POLLING; 279 280 281 /******************************************************************************* 282 * 283 * ECDT - Embedded Controller Boot Resources Table 284 * Version 1 285 * 286 ******************************************************************************/ 287 288 typedef struct acpi_table_ecdt 289 { 290 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 291 ACPI_GENERIC_ADDRESS Control; /* Address of EC command/status register */ 292 ACPI_GENERIC_ADDRESS Data; /* Address of EC data register */ 293 UINT32 Uid; /* Unique ID - must be same as the EC _UID method */ 294 UINT8 Gpe; /* The GPE for the EC */ 295 UINT8 Id[1]; /* Full namepath of the EC in the ACPI namespace */ 296 297 } ACPI_TABLE_ECDT; 298 299 300 /******************************************************************************* 301 * 302 * EINJ - Error Injection Table (ACPI 4.0) 303 * Version 1 304 * 305 ******************************************************************************/ 306 307 typedef struct acpi_table_einj 308 { 309 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 310 UINT32 HeaderLength; 311 UINT8 Flags; 312 UINT8 Reserved[3]; 313 UINT32 Entries; 314 315 } ACPI_TABLE_EINJ; 316 317 318 /* EINJ Injection Instruction Entries (actions) */ 319 320 typedef struct acpi_einj_entry 321 { 322 ACPI_WHEA_HEADER WheaHeader; /* Common header for WHEA tables */ 323 324 } ACPI_EINJ_ENTRY; 325 326 /* Masks for Flags field above */ 327 328 #define ACPI_EINJ_PRESERVE (1) 329 330 /* Values for Action field above */ 331 332 enum AcpiEinjActions 333 { 334 ACPI_EINJ_BEGIN_OPERATION = 0, 335 ACPI_EINJ_GET_TRIGGER_TABLE = 1, 336 ACPI_EINJ_SET_ERROR_TYPE = 2, 337 ACPI_EINJ_GET_ERROR_TYPE = 3, 338 ACPI_EINJ_END_OPERATION = 4, 339 ACPI_EINJ_EXECUTE_OPERATION = 5, 340 ACPI_EINJ_CHECK_BUSY_STATUS = 6, 341 ACPI_EINJ_GET_COMMAND_STATUS = 7, 342 ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS = 8, 343 ACPI_EINJ_ACTION_RESERVED = 9, /* 9 and greater are reserved */ 344 ACPI_EINJ_TRIGGER_ERROR = 0xFF /* Except for this value */ 345 }; 346 347 /* Values for Instruction field above */ 348 349 enum AcpiEinjInstructions 350 { 351 ACPI_EINJ_READ_REGISTER = 0, 352 ACPI_EINJ_READ_REGISTER_VALUE = 1, 353 ACPI_EINJ_WRITE_REGISTER = 2, 354 ACPI_EINJ_WRITE_REGISTER_VALUE = 3, 355 ACPI_EINJ_NOOP = 4, 356 ACPI_EINJ_FLUSH_CACHELINE = 5, 357 ACPI_EINJ_INSTRUCTION_RESERVED = 6 /* 6 and greater are reserved */ 358 }; 359 360 typedef struct acpi_einj_error_type_with_addr 361 { 362 UINT32 ErrorType; 363 UINT32 VendorStructOffset; 364 UINT32 Flags; 365 UINT32 ApicId; 366 UINT64 Address; 367 UINT64 Range; 368 UINT32 PcieId; 369 370 } ACPI_EINJ_ERROR_TYPE_WITH_ADDR; 371 372 typedef struct acpi_einj_vendor 373 { 374 UINT32 Length; 375 UINT32 PcieId; 376 UINT16 VendorId; 377 UINT16 DeviceId; 378 UINT8 RevisionId; 379 UINT8 Reserved[3]; 380 381 } ACPI_EINJ_VENDOR; 382 383 384 /* EINJ Trigger Error Action Table */ 385 386 typedef struct acpi_einj_trigger 387 { 388 UINT32 HeaderSize; 389 UINT32 Revision; 390 UINT32 TableSize; 391 UINT32 EntryCount; 392 393 } ACPI_EINJ_TRIGGER; 394 395 /* Command status return values */ 396 397 enum AcpiEinjCommandStatus 398 { 399 ACPI_EINJ_SUCCESS = 0, 400 ACPI_EINJ_FAILURE = 1, 401 ACPI_EINJ_INVALID_ACCESS = 2, 402 ACPI_EINJ_STATUS_RESERVED = 3 /* 3 and greater are reserved */ 403 }; 404 405 406 /* Error types returned from ACPI_EINJ_GET_ERROR_TYPE (bitfield) */ 407 408 #define ACPI_EINJ_PROCESSOR_CORRECTABLE (1) 409 #define ACPI_EINJ_PROCESSOR_UNCORRECTABLE (1<<1) 410 #define ACPI_EINJ_PROCESSOR_FATAL (1<<2) 411 #define ACPI_EINJ_MEMORY_CORRECTABLE (1<<3) 412 #define ACPI_EINJ_MEMORY_UNCORRECTABLE (1<<4) 413 #define ACPI_EINJ_MEMORY_FATAL (1<<5) 414 #define ACPI_EINJ_PCIX_CORRECTABLE (1<<6) 415 #define ACPI_EINJ_PCIX_UNCORRECTABLE (1<<7) 416 #define ACPI_EINJ_PCIX_FATAL (1<<8) 417 #define ACPI_EINJ_PLATFORM_CORRECTABLE (1<<9) 418 #define ACPI_EINJ_PLATFORM_UNCORRECTABLE (1<<10) 419 #define ACPI_EINJ_PLATFORM_FATAL (1<<11) 420 #define ACPI_EINJ_VENDOR_DEFINED (1<<31) 421 422 423 /******************************************************************************* 424 * 425 * ERST - Error Record Serialization Table (ACPI 4.0) 426 * Version 1 427 * 428 ******************************************************************************/ 429 430 typedef struct acpi_table_erst 431 { 432 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 433 UINT32 HeaderLength; 434 UINT32 Reserved; 435 UINT32 Entries; 436 437 } ACPI_TABLE_ERST; 438 439 440 /* ERST Serialization Entries (actions) */ 441 442 typedef struct acpi_erst_entry 443 { 444 ACPI_WHEA_HEADER WheaHeader; /* Common header for WHEA tables */ 445 446 } ACPI_ERST_ENTRY; 447 448 /* Masks for Flags field above */ 449 450 #define ACPI_ERST_PRESERVE (1) 451 452 /* Values for Action field above */ 453 454 enum AcpiErstActions 455 { 456 ACPI_ERST_BEGIN_WRITE = 0, 457 ACPI_ERST_BEGIN_READ = 1, 458 ACPI_ERST_BEGIN_CLEAR = 2, 459 ACPI_ERST_END = 3, 460 ACPI_ERST_SET_RECORD_OFFSET = 4, 461 ACPI_ERST_EXECUTE_OPERATION = 5, 462 ACPI_ERST_CHECK_BUSY_STATUS = 6, 463 ACPI_ERST_GET_COMMAND_STATUS = 7, 464 ACPI_ERST_GET_RECORD_ID = 8, 465 ACPI_ERST_SET_RECORD_ID = 9, 466 ACPI_ERST_GET_RECORD_COUNT = 10, 467 ACPI_ERST_BEGIN_DUMMY_WRIITE = 11, 468 ACPI_ERST_NOT_USED = 12, 469 ACPI_ERST_GET_ERROR_RANGE = 13, 470 ACPI_ERST_GET_ERROR_LENGTH = 14, 471 ACPI_ERST_GET_ERROR_ATTRIBUTES = 15, 472 ACPI_ERST_ACTION_RESERVED = 16 /* 16 and greater are reserved */ 473 }; 474 475 /* Values for Instruction field above */ 476 477 enum AcpiErstInstructions 478 { 479 ACPI_ERST_READ_REGISTER = 0, 480 ACPI_ERST_READ_REGISTER_VALUE = 1, 481 ACPI_ERST_WRITE_REGISTER = 2, 482 ACPI_ERST_WRITE_REGISTER_VALUE = 3, 483 ACPI_ERST_NOOP = 4, 484 ACPI_ERST_LOAD_VAR1 = 5, 485 ACPI_ERST_LOAD_VAR2 = 6, 486 ACPI_ERST_STORE_VAR1 = 7, 487 ACPI_ERST_ADD = 8, 488 ACPI_ERST_SUBTRACT = 9, 489 ACPI_ERST_ADD_VALUE = 10, 490 ACPI_ERST_SUBTRACT_VALUE = 11, 491 ACPI_ERST_STALL = 12, 492 ACPI_ERST_STALL_WHILE_TRUE = 13, 493 ACPI_ERST_SKIP_NEXT_IF_TRUE = 14, 494 ACPI_ERST_GOTO = 15, 495 ACPI_ERST_SET_SRC_ADDRESS_BASE = 16, 496 ACPI_ERST_SET_DST_ADDRESS_BASE = 17, 497 ACPI_ERST_MOVE_DATA = 18, 498 ACPI_ERST_INSTRUCTION_RESERVED = 19 /* 19 and greater are reserved */ 499 }; 500 501 /* Command status return values */ 502 503 enum AcpiErstCommandStatus 504 { 505 ACPI_ERST_SUCESS = 0, 506 ACPI_ERST_NO_SPACE = 1, 507 ACPI_ERST_NOT_AVAILABLE = 2, 508 ACPI_ERST_FAILURE = 3, 509 ACPI_ERST_RECORD_EMPTY = 4, 510 ACPI_ERST_NOT_FOUND = 5, 511 ACPI_ERST_STATUS_RESERVED = 6 /* 6 and greater are reserved */ 512 }; 513 514 515 /* Error Record Serialization Information */ 516 517 typedef struct acpi_erst_info 518 { 519 UINT16 Signature; /* Should be "ER" */ 520 UINT8 Data[48]; 521 522 } ACPI_ERST_INFO; 523 524 525 /******************************************************************************* 526 * 527 * HEST - Hardware Error Source Table (ACPI 4.0) 528 * Version 1 529 * 530 ******************************************************************************/ 531 532 typedef struct acpi_table_hest 533 { 534 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 535 UINT32 ErrorSourceCount; 536 537 } ACPI_TABLE_HEST; 538 539 540 /* HEST subtable header */ 541 542 typedef struct acpi_hest_header 543 { 544 UINT16 Type; 545 UINT16 SourceId; 546 547 } ACPI_HEST_HEADER; 548 549 550 /* Values for Type field above for subtables */ 551 552 enum AcpiHestTypes 553 { 554 ACPI_HEST_TYPE_IA32_CHECK = 0, 555 ACPI_HEST_TYPE_IA32_CORRECTED_CHECK = 1, 556 ACPI_HEST_TYPE_IA32_NMI = 2, 557 ACPI_HEST_TYPE_NOT_USED3 = 3, 558 ACPI_HEST_TYPE_NOT_USED4 = 4, 559 ACPI_HEST_TYPE_NOT_USED5 = 5, 560 ACPI_HEST_TYPE_AER_ROOT_PORT = 6, 561 ACPI_HEST_TYPE_AER_ENDPOINT = 7, 562 ACPI_HEST_TYPE_AER_BRIDGE = 8, 563 ACPI_HEST_TYPE_GENERIC_ERROR = 9, 564 ACPI_HEST_TYPE_RESERVED = 10 /* 10 and greater are reserved */ 565 }; 566 567 568 /* 569 * HEST substructures contained in subtables 570 */ 571 572 /* 573 * IA32 Error Bank(s) - Follows the ACPI_HEST_IA_MACHINE_CHECK and 574 * ACPI_HEST_IA_CORRECTED structures. 575 */ 576 typedef struct acpi_hest_ia_error_bank 577 { 578 UINT8 BankNumber; 579 UINT8 ClearStatusOnInit; 580 UINT8 StatusFormat; 581 UINT8 Reserved; 582 UINT32 ControlRegister; 583 UINT64 ControlData; 584 UINT32 StatusRegister; 585 UINT32 AddressRegister; 586 UINT32 MiscRegister; 587 588 } ACPI_HEST_IA_ERROR_BANK; 589 590 591 /* Common HEST sub-structure for PCI/AER structures below (6,7,8) */ 592 593 typedef struct acpi_hest_aer_common 594 { 595 UINT16 Reserved1; 596 UINT8 Flags; 597 UINT8 Enabled; 598 UINT32 RecordsToPreallocate; 599 UINT32 MaxSectionsPerRecord; 600 UINT32 Bus; /* Bus and Segment numbers */ 601 UINT16 Device; 602 UINT16 Function; 603 UINT16 DeviceControl; 604 UINT16 Reserved2; 605 UINT32 UncorrectableMask; 606 UINT32 UncorrectableSeverity; 607 UINT32 CorrectableMask; 608 UINT32 AdvancedCapabilities; 609 610 } ACPI_HEST_AER_COMMON; 611 612 /* Masks for HEST Flags fields */ 613 614 #define ACPI_HEST_FIRMWARE_FIRST (1) 615 #define ACPI_HEST_GLOBAL (1<<1) 616 617 /* 618 * Macros to access the bus/segment numbers in Bus field above: 619 * Bus number is encoded in bits 7:0 620 * Segment number is encoded in bits 23:8 621 */ 622 #define ACPI_HEST_BUS(Bus) ((Bus) & 0xFF) 623 #define ACPI_HEST_SEGMENT(Bus) (((Bus) >> 8) & 0xFFFF) 624 625 626 /* Hardware Error Notification */ 627 628 typedef struct acpi_hest_notify 629 { 630 UINT8 Type; 631 UINT8 Length; 632 UINT16 ConfigWriteEnable; 633 UINT32 PollInterval; 634 UINT32 Vector; 635 UINT32 PollingThresholdValue; 636 UINT32 PollingThresholdWindow; 637 UINT32 ErrorThresholdValue; 638 UINT32 ErrorThresholdWindow; 639 640 } ACPI_HEST_NOTIFY; 641 642 /* Values for Notify Type field above */ 643 644 enum AcpiHestNotifyTypes 645 { 646 ACPI_HEST_NOTIFY_POLLED = 0, 647 ACPI_HEST_NOTIFY_EXTERNAL = 1, 648 ACPI_HEST_NOTIFY_LOCAL = 2, 649 ACPI_HEST_NOTIFY_SCI = 3, 650 ACPI_HEST_NOTIFY_NMI = 4, 651 ACPI_HEST_NOTIFY_CMCI = 5, /* ACPI 5.0 */ 652 ACPI_HEST_NOTIFY_MCE = 6, /* ACPI 5.0 */ 653 ACPI_HEST_NOTIFY_RESERVED = 7 /* 7 and greater are reserved */ 654 }; 655 656 /* Values for ConfigWriteEnable bitfield above */ 657 658 #define ACPI_HEST_TYPE (1) 659 #define ACPI_HEST_POLL_INTERVAL (1<<1) 660 #define ACPI_HEST_POLL_THRESHOLD_VALUE (1<<2) 661 #define ACPI_HEST_POLL_THRESHOLD_WINDOW (1<<3) 662 #define ACPI_HEST_ERR_THRESHOLD_VALUE (1<<4) 663 #define ACPI_HEST_ERR_THRESHOLD_WINDOW (1<<5) 664 665 666 /* 667 * HEST subtables 668 */ 669 670 /* 0: IA32 Machine Check Exception */ 671 672 typedef struct acpi_hest_ia_machine_check 673 { 674 ACPI_HEST_HEADER Header; 675 UINT16 Reserved1; 676 UINT8 Flags; 677 UINT8 Enabled; 678 UINT32 RecordsToPreallocate; 679 UINT32 MaxSectionsPerRecord; 680 UINT64 GlobalCapabilityData; 681 UINT64 GlobalControlData; 682 UINT8 NumHardwareBanks; 683 UINT8 Reserved3[7]; 684 685 } ACPI_HEST_IA_MACHINE_CHECK; 686 687 688 /* 1: IA32 Corrected Machine Check */ 689 690 typedef struct acpi_hest_ia_corrected 691 { 692 ACPI_HEST_HEADER Header; 693 UINT16 Reserved1; 694 UINT8 Flags; 695 UINT8 Enabled; 696 UINT32 RecordsToPreallocate; 697 UINT32 MaxSectionsPerRecord; 698 ACPI_HEST_NOTIFY Notify; 699 UINT8 NumHardwareBanks; 700 UINT8 Reserved2[3]; 701 702 } ACPI_HEST_IA_CORRECTED; 703 704 705 /* 2: IA32 Non-Maskable Interrupt */ 706 707 typedef struct acpi_hest_ia_nmi 708 { 709 ACPI_HEST_HEADER Header; 710 UINT32 Reserved; 711 UINT32 RecordsToPreallocate; 712 UINT32 MaxSectionsPerRecord; 713 UINT32 MaxRawDataLength; 714 715 } ACPI_HEST_IA_NMI; 716 717 718 /* 3,4,5: Not used */ 719 720 /* 6: PCI Express Root Port AER */ 721 722 typedef struct acpi_hest_aer_root 723 { 724 ACPI_HEST_HEADER Header; 725 ACPI_HEST_AER_COMMON Aer; 726 UINT32 RootErrorCommand; 727 728 } ACPI_HEST_AER_ROOT; 729 730 731 /* 7: PCI Express AER (AER Endpoint) */ 732 733 typedef struct acpi_hest_aer 734 { 735 ACPI_HEST_HEADER Header; 736 ACPI_HEST_AER_COMMON Aer; 737 738 } ACPI_HEST_AER; 739 740 741 /* 8: PCI Express/PCI-X Bridge AER */ 742 743 typedef struct acpi_hest_aer_bridge 744 { 745 ACPI_HEST_HEADER Header; 746 ACPI_HEST_AER_COMMON Aer; 747 UINT32 UncorrectableMask2; 748 UINT32 UncorrectableSeverity2; 749 UINT32 AdvancedCapabilities2; 750 751 } ACPI_HEST_AER_BRIDGE; 752 753 754 /* 9: Generic Hardware Error Source */ 755 756 typedef struct acpi_hest_generic 757 { 758 ACPI_HEST_HEADER Header; 759 UINT16 RelatedSourceId; 760 UINT8 Reserved; 761 UINT8 Enabled; 762 UINT32 RecordsToPreallocate; 763 UINT32 MaxSectionsPerRecord; 764 UINT32 MaxRawDataLength; 765 ACPI_GENERIC_ADDRESS ErrorStatusAddress; 766 ACPI_HEST_NOTIFY Notify; 767 UINT32 ErrorBlockLength; 768 769 } ACPI_HEST_GENERIC; 770 771 772 /* Generic Error Status block */ 773 774 typedef struct acpi_hest_generic_status 775 { 776 UINT32 BlockStatus; 777 UINT32 RawDataOffset; 778 UINT32 RawDataLength; 779 UINT32 DataLength; 780 UINT32 ErrorSeverity; 781 782 } ACPI_HEST_GENERIC_STATUS; 783 784 /* Values for BlockStatus flags above */ 785 786 #define ACPI_HEST_UNCORRECTABLE (1) 787 #define ACPI_HEST_CORRECTABLE (1<<1) 788 #define ACPI_HEST_MULTIPLE_UNCORRECTABLE (1<<2) 789 #define ACPI_HEST_MULTIPLE_CORRECTABLE (1<<3) 790 #define ACPI_HEST_ERROR_ENTRY_COUNT (0xFF<<4) /* 8 bits, error count */ 791 792 793 /* Generic Error Data entry */ 794 795 typedef struct acpi_hest_generic_data 796 { 797 UINT8 SectionType[16]; 798 UINT32 ErrorSeverity; 799 UINT16 Revision; 800 UINT8 ValidationBits; 801 UINT8 Flags; 802 UINT32 ErrorDataLength; 803 UINT8 FruId[16]; 804 UINT8 FruText[20]; 805 806 } ACPI_HEST_GENERIC_DATA; 807 808 809 /******************************************************************************* 810 * 811 * MADT - Multiple APIC Description Table 812 * Version 3 813 * 814 ******************************************************************************/ 815 816 typedef struct acpi_table_madt 817 { 818 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 819 UINT32 Address; /* Physical address of local APIC */ 820 UINT32 Flags; 821 822 } ACPI_TABLE_MADT; 823 824 /* Masks for Flags field above */ 825 826 #define ACPI_MADT_PCAT_COMPAT (1) /* 00: System also has dual 8259s */ 827 828 /* Values for PCATCompat flag */ 829 830 #define ACPI_MADT_DUAL_PIC 0 831 #define ACPI_MADT_MULTIPLE_APIC 1 832 833 834 /* Values for MADT subtable type in ACPI_SUBTABLE_HEADER */ 835 836 enum AcpiMadtType 837 { 838 ACPI_MADT_TYPE_LOCAL_APIC = 0, 839 ACPI_MADT_TYPE_IO_APIC = 1, 840 ACPI_MADT_TYPE_INTERRUPT_OVERRIDE = 2, 841 ACPI_MADT_TYPE_NMI_SOURCE = 3, 842 ACPI_MADT_TYPE_LOCAL_APIC_NMI = 4, 843 ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE = 5, 844 ACPI_MADT_TYPE_IO_SAPIC = 6, 845 ACPI_MADT_TYPE_LOCAL_SAPIC = 7, 846 ACPI_MADT_TYPE_INTERRUPT_SOURCE = 8, 847 ACPI_MADT_TYPE_LOCAL_X2APIC = 9, 848 ACPI_MADT_TYPE_LOCAL_X2APIC_NMI = 10, 849 ACPI_MADT_TYPE_GENERIC_INTERRUPT = 11, 850 ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR = 12, 851 ACPI_MADT_TYPE_GENERIC_MSI_FRAME = 13, 852 ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR = 14, 853 ACPI_MADT_TYPE_GENERIC_TRANSLATOR = 15, 854 ACPI_MADT_TYPE_RESERVED = 16 /* 16 and greater are reserved */ 855 }; 856 857 858 /* 859 * MADT Subtables, correspond to Type in ACPI_SUBTABLE_HEADER 860 */ 861 862 /* 0: Processor Local APIC */ 863 864 typedef struct acpi_madt_local_apic 865 { 866 ACPI_SUBTABLE_HEADER Header; 867 UINT8 ProcessorId; /* ACPI processor id */ 868 UINT8 Id; /* Processor's local APIC id */ 869 UINT32 LapicFlags; 870 871 } ACPI_MADT_LOCAL_APIC; 872 873 874 /* 1: IO APIC */ 875 876 typedef struct acpi_madt_io_apic 877 { 878 ACPI_SUBTABLE_HEADER Header; 879 UINT8 Id; /* I/O APIC ID */ 880 UINT8 Reserved; /* Reserved - must be zero */ 881 UINT32 Address; /* APIC physical address */ 882 UINT32 GlobalIrqBase; /* Global system interrupt where INTI lines start */ 883 884 } ACPI_MADT_IO_APIC; 885 886 887 /* 2: Interrupt Override */ 888 889 typedef struct acpi_madt_interrupt_override 890 { 891 ACPI_SUBTABLE_HEADER Header; 892 UINT8 Bus; /* 0 - ISA */ 893 UINT8 SourceIrq; /* Interrupt source (IRQ) */ 894 UINT32 GlobalIrq; /* Global system interrupt */ 895 UINT16 IntiFlags; 896 897 } ACPI_MADT_INTERRUPT_OVERRIDE; 898 899 900 /* 3: NMI Source */ 901 902 typedef struct acpi_madt_nmi_source 903 { 904 ACPI_SUBTABLE_HEADER Header; 905 UINT16 IntiFlags; 906 UINT32 GlobalIrq; /* Global system interrupt */ 907 908 } ACPI_MADT_NMI_SOURCE; 909 910 911 /* 4: Local APIC NMI */ 912 913 typedef struct acpi_madt_local_apic_nmi 914 { 915 ACPI_SUBTABLE_HEADER Header; 916 UINT8 ProcessorId; /* ACPI processor id */ 917 UINT16 IntiFlags; 918 UINT8 Lint; /* LINTn to which NMI is connected */ 919 920 } ACPI_MADT_LOCAL_APIC_NMI; 921 922 923 /* 5: Address Override */ 924 925 typedef struct acpi_madt_local_apic_override 926 { 927 ACPI_SUBTABLE_HEADER Header; 928 UINT16 Reserved; /* Reserved, must be zero */ 929 UINT64 Address; /* APIC physical address */ 930 931 } ACPI_MADT_LOCAL_APIC_OVERRIDE; 932 933 934 /* 6: I/O Sapic */ 935 936 typedef struct acpi_madt_io_sapic 937 { 938 ACPI_SUBTABLE_HEADER Header; 939 UINT8 Id; /* I/O SAPIC ID */ 940 UINT8 Reserved; /* Reserved, must be zero */ 941 UINT32 GlobalIrqBase; /* Global interrupt for SAPIC start */ 942 UINT64 Address; /* SAPIC physical address */ 943 944 } ACPI_MADT_IO_SAPIC; 945 946 947 /* 7: Local Sapic */ 948 949 typedef struct acpi_madt_local_sapic 950 { 951 ACPI_SUBTABLE_HEADER Header; 952 UINT8 ProcessorId; /* ACPI processor id */ 953 UINT8 Id; /* SAPIC ID */ 954 UINT8 Eid; /* SAPIC EID */ 955 UINT8 Reserved[3]; /* Reserved, must be zero */ 956 UINT32 LapicFlags; 957 UINT32 Uid; /* Numeric UID - ACPI 3.0 */ 958 char UidString[1]; /* String UID - ACPI 3.0 */ 959 960 } ACPI_MADT_LOCAL_SAPIC; 961 962 963 /* 8: Platform Interrupt Source */ 964 965 typedef struct acpi_madt_interrupt_source 966 { 967 ACPI_SUBTABLE_HEADER Header; 968 UINT16 IntiFlags; 969 UINT8 Type; /* 1=PMI, 2=INIT, 3=corrected */ 970 UINT8 Id; /* Processor ID */ 971 UINT8 Eid; /* Processor EID */ 972 UINT8 IoSapicVector; /* Vector value for PMI interrupts */ 973 UINT32 GlobalIrq; /* Global system interrupt */ 974 UINT32 Flags; /* Interrupt Source Flags */ 975 976 } ACPI_MADT_INTERRUPT_SOURCE; 977 978 /* Masks for Flags field above */ 979 980 #define ACPI_MADT_CPEI_OVERRIDE (1) 981 982 983 /* 9: Processor Local X2APIC (ACPI 4.0) */ 984 985 typedef struct acpi_madt_local_x2apic 986 { 987 ACPI_SUBTABLE_HEADER Header; 988 UINT16 Reserved; /* Reserved - must be zero */ 989 UINT32 LocalApicId; /* Processor x2APIC ID */ 990 UINT32 LapicFlags; 991 UINT32 Uid; /* ACPI processor UID */ 992 993 } ACPI_MADT_LOCAL_X2APIC; 994 995 996 /* 10: Local X2APIC NMI (ACPI 4.0) */ 997 998 typedef struct acpi_madt_local_x2apic_nmi 999 { 1000 ACPI_SUBTABLE_HEADER Header; 1001 UINT16 IntiFlags; 1002 UINT32 Uid; /* ACPI processor UID */ 1003 UINT8 Lint; /* LINTn to which NMI is connected */ 1004 UINT8 Reserved[3]; /* Reserved - must be zero */ 1005 1006 } ACPI_MADT_LOCAL_X2APIC_NMI; 1007 1008 1009 /* 11: Generic Interrupt (ACPI 5.0 + ACPI 6.0 changes) */ 1010 1011 typedef struct acpi_madt_generic_interrupt 1012 { 1013 ACPI_SUBTABLE_HEADER Header; 1014 UINT16 Reserved; /* Reserved - must be zero */ 1015 UINT32 CpuInterfaceNumber; 1016 UINT32 Uid; 1017 UINT32 Flags; 1018 UINT32 ParkingVersion; 1019 UINT32 PerformanceInterrupt; 1020 UINT64 ParkedAddress; 1021 UINT64 BaseAddress; 1022 UINT64 GicvBaseAddress; 1023 UINT64 GichBaseAddress; 1024 UINT32 VgicInterrupt; 1025 UINT64 GicrBaseAddress; 1026 UINT64 ArmMpidr; 1027 UINT8 EfficiencyClass; 1028 UINT8 Reserved2[3]; 1029 1030 } ACPI_MADT_GENERIC_INTERRUPT; 1031 1032 /* Masks for Flags field above */ 1033 1034 /* ACPI_MADT_ENABLED (1) Processor is usable if set */ 1035 #define ACPI_MADT_PERFORMANCE_IRQ_MODE (1<<1) /* 01: Performance Interrupt Mode */ 1036 #define ACPI_MADT_VGIC_IRQ_MODE (1<<2) /* 02: VGIC Maintenance Interrupt mode */ 1037 1038 1039 /* 12: Generic Distributor (ACPI 5.0 + ACPI 6.0 changes) */ 1040 1041 typedef struct acpi_madt_generic_distributor 1042 { 1043 ACPI_SUBTABLE_HEADER Header; 1044 UINT16 Reserved; /* Reserved - must be zero */ 1045 UINT32 GicId; 1046 UINT64 BaseAddress; 1047 UINT32 GlobalIrqBase; 1048 UINT8 Version; 1049 UINT8 Reserved2[3]; /* Reserved - must be zero */ 1050 1051 } ACPI_MADT_GENERIC_DISTRIBUTOR; 1052 1053 /* Values for Version field above */ 1054 1055 enum AcpiMadtGicVersion 1056 { 1057 ACPI_MADT_GIC_VERSION_NONE = 0, 1058 ACPI_MADT_GIC_VERSION_V1 = 1, 1059 ACPI_MADT_GIC_VERSION_V2 = 2, 1060 ACPI_MADT_GIC_VERSION_V3 = 3, 1061 ACPI_MADT_GIC_VERSION_V4 = 4, 1062 ACPI_MADT_GIC_VERSION_RESERVED = 5 /* 5 and greater are reserved */ 1063 }; 1064 1065 1066 /* 13: Generic MSI Frame (ACPI 5.1) */ 1067 1068 typedef struct acpi_madt_generic_msi_frame 1069 { 1070 ACPI_SUBTABLE_HEADER Header; 1071 UINT16 Reserved; /* Reserved - must be zero */ 1072 UINT32 MsiFrameId; 1073 UINT64 BaseAddress; 1074 UINT32 Flags; 1075 UINT16 SpiCount; 1076 UINT16 SpiBase; 1077 1078 } ACPI_MADT_GENERIC_MSI_FRAME; 1079 1080 /* Masks for Flags field above */ 1081 1082 #define ACPI_MADT_OVERRIDE_SPI_VALUES (1) 1083 1084 1085 /* 14: Generic Redistributor (ACPI 5.1) */ 1086 1087 typedef struct acpi_madt_generic_redistributor 1088 { 1089 ACPI_SUBTABLE_HEADER Header; 1090 UINT16 Reserved; /* reserved - must be zero */ 1091 UINT64 BaseAddress; 1092 UINT32 Length; 1093 1094 } ACPI_MADT_GENERIC_REDISTRIBUTOR; 1095 1096 1097 /* 15: Generic Translator (ACPI 6.0) */ 1098 1099 typedef struct acpi_madt_generic_translator 1100 { 1101 ACPI_SUBTABLE_HEADER Header; 1102 UINT16 Reserved; /* reserved - must be zero */ 1103 UINT32 TranslationId; 1104 UINT64 BaseAddress; 1105 UINT32 Reserved2; 1106 1107 } ACPI_MADT_GENERIC_TRANSLATOR; 1108 1109 1110 /* 1111 * Common flags fields for MADT subtables 1112 */ 1113 1114 /* MADT Local APIC flags */ 1115 1116 #define ACPI_MADT_ENABLED (1) /* 00: Processor is usable if set */ 1117 1118 /* MADT MPS INTI flags (IntiFlags) */ 1119 1120 #define ACPI_MADT_POLARITY_MASK (3) /* 00-01: Polarity of APIC I/O input signals */ 1121 #define ACPI_MADT_TRIGGER_MASK (3<<2) /* 02-03: Trigger mode of APIC input signals */ 1122 1123 /* Values for MPS INTI flags */ 1124 1125 #define ACPI_MADT_POLARITY_CONFORMS 0 1126 #define ACPI_MADT_POLARITY_ACTIVE_HIGH 1 1127 #define ACPI_MADT_POLARITY_RESERVED 2 1128 #define ACPI_MADT_POLARITY_ACTIVE_LOW 3 1129 1130 #define ACPI_MADT_TRIGGER_CONFORMS (0) 1131 #define ACPI_MADT_TRIGGER_EDGE (1<<2) 1132 #define ACPI_MADT_TRIGGER_RESERVED (2<<2) 1133 #define ACPI_MADT_TRIGGER_LEVEL (3<<2) 1134 1135 1136 /******************************************************************************* 1137 * 1138 * MSCT - Maximum System Characteristics Table (ACPI 4.0) 1139 * Version 1 1140 * 1141 ******************************************************************************/ 1142 1143 typedef struct acpi_table_msct 1144 { 1145 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 1146 UINT32 ProximityOffset; /* Location of proximity info struct(s) */ 1147 UINT32 MaxProximityDomains;/* Max number of proximity domains */ 1148 UINT32 MaxClockDomains; /* Max number of clock domains */ 1149 UINT64 MaxAddress; /* Max physical address in system */ 1150 1151 } ACPI_TABLE_MSCT; 1152 1153 1154 /* Subtable - Maximum Proximity Domain Information. Version 1 */ 1155 1156 typedef struct acpi_msct_proximity 1157 { 1158 UINT8 Revision; 1159 UINT8 Length; 1160 UINT32 RangeStart; /* Start of domain range */ 1161 UINT32 RangeEnd; /* End of domain range */ 1162 UINT32 ProcessorCapacity; 1163 UINT64 MemoryCapacity; /* In bytes */ 1164 1165 } ACPI_MSCT_PROXIMITY; 1166 1167 1168 /******************************************************************************* 1169 * 1170 * NFIT - NVDIMM Interface Table (ACPI 6.0) 1171 * Version 1 1172 * 1173 ******************************************************************************/ 1174 1175 typedef struct acpi_table_nfit 1176 { 1177 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 1178 UINT32 Reserved; /* Reserved, must be zero */ 1179 1180 } ACPI_TABLE_NFIT; 1181 1182 /* Subtable header for NFIT */ 1183 1184 typedef struct acpi_nfit_header 1185 { 1186 UINT16 Type; 1187 UINT16 Length; 1188 1189 } ACPI_NFIT_HEADER; 1190 1191 1192 /* Values for subtable type in ACPI_NFIT_HEADER */ 1193 1194 enum AcpiNfitType 1195 { 1196 ACPI_NFIT_TYPE_SYSTEM_ADDRESS = 0, 1197 ACPI_NFIT_TYPE_MEMORY_MAP = 1, 1198 ACPI_NFIT_TYPE_INTERLEAVE = 2, 1199 ACPI_NFIT_TYPE_SMBIOS = 3, 1200 ACPI_NFIT_TYPE_CONTROL_REGION = 4, 1201 ACPI_NFIT_TYPE_DATA_REGION = 5, 1202 ACPI_NFIT_TYPE_FLUSH_ADDRESS = 6, 1203 ACPI_NFIT_TYPE_RESERVED = 7 /* 7 and greater are reserved */ 1204 }; 1205 1206 /* 1207 * NFIT Subtables 1208 */ 1209 1210 /* 0: System Physical Address Range Structure */ 1211 1212 typedef struct acpi_nfit_system_address 1213 { 1214 ACPI_NFIT_HEADER Header; 1215 UINT16 RangeIndex; 1216 UINT16 Flags; 1217 UINT32 Reserved; /* Reseved, must be zero */ 1218 UINT32 ProximityDomain; 1219 UINT8 RangeGuid[16]; 1220 UINT64 Address; 1221 UINT64 Length; 1222 UINT64 MemoryMapping; 1223 1224 } ACPI_NFIT_SYSTEM_ADDRESS; 1225 1226 /* Flags */ 1227 1228 #define ACPI_NFIT_ADD_ONLINE_ONLY (1) /* 00: Add/Online Operation Only */ 1229 #define ACPI_NFIT_PROXIMITY_VALID (1<<1) /* 01: Proximity Domain Valid */ 1230 1231 /* Range Type GUIDs appear in the include/acuuid.h file */ 1232 1233 1234 /* 1: Memory Device to System Address Range Map Structure */ 1235 1236 typedef struct acpi_nfit_memory_map 1237 { 1238 ACPI_NFIT_HEADER Header; 1239 UINT32 DeviceHandle; 1240 UINT16 PhysicalId; 1241 UINT16 RegionId; 1242 UINT16 RangeIndex; 1243 UINT16 RegionIndex; 1244 UINT64 RegionSize; 1245 UINT64 RegionOffset; 1246 UINT64 Address; 1247 UINT16 InterleaveIndex; 1248 UINT16 InterleaveWays; 1249 UINT16 Flags; 1250 UINT16 Reserved; /* Reserved, must be zero */ 1251 1252 } ACPI_NFIT_MEMORY_MAP; 1253 1254 /* Flags */ 1255 1256 #define ACPI_NFIT_MEM_SAVE_FAILED (1) /* 00: Last SAVE to Memory Device failed */ 1257 #define ACPI_NFIT_MEM_RESTORE_FAILED (1<<1) /* 01: Last RESTORE from Memory Device failed */ 1258 #define ACPI_NFIT_MEM_FLUSH_FAILED (1<<2) /* 02: Platform flush failed */ 1259 #define ACPI_NFIT_MEM_NOT_ARMED (1<<3) /* 03: Memory Device is not armed */ 1260 #define ACPI_NFIT_MEM_HEALTH_OBSERVED (1<<4) /* 04: Memory Device observed SMART/health events */ 1261 #define ACPI_NFIT_MEM_HEALTH_ENABLED (1<<5) /* 05: SMART/health events enabled */ 1262 1263 1264 /* 2: Interleave Structure */ 1265 1266 typedef struct acpi_nfit_interleave 1267 { 1268 ACPI_NFIT_HEADER Header; 1269 UINT16 InterleaveIndex; 1270 UINT16 Reserved; /* Reserved, must be zero */ 1271 UINT32 LineCount; 1272 UINT32 LineSize; 1273 UINT32 LineOffset[1]; /* Variable length */ 1274 1275 } ACPI_NFIT_INTERLEAVE; 1276 1277 1278 /* 3: SMBIOS Management Information Structure */ 1279 1280 typedef struct acpi_nfit_smbios 1281 { 1282 ACPI_NFIT_HEADER Header; 1283 UINT32 Reserved; /* Reserved, must be zero */ 1284 UINT8 Data[1]; /* Variable length */ 1285 1286 } ACPI_NFIT_SMBIOS; 1287 1288 1289 /* 4: NVDIMM Control Region Structure */ 1290 1291 typedef struct acpi_nfit_control_region 1292 { 1293 ACPI_NFIT_HEADER Header; 1294 UINT16 RegionIndex; 1295 UINT16 VendorId; 1296 UINT16 DeviceId; 1297 UINT16 RevisionId; 1298 UINT16 SubsystemVendorId; 1299 UINT16 SubsystemDeviceId; 1300 UINT16 SubsystemRevisionId; 1301 UINT8 Reserved[6]; /* Reserved, must be zero */ 1302 UINT32 SerialNumber; 1303 UINT16 Code; 1304 UINT16 Windows; 1305 UINT64 WindowSize; 1306 UINT64 CommandOffset; 1307 UINT64 CommandSize; 1308 UINT64 StatusOffset; 1309 UINT64 StatusSize; 1310 UINT16 Flags; 1311 UINT8 Reserved1[6]; /* Reserved, must be zero */ 1312 1313 } ACPI_NFIT_CONTROL_REGION; 1314 1315 /* Flags */ 1316 1317 #define ACPI_NFIT_CONTROL_BUFFERED (1) /* Block Data Windows implementation is buffered */ 1318 1319 1320 /* 5: NVDIMM Block Data Window Region Structure */ 1321 1322 typedef struct acpi_nfit_data_region 1323 { 1324 ACPI_NFIT_HEADER Header; 1325 UINT16 RegionIndex; 1326 UINT16 Windows; 1327 UINT64 Offset; 1328 UINT64 Size; 1329 UINT64 Capacity; 1330 UINT64 StartAddress; 1331 1332 } ACPI_NFIT_DATA_REGION; 1333 1334 1335 /* 6: Flush Hint Address Structure */ 1336 1337 typedef struct acpi_nfit_flush_address 1338 { 1339 ACPI_NFIT_HEADER Header; 1340 UINT32 DeviceHandle; 1341 UINT16 HintCount; 1342 UINT8 Reserved[6]; /* Reserved, must be zero */ 1343 UINT64 HintAddress[1]; /* Variable length */ 1344 1345 } ACPI_NFIT_FLUSH_ADDRESS; 1346 1347 1348 /******************************************************************************* 1349 * 1350 * SBST - Smart Battery Specification Table 1351 * Version 1 1352 * 1353 ******************************************************************************/ 1354 1355 typedef struct acpi_table_sbst 1356 { 1357 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 1358 UINT32 WarningLevel; 1359 UINT32 LowLevel; 1360 UINT32 CriticalLevel; 1361 1362 } ACPI_TABLE_SBST; 1363 1364 1365 /******************************************************************************* 1366 * 1367 * SLIT - System Locality Distance Information Table 1368 * Version 1 1369 * 1370 ******************************************************************************/ 1371 1372 typedef struct acpi_table_slit 1373 { 1374 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 1375 UINT64 LocalityCount; 1376 UINT8 Entry[1]; /* Real size = localities^2 */ 1377 1378 } ACPI_TABLE_SLIT; 1379 1380 1381 /******************************************************************************* 1382 * 1383 * SRAT - System Resource Affinity Table 1384 * Version 3 1385 * 1386 ******************************************************************************/ 1387 1388 typedef struct acpi_table_srat 1389 { 1390 ACPI_TABLE_HEADER Header; /* Common ACPI table header */ 1391 UINT32 TableRevision; /* Must be value '1' */ 1392 UINT64 Reserved; /* Reserved, must be zero */ 1393 1394 } ACPI_TABLE_SRAT; 1395 1396 /* Values for subtable type in ACPI_SUBTABLE_HEADER */ 1397 1398 enum AcpiSratType 1399 { 1400 ACPI_SRAT_TYPE_CPU_AFFINITY = 0, 1401 ACPI_SRAT_TYPE_MEMORY_AFFINITY = 1, 1402 ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY = 2, 1403 ACPI_SRAT_TYPE_GICC_AFFINITY = 3, 1404 ACPI_SRAT_TYPE_RESERVED = 4 /* 4 and greater are reserved */ 1405 }; 1406 1407 /* 1408 * SRAT Subtables, correspond to Type in ACPI_SUBTABLE_HEADER 1409 */ 1410 1411 /* 0: Processor Local APIC/SAPIC Affinity */ 1412 1413 typedef struct acpi_srat_cpu_affinity 1414 { 1415 ACPI_SUBTABLE_HEADER Header; 1416 UINT8 ProximityDomainLo; 1417 UINT8 ApicId; 1418 UINT32 Flags; 1419 UINT8 LocalSapicEid; 1420 UINT8 ProximityDomainHi[3]; 1421 UINT32 ClockDomain; 1422 1423 } ACPI_SRAT_CPU_AFFINITY; 1424 1425 /* Flags */ 1426 1427 #define ACPI_SRAT_CPU_USE_AFFINITY (1) /* 00: Use affinity structure */ 1428 1429 1430 /* 1: Memory Affinity */ 1431 1432 typedef struct acpi_srat_mem_affinity 1433 { 1434 ACPI_SUBTABLE_HEADER Header; 1435 UINT32 ProximityDomain; 1436 UINT16 Reserved; /* Reserved, must be zero */ 1437 UINT64 BaseAddress; 1438 UINT64 Length; 1439 UINT32 Reserved1; 1440 UINT32 Flags; 1441 UINT64 Reserved2; /* Reserved, must be zero */ 1442 1443 } ACPI_SRAT_MEM_AFFINITY; 1444 1445 /* Flags */ 1446 1447 #define ACPI_SRAT_MEM_ENABLED (1) /* 00: Use affinity structure */ 1448 #define ACPI_SRAT_MEM_HOT_PLUGGABLE (1<<1) /* 01: Memory region is hot pluggable */ 1449 #define ACPI_SRAT_MEM_NON_VOLATILE (1<<2) /* 02: Memory region is non-volatile */ 1450 1451 1452 /* 2: Processor Local X2_APIC Affinity (ACPI 4.0) */ 1453 1454 typedef struct acpi_srat_x2apic_cpu_affinity 1455 { 1456 ACPI_SUBTABLE_HEADER Header; 1457 UINT16 Reserved; /* Reserved, must be zero */ 1458 UINT32 ProximityDomain; 1459 UINT32 ApicId; 1460 UINT32 Flags; 1461 UINT32 ClockDomain; 1462 UINT32 Reserved2; 1463 1464 } ACPI_SRAT_X2APIC_CPU_AFFINITY; 1465 1466 /* Flags for ACPI_SRAT_CPU_AFFINITY and ACPI_SRAT_X2APIC_CPU_AFFINITY */ 1467 1468 #define ACPI_SRAT_CPU_ENABLED (1) /* 00: Use affinity structure */ 1469 1470 1471 /* 3: GICC Affinity (ACPI 5.1) */ 1472 1473 typedef struct acpi_srat_gicc_affinity 1474 { 1475 ACPI_SUBTABLE_HEADER Header; 1476 UINT32 ProximityDomain; 1477 UINT32 AcpiProcessorUid; 1478 UINT32 Flags; 1479 UINT32 ClockDomain; 1480 1481 } ACPI_SRAT_GICC_AFFINITY; 1482 1483 /* Flags for ACPI_SRAT_GICC_AFFINITY */ 1484 1485 #define ACPI_SRAT_GICC_ENABLED (1) /* 00: Use affinity structure */ 1486 1487 1488 /* Reset to default packing */ 1489 1490 #pragma pack() 1491 1492 #endif /* __ACTBL1_H__ */ 1493