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
  37   if (IsCpuFeatureSupported (CPU_FEATURE_MWAIT)) {
  38     Status = RegisterCpuFeature (
  39                "MWAIT",
  40                NULL,
  41                MonitorMwaitSupport,
  42                MonitorMwaitInitialize,
  43                CPU_FEATURE_MWAIT,
  44                CPU_FEATURE_END
  45                );
  46     ASSERT_EFI_ERROR (Status);
  47   }
  48
  49   if (IsCpuFeatureSupported (CPU_FEATURE_ACPI)) {
  50     Status = RegisterCpuFeature (
  51                "ACPI",
  52                ClockModulationGetConfigData,
  53                ClockModulationSupport,
  54                ClockModulationInitialize,
  55                CPU_FEATURE_ACPI,
  56                CPU_FEATURE_END
  57                );
  58     ASSERT_EFI_ERROR (Status);
  59   }
  60
  61   if (IsCpuFeatureSupported (CPU_FEATURE_EIST)) {
  62     Status = RegisterCpuFeature (
  63                "EIST",
  64                NULL,
  65                EistSupport,
  66                EistInitialize,
  67                CPU_FEATURE_EIST,
  68                CPU_FEATURE_END
  69                );
  70     ASSERT_EFI_ERROR (Status);
  71   }
  72
  73   if (IsCpuFeatureSupported (CPU_FEATURE_FASTSTRINGS)) {
  74     Status = RegisterCpuFeature (
  75                "FastStrings",
  76                NULL,
  77                NULL,
  78                FastStringsInitialize,
  79                CPU_FEATURE_FASTSTRINGS,
  80                CPU_FEATURE_END
  81                );
  82     ASSERT_EFI_ERROR (Status);
  83   }
  84
  85   if (IsCpuFeatureSupported (CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER)) {
  86     Status = RegisterCpuFeature (
  87                "Lock Feature Control Register",
  88                NULL,
  89                LockFeatureControlRegisterSupport,
  90                LockFeatureControlRegisterInitialize,
  91                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER,
  92                CPU_FEATURE_END
  93                );
  94     ASSERT_EFI_ERROR (Status);
  95   }
  96
  97   if (IsCpuFeatureSupported (CPU_FEATURE_SMX)) {
  98     Status = RegisterCpuFeature (
  99                "SMX",
 100                NULL,
 101                SmxSupport,
 102                SmxInitialize,
 103                CPU_FEATURE_SMX,
 104                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER | CPU_FEATURE_THREAD_BEFORE,
 105                CPU_FEATURE_END
 106                );
 107     ASSERT_EFI_ERROR (Status);
 108   }
 109
 110   if (IsCpuFeatureSupported (CPU_FEATURE_VMX)) {
 111     Status = RegisterCpuFeature (
 112                "VMX",
 113                NULL,
 114                VmxSupport,
 115                VmxInitialize,
 116                CPU_FEATURE_VMX,
 117                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER | CPU_FEATURE_THREAD_BEFORE,
 118                CPU_FEATURE_END
 119                );
 120     ASSERT_EFI_ERROR (Status);
 121   }
 122
 123   if (IsCpuFeatureSupported (CPU_FEATURE_LIMIT_CPUID_MAX_VAL)) {
 124     Status = RegisterCpuFeature (
 125                "Limit CpuId Maximum Value",
 126                NULL,
 127                LimitCpuidMaxvalSupport,
 128                LimitCpuidMaxvalInitialize,
 129                CPU_FEATURE_LIMIT_CPUID_MAX_VAL,
 130                CPU_FEATURE_END
 131                );
 132     ASSERT_EFI_ERROR (Status);
 133   }
 134
 135   if (IsCpuFeatureSupported (CPU_FEATURE_MCE)) {
 136     Status = RegisterCpuFeature (
 137                "Machine Check Enable",
 138                NULL,
 139                MceSupport,
 140                MceInitialize,
 141                CPU_FEATURE_MCE,
 142                CPU_FEATURE_END
 143                );
 144     ASSERT_EFI_ERROR (Status);
 145   }
 146
 147   if (IsCpuFeatureSupported (CPU_FEATURE_MCA)) {
 148     Status = RegisterCpuFeature (
 149                "Machine Check Architect",
 150                NULL,
 151                McaSupport,
 152                McaInitialize,
 153                CPU_FEATURE_MCA,
 154                CPU_FEATURE_END
 155                );
 156     ASSERT_EFI_ERROR (Status);
 157   }
 158
 159   if (IsCpuFeatureSupported (CPU_FEATURE_MCG_CTL)) {
 160     Status = RegisterCpuFeature (
 161                "MCG_CTL",
 162                NULL,
 163                McgCtlSupport,
 164                McgCtlInitialize,
 165                CPU_FEATURE_MCG_CTL,
 166                CPU_FEATURE_END
 167                );
 168     ASSERT_EFI_ERROR (Status);
 169   }
 170
 171   if (IsCpuFeatureSupported (CPU_FEATURE_PENDING_BREAK)) {
 172     Status = RegisterCpuFeature (
 173                "Pending Break",
 174                NULL,
 175                PendingBreakSupport,
 176                PendingBreakInitialize,
 177                CPU_FEATURE_PENDING_BREAK,
 178                CPU_FEATURE_END
 179                );
 180     ASSERT_EFI_ERROR (Status);
 181   }
 182
 183   if (IsCpuFeatureSupported (CPU_FEATURE_C1E)) {
 184     Status = RegisterCpuFeature (
 185                "C1E",
 186                NULL,
 187                C1eSupport,
 188                C1eInitialize,
 189                CPU_FEATURE_C1E,
 190                CPU_FEATURE_END
 191                );
 192     ASSERT_EFI_ERROR (Status);
 193   }
 194
 195   if (IsCpuFeatureSupported (CPU_FEATURE_X2APIC)) {
 196     Status = RegisterCpuFeature (
 197                "X2Apic",
 198                X2ApicGetConfigData,
 199                X2ApicSupport,
 200                X2ApicInitialize,
 201                CPU_FEATURE_X2APIC,
 202                CPU_FEATURE_END
 203                );
 204     ASSERT_EFI_ERROR (Status);
 205   }
 206
 207   if (IsCpuFeatureSupported (CPU_FEATURE_PPIN)) {
 208     Status = RegisterCpuFeature (
 209                "PPIN",
 210                PpinGetConfigData,
 211                PpinSupport,
 212                PpinInitialize,
 213                CPU_FEATURE_PPIN,
 214                CPU_FEATURE_END
 215                );
 216     ASSERT_EFI_ERROR (Status);
 217   }
 218
 219   if (IsCpuFeatureSupported (CPU_FEATURE_LMCE)) {
 220     Status = RegisterCpuFeature (
 221                "LMCE",
 222                NULL,
 223                LmceSupport,
 224                LmceInitialize,
 225                CPU_FEATURE_LMCE,
 226                CPU_FEATURE_LOCK_FEATURE_CONTROL_REGISTER | CPU_FEATURE_THREAD_BEFORE,
 227                CPU_FEATURE_END
 228                );
 229     ASSERT_EFI_ERROR (Status);
 230   }
 231
 232   if (IsCpuFeatureSupported (CPU_FEATURE_PROC_TRACE)) {
 233     Status = RegisterCpuFeature (
 234                "Proc Trace",
 235                ProcTraceGetConfigData,
 236                ProcTraceSupport,
 237                ProcTraceInitialize,
 238                CPU_FEATURE_PROC_TRACE,
 239                CPU_FEATURE_END
 240                );
 241     ASSERT_EFI_ERROR (Status);
 242   }
 243
 244   return RETURN_SUCCESS;
 245 }