Vlv2TbltDevicePkg/SmBiosMiscDxe/MiscProcessorInformationFunction.c

   1 /*++
   2
   3 Copyright (c) 2006  - 2014, Intel Corporation. All rights reserved.<BR>
   4
   5   This program and the accompanying materials are licensed and made available under
   6   the terms and conditions of the BSD License that accompanies this distribution.
   7   The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php.
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13
  14
  15 Module Name:
  16
  17   MiscProcessorInformationFunction.c
  18
  19 Abstract:
  20
  21   Onboard processor information boot time changes.
  22   SMBIOS type 4.
  23
  24 --*/
  25
  26 #include "CommonHeader.h"
  27
  28 #include "MiscSubclassDriver.h"
  29
  30 #include <Protocol/MpService.h>
  31 #include <Protocol/DataHub.h>
  32 #include <Guid/DataHubRecords.h>
  33 #include <Library/CpuIA32.h>
  34
  35 #define EfiProcessorFamilyIntelAtomProcessor    0x2B
  36
  37 EFI_GUID                        mProcessorProducerGuid;
  38
  39
  40 /**
  41   Get cache SMBIOS record handle.
  42
  43   @param  Smbios        Pointer to SMBIOS protocol instance.
  44   @param  CacheLevel    Level of cache, starting from one.
  45   @param  Handle        Returned record handle.
  46
  47 **/
  48
  49 VOID
  50 GetCacheHandle (
  51   IN  EFI_SMBIOS_PROTOCOL      *Smbios,
  52   IN  UINT8                    CacheLevel,
  53   OUT  EFI_SMBIOS_HANDLE       *Handle
  54   )
  55 {
  56   UINT16                     CacheConfig;
  57   EFI_STATUS                 Status;
  58   EFI_SMBIOS_TYPE            RecordType;
  59   EFI_SMBIOS_TABLE_HEADER    *Buffer;
  60
  61   *Handle = 0;
  62   RecordType = EFI_SMBIOS_TYPE_CACHE_INFORMATION;
  63
  64   do {
  65     Status = Smbios->GetNext (
  66                        Smbios,
  67                        Handle,
  68                        &RecordType,
  69                        &Buffer,
  70                        NULL
  71                        );
  72     if (!EFI_ERROR(Status)) {
  73       CacheConfig = *(UINT16*)((UINT8*)Buffer + 5);
  74       if ((CacheConfig & 0x7) == (CacheLevel -1) ) {
  75         return;
  76       }
  77     }
  78   } while (!EFI_ERROR(Status));
  79
  80   *Handle = 0xFFFF;
  81 }
  82
  83
  84 /**
  85   This function makes boot time changes to the contents of the
  86   MiscProcessorInformation (Type 4).
  87
  88   @param  RecordData                 Pointer to copy of RecordData from the Data Table.
  89
  90   @retval EFI_SUCCESS                All parameters were valid.
  91   @retval EFI_UNSUPPORTED            Unexpected RecordType value.
  92   @retval EFI_INVALID_PARAMETER      Invalid parameter was found.
  93
  94 **/
  95 UINT32
  96 ConvertBase10ToRaw (
  97   IN  EFI_EXP_BASE10_DATA             *Data)
  98 {
  99   UINTN         Index;
 100   UINT32        RawData;
 101
 102   RawData = Data->Value;
 103   for (Index = 0; Index < (UINTN) Data->Exponent; Index++) {
 104      RawData *= 10;
 105   }
 106
 107   return  RawData;
 108 }
 109
 110 #define BSEL_CR_OVERCLOCK_CONTROL       0xCD
 111 #define FUSE_BSEL_MASK                          0x03
 112
 113
 114
 115 UINT16 miFSBFrequencyTable[4] = {
 116   83,           // 83.3MHz
 117   100,          // 100MHz
 118   133,          // 133MHz
 119   117           // 116.7MHz
 120 };
 121
 122 /**
 123   Determine the processor core frequency
 124
 125   @param None
 126
 127   @retval Processor core frequency multiplied by 3
 128
 129
 130 **/
 131 UINT16
 132 DetermineiFsbFromMsr (
 133   VOID
 134   )
 135 {
 136   //
 137   // Determine the processor core frequency
 138   //
 139   UINT64        Temp;
 140   Temp = (EfiReadMsr (BSEL_CR_OVERCLOCK_CONTROL)) & FUSE_BSEL_MASK;
 141   return miFSBFrequencyTable[(UINT32)(Temp)];
 142
 143 }
 144
 145 MISC_SMBIOS_TABLE_FUNCTION (MiscProcessorInformation)
 146 {
 147     CHAR8                           *OptionalStrStart;
 148     EFI_STRING                      SerialNumber;
 149     CHAR16                          *Version=NULL;
 150     CHAR16                          *Manufacturer=NULL;
 151     CHAR16                          *Socket=NULL;
 152     CHAR16                          *AssetTag=NULL;
 153     CHAR16                          *PartNumber=NULL;
 154     UINTN                           SerialNumberStrLen=0;
 155     UINTN                           VersionStrLen=0;
 156     UINTN                           ManufacturerStrLen=0;
 157     UINTN                           SocketStrLen=0;
 158     UINTN                           AssetTagStrLen=0;
 159     UINTN                           PartNumberStrLen=0;
 160     UINTN                           ProcessorVoltage=0xAE;
 161     UINT32                          Eax01;
 162     UINT32                          Ebx01;
 163     UINT32                          Ecx01;
 164     UINT32                          Edx01;
 165     STRING_REF                      TokenToGet;
 166     EFI_STATUS                      Status;
 167     EFI_SMBIOS_HANDLE               SmbiosHandle;
 168     SMBIOS_TABLE_TYPE4              *SmbiosRecord;
 169     EFI_CPU_DATA_RECORD             *ForType4InputData;
 170     UINT16                          L1CacheHandle=0;
 171     UINT16                          L2CacheHandle=0;
 172     UINT16                          L3CacheHandle=0;
 173     UINTN                           NumberOfEnabledProcessors=0 ;
 174     UINTN                           NumberOfProcessors=0;
 175     UINT64                          Frequency = 0;
 176     EFI_MP_SERVICES_PROTOCOL        *MpService;
 177     EFI_DATA_HUB_PROTOCOL           *DataHub;
 178     UINT64                          MonotonicCount;
 179     EFI_DATA_RECORD_HEADER          *Record;
 180     EFI_SUBCLASS_TYPE1_HEADER       *DataHeader;
 181     UINT8                           *SrcData;
 182     UINT32                          SrcDataSize;
 183     EFI_PROCESSOR_VERSION_DATA      *ProcessorVersion;
 184     CHAR16                          *NewStringToken;
 185     STRING_REF                      TokenToUpdate;
 186     PROCESSOR_ID_DATA               *ProcessorId = NULL;
 187
 188
 189     //
 190     // First check for invalid parameters.
 191     //
 192     if (RecordData == NULL) {
 193         return EFI_INVALID_PARAMETER;
 194     }
 195
 196     ForType4InputData = (EFI_CPU_DATA_RECORD *)RecordData;
 197
 198     ProcessorId = AllocateZeroPool(sizeof(PROCESSOR_ID_DATA));
 199     if (ProcessorId == NULL) {
 200       return EFI_INVALID_PARAMETER;
 201     }
 202
 203     //
 204     // Get the Data Hub Protocol. Assume only one instance
 205     //
 206     Status = gBS->LocateProtocol (
 207                     &gEfiDataHubProtocolGuid,
 208                     NULL,
 209                     (VOID **)&DataHub
 210                     );
 211     ASSERT_EFI_ERROR(Status);
 212
 213     MonotonicCount = 0;
 214     Record = NULL;
 215
 216     do {
 217       Status = DataHub->GetNextRecord (
 218                           DataHub,
 219                           &MonotonicCount,
 220                           NULL,
 221                           &Record
 222                           );
 223        if (!EFI_ERROR(Status)) {
 224          if (Record->DataRecordClass == EFI_DATA_RECORD_CLASS_DATA) {
 225
 226             DataHeader  = (EFI_SUBCLASS_TYPE1_HEADER *)(Record + 1);
 227             SrcData     = (UINT8  *)(DataHeader + 1);
 228             SrcDataSize = Record->RecordSize - Record->HeaderSize - sizeof (EFI_SUBCLASS_TYPE1_HEADER);
 229
 230             //
 231             // Processor
 232             //
 233             if (CompareGuid(&Record->DataRecordGuid, &gEfiProcessorSubClassGuid)) {
 234               CopyMem (&mProcessorProducerGuid, &Record->ProducerName, sizeof(EFI_GUID));
 235               switch (DataHeader->RecordType) {
 236                 case ProcessorVoltageRecordType:
 237                   ProcessorVoltage = (((EFI_EXP_BASE10_DATA *)SrcData)->Value)/100 + 0x80;
 238                   break;
 239                 case ProcessorCoreFrequencyRecordType:
 240                   DEBUG ((EFI_D_ERROR, "ProcessorCoreFrequencyRecordType SrcData1 =%d\n", ConvertBase10ToRaw((EFI_EXP_BASE10_DATA *)SrcData)/1000000));
 241                   Frequency = (ConvertBase10ToRaw((EFI_EXP_BASE10_DATA *)SrcData)/1000000);
 242                   break;
 243                 case ProcessorVersionRecordType:
 244                   ProcessorVersion = (EFI_PROCESSOR_VERSION_DATA *)SrcData;
 245                   NewStringToken = HiiGetPackageString(&mProcessorProducerGuid, *ProcessorVersion, NULL);
 246                   TokenToUpdate = (STRING_REF)STR_MISC_PROCESSOR_VERSION;
 247                   HiiSetString(mHiiHandle, TokenToUpdate, NewStringToken, NULL);
 248                   break;
 249                 default:
 250                   break;
 251               }
 252             }
 253           }
 254         }
 255     } while (!EFI_ERROR(Status) && (MonotonicCount != 0));
 256
 257     //
 258     // Token to get for Socket Name
 259     //
 260     TokenToGet = STRING_TOKEN (STR_MISC_SOCKET_NAME);
 261     Socket = SmbiosMiscGetString (TokenToGet);
 262     SocketStrLen = StrLen(Socket);
 263     if (SocketStrLen > SMBIOS_STRING_MAX_LENGTH) {
 264          return EFI_UNSUPPORTED;
 265     }
 266
 267     //
 268     // Token to get for Processor Manufacturer
 269     //
 270     TokenToGet = STRING_TOKEN (STR_MISC_PROCESSOR_MAUFACTURER);
 271     Manufacturer = SmbiosMiscGetString (TokenToGet);
 272     ManufacturerStrLen = StrLen(Manufacturer);
 273     if (ManufacturerStrLen > SMBIOS_STRING_MAX_LENGTH) {
 274       return EFI_UNSUPPORTED;
 275     }
 276
 277     //
 278     // Token to get for Processor Version
 279     //
 280     TokenToGet = STRING_TOKEN (STR_MISC_PROCESSOR_VERSION);
 281     Version = SmbiosMiscGetString (TokenToGet);
 282     VersionStrLen = StrLen(Version);
 283     if (VersionStrLen > SMBIOS_STRING_MAX_LENGTH) {
 284         return EFI_UNSUPPORTED;
 285     }
 286
 287     //
 288     // Token to get for Serial Number
 289     //
 290     TokenToGet = STRING_TOKEN (STR_MISC_PROCESSOR_SERIAL_NUMBER);
 291     SerialNumber = SmbiosMiscGetString (TokenToGet);
 292     SerialNumberStrLen = StrLen(SerialNumber);
 293     if (SerialNumberStrLen > SMBIOS_STRING_MAX_LENGTH) {
 294         return EFI_UNSUPPORTED;
 295     }
 296
 297     //
 298     // Token to get for Assert Tag Information
 299     //
 300     TokenToGet = STRING_TOKEN (STR_MISC_ASSERT_TAG_DATA);
 301     AssetTag = SmbiosMiscGetString (TokenToGet);
 302     AssetTagStrLen = StrLen(AssetTag);
 303     if (AssetTagStrLen > SMBIOS_STRING_MAX_LENGTH) {
 304         return EFI_UNSUPPORTED;
 305     }
 306
 307     //
 308     // Token to get for part number Information
 309     //
 310     TokenToGet = STRING_TOKEN (STR_MISC_PART_NUMBER);
 311     PartNumber = SmbiosMiscGetString (TokenToGet);
 312     PartNumberStrLen = StrLen(PartNumber);
 313     if (PartNumberStrLen > SMBIOS_STRING_MAX_LENGTH) {
 314          return EFI_UNSUPPORTED;
 315     }
 316
 317     //
 318     // Two zeros following the last string.
 319     //
 320     SmbiosRecord = AllocateZeroPool(sizeof (SMBIOS_TABLE_TYPE4) + AssetTagStrLen + 1 + SocketStrLen + 1+ ManufacturerStrLen +1 + VersionStrLen+ 1+ SerialNumberStrLen + 1 + PartNumberStrLen+ 1 + 1);
 321
 322     SmbiosRecord->Hdr.Type = EFI_SMBIOS_TYPE_PROCESSOR_INFORMATION;
 323     SmbiosRecord->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE4);
 324
 325     //
 326     // Make handle chosen by smbios protocol.add automatically.
 327     //
 328     SmbiosRecord->Hdr.Handle = 0;
 329
 330     SmbiosRecord-> Socket= 1;
 331     SmbiosRecord -> ProcessorManufacture = 2;
 332     SmbiosRecord -> ProcessorVersion = 3;
 333     SmbiosRecord ->SerialNumber =4;
 334
 335     SmbiosRecord-> AssetTag= 5;
 336     SmbiosRecord-> PartNumber= 6;
 337
 338     //
 339     // Processor Type
 340     //
 341     ForType4InputData-> VariableRecord.ProcessorType= EfiCentralProcessor;
 342     SmbiosRecord -> ProcessorType = ForType4InputData-> VariableRecord.ProcessorType;
 343
 344     //
 345     // Processor Family
 346     //
 347     ForType4InputData-> VariableRecord.ProcessorFamily= EfiProcessorFamilyIntelAtomProcessor; //0x2B;;
 348     SmbiosRecord -> ProcessorFamily = ForType4InputData-> VariableRecord.ProcessorFamily;
 349     SmbiosRecord -> ExternalClock = DetermineiFsbFromMsr();
 350
 351     //
 352     // Processor ID
 353     //
 354     AsmCpuid(0x001, &Eax01, &Ebx01, &Ecx01, &Edx01);
 355     ProcessorId->Signature = *(PROCESSOR_SIGNATURE *)&Eax01;
 356     ProcessorId->FeatureFlags = *(PROCESSOR_FEATURE_FLAGS *)&Edx01;
 357     SmbiosRecord -> ProcessorId = *(PROCESSOR_ID_DATA *)ProcessorId;
 358
 359     //
 360     // Processor Voltage
 361     //
 362     ForType4InputData-> VariableRecord.ProcessorVoltage= *(EFI_PROCESSOR_VOLTAGE_DATA *)&ProcessorVoltage;
 363     SmbiosRecord -> Voltage = *(PROCESSOR_VOLTAGE *) &(ForType4InputData-> VariableRecord.ProcessorVoltage);
 364
 365     //
 366     // Status
 367     //
 368     ForType4InputData-> VariableRecord.ProcessorHealthStatus= 0x41;//0x41;
 369     SmbiosRecord -> Status = ForType4InputData-> VariableRecord.ProcessorHealthStatus;
 370
 371     //
 372     // Processor Upgrade
 373     //
 374     SmbiosRecord -> ProcessorUpgrade = 0x008;
 375
 376     //
 377     // Processor Family 2
 378     //
 379     SmbiosRecord -> ProcessorFamily2 = ForType4InputData-> VariableRecord.ProcessorFamily;
 380
 381     //
 382     // Processor speed
 383     //
 384     SmbiosRecord-> CurrentSpeed = *(UINT16*) & Frequency;
 385     SmbiosRecord-> MaxSpeed = *(UINT16*) & Frequency;
 386
 387     //
 388     // Processor Characteristics
 389     //
 390     AsmCpuid(0x8000000, NULL, NULL, NULL, &Edx01);
 391     Edx01= Edx01 >> 28;
 392     Edx01 &= 0x01;
 393     SmbiosRecord-> ProcessorCharacteristics= (UINT16)Edx01;
 394
 395     //
 396     // Processor Core Count and Enabled core count
 397     //
 398     Status = gBS->LocateProtocol (
 399                     &gEfiMpServiceProtocolGuid,
 400                     NULL,
 401                     (void **)&MpService
 402                     );
 403     if (!EFI_ERROR (Status)) {
 404     //
 405     // Determine the number of processors
 406     //
 407     MpService->GetNumberOfProcessors (
 408                  MpService,
 409                  &NumberOfProcessors,
 410                  &NumberOfEnabledProcessors
 411                  );
 412     }
 413     SmbiosRecord-> CoreCount= (UINT8)NumberOfProcessors;
 414     SmbiosRecord-> EnabledCoreCount= (UINT8)NumberOfEnabledProcessors;
 415     SmbiosRecord-> ThreadCount= (UINT8)NumberOfEnabledProcessors;
 416     SmbiosRecord-> ProcessorCharacteristics = 0x2; // Unknown
 417
 418     //
 419     // Processor Cache Handle
 420     //
 421     GetCacheHandle( Smbios,1, &L1CacheHandle);
 422     GetCacheHandle( Smbios,2, &L2CacheHandle);
 423     GetCacheHandle( Smbios,3, &L3CacheHandle);
 424
 425     //
 426     // Updating Cache Handle Information
 427     //
 428     SmbiosRecord->L1CacheHandle  = L1CacheHandle;
 429     SmbiosRecord->L2CacheHandle  = L2CacheHandle;
 430     SmbiosRecord->L3CacheHandle  = L3CacheHandle;
 431
 432     OptionalStrStart = (CHAR8 *)(SmbiosRecord + 1);
 433     UnicodeStrToAsciiStr(Socket, OptionalStrStart);
 434     UnicodeStrToAsciiStr(Manufacturer, OptionalStrStart + SocketStrLen + 1);
 435     UnicodeStrToAsciiStr(Version, OptionalStrStart + SocketStrLen + 1 + ManufacturerStrLen+ 1);
 436     UnicodeStrToAsciiStr(SerialNumber, OptionalStrStart + SocketStrLen + 1 + VersionStrLen + 1 + ManufacturerStrLen + 1);
 437     UnicodeStrToAsciiStr(AssetTag, OptionalStrStart + SerialNumberStrLen + 1 + VersionStrLen + 1 + ManufacturerStrLen + 1 + SocketStrLen + 1);
 438     UnicodeStrToAsciiStr(PartNumber, OptionalStrStart + SerialNumberStrLen + 1 + VersionStrLen + 1 + ManufacturerStrLen + 1 + SocketStrLen + 1 + AssetTagStrLen + 1 );
 439
 440     //
 441     // Now we have got the full Smbios record, call Smbios protocol to add this record.
 442     //
 443     SmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
 444     Status = Smbios-> Add(
 445                         Smbios,
 446                         NULL,
 447                         &SmbiosHandle,
 448                         (EFI_SMBIOS_TABLE_HEADER *) SmbiosRecord
 449                         );
 450     if (EFI_ERROR (Status)) return Status;
 451     FreePool(SmbiosRecord);
 452     return Status;
 453
 454 }
 455