/** @file
*
*  Copyright (c) 2015, Hisilicon Limited. All rights reserved.
*  Copyright (c) 2015, Linaro Limited. All rights reserved.
*
*  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"

EFI_SMBIOS_PROTOCOL             *mSmbios = NULL;
EFI_HII_HANDLE                  mHiiHandle;

UINT8                           mMaxSkt;
UINT8                           mMaxCh;

VOID
SmbiosGetManufacturer (
  IN  UINT8           MfgIdLSB,
  IN  UINT8           MfgIdMSB,
  OUT CHAR16          *Manufacturer
)
{
    UINT32                  Index = 0;

    (VOID)StrCpyS(Manufacturer, SMBIOS_STRING_MAX_LENGTH - 1, L"Unknown");
    while (JEP106[Index].MfgIdLSB != 0xFF && JEP106[Index].MfgIdMSB != 0xFF )
    {
        if (JEP106[Index].MfgIdLSB == MfgIdLSB && JEP106[Index].MfgIdMSB == MfgIdMSB)
        {
            (VOID)StrCpyS (Manufacturer, SMBIOS_STRING_MAX_LENGTH - 1, JEP106[Index].Name);
            break;
        }
        Index++;
    }
}

VOID
SmbiosGetPartNumber (
  IN pGBL_DATA          pGblData,
  IN UINT8              Skt,
  IN UINT8              Ch,
  IN UINT8              Dimm,
  OUT CHAR16             *PartNumber
  )
{
    CHAR16                        StringBuffer2[SMBIOS_STRING_MAX_LENGTH];
    UINT32                        Index2;

    (VOID)StrCpyS(PartNumber, SMBIOS_STRING_MAX_LENGTH - 1, L"");
    if (pGblData->Channel[Skt][Ch].Dimm[Dimm].DramType == SPD_TYPE_DDR3)
    {
        for (Index2 = 0; Index2 < SPD_MODULE_PART; Index2++)
        {
            UnicodeSPrint (StringBuffer2, SMBIOS_STRING_MAX_LENGTH - 1, L"%c", pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdModPart[Index2]);
            (VOID)StrCatS(PartNumber, SMBIOS_STRING_MAX_LENGTH - 1, StringBuffer2);
        }
    }
    else
    {
        for (Index2 = 0; Index2 < SPD_MODULE_PART_DDR4; Index2++)
        {
            UnicodeSPrint (StringBuffer2, SMBIOS_STRING_MAX_LENGTH - 1, L"%c", pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdModPartDDR4[Index2]);
            (VOID)StrCatS(PartNumber, SMBIOS_STRING_MAX_LENGTH - 1, StringBuffer2);
        }
    }

    return;
}

VOID
SmbiosGetSerialNumber (
  IN pGBL_DATA          pGblData,
  IN UINT8              Skt,
  IN UINT8              Ch,
  IN UINT8              Dimm,
  OUT CHAR16            *SerialNumber
  )
{
    UINT32              Temp;

    Temp = SwapBytes32 (pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdSerialNum);

    UnicodeSPrint(SerialNumber, SMBIOS_STRING_MAX_LENGTH, L"0x%08x", Temp);

    return;
}

BOOLEAN
IsDimmPresent (
  IN  pGBL_DATA          pGblData,
  IN  UINT8              Skt,
  IN  UINT8              Ch,
  IN  UINT8              Dimm
)
{
    if (pGblData->Channel[Skt][Ch].Status == FALSE ||
          pGblData->Channel[Skt][Ch].Dimm[Dimm].Status == FALSE)
    {
        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

UINT8
SmbiosGetMemoryType (
  IN  pGBL_DATA          pGblData,
  IN  UINT8              Skt,
  IN  UINT8              Ch,
  IN  UINT8              Dimm
)
{
    UINT8 MemoryType;

    if(!IsDimmPresent(pGblData, Skt, Ch, Dimm))
    {
        return MemoryTypeUnknown;
    }

    if (pGblData->Channel[Skt][Ch].Dimm[Dimm].DramType == SPD_TYPE_DDR3)
    {
        MemoryType = MemoryTypeDdr3;
    }
    else if (pGblData->Channel[Skt][Ch].Dimm[Dimm].DramType == SPD_TYPE_DDR4)
    {
        MemoryType = MemoryTypeDdr4;
    }
    else
    {
        MemoryType = MemoryTypeUnknown;
    }

    return MemoryType;
}

VOID
SmbiosGetTypeDetail (
  IN  pGBL_DATA             pGblData,
  IN  UINT8                 Skt,
  IN  UINT8                 Ch,
  IN  UINT8                 Dimm,
  IN  OUT MEMORY_DEVICE_TYPE_DETAIL *TypeDetail
)
{
    if (NULL == TypeDetail)
    {
        return;
    }

    if(!IsDimmPresent(pGblData, Skt, Ch, Dimm))
    {
        TypeDetail->Unknown = 1;
        return;
    }

    switch (pGblData->Channel[Skt][Ch].Dimm[Dimm].ModuleType)
    {
        case SPD_UDIMM:
          TypeDetail->Unbuffered = 1;
          break;

        case SPD_LRDIMM:
          TypeDetail->LrDimm = 1;
          break;

        case SPD_RDIMM:
          TypeDetail->Registered = 1;
          break;

        default:
          TypeDetail->Unknown = 1;
          break;
    }
}

VOID
SmbiosGetDimmVoltageInfo (
  IN     pGBL_DATA             pGblData,
  IN     UINT8                 Skt,
  IN     UINT8                 Ch,
  IN     UINT8                 Dimm,
  IN OUT SMBIOS_TABLE_TYPE17   *Type17Record

)
{
    if(!IsDimmPresent(pGblData, Skt, Ch, Dimm))
    {
        return;
    }

    if (pGblData->Channel[Skt][Ch].Dimm[Dimm].DramType == SPD_TYPE_DDR3)
    {
        Type17Record->MinimumVoltage                = 1250;
        Type17Record->MaximumVoltage                = 1500;

        switch (pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdVdd)
        {
            case SPD_VDD_150:
              Type17Record->ConfiguredVoltage = 1500;
              break;

            case SPD_VDD_135:
              Type17Record->ConfiguredVoltage = 1350;
              break;

            case SPD_VDD_125:
              Type17Record->ConfiguredVoltage = 1250;
              break;

            default:
              break;
        }
    }
    else if (pGblData->Channel[Skt][Ch].Dimm[Dimm].DramType == SPD_TYPE_DDR4)
    {
        Type17Record->MinimumVoltage                = 1200;
        Type17Record->MaximumVoltage                = 2000;
        switch (pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdVdd)
        {
            case SPD_VDD_120:
              Type17Record->ConfiguredVoltage = 1200;
              break;

            default:
              break;
        }
    }
}

VOID
SmbiosGetMemoryDevicesNumber (
  IN OUT UINT16 *NumberOfDevices
)
{
    UINT8       Skt, Ch, Dimm;

    for(Skt = 0; Skt < mMaxSkt; Skt++)
    {
        for(Ch = 0; Ch < mMaxCh; Ch++)
        {
            for(Dimm = 0; Dimm < OemGetDimmSlot(Skt, Ch); Dimm++)
            {
                (*NumberOfDevices)++;
            }
        }
    }
}

UINT8
SmbiosGetPartitionWidth (
)
{

    UINT8       Skt, Ch, Dimm;
    UINT8       PartitionWidth = 0;

    for(Skt = 0; Skt < mMaxSkt; Skt++)
    {
        for(Ch = 0; Ch < mMaxCh; Ch++)
        {
            for(Dimm = 0; Dimm < OemGetDimmSlot(Skt, Ch); Dimm++)
            {
                PartitionWidth++;
            }
        }
    }

    return PartitionWidth;
}

EFI_STATUS
SmbiosAddType16Table (
  IN  pGBL_DATA          pGblData,
  OUT EFI_SMBIOS_HANDLE  *MemArraySmbiosHandle
  )
{
    EFI_STATUS                      Status;
    UINT64                          MemoryCapacity;
    SMBIOS_TABLE_TYPE16             *Type16Record;

    UINT16                          NumberOfMemoryDevices = 0;

    SmbiosGetMemoryDevicesNumber (&NumberOfMemoryDevices);

    MemoryCapacity = (UINT64) LShiftU64 (NumberOfMemoryDevices * MAX_DIMM_SIZE, 20); // GB to KB.

    //
    // Type 16 SMBIOS Record
    //
    Type16Record = AllocateZeroPool(sizeof(SMBIOS_TABLE_TYPE16) + 1 + 1);
    if (NULL == Type16Record)
    {
        return EFI_OUT_OF_RESOURCES;
    }

    Type16Record->Hdr.Type                          = EFI_SMBIOS_TYPE_PHYSICAL_MEMORY_ARRAY;
    Type16Record->Hdr.Length                        = sizeof (SMBIOS_TABLE_TYPE16);
    Type16Record->Hdr.Handle                        = 0x0;
    Type16Record->Location                          = MemoryArrayLocationSystemBoard;
    Type16Record->Use                               = MemoryArrayUseSystemMemory;
    Type16Record->MemoryErrorInformationHandle      = 0xFFFE;
    Type16Record->NumberOfMemoryDevices             = NumberOfMemoryDevices;

    if(pGblData->EccEn)
    {
        Type16Record->MemoryErrorCorrection         = MemoryErrorCorrectionSingleBitEcc;
    }
    else
    {
        Type16Record->MemoryErrorCorrection         = MemoryErrorCorrectionNone;
    }

    if (MemoryCapacity >= 0x80000000)
    {
        Type16Record->MaximumCapacity = 0x80000000;   // in KB;
        Type16Record->ExtendedMaximumCapacity = MemoryCapacity << 10;  // Extended Max capacity should be stored in bytes.
    }
    else
    {
        Type16Record->MaximumCapacity = (UINT32)MemoryCapacity;  // Max capacity should be stored in kilo bytes.
        Type16Record->ExtendedMaximumCapacity = 0;
    }

    *MemArraySmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
    Status = mSmbios->Add (mSmbios, NULL, MemArraySmbiosHandle, (EFI_SMBIOS_TABLE_HEADER *)Type16Record);
    if(EFI_ERROR(Status))
    {
        DEBUG((EFI_D_ERROR, "[%a]:[%dL] Smbios Type16 Table Log Failed! %r \n", __FUNCTION__, __LINE__, Status));
    }

    FreePool(Type16Record);
    return Status;
}

EFI_STATUS
SmbiosAddType19Table (
  IN pGBL_DATA          pGblData,
  IN EFI_SMBIOS_HANDLE  MemArraySmbiosHandle
  )
{
    EFI_STATUS                      Status;
    UINT32                          MemInfoTotalMem;
    UINT64                          TotalMemorySize;
    EFI_SMBIOS_HANDLE               MemArrayMappedAddrSmbiosHandle;
    SMBIOS_TABLE_TYPE19             *Type19Record;

    MemInfoTotalMem = pGblData->MemSize;  // In MB

    if (MemInfoTotalMem == 0)
    {
        return EFI_NOT_FOUND;
    }

    TotalMemorySize = (UINT64) LShiftU64 (MemInfoTotalMem, 10);  // MB to KB.

    //
    // Type 19 SMBIOS Record
    //
    Type19Record = AllocateZeroPool(sizeof(SMBIOS_TABLE_TYPE19) + 1 + 1);
    if (NULL == Type19Record)
    {
        return EFI_OUT_OF_RESOURCES;
    }

    Type19Record->Hdr.Type                          = EFI_SMBIOS_TYPE_MEMORY_ARRAY_MAPPED_ADDRESS;
    Type19Record->Hdr.Length                        = sizeof(SMBIOS_TABLE_TYPE19);
    Type19Record->Hdr.Handle                        = 0x0;
    Type19Record->StartingAddress                   = 0x0;
    Type19Record->EndingAddress                     = (UINT32) (TotalMemorySize - 1); // in KB;
    Type19Record->MemoryArrayHandle                 = MemArraySmbiosHandle;
    Type19Record->PartitionWidth                    = SmbiosGetPartitionWidth ();
    Type19Record->ExtendedStartingAddress           = 0x0;
    Type19Record->ExtendedEndingAddress             = 0x0;

    MemArrayMappedAddrSmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
    Status = mSmbios->Add (mSmbios, NULL, &MemArrayMappedAddrSmbiosHandle, (EFI_SMBIOS_TABLE_HEADER *)Type19Record);
    if(EFI_ERROR(Status))
    {
        DEBUG((EFI_D_ERROR, "[%a]:[%dL] Smbios Type19 Table Log Failed! %r \n", __FUNCTION__, __LINE__, Status));
    }

    FreePool(Type19Record);
    return Status;
}


EFI_STATUS
SmbiosAddType17Table (
  IN pGBL_DATA          pGblData,
  IN UINT8              Skt,
  IN UINT8              Ch,
  IN UINT8              Dimm,
  IN EFI_SMBIOS_HANDLE  MemArraySmbiosHandle
  )
{
    EFI_STATUS                      Status;
    SMBIOS_TABLE_TYPE17             *Type17Record;
    EFI_SMBIOS_HANDLE               MemDevSmbiosHandle;
    UINTN                           TableSize;

    UINTN                           StringBufferSize;
    EFI_STRING                      StringBuffer;
    UINT16                          MemInfoMemFreq;
    UINT16                          MemoryTotalWidth;
    UINT16                          MemoryDataWidth;
    UINT16                          MemoryDeviceSize;
    UINT16                          MemorySpeed;
    UINT8                           Attributes;
    UINT32                          MemoryDeviceExtendSize;
    UINT16                          CfgMemorySpeed;

    CHAR8                           *OptionalStrStart;
    UINTN                           DeviceLocatorStrLen;
    UINTN                           BankLocatorStrLen;
    UINTN                           ManufactureStrLen;
    UINTN                           SerialNumberStrLen;
    UINTN                           AssertTagStrLen;
    UINTN                           PartNumberStrLen;
    EFI_STRING                      DeviceLocatorStr;
    EFI_STRING                      BankLocatorStr;
    EFI_STRING                      ManufactureStr;
    EFI_STRING                      SerialNumberStr;
    EFI_STRING                      AssertTagStr;
    EFI_STRING                      PartNumberStr;
    EFI_STRING_ID                   DeviceLocator;

    Type17Record        = NULL;
    DeviceLocatorStr    = NULL;
    BankLocatorStr      = NULL;
    ManufactureStr      = NULL;
    SerialNumberStr     = NULL;
    AssertTagStr        = NULL;
    PartNumberStr       = NULL;

    MemoryTotalWidth    = 0;
    MemoryDataWidth     = 0;
    MemoryDeviceSize    = 0;
    MemoryDeviceExtendSize = 0;
    MemorySpeed         = 0;
    Attributes          = 0;
    CfgMemorySpeed      = 0;

    //
    // Allocate Buffers
    //
    StringBufferSize = (sizeof (CHAR16)) * SMBIOS_STRING_MAX_LENGTH;
    StringBuffer = AllocateZeroPool (StringBufferSize);
    if(NULL == StringBuffer)
    {
        return EFI_OUT_OF_RESOURCES;
    }


    //
    // Manufacture
    //
    ManufactureStr = AllocateZeroPool (StringBufferSize);
    if(NULL == ManufactureStr)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_STR_BUF;
    }
    UnicodeSPrint(ManufactureStr, SMBIOS_STRING_MAX_LENGTH - 1, L"NO DIMM");

    //
    // SerialNumber
    //
    SerialNumberStr = AllocateZeroPool (StringBufferSize);
    if(NULL == SerialNumberStr)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_STR_MAN;
    }
    UnicodeSPrint(SerialNumberStr, SMBIOS_STRING_MAX_LENGTH - 1, L"NO DIMM");

    //
    // AssetTag
    //
    AssertTagStr = AllocateZeroPool (StringBufferSize);
    if(NULL == AssertTagStr)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_STR_SN;
    }
    UnicodeSPrint(AssertTagStr, SMBIOS_STRING_MAX_LENGTH - 1, L"NO DIMM");

    //
    // PartNumber
    //
    PartNumberStr = AllocateZeroPool (StringBufferSize);
    if(NULL == PartNumberStr)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_STR_AST;
    }
    UnicodeSPrint(PartNumberStr, SMBIOS_STRING_MAX_LENGTH - 1, L"NO DIMM");


    if(IsDimmPresent(pGblData, Skt, Ch, Dimm))
    {
        MemoryDataWidth = pGblData->Channel[Skt][Ch].Dimm[Dimm].PrimaryBusWidth;
        MemoryTotalWidth = MemoryDataWidth + pGblData->Channel[Skt][Ch].Dimm[Dimm].ExtensionBusWidth;

        MemoryDeviceSize = pGblData->Channel[Skt][Ch].Dimm[Dimm].DimmSize;  //in MB
        MemoryDeviceExtendSize = 0;

        if (MemoryDeviceSize >= 0x7fff)
        {
            MemoryDeviceExtendSize = MemoryDeviceSize;  // in MB
            MemoryDeviceSize = 0x7fff;                    // max value
        }

        MemInfoMemFreq = pGblData->Freq;
        MemorySpeed = pGblData->Channel[Skt][Ch].Dimm[Dimm].DimmSpeed;
        Attributes = pGblData->Channel[Skt][Ch].Dimm[Dimm].RankNum;
        CfgMemorySpeed = MemInfoMemFreq;

        //
        // Manufacturer
        //
        SmbiosGetManufacturer (pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdMMfgId & 0xFF,
                                        pGblData->Channel[Skt][Ch].Dimm[Dimm].SpdMMfgId >> 8,
                                        ManufactureStr
                                        );

        //
        // SerialNumber
        //
        SmbiosGetSerialNumber(pGblData, Skt, Ch, Dimm, SerialNumberStr);

        //
        // AssetTag
        //
        UnicodeSPrint(AssertTagStr, SMBIOS_STRING_MAX_LENGTH - 1, L"Unknown");

        //
        // PartNumber
        //
        SmbiosGetPartNumber(pGblData, Skt, Ch, Dimm, PartNumberStr);
    }

    //
    // DeviceLocator
    //
    DeviceLocatorStr = AllocateZeroPool ((sizeof (CHAR16)) * SMBIOS_STRING_MAX_LENGTH);
    if(NULL == DeviceLocatorStr)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_STR_PN;
    }
    DeviceLocator = gDimmToDevLocator[Skt][Ch][Dimm];
    if (DeviceLocator != 0xFFFF)
    {
        UnicodeSPrint(DeviceLocatorStr, SMBIOS_STRING_MAX_LENGTH, L"DIMM%x%x%x ", Skt, Ch, Dimm);
        StringBuffer = HiiGetPackageString (&gEfiCallerIdGuid, DeviceLocator, NULL);
        (VOID)StrCatS(DeviceLocatorStr, SMBIOS_STRING_MAX_LENGTH, StringBuffer);
    }
    else
    {
    UnicodeSPrint(DeviceLocatorStr, SMBIOS_STRING_MAX_LENGTH, L"DIMM%x%x%x", Skt, Ch, Dimm);
    }
    DeviceLocatorStrLen = StrLen (DeviceLocatorStr);

    //
    // BankLocator
    //
    BankLocatorStr = AllocateZeroPool ((sizeof (CHAR16)) * SMBIOS_STRING_MAX_LENGTH);
    if(NULL == BankLocatorStr)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_STR_DEV;
    }
    UnicodeSPrint(BankLocatorStr, SMBIOS_STRING_MAX_LENGTH, L"SOCKET %x CHANNEL %x DIMM %x", Skt, Ch, Dimm);
    BankLocatorStrLen = StrLen (BankLocatorStr);

    ManufactureStrLen = StrLen (ManufactureStr);
    SerialNumberStrLen = StrLen (SerialNumberStr);
    AssertTagStrLen = StrLen (AssertTagStr);
    PartNumberStrLen = StrLen (PartNumberStr);

    //
    // Report Type 17 SMBIOS Record
    //
    TableSize = sizeof(SMBIOS_TABLE_TYPE17) + DeviceLocatorStrLen + 1 + BankLocatorStrLen + 1 + ManufactureStrLen + 1 + SerialNumberStrLen + 1 + AssertTagStrLen + 1 + PartNumberStrLen + 1 + 1;
    Type17Record = AllocateZeroPool (TableSize);
    if(NULL == Type17Record)
    {
        Status = EFI_OUT_OF_RESOURCES;
        goto FREE_BL;
    }

    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                    = MemoryTotalWidth;
    Type17Record->DataWidth                     = MemoryDataWidth;
    Type17Record->Size                          = MemoryDeviceSize;           // in MB
    Type17Record->FormFactor                    = MemoryFormFactorDimm;
    Type17Record->DeviceLocator                 = 1;
    Type17Record->BankLocator                   = 2;
    Type17Record->MemoryType                    = SmbiosGetMemoryType (pGblData, Skt, Ch, Dimm);

    Type17Record->TypeDetail.Synchronous    = 1;

    SmbiosGetTypeDetail (pGblData, Skt, Ch, Dimm, &(Type17Record->TypeDetail));

    Type17Record->Speed                         = MemorySpeed; // in MHZ
    Type17Record->Manufacturer                  = 3;
    Type17Record->SerialNumber                  = 4;
    Type17Record->AssetTag                      = 5;
    Type17Record->PartNumber                    = 6;
    Type17Record->Attributes                    = Attributes;
    Type17Record->ExtendedSize                  = MemoryDeviceExtendSize;
    Type17Record->ConfiguredMemoryClockSpeed    = CfgMemorySpeed;
    //
    // Add for smbios 2.8.0
    //
    SmbiosGetDimmVoltageInfo (pGblData, Skt, Ch, Dimm, Type17Record);

    OptionalStrStart = (CHAR8 *) (Type17Record + 1);
    UnicodeStrToAsciiStr (DeviceLocatorStr, OptionalStrStart);
    UnicodeStrToAsciiStr (BankLocatorStr, OptionalStrStart + DeviceLocatorStrLen + 1);
    UnicodeStrToAsciiStr (ManufactureStr, OptionalStrStart + DeviceLocatorStrLen + 1 + BankLocatorStrLen + 1);
    UnicodeStrToAsciiStr (SerialNumberStr, OptionalStrStart + DeviceLocatorStrLen + 1 + BankLocatorStrLen + 1 + ManufactureStrLen + 1);
    UnicodeStrToAsciiStr (AssertTagStr, OptionalStrStart + DeviceLocatorStrLen + 1 + BankLocatorStrLen + 1 + ManufactureStrLen + 1 + SerialNumberStrLen + 1);
    UnicodeStrToAsciiStr (PartNumberStr, OptionalStrStart + DeviceLocatorStrLen + 1 + BankLocatorStrLen + 1 + ManufactureStrLen + 1 + SerialNumberStrLen + 1 + AssertTagStrLen + 1);

    MemDevSmbiosHandle = SMBIOS_HANDLE_PI_RESERVED;
    Status = mSmbios->Add (mSmbios, NULL, &MemDevSmbiosHandle, (EFI_SMBIOS_TABLE_HEADER*) Type17Record);
    if(EFI_ERROR(Status))
    {
        DEBUG((EFI_D_ERROR, "[%a]:[%dL] Smbios Type17 Table Log Failed! %r \n", __FUNCTION__, __LINE__, Status));
    }

    FreePool (Type17Record);

FREE_BL:
    FreePool (BankLocatorStr);

FREE_STR_DEV:
    FreePool (DeviceLocatorStr);

FREE_STR_PN:
    FreePool (PartNumberStr);

FREE_STR_AST:
    FreePool (AssertTagStr);

FREE_STR_SN:
    FreePool (SerialNumberStr);

FREE_STR_MAN:
    FreePool (ManufactureStr);

FREE_STR_BUF:
    FreePool (StringBuffer);

    return Status;
}


/**
  Standard EFI driver point.  This driver locates the MemoryConfigurationData Variable,
  if it exists, add the related SMBIOS tables by PI SMBIOS protocol.

  @param  ImageHandle     Handle for the image of this driver
  @param  SystemTable     Pointer to the EFI System Table

  @retval  EFI_SUCCESS    The data was successfully stored.

**/
EFI_STATUS
EFIAPI
MemorySubClassEntryPoint(
  IN EFI_HANDLE         ImageHandle,
  IN EFI_SYSTEM_TABLE   *SystemTable
  )
{
    EFI_STATUS                      Status;
    EFI_SMBIOS_PROTOCOL             *Smbios;
    EFI_HOB_GUID_TYPE               *GuidHob;
    pGBL_DATA                       pGblData;
    EFI_SMBIOS_HANDLE               MemArraySmbiosHandle;
    UINT8                           Skt, Ch, Dimm;

    GuidHob = GetFirstGuidHob(&gHisiEfiMemoryMapGuid);
    if(NULL == GuidHob)
    {
        DEBUG((EFI_D_ERROR, "Could not get MemoryMap Guid hob.  %r\n"));
        return EFI_NOT_FOUND;
    }
    pGblData = (pGBL_DATA) GET_GUID_HOB_DATA(GuidHob);

    //
    // Locate dependent protocols
    //
    Status = gBS->LocateProtocol(&gEfiSmbiosProtocolGuid, NULL, (VOID**)&Smbios);
    if (EFI_ERROR(Status))
    {
        DEBUG((EFI_D_ERROR, "Could not locate SMBIOS protocol.  %r\n", Status));
        return Status;
    }
    mSmbios = Smbios;

    //
    // Add our default strings to the HII database. They will be modified later.
    //
    mHiiHandle = OemGetPackages();
    if(NULL == mHiiHandle)
    {
        return EFI_OUT_OF_RESOURCES;
    }

    mMaxSkt  = OemGetSocketNumber();
    mMaxCh   = OemGetDdrChannel();
    // Get DIMM slot number on Socket 0 Channel 0
    // TODO: Assume all channels have same slot number

    Status = SmbiosAddType16Table (pGblData, &MemArraySmbiosHandle);
    if(EFI_ERROR(Status))
    {
        DEBUG((EFI_D_ERROR, "Smbios Add Type16 Table Failed.  %r\n", Status));
        return Status;
    }

    Status = SmbiosAddType19Table (pGblData, MemArraySmbiosHandle);
    if(EFI_ERROR(Status))
    {
        DEBUG((EFI_D_ERROR, "Smbios Add Type19 Table Failed.  %r\n", Status));
        return Status;
    }

    for(Skt = 0; Skt < mMaxSkt; Skt++)
    {
        for(Ch = 0; Ch < mMaxCh; Ch++)
        {
            for(Dimm = 0; Dimm < OemGetDimmSlot(Skt, Ch); Dimm++)
            {
                Status = SmbiosAddType17Table (pGblData, Skt, Ch, Dimm, MemArraySmbiosHandle);
                if(EFI_ERROR(Status))
                {
                    DEBUG((EFI_D_ERROR, "Smbios Add Type17 Table Failed.  %r\n", Status));
                }
            }
        }
    }

    return Status;
}