sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
c9eb56e5fddc77a6a68c57c5685f64adbb5a05b9
system76-edk2/QuarkPlatformPkg/Platform/Dxe/MemorySubClass/MemorySubClass.c
Michael Kinney b303605e1b QuarkPlatformPkg: Add new package for Galileo boards 
Changes for V4
==============
1) Move delete of QuarkSocPkg\QuarkNorthCluster\Binary\QuarkMicrocode
   from QuarkPlatformPkg commit to QuarkSocPkg commit
2) Fix incorrect license header in PlatformSecLibModStrs.uni

Changes for V3
==============
1) Set PcdResetOnMemoryTypeInformationChange FALSE in QuarkMin.dsc
   This is required because QuarkMin.dsc uses the emulated variable
   driver that does not preserve any non-volatile UEFI variables
   across reset.  If the condition is met where the memory type
   information variable needs to be updated, then the system will reset
   every time the UEFI Shell is run.  By setting this PCD to FALSE,
   then reset action is disabled.
2) Move one binary file to QuarkSocBinPkg
3) Change RMU.bin FILE statements to INF statement in DSC FD region
   to be compatible with PACKAGES_PATH search for QuarkSocBinPkg

Changes for V2
==============
1) Use new generic PCI serial driver PciSioSerialDxe in MdeModulePkg
2) Configure PcdPciSerialParameters for PCI serial driver for Quark
3) Use new MtrrLib API to reduce time to set MTRRs for all DRAM
4) Convert all UNI files to utf-8
5) Replace tabs with spaces and remove trailing spaces
6) Add License.txt

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Michael Kinney <michael.d.kinney@intel.com>
Acked-by: Jordan Justen <jordan.l.justen@intel.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@19287 6f19259b-4bc3-4df7-8a09-765794883524
2015-12-15 19:23:57 +00:00

442 lines
18 KiB
C
Raw Blame History

/** @file
This is the driver that locates the MemoryConfigurationData Variable, if it
exists, and reports the data to the DataHub.
Copyright (c) 2013-2015 Intel Corporation.
This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
**/
#include "MemorySubClass.h"
extern UINT8 MemorySubClassStrings[];
EFI_GUID gEfiMemorySubClassDriverGuid = EFI_MEMORY_SUBCLASS_DRIVER_GUID;
EFI_STATUS
MemorySubClassEntryPoint (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
/*++
Routine Description:
This is the standard EFI driver point that detects whether there is a
MemoryConfigurationData Variable and, if so, reports memory configuration info
to the DataHub.
Arguments:
ImageHandle - Handle for the image of this driver
SystemTable - Pointer to the EFI System Table
Returns:
EFI_SUCCESS if the data is successfully reported
EFI_NOT_FOUND if the HOB list could not be located.
--*/
{
// UINT8 Index;
UINTN DataSize;
UINT8 Dimm;
UINTN StringBufferSize;
UINT8 NumSlots;
UINTN DevLocStrLen;
UINTN BankLocStrLen;
UINTN ManuStrLen;
UINTN SerialNumStrLen;
UINTN AssertTagStrLen;
UINTN PartNumStrLen;
UINTN MemoryDeviceSize;
CHAR8* OptionalStrStart;
UINT16 ArrayInstance;
UINT64 DimmMemorySize;
UINT64 TotalMemorySize;
UINT32 Data;
UINT32 MemoryCapacity;
BOOLEAN MemoryDeviceSizeUnitMega;
EFI_STATUS Status;
EFI_STRING StringBuffer;
EFI_STRING DevLocStr;
EFI_STRING BankLocStr;
EFI_STRING ManuStr;
EFI_STRING SerialNumStr;
EFI_STRING AssertTagStr;
EFI_STRING PartNumStr;
EFI_HII_HANDLE HiiHandle;
EFI_SMBIOS_HANDLE MemArraySmbiosHandle;
EFI_SMBIOS_HANDLE MemArrayMappedAddrSmbiosHandle;
EFI_SMBIOS_HANDLE MemDevSmbiosHandle;
EFI_SMBIOS_HANDLE MemDevMappedAddrSmbiosHandle;
EFI_SMBIOS_HANDLE MemModuleInfoSmbiosHandle;
SMBIOS_TABLE_TYPE6 *Type6Record;
SMBIOS_TABLE_TYPE16 *Type16Record;
SMBIOS_TABLE_TYPE17 *Type17Record;
SMBIOS_TABLE_TYPE19 *Type19Record;
SMBIOS_TABLE_TYPE20 *Type20Record;
EFI_SMBIOS_PROTOCOL *Smbios;
EFI_MEMORY_ARRAY_LINK_DATA ArrayLink;
EFI_MEMORY_ARRAY_LOCATION_DATA ArrayLocationData;
EFI_MEMORY_DEVICE_START_ADDRESS_DATA DeviceStartAddress;
DataSize = 0;
Dimm = 0;
//
// Allocate Buffers
//
StringBufferSize = (sizeof (CHAR16)) * 100;
StringBuffer = AllocateZeroPool (StringBufferSize);
ASSERT (StringBuffer != NULL);
//
// Locate dependent protocols
//
Status = gBS->LocateProtocol (&gEfiSmbiosProtocolGuid, NULL, (VOID**)&Smbios);
ASSERT_EFI_ERROR (Status);
//
// Add our default strings to the HII database. They will be modified later.
//
HiiHandle = HiiAddPackages (
&gEfiMemorySubClassDriverGuid,
NULL,
MemorySubClassStrings,
NULL
);
ASSERT (HiiHandle != NULL);
//
// Create physical array and associated data for all mainboard memory
// This will translate into a Type 16 SMBIOS Record
//
ArrayInstance = 1;
McD0PciCfg32 (QNC_ACCESS_PORT_MCR) = MESSAGE_READ_DW (0x3, 0x8);
TotalMemorySize = McD0PciCfg32 (QNC_ACCESS_PORT_MDR);
ArrayLocationData.MemoryArrayLocation = EfiMemoryArrayLocationSystemBoard;
ArrayLocationData.MemoryArrayUse = EfiMemoryArrayUseSystemMemory;
ArrayLocationData.MemoryErrorCorrection = EfiMemoryErrorCorrectionNone;
Data = 0x40000000;//(UINT32) RShiftU64(MemConfigData->RowInfo.MaxMemory, 10);
ArrayLocationData.MaximumMemoryCapacity.Exponent = (UINT16) LowBitSet32 (Data);
ArrayLocationData.MaximumMemoryCapacity.Value = (UINT16) (Data >> ArrayLocationData.MaximumMemoryCapacity.Exponent);
NumSlots = 2;// (UINT8)(MemConfigData->RowInfo.MaxRows >> 1);
ArrayLocationData.NumberMemoryDevices = (UINT16)(NumSlots);
//
// Report top level physical array to Type 16 SMBIOS Record
//
Type16Record = AllocatePool(sizeof(SMBIOS_TABLE_TYPE16) + 1 + 1);
ZeroMem(Type16Record, sizeof(SMBIOS_TABLE_TYPE16) + 1 + 1);
Type16Record->Hdr.Type = EFI_SMBIOS_TYPE_PHYSICAL_MEMORY_ARRAY;
Type16Record->Hdr.Length = sizeof(SMBIOS_TABLE_TYPE16);
Type16Record->Hdr.Handle = 0;
Type16Record->Location = (UINT8)ArrayLocationData.MemoryArrayLocation;
Type16Record->Use = (UINT8)ArrayLocationData.MemoryArrayUse;
Type16Record->MemoryErrorCorrection = (UINT8)ArrayLocationData.MemoryErrorCorrection;
MemoryCapacity = (UINT32) ArrayLocationData.MaximumMemoryCapacity.Value * (1 << ((UINT32) ArrayLocationData.MaximumMemoryCapacity.Exponent - 10));
Type16Record->MaximumCapacity = MemoryCapacity;
Type16Record->MemoryErrorInformationHandle = 0xfffe;
Type16Record->NumberOfMemoryDevices = ArrayLocationData.NumberMemoryDevices;
//
// Don't change it. This handle will be referenced by type 17 records
//
MemArraySmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = Smbios->Add (Smbios, NULL, &MemArraySmbiosHandle, (EFI_SMBIOS_TABLE_HEADER*) Type16Record);
FreePool(Type16Record);
ASSERT_EFI_ERROR (Status);
// Do associated data for each DIMM
//RowConfArray = &MemConfigData->RowConfArray;
//
// Get total memory size for the construction of smbios record type 19
//
//TotalMemorySize = 0;// MSG_BUS_READ(0x0208);
//
// Generate Memory Array Mapped Address info
//
Type19Record = AllocatePool(sizeof (SMBIOS_TABLE_TYPE19));
ZeroMem(Type19Record, sizeof(SMBIOS_TABLE_TYPE19));
Type19Record->Hdr.Type = EFI_SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS;
Type19Record->Hdr.Length = sizeof(SMBIOS_TABLE_TYPE19);
Type19Record->Hdr.Handle = 0;
Type19Record->StartingAddress = 0;
Type19Record->EndingAddress = (UINT32)RShiftU64(TotalMemorySize, 10) - 1;
Type19Record->MemoryArrayHandle = MemArraySmbiosHandle;
Type19Record->PartitionWidth = (UINT8)(NumSlots);
//
// Generate Memory Array Mapped Address info (TYPE 19)
//
MemArrayMappedAddrSmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = Smbios->Add (Smbios, NULL, &MemArrayMappedAddrSmbiosHandle, (EFI_SMBIOS_TABLE_HEADER*) Type19Record);
FreePool(Type19Record);
ASSERT_EFI_ERROR (Status);
// Use SPD data to generate Device Type info
ZeroMem (&ArrayLink, sizeof (EFI_MEMORY_ARRAY_LINK_DATA));
ArrayLink.MemoryDeviceLocator = STRING_TOKEN(STR_MEMORY_SUBCLASS_DEVICE_LOCATOR_0);
ArrayLink.MemoryBankLocator = STRING_TOKEN(STR_MEMORY_SUBCLASS_DEVICE_LOCATOR_0);
ArrayLink.MemoryAssetTag = STRING_TOKEN(STR_MEMORY_SUBCLASS_UNKNOWN);
ArrayLink.MemoryArrayLink.ProducerName = gEfiMemorySubClassDriverGuid;
ArrayLink.MemoryArrayLink.Instance = ArrayInstance;
ArrayLink.MemoryArrayLink.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
ArrayLink.MemorySubArrayLink.ProducerName = gEfiMemorySubClassDriverGuid;
ArrayLink.MemorySubArrayLink.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
ArrayLink.MemoryFormFactor = EfiMemoryFormFactorChip;
ArrayLink.MemoryType = EfiMemoryTypeDdr2;
StrCpy (StringBuffer, L"NO DIMM,MEMROY DOWN");
ArrayLink.MemoryManufacturer = HiiSetString (
HiiHandle,
0,
StringBuffer,
NULL
);
ArrayLink.MemorySerialNumber = HiiSetString (
HiiHandle,
0,
StringBuffer,
NULL
);
ArrayLink.MemoryPartNumber = HiiSetString (
HiiHandle,
0,
StringBuffer,
NULL
);
//
// Hardcode value. Need to revise for different configuration.
//
ArrayLink.MemoryTotalWidth = 64;
ArrayLink.MemoryDataWidth = 64;
DimmMemorySize = TotalMemorySize;// MSG_BUS_READ(0x0208);
ArrayLink.MemoryDeviceSize.Exponent = (UINT16) LowBitSet64 (DimmMemorySize);
ArrayLink.MemoryDeviceSize.Value = (UINT16) RShiftU64(DimmMemorySize, ArrayLink.MemoryDeviceSize.Exponent);
ArrayLink.MemoryTypeDetail.Synchronous = 1;
Data = 800;
ArrayLink.MemorySpeed = *((EFI_EXP_BASE10_DATA *) &Data);
DevLocStr = HiiGetPackageString(&gEfiMemorySubClassDriverGuid, ArrayLink.MemoryDeviceLocator, NULL);
DevLocStrLen = StrLen(DevLocStr);
ASSERT(DevLocStrLen <= SMBIOS_STRING_MAX_LENGTH);
BankLocStr = HiiGetPackageString(&gEfiMemorySubClassDriverGuid, ArrayLink.MemoryBankLocator, NULL);
BankLocStrLen = StrLen(BankLocStr);
ASSERT(BankLocStrLen <= SMBIOS_STRING_MAX_LENGTH);
ManuStr = HiiGetPackageString(&gEfiMemorySubClassDriverGuid, ArrayLink.MemoryManufacturer, NULL);
ManuStrLen = StrLen(ManuStr);
ASSERT(ManuStrLen <= SMBIOS_STRING_MAX_LENGTH);
SerialNumStr = HiiGetPackageString(&gEfiMemorySubClassDriverGuid, ArrayLink.MemorySerialNumber, NULL);
SerialNumStrLen = StrLen(SerialNumStr);
ASSERT(SerialNumStrLen <= SMBIOS_STRING_MAX_LENGTH);
AssertTagStr = HiiGetPackageString(&gEfiMemorySubClassDriverGuid, ArrayLink.MemoryAssetTag, NULL);
AssertTagStrLen = StrLen(AssertTagStr);
ASSERT(AssertTagStrLen <= SMBIOS_STRING_MAX_LENGTH);
PartNumStr = HiiGetPackageString(&gEfiMemorySubClassDriverGuid, ArrayLink.MemoryPartNumber, NULL);
PartNumStrLen = StrLen(PartNumStr);
ASSERT(PartNumStrLen <= SMBIOS_STRING_MAX_LENGTH);
//
// Report DIMM level memory module information to smbios (Type 6)
//
DataSize = sizeof(SMBIOS_TABLE_TYPE6) + DevLocStrLen + 1 + 1;
Type6Record = AllocatePool(DataSize);
ZeroMem(Type6Record, DataSize);
Type6Record->Hdr.Type = EFI_SMBIOS_TYPE_MEMORY_MODULE_INFORMATON;
Type6Record->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE6);
Type6Record->Hdr.Handle = 0;
Type6Record->SocketDesignation = 1;
if (ArrayLink.MemorySpeed.Value == 0) {
Type6Record->CurrentSpeed = 0;
} else {
//
// Memory speed is in ns unit
//
Type6Record->CurrentSpeed = (UINT8)(1000 / (ArrayLink.MemorySpeed.Value));
}
//
// Device Size
//
MemoryDeviceSize = (UINTN)(ArrayLink.MemoryDeviceSize.Value) * (UINTN)(1 << ArrayLink.MemoryDeviceSize.Exponent);
if (MemoryDeviceSize == 0) {
*(UINT8*)&(Type6Record->InstalledSize) = 0x7F;
*(UINT8*)&(Type6Record->EnabledSize) = 0x7F;
} else {
MemoryDeviceSize = (UINTN) RShiftU64 ((UINT64) MemoryDeviceSize, 21);
while (MemoryDeviceSize != 0) {
(*(UINT8*)&(Type6Record->InstalledSize))++;
(*(UINT8*)&(Type6Record->EnabledSize))++;
MemoryDeviceSize = (UINTN) RShiftU64 ((UINT64) MemoryDeviceSize,1);
}
}
if (ArrayLink.MemoryFormFactor == EfiMemoryFormFactorDimm ||
ArrayLink.MemoryFormFactor == EfiMemoryFormFactorFbDimm) {
*(UINT16*)&Type6Record->CurrentMemoryType |= 1<<8;
}
if (ArrayLink.MemoryFormFactor == EfiMemoryFormFactorSimm) {
*(UINT16*)&Type6Record->CurrentMemoryType |= 1<<7;
}
if (ArrayLink.MemoryType == EfiMemoryTypeSdram) {
*(UINT16*)&Type6Record->CurrentMemoryType |= 1<<10;
}
if (ArrayLink.MemoryTypeDetail.Edo == 1) {
*(UINT16*)&Type6Record->CurrentMemoryType |= 1<<4;
}
if (ArrayLink.MemoryTypeDetail.FastPaged == 1) {
*(UINT16*)&Type6Record->CurrentMemoryType |= 1<<3;
}
OptionalStrStart = (CHAR8 *)(Type6Record + 1);
UnicodeStrToAsciiStr(DevLocStr, OptionalStrStart);
MemModuleInfoSmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = Smbios->Add (Smbios, NULL, &MemModuleInfoSmbiosHandle, (EFI_SMBIOS_TABLE_HEADER*) Type6Record);
FreePool(Type6Record);
ASSERT_EFI_ERROR (Status);
//
// Report DIMM level Device Type to smbios (Type 17)
//
DataSize = sizeof (SMBIOS_TABLE_TYPE17) + DevLocStrLen + 1 + BankLocStrLen + 1 + ManuStrLen + 1 + SerialNumStrLen + 1 + AssertTagStrLen + 1 + PartNumStrLen + 1 + 1;
Type17Record = AllocatePool(DataSize);
ZeroMem(Type17Record, DataSize);
Type17Record->Hdr.Type = EFI_SMBIOS_TYPE_MEMORY_DEVICE;
Type17Record->Hdr.Length = sizeof (SMBIOS_TABLE_TYPE17);
Type17Record->Hdr.Handle = 0;
Type17Record->MemoryArrayHandle = MemArraySmbiosHandle;
Type17Record->MemoryErrorInformationHandle = 0xfffe;
Type17Record->TotalWidth = ArrayLink.MemoryTotalWidth;
Type17Record->DataWidth = ArrayLink.MemoryDataWidth;
//
// Device Size
//
MemoryDeviceSize = ((UINTN) ArrayLink.MemoryDeviceSize.Value) << (ArrayLink.MemoryDeviceSize.Exponent - 10);
MemoryDeviceSizeUnitMega = FALSE;
//
// kilo as unit
//
if (MemoryDeviceSize > 0xffff) {
MemoryDeviceSize = MemoryDeviceSize >> 10;
//
// Mega as unit
//
MemoryDeviceSizeUnitMega = TRUE;
}
MemoryDeviceSize = MemoryDeviceSize & 0x7fff;
if (MemoryDeviceSize != 0 && MemoryDeviceSizeUnitMega == FALSE) {
MemoryDeviceSize |= 0x8000;
}
Type17Record->Size = (UINT16)MemoryDeviceSize;
Type17Record->FormFactor = (UINT8)ArrayLink.MemoryFormFactor;
Type17Record->DeviceLocator = 1;
Type17Record->BankLocator = 2;
Type17Record->MemoryType = (UINT8)ArrayLink.MemoryType;
CopyMem (
(UINT8 *) &Type17Record->TypeDetail,
&ArrayLink.MemoryTypeDetail,
2
);
Type17Record->Speed = ArrayLink.MemorySpeed.Value;
Type17Record->Manufacturer = 3;
Type17Record->SerialNumber = 4;
Type17Record->AssetTag = 5;
Type17Record->PartNumber = 6;
//
// temporary solution for save device label information.
//
Type17Record->Attributes = (UINT8)(Dimm + 1);
OptionalStrStart = (CHAR8 *)(Type17Record + 1);
UnicodeStrToAsciiStr(DevLocStr, OptionalStrStart);
UnicodeStrToAsciiStr(BankLocStr, OptionalStrStart + DevLocStrLen + 1);
UnicodeStrToAsciiStr(ManuStr, OptionalStrStart + DevLocStrLen + 1 + BankLocStrLen + 1);
UnicodeStrToAsciiStr(SerialNumStr, OptionalStrStart + DevLocStrLen + 1 + BankLocStrLen + 1 + ManuStrLen + 1);
UnicodeStrToAsciiStr(AssertTagStr, OptionalStrStart + DevLocStrLen + 1 + BankLocStrLen + 1 + ManuStrLen + 1 + SerialNumStrLen + 1);
UnicodeStrToAsciiStr(PartNumStr, OptionalStrStart + DevLocStrLen + 1 + BankLocStrLen + 1 + ManuStrLen + 1 + SerialNumStrLen + 1 + AssertTagStrLen + 1);
MemDevSmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = Smbios->Add (Smbios, NULL, &MemDevSmbiosHandle, (EFI_SMBIOS_TABLE_HEADER*) Type17Record);
FreePool(Type17Record);
ASSERT_EFI_ERROR (Status);
//
// Generate Memory Device Mapped Address info
//
ZeroMem(&DeviceStartAddress, sizeof(EFI_MEMORY_DEVICE_START_ADDRESS_DATA));
DeviceStartAddress.MemoryDeviceStartAddress = 0;
DeviceStartAddress.MemoryDeviceEndAddress = DeviceStartAddress.MemoryDeviceStartAddress + DimmMemorySize-1;
DeviceStartAddress.PhysicalMemoryDeviceLink.ProducerName = gEfiMemorySubClassDriverGuid;
DeviceStartAddress.PhysicalMemoryDeviceLink.Instance = ArrayInstance;
DeviceStartAddress.PhysicalMemoryDeviceLink.SubInstance = (UINT16)(Dimm + 1);
DeviceStartAddress.PhysicalMemoryArrayLink.ProducerName = gEfiMemorySubClassDriverGuid;
DeviceStartAddress.PhysicalMemoryArrayLink.Instance = ArrayInstance;
DeviceStartAddress.PhysicalMemoryArrayLink.SubInstance = EFI_SUBCLASS_INSTANCE_NON_APPLICABLE;
//
// Single channel mode
//
DeviceStartAddress.MemoryDevicePartitionRowPosition = 0x01;
DeviceStartAddress.MemoryDeviceInterleavePosition = 0x00;
DeviceStartAddress.MemoryDeviceInterleaveDataDepth = 0x00;
//
// Generate Memory Device Mapped Address info (TYPE 20)
//
Type20Record = AllocatePool(sizeof (SMBIOS_TABLE_TYPE20));
ZeroMem(Type20Record, sizeof (SMBIOS_TABLE_TYPE20));
Type20Record->Hdr.Type = EFI_SMBIOS_TYPE_MEMORY_DEVICE_MAPPED_ADDRESS;
Type20Record->Hdr.Length = sizeof(SMBIOS_TABLE_TYPE20);
Type20Record->Hdr.Handle = 0;
Type20Record->StartingAddress = (UINT32)RShiftU64 (DeviceStartAddress.MemoryDeviceStartAddress, 10);
Type20Record->EndingAddress = (UINT32)RShiftU64 (DeviceStartAddress.MemoryDeviceEndAddress, 10);
Type20Record->MemoryDeviceHandle = MemDevSmbiosHandle;
Type20Record->MemoryArrayMappedAddressHandle = MemArrayMappedAddrSmbiosHandle;
Type20Record->PartitionRowPosition = DeviceStartAddress.MemoryDevicePartitionRowPosition;
Type20Record->InterleavePosition = DeviceStartAddress.MemoryDeviceInterleavePosition;
Type20Record->InterleavedDataDepth = DeviceStartAddress.MemoryDeviceInterleaveDataDepth;
MemDevMappedAddrSmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
Status = Smbios->Add (Smbios, NULL, &MemDevMappedAddrSmbiosHandle, (EFI_SMBIOS_TABLE_HEADER*) Type20Record);
FreePool(Type20Record);
ASSERT_EFI_ERROR (Status);
return Status;
}
Reference in New Issue View Git Blame Copy Permalink