HBRT fapi wakeup support

RTC: 98665
Change-Id: Ib9e9f8f3656989975cc08a29304ba7faa25c59e4
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/9364
Tested-by: Jenkins Server
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>
Reviewed-by: A. Patrick Williams III <iawillia@us.ibm.com>

9 files changed, 599 insertions, 164 deletions

diff --git a/src/include/usr/hwpf/hwpf_reasoncodes.H b/src/include/usr/hwpf/hwpf_reasoncodes.H
index ce8f55e0e..37c3b50c9 100644
--- a/src/include/usr/hwpf/hwpf_reasoncodes.H
+++ b/src/include/usr/hwpf/hwpf_reasoncodes.H
@@ -66,6 +66,8 @@ namespace fapi
         MOD_PLAT_ATTR_SVC_SET_BADDQ_DATA           = 0x1B,
         MOD_HOST_COALESCE_HOST                     = 0x1C,
         MOD_ATTR_OVERRIDE                          = 0x1D,
+        MOD_PLAT_SPECIAL_WAKEUP                    = 0x1E,
+
     };
 
     /**
@@ -114,6 +116,7 @@ namespace fapi
         RC_HOST_TIMER_EXPIRED         = HWPF_COMP_ID | 0x2A,
         RC_HOST_TIMER_THREAD_FAIL     = HWPF_COMP_ID | 0x2B,
         RC_NULL_POINTER               = HWPF_COMP_ID | 0x2C,
+        RC_RT_WAKEUP_FAILED           = HWPF_COMP_ID | 0x2D,
     };
 
     /**
diff --git a/src/include/usr/runtime/rt_targeting.H b/src/include/usr/runtime/rt_targeting.H
new file mode 100644
index 000000000..d3e5475cd
--- /dev/null
+++ b/src/include/usr/runtime/rt_targeting.H
@@ -0,0 +1,70 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/include/usr/runtime/rt_targeting.H $                      */
+/*                                                                        */
+/* IBM CONFIDENTIAL                                                       */
+/*                                                                        */
+/* COPYRIGHT International Business Machines Corp. 2014                   */
+/*                                                                        */
+/* 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                                                     */
+#ifndef __RT_TARGETING_H
+#define __RT_TARGETING_H
+
+#include <errl/errlentry.H>
+
+namespace TARGETING
+{
+    class Target;
+}
+
+namespace RT_TARG
+{
+    typedef uint64_t rtChipId_t;
+
+    enum
+    {
+        CHIPID_NODE_SHIFT = 3,  //!< CHIPID NODE is 'NNNCCC'b
+        MEMBUF_ID_SHIFT = 4,    //!< CHIPID for MEMBUF is 'NNNCCCMMMM'b
+        UNIT_ID_SHIFT   = 4,    //!< CHIPID for CORE is 'NNNCCCPPPP'b
+        UNIT_ID_MASK    = 0x000003ff, //!< Valid id bits w/o ID_FLAG
+        PROC_ID_TYPE    = 0x00000000, //!< PROC chip id type
+        MEMBUF_ID_TYPE  = 0x80000000, //!< MEMBUF chip id type
+        CORE_ID_TYPE    = 0x40000000, //!< CORE/EX chip id type
+        CHIPID_ID_MASK  = 0xFF000000, //!< TYPE field
+    };
+
+
+    /**
+     * @brief Convert a TARGETING::Target to an unit ID that can be used
+     * in calls to Sapphire
+     * @param[in] The HB TARGETING::Target
+     * @param[out] Sapphire target id
+     * @return an error handle on error
+     */
+    errlHndl_t getRtTarget(const TARGETING::Target* i_target,
+                           rtChipId_t &o_targetId);
+
+    /**
+     * @brier Convert a runtime chip_id (target) into a TARGETING::Target
+     * @param[in] The rt chipId
+     * @param[out] The TARGETING::Target pointer
+     * @return error log handle on error else NULL
+     */
+    errlHndl_t getHbTarget(rtChipId_t i_rt_chip_id,
+                           TARGETING::Target *& o_target);
+};
+
+#endif
diff --git a/src/include/usr/targeting/common/targreasoncodes.H b/src/include/usr/targeting/common/targreasoncodes.H
index fcd45ae95..cc05ae437 100644
--- a/src/include/usr/targeting/common/targreasoncodes.H
+++ b/src/include/usr/targeting/common/targreasoncodes.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* IBM CONFIDENTIAL                                                       */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2011,2013              */
+/* COPYRIGHT International Business Machines Corp. 2011,2014              */
 /*                                                                        */
 /* p1                                                                     */
 /*                                                                        */
@@ -39,6 +39,8 @@ enum TargetingModuleId
     TARG_MOD_TEST           = 0x01,
     TARG_MOD_ATTRRP         = 0x02,
     TARG_MOD_ATTR_SYNC      = 0x03,
+    TARG_RT_GET_RT_TARGET   = 0x04,
+    TARG_RT_GET_HB_TARGET   = 0x05,
 };
 
 enum TargetingReasonCode
@@ -52,6 +54,9 @@ enum TargetingReasonCode
     TARG_RC_ATTR_SYNC_TO_FSP_FAIL        = TARG_COMP_ID | 0x07,
     TARG_RC_ATTR_SYNC_REQUEST_TO_HB_FAIL = TARG_COMP_ID | 0x08,
     TARG_RC_ATTR_SYNC_TO_HB_FAIL         = TARG_COMP_ID | 0x09,
+    TARG_RT_UNIT_TARGET_NOT_FOUND        = TARG_COMP_ID | 0x0a,
+    TARG_RT_NO_PROC_TARGET               = TARG_COMP_ID | 0x0b,
+    TARG_RT_TARGET_TYPE_NOT_SUPPORTED    = TARG_COMP_ID | 0x0c,
 };
 
 }; // End TARGETING namespace
diff --git a/src/include/usr/xscom/xscomreasoncodes.H b/src/include/usr/xscom/xscomreasoncodes.H
index c3af7a186..5f6593da7 100644
--- a/src/include/usr/xscom/xscomreasoncodes.H
+++ b/src/include/usr/xscom/xscomreasoncodes.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* IBM CONFIDENTIAL                                                       */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2011,2013              */
+/* COPYRIGHT International Business Machines Corp. 2011,2014              */
 /*                                                                        */
 /* p1                                                                     */
 /*                                                                        */
@@ -39,7 +39,6 @@ namespace XSCOM
         XSCOM_DO_OP                 = 0x07,
         XSCOM_RT_DO_OP              = 0x08,
         XSCOM_RT_SANITY_CHECK       = 0x09,
-        XSCOM_RT_GET_TARGET         = 0x0A,
     };
 
     enum xscomReasonCode
@@ -51,8 +50,6 @@ namespace XSCOM
         XSCOM_MMIO_UNMAP_ERR       = XSCOM_COMP_ID | 0x05,
         XSCOM_RUNTIME_ERR          = XSCOM_COMP_ID | 0x06,
         XSCOM_RUNTIME_INTERFACE_ERR = XSCOM_COMP_ID | 0x07,
-        XSCOM_RT_NO_MCS_TARGET     = XSCOM_COMP_ID | 0x08,
-        XSCOM_RT_NO_PROC_TARGET    = XSCOM_COMP_ID | 0x09,
     };
 };
 
diff --git a/src/usr/hwpf/plat/fapiPlatUtil.C b/src/usr/hwpf/plat/fapiPlatUtil.C
index 452158127..1c85d0a54 100644
--- a/src/usr/hwpf/plat/fapiPlatUtil.C
+++ b/src/usr/hwpf/plat/fapiPlatUtil.C
@@ -41,6 +41,8 @@
 #ifdef __HOSTBOOT_RUNTIME
 #include <runtime/interface.h>
 #include <targeting/common/targetservice.H>
+#include <runtime/rt_targeting.H>
+#include <hwpf/hwpf_reasoncodes.H>
 #endif
 
 //******************************************************************************
@@ -261,24 +263,48 @@ fapi::ReturnCode fapiSpecialWakeup(const fapi::Target & i_target,
 #ifdef __HOSTBOOT_RUNTIME
     if(g_hostInterfaces && g_hostInterfaces->wakeup)
     {
-        // TODO Support wakeup RTC = 98665
-        // We need to merge all rt - sapphire tareting id stuff into a
-        // common runtime targeting util - right now some is in xscom and some
-        // is in RT_OCC.
+        TARGETING::Target* target =
+            reinterpret_cast<TARGETING::Target*>(i_target.get());
 
-        //TARGETING::Target* target =
-        //    reinterpret_cast<TARGETING::Target*>(i_target.get());
-
-        //uint64_t core_id = 0;
-        //int rc = g_hostInterfaces->wakeup(core_id,0);
-        //if(rc)
-        //{
-        //    FAPI_ERR("CPU core wakeup call to hypervisor returned rc = %d",
-        //             rc);
+        RT_TARG::rtChipId_t core_id = 0;
+        errlHndl_t err = RT_TARG::getRtTarget(target, core_id);
+        if(err)
+        {
+            fapi_rc.setPlatError(reinterpret_cast<void *>(err));
+        }
+        else
+        {
+            uint32_t mode = 0;   //Force awake
+            if(!i_enable)
+            {
+                mode = 1;       // clear force
+            }
+            int rc = g_hostInterfaces->wakeup(core_id, mode);
 
-            // Make error log
+            if(rc)
+            {
+                FAPI_ERR("CPU core wakeup call to hypervisor returned rc = %d",
+                         rc);
+                /*@
+                 * @errortype
+                 * @moduleid     fapi::MOD_PLAT_SPECIAL_WAKEUP
+                 * @reasoncode   fapi::RC_RT_WAKEUP_FAILED
+                 * @userdata1    Hypervisor return code
+                 * @userdata2    Chiplet HUID
+                 * @devdesc      Error code from hypervisor wakeup call
+                 */
+                const bool hbSwError = true;
+                err = new ERRORLOG::ErrlEntry(
+                                              ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                                              fapi::MOD_PLAT_SPECIAL_WAKEUP,
+                                              fapi::RC_RT_WAKEUP_FAILED,
+                                              rc,
+                                              TARGETING::get_huid(target),
+                                              hbSwError);
 
-        //}
+                fapi_rc.setPlatError(reinterpret_cast<void*>(err));
+            }
+        }
     }
 #endif
     // On Hostboot, processor cores cannot sleep so return success to the
diff --git a/src/usr/targeting/runtime/makefile b/src/usr/targeting/runtime/makefile
index 9efa9547f..51296c71e 100644
--- a/src/usr/targeting/runtime/makefile
+++ b/src/usr/targeting/runtime/makefile
@@ -5,7 +5,7 @@
 #
 # IBM CONFIDENTIAL
 #
-# COPYRIGHT International Business Machines Corp. 2013
+# COPYRIGHT International Business Machines Corp. 2013,2014
 #
 # p1
 #
@@ -30,7 +30,8 @@ TARGETING_REL_PATH = ..
 include ${TARGETING_REL_PATH}/hostboot_common.mk
 vpath %.C ${TARGETING_REL_PATH}
 
-HOSTBOOT_RUNTIME_SPECIFIC_OBJS = attrrp_rt.o start_rt.o targplatutil.o
+HOSTBOOT_RUNTIME_SPECIFIC_OBJS = attrrp_rt.o start_rt.o targplatutil.o \
+                                 rt_targeting.o
 
 OBJS = ${COMMON_TARGETING_OBJS} ${HOSTBOOT_RUNTIME_SPECIFIC_OBJS}
 
diff --git a/src/usr/targeting/runtime/rt_targeting.C b/src/usr/targeting/runtime/rt_targeting.C
new file mode 100644
index 000000000..b0aa06aca
--- /dev/null
+++ b/src/usr/targeting/runtime/rt_targeting.C
@@ -0,0 +1,400 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/usr/targeting/runtime/rt_targeting.C $                    */
+/*                                                                        */
+/* IBM CONFIDENTIAL                                                       */
+/*                                                                        */
+/* COPYRIGHT International Business Machines Corp. 2014                   */
+/*                                                                        */
+/* 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                                                     */
+#include <errl/errlentry.H>
+#include <errl/errlmanager.H>
+#include <errl/errludlogregister.H>
+#include <errl/errludtarget.H>
+#include <targeting/common/targetservice.H>
+#include <targeting/common/iterators/rangefilter.H>
+#include <targeting/common/predicates/predicatepostfixexpr.H>
+#include <targeting/common/predicates/predicateattrval.H>
+#include <targeting/common/predicates/predicatectm.H>
+#include <targeting/common/utilFilter.H>
+#include <targeting/common/trace.H>
+#include <targeting/common/targreasoncodes.H>
+
+#include <runtime/rt_targeting.H>
+
+using namespace TARGETING;
+
+namespace RT_TARG
+{
+
+errlHndl_t procRtTargetError(const TARGETING::Target * i_target)
+{
+    errlHndl_t err = NULL;
+    uint32_t huid = get_huid(i_target);
+    TRACFCOMP(g_trac_targeting,ERR_MRK
+              "No proc target found for target. huid: %08x",
+              huid);
+    /*@
+     * @errortype
+     * @moduleid     TARG_RT_GET_RT_TARGET
+     * @reasoncode   TARG_RT_NO_PROC_TARGET
+     * @userdata1    HUID of the UNIT target
+     * @devdesc      No processor target found for the UNIT
+     */
+    err =
+        new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_INFORMATIONAL,
+                                TARGETING::TARG_RT_GET_RT_TARGET,
+                                TARGETING::TARG_RT_NO_PROC_TARGET,
+                                huid,
+                                0,
+                                true);
+
+    ERRORLOG::ErrlUserDetailsTarget(i_target,"Runtime Target").
+        addToLog(err);
+
+    return err;
+}
+
+
+errlHndl_t getRtTarget(const TARGETING::Target* i_target,
+                       rtChipId_t &o_chipId)
+{
+    errlHndl_t err = NULL;
+
+    do
+    {
+        if(i_target == TARGETING::MASTER_PROCESSOR_CHIP_TARGET_SENTINEL)
+        {
+            TARGETING::Target* masterProcChip = NULL;
+            TARGETING::targetService().
+                masterProcChipTargetHandle(masterProcChip);
+
+            i_target = masterProcChip;
+        }
+
+        TARGETING::TYPE target_type = i_target->getAttr<TARGETING::ATTR_TYPE>();
+
+        if(target_type == TARGETING::TYPE_PROC)
+        {
+            // use 0b0000.0000.0000.0000.0000.0000.00NN.NCCC:
+            uint32_t fabId =
+                i_target->getAttr<TARGETING::ATTR_FABRIC_NODE_ID>();
+
+            uint32_t procPos =
+                i_target->getAttr<TARGETING::ATTR_FABRIC_CHIP_ID>();
+
+            o_chipId = (fabId << CHIPID_NODE_SHIFT) + procPos;
+        }
+        else if( target_type == TARGETING::TYPE_MEMBUF)
+        {
+            //MEMBUF
+            // 0b1000.0000.0000.0000.0000.00NN.NCCC.MMMM
+            // where NNN id node, CCC is chip, MMMM is memory channel
+            //
+            TARGETING::TargetHandleList targetList;
+
+            getParentAffinityTargets(targetList,
+                                    i_target,
+                                    TARGETING::CLASS_UNIT,
+                                    TARGETING::TYPE_MCS);
+
+            if( targetList.empty() )
+            {
+                uint32_t huid = get_huid(i_target);
+                TRACFCOMP(g_trac_targeting,ERR_MRK
+                          "getRtTarget: No target found for huid: %08x",
+                          huid);
+                /*@
+                 * @errortype
+                 * @moduleid     TARG_RT_GET_RT_TARGET
+                 * @reasoncode   TARG_RT_UNIT_TARGET_NOT_FOUND
+                 * @userdata1    HUID of given MEMBUF target
+                 * @devdesc      No MCS target(s) found for the
+                 *               given MEMBUF target
+                 */
+                err =
+                    new ERRORLOG::ErrlEntry
+                    (ERRORLOG::ERRL_SEV_INFORMATIONAL,
+                     TARGETING::TARG_RT_GET_RT_TARGET,
+                     TARGETING::TARG_RT_UNIT_TARGET_NOT_FOUND,
+                     huid,
+                     0,
+                     true);
+
+                ERRORLOG::ErrlUserDetailsTarget(i_target,"Runtime Target").
+                    addToLog(err);
+
+                break;
+            }
+
+            TARGETING::Target * target = targetList[0];
+            uint32_t pos = target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+
+            targetList.clear();
+            getParentAffinityTargets(targetList,
+                                     target,
+                                     TARGETING::CLASS_CHIP,
+                                     TARGETING::TYPE_PROC);
+
+            if(targetList.empty())
+            {
+                err = procRtTargetError(target);
+                break;
+            }
+
+            TARGETING::Target * proc_target = targetList[0];
+
+            err = getRtTarget(proc_target, o_chipId);
+            if(err)
+            {
+                break;
+            }
+
+            o_chipId = (o_chipId << UNIT_ID_SHIFT);
+            o_chipId += pos;
+            o_chipId |= MEMBUF_ID_TYPE;
+        }
+        else if(target_type == TARGETING::TYPE_EX ||
+                target_type == TARGETING::TYPE_CORE)
+        {
+            // EX/CORE
+            // 0b0100.0000.0000.0000.0000.00NN.NCCC.PPPP
+            // NNN is node, CCC is chip, PPPP is core
+            uint32_t pos = i_target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
+
+            const TARGETING::Target * proc_target = getParentChip(i_target);
+            if(proc_target == NULL)
+            {
+                err =  procRtTargetError(i_target);
+                break;
+            }
+
+            err = getRtTarget(proc_target, o_chipId);
+            if(err)
+            {
+                break;
+            }
+
+            o_chipId = (o_chipId << UNIT_ID_SHIFT);
+            o_chipId += pos;
+            o_chipId |= CORE_ID_TYPE;
+        }
+        else
+        {
+            uint32_t huid = get_huid(i_target);
+            TRACFCOMP(g_trac_targeting,ERR_MRK
+                      "Runtime target type %d not supported."
+                      " huid: %08x",
+                      target_type,
+                      huid);
+            /*@
+             * @errortype
+             * @moduleid     TARG_RT_GET_RT_TARGET
+             * @reasoncode   TARG_RT_TARGET_TYPE_NOT_SUPPORTED
+             * @userdata1    HUID of the target
+             * @userdata2    target_type
+             * @devdesc      Target type not supported by HBRT.
+             */
+            err =
+                new ERRORLOG::ErrlEntry
+                (ERRORLOG::ERRL_SEV_INFORMATIONAL,
+                 TARGETING::TARG_RT_GET_RT_TARGET,
+                 TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED,
+                 huid,
+                 target_type,
+                 true);
+
+            ERRORLOG::ErrlUserDetailsTarget(i_target,"Runtime Target").
+                addToLog(err);
+        }
+    } while(0);
+
+    return err;
+}
+
+
+errlHndl_t getHbTarget(rtChipId_t i_rt_chip_id,
+                       TARGETING::Target *& o_target)
+{
+    errlHndl_t err = NULL;
+    o_target = NULL;
+
+    do
+    {
+        uint64_t idType = i_rt_chip_id & CHIPID_ID_MASK;
+
+        if(0 != (idType ==  MEMBUF_ID_TYPE))
+        {
+            //membuf
+            uint64_t chip_id = i_rt_chip_id & UNIT_ID_MASK;
+            uint32_t unitPos = chip_id & 0x0000000f;
+            chip_id >>= UNIT_ID_SHIFT;
+            TARGETING::Target * proc = NULL;
+            TARGETING::Target * msc = NULL;
+
+            err = getHbTarget(chip_id, proc);
+            if(err)
+            {
+                break;
+            }
+
+            PredicateCTM mcsFilter(CLASS_UNIT, TYPE_MCS);
+            PredicateAttrVal<ATTR_CHIP_UNIT> unitAttr(unitPos);
+            PredicatePostfixExpr mcsUnitFilter;
+            mcsUnitFilter.push(&mcsFilter).push(&unitAttr).And();
+
+            TargetHandleList target_list;
+
+            targetService().getAssociated( target_list,
+                                           proc,
+                                           TargetService::CHILD_BY_AFFINITY,
+                                           TargetService::ALL,
+                                           &mcsUnitFilter);
+
+            // should only be one result
+            if(target_list.size())
+            {
+                msc = target_list[0];
+
+                target_list.clear();
+
+
+                getChildAffinityTargets( target_list,
+                                         msc,
+                                         TARGETING::CLASS_CHIP,
+                                         TARGETING::TYPE_MEMBUF);
+
+                // should only be one result
+                if(target_list.size())
+                {
+                    o_target = target_list[0];
+                }
+            }
+
+            if(o_target == NULL) // no mcs and/or membuf found
+            {
+                TRACFCOMP(g_trac_targeting,ERR_MRK "getHbTarget: "
+                          "MCS or MEMBUF target not found for chipId %08lx",
+                          i_rt_chip_id);
+                /*@
+                 * @errortype
+                 * @moduleid     TARGETING::TARG_RT_GET_HB_TARGET
+                 * @reasoncode   TARG_RT_UNIT_TARGET_NOT_FOUND
+                 * @userdata1    Runtime chip Id
+                 * @devdesc      No MCS or MEMBUF target(s) found for the
+                 *               given target
+                 */
+                err =
+                    new ERRORLOG::ErrlEntry
+                    (ERRORLOG::ERRL_SEV_INFORMATIONAL,
+                     TARGETING::TARG_RT_GET_HB_TARGET,
+                     TARGETING::TARG_RT_UNIT_TARGET_NOT_FOUND,
+                     i_rt_chip_id,
+                     0,
+                     true);
+            }
+
+        }
+        else if(0 != (idType == CORE_ID_TYPE))
+        {
+            // core/ex  will alway return EX chiplet as there is no concept
+            //  (yet) of a core in fapi
+            uint64_t chip_id = i_rt_chip_id & UNIT_ID_MASK;
+            uint32_t unitPos = chip_id & 0x0000000f;
+            chip_id >>= UNIT_ID_SHIFT;
+            TARGETING::Target * proc = NULL;
+
+            err = getHbTarget(chip_id, proc);
+            if(err)
+            {
+                break;
+            }
+
+            PredicateCTM exFilter(CLASS_UNIT, TYPE_EX);
+            PredicateAttrVal<ATTR_CHIP_UNIT> unitAttr(unitPos);
+            PredicatePostfixExpr exUnitFilter;
+            exUnitFilter.push(&exFilter).push(&unitAttr).And();
+
+            TargetHandleList target_list;
+
+            targetService().getAssociated( target_list,
+                                           proc,
+                                           TargetService::CHILD,
+                                           TargetService::ALL,
+                                           &exUnitFilter);
+
+            //Should only be one result
+            if(target_list.size())
+            {
+                o_target = target_list[0];
+            }
+            // o_target not found caught below..
+        }
+        else if( idType == PROC_ID_TYPE)
+        {
+            // assume processor chip
+            // chip_id  = 'NNNCCC'b
+            uint32_t fabId = i_rt_chip_id >> CHIPID_NODE_SHIFT;
+            uint32_t procPos = i_rt_chip_id & 0x7;
+
+            PredicateCTM procFilter(CLASS_CHIP, TYPE_PROC);
+            PredicateAttrVal<ATTR_FABRIC_NODE_ID> nodeFilter(fabId);
+            PredicateAttrVal<ATTR_FABRIC_CHIP_ID> chipFilter(procPos);
+
+            PredicatePostfixExpr theProc, theAttrs;
+            theAttrs.push(&nodeFilter).push(&chipFilter).And();
+            theProc.push(&procFilter).push(&theAttrs).And();
+
+            TargetRangeFilter procRange(targetService().begin(),
+                                        targetService().end(),
+                                        &theProc);
+
+            if(procRange)
+            {
+                o_target = *procRange;
+            }
+        }
+
+        if(!err && o_target == NULL)
+        {
+            TRACFCOMP( g_trac_targeting,
+                       ERR_MRK"Can't find HB target for chipId 0x%lx",
+                       i_rt_chip_id);
+            /*@
+             * @errortype
+             * @moduleid     TARGETING::TARG_RT_GET_HB_TARGET
+             * @reasoncode   TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED
+             * @userdata1    runtime procId
+             * @userdata2    0
+             * @devdesc      Can't find HB Target for chipId provided.
+             */
+            err =
+                new ERRORLOG::ErrlEntry
+                (
+                 ERRORLOG::ERRL_SEV_UNRECOVERABLE,
+                 TARGETING::TARG_RT_GET_HB_TARGET,
+                 TARGETING::TARG_RT_TARGET_TYPE_NOT_SUPPORTED,
+                 i_rt_chip_id,
+                 0,
+                 true);
+
+        }
+    } while(0);
+
+    return err;
+}
+
+}; // namespace
diff --git a/src/usr/targeting/runtime/test/testtargeting.H b/src/usr/targeting/runtime/test/testtargeting.H
index d68ade369..22d79df05 100644
--- a/src/usr/targeting/runtime/test/testtargeting.H
+++ b/src/usr/targeting/runtime/test/testtargeting.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* IBM CONFIDENTIAL                                                       */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2013                   */
+/* COPYRIGHT International Business Machines Corp. 2013,2014              */
 /*                                                                        */
 /* p1                                                                     */
 /*                                                                        */
@@ -22,6 +22,11 @@
 /* IBM_PROLOG_END_TAG                                                     */
 #include <cxxtest/TestSuite.H>
 #include <targeting/common/commontargeting.H>
+#include <runtime/rt_targeting.H>
+#include <errl/errlentry.H>
+#include <errl/errlmanager.H>
+#include <targeting/common/trace.H>
+#include <targeting/common/utilFilter.H>
 
 class TargetingTestSuite : public CxxTest::TestSuite
 {
@@ -42,4 +47,69 @@ class TargetingTestSuite : public CxxTest::TestSuite
 
             (void)l_pTarget->getAttr<ATTR_PHYS_PATH>().dump();
         }
+
+        void testHBRT_targets()
+        {
+            using namespace TARGETING;
+            errlHndl_t err = NULL;
+            RT_TARG::rtChipId_t rt_chipid;
+
+            TARGETING::TargetHandleList allTargets;
+            TARGETING::TargetHandleList targetList;
+
+            getAllChips(targetList, TYPE_PROC);
+
+            allTargets.insert(allTargets.end(),
+                              targetList.begin(),
+                              targetList.end());
+
+            targetList.clear();
+            getAllChips(targetList,TYPE_MEMBUF);
+
+            allTargets.insert(allTargets.end(),
+                              targetList.begin(),
+                              targetList.end());
+
+            targetList.clear();
+            getAllChiplets(targetList, TYPE_EX);
+
+            allTargets.insert(allTargets.end(),
+                              targetList.begin(),
+                              targetList.end());
+
+
+            for(TargetHandleList::iterator pTarg = allTargets.begin();
+                pTarg != allTargets.end(); ++pTarg)
+            {
+                err = RT_TARG::getRtTarget(*pTarg, rt_chipid);
+                if( err )
+                {
+                    TS_FAIL("getRtTarget returned error log");
+                    errlCommit( err, TARG_COMP_ID);
+                    err = NULL;
+                    break;
+                }
+                TRACDCOMP(g_trac_targeting,"chipId = %x",rt_chipid);
+
+                TARGETING::Target * target = NULL;
+
+                err = RT_TARG::getHbTarget(rt_chipid, target);
+                if(err)
+                {
+                    TS_FAIL("getRtTarget_returned error log");
+                    errlCommit( err, TARG_COMP_ID);
+                    err = NULL;
+                    break;
+                }
+
+                if(*pTarg != target)
+                {
+                    TS_FAIL("testHBRT_targets failed for rt_chipID %x"
+                            "target_in %p, target_out %p",
+                            rt_chipid,
+                            *pTarg,
+                            target);
+                }
+            }
+        }
 };
diff --git a/src/usr/xscom/runtime/rt_xscom.C b/src/usr/xscom/runtime/rt_xscom.C
index 13c2557ba..a9b74bd14 100644
--- a/src/usr/xscom/runtime/rt_xscom.C
+++ b/src/usr/xscom/runtime/rt_xscom.C
@@ -32,6 +32,7 @@
 #include <errl/errludlogregister.H>
 #include <runtime/interface.h>
 #include <errl/errludtarget.H>
+#include <runtime/rt_targeting.H>
 
 // Trace definition
 trace_desc_t* g_trac_xscom = NULL;
@@ -40,14 +41,6 @@ TRAC_INIT(&g_trac_xscom, "XSCOM", 2*KILOBYTE, TRACE::BUFFER_SLOW);
 namespace XSCOM
 {
 
-enum
-{
-    CHIPID_NODE_SHIFT = 3,  // CHIPID is 'NNNCCC'b, shift 3
-    MEMBUF_ID_SHIFT = 4,    // CHIPID for MEMBUF is 'NNNCCCMMMM'b
-    MEMBUF_ID_FLAG  = 0x80000000, // MEMBUF chip id has MSbit on
-};
-
-
 DEVICE_REGISTER_ROUTE(DeviceFW::WILDCARD,
                       DeviceFW::XSCOM,
                       TARGETING::TYPE_PROC,
@@ -69,15 +62,6 @@ DEVICE_REGISTER_ROUTE(DeviceFW::WILDCARD,
                       TARGETING::TYPE_MEMBUF,
                       xscomPerformOp);
 /**
- * @brief Convert target into chipId that the hypervisor uses
- * @param[in]   i_target   The HB TARGETING target
- * @param[out]  o_chipId    Chipid
- * @return      errlHndl_t  Error handle if there was an error
- */
-errlHndl_t get_rt_target(TARGETING::Target* i_target,
-                         uint64_t & o_chipId);
-
-/**
  * @brief Internal routine that verifies the validity of input parameters
  * for an XSCOM access.
  *
@@ -160,127 +144,6 @@ errlHndl_t xscomOpSanityCheck(const DeviceFW::OperationType i_opType,
     return l_err;
 }
 
-
-errlHndl_t get_rt_target(TARGETING::Target* i_target,
-                         uint64_t &o_chipId)
-{
-    errlHndl_t l_err = NULL;
-
-    do
-    {
-        if(i_target == TARGETING::MASTER_PROCESSOR_CHIP_TARGET_SENTINEL)
-        {
-            TARGETING::Target* masterProcChip = NULL;
-            TARGETING::targetService().
-                masterProcChipTargetHandle(masterProcChip);
-
-            i_target = masterProcChip;
-        }
-
-        uint32_t target_type = i_target->getAttr<TARGETING::ATTR_TYPE>();
-
-        if(target_type == TARGETING::TYPE_MEMBUF)
-        {
-            TARGETING::TargetHandleList targetList;
-
-            // need to get assoicated MC for this MEMBUF
-            getParentAffinityTargets(targetList,
-                                     i_target,
-                                     TARGETING::CLASS_UNIT,
-                                     TARGETING::TYPE_MCS);
-            if( targetList.empty() )
-            {
-                uint32_t huid = get_huid(i_target);
-                TRACFCOMP(g_trac_xscom,ERR_MRK
-                          "No MSC target found for MEMBUF. MEMBUF huid: %08x",
-                          huid);
-                /*@
-                 * @errortype
-                 * @moduleid     XSCOM_RT_GET_TARGET
-                 * @reasoncode   XSCOM_RT_NO_MCS_TARGET
-                 * @userdata1    HUID of MEMBUF target
-                 * @devdesc      No memory controller target found for the
-                 *               given Memory data controller
-                 */
-                l_err =
-                    new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_INFORMATIONAL,
-                                            XSCOM_RT_GET_TARGET,
-                                            XSCOM_RT_NO_MCS_TARGET,
-                                            huid,
-                                            0);
-
-                l_err->addProcedureCallout(HWAS::EPUB_PRC_HB_CODE,
-                                           HWAS::SRCI_PRIORITY_HIGH);
-
-                ERRORLOG::ErrlUserDetailsTarget(i_target,"SCOM Target").
-                    addToLog(l_err);
-
-                break;
-            }
-
-            TARGETING::Target * mcs_target = targetList[0];
-            uint32_t mcpos = mcs_target->getAttr<TARGETING::ATTR_CHIP_UNIT>();
-
-            // Get associated proc chip
-            targetList.clear();
-            getParentAffinityTargets(targetList,
-                                     mcs_target,
-                                     TARGETING::CLASS_CHIP,
-                                     TARGETING::TYPE_PROC);
-
-            if(targetList.empty())
-            {
-                uint32_t huid = get_huid(mcs_target);
-                TRACFCOMP(g_trac_xscom,ERR_MRK
-                          "No proc target found for MSC. MSC huid: %08x",
-                          huid);
-                /*@
-                 * @errortype
-                 * @moduleid     XSCOM_RT_GET_TARGET
-                 * @reasoncode   XSCOM_RT_NO_PROC_TARGET
-                 * @userdata1    HUID of the MSC target
-                 * @devdesc      No processor target found for the Memory
-                 *               controller.
-                 */
-                l_err =
-                    new ERRORLOG::ErrlEntry(ERRORLOG::ERRL_SEV_INFORMATIONAL,
-                                            XSCOM_RT_GET_TARGET,
-                                            XSCOM_RT_NO_PROC_TARGET,
-                                            huid,
-                                            0);
-
-                l_err->addProcedureCallout(HWAS::EPUB_PRC_HB_CODE,
-                                           HWAS::SRCI_PRIORITY_HIGH);
-
-                ERRORLOG::ErrlUserDetailsTarget(mcs_target,"SCOM Target").
-                    addToLog(l_err);
-
-                break;
-            }
-
-            TARGETING::Target * proc_target = targetList[0];
-            uint32_t fabId =
-                proc_target->getAttr<TARGETING::ATTR_FABRIC_NODE_ID>();
-            uint32_t procPos =
-                proc_target->getAttr<TARGETING::ATTR_FABRIC_CHIP_ID>();
-
-            o_chipId = (fabId << CHIPID_NODE_SHIFT) + procPos;
-            o_chipId = (o_chipId << MEMBUF_ID_SHIFT) | MEMBUF_ID_FLAG;
-            o_chipId += mcpos;
-        }
-        else // must be proc
-        {
-            uint32_t fabId = i_target->getAttr<TARGETING::ATTR_FABRIC_NODE_ID>();
-            uint32_t procPos = i_target->getAttr<TARGETING::ATTR_FABRIC_CHIP_ID>();
-
-            o_chipId = (fabId << CHIPID_NODE_SHIFT) + procPos;
-        }
-    } while(0);
-
-    return l_err;
-}
-
-
 /**
  * @brief Do the scom operation
  */
@@ -291,11 +154,11 @@ errlHndl_t  xScomDoOp(DeviceFW::OperationType i_ioType,
 {
     errlHndl_t l_err = NULL;
     int rc = 0;
-    uint64_t proc_id = 0;
+    RT_TARG::rtChipId_t proc_id = 0;
 
     // Convert target to something  Sapphire understands
-    l_err = get_rt_target(i_target,
-                          proc_id);
+    l_err = RT_TARG::getRtTarget(i_target,
+                                 proc_id);
 
     if(l_err)
     {