OvmfPkg/PlatformPei/Platform.c

   1 /**@file
   2   Platform PEI driver
   3
   4   Copyright (c) 2006 - 2014, 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/QemuFwCfgLib.h>
  34 #include <Library/ResourcePublicationLib.h>
  35 #include <Library/BaseMemoryLib.h>
  36 #include <Guid/MemoryTypeInformation.h>
  37 #include <Ppi/MasterBootMode.h>
  38 #include <IndustryStandard/Pci22.h>
  39 #include <IndustryStandard/SmBios.h>
  40 #include <OvmfPlatforms.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 UINT16 mHostBridgeDevId;
  67
  68 EFI_BOOT_MODE mBootMode = BOOT_WITH_FULL_CONFIGURATION;
  69
  70 BOOLEAN mS3Supported = FALSE;
  71
  72
  73 VOID
  74 AddIoMemoryBaseSizeHob (
  75   EFI_PHYSICAL_ADDRESS        MemoryBase,
  76   UINT64                      MemorySize
  77   )
  78 {
  79   BuildResourceDescriptorHob (
  80     EFI_RESOURCE_MEMORY_MAPPED_IO,
  81       EFI_RESOURCE_ATTRIBUTE_PRESENT     |
  82       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
  83       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
  84       EFI_RESOURCE_ATTRIBUTE_TESTED,
  85     MemoryBase,
  86     MemorySize
  87     );
  88 }
  89
  90 VOID
  91 AddReservedMemoryBaseSizeHob (
  92   EFI_PHYSICAL_ADDRESS        MemoryBase,
  93   UINT64                      MemorySize
  94   )
  95 {
  96   BuildResourceDescriptorHob (
  97     EFI_RESOURCE_MEMORY_RESERVED,
  98       EFI_RESOURCE_ATTRIBUTE_PRESENT     |
  99       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 100       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 101       EFI_RESOURCE_ATTRIBUTE_TESTED,
 102     MemoryBase,
 103     MemorySize
 104     );
 105 }
 106
 107 VOID
 108 AddIoMemoryRangeHob (
 109   EFI_PHYSICAL_ADDRESS        MemoryBase,
 110   EFI_PHYSICAL_ADDRESS        MemoryLimit
 111   )
 112 {
 113   AddIoMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 114 }
 115
 116
 117 VOID
 118 AddMemoryBaseSizeHob (
 119   EFI_PHYSICAL_ADDRESS        MemoryBase,
 120   UINT64                      MemorySize
 121   )
 122 {
 123   BuildResourceDescriptorHob (
 124     EFI_RESOURCE_SYSTEM_MEMORY,
 125       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 126       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 127       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 128       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 129       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 130       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE |
 131       EFI_RESOURCE_ATTRIBUTE_TESTED,
 132     MemoryBase,
 133     MemorySize
 134     );
 135 }
 136
 137
 138 VOID
 139 AddMemoryRangeHob (
 140   EFI_PHYSICAL_ADDRESS        MemoryBase,
 141   EFI_PHYSICAL_ADDRESS        MemoryLimit
 142   )
 143 {
 144   AddMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 145 }
 146
 147
 148 VOID
 149 AddUntestedMemoryBaseSizeHob (
 150   EFI_PHYSICAL_ADDRESS        MemoryBase,
 151   UINT64                      MemorySize
 152   )
 153 {
 154   BuildResourceDescriptorHob (
 155     EFI_RESOURCE_SYSTEM_MEMORY,
 156       EFI_RESOURCE_ATTRIBUTE_PRESENT |
 157       EFI_RESOURCE_ATTRIBUTE_INITIALIZED |
 158       EFI_RESOURCE_ATTRIBUTE_UNCACHEABLE |
 159       EFI_RESOURCE_ATTRIBUTE_WRITE_COMBINEABLE |
 160       EFI_RESOURCE_ATTRIBUTE_WRITE_THROUGH_CACHEABLE |
 161       EFI_RESOURCE_ATTRIBUTE_WRITE_BACK_CACHEABLE,
 162     MemoryBase,
 163     MemorySize
 164     );
 165 }
 166
 167
 168 VOID
 169 AddUntestedMemoryRangeHob (
 170   EFI_PHYSICAL_ADDRESS        MemoryBase,
 171   EFI_PHYSICAL_ADDRESS        MemoryLimit
 172   )
 173 {
 174   AddUntestedMemoryBaseSizeHob (MemoryBase, (UINT64)(MemoryLimit - MemoryBase));
 175 }
 176
 177 VOID
 178 MemMapInitialization (
 179   VOID
 180   )
 181 {
 182   //
 183   // Create Memory Type Information HOB
 184   //
 185   BuildGuidDataHob (
 186     &gEfiMemoryTypeInformationGuid,
 187     mDefaultMemoryTypeInformation,
 188     sizeof(mDefaultMemoryTypeInformation)
 189     );
 190
 191   //
 192   // Add PCI IO Port space available for PCI resource allocations.
 193   //
 194   BuildResourceDescriptorHob (
 195     EFI_RESOURCE_IO,
 196     EFI_RESOURCE_ATTRIBUTE_PRESENT     |
 197     EFI_RESOURCE_ATTRIBUTE_INITIALIZED,
 198     0xC000,
 199     0x4000
 200     );
 201
 202   //
 203   // Video memory + Legacy BIOS region
 204   //
 205   AddIoMemoryRangeHob (0x0A0000, BASE_1MB);
 206
 207   if (!mXen) {
 208     UINT32  TopOfLowRam;
 209     TopOfLowRam = GetSystemMemorySizeBelow4gb ();
 210
 211     //
 212     // address       purpose   size
 213     // ------------  --------  -------------------------
 214     // max(top, 2g)  PCI MMIO  0xFC000000 - max(top, 2g)
 215     // 0xFC000000    gap                           44 MB
 216     // 0xFEC00000    IO-APIC                        4 KB
 217     // 0xFEC01000    gap                         1020 KB
 218     // 0xFED00000    HPET                           1 KB
 219     // 0xFED00400    gap                          111 KB
 220     // 0xFED1C000    gap (PIIX4) / RCRB (ICH9)     16 KB
 221     // 0xFED20000    gap                          896 KB
 222     // 0xFEE00000    LAPIC                          1 MB
 223     //
 224     AddIoMemoryRangeHob (TopOfLowRam < BASE_2GB ?
 225                          BASE_2GB : TopOfLowRam, 0xFC000000);
 226     AddIoMemoryBaseSizeHob (0xFEC00000, SIZE_4KB);
 227     AddIoMemoryBaseSizeHob (0xFED00000, SIZE_1KB);
 228     if (mHostBridgeDevId == INTEL_Q35_MCH_DEVICE_ID) {
 229       AddIoMemoryBaseSizeHob (ICH9_ROOT_COMPLEX_BASE, SIZE_16KB);
 230     }
 231     AddIoMemoryBaseSizeHob (PcdGet32(PcdCpuLocalApicBaseAddress), SIZE_1MB);
 232   }
 233 }
 234
 235
 236 VOID
 237 MiscInitialization (
 238   VOID
 239   )
 240 {
 241   UINTN  PmCmd;
 242   UINTN  Pmba;
 243   UINTN  AcpiCtlReg;
 244   UINT8  AcpiEnBit;
 245
 246   //
 247   // Disable A20 Mask
 248   //
 249   IoOr8 (0x92, BIT1);
 250
 251   //
 252   // Build the CPU hob with 36-bit addressing and 16-bits of IO space.
 253   //
 254   BuildCpuHob (36, 16);
 255
 256   //
 257   // Determine platform type and save Host Bridge DID to PCD
 258   //
 259   switch (mHostBridgeDevId) {
 260     case INTEL_82441_DEVICE_ID:
 261       PmCmd      = POWER_MGMT_REGISTER_PIIX4 (PCI_COMMAND_OFFSET);
 262       Pmba       = POWER_MGMT_REGISTER_PIIX4 (PIIX4_PMBA);
 263       AcpiCtlReg = POWER_MGMT_REGISTER_PIIX4 (PIIX4_PMREGMISC);
 264       AcpiEnBit  = PIIX4_PMREGMISC_PMIOSE;
 265       break;
 266     case INTEL_Q35_MCH_DEVICE_ID:
 267       PmCmd      = POWER_MGMT_REGISTER_Q35 (PCI_COMMAND_OFFSET);
 268       Pmba       = POWER_MGMT_REGISTER_Q35 (ICH9_PMBASE);
 269       AcpiCtlReg = POWER_MGMT_REGISTER_Q35 (ICH9_ACPI_CNTL);
 270       AcpiEnBit  = ICH9_ACPI_CNTL_ACPI_EN;
 271       break;
 272     default:
 273       DEBUG ((EFI_D_ERROR, "%a: Unknown Host Bridge Device ID: 0x%04x\n",
 274         __FUNCTION__, mHostBridgeDevId));
 275       ASSERT (FALSE);
 276       return;
 277   }
 278   PcdSet16 (PcdOvmfHostBridgePciDevId, mHostBridgeDevId);
 279
 280   //
 281   // If the appropriate IOspace enable bit is set, assume the ACPI PMBA
 282   // has been configured (e.g., by Xen) and skip the setup here.
 283   // This matches the logic in AcpiTimerLibConstructor ().
 284   //
 285   if ((PciRead8 (AcpiCtlReg) & AcpiEnBit) == 0) {
 286     //
 287     // The PEI phase should be exited with fully accessibe ACPI PM IO space:
 288     // 1. set PMBA
 289     //
 290     PciAndThenOr32 (Pmba, (UINT32) ~0xFFC0, PcdGet16 (PcdAcpiPmBaseAddress));
 291
 292     //
 293     // 2. set PCICMD/IOSE
 294     //
 295     PciOr8 (PmCmd, EFI_PCI_COMMAND_IO_SPACE);
 296
 297     //
 298     // 3. set ACPI PM IO enable bit (PMREGMISC:PMIOSE or ACPI_CNTL:ACPI_EN)
 299     //
 300     PciOr8 (AcpiCtlReg, AcpiEnBit);
 301   }
 302
 303   if (mHostBridgeDevId == INTEL_Q35_MCH_DEVICE_ID) {
 304     //
 305     // Set Root Complex Register Block BAR
 306     //
 307     PciWrite32 (
 308       POWER_MGMT_REGISTER_Q35 (ICH9_RCBA),
 309       ICH9_ROOT_COMPLEX_BASE | ICH9_RCBA_EN
 310       );
 311   }
 312 }
 313
 314
 315 VOID
 316 BootModeInitialization (
 317   VOID
 318   )
 319 {
 320   EFI_STATUS    Status;
 321
 322   if (CmosRead8 (0xF) == 0xFE) {
 323     mBootMode = BOOT_ON_S3_RESUME;
 324   }
 325
 326   Status = PeiServicesSetBootMode (mBootMode);
 327   ASSERT_EFI_ERROR (Status);
 328
 329   Status = PeiServicesInstallPpi (mPpiBootMode);
 330   ASSERT_EFI_ERROR (Status);
 331 }
 332
 333
 334 VOID
 335 ReserveEmuVariableNvStore (
 336   )
 337 {
 338   EFI_PHYSICAL_ADDRESS VariableStore;
 339
 340   //
 341   // Allocate storage for NV variables early on so it will be
 342   // at a consistent address.  Since VM memory is preserved
 343   // across reboots, this allows the NV variable storage to survive
 344   // a VM reboot.
 345   //
 346   VariableStore =
 347     (EFI_PHYSICAL_ADDRESS)(UINTN)
 348       AllocateAlignedRuntimePages (
 349         EFI_SIZE_TO_PAGES (2 * PcdGet32 (PcdFlashNvStorageFtwSpareSize)),
 350         PcdGet32 (PcdFlashNvStorageFtwSpareSize)
 351         );
 352   DEBUG ((EFI_D_INFO,
 353           "Reserved variable store memory: 0x%lX; size: %dkb\n",
 354           VariableStore,
 355           (2 * PcdGet32 (PcdFlashNvStorageFtwSpareSize)) / 1024
 356         ));
 357   PcdSet64 (PcdEmuVariableNvStoreReserved, VariableStore);
 358 }
 359
 360
 361 VOID
 362 DebugDumpCmos (
 363   VOID
 364   )
 365 {
 366   UINTN  Loop;
 367
 368   DEBUG ((EFI_D_INFO, "CMOS:\n"));
 369
 370   for (Loop = 0; Loop < 0x80; Loop++) {
 371     if ((Loop % 0x10) == 0) {
 372       DEBUG ((EFI_D_INFO, "%02x:", Loop));
 373     }
 374     DEBUG ((EFI_D_INFO, " %02x", CmosRead8 (Loop)));
 375     if ((Loop % 0x10) == 0xf) {
 376       DEBUG ((EFI_D_INFO, "\n"));
 377     }
 378   }
 379 }
 380
 381
 382 /**
 383   Set the SMBIOS entry point version for the generic SmbiosDxe driver.
 384 **/
 385 STATIC
 386 VOID
 387 SmbiosVersionInitialization (
 388   VOID
 389   )
 390 {
 391   FIRMWARE_CONFIG_ITEM     Anchor;
 392   UINTN                    AnchorSize;
 393   SMBIOS_TABLE_ENTRY_POINT QemuAnchor;
 394   UINT16                   SmbiosVersion;
 395
 396   if (RETURN_ERROR (QemuFwCfgFindFile ("etc/smbios/smbios-anchor", &Anchor,
 397                       &AnchorSize)) ||
 398       AnchorSize != sizeof QemuAnchor) {
 399     return;
 400   }
 401
 402   QemuFwCfgSelectItem (Anchor);
 403   QemuFwCfgReadBytes (AnchorSize, &QemuAnchor);
 404   if (CompareMem (QemuAnchor.AnchorString, "_SM_", 4) != 0 ||
 405       CompareMem (QemuAnchor.IntermediateAnchorString, "_DMI_", 5) != 0) {
 406     return;
 407   }
 408
 409   SmbiosVersion = (UINT16)(QemuAnchor.MajorVersion << 8 |
 410                            QemuAnchor.MinorVersion);
 411   DEBUG ((EFI_D_INFO, "%a: SMBIOS version from QEMU: 0x%04x\n", __FUNCTION__,
 412     SmbiosVersion));
 413   PcdSet16 (PcdSmbiosVersion, SmbiosVersion);
 414 }
 415
 416
 417 /**
 418   Perform Platform PEI initialization.
 419
 420   @param  FileHandle      Handle of the file being invoked.
 421   @param  PeiServices     Describes the list of possible PEI Services.
 422
 423   @return EFI_SUCCESS     The PEIM initialized successfully.
 424
 425 **/
 426 EFI_STATUS
 427 EFIAPI
 428 InitializePlatform (
 429   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 430   IN CONST EFI_PEI_SERVICES     **PeiServices
 431   )
 432 {
 433   DEBUG ((EFI_D_ERROR, "Platform PEIM Loaded\n"));
 434
 435   DebugDumpCmos ();
 436
 437   XenDetect ();
 438
 439   if (QemuFwCfgS3Enabled ()) {
 440     DEBUG ((EFI_D_INFO, "S3 support was detected on QEMU\n"));
 441     mS3Supported = TRUE;
 442   }
 443
 444   BootModeInitialization ();
 445   AddressWidthInitialization ();
 446
 447   PublishPeiMemory ();
 448
 449   InitializeRamRegions ();
 450
 451   if (mXen) {
 452     DEBUG ((EFI_D_INFO, "Xen was detected\n"));
 453     InitializeXen ();
 454   }
 455
 456   //
 457   // Query Host Bridge DID
 458   //
 459   mHostBridgeDevId = PciRead16 (OVMF_HOSTBRIDGE_DID);
 460
 461   if (mBootMode != BOOT_ON_S3_RESUME) {
 462     ReserveEmuVariableNvStore ();
 463
 464     PeiFvInitialization ();
 465
 466     MemMapInitialization ();
 467
 468     SmbiosVersionInitialization ();
 469   }
 470
 471   MiscInitialization ();
 472
 473   return EFI_SUCCESS;
 474 }