diff --git a/src/usr/isteps/istep11/call_cen_arrayinit.C b/src/usr/isteps/istep11/call_cen_arrayinit.C index 4507c295793..381c1834095 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 7c63f9c147e..391d6aab9e2 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 +#include + +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 7e4ae5fb5ae..b47dcf3a652 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 e787b36b612..2e45838ff21 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 b9f10776bac..b41458f8a48 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 eb83322aae1..769126126ee 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 49e67eaec28..68b65876bb3 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 3509e393518..d332f064ef7 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 147b8860982..92f41e9f266 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 +#include + +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 4ce781ca947..7fc32ca86eb 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 8fa24fe0c18..ec725b970d4 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 d3e05feb87f..6d7fee2426d 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 +#include -using namespace ERRORLOG; +#include +#include +#include + +#include +#include + +#include + +// targeting support +#include +#include + +//Fapi Support +#include +#include +#include +#include + +// HWP +#include + +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 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 3d3c053d4ec..ccc3f67caac 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