Add MCBIST Target Support

-- Support MCBIST targets
-- Fix MCS targets

Change-Id: Ib80e0986171102877059fd3142412277b6d0189f
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/26330
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: Gregory S. Still <stillgs@us.ibm.com>
Reviewed-by: Sunil Kumar <skumar8j@in.ibm.com>
Reviewed-by: Jennifer A. Stofer <stofer@us.ibm.com>

3 files changed, 36 insertions, 75 deletions

diff --git a/hwpf/include/plat/plat_target_parms.H b/hwpf/include/plat/plat_target_parms.H
index 74825e05..f43fe202 100644
--- a/hwpf/include/plat/plat_target_parms.H
+++ b/hwpf/include/plat/plat_target_parms.H
@@ -41,13 +41,13 @@ CONST_UINT32_T(NEST_GROUP1_TARGET_OFFSET,  CHIP_TARGET_OFFSET + CHIP_TARGET_COUN
 CONST_UINT32_T(NEST_GROUP1_CHIPLET_OFFSET, 0x1);
 CONST_UINT32_T(NEST_GROUP1_TARGET_COUNT,   6);
 
-// MCS targets
-CONST_UINT32_T(MCS_TARGET_OFFSET, NEST_GROUP1_TARGET_OFFSET + NEST_GROUP1_TARGET_COUNT);
-CONST_UINT32_T(MCS_CHIPLET_OFFSET,      0x7);
-CONST_UINT32_T(MCS_TARGET_COUNT,        2);
+// MCBIST targets
+CONST_UINT32_T(MCBIST_TARGET_OFFSET, NEST_GROUP1_TARGET_OFFSET + NEST_GROUP1_TARGET_COUNT);
+CONST_UINT32_T(MCBIST_CHIPLET_OFFSET,      0x7);
+CONST_UINT32_T(MCBIST_TARGET_COUNT,        2);
 
 // Nest targets - Group 2
-CONST_UINT32_T(NEST_GROUP2_TARGET_OFFSET, MCS_TARGET_OFFSET + MCS_TARGET_COUNT);
+CONST_UINT32_T(NEST_GROUP2_TARGET_OFFSET, MCBIST_TARGET_OFFSET + MCBIST_TARGET_COUNT);
 CONST_UINT32_T(NEST_GROUP2_TARGET_COUNT,   7);
 CONST_UINT32_T(NEST_GROUP2_CHIPLET_OFFSET, 0x9);
 
@@ -66,76 +66,28 @@ CONST_UINT32_T(EX_TARGET_OFFSET, CORE_TARGET_OFFSET + CORE_TARGET_COUNT);
 CONST_UINT32_T(EX_CHIPLET_OFFSET,       0x10);
 CONST_UINT32_T(EX_TARGET_COUNT,         12);
 
+// MCS Targets
+CONST_UINT32_T(MCS_TARGET_OFFSET, EX_TARGET_OFFSET + EX_TARGET_COUNT);
+CONST_UINT32_T(MCS_TARGET_COUNT,         4);
+
 // System Target
-CONST_UINT32_T(SYSTEM_TARGET_OFFSET, EX_TARGET_OFFSET + EX_TARGET_COUNT);
+CONST_UINT32_T(SYSTEM_TARGET_OFFSET, MCS_TARGET_OFFSET + MCS_TARGET_COUNT);
 CONST_UINT32_T(SYSTEM_TARGET_COUNT,     1);
 
 CONST_UINT32_T(MCAST_TARGET_OFFSET, SYSTEM_TARGET_OFFSET + SYSTEM_TARGET_COUNT);
 CONST_UINT32_T(MCAST_CHIPLET_OFFSET,    4);
 CONST_UINT32_T(MCAST_TARGET_COUNT,      3);  // PPE only needs multicast groups 4-6
 
-// Total number of pervasive targets (Both NEST groups + EQs + COREs +MCSs)
+// Total number of pervasive targets (Both NEST groups + EQs + COREs +MCBISTs)
 CONST_UINT32_T(PERV_TARGET_COUNT, NEST_GROUP1_TARGET_COUNT + NEST_GROUP2_TARGET_COUNT +
-        MCS_TARGET_COUNT + EQ_TARGET_COUNT + CORE_TARGET_COUNT);
+        MCBIST_TARGET_COUNT + EQ_TARGET_COUNT + CORE_TARGET_COUNT);
 
 // Total Target Count
 CONST_UINT32_T(TARGET_COUNT,            CHIP_TARGET_COUNT +
                                         PERV_TARGET_COUNT +
                                         EX_TARGET_COUNT +
+                                        MCS_TARGET_COUNT +
                                         SYSTEM_TARGET_COUNT +
                                         MCAST_TARGET_COUNT);
 
-/*
-enum TargetFilter
-{
-    TARGET_FILTER_ALL_NEST   ,
-    TARGET_FILTER_NEST_NORTH ,
-    TARGET_FILTER_NEST_SOUTH ,
-    TARGET_FILTER_NEST_EAST  ,
-    TARGET_FILTER_NEST_WEST  ,
-    TARGET_FILTER_XBUS       ,
-    TARGET_FILTER_ALL_OBUS   ,
-    TARGET_FILTER_OBUS0      ,
-    TARGET_FILTER_OBUS1      ,
-    TARGET_FILTER_OBUS2      ,
-    TARGET_FILTER_OBUS3      ,
-    TARGET_FILTER_ALL_PCI    ,
-    TARGET_FILTER_PCI0       ,
-    TARGET_FILTER_PCI1       ,
-    TARGET_FILTER_PCI2       ,
-    TARGET_FILTER_ALL_EC     ,
-    TARGET_FILTER_ALL_EP     ,
-    TARGET_FILTER_ALL_MC     ,
-    TARGET_FILTER_MC_WEST    ,
-    TARGET_FILTER_MC_EAST    ,
-    TARGET_FILTER_TP         ,
-};
-
-// The order of this MUST match the order of the TargetFilter enum above
-// The bit vectors represent
-const uint64_t TargetFilters[] =
-{
-    BITS(2,4),   // TARGET_FILTER_ALL_NEST
-    BIT(2),      // TARGET_FILTER_NEST_NORTH
-    BIT(3),      // TARGET_FILTER_NEST_SOUTH
-    BIT(4),      // TARGET_FILTER_NEST_EAST
-    BIT(5),      // TARGET_FILTER_NEST_WEST
-    BIT(6),      // TARGET_FILTER_XBUS
-    BITS(9,4),   // TARGET_FILTER_ALL_OBUS
-    BIT(9),      // TARGET_FILTER_OBUS0
-    BIT(10),     // TARGET_FILTER_OBUS1
-    BIT(11),     // TARGET_FILTER_OBUS2
-    BIT(12),     // TARGET_FILTER_OBUS3
-    BITS(13,3),  // TARGET_FILTER_ALL_PCI
-    BIT(12),     // TARGET_FILTER_PCI0
-    BIT(13),     // TARGET_FILTER_PCI1
-    BIT(14),     // TARGET_FILTER_PCI2
-    BITS(32,24), // TARGET_FILTER_ALL_EC
-    BITS(16,6),  // TARGET_FILTER_ALL_EP
-    BITS(7,2),   // TARGET_FILTER_ALL_MC
-    BIT(7),      // TARGET_FILTER_MC_WEST
-    BIT(8),      // TARGET_FILTER_MC_EAST
-    BIT(1),      // TARGET_FILTER_TP
-};
-*/
 #endif  // __FAPI2_PPE_TARGET_PARMS__
diff --git a/hwpf/include/plat/target.H b/hwpf/include/plat/target.H
index 4d37d4e6..0b7e9d89 100644
--- a/hwpf/include/plat/target.H
+++ b/hwpf/include/plat/target.H
@@ -47,6 +47,8 @@ static const uint8_t CORES_PER_QUAD = 4;
 static const uint8_t EX_PER_QUAD = 2;
 static const uint8_t CORES_PER_EX = 2;
 static const uint8_t N3_CHIPLET = 5;
+static const uint8_t MCS_PER_MCBIST = 2;
+
 struct ScomAddr
 {
     ScomAddr(uint32_t i_addr) : iv_addr(i_addr)
@@ -128,11 +130,17 @@ namespace fapi2
             this->iv_handle.fields.type = TARGET_TYPE_EX;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
-        else if(K & TARGET_TYPE_MCS)
+        else if(K & TARGET_TYPE_MCBIST)
         {
 
-            this->iv_handle.fields.chiplet_num = l_plat_argument + MCS_CHIPLET_OFFSET;
-            this->iv_handle.fields.type = TARGET_TYPE_MCS | TARGET_TYPE_PERV;
+            this->iv_handle.fields.chiplet_num = l_plat_argument + MCBIST_CHIPLET_OFFSET;
+            this->iv_handle.fields.type = TARGET_TYPE_MCBIST | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type_target_num = l_plat_argument;
+        }
+        else if(K & TARGET_TYPE_MCS)
+        {
+            this->iv_handle.fields.chiplet_num = N3_CHIPLET - (MCS_PER_MCBIST * (l_plat_argument / MCS_PER_MCBIST));
+            this->iv_handle.fields.type = TARGET_TYPE_MCS;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
         else if(K == TARGET_TYPE_ALL)
@@ -199,7 +207,7 @@ namespace fapi2
     {
         static_assert(((K == TARGET_TYPE_EQ) ||
                        (K == TARGET_TYPE_CORE) ||
-                       (K == TARGET_TYPE_MCS) ||
+                       (K == TARGET_TYPE_MCBIST) ||
                        (K == TARGET_TYPE_PERV) ||
                        (K == TARGET_TYPE_EX)) &&
                       ((T == TARGET_TYPE_EQ) ||
@@ -214,10 +222,10 @@ namespace fapi2
                         "Invalid parent for EQ target, must be PERV or "
                         "PROC_CHIP");
 
-        static_assert(!((K == TARGET_TYPE_MCS) &&
+        static_assert(!((K == TARGET_TYPE_MCBIST) &&
                         (T != TARGET_TYPE_PERV) &&
                         (T != TARGET_TYPE_PROC_CHIP)),
-                        "Invalid parent for MCS target, must be PERV or "
+                        "Invalid parent for MCBIST target, must be PERV or "
                         "PROC_CHIP");
 
         static_assert(!((K == TARGET_TYPE_CORE) &&
@@ -240,11 +248,11 @@ namespace fapi2
                         "Invalid parent for EX target, must be PERV or "
                         "PROC_CHIP or EQ");
 
-        if(TARGET_TYPE_PERV == T) // EQ/EC/MCS/PERV ===> PERV
+        if(TARGET_TYPE_PERV == T) // EQ/EC/MCBIST/PERV ===> PERV
         {
             return this->iv_handle;
         }
-        if(TARGET_TYPE_PROC_CHIP == T) // EQ/EC/EX/MCS/PERV ===> PROC
+        if(TARGET_TYPE_PROC_CHIP == T) // EQ/EC/EX/MCBIST/PERV ===> PROC
         {
             return G_vec_targets[CHIP_TARGET_OFFSET];
         }
@@ -396,7 +404,7 @@ namespace fapi2
     {
         static_assert((K == TARGET_TYPE_PROC_CHIP), "Parent target must be the proc chip");
         static_assert((T == TARGET_TYPE_EQ) || (T == TARGET_TYPE_CORE)
-                || (T == TARGET_TYPE_PERV) || (T == TARGET_TYPE_MCS),
+                || (T == TARGET_TYPE_PERV) || (T == TARGET_TYPE_MCBIST),
                 "Child target type must be a pervasive chiplet");
 
         std::vector<Target<T> > l_children;
@@ -524,7 +532,7 @@ namespace fapi2
                                         const uint32_t i_addr)
     {
         ScomAddr l_addr = i_addr;
-        l_addr.iv_chiplet = N3_CHIPLET - (2 * (i_target.getTargetNumber() / 2));
+        l_addr.iv_chiplet = i_target.getChipletNumber();
         l_addr.iv_satId = (2 * (i_target.getTargetNumber() % 2));
         return l_addr;
     }
diff --git a/hwpf/include/target_types.H b/hwpf/include/target_types.H
index 90b400b7..f2519eef 100644
--- a/hwpf/include/target_types.H
+++ b/hwpf/include/target_types.H
@@ -1,11 +1,11 @@
 /* IBM_PROLOG_BEGIN_TAG                                                   */
 /* This is an automatically generated prolog.                             */
 /*                                                                        */
-/* $Source: $                                                             */
+/* $Source: hwpf/include/target_types.H $                                 */
 /*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
+/* OpenPOWER sbe Project                                                  */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2016                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -55,7 +55,8 @@ namespace fapi2
         TARGET_TYPE_PERV              = 0x20,  ///< Pervasive type
         TARGET_TYPE_MCAST             = 0x40,  ///< Multicast type
         TARGET_TYPE_MI                = 0x80,  ///< MI type
-        TARGET_TYPE_SYSTEM            = 0x100, ///< System type
+        TARGET_TYPE_MCBIST            = 0x100, ///< MCBIST type
+        TARGET_TYPE_SYSTEM            = 0x400, ///< System type
         TARGET_TYPE_ALL               = 0xFFF, ///< Any/All types
 
         // The following are actually illegal targets on PPE platforms