14 files changed, 940 insertions, 189 deletions

diff --git a/sys/contrib/dev/acpica/common/acfileio.c b/sys/contrib/dev/acpica/common/acfileio.c
index 5124e2d7f1ed..b93b14d3e654 100644
--- a/sys/contrib/dev/acpica/common/acfileio.c
+++ b/sys/contrib/dev/acpica/common/acfileio.c
@@ -559,6 +559,9 @@ AcValidateTableHeader (
 
     if (Actual < sizeof (ACPI_TABLE_HEADER))
     {
+        fprintf (stderr,
+            "Could not read entire table header: Actual %u, Requested %u\n",
+            (UINT32) Actual, (UINT32) sizeof (ACPI_TABLE_HEADER));
         return (AE_ERROR);
     }
 
diff --git a/sys/contrib/dev/acpica/common/ahids.c b/sys/contrib/dev/acpica/common/ahids.c
index 6249fa40369a..35d17513a57b 100644
--- a/sys/contrib/dev/acpica/common/ahids.c
+++ b/sys/contrib/dev/acpica/common/ahids.c
@@ -188,6 +188,8 @@ const AH_DEVICE_ID  AslDeviceIds[] =
     {"ACPI0012",    "NVDIMM Root Device"},
     {"ACPI0013",    "Generic Event Device"},
     {"ACPI0014",    "Wireless Power Calibration Device"},
+    {"ACPI0015",    "USB4 host interface device"},
+    {"ACPI0016",    "Compute Express Link Host Bridge"},
     {"ADMA0F28",    "Intel Audio DMA"},
     {"AMCR0F28",    "Intel Audio Machine Driver"},
     {"ATK4001",     "Asus Radio Control Button"},
diff --git a/sys/contrib/dev/acpica/common/ahpredef.c b/sys/contrib/dev/acpica/common/ahpredef.c
index 5f407bcbf2f4..89f8a784efd3 100644
--- a/sys/contrib/dev/acpica/common/ahpredef.c
+++ b/sys/contrib/dev/acpica/common/ahpredef.c
@@ -200,12 +200,16 @@ const AH_PREDEFINED_NAME    AslPredefinedInfo[] =
     AH_PREDEF ("_BMC",    "Battery Maintenance Control", "Sets battery maintenance and control features"),
     AH_PREDEF ("_BMD",    "Battery Maintenance Data", "Returns battery maintenance, control, and state data"),
     AH_PREDEF ("_BMS",    "Battery Measurement Sampling Time", "Sets the battery measurement sampling time"),
+    AH_PREDEF ("_BPC",    "Battery Power Characteristics", "Returns static values used to configure power threshold support in the platform firmware"),
+    AH_PREDEF ("_BPS",    "Battery Power State", "Returns the power delivery capabilities of the battery at the present time"),
+    AH_PREDEF ("_BPT",    "Battery Power Threshold", "Set a relative battery peak power capability change threshold"),
     AH_PREDEF ("_BQC",    "Brightness Query Current", "Returns the current display brightness level"),
     AH_PREDEF ("_BST",    "Battery Status", "Returns a Control Method Battery status block"),
     AH_PREDEF ("_BTH",    "Battery Throttle Limit", "Thermal limit for charging and discharging"),
     AH_PREDEF ("_BTM",    "Battery Time", "Returns the battery runtime"),
     AH_PREDEF ("_BTP",    "Battery Trip Point", "Sets a Control Method Battery trip point"),
     AH_PREDEF ("_CBA",    "Configuration Base Address", "Sets the base address for a PCI Express host bridge"),
+    AH_PREDEF ("_CBR",    "CXL Host Bridge Register Info", "Get the memory location of CXL Host Bridge Registers"),
     AH_PREDEF ("_CCA",    "Cache Coherency Attribute", "Returns a device's support level for cache coherency"),
     AH_PREDEF ("_CDM",    "Clock Domain", "Returns a logical processor's clock domain identifier"),
     AH_PREDEF ("_CID",    "Compatible ID", "Returns a device's Plug and Play Compatible ID list"),
diff --git a/sys/contrib/dev/acpica/common/ahtable.c b/sys/contrib/dev/acpica/common/ahtable.c
index cf369e4c0695..3d3eee5b41b4 100644
--- a/sys/contrib/dev/acpica/common/ahtable.c
+++ b/sys/contrib/dev/acpica/common/ahtable.c
@@ -203,6 +203,7 @@ const AH_TABLE      AcpiGbl_SupportedTables[] =
     {ACPI_SIG_BERT, "Boot Error Record Table"},
     {ACPI_SIG_BGRT, "Boot Graphics Resource Table"},
     {ACPI_SIG_BOOT, "Simple Boot Flag Table"},
+    {ACPI_SIG_CEDT, "CXL Early Discovery Table"},
     {ACPI_SIG_CPEP, "Corrected Platform Error Polling table"},
     {ACPI_SIG_CSRT, "Core System Resource Table"},
     {ACPI_SIG_DBG2, "Debug Port table type 2"},
@@ -231,6 +232,7 @@ const AH_TABLE      AcpiGbl_SupportedTables[] =
     {ACPI_SIG_MSDM, "Microsoft Data Management table"},
     {ACPI_SIG_NFIT, "NVDIMM Firmware Interface Table"},
     {ACPI_SIG_PCCT, "Platform Communications Channel Table"},
+    {ACPI_SIG_PHAT, "Platform Health Assessment Table"},
     {ACPI_SIG_PDTT, "Platform Debug Trigger Table"},
     {ACPI_SIG_PMTT, "Platform Memory Topology Table"},
     {ACPI_SIG_PPTT, "Processor Properties Topology Table"},
@@ -251,6 +253,7 @@ const AH_TABLE      AcpiGbl_SupportedTables[] =
     {ACPI_SIG_TCPA, "Trusted Computing Platform Alliance table"},
     {ACPI_SIG_TPM2, "Trusted Platform Module hardware interface table"},
     {ACPI_SIG_UEFI, "UEFI Boot Optimization Table"},
+    {ACPI_SIG_VIOT, "Virtual I/O Translation Table"},
     {ACPI_SIG_WAET, "Windows ACPI Emulated Devices Table"},
     {ACPI_SIG_WDAT, "Watchdog Action Table"},
     {ACPI_SIG_WDDT, "Watchdog Description Table"},
diff --git a/sys/contrib/dev/acpica/common/ahuuids.c b/sys/contrib/dev/acpica/common/ahuuids.c
index 13c764d298a8..73585e81c4da 100644
--- a/sys/contrib/dev/acpica/common/ahuuids.c
+++ b/sys/contrib/dev/acpica/common/ahuuids.c
@@ -208,6 +208,7 @@ const AH_UUID  Gbl_AcpiUuids[] =
     {"Device Graphs for _DSD",      UUID_DEVICE_GRAPHS},
     {"Hierarchical Data Extension", UUID_HIERARCHICAL_DATA_EXTENSION},
     {"ARM Coresight Graph",         UUID_CORESIGHT_GRAPH},
+    {"USB4 Capabilities",           UUID_USB4_CAPABILITIES},
     {NULL, NULL}
 };
 
diff --git a/sys/contrib/dev/acpica/common/cmfsize.c b/sys/contrib/dev/acpica/common/cmfsize.c
index 7026c17b43bc..eb419a94f9af 100644
--- a/sys/contrib/dev/acpica/common/cmfsize.c
+++ b/sys/contrib/dev/acpica/common/cmfsize.c
@@ -1,6 +1,6 @@
 /******************************************************************************
  *
- * Module Name: cfsize - Common get file size function
+ * Module Name: cmfsize - Common get file size function
  *
  *****************************************************************************/
 
diff --git a/sys/contrib/dev/acpica/common/dmrestag.c b/sys/contrib/dev/acpica/common/dmrestag.c
index 15ddb8f2da44..a430a6d7a1c7 100644
--- a/sys/contrib/dev/acpica/common/dmrestag.c
+++ b/sys/contrib/dev/acpica/common/dmrestag.c
@@ -384,6 +384,14 @@ static const ACPI_RESOURCE_TAG      AcpiDmGpioIoTags[] =
 
 /* Subtype tables for SerialBus descriptors */
 
+static const ACPI_RESOURCE_TAG      AcpiDmCsi2SerialBusTags[] =    /* ACPI 6.4 */
+{
+    {( 6 * 8) + 0,  ACPI_RESTAG_SLAVEMODE},
+    {( 7 * 8) + 0,  ACPI_RESTAG_PHYTYPE},
+    {( 7 * 8) + 2,  ACPI_RESTAG_LOCALPORT},
+    {0,             NULL}
+};
+
 static const ACPI_RESOURCE_TAG      AcpiDmI2cSerialBusTags[] =
 {
     {( 6 * 8) + 0,  ACPI_RESTAG_SLAVEMODE},
@@ -424,6 +432,7 @@ static const ACPI_RESOURCE_TAG      AcpiDmUartSerialBusTags[] =
     {0,             NULL}
 };
 
+
 /* Subtype tables for PinFunction descriptor */
 
 static const ACPI_RESOURCE_TAG      AcpiDmPinFunctionTags[] =
@@ -539,7 +548,8 @@ static const ACPI_RESOURCE_TAG      *AcpiGbl_SerialResourceTags[] =
     NULL,                           /* 0x00 Reserved */
     AcpiDmI2cSerialBusTags,         /* 0x01 I2C SerialBus */
     AcpiDmSpiSerialBusTags,         /* 0x02 SPI SerialBus */
-    AcpiDmUartSerialBusTags         /* 0x03 UART SerialBus */
+    AcpiDmUartSerialBusTags,        /* 0x03 UART SerialBus */
+    AcpiDmCsi2SerialBusTags         /* 0x04 CSI2 SerialBus */
 };
 
 /*
@@ -987,7 +997,7 @@ AcpiDmGetResourceTag (
 
     case ACPI_RESOURCE_NAME_SERIAL_BUS:
 
-        /* SerialBus has 3 subtypes: I2C, SPI, and UART */
+        /* SerialBus has 4 subtypes: I2C, SPI, UART, and CSI2 */
 
         if ((Resource->CommonSerialBus.Type == 0) ||
             (Resource->CommonSerialBus.Type > AML_RESOURCE_MAX_SERIALBUSTYPE))
diff --git a/sys/contrib/dev/acpica/common/dmtable.c b/sys/contrib/dev/acpica/common/dmtable.c
index 565a76071aad..6f34e82c1b62 100644
--- a/sys/contrib/dev/acpica/common/dmtable.c
+++ b/sys/contrib/dev/acpica/common/dmtable.c
@@ -184,6 +184,12 @@ static const char           *AcpiDmAsfSubnames[] =
     "Unknown Subtable Type"         /* Reserved */
 };
 
+static const char           *AcpiDmCedtSubnames[] =
+{
+    "CXL Host Bridge Structure",
+    "Unknown Subtable Type"         /* Reserved */
+};
+
 static const char           *AcpiDmDmarSubnames[] =
 {
     "Hardware Unit Definition",
@@ -367,15 +373,24 @@ static const char           *AcpiDmPcctSubnames[] =
     "HW-Reduced Comm Subspace Type2",   /* ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2 */
     "Extended PCC Master Subspace",     /* ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE */
     "Extended PCC Slave Subspace",      /* ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE */
+    "HW Registers based Comm Subspace", /* ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE */
     "Unknown Subtable Type"             /* Reserved */
 };
 
+static const char           *AcpiDmPhatSubnames[] =
+{
+    "Firmware Version Data",        /* ACPI_PHAT_TYPE_FW_VERSION_DATA */
+    "Firmware Health Data",         /* ACPI_PHAT_TYPE_FW_HEALTH_DATA */
+    "Unknown Subtable Type"         /* Reserved */
+};
+
 static const char           *AcpiDmPmttSubnames[] =
 {
     "Socket",                       /* ACPI_PMTT_TYPE_SOCKET */
     "Memory Controller",            /* ACPI_PMTT_TYPE_CONTROLLER */
     "Physical Component (DIMM)",    /* ACPI_PMTT_TYPE_DIMM */
-    "Unknown Subtable Type"         /* Reserved */
+    "Unknown Subtable Type",        /* Reserved */
+    "Vendor Specific"               /* ACPI_PMTT_TYPE_VENDOR */
 };
 
 static const char           *AcpiDmPpttSubnames[] =
@@ -434,6 +449,16 @@ static const char           *AcpiDmLpitSubnames[] =
     "Unknown Subtable Type"         /* Reserved */
 };
 
+static const char           *AcpiDmViotSubnames[] =
+{
+    "Unknown Subtable Type",        /* 0 -Reserved */
+    "PCI Range",
+    "MMIO Endpoint",
+    "VirtIO-PCI IOMMU",
+    "VirtIO-MMIO IOMMU",
+    "Unknown Subtable Type"         /* Reserved */
+};
+
 #define ACPI_FADT_PM_RESERVED       9
 
 static const char           *AcpiDmFadtProfiles[] =
@@ -474,8 +499,8 @@ static const char           *AcpiDmGasAccessWidth[] =
  * handler. This table must be NULL terminated. RSDP and FACS are
  * special-cased elsewhere.
  *
- * Note: Any tables added here should be duplicated within AcpiSupportedTables
- * in the file common/ahtable.c
+ * Note: Any tables added here should be duplicated within
+ * AcpiGbl_SupportedTables in the file common/ahtable.c
  *
  ******************************************************************************/
 
@@ -485,6 +510,7 @@ const ACPI_DMTABLE_DATA     AcpiDmTableData[] =
     {ACPI_SIG_BERT, AcpiDmTableInfoBert,    NULL,           NULL,           TemplateBert},
     {ACPI_SIG_BGRT, AcpiDmTableInfoBgrt,    NULL,           NULL,           TemplateBgrt},
     {ACPI_SIG_BOOT, AcpiDmTableInfoBoot,    NULL,           NULL,           TemplateBoot},
+    {ACPI_SIG_CEDT, NULL,                   AcpiDmDumpCedt, DtCompileCedt,  TemplateCedt},
     {ACPI_SIG_CPEP, NULL,                   AcpiDmDumpCpep, DtCompileCpep,  TemplateCpep},
     {ACPI_SIG_CSRT, NULL,                   AcpiDmDumpCsrt, DtCompileCsrt,  TemplateCsrt},
     {ACPI_SIG_DBG2, AcpiDmTableInfoDbg2,    AcpiDmDumpDbg2, DtCompileDbg2,  TemplateDbg2},
@@ -512,6 +538,7 @@ const ACPI_DMTABLE_DATA     AcpiDmTableData[] =
     {ACPI_SIG_NFIT, AcpiDmTableInfoNfit,    AcpiDmDumpNfit, DtCompileNfit,  TemplateNfit},
     {ACPI_SIG_PCCT, AcpiDmTableInfoPcct,    AcpiDmDumpPcct, DtCompilePcct,  TemplatePcct},
     {ACPI_SIG_PDTT, AcpiDmTableInfoPdtt,    AcpiDmDumpPdtt, DtCompilePdtt,  TemplatePdtt},
+    {ACPI_SIG_PHAT, NULL,                   AcpiDmDumpPhat, DtCompilePhat,  TemplatePhat},
     {ACPI_SIG_PMTT, NULL,                   AcpiDmDumpPmtt, DtCompilePmtt,  TemplatePmtt},
     {ACPI_SIG_PPTT, NULL,                   AcpiDmDumpPptt, DtCompilePptt,  TemplatePptt},
     {ACPI_SIG_RASF, AcpiDmTableInfoRasf,    NULL,           NULL,           TemplateRasf},
@@ -529,6 +556,7 @@ const ACPI_DMTABLE_DATA     AcpiDmTableData[] =
     {ACPI_SIG_TCPA, NULL,                   AcpiDmDumpTcpa, DtCompileTcpa,  TemplateTcpa},
     {ACPI_SIG_TPM2, AcpiDmTableInfoTpm2,    AcpiDmDumpTpm2, DtCompileTpm2,  TemplateTpm2},
     {ACPI_SIG_UEFI, AcpiDmTableInfoUefi,    NULL,           DtCompileUefi,  TemplateUefi},
+    {ACPI_SIG_VIOT, AcpiDmTableInfoViot,    AcpiDmDumpViot, DtCompileViot,  TemplateViot},
     {ACPI_SIG_WAET, AcpiDmTableInfoWaet,    NULL,           NULL,           TemplateWaet},
     {ACPI_SIG_WDAT, NULL,                   AcpiDmDumpWdat, DtCompileWdat,  TemplateWdat},
     {ACPI_SIG_WDDT, AcpiDmTableInfoWddt,    NULL,           NULL,           TemplateWddt},
@@ -936,6 +964,7 @@ AcpiDmDumpTable (
         case ACPI_DMT_CHKSUM:
         case ACPI_DMT_SPACEID:
         case ACPI_DMT_ACCWIDTH:
+        case ACPI_DMT_CEDT:
         case ACPI_DMT_IVRS:
         case ACPI_DMT_GTDT:
         case ACPI_DMT_MADT:
@@ -952,6 +981,7 @@ AcpiDmDumpTable (
         case ACPI_DMT_ERSTACT:
         case ACPI_DMT_ERSTINST:
         case ACPI_DMT_DMAR_SCOPE:
+        case ACPI_DMT_VIOT:
 
             ByteLength = 1;
             break;
@@ -961,6 +991,7 @@ AcpiDmDumpTable (
         case ACPI_DMT_HEST:
         case ACPI_DMT_HMAT:
         case ACPI_DMT_NFIT:
+        case ACPI_DMT_PHAT:
 
             ByteLength = 2;
             break;
@@ -1030,6 +1061,17 @@ AcpiDmDumpTable (
             ByteLength = SubtableLength;
             break;
 
+        case ACPI_DMT_PMTT_VENDOR:
+            /*
+             * Calculate the length of the vendor data for the PMTT table:
+             * Length = (Current Subtable ptr + Subtable length) -
+             *          Start of the vendor data (Target)
+             */
+            ByteLength = ((ACPI_CAST_PTR (char, Table) +
+                            (ACPI_CAST_PTR (ACPI_PMTT_HEADER, Table)->Length)) -
+                            ACPI_CAST_PTR (char, Target));
+            break;
+
         case ACPI_DMT_STRING:
 
             ByteLength = strlen (ACPI_CAST_PTR (char, Target)) + 1;
@@ -1346,6 +1388,20 @@ AcpiDmDumpTable (
             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmAsfSubnames[Temp16]);
             break;
 
+        case ACPI_DMT_CEDT:
+
+            /* CEDT subtable types */
+
+            Temp8 = *Target;
+            if (Temp8 > ACPI_CEDT_TYPE_RESERVED)
+            {
+                Temp8 = ACPI_CEDT_TYPE_RESERVED;
+            }
+
+            AcpiOsPrintf (UINT8_FORMAT, *Target,
+                AcpiDmCedtSubnames[Temp8]);
+            break;
+
         case ACPI_DMT_DMAR:
 
             /* DMAR subtable types */
@@ -1559,16 +1615,33 @@ AcpiDmDumpTable (
                 AcpiDmPcctSubnames[Temp8]);
             break;
 
+        case ACPI_DMT_PHAT:
+
+            /* PMTT subtable types */
+
+            Temp16 = *Target;
+            if (Temp16 > ACPI_PHAT_TYPE_RESERVED)
+            {
+                Temp16 = ACPI_PHAT_TYPE_RESERVED;
+            }
+
+            AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16(Target),
+                AcpiDmPhatSubnames[Temp16]);
+            break;
+
         case ACPI_DMT_PMTT:
 
             /* PMTT subtable types */
 
             Temp8 = *Target;
-            if (Temp8 > ACPI_PMTT_TYPE_RESERVED)
+            if (Temp8 == ACPI_PMTT_TYPE_VENDOR)
+            {
+                Temp8 = ACPI_PMTT_TYPE_RESERVED + 1;
+            }
+            else if (Temp8 > ACPI_PMTT_TYPE_RESERVED)
             {
                 Temp8 = ACPI_PMTT_TYPE_RESERVED;
             }
-
             AcpiOsPrintf (UINT8_FORMAT, *Target,
                 AcpiDmPmttSubnames[Temp8]);
             break;
@@ -1599,6 +1672,8 @@ AcpiDmDumpTable (
             break;
 
         case ACPI_DMT_RAW_BUFFER:
+        case ACPI_DMT_BUFFER:
+        case ACPI_DMT_PMTT_VENDOR:
 
             if (ByteLength == 0)
             {
@@ -1606,8 +1681,7 @@ AcpiDmDumpTable (
                 break;
             }
 
-            AcpiDmDumpBuffer (Table, CurrentOffset, ByteLength,
-                CurrentOffset, NULL);
+            AcpiDmDumpBuffer (Target, 0, ByteLength, 0, NULL);
             break;
 
         case ACPI_DMT_SDEV:
@@ -1676,6 +1750,7 @@ AcpiDmDumpTable (
             {
             case ACPI_IVRS_TYPE_HARDWARE1:
             case ACPI_IVRS_TYPE_HARDWARE2:
+            case ACPI_IVRS_TYPE_HARDWARE3:
 
                 Name = AcpiDmIvrsSubnames[0];
                 break;
@@ -1710,6 +1785,20 @@ AcpiDmDumpTable (
                 AcpiDmLpitSubnames[Temp32]);
             break;
 
+        case ACPI_DMT_VIOT:
+
+            /* VIOT subtable types */
+
+            Temp8 = *Target;
+            if (Temp8 > ACPI_VIOT_RESERVED)
+            {
+                Temp8 = ACPI_VIOT_RESERVED;
+            }
+
+            AcpiOsPrintf (UINT8_FORMAT, *Target,
+                AcpiDmViotSubnames[Temp8]);
+            break;
+
         case ACPI_DMT_EXIT:
 
             return (AE_OK);
diff --git a/sys/contrib/dev/acpica/common/dmtbdump1.c b/sys/contrib/dev/acpica/common/dmtbdump1.c
index b9b30dc2f4a5..d134c63f856a 100644
--- a/sys/contrib/dev/acpica/common/dmtbdump1.c
+++ b/sys/contrib/dev/acpica/common/dmtbdump1.c
@@ -329,6 +329,82 @@ AcpiDmDumpAsf (
     }
 }
 
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDmDumpCedt
+ *
+ * PARAMETERS:  Table               - A CEDT table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Format the contents of a CEDT. This table type consists
+ *              of an open-ended number of subtables.
+ *
+ ******************************************************************************/
+
+void
+AcpiDmDumpCedt (
+    ACPI_TABLE_HEADER       *Table)
+{
+    ACPI_STATUS             Status;
+    ACPI_CEDT_HEADER        *Subtable;
+    UINT32                  Length = Table->Length;
+    UINT32                  Offset = sizeof (ACPI_TABLE_CEDT);
+    ACPI_DMTABLE_INFO       *InfoTable;
+
+
+    /* There is no main table (other than the standard ACPI header) */
+
+    Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Table, Offset);
+    while (Offset < Table->Length)
+    {
+        /* Common subtable header */
+
+        AcpiOsPrintf ("\n");
+        Status = AcpiDmDumpTable (Length, Offset, Subtable,
+            Subtable->Length, AcpiDmTableInfoCedtHdr);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
+
+        switch (Subtable->Type)
+        {
+        case ACPI_CEDT_TYPE_CHBS:
+
+            InfoTable = AcpiDmTableInfoCedt0;
+            break;
+
+        default:
+
+            AcpiOsPrintf ("\n**** Unknown CEDT subtable type 0x%X\n\n",
+                Subtable->Type);
+
+            /* Attempt to continue */
+
+            if (!Subtable->Length)
+            {
+                AcpiOsPrintf ("Invalid zero length subtable\n");
+                return;
+            }
+            goto NextSubtable;
+        }
+
+        Status = AcpiDmDumpTable (Length, Offset, Subtable,
+            Subtable->Length, InfoTable);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
+
+NextSubtable:
+        /* Point to next subtable */
+
+        Offset += Subtable->Length;
+        Subtable = ACPI_ADD_PTR (ACPI_CEDT_HEADER, Subtable,
+            Subtable->Length);
+    }
+}
 
 /*******************************************************************************
  *
diff --git a/sys/contrib/dev/acpica/common/dmtbdump2.c b/sys/contrib/dev/acpica/common/dmtbdump2.c
index e5124a26d587..e3ab39b53078 100644
--- a/sys/contrib/dev/acpica/common/dmtbdump2.c
+++ b/sys/contrib/dev/acpica/common/dmtbdump2.c
@@ -181,6 +181,7 @@ AcpiDmDumpIort (
     ACPI_IORT_NODE          *IortNode;
     ACPI_IORT_ITS_GROUP     *IortItsGroup = NULL;
     ACPI_IORT_SMMU          *IortSmmu = NULL;
+    ACPI_IORT_RMR           *IortRmr = NULL;
     UINT32                  Offset;
     UINT32                  NodeOffset;
     UINT32                  Length;
@@ -188,6 +189,7 @@ AcpiDmDumpIort (
     char                    *String;
     UINT32                  i;
     UINT32                  MappingByteLength;
+    UINT8                   Revision;
 
 
     /* Main table */
@@ -198,6 +200,17 @@ AcpiDmDumpIort (
         return;
     }
 
+    Revision = Table->Revision;
+
+    /* Both IORT Rev E and E.a have known issues and are not supported */
+
+    if (Revision == 1 || Revision == 2)
+    {
+        AcpiOsPrintf ("\n**** Unsupported IORT revision 0x%X\n",
+                      Revision);
+        return;
+    }
+
     Iort = ACPI_CAST_PTR (ACPI_TABLE_IORT, Table);
     Offset = sizeof (ACPI_TABLE_IORT);
 
@@ -221,8 +234,18 @@ AcpiDmDumpIort (
         IortNode = ACPI_ADD_PTR (ACPI_IORT_NODE, Table, Offset);
         AcpiOsPrintf ("\n");
         Length = ACPI_OFFSET (ACPI_IORT_NODE, NodeData);
-        Status = AcpiDmDumpTable (Table->Length, Offset,
-            IortNode, Length, AcpiDmTableInfoIortHdr);
+
+        if (Revision == 0)
+        {
+            Status = AcpiDmDumpTable (Table->Length, Offset,
+                IortNode, Length, AcpiDmTableInfoIortHdr);
+        }
+        else if (Revision >= 3)
+        {
+            Status = AcpiDmDumpTable (Table->Length, Offset,
+                IortNode, Length, AcpiDmTableInfoIortHdr3);
+        }
+
         if (ACPI_FAILURE (Status))
         {
             return;
@@ -272,6 +295,13 @@ AcpiDmDumpIort (
             Length = IortNode->Length - NodeOffset;
             break;
 
+        case ACPI_IORT_NODE_RMR:
+
+            InfoTable = AcpiDmTableInfoIort6;
+            Length = IortNode->Length - NodeOffset;
+            IortRmr = ACPI_ADD_PTR (ACPI_IORT_RMR, IortNode, NodeOffset);
+            break;
+
         default:
 
             AcpiOsPrintf ("\n**** Unknown IORT node type 0x%X\n",
@@ -391,7 +421,30 @@ AcpiDmDumpIort (
             }
             break;
 
-        default:
+        case ACPI_IORT_NODE_RMR:
+
+            /* Validate IortRmr to avoid compiler warnings */
+            if (IortRmr)
+            {
+                NodeOffset = IortRmr->RmrOffset;
+                Length = sizeof (ACPI_IORT_RMR_DESC);
+                for (i = 0; i < IortRmr->RmrCount; i++)
+                {
+                    AcpiOsPrintf ("\n");
+                    Status = AcpiDmDumpTable (Table->Length, Offset + NodeOffset,
+                        ACPI_ADD_PTR (ACPI_IORT_NODE, IortNode, NodeOffset),
+                        Length, AcpiDmTableInfoIort6a);
+                    if (ACPI_FAILURE (Status))
+                    {
+                        return;
+                    }
+
+                    NodeOffset += Length;
+                }
+            }
+            break;
+
+	default:
 
             break;
         }
@@ -434,8 +487,6 @@ NextSubtable:
  *
  ******************************************************************************/
 
-static UINT8 EntrySizes[] = {4,8,16,32};
-
 void
 AcpiDmDumpIvrs (
     ACPI_TABLE_HEADER       *Table)
@@ -445,6 +496,7 @@ AcpiDmDumpIvrs (
     UINT32                  EntryOffset;
     UINT32                  EntryLength;
     UINT32                  EntryType;
+    ACPI_IVRS_DEVICE_HID    *HidSubtable;
     ACPI_IVRS_DE_HEADER     *DeviceEntry;
     ACPI_IVRS_HEADER        *Subtable;
     ACPI_DMTABLE_INFO       *InfoTable;
@@ -481,6 +533,7 @@ AcpiDmDumpIvrs (
             break;
 
         case ACPI_IVRS_TYPE_HARDWARE2:
+        case ACPI_IVRS_TYPE_HARDWARE3:
 
             InfoTable = AcpiDmTableInfoIvrs01;
             break;
@@ -520,7 +573,8 @@ AcpiDmDumpIvrs (
         /* The hardware subtable can contain multiple device entries */
 
         if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1 ||
-            Subtable->Type == ACPI_IVRS_TYPE_HARDWARE2)
+            Subtable->Type == ACPI_IVRS_TYPE_HARDWARE2 ||
+            Subtable->Type == ACPI_IVRS_TYPE_HARDWARE3)
         {
             if (Subtable->Type == ACPI_IVRS_TYPE_HARDWARE1)
             {
@@ -545,11 +599,10 @@ AcpiDmDumpIvrs (
                  *
                  * 00 = 4 byte
                  * 01 = 8 byte
-                 * 10 = 16 byte - currently no entries defined
-                 * 11 = 32 byte - currently no entries defined
+                 * 1x = variable length
                  */
                 EntryType = DeviceEntry->Type;
-                EntryLength = EntrySizes [EntryType >> 6];
+                EntryLength = EntryType >> 6 == 1 ? 8 : 4;
 
                 switch (EntryType)
                 {
@@ -588,6 +641,14 @@ AcpiDmDumpIvrs (
                     InfoTable = AcpiDmTableInfoIvrs8c;
                     break;
 
+                /* Variable-length entries */
+
+                case ACPI_IVRS_TYPE_HID:
+
+                    EntryLength = 22;
+                    InfoTable = AcpiDmTableInfoIvrsHid;
+                    break;
+
                 default:
                     InfoTable = AcpiDmTableInfoIvrs4;
                     AcpiOsPrintf (
@@ -606,9 +667,24 @@ AcpiDmDumpIvrs (
                     return;
                 }
 
+                HidSubtable = ACPI_CAST_PTR (ACPI_IVRS_DEVICE_HID, DeviceEntry);
                 EntryOffset += EntryLength;
                 DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER, DeviceEntry,
                     EntryLength);
+
+                if (EntryType == ACPI_IVRS_TYPE_HID)
+                {
+                    EntryLength = HidSubtable->UidLength;
+                    Status = AcpiDmDumpTable (Table->Length, EntryOffset,
+                        Table, EntryLength, AcpiDmTableInfoIvrsHid1);
+                    if (ACPI_FAILURE (Status))
+                    {
+                        return;
+                    }
+                    EntryOffset += EntryLength;
+                    DeviceEntry = ACPI_ADD_PTR (ACPI_IVRS_DE_HEADER,
+                        DeviceEntry, EntryLength);
+                }
             }
         }
 
@@ -825,6 +901,11 @@ AcpiDmDumpMadt (
             InfoTable = AcpiDmTableInfoMadt15;
             break;
 
+        case ACPI_MADT_TYPE_MULTIPROC_WAKEUP:
+
+            InfoTable = AcpiDmTableInfoMadt16;
+            break;
+
         default:
 
             AcpiOsPrintf ("\n**** Unknown MADT subtable type 0x%X\n\n",
@@ -1380,6 +1461,11 @@ AcpiDmDumpPcct (
             InfoTable = AcpiDmTableInfoPcct4;
             break;
 
+        case ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE:
+
+            InfoTable = AcpiDmTableInfoPcct5;
+            break;
+
         default:
 
             AcpiOsPrintf (
@@ -1461,201 +1547,224 @@ AcpiDmDumpPdtt (
 
 /*******************************************************************************
  *
- * FUNCTION:    AcpiDmDumpPmtt
+ * FUNCTION:    AcpiDmDumpPhat
  *
- * PARAMETERS:  Table               - A PMTT table
+ * PARAMETERS:  Table               - A PHAT table
  *
  * RETURN:      None
  *
- * DESCRIPTION: Format the contents of a PMTT. This table type consists
- *              of an open-ended number of subtables.
+ * DESCRIPTION: Format the contents of a PHAT.
  *
  ******************************************************************************/
 
 void
-AcpiDmDumpPmtt (
+AcpiDmDumpPhat (
     ACPI_TABLE_HEADER       *Table)
 {
     ACPI_STATUS             Status;
-    ACPI_PMTT_HEADER        *Subtable;
-    ACPI_PMTT_HEADER        *MemSubtable;
-    ACPI_PMTT_HEADER        *DimmSubtable;
-    ACPI_PMTT_DOMAIN        *DomainArray;
+    ACPI_DMTABLE_INFO       *InfoTable;
+    ACPI_PHAT_HEADER        *Subtable;
+    ACPI_PHAT_VERSION_DATA  *VersionData;
+    UINT32                  RecordCount;
     UINT32                  Length = Table->Length;
-    UINT32                  Offset = sizeof (ACPI_TABLE_PMTT);
-    UINT32                  MemOffset;
-    UINT32                  DimmOffset;
-    UINT32                  DomainOffset;
-    UINT32                  DomainCount;
-
+    UINT32                  Offset = sizeof (ACPI_TABLE_PHAT);
+    UINT32                  SubtableLength;
+    UINT32                  PathLength;
+    UINT32                  VendorLength;
 
-    /* Main table */
 
-    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
-    if (ACPI_FAILURE (Status))
-    {
-        return;
-    }
+    Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Table, sizeof (ACPI_TABLE_PHAT));
 
-    /* Subtables */
-
-    Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
     while (Offset < Table->Length)
     {
         /* Common subtable header */
 
         AcpiOsPrintf ("\n");
-        Status = AcpiDmDumpTable (Length, Offset, Subtable,
-            Subtable->Length, AcpiDmTableInfoPmttHdr);
+        Status = AcpiDmDumpTable (Length, 0, Subtable,
+            sizeof (ACPI_PHAT_HEADER), AcpiDmTableInfoPhatHdr);
         if (ACPI_FAILURE (Status))
         {
             return;
         }
 
-        /* Only Socket subtables are expected at this level */
-
-        if (Subtable->Type != ACPI_PMTT_TYPE_SOCKET)
+        switch (Subtable->Type)
         {
-            AcpiOsPrintf (
-                "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
+        case ACPI_PHAT_TYPE_FW_VERSION_DATA:
+
+            InfoTable = AcpiDmTableInfoPhat0;
+            SubtableLength = sizeof (ACPI_PHAT_VERSION_DATA);
+            break;
+
+        case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
+
+            InfoTable = AcpiDmTableInfoPhat1;
+            SubtableLength = sizeof (ACPI_PHAT_HEALTH_DATA);
+            break;
+
+        default:
+
+            AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
                 Subtable->Type);
+
             return;
         }
 
-        /* Dump the fixed-length portion of the subtable */
-
-        Status = AcpiDmDumpTable (Length, Offset, Subtable,
-            Subtable->Length, AcpiDmTableInfoPmtt0);
+        Status = AcpiDmDumpTable (Length, 0, Subtable,
+            SubtableLength, InfoTable);
         if (ACPI_FAILURE (Status))
         {
             return;
         }
 
-        /* Walk the memory controller subtables */
-
-        MemOffset = sizeof (ACPI_PMTT_SOCKET);
-        MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Subtable,
-            sizeof (ACPI_PMTT_SOCKET));
-
-        while (((Offset + MemOffset) < Table->Length) &&
-            (MemOffset < Subtable->Length))
+        switch (Subtable->Type)
         {
-            /* Common subtable header */
+        case ACPI_PHAT_TYPE_FW_VERSION_DATA:
 
-            AcpiOsPrintf ("\n");
-            Status = AcpiDmDumpTable (Length,
-                Offset + MemOffset, MemSubtable,
-                MemSubtable->Length, AcpiDmTableInfoPmttHdr);
-            if (ACPI_FAILURE (Status))
+            VersionData = ACPI_CAST_PTR (ACPI_PHAT_VERSION_DATA, Subtable);
+            RecordCount = VersionData->ElementCount;
+            while (RecordCount)
             {
-                return;
+                Status = AcpiDmDumpTable (Length, Offset,
+                    ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_VERSION_DATA)),
+                    sizeof (ACPI_PHAT_VERSION_ELEMENT), AcpiDmTableInfoPhat0a);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
+
+                RecordCount--;
             }
 
-            /* Only memory controller subtables are expected at this level */
+            break;
+
+        case ACPI_PHAT_TYPE_FW_HEALTH_DATA:
 
-            if (MemSubtable->Type != ACPI_PMTT_TYPE_CONTROLLER)
+            /* account for the null terminator */
+
+            PathLength = strlen (ACPI_ADD_PTR (char, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA))) + 1;
+            Status = AcpiDmDumpTable (Length, Offset,
+                ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA)),
+                PathLength, AcpiDmTableInfoPhat1a);
+            if (ACPI_FAILURE (Status))
             {
-                AcpiOsPrintf (
-                    "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
-                    MemSubtable->Type);
                 return;
             }
 
-            /* Dump the fixed-length portion of the controller subtable */
+            /* Get vendor data - data length is the remaining subtable length */
 
-            Status = AcpiDmDumpTable (Length,
-                Offset + MemOffset, MemSubtable,
-                MemSubtable->Length, AcpiDmTableInfoPmtt1);
+            VendorLength =
+                Subtable->Length - sizeof (ACPI_PHAT_HEALTH_DATA) - PathLength;
+            Status = AcpiDmDumpTable (Length, 0,
+                ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable, sizeof (ACPI_PHAT_HEALTH_DATA) + PathLength),
+                VendorLength, AcpiDmTableInfoPhat1b);
             if (ACPI_FAILURE (Status))
             {
                 return;
             }
+            break;
 
-            /* Walk the variable count of proximity domains */
+        default:
 
-            DomainCount = ((ACPI_PMTT_CONTROLLER *) MemSubtable)->DomainCount;
-            DomainOffset = sizeof (ACPI_PMTT_CONTROLLER);
-            DomainArray = ACPI_ADD_PTR (ACPI_PMTT_DOMAIN, MemSubtable,
-                sizeof (ACPI_PMTT_CONTROLLER));
+            AcpiOsPrintf ("\n**** Unknown PHAT subtable type 0x%X\n\n",
+                Subtable->Type);
+            return;
+        }
 
-            while (((Offset + MemOffset + DomainOffset) < Table->Length) &&
-                ((MemOffset + DomainOffset) < Subtable->Length) &&
-                DomainCount)
-            {
-                Status = AcpiDmDumpTable (Length,
-                    Offset + MemOffset + DomainOffset, DomainArray,
-                    sizeof (ACPI_PMTT_DOMAIN), AcpiDmTableInfoPmtt1a);
-                if (ACPI_FAILURE (Status))
-                {
-                    return;
-                }
+        /* Next subtable */
 
-                DomainOffset += sizeof (ACPI_PMTT_DOMAIN);
-                DomainArray++;
-                DomainCount--;
-            }
+        Offset += Subtable->Length;
+        Subtable = ACPI_ADD_PTR (ACPI_PHAT_HEADER, Subtable,
+            Subtable->Length);
+    }
+}
 
-            if (DomainCount)
-            {
-                AcpiOsPrintf (
-                    "\n**** DomainCount exceeds subtable length\n\n");
-            }
 
-            /* Walk the physical component (DIMM) subtables */
+/*******************************************************************************
+ *
+ * FUNCTION:    AcpiDmDumpPmtt
+ *
+ * PARAMETERS:  Table               - A PMTT table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Format the contents of a PMTT. This table type consists
+ *              of an open-ended number of subtables.
+ *
+ ******************************************************************************/
 
-            DimmOffset = DomainOffset;
-            DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, MemSubtable,
-                DomainOffset);
+void
+AcpiDmDumpPmtt (
+    ACPI_TABLE_HEADER       *Table)
+{
+    ACPI_STATUS             Status;
+    ACPI_PMTT_HEADER        *Subtable;
+    UINT32                  Length = Table->Length;
+    UINT32                  Offset = sizeof (ACPI_TABLE_PMTT);
 
-            while (((Offset + MemOffset + DimmOffset) < Table->Length) &&
-                (DimmOffset < MemSubtable->Length))
-            {
-                /* Common subtable header */
 
-                AcpiOsPrintf ("\n");
-                Status = AcpiDmDumpTable (Length,
-                    Offset + MemOffset + DimmOffset, DimmSubtable,
-                    DimmSubtable->Length, AcpiDmTableInfoPmttHdr);
-                if (ACPI_FAILURE (Status))
-                {
-                    return;
-                }
+    /* Main table */
 
-                /* Only DIMM subtables are expected at this level */
+    Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoPmtt);
+    if (ACPI_FAILURE (Status))
+    {
+        return;
+    }
 
-                if (DimmSubtable->Type != ACPI_PMTT_TYPE_DIMM)
-                {
-                    AcpiOsPrintf (
-                        "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
-                        DimmSubtable->Type);
-                    return;
-                }
+    /* Subtables */
 
-                /* Dump the fixed-length DIMM subtable */
+    Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER, Table, Offset);
+    while (Offset < Table->Length)
+    {
+        /* Each of the types below contain the common subtable header */
 
-                Status = AcpiDmDumpTable (Length,
-                    Offset + MemOffset + DimmOffset, DimmSubtable,
-                    DimmSubtable->Length, AcpiDmTableInfoPmtt2);
-                if (ACPI_FAILURE (Status))
-                {
-                    return;
-                }
+        AcpiOsPrintf ("\n");
+        switch (Subtable->Type)
+        {
+        case ACPI_PMTT_TYPE_SOCKET:
+
+            Status = AcpiDmDumpTable (Length, Offset, Subtable,
+                Subtable->Length, AcpiDmTableInfoPmtt0);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
+            break;
 
-                /* Point to next DIMM subtable */
+        case ACPI_PMTT_TYPE_CONTROLLER:
+            Status = AcpiDmDumpTable (Length, Offset, Subtable,
+                Subtable->Length, AcpiDmTableInfoPmtt1);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
+            break;
 
-                DimmOffset += DimmSubtable->Length;
-                DimmSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
-                    DimmSubtable, DimmSubtable->Length);
+       case ACPI_PMTT_TYPE_DIMM:
+            Status = AcpiDmDumpTable (Length, Offset, Subtable,
+                Subtable->Length, AcpiDmTableInfoPmtt2);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
             }
+            break;
 
-            /* Point to next Controller subtable */
+        case ACPI_PMTT_TYPE_VENDOR:
+            Status = AcpiDmDumpTable (Length, Offset, Subtable,
+                Subtable->Length, AcpiDmTableInfoPmttVendor);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
+            break;
 
-            MemOffset += MemSubtable->Length;
-            MemSubtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
-                MemSubtable, MemSubtable->Length);
+        default:
+            AcpiOsPrintf (
+                "\n**** Unexpected or unknown PMTT subtable type 0x%X\n\n",
+                Subtable->Type);
+            return;
         }
 
-        /* Point to next Socket subtable */
+        /* Point to next subtable */
 
         Offset += Subtable->Length;
         Subtable = ACPI_ADD_PTR (ACPI_PMTT_HEADER,
@@ -1786,6 +1895,21 @@ AcpiDmDumpPptt (
             }
             break;
 
+        case ACPI_PPTT_TYPE_CACHE:
+
+            if (Table->Revision < 3)
+            {
+                break;
+            }
+            Status = AcpiDmDumpTable (Table->Length, Offset + SubtableOffset,
+                ACPI_ADD_PTR (ACPI_SUBTABLE_HEADER, Subtable, SubtableOffset),
+                sizeof (ACPI_PPTT_CACHE_V1), AcpiDmTableInfoPptt1a);
+            if (ACPI_FAILURE (Status))
+            {
+                return;
+            }
+            break;
+
         default:
 
             break;
@@ -1906,17 +2030,20 @@ void
 AcpiDmDumpSdev (
     ACPI_TABLE_HEADER       *Table)
 {
-    ACPI_STATUS             Status;
-    ACPI_SDEV_HEADER        *Subtable;
-    ACPI_SDEV_PCIE          *Pcie;
-    ACPI_SDEV_NAMESPACE     *Namesp;
-    ACPI_DMTABLE_INFO       *InfoTable;
-    UINT32                  Length = Table->Length;
-    UINT32                  Offset = sizeof (ACPI_TABLE_SDEV);
-    UINT16                  PathOffset;
-    UINT16                  PathLength;
-    UINT16                  VendorDataOffset;
-    UINT16                  VendorDataLength;
+    ACPI_STATUS                 Status;
+    ACPI_SDEV_HEADER            *Subtable;
+    ACPI_SDEV_PCIE              *Pcie;
+    ACPI_SDEV_NAMESPACE         *Namesp;
+    ACPI_DMTABLE_INFO           *InfoTable;
+    ACPI_DMTABLE_INFO           *SecureComponentInfoTable;
+    UINT32                      Length = Table->Length;
+    UINT32                      Offset = sizeof (ACPI_TABLE_SDEV);
+    UINT16                      PathOffset;
+    UINT16                      PathLength;
+    UINT16                      VendorDataOffset;
+    UINT16                      VendorDataLength;
+    ACPI_SDEV_SECURE_COMPONENT  *SecureComponent = NULL;
+    UINT32                      CurrentOffset = 0;
 
 
     /* Main table */
@@ -1959,7 +2086,7 @@ AcpiDmDumpSdev (
         }
 
         AcpiOsPrintf ("\n");
-        Status = AcpiDmDumpTable (Table->Length, Offset, Subtable,
+        Status = AcpiDmDumpTable (Table->Length, 0, Subtable,
             Subtable->Length, InfoTable);
         if (ACPI_FAILURE (Status))
         {
@@ -1970,6 +2097,52 @@ AcpiDmDumpSdev (
         {
         case ACPI_SDEV_TYPE_NAMESPACE_DEVICE:
 
+            CurrentOffset = sizeof (ACPI_SDEV_NAMESPACE);
+            if (Subtable->Flags & ACPI_SDEV_SECURE_COMPONENTS_PRESENT)
+            {
+                SecureComponent = ACPI_CAST_PTR (ACPI_SDEV_SECURE_COMPONENT,
+                    ACPI_ADD_PTR (UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)));
+
+                Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
+                    ACPI_ADD_PTR(UINT8, Subtable, sizeof (ACPI_SDEV_NAMESPACE)),
+                    sizeof (ACPI_SDEV_SECURE_COMPONENT), AcpiDmTableInfoSdev0b);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
+                CurrentOffset += sizeof (ACPI_SDEV_SECURE_COMPONENT);
+
+                Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
+                    ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
+                    sizeof (ACPI_SDEV_HEADER), AcpiDmTableInfoSdevSecCompHdr);
+                if (ACPI_FAILURE (Status))
+                {
+                    return;
+                }
+                CurrentOffset += sizeof (ACPI_SDEV_HEADER);
+
+                switch (Subtable->Type)
+                {
+                case ACPI_SDEV_TYPE_ID_COMPONENT:
+
+                    SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompId;
+                    break;
+
+                case ACPI_SDEV_TYPE_MEM_COMPONENT:
+
+                    SecureComponentInfoTable = AcpiDmTableInfoSdevSecCompMem;
+                    break;
+
+                default:
+                    goto NextSubtable;
+                }
+
+                Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
+                    ACPI_ADD_PTR(UINT8, Subtable, SecureComponent->SecureComponentOffset),
+                    SecureComponent->SecureComponentLength, SecureComponentInfoTable);
+                CurrentOffset += SecureComponent->SecureComponentLength;
+            }
+
             /* Dump the PCIe device ID(s) */
 
             Namesp = ACPI_CAST_PTR (ACPI_SDEV_NAMESPACE, Subtable);
@@ -1978,13 +2151,14 @@ AcpiDmDumpSdev (
 
             if (PathLength)
             {
-                Status = AcpiDmDumpTable (Table->Length, 0,
+                Status = AcpiDmDumpTable (Table->Length, CurrentOffset,
                     ACPI_ADD_PTR (UINT8, Namesp, PathOffset),
                     PathLength, AcpiDmTableInfoSdev0a);
                 if (ACPI_FAILURE (Status))
                 {
                     return;
                 }
+                CurrentOffset += PathLength;
             }
 
             /* Dump the vendor-specific data */
diff --git a/sys/contrib/dev/acpica/common/dmtbdump3.c b/sys/contrib/dev/acpica/common/dmtbdump3.c
index 0dac4d401a2c..6f3b8f17e039 100644
--- a/sys/contrib/dev/acpica/common/dmtbdump3.c
+++ b/sys/contrib/dev/acpica/common/dmtbdump3.c
@@ -603,6 +603,106 @@ AcpiDmDumpTpm2 (
 
 /*******************************************************************************
  *
+ * FUNCTION:    AcpiDmDumpViot
+ *
+ * PARAMETERS:  Table               - A VIOT table
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Format the contents of a VIOT
+ *
+ ******************************************************************************/
+
+void
+AcpiDmDumpViot (
+    ACPI_TABLE_HEADER       *Table)
+{
+    ACPI_STATUS             Status;
+    ACPI_TABLE_VIOT         *Viot;
+    ACPI_VIOT_HEADER        *ViotHeader;
+    UINT16                  Length;
+    UINT16                  Offset;
+    ACPI_DMTABLE_INFO       *InfoTable;
+
+    /* Main table */
+
+    Status = AcpiDmDumpTable (Table->Length, 0, Table, 0, AcpiDmTableInfoViot);
+    if (ACPI_FAILURE (Status))
+    {
+        return;
+    }
+
+    Viot = ACPI_CAST_PTR (ACPI_TABLE_VIOT, Table);
+
+    Offset = Viot->NodeOffset;
+    while (Offset < Table->Length)
+    {
+        /* Common subtable header */
+        ViotHeader = ACPI_ADD_PTR (ACPI_VIOT_HEADER, Table, Offset);
+        AcpiOsPrintf ("\n");
+
+        Length = sizeof (ACPI_VIOT_HEADER);
+        Status = AcpiDmDumpTable (Table->Length, Offset, ViotHeader, Length,
+            AcpiDmTableInfoViotHeader);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
+
+        Length = ViotHeader->Length;
+        switch (ViotHeader->Type)
+        {
+        case ACPI_VIOT_NODE_PCI_RANGE:
+
+            InfoTable = AcpiDmTableInfoViot1;
+            break;
+
+        case ACPI_VIOT_NODE_MMIO:
+
+            InfoTable = AcpiDmTableInfoViot2;
+            break;
+
+        case ACPI_VIOT_NODE_VIRTIO_IOMMU_PCI:
+
+            InfoTable = AcpiDmTableInfoViot3;
+            break;
+
+        case ACPI_VIOT_NODE_VIRTIO_IOMMU_MMIO:
+
+            InfoTable = AcpiDmTableInfoViot4;
+            break;
+
+        default:
+
+            AcpiOsPrintf ("\n*** Unknown VIOT node type 0x%X\n",
+                ViotHeader->Type);
+
+            /* Attempt to continue */
+
+            if (!Length)
+            {
+                AcpiOsPrintf ("Invalid zero length VIOT node\n");
+                return;
+            }
+            goto NextSubtable;
+        }
+
+        AcpiOsPrintf ("\n");
+        Status = AcpiDmDumpTable (Table->Length, Offset, ViotHeader, Length,
+            InfoTable);
+        if (ACPI_FAILURE (Status))
+        {
+            return;
+        }
+
+NextSubtable:
+        Offset += Length;
+    }
+}
+
+
+/*******************************************************************************
+ *
  * FUNCTION:    AcpiDmDumpWdat
  *
  * PARAMETERS:  Table               - A WDAT table
diff --git a/sys/contrib/dev/acpica/common/dmtbinfo1.c b/sys/contrib/dev/acpica/common/dmtbinfo1.c
index 9792f47ac377..1e4eb0542d71 100644
--- a/sys/contrib/dev/acpica/common/dmtbinfo1.c
+++ b/sys/contrib/dev/acpica/common/dmtbinfo1.c
@@ -346,6 +346,33 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoBoot[] =
 
 /*******************************************************************************
  *
+ * CEDT - CXL Early Discovery Table
+ *
+ ******************************************************************************/
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoCedtHdr[] =
+{
+    {ACPI_DMT_CEDT,     ACPI_CEDT_OFFSET (Type),               "Subtable Type", 0},
+    {ACPI_DMT_UINT8,    ACPI_CEDT_OFFSET (Reserved),           "Reserved", 0},
+    {ACPI_DMT_UINT16,   ACPI_CEDT_OFFSET (Length),             "Length", DT_LENGTH},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 0: CXL Host Bridge Structure */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoCedt0[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_CEDT0_OFFSET (Uid),               "Associated host bridge", 0},
+    {ACPI_DMT_UINT32,   ACPI_CEDT0_OFFSET (CxlVersion),        "Specification version", 0},
+    {ACPI_DMT_UINT32,   ACPI_CEDT0_OFFSET (Reserved),          "Reserved", 0},
+    {ACPI_DMT_UINT64,   ACPI_CEDT0_OFFSET (Base),              "Register base", 0},
+    {ACPI_DMT_UINT64,   ACPI_CEDT0_OFFSET (Length),            "Register length", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+
+/*******************************************************************************
+ *
  * CPEP - Corrected Platform Error Polling table
  *
  ******************************************************************************/
@@ -1134,9 +1161,12 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoHmat0[] =
 ACPI_DMTABLE_INFO           AcpiDmTableInfoHmat1[] =
 {
     {ACPI_DMT_UINT8,    ACPI_HMAT1_OFFSET (Flags),                  "Flags (decoded below)", 0},
-    {ACPI_DMT_FLAGS4_0, ACPI_HMAT1_FLAG_OFFSET (Flags,0),           "Memory Hierarchy", 0},
+    {ACPI_DMT_FLAGS4_0, ACPI_HMAT1_FLAG_OFFSET (Flags,0),           "Memory Hierarchy", 0},         /* First 4 bits */
+    {ACPI_DMT_FLAG4,    ACPI_HMAT1_FLAG_OFFSET (Flags,0),           "Use Minimum Transfer Size", 0},
+    {ACPI_DMT_FLAG5,    ACPI_HMAT1_FLAG_OFFSET (Flags,0),           "Non-sequential Transfers", 0},
     {ACPI_DMT_UINT8,    ACPI_HMAT1_OFFSET (DataType),               "Data Type", 0},
-    {ACPI_DMT_UINT16,   ACPI_HMAT1_OFFSET (Reserved1),              "Reserved1", 0},
+    {ACPI_DMT_UINT8,    ACPI_HMAT1_OFFSET (MinTransferSize),        "Minimum Transfer Size", 0},
+    {ACPI_DMT_UINT8,    ACPI_HMAT1_OFFSET (Reserved1),              "Reserved1", 0},
     {ACPI_DMT_UINT32,   ACPI_HMAT1_OFFSET (NumberOfInitiatorPDs),   "Initiator Proximity Domains #", 0},
     {ACPI_DMT_UINT32,   ACPI_HMAT1_OFFSET (NumberOfTargetPDs),      "Target Proximity Domains #", 0},
     {ACPI_DMT_UINT32,   ACPI_HMAT1_OFFSET (Reserved2),              "Reserved2", 0},
diff --git a/sys/contrib/dev/acpica/common/dmtbinfo2.c b/sys/contrib/dev/acpica/common/dmtbinfo2.c
index 9056c043129f..b51acd654997 100644
--- a/sys/contrib/dev/acpica/common/dmtbinfo2.c
+++ b/sys/contrib/dev/acpica/common/dmtbinfo2.c
@@ -218,7 +218,20 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoIortHdr[] =
     {ACPI_DMT_UINT8,    ACPI_IORTH_OFFSET (Type),                   "Type", 0},
     {ACPI_DMT_UINT16,   ACPI_IORTH_OFFSET (Length),                 "Length", DT_LENGTH},
     {ACPI_DMT_UINT8,    ACPI_IORTH_OFFSET (Revision),               "Revision", 0},
-    {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (Reserved),               "Reserved", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (Identifier),             "Reserved", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (MappingCount),           "Mapping Count", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (MappingOffset),          "Mapping Offset", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* Common Subtable header (one per Subtable)- Revision 3 */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoIortHdr3[] =
+{
+    {ACPI_DMT_UINT8,    ACPI_IORTH_OFFSET (Type),                   "Type", 0},
+    {ACPI_DMT_UINT16,   ACPI_IORTH_OFFSET (Length),                 "Length", DT_LENGTH},
+    {ACPI_DMT_UINT8,    ACPI_IORTH_OFFSET (Revision),               "Revision", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (Identifier),             "Identifier", 0},
     {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (MappingCount),           "Mapping Count", 0},
     {ACPI_DMT_UINT32,   ACPI_IORTH_OFFSET (MappingOffset),          "Mapping Offset", 0},
     ACPI_DMT_TERMINATOR
@@ -369,6 +382,25 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoIort5[] =
 };
 
 
+/* 0x06: RMR */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoIort6[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_IORT6_OFFSET (Flags),                  "Flags (decoded below)", 0},
+    {ACPI_DMT_FLAG0,    ACPI_IORT6_FLAG_OFFSET (Flags, 0),          "Remapping Permitted", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORT6_OFFSET (RmrCount),               "Number of RMR Descriptors", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORT6_OFFSET (RmrOffset),              "RMR Descriptor Offset", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoIort6a[] =
+{
+    {ACPI_DMT_UINT64,   ACPI_IORT6A_OFFSET (BaseAddress),           "Base Address of RMR", DT_OPTIONAL},
+    {ACPI_DMT_UINT64,   ACPI_IORT6A_OFFSET (Length),                "Length of RMR", 0},
+    {ACPI_DMT_UINT32,   ACPI_IORT6A_OFFSET (Reserved),              "Reserved", 0},
+    ACPI_DMT_TERMINATOR
+};
+
 /*******************************************************************************
  *
  * IVRS - I/O Virtualization Reporting Structure
@@ -478,6 +510,24 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoIvrs8c[] =
     ACPI_DMT_TERMINATOR
 };
 
+/* Variable-length device entry */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoIvrsHid[] =
+{
+    ACPI_DMT_IVRS_DE_HEADER,
+    {ACPI_DMT_NAME8,    ACPI_IVRSHID_OFFSET (AcpiHid),              "ACPI HID", 0},
+    {ACPI_DMT_NAME8,    ACPI_IVRSHID_OFFSET (AcpiCid),              "ACPI CID", 0},
+    {ACPI_DMT_UINT8,    ACPI_IVRSHID_OFFSET (UidType),              "UID Format", DT_DESCRIBES_OPTIONAL},
+    {ACPI_DMT_UINT8,    ACPI_IVRSHID_OFFSET (UidLength),            "UID Length", DT_DESCRIBES_OPTIONAL},
+    ACPI_DMT_TERMINATOR
+};
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoIvrsHid1[] =
+{
+    {ACPI_DMT_RAW_BUFFER, 0,                                        "UID", DT_OPTIONAL},
+    ACPI_DMT_TERMINATOR
+};
+
 
 /*******************************************************************************
  *
@@ -751,6 +801,16 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoMadt15[] =
    ACPI_DMT_TERMINATOR
 };
 
+/* 16: Multiprocessor wakeup structure (ACPI 6.4) */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoMadt16[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_MADT16_OFFSET (MailboxVersion),        "Mailbox Version", 0},
+    {ACPI_DMT_UINT32,   ACPI_MADT16_OFFSET (Reserved),              "Reserved", 0},
+    {ACPI_DMT_UINT64,   ACPI_MADT16_OFFSET (BaseAddress),           "Mailbox Address", 0},
+   ACPI_DMT_TERMINATOR
+};
+
 
 /*******************************************************************************
  *
@@ -938,12 +998,14 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoNfit0[] =
     {ACPI_DMT_UINT16,   ACPI_NFIT0_OFFSET (Flags),                  "Flags (decoded below)", DT_FLAG},
     {ACPI_DMT_FLAG0,    ACPI_NFIT0_FLAG_OFFSET (Flags,0),           "Add/Online Operation Only", 0},
     {ACPI_DMT_FLAG1,    ACPI_NFIT0_FLAG_OFFSET (Flags,0),           "Proximity Domain Valid", 0},
+    {ACPI_DMT_FLAG2,    ACPI_NFIT0_FLAG_OFFSET (Flags,0),           "Location Cookie Valid", 0},
     {ACPI_DMT_UINT32,   ACPI_NFIT0_OFFSET (Reserved),               "Reserved", 0},
     {ACPI_DMT_UINT32,   ACPI_NFIT0_OFFSET (ProximityDomain),        "Proximity Domain", 0},
     {ACPI_DMT_UUID,     ACPI_NFIT0_OFFSET (RangeGuid[0]),           "Region Type GUID", 0},
     {ACPI_DMT_UINT64,   ACPI_NFIT0_OFFSET (Address),                "Address Range Base", 0},
     {ACPI_DMT_UINT64,   ACPI_NFIT0_OFFSET (Length),                 "Address Range Length", 0},
     {ACPI_DMT_UINT64,   ACPI_NFIT0_OFFSET (MemoryMapping),          "Memory Map Attribute", 0},
+    {ACPI_DMT_UINT64,   ACPI_NFIT0_OFFSET (LocationCookie),         "Location Cookie", 0},      /* ACPI 6.4 */
     ACPI_DMT_TERMINATOR
 };
 
@@ -1219,6 +1281,25 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoPcct4[] =
     ACPI_DMT_TERMINATOR
 };
 
+/* 5: HW Registers based Communications Subspace */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPcct5[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_PCCT5_OFFSET (Version),                "Version", 0},
+    {ACPI_DMT_UINT64,   ACPI_PCCT5_OFFSET (BaseAddress),            "Base Address", 0},
+    {ACPI_DMT_UINT64,   ACPI_PCCT5_OFFSET (Length),                 "Length", 0},
+    {ACPI_DMT_GAS,      ACPI_PCCT5_OFFSET (DoorbellRegister),       "Doorbell Register", 0},
+    {ACPI_DMT_UINT64,   ACPI_PCCT5_OFFSET (DoorbellPreserve),       "Preserve Mask", 0},
+    {ACPI_DMT_UINT64,   ACPI_PCCT5_OFFSET (DoorbellWrite),          "Write Mask", 0},
+    {ACPI_DMT_GAS,      ACPI_PCCT5_OFFSET (CmdCompleteRegister),    "Command Complete Register", 0},
+    {ACPI_DMT_UINT64,   ACPI_PCCT5_OFFSET (CmdCompleteMask),        "Command Complete Check Mask", 0},
+    {ACPI_DMT_GAS,      ACPI_PCCT5_OFFSET (ErrorStatusRegister),    "Error Status Register", 0},
+    {ACPI_DMT_UINT64,   ACPI_PCCT5_OFFSET (ErrorStatusMask),        "Error Status Mask", 0},
+    {ACPI_DMT_UINT32,   ACPI_PCCT5_OFFSET (NominalLatency),         "Nominal Latency", 0},
+    {ACPI_DMT_UINT32,   ACPI_PCCT5_OFFSET (MinTurnaroundTime),      "Minimum Turnaround Time", 0},
+    ACPI_DMT_TERMINATOR
+};
+
 
 /*******************************************************************************
  *
@@ -1247,37 +1328,91 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoPdtt0[] =
 
 /*******************************************************************************
  *
- * PMTT - Platform Memory Topology Table
+ * PHAT - Platform Health Assessment Table (ACPI 6.4)
  *
  ******************************************************************************/
 
-ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt[] =
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPhatHdr[] =
 {
-    {ACPI_DMT_UINT32,   ACPI_PMTT_OFFSET (Reserved),                "Reserved", 0},
+    {ACPI_DMT_PHAT,     ACPI_PHATH_OFFSET (Type),                 "Subtable Type", 0},
+    {ACPI_DMT_UINT16,   ACPI_PHATH_OFFSET (Length),               "Length", 0},
+    {ACPI_DMT_UINT8,    ACPI_PHATH_OFFSET (Revision),             "Revision", 0},
     ACPI_DMT_TERMINATOR
 };
 
-/* Common Subtable header (one per Subtable) */
+/* 0: Firmware version table */
 
-ACPI_DMTABLE_INFO           AcpiDmTableInfoPmttHdr[] =
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPhat0[] =
 {
-    {ACPI_DMT_PMTT,     ACPI_PMTTH_OFFSET (Type),                   "Subtable Type", 0},
-    {ACPI_DMT_UINT8,    ACPI_PMTTH_OFFSET (Reserved1),              "Reserved", 0},
-    {ACPI_DMT_UINT16,   ACPI_PMTTH_OFFSET (Length),                 "Length", DT_LENGTH},
-    {ACPI_DMT_UINT16,   ACPI_PMTTH_OFFSET (Flags),                  "Flags (decoded below)", DT_FLAG},
-    {ACPI_DMT_FLAG0,    ACPI_PMTTH_FLAG_OFFSET (Flags,0),           "Top-level Device", 0},
-    {ACPI_DMT_FLAG1,    ACPI_PMTTH_FLAG_OFFSET (Flags,0),           "Physical Element", 0},
-    {ACPI_DMT_FLAGS2,   ACPI_PMTTH_FLAG_OFFSET (Flags,0),           "Memory Type", 0},
-    {ACPI_DMT_UINT16,   ACPI_PMTTH_OFFSET (Reserved2),              "Reserved", 0},
+    {ACPI_DMT_UINT24,   ACPI_PHAT0_OFFSET (Reserved),             "Reserved", 0},
+    {ACPI_DMT_UINT32,   ACPI_PHAT0_OFFSET (ElementCount),         "Element Count", 0},
     ACPI_DMT_TERMINATOR
 };
 
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPhat0a[] =
+{
+    {ACPI_DMT_UUID,     ACPI_PHAT0A_OFFSET (Guid),                "GUID", 0},
+    {ACPI_DMT_UINT64,   ACPI_PHAT0A_OFFSET (VersionValue),        "Version Value", 0},
+    {ACPI_DMT_UINT32,   ACPI_PHAT0A_OFFSET (ProducerId),          "Producer ID", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 1: Firmware Health Data Record */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPhat1[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_PHAT1_OFFSET (Reserved),             "Reserved", 0},
+    {ACPI_DMT_UINT8,    ACPI_PHAT1_OFFSET (Health),               "Health", 0},
+    {ACPI_DMT_UUID,     ACPI_PHAT1_OFFSET (DeviceGuid),           "Device GUID", 0},
+    {ACPI_DMT_UINT32,   ACPI_PHAT1_OFFSET (DeviceSpecificOffset), "Device specific offset", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPhat1a[] =
+{
+    {ACPI_DMT_STRING,   0,                                          "Namepath", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPhat1b[] =
+{
+    {ACPI_DMT_RAW_BUFFER, 0,                                        "Vendor Data", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+
+/*******************************************************************************
+ *
+ * PMTT - Platform Memory Topology Table
+ *
+ ******************************************************************************/
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_PMTT_OFFSET (MemoryDeviceCount),       "Memory Device Count", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* Common Subtable header (one per Subtable) */
+
+#define ACPI_DM_PMTT_HEADER \
+    {ACPI_DMT_PMTT,     ACPI_PMTTH_OFFSET (Type),                   "Subtable Type", 0}, \
+    {ACPI_DMT_UINT8,    ACPI_PMTTH_OFFSET (Reserved1),              "Reserved", 0}, \
+    {ACPI_DMT_UINT16,   ACPI_PMTTH_OFFSET (Length),                 "Length", DT_LENGTH}, \
+    {ACPI_DMT_UINT16,   ACPI_PMTTH_OFFSET (Flags),                  "Flags (decoded below)", DT_FLAG}, \
+    {ACPI_DMT_FLAG0,    ACPI_PMTTH_FLAG_OFFSET (Flags,0),           "Top-level Device", 0}, \
+    {ACPI_DMT_FLAG1,    ACPI_PMTTH_FLAG_OFFSET (Flags,0),           "Physical Element", 0}, \
+    {ACPI_DMT_FLAGS2,   ACPI_PMTTH_FLAG_OFFSET (Flags,0),           "Memory Type", 0}, \
+    {ACPI_DMT_UINT16,   ACPI_PMTTH_OFFSET (Reserved2),              "Reserved", 0}, \
+    {ACPI_DMT_UINT32,   ACPI_PMTTH_OFFSET (MemoryDeviceCount),      "Memory Device Count", 0}
+
 /* PMTT Subtables */
 
 /* 0: Socket */
 
 ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt0[] =
 {
+    ACPI_DM_PMTT_HEADER,
     {ACPI_DMT_UINT16,   ACPI_PMTT0_OFFSET (SocketId),               "Socket ID", 0},
     {ACPI_DMT_UINT16,   ACPI_PMTT0_OFFSET (Reserved),               "Reserved", 0},
     ACPI_DMT_TERMINATOR
@@ -1287,33 +1422,28 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt0[] =
 
 ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt1[] =
 {
-    {ACPI_DMT_UINT32,   ACPI_PMTT1_OFFSET (ReadLatency),            "Read Latency", 0},
-    {ACPI_DMT_UINT32,   ACPI_PMTT1_OFFSET (WriteLatency),           "Write Latency", 0},
-    {ACPI_DMT_UINT32,   ACPI_PMTT1_OFFSET (ReadBandwidth),          "Read Bandwidth", 0},
-    {ACPI_DMT_UINT32,   ACPI_PMTT1_OFFSET (WriteBandwidth),         "Write Bandwidth", 0},
-    {ACPI_DMT_UINT16,   ACPI_PMTT1_OFFSET (AccessWidth),            "Access Width", 0},
-    {ACPI_DMT_UINT16,   ACPI_PMTT1_OFFSET (Alignment),              "Alignment", 0},
+    ACPI_DM_PMTT_HEADER,
+    {ACPI_DMT_UINT16,   ACPI_PMTT1_OFFSET (ControllerId),           "Controller ID", 0},
     {ACPI_DMT_UINT16,   ACPI_PMTT1_OFFSET (Reserved),               "Reserved", 0},
-    {ACPI_DMT_UINT16,   ACPI_PMTT1_OFFSET (DomainCount),            "Domain Count", 0},
     ACPI_DMT_TERMINATOR
 };
 
-/* 1a: Proximity Domain */
+/* 2: Physical Component */
 
-ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt1a[] =
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt2[] =
 {
-    {ACPI_DMT_UINT32,   ACPI_PMTT1A_OFFSET (ProximityDomain),       "Proximity Domain", 0},
+    ACPI_DM_PMTT_HEADER,
+    {ACPI_DMT_UINT32,   ACPI_PMTT2_OFFSET (BiosHandle),             "Bios Handle", 0},
     ACPI_DMT_TERMINATOR
 };
 
-/* 2: Physical Component */
+/* 0xFF: Vendor Specific */
 
-ACPI_DMTABLE_INFO           AcpiDmTableInfoPmtt2[] =
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPmttVendor[] =
 {
-    {ACPI_DMT_UINT16,   ACPI_PMTT2_OFFSET (ComponentId),            "Component ID", 0},
-    {ACPI_DMT_UINT16,   ACPI_PMTT2_OFFSET (Reserved),               "Reserved", 0},
-    {ACPI_DMT_UINT32,   ACPI_PMTT2_OFFSET (MemorySize),             "Memory Size", 0},
-    {ACPI_DMT_UINT32,   ACPI_PMTT2_OFFSET (BiosHandle),             "Bios Handle", 0},
+    ACPI_DM_PMTT_HEADER,
+    {ACPI_DMT_UUID,         ACPI_PMTT_VENDOR_OFFSET (TypeUuid),     "Type Uuid", 0},
+    {ACPI_DMT_PMTT_VENDOR,  ACPI_PMTT_VENDOR_OFFSET (Specific),     "Vendor Data", 0},
     ACPI_DMT_TERMINATOR
 };
 
@@ -1371,6 +1501,7 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoPptt1[] =
     {ACPI_DMT_FLAG4,    ACPI_PPTT1_FLAG_OFFSET (Flags,0),           "Cache Type valid", 0},
     {ACPI_DMT_FLAG5,    ACPI_PPTT1_FLAG_OFFSET (Flags,0),           "Write Policy valid", 0},
     {ACPI_DMT_FLAG6,    ACPI_PPTT1_FLAG_OFFSET (Flags,0),           "Line Size valid", 0},
+    {ACPI_DMT_FLAG7,    ACPI_PPTT1_FLAG_OFFSET (Flags,0),           "Cache ID valid", 0},
     {ACPI_DMT_UINT32,   ACPI_PPTT1_OFFSET (NextLevelOfCache),       "Next Level of Cache", 0},
     {ACPI_DMT_UINT32,   ACPI_PPTT1_OFFSET (Size),                   "Size", 0},
     {ACPI_DMT_UINT32,   ACPI_PPTT1_OFFSET (NumberOfSets),           "Number of Sets", 0},
@@ -1383,6 +1514,14 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoPptt1[] =
     ACPI_DMT_TERMINATOR
 };
 
+/* 1: cache type v1 */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoPptt1a[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_PPTT1A_OFFSET (CacheId),               "Cache ID", 0},
+    ACPI_DMT_TERMINATOR
+};
+
 /* 2: ID */
 
 ACPI_DMTABLE_INFO           AcpiDmTableInfoPptt2[] =
@@ -1499,6 +1638,7 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoSdevHdr[] =
     {ACPI_DMT_SDEV,     ACPI_SDEVH_OFFSET (Type),                   "Subtable Type", 0},
     {ACPI_DMT_UINT8,    ACPI_SDEVH_OFFSET (Flags),                  "Flags (decoded below)", 0},
     {ACPI_DMT_FLAG0,    ACPI_SDEVH_FLAG_OFFSET (Flags,0),           "Allow handoff to unsecure OS", 0},
+    {ACPI_DMT_FLAG1,    ACPI_SDEVH_FLAG_OFFSET (Flags,0),           "Secure access components present", 0},
     {ACPI_DMT_UINT16,   ACPI_SDEVH_OFFSET (Length),                 "Length", 0},
     ACPI_DMT_TERMINATOR
 };
@@ -1522,6 +1662,53 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoSdev0a[] =
     ACPI_DMT_TERMINATOR
 };
 
+ACPI_DMTABLE_INFO           AcpiDmTableInfoSdev0b[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_SDEV0B_OFFSET (SecureComponentOffset), "Secure Access Components Offset", 0},
+    {ACPI_DMT_UINT16,   ACPI_SDEV0B_OFFSET (SecureComponentLength), "Secure Access Components Length", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* Secure access components */
+
+/* Common secure access components header secure access component */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoSdevSecCompHdr[] =
+{
+    {ACPI_DMT_UINT8,    ACPI_SDEVCH_OFFSET (Type),                   "Secure Component Type", 0},
+    {ACPI_DMT_UINT8,    ACPI_SDEVCH_OFFSET (Flags),                  "Flags (decoded below)", 0},
+    {ACPI_DMT_UINT16,   ACPI_SDEVCH_OFFSET (Length),                 "Length", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 0: Identification Based Secure Access Component */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoSdevSecCompId[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_SDEVC0_OFFSET (HardwareIdOffset),      "Hardware ID Offset", 0},
+    {ACPI_DMT_UINT16,   ACPI_SDEVC0_OFFSET (HardwareIdLength),      "Hardware ID Length", 0},
+    {ACPI_DMT_UINT16,   ACPI_SDEVC0_OFFSET (SubsystemIdOffset),     "Subsystem ID Offset", 0},
+    {ACPI_DMT_UINT16,   ACPI_SDEVC0_OFFSET (SubsystemIdLength),     "Subsystem ID Length", 0},
+    {ACPI_DMT_UINT16,   ACPI_SDEVC0_OFFSET (HardwareRevision),      "Hardware Revision", 0},
+    {ACPI_DMT_UINT8,    ACPI_SDEVC0_OFFSET (HardwareRevPresent),    "Hardware Rev Present", 0},
+    {ACPI_DMT_UINT8,    ACPI_SDEVC0_OFFSET (ClassCodePresent),      "Class Code Present", 0},
+    {ACPI_DMT_UINT8,    ACPI_SDEVC0_OFFSET (PciBaseClass),          "PCI Base Class", 0},
+    {ACPI_DMT_UINT8,    ACPI_SDEVC0_OFFSET (PciSubClass),           "PCI SubClass", 0},
+    {ACPI_DMT_UINT8,    ACPI_SDEVC0_OFFSET (PciProgrammingXface),   "PCI Programming Xface", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 1: Memory Based Secure Access Component */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoSdevSecCompMem[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_SDEVC1_OFFSET (Reserved),              "Reserved", 0},
+    {ACPI_DMT_UINT64,   ACPI_SDEVC1_OFFSET (MemoryBaseAddress),     "Memory Base Address", 0},
+    {ACPI_DMT_UINT64,   ACPI_SDEVC1_OFFSET (MemoryLength),          "Memory Length", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+
 /* 1: PCIe Endpoint Device Based Device Structure */
 
 ACPI_DMTABLE_INFO           AcpiDmTableInfoSdev1[] =
diff --git a/sys/contrib/dev/acpica/common/dmtbinfo3.c b/sys/contrib/dev/acpica/common/dmtbinfo3.c
index d2526f1a834a..496535613556 100644
--- a/sys/contrib/dev/acpica/common/dmtbinfo3.c
+++ b/sys/contrib/dev/acpica/common/dmtbinfo3.c
@@ -378,6 +378,7 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoSrat5[] =
     {ACPI_DMT_BUF16,    ACPI_SRAT5_OFFSET (DeviceHandle),           "Device Handle", 0},
     {ACPI_DMT_UINT32,   ACPI_SRAT5_OFFSET (Flags),                  "Flags (decoded below)", DT_FLAG},
     {ACPI_DMT_FLAG0,    ACPI_SRAT5_FLAG_OFFSET (Flags,0),           "Enabled", 0},
+    {ACPI_DMT_FLAG1,    ACPI_SRAT5_FLAG_OFFSET (Flags,0),           "Architectural Transactions", 0},
     {ACPI_DMT_UINT32,   ACPI_SRAT5_OFFSET (Reserved1),              "Reserved2", 0},
     ACPI_DMT_TERMINATOR
 };
@@ -528,6 +529,77 @@ ACPI_DMTABLE_INFO           AcpiDmTableInfoUefi[] =
 
 /*******************************************************************************
  *
+ * VIOT - Virtual I/O Translation Table
+ *
+ ******************************************************************************/
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoViot[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_VIOT_OFFSET (NodeCount),               "Node count", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT_OFFSET (NodeOffset),              "Node offset", 0},
+    {ACPI_DMT_UINT64,   ACPI_VIOT_OFFSET (Reserved),                "Reserved", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* Common VIOT subtable header */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoViotHeader[] =
+{
+    {ACPI_DMT_VIOT,     ACPI_VIOTH_OFFSET (Type),                   "Type", 0},
+    {ACPI_DMT_UINT8,    ACPI_VIOTH_OFFSET (Reserved),               "Reserved", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOTH_OFFSET (Length),                 "Length", DT_LENGTH},
+    ACPI_DMT_TERMINATOR
+};
+
+/* VIOT Subtables */
+
+/* 0x01: PCI Range Node */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoViot1[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_VIOT1_OFFSET (EndpointStart),          "Endpoint start", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT1_OFFSET (SegmentStart),           "PCI Segment start", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT1_OFFSET (SegmentEnd),             "PCI Segment end", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT1_OFFSET (BdfStart),               "PCI BDF start", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT1_OFFSET (BdfEnd),                 "PCI BDF end", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT1_OFFSET (OutputNode),             "Output node", 0},
+    {ACPI_DMT_UINT48,   ACPI_VIOT1_OFFSET (Reserved),               "Reserved", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 0x02: MMIO Endpoint Node */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoViot2[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_VIOT2_OFFSET (Endpoint),               "Endpoint", 0},
+    {ACPI_DMT_UINT64,   ACPI_VIOT2_OFFSET (BaseAddress),            "Base address", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT2_OFFSET (OutputNode),             "Output node", 0},
+    {ACPI_DMT_UINT48,   ACPI_VIOT2_OFFSET (Reserved),               "Reserved", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 0x03: PCI Virtio-IOMMU Node */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoViot3[] =
+{
+    {ACPI_DMT_UINT16,   ACPI_VIOT3_OFFSET (Segment),                "PCI Segment", 0},
+    {ACPI_DMT_UINT16,   ACPI_VIOT3_OFFSET (Bdf),                    "PCI BDF number", 0},
+    {ACPI_DMT_UINT64,   ACPI_VIOT3_OFFSET (Reserved),               "Reserved", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+/* 0x04: MMIO Virtio-IOMMU Node */
+
+ACPI_DMTABLE_INFO           AcpiDmTableInfoViot4[] =
+{
+    {ACPI_DMT_UINT32,   ACPI_VIOT4_OFFSET (Reserved),               "Reserved", 0},
+    {ACPI_DMT_UINT64,   ACPI_VIOT4_OFFSET (BaseAddress),            "Base address", 0},
+    ACPI_DMT_TERMINATOR
+};
+
+
+/*******************************************************************************
+ *
  * WAET - Windows ACPI Emulated devices Table
  *
  ******************************************************************************/