ArmPlatformPkg/MemoryInitPei/MemoryInitPeiLib.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2011-2015, ARM Limited. All rights reserved.
   4 *
   5 *  This program and the accompanying materials
   6 *  are licensed and made available under the terms and conditions of the BSD License
   7 *  which accompanies this distribution.  The full text of the license may be found at
   8 *  http://opensource.org/licenses/bsd-license.php
   9 *
  10 *  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 *  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 *
  13 **/
  14
  15 #include <PiPei.h>
  16
  17 #include <Library/ArmMmuLib.h>
  18 #include <Library/ArmPlatformLib.h>
  19 #include <Library/DebugLib.h>
  20 #include <Library/HobLib.h>
  21 #include <Library/MemoryAllocationLib.h>
  22 #include <Library/PcdLib.h>
  23
  24 VOID
  25 BuildMemoryTypeInformationHob (
  26   VOID
  27   );
  28
  29 STATIC
  30 VOID
  31 InitMmu (
  32   IN ARM_MEMORY_REGION_DESCRIPTOR  *MemoryTable
  33   )
  34 {
  35
  36   VOID                          *TranslationTableBase;
  37   UINTN                         TranslationTableSize;
  38   RETURN_STATUS                 Status;
  39
  40   //Note: Because we called PeiServicesInstallPeiMemory() before to call InitMmu() the MMU Page Table resides in
  41   //      DRAM (even at the top of DRAM as it is the first permanent memory allocation)
  42   Status = ArmConfigureMmu (MemoryTable, &TranslationTableBase, &TranslationTableSize);
  43   if (EFI_ERROR (Status)) {
  44     DEBUG ((EFI_D_ERROR, "Error: Failed to enable MMU\n"));
  45   }
  46 }
  47
  48 /*++
  49
  50 Routine Description:
  51
  52
  53
  54 Arguments:
  55
  56   FileHandle  - Handle of the file being invoked.
  57   PeiServices - Describes the list of possible PEI Services.
  58
  59 Returns:
  60
  61   Status -  EFI_SUCCESS if the boot mode could be set
  62
  63 --*/
  64 EFI_STATUS
  65 EFIAPI
  66 MemoryPeim (
  67   IN EFI_PHYSICAL_ADDRESS               UefiMemoryBase,
  68   IN UINT64                             UefiMemorySize
  69   )
  70 {
  71   ARM_MEMORY_REGION_DESCRIPTOR *MemoryTable;
  72   EFI_RESOURCE_ATTRIBUTE_TYPE  ResourceAttributes;
  73   UINT64                       ResourceLength;
  74   EFI_PEI_HOB_POINTERS         NextHob;
  75   EFI_PHYSICAL_ADDRESS         FdTop;
  76   EFI_PHYSICAL_ADDRESS         SystemMemoryTop;
  77   EFI_PHYSICAL_ADDRESS         ResourceTop;
  78   BOOLEAN                      Found;
  79
  80   // Get Virtual Memory Map from the Platform Library
  81   ArmPlatformGetVirtualMemoryMap (&MemoryTable);
  82
  83   // Ensure PcdSystemMemorySize has been set
  84   ASSERT (PcdGet64 (PcdSystemMemorySize) != 0);
  85
  86   //
  87   // Now, the permanent memory has been installed, we can call AllocatePages()
  88   //
  89   ResourceAttributes = (
  90       EFI_RESOURCE_ATTRIBUTE_PRESENT |
  91       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  92       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
  93       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
  94       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE |
  95       EFI_RESOURCE_ATTRIBUTE_TESTED
  96   );
  97
  98   //
  99   // Check if the resource for the main system memory has been declared
 100   //
 101   Found = FALSE;
 102   NextHob.Raw = GetHobList ();
 103   while ((NextHob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, NextHob.Raw)) != NULL) {
 104     if ((NextHob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) &&
 105         (PcdGet64 (PcdSystemMemoryBase) >= NextHob.ResourceDescriptor->PhysicalStart) &&
 106         (NextHob.ResourceDescriptor->PhysicalStart + NextHob.ResourceDescriptor->ResourceLength <= PcdGet64 (PcdSystemMemoryBase) + PcdGet64 (PcdSystemMemorySize)))
 107     {
 108       Found = TRUE;
 109       break;
 110     }
 111     NextHob.Raw = GET_NEXT_HOB (NextHob);
 112   }
 113
 114   if (!Found) {
 115     // Reserved the memory space occupied by the firmware volume
 116     BuildResourceDescriptorHob (
 117         EFI_RESOURCE_SYSTEM_MEMORY,
 118         ResourceAttributes,
 119         PcdGet64 (PcdSystemMemoryBase),
 120         PcdGet64 (PcdSystemMemorySize)
 121     );
 122   }
 123
 124   //
 125   // Reserved the memory space occupied by the firmware volume
 126   //
 127
 128   SystemMemoryTop = (EFI_PHYSICAL_ADDRESS)PcdGet64 (PcdSystemMemoryBase) + (EFI_PHYSICAL_ADDRESS)PcdGet64 (PcdSystemMemorySize);
 129   FdTop = (EFI_PHYSICAL_ADDRESS)PcdGet64 (PcdFdBaseAddress) + (EFI_PHYSICAL_ADDRESS)PcdGet32 (PcdFdSize);
 130
 131   // EDK2 does not have the concept of boot firmware copied into DRAM. To avoid the DXE
 132   // core to overwrite this area we must create a memory allocation HOB for the region,
 133   // but this only works if we split off the underlying resource descriptor as well.
 134   if ((PcdGet64 (PcdFdBaseAddress) >= PcdGet64 (PcdSystemMemoryBase)) && (FdTop <= SystemMemoryTop)) {
 135     Found = FALSE;
 136
 137     // Search for System Memory Hob that contains the firmware
 138     NextHob.Raw = GetHobList ();
 139     while ((NextHob.Raw = GetNextHob (EFI_HOB_TYPE_RESOURCE_DESCRIPTOR, NextHob.Raw)) != NULL) {
 140       if ((NextHob.ResourceDescriptor->ResourceType == EFI_RESOURCE_SYSTEM_MEMORY) &&
 141           (PcdGet64 (PcdFdBaseAddress) >= NextHob.ResourceDescriptor->PhysicalStart) &&
 142           (FdTop <= NextHob.ResourceDescriptor->PhysicalStart + NextHob.ResourceDescriptor->ResourceLength))
 143       {
 144         ResourceAttributes = NextHob.ResourceDescriptor->ResourceAttribute;
 145         ResourceLength = NextHob.ResourceDescriptor->ResourceLength;
 146         ResourceTop = NextHob.ResourceDescriptor->PhysicalStart + ResourceLength;
 147
 148         if (PcdGet64 (PcdFdBaseAddress) == NextHob.ResourceDescriptor->PhysicalStart) {
 149           if (SystemMemoryTop != FdTop) {
 150             // Create the System Memory HOB for the firmware
 151             BuildResourceDescriptorHob (EFI_RESOURCE_SYSTEM_MEMORY,
 152                                         ResourceAttributes,
 153                                         PcdGet64 (PcdFdBaseAddress),
 154                                         PcdGet32 (PcdFdSize));
 155
 156             // Top of the FD is system memory available for UEFI
 157             NextHob.ResourceDescriptor->PhysicalStart += PcdGet32(PcdFdSize);
 158             NextHob.ResourceDescriptor->ResourceLength -= PcdGet32(PcdFdSize);
 159           }
 160         } else {
 161           // Create the System Memory HOB for the firmware
 162           BuildResourceDescriptorHob (EFI_RESOURCE_SYSTEM_MEMORY,
 163                                       ResourceAttributes,
 164                                       PcdGet64 (PcdFdBaseAddress),
 165                                       PcdGet32 (PcdFdSize));
 166
 167           // Update the HOB
 168           NextHob.ResourceDescriptor->ResourceLength = PcdGet64 (PcdFdBaseAddress) - NextHob.ResourceDescriptor->PhysicalStart;
 169
 170           // If there is some memory available on the top of the FD then create a HOB
 171           if (FdTop < NextHob.ResourceDescriptor->PhysicalStart + ResourceLength) {
 172             // Create the System Memory HOB for the remaining region (top of the FD)
 173             BuildResourceDescriptorHob (EFI_RESOURCE_SYSTEM_MEMORY,
 174                                         ResourceAttributes,
 175                                         FdTop,
 176                                         ResourceTop - FdTop);
 177           }
 178         }
 179
 180         // Mark the memory covering the Firmware Device as boot services data
 181         BuildMemoryAllocationHob (PcdGet64 (PcdFdBaseAddress),
 182                                   PcdGet32 (PcdFdSize),
 183                                   EfiBootServicesData);
 184
 185         Found = TRUE;
 186         break;
 187       }
 188       NextHob.Raw = GET_NEXT_HOB (NextHob);
 189     }
 190
 191     ASSERT(Found);
 192   }
 193
 194   // Build Memory Allocation Hob
 195   InitMmu (MemoryTable);
 196
 197   if (FeaturePcdGet (PcdPrePiProduceMemoryTypeInformationHob)) {
 198     // Optional feature that helps prevent EFI memory map fragmentation.
 199     BuildMemoryTypeInformationHob ();
 200   }
 201
 202   return EFI_SUCCESS;
 203 }