HDAT: Add SMF Memory Region

The SMF memory region was not being populated in HDAT, causing
skiboot to not find any secure memory. This commit adds changes
to include the SMF memory range into HDAT.

Change-Id: I67cfc2787d90604e3da0f61844776c8704ea2640
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/82180
Reviewed-by: Nicholas E Bofferding <bofferdn@us.ibm.com>
Reviewed-by: Jayashankar Padath <jayashankar.padath@in.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M Crowell <dcrowell@us.ibm.com>

4 files changed, 160 insertions, 16 deletions

diff --git a/src/usr/hdat/hdatmsarea.C b/src/usr/hdat/hdatmsarea.C
index 78c3633e8..336428644 100755
--- a/src/usr/hdat/hdatmsarea.C
+++ b/src/usr/hdat/hdatmsarea.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2016,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2016,2019                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -309,7 +309,8 @@ errlHndl_t HdatMsArea::addAddrRange(hdatMsAddr_t &i_start,
                                     bool i_rangeIsMirrorable,
                                     uint8_t i_mirroringAlgorithm,
                                     hdatMsAddr_t &i_startMirrAddr,
-                                    uint32_t  i_memcntlrId)
+                                    uint32_t  i_memcntlrId,
+                                    bool i_hdatSmf)
 {
     HDAT_ENTER();
     errlHndl_t l_errlHndl = NULL;
@@ -324,9 +325,10 @@ errlHndl_t HdatMsArea::addAddrRange(hdatMsAddr_t &i_start,
         l_addr->hdatMsAreaStrAddr = i_start;
         l_addr->hdatMsAreaEndAddr = i_end;
         l_addr->hatMsAreaProcChipId = i_procChipId;
-        l_addr->hdatSMMAttributes.hdatRangeIsMirrorable = 
-                i_rangeIsMirrorable ? 1 : 0; 
+        l_addr->hdatSMMAttributes.hdatRangeIsMirrorable =
+                i_rangeIsMirrorable ? 1 : 0;
         l_addr->hdatSMMAttributes.hdatMirroringAlgorithm = i_mirroringAlgorithm;
+        l_addr->hdatSMMAttributes.hdatIsSMFmemory = i_hdatSmf;
         l_addr->hdatStartMirrAddr = i_startMirrAddr;
         l_addr->hdatMsAreaMemCntId = i_memcntlrId;
         iv_addrRngArrayHdr.hdatArrayCnt++;
@@ -343,7 +345,7 @@ errlHndl_t HdatMsArea::addAddrRange(hdatMsAddr_t &i_start,
          * @userdata2 maximum number of array entries
          * @userdata3 ID number of mainstore area
          * @userdata4 none
-         * @devdesc Failed trying to add another entry to a mainstore area 
+         * @devdesc Failed trying to add another entry to a mainstore area
          *          address range array
          */
         hdatBldErrLog(l_errlHndl,
diff --git a/src/usr/hdat/hdatmsarea.H b/src/usr/hdat/hdatmsarea.H
index 82d454d54..83236d134 100755
--- a/src/usr/hdat/hdatmsarea.H
+++ b/src/usr/hdat/hdatmsarea.H
@@ -119,10 +119,11 @@ struct hdatMsAreaSize_t
  */
 struct hdatSMMAttributes_t
 {
-    uint8_t  hdatRangeIsMirrorable;  // 0x0000 Memory range is mirrorable
-    uint8_t  hdatMirroringAlgorithm; // 0x0001 Hardware mirroring algorithm to
+    uint8_t hdatRangeIsMirrorable;  // 0x0000 Memory range is mirrorable
+    uint8_t hdatMirroringAlgorithm; // 0x0001 Hardware mirroring algorithm to
                                       // use
-    uint16_t hdatReserved;           // 0x0002
+    uint8_t hdatIsSMFmemory;        // 0x0002 SMF memory region
+    uint8_t hdatReserved;           // 0x0003
 }  __attribute__ ((packed));
 
 
@@ -418,6 +419,7 @@ public:
    * @param[in] i_startMirrAddr - Specifies the starting mirrorable
    *                          address for range
    * @param[in] i_memcntlrId - Memory Controller ID
+   * @param[in] i_hdatSmf - Whether the range is in SMF memory
    *
    * @return A null error log handle if successful, else the return code pointed
    *         to by o_errlHndl contains one of:
@@ -427,10 +429,11 @@ public:
   errlHndl_t addAddrRange(hdatMsAddr_t &i_start,
                           hdatMsAddr_t &i_end,
                           uint32_t i_procChipId,
-			  bool i_rangeIsMirrorable,
-			  uint8_t i_mirroringAlgorithm,
-			  hdatMsAddr_t &i_startMirrAddr,
-              uint32_t  i_memcntlrId);
+                          bool i_rangeIsMirrorable,
+                          uint8_t i_mirroringAlgorithm,
+                          hdatMsAddr_t &i_startMirrAddr,
+                          uint32_t  i_memcntlrId,
+                          bool i_hdatSmf);
 
 
   /**
diff --git a/src/usr/hdat/hdatmsvpd.C b/src/usr/hdat/hdatmsvpd.C
index def8a37e8..2a7ba42e1 100755
--- a/src/usr/hdat/hdatmsvpd.C
+++ b/src/usr/hdat/hdatmsvpd.C
@@ -609,7 +609,8 @@ errlHndl_t HdatMsVpd::addMsAreaAddr(uint16_t i_msAreaId,
                                     bool i_rangeIsMirrorable,
                                     uint8_t i_mirroringAlgorithm,
                                     uint64_t i_startMirrAddr,
-                                    uint32_t i_hdatMemCntrlID)
+                                    uint32_t i_hdatMemCntrlID,
+                                    bool i_hdatSmf)
 {
     errlHndl_t l_errlHndl = NULL;
     HdatMsArea *l_obj;
@@ -620,8 +621,14 @@ errlHndl_t HdatMsVpd::addMsAreaAddr(uint16_t i_msAreaId,
     if (i_msAreaId < iv_actMsAreaCnt)
     {
         l_obj = HDAT_MS_AREA(i_msAreaId);
-        l_errlHndl = l_obj->addAddrRange(i_start, i_end, i_procChipId,
-        i_rangeIsMirrorable, i_mirroringAlgorithm, l_startMirrAddr, i_hdatMemCntrlID);
+        l_errlHndl = l_obj->addAddrRange(i_start,
+                                         i_end,
+                                         i_procChipId,
+                                         i_rangeIsMirrorable,
+                                         i_mirroringAlgorithm,
+                                         l_startMirrAddr,
+                                         i_hdatMemCntrlID,
+                                         i_hdatSmf);
     }
     else
     {
@@ -1094,6 +1101,8 @@ errlHndl_t  HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count)
 
         for(;l_procs;++l_procs)
         {
+            bool l_smfAdded = false;
+
             TARGETING::Target *l_pProcTarget = *(l_procs);
             TARGETING::ATTR_ORDINAL_ID_type l_procChipId
                          = l_pProcTarget->getAttr<TARGETING::ATTR_ORDINAL_ID>();
@@ -1639,9 +1648,69 @@ errlHndl_t  HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count)
                                 l_nhtmSize=0; //only add 1 entry
                             }
                             l_addr_range = l_end;
+
+                            auto l_smfStartAddr = l_pProcTarget->
+                              getAttr<TARGETING::ATTR_PROC_SMF_BAR_BASE_ADDR>();
+                            auto l_smfSize = l_pProcTarget->
+                                getAttr<TARGETING::ATTR_PROC_SMF_BAR_SIZE>();
+
+                            if(l_smfSize && !l_smfAdded)
+                            {
+                                hdatMsAddr_t l_hdatSmfStartAddr{};
+                                hdatMsAddr_t l_hdatSmfEndAddr{};
+                                l_hdatSmfStartAddr.hi =
+                                 (l_smfStartAddr & 0xFFFFFFFF00000000ull) >> 32;
+                                l_hdatSmfStartAddr.lo =
+                                    l_smfStartAddr & 0x00000000FFFFFFFFull;
+                                l_hdatSmfStartAddr.hi |= HDAT_REAL_ADDRESS_MASK;
+
+                                l_hdatSmfEndAddr.hi =
+                                    ((l_smfStartAddr + l_smfSize) &
+                                    0xFFFFFFFF00000000ull) >>32;
+                                l_hdatSmfEndAddr.lo =
+                                    (l_smfStartAddr + l_smfSize) &
+                                    0x00000000FFFFFFFFull;
+                                l_hdatSmfEndAddr.hi |= HDAT_REAL_ADDRESS_MASK;
+
+                                l_err = addMsAreaAddr(l_index,
+                                                      l_hdatSmfStartAddr,
+                                                      l_hdatSmfEndAddr,
+                                                      l_procChipId,
+                                                      false, //rangeIsMirrorable
+                                                      0, // i_mirroringAlgorithm
+                                                      0, // i_startMirrAddr
+                                                      l_hdatMemcntrlID,
+                                                      true); // i_hdatsmf
+                                l_smfAdded = true;
+                            }
+
+                            if(l_err)
+                            {
+                                HDAT_ERR("Could not add SMF memory range to "
+                                         "HDAT at index[%d]", l_index);
+                                break;
+                            }
+                            else
+                            {
+                                HDAT_INF("Added SMF memory range to HDAT at "
+                                        "index[%d]; start addr: 0x%08x; end addr: 0x%08x"
+                                        "; size: 0x%08x",
+                                        l_smfStartAddr,
+                                        l_smfStartAddr + l_smfSize,
+                                        l_smfSize);
+                            }
+
                             l_index++;
                         } //end of mca list
+                        if(l_err)
+                        {
+                            break;
+                        }
                     } //end of MCS list
+                    if(l_err)
+                    {
+                        break;
+                    }
                 } //end of MCBIST list
             }
             else //if model is Axone
@@ -2231,11 +2300,79 @@ errlHndl_t  HdatMsVpd::hdatLoadMsData(uint32_t &o_size, uint32_t &o_count)
                                         l_nhtmSize=0; //only add 1 entry
                                     }
                                     l_addr_range = l_end;
+
+                                    // Add SMF memory addr range
+                                    auto l_smfStartAddr = l_pProcTarget->
+                                        getAttr<TARGETING::ATTR_PROC_SMF_BAR_BASE_ADDR>();
+                                    auto l_smfSize = l_pProcTarget->
+                                        getAttr<TARGETING::ATTR_PROC_SMF_BAR_SIZE>();
+
+                                    if(l_smfSize && !l_smfAdded)
+                                    {
+                                        hdatMsAddr_t l_hdatSmfStartAddr{};
+                                        hdatMsAddr_t l_hdatSmfEndAddr{};
+                                        l_hdatSmfStartAddr.hi =
+                                            (l_smfStartAddr & 0xFFFFFFFF00000000ull) >> 32;
+                                        l_hdatSmfStartAddr.lo =
+                                            l_smfStartAddr & 0x00000000FFFFFFFFull;
+                                        l_hdatSmfStartAddr.hi |= HDAT_REAL_ADDRESS_MASK;
+
+                                        l_hdatSmfEndAddr.hi =
+                                            ((l_smfStartAddr + l_smfSize) &
+                                            0xFFFFFFFF00000000ull) >>32;
+                                        l_hdatSmfEndAddr.lo =
+                                            (l_smfStartAddr + l_smfSize) &
+                                            0x00000000FFFFFFFFull;
+                                        l_hdatSmfEndAddr.hi |= HDAT_REAL_ADDRESS_MASK;
+
+                                        l_err = addMsAreaAddr(l_index,
+                                                              l_hdatSmfStartAddr,
+                                                              l_hdatSmfEndAddr,
+                                                              l_procChipId,
+                                                              false, //rangeIsMirrorable
+                                                              0, // i_mirroringAlgorithm
+                                                              0, // i_startMirrAddr
+                                                              l_hdatMemcntrlID,
+                                                              true); // i_hdatsmf
+                                        l_smfAdded = true;
+                                    }
+
+                                    if(l_err)
+                                    {
+                                        HDAT_ERR("Could not add SMF memory range to "
+                                             "HDAT at index[%d]", l_index);
+                                        break;
+                                    }
+                                    else
+                                    {
+                                        HDAT_INF("Added SMF memory range to HDAT at "
+                                            "index[%d]; start addr: 0x%08x; end addr: 0x%08x"
+                                            "; size: 0x%08x",
+                                            l_smfStartAddr,
+                                            l_smfStartAddr + l_smfSize,
+                                            l_smfSize);
+                                    }
                                     l_index++;
                                 } // end of OCMB_CHIP list
+                                if(l_err)
+                                {
+                                    break;
+                                }
                             } //end of OMI list
+                            if(l_err)
+                            {
+                                break;
+                            }
                         } //end of MCC list
+                        if(l_err)
+                        {
+                            break;
+                        }
                     } //end of MI list
+                    if(l_err)
+                    {
+                        break;
+                    }
                 } //end of MC list
             }
             if(l_err)
diff --git a/src/usr/hdat/hdatmsvpd.H b/src/usr/hdat/hdatmsvpd.H
index 86aecaa42..93955ba39 100755
--- a/src/usr/hdat/hdatmsvpd.H
+++ b/src/usr/hdat/hdatmsvpd.H
@@ -636,6 +636,7 @@ class HdatMsVpd : public HdatHdif
          * @param[in] i_startMirrAddr - Specifies the starting mirrorable
          *                          address for range
          * @param[in] i_hdatMemCntlID - Memory Controller ID
+         * @param[in] i_hdatSmf - Whether the range is in SMF memory
          *
          * @return A null error log handle if successful, else the return code
          * pointed to by errlHndl_t contains one of:
@@ -649,7 +650,8 @@ class HdatMsVpd : public HdatHdif
                                  bool i_rangeIsMirrorable = false,
                                  uint8_t i_mirroringAlgorithm = 0,
                                  uint64_t i_startMirrAddr = 0,
-                                 uint32_t i_hdatMemCntlID = 0);
+                                 uint32_t i_hdatMemCntlID = 0,
+                                 bool i_hdatSmf = false);
 
 
         /**