ShellPkg/Library/UefiShellAcpiViewCommandLib/Parsers/Slit/SlitParser.c

   1 /** @file
   2   SLIT table parser
   3
   4   Copyright (c) 2016 - 2018, ARM Limited. All rights reserved.
   5   SPDX-License-Identifier: BSD-2-Clause-Patent
   6
   7   @par Reference(s):
   8     - ACPI 6.2 Specification - Errata A, September 2017
   9 **/
  10
  11 #include <IndustryStandard/Acpi.h>
  12 #include <Library/PrintLib.h>
  13 #include <Library/UefiLib.h>
  14 #include "AcpiParser.h"
  15 #include "AcpiTableParser.h"
  16
  17 // Local Variables
  18 STATIC CONST UINT64* SlitSystemLocalityCount;
  19 STATIC ACPI_DESCRIPTION_HEADER_INFO AcpiHdrInfo;
  20
  21 /**
  22   An ACPI_PARSER array describing the ACPI SLIT table.
  23 **/
  24 STATIC CONST ACPI_PARSER SlitParser[] = {
  25   PARSE_ACPI_HEADER (&AcpiHdrInfo),
  26   {L"Number of System Localities", 8, 36, L"0x%lx", NULL,
  27    (VOID**)&SlitSystemLocalityCount, NULL, NULL}
  28 };
  29
  30 /**
  31   Macro to get the value of a System Locality
  32 **/
  33 #define SLIT_ELEMENT(Ptr, i, j) *(Ptr + (i * LocalityCount) + j)
  34
  35 /**
  36   This function parses the ACPI SLIT table.
  37   When trace is enabled this function parses the SLIT table and
  38   traces the ACPI table fields.
  39
  40   This function also validates System Localities for the following:
  41     - Diagonal elements have a normalized value of 10
  42     - Relative distance from System Locality at i*N+j is same as
  43       j*N+i
  44
  45   @param [in] Trace              If TRUE, trace the ACPI fields.
  46   @param [in] Ptr                Pointer to the start of the buffer.
  47   @param [in] AcpiTableLength    Length of the ACPI table.
  48   @param [in] AcpiTableRevision  Revision of the ACPI table.
  49 **/
  50 VOID
  51 EFIAPI
  52 ParseAcpiSlit (
  53   IN BOOLEAN Trace,
  54   IN UINT8*  Ptr,
  55   IN UINT32  AcpiTableLength,
  56   IN UINT8   AcpiTableRevision
  57   )
  58 {
  59   UINT32 Offset;
  60   UINT64 Count;
  61   UINT64 Index;
  62   UINT64 LocalityCount;
  63   UINT8* LocalityPtr;
  64   CHAR16 Buffer[80];  // Used for AsciiName param of ParseAcpi
  65
  66   if (!Trace) {
  67     return;
  68   }
  69
  70   Offset = ParseAcpi (
  71              TRUE,
  72              0,
  73              "SLIT",
  74              Ptr,
  75              AcpiTableLength,
  76              PARSER_PARAMS (SlitParser)
  77              );
  78   LocalityPtr = Ptr + Offset;
  79
  80   LocalityCount = *SlitSystemLocalityCount;
  81   // We only print the Localities if the count is less than 16
  82   // If the locality count is more than 16 then refer to the
  83   // raw data dump.
  84   if (LocalityCount < 16) {
  85     UnicodeSPrint (
  86       Buffer,
  87       sizeof (Buffer),
  88       L"Entry[0x%lx][0x%lx]",
  89       LocalityCount,
  90       LocalityCount
  91       );
  92     PrintFieldName (0, Buffer);
  93     Print (L"\n");
  94     Print (L"       ");
  95     for (Index = 0; Index < LocalityCount; Index++) {
  96       Print (L" (%3d) ", Index);
  97     }
  98     Print (L"\n");
  99     for (Count = 0; Count< LocalityCount; Count++) {
 100       Print (L" (%3d) ", Count);
 101       for (Index = 0; Index < LocalityCount; Index++) {
 102         Print (L"  %3d  ", SLIT_ELEMENT (LocalityPtr, Count, Index));
 103       }
 104       Print (L"\n");
 105     }
 106   }
 107
 108   // Validate
 109   for (Count = 0; Count < LocalityCount; Count++) {
 110     for (Index = 0; Index < LocalityCount; Index++) {
 111       // Element[x][x] must be equal to 10
 112       if ((Count == Index) && (SLIT_ELEMENT (LocalityPtr, Count,Index) != 10)) {
 113         IncrementErrorCount ();
 114         Print (
 115           L"ERROR: Diagonal Element[0x%lx][0x%lx] (%3d)."
 116             L" Normalized Value is not 10\n",
 117           Count,
 118           Index,
 119           SLIT_ELEMENT (LocalityPtr, Count, Index)
 120           );
 121       }
 122       // Element[i][j] must be equal to Element[j][i]
 123       if (SLIT_ELEMENT (LocalityPtr, Count, Index) !=
 124           SLIT_ELEMENT (LocalityPtr, Index, Count)) {
 125         IncrementErrorCount ();
 126         Print (
 127           L"ERROR: Relative distances for Element[0x%lx][0x%lx] (%3d) and \n"
 128            L"Element[0x%lx][0x%lx] (%3d) do not match.\n",
 129           Count,
 130           Index,
 131           SLIT_ELEMENT (LocalityPtr, Count, Index),
 132           Index,
 133           Count,
 134           SLIT_ELEMENT (LocalityPtr, Index, Count)
 135           );
 136       }
 137     }
 138   }
 139 }