Support getting FAPI Target type and instance

-- Use mirrored target_types.H

Change-Id: If6c30b2122980470f8a7a5acffcc59df9304e979
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/27592
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: Gregory S. Still <stillgs@us.ibm.com>
Reviewed-by: Sachin Gupta <sgupta2m@in.ibm.com>

3 files changed, 174 insertions, 11 deletions

diff --git a/hwpf/include/plat/plat_target.H b/hwpf/include/plat/plat_target.H
index 75e924ff..95a2282b 100644
--- a/hwpf/include/plat/plat_target.H
+++ b/hwpf/include/plat/plat_target.H
@@ -31,6 +31,8 @@
 #define __FAPI2_PLAT_TARGET__
 
 #include <stdint.h>
+#include <target_types.H>
+#include <assert.h>
 
 //
 // Define what a platform handle looks like. For Hostboot,
@@ -39,6 +41,20 @@
 //
 namespace fapi2
 {
+    typedef enum plat_target_type
+    {
+        PPE_TARGET_TYPE_NONE              = 0x00,
+        PPE_TARGET_TYPE_PROC_CHIP         = 0x01,
+        PPE_TARGET_TYPE_MCS               = 0x02,
+        PPE_TARGET_TYPE_CORE              = 0x04,
+        PPE_TARGET_TYPE_EQ                = 0x08,
+        PPE_TARGET_TYPE_EX                = 0x10,
+        PPE_TARGET_TYPE_PERV              = 0x20,
+        PPE_TARGET_TYPE_MCBIST            = 0x40,
+        PPE_TARGET_TYPE_SYSTEM            = 0x80,
+        PPE_TARGET_TYPE_ALL               = 0xFFF,
+    } plat_target_type_t;
+
     typedef union plat_target_handle {
         uint32_t value;
         struct {
@@ -62,6 +78,14 @@ namespace fapi2
         } fields;
         // Union Constructor
         plat_target_handle(uint32_t i_value = 0):value(i_value) {}
+
+
+        TargetType getFapiTargetType() const;
+
+        inline uint32_t getTargetInstance() const
+        {
+            return fields.type_target_num;
+        }
     } plat_target_handle_t;
 };
 
diff --git a/hwpf/include/plat/plat_target_filter.H b/hwpf/include/plat/plat_target_filter.H
new file mode 100644
index 00000000..1dc5a40e
--- /dev/null
+++ b/hwpf/include/plat/plat_target_filter.H
@@ -0,0 +1,90 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: hwpf/include/plat/plat_target_filter.H $                      */
+/*                                                                        */
+/* OpenPOWER sbe Project                                                  */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2016                             */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* Licensed under the Apache License, Version 2.0 (the "License");        */
+/* you may not use this file except in compliance with the License.       */
+/* You may obtain a copy of the License at                                */
+/*                                                                        */
+/*     http://www.apache.org/licenses/LICENSE-2.0                         */
+/*                                                                        */
+/* Unless required by applicable law or agreed to in writing, software    */
+/* distributed under the License is distributed on an "AS IS" BASIS,      */
+/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
+/* implied. See the License for the specific language governing           */
+/* permissions and limitations under the License.                         */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+#ifndef __FAPI2_PLAT_TARGET_FILTER__
+#define __FAPI2_PLAT_TARGET_FILTER__
+
+#include <stdint.h>
+
+//
+// Define TargetFilter enum values for the platform
+//
+namespace fapi2
+{
+namespace PlatTargetFilter
+{
+// These values must contain only 1 bit 'on' so that they can be ORed
+// together as composite filters
+
+constexpr uint64_t PLAT_TARGET_FILTER_TP          = 0x8000000000000000;  // Pervasive 1
+constexpr uint64_t PLAT_TARGET_FILTER_NEST_NORTH  = 0x4000000000000000;  // Pervasive 2
+constexpr uint64_t PLAT_TARGET_FILTER_NEST_EAST   = 0x2000000000000000;  // Pervasive 3
+constexpr uint64_t PLAT_TARGET_FILTER_NEST_SOUTH  = 0x1000000000000000;  // Pervasive 4
+constexpr uint64_t PLAT_TARGET_FILTER_NEST_WEST   = 0x0800000000000000;  // Pervasive 5
+constexpr uint64_t PLAT_TARGET_FILTER_XBUS        = 0x0400000000000000;  // Pervasive 6
+constexpr uint64_t PLAT_TARGET_FILTER_MC_WEST     = 0x0200000000000000;  // Pervasive 7
+constexpr uint64_t PLAT_TARGET_FILTER_MC_EAST     = 0x0100000000000000;  // Pervasive 8
+constexpr uint64_t PLAT_TARGET_FILTER_OBUS0       = 0x0080000000000000;  // Pervasive 9
+constexpr uint64_t PLAT_TARGET_FILTER_OBUS1       = 0x0040000000000000;  // Pervasive 10
+constexpr uint64_t PLAT_TARGET_FILTER_OBUS2       = 0x0020000000000000;  // Pervasive 11
+constexpr uint64_t PLAT_TARGET_FILTER_OBUS3       = 0x0010000000000000;  // Pervasive 12
+constexpr uint64_t PLAT_TARGET_FILTER_PCI0        = 0x0008000000000000;  // Pervasive 13
+constexpr uint64_t PLAT_TARGET_FILTER_PCI1        = 0x0004000000000000;  // Pervasive 14
+constexpr uint64_t PLAT_TARGET_FILTER_PCI2        = 0x0002000000000000;  // Pervasive 15
+constexpr uint64_t PLAT_TARGET_FILTER_CACHE0      = 0x0001000000000000;  // Pervasive 16
+constexpr uint64_t PLAT_TARGET_FILTER_CACHE1      = 0x0000800000000000;  // Pervasive 17
+constexpr uint64_t PLAT_TARGET_FILTER_CACHE2      = 0x0000400000000000;  // Pervasive 18
+constexpr uint64_t PLAT_TARGET_FILTER_CACHE3      = 0x0000200000000000;  // Pervasive 19
+constexpr uint64_t PLAT_TARGET_FILTER_CACHE4      = 0x0000100000000000;  // Pervasive 20
+constexpr uint64_t PLAT_TARGET_FILTER_CACHE5      = 0x0000080000000000;  // Pervasive 21
+constexpr uint64_t PLAT_TARGET_FILTER_CORE0       = 0x0000040000000000;  // Pervasive 32
+constexpr uint64_t PLAT_TARGET_FILTER_CORE1       = 0x0000020000000000;  // Pervasive 33
+constexpr uint64_t PLAT_TARGET_FILTER_CORE2       = 0x0000010000000000;  // Pervasive 34
+constexpr uint64_t PLAT_TARGET_FILTER_CORE3       = 0x0000008000000000;  // Pervasive 35
+constexpr uint64_t PLAT_TARGET_FILTER_CORE4       = 0x0000004000000000;  // Pervasive 36
+constexpr uint64_t PLAT_TARGET_FILTER_CORE5       = 0x0000002000000000;  // Pervasive 37
+constexpr uint64_t PLAT_TARGET_FILTER_CORE6       = 0x0000001000000000;  // Pervasive 38
+constexpr uint64_t PLAT_TARGET_FILTER_CORE7       = 0x0000000800000000;  // Pervasive 39
+constexpr uint64_t PLAT_TARGET_FILTER_CORE8       = 0x0000000400000000;  // Pervasive 40
+constexpr uint64_t PLAT_TARGET_FILTER_CORE9       = 0x0000000200000000;  // Pervasive 41
+constexpr uint64_t PLAT_TARGET_FILTER_CORE10      = 0x0000000100000000;  // Pervasive 42
+constexpr uint64_t PLAT_TARGET_FILTER_CORE11      = 0x0000000080000000;  // Pervasive 43
+constexpr uint64_t PLAT_TARGET_FILTER_CORE12      = 0x0000000040000000;  // Pervasive 44
+constexpr uint64_t PLAT_TARGET_FILTER_CORE13      = 0x0000000020000000;  // Pervasive 45
+constexpr uint64_t PLAT_TARGET_FILTER_CORE14      = 0x0000000010000000;  // Pervasive 46
+constexpr uint64_t PLAT_TARGET_FILTER_CORE15      = 0x0000000008000000;  // Pervasive 47
+constexpr uint64_t PLAT_TARGET_FILTER_CORE16      = 0x0000000004000000;  // Pervasive 48
+constexpr uint64_t PLAT_TARGET_FILTER_CORE17      = 0x0000000002000000;  // Pervasive 49
+constexpr uint64_t PLAT_TARGET_FILTER_CORE18      = 0x0000000001000000;  // Pervasive 50
+constexpr uint64_t PLAT_TARGET_FILTER_CORE19      = 0x0000000000800000;  // Pervasive 51
+constexpr uint64_t PLAT_TARGET_FILTER_CORE20      = 0x0000000000400000;  // Pervasive 52
+constexpr uint64_t PLAT_TARGET_FILTER_CORE21      = 0x0000000000200000;  // Pervasive 53
+constexpr uint64_t PLAT_TARGET_FILTER_CORE22      = 0x0000000000100000;  // Pervasive 54
+constexpr uint64_t PLAT_TARGET_FILTER_CORE23      = 0x0000000000080000;  // Pervasive 55
+
+} // namespace PlatTargetFilter
+
+} // namespace fapi2
+
+#endif
diff --git a/hwpf/include/plat/target.H b/hwpf/include/plat/target.H
index 0b7e9d89..f61e40dd 100644
--- a/hwpf/include/plat/target.H
+++ b/hwpf/include/plat/target.H
@@ -81,6 +81,55 @@ struct ScomAddr
 
 namespace fapi2
 {
+
+    template<TargetType T>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType()
+    {
+        return PPE_TARGET_TYPE_NONE;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_PROC_CHIP>()
+    {
+        return PPE_TARGET_TYPE_PROC_CHIP;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_EQ>()
+    {
+        return PPE_TARGET_TYPE_EQ;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_CORE>()
+    {
+        return PPE_TARGET_TYPE_CORE;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_EX>()
+    {
+        return PPE_TARGET_TYPE_EX;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_MCS>()
+    {
+        return PPE_TARGET_TYPE_MCS;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_MCBIST>()
+    {
+        return PPE_TARGET_TYPE_MCBIST;
+    }
+
+    template<>
+    constexpr plat_target_type_t fapiTargetTypeToPlatTargetType<TARGET_TYPE_PERV>()
+    {
+        return PPE_TARGET_TYPE_PERV;
+    }
+
     /// @brief Create a Target, with a value
     /// @param[in] Value the value (i.e., specific element this
     /// target represents, or pointer)
@@ -103,50 +152,50 @@ namespace fapi2
         if(K & TARGET_TYPE_PROC_CHIP)
         {
             this->iv_handle.fields.chiplet_num = 0;
-            this->iv_handle.fields.type = TARGET_TYPE_PROC_CHIP;
+            this->iv_handle.fields.type = PPE_TARGET_TYPE_PROC_CHIP;
             this->iv_handle.fields.type_target_num = 0;
         }
         else if(K & TARGET_TYPE_PERV)
         {
             this->iv_handle.fields.chiplet_num = l_plat_argument + NEST_GROUP1_CHIPLET_OFFSET;
-            this->iv_handle.fields.type = TARGET_TYPE_PERV;
+            this->iv_handle.fields.type = PPE_TARGET_TYPE_PERV;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
         else if(K & TARGET_TYPE_CORE)
         {
             this->iv_handle.fields.chiplet_num = l_plat_argument + CORE_CHIPLET_OFFSET;
-            this->iv_handle.fields.type = TARGET_TYPE_CORE | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type = PPE_TARGET_TYPE_CORE | PPE_TARGET_TYPE_PERV;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
         else if(K & TARGET_TYPE_EQ)
         {
             this->iv_handle.fields.chiplet_num = l_plat_argument + EQ_CHIPLET_OFFSET;
-            this->iv_handle.fields.type = TARGET_TYPE_EQ | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type = PPE_TARGET_TYPE_EQ | PPE_TARGET_TYPE_PERV;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
         else if(K & TARGET_TYPE_EX)
         {
             this->iv_handle.fields.chiplet_num = (l_plat_argument / 2) + EX_CHIPLET_OFFSET;
-            this->iv_handle.fields.type = TARGET_TYPE_EX;
+            this->iv_handle.fields.type = PPE_TARGET_TYPE_EX;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
         else if(K & TARGET_TYPE_MCBIST)
         {
 
             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 = PPE_TARGET_TYPE_MCBIST | PPE_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 = PPE_TARGET_TYPE_MCS;
             this->iv_handle.fields.type_target_num = l_plat_argument;
         }
         else if(K == TARGET_TYPE_ALL)
         {
             this->iv_handle.fields.chiplet_num = l_plat_argument;
-            this->iv_handle.fields.type = TARGET_TYPE_ALL;
+            this->iv_handle.fields.type = PPE_TARGET_TYPE_ALL;
         }
 
         this->iv_handle.fields.valid = 1;
@@ -365,12 +414,12 @@ namespace fapi2
     {
         std::vector<fapi2::plat_target_handle_t>::iterator l_iter;
         std::vector<Target<T> > l_children;
+        constexpr plat_target_type_t P = fapiTargetTypeToPlatTargetType<T>();
 
         for (l_iter = G_vec_targets.begin(); l_iter != G_vec_targets.end(); ++l_iter)
         {
-
             Target<T> * l_temp =  reinterpret_cast< Target<T>* >(l_iter);
-            if (((*l_temp).getTargetType() & T) == T)
+            if (((*l_temp).getTargetType() & P) == P)
             {
                 switch (i_state)
                 {
@@ -421,7 +470,7 @@ namespace fapi2
             {
                 plat_target_handle_t l_targetHandle = G_vec_targets.at(l_idx + NEST_GROUP1_CHIPLET_OFFSET);
 
-                if(l_targetHandle.fields.type & TARGET_TYPE_PERV) // Can be an assertion?
+                if(l_targetHandle.fields.type & PPE_TARGET_TYPE_PERV) // Can be an assertion?
                 {
                     switch (i_state)
                     {