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 #include <IndustryStandard/Pci22.h>
  37 #include <Guid/XenInfo.h>
  38 #include <IndustryStandard/E820.h>
  39 #include <Library/ResourcePublicationLib.h>
  40 #include <Library/MtrrLib.h>
  41
  42 #include "Platform.h"
  43 #include "Cmos.h"
  44
  45 EFI_MEMORY_TYPE_INFORMATION mDefaultMemoryTypeInformation[] = {
  46   { EfiACPIMemoryNVS,       0x004 },
  47   { EfiACPIReclaimMemory,   0x008 },
  48   { EfiReservedMemoryType,  0x004 },
  49   { EfiRuntimeServicesData, 0x024 },
  50   { EfiRuntimeServicesCode, 0x030 },
  51   { EfiBootServicesCode,    0x180 },
  52   { EfiBootServicesData,    0xF00 },
  53   { EfiMaxMemoryType,       0x000 }
  54 };
  55
  56
  57 EFI_PEI_PPI_DESCRIPTOR   mPpiBootMode[] = {
  58   {
  59     EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST,
  60     &gEfiPeiMasterBootModePpiGuid,
  61     NULL
  62   }
  63 };
  64
  65
  66 VOID
  67 AddIoMemoryBaseSizeHob (
  68   EFI_PHYSICAL_ADDRESS        MemoryBase,
  69   UINT64                      MemorySize
  70   )
  71 {
  72   BuildResourceDescriptorHob (
  73     EFI_RESOURCE_MEMORY_MAPPED_IO,
  74       EFI_RESOURCE_ATTRIBUTE_PRESENT     |
  75       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  76       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
  77       EFI_RESOURCE_ATTRIBUTE_TESTED,
  78     MemoryBase,
  79     MemorySize
  80     );
  81 }
  82
  83 VOID
  84 AddReservedMemoryBaseSizeHob (
  85   EFI_PHYSICAL_ADDRESS        MemoryBase,
  86   UINT64                      MemorySize
  87   )
  88 {
  89   BuildResourceDescriptorHob (
  90     EFI_RESOURCE_MEMORY_RESERVED,
  91       EFI_RESOURCE_ATTRIBUTE_PRESENT     |
  92       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  93       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
  94       EFI_RESOURCE_ATTRIBUTE_TESTED,
  95     MemoryBase,
  96     MemorySize
  97     );
  98 }
  99
 100 VOID
 101 AddIoMemoryRangeHob (
 102   EFI_PHYSICAL_ADDRESS        MemoryBase,
 103   EFI_PHYSICAL_ADDRESS        MemoryLimit
 104   )
 105 {
 106   AddIoMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 107 }
 108
 109
 110 VOID
 111 AddMemoryBaseSizeHob (
 112   EFI_PHYSICAL_ADDRESS        MemoryBase,
 113   UINT64                      MemorySize
 114   )
 115 {
 116   BuildResourceDescriptorHob (
 117     EFI_RESOURCE_SYSTEM_MEMORY,
 118       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 119       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 120       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 121       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 122       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 123       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE |
 124       EFI_RESOURCE_ATTRIBUTE_TESTED,
 125     MemoryBase,
 126     MemorySize
 127     );
 128 }
 129
 130
 131 VOID
 132 AddMemoryRangeHob (
 133   EFI_PHYSICAL_ADDRESS        MemoryBase,
 134   EFI_PHYSICAL_ADDRESS        MemoryLimit
 135   )
 136 {
 137   AddMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 138 }
 139
 140
 141 VOID
 142 AddUntestedMemoryBaseSizeHob (
 143   EFI_PHYSICAL_ADDRESS        MemoryBase,
 144   UINT64                      MemorySize
 145   )
 146 {
 147   BuildResourceDescriptorHob (
 148     EFI_RESOURCE_SYSTEM_MEMORY,
 149       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 150       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 151       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 152       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 153       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 154       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE,
 155     MemoryBase,
 156     MemorySize
 157     );
 158 }
 159
 160
 161 VOID
 162 AddUntestedMemoryRangeHob (
 163   EFI_PHYSICAL_ADDRESS        MemoryBase,
 164   EFI_PHYSICAL_ADDRESS        MemoryLimit
 165   )
 166 {
 167   AddUntestedMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 168 }
 169
 170 VOID
 171 XenMemMapInitialization (
 172   VOID
 173   )
 174 {
 175   EFI_E820_ENTRY64 *E820Map;
 176   UINT32 E820EntriesCount;
 177   EFI_STATUS Status;
 178
 179   DEBUG ((EFI_D_INFO, "Using memory map provided by Xen\n"));
 180
 181   //
 182   // Create Memory Type Information HOB
 183   //
 184   BuildGuidDataHob (
 185     &gEfiMemoryTypeInformationGuid,
 186     mDefaultMemoryTypeInformation,
 187     sizeof(mDefaultMemoryTypeInformation)
 188     );
 189
 190   //
 191   // Add PCI IO Port space available for PCI resource allocations.
 192   //
 193   BuildResourceDescriptorHob (
 194     EFI_RESOURCE_IO,
 195     EFI_RESOURCE_ATTRIBUTE_PRESENT     |
 196     EFI_RESOURCE_ATTRIBUTE_INITIALIZED,
 197     0xC000,
 198     0x4000
 199     );
 200
 201   //
 202   // Video memory + Legacy BIOS region
 203   //
 204   AddIoMemoryRangeHob (0x0A0000, BASE_1MB);
 205
 206   //
 207   // Parse RAM in E820 map
 208   //
 209   Status = XenGetE820Map(&E820Map, &E820EntriesCount);
 210
 211   ASSERT_EFI_ERROR (Status);
 212
 213   if (E820EntriesCount > 0) {
 214     EFI_E820_ENTRY64 *Entry;
 215     UINT32 Loop;
 216
 217     for (Loop = 0; Loop < E820EntriesCount; Loop++) {
 218       Entry = E820Map + Loop;
 219
 220       //
 221       // Only care about RAM
 222       //
 223       if (Entry->Type != EfiAcpiAddressRangeMemory) {
 224         continue;
 225       }
 226
 227       if (Entry->BaseAddr >= BASE_4GB) {
 228         AddUntestedMemoryBaseSizeHob (Entry->BaseAddr, Entry->Length);
 229       } else {
 230         AddMemoryBaseSizeHob (Entry->BaseAddr, Entry->Length);
 231       }
 232
 233       MtrrSetMemoryAttribute (Entry->BaseAddr, Entry->Length, CacheWriteBack);
 234     }
 235   }
 236 }
 237
 238
 239 VOID
 240 MemMapInitialization (
 241   EFI_PHYSICAL_ADDRESS  TopOfMemory
 242   )
 243 {
 244   //
 245   // Create Memory Type Information HOB
 246   //
 247   BuildGuidDataHob (
 248     &gEfiMemoryTypeInformationGuid,
 249     mDefaultMemoryTypeInformation,
 250     sizeof(mDefaultMemoryTypeInformation)
 251     );
 252
 253   //
 254   // Add PCI IO Port space available for PCI resource allocations.
 255   //
 256   BuildResourceDescriptorHob (
 257     EFI_RESOURCE_IO,
 258     EFI_RESOURCE_ATTRIBUTE_PRESENT     |
 259     EFI_RESOURCE_ATTRIBUTE_INITIALIZED,
 260     0xC000,
 261     0x4000
 262     );
 263
 264   //
 265   // Video memory + Legacy BIOS region
 266   //
 267   AddIoMemoryRangeHob (0x0A0000, BASE_1MB);
 268
 269   //
 270   // address       purpose   size
 271   // ------------  --------  -------------------------
 272   // max(top, 2g)  PCI MMIO  0xFC000000 - max(top, 2g)
 273   // 0xFC000000    gap                           44 MB
 274   // 0xFEC00000    IO-APIC                        4 KB
 275   // 0xFEC01000    gap                         1020 KB
 276   // 0xFED00000    HPET                           1 KB
 277   // 0xFED00400    gap                         1023 KB
 278   // 0xFEE00000    LAPIC                          1 MB
 279   //
 280   AddIoMemoryRangeHob (TopOfMemory < BASE_2GB ? BASE_2GB : TopOfMemory, 0xFC000000);
 281   AddIoMemoryBaseSizeHob (0xFEC00000, SIZE_4KB);
 282   AddIoMemoryBaseSizeHob (0xFED00000, SIZE_1KB);
 283   AddIoMemoryBaseSizeHob (PcdGet32(PcdCpuLocalApicBaseAddress), SIZE_1MB);
 284 }
 285
 286
 287 VOID
 288 MiscInitialization (
 289   VOID
 290   )
 291 {
 292   //
 293   // Disable A20 Mask
 294   //
 295   IoOr8 (0x92, BIT1);
 296
 297   //
 298   // Build the CPU hob with 36-bit addressing and 16-bits of IO space.
 299   //
 300   BuildCpuHob (36, 16);
 301
 302   //
 303   // If PMREGMISC/PMIOSE is set, assume the ACPI PMBA has been configured (for
 304   // example by Xen) and skip the setup here. This matches the logic in
 305   // AcpiTimerLibConstructor ().
 306   //
 307   if ((PciRead8 (PCI_LIB_ADDRESS (0, 1, 3, 0x80)) & 0x01) == 0) {
 308     //
 309     // The PEI phase should be exited with fully accessibe PIIX4 IO space:
 310     // 1. set PMBA
 311     //
 312     PciAndThenOr32 (
 313       PCI_LIB_ADDRESS (0, 1, 3, 0x40),
 314       (UINT32) ~0xFFC0,
 315       PcdGet16 (PcdAcpiPmBaseAddress)
 316       );
 317
 318     //
 319     // 2. set PCICMD/IOSE
 320     //
 321     PciOr8 (
 322       PCI_LIB_ADDRESS (0, 1, 3, PCI_COMMAND_OFFSET),
 323       EFI_PCI_COMMAND_IO_SPACE
 324       );
 325
 326     //
 327     // 3. set PMREGMISC/PMIOSE
 328     //
 329     PciOr8 (PCI_LIB_ADDRESS (0, 1, 3, 0x80), 0x01);
 330   }
 331 }
 332
 333
 334 VOID
 335 BootModeInitialization (
 336   )
 337 {
 338   EFI_STATUS Status;
 339
 340   Status = PeiServicesSetBootMode (BOOT_WITH_FULL_CONFIGURATION);
 341   ASSERT_EFI_ERROR (Status);
 342
 343   Status = PeiServicesInstallPpi (mPpiBootMode);
 344   ASSERT_EFI_ERROR (Status);
 345 }
 346
 347
 348 VOID
 349 ReserveEmuVariableNvStore (
 350   )
 351 {
 352   EFI_PHYSICAL_ADDRESS VariableStore;
 353
 354   //
 355   // Allocate storage for NV variables early on so it will be
 356   // at a consistent address.  Since VM memory is preserved
 357   // across reboots, this allows the NV variable storage to survive
 358   // a VM reboot.
 359   //
 360   VariableStore =
 361     (EFI_PHYSICAL_ADDRESS)(UINTN)
 362       AllocateAlignedRuntimePages (
 363         EFI_SIZE_TO_PAGES (2 * PcdGet32 (PcdFlashNvStorageFtwSpareSize)),
 364         PcdGet32 (PcdFlashNvStorageFtwSpareSize)
 365         );
 366   DEBUG ((EFI_D_INFO,
 367           "Reserved variable store memory: 0x%lX; size: %dkb\n",
 368           VariableStore,
 369           (2 * PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / 1024
 370         ));
 371   PcdSet64 (PcdEmuVariableNvStoreReserved, VariableStore);
 372 }
 373
 374
 375 VOID
 376 DebugDumpCmos (
 377   VOID
 378   )
 379 {
 380   UINTN  Loop;
 381
 382   DEBUG ((EFI_D_INFO, "CMOS:\n"));
 383
 384   for (Loop = 0; Loop < 0x80; Loop++) {
 385     if ((Loop % 0x10) == 0) {
 386       DEBUG ((EFI_D_INFO, "%02x:", Loop));
 387     }
 388     DEBUG ((EFI_D_INFO, " %02x", CmosRead8 (Loop)));
 389     if ((Loop % 0x10) == 0xf) {
 390       DEBUG ((EFI_D_INFO, "\n"));
 391     }
 392   }
 393 }
 394
 395
 396 /**
 397   Perform Platform PEI initialization.
 398
 399   @param  FileHandle      Handle of the file being invoked.
 400   @param  PeiServices     Describes the list of possible PEI Services.
 401
 402   @return EFI_SUCCESS     The PEIM initialized successfully.
 403
 404 **/
 405 EFI_STATUS
 406 EFIAPI
 407 InitializePlatform (
 408   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 409   IN CONST EFI_PEI_SERVICES     **PeiServices
 410   )
 411 {
 412   EFI_PHYSICAL_ADDRESS  TopOfMemory;
 413   UINT32 XenLeaf;
 414
 415   TopOfMemory = 0;
 416
 417   DEBUG ((EFI_D_ERROR, "Platform PEIM Loaded\n"));
 418
 419   DebugDumpCmos ();
 420
 421   XenLeaf = XenDetect ();
 422
 423   if (XenLeaf != 0) {
 424     PublishPeiMemory ();
 425     PcdSetBool (PcdPciDisableBusEnumeration, TRUE);
 426   } else {
 427     TopOfMemory = MemDetect ();
 428   }
 429
 430   if (XenLeaf != 0) {
 431     DEBUG ((EFI_D_INFO, "Xen was detected\n"));
 432     InitializeXen (XenLeaf);
 433   }
 434
 435   ReserveEmuVariableNvStore ();
 436
 437   PeiFvInitialization ();
 438
 439   if (XenLeaf != 0) {
 440     XenMemMapInitialization ();
 441   } else {
 442     MemMapInitialization (TopOfMemory);
 443   }
 444
 445   MiscInitialization ();
 446
 447   BootModeInitialization ();
 448
 449   return EFI_SUCCESS;
 450 }