diff options
Diffstat (limited to 'importtemp/fapi2/include/plat')
| -rw-r--r-- | importtemp/fapi2/include/plat/hw_access.H | 605 | ||||
| -rw-r--r-- | importtemp/fapi2/include/plat/plat_error_scope.H | 58 | ||||
| -rw-r--r-- | importtemp/fapi2/include/plat/plat_hw_access.H | 33 | ||||
| -rw-r--r-- | importtemp/fapi2/include/plat/plat_target.H | 39 | ||||
| -rw-r--r-- | importtemp/fapi2/include/plat/plat_trace.H | 64 | ||||
| -rw-r--r-- | importtemp/fapi2/include/plat/target.H | 172 |
6 files changed, 971 insertions, 0 deletions
diff --git a/importtemp/fapi2/include/plat/hw_access.H b/importtemp/fapi2/include/plat/hw_access.H new file mode 100644 index 00000000..d86dce17 --- /dev/null +++ b/importtemp/fapi2/include/plat/hw_access.H @@ -0,0 +1,605 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: hwpf/fapi2/include/plat/hw_access.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 hw_access.H +/// +/// @brief Hardware access functions that needs to be specialized for +/// platform implementation. +/// + +#ifndef _FAPI2_HWACCESS_H_ +#define _FAPI2_HWACCESS_H_ + +// variable_buffer isn't supported on PPE +#ifndef __PPE__ + #include <variable_buffer.H> +#endif + +#include <plat_hw_access.H> +#include <fapi2_hw_access.H> + +//@TODO remove with RTC: 133089 +#ifdef TEMPORARY_FOR_INITFILE + #include <SpyInterface.H> +#endif +namespace fapi2 +{ +//-------------------------------------------------------------------------- +// PIB Error Functions +//-------------------------------------------------------------------------- + +/// @brief Sets the PIB error mask - platform dependant +/// @param[in] i_mask The new error mask +// note: this can be moved to a C file if desired +inline void setPIBErrorMask(uint8_t i_mask) +{ + // Keeps the compiler from complaining about the unused i_mask + static_cast<void>(i_mask); + + return; +} + +/// @brief Gets the PIB error mask - platform dependant +/// @return uint8_t The current PIB error mask +// note: this can be moved to a C file if desired +inline uint8_t getPIBErrorMask(void) +{ + return 0; +} + +//-------------------------------------------------------------------------- +// 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 to be implemented at the platform layer. +//------------------------------------------------------------------------------ + +/// +/// @brief Platform-level implementation of getScom() +/// @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_date Buffer that holds data read from HW target. +/// @return fapi::ReturnCode. FAPI2_RC_SUCCESS if success, else error code. +/// +template< TargetType K > +inline ReturnCode getScom(const Target<K>& i_target, + const uint64_t i_address, + buffer<uint64_t>& o_data) +{ + o_data = 0x0000FEEDFACE0000; + std::cout << std::hex << " getScom " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "output data: " << uint64_t(o_data) + << std::dec << std::endl; + + return FAPI2_RC_SUCCESS; +} + +/// @brief Platform-level implementation of putScom() +/// @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 ReturnCode putScom(const Target<K>& i_target, + const uint64_t i_address, + const buffer<uint64_t> i_data) +{ + std::cout << std::hex << " putScom " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "input data: " << uint64_t(i_data) + << std::dec << std::endl; + return FAPI2_RC_SUCCESS; +} + +/// @brief Platform-level implementation of putScomUnderMask() +/// @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 ReturnCode putScomUnderMask(const Target<K>& i_target, + const uint64_t i_address, + const buffer<uint64_t> i_data, + const buffer<uint64_t> i_mask) +{ + std::cout << std::hex << " putScomUnderMask " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "input data: " << uint64_t(i_data) << "; " + << "input mask: " << uint64_t(i_mask) + << std::dec << std::endl; + return FAPI2_RC_SUCCESS; +} + +/// +/// @brief Platform-level implementation called by getCfamRegister() +/// Hardware procedures writers will not call this function. +/// @Tparam K template parameter, passed in target. +/// @param[in] i_target HW target to operate on. +/// @param[in] i_address CFAM address to read from. +/// @param[out] o_data 32-bit 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) +{ + o_data = 0xFEED0CFA; + std::cout << std::hex << " getCfamRegister " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "output data: " << uint32_t(o_data) + << std::dec << std::endl; + return FAPI2_RC_SUCCESS; +} + +/// +/// @brief Platform-level implementation of putCfamRegister() +/// Hardware procedures writers will not call this function. +/// @Tparam K template parameter, passed in target. +/// @param[in] i_target HW target to operate on. +/// @param[in] i_address CFAM address to write to. +/// @param[out] i_data 32-bit 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, + const buffer<uint32_t> i_data) +{ + std::cout << std::hex << " putCfamRegister " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "input data: " << uint32_t(i_data) + << std::dec << std::endl; + return FAPI2_RC_SUCCESS; +} + + +/// +/// @brief Platform-level implementation of modifyCfamRegister() +/// Hardware procedures writers will not call this function. +/// @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[out] i_data 32-bit buffer that holds data to modify. +/// @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 fapi2::ChipOpModifyMode i_modifyMode) +{ + std::cout << std::hex << " modifyCfamRegister " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "input modifying data: " << uint32_t(i_data) << "; " + << "input ChipOpModifyMode: " << i_modifyMode + << std::dec << std::endl; + return FAPI2_RC_SUCCESS; +} + +// variable_buffer isn't supported on PPE +#ifndef __PPE__ +/// +/// @brief Platform-level implementation of getRing() +/// Hardware procedures writers will not call this function. +/// @Tparam K template parameter, passed in target. +/// @param[in] i_target HW target to operate on. +/// @param[in] i_address Ring address to read from. +/// @param[out] o_data Buffer that holds ring 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) +{ + o_data.setBit(0); + o_data.setBit(3); + std::cout << std::hex << " getRing " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "ring address: " << i_address << "; " + << "ring mode: " << i_ringMode << "; " + << "first element of output data: " << o_data()[0] + << std::endl; + + return FAPI2_RC_SUCCESS; +} + +/// @brief Platform-level implementation of putRing() +/// Hardware procedures writers will not call this function. +/// @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, + const variable_buffer& i_data, + const RingMode i_ringMode) +{ + std::cout << std::hex << " putRing " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "ring mode: " << i_ringMode << "; " + << "first element of the input data: " << i_data()[0] + << std::endl; + + return FAPI2_RC_SUCCESS; +} + +/// @brief Platform-level implementation of modifyRing() +/// @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, + const variable_buffer& i_data, + const ChipOpModifyMode i_modifyMode, + const RingMode i_ringMode) +{ + std::cout << std::hex << " modifyRing " + << "target: {" << i_target.getType() << "," + << uint64_t(i_target) << "}; " + << "address: " << i_address << "; " + << "input ChipOpModifyMode: " << i_modifyMode << "; " + << "ring mode: " << i_ringMode << "; " + << "first element of the input data: " << i_data()[0] + << std::endl; + + 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 (enum)"); + 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, + const 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, + const variable_buffer& i_data) +{ +//@TODO remove with RTC: 133089 +#ifdef TEMPORARY_FOR_INITFILE + uint32_t l_chipId = strtol(getenv("CHIPID"), NULL, 16); + uint32_t l_chipEc = strtol(getenv("CHIPEC"), NULL, 16); + + return (SPY::PutSpy(l_chipId, l_chipEc, i_spyId, i_data )); +#else + static_assert(K == 0, "implement putSpy (string)"); + return ~FAPI2_RC_SUCCESS; +#endif +} + +template< TargetType K > +inline ReturnCode putSpy(const Target<K>& i_target, + const char* const i_spyId, + const char* i_enum) +{ +//@TODO remove with RTC: 133089 +#ifdef TEMPORARY_FOR_INITFILE + uint32_t l_chipId = strtol(getenv("CHIPID"), NULL, 16); + uint32_t l_chipEc = strtol(getenv("CHIPEC"), NULL, 16); + + return (SPY::PutSpy(l_chipId, l_chipEc, i_spyId, i_enum )); +#else + static_assert(K == 0, "implement putSpy (string)"); + return ~FAPI2_RC_SUCCESS; +#endif +} +#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/importtemp/fapi2/include/plat/plat_error_scope.H b/importtemp/fapi2/include/plat/plat_error_scope.H new file mode 100644 index 00000000..d2b22fbc --- /dev/null +++ b/importtemp/fapi2/include/plat/plat_error_scope.H @@ -0,0 +1,58 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: hwpf/fapi2/include/plat/plat_error_scope.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_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__ ) \ + if ((fapi2::current_err = (__operation__)) != fapi2::FAPI2_RC_SUCCESS) \ + { \ + goto fapi_try_exit; \ + } + +#define PLAT_FAPI_TRY_TRACE( __operation__, ... ) \ + if ((fapi2::current_err = (__operation__)) != fapi2::FAPI2_RC_SUCCESS) \ + { \ + FAPI_ERR(__VA_ARGS__); \ + goto fapi_try_exit; \ + } + +/// +/// @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; \ + } +/// @endcond + +#endif diff --git a/importtemp/fapi2/include/plat/plat_hw_access.H b/importtemp/fapi2/include/plat/plat_hw_access.H new file mode 100644 index 00000000..9a9ad5e4 --- /dev/null +++ b/importtemp/fapi2/include/plat/plat_hw_access.H @@ -0,0 +1,33 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: hwpf/fapi2/include/plat/plat_hw_access.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_hw_access.H +/// +/// @brief Platform hardware-access definitions +/// + +#ifndef _FAPI2_PLAT_HWACCESS_H_ +#define _FAPI2_PLAT_HWACCESS_H_ + +namespace fapi2 +{ + +} + +#endif // _FAPI2_PLAT_HWACCESS_H_ diff --git a/importtemp/fapi2/include/plat/plat_target.H b/importtemp/fapi2/include/plat/plat_target.H new file mode 100644 index 00000000..3e28c1da --- /dev/null +++ b/importtemp/fapi2/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/importtemp/fapi2/include/plat/plat_trace.H b/importtemp/fapi2/include/plat/plat_trace.H new file mode 100644 index 00000000..c7e1b693 --- /dev/null +++ b/importtemp/fapi2/include/plat/plat_trace.H @@ -0,0 +1,64 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: hwpf/fapi2/include/plat/plat_trace.H $ */ +/* */ +/* IBM CONFIDENTIAL */ +/* */ +/* EKB Project */ +/* */ +/* COPYRIGHT 2011,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_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> + +// 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_...) \ + printf("%s: %s:%d ", _id_, __func__, __LINE__); \ + printf(_fmt_, ##_args_); \ + printf("\n") + +#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/importtemp/fapi2/include/plat/target.H b/importtemp/fapi2/include/plat/target.H new file mode 100644 index 00000000..a7275224 --- /dev/null +++ b/importtemp/fapi2/include/plat/target.H @@ -0,0 +1,172 @@ +/* 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 target.H + * @brief platform specializations for fapi2 targets + */ + +#ifndef __FAPI2_TARGET__ +#define __FAPI2_TARGET__ + +#include <plat_target.H> +#include <fapi2_target.H> +#include <stdio.h> + +namespace fapi2 +{ + +/// +/// @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) +{ + iv_handle = i_right.iv_handle; + 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 +{ + return i_right.iv_handle == iv_handle; +} + +/// +/// @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 +{ + return i_right.iv_handle != iv_handle; +} + +/// +/// @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 +{ + // For testing + return Target<T>(iv_handle); +} + +/// +/// @brief Get this target's children +/// @tparam T The type of the parent +/// @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 +{ + // To keep the compiler quiet about unused variables + static_cast<void>(i_state); + // For testing + return {Target<T>(), Target<T>()}; +} + +/// +/// @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 +{ + // Implementation note: cast to a composite of + // bus types and the compiler will check if this is + // a good function at compile time + return Target<T>(); +} + + +/// +/// @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 |
