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 }