MDIA: Initial Axone/OCMB updates

Change-Id: Ifd1c78e5a777431731707103da1d816fd77e9e86
RTC: 199041
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/68426
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: Zane C. Shelley <zshelle@us.ibm.com>

5 files changed, 309 insertions, 70 deletions

diff --git a/src/usr/diag/mdia/mdia.C b/src/usr/diag/mdia/mdia.C
index c05e38a1e..a13f28e59 100644
--- a/src/usr/diag/mdia/mdia.C
+++ b/src/usr/diag/mdia/mdia.C
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2017                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2018                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -122,6 +122,7 @@ errlHndl_t runStep(const TargetHandleList & i_targetList)
     ATTR_RECONFIGURE_LOOP_type attr = top->getAttr<ATTR_RECONFIGURE_LOOP>();
     if ( 0 == (attr & RECONFIGURE_LOOP_RCD_PARITY_ERROR) )
     {
+        //TODO RTC 201293 - may need to update this for axone as well
         TargetHandleList trgtList; getAllChiplets( trgtList, TYPE_MCA );
         for ( auto & trgt : trgtList )
         {
diff --git a/src/usr/diag/mdia/mdiafwd.H b/src/usr/diag/mdia/mdiafwd.H
index 64fbf7887..e3395781e 100644
--- a/src/usr/diag/mdia/mdiafwd.H
+++ b/src/usr/diag/mdia/mdiafwd.H
@@ -96,6 +96,20 @@ enum
     MCBIST_FIR_ACT0         = 0x07012306,
     MCBIST_FIR_ACT1         = 0x07012307,
 
+    // ocmb mcbist unit regs
+    OCMB_MCBIST_FIR         = 0x08011800,
+    OCMB_MCBIST_FIR_AND     = 0x08011801,
+    OCMB_MCBIST_FIR_MASK    = 0x08011803,
+    OCMB_MCBIST_FIR_ACT0    = 0x08011806,
+    OCMB_MCBIST_FIR_ACT1    = 0x08011807,
+
+    // ocmb omidlfir unit regs
+    OMIDLFIR                = 0x07013340,
+    OMIDLFIR_AND            = 0x07013341,
+    OMIDLFIR_MASK           = 0x07013343,
+    OMIDLFIR_ACT0           = 0x07013346,
+    OMIDLFIR_ACT1           = 0x07013347,
+
     // mcs unit regs
     CHI_FIR                 = 0x07010900,
     CHI_FIR_MASK            = 0x07010903,
diff --git a/src/usr/diag/mdia/mdiamba.C b/src/usr/diag/mdia/mdiamba.C
index c1d32ea3e..6f3914d27 100644
--- a/src/usr/diag/mdia/mdiamba.C
+++ b/src/usr/diag/mdia/mdiamba.C
@@ -342,17 +342,42 @@ TargetHandleList getMemTargetsForQueryOrClear(
 
             o_list.push_back(centaur);
 
-            // get connected mcs target
-            targetList.clear();
-
-            getParentAffinityTargets(targetList,
+            // get connected dmi target
+            TargetHandleList dmiList;
+            getParentAffinityTargets(dmiList,
                                      centaur,
                                      CLASS_UNIT,
-                                     TYPE_MCS);
+                                     TYPE_DMI);
 
-            if( !targetList.empty() )
+            if( !dmiList.empty() )
             {
-                o_list.push_back(targetList[0]);
+                o_list.push_back(dmiList[0]);
+            }
+
+            // add associated MI
+            TargetHandleList miList;
+            getParentAffinityTargets( miList, dmiList[0], CLASS_UNIT, TYPE_MI );
+            if ( miList.size() == 1 )
+            {
+                o_list.push_back( miList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent MI." );
+                break;
+            }
+
+            // add associated MC
+            TargetHandleList mcList;
+            getParentAffinityTargets( mcList, miList[0], CLASS_UNIT, TYPE_MC );
+            if ( mcList.size() == 1 )
+            {
+                o_list.push_back( mcList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent MC." );
+                break;
             }
 
             // add associated MBAs
@@ -367,6 +392,80 @@ TargetHandleList getMemTargetsForQueryOrClear(
             }
 
         }
+        // OCMB target
+        else if ( TYPE_OCMB_CHIP == trgtType )
+        {
+            // add associated OCMB
+            o_list.push_back( i_trgt );
+
+            // add associated OMI
+            TargetHandleList omiList;
+            getParentAffinityTargets( omiList, i_trgt, CLASS_UNIT, TYPE_OMI );
+            if ( omiList.size() == 1 )
+            {
+                o_list.push_back( omiList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent OMI." );
+                break;
+            }
+
+            // add associated OMIC
+            TargetHandleList omicList;
+            getParentAffinityTargets( omicList, omiList[0], CLASS_UNIT,
+                                      TYPE_OMIC );
+            if ( omicList.size() == 1 )
+            {
+                o_list.push_back( omicList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent OMIC." );
+                break;
+            }
+
+            // add associated MCC
+            TargetHandleList mccList;
+            getParentAffinityTargets( mccList, omiList[0], CLASS_UNIT,
+                                      TYPE_MCC );
+            if ( mccList.size() == 1 )
+            {
+                o_list.push_back( mccList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent MCC." );
+                break;
+            }
+
+            // add associated MI
+            TargetHandleList miList;
+            getParentAffinityTargets( miList, mccList[0], CLASS_UNIT, TYPE_MI );
+            if ( miList.size() == 1 )
+            {
+                o_list.push_back( miList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent MI." );
+                break;
+            }
+
+            // add associated MC
+            TargetHandleList mcList;
+            getParentAffinityTargets( mcList, miList[0], CLASS_UNIT, TYPE_MC );
+            if ( mcList.size() == 1 )
+            {
+                o_list.push_back( mcList[0] );
+            }
+            else
+            {
+                MDIA_FAST( FUNC "Could not find parent MC." );
+                break;
+            }
+
+        }
         else
         {
             assert( false, "getMemTargetsForQueryOrClear: Invalid target "
diff --git a/src/usr/diag/mdia/mdiasm.C b/src/usr/diag/mdia/mdiasm.C
index 75a136180..054010e11 100644
--- a/src/usr/diag/mdia/mdiasm.C
+++ b/src/usr/diag/mdia/mdiasm.C
@@ -130,6 +130,19 @@ void addTimeoutFFDC(TargetHandle_t i_target, errlHndl_t & io_log)
         MCBIST_FIR_ACT1,
     };
 
+    const uint64_t ocmbRegs[] = {
+        OCMB_MCBIST_FIR,
+        OCMB_MCBIST_FIR_AND,
+        OCMB_MCBIST_FIR_MASK,
+        OCMB_MCBIST_FIR_ACT0,
+        OCMB_MCBIST_FIR_ACT1,
+        OMIDLFIR,
+        OMIDLFIR_AND,
+        OMIDLFIR_MASK,
+        OMIDLFIR_ACT0,
+        OMIDLFIR_ACT1,
+    };
+
     const uint64_t procRegs[] = {
         IPOLL_MASK,
         IPOLL_STATUS,
@@ -240,6 +253,41 @@ void addTimeoutFFDC(TargetHandle_t i_target, errlHndl_t & io_log)
             }
         }
     }
+    else if ( TYPE_OCMB_CHIP == i_target->getAttr<ATTR_TYPE>() )
+    {
+        // get the parent proc
+        ConstTargetHandle_t proc = getParentChip(i_target);
+
+        const struct Entry
+        {
+            TARGETING::ConstTargetHandle_t target;
+            const uint64_t * begin;
+            const uint64_t * end;
+        } tables[] = {
+            {i_target, ocmbRegs, ocmbRegs + sizeof(ocmbRegs)/sizeof(*ocmbRegs)},
+            {proc, procRegs, procRegs + sizeof(procRegs)/sizeof(*procRegs)},
+        };
+
+        for(const Entry * tableIt = tables;
+                tableIt != tables + sizeof(tables)/sizeof(*tables);
+                ++tableIt)
+        {
+            if(!tableIt->target)
+            {
+                continue;
+            }
+
+            for(const uint64_t * regIt = tableIt->begin;
+                    regIt != tableIt->end;
+                    ++regIt)
+            {
+                ErrlUserDetailsLogRegister udLogRegister(
+                        tableIt->target,
+                        DEVICE_SCOM_ADDRESS(*regIt));
+                udLogRegister.addToLog(io_log);
+            }
+        }
+    }
     else
     {
         assert( false, "addTimeoutFFDC: Invalid target type from i_target: %x",
@@ -274,6 +322,11 @@ fapi2::TargetType getMdiaTargetType()
     {
         targetType = fapi2::TARGET_TYPE_MCBIST;
     }
+    else if ( TARGETING::MODEL_AXONE ==
+              masterProc->getAttr<TARGETING::ATTR_MODEL>() )
+    {
+        targetType = fapi2::TARGET_TYPE_OCMB_CHIP;
+    }
     else
     {
         assert( false, "getMdiaTargetType: Invalid model type from "
@@ -387,56 +440,6 @@ errlHndl_t ceErrorSetup<TYPE_MBA>( TargetHandle_t i_mba )
     return err;
 }
 
-uint64_t getMemSize(TargetHandle_t i_target)
-{
-    uint64_t memsize = 0;
-    AttributeTraits<TARGETING::ATTR_EFF_DIMM_SIZE>::Type effDimmSizeAttr;
-    TargetHandleList targetList;
-
-    // if target is MBA
-    if( TYPE_MBA == i_target->getAttr<ATTR_TYPE>() )
-    {
-        targetList.push_back(i_target);
-    }
-    // if target is MCBIST we have to get the connected MCSs
-    else if( TYPE_MCBIST == i_target->getAttr<ATTR_TYPE>() )
-    {
-        PredicateCTM predType( CLASS_NA, TYPE_MCS );
-        PredicateIsFunctional predFunc;
-        PredicatePostfixExpr predAnd;
-        predAnd.push(&predType).push(&predFunc).And();
-
-        targetService().getAssociated( targetList, i_target,
-                                       TargetService::CHILD_BY_AFFINITY,
-                                       TargetService::ALL, &predAnd );
-    }
-    else
-    {
-        assert( false, "getMemSize: Invalid target type from i_target: %x",
-                get_huid(i_target) );
-    }
-
-    for (auto trgt : targetList)
-    {
-        if(trgt->tryGetAttr<TARGETING::ATTR_EFF_DIMM_SIZE>(effDimmSizeAttr))
-        {
-            for(uint64_t port = 0;
-                    port < sizeof(effDimmSizeAttr)/sizeof(*effDimmSizeAttr);
-                    ++port)
-            {
-                for(uint64_t dimm = 0; dimm <
-                        sizeof(effDimmSizeAttr[0])/sizeof(*effDimmSizeAttr[0]);
-                        ++dimm)
-                {
-                    memsize += effDimmSizeAttr[port][dimm];
-                }
-            }
-        }
-    }
-
-    return memsize;
-}
-
 void StateMachine::processCommandTimeout(const MonitorIDs & i_monitorIDs)
 {
     MDIA_FAST("sm: processCommandTimeout");
@@ -483,6 +486,14 @@ void StateMachine::processCommandTimeout(const MonitorIDs & i_monitorIDs)
                     mskAddr = MBA01_SPA_MASK;
                     bitMask = 0x8080000000000000; // bits 0 or 8
                 }
+                // Change if target type is OCMB_CHIP
+                else if ( TYPE_OCMB_CHIP == trgtType )
+                {
+                    firAddr    = OCMB_MCBIST_FIR;
+                    firAndAddr = OCMB_MCBIST_FIR_AND;
+                    mskAddr    = OCMB_MCBIST_FIR_MASK;
+                    bitMask    = 0x0020000000000000; // bit 10
+                }
                 // Assert if unsupported type
                 else
                 {
@@ -643,6 +654,35 @@ void StateMachine::processCommandTimeout(const MonitorIDs & i_monitorIDs)
                         errlCommit(err, MDIA_COMP_ID);
                     }
                 }
+                // target type is OCMB_CHIP
+                else if ( TYPE_OCMB_CHIP == trgtType )
+                {
+                    /* TODO RTC 201293 uncomment once we have hwp support
+                    fapi2::Target<fapi2::TARGET_TYPE_OCMB_CHIP>
+                        fapiOcmb(target);
+                    FAPI_INVOKE_HWP( err, mss::memdiags::stop, fapiOcmb );
+
+                    if ( nullptr != err )
+                    {
+                        MDIA_ERR("sm: mss::memdiags::stop failed");
+                        errlCommit(err, MDIA_COMP_ID);
+                    }
+
+                    // mss::memdiags::stop will set the command complete
+                    // attention so we need to clear those
+                    bitMask = ~bitMask;
+
+                    err = deviceWrite( target, &bitMask, sz_uint64,
+                                       DEVICE_SCOM_ADDRESS(firAndAddr) );
+
+                    if ( nullptr != err )
+                    {
+                        MDIA_FAST( "sm: deviceWrite on 0x%08X failed, HUID: "
+                                   "0x%08X", firAddr, get_huid(target) );
+                        errlCommit(err, MDIA_COMP_ID);
+                    }
+                    */
+                }
                 // Assert if unsupported type
                 else
                 {
@@ -740,9 +780,6 @@ void StateMachine::setup(const WorkFlowAssocMap & i_list)
         p->timer = 0;
         p->timeoutCnt = 0;
 
-        // get the memsize
-        p->memSize = getMemSize(it->first);
-
         p->data = NULL;
         p->chipUnit = it->first->getAttr<ATTR_CHIP_UNIT>();
 
@@ -847,14 +884,8 @@ bool StateMachine::scheduleWorkItem(WorkFlowProperties & i_wfp)
         // 3 - schedule it
 
         // determine the priority for the work item to be scheduled
-        // the priority is the number of iterations
-        // through the memory multiplied by the memory size
-
-        // multiply by memory size
-        // assume 1 GB DIMMS if figuring out the memory
-        // size failed
-        uint64_t priority = getRemainingWorkItems(i_wfp)
-            * (i_wfp.memSize ? i_wfp.memSize : 1);
+        // the priority is the number of iterations through the memory
+        uint64_t priority = getRemainingWorkItems(i_wfp);
 
         if(!iv_tp)
         {
@@ -957,6 +988,13 @@ bool StateMachine::executeWorkItem(WorkFlowProperties * i_wfp)
                         rc |= PRDF::restoreDramRepairs<TYPE_MCA>( mca );
                     }
                 }
+                // OCMB target
+                else if ( TYPE_OCMB_CHIP == trgtType )
+                {
+                    /* TODO RTC 199034 - uncomment for restoreDramRepairs
+                    rc = PRDF::restoreDramRepairs<TYPE_OCMB_CHIP>( target );
+                    */
+                }
                 else
                 {
                     assert( false, "executeWorkItem: Invalid target type from "
@@ -1260,6 +1298,71 @@ errlHndl_t StateMachine::doMaintCommand(WorkFlowProperties & i_wfp)
                 i_wfp.data = nullptr;
             }
         }
+        // target type is OCMB_CHIP
+        else if ( TYPE_OCMB_CHIP == trgtType )
+        {
+            /* TODO RTC 201293 - uncomment with hwp support
+            fapi2::Target<fapi2::TARGET_TYPE_OCMB_CHIP> fapiOcmb(target);
+            mss::mcbist::stop_conditions stopCond;
+
+            switch(workItem)
+            {
+                case START_RANDOM_PATTERN:
+
+                    FAPI_INVOKE_HWP( err, mss::memdiags::sf_init, fapiOcmb,
+                                     mss::mcbist::PATTERN_RANDOM );
+                    MDIA_FAST("sm: random init %p on: %x", fapiOcmb,
+                            get_huid(target));
+                    break;
+
+                case START_SCRUB:
+
+                    //set stop conditions
+                    stopCond.set_pause_on_mpe(mss::ON);
+                    stopCond.set_pause_on_ue( mss::ON);
+                    stopCond.set_pause_on_aue(mss::ON);
+                    stopCond.set_nce_inter_symbol_count_enable(mss::ON);
+                    stopCond.set_nce_soft_symbol_count_enable( mss::ON);
+                    stopCond.set_nce_hard_symbol_count_enable( mss::ON);
+                    if ( TARGETING::MNFG_FLAG_IPL_MEMORY_CE_CHECKING
+                            & iv_globals.mfgPolicy )
+                    {
+                        stopCond.set_pause_on_nce_hard(mss::ON);
+                    }
+
+                    FAPI_INVOKE_HWP( err, mss::memdiags::sf_read, fapiOcmb,
+                                     stopCond );
+                    MDIA_FAST( "sm: scrub %p on: %x", fapiOcmb,
+                               get_huid(target) );
+                    break;
+
+                case START_PATTERN_0:
+                case START_PATTERN_1:
+                case START_PATTERN_2:
+                case START_PATTERN_3:
+                case START_PATTERN_4:
+                case START_PATTERN_5:
+                case START_PATTERN_6:
+                case START_PATTERN_7:
+
+                    FAPI_INVOKE_HWP( err, mss::memdiags::sf_init, fapiOcmb,
+                                     workItem );
+                    MDIA_FAST( "sm: init %p on: %x", fapiOcmb,
+                               get_huid(target) );
+                    break;
+
+                default:
+                    MDIA_ERR("unrecognized work item type %d on: %x",
+                             workItem, get_huid(target));
+                    break;
+            }
+            if( nullptr != err )
+            {
+                MDIA_FAST("sm: Running Maint Cmd failed");
+                i_wfp.data = nullptr;
+            }
+            */
+        }
         else
         {
             assert( false, "doMaintCommand: Invalid target type from "
@@ -1478,6 +1581,24 @@ bool StateMachine::processMaintCommandEvent(const MaintCommandEvent & i_event)
                 }
             }
         }
+        // target type is OCMB_CHIP
+        else if ( TYPE_OCMB_CHIP == trgtType )
+        {
+            if(flags & STOP_CMD)
+            {
+                MDIA_FAST("sm: stopping command: %p", target);
+                /* TODO RTC 201293 - reenable with hwp support
+                fapi2::Target<fapi2::TARGET_TYPE_OCMB_CHIP> fapiOcmb(target);
+                FAPI_INVOKE_HWP( err, mss::memdiags::stop, fapiOcmb );
+
+                if(nullptr != err)
+                {
+                    MDIA_ERR("sm: mss::memdiags::stop failed");
+                    errlCommit(err, MDIA_COMP_ID);
+                }
+                */
+            }
+        }
         else
         {
             assert( false, "processMaintCommandEvent: Invalid target type "
diff --git a/src/usr/diag/mdia/test/mdiatestsm.H b/src/usr/diag/mdia/test/mdiatestsm.H
index b4e20a9ea..b7df7d954 100644
--- a/src/usr/diag/mdia/test/mdiatestsm.H
+++ b/src/usr/diag/mdia/test/mdiatestsm.H
@@ -58,10 +58,14 @@ class MdiaSmTest : public CxxTest::TestSuite
             {
                 TARGETING::getAllChiplets(tmp, TYPE_MBA);
             }
-            else
+            else if (fapi2::TARGET_TYPE_MCBIST == type)
             {
                 TARGETING::getAllChiplets(tmp, TYPE_MCBIST);
             }
+            else if (fapi2::TARGET_TYPE_OCMB_CHIP == type)
+            {
+                TARGETING::getAllChiplets(tmp, TYPE_OCMB_CHIP);
+            }
 
             TargetHandleList::iterator it = tmp.end();