P9 changes for PR core restriction

Covers the work required to support the P9 module vpd and new EQ/EX/EC core
structure in relation to the processing of the PR keyword to restrict the
number of cores.

Add new traces or enhance old traces with additional data to improve debug.

Update the module vpd binary for our standalone model.

Change-Id: I20018ccf1daa429e5b0ad9e38f50b1bc5943bcb5
RTC:145459
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/705
Tested-by: Jenkins Server
Tested-by: FSP CI Jenkins
Reviewed-by: Christian R. Geddes <crgeddes@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>
Reviewed-by: Matthew A. Ploetz <maploetz@us.ibm.com>

10 files changed, 252 insertions, 108 deletions

diff --git a/src/build/simics/hb-pnor-vpd-preload.pl b/src/build/simics/hb-pnor-vpd-preload.pl
index 25a1c5a24..f82cca728 100755
--- a/src/build/simics/hb-pnor-vpd-preload.pl
+++ b/src/build/simics/hb-pnor-vpd-preload.pl
@@ -306,11 +306,15 @@ sub createMVPDData
             {
                 $sourceFile = "$dataPath/$mvpdFile";
             }
+
+            debugMsg( "Using source $sourceFile for machine $machine\n" );
         }
         else
         {
             # No processor, use empty data chunk.
             $sourceFile = $emptyMVPD;
+
+            debugMsg( "Using source $sourceFile\n" );
         }
 
         $result = `dd if=$sourceFile of=$sysMVPDFile conv=notrunc oflag=append 2>&1 1>/dev/null`;
@@ -377,6 +381,8 @@ sub createCVPDData
                 $sourceFile = $emptyMemVPD;
             }
 
+            debugMsg( "Using source $sourceFile\n" );
+
             $result = `dd if=$sourceFile of=$sysMemVPDFile conv=notrunc oflag=append 2>&1 1>/dev/null`;
             if( $? )
             {
@@ -439,6 +445,8 @@ sub createSPDData
                     $sourceFile = $emptySPD;
                 }
 
+                debugMsg( "Using source $sourceFile\n" );
+
                 $result = `dd if=$sourceFile of=$sysSPDFile conv=notrunc oflag=append 2>&1 1>/dev/null`;
                 if( $? )
                 {
diff --git a/src/include/usr/hwas/common/hwas.H b/src/include/usr/hwas/common/hwas.H
index 2a6d59ed9..8dafb39ae 100644
--- a/src/include/usr/hwas/common/hwas.H
+++ b/src/include/usr/hwas/common/hwas.H
@@ -81,31 +81,36 @@ errlHndl_t initHardware();
 errlHndl_t discoverTargets();
 
 /**
- * @brief   restrictEXunits   Internal HWAS function to restrict the EXs
+ * @brief   restrictECunits   Internal HWAS function to restrict the ECs
  *
- *  This routine will walk through the procs in the list, and turn EX
+ *  This routine will walk through the procs in the list, and turn EC
  *  units to not functional if the number of units is larger than the max
  *  given. This is used for PR keyword and Field Core Override (FCO)
  *  processing.
  *
  * @param[in] i_procRestrict   vector of procRestrict entries
  * @param[in] i_present    boolean for 'present' HWAS value for restricted
- *                          EX units
+ *                          EC units
  * @param[in] i_deconfigReason   DECONFIGURED_BY_ enum or 0
  *
  * @return errlHndl_t       valid errlHndl_t handle if there was an error
  *                          NULL if no errors;
  */
 
-// structure used to store proc information for EX restrict processing
+// Maximum number of EXs per proc
+#define NUM_EX_PER_EQ     2
+#define NUM_EQ_PER_CHIP   6
+#define NUM_EX_PER_CHIP   (NUM_EX_PER_EQ * NUM_EQ_PER_CHIP)
+
+// structure used to store proc information for EC restrict processing
 typedef struct {
     TARGETING::TargetHandle_t target;      // proc target
     uint32_t group;             // uniq id for this group - ie: FRUID, node
-    uint32_t maxEXs;            // max EX units for this group
+    uint32_t maxECs;            // max EC units for this group
     uint8_t procs;              // number of procs in the group
 } procRestrict_t;
 
-errlHndl_t restrictEXunits(
+errlHndl_t restrictECunits(
     std::vector <procRestrict_t> &i_procRestrict,
     const bool i_present,
     const uint32_t i_deconfigReason);
diff --git a/src/usr/fapi2/test/fapi2GetChildrenTest.H b/src/usr/fapi2/test/fapi2GetChildrenTest.H
index 855028cb5..ddcf1f9ae 100644
--- a/src/usr/fapi2/test/fapi2GetChildrenTest.H
+++ b/src/usr/fapi2/test/fapi2GetChildrenTest.H
@@ -142,10 +142,11 @@ void test_fapi2GetChildren()
 //         l_actualSize = l_childMCAs.size();
 //
 //         //Set expected size to be the number of MCAs per MCBIST
-//         l_expectedSize = 2;
+//         l_expectedSize = MCA_PER_MCS * MCS_PER_PROC / MCBIST_PER_PROC;
 //         numTests++;
 //         if(l_actualSize != l_expectedSize)
 //         {
+//             FAPI_INF("fapi2TargetTest:: MCAs per MCBIST mismatch");
 //             numFails++;
 //             break;
 //         }
@@ -159,6 +160,7 @@ void test_fapi2GetChildren()
         numTests++;
         if(l_actualSize != l_expectedSize)
         {
+            FAPI_INF("fapi2TargetTest:: present cores per proc mismatch");
             numFails++;
             break;
         }
@@ -168,10 +170,11 @@ void test_fapi2GetChildren()
         l_actualSize = l_childCores.size();
 
         //Set expected size to be the number of cores per proc
-        l_expectedSize = 1;
+        l_expectedSize = EQ_PER_PROC * EX_PER_EQ * CORE_PER_EX;
         numTests++;
         if(l_actualSize != l_expectedSize)
         {
+            FAPI_INF("fapi2TargetTest:: functional cores per proc mismatch");
             numFails++;
             break;
         }
@@ -180,11 +183,12 @@ void test_fapi2GetChildren()
         l_targetHuid = TARGETING::get_huid(l_nimbusProc) ;
         l_actualSize = l_childMCAs.size();
 
-        //Set expected size to be the number of cores per proc
-        l_expectedSize = 8;
+        //Set expected size to be the number of MCAs per proc
+        l_expectedSize = MCA_PER_MCS * MCS_PER_PROC;
         numTests++;
         if(l_actualSize != l_expectedSize)
         {
+            FAPI_INF("fapi2TargetTest:: MCAs per proc mismatch");
             numFails++;
             break;
         }
@@ -198,6 +202,7 @@ void test_fapi2GetChildren()
         numTests++;
         if(l_actualSize != l_expectedSize)
         {
+            FAPI_INF("fapi2TargetTest:: cores per EX mismatch");
             numFails++;
             break;
         }
@@ -211,6 +216,7 @@ void test_fapi2GetChildren()
         numTests++;
         if(l_actualSize != l_expectedSize)
         {
+            FAPI_INF("fapi2TargetTest:: cores per EQ mismatch");
             numFails++;
             break;
         }
@@ -379,6 +385,7 @@ void test_fapi2GetChildren()
 
             if(candidateTarget == NULL)
             {
+                FAPI_INF("fapi2TargetTest:: candidateTarget not found");
                 numFails++;
                 break;
             }
@@ -392,6 +399,7 @@ void test_fapi2GetChildren()
 
             if(l_actualSize != l_expectedSize)
             {
+                FAPI_INF("fapi2TargetTest:: children of pervasive mismatch");
                 numFails++;
                 break;
             }
diff --git a/src/usr/fapi2/test/fapi2TestUtils.H b/src/usr/fapi2/test/fapi2TestUtils.H
index c2f6d2649..8fb194c1e 100644
--- a/src/usr/fapi2/test/fapi2TestUtils.H
+++ b/src/usr/fapi2/test/fapi2TestUtils.H
@@ -36,6 +36,9 @@
 #define EQ_PER_PROC 6
 #define EX_PER_EQ 2
 #define CORE_PER_EX 2
+#define MCS_PER_PROC 4
+#define MCA_PER_MCS 2
+#define MCBIST_PER_PROC 2
 
 #include <fapi2.H>
 
diff --git a/src/usr/hwas/HBconfig b/src/usr/hwas/HBconfig
index f20bab8d1..371bca3b0 100644
--- a/src/usr/hwas/HBconfig
+++ b/src/usr/hwas/HBconfig
@@ -1,7 +1,7 @@
-config SKIP_RESTRICT_EX_UNITS
+config SKIP_RESTRICT_EC_UNITS
     default n
     help
-        Skip restricting the number of ex/cores based on PR keyword
+        Skip restricting the number of ec/cores based on PR keyword
 
 config NO_GARD_SUPPORT
     default n
diff --git a/src/usr/hwas/common/deconfigGard.C b/src/usr/hwas/common/deconfigGard.C
index 5e08ed095..8071d7df5 100644
--- a/src/usr/hwas/common/deconfigGard.C
+++ b/src/usr/hwas/common/deconfigGard.C
@@ -752,7 +752,7 @@ errlHndl_t DeconfigGard::processFieldCoreOverride()
             std::sort(pProcList.begin(), pProcList.end(),
                     compareTargetHuid);
 
-            // create list for restrictEXunits() function
+            // create list for restrictECunits() function
             procRestrict_t l_procEntry;
             std::vector <procRestrict_t> l_procRestrictList;
             for (TargetHandleList::const_iterator
@@ -764,22 +764,22 @@ errlHndl_t DeconfigGard::processFieldCoreOverride()
                 const TargetHandle_t pProc = *pProc_it;
 
                 // save info so that we can
-                //  restrict the number of EX units
+                //  restrict the number of EC units
                 HWAS_DBG("pProc %.8X - pushing to proclist",
                     get_huid(pProc));
                 l_procEntry.target = pProc;
                 l_procEntry.group = 0;
                 l_procEntry.procs = pProcList.size();
-                l_procEntry.maxEXs = l_fco;
+                l_procEntry.maxECs = l_fco;
                 l_procRestrictList.push_back(l_procEntry);
             } // for pProc_it
 
-            // restrict the EX units; units turned off are marked
+            // restrict the EC units; units turned off are marked
             //  present=true, functional=false, and marked with the
             //  appropriate deconfigure code.
-            HWAS_INF("FCO: calling restrictEXunits with %d entries",
+            HWAS_INF("FCO: calling restrictECunits with %d entries",
                     l_procRestrictList.size());
-            l_pErr = restrictEXunits(l_procRestrictList,
+            l_pErr = restrictECunits(l_procRestrictList,
                         true, DECONFIGURED_BY_FIELD_CORE_OVERRIDE);
             if (l_pErr)
             {
diff --git a/src/usr/hwas/common/hwas.C b/src/usr/hwas/common/hwas.C
index 064563a1b..2b7f584c2 100644
--- a/src/usr/hwas/common/hwas.C
+++ b/src/usr/hwas/common/hwas.C
@@ -52,7 +52,6 @@
 #include <hwas/common/hwas_reasoncodes.H>
 #include <targeting/common/utilFilter.H>
 
-
 namespace HWAS
 {
 
@@ -364,16 +363,16 @@ errlHndl_t discoverTargets()
                             l_procEntry.group = pTarget->getAttr<ATTR_FRU_ID>();
                             l_procEntry.procs =
                                         (prData[7] & VPD_VINI_PR_B7_MASK) + 1;
-                            l_procEntry.maxEXs = l_procEntry.procs *
+                            l_procEntry.maxECs = l_procEntry.procs *
                                         (prData[2] & VPD_VINI_PR_B2_MASK)
                                             >> VPD_VINI_PR_B2_SHIFT;
                             l_procPRList.push_back(l_procEntry);
 
-                            if (l_procEntry.maxEXs == 0)
+                            if (l_procEntry.maxECs == 0)
                             {
                                 // this is PROBABLY bad PR, so YELL...
                                 HWAS_ERR("pTarget %.8X - PR VPD says 0 CORES",
-                                   pTarget->getAttr<ATTR_HUID>());
+                                    pTarget->getAttr<ATTR_HUID>());
                             }
                         }
                       }
@@ -443,17 +442,17 @@ errlHndl_t discoverTargets()
             }
         }
 
-        // PR keyword processing - potentially reduce the number of ex/core
+        // PR keyword processing - potentially reduce the number of ec/core
         //  units that are functional based on what's in the PR keyword.
-        //  call to restrict EX units, marking bad units as present=false;
+        //  call to restrict EC units, marking bad units as present=false;
         //  deconfigReason = 0 because present is false so this is not a
         //  deconfigured event.
-#ifndef CONFIG_SKIP_RESTRICT_EX_UNITS
-        errl = restrictEXunits(l_procPRList, false, 0);
+#ifndef CONFIG_SKIP_RESTRICT_EC_UNITS
+        errl = restrictECunits(l_procPRList, false, 0);
 
         if (errl)
         {
-            HWAS_ERR("discoverTargets: restrictEXunits failed");
+            HWAS_ERR("discoverTargets: restrictECunits failed");
             break;
         }
 #endif
@@ -922,16 +921,14 @@ bool isDescFunctional(const TARGETING::TargetHandle_t &i_desc,
 
 
 
-errlHndl_t restrictEXunits(
+errlHndl_t restrictECunits(
     std::vector <procRestrict_t> &i_procList,
     const bool i_present,
     const uint32_t i_deconfigReason)
 {
-    HWAS_INF("restrictEXunits entry, %d elements", i_procList.size());
+    HWAS_INF("restrictECunits entry, %d elements", i_procList.size());
     errlHndl_t errl = NULL;
 
-    // @todo RTC:145459 - P9 changes for PR core restriction
-    return errl;
     // sort by group so PROC# are in the right groupings.
     std::sort(i_procList.begin(), i_procList.end(),
                 compareProcGroup);
@@ -946,20 +943,23 @@ errlHndl_t restrictEXunits(
     {
         // determine the number of procs we should enable
         uint8_t procs = i_procList[procIdx].procs;
-        uint32_t maxEXs = i_procList[procIdx].maxEXs;
+        uint32_t maxECs = i_procList[procIdx].maxECs;
 
         // this procs number, used to determine groupings
         uint32_t thisGroup = i_procList[procIdx].group;
 
-        HWAS_INF("procRestrictList[%d] - maxEXs %d, procs %d, group %d",
-                procIdx, maxEXs, procs, thisGroup);
+        HWAS_INF("procRestrictList[%d] - maxECs %d, procs %d, group %d",
+                procIdx, maxECs, procs, thisGroup);
 
-        // exs and iters for each proc in this vpd set
+        // exs, ecs, and iters for each proc in this vpd set
         TargetHandleList pEXList[procs];
         TargetHandleList::const_iterator pEX_it[procs];
+        TargetHandleList pECList[procs][NUM_EX_PER_CHIP];
+        TargetHandleList::const_iterator pEC_it[procs][NUM_EX_PER_CHIP];
 
         // find the proc's that we think are in this group
-        uint32_t currentEXs = 0;
+        uint32_t currentPairedECs = 0;
+        uint32_t currentSingleECs = 0;
         for (uint32_t i = 0; i < procs; ) // increment in loop
         {
             TargetHandle_t pProc = i_procList[procIdx].target;
@@ -988,13 +988,47 @@ errlHndl_t restrictEXunits(
                 // sort the list by ATTR_HUID to ensure that we
                 //  start at the same place each time
                 std::sort(pEXList[i].begin(), pEXList[i].end(),
-                            compareTargetHuid);
+                          compareTargetHuid);
 
                 // keep a pointer into that list
                 pEX_it[i] = pEXList[i].begin();
 
-                // keep local count of current functional EX units
-                currentEXs += pEXList[i].size();
+                for (uint32_t j = 0;
+                     (j < NUM_EX_PER_CHIP) && (pEX_it[i] != pEXList[i].end());
+                     j++)
+                {
+                    TargetHandle_t pEX = *(pEX_it[i]);
+
+                    // get this EX's (CHILD) functional EC/core units
+                    getChildChiplets(pECList[i][j], pEX,
+                                     TYPE_CORE, true);
+
+                    if (!pECList[i][j].empty())
+                    {
+                        // sort the list by ATTR_HUID to ensure that we
+                        //  start at the same place each time
+                        std::sort(pECList[i][j].begin(), pECList[i][j].end(),
+                                  compareTargetHuid);
+
+                        // keep a pointer into that list
+                        pEC_it[i][j] = pECList[i][j].begin();
+
+                        // keep local count of current functional EC units
+                        if (pECList[i][j].size() == 2)
+                        {
+                            // track ECs that can make a fused-core pair
+                            currentPairedECs += pECList[i][j].size();
+                        }
+                        else
+                        {
+                            // track ECs without a pair for a fused-core
+                            currentSingleECs += pECList[i][j].size();
+                        }
+                    }
+
+                    // go to next EX
+                    (pEX_it[i])++;
+                } // for j < NUM_EX_PER_CHIP
 
                 // go to next proc
                 i++;
@@ -1008,88 +1042,99 @@ errlHndl_t restrictEXunits(
             // advance the outer loop as well since we're doing these
             //  procs together
             ++procIdx;
-        } // for
+        } // for i < procs
 
-        if (currentEXs <= maxEXs)
+        if ((currentPairedECs + currentSingleECs) <= maxECs)
         {
             // we don't need to restrict - we're done with this group.
-            HWAS_DBG("currentEXs %d <= maxEXs %d -- done",
-                    currentEXs, maxEXs);
+            HWAS_DBG("currentECs %d <= maxECs %d -- done",
+                    (currentPairedECs + currentSingleECs), maxECs);
             continue;
         }
 
-        HWAS_DBG("currentEXs %d > maxEXs %d -- restricting!",
-                currentEXs, maxEXs);
-
-        // now need to find EX units that stay function, going
-        //  across the list of units for each proc we have, until
-        //  we get to the max or run out of EXs.
-        uint8_t procs_remaining = procs;
-        uint32_t goodEXs = 0;
-        HWAS_DBG("procs %d maxEXs %d", procs, maxEXs);
-        do
+        HWAS_DBG("currentECs %d > maxECs %d -- restricting!",
+                (currentPairedECs + currentSingleECs), maxECs);
+
+        // now need to find EC units that stay functional, going
+        //  across the list of units for each proc and EX we have,
+        //  until we get to the max or run out of ECs, giving
+        //  preference to paired ECs and if we are in fused mode
+        //  excluding single, non-paired ECs.
+
+        // Use as many paired ECs as we can up to maxECs
+        uint32_t pairedECs_remaining =
+            (maxECs < currentPairedECs) ? maxECs : currentPairedECs;
+        // If not in fused mode, use single ECs as needed to get to maxECs
+        uint32_t singleECs_remaining =
+            ((maxECs > currentPairedECs) && !is_fused_mode())
+            ? (maxECs - currentPairedECs) : 0;
+        uint32_t goodECs = 0;
+        HWAS_DBG("procs %d maxECs %d", procs, maxECs);
+
+        // Each pECList has ECs for a given EX and proc.  Check each EC list to
+        //  determine if it has an EC pair or a single EC and if the remaining
+        //  count indicates the given EC from that list is to stay functional.
+
+        // Cycle through the procs
+        for (uint32_t i = 0; i < procs; i++)
         {
-            // now cycle thru the procs, stopping when we either hit
-            //  the end, or when we hit our maxEXs limit
-            for (uint32_t i = 0;(i < procs) && (goodEXs < maxEXs);i++)
+            // Cycle through the EXs for this proc
+            for (uint32_t j = 0; j < NUM_EX_PER_CHIP; j++)
             {
-                // if we have EX units still to process
-                //  from this processor
-                if (pEX_it[i] != pEXList[i].end())
+                // Walk through the EC list from this EX
+                while (pEC_it[i][j] != pECList[i][j].end())
                 {
-                    // got a functional EX
-                    goodEXs++;
-                    HWAS_DBG("pEX   %.8X - is good %d!",
-                        (*(pEX_it[i]))->getAttr<ATTR_HUID>(), goodEXs);
-
-                    (pEX_it[i])++; // next ex/core in this proc's list
-
-                    // check to see if we just hit the end of the list
-                    if (pEX_it[i] == pEXList[i].end())
+                    // Check if EC pair for this EX
+                    if ((pECList[i][j].size() == 2) &&
+                        (pairedECs_remaining != 0))
                     {
-                        procs_remaining--;
-                        continue;
+                        // got a functional EC that is part of a pair
+                        goodECs++;
+                        pairedECs_remaining--;
+                        HWAS_DBG("pEC   %.8X - is good %d!",
+                                 (*(pEC_it[i][j]))->getAttr<ATTR_HUID>(),
+                                 goodECs);
+                    }
+                    // Check if single EC for this EX
+                    else if ((pECList[i][j].size() == 1) &&
+                             (singleECs_remaining != 0))
+                    {
+                        // got a functional EC without a pair
+                        goodECs++;
+                        singleECs_remaining--;
+                        HWAS_DBG("pEC   %.8X - is good %d!",
+                                 (*(pEC_it[i][j]))->getAttr<ATTR_HUID>(),
+                                 ++goodECs);
+                    }
+                    // Otherwise paired or single EC, but not needed for maxECs
+                    else
+                    {
+                        // got an EC to be restricted and marked not functional
+                        TargetHandle_t l_pEC = *(pEC_it[i][j]);
+                        enableHwasState(l_pEC, i_present,
+                                        false, i_deconfigReason);
+                        HWAS_INF("pEC   %.8X - marked %spresent,"
+                                 " NOT functional",
+                                 l_pEC->getAttr<ATTR_HUID>(),
+                                 i_present ? "" : "NOT ");
                     }
-                }
-            } // for
-        }
-        while ((goodEXs < maxEXs) && (procs_remaining != 0));
 
-        // now mark the rest of the EXs as non-functional
-        for (uint32_t i = 0;i < procs;i++)
-        {
-            // walk thru the rest of the EX list
-            while (pEX_it[i] != pEXList[i].end())
-            {
-                TargetHandle_t l_pEX = *(pEX_it[i]);
-                enableHwasState(l_pEX, i_present, false, i_deconfigReason);
-                HWAS_INF("pEX   %.8X - marked %spresent, NOT functional",
-                        l_pEX->getAttr<ATTR_HUID>(),
-                        i_present ? "" : "NOT ");
-
-                // now need to mark the child CORE
-                TargetHandleList pCoreList;
-                getChildChiplets(pCoreList, l_pEX, TYPE_CORE, true);
-                enableHwasState(pCoreList[0], i_present, false,
-                        i_deconfigReason);
-                HWAS_INF("pCore %.8X - marked %spresent, NOT functional",
-                        l_pEX->getAttr<ATTR_HUID>(),
-                        i_present ? "" : "NOT ");
-                (pEX_it[i])++; // next ex/core in this proc's list
-            }
-        } // for making remaining non-functional
+                    (pEC_it[i][j])++; // next ec in this ex's list
+                } // while pEC_it[i][j] != pECList[i][j].end()
+            } // for j < NUM_EX_PER_CHIP
+        } // for i < procs
     } // for procIdx < l_ProcCount
 
     if (errl)
     {
-        HWAS_INF("restrictEXunits failed (plid 0x%X)", errl->plid());
+        HWAS_INF("restrictECunits failed (plid 0x%X)", errl->plid());
     }
     else
     {
-        HWAS_INF("restrictEXunits completed successfully");
+        HWAS_INF("restrictECunits completed successfully");
     }
     return errl;
-} // restrictEXunits
+} // restrictECunits
 
 
 void checkCriticalResources(uint32_t & io_commonPlid,
@@ -1339,9 +1384,9 @@ errlHndl_t checkMinimumHardware(const TARGETING::ConstTargetHandle_t i_nodeOrSys
         else
         {
             // we have a Master Proc and it's functional
-            // check for at least 1 functional ex/core on Master Proc
+            // check for at least 1 functional ec/core on Master Proc
             TargetHandleList l_cores;
-            PredicateCTM l_core(CLASS_UNIT, TYPE_EX);
+            PredicateCTM l_core(CLASS_UNIT, TYPE_CORE);
             PredicatePostfixExpr l_coresFunctional;
             l_coresFunctional.push(&l_core).push(&l_functional).And();
             targetService().getAssociated(l_cores, l_pMasterProc,
diff --git a/src/usr/hwas/test/hwas1test.H b/src/usr/hwas/test/hwas1test.H
index b6aad2fa2..1f24dadd0 100644
--- a/src/usr/hwas/test/hwas1test.H
+++ b/src/usr/hwas/test/hwas1test.H
@@ -1236,6 +1236,73 @@ public:
         TS_TRACE( "testHWASisDescFunctional exit" );
     }
 
+    /**
+     * @brief   test restrictECunits
+     */
+    void testHWASrestrictECunits()
+    {
+        using namespace HWAS;
+        using namespace TARGETING;
+
+        errlHndl_t errl = NULL;
+
+        // list of procs and data that we'll need to look at the PR keyword
+        procRestrict_t l_procEntry;
+        std::vector <procRestrict_t> l_procPRList;
+
+        // Get list of present targets with type PROC
+        TargetHandleList pCheckPres;
+        getAllChips( pCheckPres, TYPE_PROC, true );
+
+        for (TargetHandleList::const_iterator pTarget_it = pCheckPres.begin();
+             pTarget_it != pCheckPres.end();
+             ++pTarget_it
+            )
+        {
+            TargetHandle_t pTarget = *pTarget_it;
+
+            // read the PR keywords that we need, so that if
+            //  we have errors, we can handle them as approprite.
+            uint8_t prData[VPD_VINI_PR_DATA_LENGTH/sizeof(uint8_t)];
+            bzero(prData, sizeof(prData));
+            errl = platReadPR(pTarget, prData);
+            if (errl != NULL)
+            {   // read of PR keyword failed
+                TS_FAIL("testHWASrestrictECunits>"
+                        "pTarget %.8X - read PR failed - bad",
+                        pTarget->getAttr<ATTR_HUID>());
+            }
+            else
+            {
+                // save info so that we can
+                //  process the PR keyword after this loop
+                l_procEntry.target = pTarget;
+                l_procEntry.group = pTarget->getAttr<ATTR_FRU_ID>();
+                l_procEntry.procs = (prData[7] & VPD_VINI_PR_B7_MASK) + 1;
+                l_procEntry.maxECs = l_procEntry.procs *
+                    (prData[2] & VPD_VINI_PR_B2_MASK) >> VPD_VINI_PR_B2_SHIFT;
+                l_procPRList.push_back(l_procEntry);
+
+                if (l_procEntry.maxECs == 0)
+                {
+                    // this is PROBABLY bad PR, so YELL...
+                    TS_FAIL("testHWASrestrictECunits>"
+                            "pTarget %.8X - PR VPD says 0 CORES",
+                            pTarget->getAttr<ATTR_HUID>());
+                }
+            }
+        } // for pTarget_it
+
+        // Call restrictECunits
+        errl = restrictECunits(l_procPRList, false, 0);
+        if (errl != NULL)
+        {   // restrict EC units failed
+            TS_FAIL("testHWASrestrictECunits> - restrict EC units failed");
+        }
+
+        TS_TRACE( "testHWASrestrictECunits exit" );
+    }
+
 };
 
 #endif //
diff --git a/src/usr/vpd/ipvpd.C b/src/usr/vpd/ipvpd.C
index e148bc970..8067d24a5 100644
--- a/src/usr/vpd/ipvpd.C
+++ b/src/usr/vpd/ipvpd.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2015                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2016                        */
 /* [+] Google Inc.                                                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
@@ -1435,7 +1435,9 @@ errlHndl_t IpVpdFacade::retrieveKeyword ( const char * i_keywordName,
     errlHndl_t err = NULL;
 
     TRACSSCOMP( g_trac_vpd,
-                ENTER_MRK"IpVpdFacade::retrieveKeyword()" );
+                ENTER_MRK"IpVpdFacade::retrieveKeyword(%s, %s, . . .)",
+                i_keywordName,
+                i_recordName );
 
     do
     {
@@ -1641,7 +1643,9 @@ errlHndl_t IpVpdFacade::fetchDataFromPnor ( uint64_t i_byteAddr,
 {
     errlHndl_t err = NULL;
     TRACSSCOMP( g_trac_vpd,
-                ENTER_MRK"IpVpdFacade::fetchDataFromPnor()" );
+                ENTER_MRK"IpVpdFacade::fetchDataFromPnor(%ld, %d, . . .)",
+                i_byteAddr,
+                i_numBytes );
     do
     {
         // Call a function in the common VPD code
@@ -1679,7 +1683,9 @@ errlHndl_t IpVpdFacade::fetchDataFromEeprom ( uint64_t i_byteAddr,
 {
     errlHndl_t err = NULL;
     TRACSSCOMP( g_trac_vpd,
-                ENTER_MRK"IpVpdFacade::fetchDataFromEeprom()" );
+                ENTER_MRK"IpVpdFacade::fetchDataFromEeprom(%ld, %d, . . .)",
+                i_byteAddr,
+                i_numBytes );
 
     do
     {
@@ -1724,7 +1730,9 @@ errlHndl_t IpVpdFacade::findKeywordAddr ( const char * i_keywordName,
     int matchesFound = 0;
 
     TRACSSCOMP( g_trac_vpd,
-                ENTER_MRK"IpVpdFacade::findKeywordAddr()" );
+                ENTER_MRK"IpVpdFacade::findKeywordAddr(%s, %s, . . .)",
+                i_keywordName,
+                i_recordName );
 
     do
     {
diff --git a/src/usr/vpd/makefile b/src/usr/vpd/makefile
index 482d927ff..2f044d3d5 100644
--- a/src/usr/vpd/makefile
+++ b/src/usr/vpd/makefile
@@ -41,7 +41,7 @@ BINARY_FILES = $(IMGDIR)/dimmspd.dat:3a9f53e3684e57401ed0aed75f25980fca99f40b
 #found for procs CCIN 54E3
 BINARY_FILES += $(IMGDIR)/procmvpd.dat:65759fa4aebd2e3b42b25309504a3007b3b51036
 BINARY_FILES += $(IMGDIR)/procmvpd_ven.dat:dd8507bec946283260f82af212ed32feaeb3363a
-BINARY_FILES += $(IMGDIR)/procmvpd_p9n.dat:c459021cad3335d42274fbf151ecd3647d0df578
+BINARY_FILES += $(IMGDIR)/procmvpd_p9n.dat:99dcbae6e8900149e9d4378cfc15667586a4e363
 
 
 #Update to Centaur DD2.0 for CCIN 31E8