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