Rearrange PPE FAPI2 directory structure to be more in-line with HWPF

- Move files into new structure
- Delete old, obsolete files and directories
- Pre-import mirror of HWPF into importtemp
- No additional function

Change-Id: Iadad6eb05349f807acea362ec77d7f58273878b5
Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/21150
Tested-by: Jenkins Server
Reviewed-by: Santosh S. Puranik <santosh.puranik@in.ibm.com>
Reviewed-by: Sachin Gupta <sgupta2m@in.ibm.com>
Reviewed-by: Martin Peschke <mpeschke@de.ibm.com>

14 files changed, 1753 insertions, 0 deletions

diff --git a/hwpf/include/plat/hw_access.H b/hwpf/include/plat/hw_access.H
new file mode 100644
index 00000000..047176a7
--- /dev/null
+++ b/hwpf/include/plat/hw_access.H
@@ -0,0 +1,606 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ *  @file hw_access.H
+ *
+ *  @brief Defines the hardware access functions for PPE platforms that
+ *  don't leverage FAPI2 return codes.
+ */
+
+#ifndef FAPI2_HWACCESS_H_
+#define FAPI2_HWACCESS_H_
+
+
+// variable_buffer isn't supported on PPE
+#ifndef __PPE__
+#include <variable_buffer.H>
+#endif
+
+#include <utils.H>
+#include <plat_hw_access.H>
+#include <fapi2_hw_access.H>
+
+namespace fapi2
+{
+
+    //--------------------------------------------------------------------------
+    // PIB Error Functions
+    //--------------------------------------------------------------------------
+
+    /// @brief Sets the PIB error mask - platform dependant
+    /// @param[in]  i_mask     The new error mask
+    void setPIBErrorMask(uint8_t i_mask)
+    {       
+        PLAT_SET_PIB_ERROR_MASK(i_mask);
+    }
+
+    /// @brief Gets the PIB error mask - platform dependant
+    /// @return uint8_t The current PIB error mask
+    uint8_t getPIBErrorMask(void)
+    {
+        PLAT_GET_PIB_ERROR_MASK(o_pib_mask);
+        return o_pib_mask;
+    }
+
+    //--------------------------------------------------------------------------
+    // Operational Mode Error Functions
+    //--------------------------------------------------------------------------
+
+    /// @brief Sets the operational mode
+    /// @param[in]  i_mode     The new mode
+    // note: this can be moved  to a C file if desired
+    inline void setOpMode(const OpModes i_mode)
+    {
+        // Keeps the compiler from complaining about the unused i_mode
+        static_cast<void>(i_mode);
+
+        // No-op for now. Should set thread-local operational mode
+        return;
+    }
+
+    /// @brief Gets the operational mode
+    /// @return the operational mode
+    // note: this can be moved  to a C file if desired
+    inline OpModes getOpMode(void)
+    {
+        // No-op for now. Should read thread-local operational mode
+        return NORMAL;
+    }
+
+    //--------------------------------------------------------------------------
+    // HW Communication Functions
+    //--------------------------------------------------------------------------
+
+    /// @brief Reads a SCOM register from a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]  i_target     HW target to operate on.
+    /// @param[in]  i_address    SCOM register address to read from.
+    /// @param[out] o_data       Buffer that holds data read from HW target.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline void getScom(const Target<K>& i_target, const uint64_t i_address,
+                       buffer<uint64_t>& o_data)
+    {
+
+        PLAT_GETSCOM(current_err,
+                     i_target,
+                    (uint32_t)(i_address ),
+                    &(o_data()));
+    }
+
+
+    /// @brief Writes a SCOM register on a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target     HW target to operate on.
+    /// @param[in] i_address    SCOM register address to write to.
+    /// @param[in] i_data       Buffer that holds data to write into address.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline void putScom(const Target<K>& i_target, const uint64_t i_address,
+                       buffer<uint64_t> i_data)
+    {
+
+        PLAT_PUTSCOM(current_err,
+                    i_target,
+                    (uint32_t)(i_address ),
+                    i_data());
+    }
+
+    /// @brief Read-modify-write a SCOM register on a chip
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target     HW target to operate on.
+    /// @param[in] i_address    SCOM register address to write to.
+    /// @param[in] i_data       Buffer that holds data to be modified.
+    /// @param[in] i_modifyMode The modify mode (or/and/xor).
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline void modifyScom( const Target<K>& i_target,
+                            const uint64_t i_address,
+                            const buffer<uint64_t> i_data,
+                            const ChipOpModifyMode i_modifyMode)
+    {
+        fapi2::buffer<uint64_t> l_modifyDataBuffer;
+        
+        PLAT_GETSCOM(current_err,
+                     i_target,
+                     (uint32_t)(i_address ),
+                     &(l_modifyDataBuffer()));
+
+        if ( i_modifyMode == CHIP_OP_MODIFY_MODE_OR)
+        {
+            l_modifyDataBuffer |= i_data;
+        }
+
+        if ( i_modifyMode == CHIP_OP_MODIFY_MODE_AND)
+        {
+            l_modifyDataBuffer &= i_data;
+        }
+
+        if ( i_modifyMode == CHIP_OP_MODIFY_MODE_XOR)
+        {
+            l_modifyDataBuffer ^= i_data;
+        }
+
+        PLAT_PUTSCOM(current_err,
+                     i_target,
+                     (uint32_t)(i_address ),
+                     l_modifyDataBuffer()); 
+        return;
+    }
+
+    /// @brief Writes a SCOM register under mask on a chip
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target     HW target to operate on.
+    /// @param[in] i_address    SCOM register address to write to.
+    /// @param[in] i_data       Buffer that holds data to write into address.
+    /// @param[in] i_mask       Buffer that holds the mask value.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline void putScomUnderMask(const Target<K>& i_target,
+                                 const uint64_t i_address,
+                                 buffer<uint64_t> i_data,
+                                 buffer<uint64_t> i_mask)
+    {
+        fapi2::buffer<uint64_t> l_modifyDataBuffer = i_data;
+
+        l_modifyDataBuffer &= i_mask;
+        
+        PLAT_PUTSCOM(current_err,
+                    i_target,
+                    (uint32_t)(i_address ),
+                    l_modifyDataBuffer());
+        return;
+    }
+          
+
+    /// @brief Reads a CFAM register from a chip.
+    ///        CFAM register is 32-bit wide.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]  i_target  HW target to operate on.
+    /// @param[in]  i_address CFAM register address to read from.
+    /// @param[out] o_data    Buffer that holds data read from HW target.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode getCfamRegister(const Target<K>& i_target,
+                               const uint32_t i_address,
+                               buffer<uint32_t>& o_data)
+    {
+        PLAT_GETCFAM(i_target.get(),
+                    (uint32_t)(i_address & BITS(40,24)),
+                    &(o_data()));
+
+        return FAPI2_RC_SUCCESS;
+    }
+
+    /// @brief Writes a CFAM register on a chip.
+    ///        CFAM register is 32-bit wide.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target  HW target to operate on.
+    /// @param[in] i_address CFAM register address to write to.
+    /// @param[in] i_data    Buffer that holds data to write into address.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode putCfamRegister(const Target<K>& i_target,
+                               const uint32_t i_address,
+                               buffer<uint32_t>& i_data)
+    {
+        PLAT_PUTCFAM(i_target.get(),
+                    (uint32_t)(i_address & BITS(40,24)),
+                    &(i_data()));
+
+        return FAPI2_RC_SUCCESS;
+    }
+
+    /// @brief Read-modify-write a CFAM register on a chip.
+    ///        CFAM register is 32-bit wide.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target     HW target to operate on.
+    /// @param[in] i_address    CFAM register address to modify.
+    /// @param[in] i_data       Buffer that holds data to be modified.
+    /// @param[in] i_modifyMode The modify mode (or/and/xor).
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode modifyCfamRegister(const Target<K>& i_target,
+                                         const uint32_t i_address,
+                                         const buffer<uint32_t>& i_data,
+                                         const ChipOpModifyMode i_modifyMode)
+    {
+        PLAT_MODCFAM(i_target.get(),
+                    (uint32_t)(i_address & BITS(40,24)),
+                    &(i_data()),
+                    i_modifyMode);
+
+        return FAPI2_RC_SUCCESS;
+    }
+
+    // variable_buffer isn't supported on PPE
+#ifndef __PPE__
+    /// @brief Reads a ring from a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]  i_target   Target to operate on.
+    /// @param[in]  i_address  Ring address to read from.
+    /// @param[out] o_data     Buffer that holds data read from HW target.
+    /// @param[in]  i_ringMode Ring operation mode.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode getRing(const Target<K>& i_target,
+                       const scanRingId_t i_address,
+                       variable_buffer& o_data,
+                       const RingMode i_ringMode = 0)
+    {
+        o_data.setBit(0);
+        o_data.setBit(3);
+#ifndef __PPE__
+        std::cout << std::hex << "   getRing "
+                  << "target: {" << i_target.getType() << ","
+                  << uint64_t(i_target) << "}; "
+                  << "ring address: " << i_address << "; "
+                  << "ring mode: " << i_ringMode << "; "
+                  << "output data:";
+                  o_data.print();
+#endif
+
+        return FAPI2_RC_SUCCESS;
+    }
+
+    /// @brief Writes a ring to a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target   Target to operate on.
+    /// @param[in] i_address  Ring address to write to.
+    /// @param[in] i_data     Buffer that contains RS4 compressed ring data
+    ///                       to write into address
+    /// @param[in] i_ringMode Ring operation mode.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode putRing(const Target<K>& i_target,
+                              const scanRingId_t i_address,
+                              variable_buffer& i_data,
+                              const RingMode i_ringMode = 0)
+    {
+
+        return FAPI2_RC_SUCCESS;
+    }
+
+
+    /// @brief Writes a ring to a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target   Target to operate on.
+    /// @param[in] i_address  Ring address to write to.
+    /// @param[in] i_data     Pointer to location that contains RS4 compressed
+    //  ring data to write into address
+    /// @param[in] i_ringMode Ring operation mode.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode putRing(const Target<K>& i_target,
+                              const scanRingId_t i_address,
+                              const void* i_data,
+                              const RingMode i_ringMode = 0)
+    {
+        uint64_t* dataPtr =   reinterpret_cast<uint64_t*>(const_cast<void*>(i_data));
+
+       return FAPI2_RC_SUCCESS;
+    }
+
+    /// @brief Read-modify-write a ring on a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in] i_target     Target to operate on.
+    /// @param[in] i_address    Ring address to modify.
+    /// @param[in] i_data       Buffer that contains RS4 compressed ring data
+    ///                         to be modified.
+    /// @param[in] i_modifyMode The modify mode (or/and/xor)
+    /// @param[in] i_ringMode   Ring operation mode.
+    /// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    template< TargetType K >
+    inline ReturnCode modifyRing(const Target<K>& i_target,
+                                 const scanRingId_t i_address,
+                                 variable_buffer& i_data,
+                                 const ChipOpModifyMode i_modifyMode,
+                                 const RingMode i_ringMode = 0)
+    {
+
+        return FAPI2_RC_SUCCESS;
+    }
+#endif
+
+
+#ifdef FAPI_SUPPORT_MULTI_SCOM
+    /// @brief Performs a multiple SCOM operation
+    ///        This interface performs multiple SCOM operations on a chip in the
+    ///        order specified by the input MultiScom object.
+    ///        See fapiMultiScom.H for details of how to populate the MultiScom
+    ///        object with SCOM operations.
+    ///
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]     i_target Target to operate on.
+    /// @param[in,out] io_multiScomObj Reference to a MultiScom object,
+    ///                                pre-populated with SingleScomInfo entries
+    ///                                to perform multiple SCOMs on input target
+    /// @return fapi2::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    ///
+    /// @note   This is a synchronous interface and would return after all the
+    ///         SCOM operations are completed or on the first failed operation
+    ///
+    /// @note   SCOMs will be performed in the order they were added to the
+    ///         input MultiScom object
+    ///
+    /// @note   In case of errors, the platform code is responsible to collect
+    ///         and add all the required error info and FFDC into the error data
+    ///         for debugging
+    ///
+    /// @note   If the SCOM operations added are specific to a processor chip,
+    ///         then the FSI Shift Engine configured in scatter-gather DMA mode
+    ///         extension would be used to execute the SCOM operations in a
+    ///         performance optimize mode. In this mode, the special
+    ///         SCOM_BULK_READ_MODE and SCOM_BULK_WRITE_MODE operations are
+    ///         supported that allow a large bulk of SCOM access (in multiple of
+    ///         64 bits) for targets that support auto-increment. The
+    ///         SCOM_WRITE_UNDER_MASK operation is not supported in this mode
+    ///
+    /// @note   If the SCOM operations added are specific to a memory buffer
+    ///         chip, then the regular SCOM engine is used to execute the SCOM
+    ///         operations. SCOM_WRITE_UNDER_MASK operation is supported in
+    ///         this mode, but the special SCOM_BULK_READ_MODE and
+    ///         SCOM_BULK_WRITE_MODE operations are not supported due to
+    ///         hardware limitations.
+    ///
+    template< TargetType K >
+    fapi2::ReturnCode multiScom (const Target<K>& i_target,
+                                 MultiScom&  io_multiScomObj)
+    {
+    }
+#endif
+
+    // --------------------------------------------------------------------------
+    // NOTE:
+    // Implement platform Spy access functions if platform supports them.
+    // --------------------------------------------------------------------------
+
+    // variable_buffer isn't supported on PPE
+#ifndef __PPE__
+    /// @brief Reads a spy from a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]  i_target   Target to operate on.
+    /// @param[in]  i_spyId    Id of the spy whose data to be read.
+    /// @param[out] o_data     Buffer that holds data read from HW target.
+    /// @return fapi2::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    ///
+    /// @note:  The string version is only supported for cronus.
+    ///
+    ///         The fapi design to support both FSP and cronus use of get and
+    ///         put spy functions is dependant on the SPY names being expanded
+    ///         to resemble a valid C identifier. This design places some
+    ///         restrictions on the SPY names which can be used.
+    ///
+    ///         1. if the spy name contains a # procedure writers should replace
+    ///         it with an __P__ for example -
+    ///
+    ///         ABUS.RX0.RXPACKS#0.RXPACK.RD.LC.LC.ACT_DIS
+    ///         becomes
+    ///         ABUS.RX0.RXPACKS__P__0.RXPACK.RD.LC.LC.ACT_DIS
+    ///
+    ///         2. if the spy name has a number following a "." it must have an
+    ///         underscore prepended to the number.
+    ///
+    ///         EH.TPCHIP.2KX100_ARY_CLK_EDGES_DLY
+    ///         becomes
+    ///         EH.TPCHIP._2KX100_ARY_CLK_EDGES_DLY
+    ///
+    ///         Example SPY name:
+    ///         The hardware procedure should call the function like:
+    ///
+    ///          ABUS.RX0.RXPACKS#0.RXPACK.RD.LC.LC.ACT_DIS
+    ///
+    ///          fapi2::ReturnCode rc = fapiGetSpy( targ,
+    ///                  ABUS.RX0.RXPACKS__P__0.RXPACK.RD.LC.LC.ACT_DIS, data );
+    ///
+    /// @note The ID is not in quotes the fapi code will handle adding
+    ///       the quotes for the cronus environment
+    ///
+#ifdef FAPI_SUPPORT_SPY_AS_ENUM
+    template< TargetType K >
+    inline ReturnCode getSpy(const Target<K>& i_target,
+                             const spyId_t i_spyId,
+                             variable_buffer& o_data)
+    {
+        static_assert(K == 0, "implement getSpy (string)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+#ifdef FAPI_SUPPORT_SPY_AS_STRING
+    template< TargetType K >
+    inline ReturnCode getSpy(const Target<K>& i_target,
+                             const char * const i_spyId,
+                             variable_buffer& o_data)
+    {
+        static_assert(K == 0, "implement getSpy (string)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+    /// @brief Writes a spy on a chip.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]  i_target   Target to operate on.
+    /// @param[in]  i_spyId    Id of the spy to write data to.
+    /// @param[out] i_data     Buffer that holds data to write into spy.
+    /// @return fapi2::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    ///
+    /// @note:  The string version is only supported for cronus.
+    ///
+    ///         The fapi design to support both FSP and cronus use of get and
+    ///         put spy functions is dependent on the SPY names being expanded
+    ///         to resemble a valid C identifier. This design places some
+    ///         restrictions on the SPY names which can be used.
+    ///
+    ///         1. if the spy name contains a # procedure writers should replace
+    ///         is with an __P__ for example -
+    ///
+    ///         ABUS.RX0.RXPACKS#0.RXPACK.RD.LC.LC.ACT_DIS
+    ///         becomes
+    ///         ABUS.RX0.RXPACKS__P__0.RXPACK.RD.LC.LC.ACT_DIS
+    ///
+    ///         2. if the spy name has a number following a "." it must have an
+    ///         underscore prepended to the number.
+    ///
+    ///         EH.TPCHIP.2KX100_ARY_CLK_EDGES_DLY
+    ///         becomes
+    ///         EH.TPCHIP._2KX100_ARY_CLK_EDGES_DLY
+    ///
+    ///         Example SPY name:
+    ///         The hardware procedure should call the function like:
+    ///
+    ///          ABUS.RX0.RXPACKS#0.RXPACK.RD.LC.LC.ACT_DIS
+    ///
+    ///          fapi2::ReturnCode rc = fapiPutSpy( targ,
+    ///                  ABUS.RX0.RXPACKS__P__0.RXPACK.RD.LC.LC.ACT_DIS, data );
+    ///
+    /// @note The ID is not in quotes the fapi code will handle adding
+    ///         the quotes for the cronus environment
+    ///
+#ifdef FAPI_SUPPORT_SPY_AS_ENUM
+    template< TargetType K >
+    inline ReturnCode putSpy(const Target<K>& i_target,
+                             const spyId_t i_spyId,
+                             variable_buffer& i_data)
+    {
+        static_assert(K == 0, "implement putSpy (enum)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+#ifdef FAPI_SUPPORT_SPY_AS_STRING
+    template< TargetType K >
+    inline ReturnCode putSpy(const Target<K>& i_target,
+                             const char* const i_spyId,
+                             variable_buffer& i_data)
+    {
+        static_assert(K == 0, "implement putSpy (string)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+    /// @brief Writes spy data into a buffer holding ring data image
+    ///        This API is used by L2/L3 repair to put column repair data
+    ///        into a ring buffer image.
+    /// @tparam K template parameter, passed in target.
+    /// @param[in]  i_target Target to operate on.
+    /// @param[in]  i_spyId  Id of the spy.
+    /// @param[in]  i_data   Buffer that holds spy data to write into ring
+    ///                      image.
+    /// @param[out] o_data   Buffer that holds updated ring image.
+    /// @return fapi2::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    ///
+    /// @note:  The string version is only supported for cronus.
+    ///
+    ///         The fapi design to support both FSP and cronus use of get and
+    ///         put spy functions is dependent on the SPY names being expanded
+    ///         to resemble a valid C identifier. This design places some
+    ///         restrictions on the SPY names which can be used.
+    ///
+    ///         See fapiPutSpy for details on spy id specifics.
+    ///
+#ifdef FAPI_SUPPORT_SPY_AS_ENUM
+    template< TargetType K >
+    inline ReturnCode putSpyImage(const Target<K>& i_target,
+                                  const spyId_t i_spyId,
+                                  const variable_buffer& i_data,
+                                  variable_buffer& o_imageData)
+    {
+        static_assert(K == 0, "implement putSpyImage (enum)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+#ifdef FAPI_SUPPORT_SPY_AS_STRING
+    template< TargetType K >
+    inline ReturnCode putSpyImage(const Target<K>& i_target,
+                                  const char* const i_spyId,
+                                  const variable_buffer& i_data,
+                                  variable_buffer& o_imageData)
+    {
+        static_assert(K == 0, "implement putSpyImage (string)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+    /// @brief Reads spy data from a ring image buffer
+    /// @param[in]   i_target      Target to operate on
+    /// @param[in]   i_spyId       The spy's id
+    /// @param[out]  o_data        Buffer that holds data read from ring image.
+    /// @param[in]   i_imageData   Buffer that holds ring image to read data
+    ///                            from.
+    /// @return fapi2::ReturnCode. FAPI2_RC_SUCCESS if success, else error code.
+    ///
+    /// @note:  The string version is only supported for cronus.
+    ///
+    ///         The fapi design to support both FSP and cronus use of get and
+    ///         put spy functions is dependent on the SPY names being expanded
+    ///         to resemble a valid C identifier. This design places some
+    ///         restrictions on the SPY names which can be used.
+    ///
+    ///         See fapiPutSpy for details on spy id specifics.
+    ///
+#ifdef FAPI_SUPPORT_SPY_AS_ENUM
+    template< TargetType K >
+    inline ReturnCode getSpyImage(const Target<K>& i_target,
+                                  const spyId_t i_spyId,
+                                  variable_buffer& o_data,
+                                  const variable_buffer& i_imageData)
+    {
+        static_assert(K == 0, "implement getSpyImage (enum)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+#ifdef FAPI_SUPPORT_SPY_AS_STRING
+    template< TargetType K >
+    inline ReturnCode getSpyImage(const Target<K>& i_target,
+                                  const char * const i_spyId,
+                                  variable_buffer& o_data,
+                                  const variable_buffer& i_imageData)
+    {
+        static_assert(K == 0, "implement getSpyImage (string)");
+        return ~FAPI2_RC_SUCCESS;
+    }
+#endif
+
+#endif // PPE
+
+};
+
+#endif // _FAPI2_HWACCESS_H_
diff --git a/hwpf/include/plat/hwp_executor.H b/hwpf/include/plat/hwp_executor.H
new file mode 100644
index 00000000..5a451081
--- /dev/null
+++ b/hwpf/include/plat/hwp_executor.H
@@ -0,0 +1,59 @@
+// IBM_PROLOG_BEGIN_TAG 
+// This is an automatically generated prolog. 
+//  
+// fipsrefactordoc src/hwpf/plat/fapi2PlatHwpExecutor.H 1.1 
+//  
+// IBM CONFIDENTIAL 
+//  
+// OBJECT CODE ONLY SOURCE MATERIALS 
+//  
+// COPYRIGHT International Business Machines Corp. 2011 
+// All Rights Reserved 
+//  
+// 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. 
+//  
+// IBM_PROLOG_END_TAG 
+/**
+ *  @file fapi2PlatHwpExecutor.H
+ *
+ *  @brief Defines the FAPI HWP Executor Macro.
+ *
+ *  The HWP Executor macro is called when a PLAT invoker function or a HWP wants
+ *  to execute a HWP. Each platform can modify the macro to do any platform
+ *  specific work to execute the HWP (e.g. dlopening a shared library)
+ */
+
+#ifndef FAPI2PLATHWPEXECUTOR_H_
+#define FAPI2PLATHWPEXECUTOR_H_
+
+/**
+ * @brief HWP Executor macro
+ *
+ * By default, this macro just calls the HWP directly. If this cannot be done
+ * then the platform needs to modify
+ */
+
+#include <return_code.H>
+#include <target.H>
+#include <string>
+
+
+
+// Macro to execute an arbitrary function with an arbitray number of arguments. The
+// function is in a shared lib that must be dlopened. All that is required is that
+// there is a typedef for the function pointer available that is called <FUNC>_FP_t
+// i.e. if the function is called foo, then the typedef is called foo_FP_t
+#define FAPI_PLAT_EXEC_HWP(RC, FUNC, _args_...) \
+{\
+    RC = FUNC(_args_); \
+}
+
+#define FAPI_PLAT_EXEC_HWP_LAMBDA(FUNC, _args_...) \
+[&]()->fapi2::ReturnCode \
+{\
+    FUNC(_args_); \
+}()
+
+#endif // FAPI2PLATHWPEXECUTOR_H_
diff --git a/hwpf/include/plat/plat_attributes.H b/hwpf/include/plat/plat_attributes.H
new file mode 100644
index 00000000..894d516d
--- /dev/null
+++ b/hwpf/include/plat/plat_attributes.H
@@ -0,0 +1,37 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_attributes.H
+ * @brief Platform specific attribute headers
+ */
+
+#ifndef __PLAT_ATTTRIBUTE_H__
+#define __PLAT_ATTTRIBUTE_H__
+
+#include <fapi2AttributeService.H>
+#include <fapi2AttributeIds.H>      // Generated file
+//#include <plat_target_pg_attributes.H>
+
+#endif  // __PLAT_ATTTRIBUTE_H__
diff --git a/hwpf/include/plat/plat_error_scope.H b/hwpf/include/plat/plat_error_scope.H
new file mode 100644
index 00000000..a2de6bd5
--- /dev/null
+++ b/hwpf/include/plat/plat_error_scope.H
@@ -0,0 +1,65 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_error_scope.H
+ * @brief platform definitions which create a scope for automatic error handling
+ */
+
+#ifndef __FAPI2_PLAT_ERROR_SCOPE__
+#define __FAPI2_PLAT_ERROR_SCOPE__
+
+/// @cond
+#define PLAT_FAPI_TRY_NO_TRACE( __operation__ )                         \
+    (__operation__) 
+
+#define PLAT_FAPI_TRY_TRACE( __operation__, ... )                       \
+    FAPI_DBG(__VA_ARGS));                                               \
+    (__operation__) 
+    
+///
+/// @brief Assert a conditional is true.
+/// If it is not, the FFDC gathering function is called and the
+/// trace is output as a FAPI error trace.
+/// @param[in] __conditional__ the condition to assert
+/// @param[in] __ffdc__ the FFDC gathering function
+/// @param[in] ... varargs, as input to FAPI_ERR
+///
+#define PLAT_FAPI_ASSERT( __conditional__, __ffdc__, ... )      \
+    if (! (__conditional__))                                    \
+    {                                                           \
+        (__ffdc__).execute();                                   \
+        FAPI_ERR(__VA_ARGS__);                                  \
+        goto fapi_try_exit;                                     \
+    }
+    
+    
+///
+/// @brief Temporary macro for error label until all are removed.
+/// @todo REMOVE this in time.
+#define FAPI_CLEANUP()   \
+fapi_try_exit:
+/// @endcond
+
+#endif
diff --git a/hwpf/include/plat/plat_hw_access.H b/hwpf/include/plat/plat_hw_access.H
new file mode 100644
index 00000000..7d8e3c86
--- /dev/null
+++ b/hwpf/include/plat/plat_hw_access.H
@@ -0,0 +1,78 @@
+/**
+ *  @file plat_hw_access.H
+ *
+ *  @brief Define platform specific calls for PPE Platforms that use the machine
+ *  check function of the PPE to deal with errors (eg no explicit return codes
+ *  returned)
+ */
+
+#ifndef PLATHWACCESS_H_
+#define PLATHWACCESS_H_
+
+#include <plat_includes.H>
+
+/// PIB Error Mask
+
+#define PLAT_SET_PIB_ERROR_MASK(_m_mask) \
+    {   /*  Read MSR */ \
+        uint32_t msr_data = mfmsr(); \
+        /* Set SEM field */ \
+        msr_data &= ~(BITS(0,8)); \
+        msr_data |= (uint32_t)(i_mask << 24); \
+        /* Write MSR */ \
+        mtmsr(msr_data); \
+    };
+    
+#define PLAT_GET_PIB_ERROR_MASK(_m_mask) \
+        uint8_t _m_mask; \
+        uint32_t _sem = mfmsr(); \
+        _m_mask = (uint8_t)((_sem & MSR_SEM) >> (32-(MSR_SEM_START_BIT + MSR_SEM_LEN)));
+        
+// Building block PPE instructions
+#define PPE_MFMSR(_m_data) \
+asm volatile \
+    ( \
+    "mfmsr %[data] \n" \
+    :  [data]"=&r"(*_m_data) \
+    :  "[data]"(*_m_data) \
+    );
+
+#define PPE_MTMSR(_m_data) \
+asm volatile \
+    ( \
+    "mtmsr %[data] \n" \
+    :  [data]"=&r"(*_m_data) \
+    :  "[data]"(*_m_data) \
+    );
+
+
+/// GetScom   
+#define PLAT_GETSCOM(_m_rc, _m_base, _m_offset, _m_data) \
+    PPE_LVDX(_m_base.getAddressOverlay(), (uint32_t)(_m_offset & BITS(40,24)), _m_data)
+    
+/// PutScom
+#define PLAT_PUTSCOM(_m_rc, _m_base, _m_offset, _m_data) \
+    PPE_STVDX(_m_base.getAddressOverlay(), (uint32_t)(_m_offset & BITS(40,24)), _m_data)
+    
+/// ModifyScom
+#define PLAT_MODSCOM(_m_base, _m_offset, _m_data, _m_mode) \
+    PPE_STVDX(_m_base.getAddressOverlay(), _m_offset, _m_data)
+
+
+/// GetCFAM  
+#define PLAT_GETCFAM(_m_base, _m_offset, _m_data) \
+    static_assert( K == TARGET_TYPE_NONE, \
+                  "getCfamRegister is not supported by PPE platforms")
+
+/// PutCFAM
+#define PLAT_PUTCFAM(_m_base, _m_offset, _m_data) \
+     static_assert( K == TARGET_TYPE_NONE, \
+                  "putCfamRegister is not supported by PPE platforms")
+                  
+/// ModifyCFAM
+#define PLAT_MODCFAM(_m_base, _m_offset, _m_data, _m_mode) \
+     static_assert( K == TARGET_TYPE_NONE, \
+                  "modifyCfamRegister is not supported by PPE platforms")
+
+#endif // PLATHWACCESS_H_
+
diff --git a/hwpf/include/plat/plat_includes.H b/hwpf/include/plat/plat_includes.H
new file mode 100644
index 00000000..97074b67
--- /dev/null
+++ b/hwpf/include/plat/plat_includes.H
@@ -0,0 +1,40 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_includes.H
+ * @brief Platform specific include to implement FAPI2 APIs
+ */
+
+#ifndef __PLAT_INCLUDES_H__
+#define __PLAT_INCLUDES_H__
+
+#include <plat_hw_access.H>
+
+#include <ppe42_scom.h>
+#include <ppe42_msr.h>
+//#include <pk.h>
+
+
+#endif  // __PLAT_INCLUDES_H__
diff --git a/hwpf/include/plat/plat_target.H b/hwpf/include/plat/plat_target.H
new file mode 100644
index 00000000..3e28c1da
--- /dev/null
+++ b/hwpf/include/plat/plat_target.H
@@ -0,0 +1,39 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: hwpf/fapi2/include/plat_target.H $                            */
+/*                                                                        */
+/* IBM CONFIDENTIAL                                                       */
+/*                                                                        */
+/* EKB Project                                                            */
+/*                                                                        */
+/* COPYRIGHT 2012,2015                                                    */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* 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.                              */
+/*                                                                        */
+/* IBM_PROLOG_END_TAG                                                     */
+/**
+ * @file plat_target.H
+ * @brief platform definitions for fapi2 targets
+ */
+
+#ifndef __FAPI2_PLAT_TARGET__
+#define __FAPI2_PLAT_TARGET__
+
+#include <stdint.h>
+
+//
+// Define what a platform handle looks like. For Hostboot,
+// for example, this might be a void*. For the SBE, this
+// will be a uint64_t ...
+//
+namespace fapi2
+{
+typedef uint64_t plat_target_handle_t;
+}
+
+#endif
diff --git a/hwpf/include/plat/plat_target_definitions.H b/hwpf/include/plat/plat_target_definitions.H
new file mode 100644
index 00000000..c2ec0518
--- /dev/null
+++ b/hwpf/include/plat/plat_target_definitions.H
@@ -0,0 +1,112 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_ppe_target.H
+ * @brief Definitions for fapi2 PPE targets
+ */
+
+#ifndef __FAPI2_PPE_TARGET__
+#define __FAPI2_PPE_TARGET__
+
+#define TARGET_CHIP(_name, _index) \
+            fapi2::Target<fapi2::TARGET_TYPE_PROC_CHIP > _name((uint64_t)_index);
+
+#define TARGET_CHIP_PERV(_name, _index) \
+            fapi2::Target<fapi2::TARGET_TYPE_PERV> _name((uint64_t)_index);
+
+#define TARGET_EQ(_name, _index) \
+            fapi2::Target<fapi2::TARGET_TYPE_EQ> _name((uint64_t)_index);
+
+#define TARGET_CORE(_name, _index) \
+            fapi2::Target<fapi2::TARGET_TYPE_CORE> _name((uint64_t)_index);
+            
+#define TARGET_EX(_name, _index) \
+            fapi2::Target<fapi2::TARGET_TYPE_EX> _name((uint64_t)_index);
+
+namespace fapi2 
+{
+
+           TARGET_CHIP         (chip_target,   0);       
+           TARGET_CHIP_PERV    (perv_target,   1);
+           TARGET_CHIP_PERV    (n0_target,     2);
+           TARGET_CHIP_PERV    (n1_target,     3);
+           TARGET_CHIP_PERV    (n2_target,     4);
+           TARGET_CHIP_PERV    (n3_target,     5);
+           TARGET_CHIP_PERV    (xb_target,     6);
+           TARGET_CHIP_PERV    (mc0_target,    7);
+           TARGET_CHIP_PERV    (mc1_target,    8);
+           TARGET_CHIP_PERV    (ob0_target,    9);
+           TARGET_CHIP_PERV    (ob1_target,   10);
+           TARGET_CHIP_PERV    (ob2_target,   11);
+           TARGET_CHIP_PERV    (ob3_target,   12);
+           TARGET_CHIP_PERV    (pci0_target,  13);
+           TARGET_CHIP_PERV    (pci1_target,  14);  
+           TARGET_CHIP_PERV    (pci2_target,  15);
+           TARGET_EQ           (eq0_target,    0); 
+           TARGET_EQ           (eq1_target,    1);  
+           TARGET_EQ           (eq2_target,    2); 
+           TARGET_EQ           (eq3_target,    3);  
+           TARGET_EQ           (eq4_target,    4); 
+           TARGET_EQ           (eq5_target,    5);   
+           TARGET_EX           (ex0_target,    0);                
+           TARGET_EX           (ex1_target,    1);                
+           TARGET_EX           (ex2_target,    2);                
+           TARGET_EX           (ex3_target,    3);                
+           TARGET_EX           (ex4_target,    4);                
+           TARGET_EX           (ex5_target,    5);                
+           TARGET_EX           (ex6_target,    6);                
+           TARGET_EX           (ex7_target,    7);                
+           TARGET_EX           (ex8_target,    8);                
+           TARGET_EX           (ex9_target,    9);                
+           TARGET_EX           (ex10_target,  10);                
+           TARGET_EX           (ex11_target,  11);                
+           TARGET_CORE         (core0_target,  0);
+           TARGET_CORE         (core1_target,  1);
+           TARGET_CORE         (core2_target,  2);
+           TARGET_CORE         (core3_target,  3);
+           TARGET_CORE         (core4_target,  4);
+           TARGET_CORE         (core5_target,  5);
+           TARGET_CORE         (core6_target,  6);
+           TARGET_CORE         (core7_target,  7);
+           TARGET_CORE         (core8_target,  8);
+           TARGET_CORE         (core9_target,  9);
+           TARGET_CORE         (core10_target,10);
+           TARGET_CORE         (core11_target,11);
+           TARGET_CORE         (core12_target,12);
+           TARGET_CORE         (core13_target,13);
+           TARGET_CORE         (core14_target,14);
+           TARGET_CORE         (core15_target,15);
+           TARGET_CORE         (core16_target,16);
+           TARGET_CORE         (core17_target,17);
+           TARGET_CORE         (core18_target,18);
+           TARGET_CORE         (core19_target,19);
+           TARGET_CORE         (core20_target,20);
+           TARGET_CORE         (core21_target,21);
+           TARGET_CORE         (core22_target,22);
+           TARGET_CORE         (core23_target,23); 
+
+};  // fapi2 namespace
+
+#endif  // __FAPI2_PPE_TARGET__
diff --git a/hwpf/include/plat/plat_target_parms.H b/hwpf/include/plat/plat_target_parms.H
new file mode 100644
index 00000000..0c6c5c67
--- /dev/null
+++ b/hwpf/include/plat/plat_target_parms.H
@@ -0,0 +1,133 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_ppe_target.H
+ * @brief Definitions for fapi2 PPE targets
+ */
+
+#ifndef __FAPI2_PPE_TARGET_PARMS__
+#define __FAPI2_PPE_TARGET_PARMS__
+
+#include "fapi_sbe_common.H"
+
+
+CONST_UINT32_T(CHIP_TARGET_OFFSET,      0);
+CONST_UINT32_T(CHIP_TARGET_COUNT ,      1);
+
+// Pervasive Targets (note; these include the MCS targets as well)
+CONST_UINT32_T(PERV_TARGET_OFFSET, CHIP_TARGET_OFFSET + CHIP_TARGET_COUNT);
+CONST_UINT32_T(PERV_CHIPLET_OFFSET,     0x1);
+CONST_UINT32_T(PERV_TARGET_COUNT,       15);
+
+// Cache Targets
+CONST_UINT32_T(EQ_TARGET_OFFSET, PERV_TARGET_OFFSET + PERV_TARGET_COUNT);
+CONST_UINT32_T(EQ_CHIPLET_OFFSET,       0x10);
+CONST_UINT32_T(EQ_TARGET_COUNT,         6);
+
+// Core Targets
+CONST_UINT32_T(CORE_TARGET_OFFSET, EQ_TARGET_OFFSET + EQ_TARGET_COUNT);
+CONST_UINT32_T(CORE_CHIPLET_OFFSET,     0x20);
+CONST_UINT32_T(CORE_TARGET_COUNT,       24);
+
+// MCS Targets (note: these are phyically Pervasive targets)
+CONST_UINT32_T(MCS_TARGET_OFFSET, CORE_TARGET_OFFSET + CORE_TARGET_COUNT);
+CONST_UINT32_T(MCS_CHIPLET_OFFSET,      0x7);
+CONST_UINT32_T(MCS_TARGET_COUNT,        2);
+
+CONST_UINT32_T(EX_TARGET_OFFSET, MCS_TARGET_OFFSET + MCS_TARGET_COUNT);
+CONST_UINT32_T(EX_CHIPLET_OFFSET,       0x10);
+CONST_UINT32_T(EX_TARGET_COUNT,         12);
+
+CONST_UINT32_T(SYSTEM_TARGET_OFFSET, EX_TARGET_OFFSET + EX_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,    0);
+CONST_UINT32_T(MCAST_TARGET_COUNT,      7);  // 0 - 6
+
+// Total Target Count
+CONST_UINT32_T(TARGET_COUNT,            CHIP_TARGET_COUNT +
+                                        PERV_TARGET_COUNT +
+                                        EQ_TARGET_COUNT +
+                                        CORE_TARGET_COUNT +
+                                        MCS_TARGET_COUNT +
+                                        EX_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/plat_target_pg_attributes.H b/hwpf/include/plat/plat_target_pg_attributes.H
new file mode 100644
index 00000000..e27a1784
--- /dev/null
+++ b/hwpf/include/plat/plat_target_pg_attributes.H
@@ -0,0 +1,97 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_target_pg_attribute.H
+ * @brief Definitions for fapi2 PPE targets' partial good attribute mapping
+ */
+
+#ifndef __FAPI2_PPE_TARGET_PG_ATTR__
+#define __FAPI2_PPE_TARGET_PG_ATTR__
+
+
+typedef struct chiplet_pg_entry_t
+{
+    // char[16]  pg_attribute;
+    uint32_t  pg_attribute;
+    uint8_t   target_type;
+    uint16_t  relative_target_num;
+} chiplet_pg_entry_t;
+
+const chiplet_pg_entry_t CHIPLET_PG_ARRAY[] =
+{
+     // Pervasive Chiplets
+     { fapi2::ATTR_PG_PRV , fapi2::TARGET_TYPE_PERV,      0x01 },
+     { fapi2::ATTR_PG_N0  , fapi2::TARGET_TYPE_PERV,      0x02 },
+     { fapi2::ATTR_PG_N1  , fapi2::TARGET_TYPE_PERV,      0x03 },
+     { fapi2::ATTR_PG_N2  , fapi2::TARGET_TYPE_PERV,      0x04 },
+     { fapi2::ATTR_PG_N3  , fapi2::TARGET_TYPE_PERV,      0x05 },
+     { fapi2::ATTR_PG_XB  , fapi2::TARGET_TYPE_PERV,      0x06 },
+     { fapi2::ATTR_PG_MC01, fapi2::TARGET_TYPE_PERV,      0x07 },
+     { fapi2::ATTR_PG_MC23, fapi2::TARGET_TYPE_PERV,      0x08 },
+     { fapi2::ATTR_PG_OB0 , fapi2::TARGET_TYPE_PERV,      0x09 },
+     { fapi2::ATTR_PG_OB1 , fapi2::TARGET_TYPE_PERV,      0x0A },
+     { fapi2::ATTR_PG_OB2 , fapi2::TARGET_TYPE_PERV,      0x0B },
+     { fapi2::ATTR_PG_OB3 , fapi2::TARGET_TYPE_PERV,      0x0C },
+     { fapi2::ATTR_PG_PCI0, fapi2::TARGET_TYPE_PERV,      0x0D },
+     { fapi2::ATTR_PG_PCI1, fapi2::TARGET_TYPE_PERV,      0x0E },
+     { fapi2::ATTR_PG_PCI2, fapi2::TARGET_TYPE_PERV,      0x0F },
+     // EQ Chiplets
+     { fapi2::ATTR_PG_EQ0 , fapi2::TARGET_TYPE_EQ,        0x00 },
+     { fapi2::ATTR_PG_EQ1 , fapi2::TARGET_TYPE_EQ,        0x01 },
+     { fapi2::ATTR_PG_EQ2 , fapi2::TARGET_TYPE_EQ,        0x02 },
+     { fapi2::ATTR_PG_EQ3 , fapi2::TARGET_TYPE_EQ,        0x03 },
+     { fapi2::ATTR_PG_EQ4 , fapi2::TARGET_TYPE_EQ,        0x04 },
+     { fapi2::ATTR_PG_EQ5 , fapi2::TARGET_TYPE_EQ,        0x05 },
+     // Core Chiplets
+     { fapi2::ATTR_PG_EC00, fapi2::TARGET_TYPE_CORE,      0x00 },
+     { fapi2::ATTR_PG_EC01, fapi2::TARGET_TYPE_CORE,      0x01 },
+     { fapi2::ATTR_PG_EC02, fapi2::TARGET_TYPE_CORE,      0x02 },
+     { fapi2::ATTR_PG_EC03, fapi2::TARGET_TYPE_CORE,      0x03 },
+     { fapi2::ATTR_PG_EC04, fapi2::TARGET_TYPE_CORE,      0x04 },
+     { fapi2::ATTR_PG_EC05, fapi2::TARGET_TYPE_CORE,      0x05 },
+     { fapi2::ATTR_PG_EC06, fapi2::TARGET_TYPE_CORE,      0x06 },
+     { fapi2::ATTR_PG_EC07, fapi2::TARGET_TYPE_CORE,      0x07 },
+     { fapi2::ATTR_PG_EC08, fapi2::TARGET_TYPE_CORE,      0x08 },
+     { fapi2::ATTR_PG_EC09, fapi2::TARGET_TYPE_CORE,      0x09 },
+     { fapi2::ATTR_PG_EC10, fapi2::TARGET_TYPE_CORE,      0x0A },
+     { fapi2::ATTR_PG_EC11, fapi2::TARGET_TYPE_CORE,      0x0B },
+     { fapi2::ATTR_PG_EC12, fapi2::TARGET_TYPE_CORE,      0x0C },
+     { fapi2::ATTR_PG_EC13, fapi2::TARGET_TYPE_CORE,      0x0D },
+     { fapi2::ATTR_PG_EC14, fapi2::TARGET_TYPE_CORE,      0x0E },
+     { fapi2::ATTR_PG_EC15, fapi2::TARGET_TYPE_CORE,      0x0F },
+     { fapi2::ATTR_PG_EC16, fapi2::TARGET_TYPE_CORE,      0x10 },
+     { fapi2::ATTR_PG_EC17, fapi2::TARGET_TYPE_CORE,      0x11 },
+     { fapi2::ATTR_PG_EC18, fapi2::TARGET_TYPE_CORE,      0x12 },
+     { fapi2::ATTR_PG_EC19, fapi2::TARGET_TYPE_CORE,      0x13 },
+     { fapi2::ATTR_PG_EC20, fapi2::TARGET_TYPE_CORE,      0x14 },
+     { fapi2::ATTR_PG_EC21, fapi2::TARGET_TYPE_CORE,      0x15 },
+     { fapi2::ATTR_PG_EC22, fapi2::TARGET_TYPE_CORE,      0x16 },
+     { fapi2::ATTR_PG_EC23, fapi2::TARGET_TYPE_CORE,      0x17 }
+};
+
+uint32_t CHIPLET_PG_ARRAY_ENTRIES = sizeof(CHIPLET_PG_ARRAY) /
+                                    sizeof(chiplet_pg_entry_t);
+
+#endif  // __FAPI2_PPE_TARGET_PG_ATTR__
diff --git a/hwpf/include/plat/plat_target_utils.H b/hwpf/include/plat/plat_target_utils.H
new file mode 100644
index 00000000..e1e360c0
--- /dev/null
+++ b/hwpf/include/plat/plat_target_utils.H
@@ -0,0 +1,48 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file plat_target_util.H
+ * @brief platform utility definitions for fapi2 targets
+ */
+
+#ifndef __FAPI2_PLAT_TARGET_UTIL__
+#define __FAPI2_PLAT_TARGET_UTIL__
+
+//
+// Platform Utility functions..
+//
+namespace fapi2
+{
+
+    /// @brief Function to initialize the G_targets vector based on partial good
+    ///      attributes
+    ReturnCode plat_TargetsInit();
+    
+    /// @brief Function to initialize the G_targets vector based on partial good
+    ///      attributes
+    Target<TARGET_TYPE_PROC_CHIP> plat_getChipTarget();
+
+} 
+#endif
diff --git a/hwpf/include/plat/plat_trace.H b/hwpf/include/plat/plat_trace.H
new file mode 100644
index 00000000..423ef6ea
--- /dev/null
+++ b/hwpf/include/plat/plat_trace.H
@@ -0,0 +1,86 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source:  $                                                            */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2015                        */
+/* [+] 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                                                     */
+/**
+ *  @file plat_trace.H
+ *  @brief Defines the FAPI2 trace macros.
+ *
+ *  Note that platform code must provide the implementation.
+ *
+ *  FAPI has provided a default implementation. Platform code must
+ *  provide an alternate implementation if needed.
+ */
+
+#ifndef FAPI2_PLATTRACE_H_
+#define FAPI2_PLATTRACE_H_
+
+#include <stdio.h>
+#include <stdint.h>
+
+// @todo  update these headers with extern "C" in a future commit
+//        or not and leave this just as it is.
+extern "C" 
+{
+#include "pk.h"
+#include <pk_trace.h>
+#include "trac_interface.h"
+}
+
+// Why not a #define, why is this in the fapi2 namespace?
+// To prevent problems with Cronus and the fapi1 definitions.
+namespace fapi2
+{
+    static const uint32_t MAX_ECMD_STRING_LEN = 64;
+};
+
+// Information traces (go into fast trace buffer that can wrap often)
+#define FAPI_TRACE(_id_, _fmt_, _args_...)                              \
+    PK_TRACE(_fmt_, ##_args_);
+
+
+/*  The following is a desirous trace entry but the second line has a
+    compilation issue that is unresolved
+    
+#define FAPI_TRACE(_id_, _fmt_, _args_...)                              \
+    PK_TRACE("%s: %s:%d ", _id_, __FUNCTION__, __LINE__);               \
+    PK_TRACE(_fmt_, ##_args_);
+*/
+
+#define FAPI_INF(_fmt_, _args_...) FAPI_TRACE("inf", _fmt_, ##_args_)
+
+// Important traces (go into slow trace buffer that should not wrap often)
+#define FAPI_IMP(_fmt_, _args_...) FAPI_TRACE("imp", _fmt_, ##_args_)
+
+// Error traces (go into slow trace buffer that should not wrap often)
+#define FAPI_ERR(_fmt_, _args_...) FAPI_TRACE("err", _fmt_, ##_args_)
+
+// Debug traces (go into fast trace buffer that can wrap often)
+#define FAPI_DBG(_fmt_, _args_...) FAPI_TRACE("dbg", _fmt_, ##_args_)
+
+// Scan traces
+#define FAPI_SCAN(_fmt_, _args_...) FAPI_TRACE("scan", _fmt_, ##_args_)
+
+#define FAPI_MFG(_fmt_, _args_...) FAPI_TRACE("mfg", _fmt_, ##_args_)
+
+#endif // FAPI2_PLATTRACE_H_
diff --git a/hwpf/include/plat/target.H b/hwpf/include/plat/target.H
new file mode 100644
index 00000000..0c40642b
--- /dev/null
+++ b/hwpf/include/plat/target.H
@@ -0,0 +1,342 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: $                                                             */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2012,2014                        */
+/* [+] 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                                                     */
+/**
+ * @file target.H
+ * @brief platform specializations for fapi2 targets
+ */
+
+#ifndef __FAPI2_TARGET__
+#define __FAPI2_TARGET__
+
+#include <plat_target.H>
+#include <plat_target_parms.H>
+#include <fapi2_target.H>
+#include <plat_trace.H>
+#include <utils.H>
+#include <stdio.h>
+#include <stdint.h>
+#include <vector>
+
+extern "C"
+{
+    extern std::vector<fapi2::plat_target_handle_t> G_vec_targets;
+}
+
+namespace fapi2
+{
+    /// @brief Create a Target, with a value
+    /// @param[in] Value the value (i.e., specific element this
+    /// target represents, or pointer)
+    /// @note Platforms can mangle the value and K to get a
+    /// single uint64_t in value which represents all the information
+    /// they might need. value( K | V ), for example
+    ///
+    template<TargetType K, typename V>
+    Target<K, V>::Target(V Value)
+    {
+        static_assert( ((K == TARGET_TYPE_CORE) &
+                            (K == TARGET_TYPE_EQ)       ) != true,
+            "TARGET_TYPE_CORE and TARGET_TYPE_EQ cannot be specified at the same time");
+
+        this->iv_handle.value = 0;
+        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_target_num = 0;
+        }
+
+        if(K & TARGET_TYPE_PERV)
+        {
+            this->iv_handle.fields.chiplet_num = Value;
+            this->iv_handle.fields.type = TARGET_TYPE_PERV;
+            this->iv_handle.fields.type_target_num = Value;
+        }
+
+        if(K & TARGET_TYPE_CORE)
+        {
+            this->iv_handle.fields.chiplet_num = Value + CORE_CHIPLET_OFFSET;
+            this->iv_handle.fields.type = TARGET_TYPE_CORE | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type_target_num = Value;
+        }
+
+        if(K & TARGET_TYPE_EQ)
+        {
+            this->iv_handle.fields.chiplet_num = Value + EQ_CHIPLET_OFFSET;
+            this->iv_handle.fields.type = TARGET_TYPE_EQ | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type_target_num = Value;
+        }
+
+        if(K & TARGET_TYPE_EX)
+        {
+
+            this->iv_handle.fields.chiplet_num = (Value / 2) + EX_CHIPLET_OFFSET;
+            this->iv_handle.fields.type = TARGET_TYPE_EX | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type_target_num = Value;
+        }
+
+        if(K & TARGET_TYPE_MCS)
+        {
+
+            this->iv_handle.fields.chiplet_num = Value + MCS_CHIPLET_OFFSET;
+            this->iv_handle.fields.type = TARGET_TYPE_MCS | TARGET_TYPE_PERV;
+            this->iv_handle.fields.type_target_num = Value;
+        }
+
+        if(K == TARGET_TYPE_ALL)
+        {
+            this->iv_handle.fields.chiplet_num = Value;
+            this->iv_handle.fields.type = TARGET_TYPE_ALL;
+        }
+        this->iv_handle.fields.address_overlay =
+                (this->iv_handle.fields.chiplet_num << 24);
+
+    }
+
+    ///
+    /// @brief Assignment Operator.
+    /// @param[in] i_right Reference to Target to assign from.
+    /// @return Reference to 'this' Target
+    ///
+    template<TargetType K, typename V>
+    Target<K, V>& Target<K, V>::operator=(const Target& i_right)
+        {
+            this->iv_handle.value = i_right->iv_handle.value;
+            return *this;
+        }
+    ///
+    /// @brief Equality Comparison Operator
+    /// @param[in] i_right Reference to Target to compare.
+    /// @return bool. True if equal.
+    /// @note Platforms need to define this so that the physical
+    /// targets are determined to be equivilent rather than just the handles
+    ///
+    template<TargetType K, typename V>
+    bool Target<K, V>::operator==(const Target& i_right) const
+    {
+        if (this->iv_handle.value == i_right->iv_handle.value)
+            return true;
+        else
+            return false;
+    }
+
+    ///
+    /// @brief Inquality Comparison Operator
+    /// @param[in] i_right Reference to Target to compare.
+    /// @return bool. True if not equal.
+    /// @note Platforms need to define this so that the physical
+    /// targets are determined to be equivilent rather than just the handles
+    ///
+    template<TargetType K, typename V>
+    bool Target<K, V>::operator!=(const Target& i_right) const
+    {
+        if (this->iv_handle.value != i_right->iv_handle.value)
+            return true;
+        else
+            return false;
+    }
+
+    ///
+    /// @brief Get this target's immediate parent
+    /// @tparam T The type of the parent
+    /// @return Target<T> a target representing the parent
+    ///
+    template<TargetType K, typename V>
+    template<TargetType T>
+    inline Target<T> Target<K, V>::getParent(void) const
+    {
+        return this->iv_handle.value;
+    }
+
+    ///
+    /// @brief Get this target's children
+    /// @tparam K The type of the parent
+    /// @tparam T The type of child
+    /// @param[in] i_state The desired TargetState of the children
+    /// @return std::vector<Target<T> > a vector of present/functional
+    /// children
+    /// @warning The children of EX's (cores) are expected to be returned
+    /// in order. That is, core 0 is std::vector[0].
+    ///
+    template<TargetType K, typename V>
+    template< TargetType T>
+    inline std::vector<Target<T> >
+    Target<K, V>::getChildren(const TargetState i_state) const
+    {
+#define INVALID_CHILD(PARENT, CHILD) \
+        static_assert(!((K == PARENT) && (T == CHILD)), \
+                  #CHILD " is not a child of " #PARENT );
+
+        // invalid children for proc
+//        INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_NONE)
+//        INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_SYSTEM)
+//        INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_DIMM)
+//        INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_PROC_CHIP)
+//        INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_MEMBUF_CHIP)
+//        INVALID_CHILD(fapi2::TARGET_TYPE_PROC_CHIP, fapi2::TARGET_TYPE_MBA)
+#undef INVALID_CHILD
+
+#define INVALID_PARENT(PARENT) \
+        static_assert(!((K == PARENT)), \
+                  #PARENT "is not supported on PPE platforms");
+
+        // invalid parents
+//         INVALID_PARENT(fapi2::TARGET_TYPE_SYSTEM)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_MEMBUF_CHIP)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_L4)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_DIMM)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_MCA)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_MBA)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_MI)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_MCBIST)
+//         INVALID_PARENT(fapi2::TARGET_TYPE_DMI)
+#undef INVALID_PARENT
+
+        // valid children for EQ
+        // EQ -> CORE
+        // EQ -> EX
+        static_assert(!((K == fapi2::TARGET_TYPE_EQ) &&
+                        (T != fapi2::TARGET_TYPE_CORE) &&
+                        (T != fapi2::TARGET_TYPE_EX)),
+                      "improper child of fapi2::TARGET_TYPE_EQ");
+
+        // valid children for EX
+        // EX -> CORE
+        static_assert(!((K == fapi2::TARGET_TYPE_EX) &&
+                        (T != fapi2::TARGET_TYPE_CORE)),
+                      "improper child of fapi2::TARGET_TYPE_EX");
+
+        // Nimbus Memory
+        // valid children for MCS
+        // MCS -> MCA
+//         static_assert(!((K == fapi2::TARGET_TYPE_MCS) &&
+//                         (T != fapi2::TARGET_TYPE_MCA)),
+//                       "improper child of fapi2::TARGET_TYPE_MCS");
+
+
+        std::vector<fapi2::plat_target_handle_t>::iterator l_iter;
+        FAPI_DBG("getChildren: initializing children vector");
+        std::vector<Target<T> > l_children;
+        
+        
+       
+        uint32_t c = 0;
+        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)
+            {
+                switch (i_state)
+                {
+                    case TARGET_STATE_PRESENT:                
+                        if ((*l_temp).getPresent())
+                        {
+                            l_children.push_back((*l_temp));
+//                            FAPI_DBG("Pushing getChildren present 0x%08X", (uint32_t)(((*l_temp)).get()>>32));
+                        }
+                        break;
+                    case TARGET_STATE_FUNCTIONAL:
+                        if ((*l_temp).getFunctional())
+                        {
+                            l_children.push_back((*l_temp));
+//                            FAPI_DBG("Pushing getChildren functional 0x%08X", (uint32_t)(((*l_temp)).get()>>32));
+                        }
+                        break;
+                    default:
+                        FAPI_ERR("Coming error ASSERT for illegal i_state = %u", i_state);
+                }
+            }
+            ++c;
+        }
+
+        return l_children;
+    }
+
+    ///
+    /// @brief Get the target at the other end of a bus - dimm included
+    /// @tparam T The type of the parent
+    /// @param[in] i_state The desired TargetState of the children
+    /// @return Target<T> a target representing the thing on the other end
+    /// @note Can be easily changed to a vector if needed
+    ///
+    template<TargetType K, typename V>
+    template<TargetType T>
+    inline Target<T>
+    Target<K, V>::getOtherEnd(const TargetState i_state) const
+    {
+//        static_assert( false, "getOtherEnd() is not supported on PPE platforms");
+    }
+
+
+    ///
+    /// @brief Return the string interpretation of this target
+    /// @tparam T The type of the target
+    /// @param[in] i_target Target<T>
+    /// @param[in] i_buffer buffer to write in to
+    /// @param[in] i_bsize size of the buffer
+    /// @return void
+    /// @post The contents of the buffer is replaced with the string
+    /// representation of the target
+    ///
+    template< TargetType T >
+    inline void toString(const Target<T>& i_target, char* i_buffer, size_t i_bsize)
+    {
+        snprintf(i_buffer, i_bsize, "Target 0x%lx/0x%x", i_target.get(), T);
+    }
+
+    ///
+    /// @brief Return the string interpretation of this target
+    /// @tparam T The type of the target
+    /// @tparam B The type of the buffer
+    /// @param[in] A pointer to the Target<T>
+    /// @param[in] i_buffer buffer to write in to
+    /// @param[in] i_bsize size of the buffer
+    /// @return void
+    /// @post The contents of the buffer is replaced with the string
+    /// representation of the target
+    ///
+    template< TargetType T >
+    inline void toString(const Target<T>* i_target, char* i_buffer, size_t i_bsize)
+    {
+        snprintf(i_buffer, i_bsize, "Target 0x%lx/0x%x", i_target->get(), T);
+    }
+
+    ///
+    /// @brief Get an enumerated target of a specific type
+    /// @tparam T The type of the target
+    /// @param[in] Ordinal representing the ordinal number of
+    /// the desired target
+    /// @return Target<T> the target requested
+    ///
+    template<TargetType T>
+    inline Target<T> getTarget(uint64_t Ordinal)
+    {
+        // For testing
+        return Target<T>(Ordinal);
+    }
+}
+
+#endif
diff --git a/hwpf/include/plat/target.apis b/hwpf/include/plat/target.apis
new file mode 100644
index 00000000..3490c05e
--- /dev/null
+++ b/hwpf/include/plat/target.apis
@@ -0,0 +1,11 @@
+
+inline Target<T> Target<K, V>::getParent(void) const
+
+Target<K, V>::getChildren(const TargetState i_state) const
+
+Target<K, V>::getOtherEnd(const TargetState i_state) const
+
+inline void toString(const Target<T>& i_target, char* i_buffer, size_t i_bsize)
+
+inline Target<T> getTarget(uint64_t Ordinal)
+