1 /******************************************************************************
   2  *
   3  * Module Name: dmtable - Support for ACPI tables that contain no AML code
   4  *
   5  *****************************************************************************/
   6 
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43 
  44 #include "acpi.h"
  45 #include "accommon.h"
  46 #include "acdisasm.h"
  47 #include "actables.h"
  48 #include "aslcompiler.h"
  49 #include "dtcompiler.h"
  50 
  51 /* This module used for application-level code only */
  52 
  53 #define _COMPONENT          ACPI_CA_DISASSEMBLER
  54         ACPI_MODULE_NAME    ("dmtable")
  55 
  56 /* Local Prototypes */
  57 
  58 static void
  59 AcpiDmCheckAscii (
  60     UINT8                   *Target,
  61     char                    *RepairedName,
  62     UINT32                  Count);
  63 
  64 
  65 /* Common format strings for commented values */
  66 
  67 #define UINT8_FORMAT        "%2.2X [%s]\n"
  68 #define UINT16_FORMAT       "%4.4X [%s]\n"
  69 #define UINT32_FORMAT       "%8.8X [%s]\n"
  70 #define STRING_FORMAT       "[%s]\n"
  71 
  72 /* These tables map a subtable type to a description string */
  73 
  74 static const char           *AcpiDmAsfSubnames[] =
  75 {
  76     "ASF Information",
  77     "ASF Alerts",
  78     "ASF Remote Control",
  79     "ASF RMCP Boot Options",
  80     "ASF Address",
  81     "Unknown SubTable Type"         /* Reserved */
  82 };
  83 
  84 static const char           *AcpiDmDmarSubnames[] =
  85 {
  86     "Hardware Unit Definition",
  87     "Reserved Memory Region",
  88     "Root Port ATS Capability",
  89     "Remapping Hardware Static Affinity",
  90     "Unknown SubTable Type"         /* Reserved */
  91 };
  92 
  93 static const char           *AcpiDmEinjActions[] =
  94 {
  95     "Begin Operation",
  96     "Get Trigger Table",
  97     "Set Error Type",
  98     "Get Error Type",
  99     "End Operation",
 100     "Execute Operation",
 101     "Check Busy Status",
 102     "Get Command Status",
 103     "Set Error Type With Address",
 104     "Unknown Action"
 105 };
 106 
 107 static const char           *AcpiDmEinjInstructions[] =
 108 {
 109     "Read Register",
 110     "Read Register Value",
 111     "Write Register",
 112     "Write Register Value",
 113     "Noop",
 114     "Flush Cacheline",
 115     "Unknown Instruction"
 116 };
 117 
 118 static const char           *AcpiDmErstActions[] =
 119 {
 120     "Begin Write Operation",
 121     "Begin Read Operation",
 122     "Begin Clear Operation",
 123     "End Operation",
 124     "Set Record Offset",
 125     "Execute Operation",
 126     "Check Busy Status",
 127     "Get Command Status",
 128     "Get Record Identifier",
 129     "Set Record Identifier",
 130     "Get Record Count",
 131     "Begin Dummy Write",
 132     "Unused/Unknown Action",
 133     "Get Error Address Range",
 134     "Get Error Address Length",
 135     "Get Error Attributes",
 136     "Unknown Action"
 137 };
 138 
 139 static const char           *AcpiDmErstInstructions[] =
 140 {
 141     "Read Register",
 142     "Read Register Value",
 143     "Write Register",
 144     "Write Register Value",
 145     "Noop",
 146     "Load Var1",
 147     "Load Var2",
 148     "Store Var1",
 149     "Add",
 150     "Subtract",
 151     "Add Value",
 152     "Subtract Value",
 153     "Stall",
 154     "Stall While True",
 155     "Skip Next If True",
 156     "GoTo",
 157     "Set Source Address",
 158     "Set Destination Address",
 159     "Move Data",
 160     "Unknown Instruction"
 161 };
 162 
 163 static const char           *AcpiDmHestSubnames[] =
 164 {
 165     "IA-32 Machine Check Exception",
 166     "IA-32 Corrected Machine Check",
 167     "IA-32 Non-Maskable Interrupt",
 168     "Unknown SubTable Type",        /* 3 - Reserved */
 169     "Unknown SubTable Type",        /* 4 - Reserved */
 170     "Unknown SubTable Type",        /* 5 - Reserved */
 171     "PCI Express Root Port AER",
 172     "PCI Express AER (AER Endpoint)",
 173     "PCI Express/PCI-X Bridge AER",
 174     "Generic Hardware Error Source",
 175     "Unknown SubTable Type"         /* Reserved */
 176 };
 177 
 178 static const char           *AcpiDmHestNotifySubnames[] =
 179 {
 180     "Polled",
 181     "External Interrupt",
 182     "Local Interrupt",
 183     "SCI",
 184     "NMI",
 185     "CMCI",                         /* ACPI 5.0 */
 186     "MCE",                          /* ACPI 5.0 */
 187     "Unknown Notify Type"           /* Reserved */
 188 };
 189 
 190 static const char           *AcpiDmMadtSubnames[] =
 191 {
 192     "Processor Local APIC",         /* ACPI_MADT_TYPE_LOCAL_APIC */
 193     "I/O APIC",                     /* ACPI_MADT_TYPE_IO_APIC */
 194     "Interrupt Source Override",    /* ACPI_MADT_TYPE_INTERRUPT_OVERRIDE */
 195     "NMI Source",                   /* ACPI_MADT_TYPE_NMI_SOURCE */
 196     "Local APIC NMI",               /* ACPI_MADT_TYPE_LOCAL_APIC_NMI */
 197     "Local APIC Address Override",  /* ACPI_MADT_TYPE_LOCAL_APIC_OVERRIDE */
 198     "I/O SAPIC",                    /* ACPI_MADT_TYPE_IO_SAPIC */
 199     "Local SAPIC",                  /* ACPI_MADT_TYPE_LOCAL_SAPIC */
 200     "Platform Interrupt Sources",   /* ACPI_MADT_TYPE_INTERRUPT_SOURCE */
 201     "Processor Local x2APIC",       /* ACPI_MADT_TYPE_LOCAL_X2APIC */
 202     "Local x2APIC NMI",             /* ACPI_MADT_TYPE_LOCAL_X2APIC_NMI */
 203     "Generic Interrupt Controller", /* ACPI_MADT_GENERIC_INTERRUPT */
 204     "Generic Interrupt Distributor",/* ACPI_MADT_GENERIC_DISTRIBUTOR */
 205     "Unknown SubTable Type"         /* Reserved */
 206 };
 207 
 208 static const char           *AcpiDmPcctSubnames[] =
 209 {
 210     "Generic Communications Subspace",  /* ACPI_PCCT_TYPE_GENERIC_SUBSPACE */
 211     "Unknown SubTable Type"             /* Reserved */
 212 };
 213 
 214 static const char           *AcpiDmPmttSubnames[] =
 215 {
 216     "Socket",                       /* ACPI_PMTT_TYPE_SOCKET */
 217     "Memory Controller",            /* ACPI_PMTT_TYPE_CONTROLLER */
 218     "Physical Component (DIMM)",    /* ACPI_PMTT_TYPE_DIMM  */
 219     "Unknown SubTable Type"         /* Reserved */
 220 };
 221 
 222 static const char           *AcpiDmSlicSubnames[] =
 223 {
 224     "Public Key Structure",
 225     "Windows Marker Structure",
 226     "Unknown SubTable Type"         /* Reserved */
 227 };
 228 
 229 static const char           *AcpiDmSratSubnames[] =
 230 {
 231     "Processor Local APIC/SAPIC Affinity",
 232     "Memory Affinity",
 233     "Processor Local x2APIC Affinity",
 234     "Unknown SubTable Type"         /* Reserved */
 235 };
 236 
 237 static const char           *AcpiDmIvrsSubnames[] =
 238 {
 239     "Hardware Definition Block",
 240     "Memory Definition Block",
 241     "Unknown SubTable Type"         /* Reserved */
 242 };
 243 
 244 
 245 #define ACPI_FADT_PM_RESERVED       9
 246 
 247 static const char           *AcpiDmFadtProfiles[] =
 248 {
 249     "Unspecified",
 250     "Desktop",
 251     "Mobile",
 252     "Workstation",
 253     "Enterprise Server",
 254     "SOHO Server",
 255     "Appliance PC",
 256     "Performance Server",
 257     "Tablet",
 258     "Unknown Profile Type"
 259 };
 260 
 261 #define ACPI_GAS_WIDTH_RESERVED     5
 262 
 263 static const char           *AcpiDmGasAccessWidth[] =
 264 {
 265     "Undefined/Legacy",
 266     "Byte Access:8",
 267     "Word Access:16",
 268     "DWord Access:32",
 269     "QWord Access:64",
 270     "Unknown Width Encoding"
 271 };
 272 
 273 
 274 /*******************************************************************************
 275  *
 276  * ACPI Table Data, indexed by signature.
 277  *
 278  * Each entry contains: Signature, Table Info, Handler, DtHandler,
 279  *  Template, Description
 280  *
 281  * Simple tables have only a TableInfo structure, complex tables have a
 282  * handler. This table must be NULL terminated. RSDP and FACS are
 283  * special-cased elsewhere.
 284  *
 285  ******************************************************************************/
 286 
 287 ACPI_DMTABLE_DATA    AcpiDmTableData[] =
 288 {
 289     {ACPI_SIG_ASF,  NULL,                   AcpiDmDumpAsf,  DtCompileAsf,   TemplateAsf,    "Alert Standard Format table"},
 290     {ACPI_SIG_BERT, AcpiDmTableInfoBert,    NULL,           NULL,           TemplateBert,   "Boot Error Record Table"},
 291     {ACPI_SIG_BGRT, AcpiDmTableInfoBgrt,    NULL,           NULL,           TemplateBgrt,   "Boot Graphics Resource Table"},
 292     {ACPI_SIG_BOOT, AcpiDmTableInfoBoot,    NULL,           NULL,           TemplateBoot,   "Simple Boot Flag Table"},
 293     {ACPI_SIG_CPEP, NULL,                   AcpiDmDumpCpep, DtCompileCpep,  TemplateCpep,   "Corrected Platform Error Polling table"},
 294     {ACPI_SIG_CSRT, NULL,                   AcpiDmDumpCsrt, DtCompileCsrt,  TemplateCsrt,   "Core System Resource Table"},
 295     {ACPI_SIG_DBG2, AcpiDmTableInfoDbg2,    AcpiDmDumpDbg2, DtCompileDbg2,  TemplateDbg2,   "Debug Port table type 2"},
 296     {ACPI_SIG_DBGP, AcpiDmTableInfoDbgp,    NULL,           NULL,           TemplateDbgp,   "Debug Port table"},
 297     {ACPI_SIG_DMAR, NULL,                   AcpiDmDumpDmar, DtCompileDmar,  TemplateDmar,   "DMA Remapping table"},
 298     {ACPI_SIG_ECDT, AcpiDmTableInfoEcdt,    NULL,           NULL,           TemplateEcdt,   "Embedded Controller Boot Resources Table"},
 299     {ACPI_SIG_EINJ, NULL,                   AcpiDmDumpEinj, DtCompileEinj,  TemplateEinj,   "Error Injection table"},
 300     {ACPI_SIG_ERST, NULL,                   AcpiDmDumpErst, DtCompileErst,  TemplateErst,   "Error Record Serialization Table"},
 301     {ACPI_SIG_FADT, NULL,                   AcpiDmDumpFadt, DtCompileFadt,  TemplateFadt,   "Fixed ACPI Description Table (FADT)"},
 302     {ACPI_SIG_FPDT, NULL,                   AcpiDmDumpFpdt, DtCompileFpdt,  TemplateFpdt,   "Firmware Performance Data Table"},
 303     {ACPI_SIG_GTDT, AcpiDmTableInfoGtdt,    NULL,           NULL,           TemplateGtdt,   "Generic Timer Description Table"},
 304     {ACPI_SIG_HEST, NULL,                   AcpiDmDumpHest, DtCompileHest,  TemplateHest,   "Hardware Error Source Table"},
 305     {ACPI_SIG_HPET, AcpiDmTableInfoHpet,    NULL,           NULL,           TemplateHpet,   "High Precision Event Timer table"},
 306     {ACPI_SIG_IVRS, NULL,                   AcpiDmDumpIvrs, DtCompileIvrs,  TemplateIvrs,   "I/O Virtualization Reporting Structure"},
 307     {ACPI_SIG_MADT, NULL,                   AcpiDmDumpMadt, DtCompileMadt,  TemplateMadt,   "Multiple APIC Description Table (MADT)"},
 308     {ACPI_SIG_MCFG, NULL,                   AcpiDmDumpMcfg, DtCompileMcfg,  TemplateMcfg,   "Memory Mapped Configuration table"},
 309     {ACPI_SIG_MCHI, AcpiDmTableInfoMchi,    NULL,           NULL,           TemplateMchi,   "Management Controller Host Interface table"},
 310     {ACPI_SIG_MPST, AcpiDmTableInfoMpst,    AcpiDmDumpMpst, DtCompileMpst,  TemplateMpst,   "Memory Power State Table"},
 311     {ACPI_SIG_MSCT, NULL,                   AcpiDmDumpMsct, DtCompileMsct,  TemplateMsct,   "Maximum System Characteristics Table"},
 312     {ACPI_SIG_MTMR, NULL,                   AcpiDmDumpMtmr, DtCompileMtmr,  TemplateMtmr,   "MID Timer Table"},
 313     {ACPI_SIG_PCCT, AcpiDmTableInfoPcct,    AcpiDmDumpPcct, DtCompilePcct,  TemplatePcct,   "Platform Communications Channel Table"},
 314     {ACPI_SIG_PMTT, NULL,                   AcpiDmDumpPmtt, DtCompilePmtt,  TemplatePmtt,   "Platform Memory Topology Table"},
 315     {ACPI_SIG_RSDT, NULL,                   AcpiDmDumpRsdt, DtCompileRsdt,  TemplateRsdt,   "Root System Description Table"},
 316     {ACPI_SIG_S3PT, NULL,                   NULL,           NULL,           TemplateS3pt,   "S3 Performance Table"},
 317     {ACPI_SIG_SBST, AcpiDmTableInfoSbst,    NULL,           NULL,           TemplateSbst,   "Smart Battery Specification Table"},
 318     {ACPI_SIG_SLIC, NULL,                   AcpiDmDumpSlic, DtCompileSlic,  TemplateSlic,   "Software Licensing Description Table"},
 319     {ACPI_SIG_SLIT, NULL,                   AcpiDmDumpSlit, DtCompileSlit,  TemplateSlit,   "System Locality Information Table"},
 320     {ACPI_SIG_SPCR, AcpiDmTableInfoSpcr,    NULL,           NULL,           TemplateSpcr,   "Serial Port Console Redirection table"},
 321     {ACPI_SIG_SPMI, AcpiDmTableInfoSpmi,    NULL,           NULL,           TemplateSpmi,   "Server Platform Management Interface table"},
 322     {ACPI_SIG_SRAT, NULL,                   AcpiDmDumpSrat, DtCompileSrat,  TemplateSrat,   "System Resource Affinity Table"},
 323     {ACPI_SIG_TCPA, AcpiDmTableInfoTcpa,    NULL,           NULL,           TemplateTcpa,   "Trusted Computing Platform Alliance table"},
 324     {ACPI_SIG_TPM2, AcpiDmTableInfoTpm2,    NULL,           NULL,           TemplateTpm2,   "Trusted Platform Module hardware interface table"},
 325     {ACPI_SIG_UEFI, AcpiDmTableInfoUefi,    NULL,           DtCompileUefi,  TemplateUefi,   "UEFI Boot Optimization Table"},
 326     {ACPI_SIG_VRTC, AcpiDmTableInfoVrtc,    AcpiDmDumpVrtc, DtCompileVrtc,  TemplateVrtc,   "Virtual Real-Time Clock Table"},
 327     {ACPI_SIG_WAET, AcpiDmTableInfoWaet,    NULL,           NULL,           TemplateWaet,   "Windows ACPI Emulated Devices Table"},
 328     {ACPI_SIG_WDAT, NULL,                   AcpiDmDumpWdat, DtCompileWdat,  TemplateWdat,   "Watchdog Action Table"},
 329     {ACPI_SIG_WDDT, AcpiDmTableInfoWddt,    NULL,           NULL,           TemplateWddt,   "Watchdog Description Table"},
 330     {ACPI_SIG_WDRT, AcpiDmTableInfoWdrt,    NULL,           NULL,           TemplateWdrt,   "Watchdog Resource Table"},
 331     {ACPI_SIG_XSDT, NULL,                   AcpiDmDumpXsdt, DtCompileXsdt,  TemplateXsdt,   "Extended System Description Table"},
 332     {NULL,          NULL,                   NULL,           NULL,           NULL,           NULL}
 333 };
 334 
 335 
 336 /*******************************************************************************
 337  *
 338  * FUNCTION:    AcpiDmGenerateChecksum
 339  *
 340  * PARAMETERS:  Table               - Pointer to table to be checksummed
 341  *              Length              - Length of the table
 342  *              OriginalChecksum    - Value of the checksum field
 343  *
 344  * RETURN:      8 bit checksum of buffer
 345  *
 346  * DESCRIPTION: Computes an 8 bit checksum of the table.
 347  *
 348  ******************************************************************************/
 349 
 350 UINT8
 351 AcpiDmGenerateChecksum (
 352     void                    *Table,
 353     UINT32                  Length,
 354     UINT8                   OriginalChecksum)
 355 {
 356     UINT8                   Checksum;
 357 
 358 
 359     /* Sum the entire table as-is */
 360 
 361     Checksum = AcpiTbChecksum ((UINT8 *) Table, Length);
 362 
 363     /* Subtract off the existing checksum value in the table */
 364 
 365     Checksum = (UINT8) (Checksum - OriginalChecksum);
 366 
 367     /* Compute the final checksum */
 368 
 369     Checksum = (UINT8) (0 - Checksum);
 370     return (Checksum);
 371 }
 372 
 373 
 374 /*******************************************************************************
 375  *
 376  * FUNCTION:    AcpiDmGetTableData
 377  *
 378  * PARAMETERS:  Signature           - ACPI signature (4 chars) to match
 379  *
 380  * RETURN:      Pointer to a valid ACPI_DMTABLE_DATA. Null if no match found.
 381  *
 382  * DESCRIPTION: Find a match in the global table of supported ACPI tables
 383  *
 384  ******************************************************************************/
 385 
 386 ACPI_DMTABLE_DATA *
 387 AcpiDmGetTableData (
 388     char                    *Signature)
 389 {
 390     ACPI_DMTABLE_DATA       *TableData;
 391 
 392 
 393     for (TableData = AcpiDmTableData; TableData->Signature; TableData++)
 394     {
 395         if (ACPI_COMPARE_NAME (Signature, TableData->Signature))
 396         {
 397             return (TableData);
 398         }
 399     }
 400 
 401     return (NULL);
 402 }
 403 
 404 
 405 /*******************************************************************************
 406  *
 407  * FUNCTION:    AcpiDmDumpDataTable
 408  *
 409  * PARAMETERS:  Table               - An ACPI table
 410  *
 411  * RETURN:      None.
 412  *
 413  * DESCRIPTION: Format the contents of an ACPI data table (any table other
 414  *              than an SSDT or DSDT that does not contain executable AML code)
 415  *
 416  ******************************************************************************/
 417 
 418 void
 419 AcpiDmDumpDataTable (
 420     ACPI_TABLE_HEADER       *Table)
 421 {
 422     ACPI_STATUS             Status;
 423     ACPI_DMTABLE_DATA       *TableData;
 424     UINT32                  Length;
 425 
 426 
 427     /* Ignore tables that contain AML */
 428 
 429     if (AcpiUtIsAmlTable (Table))
 430     {
 431         if (Gbl_VerboseTemplates)
 432         {
 433             /* Dump the raw table data */
 434 
 435             Length = Table->Length;
 436 
 437             AcpiOsPrintf ("\n/*\n%s: Length %d (0x%X)\n\n",
 438                 ACPI_RAW_TABLE_DATA_HEADER, Length, Length);
 439             AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table),
 440                 Length, DB_BYTE_DISPLAY, 0);
 441             AcpiOsPrintf (" */\n");
 442         }
 443         return;
 444     }
 445 
 446     /*
 447      * Handle tables that don't use the common ACPI table header structure.
 448      * Currently, these are the FACS, RSDP, and S3PT.
 449      */
 450     if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_FACS))
 451     {
 452         Length = Table->Length;
 453         AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoFacs);
 454     }
 455     else if (ACPI_VALIDATE_RSDP_SIG (Table->Signature))
 456     {
 457         Length = AcpiDmDumpRsdp (Table);
 458     }
 459     else if (ACPI_COMPARE_NAME (Table->Signature, ACPI_SIG_S3PT))
 460     {
 461         Length = AcpiDmDumpS3pt (Table);
 462     }
 463     else
 464     {
 465         /*
 466          * All other tables must use the common ACPI table header, dump it now
 467          */
 468         Length = Table->Length;
 469         Status = AcpiDmDumpTable (Length, 0, Table, 0, AcpiDmTableInfoHeader);
 470         if (ACPI_FAILURE (Status))
 471         {
 472             return;
 473         }
 474         AcpiOsPrintf ("\n");
 475 
 476         /* Match signature and dispatch appropriately */
 477 
 478         TableData = AcpiDmGetTableData (Table->Signature);
 479         if (!TableData)
 480         {
 481             if (!ACPI_STRNCMP (Table->Signature, "OEM", 3))
 482             {
 483                 AcpiOsPrintf ("\n**** OEM-defined ACPI table [%4.4s], unknown contents\n\n",
 484                     Table->Signature);
 485             }
 486             else
 487             {
 488                 AcpiOsPrintf ("\n**** Unknown ACPI table type [%4.4s]\n\n",
 489                     Table->Signature);
 490                 fprintf (stderr, "Unknown ACPI table signature [%4.4s], decoding header only\n",
 491                     Table->Signature);
 492             }
 493         }
 494         else if (TableData->TableHandler)
 495         {
 496             /* Complex table, has a handler */
 497 
 498             TableData->TableHandler (Table);
 499         }
 500         else if (TableData->TableInfo)
 501         {
 502             /* Simple table, just walk the info table */
 503 
 504             AcpiDmDumpTable (Length, 0, Table, 0, TableData->TableInfo);
 505         }
 506     }
 507 
 508     if (!Gbl_DoTemplates || Gbl_VerboseTemplates)
 509     {
 510         /* Dump the raw table data */
 511 
 512         AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
 513             ACPI_RAW_TABLE_DATA_HEADER, Length, Length);
 514         AcpiUtDumpBuffer (ACPI_CAST_PTR (UINT8, Table),
 515             Length, DB_BYTE_DISPLAY, 0);
 516     }
 517 }
 518 
 519 
 520 /*******************************************************************************
 521  *
 522  * FUNCTION:    AcpiDmLineHeader
 523  *
 524  * PARAMETERS:  Offset              - Current byte offset, from table start
 525  *              ByteLength          - Length of the field in bytes, 0 for flags
 526  *              Name                - Name of this field
 527  *              Value               - Optional value, displayed on left of ':'
 528  *
 529  * RETURN:      None
 530  *
 531  * DESCRIPTION: Utility routines for formatting output lines. Displays the
 532  *              current table offset in hex and decimal, the field length,
 533  *              and the field name.
 534  *
 535  ******************************************************************************/
 536 
 537 void
 538 AcpiDmLineHeader (
 539     UINT32                  Offset,
 540     UINT32                  ByteLength,
 541     char                    *Name)
 542 {
 543 
 544     /* Allow a null name for fields that span multiple lines (large buffers) */
 545 
 546     if (!Name)
 547     {
 548         Name = "";
 549     }
 550 
 551     if (Gbl_DoTemplates && !Gbl_VerboseTemplates) /* Terse template */
 552     {
 553         if (ByteLength)
 554         {
 555             AcpiOsPrintf ("[%.4d] %34s : ", ByteLength, Name);
 556         }
 557         else
 558         {
 559             if (*Name)
 560             {
 561                 AcpiOsPrintf ("%41s : ", Name);
 562             }
 563             else
 564             {
 565                 AcpiOsPrintf ("%41s   ", Name);
 566             }
 567         }
 568     }
 569     else /* Normal disassembler or verbose template */
 570     {
 571         if (ByteLength)
 572         {
 573             AcpiOsPrintf ("[%3.3Xh %4.4d% 4d] %28s : ",
 574                 Offset, Offset, ByteLength, Name);
 575         }
 576         else
 577         {
 578             if (*Name)
 579             {
 580                 AcpiOsPrintf ("%44s : ", Name);
 581             }
 582             else
 583             {
 584                 AcpiOsPrintf ("%44s   ", Name);
 585             }
 586         }
 587     }
 588 }
 589 
 590 void
 591 AcpiDmLineHeader2 (
 592     UINT32                  Offset,
 593     UINT32                  ByteLength,
 594     char                    *Name,
 595     UINT32                  Value)
 596 {
 597 
 598     if (Gbl_DoTemplates && !Gbl_VerboseTemplates) /* Terse template */
 599     {
 600         if (ByteLength)
 601         {
 602             AcpiOsPrintf ("[%.4d] %30s %3d : ",
 603                 ByteLength, Name, Value);
 604         }
 605         else
 606         {
 607             AcpiOsPrintf ("%36s % 3d : ",
 608                 Name, Value);
 609         }
 610     }
 611     else /* Normal disassembler or verbose template */
 612     {
 613         if (ByteLength)
 614         {
 615             AcpiOsPrintf ("[%3.3Xh %4.4d %3d] %24s %3d : ",
 616                 Offset, Offset, ByteLength, Name, Value);
 617         }
 618         else
 619         {
 620             AcpiOsPrintf ("[%3.3Xh %4.4d   ] %24s %3d : ",
 621                 Offset, Offset, Name, Value);
 622         }
 623     }
 624 }
 625 
 626 
 627 /*******************************************************************************
 628  *
 629  * FUNCTION:    AcpiDmDumpTable
 630  *
 631  * PARAMETERS:  TableLength         - Length of the entire ACPI table
 632  *              TableOffset         - Starting offset within the table for this
 633  *                                    sub-descriptor (0 if main table)
 634  *              Table               - The ACPI table
 635  *              SubtableLength      - Length of this sub-descriptor
 636  *              Info                - Info table for this ACPI table
 637  *
 638  * RETURN:      None
 639  *
 640  * DESCRIPTION: Display ACPI table contents by walking the Info table.
 641  *
 642  * Note: This function must remain in sync with DtGetFieldLength.
 643  *
 644  ******************************************************************************/
 645 
 646 ACPI_STATUS
 647 AcpiDmDumpTable (
 648     UINT32                  TableLength,
 649     UINT32                  TableOffset,
 650     void                    *Table,
 651     UINT32                  SubtableLength,
 652     ACPI_DMTABLE_INFO       *Info)
 653 {
 654     UINT8                   *Target;
 655     UINT32                  CurrentOffset;
 656     UINT32                  ByteLength;
 657     UINT8                   Temp8;
 658     UINT16                  Temp16;
 659     UINT64                  Value;
 660     ACPI_DMTABLE_DATA       *TableData;
 661     const char              *Name;
 662     BOOLEAN                 LastOutputBlankLine = FALSE;
 663     char                    RepairedName[8];
 664 
 665 
 666     if (!Info)
 667     {
 668         AcpiOsPrintf ("Display not implemented\n");
 669         return (AE_NOT_IMPLEMENTED);
 670     }
 671 
 672     /* Walk entire Info table; Null name terminates */
 673 
 674     for (; Info->Name; Info++)
 675     {
 676         /*
 677          * Target points to the field within the ACPI Table. CurrentOffset is
 678          * the offset of the field from the start of the main table.
 679          */
 680         Target = ACPI_ADD_PTR (UINT8, Table, Info->Offset);
 681         CurrentOffset = TableOffset + Info->Offset;
 682 
 683         /* Check for beyond EOT or beyond subtable end */
 684 
 685         if ((CurrentOffset >= TableLength) ||
 686             (SubtableLength && (Info->Offset >= SubtableLength)))
 687         {
 688             AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 689             return (AE_BAD_DATA);
 690         }
 691 
 692         /* Generate the byte length for this field */
 693 
 694         switch (Info->Opcode)
 695         {
 696         case ACPI_DMT_UINT8:
 697         case ACPI_DMT_CHKSUM:
 698         case ACPI_DMT_SPACEID:
 699         case ACPI_DMT_ACCWIDTH:
 700         case ACPI_DMT_IVRS:
 701         case ACPI_DMT_MADT:
 702         case ACPI_DMT_PCCT:
 703         case ACPI_DMT_PMTT:
 704         case ACPI_DMT_SRAT:
 705         case ACPI_DMT_ASF:
 706         case ACPI_DMT_HESTNTYP:
 707         case ACPI_DMT_FADTPM:
 708         case ACPI_DMT_EINJACT:
 709         case ACPI_DMT_EINJINST:
 710         case ACPI_DMT_ERSTACT:
 711         case ACPI_DMT_ERSTINST:
 712 
 713             ByteLength = 1;
 714             break;
 715 
 716         case ACPI_DMT_UINT16:
 717         case ACPI_DMT_DMAR:
 718         case ACPI_DMT_HEST:
 719 
 720             ByteLength = 2;
 721             break;
 722 
 723         case ACPI_DMT_UINT24:
 724 
 725             ByteLength = 3;
 726             break;
 727 
 728         case ACPI_DMT_UINT32:
 729         case ACPI_DMT_NAME4:
 730         case ACPI_DMT_SIG:
 731         case ACPI_DMT_SLIC:
 732 
 733             ByteLength = 4;
 734             break;
 735 
 736         case ACPI_DMT_UINT40:
 737 
 738             ByteLength = 5;
 739             break;
 740 
 741         case ACPI_DMT_UINT48:
 742         case ACPI_DMT_NAME6:
 743 
 744             ByteLength = 6;
 745             break;
 746 
 747         case ACPI_DMT_UINT56:
 748         case ACPI_DMT_BUF7:
 749 
 750             ByteLength = 7;
 751             break;
 752 
 753         case ACPI_DMT_UINT64:
 754         case ACPI_DMT_NAME8:
 755 
 756             ByteLength = 8;
 757             break;
 758 
 759         case ACPI_DMT_BUF10:
 760 
 761             ByteLength = 10;
 762             break;
 763 
 764         case ACPI_DMT_BUF16:
 765         case ACPI_DMT_UUID:
 766 
 767             ByteLength = 16;
 768             break;
 769 
 770         case ACPI_DMT_BUF128:
 771 
 772             ByteLength = 128;
 773             break;
 774 
 775         case ACPI_DMT_STRING:
 776 
 777             ByteLength = ACPI_STRLEN (ACPI_CAST_PTR (char, Target)) + 1;
 778             break;
 779 
 780         case ACPI_DMT_GAS:
 781 
 782             if (!LastOutputBlankLine)
 783             {
 784                 AcpiOsPrintf ("\n");
 785                 LastOutputBlankLine = TRUE;
 786             }
 787             ByteLength = sizeof (ACPI_GENERIC_ADDRESS);
 788             break;
 789 
 790         case ACPI_DMT_HESTNTFY:
 791 
 792             if (!LastOutputBlankLine)
 793             {
 794                 AcpiOsPrintf ("\n");
 795                 LastOutputBlankLine = TRUE;
 796             }
 797             ByteLength = sizeof (ACPI_HEST_NOTIFY);
 798             break;
 799 
 800         default:
 801 
 802             ByteLength = 0;
 803             break;
 804         }
 805 
 806         if (CurrentOffset + ByteLength > TableLength)
 807         {
 808             AcpiOsPrintf ("**** ACPI table terminates in the middle of a data structure!\n");
 809             return (AE_BAD_DATA);
 810         }
 811 
 812         if (Info->Opcode == ACPI_DMT_EXTRA_TEXT)
 813         {
 814             AcpiOsPrintf ("%s", Info->Name);
 815             continue;
 816         }
 817 
 818         /* Start a new line and decode the opcode */
 819 
 820         AcpiDmLineHeader (CurrentOffset, ByteLength, Info->Name);
 821 
 822         switch (Info->Opcode)
 823         {
 824         /* Single-bit Flag fields. Note: Opcode is the bit position */
 825 
 826         case ACPI_DMT_FLAG0:
 827         case ACPI_DMT_FLAG1:
 828         case ACPI_DMT_FLAG2:
 829         case ACPI_DMT_FLAG3:
 830         case ACPI_DMT_FLAG4:
 831         case ACPI_DMT_FLAG5:
 832         case ACPI_DMT_FLAG6:
 833         case ACPI_DMT_FLAG7:
 834 
 835             AcpiOsPrintf ("%1.1X\n", (*Target >> Info->Opcode) & 0x01);
 836             break;
 837 
 838         /* 2-bit Flag fields */
 839 
 840         case ACPI_DMT_FLAGS0:
 841 
 842             AcpiOsPrintf ("%1.1X\n", *Target & 0x03);
 843             break;
 844 
 845         case ACPI_DMT_FLAGS1:
 846 
 847             AcpiOsPrintf ("%1.1X\n", (*Target >> 1) & 0x03);
 848             break;
 849 
 850         case ACPI_DMT_FLAGS2:
 851 
 852             AcpiOsPrintf ("%1.1X\n", (*Target >> 2) & 0x03);
 853             break;
 854 
 855         case ACPI_DMT_FLAGS4:
 856 
 857             AcpiOsPrintf ("%1.1X\n", (*Target >> 4) & 0x03);
 858             break;
 859 
 860         /* Integer Data Types */
 861 
 862         case ACPI_DMT_UINT8:
 863         case ACPI_DMT_UINT16:
 864         case ACPI_DMT_UINT24:
 865         case ACPI_DMT_UINT32:
 866         case ACPI_DMT_UINT40:
 867         case ACPI_DMT_UINT48:
 868         case ACPI_DMT_UINT56:
 869         case ACPI_DMT_UINT64:
 870             /*
 871              * Dump bytes - high byte first, low byte last.
 872              * Note: All ACPI tables are little-endian.
 873              */
 874             Value = 0;
 875             for (Temp8 = (UINT8) ByteLength; Temp8 > 0; Temp8--)
 876             {
 877                 AcpiOsPrintf ("%2.2X", Target[Temp8 - 1]);
 878                 Value |= Target[Temp8 - 1];
 879                 Value <<= 8;
 880             }
 881 
 882             if (!Value && (Info->Flags & DT_DESCRIBES_OPTIONAL))
 883             {
 884                 AcpiOsPrintf (" [Optional field not present]");
 885             }
 886 
 887             AcpiOsPrintf ("\n");
 888             break;
 889 
 890         case ACPI_DMT_BUF7:
 891         case ACPI_DMT_BUF10:
 892         case ACPI_DMT_BUF16:
 893         case ACPI_DMT_BUF128:
 894             /*
 895              * Buffer: Size depends on the opcode and was set above.
 896              * Each hex byte is separated with a space.
 897              * Multiple lines are separated by line continuation char.
 898              */
 899             for (Temp16 = 0; Temp16 < ByteLength; Temp16++)
 900             {
 901                 AcpiOsPrintf ("%2.2X", Target[Temp16]);
 902                 if ((UINT32) (Temp16 + 1) < ByteLength)
 903                 {
 904                     if ((Temp16 > 0) && (!((Temp16+1) % 16)))
 905                     {
 906                         AcpiOsPrintf (" \\\n"); /* Line continuation */
 907                         AcpiDmLineHeader (0, 0, NULL);
 908                     }
 909                     else
 910                     {
 911                         AcpiOsPrintf (" ");
 912                     }
 913                 }
 914             }
 915             AcpiOsPrintf ("\n");
 916             break;
 917 
 918         case ACPI_DMT_UUID:
 919 
 920             /* Convert 16-byte UUID buffer to 36-byte formatted UUID string */
 921 
 922             (void) AuConvertUuidToString ((char *) Target, MsgBuffer);
 923 
 924             AcpiOsPrintf ("%s\n", MsgBuffer);
 925             break;
 926 
 927         case ACPI_DMT_STRING:
 928 
 929             AcpiOsPrintf ("\"%s\"\n", ACPI_CAST_PTR (char, Target));
 930             break;
 931 
 932         /* Fixed length ASCII name fields */
 933 
 934         case ACPI_DMT_SIG:
 935 
 936             AcpiDmCheckAscii (Target, RepairedName, 4);
 937             AcpiOsPrintf ("\"%.4s\"    ", RepairedName);
 938             TableData = AcpiDmGetTableData (ACPI_CAST_PTR (char, Target));
 939             if (TableData)
 940             {
 941                 AcpiOsPrintf (STRING_FORMAT, TableData->Name);
 942             }
 943             else
 944             {
 945                 AcpiOsPrintf ("\n");
 946             }
 947             break;
 948 
 949         case ACPI_DMT_NAME4:
 950 
 951             AcpiDmCheckAscii (Target, RepairedName, 4);
 952             AcpiOsPrintf ("\"%.4s\"\n", RepairedName);
 953             break;
 954 
 955         case ACPI_DMT_NAME6:
 956 
 957             AcpiDmCheckAscii (Target, RepairedName, 6);
 958             AcpiOsPrintf ("\"%.6s\"\n", RepairedName);
 959             break;
 960 
 961         case ACPI_DMT_NAME8:
 962 
 963             AcpiDmCheckAscii (Target, RepairedName, 8);
 964             AcpiOsPrintf ("\"%.8s\"\n", RepairedName);
 965             break;
 966 
 967         /* Special Data Types */
 968 
 969         case ACPI_DMT_CHKSUM:
 970 
 971             /* Checksum, display and validate */
 972 
 973             AcpiOsPrintf ("%2.2X", *Target);
 974             Temp8 = AcpiDmGenerateChecksum (Table,
 975                         ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Length,
 976                         ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum);
 977             if (Temp8 != ACPI_CAST_PTR (ACPI_TABLE_HEADER, Table)->Checksum)
 978             {
 979                 AcpiOsPrintf (
 980                     "     /* Incorrect checksum, should be %2.2X */", Temp8);
 981             }
 982             AcpiOsPrintf ("\n");
 983             break;
 984 
 985         case ACPI_DMT_SPACEID:
 986 
 987             /* Address Space ID */
 988 
 989             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiUtGetRegionName (*Target));
 990             break;
 991 
 992         case ACPI_DMT_ACCWIDTH:
 993 
 994             /* Encoded Access Width */
 995 
 996             Temp8 = *Target;
 997             if (Temp8 > ACPI_GAS_WIDTH_RESERVED)
 998             {
 999                 Temp8 = ACPI_GAS_WIDTH_RESERVED;
1000             }
1001 
1002             AcpiOsPrintf (UINT8_FORMAT, Temp8, AcpiDmGasAccessWidth[Temp8]);
1003             break;
1004 
1005         case ACPI_DMT_GAS:
1006 
1007             /* Generic Address Structure */
1008 
1009             AcpiOsPrintf (STRING_FORMAT, "Generic Address Structure");
1010             AcpiDmDumpTable (TableLength, CurrentOffset, Target,
1011                 sizeof (ACPI_GENERIC_ADDRESS), AcpiDmTableInfoGas);
1012             AcpiOsPrintf ("\n");
1013             LastOutputBlankLine = TRUE;
1014             break;
1015 
1016         case ACPI_DMT_ASF:
1017 
1018             /* ASF subtable types */
1019 
1020             Temp16 = (UINT16) ((*Target) & 0x7F);  /* Top bit can be zero or one */
1021             if (Temp16 > ACPI_ASF_TYPE_RESERVED)
1022             {
1023                 Temp16 = ACPI_ASF_TYPE_RESERVED;
1024             }
1025 
1026             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmAsfSubnames[Temp16]);
1027             break;
1028 
1029         case ACPI_DMT_DMAR:
1030 
1031             /* DMAR subtable types */
1032 
1033             Temp16 = ACPI_GET16 (Target);
1034             if (Temp16 > ACPI_DMAR_TYPE_RESERVED)
1035             {
1036                 Temp16 = ACPI_DMAR_TYPE_RESERVED;
1037             }
1038 
1039             AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), AcpiDmDmarSubnames[Temp16]);
1040             break;
1041 
1042         case ACPI_DMT_EINJACT:
1043 
1044             /* EINJ Action types */
1045 
1046             Temp8 = *Target;
1047             if (Temp8 > ACPI_EINJ_ACTION_RESERVED)
1048             {
1049                 Temp8 = ACPI_EINJ_ACTION_RESERVED;
1050             }
1051 
1052             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmEinjActions[Temp8]);
1053             break;
1054 
1055         case ACPI_DMT_EINJINST:
1056 
1057             /* EINJ Instruction types */
1058 
1059             Temp8 = *Target;
1060             if (Temp8 > ACPI_EINJ_INSTRUCTION_RESERVED)
1061             {
1062                 Temp8 = ACPI_EINJ_INSTRUCTION_RESERVED;
1063             }
1064 
1065             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmEinjInstructions[Temp8]);
1066             break;
1067 
1068         case ACPI_DMT_ERSTACT:
1069 
1070             /* ERST Action types */
1071 
1072             Temp8 = *Target;
1073             if (Temp8 > ACPI_ERST_ACTION_RESERVED)
1074             {
1075                 Temp8 = ACPI_ERST_ACTION_RESERVED;
1076             }
1077 
1078             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmErstActions[Temp8]);
1079             break;
1080 
1081         case ACPI_DMT_ERSTINST:
1082 
1083             /* ERST Instruction types */
1084 
1085             Temp8 = *Target;
1086             if (Temp8 > ACPI_ERST_INSTRUCTION_RESERVED)
1087             {
1088                 Temp8 = ACPI_ERST_INSTRUCTION_RESERVED;
1089             }
1090 
1091             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmErstInstructions[Temp8]);
1092             break;
1093 
1094         case ACPI_DMT_HEST:
1095 
1096             /* HEST subtable types */
1097 
1098             Temp16 = ACPI_GET16 (Target);
1099             if (Temp16 > ACPI_HEST_TYPE_RESERVED)
1100             {
1101                 Temp16 = ACPI_HEST_TYPE_RESERVED;
1102             }
1103 
1104             AcpiOsPrintf (UINT16_FORMAT, ACPI_GET16 (Target), AcpiDmHestSubnames[Temp16]);
1105             break;
1106 
1107         case ACPI_DMT_HESTNTFY:
1108 
1109             AcpiOsPrintf (STRING_FORMAT, "Hardware Error Notification Structure");
1110             AcpiDmDumpTable (TableLength, CurrentOffset, Target,
1111                 sizeof (ACPI_HEST_NOTIFY), AcpiDmTableInfoHestNotify);
1112             AcpiOsPrintf ("\n");
1113             LastOutputBlankLine = TRUE;
1114             break;
1115 
1116         case ACPI_DMT_HESTNTYP:
1117 
1118             /* HEST Notify types */
1119 
1120             Temp8 = *Target;
1121             if (Temp8 > ACPI_HEST_NOTIFY_RESERVED)
1122             {
1123                 Temp8 = ACPI_HEST_NOTIFY_RESERVED;
1124             }
1125 
1126             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmHestNotifySubnames[Temp8]);
1127             break;
1128 
1129         case ACPI_DMT_MADT:
1130 
1131             /* MADT subtable types */
1132 
1133             Temp8 = *Target;
1134             if (Temp8 > ACPI_MADT_TYPE_RESERVED)
1135             {
1136                 Temp8 = ACPI_MADT_TYPE_RESERVED;
1137             }
1138 
1139             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmMadtSubnames[Temp8]);
1140             break;
1141 
1142         case ACPI_DMT_PCCT:
1143 
1144             /* PCCT subtable types */
1145 
1146             Temp8 = *Target;
1147             if (Temp8 > ACPI_PCCT_TYPE_RESERVED)
1148             {
1149                 Temp8 = ACPI_PCCT_TYPE_RESERVED;
1150             }
1151 
1152             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmPcctSubnames[Temp8]);
1153             break;
1154 
1155         case ACPI_DMT_PMTT:
1156 
1157             /* PMTT subtable types */
1158 
1159             Temp8 = *Target;
1160             if (Temp8 > ACPI_PMTT_TYPE_RESERVED)
1161             {
1162                 Temp8 = ACPI_PMTT_TYPE_RESERVED;
1163             }
1164 
1165             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmPmttSubnames[Temp8]);
1166             break;
1167 
1168         case ACPI_DMT_SLIC:
1169 
1170             /* SLIC subtable types */
1171 
1172             Temp8 = *Target;
1173             if (Temp8 > ACPI_SLIC_TYPE_RESERVED)
1174             {
1175                 Temp8 = ACPI_SLIC_TYPE_RESERVED;
1176             }
1177 
1178             AcpiOsPrintf (UINT32_FORMAT, *Target, AcpiDmSlicSubnames[Temp8]);
1179             break;
1180 
1181         case ACPI_DMT_SRAT:
1182 
1183             /* SRAT subtable types */
1184 
1185             Temp8 = *Target;
1186             if (Temp8 > ACPI_SRAT_TYPE_RESERVED)
1187             {
1188                 Temp8 = ACPI_SRAT_TYPE_RESERVED;
1189             }
1190 
1191             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmSratSubnames[Temp8]);
1192             break;
1193 
1194         case ACPI_DMT_FADTPM:
1195 
1196             /* FADT Preferred PM Profile names */
1197 
1198             Temp8 = *Target;
1199             if (Temp8 > ACPI_FADT_PM_RESERVED)
1200             {
1201                 Temp8 = ACPI_FADT_PM_RESERVED;
1202             }
1203 
1204             AcpiOsPrintf (UINT8_FORMAT, *Target, AcpiDmFadtProfiles[Temp8]);
1205             break;
1206 
1207         case ACPI_DMT_IVRS:
1208 
1209             /* IVRS subtable types */
1210 
1211             Temp8 = *Target;
1212             switch (Temp8)
1213             {
1214             case ACPI_IVRS_TYPE_HARDWARE:
1215 
1216                 Name = AcpiDmIvrsSubnames[0];
1217                 break;
1218 
1219             case ACPI_IVRS_TYPE_MEMORY1:
1220             case ACPI_IVRS_TYPE_MEMORY2:
1221             case ACPI_IVRS_TYPE_MEMORY3:
1222 
1223                 Name = AcpiDmIvrsSubnames[1];
1224                 break;
1225 
1226             default:
1227 
1228                 Name = AcpiDmIvrsSubnames[2];
1229                 break;
1230             }
1231 
1232             AcpiOsPrintf (UINT8_FORMAT, *Target, Name);
1233             break;
1234 
1235         case ACPI_DMT_EXIT:
1236 
1237             return (AE_OK);
1238 
1239         default:
1240 
1241             ACPI_ERROR ((AE_INFO,
1242                 "**** Invalid table opcode [0x%X] ****\n", Info->Opcode));
1243             return (AE_SUPPORT);
1244         }
1245     }
1246 
1247     if (TableOffset && !SubtableLength)
1248     {
1249         /* If this table is not the main table, subtable must have valid length */
1250 
1251         AcpiOsPrintf ("Invalid zero length subtable\n");
1252         return (AE_BAD_DATA);
1253     }
1254 
1255     return (AE_OK);
1256 }
1257 
1258 
1259 /*******************************************************************************
1260  *
1261  * FUNCTION:    AcpiDmCheckAscii
1262  *
1263  * PARAMETERS:  Name                - Ascii string
1264  *              Count               - Number of characters to check
1265  *
1266  * RETURN:      None
1267  *
1268  * DESCRIPTION: Ensure that the requested number of characters are printable
1269  *              Ascii characters. Sets non-printable and null chars to <space>.
1270  *
1271  ******************************************************************************/
1272 
1273 static void
1274 AcpiDmCheckAscii (
1275     UINT8                   *Name,
1276     char                    *RepairedName,
1277     UINT32                  Count)
1278 {
1279     UINT32                  i;
1280 
1281 
1282     for (i = 0; i < Count; i++)
1283     {
1284         RepairedName[i] = (char) Name[i];
1285 
1286         if (!Name[i])
1287         {
1288             return;
1289         }
1290         if (!isprint (Name[i]))
1291         {
1292             RepairedName[i] = ' ';
1293         }
1294     }
1295 }