IoLibInternalTdx.c

Go to the documentation of this file.

 
#include "BaseIoLibIntrinsicInternal.h"
#include <Uefi/UefiBaseType.h>
#include <Include/IndustryStandard/Tdx.h>
#include <Library/TdxLib.h>
#include <Register/Intel/Cpuid.h>
#include <Library/CcProbeLib.h>
#include "IoLibTdx.h"
 
// Size of TDVMCALL Access, including IO and MMIO
#define TDVMCALL_ACCESS_SIZE_1  1
#define TDVMCALL_ACCESS_SIZE_2  2
#define TDVMCALL_ACCESS_SIZE_4  4
#define TDVMCALL_ACCESS_SIZE_8  8
 
// Direction of TDVMCALL Access, including IO and MMIO
#define TDVMCALL_ACCESS_READ   0
#define TDVMCALL_ACCESS_WRITE  1
 
BOOLEAN
EFIAPI
IsTdxGuest (
  VOID
  )
{
  return CcProbe () == CcGuestTypeIntelTdx;
}
 
UINT8
EFIAPI
TdIoRead8 (
  IN      UINTN  Port
  )
{
  UINT64  Status;
  UINT64  Val;
 
  Status = TdVmCall (TDVMCALL_IO, TDVMCALL_ACCESS_SIZE_1, TDVMCALL_ACCESS_READ, Port, 0, &Val);
  if (Status != 0) {
    TdVmCall (TDVMCALL_HALT, 0, 0, 0, 0, 0);
  }
 
  return (UINT8)Val;
}
 
UINT16
EFIAPI
TdIoRead16 (
  IN      UINTN  Port
  )
{
  UINT64  Status;
  UINT64  Val;
 
  ASSERT ((Port & 1) == 0);
 
  Status = TdVmCall (TDVMCALL_IO, TDVMCALL_ACCESS_SIZE_2, TDVMCALL_ACCESS_READ, Port, 0, &Val);
  if (Status != 0) {
    TdVmCall (TDVMCALL_HALT, 0, 0, 0, 0, 0);
  }
 
  return (UINT16)Val;
}
 
UINT32
EFIAPI
TdIoRead32 (
  IN      UINTN  Port
  )
{
  UINT64  Status;
  UINT64  Val;
 
  ASSERT ((Port & 3) == 0);
 
  Status = TdVmCall (TDVMCALL_IO, TDVMCALL_ACCESS_SIZE_4, TDVMCALL_ACCESS_READ, Port, 0, &Val);
  if (Status != 0) {
    TdVmCall (TDVMCALL_HALT, 0, 0, 0, 0, 0);
  }
 
  return (UINT32)Val;
}
 
UINT8
EFIAPI
TdIoWrite8 (
  IN      UINTN  Port,
  IN      UINT8  Value
  )
{
  UINT64  Status;
  UINT64  Val;
 
  Val    = Value;
  Status = TdVmCall (TDVMCALL_IO, TDVMCALL_ACCESS_SIZE_1, TDVMCALL_ACCESS_WRITE, Port, Val, 0);
  if (Status != 0) {
    TdVmCall (TDVMCALL_HALT, 0, 0, 0, 0, 0);
  }
 
  return Value;
}
 
UINT16
EFIAPI
TdIoWrite16 (
  IN      UINTN   Port,
  IN      UINT16  Value
  )
{
  UINT64  Status;
  UINT64  Val;
 
  ASSERT ((Port & 1) == 0);
  Val    = Value;
  Status = TdVmCall (TDVMCALL_IO, TDVMCALL_ACCESS_SIZE_2, TDVMCALL_ACCESS_WRITE, Port, Val, 0);
  if (Status != 0) {
    TdVmCall (TDVMCALL_HALT, 0, 0, 0, 0, 0);
  }
 
  return Value;
}
 
UINT32
EFIAPI
TdIoWrite32 (
  IN      UINTN   Port,
  IN      UINT32  Value
  )
{
  UINT64  Status;
  UINT64  Val;
 
  ASSERT ((Port & 3) == 0);
  Val    = Value;
  Status = TdVmCall (TDVMCALL_IO, TDVMCALL_ACCESS_SIZE_4, TDVMCALL_ACCESS_WRITE, Port, Val, 0);
  if (Status != 0) {
    TdVmCall (TDVMCALL_HALT, 0, 0, 0, 0, 0);
  }
 
  return Value;
}
 
UINT8
EFIAPI
TdMmioRead8 (
  IN      UINTN  Address
  )
{
  UINT64  Value;
  UINT64  Status;
 
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_1, TDVMCALL_ACCESS_READ, Address | TdSharedPageMask (), 0, &Value);
  if (Status != 0) {
    Value = *(volatile UINT8 *)Address;
  }
 
  return (UINT8)Value;
}
 
UINT8
EFIAPI
TdMmioWrite8 (
  IN      UINTN  Address,
  IN      UINT8  Value
  )
{
  UINT64  Val;
  UINT64  Status;
 
  Val    = Value;
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_1, TDVMCALL_ACCESS_WRITE, Address | TdSharedPageMask (), Val, 0);
  if (Status != 0) {
    *(volatile UINT8 *)Address = Value;
  }
 
  return Value;
}
 
UINT16
EFIAPI
TdMmioRead16 (
  IN      UINTN  Address
  )
{
  UINT64  Value;
  UINT64  Status;
 
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_2, TDVMCALL_ACCESS_READ, Address | TdSharedPageMask (), 0, &Value);
  if (Status != 0) {
    Value = *(volatile UINT16 *)Address;
  }
 
  return (UINT16)Value;
}
 
UINT16
EFIAPI
TdMmioWrite16 (
  IN      UINTN   Address,
  IN      UINT16  Value
  )
{
  UINT64  Val;
  UINT64  Status;
 
  ASSERT ((Address & 1) == 0);
 
  Val    = Value;
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_2, TDVMCALL_ACCESS_WRITE, Address | TdSharedPageMask (), Val, 0);
  if (Status != 0) {
    *(volatile UINT16 *)Address = Value;
  }
 
  return Value;
}
 
UINT32
EFIAPI
TdMmioRead32 (
  IN      UINTN  Address
  )
{
  UINT64  Value;
  UINT64  Status;
 
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_4, TDVMCALL_ACCESS_READ, Address | TdSharedPageMask (), 0, &Value);
  if (Status != 0) {
    Value = *(volatile UINT32 *)Address;
  }
 
  return (UINT32)Value;
}
 
UINT32
EFIAPI
TdMmioWrite32 (
  IN      UINTN   Address,
  IN      UINT32  Value
  )
{
  UINT64  Val;
  UINT64  Status;
 
  ASSERT ((Address & 3) == 0);
 
  Val    = Value;
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_4, TDVMCALL_ACCESS_WRITE, Address | TdSharedPageMask (), Val, 0);
  if (Status != 0) {
    *(volatile UINT32 *)Address = Value;
  }
 
  return Value;
}
 
UINT64
EFIAPI
TdMmioRead64 (
  IN      UINTN  Address
  )
{
  UINT64  Value;
  UINT64  Status;
 
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_8, TDVMCALL_ACCESS_READ, Address | TdSharedPageMask (), 0, &Value);
  if (Status != 0) {
    Value = *(volatile UINT64 *)Address;
  }
 
  return Value;
}
 
UINT64
EFIAPI
TdMmioWrite64 (
  IN      UINTN   Address,
  IN      UINT64  Value
  )
{
  UINT64  Status;
  UINT64  Val;
 
  ASSERT ((Address & 7) == 0);
 
  Val    = Value;
  Status = TdVmCall (TDVMCALL_MMIO, TDVMCALL_ACCESS_SIZE_8, TDVMCALL_ACCESS_WRITE, Address | TdSharedPageMask (), Val, 0);
  if (Status != 0) {
    *(volatile UINT64 *)Address = Value;
  }
 
  return Value;
}
 
VOID
EFIAPI
TdIoReadFifo8 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  UINT8  *Buf8;
  UINTN  Index;
 
  Buf8 = (UINT8 *)Buffer;
  for (Index = 0; Index < Count; Index++) {
    Buf8[Index] = TdIoRead8 (Port);
  }
}
 
VOID
EFIAPI
TdIoWriteFifo8 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  UINT8  *Buf8;
  UINTN  Index;
 
  Buf8 = (UINT8 *)Buffer;
  for (Index = 0; Index < Count; Index++) {
    TdIoWrite8 (Port, Buf8[Index]);
  }
}
 
VOID
EFIAPI
TdIoReadFifo16 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  UINT16  *Buf16;
  UINTN   Index;
 
  Buf16 = (UINT16 *)Buffer;
  for (Index = 0; Index < Count; Index++) {
    Buf16[Index] = TdIoRead16 (Port);
  }
}
 
VOID
EFIAPI
TdIoWriteFifo16 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  UINT16  *Buf16;
  UINTN   Index;
 
  Buf16 = (UINT16 *)Buffer;
  for (Index = 0; Index < Count; Index++) {
    TdIoWrite16 (Port, Buf16[Index]);
  }
}
 
VOID
EFIAPI
TdIoReadFifo32 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  OUT     VOID   *Buffer
  )
{
  UINT32  *Buf32;
  UINTN   Index;
 
  Buf32 = (UINT32 *)Buffer;
  for (Index = 0; Index < Count; Index++) {
    Buf32[Index] = TdIoRead32 (Port);
  }
}
 
VOID
EFIAPI
TdIoWriteFifo32 (
  IN      UINTN  Port,
  IN      UINTN  Count,
  IN      VOID   *Buffer
  )
{
  UINT32  *Buf32;
  UINTN   Index;
 
  Buf32 = (UINT32 *)Buffer;
  for (Index = 0; Index < Count; Index++) {
    TdIoWrite32 (Port, Buf32[Index]);
  }
}