path: root/src/usr/hwas/hostbootIstep.C

/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/usr/hwas/hostbootIstep.C $                                */
/*                                                                        */
/* IBM CONFIDENTIAL                                                       */
/*                                                                        */
/* COPYRIGHT International Business Machines Corp. 2012,2013              */
/*                                                                        */
/* p1                                                                     */
/*                                                                        */
/* Object Code Only (OCO) source materials                                */
/* Licensed Internal Code Source Materials                                */
/* IBM HostBoot Licensed Internal Code                                    */
/*                                                                        */
/* The source code for this program is not published or otherwise         */
/* divested of its trade secrets, irrespective of what has been           */
/* deposited with the U.S. Copyright Office.                              */
/*                                                                        */
/* Origin: 30                                                             */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */
/**
 *  @file hostbootIstep.C
 *
 *  @brief hostboot istep-called functions
 */

#include <hwas/common/hwas.H>
#include <hwas/common/hwasCommon.H>
#include <hwas/common/hwas_reasoncodes.H>
#include <hwas/hwasPlat.H>

#include <hwas/hostbootIstep.H>
#include <hwas/common/deconfigGard.H>

#include <fsi/fsiif.H>
#include <initservice/taskargs.H>
#include <initservice/isteps_trace.H>
#include <hwpisteperror.H>

#include <targeting/attrsync.H>
#include <diag/prdf/prdfMain.H>
#include <intr/interrupt.H>
#include <ibscom/ibscomif.H>

//  fapi support
#include  <fapi.H>
#include  <fapiPlatHwpInvoker.H>

//  targeting support.
#include  <targeting/common/utilFilter.H>
#include  <targeting/common/commontargeting.H>

#include  <errl/errludtarget.H>

#include <proc_enable_reconfig.H>

namespace HWAS
{

using namespace TARGETING;
using namespace fapi;
using namespace ISTEP;
using namespace ISTEP_ERROR;

// functions called from the istep dispatcher -- hostboot only

//******************************************************************************
// host_init_fsi function
//******************************************************************************
void* host_init_fsi( void *io_pArgs )
{
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "host_init_fsi entry" );

    errlHndl_t errl = FSI::initializeHardware( );

    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "host_init_fsi exit" );

    return errl;
}

//******************************************************************************
// host_set_ipl_parms function
//******************************************************************************
void* host_set_ipl_parms( void *io_pArgs )
{
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "host_set_ipl_parms entry" );
    errlHndl_t errl = NULL;

    // stub -- nothing here currently

    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "host_set_ipl_parms exit" );

    return errl;
}

//******************************************************************************
// host_discover_targets function
//******************************************************************************
void* host_discover_targets( void *io_pArgs )
{
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_discover_targets entry" );

    errlHndl_t errl = NULL;

    // Check whether we're in MPIPL mode
    TARGETING::Target* l_pTopLevel = NULL;
    targetService().getTopLevelTarget( l_pTopLevel );

    if( l_pTopLevel == NULL )
    {
        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                   "Top level handle was NULL" );

        /*@
         * @errortype
         * @severity     ERRORLOG::ERRL_SEV_UNRECOVERABLE
         * @moduleid     HWAS::MOD_HOST_DISCOVER_TARGETS
         * @reasoncode   HWAS::RC_TOP_LEVEL_TARGET_NULL
         * @devdesc      Call to get top level targeting handle
         *               returned NULL
         */
        errl =  hwasError( ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                           HWAS::MOD_HOST_DISCOVER_TARGETS,
                           HWAS::RC_TOP_LEVEL_TARGET_NULL );
    }
    else
    {
        if (l_pTopLevel->getAttr<ATTR_IS_MPIPL_HB>())
        {
            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "MPIPL mode");

            // Sync attributes from Fsp
            errl = syncAllAttributesFromFsp();

        }
        else
        {
            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "Normal IPL mode");

            errl = discoverTargets();

            // also if SP doesn't support change detection, call
            // function to do it here.
            if (!errl &&
                !l_pTopLevel->getAttr<ATTR_SP_FUNCTIONS>()
                    .hardwareChangeDetection)
            {
                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
                    "calling hwasChangeDetection");
                errl = hwasChangeDetection();
            }
        }
    }

    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_discover_targets exit" );

    return errl;
}

//******************************************************************************
// host_gard function
//******************************************************************************
void* host_gard( void *io_pArgs )
{
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "host_gard entry" );

    errlHndl_t errl;

    // Check whether we're in MPIPL mode
    TARGETING::Target* l_pTopLevel = NULL;
    targetService().getTopLevelTarget( l_pTopLevel );

    if( l_pTopLevel == NULL )
    {
        TRACFCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                   "Top level handle was NULL" );

        /*@
         * @errortype
         * @severity     ERRORLOG::ERRL_SEV_UNRECOVERABLE
         * @moduleid     HWAS::MOD_HOST_GARD
         * @reasoncode   HWAS::RC_TOP_LEVEL_TARGET_NULL
         * @devdesc      Call to get top level targeting handle
         *               returned NULL
         */
        errl =  hwasError( ERRORLOG::ERRL_SEV_UNRECOVERABLE,
                           HWAS::MOD_HOST_GARD,
                           HWAS::RC_TOP_LEVEL_TARGET_NULL );
    }
    else
    {
        if (l_pTopLevel->getAttr<ATTR_IS_MPIPL_HB>())
        {
            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "MPIPL mode");

            // we only want EX units to be processed
            TARGETING::PredicateCTM l_exFilter(TARGETING::CLASS_UNIT,
                                                TARGETING::TYPE_EX);
            errl = collectGard(&l_exFilter);
        }
        else
        {
            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace, "Normal IPL mode");

            errl = collectGard();

            // if no error,
            if (errl == NULL)
            {
                //  check and see if we still have enough hardware to continue
                errl = checkMinimumHardware();
            }
        }
    }

    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace, "host_gard exit" );
    return errl;
}

//******************************************************************************
// host_cancontinue_clear function
//******************************************************************************
void* host_cancontinue_clear( void *io_pArgs )
{
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_cancontinue_clear entry" );
    errlHndl_t errl = NULL;

    // stub -- nothing here currently

    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_cancontinue_clear exit" );

    return errl;
}

//******************************************************************************
// host_prd_hwreconfig function
//******************************************************************************
void* host_prd_hwreconfig( void *io_pArgs )
{
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_prd_hwreconfig entry" );

    errlHndl_t errl = NULL;
    IStepError l_stepError;
    do
    {
        // Flip the scom path back to FSI in case we enabled IBSCOM previously
        IBSCOM::enableInbandScoms(IBSCOM_DISABLE);

        // Call PRDF to remove non-function chips from its system model
        errl = PRDF::refresh();

        if (errl)
        {
            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
                      "host_prd_hwreconfig ERROR 0x%.8X returned from"
                      "  call to PRDF::refresh", errl->reasonCode());

            // Create IStep error log and cross reference error that occurred
            l_stepError.addErrorDetails(errl);

            // Commit Error
            errlCommit(errl, HWPF_COMP_ID);

            break;
        }

        // Lists for functional MCS/Centaurs
        TARGETING::TargetHandleList l_fncMcsList;
        TARGETING::TargetHandleList l_fncCentaurList;

        // find all functional MCS chiplets of all procs
        getChipletResources(l_fncMcsList, TYPE_MCS, UTIL_FILTER_FUNCTIONAL);

        for (TargetHandleList::const_iterator
             l_mcs_iter = l_fncMcsList.begin();
             l_mcs_iter != l_fncMcsList.end();
             ++l_mcs_iter)
        {
            // make a local copy of the MCS target
            const TARGETING::Target * l_pMcs = *l_mcs_iter;
            // Retrieve HUID of current MCS
            TARGETING::ATTR_HUID_type l_currMcsHuid =
                TARGETING::get_huid(l_pMcs);

            // Find all the functional Centaurs that are associated with this MCS
            getChildAffinityTargets(l_fncCentaurList, l_pMcs,
                           CLASS_CHIP, TYPE_MEMBUF);

            // There will always be 1 Centaur associated with a MCS.
            if(1 != l_fncCentaurList.size())
            {
                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
                        "No functional Centaurs found for "
                        "MCS target HUID %.8X , skipping this MCS",
                        l_currMcsHuid);
                continue;
            }

            // Make a local copy
            const TARGETING::Target * l_pCentaur = l_fncCentaurList[0];
            // Retrieve HUID of current Centaur
            TARGETING::ATTR_HUID_type l_currCentaurHuid =
                TARGETING::get_huid(l_pCentaur);

            // Dump current run on target
            TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
                    "Running proc_enable_reconfig HWP on "
                    "MCS target HUID %.8X CENTAUR target HUID %.8X",
                    l_currMcsHuid, l_currCentaurHuid);

            // Create FAPI Targets.
            fapi::Target l_fapiMcsTarget(TARGET_TYPE_MCS_CHIPLET,
                    (const_cast<TARGETING::Target*>(l_pMcs)));
            fapi::Target l_fapiCentaurTarget(TARGET_TYPE_MEMBUF_CHIP,
                    (const_cast<TARGETING::Target*>(l_pCentaur)));

            // Call the HWP with each fapi::Target
            FAPI_INVOKE_HWP(errl, proc_enable_reconfig,
                            l_fapiMcsTarget, l_fapiCentaurTarget);

            if (errl)
            {
                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
                          "ERROR 0x%.8X: proc_enable_reconfig HWP returns error",
                          errl->reasonCode());

                // Capture the target data in the elog
                ERRORLOG::ErrlUserDetailsTarget(l_pMcs).addToLog( errl );

                // Create IStep error log and cross reference error that occurred
                l_stepError.addErrorDetails(errl);

                // Commit Error
                errlCommit(errl, HWPF_COMP_ID);
            }
            else
            {
                // Success
                TRACFCOMP(ISTEPS_TRACE::g_trac_isteps_trace,
                        "Successfully ran proc_enable_reconfig HWP on "
                        "MCS target HUID %.8X CENTAUR target HUID %.8X",
                        l_currMcsHuid,
                        l_currCentaurHuid);
            }
        }
    }
    while(0);
    TRACDCOMP( ISTEPS_TRACE::g_trac_isteps_trace,
                "host_prd_hwreconfig exit" );
    // end task, returning any errorlogs to IStepDisp
    return l_stepError.getErrorHandle();
}

//******************************************************************************
// host_stub function
//******************************************************************************
void* host_stub( void *io_pArgs )
{
    errlHndl_t errl = NULL;
    // no function required
    return errl;
}

} // namespace HWAS