MdePkg: Declare _ReturnAddress() in Base.h for MSFT tool chain

[mirror_edk2.git] / OvmfPkg / Library / QemuFwCfgLib / QemuFwCfgLib.c

/** @file\r
\r
  Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
  Copyright (C) 2013, Red Hat, Inc.\r
  Copyright (c) 2017, AMD Incorporated. All rights reserved.<BR>\r
\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "Uefi.h"\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/IoLib.h>\r
#include <Library/QemuFwCfgLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UefiBootServicesTableLib.h>\r
\r
#include "QemuFwCfgLibInternal.h"\r
\r
\r
/**\r
  Selects a firmware configuration item for reading.\r
  \r
  Following this call, any data read from this item will start from\r
  the beginning of the configuration item's data.\r
\r
  @param[in] QemuFwCfgItem - Firmware Configuration item to read\r
\r
**/\r
VOID\r
EFIAPI\r
QemuFwCfgSelectItem (\r
  IN FIRMWARE_CONFIG_ITEM   QemuFwCfgItem\r
  )\r
{\r
  DEBUG ((EFI_D_INFO, "Select Item: 0x%x\n", (UINT16)(UINTN) QemuFwCfgItem));\r
  IoWrite16 (FW_CFG_IO_SELECTOR, (UINT16)(UINTN) QemuFwCfgItem);\r
}\r
\r
\r
/**\r
  Transfer an array of bytes, or skip a number of bytes, using the DMA\r
  interface.\r
\r
  @param[in]     Size     Size in bytes to transfer or skip.\r
\r
  @param[in,out] Buffer   Buffer to read data into or write data from. Ignored,\r
                          and may be NULL, if Size is zero, or Control is\r
                          FW_CFG_DMA_CTL_SKIP.\r
\r
  @param[in]     Control  One of the following:\r
                          FW_CFG_DMA_CTL_WRITE - write to fw_cfg from Buffer.\r
                          FW_CFG_DMA_CTL_READ  - read from fw_cfg into Buffer.\r
                          FW_CFG_DMA_CTL_SKIP  - skip bytes in fw_cfg.\r
**/\r
VOID\r
InternalQemuFwCfgDmaBytes (\r
  IN     UINT32   Size,\r
  IN OUT VOID     *Buffer OPTIONAL,\r
  IN     UINT32   Control\r
  )\r
{\r
  volatile FW_CFG_DMA_ACCESS LocalAccess;\r
  volatile FW_CFG_DMA_ACCESS *Access;\r
  UINT32                     AccessHigh, AccessLow;\r
  UINT32                     Status;\r
  UINT32                     NumPages;\r
  VOID                       *DmaBuffer, *BounceBuffer;\r
\r
  ASSERT (Control == FW_CFG_DMA_CTL_WRITE || Control == FW_CFG_DMA_CTL_READ ||\r
    Control == FW_CFG_DMA_CTL_SKIP);\r
\r
  if (Size == 0) {\r
    return;\r
  }\r
\r
  //\r
  // When SEV is enabled then allocate DMA bounce buffer\r
  //\r
  if (InternalQemuFwCfgSevIsEnabled ()) {\r
    UINTN  TotalSize;\r
\r
    TotalSize = sizeof (*Access);\r
    //\r
    // Skip operation does not need buffer\r
    //\r
    if (Control != FW_CFG_DMA_CTL_SKIP) {\r
      TotalSize += Size;\r
    }\r
\r
    //\r
    // Allocate SEV DMA buffer\r
    //\r
    NumPages = (UINT32)EFI_SIZE_TO_PAGES (TotalSize);\r
    InternalQemuFwCfgSevDmaAllocateBuffer (&BounceBuffer, NumPages);\r
\r
    Access = BounceBuffer;\r
    DmaBuffer = (UINT8*)BounceBuffer + sizeof (*Access);\r
\r
    //\r
    //  Decrypt data from encrypted guest buffer into DMA buffer\r
    //\r
    if (Control == FW_CFG_DMA_CTL_WRITE) {\r
      CopyMem (DmaBuffer, Buffer, Size);\r
    }\r
  } else {\r
    Access = &LocalAccess;\r
    DmaBuffer = Buffer;\r
    BounceBuffer = NULL;\r
  }\r
\r
  Access->Control = SwapBytes32 (Control);\r
  Access->Length  = SwapBytes32 (Size);\r
  Access->Address = SwapBytes64 ((UINTN)DmaBuffer);\r
\r
  //\r
  // Delimit the transfer from (a) modifications to Access, (b) in case of a\r
  // write, from writes to Buffer by the caller.\r
  //\r
  MemoryFence ();\r
\r
  //\r
  // Start the transfer.\r
  //\r
  AccessHigh = (UINT32)RShiftU64 ((UINTN)Access, 32);\r
  AccessLow  = (UINT32)(UINTN)Access;\r
  IoWrite32 (FW_CFG_IO_DMA_ADDRESS,     SwapBytes32 (AccessHigh));\r
  IoWrite32 (FW_CFG_IO_DMA_ADDRESS + 4, SwapBytes32 (AccessLow));\r
\r
  //\r
  // Don't look at Access.Control before starting the transfer.\r
  //\r
  MemoryFence ();\r
\r
  //\r
  // Wait for the transfer to complete.\r
  //\r
  do {\r
    Status = SwapBytes32 (Access->Control);\r
    ASSERT ((Status & FW_CFG_DMA_CTL_ERROR) == 0);\r
  } while (Status != 0);\r
\r
  //\r
  // After a read, the caller will want to use Buffer.\r
  //\r
  MemoryFence ();\r
\r
  //\r
  // If Bounce buffer was allocated then copy the data into guest buffer and\r
  // free the bounce buffer\r
  //\r
  if (BounceBuffer != NULL) {\r
    //\r
    //  Encrypt the data from DMA buffer into guest buffer\r
    //\r
    if (Control == FW_CFG_DMA_CTL_READ) {\r
      CopyMem (Buffer, DmaBuffer, Size);\r
    }\r
\r
    InternalQemuFwCfgSevDmaFreeBuffer (BounceBuffer, NumPages);\r
  }\r
}\r
\r
\r
/**\r
  Reads firmware configuration bytes into a buffer\r
\r
  @param[in] Size - Size in bytes to read\r
  @param[in] Buffer - Buffer to store data into  (OPTIONAL if Size is 0)\r
\r
**/\r
VOID\r
EFIAPI\r
InternalQemuFwCfgReadBytes (\r
  IN UINTN                  Size,\r
  IN VOID                   *Buffer  OPTIONAL\r
  )\r
{\r
  if (InternalQemuFwCfgDmaIsAvailable () && Size <= MAX_UINT32) {\r
    InternalQemuFwCfgDmaBytes ((UINT32)Size, Buffer, FW_CFG_DMA_CTL_READ);\r
    return;\r
  }\r
  IoReadFifo8 (FW_CFG_IO_DATA, Size, Buffer);\r
}\r
\r
\r
/**\r
  Reads firmware configuration bytes into a buffer\r
\r
  If called multiple times, then the data read will\r
  continue at the offset of the firmware configuration\r
  item where the previous read ended.\r
\r
  @param[in] Size - Size in bytes to read\r
  @param[in] Buffer - Buffer to store data into\r
\r
**/\r
VOID\r
EFIAPI\r
QemuFwCfgReadBytes (\r
  IN UINTN                  Size,\r
  IN VOID                   *Buffer\r
  )\r
{\r
  if (InternalQemuFwCfgIsAvailable ()) {\r
    InternalQemuFwCfgReadBytes (Size, Buffer);\r
  } else {\r
    ZeroMem (Buffer, Size);\r
  }\r
}\r
\r
/**\r
  Write firmware configuration bytes from a buffer\r
\r
  If called multiple times, then the data written will\r
  continue at the offset of the firmware configuration\r
  item where the previous write ended.\r
\r
  @param[in] Size - Size in bytes to write\r
  @param[in] Buffer - Buffer to read data from\r
\r
**/\r
VOID\r
EFIAPI\r
QemuFwCfgWriteBytes (\r
  IN UINTN                  Size,\r
  IN VOID                   *Buffer\r
  )\r
{\r
  if (InternalQemuFwCfgIsAvailable ()) {\r
    if (InternalQemuFwCfgDmaIsAvailable () && Size <= MAX_UINT32) {\r
      InternalQemuFwCfgDmaBytes ((UINT32)Size, Buffer, FW_CFG_DMA_CTL_WRITE);\r
      return;\r
    }\r
    IoWriteFifo8 (FW_CFG_IO_DATA, Size, Buffer);\r
  }\r
}\r
\r
\r
/**\r
  Skip bytes in the firmware configuration item.\r
\r
  Increase the offset of the firmware configuration item without transferring\r
  bytes between the item and a caller-provided buffer. Subsequent read, write\r
  or skip operations will commence at the increased offset.\r
\r
  @param[in] Size  Number of bytes to skip.\r
**/\r
VOID\r
EFIAPI\r
QemuFwCfgSkipBytes (\r
  IN UINTN                  Size\r
  )\r
{\r
  UINTN ChunkSize;\r
  UINT8 SkipBuffer[256];\r
\r
  if (!InternalQemuFwCfgIsAvailable ()) {\r
    return;\r
  }\r
\r
  if (InternalQemuFwCfgDmaIsAvailable () && Size <= MAX_UINT32) {\r
    InternalQemuFwCfgDmaBytes ((UINT32)Size, NULL, FW_CFG_DMA_CTL_SKIP);\r
    return;\r
  }\r
\r
  //\r
  // Emulate the skip by reading data in chunks, and throwing it away. The\r
  // implementation below is suitable even for phases where RAM or dynamic\r
  // allocation is not available or appropriate. It also doesn't affect the\r
  // static data footprint for client modules. Large skips are not expected,\r
  // therefore this fallback is not performance critical. The size of\r
  // SkipBuffer is thought not to exert a large pressure on the stack in any\r
  // phase.\r
  //\r
  while (Size > 0) {\r
    ChunkSize = MIN (Size, sizeof SkipBuffer);\r
    IoReadFifo8 (FW_CFG_IO_DATA, ChunkSize, SkipBuffer);\r
    Size -= ChunkSize;\r
  }\r
}\r
\r
\r
/**\r
  Reads a UINT8 firmware configuration value\r
\r
  @return    Value of Firmware Configuration item read\r
\r
**/\r
UINT8\r
EFIAPI\r
QemuFwCfgRead8 (\r
  VOID\r
  )\r
{\r
  UINT8 Result;\r
\r
  QemuFwCfgReadBytes (sizeof (Result), &Result);\r
\r
  return Result;\r
}\r
\r
\r
/**\r
  Reads a UINT16 firmware configuration value\r
\r
  @return    Value of Firmware Configuration item read\r
\r
**/\r
UINT16\r
EFIAPI\r
QemuFwCfgRead16 (\r
  VOID\r
  )\r
{\r
  UINT16 Result;\r
\r
  QemuFwCfgReadBytes (sizeof (Result), &Result);\r
\r
  return Result;\r
}\r
\r
\r
/**\r
  Reads a UINT32 firmware configuration value\r
\r
  @return    Value of Firmware Configuration item read\r
\r
**/\r
UINT32\r
EFIAPI\r
QemuFwCfgRead32 (\r
  VOID\r
  )\r
{\r
  UINT32 Result;\r
\r
  QemuFwCfgReadBytes (sizeof (Result), &Result);\r
\r
  return Result;\r
}\r
\r
\r
/**\r
  Reads a UINT64 firmware configuration value\r
\r
  @return    Value of Firmware Configuration item read\r
\r
**/\r
UINT64\r
EFIAPI\r
QemuFwCfgRead64 (\r
  VOID\r
  )\r
{\r
  UINT64 Result;\r
\r
  QemuFwCfgReadBytes (sizeof (Result), &Result);\r
\r
  return Result;\r
}\r
\r
\r
/**\r
  Find the configuration item corresponding to the firmware configuration file.\r
\r
  @param[in]  Name - Name of file to look up.\r
  @param[out] Item - Configuration item corresponding to the file, to be passed\r
                     to QemuFwCfgSelectItem ().\r
  @param[out] Size - Number of bytes in the file.\r
\r
  @return    RETURN_SUCCESS       If file is found.\r
             RETURN_NOT_FOUND     If file is not found.\r
             RETURN_UNSUPPORTED   If firmware configuration is unavailable.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
QemuFwCfgFindFile (\r
  IN   CONST CHAR8           *Name,\r
  OUT  FIRMWARE_CONFIG_ITEM  *Item,\r
  OUT  UINTN                 *Size\r
  )\r
{\r
  UINT32 Count;\r
  UINT32 Idx;\r
\r
  if (!InternalQemuFwCfgIsAvailable ()) {\r
    return RETURN_UNSUPPORTED;\r
  }\r
\r
  QemuFwCfgSelectItem (QemuFwCfgItemFileDir);\r
  Count = SwapBytes32 (QemuFwCfgRead32 ());\r
\r
  for (Idx = 0; Idx < Count; ++Idx) {\r
    UINT32 FileSize;\r
    UINT16 FileSelect;\r
    UINT16 FileReserved;\r
    CHAR8  FName[QEMU_FW_CFG_FNAME_SIZE];\r
\r
    FileSize     = QemuFwCfgRead32 ();\r
    FileSelect   = QemuFwCfgRead16 ();\r
    FileReserved = QemuFwCfgRead16 ();\r
    (VOID) FileReserved; /* Force a do-nothing reference. */\r
    InternalQemuFwCfgReadBytes (sizeof (FName), FName);\r
\r
    if (AsciiStrCmp (Name, FName) == 0) {\r
      *Item = SwapBytes16 (FileSelect);\r
      *Size = SwapBytes32 (FileSize);\r
      return RETURN_SUCCESS;\r
    }\r
  }\r
\r
  return RETURN_NOT_FOUND;\r
}\r