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   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                        &gEfiMiscProducerGuid,
 121                        EFI_DATA_RECORD_CLASS_DATA,
 122                        &DataRecord,
 123                        sizeof (DataRecord.DataRecordHeader) + sizeof (DataRecord.VariableRecord.ProcessorVersion)
 124                        );
 125
 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, &gEfiMemoryProducerGuid);
 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                        &gEfiMiscProducerGuid,
 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                        &gEfiMiscProducerGuid,
 259                        EFI_DATA_RECORD_CLASS_DATA,
 260                        &DataRecord,
 261                        sizeof (DataRecord.Header) + sizeof (DataRecord.Record.MiscBiosVendor)
 262                        );
 263
 264   //
 265   // System information (TYPE 1)
 266   //
 267   SmbiosTable = GetSmbiosTableFromType ((SMBIOS_TABLE_ENTRY_POINT *)Smbios, 1, 0);
 268   if (SmbiosTable.Raw == NULL) {
 269     DEBUG ((EFI_D_ERROR, "SmbiosTable: Type 1 (System Information) not found!\n"));
 270     return ;
 271   }
 272
 273   //
 274   // Record Type 3
 275   //
 276   AString = GetSmbiosString (SmbiosTable, SmbiosTable.Type1->ProductName);
 277   UString = AllocateZeroPool ((AsciiStrLen(AString) + 1) * sizeof(CHAR16) + sizeof(FIRMWARE_PRODUCT_NAME));
 278   ASSERT (UString != NULL);
 279   CopyMem (UString, FIRMWARE_PRODUCT_NAME, sizeof(FIRMWARE_PRODUCT_NAME));
 280   AsciiStrToUnicodeStr (AString, UString + sizeof(FIRMWARE_PRODUCT_NAME) / sizeof(CHAR16) - 1);
 281
 282   Token = HiiSetString (gStringHandle, 0, UString, NULL);
 283   if (Token == 0) {
 284     gBS->FreePool (UString);
 285     return ;
 286   }
 287   gBS->FreePool (UString);
 288
 289   DataRecord.Header.RecordType = EFI_MISC_SYSTEM_MANUFACTURER_RECORD_NUMBER;
 290   DataRecord.Record.MiscSystemManufacturer.SystemManufacturer  = 0;
 291   DataRecord.Record.MiscSystemManufacturer.SystemProductName = Token;
 292   DataRecord.Record.MiscSystemManufacturer.SystemVersion  = 0;
 293   DataRecord.Record.MiscSystemManufacturer.SystemSerialNumber  = 0;
 294 //  DataRecord.Record.MiscSystemManufacturer.SystemUuid  = {0};
 295   DataRecord.Record.MiscSystemManufacturer.SystemWakeupType  = EfiSystemWakeupTypeReserved;
 296   DataRecord.Record.MiscSystemManufacturer.SystemSKUNumber  = 0;
 297   DataRecord.Record.MiscSystemManufacturer.SystemFamily  = 0;
 298
 299   Status = gDataHub->LogData (
 300                        gDataHub,
 301                        &gEfiMiscSubClassGuid,
 302                        &gEfiMiscProducerGuid,
 303                        EFI_DATA_RECORD_CLASS_DATA,
 304                        &DataRecord,
 305                        sizeof (DataRecord.Header) + sizeof (DataRecord.Record.MiscSystemManufacturer)
 306                        );
 307
 308   return ;
 309 }
 310
 311 EFI_STATUS
 312 EFIAPI
 313 DataHubGenEntrypoint (
 314   IN EFI_HANDLE           ImageHandle,
 315   IN EFI_SYSTEM_TABLE     *SystemTable
 316   )
 317 {
 318   EFI_STATUS              Status;
 319   VOID                    *Smbios;
 320
 321   Smbios = GetSmbiosTablesFromHob ();
 322   if (Smbios == NULL) {
 323     return EFI_NOT_FOUND;
 324   }
 325
 326   Status = gBS->LocateProtocol (
 327                   &gEfiDataHubProtocolGuid,
 328                   NULL,
 329                   (VOID**)&gDataHub
 330                   );
 331   if (EFI_ERROR (Status)) {
 332     return Status;
 333   }
 334
 335   Status = gBS->LocateProtocol (
 336                   &gEfiHiiDatabaseProtocolGuid,
 337                   NULL,
 338                   (VOID**)&gHiiDatabase
 339                   );
 340
 341   if (EFI_ERROR (Status)) {
 342     return Status;
 343   }
 344
 345   gStringHandle = HiiAddPackages (
 346                     &gEfiMiscProducerGuid,
 347                     NULL,
 348                     DataHubGenDxeStrings,
 349                     NULL
 350                     );
 351   ASSERT (gStringHandle != NULL);
 352
 353   InstallProcessorDataHub (Smbios);
 354   InstallCacheDataHub     (Smbios);
 355   InstallMemoryDataHub    (Smbios);
 356   InstallMiscDataHub      (Smbios);
 357
 358   return EFI_SUCCESS;
 359 }
 360
 361 //
 362 // Internal function
 363 //
 364
 365 UINTN
 366 SmbiosTableLength (
 367   IN SMBIOS_STRUCTURE_POINTER SmbiosTable
 368   )
 369 {
 370   CHAR8  *AChar;
 371   UINTN  Length;
 372
 373   AChar = (CHAR8 *)(SmbiosTable.Raw + SmbiosTable.Hdr->Length);
 374   while ((*AChar != 0) || (*(AChar + 1) != 0)) {
 375     AChar ++;
 376   }
 377   Length = ((UINTN)AChar - (UINTN)SmbiosTable.Raw + 2);
 378
 379   return Length;
 380 }
 381
 382 SMBIOS_STRUCTURE_POINTER
 383 GetSmbiosTableFromType (
 384   IN SMBIOS_TABLE_ENTRY_POINT  *Smbios,
 385   IN UINT8                     Type,
 386   IN UINTN                     Index
 387   )
 388 {
 389   SMBIOS_STRUCTURE_POINTER SmbiosTable;
 390   UINTN                    SmbiosTypeIndex;
 391
 392   SmbiosTypeIndex = 0;
 393   SmbiosTable.Raw = (UINT8 *)(UINTN)Smbios->TableAddress;
 394   if (SmbiosTable.Raw == NULL) {
 395     return SmbiosTable;
 396   }
 397   while ((SmbiosTypeIndex != Index) || (SmbiosTable.Hdr->Type != Type)) {
 398     if (SmbiosTable.Hdr->Type == 127) {
 399       SmbiosTable.Raw = NULL;
 400       return SmbiosTable;
 401     }
 402     if (SmbiosTable.Hdr->Type == Type) {
 403       SmbiosTypeIndex ++;
 404     }
 405     SmbiosTable.Raw = (UINT8 *)(SmbiosTable.Raw + SmbiosTableLength (SmbiosTable));
 406   }
 407
 408   return SmbiosTable;
 409 }
 410
 411 CHAR8 *
 412 GetSmbiosString (
 413   IN SMBIOS_STRUCTURE_POINTER  SmbiosTable,
 414   IN SMBIOS_TABLE_STRING       String
 415   )
 416 {
 417   CHAR8      *AString;
 418   UINT8      Index;
 419
 420   Index = 1;
 421   AString = (CHAR8 *)(SmbiosTable.Raw + SmbiosTable.Hdr->Length);
 422   while (Index != String) {
 423     while (*AString != 0) {
 424       AString ++;
 425     }
 426     AString ++;
 427     if (*AString == 0) {
 428       return AString;
 429     }
 430     Index ++;
 431   }
 432
 433   return AString;
 434 }