DuetPkg/DataHubGenDxe/DataHubGen.c

   1 /** @file
   2
   3 Copyright (c) 2006 - 2010, Intel Corporation
   4 All rights reserved. This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   DataHubGen.c
  15
  16 Abstract:
  17
  18 **/
  19
  20 #include "DataHubGen.h"
  21 EFI_HII_DATABASE_PROTOCOL        *gHiiDatabase;
  22
  23 extern UINT8                DataHubGenDxeStrings[];
  24
  25 EFI_DATA_HUB_PROTOCOL       *gDataHub;
  26 EFI_HII_HANDLE              gStringHandle;
  27
  28 VOID *
  29 GetSmbiosTablesFromHob (
  30   VOID
  31   )
  32 {
  33   EFI_PHYSICAL_ADDRESS       *Table;
  34   EFI_PEI_HOB_POINTERS        GuidHob;
  35   //
  36   // Get Hob List
  37   //
  38   GuidHob.Raw = GetFirstGuidHob (&gEfiSmbiosTableGuid);
  39   if (GuidHob.Raw != NULL) {
  40     Table = GET_GUID_HOB_DATA (GuidHob.Guid);
  41     if (Table != NULL) {
  42       return (VOID *)(UINTN)*Table;
  43     }
  44   }
  45
  46   return NULL;
  47 }
  48
  49 EFI_SUBCLASS_TYPE1_HEADER mCpuDataRecordHeader = {
  50   EFI_PROCESSOR_SUBCLASS_VERSION,       // Version
  51   sizeof (EFI_SUBCLASS_TYPE1_HEADER),   // Header Size
  52   0,                                    // Instance, Initialize later
  53   EFI_SUBCLASS_INSTANCE_NON_APPLICABLE, // SubInstance
  54   0                                     // RecordType, Initialize later
  55 };
  56
  57 VOID
  58 InstallProcessorDataHub (
  59   IN VOID                  *Smbios
  60   )
  61 {
  62   EFI_STATUS                        Status;
  63   SMBIOS_STRUCTURE_POINTER          SmbiosTable;
  64   EFI_CPU_DATA_RECORD               DataRecord;
  65   CHAR8                             *AString;
  66   CHAR16                            *UString;
  67   STRING_REF                        Token;
  68
  69   //
  70   // Processor info (TYPE 4)
  71   //
  72   SmbiosTable = GetSmbiosTableFromType ((SMBIOS_TABLE_ENTRY_POINT *)Smbios, 4, 0);
  73   if (SmbiosTable.Raw == NULL) {
  74     DEBUG ((EFI_D_ERROR, "SmbiosTable: Type 4 (Processor Info) not found!\n"));
  75     return ;
  76   }
  77
  78   //
  79   // Record Header
  80   //
  81   CopyMem (&DataRecord, &mCpuDataRecordHeader, sizeof (DataRecord.DataRecordHeader));
  82
  83   //
  84   // Record Type 1
  85   //
  86   DataRecord.DataRecordHeader.RecordType = ProcessorCoreFrequencyRecordType;
  87   DataRecord.VariableRecord.ProcessorCoreFrequency.Value = SmbiosTable.Type4->CurrentSpeed;
  88   DataRecord.VariableRecord.ProcessorCoreFrequency.Exponent = 6;
  89
  90   Status = gDataHub->LogData (
  91                        gDataHub,
  92                        &gEfiProcessorSubClassGuid,
  93                        &gEfiCallerIdGuid,
  94                        EFI_DATA_RECORD_CLASS_DATA,
  95                        &DataRecord,
  96                        sizeof (DataRecord.DataRecordHeader) + sizeof (DataRecord.VariableRecord.ProcessorCoreFrequency)
  97                        );
  98   ASSERT_EFI_ERROR (Status);
  99   //
 100   // Record Type 3
 101   //
 102   AString = GetSmbiosString (SmbiosTable, SmbiosTable.Type4->ProcessorVersion);
 103   UString = AllocateZeroPool ((AsciiStrLen(AString) + 1) * sizeof(CHAR16));
 104   ASSERT (UString != NULL);
 105   AsciiStrToUnicodeStr (AString, UString);
 106
 107   Token = HiiSetString (gStringHandle, 0, UString, NULL);
 108   if (Token == 0) {
 109     gBS->FreePool (UString);
 110     return ;
 111   }
 112   gBS->FreePool (UString);
 113
 114   DataRecord.DataRecordHeader.RecordType = ProcessorVersionRecordType;
 115   DataRecord.VariableRecord.ProcessorVersion  = Token;
 116
 117   Status = gDataHub->LogData (
 118                        gDataHub,
 119                        &gEfiProcessorSubClassGuid,
 120                        &gEfiCallerIdGuid,
 121                        EFI_DATA_RECORD_CLASS_DATA,
 122                        &DataRecord,
 123                        sizeof (DataRecord.DataRecordHeader) + sizeof (DataRecord.VariableRecord.ProcessorVersion)
 124                        );
 125   ASSERT_EFI_ERROR (Status);
 126   return ;
 127 }
 128
 129 VOID
 130 InstallCacheDataHub (
 131   IN VOID                  *Smbios
 132   )
 133 {
 134   return ;
 135 }
 136
 137 EFI_SUBCLASS_TYPE1_HEADER mMemorySubclassDriverDataHeader = {
 138   EFI_MEMORY_SUBCLASS_VERSION,          // Version
 139   sizeof (EFI_SUBCLASS_TYPE1_HEADER),   // Header Size
 140   0,                                    // Instance, Initialize later
 141   EFI_SUBCLASS_INSTANCE_NON_APPLICABLE, // SubInstance
 142   0                                     // RecordType, Initialize later
 143 };
 144
 145 VOID
 146 InstallMemoryDataHub (
 147   IN VOID                  *Smbios
 148   )
 149 {
 150   SMBIOS_STRUCTURE_POINTER          SmbiosTable;
 151   EFI_MEMORY_SUBCLASS_DRIVER_DATA   DataRecord;
 152
 153   //
 154   // Generate Memory Array Mapped Address info (TYPE 19)
 155   //
 156   SmbiosTable = GetSmbiosTableFromType ((SMBIOS_TABLE_ENTRY_POINT *)Smbios, 19, 0);
 157   if (SmbiosTable.Raw == NULL) {
 158     DEBUG ((EFI_D_ERROR, "SmbiosTable: Type 19 (Memory Array Mapped Address Info) not found!\n"));
 159     return ;
 160   }
 161
 162   //
 163   // Record Header
 164   //
 165   CopyMem (&DataRecord, &mMemorySubclassDriverDataHeader, sizeof (DataRecord.Header));
 166
 167   //
 168   // Record Type 4
 169   //
 170   DataRecord.Header.RecordType = EFI_MEMORY_ARRAY_START_ADDRESS_RECORD_NUMBER;
 171   DataRecord.Record.ArrayStartAddress.MemoryArrayStartAddress = LShiftU64(SmbiosTable.Type19->StartingAddress, 10);
 172   DataRecord.Record.ArrayStartAddress.MemoryArrayEndAddress = LShiftU64((UINT64) SmbiosTable.Type19->EndingAddress + 1, 10) - 1;
 173
 174   CopyGuid (&DataRecord.Record.ArrayStartAddress.PhysicalMemoryArrayLink.ProducerName, &gEfiCallerIdGuid);
 175   DataRecord.Record.ArrayStartAddress.PhysicalMemoryArrayLink.Instance = 0;
 176   DataRecord.Record.ArrayStartAddress.PhysicalMemoryArrayLink.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
 177   DataRecord.Record.ArrayStartAddress.MemoryArrayPartitionWidth = (UINT16)(SmbiosTable.Type19->PartitionWidth);
 178
 179   gDataHub->LogData (
 180                        gDataHub,
 181                        &gEfiMemorySubClassGuid,
 182                        &gEfiCallerIdGuid,
 183                        EFI_DATA_RECORD_CLASS_DATA,
 184                        &DataRecord,
 185                        sizeof (DataRecord.Header) + sizeof (DataRecord.Record.ArrayStartAddress)
 186                        );
 187
 188   return ;
 189 }
 190
 191 EFI_SUBCLASS_TYPE1_HEADER mMiscSubclassDriverDataHeader = {
 192   EFI_MISC_SUBCLASS_VERSION,            // Version
 193   sizeof (EFI_SUBCLASS_TYPE1_HEADER),   // Header Size
 194   0,                                    // Instance, Initialize later
 195   EFI_SUBCLASS_INSTANCE_NON_APPLICABLE, // SubInstance
 196   0                                     // RecordType, Initialize later
 197 };
 198
 199 VOID
 200 InstallMiscDataHub (
 201   IN VOID                  *Smbios
 202   )
 203 {
 204   EFI_STATUS                        Status;
 205   SMBIOS_STRUCTURE_POINTER          SmbiosTable;
 206   EFI_MISC_SUBCLASS_DRIVER_DATA     DataRecord;
 207   CHAR8                             *AString;
 208   CHAR16                            *UString;
 209   STRING_REF                        Token;
 210
 211   //
 212   // BIOS information (TYPE 0)
 213   //
 214   SmbiosTable = GetSmbiosTableFromType ((SMBIOS_TABLE_ENTRY_POINT *)Smbios, 0, 0);
 215   if (SmbiosTable.Raw == NULL) {
 216     DEBUG ((EFI_D_ERROR, "SmbiosTable: Type 0 (BIOS Information) not found!\n"));
 217     return ;
 218   }
 219
 220   //
 221   // Record Header
 222   //
 223   CopyMem (&DataRecord, &mMiscSubclassDriverDataHeader, sizeof (DataRecord.Header));
 224
 225   //
 226   // Record Type 2
 227   //
 228   AString = GetSmbiosString (SmbiosTable, SmbiosTable.Type0->BiosVersion);
 229   UString = AllocateZeroPool ((AsciiStrLen(AString) + 1) * sizeof(CHAR16) + sizeof(FIRMWARE_BIOS_VERSIONE));
 230   ASSERT (UString != NULL);
 231   CopyMem (UString, FIRMWARE_BIOS_VERSIONE, sizeof(FIRMWARE_BIOS_VERSIONE));
 232   AsciiStrToUnicodeStr (AString, UString + sizeof(FIRMWARE_BIOS_VERSIONE) / sizeof(CHAR16) - 1);
 233
 234   Token = HiiSetString (gStringHandle, 0, UString, NULL);
 235   if (Token == 0) {
 236     gBS->FreePool (UString);
 237     return ;
 238   }
 239   gBS->FreePool (UString);
 240
 241   DataRecord.Header.RecordType = EFI_MISC_BIOS_VENDOR_RECORD_NUMBER;
 242   DataRecord.Record.MiscBiosVendor.BiosVendor  = 0;
 243   DataRecord.Record.MiscBiosVendor.BiosVersion = Token;
 244   DataRecord.Record.MiscBiosVendor.BiosReleaseDate  = 0;
 245   DataRecord.Record.MiscBiosVendor.BiosStartingAddress  = 0;
 246   DataRecord.Record.MiscBiosVendor.BiosPhysicalDeviceSize.Value  = 0;
 247   DataRecord.Record.MiscBiosVendor.BiosPhysicalDeviceSize.Exponent  = 0;
 248 //  DataRecord.Record.MiscBiosVendor.BiosCharacteristics1  = {0};
 249 //  DataRecord.Record.MiscBiosVendor.BiosCharacteristics2  = {0};
 250   DataRecord.Record.MiscBiosVendor.BiosMajorRelease  = 0;
 251   DataRecord.Record.MiscBiosVendor.BiosMinorRelease  = 0;
 252   DataRecord.Record.MiscBiosVendor.BiosEmbeddedFirmwareMajorRelease  = 0;
 253   DataRecord.Record.MiscBiosVendor.BiosEmbeddedFirmwareMinorRelease  = 0;
 254
 255   Status = gDataHub->LogData (
 256                        gDataHub,
 257                        &gEfiMiscSubClassGuid,
 258                        &gEfiCallerIdGuid,
 259                        EFI_DATA_RECORD_CLASS_DATA,
 260                        &DataRecord,
 261                        sizeof (DataRecord.Header) + sizeof (DataRecord.Record.MiscBiosVendor)
 262                        );
 263   ASSERT_EFI_ERROR (Status);
 264
 265   //
 266   // System information (TYPE 1)
 267   //
 268   SmbiosTable = GetSmbiosTableFromType ((SMBIOS_TABLE_ENTRY_POINT *)Smbios, 1, 0);
 269   if (SmbiosTable.Raw == NULL) {
 270     DEBUG ((EFI_D_ERROR, "SmbiosTable: Type 1 (System Information) not found!\n"));
 271     return ;
 272   }
 273
 274   //
 275   // Record Type 3
 276   //
 277   AString = GetSmbiosString (SmbiosTable, SmbiosTable.Type1->ProductName);
 278   UString = AllocateZeroPool ((AsciiStrLen(AString) + 1) * sizeof(CHAR16) + sizeof(FIRMWARE_PRODUCT_NAME));
 279   ASSERT (UString != NULL);
 280   CopyMem (UString, FIRMWARE_PRODUCT_NAME, sizeof(FIRMWARE_PRODUCT_NAME));
 281   AsciiStrToUnicodeStr (AString, UString + sizeof(FIRMWARE_PRODUCT_NAME) / sizeof(CHAR16) - 1);
 282
 283   Token = HiiSetString (gStringHandle, 0, UString, NULL);
 284   if (Token == 0) {
 285     gBS->FreePool (UString);
 286     return ;
 287   }
 288   gBS->FreePool (UString);
 289
 290   DataRecord.Header.RecordType = EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER;
 291   DataRecord.Record.MiscSystemManufacturer.SystemManufacturer  = 0;
 292   DataRecord.Record.MiscSystemManufacturer.SystemProductName = Token;
 293   DataRecord.Record.MiscSystemManufacturer.SystemVersion  = 0;
 294   DataRecord.Record.MiscSystemManufacturer.SystemSerialNumber  = 0;
 295 //  DataRecord.Record.MiscSystemManufacturer.SystemUuid  = {0};
 296   DataRecord.Record.MiscSystemManufacturer.SystemWakeupType  = EfiSystemWakeupTypeReserved;
 297   DataRecord.Record.MiscSystemManufacturer.SystemSKUNumber  = 0;
 298   DataRecord.Record.MiscSystemManufacturer.SystemFamily  = 0;
 299
 300   Status = gDataHub->LogData (
 301                        gDataHub,
 302                        &gEfiMiscSubClassGuid,
 303                        &gEfiCallerIdGuid,
 304                        EFI_DATA_RECORD_CLASS_DATA,
 305                        &DataRecord,
 306                        sizeof (DataRecord.Header) + sizeof (DataRecord.Record.MiscSystemManufacturer)
 307                        );
 308   ASSERT_EFI_ERROR (Status);
 309
 310   return ;
 311 }
 312
 313 EFI_STATUS
 314 EFIAPI
 315 DataHubGenEntrypoint (
 316   IN EFI_HANDLE           ImageHandle,
 317   IN EFI_SYSTEM_TABLE     *SystemTable
 318   )
 319 {
 320   EFI_STATUS              Status;
 321   VOID                    *Smbios;
 322
 323   Smbios = GetSmbiosTablesFromHob ();
 324   if (Smbios == NULL) {
 325     return EFI_NOT_FOUND;
 326   }
 327
 328   Status = gBS->LocateProtocol (
 329                   &gEfiDataHubProtocolGuid,
 330                   NULL,
 331                   (VOID**)&gDataHub
 332                   );
 333   if (EFI_ERROR (Status)) {
 334     return Status;
 335   }
 336
 337   Status = gBS->LocateProtocol (
 338                   &gEfiHiiDatabaseProtocolGuid,
 339                   NULL,
 340                   (VOID**)&gHiiDatabase
 341                   );
 342
 343   if (EFI_ERROR (Status)) {
 344     return Status;
 345   }
 346
 347   gStringHandle = HiiAddPackages (
 348                     &gEfiCallerIdGuid,
 349                     NULL,
 350                     DataHubGenDxeStrings,
 351                     NULL
 352                     );
 353   ASSERT (gStringHandle != NULL);
 354
 355   InstallProcessorDataHub (Smbios);
 356   InstallCacheDataHub     (Smbios);
 357   InstallMemoryDataHub    (Smbios);
 358   InstallMiscDataHub      (Smbios);
 359
 360   return EFI_SUCCESS;
 361 }
 362
 363 //
 364 // Internal function
 365 //
 366
 367 UINTN
 368 SmbiosTableLength (
 369   IN SMBIOS_STRUCTURE_POINTER SmbiosTable
 370   )
 371 {
 372   CHAR8  *AChar;
 373   UINTN  Length;
 374
 375   AChar = (CHAR8 *)(SmbiosTable.Raw + SmbiosTable.Hdr->Length);
 376   while ((*AChar != 0) || (*(AChar + 1) != 0)) {
 377     AChar ++;
 378   }
 379   Length = ((UINTN)AChar - (UINTN)SmbiosTable.Raw + 2);
 380
 381   return Length;
 382 }
 383
 384 SMBIOS_STRUCTURE_POINTER
 385 GetSmbiosTableFromType (
 386   IN SMBIOS_TABLE_ENTRY_POINT  *Smbios,
 387   IN UINT8                     Type,
 388   IN UINTN                     Index
 389   )
 390 {
 391   SMBIOS_STRUCTURE_POINTER SmbiosTable;
 392   UINTN                    SmbiosTypeIndex;
 393
 394   SmbiosTypeIndex = 0;
 395   SmbiosTable.Raw = (UINT8 *)(UINTN)Smbios->TableAddress;
 396   if (SmbiosTable.Raw == NULL) {
 397     return SmbiosTable;
 398   }
 399   while ((SmbiosTypeIndex != Index) || (SmbiosTable.Hdr->Type != Type)) {
 400     if (SmbiosTable.Hdr->Type == 127) {
 401       SmbiosTable.Raw = NULL;
 402       return SmbiosTable;
 403     }
 404     if (SmbiosTable.Hdr->Type == Type) {
 405       SmbiosTypeIndex ++;
 406     }
 407     SmbiosTable.Raw = (UINT8 *)(SmbiosTable.Raw + SmbiosTableLength (SmbiosTable));
 408   }
 409
 410   return SmbiosTable;
 411 }
 412
 413 CHAR8 *
 414 GetSmbiosString (
 415   IN SMBIOS_STRUCTURE_POINTER  SmbiosTable,
 416   IN SMBIOS_TABLE_STRING       String
 417   )
 418 {
 419   CHAR8      *AString;
 420   UINT8      Index;
 421
 422   Index = 1;
 423   AString = (CHAR8 *)(SmbiosTable.Raw + SmbiosTable.Hdr->Length);
 424   while (Index != String) {
 425     while (*AString != 0) {
 426       AString ++;
 427     }
 428     AString ++;
 429     if (*AString == 0) {
 430       return AString;
 431     }
 432     Index ++;
 433   }
 434
 435   return AString;
 436 }