usr.sbin/acpi/acpidump/acpi.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1998 Doug Rabson
   5  * Copyright (c) 2000 Mitsuru IWASAKI <iwasaki@FreeBSD.org>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      $FreeBSD$
  30  */
  31
  32 #include <sys/param.h>
  33 #include <sys/endian.h>
  34 #include <sys/stat.h>
  35 #include <sys/wait.h>
  36 #include <assert.h>
  37 #include <err.h>
  38 #include <fcntl.h>
  39 #include <paths.h>
  40 #include <stdio.h>
  41 #include <stdint.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <uuid.h>
  46
  47 #include "acpidump.h"
  48
  49 #define BEGIN_COMMENT   "/*\n"
  50 #define END_COMMENT     " */\n"
  51
  52 static void     acpi_print_string(char *s, size_t length);
  53 static void     acpi_print_gas(ACPI_GENERIC_ADDRESS *gas);
  54 static int      acpi_get_fadt_revision(ACPI_TABLE_FADT *fadt);
  55 static void     acpi_handle_fadt(ACPI_TABLE_HEADER *fadt);
  56 static void     acpi_print_cpu(u_char cpu_id);
  57 static void     acpi_print_cpu_uid(uint32_t uid, char *uid_string);
  58 static void     acpi_print_local_apic(uint32_t apic_id, uint32_t flags);
  59 static void     acpi_print_io_apic(uint32_t apic_id, uint32_t int_base,
  60                     uint64_t apic_addr);
  61 static void     acpi_print_mps_flags(uint16_t flags);
  62 static void     acpi_print_intr(uint32_t intr, uint16_t mps_flags);
  63 static void     acpi_print_local_nmi(u_int lint, uint16_t mps_flags);
  64 static void     acpi_print_madt(ACPI_SUBTABLE_HEADER *mp);
  65 static void     acpi_handle_madt(ACPI_TABLE_HEADER *sdp);
  66 static void     acpi_handle_ecdt(ACPI_TABLE_HEADER *sdp);
  67 static void     acpi_handle_hpet(ACPI_TABLE_HEADER *sdp);
  68 static void     acpi_handle_mcfg(ACPI_TABLE_HEADER *sdp);
  69 static void     acpi_handle_slit(ACPI_TABLE_HEADER *sdp);
  70 static void     acpi_print_srat_cpu(uint32_t apic_id, uint32_t proximity_domain,
  71                     uint32_t flags);
  72 static void     acpi_print_srat_memory(ACPI_SRAT_MEM_AFFINITY *mp);
  73 static void     acpi_print_srat(ACPI_SUBTABLE_HEADER *srat);
  74 static void     acpi_handle_srat(ACPI_TABLE_HEADER *sdp);
  75 static void     acpi_handle_tcpa(ACPI_TABLE_HEADER *sdp);
  76 static void     acpi_print_nfit(ACPI_NFIT_HEADER *nfit);
  77 static void     acpi_handle_nfit(ACPI_TABLE_HEADER *sdp);
  78 static void     acpi_print_sdt(ACPI_TABLE_HEADER *sdp);
  79 static void     acpi_print_fadt(ACPI_TABLE_HEADER *sdp);
  80 static void     acpi_print_facs(ACPI_TABLE_FACS *facs);
  81 static void     acpi_print_dsdt(ACPI_TABLE_HEADER *dsdp);
  82 static ACPI_TABLE_HEADER *acpi_map_sdt(vm_offset_t pa);
  83 static void     acpi_print_rsd_ptr(ACPI_TABLE_RSDP *rp);
  84 static void     acpi_handle_rsdt(ACPI_TABLE_HEADER *rsdp);
  85 static void     acpi_walk_subtables(ACPI_TABLE_HEADER *table, void *first,
  86                     void (*action)(ACPI_SUBTABLE_HEADER *));
  87 static void     acpi_walk_nfit(ACPI_TABLE_HEADER *table, void *first,
  88                     void (*action)(ACPI_NFIT_HEADER *));
  89
  90 /* Size of an address. 32-bit for ACPI 1.0, 64-bit for ACPI 2.0 and up. */
  91 static int addr_size;
  92
  93 /* Strings used in the TCPA table */
  94 static const char *tcpa_event_type_strings[] = {
  95         "PREBOOT Certificate",
  96         "POST Code",
  97         "Unused",
  98         "No Action",
  99         "Separator",
 100         "Action",
 101         "Event Tag",
 102         "S-CRTM Contents",
 103         "S-CRTM Version",
 104         "CPU Microcode",
 105         "Platform Config Flags",
 106         "Table of Devices",
 107         "Compact Hash",
 108         "IPL",
 109         "IPL Partition Data",
 110         "Non-Host Code",
 111         "Non-Host Config",
 112         "Non-Host Info"
 113 };
 114
 115 static const char *TCPA_pcclient_strings[] = {
 116         "<undefined>",
 117         "SMBIOS",
 118         "BIS Certificate",
 119         "POST BIOS ROM Strings",
 120         "ESCD",
 121         "CMOS",
 122         "NVRAM",
 123         "Option ROM Execute",
 124         "Option ROM Configurateion",
 125         "<undefined>",
 126         "Option ROM Microcode Update ",
 127         "S-CRTM Version String",
 128         "S-CRTM Contents",
 129         "POST Contents",
 130         "Table of Devices",
 131 };
 132
 133 #define PRINTFLAG_END()         printflag_end()
 134
 135 static char pf_sep = '{';
 136
 137 static void
 138 printflag_end(void)
 139 {
 140
 141         if (pf_sep != '{') {
 142                 printf("}");
 143                 pf_sep = '{';
 144         }
 145         printf("\n");
 146 }
 147
 148 static void
 149 printflag(uint64_t var, uint64_t mask, const char *name)
 150 {
 151
 152         if (var & mask) {
 153                 printf("%c%s", pf_sep, name);
 154                 pf_sep = ',';
 155         }
 156 }
 157
 158 static void
 159 acpi_print_string(char *s, size_t length)
 160 {
 161         int     c;
 162
 163         /* Trim trailing spaces and NULLs */
 164         while (length > 0 && (s[length - 1] == ' ' || s[length - 1] == '\0'))
 165                 length--;
 166
 167         while (length--) {
 168                 c = *s++;
 169                 putchar(c);
 170         }
 171 }
 172
 173 static void
 174 acpi_print_gas(ACPI_GENERIC_ADDRESS *gas)
 175 {
 176         switch(gas->SpaceId) {
 177         case ACPI_GAS_MEMORY:
 178                 if (gas->BitWidth <= 32)
 179                         printf("0x%08x:%u[%u] (Memory)",
 180                             (u_int)gas->Address, gas->BitOffset,
 181                             gas->BitWidth);
 182                 else
 183                         printf("0x%016jx:%u[%u] (Memory)",
 184                             (uintmax_t)gas->Address, gas->BitOffset,
 185                             gas->BitWidth);
 186                 break;
 187         case ACPI_GAS_IO:
 188                 printf("0x%02x:%u[%u] (IO)", (u_int)gas->Address,
 189                     gas->BitOffset, gas->BitWidth);
 190                 break;
 191         case ACPI_GAS_PCI:
 192                 printf("%x:%x+0x%x (PCI)", (uint16_t)(gas->Address >> 32),
 193                        (uint16_t)((gas->Address >> 16) & 0xffff),
 194                        (uint16_t)gas->Address);
 195                 break;
 196         /* XXX How to handle these below? */
 197         case ACPI_GAS_EMBEDDED:
 198                 printf("0x%x:%u[%u] (EC)", (uint16_t)gas->Address,
 199                        gas->BitOffset, gas->BitWidth);
 200                 break;
 201         case ACPI_GAS_SMBUS:
 202                 printf("0x%x:%u[%u] (SMBus)", (uint16_t)gas->Address,
 203                        gas->BitOffset, gas->BitWidth);
 204                 break;
 205         case ACPI_GAS_CMOS:
 206         case ACPI_GAS_PCIBAR:
 207         case ACPI_GAS_DATATABLE:
 208         case ACPI_GAS_FIXED:
 209         default:
 210                 printf("0x%016jx (?)", (uintmax_t)gas->Address);
 211                 break;
 212         }
 213 }
 214
 215 /* The FADT revision indicates whether we use the DSDT or X_DSDT addresses. */
 216 static int
 217 acpi_get_fadt_revision(ACPI_TABLE_FADT *fadt)
 218 {
 219         int fadt_revision;
 220
 221         /* Set the FADT revision separately from the RSDP version. */
 222         if (addr_size == 8) {
 223                 fadt_revision = 2;
 224
 225                 /*
 226                  * A few systems (e.g., IBM T23) have an RSDP that claims
 227                  * revision 2 but the 64 bit addresses are invalid.  If
 228                  * revision 2 and the 32 bit address is non-zero but the
 229                  * 32 and 64 bit versions don't match, prefer the 32 bit
 230                  * version for all subsequent tables.
 231                  */
 232                 if (fadt->Facs != 0 &&
 233                     (fadt->XFacs & 0xffffffff) != fadt->Facs)
 234                         fadt_revision = 1;
 235         } else
 236                 fadt_revision = 1;
 237         return (fadt_revision);
 238 }
 239
 240 static void
 241 acpi_handle_fadt(ACPI_TABLE_HEADER *sdp)
 242 {
 243         ACPI_TABLE_HEADER *dsdp;
 244         ACPI_TABLE_FACS *facs;
 245         ACPI_TABLE_FADT *fadt;
 246         int             fadt_revision;
 247
 248         fadt = (ACPI_TABLE_FADT *)sdp;
 249         acpi_print_fadt(sdp);
 250
 251         fadt_revision = acpi_get_fadt_revision(fadt);
 252         if (fadt_revision == 1)
 253                 facs = (ACPI_TABLE_FACS *)acpi_map_sdt(fadt->Facs);
 254         else
 255                 facs = (ACPI_TABLE_FACS *)acpi_map_sdt(fadt->XFacs);
 256         if (memcmp(facs->Signature, ACPI_SIG_FACS, 4) != 0 || facs->Length < 64)
 257                 errx(1, "FACS is corrupt");
 258         acpi_print_facs(facs);
 259
 260         if (fadt_revision == 1)
 261                 dsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(fadt->Dsdt);
 262         else
 263                 dsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(fadt->XDsdt);
 264         if (acpi_checksum(dsdp, dsdp->Length))
 265                 errx(1, "DSDT is corrupt");
 266         acpi_print_dsdt(dsdp);
 267 }
 268
 269 static void
 270 acpi_walk_subtables(ACPI_TABLE_HEADER *table, void *first,
 271     void (*action)(ACPI_SUBTABLE_HEADER *))
 272 {
 273         ACPI_SUBTABLE_HEADER *subtable;
 274         char *end;
 275
 276         subtable = first;
 277         end = (char *)table + table->Length;
 278         while ((char *)subtable < end) {
 279                 printf("\n");
 280                 if (subtable->Length < sizeof(ACPI_SUBTABLE_HEADER)) {
 281                         warnx("invalid subtable length %u", subtable->Length);
 282                         return;
 283                 }
 284                 action(subtable);
 285                 subtable = (ACPI_SUBTABLE_HEADER *)((char *)subtable +
 286                     subtable->Length);
 287         }
 288 }
 289
 290 static void
 291 acpi_walk_nfit(ACPI_TABLE_HEADER *table, void *first,
 292     void (*action)(ACPI_NFIT_HEADER *))
 293 {
 294         ACPI_NFIT_HEADER *subtable;
 295         char *end;
 296
 297         subtable = first;
 298         end = (char *)table + table->Length;
 299         while ((char *)subtable < end) {
 300                 printf("\n");
 301                 if (subtable->Length < sizeof(ACPI_NFIT_HEADER)) {
 302                         warnx("invalid subtable length %u", subtable->Length);
 303                         return;
 304                 }
 305                 action(subtable);
 306                 subtable = (ACPI_NFIT_HEADER *)((char *)subtable +
 307                     subtable->Length);
 308         }
 309 }
 310
 311 static void
 312 acpi_print_cpu(u_char cpu_id)
 313 {
 314
 315         printf("\tACPI CPU=");
 316         if (cpu_id == 0xff)
 317                 printf("ALL\n");
 318         else
 319                 printf("%d\n", (u_int)cpu_id);
 320 }
 321
 322 static void
 323 acpi_print_cpu_uid(uint32_t uid, char *uid_string)
 324 {
 325
 326         printf("\tUID=%d", uid);
 327         if (uid_string != NULL)
 328                 printf(" (%s)", uid_string);
 329         printf("\n");
 330 }
 331
 332 static void
 333 acpi_print_local_apic(uint32_t apic_id, uint32_t flags)
 334 {
 335
 336         printf("\tFlags={");
 337         if (flags & ACPI_MADT_ENABLED)
 338                 printf("ENABLED");
 339         else
 340                 printf("DISABLED");
 341         printf("}\n");
 342         printf("\tAPIC ID=%d\n", apic_id);
 343 }
 344
 345 static void
 346 acpi_print_io_apic(uint32_t apic_id, uint32_t int_base, uint64_t apic_addr)
 347 {
 348
 349         printf("\tAPIC ID=%d\n", apic_id);
 350         printf("\tINT BASE=%d\n", int_base);
 351         printf("\tADDR=0x%016jx\n", (uintmax_t)apic_addr);
 352 }
 353
 354 static void
 355 acpi_print_mps_flags(uint16_t flags)
 356 {
 357
 358         printf("\tFlags={Polarity=");
 359         switch (flags & ACPI_MADT_POLARITY_MASK) {
 360         case ACPI_MADT_POLARITY_CONFORMS:
 361                 printf("conforming");
 362                 break;
 363         case ACPI_MADT_POLARITY_ACTIVE_HIGH:
 364                 printf("active-hi");
 365                 break;
 366         case ACPI_MADT_POLARITY_ACTIVE_LOW:
 367                 printf("active-lo");
 368                 break;
 369         default:
 370                 printf("0x%x", flags & ACPI_MADT_POLARITY_MASK);
 371                 break;
 372         }
 373         printf(", Trigger=");
 374         switch (flags & ACPI_MADT_TRIGGER_MASK) {
 375         case ACPI_MADT_TRIGGER_CONFORMS:
 376                 printf("conforming");
 377                 break;
 378         case ACPI_MADT_TRIGGER_EDGE:
 379                 printf("edge");
 380                 break;
 381         case ACPI_MADT_TRIGGER_LEVEL:
 382                 printf("level");
 383                 break;
 384         default:
 385                 printf("0x%x", (flags & ACPI_MADT_TRIGGER_MASK) >> 2);
 386         }
 387         printf("}\n");
 388 }
 389
 390 static void
 391 acpi_print_gicc_flags(uint32_t flags)
 392 {
 393
 394         printf("\tFlags={Performance intr=");
 395         if (flags & ACPI_MADT_PERFORMANCE_IRQ_MODE)
 396                 printf("edge");
 397         else
 398                 printf("level");
 399         printf(", VGIC intr=");
 400         if (flags & ACPI_MADT_VGIC_IRQ_MODE)
 401                 printf("edge");
 402         else
 403                 printf("level");
 404         printf("}\n");
 405 }
 406
 407 static void
 408 acpi_print_intr(uint32_t intr, uint16_t mps_flags)
 409 {
 410
 411         printf("\tINTR=%d\n", intr);
 412         acpi_print_mps_flags(mps_flags);
 413 }
 414
 415 static void
 416 acpi_print_local_nmi(u_int lint, uint16_t mps_flags)
 417 {
 418
 419         printf("\tLINT Pin=%d\n", lint);
 420         acpi_print_mps_flags(mps_flags);
 421 }
 422
 423 static const char *apic_types[] = {
 424     [ACPI_MADT_TYPE_LOCAL_APIC] = "Local APIC",
 425     [ACPI_MADT_TYPE_IO_APIC] = "IO APIC",
 426     [ACPI_MADT_TYPE_INTERRUPT_OVERRIDE] = "INT Override",
 427     [ACPI_MADT_TYPE_NMI_SOURCE] = "NMI",
 428     [ACPI_MADT_TYPE_LOCAL_APIC_NMI] = "Local APIC NMI",
 429     [ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE] = "Local APIC Override",
 430     [ACPI_MADT_TYPE_IO_SAPIC] = "IO SAPIC",
 431     [ACPI_MADT_TYPE_LOCAL_SAPIC] = "Local SAPIC",
 432     [ACPI_MADT_TYPE_INTERRUPT_SOURCE] = "Platform Interrupt",
 433     [ACPI_MADT_TYPE_LOCAL_X2APIC] = "Local X2APIC",
 434     [ACPI_MADT_TYPE_LOCAL_X2APIC_NMI] = "Local X2APIC NMI",
 435     [ACPI_MADT_TYPE_GENERIC_INTERRUPT] = "GIC CPU Interface Structure",
 436     [ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR] = "GIC Distributor Structure",
 437     [ACPI_MADT_TYPE_GENERIC_MSI_FRAME] = "GICv2m MSI Frame",
 438     [ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR] = "GIC Redistributor Structure",
 439     [ACPI_MADT_TYPE_GENERIC_TRANSLATOR] = "GIC ITS Structure"
 440 };
 441
 442 static const char *platform_int_types[] = { "0 (unknown)", "PMI", "INIT",
 443                                             "Corrected Platform Error" };
 444
 445 static void
 446 acpi_print_madt(ACPI_SUBTABLE_HEADER *mp)
 447 {
 448         ACPI_MADT_LOCAL_APIC *lapic;
 449         ACPI_MADT_IO_APIC *ioapic;
 450         ACPI_MADT_INTERRUPT_OVERRIDE *over;
 451         ACPI_MADT_NMI_SOURCE *nmi;
 452         ACPI_MADT_LOCAL_APIC_NMI *lapic_nmi;
 453         ACPI_MADT_LOCAL_APIC_OVERRIDE *lapic_over;
 454         ACPI_MADT_IO_SAPIC *iosapic;
 455         ACPI_MADT_LOCAL_SAPIC *lsapic;
 456         ACPI_MADT_INTERRUPT_SOURCE *isrc;
 457         ACPI_MADT_LOCAL_X2APIC *x2apic;
 458         ACPI_MADT_LOCAL_X2APIC_NMI *x2apic_nmi;
 459         ACPI_MADT_GENERIC_INTERRUPT *gicc;
 460         ACPI_MADT_GENERIC_DISTRIBUTOR *gicd;
 461         ACPI_MADT_GENERIC_REDISTRIBUTOR *gicr;
 462         ACPI_MADT_GENERIC_TRANSLATOR *gict;
 463
 464         if (mp->Type < nitems(apic_types))
 465                 printf("\tType=%s\n", apic_types[mp->Type]);
 466         else
 467                 printf("\tType=%d (unknown)\n", mp->Type);
 468         switch (mp->Type) {
 469         case ACPI_MADT_TYPE_LOCAL_APIC:
 470                 lapic = (ACPI_MADT_LOCAL_APIC *)mp;
 471                 acpi_print_cpu(lapic->ProcessorId);
 472                 acpi_print_local_apic(lapic->Id, lapic->LapicFlags);
 473                 break;
 474         case ACPI_MADT_TYPE_IO_APIC:
 475                 ioapic = (ACPI_MADT_IO_APIC *)mp;
 476                 acpi_print_io_apic(ioapic->Id, ioapic->GlobalIrqBase,
 477                     ioapic->Address);
 478                 break;
 479         case ACPI_MADT_TYPE_INTERRUPT_OVERRIDE:
 480                 over = (ACPI_MADT_INTERRUPT_OVERRIDE *)mp;
 481                 printf("\tBUS=%d\n", (u_int)over->Bus);
 482                 printf("\tIRQ=%d\n", (u_int)over->SourceIrq);
 483                 acpi_print_intr(over->GlobalIrq, over->IntiFlags);
 484                 break;
 485         case ACPI_MADT_TYPE_NMI_SOURCE:
 486                 nmi = (ACPI_MADT_NMI_SOURCE *)mp;
 487                 acpi_print_intr(nmi->GlobalIrq, nmi->IntiFlags);
 488                 break;
 489         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
 490                 lapic_nmi = (ACPI_MADT_LOCAL_APIC_NMI *)mp;
 491                 acpi_print_cpu(lapic_nmi->ProcessorId);
 492                 acpi_print_local_nmi(lapic_nmi->Lint, lapic_nmi->IntiFlags);
 493                 break;
 494         case ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE:
 495                 lapic_over = (ACPI_MADT_LOCAL_APIC_OVERRIDE *)mp;
 496                 printf("\tLocal APIC ADDR=0x%016jx\n",
 497                     (uintmax_t)lapic_over->Address);
 498                 break;
 499         case ACPI_MADT_TYPE_IO_SAPIC:
 500                 iosapic = (ACPI_MADT_IO_SAPIC *)mp;
 501                 acpi_print_io_apic(iosapic->Id, iosapic->GlobalIrqBase,
 502                     iosapic->Address);
 503                 break;
 504         case ACPI_MADT_TYPE_LOCAL_SAPIC:
 505                 lsapic = (ACPI_MADT_LOCAL_SAPIC *)mp;
 506                 acpi_print_cpu(lsapic->ProcessorId);
 507                 acpi_print_local_apic(lsapic->Id, lsapic->LapicFlags);
 508                 printf("\tAPIC EID=%d\n", (u_int)lsapic->Eid);
 509                 if (mp->Length > __offsetof(ACPI_MADT_LOCAL_SAPIC, Uid))
 510                         acpi_print_cpu_uid(lsapic->Uid, lsapic->UidString);
 511                 break;
 512         case ACPI_MADT_TYPE_INTERRUPT_SOURCE:
 513                 isrc = (ACPI_MADT_INTERRUPT_SOURCE *)mp;
 514                 if (isrc->Type < nitems(platform_int_types))
 515                         printf("\tType=%s\n", platform_int_types[isrc->Type]);
 516                 else
 517                         printf("\tType=%d (unknown)\n", isrc->Type);
 518                 printf("\tAPIC ID=%d\n", (u_int)isrc->Id);
 519                 printf("\tAPIC EID=%d\n", (u_int)isrc->Eid);
 520                 printf("\tSAPIC Vector=%d\n", (u_int)isrc->IoSapicVector);
 521                 acpi_print_intr(isrc->GlobalIrq, isrc->IntiFlags);
 522                 break;
 523         case ACPI_MADT_TYPE_LOCAL_X2APIC:
 524                 x2apic = (ACPI_MADT_LOCAL_X2APIC *)mp;
 525                 acpi_print_cpu_uid(x2apic->Uid, NULL);
 526                 acpi_print_local_apic(x2apic->LocalApicId, x2apic->LapicFlags);
 527                 break;
 528         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
 529                 x2apic_nmi = (ACPI_MADT_LOCAL_X2APIC_NMI *)mp;
 530                 acpi_print_cpu_uid(x2apic_nmi->Uid, NULL);
 531                 acpi_print_local_nmi(x2apic_nmi->Lint, x2apic_nmi->IntiFlags);
 532                 break;
 533         case ACPI_MADT_TYPE_GENERIC_INTERRUPT:
 534                 gicc = (ACPI_MADT_GENERIC_INTERRUPT *)mp;
 535                 acpi_print_cpu_uid(gicc->Uid, NULL);
 536                 printf("\tCPU INTERFACE=%x\n", gicc->CpuInterfaceNumber);
 537                 acpi_print_gicc_flags(gicc->Flags);
 538                 printf("\tParking Protocol Version=%x\n", gicc->ParkingVersion);
 539                 printf("\tPERF INTR=%d\n", gicc->PerformanceInterrupt);
 540                 printf("\tParked ADDR=%016jx\n",
 541                     (uintmax_t)gicc->ParkedAddress);
 542                 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicc->BaseAddress);
 543                 printf("\tGICV=%016jx\n", (uintmax_t)gicc->GicvBaseAddress);
 544                 printf("\tGICH=%016jx\n", (uintmax_t)gicc->GichBaseAddress);
 545                 printf("\tVGIC INTR=%d\n", gicc->VgicInterrupt);
 546                 printf("\tGICR ADDR=%016jx\n",
 547                     (uintmax_t)gicc->GicrBaseAddress);
 548                 printf("\tMPIDR=%jx\n", (uintmax_t)gicc->ArmMpidr);
 549                 printf("\tEfficency Class=%d\n", (u_int)gicc->EfficiencyClass);
 550                 break;
 551         case ACPI_MADT_TYPE_GENERIC_DISTRIBUTOR:
 552                 gicd = (ACPI_MADT_GENERIC_DISTRIBUTOR *)mp;
 553                 printf("\tGIC ID=%d\n", (u_int)gicd->GicId);
 554                 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicd->BaseAddress);
 555                 printf("\tVector Base=%d\n", gicd->GlobalIrqBase);
 556                 printf("\tGIC VERSION=%d\n", (u_int)gicd->Version);
 557                 break;
 558         case ACPI_MADT_TYPE_GENERIC_REDISTRIBUTOR:
 559                 gicr = (ACPI_MADT_GENERIC_REDISTRIBUTOR *)mp;
 560                 printf("\tBase ADDR=%016jx\n", (uintmax_t)gicr->BaseAddress);
 561                 printf("\tLength=%08x\n", gicr->Length);
 562                 break;
 563         case ACPI_MADT_TYPE_GENERIC_TRANSLATOR:
 564                 gict = (ACPI_MADT_GENERIC_TRANSLATOR *)mp;
 565                 printf("\tGIC ITS ID=%d\n", gict->TranslationId);
 566                 printf("\tBase ADDR=%016jx\n", (uintmax_t)gict->BaseAddress);
 567                 break;
 568         }
 569 }
 570
 571 static void
 572 acpi_handle_madt(ACPI_TABLE_HEADER *sdp)
 573 {
 574         ACPI_TABLE_MADT *madt;
 575
 576         printf(BEGIN_COMMENT);
 577         acpi_print_sdt(sdp);
 578         madt = (ACPI_TABLE_MADT *)sdp;
 579         printf("\tLocal APIC ADDR=0x%08x\n", madt->Address);
 580         printf("\tFlags={");
 581         if (madt->Flags & ACPI_MADT_PCAT_COMPAT)
 582                 printf("PC-AT");
 583         printf("}\n");
 584         acpi_walk_subtables(sdp, (madt + 1), acpi_print_madt);
 585         printf(END_COMMENT);
 586 }
 587
 588 static void
 589 acpi_handle_hpet(ACPI_TABLE_HEADER *sdp)
 590 {
 591         ACPI_TABLE_HPET *hpet;
 592
 593         printf(BEGIN_COMMENT);
 594         acpi_print_sdt(sdp);
 595         hpet = (ACPI_TABLE_HPET *)sdp;
 596         printf("\tHPET Number=%d\n", hpet->Sequence);
 597         printf("\tADDR=");
 598         acpi_print_gas(&hpet->Address);
 599         printf("\tHW Rev=0x%x\n", hpet->Id & ACPI_HPET_ID_HARDWARE_REV_ID);
 600         printf("\tComparators=%d\n", (hpet->Id & ACPI_HPET_ID_COMPARATORS) >>
 601             8);
 602         printf("\tCounter Size=%d\n", hpet->Id & ACPI_HPET_ID_COUNT_SIZE_CAP ?
 603             1 : 0);
 604         printf("\tLegacy IRQ routing capable={");
 605         if (hpet->Id & ACPI_HPET_ID_LEGACY_CAPABLE)
 606                 printf("TRUE}\n");
 607         else
 608                 printf("FALSE}\n");
 609         printf("\tPCI Vendor ID=0x%04x\n", hpet->Id >> 16);
 610         printf("\tMinimal Tick=%d\n", hpet->MinimumTick);
 611         printf("\tFlags=0x%02x\n", hpet->Flags);
 612         printf(END_COMMENT);
 613 }
 614
 615 static void
 616 acpi_handle_ecdt(ACPI_TABLE_HEADER *sdp)
 617 {
 618         ACPI_TABLE_ECDT *ecdt;
 619
 620         printf(BEGIN_COMMENT);
 621         acpi_print_sdt(sdp);
 622         ecdt = (ACPI_TABLE_ECDT *)sdp;
 623         printf("\tEC_CONTROL=");
 624         acpi_print_gas(&ecdt->Control);
 625         printf("\n\tEC_DATA=");
 626         acpi_print_gas(&ecdt->Data);
 627         printf("\n\tUID=%#x, ", ecdt->Uid);
 628         printf("GPE_BIT=%#x\n", ecdt->Gpe);
 629         printf("\tEC_ID=%s\n", ecdt->Id);
 630         printf(END_COMMENT);
 631 }
 632
 633 static void
 634 acpi_handle_mcfg(ACPI_TABLE_HEADER *sdp)
 635 {
 636         ACPI_TABLE_MCFG *mcfg;
 637         ACPI_MCFG_ALLOCATION *alloc;
 638         u_int i, entries;
 639
 640         printf(BEGIN_COMMENT);
 641         acpi_print_sdt(sdp);
 642         mcfg = (ACPI_TABLE_MCFG *)sdp;
 643         entries = (sdp->Length - sizeof(ACPI_TABLE_MCFG)) /
 644             sizeof(ACPI_MCFG_ALLOCATION);
 645         alloc = (ACPI_MCFG_ALLOCATION *)(mcfg + 1);
 646         for (i = 0; i < entries; i++, alloc++) {
 647                 printf("\n");
 648                 printf("\tBase Address=0x%016jx\n", (uintmax_t)alloc->Address);
 649                 printf("\tSegment Group=0x%04x\n", alloc->PciSegment);
 650                 printf("\tStart Bus=%d\n", alloc->StartBusNumber);
 651                 printf("\tEnd Bus=%d\n", alloc->EndBusNumber);
 652         }
 653         printf(END_COMMENT);
 654 }
 655
 656 static void
 657 acpi_handle_slit(ACPI_TABLE_HEADER *sdp)
 658 {
 659         ACPI_TABLE_SLIT *slit;
 660         UINT64 i, j;
 661
 662         printf(BEGIN_COMMENT);
 663         acpi_print_sdt(sdp);
 664         slit = (ACPI_TABLE_SLIT *)sdp;
 665         printf("\tLocality Count=%ju\n", (uintmax_t)slit->LocalityCount);
 666         printf("\n\t      ");
 667         for (i = 0; i < slit->LocalityCount; i++)
 668                 printf(" %3ju", (uintmax_t)i);
 669         printf("\n\t     +");
 670         for (i = 0; i < slit->LocalityCount; i++)
 671                 printf("----");
 672         printf("\n");
 673         for (i = 0; i < slit->LocalityCount; i++) {
 674                 printf("\t %3ju |", (uintmax_t)i);
 675                 for (j = 0; j < slit->LocalityCount; j++)
 676                         printf(" %3d",
 677                             slit->Entry[i * slit->LocalityCount + j]);
 678                 printf("\n");
 679         }
 680         printf(END_COMMENT);
 681 }
 682
 683 static void
 684 acpi_print_srat_cpu(uint32_t apic_id, uint32_t proximity_domain,
 685     uint32_t flags)
 686 {
 687
 688         printf("\tFlags={");
 689         if (flags & ACPI_SRAT_CPU_ENABLED)
 690                 printf("ENABLED");
 691         else
 692                 printf("DISABLED");
 693         printf("}\n");
 694         printf("\tAPIC ID=%d\n", apic_id);
 695         printf("\tProximity Domain=%d\n", proximity_domain);
 696 }
 697
 698 static char *
 699 acpi_tcpa_evname(struct TCPAevent *event)
 700 {
 701         struct TCPApc_event *pc_event;
 702         char *eventname = NULL;
 703
 704         pc_event = (struct TCPApc_event *)(event + 1);
 705
 706         switch(event->event_type) {
 707         case PREBOOT:
 708         case POST_CODE:
 709         case UNUSED:
 710         case NO_ACTION:
 711         case SEPARATOR:
 712         case SCRTM_CONTENTS:
 713         case SCRTM_VERSION:
 714         case CPU_MICROCODE:
 715         case PLATFORM_CONFIG_FLAGS:
 716         case TABLE_OF_DEVICES:
 717         case COMPACT_HASH:
 718         case IPL:
 719         case IPL_PARTITION_DATA:
 720         case NONHOST_CODE:
 721         case NONHOST_CONFIG:
 722         case NONHOST_INFO:
 723                 asprintf(&eventname, "%s",
 724                     tcpa_event_type_strings[event->event_type]);
 725                 break;
 726
 727         case ACTION:
 728                 eventname = calloc(event->event_size + 1, sizeof(char));
 729                 memcpy(eventname, pc_event, event->event_size);
 730                 break;
 731
 732         case EVENT_TAG:
 733                 switch (pc_event->event_id) {
 734                 case SMBIOS:
 735                 case BIS_CERT:
 736                 case CMOS:
 737                 case NVRAM:
 738                 case OPTION_ROM_EXEC:
 739                 case OPTION_ROM_CONFIG:
 740                 case S_CRTM_VERSION:
 741                 case POST_BIOS_ROM:
 742                 case ESCD:
 743                 case OPTION_ROM_MICROCODE:
 744                 case S_CRTM_CONTENTS:
 745                 case POST_CONTENTS:
 746                         asprintf(&eventname, "%s",
 747                             TCPA_pcclient_strings[pc_event->event_id]);
 748                         break;
 749
 750                 default:
 751                         asprintf(&eventname, "<unknown tag 0x%02x>",
 752                             pc_event->event_id);
 753                         break;
 754                 }
 755                 break;
 756
 757         default:
 758                 asprintf(&eventname, "<unknown 0x%02x>", event->event_type);
 759                 break;
 760         }
 761
 762         return eventname;
 763 }
 764
 765 static void
 766 acpi_print_tcpa(struct TCPAevent *event)
 767 {
 768         int i;
 769         char *eventname;
 770
 771         eventname = acpi_tcpa_evname(event);
 772
 773         printf("\t%d", event->pcr_index);
 774         printf(" 0x");
 775         for (i = 0; i < 20; i++)
 776                 printf("%02x", event->pcr_value[i]);
 777         printf(" [%s]\n", eventname ? eventname : "<unknown>");
 778
 779         free(eventname);
 780 }
 781
 782 static void
 783 acpi_handle_tcpa(ACPI_TABLE_HEADER *sdp)
 784 {
 785         struct TCPAbody *tcpa;
 786         struct TCPAevent *event;
 787         uintmax_t len, paddr;
 788         unsigned char *vaddr = NULL;
 789         unsigned char *vend = NULL;
 790
 791         printf(BEGIN_COMMENT);
 792         acpi_print_sdt(sdp);
 793         tcpa = (struct TCPAbody *) sdp;
 794
 795         switch (tcpa->platform_class) {
 796         case ACPI_TCPA_BIOS_CLIENT:
 797                 len = tcpa->client.log_max_len;
 798                 paddr = tcpa->client.log_start_addr;
 799                 break;
 800
 801         case ACPI_TCPA_BIOS_SERVER:
 802                 len = tcpa->server.log_max_len;
 803                 paddr = tcpa->server.log_start_addr;
 804                 break;
 805
 806         default:
 807                 printf("XXX");
 808                 printf(END_COMMENT);
 809                 return;
 810         }
 811         printf("\tClass %u Base Address 0x%jx Length %ju\n\n",
 812             tcpa->platform_class, paddr, len);
 813
 814         if (len == 0) {
 815                 printf("\tEmpty TCPA table\n");
 816                 printf(END_COMMENT);
 817                 return;
 818         }
 819         if(sdp->Revision == 1){
 820                 printf("\tOLD TCPA spec log found. Dumping not supported.\n");
 821                 printf(END_COMMENT);
 822                 return;
 823         }
 824
 825         vaddr = (unsigned char *)acpi_map_physical(paddr, len);
 826         vend = vaddr + len;
 827
 828         while (vaddr != NULL) {
 829                 if ((vaddr + sizeof(struct TCPAevent) >= vend)||
 830                     (vaddr + sizeof(struct TCPAevent) < vaddr))
 831                         break;
 832                 event = (struct TCPAevent *)(void *)vaddr;
 833                 if (vaddr + event->event_size >= vend)
 834                         break;
 835                 if (vaddr + event->event_size < vaddr)
 836                         break;
 837                 if (event->event_type == 0 && event->event_size == 0)
 838                         break;
 839 #if 0
 840                 {
 841                 unsigned int i, j, k;
 842
 843                 printf("\n\tsize %d\n\t\t%p ", event->event_size, vaddr);
 844                 for (j = 0, i = 0; i <
 845                     sizeof(struct TCPAevent) + event->event_size; i++) {
 846                         printf("%02x ", vaddr[i]);
 847                         if ((i+1) % 8 == 0) {
 848                                 for (k = 0; k < 8; k++)
 849                                         printf("%c", isprint(vaddr[j+k]) ?
 850                                             vaddr[j+k] : '.');
 851                                 printf("\n\t\t%p ", &vaddr[i + 1]);
 852                                 j = i + 1;
 853                         }
 854                 }
 855                 printf("\n"); }
 856 #endif
 857                 acpi_print_tcpa(event);
 858
 859                 vaddr += sizeof(struct TCPAevent) + event->event_size;
 860         }
 861
 862         printf(END_COMMENT);
 863 }
 864 static void acpi_handle_tpm2(ACPI_TABLE_HEADER *sdp)
 865 {
 866         ACPI_TABLE_TPM2 *tpm2;
 867
 868         printf (BEGIN_COMMENT);
 869         acpi_print_sdt(sdp);
 870         tpm2 = (ACPI_TABLE_TPM2 *) sdp;
 871         printf ("\t\tControlArea=%lx\n", tpm2->ControlAddress);
 872         printf ("\t\tStartMethod=%x\n", tpm2->StartMethod);
 873         printf (END_COMMENT);
 874 }
 875
 876 static const char *
 877 devscope_type2str(int type)
 878 {
 879         static char typebuf[16];
 880
 881         switch (type) {
 882         case 1:
 883                 return ("PCI Endpoint Device");
 884         case 2:
 885                 return ("PCI Sub-Hierarchy");
 886         case 3:
 887                 return ("IOAPIC");
 888         case 4:
 889                 return ("HPET");
 890         default:
 891                 snprintf(typebuf, sizeof(typebuf), "%d", type);
 892                 return (typebuf);
 893         }
 894 }
 895
 896 static int
 897 acpi_handle_dmar_devscope(void *addr, int remaining)
 898 {
 899         char sep;
 900         int pathlen;
 901         ACPI_DMAR_PCI_PATH *path, *pathend;
 902         ACPI_DMAR_DEVICE_SCOPE *devscope = addr;
 903
 904         if (remaining < (int)sizeof(ACPI_DMAR_DEVICE_SCOPE))
 905                 return (-1);
 906
 907         if (remaining < devscope->Length)
 908                 return (-1);
 909
 910         printf("\n");
 911         printf("\t\tType=%s\n", devscope_type2str(devscope->EntryType));
 912         printf("\t\tLength=%d\n", devscope->Length);
 913         printf("\t\tEnumerationId=%d\n", devscope->EnumerationId);
 914         printf("\t\tStartBusNumber=%d\n", devscope->Bus);
 915
 916         path = (ACPI_DMAR_PCI_PATH *)(devscope + 1);
 917         pathlen = devscope->Length - sizeof(ACPI_DMAR_DEVICE_SCOPE);
 918         pathend = path + pathlen / sizeof(ACPI_DMAR_PCI_PATH);
 919         if (path < pathend) {
 920                 sep = '{';
 921                 printf("\t\tPath=");
 922                 do {
 923                         printf("%c%d:%d", sep, path->Device, path->Function);
 924                         sep=',';
 925                         path++;
 926                 } while (path < pathend);
 927                 printf("}\n");
 928         }
 929
 930         return (devscope->Length);
 931 }
 932
 933 static void
 934 acpi_handle_dmar_drhd(ACPI_DMAR_HARDWARE_UNIT *drhd)
 935 {
 936         char *cp;
 937         int remaining, consumed;
 938
 939         printf("\n");
 940         printf("\tType=DRHD\n");
 941         printf("\tLength=%d\n", drhd->Header.Length);
 942
 943 #define PRINTFLAG(var, flag)    printflag((var), ACPI_DMAR_## flag, #flag)
 944
 945         printf("\tFlags=");
 946         PRINTFLAG(drhd->Flags, INCLUDE_ALL);
 947         PRINTFLAG_END();
 948
 949 #undef PRINTFLAG
 950
 951         printf("\tSegment=%d\n", drhd->Segment);
 952         printf("\tAddress=0x%016jx\n", (uintmax_t)drhd->Address);
 953
 954         remaining = drhd->Header.Length - sizeof(ACPI_DMAR_HARDWARE_UNIT);
 955         if (remaining > 0)
 956                 printf("\tDevice Scope:");
 957         while (remaining > 0) {
 958                 cp = (char *)drhd + drhd->Header.Length - remaining;
 959                 consumed = acpi_handle_dmar_devscope(cp, remaining);
 960                 if (consumed <= 0)
 961                         break;
 962                 else
 963                         remaining -= consumed;
 964         }
 965 }
 966
 967 static void
 968 acpi_handle_dmar_rmrr(ACPI_DMAR_RESERVED_MEMORY *rmrr)
 969 {
 970         char *cp;
 971         int remaining, consumed;
 972
 973         printf("\n");
 974         printf("\tType=RMRR\n");
 975         printf("\tLength=%d\n", rmrr->Header.Length);
 976         printf("\tSegment=%d\n", rmrr->Segment);
 977         printf("\tBaseAddress=0x%016jx\n", (uintmax_t)rmrr->BaseAddress);
 978         printf("\tLimitAddress=0x%016jx\n", (uintmax_t)rmrr->EndAddress);
 979
 980         remaining = rmrr->Header.Length - sizeof(ACPI_DMAR_RESERVED_MEMORY);
 981         if (remaining > 0)
 982                 printf("\tDevice Scope:");
 983         while (remaining > 0) {
 984                 cp = (char *)rmrr + rmrr->Header.Length - remaining;
 985                 consumed = acpi_handle_dmar_devscope(cp, remaining);
 986                 if (consumed <= 0)
 987                         break;
 988                 else
 989                         remaining -= consumed;
 990         }
 991 }
 992
 993 static void
 994 acpi_handle_dmar_atsr(ACPI_DMAR_ATSR *atsr)
 995 {
 996         char *cp;
 997         int remaining, consumed;
 998
 999         printf("\n");
1000         printf("\tType=ATSR\n");
1001         printf("\tLength=%d\n", atsr->Header.Length);
1002
1003 #define PRINTFLAG(var, flag)    printflag((var), ACPI_DMAR_## flag, #flag)
1004
1005         printf("\tFlags=");
1006         PRINTFLAG(atsr->Flags, ALL_PORTS);
1007         PRINTFLAG_END();
1008
1009 #undef PRINTFLAG
1010
1011         printf("\tSegment=%d\n", atsr->Segment);
1012
1013         remaining = atsr->Header.Length - sizeof(ACPI_DMAR_ATSR);
1014         if (remaining > 0)
1015                 printf("\tDevice Scope:");
1016         while (remaining > 0) {
1017                 cp = (char *)atsr + atsr->Header.Length - remaining;
1018                 consumed = acpi_handle_dmar_devscope(cp, remaining);
1019                 if (consumed <= 0)
1020                         break;
1021                 else
1022                         remaining -= consumed;
1023         }
1024 }
1025
1026 static void
1027 acpi_handle_dmar_rhsa(ACPI_DMAR_RHSA *rhsa)
1028 {
1029
1030         printf("\n");
1031         printf("\tType=RHSA\n");
1032         printf("\tLength=%d\n", rhsa->Header.Length);
1033         printf("\tBaseAddress=0x%016jx\n", (uintmax_t)rhsa->BaseAddress);
1034         printf("\tProximityDomain=0x%08x\n", rhsa->ProximityDomain);
1035 }
1036
1037 static int
1038 acpi_handle_dmar_remapping_structure(void *addr, int remaining)
1039 {
1040         ACPI_DMAR_HEADER *hdr = addr;
1041
1042         if (remaining < (int)sizeof(ACPI_DMAR_HEADER))
1043                 return (-1);
1044
1045         if (remaining < hdr->Length)
1046                 return (-1);
1047
1048         switch (hdr->Type) {
1049         case ACPI_DMAR_TYPE_HARDWARE_UNIT:
1050                 acpi_handle_dmar_drhd(addr);
1051                 break;
1052         case ACPI_DMAR_TYPE_RESERVED_MEMORY:
1053                 acpi_handle_dmar_rmrr(addr);
1054                 break;
1055         case ACPI_DMAR_TYPE_ROOT_ATS:
1056                 acpi_handle_dmar_atsr(addr);
1057                 break;
1058         case ACPI_DMAR_TYPE_HARDWARE_AFFINITY:
1059                 acpi_handle_dmar_rhsa(addr);
1060                 break;
1061         default:
1062                 printf("\n");
1063                 printf("\tType=%d\n", hdr->Type);
1064                 printf("\tLength=%d\n", hdr->Length);
1065                 break;
1066         }
1067         return (hdr->Length);
1068 }
1069
1070 #ifndef ACPI_DMAR_X2APIC_OPT_OUT
1071 #define ACPI_DMAR_X2APIC_OPT_OUT        (0x2)
1072 #endif
1073
1074 static void
1075 acpi_handle_dmar(ACPI_TABLE_HEADER *sdp)
1076 {
1077         char *cp;
1078         int remaining, consumed;
1079         ACPI_TABLE_DMAR *dmar;
1080
1081         printf(BEGIN_COMMENT);
1082         acpi_print_sdt(sdp);
1083         dmar = (ACPI_TABLE_DMAR *)sdp;
1084         printf("\tHost Address Width=%d\n", dmar->Width + 1);
1085
1086 #define PRINTFLAG(var, flag)    printflag((var), ACPI_DMAR_## flag, #flag)
1087
1088         printf("\tFlags=");
1089         PRINTFLAG(dmar->Flags, INTR_REMAP);
1090         PRINTFLAG(dmar->Flags, X2APIC_OPT_OUT);
1091         PRINTFLAG_END();
1092
1093 #undef PRINTFLAG
1094
1095         remaining = sdp->Length - sizeof(ACPI_TABLE_DMAR);
1096         while (remaining > 0) {
1097                 cp = (char *)sdp + sdp->Length - remaining;
1098                 consumed = acpi_handle_dmar_remapping_structure(cp, remaining);
1099                 if (consumed <= 0)
1100                         break;
1101                 else
1102                         remaining -= consumed;
1103         }
1104
1105         printf(END_COMMENT);
1106 }
1107
1108 static void
1109 acpi_print_srat_memory(ACPI_SRAT_MEM_AFFINITY *mp)
1110 {
1111
1112         printf("\tFlags={");
1113         if (mp->Flags & ACPI_SRAT_MEM_ENABLED)
1114                 printf("ENABLED");
1115         else
1116                 printf("DISABLED");
1117         if (mp->Flags & ACPI_SRAT_MEM_HOT_PLUGGABLE)
1118                 printf(",HOT_PLUGGABLE");
1119         if (mp->Flags & ACPI_SRAT_MEM_NON_VOLATILE)
1120                 printf(",NON_VOLATILE");
1121         printf("}\n");
1122         printf("\tBase Address=0x%016jx\n", (uintmax_t)mp->BaseAddress);
1123         printf("\tLength=0x%016jx\n", (uintmax_t)mp->Length);
1124         printf("\tProximity Domain=%d\n", mp->ProximityDomain);
1125 }
1126
1127 static const char *srat_types[] = {
1128     [ACPI_SRAT_TYPE_CPU_AFFINITY] = "CPU",
1129     [ACPI_SRAT_TYPE_MEMORY_AFFINITY] = "Memory",
1130     [ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY] = "X2APIC",
1131     [ACPI_SRAT_TYPE_GICC_AFFINITY] = "GICC",
1132     [ACPI_SRAT_TYPE_GIC_ITS_AFFINITY] = "GIC ITS",
1133 };
1134
1135 static void
1136 acpi_print_srat(ACPI_SUBTABLE_HEADER *srat)
1137 {
1138         ACPI_SRAT_CPU_AFFINITY *cpu;
1139         ACPI_SRAT_X2APIC_CPU_AFFINITY *x2apic;
1140         ACPI_SRAT_GICC_AFFINITY *gic;
1141
1142         if (srat->Type < nitems(srat_types))
1143                 printf("\tType=%s\n", srat_types[srat->Type]);
1144         else
1145                 printf("\tType=%d (unknown)\n", srat->Type);
1146         switch (srat->Type) {
1147         case ACPI_SRAT_TYPE_CPU_AFFINITY:
1148                 cpu = (ACPI_SRAT_CPU_AFFINITY *)srat;
1149                 acpi_print_srat_cpu(cpu->ApicId,
1150                     cpu->ProximityDomainHi[2] << 24 |
1151                     cpu->ProximityDomainHi[1] << 16 |
1152                     cpu->ProximityDomainHi[0] << 0 |
1153                     cpu->ProximityDomainLo, cpu->Flags);
1154                 break;
1155         case ACPI_SRAT_TYPE_MEMORY_AFFINITY:
1156                 acpi_print_srat_memory((ACPI_SRAT_MEM_AFFINITY *)srat);
1157                 break;
1158         case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
1159                 x2apic = (ACPI_SRAT_X2APIC_CPU_AFFINITY *)srat;
1160                 acpi_print_srat_cpu(x2apic->ApicId, x2apic->ProximityDomain,
1161                     x2apic->Flags);
1162                 break;
1163         case ACPI_SRAT_TYPE_GICC_AFFINITY:
1164                 gic = (ACPI_SRAT_GICC_AFFINITY *)srat;
1165                 acpi_print_srat_cpu(gic->AcpiProcessorUid, gic->ProximityDomain,
1166                     gic->Flags);
1167                 break;
1168         }
1169 }
1170
1171 static void
1172 acpi_handle_srat(ACPI_TABLE_HEADER *sdp)
1173 {
1174         ACPI_TABLE_SRAT *srat;
1175
1176         printf(BEGIN_COMMENT);
1177         acpi_print_sdt(sdp);
1178         srat = (ACPI_TABLE_SRAT *)sdp;
1179         printf("\tTable Revision=%d\n", srat->TableRevision);
1180         acpi_walk_subtables(sdp, (srat + 1), acpi_print_srat);
1181         printf(END_COMMENT);
1182 }
1183
1184 static const char *nfit_types[] = {
1185     [ACPI_NFIT_TYPE_SYSTEM_ADDRESS] = "System Address",
1186     [ACPI_NFIT_TYPE_MEMORY_MAP] = "Memory Map",
1187     [ACPI_NFIT_TYPE_INTERLEAVE] = "Interleave",
1188     [ACPI_NFIT_TYPE_SMBIOS] = "SMBIOS",
1189     [ACPI_NFIT_TYPE_CONTROL_REGION] = "Control Region",
1190     [ACPI_NFIT_TYPE_DATA_REGION] = "Data Region",
1191     [ACPI_NFIT_TYPE_FLUSH_ADDRESS] = "Flush Address"
1192 };
1193
1194
1195 static void
1196 acpi_print_nfit(ACPI_NFIT_HEADER *nfit)
1197 {
1198         char *uuidstr;
1199         uint32_t status;
1200
1201         ACPI_NFIT_SYSTEM_ADDRESS *sysaddr;
1202         ACPI_NFIT_MEMORY_MAP *mmap;
1203         ACPI_NFIT_INTERLEAVE *ileave;
1204         ACPI_NFIT_SMBIOS *smbios;
1205         ACPI_NFIT_CONTROL_REGION *ctlreg;
1206         ACPI_NFIT_DATA_REGION *datareg;
1207         ACPI_NFIT_FLUSH_ADDRESS *fladdr;
1208
1209         if (nfit->Type < nitems(nfit_types))
1210                 printf("\tType=%s\n", nfit_types[nfit->Type]);
1211         else
1212                 printf("\tType=%u (unknown)\n", nfit->Type);
1213         switch (nfit->Type) {
1214         case ACPI_NFIT_TYPE_SYSTEM_ADDRESS:
1215                 sysaddr = (ACPI_NFIT_SYSTEM_ADDRESS *)nfit;
1216                 printf("\tRangeIndex=%u\n", (u_int)sysaddr->RangeIndex);
1217                 printf("\tProximityDomain=%u\n",
1218                     (u_int)sysaddr->ProximityDomain);
1219                 uuid_to_string((uuid_t *)(sysaddr->RangeGuid),
1220                     &uuidstr, &status);
1221                 if (status != uuid_s_ok)
1222                         errx(1, "uuid_to_string: status=%u", status);
1223                 printf("\tRangeGuid=%s\n", uuidstr);
1224                 free(uuidstr);
1225                 printf("\tAddress=0x%016jx\n", (uintmax_t)sysaddr->Address);
1226                 printf("\tLength=0x%016jx\n", (uintmax_t)sysaddr->Length);
1227                 printf("\tMemoryMapping=0x%016jx\n",
1228                     (uintmax_t)sysaddr->MemoryMapping);
1229
1230 #define PRINTFLAG(var, flag)    printflag((var), ACPI_NFIT_## flag, #flag)
1231
1232                 printf("\tFlags=");
1233                 PRINTFLAG(sysaddr->Flags, ADD_ONLINE_ONLY);
1234                 PRINTFLAG(sysaddr->Flags, PROXIMITY_VALID);
1235                 PRINTFLAG_END();
1236
1237 #undef PRINTFLAG
1238
1239                 break;
1240         case ACPI_NFIT_TYPE_MEMORY_MAP:
1241                 mmap = (ACPI_NFIT_MEMORY_MAP *)nfit;
1242                 printf("\tDeviceHandle=%u\n", (u_int)mmap->DeviceHandle);
1243                 printf("\tPhysicalId=%u\n", (u_int)mmap->PhysicalId);
1244                 printf("\tRegionId=%u\n", (u_int)mmap->RegionId);
1245                 printf("\tRangeIndex=%u\n", (u_int)mmap->RangeIndex);
1246                 printf("\tRegionIndex=%u\n", (u_int)mmap->RegionIndex);
1247                 printf("\tRegionSize=0x%016jx\n", (uintmax_t)mmap->RegionSize);
1248                 printf("\tRegionOffset=0x%016jx\n",
1249                     (uintmax_t)mmap->RegionOffset);
1250                 printf("\tAddress=0x%016jx\n", (uintmax_t)mmap->Address);
1251                 printf("\tInterleaveIndex=%u\n", (u_int)mmap->InterleaveIndex);
1252                 printf("\tInterleaveWays=%u\n", (u_int)mmap->InterleaveWays);
1253
1254 #define PRINTFLAG(var, flag)    printflag((var), ACPI_NFIT_MEM_## flag, #flag)
1255
1256                 printf("\tFlags=");
1257                 PRINTFLAG(mmap->Flags, SAVE_FAILED);
1258                 PRINTFLAG(mmap->Flags, RESTORE_FAILED);
1259                 PRINTFLAG(mmap->Flags, FLUSH_FAILED);
1260                 PRINTFLAG(mmap->Flags, NOT_ARMED);
1261                 PRINTFLAG(mmap->Flags, HEALTH_OBSERVED);
1262                 PRINTFLAG(mmap->Flags, HEALTH_ENABLED);
1263                 PRINTFLAG(mmap->Flags, MAP_FAILED);
1264                 PRINTFLAG_END();
1265
1266 #undef PRINTFLAG
1267
1268                 break;
1269         case ACPI_NFIT_TYPE_INTERLEAVE:
1270                 ileave = (ACPI_NFIT_INTERLEAVE *)nfit;
1271                 printf("\tInterleaveIndex=%u\n",
1272                     (u_int)ileave->InterleaveIndex);
1273                 printf("\tLineCount=%u\n", (u_int)ileave->LineCount);
1274                 printf("\tLineSize=%u\n", (u_int)ileave->LineSize);
1275                 /* XXX ileave->LineOffset[i] output is not supported */
1276                 break;
1277         case ACPI_NFIT_TYPE_SMBIOS:
1278                 smbios = (ACPI_NFIT_SMBIOS *)nfit;
1279                 /* XXX smbios->Data[x] output is not supported */
1280                 break;
1281         case ACPI_NFIT_TYPE_CONTROL_REGION:
1282                 ctlreg = (ACPI_NFIT_CONTROL_REGION *)nfit;
1283                 printf("\tRegionIndex=%u\n", (u_int)ctlreg->RegionIndex);
1284                 printf("\tVendorId=0x%04x\n", (u_int)ctlreg->VendorId);
1285                 printf("\tDeviceId=0x%04x\n", (u_int)ctlreg->DeviceId);
1286                 printf("\tRevisionId=%u\n", (u_int)ctlreg->RevisionId);
1287                 printf("\tSubsystemVendorId=0x%04x\n",
1288                     (u_int)ctlreg->SubsystemVendorId);
1289                 printf("\tSubsystemDeviceId=0x%04x\n",
1290                     (u_int)ctlreg->SubsystemDeviceId);
1291                 printf("\tSubsystemRevisionId=%u\n",
1292                     (u_int)ctlreg->SubsystemRevisionId);
1293                 printf("\tValidFields=0x%02x\n", (u_int)ctlreg->ValidFields);
1294                 printf("\tManufacturingLocation=%u\n",
1295                     (u_int)ctlreg->ManufacturingLocation);
1296                 printf("\tManufacturingDate=%u\n",
1297                     (u_int)ctlreg->ManufacturingDate);
1298                 printf("\tSerialNumber=%u\n",
1299                     (u_int)ctlreg->SerialNumber);
1300                 printf("\tCode=0x%04x\n", (u_int)ctlreg->Code);
1301                 printf("\tWindows=%u\n", (u_int)ctlreg->Windows);
1302                 printf("\tWindowSize=0x%016jx\n",
1303                     (uintmax_t)ctlreg->WindowSize);
1304                 printf("\tCommandOffset=0x%016jx\n",
1305                     (uintmax_t)ctlreg->CommandOffset);
1306                 printf("\tCommandSize=0x%016jx\n",
1307                     (uintmax_t)ctlreg->CommandSize);
1308                 printf("\tStatusOffset=0x%016jx\n",
1309                     (uintmax_t)ctlreg->StatusOffset);
1310                 printf("\tStatusSize=0x%016jx\n",
1311                     (uintmax_t)ctlreg->StatusSize);
1312
1313 #define PRINTFLAG(var, flag)    printflag((var), ACPI_NFIT_## flag, #flag)
1314
1315                 printf("\tFlags=");
1316                 PRINTFLAG(ctlreg->Flags, CONTROL_BUFFERED);
1317                 PRINTFLAG_END();
1318
1319 #undef PRINTFLAG
1320
1321                 break;
1322         case ACPI_NFIT_TYPE_DATA_REGION:
1323                 datareg = (ACPI_NFIT_DATA_REGION *)nfit;
1324                 printf("\tRegionIndex=%u\n", (u_int)datareg->RegionIndex);
1325                 printf("\tWindows=%u\n", (u_int)datareg->Windows);
1326                 printf("\tOffset=0x%016jx\n", (uintmax_t)datareg->Offset);
1327                 printf("\tSize=0x%016jx\n", (uintmax_t)datareg->Size);
1328                 printf("\tCapacity=0x%016jx\n", (uintmax_t)datareg->Capacity);
1329                 printf("\tStartAddress=0x%016jx\n",
1330                     (uintmax_t)datareg->StartAddress);
1331                 break;
1332         case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
1333                 fladdr = (ACPI_NFIT_FLUSH_ADDRESS *)nfit;
1334                 printf("\tDeviceHandle=%u\n", (u_int)fladdr->DeviceHandle);
1335                 printf("\tHintCount=%u\n", (u_int)fladdr->HintCount);
1336                 /* XXX fladdr->HintAddress[i] output is not supported */
1337                 break;
1338         }
1339 }
1340
1341 static void
1342 acpi_handle_nfit(ACPI_TABLE_HEADER *sdp)
1343 {
1344         ACPI_TABLE_NFIT *nfit;
1345
1346         printf(BEGIN_COMMENT);
1347         acpi_print_sdt(sdp);
1348         nfit = (ACPI_TABLE_NFIT *)sdp;
1349         acpi_walk_nfit(sdp, (nfit + 1), acpi_print_nfit);
1350         printf(END_COMMENT);
1351 }
1352
1353 static void
1354 acpi_print_sdt(ACPI_TABLE_HEADER *sdp)
1355 {
1356         printf("  ");
1357         acpi_print_string(sdp->Signature, ACPI_NAME_SIZE);
1358         printf(": Length=%d, Revision=%d, Checksum=%d,\n",
1359                sdp->Length, sdp->Revision, sdp->Checksum);
1360         printf("\tOEMID=");
1361         acpi_print_string(sdp->OemId, ACPI_OEM_ID_SIZE);
1362         printf(", OEM Table ID=");
1363         acpi_print_string(sdp->OemTableId, ACPI_OEM_TABLE_ID_SIZE);
1364         printf(", OEM Revision=0x%x,\n", sdp->OemRevision);
1365         printf("\tCreator ID=");
1366         acpi_print_string(sdp->AslCompilerId, ACPI_NAME_SIZE);
1367         printf(", Creator Revision=0x%x\n", sdp->AslCompilerRevision);
1368 }
1369
1370 static void
1371 acpi_print_rsdt(ACPI_TABLE_HEADER *rsdp)
1372 {
1373         ACPI_TABLE_RSDT *rsdt;
1374         ACPI_TABLE_XSDT *xsdt;
1375         int     i, entries;
1376
1377         rsdt = (ACPI_TABLE_RSDT *)rsdp;
1378         xsdt = (ACPI_TABLE_XSDT *)rsdp;
1379         printf(BEGIN_COMMENT);
1380         acpi_print_sdt(rsdp);
1381         entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size;
1382         printf("\tEntries={ ");
1383         for (i = 0; i < entries; i++) {
1384                 if (i > 0)
1385                         printf(", ");
1386                 if (addr_size == 4)
1387                         printf("0x%08x", le32toh(rsdt->TableOffsetEntry[i]));
1388                 else
1389                         printf("0x%016jx",
1390                             (uintmax_t)le64toh(xsdt->TableOffsetEntry[i]));
1391         }
1392         printf(" }\n");
1393         printf(END_COMMENT);
1394 }
1395
1396 static const char *acpi_pm_profiles[] = {
1397         "Unspecified", "Desktop", "Mobile", "Workstation",
1398         "Enterprise Server", "SOHO Server", "Appliance PC"
1399 };
1400
1401 static void
1402 acpi_print_fadt(ACPI_TABLE_HEADER *sdp)
1403 {
1404         ACPI_TABLE_FADT *fadt;
1405         const char *pm;
1406
1407         fadt = (ACPI_TABLE_FADT *)sdp;
1408         printf(BEGIN_COMMENT);
1409         acpi_print_sdt(sdp);
1410         printf(" \tFACS=0x%x, DSDT=0x%x\n", fadt->Facs,
1411                fadt->Dsdt);
1412         printf("\tINT_MODEL=%s\n", fadt->Model ? "APIC" : "PIC");
1413         if (fadt->PreferredProfile >= sizeof(acpi_pm_profiles) / sizeof(char *))
1414                 pm = "Reserved";
1415         else
1416                 pm = acpi_pm_profiles[fadt->PreferredProfile];
1417         printf("\tPreferred_PM_Profile=%s (%d)\n", pm, fadt->PreferredProfile);
1418         printf("\tSCI_INT=%d\n", fadt->SciInterrupt);
1419         printf("\tSMI_CMD=0x%x, ", fadt->SmiCommand);
1420         printf("ACPI_ENABLE=0x%x, ", fadt->AcpiEnable);
1421         printf("ACPI_DISABLE=0x%x, ", fadt->AcpiDisable);
1422         printf("S4BIOS_REQ=0x%x\n", fadt->S4BiosRequest);
1423         printf("\tPSTATE_CNT=0x%x\n", fadt->PstateControl);
1424         printf("\tPM1a_EVT_BLK=0x%x-0x%x\n",
1425                fadt->Pm1aEventBlock,
1426                fadt->Pm1aEventBlock + fadt->Pm1EventLength - 1);
1427         if (fadt->Pm1bEventBlock != 0)
1428                 printf("\tPM1b_EVT_BLK=0x%x-0x%x\n",
1429                        fadt->Pm1bEventBlock,
1430                        fadt->Pm1bEventBlock + fadt->Pm1EventLength - 1);
1431         printf("\tPM1a_CNT_BLK=0x%x-0x%x\n",
1432                fadt->Pm1aControlBlock,
1433                fadt->Pm1aControlBlock + fadt->Pm1ControlLength - 1);
1434         if (fadt->Pm1bControlBlock != 0)
1435                 printf("\tPM1b_CNT_BLK=0x%x-0x%x\n",
1436                        fadt->Pm1bControlBlock,
1437                        fadt->Pm1bControlBlock + fadt->Pm1ControlLength - 1);
1438         if (fadt->Pm2ControlBlock != 0)
1439                 printf("\tPM2_CNT_BLK=0x%x-0x%x\n",
1440                        fadt->Pm2ControlBlock,
1441                        fadt->Pm2ControlBlock + fadt->Pm2ControlLength - 1);
1442         printf("\tPM_TMR_BLK=0x%x-0x%x\n",
1443                fadt->PmTimerBlock,
1444                fadt->PmTimerBlock + fadt->PmTimerLength - 1);
1445         if (fadt->Gpe0Block != 0)
1446                 printf("\tGPE0_BLK=0x%x-0x%x\n",
1447                        fadt->Gpe0Block,
1448                        fadt->Gpe0Block + fadt->Gpe0BlockLength - 1);
1449         if (fadt->Gpe1Block != 0)
1450                 printf("\tGPE1_BLK=0x%x-0x%x, GPE1_BASE=%d\n",
1451                        fadt->Gpe1Block,
1452                        fadt->Gpe1Block + fadt->Gpe1BlockLength - 1,
1453                        fadt->Gpe1Base);
1454         if (fadt->CstControl != 0)
1455                 printf("\tCST_CNT=0x%x\n", fadt->CstControl);
1456         printf("\tP_LVL2_LAT=%d us, P_LVL3_LAT=%d us\n",
1457                fadt->C2Latency, fadt->C3Latency);
1458         printf("\tFLUSH_SIZE=%d, FLUSH_STRIDE=%d\n",
1459                fadt->FlushSize, fadt->FlushStride);
1460         printf("\tDUTY_OFFSET=%d, DUTY_WIDTH=%d\n",
1461                fadt->DutyOffset, fadt->DutyWidth);
1462         printf("\tDAY_ALRM=%d, MON_ALRM=%d, CENTURY=%d\n",
1463                fadt->DayAlarm, fadt->MonthAlarm, fadt->Century);
1464
1465 #define PRINTFLAG(var, flag)    printflag((var), ACPI_FADT_## flag, #flag)
1466
1467         printf("\tIAPC_BOOT_ARCH=");
1468         PRINTFLAG(fadt->BootFlags, LEGACY_DEVICES);
1469         PRINTFLAG(fadt->BootFlags, 8042);
1470         PRINTFLAG(fadt->BootFlags, NO_VGA);
1471         PRINTFLAG(fadt->BootFlags, NO_MSI);
1472         PRINTFLAG(fadt->BootFlags, NO_ASPM);
1473         PRINTFLAG(fadt->BootFlags, NO_CMOS_RTC);
1474         PRINTFLAG_END();
1475
1476         printf("\tFlags=");
1477         PRINTFLAG(fadt->Flags, WBINVD);
1478         PRINTFLAG(fadt->Flags, WBINVD_FLUSH);
1479         PRINTFLAG(fadt->Flags, C1_SUPPORTED);
1480         PRINTFLAG(fadt->Flags, C2_MP_SUPPORTED);
1481         PRINTFLAG(fadt->Flags, POWER_BUTTON);
1482         PRINTFLAG(fadt->Flags, SLEEP_BUTTON);
1483         PRINTFLAG(fadt->Flags, FIXED_RTC);
1484         PRINTFLAG(fadt->Flags, S4_RTC_WAKE);
1485         PRINTFLAG(fadt->Flags, 32BIT_TIMER);
1486         PRINTFLAG(fadt->Flags, DOCKING_SUPPORTED);
1487         PRINTFLAG(fadt->Flags, RESET_REGISTER);
1488         PRINTFLAG(fadt->Flags, SEALED_CASE);
1489         PRINTFLAG(fadt->Flags, HEADLESS);
1490         PRINTFLAG(fadt->Flags, SLEEP_TYPE);
1491         PRINTFLAG(fadt->Flags, PCI_EXPRESS_WAKE);
1492         PRINTFLAG(fadt->Flags, PLATFORM_CLOCK);
1493         PRINTFLAG(fadt->Flags, S4_RTC_VALID);
1494         PRINTFLAG(fadt->Flags, REMOTE_POWER_ON);
1495         PRINTFLAG(fadt->Flags, APIC_CLUSTER);
1496         PRINTFLAG(fadt->Flags, APIC_PHYSICAL);
1497         PRINTFLAG(fadt->Flags, HW_REDUCED);
1498         PRINTFLAG(fadt->Flags, LOW_POWER_S0);
1499         PRINTFLAG_END();
1500
1501 #undef PRINTFLAG
1502
1503         if (fadt->Flags & ACPI_FADT_RESET_REGISTER) {
1504                 printf("\tRESET_REG=");
1505                 acpi_print_gas(&fadt->ResetRegister);
1506                 printf(", RESET_VALUE=%#x\n", fadt->ResetValue);
1507         }
1508         if (acpi_get_fadt_revision(fadt) > 1) {
1509                 printf("\tX_FACS=0x%016jx, ", (uintmax_t)fadt->XFacs);
1510                 printf("X_DSDT=0x%016jx\n", (uintmax_t)fadt->XDsdt);
1511                 printf("\tX_PM1a_EVT_BLK=");
1512                 acpi_print_gas(&fadt->XPm1aEventBlock);
1513                 if (fadt->XPm1bEventBlock.Address != 0) {
1514                         printf("\n\tX_PM1b_EVT_BLK=");
1515                         acpi_print_gas(&fadt->XPm1bEventBlock);
1516                 }
1517                 printf("\n\tX_PM1a_CNT_BLK=");
1518                 acpi_print_gas(&fadt->XPm1aControlBlock);
1519                 if (fadt->XPm1bControlBlock.Address != 0) {
1520                         printf("\n\tX_PM1b_CNT_BLK=");
1521                         acpi_print_gas(&fadt->XPm1bControlBlock);
1522                 }
1523                 if (fadt->XPm2ControlBlock.Address != 0) {
1524                         printf("\n\tX_PM2_CNT_BLK=");
1525                         acpi_print_gas(&fadt->XPm2ControlBlock);
1526                 }
1527                 printf("\n\tX_PM_TMR_BLK=");
1528                 acpi_print_gas(&fadt->XPmTimerBlock);
1529                 if (fadt->XGpe0Block.Address != 0) {
1530                         printf("\n\tX_GPE0_BLK=");
1531                         acpi_print_gas(&fadt->XGpe0Block);
1532                 }
1533                 if (fadt->XGpe1Block.Address != 0) {
1534                         printf("\n\tX_GPE1_BLK=");
1535                         acpi_print_gas(&fadt->XGpe1Block);
1536                 }
1537                 printf("\n");
1538         }
1539
1540         printf(END_COMMENT);
1541 }
1542
1543 static void
1544 acpi_print_facs(ACPI_TABLE_FACS *facs)
1545 {
1546         printf(BEGIN_COMMENT);
1547         printf("  FACS:\tLength=%u, ", facs->Length);
1548         printf("HwSig=0x%08x, ", facs->HardwareSignature);
1549         printf("Firm_Wake_Vec=0x%08x\n", facs->FirmwareWakingVector);
1550
1551         printf("\tGlobal_Lock=");
1552         if (facs->GlobalLock != 0) {
1553                 if (facs->GlobalLock & ACPI_GLOCK_PENDING)
1554                         printf("PENDING,");
1555                 if (facs->GlobalLock & ACPI_GLOCK_OWNED)
1556                         printf("OWNED");
1557         }
1558         printf("\n");
1559
1560         printf("\tFlags=");
1561         if (facs->Flags & ACPI_FACS_S4_BIOS_PRESENT)
1562                 printf("S4BIOS");
1563         printf("\n");
1564
1565         if (facs->XFirmwareWakingVector != 0)
1566                 printf("\tX_Firm_Wake_Vec=%016jx\n",
1567                     (uintmax_t)facs->XFirmwareWakingVector);
1568         printf("\tVersion=%u\n", facs->Version);
1569
1570         printf(END_COMMENT);
1571 }
1572
1573 static void
1574 acpi_print_dsdt(ACPI_TABLE_HEADER *dsdp)
1575 {
1576         printf(BEGIN_COMMENT);
1577         acpi_print_sdt(dsdp);
1578         printf(END_COMMENT);
1579 }
1580
1581 int
1582 acpi_checksum(void *p, size_t length)
1583 {
1584         uint8_t *bp;
1585         uint8_t sum;
1586
1587         bp = p;
1588         sum = 0;
1589         while (length--)
1590                 sum += *bp++;
1591
1592         return (sum);
1593 }
1594
1595 static ACPI_TABLE_HEADER *
1596 acpi_map_sdt(vm_offset_t pa)
1597 {
1598         ACPI_TABLE_HEADER *sp;
1599
1600         sp = acpi_map_physical(pa, sizeof(ACPI_TABLE_HEADER));
1601         sp = acpi_map_physical(pa, sp->Length);
1602         return (sp);
1603 }
1604
1605 static void
1606 acpi_print_rsd_ptr(ACPI_TABLE_RSDP *rp)
1607 {
1608         printf(BEGIN_COMMENT);
1609         printf("  RSD PTR: OEM=");
1610         acpi_print_string(rp->OemId, ACPI_OEM_ID_SIZE);
1611         printf(", ACPI_Rev=%s (%d)\n", rp->Revision < 2 ? "1.0x" : "2.0x",
1612                rp->Revision);
1613         if (rp->Revision < 2) {
1614                 printf("\tRSDT=0x%08x, cksum=%u\n", rp->RsdtPhysicalAddress,
1615                     rp->Checksum);
1616         } else {
1617                 printf("\tXSDT=0x%016jx, length=%u, cksum=%u\n",
1618                     (uintmax_t)rp->XsdtPhysicalAddress, rp->Length,
1619                     rp->ExtendedChecksum);
1620         }
1621         printf(END_COMMENT);
1622 }
1623
1624 static void
1625 acpi_handle_rsdt(ACPI_TABLE_HEADER *rsdp)
1626 {
1627         ACPI_TABLE_HEADER *sdp;
1628         ACPI_TABLE_RSDT *rsdt;
1629         ACPI_TABLE_XSDT *xsdt;
1630         vm_offset_t addr;
1631         int entries, i;
1632
1633         acpi_print_rsdt(rsdp);
1634         rsdt = (ACPI_TABLE_RSDT *)rsdp;
1635         xsdt = (ACPI_TABLE_XSDT *)rsdp;
1636         entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size;
1637         for (i = 0; i < entries; i++) {
1638                 if (addr_size == 4)
1639                         addr = le32toh(rsdt->TableOffsetEntry[i]);
1640                 else
1641                         addr = le64toh(xsdt->TableOffsetEntry[i]);
1642                 if (addr == 0)
1643                         continue;
1644                 sdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(addr);
1645                 if (acpi_checksum(sdp, sdp->Length)) {
1646                         warnx("RSDT entry %d (sig %.4s) is corrupt", i,
1647                             sdp->Signature);
1648                         continue;
1649                 }
1650                 if (!memcmp(sdp->Signature, ACPI_SIG_FADT, 4))
1651                         acpi_handle_fadt(sdp);
1652                 else if (!memcmp(sdp->Signature, ACPI_SIG_MADT, 4))
1653                         acpi_handle_madt(sdp);
1654                 else if (!memcmp(sdp->Signature, ACPI_SIG_HPET, 4))
1655                         acpi_handle_hpet(sdp);
1656                 else if (!memcmp(sdp->Signature, ACPI_SIG_ECDT, 4))
1657                         acpi_handle_ecdt(sdp);
1658                 else if (!memcmp(sdp->Signature, ACPI_SIG_MCFG, 4))
1659                         acpi_handle_mcfg(sdp);
1660                 else if (!memcmp(sdp->Signature, ACPI_SIG_SLIT, 4))
1661                         acpi_handle_slit(sdp);
1662                 else if (!memcmp(sdp->Signature, ACPI_SIG_SRAT, 4))
1663                         acpi_handle_srat(sdp);
1664                 else if (!memcmp(sdp->Signature, ACPI_SIG_TCPA, 4))
1665                         acpi_handle_tcpa(sdp);
1666                 else if (!memcmp(sdp->Signature, ACPI_SIG_DMAR, 4))
1667                         acpi_handle_dmar(sdp);
1668                 else if (!memcmp(sdp->Signature, ACPI_SIG_NFIT, 4))
1669                         acpi_handle_nfit(sdp);
1670                 else if (!memcmp(sdp->Signature, ACPI_SIG_TPM2, 4))
1671                         acpi_handle_tpm2(sdp);
1672                 else {
1673                         printf(BEGIN_COMMENT);
1674                         acpi_print_sdt(sdp);
1675                         printf(END_COMMENT);
1676                 }
1677         }
1678 }
1679
1680 ACPI_TABLE_HEADER *
1681 sdt_load_devmem(void)
1682 {
1683         ACPI_TABLE_RSDP *rp;
1684         ACPI_TABLE_HEADER *rsdp;
1685
1686         rp = acpi_find_rsd_ptr();
1687         if (!rp)
1688                 errx(1, "Can't find ACPI information");
1689
1690         if (tflag)
1691                 acpi_print_rsd_ptr(rp);
1692         if (rp->Revision < 2) {
1693                 rsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(rp->RsdtPhysicalAddress);
1694                 if (memcmp(rsdp->Signature, "RSDT", 4) != 0 ||
1695                     acpi_checksum(rsdp, rsdp->Length) != 0)
1696                         errx(1, "RSDT is corrupted");
1697                 addr_size = sizeof(uint32_t);
1698         } else {
1699                 rsdp = (ACPI_TABLE_HEADER *)acpi_map_sdt(rp->XsdtPhysicalAddress);
1700                 if (memcmp(rsdp->Signature, "XSDT", 4) != 0 ||
1701                     acpi_checksum(rsdp, rsdp->Length) != 0)
1702                         errx(1, "XSDT is corrupted");
1703                 addr_size = sizeof(uint64_t);
1704         }
1705         return (rsdp);
1706 }
1707
1708 /* Write the DSDT to a file, concatenating any SSDTs (if present). */
1709 static int
1710 write_dsdt(int fd, ACPI_TABLE_HEADER *rsdt, ACPI_TABLE_HEADER *dsdt)
1711 {
1712         ACPI_TABLE_HEADER sdt;
1713         ACPI_TABLE_HEADER *ssdt;
1714         uint8_t sum;
1715
1716         /* Create a new checksum to account for the DSDT and any SSDTs. */
1717         sdt = *dsdt;
1718         if (rsdt != NULL) {
1719                 sdt.Checksum = 0;
1720                 sum = acpi_checksum(dsdt + 1, dsdt->Length -
1721                     sizeof(ACPI_TABLE_HEADER));
1722                 ssdt = sdt_from_rsdt(rsdt, ACPI_SIG_SSDT, NULL);
1723                 while (ssdt != NULL) {
1724                         sdt.Length += ssdt->Length - sizeof(ACPI_TABLE_HEADER);
1725                         sum += acpi_checksum(ssdt + 1,
1726                             ssdt->Length - sizeof(ACPI_TABLE_HEADER));
1727                         ssdt = sdt_from_rsdt(rsdt, ACPI_SIG_SSDT, ssdt);
1728                 }
1729                 sum += acpi_checksum(&sdt, sizeof(ACPI_TABLE_HEADER));
1730                 sdt.Checksum -= sum;
1731         }
1732
1733         /* Write out the DSDT header and body. */
1734         write(fd, &sdt, sizeof(ACPI_TABLE_HEADER));
1735         write(fd, dsdt + 1, dsdt->Length - sizeof(ACPI_TABLE_HEADER));
1736
1737         /* Write out any SSDTs (if present.) */
1738         if (rsdt != NULL) {
1739                 ssdt = sdt_from_rsdt(rsdt, "SSDT", NULL);
1740                 while (ssdt != NULL) {
1741                         write(fd, ssdt + 1, ssdt->Length -
1742                             sizeof(ACPI_TABLE_HEADER));
1743                         ssdt = sdt_from_rsdt(rsdt, "SSDT", ssdt);
1744                 }
1745         }
1746         return (0);
1747 }
1748
1749 void
1750 dsdt_save_file(char *outfile, ACPI_TABLE_HEADER *rsdt, ACPI_TABLE_HEADER *dsdp)
1751 {
1752         int     fd;
1753         mode_t  mode;
1754
1755         assert(outfile != NULL);
1756         mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
1757         fd = open(outfile, O_WRONLY | O_CREAT | O_TRUNC, mode);
1758         if (fd == -1) {
1759                 perror("dsdt_save_file");
1760                 return;
1761         }
1762         write_dsdt(fd, rsdt, dsdp);
1763         close(fd);
1764 }
1765
1766 void
1767 aml_disassemble(ACPI_TABLE_HEADER *rsdt, ACPI_TABLE_HEADER *dsdp)
1768 {
1769         char buf[PATH_MAX], tmpstr[PATH_MAX], wrkdir[PATH_MAX];
1770         const char *iname = "/acpdump.din";
1771         const char *oname = "/acpdump.dsl";
1772         const char *tmpdir;
1773         FILE *fp;
1774         size_t len;
1775         int fd, status;
1776         pid_t pid;
1777
1778         tmpdir = getenv("TMPDIR");
1779         if (tmpdir == NULL)
1780                 tmpdir = _PATH_TMP;
1781         if (realpath(tmpdir, buf) == NULL) {
1782                 perror("realpath tmp dir");
1783                 return;
1784         }
1785         len = sizeof(wrkdir) - strlen(iname);
1786         if ((size_t)snprintf(wrkdir, len, "%s/acpidump.XXXXXX", buf) > len-1 ) {
1787                 fprintf(stderr, "$TMPDIR too long\n");
1788                 return;
1789         }
1790         if  (mkdtemp(wrkdir) == NULL) {
1791                 perror("mkdtemp tmp working dir");
1792                 return;
1793         }
1794         len = (size_t)snprintf(tmpstr, sizeof(tmpstr), "%s%s", wrkdir, iname);
1795         assert(len <= sizeof(tmpstr) - 1);
1796         fd = open(tmpstr, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
1797         if (fd < 0) {
1798                 perror("iasl tmp file");
1799                 return;
1800         }
1801         write_dsdt(fd, rsdt, dsdp);
1802         close(fd);
1803
1804         /* Run iasl -d on the temp file */
1805         if ((pid = fork()) == 0) {
1806                 close(STDOUT_FILENO);
1807                 if (vflag == 0)
1808                         close(STDERR_FILENO);
1809                 execl("/usr/sbin/iasl", "iasl", "-d", tmpstr, NULL);
1810                 err(1, "exec");
1811         }
1812         if (pid > 0)
1813                 wait(&status);
1814         if (unlink(tmpstr) < 0) {
1815                 perror("unlink");
1816                 goto out;
1817         }
1818         if (pid < 0) {
1819                 perror("fork");
1820                 goto out;
1821         }
1822         if (status != 0) {
1823                 fprintf(stderr, "iast exit status = %d\n", status);
1824         }
1825
1826         /* Dump iasl's output to stdout */
1827         len = (size_t)snprintf(tmpstr, sizeof(tmpstr), "%s%s", wrkdir, oname);
1828         assert(len <= sizeof(tmpstr) - 1);
1829         fp = fopen(tmpstr, "r");
1830         if (unlink(tmpstr) < 0) {
1831                 perror("unlink");
1832                 goto out;
1833         }
1834         if (fp == NULL) {
1835                 perror("iasl tmp file (read)");
1836                 goto out;
1837         }
1838         while ((len = fread(buf, 1, sizeof(buf), fp)) > 0)
1839                 fwrite(buf, 1, len, stdout);
1840         fclose(fp);
1841
1842     out:
1843         if (rmdir(wrkdir) < 0)
1844                 perror("rmdir");
1845 }
1846
1847 void
1848 sdt_print_all(ACPI_TABLE_HEADER *rsdp)
1849 {
1850         acpi_handle_rsdt(rsdp);
1851 }
1852
1853 /* Fetch a table matching the given signature via the RSDT. */
1854 ACPI_TABLE_HEADER *
1855 sdt_from_rsdt(ACPI_TABLE_HEADER *rsdp, const char *sig, ACPI_TABLE_HEADER *last)
1856 {
1857         ACPI_TABLE_HEADER *sdt;
1858         ACPI_TABLE_RSDT *rsdt;
1859         ACPI_TABLE_XSDT *xsdt;
1860         vm_offset_t addr;
1861         int entries, i;
1862
1863         rsdt = (ACPI_TABLE_RSDT *)rsdp;
1864         xsdt = (ACPI_TABLE_XSDT *)rsdp;
1865         entries = (rsdp->Length - sizeof(ACPI_TABLE_HEADER)) / addr_size;
1866         for (i = 0; i < entries; i++) {
1867                 if (addr_size == 4)
1868                         addr = le32toh(rsdt->TableOffsetEntry[i]);
1869                 else
1870                         addr = le64toh(xsdt->TableOffsetEntry[i]);
1871                 if (addr == 0)
1872                         continue;
1873                 sdt = (ACPI_TABLE_HEADER *)acpi_map_sdt(addr);
1874                 if (last != NULL) {
1875                         if (sdt == last)
1876                                 last = NULL;
1877                         continue;
1878                 }
1879                 if (memcmp(sdt->Signature, sig, strlen(sig)))
1880                         continue;
1881                 if (acpi_checksum(sdt, sdt->Length))
1882                         errx(1, "RSDT entry %d is corrupt", i);
1883                 return (sdt);
1884         }
1885
1886         return (NULL);
1887 }
1888
1889 ACPI_TABLE_HEADER *
1890 dsdt_from_fadt(ACPI_TABLE_FADT *fadt)
1891 {
1892         ACPI_TABLE_HEADER       *sdt;
1893
1894         /* Use the DSDT address if it is version 1, otherwise use XDSDT. */
1895         if (acpi_get_fadt_revision(fadt) == 1)
1896                 sdt = (ACPI_TABLE_HEADER *)acpi_map_sdt(fadt->Dsdt);
1897         else
1898                 sdt = (ACPI_TABLE_HEADER *)acpi_map_sdt(fadt->XDsdt);
1899         if (acpi_checksum(sdt, sdt->Length))
1900                 errx(1, "DSDT is corrupt\n");
1901         return (sdt);
1902 }