Cumulus HWPs for istep11

Change-Id: I18b8eb5595b6c83c05eae52f2d870898b28f1116
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/44967
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Reviewed-by: Prachi Gupta <pragupta@us.ibm.com>
Reviewed-by: Corey V. Swenson <cswenson@us.ibm.com>
Reviewed-by: Thomas R. Sand <trsand@us.ibm.com>
Reviewed-by: SWATHI M. BHATTIPROLU <bhmadhur@in.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

13 files changed, 985 insertions, 44 deletions

diff --git a/src/usr/isteps/istep11/call_cen_arrayinit.C b/src/usr/isteps/istep11/call_cen_arrayinit.C
index 4507c2957..381c18340 100644
--- a/src/usr/isteps/istep11/call_cen_arrayinit.C
+++ b/src/usr/isteps/istep11/call_cen_arrayinit.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_arrayinit.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_arrayinit (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_arrayinit entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_arrayinit: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_arrayinit HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_arrayinit, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_arrayinit HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_arrayinit HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_arrayinit exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_chiplet_init.C b/src/usr/isteps/istep11/call_cen_chiplet_init.C
index 7c63f9c14..391d6aab9 100644
--- a/src/usr/isteps/istep11/call_cen_chiplet_init.C
+++ b/src/usr/isteps/istep11/call_cen_chiplet_init.C
@@ -22,7 +22,34 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
+
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_chiplet_init.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 using namespace ERRORLOG;
 
@@ -30,9 +57,57 @@ namespace ISTEP_11
 {
 void* call_cen_chiplet_init (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
 
-    return l_err;
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_chiplet_init entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_chiplet_init: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_chiplet_init HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_chiplet_init, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_chiplet_init HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_chiplet_init HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_chiplet_init exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_do_manual_inits.C b/src/usr/isteps/istep11/call_cen_do_manual_inits.C
index 7e4ae5fb5..b47dcf3a6 100644
--- a/src/usr/isteps/istep11/call_cen_do_manual_inits.C
+++ b/src/usr/isteps/istep11/call_cen_do_manual_inits.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_do_manual_inits.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_do_manual_inits (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
 
-    return l_err;
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_do_manual_inits entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_do_manual_inits: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_do_manual_inits HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_do_manual_inits, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_do_manual_inits HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_do_manual_inits HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_do_manual_inits exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_initf.C b/src/usr/isteps/istep11/call_cen_initf.C
index e787b36b6..2e45838ff 100644
--- a/src/usr/isteps/istep11/call_cen_initf.C
+++ b/src/usr/isteps/istep11/call_cen_initf.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_initf.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_initf (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
 
-    return l_err;
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_initf entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_initf: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_initf HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_initf, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_initf HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_initf HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_initf exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_pll_initf.C b/src/usr/isteps/istep11/call_cen_pll_initf.C
index b9f10776b..b41458f8a 100644
--- a/src/usr/isteps/istep11/call_cen_pll_initf.C
+++ b/src/usr/isteps/istep11/call_cen_pll_initf.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_pll_initf.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_pll_initf (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_pll_initf entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_pll_initf: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_pll_initf HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_pll_initf, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_pll_initf HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_pll_initf HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_pll_initf exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_pll_setup.C b/src/usr/isteps/istep11/call_cen_pll_setup.C
index eb83322aa..769126126 100644
--- a/src/usr/isteps/istep11/call_cen_pll_setup.C
+++ b/src/usr/isteps/istep11/call_cen_pll_setup.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_pll_setup.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_pll_setup (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_pll_setup entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_pll_setup: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_pll_setup HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_pll_setup, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_pll_setup HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_pll_setup HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_pll_setup exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_scominits.C b/src/usr/isteps/istep11/call_cen_scominits.C
index 49e67eaec..68b65876b 100644
--- a/src/usr/isteps/istep11/call_cen_scominits.C
+++ b/src/usr/isteps/istep11/call_cen_scominits.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_scominits.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_scominits (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_scominits entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_scominits: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_scominits HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_scominits, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_scominits HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_scominits HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_scominits exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_startclocks.C b/src/usr/isteps/istep11/call_cen_startclocks.C
index 3509e3935..d332f064e 100644
--- a/src/usr/isteps/istep11/call_cen_startclocks.C
+++ b/src/usr/isteps/istep11/call_cen_startclocks.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_startclocks.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_startclocks (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_startclocks entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_startclocks: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_startclocks HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_startclocks, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_startclocks HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_startclocks HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_startclocks exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_tp_arrayinit.C b/src/usr/isteps/istep11/call_cen_tp_arrayinit.C
index 147b88609..92f41e9f2 100644
--- a/src/usr/isteps/istep11/call_cen_tp_arrayinit.C
+++ b/src/usr/isteps/istep11/call_cen_tp_arrayinit.C
@@ -22,17 +22,91 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
+
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_tp_arrayinit.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
-using namespace ERRORLOG;
 
 namespace ISTEP_11
 {
 void* call_cen_tp_arrayinit (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_arrayinit entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_arrayinit: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_tp_arrayinit HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_tp_arrayinit, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_tp_arrayinit HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_tp_arrayinit HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_arrayinit exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_tp_chiplet_init1.C b/src/usr/isteps/istep11/call_cen_tp_chiplet_init1.C
index 4ce781ca9..7fc32ca86 100644
--- a/src/usr/isteps/istep11/call_cen_tp_chiplet_init1.C
+++ b/src/usr/isteps/istep11/call_cen_tp_chiplet_init1.C
@@ -22,17 +22,91 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_tp_chiplet_init1.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
+
 void* call_cen_tp_chiplet_init1 (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init1 entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init1: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_tp_chiplet_init1 HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_tp_chiplet_init1, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_tp_chiplet_init1 HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_tp_chiplet_init1 HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init1 exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_tp_chiplet_init2.C b/src/usr/isteps/istep11/call_cen_tp_chiplet_init2.C
index 8fa24fe0c..ec725b970 100644
--- a/src/usr/isteps/istep11/call_cen_tp_chiplet_init2.C
+++ b/src/usr/isteps/istep11/call_cen_tp_chiplet_init2.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_tp_chiplet_init2.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_tp_chiplet_init2 (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init2 entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init2: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_tp_chiplet_init2 HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_tp_chiplet_init2, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_tp_chiplet_init2 HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_tp_chiplet_init2 HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init2 exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/call_cen_tp_chiplet_init3.C b/src/usr/isteps/istep11/call_cen_tp_chiplet_init3.C
index d3e05feb8..6d7fee242 100644
--- a/src/usr/isteps/istep11/call_cen_tp_chiplet_init3.C
+++ b/src/usr/isteps/istep11/call_cen_tp_chiplet_init3.C
@@ -22,17 +22,90 @@
 /* permissions and limitations under the License.                         */
 /*                                                                        */
 /* IBM_PROLOG_END_TAG                                                     */
-#include <errl/errlentry.H>
+#include    <stdint.h>
 
-using namespace ERRORLOG;
+#include    <trace/interface.H>
+#include    <initservice/taskargs.H>
+#include    <errl/errlentry.H>
+
+#include    <isteps/hwpisteperror.H>
+#include    <errl/errludtarget.H>
+
+#include    <initservice/isteps_trace.H>
+
+//  targeting support
+#include    <targeting/common/commontargeting.H>
+#include    <targeting/common/utilFilter.H>
+
+//Fapi Support
+#include    <config.h>
+#include    <fapi2.H>
+#include    <fapi2/plat_hwp_invoker.H>
+#include    <util/utilmbox_scratch.H>
+
+// HWP
+#include    <cen_tp_chiplet_init3.H>
+
+using   namespace   ERRORLOG;
+using   namespace   ISTEP;
+using   namespace   ISTEP_ERROR;
+using   namespace   TARGETING;
 
 namespace ISTEP_11
 {
 void* call_cen_tp_chiplet_init3 (void *io_pArgs)
 {
+    IStepError l_StepError;
     errlHndl_t l_err = NULL;
-    
-    return l_err;
+
+    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init3 entry" );
+
+    TARGETING::TargetHandleList l_membufTargetList;
+    getAllChips(l_membufTargetList, TYPE_MEMBUF);
+
+    TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init3: %d membufs found",
+            l_membufTargetList.size());
+
+    for (const auto & l_membuf_target : l_membufTargetList)
+    {
+        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+            "cen_tp_chiplet_init3 HWP target HUID %.8x",
+            TARGETING::get_huid(l_membuf_target));
+
+        //  call the HWP with each target
+        fapi2::Target <fapi2::TARGET_TYPE_MEMBUF_CHIP> l_fapi_membuf_target
+                (l_membuf_target);
+
+        FAPI_INVOKE_HWP(l_err, cen_tp_chiplet_init3, l_fapi_membuf_target);
+
+        //  process return code.
+        if ( l_err )
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                "ERROR 0x%.8X:  cen_tp_chiplet_init3 HWP on target HUID %.8x",
+                l_err->reasonCode(), TARGETING::get_huid(l_membuf_target) );
+
+            // capture the target data in the elog
+            ErrlUserDetailsTarget(l_membuf_target).addToLog( l_err );
+
+            // Create IStep error log and cross reference to error that occurred
+            l_StepError.addErrorDetails( l_err );
+
+            // Commit Error
+            errlCommit( l_err, ISTEP_COMP_ID );
+        }
+        else
+        {
+            TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
+                     "SUCCESS :  cen_tp_chiplet_init3 HWP");
+        }
+
+    }
+
+
+    TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "call_cen_tp_chiplet_init3 exit" );
+
+    return l_StepError.getErrorHandle();
 }
 
 };
diff --git a/src/usr/isteps/istep11/makefile b/src/usr/isteps/istep11/makefile
index 3d3c053d4..ccc3f67ca 100644
--- a/src/usr/isteps/istep11/makefile
+++ b/src/usr/isteps/istep11/makefile
@@ -24,6 +24,8 @@
 # IBM_PROLOG_END_TAG
 ROOTPATH = ../../../..
 MODULE = istep11
+PROCEDURES_PATH = ${ROOTPATH}/src/import/chips/p9/procedures
+HWP_PATH += ${ROOTPATH}/src/import/chips/centaur/procedures/hwp/perv
 
 OBJS += call_host_prd_hwreconfig.o
 OBJS += call_cen_tp_chiplet_init1.o
@@ -39,5 +41,64 @@ OBJS += call_cen_do_manual_inits.o
 OBJS += call_cen_startclocks.o
 OBJS += call_cen_scominits.o
 
+#Add all the extra include paths
+EXTRAINCDIR += ${ROOTPATH}/src/include/usr/fapi2/
+EXTRAINCDIR += ${ROOTPATH}/src/include/usr/sbe/
+EXTRAINCDIR += ${ROOTPATH}/src/import/hwpf/fapi2/include/
+EXTRAINCDIR += ${ROOTPATH}/src/import/chips/p9/utils/
+EXTRAINCDIR += ${ROOTPATH}/src/import/chips/centaur/common/include/
+EXTRAINCDIR += ${ROOTPATH}/src/import/chips/p9/utils/imageProcs/
+EXTRAINCDIR += ${ROOTPATH}/src/import/
+EXTRAINCDIR += ${ROOTPATH}/obj/genfiles/
+EXTRAINCDIR += ${ROOTPATH}/src/usr/isteps/
+EXTRAINCDIR += ${HWP_PATH}
+#EXTRAINCDIR += $(PROCEDURES_PATH)/hwp/nest/
+
+VPATH += $(PROCEDURES_PATH)/hwp/nest ${ROOTPATH}/src/usr/fapi2
+VPATH += ${ROOTPATH}/src/usr/sbe
+VPATH += ${ROOTPATH}/src/import/chips/centaur/procedures/hwp/perv
+
+#Required include before all the procedure.mk are included
+include ${ROOTPATH}/procedure.rules.mk
+
+#Include all the procedure makefiles
+# Centaur common functions
+include $(HWP_PATH)/cen_common_funcs.mk
+
+#11.2 : Centaur TP chiplet init, stage #1
+include $(HWP_PATH)/cen_tp_chiplet_init1.mk
+
+#11.3 : Program Nest PLL
+include $(HWP_PATH)/cen_pll_initf.mk
+
+#11.4 : Setup Nest PLL
+include $(HWP_PATH)/cen_pll_setup.mk
+
+#11.5 : Centaur TP chiplet init, stage #2
+include $(HWP_PATH)/cen_tp_chiplet_init2.mk
+
+#11.6 : Centaur TP chiplet array init
+include $(HWP_PATH)/cen_tp_arrayinit.mk
+
+#11.7 : Centaur TP chiplet init, stage #3
+include $(HWP_PATH)/cen_tp_chiplet_init3.mk
+
+#11.8 : Centaur chiplet init
+include $(HWP_PATH)/cen_chiplet_init.mk
+
+#11.9 : Centaur chiplet array init
+include $(HWP_PATH)/cen_arrayinit.mk
+
+#11.10 : Centaur Scan overrides
+include $(HWP_PATH)/cen_initf.mk
+
+#11.11 : Manual Centaur Scans
+include $(HWP_PATH)/cen_do_manual_inits.mk
+
+#11.12 : Start Centaur Nest/MEM clocks
+include $(HWP_PATH)/cen_startclocks.mk
+
+#11.13 : Perform Centaur SCOM inits
+include $(HWP_PATH)/cen_scominits.mk
 
 include ${ROOTPATH}/config.mk