DuetPkg/DataHubGenDxe/DataHubGen.c

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