SMP wrap mode - Run host_load_io_ppe earlier in Wrap mode.

This is done in order to avoid an error if the PPE code
isn't loaded when we attempt to start the PPE.

CQ:SW446328
Change-Id: I32f5ae0c617cf4d29dd6a6744158febe7b05e9da
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/66885
Tested-by: Jenkins Server <pfd-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>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

6 files changed, 271 insertions, 283 deletions

diff --git a/src/include/usr/isteps/istep16list.H b/src/include/usr/isteps/istep16list.H
index 27cdb24ba..a6a5f7df7 100644
--- a/src/include/usr/isteps/istep16list.H
+++ b/src/include/usr/isteps/istep16list.H
@@ -163,6 +163,7 @@ const DepModInfo g_istep16Dependancies = {
         DEP_LIB(libisteps_mss.so),
         DEP_LIB(libpm.so),
         DEP_LIB(libimageprocs.so),
+        DEP_LIB(libisteps_nest.so),
         NULL
     }
 };
diff --git a/src/usr/isteps/istep08/call_host_set_voltages.C b/src/usr/isteps/istep08/call_host_set_voltages.C
index 55e334fa3..70a1ae691 100644
--- a/src/usr/isteps/istep08/call_host_set_voltages.C
+++ b/src/usr/isteps/istep08/call_host_set_voltages.C
@@ -144,7 +144,13 @@ void* call_host_set_voltages(void *io_pArgs)
             fapiHWPCallWrapperHandler(P9_FBC_EFF_CONFIG_LINKS_F_T, l_stepError,
                                       HWPF_COMP_ID, TYPE_PROC)                  &&
             fapiHWPCallWrapperHandler(P9_SYS_CHIPLET_SCOMINIT, l_stepError,
-                                           HWPF_COMP_ID, TYPE_PROC);
+                                      HWPF_COMP_ID, TYPE_PROC)                  &&
+            // Make call to p9_io_obus_image_build
+            fapiHWPCallWrapperHandler(P9_IO_OBUS_IMAGE_BUILD, l_stepError,
+                                      HWPF_COMP_ID, TYPE_OBUS)                  &&
+            // Make call to p9_io_xbus_image_build
+            fapiHWPCallWrapperHandler(P9_IO_XBUS_IMAGE_BUILD, l_stepError,
+                                      HWPF_COMP_ID, TYPE_PROC);
         }
     }while( 0 );
 
diff --git a/src/usr/isteps/istep16/call_host_load_io_ppe.C b/src/usr/isteps/istep16/call_host_load_io_ppe.C
index 2f0b59f15..27d230359 100644
--- a/src/usr/isteps/istep16/call_host_load_io_ppe.C
+++ b/src/usr/isteps/istep16/call_host_load_io_ppe.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2015,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2015,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -35,8 +35,11 @@
 #include    <fapi2/target.H>
 #include    <fapi2/plat_hwp_invoker.H>
 
-#include    <p9_io_obus_image_build.H>
-#include    <p9_io_xbus_image_build.H>
+// isSMPWrapConfig call support
+#include <initservice/initserviceif.H>
+
+//  HWP call support
+#include <nest/nestHwpHelperFuncs.H>   // fapiHWPCallWrapperForChip
 
 using   namespace   ERRORLOG;
 using   namespace   TARGETING;
@@ -44,166 +47,28 @@ using   namespace   ISTEP;
 using   namespace   ISTEP_ERROR;
 using   namespace   fapi2;
 
-
 namespace ISTEP_16
 {
 
-/**
- *  @brief Load HCODE image and return a pointer to it, or NULL
- *  @param[out] -   address of the HCODE image
- *  @return      NULL if success, errorlog if failure
- */
-errlHndl_t loadHcodeImage(char *& o_rHcodeAddr)
-{
-    errlHndl_t l_err = NULL;
-    PNOR::SectionInfo_t l_info;
-
-    do
-    {
-
-#ifdef CONFIG_SECUREBOOT
-        l_err = loadSecureSection(PNOR::HCODE);
-        if (l_err)
-        {
-            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                       ERR_MRK"loadHcodeImage() - Error from "
-                       "loadSecureSection(PNOR::HCODE)");
-
-            //No need to commit error here, it gets handled later
-            //just break out to escape this function
-            break;
-        }
-#endif
-
-        // Get HCODE/WINK PNOR section info from PNOR RP
-        l_err = PNOR::getSectionInfo( PNOR::HCODE, l_info );
-        if( l_err )
-        {
-            //No need to commit error here, it gets handled later
-            //just break out to escape this function
-            break;
-        }
-
-        o_rHcodeAddr = reinterpret_cast<char*>(l_info.vaddr);
-
-        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                   "HCODE addr = 0x%p ",
-                   o_rHcodeAddr);
-
-    } while ( 0 );
-
-    return  l_err;
-}
-
 void* call_host_load_io_ppe (void *io_pArgs)
 {
-    errlHndl_t  l_err  =   NULL;
     IStepError  l_stepError;
-
-    char* l_pHcodeImage = NULL;
-
     TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_load_io_ppe entry" );
-
     do
     {
-
-        l_err = loadHcodeImage(l_pHcodeImage);
-        if (l_err)
+        if (!INITSERVICE::isSMPWrapConfig())
         {
-            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
-                  "call_host_load_io_ppe ERROR : "
-                  "Unable to load HCODE image errorlog PLID=0x%x",
-                  l_err->plid());
-
-            l_stepError.addErrorDetails(l_err);
-            errlCommit( l_err, ISTEP_COMP_ID );
-            break;
+            // Make call to p9_io_obus_image_build
+            fapiHWPCallWrapperHandler(P9_IO_OBUS_IMAGE_BUILD, l_stepError,
+                                      HWPF_COMP_ID, TYPE_OBUS)               &&
+            // Make call to p9_io_xbus_image_build
+            fapiHWPCallWrapperHandler(P9_IO_XBUS_IMAGE_BUILD, l_stepError,
+                                      HWPF_COMP_ID, TYPE_PROC);
         }
 
-        // Get all OBUS targets
-        TARGETING::TargetHandleList l_obusTargetList;
-        getAllChiplets(l_obusTargetList, TYPE_OBUS);
-        // Get all PROC targets for XBUS
-        TARGETING::TargetHandleList l_procTargetList;
-        getAllChips(l_procTargetList, TYPE_PROC);
-
-        // Loop through OBUS
-        for (const auto & l_obusTarget: l_obusTargetList)
-        {
-            const fapi2::Target<fapi2::TARGET_TYPE_OBUS>
-                l_obusFapi2Target(
-                (const_cast<TARGETING::Target*>(l_obusTarget)));
-
-            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                     "Running p9_io_obus_image_build HWP on "
-                     "OBUS target %.8X",
-                       TARGETING::get_huid(l_obusTarget));
-
-            FAPI_INVOKE_HWP( l_err,
-                      p9_io_obus_image_build,
-                      l_obusFapi2Target,
-                      reinterpret_cast<void*>(l_pHcodeImage));
-
-            if(l_err)
-            {
-                TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                         "ERROR 0x%.8X: returned from p9_io_obus_image_build on "
-                         "OBUS target %.8X, PLID=0x%x",
-                        l_err->reasonCode(),
-                        TARGETING::get_huid(l_obusTarget),
-                        l_err->plid());
-
-                l_stepError.addErrorDetails(l_err);
-                errlCommit(l_err, HWPF_COMP_ID);
-            }
-        } // end of looping through obus
-
-        // Loop through PROC (for XBUS)
-        for (const auto & l_procTarget: l_procTargetList)
-        {
-            const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>
-                l_procFapi2Target(
-                (const_cast<TARGETING::Target*>(l_procTarget)));
-
-            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                     "Running p9_io_xbus_image_build HWP on "
-                     "XBUS target %.8X",
-                       TARGETING::get_huid(l_procTarget));
-
-            FAPI_INVOKE_HWP( l_err,
-                      p9_io_xbus_image_build,
-                      l_procFapi2Target,
-                      reinterpret_cast<void*>(l_pHcodeImage));
-
-            if(l_err)
-            {
-                TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                         "ERROR 0x%.8X: returned from p9_io_xbus_image_build on "
-                         "XBUS target %.8X, PLID=0x%x",
-                        l_err->reasonCode(),
-                        TARGETING::get_huid(l_procTarget),
-                        l_err->plid());
-
-                l_stepError.addErrorDetails(l_err);
-                errlCommit(l_err, HWPF_COMP_ID);
-            }
-        } // end of looping through xbus
     } while( 0 );
 
-#ifdef CONFIG_SECUREBOOT
-    l_err = unloadSecureSection(PNOR::HCODE);
-    if (l_err)
-    {
-        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
-                   ERR_MRK"host_load_io_ppe() - Error from "
-                   "unloadSecureSection(PNOR::HCODE)");
-
-        l_stepError.addErrorDetails( l_err );
-        errlCommit( l_err, ISTEP_COMP_ID );
-    }
-#endif
-
     TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_load_io_ppe exit ");
 
diff --git a/src/usr/isteps/nest/makefile b/src/usr/isteps/nest/makefile
index a858b2cb2..884961b02 100644
--- a/src/usr/isteps/nest/makefile
+++ b/src/usr/isteps/nest/makefile
@@ -35,6 +35,7 @@ EXTRAINCDIR += ${ROOTPATH}/src/usr/isteps/
 EXTRAINCDIR += ${ROOTPATH}/src/include/usr/fapi2/
 EXTRAINCDIR += ${ROOTPATH}/src/import/hwpf/fapi2/include/
 EXTRAINCDIR += ${ROOTPATH}/src/import/chips/common/utils/imageProcs/
+EXTRAINCDIR += ${ROOTPATH}/src/import/chips/p9/xip/
 
 EXTRAINCDIR += ${PROCEDURES_PATH}/hwp/initfiles
 
@@ -83,4 +84,8 @@ include ${PROCEDURES_PATH}/hwp/initfiles/p9_npu_scom.mk
 include ${PROCEDURES_PATH}/hwp/nest/p9_npu_scominit.mk
 include ${PROCEDURES_PATH}/hwp/perv/p9_nv_ref_clk_enable.mk
 
+# p9_io_obus_image_build & p9_io_xbus_image_build
+include ${PROCEDURES_PATH}/hwp/io/p9_io_obus_image_build.mk
+include ${PROCEDURES_PATH}/hwp/io/p9_io_xbus_image_build.mk
+
 include ${ROOTPATH}/config.mk
diff --git a/src/usr/isteps/nest/nestHwpHelperFuncs.C b/src/usr/isteps/nest/nestHwpHelperFuncs.C
index 6ff374f5d..921fd3d35 100644
--- a/src/usr/isteps/nest/nestHwpHelperFuncs.C
+++ b/src/usr/isteps/nest/nestHwpHelperFuncs.C
@@ -55,6 +55,8 @@
 #include <p9_sys_chiplet_scominit.H>
 #include <p9_chiplet_fabric_scominit.H>
 #include <p9_io_obus_firmask_save_restore.H>
+#include <p9_io_obus_image_build.H>
+#include <p9_io_xbus_image_build.H>
 
 namespace ISTEP
 {
@@ -83,6 +85,8 @@ const char * hwpCallToString( HWP_CALL_TYPE i_hwpCall )
         { P9_SYS_CHIPLET_SCOMINIT, "p9_sys_chiplet_scominit" },
         { P9_XBUS_ENABLE_RIDI, "p9_xbus_enable_ridi" },
         { P9_OBUS_FIRMASK_SAVE_RESTORE, "p9_io_obus_firmask_save_restore" },
+        { P9_IO_OBUS_IMAGE_BUILD, "p9_io_obus_image_build" },
+        { P9_IO_XBUS_IMAGE_BUILD, "p9_io_xbus_image_build" },
     };
 
     if (hwpCallToStringMap.count(i_hwpCall) > 0)
@@ -96,6 +100,53 @@ const char * hwpCallToString( HWP_CALL_TYPE i_hwpCall )
 }
 
 /**
+ *  @brief Load HCODE image and return a pointer to it, or NULL
+ *  @param[out] -   address of the HCODE image
+ *  @return      NULL if success, errorlog if failure
+ */
+errlHndl_t loadHcodeImage(char *& o_rHcodeAddr)
+{
+    errlHndl_t l_err = NULL;
+    PNOR::SectionInfo_t l_info;
+
+    do
+    {
+
+#ifdef CONFIG_SECUREBOOT
+        l_err = loadSecureSection(PNOR::HCODE);
+        if (l_err)
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                       ERR_MRK"loadHcodeImage() - Error from "
+                       "loadSecureSection(PNOR::HCODE)");
+
+            //No need to commit error here, it gets handled later
+            //just break out to escape this function
+            break;
+        }
+#endif
+
+        // Get HCODE/WINK PNOR section info from PNOR RP
+        l_err = PNOR::getSectionInfo( PNOR::HCODE, l_info );
+        if( l_err )
+        {
+            //No need to commit error here, it gets handled later
+            //just break out to escape this function
+            break;
+        }
+
+        o_rHcodeAddr = reinterpret_cast<char*>(l_info.vaddr);
+
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                   "HCODE addr = 0x%p ",
+                   o_rHcodeAddr);
+
+    } while ( 0 );
+
+    return  l_err;
+}
+
+/**
  *  fapiHWPCallWrapper
  */
 void fapiHWPCallWrapper(HWP_CALL_TYPE    i_hwpCall,
@@ -111,167 +162,227 @@ void fapiHWPCallWrapper(HWP_CALL_TYPE    i_hwpCall,
 
     // An error handler
     errlHndl_t l_err(nullptr);
-
-    // Get a list of all the processors in the system
+    char* l_pHcodeImage = NULL;
     TARGETING::TargetHandleList l_targetList;
-    if (TARGETING::TYPE_PROC == i_targetType)
-    {
-        getAllChips(l_targetList, i_targetType);
-    }
-    else if (TARGETING::TYPE_OBUS == i_targetType)
-    {
-        getAllChiplets(l_targetList, i_targetType);
-    }
-    else
-    {
-        assert(0, "ERROR: Invalid target type %d", i_targetType);
-    }
 
-    if (l_targetList.empty())
-    {
-        TRACFCOMP(g_trac_isteps_trace, "Target list empty, no targets "
-                  "found. HWP call %s will not be called", l_hwpCallStr);
-    }
+    do {
 
-    // Loop through all processors including master
-    for (const auto & l_target: l_targetList)
-    {
-        // A string to contain an error or success message, defaulted to success
-        char l_errorSuccesStr[l_errorSuccesStrSize] = "SUCCESS";
-
-        TRACFCOMP(g_trac_isteps_trace,
-                  "Running %s HWP on target HUID %.8X",
-                  l_hwpCallStr,
-                  TARGETING::get_huid(l_target));
+        // Load OBUS/XBUS image
+        if ( (P9_IO_OBUS_IMAGE_BUILD == i_hwpCall) ||
+             (P9_IO_XBUS_IMAGE_BUILD == i_hwpCall) )
+        {
+            l_err = loadHcodeImage(l_pHcodeImage);
+            if (l_err)
+            {
+                  TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
+                            "call_host_load_io_ppe ERROR : "
+                            "Unable to load HCODE image errorlog PLID=0x%x",
+                            l_err->plid());
+                  // Capture error and exit
+                  captureError(l_err,
+                               o_stepError,
+                               i_componentId,
+                               NULL);
+                  break;
+             }
+        }
 
-        // Call HWP calls for chips (target type: TYPE_PROC)
+        // Get a list of all the processors in the system
         if (TARGETING::TYPE_PROC == i_targetType)
         {
-            // Get a FAPI2 target of type PROC
-            const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>l_fapi2Target(l_target);
+            getAllChips(l_targetList, i_targetType);
+        }
+        else if (TARGETING::TYPE_OBUS == i_targetType)
+        {
+            getAllChiplets(l_targetList, i_targetType);
+        }
+        else
+        {
+            assert(0, "ERROR: Invalid target type %d", i_targetType);
+        }
 
-            if (P9_XBUS_ENABLE_RIDI == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_xbus_enable_ridi,
-                                l_fapi2Target);
-            }
-            else if (P9_CHIPLET_ENABLE_RIDI == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_chiplet_enable_ridi,
-                                l_fapi2Target);
-            }
-            else if (P9_CHIPLET_SCOMINIT == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_chiplet_scominit,
-                                l_fapi2Target);
-            }
-            else if (P9_PSI_SCOMINIT == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_psi_scominit,
-                                l_fapi2Target);
-            }
-            else if (P9_NPU_SCOMINIT == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_npu_scominit,
-                                l_fapi2Target);
-            }
-            else if (P9_FBC_EFF_CONFIG_LINKS_F_T == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_fbc_eff_config_links,
-                                l_fapi2Target,
-                                SMP_ACTIVATE_PHASE2, // P9 build SMP operation
-                                false,  // process electrical
-                                true);  // process optical
-            }
-            else if (P9_FBC_EFF_CONFIG_LINKS_T_F == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_fbc_eff_config_links,
-                                l_fapi2Target,
-                                SMP_ACTIVATE_PHASE1, // P9 build SMP operation
-                                true,    // process electrical
-                                false);  // process optical
-            }
-            else if (P9_SYS_CHIPLET_SCOMINIT == i_hwpCall)
-            {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_sys_chiplet_scominit,
-                                l_fapi2Target);
-            }
-            else if (P9_CHIPLET_FABRIC_SCOMINIT == i_hwpCall)
+        if (l_targetList.empty())
+        {
+            TRACFCOMP(g_trac_isteps_trace, "Target list empty, no targets "
+                      "found. HWP call %s will not be called", l_hwpCallStr);
+        }
+
+        // Loop through all processors including master
+        for (const auto & l_target: l_targetList)
+        {
+            // A string to contain an error or success message, defaulted to success
+            char l_errorSuccesStr[l_errorSuccesStrSize] = "SUCCESS";
+
+            TRACFCOMP(g_trac_isteps_trace,
+                      "Running %s HWP on target HUID %.8X",
+                      l_hwpCallStr,
+                      TARGETING::get_huid(l_target));
+
+            // Call HWP calls for chips (target type: TYPE_PROC)
+            if (TARGETING::TYPE_PROC == i_targetType)
             {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_chiplet_fabric_scominit,
-                                l_fapi2Target);
-            }
-            else if (P9_OBUS_FIRMASK_SAVE_RESTORE == i_hwpCall)
+                // Get a FAPI2 target of type PROC
+                const fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP>l_fapi2Target(l_target);
+
+                if (P9_XBUS_ENABLE_RIDI == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_xbus_enable_ridi,
+                                    l_fapi2Target);
+                }
+                else if (P9_CHIPLET_ENABLE_RIDI == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_chiplet_enable_ridi,
+                                    l_fapi2Target);
+                }
+                else if (P9_CHIPLET_SCOMINIT == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_chiplet_scominit,
+                                    l_fapi2Target);
+                }
+                else if (P9_PSI_SCOMINIT == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_psi_scominit,
+                                    l_fapi2Target);
+                }
+                else if (P9_NPU_SCOMINIT == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_npu_scominit,
+                                    l_fapi2Target);
+                }
+                else if (P9_FBC_EFF_CONFIG_LINKS_F_T == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_fbc_eff_config_links,
+                                    l_fapi2Target,
+                                    SMP_ACTIVATE_PHASE2, // P9 build SMP operation
+                                    false,  // process electrical
+                                    true);  // process optical
+                }
+                else if (P9_FBC_EFF_CONFIG_LINKS_T_F == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_fbc_eff_config_links,
+                                    l_fapi2Target,
+                                    SMP_ACTIVATE_PHASE1, // P9 build SMP operation
+                                    true,    // process electrical
+                                    false);  // process optical
+                }
+                else if (P9_SYS_CHIPLET_SCOMINIT == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_sys_chiplet_scominit,
+                                    l_fapi2Target);
+                }
+                else if (P9_CHIPLET_FABRIC_SCOMINIT == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_chiplet_fabric_scominit,
+                                    l_fapi2Target);
+                }
+                else if (P9_OBUS_FIRMASK_SAVE_RESTORE == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_io_obus_firmask_save_restore,
+                                    l_fapi2Target, p9iofirmasksaverestore::SAVE);
+                }
+                else if (P9_IO_XBUS_IMAGE_BUILD == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_io_xbus_image_build,
+                                    l_fapi2Target, reinterpret_cast<void*>(l_pHcodeImage));
+                }
+                else
+                {
+                    TRACFCOMP(g_trac_isteps_trace, "ERROR: Invalid/Uknown HWP call");
+                    break;
+                }
+            }  // end if (TARGETING::TYPE_PROC == i_targetType)
+
+            // Call HWP calls for chiplets (target type: TYPE_OBUS)
+            else if (TARGETING::TYPE_OBUS == i_targetType)
             {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_io_obus_firmask_save_restore,
-                                l_fapi2Target, p9iofirmasksaverestore::SAVE);
-            }
+                // Get a FAPI2 target of type OBUS
+                const fapi2::Target<fapi2::TARGET_TYPE_OBUS>l_fapi2Target(l_target);
+
+                if (P9_IO_OBUS_SCOMINIT == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_io_obus_scominit,
+                                    l_fapi2Target);
+                }
+                else if (P9_IO_OBUS_IMAGE_BUILD == i_hwpCall)
+                {
+                    FAPI_INVOKE_HWP(l_err,
+                                    p9_io_obus_image_build,
+                                    l_fapi2Target,
+                                    reinterpret_cast<void*>(l_pHcodeImage));
+                }
+                else
+                {
+                    TRACFCOMP(g_trac_isteps_trace,"ERROR: Invalid/Uknown HWP call");
+                    break;
+                }
+
+            }  // end else if (TARGETING::TYPE_OBUS == i_targetType)
             else
             {
-                TRACFCOMP(g_trac_isteps_trace, "ERROR: Invalid/Uknown HWP call");
-                break;
+               assert(0, "ERROR: Invalid target type %d", i_targetType);
             }
-        }  // end if (TARGETING::TYPE_PROC == i_targetType)
-        // Call HWP calls for chiplets (target type: TYPE_OBUS)
-        else if (TARGETING::TYPE_OBUS == i_targetType)
-        {
-            // Get a FAPI2 target of type OBUS
-            const fapi2::Target<fapi2::TARGET_TYPE_OBUS>l_fapi2Target(l_target);
 
-            if (P9_IO_OBUS_SCOMINIT == i_hwpCall)
+
+            // If an error ocurred with HWP call, setup error message
+            if (l_err)
             {
-                FAPI_INVOKE_HWP(l_err,
-                                p9_io_obus_scominit,
-                                l_fapi2Target);
+                snprintf(l_errorSuccesStr, l_errorSuccesStrSize,
+                         "ERROR 0x%.8X", l_err->plid());
             }
-            else
+
+            TRACFCOMP(g_trac_isteps_trace,
+                      "%s: %s HWP returned %s with target HUID 0x%.8X",
+                      l_errorSuccesStr,
+                      l_hwpCallStr,
+                      (l_err ? "an error" : "success"),
+                      TARGETING::get_huid(l_target));
+
+            if (l_err)
             {
-                TRACFCOMP(g_trac_isteps_trace,"ERROR: Invalid/Uknown HWP call");
-                break;
+                // Capture error and continue
+                captureError(l_err,
+                             o_stepError,
+                             i_componentId,
+                             l_target);
             }
-        }  // end else if (TARGETING::TYPE_OBUS == i_targetType)
-        else
-        {
-           assert(0, "ERROR: Invalid target type %d", i_targetType);
-        }
-
 
-        // If an error ocurred with HWP call, setup error message
-        if (l_err)
-        {
-            snprintf(l_errorSuccesStr, l_errorSuccesStrSize,
-                     "ERROR 0x%.8X", l_err->plid());
-        }
+        } // end for (const auto & l_target: l_targetList)
 
-        TRACFCOMP(g_trac_isteps_trace,
-                  "%s: %s HWP returned %s with target HUID 0x%.8X",
-                  l_errorSuccesStr,
-                  l_hwpCallStr,
-                  (l_err ? "an error" : "success"),
-                  TARGETING::get_huid(l_target));
+    } while (0);
 
+#ifdef CONFIG_SECUREBOOT
+    if ( (P9_IO_OBUS_IMAGE_BUILD == i_hwpCall) ||
+           (P9_IO_XBUS_IMAGE_BUILD == i_hwpCall) )
+    {
+        l_err = unloadSecureSection(PNOR::HCODE);
         if (l_err)
         {
-            // Capture error and continue
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                       ERR_MRK"host_load_io_ppe() - Error from "
+                       "unloadSecureSection(PNOR::HCODE)");
             captureError(l_err,
                          o_stepError,
                          i_componentId,
-                         l_target);
+                         NULL);
         }
-    } // end for (const auto & l_target: l_targetList)
+    }
+#endif
 
     TRACFCOMP(g_trac_isteps_trace,
               EXIT_MRK"fapiHWPCallWrapper (%s) exit", l_hwpCallStr);
+    return;
 }
 
 /**
@@ -298,4 +409,3 @@ bool fapiHWPCallWrapperHandler(HWP_CALL_TYPE    i_hwpCall,
 }
 
 };   // end namespace ISTEP
-
diff --git a/src/usr/isteps/nest/nestHwpHelperFuncs.H b/src/usr/isteps/nest/nestHwpHelperFuncs.H
index 9fe2b23bf..6708b7b4b 100644
--- a/src/usr/isteps/nest/nestHwpHelperFuncs.H
+++ b/src/usr/isteps/nest/nestHwpHelperFuncs.H
@@ -75,6 +75,8 @@ enum HWP_CALL_TYPE
     P9_SYS_CHIPLET_SCOMINIT,  // Although it says chiplet, this uses proc chip
     P9_XBUS_ENABLE_RIDI,
     P9_OBUS_FIRMASK_SAVE_RESTORE, // loops on proc chip
+    P9_IO_OBUS_IMAGE_BUILD,
+    P9_IO_XBUS_IMAGE_BUILD,
 };
 
 /**
@@ -153,4 +155,3 @@ bool fapiHWPCallWrapperHandler(HWP_CALL_TYPE            i_hwpCall,
 };  // end namespace ISTEP
 
 #endif
-