[mirror_edk2.git] / ArmPkg / Library / ArmLib / AArch64 / AArch64Mmu.c

/** @file\r
*  File managing the MMU for ARMv8 architecture\r
*\r
*  Copyright (c) 2011-2014, ARM Limited. All rights reserved.\r
*\r
*  This program and the accompanying materials\r
*  are licensed and made available under the terms and conditions of the BSD License\r
*  which accompanies this distribution.  The full text of the license may be found at\r
*  http://opensource.org/licenses/bsd-license.php\r
*\r
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
*\r
**/\r
\r
#include <Uefi.h>\r
#include <Chipset/AArch64.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/ArmLib.h>\r
#include <Library/BaseLib.h>\r
#include <Library/DebugLib.h>\r
#include "AArch64Lib.h"\r
#include "ArmLibPrivate.h"\r
\r
// We use this index definition to define an invalid block entry\r
#define TT_ATTR_INDX_INVALID    ((UINT32)~0)\r
\r
STATIC\r
UINT64\r
ArmMemoryAttributeToPageAttribute (\r
  IN ARM_MEMORY_REGION_ATTRIBUTES  Attributes\r
  )\r
{\r
  switch (Attributes) {\r
  case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK:\r
    return TT_ATTR_INDX_MEMORY_WRITE_BACK;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH:\r
    return TT_ATTR_INDX_MEMORY_WRITE_THROUGH;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_DEVICE:\r
    return TT_ATTR_INDX_DEVICE_MEMORY;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED:\r
    return TT_ATTR_INDX_MEMORY_NON_CACHEABLE;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK:\r
    return TT_ATTR_INDX_MEMORY_WRITE_BACK;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH:\r
    return TT_ATTR_INDX_MEMORY_WRITE_THROUGH;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_DEVICE:\r
    return TT_ATTR_INDX_DEVICE_MEMORY;\r
  case ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED:\r
    return TT_ATTR_INDX_MEMORY_NON_CACHEABLE;\r
  default:\r
    ASSERT(0);\r
    return TT_ATTR_INDX_DEVICE_MEMORY;\r
  }\r
}\r
\r
UINT64\r
PageAttributeToGcdAttribute (\r
  IN UINT64 PageAttributes\r
  )\r
{\r
  UINT64  GcdAttributes;\r
\r
  switch (PageAttributes & TT_ATTR_INDX_MASK) {\r
  case TT_ATTR_INDX_DEVICE_MEMORY:\r
    GcdAttributes = EFI_MEMORY_UC;\r
    break;\r
  case TT_ATTR_INDX_MEMORY_NON_CACHEABLE:\r
    GcdAttributes = EFI_MEMORY_WC;\r
    break;\r
  case TT_ATTR_INDX_MEMORY_WRITE_THROUGH:\r
    GcdAttributes = EFI_MEMORY_WT;\r
    break;\r
  case TT_ATTR_INDX_MEMORY_WRITE_BACK:\r
    GcdAttributes = EFI_MEMORY_WB;\r
    break;\r
  default:\r
    DEBUG ((EFI_D_ERROR, "PageAttributeToGcdAttribute: PageAttributes:0x%lX not supported.\n", PageAttributes));\r
    ASSERT (0);\r
    // The Global Coherency Domain (GCD) value is defined as a bit set.\r
    // Returning 0 means no attribute has been set.\r
    GcdAttributes = 0;\r
  }\r
\r
  // Determine protection attributes\r
  if (((PageAttributes & TT_AP_MASK) == TT_AP_NO_RO) || ((PageAttributes & TT_AP_MASK) == TT_AP_RO_RO)) {\r
    // Read only cases map to write-protect\r
    GcdAttributes |= EFI_MEMORY_WP;\r
  }\r
\r
  // Process eXecute Never attribute\r
  if ((PageAttributes & (TT_PXN_MASK | TT_UXN_MASK)) != 0 ) {\r
    GcdAttributes |= EFI_MEMORY_XP;\r
  }\r
\r
  return GcdAttributes;\r
}\r
\r
UINT64\r
GcdAttributeToPageAttribute (\r
  IN UINT64 GcdAttributes\r
  )\r
{\r
  UINT64  PageAttributes;\r
\r
  switch (GcdAttributes & 0xFF) {\r
  case EFI_MEMORY_UC:\r
    PageAttributes = TT_ATTR_INDX_DEVICE_MEMORY;\r
    break;\r
  case EFI_MEMORY_WC:\r
    PageAttributes = TT_ATTR_INDX_MEMORY_NON_CACHEABLE;\r
    break;\r
  case EFI_MEMORY_WT:\r
    PageAttributes = TT_ATTR_INDX_MEMORY_WRITE_THROUGH;\r
    break;\r
  case EFI_MEMORY_WB:\r
    PageAttributes = TT_ATTR_INDX_MEMORY_WRITE_BACK;\r
    break;\r
  default:\r
    DEBUG ((EFI_D_ERROR, "GcdAttributeToPageAttribute: 0x%X attributes is not supported.\n", GcdAttributes));\r
    ASSERT (0);\r
    // If no match has been found then we mark the memory as device memory.\r
    // The only side effect of using device memory should be a slow down in the performance.\r
    PageAttributes = TT_ATTR_INDX_DEVICE_MEMORY;\r
  }\r
\r
  // Determine protection attributes\r
  if (GcdAttributes & EFI_MEMORY_WP) {\r
    // Read only cases map to write-protect\r
    PageAttributes |= TT_AP_RO_RO;\r
  }\r
\r
  // Process eXecute Never attribute\r
  if (GcdAttributes & EFI_MEMORY_XP) {\r
    PageAttributes |= (TT_PXN_MASK | TT_UXN_MASK);\r
  }\r
\r
  return PageAttributes;\r
}\r
\r
ARM_MEMORY_REGION_ATTRIBUTES\r
GcdAttributeToArmAttribute (\r
  IN UINT64 GcdAttributes\r
  )\r
{\r
  switch (GcdAttributes & 0xFF) {\r
  case EFI_MEMORY_UC:\r
    return ARM_MEMORY_REGION_ATTRIBUTE_DEVICE;\r
  case EFI_MEMORY_WC:\r
    return ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED;\r
  case EFI_MEMORY_WT:\r
    return ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH;\r
  case EFI_MEMORY_WB:\r
    return ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK;\r
  default:\r
    DEBUG ((EFI_D_ERROR, "GcdAttributeToArmAttribute: 0x%lX attributes is not supported.\n", GcdAttributes));\r
    ASSERT (0);\r
    return ARM_MEMORY_REGION_ATTRIBUTE_DEVICE;\r
  }\r
}\r
\r
// Describe the T0SZ values for each translation table level\r
typedef struct {\r
  UINTN     MinT0SZ;\r
  UINTN     MaxT0SZ;\r
  UINTN     LargestT0SZ; // Generally (MaxT0SZ == LargestT0SZ) but at the Level3 Table\r
                         // the MaxT0SZ is not at the boundary of the table\r
} T0SZ_DESCRIPTION_PER_LEVEL;\r
\r
// Map table for the corresponding Level of Table\r
STATIC CONST T0SZ_DESCRIPTION_PER_LEVEL T0SZPerTableLevel[] = {\r
    { 16, 24, 24 }, // Table Level 0\r
    { 25, 33, 33 }, // Table Level 1\r
    { 34, 39, 42 }  // Table Level 2\r
};\r
\r
VOID\r
GetRootTranslationTableInfo (\r
  IN UINTN     T0SZ,\r
  OUT UINTN   *TableLevel,\r
  OUT UINTN   *TableEntryCount\r
  )\r
{\r
  UINTN Index;\r
\r
  // Identify the level of the root table from the given T0SZ\r
  for (Index = 0; Index < sizeof (T0SZPerTableLevel) / sizeof (T0SZ_DESCRIPTION_PER_LEVEL); Index++) {\r
    if (T0SZ <= T0SZPerTableLevel[Index].MaxT0SZ) {\r
      break;\r
    }\r
  }\r
\r
  // If we have not found the corresponding maximum T0SZ then we use the last one\r
  if (Index == sizeof (T0SZPerTableLevel) / sizeof (T0SZ_DESCRIPTION_PER_LEVEL)) {\r
    Index--;\r
  }\r
\r
  // Get the level of the root table\r
  if (TableLevel) {\r
    *TableLevel = Index;\r
  }\r
\r
  // The Size of the Table is 2^(T0SZ-LargestT0SZ)\r
  if (TableEntryCount) {\r
    *TableEntryCount = 1 << (T0SZPerTableLevel[Index].LargestT0SZ - T0SZ + 1);\r
  }\r
}\r
\r
STATIC\r
VOID\r
LookupAddresstoRootTable (\r
  IN  UINT64  MaxAddress,\r
  OUT UINTN  *T0SZ,\r
  OUT UINTN  *TableEntryCount\r
  )\r
{\r
  UINTN TopBit;\r
\r
  // Check the parameters are not NULL\r
  ASSERT ((T0SZ != NULL) && (TableEntryCount != NULL));\r
\r
  // Look for the highest bit set in MaxAddress\r
  for (TopBit = 63; TopBit != 0; TopBit--) {\r
    if ((1ULL << TopBit) & MaxAddress) {\r
      // MaxAddress top bit is found\r
      TopBit = TopBit + 1;\r
      break;\r
    }\r
  }\r
  ASSERT (TopBit != 0);\r
\r
  // Calculate T0SZ from the top bit of the MaxAddress\r
  *T0SZ = 64 - TopBit;\r
\r
  // Get the Table info from T0SZ\r
  GetRootTranslationTableInfo (*T0SZ, NULL, TableEntryCount);\r
}\r
\r
STATIC\r
UINT64*\r
GetBlockEntryListFromAddress (\r
  IN  UINT64       *RootTable,\r
  IN  UINT64        RegionStart,\r
  OUT UINTN        *TableLevel,\r
  IN OUT UINT64    *BlockEntrySize,\r
  IN OUT UINT64   **LastBlockEntry\r
  )\r
{\r
  UINTN   RootTableLevel;\r
  UINTN   RootTableEntryCount;\r
  UINT64 *TranslationTable;\r
  UINT64 *BlockEntry;\r
  UINT64 *SubTableBlockEntry;\r
  UINT64  BlockEntryAddress;\r
  UINTN   BaseAddressAlignment;\r
  UINTN   PageLevel;\r
  UINTN   Index;\r
  UINTN   IndexLevel;\r
  UINTN   T0SZ;\r
  UINT64  Attributes;\r
  UINT64  TableAttributes;\r
\r
  // Initialize variable\r
  BlockEntry = NULL;\r
\r
  // Ensure the parameters are valid\r
  if (!(TableLevel && BlockEntrySize && LastBlockEntry)) {\r
    ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);\r
    return NULL;\r
  }\r
\r
  // Ensure the Region is aligned on 4KB boundary\r
  if ((RegionStart & (SIZE_4KB - 1)) != 0) {\r
    ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);\r
    return NULL;\r
  }\r
\r
  // Ensure the required size is aligned on 4KB boundary and not 0\r
  if ((*BlockEntrySize & (SIZE_4KB - 1)) != 0 || *BlockEntrySize == 0) {\r
    ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);\r
    return NULL;\r
  }\r
\r
  //\r
  // Calculate LastBlockEntry from T0SZ - this is the last block entry of the root Translation table\r
  //\r
  T0SZ = ArmGetTCR () & TCR_T0SZ_MASK;\r
  // Get the Table info from T0SZ\r
  GetRootTranslationTableInfo (T0SZ, &RootTableLevel, &RootTableEntryCount);\r
  // The last block of the root table depends on the number of entry in this table\r
  *LastBlockEntry = TT_LAST_BLOCK_ADDRESS(RootTable, RootTableEntryCount);\r
\r
  // If the start address is 0x0 then we use the size of the region to identify the alignment\r
  if (RegionStart == 0) {\r
    // Identify the highest possible alignment for the Region Size\r
    BaseAddressAlignment = LowBitSet64 (*BlockEntrySize);\r
  } else {\r
    // Identify the highest possible alignment for the Base Address\r
    BaseAddressAlignment = LowBitSet64 (RegionStart);\r
  }\r
\r
  // Identify the Page Level the RegionStart must belongs to\r
  PageLevel = 3 - ((BaseAddressAlignment - 12) / 9);\r
\r
  // If the required size is smaller than the current block size then we need to go to the page below.\r
  // The PageLevel was calculated on the Base Address alignment but did not take in account the alignment\r
  // of the allocation size\r
  while (*BlockEntrySize < TT_BLOCK_ENTRY_SIZE_AT_LEVEL (PageLevel)) {\r
    // It does not fit so we need to go a page level above\r
    PageLevel++;\r
  }\r
\r
  // Expose the found PageLevel to the caller\r
  *TableLevel = PageLevel;\r
\r
  // Now, we have the Table Level we can get the Block Size associated to this table\r
  *BlockEntrySize = TT_BLOCK_ENTRY_SIZE_AT_LEVEL (PageLevel);\r
\r
  //\r
  // Get the Table Descriptor for the corresponding PageLevel. We need to decompose RegionStart to get appropriate entries\r
  //\r
\r
  TranslationTable = RootTable;\r
  for (IndexLevel = RootTableLevel; IndexLevel <= PageLevel; IndexLevel++) {\r
    BlockEntry = (UINT64*)TT_GET_ENTRY_FOR_ADDRESS (TranslationTable, IndexLevel, RegionStart);\r
\r
    if ((IndexLevel != 3) && ((*BlockEntry & TT_TYPE_MASK) == TT_TYPE_TABLE_ENTRY)) {\r
      // Go to the next table\r
      TranslationTable = (UINT64*)(*BlockEntry & TT_ADDRESS_MASK_DESCRIPTION_TABLE);\r
\r
      // If we are at the last level then update the output\r
      if (IndexLevel == PageLevel) {\r
        // And get the appropriate BlockEntry at the next level\r
        BlockEntry = (UINT64*)TT_GET_ENTRY_FOR_ADDRESS (TranslationTable, IndexLevel + 1, RegionStart);\r
\r
        // Set the last block for this new table\r
        *LastBlockEntry = TT_LAST_BLOCK_ADDRESS(TranslationTable, TT_ENTRY_COUNT);\r
      }\r
    } else if ((*BlockEntry & TT_TYPE_MASK) == TT_TYPE_BLOCK_ENTRY) {\r
      // If we are not at the last level then we need to split this BlockEntry\r
      if (IndexLevel != PageLevel) {\r
        // Retrieve the attributes from the block entry\r
        Attributes = *BlockEntry & TT_ATTRIBUTES_MASK;\r
\r
        // Convert the block entry attributes into Table descriptor attributes\r
        TableAttributes = TT_TABLE_AP_NO_PERMISSION;\r
        if (Attributes & TT_PXN_MASK) {\r
          TableAttributes = TT_TABLE_PXN;\r
        }\r
        if (Attributes & TT_UXN_MASK) {\r
          TableAttributes = TT_TABLE_XN;\r
        }\r
        if (Attributes & TT_NS) {\r
          TableAttributes = TT_TABLE_NS;\r
        }\r
\r
        // Get the address corresponding at this entry\r
        BlockEntryAddress = RegionStart;\r
        BlockEntryAddress = BlockEntryAddress >> TT_ADDRESS_OFFSET_AT_LEVEL(IndexLevel);\r
        // Shift back to right to set zero before the effective address\r
        BlockEntryAddress = BlockEntryAddress << TT_ADDRESS_OFFSET_AT_LEVEL(IndexLevel);\r
\r
        // Set the correct entry type for the next page level\r
        if ((IndexLevel + 1) == 3) {\r
          Attributes |= TT_TYPE_BLOCK_ENTRY_LEVEL3;\r
        } else {\r
          Attributes |= TT_TYPE_BLOCK_ENTRY;\r
        }\r
\r
        // Create a new translation table\r
        TranslationTable = (UINT64*)AllocateAlignedPages (EFI_SIZE_TO_PAGES(TT_ENTRY_COUNT * sizeof(UINT64)), TT_ALIGNMENT_DESCRIPTION_TABLE);\r
        if (TranslationTable == NULL) {\r
          return NULL;\r
        }\r
\r
        // Populate the newly created lower level table\r
        SubTableBlockEntry = TranslationTable;\r
        for (Index = 0; Index < TT_ENTRY_COUNT; Index++) {\r
          *SubTableBlockEntry = Attributes | (BlockEntryAddress + (Index << TT_ADDRESS_OFFSET_AT_LEVEL(IndexLevel + 1)));\r
          SubTableBlockEntry++;\r
        }\r
\r
        // Fill the BlockEntry with the new TranslationTable\r
        *BlockEntry = ((UINTN)TranslationTable & TT_ADDRESS_MASK_DESCRIPTION_TABLE) | TableAttributes | TT_TYPE_TABLE_ENTRY;\r
        // Update the last block entry with the newly created translation table\r
        *LastBlockEntry = TT_LAST_BLOCK_ADDRESS(TranslationTable, TT_ENTRY_COUNT);\r
\r
        // Block Entry points at the beginning of the Translation Table\r
        BlockEntry = TranslationTable;\r
      }\r
    } else {\r
      if (IndexLevel != PageLevel) {\r
        //\r
        // Case when we have an Invalid Entry and we are at a page level above of the one targetted.\r
        //\r
\r
        // Create a new translation table\r
        TranslationTable = (UINT64*)AllocateAlignedPages (EFI_SIZE_TO_PAGES(TT_ENTRY_COUNT * sizeof(UINT64)), TT_ALIGNMENT_DESCRIPTION_TABLE);\r
        if (TranslationTable == NULL) {\r
          return NULL;\r
        }\r
\r
        ZeroMem (TranslationTable, TT_ENTRY_COUNT * sizeof(UINT64));\r
\r
        // Fill the new BlockEntry with the TranslationTable\r
        *BlockEntry = ((UINTN)TranslationTable & TT_ADDRESS_MASK_DESCRIPTION_TABLE) | TT_TYPE_TABLE_ENTRY;\r
        // Update the last block entry with the newly created translation table\r
        *LastBlockEntry = TT_LAST_BLOCK_ADDRESS(TranslationTable, TT_ENTRY_COUNT);\r
      } else {\r
        //\r
        // Case when the new region is part of an existing page table\r
        //\r
        *LastBlockEntry = TT_LAST_BLOCK_ADDRESS(TranslationTable, TT_ENTRY_COUNT);\r
      }\r
    }\r
  }\r
\r
  return BlockEntry;\r
}\r
\r
STATIC\r
RETURN_STATUS\r
FillTranslationTable (\r
  IN  UINT64                        *RootTable,\r
  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryRegion\r
  )\r
{\r
  UINT64  Attributes;\r
  UINT32  Type;\r
  UINT64  RegionStart;\r
  UINT64  RemainingRegionLength;\r
  UINT64 *BlockEntry;\r
  UINT64 *LastBlockEntry;\r
  UINT64  BlockEntrySize;\r
  UINTN   TableLevel;\r
\r
  // Ensure the Length is aligned on 4KB boundary\r
  if ((MemoryRegion->Length == 0) || ((MemoryRegion->Length & (SIZE_4KB - 1)) != 0)) {\r
    ASSERT_EFI_ERROR (EFI_INVALID_PARAMETER);\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  // Variable initialization\r
  Attributes = ArmMemoryAttributeToPageAttribute (MemoryRegion->Attributes) | TT_AF;\r
  RemainingRegionLength = MemoryRegion->Length;\r
  RegionStart = MemoryRegion->VirtualBase;\r
\r
  do {\r
    // Get the first Block Entry that matches the Virtual Address and also the information on the Table Descriptor\r
    // such as the the size of the Block Entry and the address of the last BlockEntry of the Table Descriptor\r
    BlockEntrySize = RemainingRegionLength;\r
    BlockEntry = GetBlockEntryListFromAddress (RootTable, RegionStart, &TableLevel, &BlockEntrySize, &LastBlockEntry);\r
    if (BlockEntry == NULL) {\r
      // GetBlockEntryListFromAddress() return NULL when it fails to allocate new pages from the Translation Tables\r
      return RETURN_OUT_OF_RESOURCES;\r
    }\r
\r
    if (TableLevel != 3) {\r
      Type = TT_TYPE_BLOCK_ENTRY;\r
    } else {\r
      Type = TT_TYPE_BLOCK_ENTRY_LEVEL3;\r
    }\r
\r
    do {\r
      // Fill the Block Entry with attribute and output block address\r
      *BlockEntry = (RegionStart & TT_ADDRESS_MASK_BLOCK_ENTRY) | Attributes | Type;\r
\r
      // Go to the next BlockEntry\r
      RegionStart += BlockEntrySize;\r
      RemainingRegionLength -= BlockEntrySize;\r
      BlockEntry++;\r
    } while ((RemainingRegionLength >= BlockEntrySize) && (BlockEntry <= LastBlockEntry));\r
  } while (RemainingRegionLength != 0);\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
RETURN_STATUS\r
SetMemoryAttributes (\r
  IN EFI_PHYSICAL_ADDRESS      BaseAddress,\r
  IN UINT64                    Length,\r
  IN UINT64                    Attributes,\r
  IN EFI_PHYSICAL_ADDRESS      VirtualMask\r
  )\r
{\r
  RETURN_STATUS                Status;\r
  ARM_MEMORY_REGION_DESCRIPTOR MemoryRegion;\r
  UINT64                      *TranslationTable;\r
\r
  MemoryRegion.PhysicalBase = BaseAddress;\r
  MemoryRegion.VirtualBase = BaseAddress;\r
  MemoryRegion.Length = Length;\r
  MemoryRegion.Attributes = GcdAttributeToArmAttribute (Attributes);\r
\r
  TranslationTable = ArmGetTTBR0BaseAddress ();\r
\r
  Status = FillTranslationTable (TranslationTable, &MemoryRegion);\r
  if (RETURN_ERROR (Status)) {\r
    return Status;\r
  }\r
\r
  // Flush d-cache so descriptors make it back to uncached memory for subsequent table walks\r
  // flush and invalidate pages\r
  ArmCleanInvalidateDataCache ();\r
\r
  ArmInvalidateInstructionCache ();\r
\r
  // Invalidate all TLB entries so changes are synced\r
  ArmInvalidateTlb ();\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
RETURN_STATUS\r
EFIAPI\r
ArmConfigureMmu (\r
  IN  ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable,\r
  OUT VOID                         **TranslationTableBase OPTIONAL,\r
  OUT UINTN                         *TranslationTableSize OPTIONAL\r
  )\r
{\r
  VOID*                         TranslationTable;\r
  UINTN                         TranslationTablePageCount;\r
  UINT32                        TranslationTableAttribute;\r
  ARM_MEMORY_REGION_DESCRIPTOR *MemoryTableEntry;\r
  UINT64                        MaxAddress;\r
  UINT64                        TopAddress;\r
  UINTN                         T0SZ;\r
  UINTN                         RootTableEntryCount;\r
  UINT64                        TCR;\r
  RETURN_STATUS                 Status;\r
\r
  if(MemoryTable == NULL) {\r
    ASSERT (MemoryTable != NULL);\r
    return RETURN_INVALID_PARAMETER;\r
  }\r
\r
  // Identify the highest address of the memory table\r
  MaxAddress = MemoryTable->PhysicalBase + MemoryTable->Length - 1;\r
  MemoryTableEntry = MemoryTable;\r
  while (MemoryTableEntry->Length != 0) {\r
    TopAddress = MemoryTableEntry->PhysicalBase + MemoryTableEntry->Length - 1;\r
    if (TopAddress > MaxAddress) {\r
      MaxAddress = TopAddress;\r
    }\r
    MemoryTableEntry++;\r
  }\r
\r
  // Lookup the Table Level to get the information\r
  LookupAddresstoRootTable (MaxAddress, &T0SZ, &RootTableEntryCount);\r
\r
  //\r
  // Set TCR that allows us to retrieve T0SZ in the subsequent functions\r
  //\r
  // Ideally we will be running at EL2, but should support EL1 as well.\r
  // UEFI should not run at EL3.\r
  if (ArmReadCurrentEL () == AARCH64_EL2) {\r
    //Note: Bits 23 and 31 are reserved(RES1) bits in TCR_EL2\r
    TCR = T0SZ | (1UL << 31) | (1UL << 23) | TCR_TG0_4KB;\r
\r
    // Set the Physical Address Size using MaxAddress\r
    if (MaxAddress < SIZE_4GB) {\r
      TCR |= TCR_PS_4GB;\r
    } else if (MaxAddress < SIZE_64GB) {\r
      TCR |= TCR_PS_64GB;\r
    } else if (MaxAddress < SIZE_1TB) {\r
      TCR |= TCR_PS_1TB;\r
    } else if (MaxAddress < SIZE_4TB) {\r
      TCR |= TCR_PS_4TB;\r
    } else if (MaxAddress < SIZE_16TB) {\r
      TCR |= TCR_PS_16TB;\r
    } else if (MaxAddress < SIZE_256TB) {\r
      TCR |= TCR_PS_256TB;\r
    } else {\r
      DEBUG ((EFI_D_ERROR, "ArmConfigureMmu: The MaxAddress 0x%lX is not supported by this MMU configuration.\n", MaxAddress));\r
      ASSERT (0); // Bigger than 48-bit memory space are not supported\r
      return RETURN_UNSUPPORTED;\r
    }\r
  } else if (ArmReadCurrentEL () == AARCH64_EL1) {\r
    TCR = T0SZ | TCR_TG0_4KB;\r
\r
    // Set the Physical Address Size using MaxAddress\r
    if (MaxAddress < SIZE_4GB) {\r
      TCR |= TCR_IPS_4GB;\r
    } else if (MaxAddress < SIZE_64GB) {\r
      TCR |= TCR_IPS_64GB;\r
    } else if (MaxAddress < SIZE_1TB) {\r
      TCR |= TCR_IPS_1TB;\r
    } else if (MaxAddress < SIZE_4TB) {\r
      TCR |= TCR_IPS_4TB;\r
    } else if (MaxAddress < SIZE_16TB) {\r
      TCR |= TCR_IPS_16TB;\r
    } else if (MaxAddress < SIZE_256TB) {\r
      TCR |= TCR_IPS_256TB;\r
    } else {\r
      DEBUG ((EFI_D_ERROR, "ArmConfigureMmu: The MaxAddress 0x%lX is not supported by this MMU configuration.\n", MaxAddress));\r
      ASSERT (0); // Bigger than 48-bit memory space are not supported\r
      return RETURN_UNSUPPORTED;\r
    }\r
  } else {\r
    ASSERT (0); // UEFI is only expected to run at EL2 and EL1, not EL3.\r
    return RETURN_UNSUPPORTED;\r
  }\r
\r
  // Set TCR\r
  ArmSetTCR (TCR);\r
\r
  // Allocate pages for translation table\r
  TranslationTablePageCount = EFI_SIZE_TO_PAGES(RootTableEntryCount * sizeof(UINT64));\r
  TranslationTable = (UINT64*)AllocateAlignedPages (TranslationTablePageCount, TT_ALIGNMENT_DESCRIPTION_TABLE);\r
  if (TranslationTable == NULL) {\r
    return RETURN_OUT_OF_RESOURCES;\r
  }\r
  // We set TTBR0 just after allocating the table to retrieve its location from the subsequent\r
  // functions without needing to pass this value across the functions. The MMU is only enabled\r
  // after the translation tables are populated.\r
  ArmSetTTBR0 (TranslationTable);\r
\r
  if (TranslationTableBase != NULL) {\r
    *TranslationTableBase = TranslationTable;\r
  }\r
\r
  if (TranslationTableSize != NULL) {\r
    *TranslationTableSize = RootTableEntryCount * sizeof(UINT64);\r
  }\r
\r
  ZeroMem (TranslationTable, RootTableEntryCount * sizeof(UINT64));\r
\r
  // Disable MMU and caches. ArmDisableMmu() also invalidates the TLBs\r
  ArmDisableMmu ();\r
  ArmDisableDataCache ();\r
  ArmDisableInstructionCache ();\r
\r
  // Make sure nothing sneaked into the cache\r
  ArmCleanInvalidateDataCache ();\r
  ArmInvalidateInstructionCache ();\r
\r
  TranslationTableAttribute = TT_ATTR_INDX_INVALID;\r
  while (MemoryTable->Length != 0) {\r
    // Find the memory attribute for the Translation Table\r
    if (((UINTN)TranslationTable >= MemoryTable->PhysicalBase) &&\r
        ((UINTN)TranslationTable <= MemoryTable->PhysicalBase - 1 + MemoryTable->Length)) {\r
      TranslationTableAttribute = MemoryTable->Attributes;\r
    }\r
\r
    Status = FillTranslationTable (TranslationTable, MemoryTable);\r
    if (RETURN_ERROR (Status)) {\r
      goto FREE_TRANSLATION_TABLE;\r
    }\r
    MemoryTable++;\r
  }\r
\r
  // Translate the Memory Attributes into Translation Table Register Attributes\r
  if ((TranslationTableAttribute == ARM_MEMORY_REGION_ATTRIBUTE_UNCACHED_UNBUFFERED) ||\r
      (TranslationTableAttribute == ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_UNCACHED_UNBUFFERED)) {\r
    TCR |= TCR_SH_NON_SHAREABLE | TCR_RGN_OUTER_NON_CACHEABLE | TCR_RGN_INNER_NON_CACHEABLE;\r
  } else if ((TranslationTableAttribute == ARM_MEMORY_REGION_ATTRIBUTE_WRITE_BACK) ||\r
      (TranslationTableAttribute == ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_BACK)) {\r
    TCR |= TCR_SH_INNER_SHAREABLE | TCR_RGN_OUTER_WRITE_BACK_ALLOC | TCR_RGN_INNER_WRITE_BACK_ALLOC;\r
  } else if ((TranslationTableAttribute == ARM_MEMORY_REGION_ATTRIBUTE_WRITE_THROUGH) ||\r
      (TranslationTableAttribute == ARM_MEMORY_REGION_ATTRIBUTE_NONSECURE_WRITE_THROUGH)) {\r
    TCR |= TCR_SH_NON_SHAREABLE | TCR_RGN_OUTER_WRITE_THROUGH | TCR_RGN_INNER_WRITE_THROUGH;\r
  } else {\r
    // If we failed to find a mapping that contains the root translation table then it probably means the translation table\r
    // is not mapped in the given memory map.\r
    ASSERT (0);\r
    Status = RETURN_UNSUPPORTED;\r
    goto FREE_TRANSLATION_TABLE;\r
  }\r
\r
  // Set again TCR after getting the Translation Table attributes\r
  ArmSetTCR (TCR);\r
\r
  ArmSetMAIR (MAIR_ATTR(TT_ATTR_INDX_DEVICE_MEMORY, MAIR_ATTR_DEVICE_MEMORY) |                      // mapped to EFI_MEMORY_UC\r
              MAIR_ATTR(TT_ATTR_INDX_MEMORY_NON_CACHEABLE, MAIR_ATTR_NORMAL_MEMORY_NON_CACHEABLE) | // mapped to EFI_MEMORY_WC\r
              MAIR_ATTR(TT_ATTR_INDX_MEMORY_WRITE_THROUGH, MAIR_ATTR_NORMAL_MEMORY_WRITE_THROUGH) | // mapped to EFI_MEMORY_WT\r
              MAIR_ATTR(TT_ATTR_INDX_MEMORY_WRITE_BACK, MAIR_ATTR_NORMAL_MEMORY_WRITE_BACK));       // mapped to EFI_MEMORY_WB\r
\r
  ArmDisableAlignmentCheck ();\r
  ArmEnableInstructionCache ();\r
  ArmEnableDataCache ();\r
\r
  ArmEnableMmu ();\r
  return RETURN_SUCCESS;\r
\r
FREE_TRANSLATION_TABLE:\r
  FreePages (TranslationTable, TranslationTablePageCount);\r
  return Status;\r
}\r