UefiCpuPkg/Library/CpuCommonFeaturesLib/CpuCommonFeaturesLib.c

   1 /** @file
   2   This library registers CPU features defined in Intel(R) 64 and IA-32
   3   Architectures Software Developer's Manual.
   4
   5   Copyright (c) 2017 - 2020, Intel Corporation. All rights reserved.<BR>
   6   SPDX-License-Identifier: BSD-2-Clause-Patent
   7
   8 **/
   9
  10 #include "CpuCommonFeatures.h"
  11
  12 /**
  13   Register CPU features.
  14
  15   @retval  RETURN_SUCCESS            Register successfully
  16 **/
  17 RETURN_STATUS
  18 EFIAPI
  19 CpuCommonFeaturesLibConstructor (
  20   VOID
  21   )
  22 {
  23   RETURN_STATUS         Status;
  24
  25   if (IsCpuFeatureSupported (CPU_FEATURE_AESNI)) {
  26     Status = RegisterCpuFeature (
  27                "AESNI",
  28                AesniGetConfigData,
  29                AesniSupport,
  30                AesniInitialize,
  31                CPU_FEATURE_AESNI,
  32                CPU_FEATURE_END
  33                );
  34     ASSERT_EFI_ERROR (Status);
  35   }
  36   if (IsCpuFeatureSupported (CPU_FEATURE_MWAIT)) {
  37     Status = RegisterCpuFeature (
  38                "MWAIT",
  39                NULL,
  40                MonitorMwaitSupport,
  41                MonitorMwaitInitialize,
  42                CPU_FEATURE_MWAIT,
  43                CPU_FEATURE_END
  44                );
  45     ASSERT_EFI_ERROR (Status);
  46   }
  47   if (IsCpuFeatureSupported (CPU_FEATURE_ACPI)) {
  48     Status = RegisterCpuFeature (
  49                "ACPI",
  50                ClockModulationGetConfigData,
  51                ClockModulationSupport,
  52                ClockModulationInitialize,
  53                CPU_FEATURE_ACPI,
  54                CPU_FEATURE_END
  55                );
  56     ASSERT_EFI_ERROR (Status);
  57   }
  58   if (IsCpuFeatureSupported (CPU_FEATURE_EIST)) {
  59     Status = RegisterCpuFeature (
  60                "EIST",
  61                NULL,
  62                EistSupport,
  63                EistInitialize,
  64                CPU_FEATURE_EIST,
  65                CPU_FEATURE_END
  66                );
  67     ASSERT_EFI_ERROR (Status);
  68   }
  69   if (IsCpuFeatureSupported (CPU_FEATURE_FASTSTRINGS)) {
  70     Status = RegisterCpuFeature (
  71                "FastStrings",
  72                NULL,
  73                NULL,
  74                FastStringsInitialize,
  75                CPU_FEATURE_FASTSTRINGS,
  76                CPU_FEATURE_END
  77                );
  78     ASSERT_EFI_ERROR (Status);
  79   }
  80   if (IsCpuFeatureSupported (CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER)) {
  81     Status = RegisterCpuFeature (
  82                "Lock Feature Control Register",
  83                NULL,
  84                LockFeatureControlRegisterSupport,
  85                LockFeatureControlRegisterInitialize,
  86                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER,
  87                CPU_FEATURE_END
  88                );
  89     ASSERT_EFI_ERROR (Status);
  90   }
  91   if (IsCpuFeatureSupported (CPU_FEATURE_SMX)) {
  92     Status = RegisterCpuFeature (
  93                "SMX",
  94                NULL,
  95                SmxSupport,
  96                SmxInitialize,
  97                CPU_FEATURE_SMX,
  98                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER | CPU_FEATURE_THREAD_BEFORE,
  99                CPU_FEATURE_END
 100                );
 101     ASSERT_EFI_ERROR (Status);
 102   }
 103   if (IsCpuFeatureSupported (CPU_FEATURE_VMX)) {
 104     Status = RegisterCpuFeature (
 105                "VMX",
 106                NULL,
 107                VmxSupport,
 108                VmxInitialize,
 109                CPU_FEATURE_VMX,
 110                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER | CPU_FEATURE_THREAD_BEFORE,
 111                CPU_FEATURE_END
 112                );
 113     ASSERT_EFI_ERROR (Status);
 114   }
 115   if (IsCpuFeatureSupported (CPU_FEATURE_LIMIT_CPUID_MAX_VAL)) {
 116     Status = RegisterCpuFeature (
 117                "Limit CpuId Maximum Value",
 118                NULL,
 119                LimitCpuidMaxvalSupport,
 120                LimitCpuidMaxvalInitialize,
 121                CPU_FEATURE_LIMIT_CPUID_MAX_VAL,
 122                CPU_FEATURE_END
 123                );
 124     ASSERT_EFI_ERROR (Status);
 125   }
 126   if (IsCpuFeatureSupported (CPU_FEATURE_MCE)) {
 127     Status = RegisterCpuFeature (
 128                "Machine Check Enable",
 129                NULL,
 130                MceSupport,
 131                MceInitialize,
 132                CPU_FEATURE_MCE,
 133                CPU_FEATURE_END
 134                );
 135     ASSERT_EFI_ERROR (Status);
 136   }
 137   if (IsCpuFeatureSupported (CPU_FEATURE_MCA)) {
 138     Status = RegisterCpuFeature (
 139                "Machine Check Architect",
 140                NULL,
 141                McaSupport,
 142                McaInitialize,
 143                CPU_FEATURE_MCA,
 144                CPU_FEATURE_END
 145                );
 146     ASSERT_EFI_ERROR (Status);
 147   }
 148   if (IsCpuFeatureSupported (CPU_FEATURE_MCG_CTL)) {
 149     Status = RegisterCpuFeature (
 150                "MCG_CTL",
 151                NULL,
 152                McgCtlSupport,
 153                McgCtlInitialize,
 154                CPU_FEATURE_MCG_CTL,
 155                CPU_FEATURE_END
 156                );
 157     ASSERT_EFI_ERROR (Status);
 158   }
 159   if (IsCpuFeatureSupported (CPU_FEATURE_PENDING_BREAK)) {
 160     Status = RegisterCpuFeature (
 161                "Pending Break",
 162                NULL,
 163                PendingBreakSupport,
 164                PendingBreakInitialize,
 165                CPU_FEATURE_PENDING_BREAK,
 166                CPU_FEATURE_END
 167                );
 168     ASSERT_EFI_ERROR (Status);
 169   }
 170   if (IsCpuFeatureSupported (CPU_FEATURE_C1E)) {
 171     Status = RegisterCpuFeature (
 172                "C1E",
 173                NULL,
 174                C1eSupport,
 175                C1eInitialize,
 176                CPU_FEATURE_C1E,
 177                CPU_FEATURE_END
 178                );
 179     ASSERT_EFI_ERROR (Status);
 180   }
 181   if (IsCpuFeatureSupported (CPU_FEATURE_X2APIC)) {
 182     Status = RegisterCpuFeature (
 183                "X2Apic",
 184                X2ApicGetConfigData,
 185                X2ApicSupport,
 186                X2ApicInitialize,
 187                CPU_FEATURE_X2APIC,
 188                CPU_FEATURE_END
 189                );
 190     ASSERT_EFI_ERROR (Status);
 191   }
 192   if (IsCpuFeatureSupported (CPU_FEATURE_PPIN)) {
 193     Status = RegisterCpuFeature (
 194                "PPIN",
 195                PpinGetConfigData,
 196                PpinSupport,
 197                PpinInitialize,
 198                CPU_FEATURE_PPIN,
 199                CPU_FEATURE_END
 200                );
 201     ASSERT_EFI_ERROR (Status);
 202   }
 203   if (IsCpuFeatureSupported (CPU_FEATURE_LMCE)) {
 204     Status = RegisterCpuFeature (
 205                "LMCE",
 206                NULL,
 207                LmceSupport,
 208                LmceInitialize,
 209                CPU_FEATURE_LMCE,
 210                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER | CPU_FEATURE_THREAD_BEFORE,
 211                CPU_FEATURE_END
 212                );
 213     ASSERT_EFI_ERROR (Status);
 214   }
 215   if (IsCpuFeatureSupported (CPU_FEATURE_PROC_TRACE)) {
 216     Status = RegisterCpuFeature (
 217                "Proc Trace",
 218                ProcTraceGetConfigData,
 219                ProcTraceSupport,
 220                ProcTraceInitialize,
 221                CPU_FEATURE_PROC_TRACE,
 222                CPU_FEATURE_END
 223                );
 224     ASSERT_EFI_ERROR (Status);
 225   }
 226
 227   return RETURN_SUCCESS;
 228 }
 229
 230
 231