OvmfPkg/PlatformPei/Platform.c

   1 /**@file
   2   Platform PEI driver
   3
   4   Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
   5   Copyright (c) 2011, Andrei Warkentin <andreiw@motorola.com>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 //
  18 // The package level header files this module uses
  19 //
  20 #include <PiPei.h>
  21
  22 //
  23 // The Library classes this module consumes
  24 //
  25 #include <Library/DebugLib.h>
  26 #include <Library/HobLib.h>
  27 #include <Library/IoLib.h>
  28 #include <Library/MemoryAllocationLib.h>
  29 #include <Library/PcdLib.h>
  30 #include <Library/PciLib.h>
  31 #include <Library/PeimEntryPoint.h>
  32 #include <Library/PeiServicesLib.h>
  33 #include <Library/ResourcePublicationLib.h>
  34 #include <Guid/MemoryTypeInformation.h>
  35 #include <Ppi/MasterBootMode.h>
  36
  37 #include "Platform.h"
  38 #include "Cmos.h"
  39
  40 EFI_MEMORY_TYPE_INFORMATION mDefaultMemoryTypeInformation[] = {
  41   { EfiACPIMemoryNVS,       0x004 },
  42   { EfiACPIReclaimMemory,   0x008 },
  43   { EfiReservedMemoryType,  0x004 },
  44   { EfiRuntimeServicesData, 0x024 },
  45   { EfiRuntimeServicesCode, 0x030 },
  46   { EfiBootServicesCode,    0x180 },
  47   { EfiBootServicesData,    0xF00 },
  48   { EfiMaxMemoryType,       0x000 }
  49 };
  50
  51
  52 EFI_PEI_PPI_DESCRIPTOR   mPpiBootMode[] = {
  53   {
  54     EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
  55     &gEfiPeiMasterBootModePpiGuid,
  56     NULL
  57   }
  58 };
  59
  60
  61 VOID
  62 AddIoMemoryBaseSizeHob (
  63   EFI_PHYSICAL_ADDRESS        MemoryBase,
  64   UINT64                      MemorySize
  65   )
  66 {
  67   BuildResourceDescriptorHob (
  68     EFI_RESOURCE_MEMORY_MAPPED_IO,
  69       EFI_RESOURCE_ATTRIBUTE_PRESENT     |
  70       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  71       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
  72       EFI_RESOURCE_ATTRIBUTE_TESTED,
  73     MemoryBase,
  74     MemorySize
  75     );
  76 }
  77
  78 VOID
  79 AddReservedMemoryBaseSizeHob (
  80   EFI_PHYSICAL_ADDRESS        MemoryBase,
  81   UINT64                      MemorySize
  82   )
  83 {
  84   BuildResourceDescriptorHob (
  85     EFI_RESOURCE_MEMORY_RESERVED,
  86       EFI_RESOURCE_ATTRIBUTE_PRESENT     |
  87       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  88       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
  89       EFI_RESOURCE_ATTRIBUTE_TESTED,
  90     MemoryBase,
  91     MemorySize
  92     );
  93 }
  94
  95 VOID
  96 AddIoMemoryRangeHob (
  97   EFI_PHYSICAL_ADDRESS        MemoryBase,
  98   EFI_PHYSICAL_ADDRESS        MemoryLimit
  99   )
 100 {
 101   AddIoMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 102 }
 103
 104
 105 VOID
 106 AddMemoryBaseSizeHob (
 107   EFI_PHYSICAL_ADDRESS        MemoryBase,
 108   UINT64                      MemorySize
 109   )
 110 {
 111   BuildResourceDescriptorHob (
 112     EFI_RESOURCE_SYSTEM_MEMORY,
 113       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 114       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 115       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 116       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 117       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 118       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE |
 119       EFI_RESOURCE_ATTRIBUTE_TESTED,
 120     MemoryBase,
 121     MemorySize
 122     );
 123 }
 124
 125
 126 VOID
 127 AddMemoryRangeHob (
 128   EFI_PHYSICAL_ADDRESS        MemoryBase,
 129   EFI_PHYSICAL_ADDRESS        MemoryLimit
 130   )
 131 {
 132   AddMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 133 }
 134
 135
 136 VOID
 137 AddUntestedMemoryBaseSizeHob (
 138   EFI_PHYSICAL_ADDRESS        MemoryBase,
 139   UINT64                      MemorySize
 140   )
 141 {
 142   BuildResourceDescriptorHob (
 143     EFI_RESOURCE_SYSTEM_MEMORY,
 144       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 145       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 146       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 147       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 148       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 149       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE,
 150     MemoryBase,
 151     MemorySize
 152     );
 153 }
 154
 155
 156 VOID
 157 AddUntestedMemoryRangeHob (
 158   EFI_PHYSICAL_ADDRESS        MemoryBase,
 159   EFI_PHYSICAL_ADDRESS        MemoryLimit
 160   )
 161 {
 162   AddUntestedMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 163 }
 164
 165
 166 VOID
 167 MemMapInitialization (
 168   EFI_PHYSICAL_ADDRESS  TopOfMemory
 169   )
 170 {
 171   //
 172   // Create Memory Type Information HOB
 173   //
 174   BuildGuidDataHob (
 175     &gEfiMemoryTypeInformationGuid,
 176     mDefaultMemoryTypeInformation,
 177     sizeof(mDefaultMemoryTypeInformation)
 178     );
 179
 180   //
 181   // Add PCI IO Port space available for PCI resource allocations.
 182   //
 183   BuildResourceDescriptorHob (
 184     EFI_RESOURCE_IO,
 185     EFI_RESOURCE_ATTRIBUTE_PRESENT     |
 186     EFI_RESOURCE_ATTRIBUTE_INITIALIZED,
 187     0xC000,
 188     0x4000
 189     );
 190
 191   //
 192   // Add PCI MMIO space available to PCI resource allocations
 193   //
 194   if (TopOfMemory < BASE_2GB) {
 195     AddIoMemoryBaseSizeHob (BASE_2GB, 0xFC000000 - BASE_2GB);
 196   } else {
 197     AddIoMemoryBaseSizeHob (TopOfMemory, 0xFC000000 - TopOfMemory);
 198   }
 199
 200   //
 201   // Local APIC range
 202   //
 203   AddIoMemoryBaseSizeHob (0xFEC80000, SIZE_512KB);
 204
 205   //
 206   // I/O APIC range
 207   //
 208   AddIoMemoryBaseSizeHob (0xFEC00000, SIZE_512KB);
 209
 210   //
 211   // Video memory + Legacy BIOS region
 212   //
 213   AddIoMemoryRangeHob (0x0A0000, BASE_1MB);
 214 }
 215
 216
 217 VOID
 218 MiscInitialization (
 219   BOOLEAN Xen
 220   )
 221 {
 222   //
 223   // Disable A20 Mask
 224   //
 225   IoOr8 (0x92, BIT1);
 226
 227   //
 228   // Build the CPU hob with 36-bit addressing and 16-bits of IO space.
 229   //
 230   BuildCpuHob (36, 16);
 231
 232   if (!Xen) {
 233     //
 234     // Set the PM I/O base address to 0x400
 235     //
 236     PciAndThenOr32 (PCI_LIB_ADDRESS (0, 1, 3, 0x40), (UINT32) ~0xfc0, 0x400);
 237   }
 238 }
 239
 240
 241 VOID
 242 BootModeInitialization (
 243   )
 244 {
 245   EFI_STATUS Status;
 246
 247   Status = PeiServicesSetBootMode (BOOT_WITH_FULL_CONFIGURATION);
 248   ASSERT_EFI_ERROR (Status);
 249
 250   Status = PeiServicesInstallPpi (mPpiBootMode);
 251   ASSERT_EFI_ERROR (Status);
 252 }
 253
 254
 255 VOID
 256 ReserveEmuVariableNvStore (
 257   )
 258 {
 259   EFI_PHYSICAL_ADDRESS VariableStore;
 260
 261   //
 262   // Allocate storage for NV variables early on so it will be
 263   // at a consistent address.  Since VM memory is preserved
 264   // across reboots, this allows the NV variable storage to survive
 265   // a VM reboot.
 266   //
 267   VariableStore =
 268     (EFI_PHYSICAL_ADDRESS)(UINTN)
 269       AllocateRuntimePool (
 270         2 * PcdGet32 (PcdFlashNvStorageFtwSpareSize)
 271         );
 272   DEBUG ((EFI_D_INFO,
 273           "Reserved variable store memory: 0x%lX; size: %dkb\n",
 274           VariableStore,
 275           (2 * PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / 1024
 276         ));
 277   PcdSet64 (PcdEmuVariableNvStoreReserved, VariableStore);
 278 }
 279
 280
 281 VOID
 282 DebugDumpCmos (
 283   VOID
 284   )
 285 {
 286   UINTN  Loop;
 287
 288   DEBUG ((EFI_D_INFO, "CMOS:\n"));
 289
 290   for (Loop = 0; Loop < 0x80; Loop++) {
 291     if ((Loop % 0x10) == 0) {
 292       DEBUG ((EFI_D_INFO, "%02x:", Loop));
 293     }
 294     DEBUG ((EFI_D_INFO, " %02x", CmosRead8 (Loop)));
 295     if ((Loop % 0x10) == 0xf) {
 296       DEBUG ((EFI_D_INFO, "\n"));
 297     }
 298   }
 299 }
 300
 301
 302 /**
 303   Perform Platform PEI initialization.
 304
 305   @param  FileHandle      Handle of the file being invoked.
 306   @param  PeiServices     Describes the list of possible PEI Services.
 307
 308   @return EFI_SUCCESS     The PEIM initialized successfully.
 309
 310 **/
 311 EFI_STATUS
 312 EFIAPI
 313 InitializePlatform (
 314   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 315   IN CONST EFI_PEI_SERVICES     **PeiServices
 316   )
 317 {
 318   EFI_STATUS            Status;
 319   EFI_PHYSICAL_ADDRESS  TopOfMemory;
 320   BOOLEAN               Xen;
 321
 322   DEBUG ((EFI_D_ERROR, "Platform PEIM Loaded\n"));
 323
 324   DebugDumpCmos ();
 325
 326   TopOfMemory = MemDetect ();
 327
 328   Status = InitializeXen ();
 329   Xen = EFI_ERROR (Status) ? FALSE : TRUE;
 330
 331   ReserveEmuVariableNvStore ();
 332
 333   PeiFvInitialization ();
 334
 335   MemMapInitialization (TopOfMemory);
 336
 337   MiscInitialization (Xen);
 338
 339   BootModeInitialization ();
 340
 341   return EFI_SUCCESS;
 342 }