DuetPkg/DataHubGenDxe/DataHubGen.c

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