PrmSampleHardwareAccessModule.c

Go to the documentation of this file.

 
#include <PrmModule.h>
 
#include <Library/BaseLib.h>
#include <Library/MtrrLib.h>
#include <Library/UefiLib.h>
 
#include <Register/Intel/ArchitecturalMsr.h>
#include <Register/Intel/Cpuid.h>
 
#include "Hpet.h"
 
//
// PRM Handler GUIDs
//
 
// {2120cd3c-848b-4d8f-abbb-4b74ce64ac89}
#define MSR_ACCESS_MICROCODE_SIGNATURE_PRM_HANDLER_GUID  {0x2120cd3c, 0x848b, 0x4d8f, {0xab, 0xbb, 0x4b, 0x74, 0xce, 0x64, 0xac, 0x89}}
 
// {ea0935a7-506b-4159-bbbb-48deeecb6f58}
#define MSR_ACCESS_MTRR_DUMP_PRM_HANDLER_GUID  {0xea0935a7, 0x506b, 0x4159, {0xbb, 0xbb, 0x48, 0xde, 0xee, 0xcb, 0x6f, 0x58}}
 
// {1bd1bda9-909a-4614-9699-25ec0c2783f7}
#define MMIO_ACCESS_HPET_PRM_HANDLER_GUID  {0x1bd1bda9, 0x909a, 0x4614, {0x96, 0x99, 0x25, 0xec, 0x0c, 0x27, 0x83, 0xf7}}
 
//
// BEGIN: MtrrLib internal library globals and function prototypes here for testing
//
extern CONST CHAR8  *mMtrrMemoryCacheTypeShortName[];
 
VOID
MtrrLibInitializeMtrrMask (
  OUT UINT64  *MtrrValidBitsMask,
  OUT UINT64  *MtrrValidAddressMask
  );
 
UINT32
MtrrLibGetRawVariableRanges (
  IN  MTRR_VARIABLE_SETTINGS  *VariableSettings,
  IN  UINTN                   VariableMtrrCount,
  IN  UINT64                  MtrrValidBitsMask,
  IN  UINT64                  MtrrValidAddressMask,
  OUT MTRR_MEMORY_RANGE       *VariableMtrr
  );
 
RETURN_STATUS
MtrrLibApplyFixedMtrrs (
  IN     MTRR_FIXED_SETTINGS  *Fixed,
  IN OUT MTRR_MEMORY_RANGE    *Ranges,
  IN     UINTN                RangeCapacity,
  IN OUT UINTN                *RangeCount
  );
 
RETURN_STATUS
MtrrLibApplyVariableMtrrs (
  IN     CONST MTRR_MEMORY_RANGE  *VariableMtrr,
  IN     UINT32                   VariableMtrrCount,
  IN OUT MTRR_MEMORY_RANGE        *Ranges,
  IN     UINTN                    RangeCapacity,
  IN OUT UINTN                    *RangeCount
  );
 
//
// END: MtrrLib internal library function prototypes here for testing
//
 
VOID
EFIAPI
AccessAllMtrrs (
  VOID
  )
{
  MTRR_SETTINGS  LocalMtrrs;
  MTRR_SETTINGS  *Mtrrs;
  UINTN          RangeCount;
  UINT64         MtrrValidBitsMask;
  UINT64         MtrrValidAddressMask;
  UINT32         VariableMtrrCount;
 
  MTRR_MEMORY_RANGE  Ranges[
                            MTRR_NUMBER_OF_FIXED_MTRR * sizeof (UINT64) + 2 * ARRAY_SIZE (Mtrrs->Variables.Mtrr) + 1
  ];
  MTRR_MEMORY_RANGE  RawVariableRanges[ARRAY_SIZE (Mtrrs->Variables.Mtrr)];
 
  if (!IsMtrrSupported ()) {
    return;
  }
 
  VariableMtrrCount = GetVariableMtrrCount ();
 
  MtrrGetAllMtrrs (&LocalMtrrs);
  Mtrrs = &LocalMtrrs;
 
  MtrrLibInitializeMtrrMask (&MtrrValidBitsMask, &MtrrValidAddressMask);
  Ranges[0].BaseAddress = 0;
  Ranges[0].Length      = MtrrValidBitsMask + 1;
  Ranges[0].Type        = MtrrGetDefaultMemoryType ();
  RangeCount            = 1;
 
  MtrrLibGetRawVariableRanges (
    &Mtrrs->Variables,
    VariableMtrrCount,
    MtrrValidBitsMask,
    MtrrValidAddressMask,
    RawVariableRanges
    );
  MtrrLibApplyVariableMtrrs (
    RawVariableRanges,
    VariableMtrrCount,
    Ranges,
    ARRAY_SIZE (Ranges),
    &RangeCount
    );
 
  MtrrLibApplyFixedMtrrs (&Mtrrs->Fixed, Ranges, ARRAY_SIZE (Ranges), &RangeCount);
}
 
UINT64
EFIAPI
HpetRead (
  IN  UINTN  Offset
  )
{
  UINTN   Address;
  UINT64  Value;
 
  Address = HPET_BASE_ADDRESS + Offset;
 
  if ((Address & 7) == 0) {
    return 0;
  }
 
  MemoryFence ();
  Value = *(volatile UINT64 *)Address;
  MemoryFence ();
 
  return Value;
}
 
VOID
EFIAPI
AccessHpetConfiguration (
  VOID
  )
{
  HpetRead (HPET_GENERAL_CAPABILITIES_ID_OFFSET);
  HpetRead (HPET_GENERAL_CONFIGURATION_OFFSET);
}
 
UINT32
GetMicrocodeSignature (
  VOID
  )
{
  MSR_IA32_BIOS_SIGN_ID_REGISTER  BiosSignIdMsr;
 
  AsmWriteMsr64 (MSR_IA32_BIOS_SIGN_ID, 0);
  AsmCpuid (CPUID_VERSION_INFO, NULL, NULL, NULL, NULL);
  BiosSignIdMsr.Uint64 = AsmReadMsr64 (MSR_IA32_BIOS_SIGN_ID);
 
  return BiosSignIdMsr.Bits.MicrocodeUpdateSignature;
}
 
PRM_HANDLER_EXPORT (MsrAccessMicrocodeSignaturePrmHandler) {
  UINT32  MicrocodeSignature;
 
  MicrocodeSignature = 0;
  MicrocodeSignature = GetMicrocodeSignature ();
 
  if (MicrocodeSignature == 0) {
    return EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
PRM_HANDLER_EXPORT (MsrAccessMtrrDumpPrmHandler) {
  AccessAllMtrrs ();
 
  return EFI_SUCCESS;
}
 
PRM_HANDLER_EXPORT (MmioAccessHpetPrmHandler) {
  AccessHpetConfiguration ();
 
  return EFI_SUCCESS;
}
 
//
// Register the PRM export information for this PRM Module
//
PRM_MODULE_EXPORT (
  PRM_HANDLER_EXPORT_ENTRY (MSR_ACCESS_MICROCODE_SIGNATURE_PRM_HANDLER_GUID, MsrAccessMicrocodeSignaturePrmHandler),
  PRM_HANDLER_EXPORT_ENTRY (MSR_ACCESS_MTRR_DUMP_PRM_HANDLER_GUID, MsrAccessMtrrDumpPrmHandler),
  PRM_HANDLER_EXPORT_ENTRY (MMIO_ACCESS_HPET_PRM_HANDLER_GUID, MmioAccessHpetPrmHandler)
  );
 
EFI_STATUS
EFIAPI
PrmSampleHardwareAccessModuleInit (
  IN  EFI_HANDLE        ImageHandle,
  IN  EFI_SYSTEM_TABLE  *SystemTable
  )
{
  return EFI_SUCCESS;
}