[WIP] Spi support

MdeModulePkg/Universal/Variable/RuntimeDxe/VariableNonVolatile.c

@@ -127,6 +127,7 @@ InitEmuNonVolatileVariableStore (
   @retval EFI_VOLUME_CORRUPTED  Variable Store or Firmware Volume for Variable Store is corrupted.
 
 **/
+
 EFI_STATUS
 InitRealNonVolatileVariableStore (
   OUT EFI_PHYSICAL_ADDRESS              *VariableStoreBase

MdeModulePkg/Universal/Variable/RuntimeDxe/VariableRuntimeDxe.inf

@@ -52,6 +52,7 @@
 [Packages]
   MdePkg/MdePkg.dec
   MdeModulePkg/MdeModulePkg.dec
+  UefiPayloadPkg/UefiPayloadPkg.dec
 
 [LibraryClasses]
   MemoryAllocationLib

PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtc.c

@@ -112,6 +112,7 @@ PcRtcInit (
   BOOLEAN         Enabled;
   BOOLEAN         Pending;
 
+  DEBUG((DEBUG_INFO, "%a\n", __FUNCTION__));
   //
   // Acquire RTC Lock to make access to RTC atomic
   //
@@ -148,6 +149,7 @@ PcRtcInit (
   //
   Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
   if (EFI_ERROR (Status)) {
+    DEBUG((DEBUG_INFO, "%a: RTC not functional\n", __FUNCTION__));
     //
     // Set the variable with default value if the RTC is functioning incorrectly.
     //
@@ -233,6 +235,7 @@ PcRtcInit (
   //
   Status = PcRtcSetTime (&Time, Global);
   if (EFI_ERROR (Status)) {
+    DEBUG((DEBUG_INFO, "%a: failed to set RTC time\n", __FUNCTION__));
     return EFI_DEVICE_ERROR;
   }
 
@@ -272,8 +275,9 @@ PcRtcInit (
   Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
   if (EFI_ERROR (Status)) {
     if (!EfiAtRuntime ()) {
-    EfiReleaseLock (&Global->RtcLock);
+      EfiReleaseLock (&Global->RtcLock);
     }
+    DEBUG((DEBUG_INFO, "%a: faield to update RTC\n", __FUNCTION__));
     return EFI_DEVICE_ERROR;
   }
 
@@ -293,6 +297,7 @@ PcRtcInit (
     if (!EfiAtRuntime ()) {
       EfiReleaseLock (&Global->RtcLock);
     }
+    DEBUG((DEBUG_INFO, "%a: failed to set variable RTCALARM\n", __FUNCTION__));
     return EFI_DEVICE_ERROR;
   }
 
@@ -366,6 +371,7 @@ PcRtcGetTime (
   //
   Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
   if (EFI_ERROR (Status)) {
+      DEBUG((DEBUG_INFO, "%a RTC did not update\n", __FUNCTION__));
       if (!EfiAtRuntime ()) {
         EfiReleaseLock (&Global->RtcLock);
       }
@@ -407,6 +413,7 @@ PcRtcGetTime (
     Status = RtcTimeFieldsValid (Time);
   }
   if (EFI_ERROR (Status)) {
+    DEBUG((DEBUG_INFO, "%a time fields invalid after convert to EFI\n", __FUNCTION__));
     return EFI_DEVICE_ERROR;
   }
 
@@ -458,6 +465,7 @@ PcRtcSetTime (
   //
   Status = RtcTimeFieldsValid (Time);
   if (EFI_ERROR (Status)) {
+    DEBUG((DEBUG_INFO, "%a time fields invalid\n", __FUNCTION__));
     return Status;
   }
 
@@ -474,6 +482,7 @@ PcRtcSetTime (
   //
   Status = RtcWaitToUpdate (PcdGet32 (PcdRealTimeClockUpdateTimeout));
   if (EFI_ERROR (Status)) {
+     DEBUG((DEBUG_INFO, "%a RTC did not update\n", __FUNCTION__));
      if (!EfiAtRuntime ()) {
        EfiReleaseLock (&Global->RtcLock);
      }
@@ -507,6 +516,7 @@ PcRtcSetTime (
   }
 
   if (EFI_ERROR (Status)) {
+    DEBUG((DEBUG_INFO, "%a failed to set variables\n", __FUNCTION__));
     if (!EfiAtRuntime ()) {
       EfiReleaseLock (&Global->RtcLock);
     }
@@ -988,6 +998,14 @@ RtcTimeFieldsValid (
       Time->Nanosecond > 999999999 ||
       (!(Time->TimeZone == EFI_UNSPECIFIED_TIMEZONE || (Time->TimeZone >= -1440 && Time->TimeZone <= 1440))) ||
       ((Time->Daylight & (~(EFI_TIME_ADJUST_DAYLIGHT | EFI_TIME_IN_DAYLIGHT))) != 0)) {
+      DEBUG ((DEBUG_INFO, "Year: %04x\n", Time->Year));
+      DEBUG ((DEBUG_INFO, "Month: %02x\n", Time->Month));
+      DEBUG ((DEBUG_INFO, "Hour: %02x\n", Time->Hour));
+      DEBUG ((DEBUG_INFO, "Minute: %02x\n", Time->Minute));
+      DEBUG ((DEBUG_INFO, "Second: %02x\n", Time->Second));
+      DEBUG ((DEBUG_INFO, "Nanosecond: %08x\n", Time->Nanosecond));
+      DEBUG ((DEBUG_INFO, "TimeZone: %d\n", Time->TimeZone));
+      DEBUG ((DEBUG_INFO, "Daylight: %02x\n", Time->Daylight));
     return EFI_INVALID_PARAMETER;
   }
 

PcAtChipsetPkg/PcatRealTimeClockRuntimeDxe/PcRtcEntry.c

@@ -128,12 +128,15 @@ InitializePcRtc (
   EFI_STATUS  Status;
   EFI_EVENT   Event;
 
+  DEBUG((DEBUG_INFO, "%a\n", __FUNCTION__));
+
   EfiInitializeLock (&mModuleGlobal.RtcLock, TPL_CALLBACK);
   mModuleGlobal.CenturyRtcAddress = GetCenturyRtcAddress ();
 
   Status = PcRtcInit (&mModuleGlobal);
   ASSERT_EFI_ERROR (Status);
 
+  DEBUG((DEBUG_INFO, "%a: CreateEventEx1\n", __FUNCTION__));
   Status = gBS->CreateEventEx (
                   EVT_NOTIFY_SIGNAL,
                   TPL_CALLBACK,
@@ -144,6 +147,7 @@ InitializePcRtc (
                   );
   ASSERT_EFI_ERROR (Status);
 
+  DEBUG((DEBUG_INFO, "%a: CreateEventEx2\n", __FUNCTION__));
   Status = gBS->CreateEventEx (
                   EVT_NOTIFY_SIGNAL,
                   TPL_CALLBACK,
@@ -158,7 +162,8 @@ InitializePcRtc (
   gRT->SetTime       = PcRtcEfiSetTime;
   gRT->GetWakeupTime = PcRtcEfiGetWakeupTime;
   gRT->SetWakeupTime = PcRtcEfiSetWakeupTime;
-
+
+  DEBUG((DEBUG_INFO, "%a: Install protocol interfaces\n", __FUNCTION__));
   Status = gBS->InstallMultipleProtocolInterfaces (
                   &mHandle,
                   &gEfiRealTimeClockArchProtocolGuid,

UefiPayloadPkg/AmdSpiDxe/AmdSpiDxe.c

@@ -0,0 +1,231 @@
+/** @file  AmdSpiStoreDxe.c
+
+  Copyright (c) 2020, 3mdeb Embedded Systems Consulting<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/UefiLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/DxeServicesTableLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/PcdLib.h>
+#include <Library/HobLib.h>
+#include <Library/AmdSpiLib.h>
+
+#include "AmdSpiDxe.h"
+
+STATIC EFI_EVENT mAmdSpiVirtualAddrChangeEvent;
+
+//
+// Global variable declarations
+//
+AMD_SPI_INSTANCE *mAMDSpiInstance;
+
+AMD_SPI_INSTANCE  mAMDSpiInstanceTemplate = {
+  AMD_SPI_SIGNATURE, // Signature
+  NULL, // Handle ... NEED TO BE FILLED
+  {
+    0, // MediaId ... NEED TO BE FILLED
+    FALSE, // RemovableMedia
+    TRUE, // MediaPresent
+    FALSE, // LogicalPartition
+    FALSE, // ReadOnly
+    FALSE, // WriteCaching;
+    0, // BlockSize ... NEED TO BE FILLED
+    4, //  IoAlign
+    0, // LastBlock ... NEED TO BE FILLED
+    0, // LowestAlignedLba
+    1, // LogicalBlocksPerPhysicalBlock
+  }, //Media;
+
+  {
+    FvbGetAttributes, // GetAttributes
+    FvbSetAttributes, // SetAttributes
+    FvbGetPhysicalAddress,  // GetPhysicalAddress
+    FvbGetBlockSize,  // GetBlockSize
+    FvbRead,  // Read
+    FvbWrite, // Write
+    FvbEraseBlocks, // EraseBlocks
+    NULL, //ParentHandle
+  }, //  FvbProtoccol;
+  {
+    {
+      {
+        HARDWARE_DEVICE_PATH,
+        HW_VENDOR_DP,
+        {
+          (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End)),
+          (UINT8)(OFFSET_OF (NOR_FLASH_DEVICE_PATH, End) >> 8)
+        }
+      },
+      { 0x0, 0x0, 0x0, { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 } }, // GUID ... NEED TO BE FILLED
+    },
+    0, // Index
+    {
+      END_DEVICE_PATH_TYPE,
+      END_ENTIRE_DEVICE_PATH_SUBTYPE,
+      { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
+    }
+    } // DevicePath
+};
+
+STATIC
+EFI_STATUS
+AmdSpiCreateInstance (
+  IN UINTN                  NumberofBlocks,
+  IN UINTN                  BlockSize,
+  OUT AMD_SPI_INSTANCE**    AMDSpiInstance
+  )
+{
+  EFI_STATUS Status;
+  AMD_SPI_INSTANCE* Instance;
+
+  ASSERT(AMDSpiInstance != NULL);
+
+  Instance = AllocateRuntimeCopyPool (sizeof(AMD_SPI_INSTANCE),&mAMDSpiInstanceTemplate);
+  if (Instance == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Instance->Media.MediaId = 0;
+  Instance->Media.BlockSize = BlockSize;
+  Instance->Media.LastBlock = NumberofBlocks - 1;
+
+  CopyGuid (&Instance->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);
+  Instance->DevicePath.Index = (UINT8)0;
+
+  Status = AmdSpiFvbInitialize (Instance);
+  if (EFI_ERROR(Status)) {
+    FreePool (Instance);
+    return Status;
+  }
+
+  Status = gBS->InstallMultipleProtocolInterfaces (
+                &Instance->Handle,
+                &gEfiDevicePathProtocolGuid, &Instance->DevicePath,
+                &gEfiFirmwareVolumeBlockProtocolGuid, &Instance->FvbProtocol,
+                NULL
+                );
+  if (EFI_ERROR(Status)) {
+    FreePool (Instance);
+    return Status;
+  }
+
+  DEBUG((DEBUG_INFO, "%a: Created a new instance\n", __FUNCTION__));
+
+  *AMDSpiInstance = Instance;
+  return Status;
+}
+
+/**
+  Fixup internal data so that EFI can be call in virtual mode.
+  Call the passed in Child Notify event and convert any pointers in
+  lib to virtual mode.
+
+  @param[in]    Event   The Event that is being processed
+  @param[in]    Context Event Context
+**/
+VOID
+EFIAPI
+BlAMDSpiVirtualNotifyEvent (
+  IN EFI_EVENT        Event,
+  IN VOID             *Context
+  )
+{
+  // Convert Fvb
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.EraseBlocks);
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.GetAttributes);
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.GetBlockSize);
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.GetPhysicalAddress);
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.Read);
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.SetAttributes);
+  EfiConvertPointer (0x0, (VOID**)&mAMDSpiInstance->FvbProtocol.Write);
+
+  return;
+}
+
+EFI_STATUS
+EFIAPI
+BlAmdSpiInitialise (
+  IN EFI_HANDLE         ImageHandle,
+  IN EFI_SYSTEM_TABLE   *SystemTable
+  )
+{
+  EFI_STATUS                              Status;
+  EFI_GCD_MEMORY_SPACE_DESCRIPTOR         GcdDescriptor;
+
+  if (PcdGetBool (PcdEmuVariableNvModeEnable)) {
+    DEBUG ((DEBUG_WARN, "Variable emulation is active! Skipping driver init.\n"));
+    return EFI_SUCCESS;
+  }
+
+  Status = AmdSpiInitialize();
+  if (EFI_ERROR(Status)) {
+    DEBUG((EFI_D_ERROR,"%a: Failed to initialize AmdSpi\n", __FUNCTION__));
+    PcdSetBoolS (PcdEmuVariableNvModeEnable, TRUE);
+    return Status;
+  }
+
+  mAMDSpiInstance = AllocateRuntimePool (sizeof(AMD_SPI_INSTANCE*));
+  if (!mAMDSpiInstance) {
+    DEBUG((EFI_D_ERROR, "%a: Out of resources\n", __FUNCTION__));
+    PcdSetBoolS (PcdEmuVariableNvModeEnable, TRUE);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Status = AmdSpiCreateInstance (3, 0x10000, &mAMDSpiInstance);
+  if (EFI_ERROR(Status)) {
+    DEBUG((EFI_D_ERROR, "%a: Fail to create instance for AmdSpi\n",
+      __FUNCTION__));
+    PcdSetBoolS (PcdEmuVariableNvModeEnable, TRUE);
+    return Status;
+  }
+
+  //
+  // Register for the virtual address change event
+  //
+  Status = gBS->CreateEventEx (
+                  EVT_NOTIFY_SIGNAL,
+                  TPL_NOTIFY,
+                  BlAMDSpiVirtualNotifyEvent,
+                  NULL,
+                  &gEfiEventVirtualAddressChangeGuid,
+                  &mAmdSpiVirtualAddrChangeEvent
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  //
+  // Mark the memory mapped store as MMIO memory
+  //
+  Status      = gDS->GetMemorySpaceDescriptor (PcdGet32(PcdFlashNvStorageVariableBase), &GcdDescriptor);
+  if (EFI_ERROR (Status) || GcdDescriptor.GcdMemoryType != EfiGcdMemoryTypeMemoryMappedIo) {
+    DEBUG((EFI_D_INFO, "%a: No memory space descriptor for com buffer found\n",
+      __FUNCTION__));
+
+    //
+    // Add a new entry if not covered by existing mapping
+    //
+    Status = gDS->AddMemorySpace (
+        EfiGcdMemoryTypeMemoryMappedIo,
+        PcdGet32(PcdFlashNvStorageVariableBase),
+        4 * 0x10000,
+        EFI_MEMORY_UC | EFI_MEMORY_RUNTIME
+        );
+    ASSERT_EFI_ERROR (Status);
+  }
+
+  //
+  // Mark as runtime service
+  //
+  Status = gDS->SetMemorySpaceAttributes (
+                  PcdGet32(PcdFlashNvStorageVariableBase),
+                  4 * 0x10000,
+                  EFI_MEMORY_RUNTIME
+                  );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}