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