From dc994064c73f0660b79021d4ef5969b16d715ae8 Mon Sep 17 00:00:00 2001 From: Prasad Bg Ranganath Date: Thu, 17 Mar 2016 12:50:41 -0500 Subject: FAPI2: FFDC Error XML Hostboot Integration Change-Id: If5c82101d973ad8fb383252d93af3aa0bd97aea7 RTC: 124673 Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/22194 Tested-by: Jenkins Server Tested-by: FSP CI Jenkins Reviewed-by: Christian R. Geddes Reviewed-by: Daniel M. Crowell --- src/usr/errl/parser/genErrlParsers.pl | 5 +- src/usr/fapi2/platCreateHwpErrParser.pl | 2 +- src/usr/fapi2/test/makefile | 1 + src/usr/fapi2/test/rcTest.C | 1792 +++++++++++++++++++++++++++++++ src/usr/fapi2/test/rcTest.H | 170 +++ 5 files changed, 1965 insertions(+), 5 deletions(-) create mode 100755 src/usr/fapi2/test/rcTest.C create mode 100644 src/usr/fapi2/test/rcTest.H (limited to 'src') diff --git a/src/usr/errl/parser/genErrlParsers.pl b/src/usr/errl/parser/genErrlParsers.pl index 4f87f5869..6ddcdb113 100755 --- a/src/usr/errl/parser/genErrlParsers.pl +++ b/src/usr/errl/parser/genErrlParsers.pl @@ -1227,10 +1227,7 @@ sub getPluginDirsToParse { if ($dirEntryPath =~ /plugins/) { - # Found plugins directory - push(@pluginDirsToParse, $dirEntryPath) - if (!($dirEntryPath =~ /hwpf/)); - # TODO RTC 124673 disable fapi1 + push(@pluginDirsToParse, $dirEntryPath); } else { diff --git a/src/usr/fapi2/platCreateHwpErrParser.pl b/src/usr/fapi2/platCreateHwpErrParser.pl index 4c2fc8ec8..ec002ac59 100755 --- a/src/usr/fapi2/platCreateHwpErrParser.pl +++ b/src/usr/fapi2/platCreateHwpErrParser.pl @@ -79,7 +79,7 @@ print TGFILE "void parseHwpRc(ErrlUsrParser & i_parser,\n"; print TGFILE " void * i_pBuffer,\n"; print TGFILE " const uint32_t i_buflen)\n"; print TGFILE "{\n"; -print TGFILE " uint64_t l_rc_64 = ntohll(*(static_cast(i_pBuffer)));\n"; +print TGFILE " uint32_t l_rc = ntohll(*(static_cast(i_pBuffer)));\n"; print TGFILE " switch(l_rc)\n"; print TGFILE " {\n"; diff --git a/src/usr/fapi2/test/makefile b/src/usr/fapi2/test/makefile index 1ed52b78b..909ee7ac2 100644 --- a/src/usr/fapi2/test/makefile +++ b/src/usr/fapi2/test/makefile @@ -31,6 +31,7 @@ MODULE = testfapi2 include fapi2Test.mk + include ${ROOTPATH}/config.mk vpath %.C ${GENDIR} diff --git a/src/usr/fapi2/test/rcTest.C b/src/usr/fapi2/test/rcTest.C new file mode 100755 index 000000000..fd7a5da7f --- /dev/null +++ b/src/usr/fapi2/test/rcTest.C @@ -0,0 +1,1792 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: src/usr/fapi2/test/rcTest.C $ */ +/* */ +/* OpenPOWER HostBoot Project */ +/* */ +/* Contributors Listed Below - COPYRIGHT 2011,2016 */ +/* [+] International Business Machines Corp. */ +/* */ +/* */ +/* Licensed under the Apache License, Version 2.0 (the "License"); */ +/* you may not use this file except in compliance with the License. */ +/* You may obtain a copy of the License at */ +/* */ +/* http://www.apache.org/licenses/LICENSE-2.0 */ +/* */ +/* Unless required by applicable law or agreed to in writing, software */ +/* distributed under the License is distributed on an "AS IS" BASIS, */ +/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ +/* implied. See the License for the specific language governing */ +/* permissions and limitations under the License. */ +/* */ +/* IBM_PROLOG_END_TAG */ +// $Id: rcTest.C,v 1.16 2015/03/18 19:41:51 pragupta Exp $ +/** + * @file rcTest.C + * + * @brief Implements Target class unit test functions. + */ + + +#include +#include +#include +#include +#include + +namespace fapi2 +{ + +//****************************************************************************** +// rcTestDefaultConstructor. Ensures that the ReturnCode default +// constructor works +//****************************************************************************** +uint32_t rcTestDefaultConstructor() +{ + uint32_t l_result = 0; + + // Create ReturnCode using default constructor + ReturnCode l_rc; + + // Ensure that the embedded return code is success + if (l_rc != FAPI2_RC_SUCCESS) + { + FAPI_ERR("rcTestDefaultConstructor. Code is 0x%x, expected success", + static_cast(l_rc)); + l_result = 1; + } + else + { + // Ensure that testing l_rc works + if (l_rc) + { + FAPI_ERR("rcTestDefaultConstructor. testing rc returned true"); + l_result = 2; + } + else + { + FAPI_INF("rcTestDefaultConstructor. Success!"); + } + } + return l_result; +} + +//TODO RTC 143127:fapi2 ReturnCode support in hostboot +#if 0 +//****************************************************************************** +// rcTestReturnCodeCreator. Ensures that the ReturnCode creator reflects +// the return code +//****************************************************************************** +uint32_t rcTestReturnCodeCreator() +{ + uint32_t l_result = 0; + + // Create ReturnCode using default constructor + ReturnCode l_rc; + + // Set the return code to a FAPI code + l_rc.setFapiError(FAPI2_RC_INVALID_ATTR_GET); + + // Ensure that the creator is FAPI + ReturnCode::returnCodeCreator l_creator = l_rc.getCreator(); + + if (l_creator != ReturnCode::CREATOR_FAPI) + { + FAPI_ERR("rcTestReturnCodeCreator. Creator is 0x%x, expected FAPI", + l_creator); + l_result = 1; + } + else + { + // Set the return code to a PLAT code + l_rc.setPlatError(NULL); + + // Ensure that the creator is PLAT + l_creator = l_rc.getCreator(); + + if (l_creator != ReturnCode::CREATOR_PLAT) + { + FAPI_ERR("rcTestReturnCodeCreator. Creator is 0x%x, expected PLAT", + l_creator); + l_result = 2; + } + else + { + // Set the return code to a HWP code (intentionally use function + // that does not add error information). + l_rc._setHwpError(RC_TEST_ERROR_A); + + // Ensure that the creator is HWP + l_creator = l_rc.getCreator(); + + if (l_creator != ReturnCode::CREATOR_HWP) + { + FAPI_ERR("rcTestReturnCodeCreator. Creator is 0x%x,expected HWP" + , l_creator); + l_result = 3; + } + else + { + FAPI_INF("rcTestReturnCodeCreator. Success!"); + } + } + } + + return l_result; +} +#endif + +//****************************************************************************** +// rcTestReturnCodeConstructor. Ensures that the ReturnCode constructor works +// when specifying a return code +//****************************************************************************** +uint32_t rcTestReturnCodeConstructor() +{ + uint32_t l_result = 0; + + // Create ReturnCode specifying a return code + ReturnCode l_rc(FAPI2_RC_INVALID_ATTR_GET); + + // Ensure that the embedded return code is as expected + uint64_t l_codeCheck = l_rc; + + if (l_codeCheck != FAPI2_RC_INVALID_ATTR_GET) + { + FAPI_ERR("rcTestReturnCodeConstructor. Code is 0x%x," + " expected FAPI2_RC_INVALID_ATTR_GET",l_codeCheck); + l_result = 1; + } + else + { + // Ensure that testing l_rc works + if (!l_rc) + { + FAPI_ERR("rcTestReturnCodeConstructor. testing rc returned false"); + l_result = 2; + } + else + { + FAPI_INF("rcTestReturnCodeConstructor. Success!"); + } + } + + return l_result; +} + +//TODO RTC 143127:fapi2 ReturnCode support in hostboot +#if 0 +//****************************************************************************** +// rcTestComparisonOperator . Ensures that the comparison operators work +// (comparing with another ReturnCode) +//****************************************************************************** +uint32_t rcTestComparisonOperator() +{ + uint32_t l_result = 0; + + // Create similar ReturnCodes + ReturnCode l_rc(FAPI2_RC_INVALID_ATTR_GET); + ReturnCode l_rc2(FAPI2_RC_INVALID_ATTR_GET); + + // Ensure that the equality comparison returns true + if (!(l_rc == l_rc2)) + { + FAPI_ERR("rcTestComparisonOperator. 1. Equality comparison false"); + l_result = 1; + } + else + { + // Ensure that the inequality comparison returns false + if (l_rc != l_rc2) + { + FAPI_ERR("rcTestComparisonOperator. 2. Inequality comparison true"); + l_result = 2; + } + else + { + // Change the code of l_rc2 + l_rc2.setFapiError(FAPI2_RC_PLAT_ERR_SEE_DATA); + + // Ensure that the equality comparison returns false + if (l_rc == l_rc2) + { + FAPI_ERR("rcTestComparisonOperator.3.Equality comparison true"); + l_result = 3; + } + else + { + // Ensure that the inequality comparison returns true + if (!(l_rc != l_rc2)) + { + FAPI_ERR("rcTestComparisonOperator. 4. Inequality " + " comparison false"); + l_result = 4; + } + else + { + FAPI_INF("rcTest4. Success!"); + } + } + } + } + + return l_result; +} +#endif + +//****************************************************************************** +// rcTestComparisonOperatorWithRCValue. Ensures that the comparison operators +// work (comparing with a return code value) +//****************************************************************************** +uint32_t rcTestComparisonOperatorWithRCValue() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc(FAPI2_RC_INVALID_ATTR_GET); + + // Ensure that the equality comparison returns true when comparing to the + // same return code value + if (!(l_rc == FAPI2_RC_INVALID_ATTR_GET)) + { + FAPI_ERR("rcTestComparisonOperatorWithRCValue. 1. Equality comparison" + " false"); + l_result = 1; + } + else + { + // Ensure that the inequality comparison returns false when comparing to + // the same return code value + if (l_rc != FAPI2_RC_INVALID_ATTR_GET) + { + FAPI_ERR("rcTestComparisonOperatorWithRCValue. 2. Inequality " + "comparison true"); + l_result = 2; + } + else + { + // Ensure that the equality comparison returns false when comparing + // to a different return code value + if (l_rc == FAPI2_RC_PLAT_ERR_SEE_DATA) + { + FAPI_ERR("rcTestComparisonOperatorWithRCValue. 3. Equality" + " comparison true"); + l_result = 3; + } + else + { + // Ensure that the inequality comparison returns true when + // comparing to a different return code value + if (!(l_rc != FAPI2_RC_PLAT_ERR_SEE_DATA)) + { + FAPI_ERR("rcTestComparisonOperatorWithRCValue. 4. " + " Inequality comparison false"); + l_result = 4; + } + else + { + FAPI_INF("rcTestComparisonOperatorWithRCValue. Success!"); + } + } + } + } + + return l_result; +} + +//TODO RTC 143127:fapi2 ReturnCode support in hostboot +#if 0 +//****************************************************************************** +// rcTestGetAndReleasePlatData. Ensures that the getPlatData and releasePlatData +// functions work when there is no attached data +//****************************************************************************** +uint32_t rcTestGetAndReleasePlatData() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc(FAPI2_RC_INVALID_ATTR_GET); + + // Ensure that the getPlatData function returns NULL + void * l_pData = reinterpret_cast (0x12345678); + + l_pData = l_rc.getPlatData(); + + if (l_pData != NULL) + { + FAPI_ERR("rcTestGetAndReleasePlatData.getPlatData did not return NULL"); + l_result = 1; + } + else + { + // Ensure that the releasePlatData function returns NULL + l_pData = reinterpret_cast (0x12345678); + + l_pData = l_rc.releasePlatData(); + + if (l_pData != NULL) + { + FAPI_ERR("rcTestGetAndReleasePlatData. releasePlatData did " + " not return NULL"); + l_result = 2; + } + else + { + FAPI_INF("rcTestGetAndReleasePlatData. Success!"); + } + } + + return l_result; +} + +//****************************************************************************** +// rcTestGetPlatData. Ensures that the getPlatData function works when there is +// attached data +//****************************************************************************** +uint32_t rcTestGetPlatData() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + + // Assign PlatData. Note that this should really be an errlHndl_t, because + // the FSP deleteData function will attempt to delete an error log, but this + // is just for test, the data will be released before the ReturnCode is + // destructed. + uint32_t l_myData = 6; + void * l_pMyData = reinterpret_cast (&l_myData); + (void) l_rc.setPlatError(l_pMyData); + + // Ensure that getPlatData retrieves the PlatData + void * l_pMyDataCheck = l_rc.getPlatData(); + + if (l_pMyDataCheck != l_pMyData) + { + FAPI_ERR("rcTestGetPlatData. 1. getPlatData returned unexpected " + "data ptr"); + l_result = 1; + } + else + { + // Ensure that getPlatData retrieves the PlatData again + l_pMyDataCheck = NULL; + l_pMyDataCheck = l_rc.getPlatData(); + + if (l_pMyDataCheck != l_pMyData) + { + FAPI_ERR("rcTestGetPlatData. 2. getPlatData returned unexpected " + " data ptr"); + l_result = 2; + } + else + { + FAPI_INF("rcTestGetPlatData. Success!"); + } + } + + // Release the data to avoid ReturnCode from deleting in on destruction + l_pMyDataCheck = l_rc.releasePlatData(); + + return l_result; +} + +//****************************************************************************** +// rcTestReleasePlatData. Ensures that the releasePlatData function works when +// there is attached data +//****************************************************************************** +uint32_t rcTestReleasePlatData() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + + // Assign PlatData. Note that this should really be an errlHndl_t, because + // the FSP deleteData function will attempt to delete an error log, but this + // is just for test, the data will be released before the ReturnCode is + // destructed. + uint32_t l_myData = 6; + void * l_pMyData = reinterpret_cast (&l_myData); + (void) l_rc.setPlatError(l_pMyData); + + // Ensure that releasePlatData retrieves the PlatData + void * l_pMyDataCheck = l_rc.releasePlatData(); + + if (l_pMyDataCheck != l_pMyData) + { + FAPI_ERR("rcTestReleasePlatData. releasePlatDatareturned unexpected " + " data ptr"); + l_result = 1; + } + else + { + // Ensure that releasePlatData now returns NULL + l_pMyDataCheck = NULL; + l_pMyDataCheck = l_rc.releasePlatData(); + + if (l_pMyDataCheck != NULL) + { + FAPI_ERR("rcTestReleasePlatData. 2. releasePlatData returned non " + " NULL ptr"); + l_result = 2; + } + else + { + FAPI_INF("rcTestReleasePlatData. Success!"); + } + } + + return l_result; +} + +//****************************************************************************** +// rcTestCopyConstructor. Ensures that the copy constructor works when there is +// attached PlatData and that the getPlatData function works +//****************************************************************************** +uint32_t rcTestCopyConstructor() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + + // Assign PlatData. Note that this should really be an errlHndl_t, because + // the FSP deleteData function will attempt to delete an error log, but this + // is just for test, the data will be released before the ReturnCode is + // destructed. + uint32_t l_myData = 6; + void * l_pMyData = reinterpret_cast (&l_myData); + (void) l_rc.setPlatError(l_pMyData); + + // Create a ReturnCode using the copy constructor + ReturnCode l_rc2(l_rc); + + // Ensure that the two ReturnCodes are the same + if (l_rc != l_rc2) + { + FAPI_ERR("rcTestCopyConstructor. ReturnCodes differ"); + l_result = 1; + } + else + { + // Ensure that getPlatData retrieves the PlatData from l_rc + void * l_pMyDataCheck = l_rc.getPlatData(); + + if (l_pMyDataCheck != l_pMyData) + { + FAPI_ERR("rcTestCopyConstructor. 1. getPlatData returned " + " unexpected data ptr"); + l_result = 2; + } + else + { + // Ensure that getPlatData retrieves the PlatData from l_rc2 + l_pMyDataCheck = NULL; + l_pMyDataCheck = l_rc2.getPlatData(); + + if (l_pMyDataCheck != l_pMyData) + { + FAPI_ERR("rcTestCopyConstructor. 2. getPlatData returned " + "unexpected data ptr"); + l_result = 3; + } + else + { + FAPI_INF("rcTestCopyConstructor. Success!"); + } + } + } + + // Release the data to avoid ReturnCode from deleting in on destruction. + // This will release the data from both copies of the ReturnCode. + (void) l_rc.releasePlatData(); + + return l_result; +} + +//****************************************************************************** +// rcTestAssignmentOperator. Ensures that the assignment operator works when +// there is attached PlatData and that the releasePlatData function works +//****************************************************************************** +uint32_t rcTestAssignmentOperator() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + + // Assign PlatData. Note that this should really be an errlHndl_t, because + // the PLAT deleteData function will attempt to delete an error log, but + // this is just for test, the data will be released before the ReturnCode is + // destructed. + uint32_t l_myData = 6; + void * l_pMyData = reinterpret_cast (&l_myData); + (void) l_rc.setPlatError(l_pMyData); + + // Create a ReturnCode using the assignment operator + ReturnCode l_rc2; + l_rc2 = l_rc; + + // Ensure that the two ReturnCodes are the same + if (l_rc != l_rc2) + { + FAPI_ERR("rcTestAssignmentOperator. ReturnCodes differ"); + l_result = 1; + } + else + { + // Ensure that releasePlatData retrieves the PlatData from l_rc + void * l_pMyDataCheck = l_rc.releasePlatData(); + + if (l_pMyDataCheck != l_pMyData) + { + FAPI_ERR("rcTestAssignmentOperator. releasePlatData returned " + "unexpected data ptr"); + l_result = 2; + } + else + { + // Ensure that releasePlatData retrieves NULL from l_rc2 + l_pMyDataCheck = NULL; + l_pMyDataCheck = l_rc2.releasePlatData(); + + if (l_pMyDataCheck != NULL) + { + FAPI_ERR("rcTestAssignmentOperator. releasePlatData returned " + " non NULL ptr"); + l_result = 3; + } + else + { + FAPI_INF("rcTestAssignmentOperator. Success!"); + } + } + } + + return l_result; +} +#endif + +//****************************************************************************** +// rcTestGetErrorInfo . Ensures that the getErrorInfo function works when there +// is no ErrorInfo +//****************************************************************************** +uint32_t rcTestGetErrorInfo() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + + // Ensure that the getErrorInfo function returns NULL + const ErrorInfo * l_pErrInfo = + reinterpret_cast (0x12345678); + + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo != NULL) + { + FAPI_ERR("rcTestGetErrorInfo. getErrorInfo did not return NULL"); + l_result = 1; + } + else + { + FAPI_INF("rcTestGetErrorInfo. Success!"); + } + + return l_result; +} + +//****************************************************************************** +// rcTestErrorInfo. Ensures that the getErrorInfo function works when there is +// ErrorInfo +//****************************************************************************** +uint32_t rcTestErrorInfo() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + + //TODO RTC 143127:fapi2 ReturnCode support in hostboot + //l_rc.setPlatError(NULL, FAPI2_RC_PLAT_ERR_SEE_DATA); + l_rc._setHwpError(RC_FAPI2_SAMPLE); + + TARGETING::Target * l_pTarget = NULL; + TARGETING::targetService().getTopLevelTarget(l_pTarget); + + fapi2::Target l_target(l_pTarget); + + TARGETING::Target* l_masterProc = NULL; + TARGETING::targetService().masterProcChipTargetHandle( l_masterProc ); + + fapi2::Target l_target2(l_masterProc); + + // Create some FFDC + uint8_t l_ffdc = 0x12; + + // Add error information to the ReturnCode, the data is the same as that + // produced by the fapiParseErrorInfo.pl script in fapiHwpErrorInfo.H + const void * l_objects[] = {&l_ffdc, &l_target, &l_target2}; + fapi2::ErrorInfoEntry l_entries[7]; + l_entries[0].iv_type = fapi2::EI_TYPE_FFDC; + l_entries[0].ffdc.iv_ffdcObjIndex = 0; + l_entries[0].ffdc.iv_ffdcId = 0x22334455; + l_entries[0].ffdc.iv_ffdcSize = + fapi2::getErrorInfoFfdcSize(l_ffdc); + l_entries[1].iv_type = fapi2::EI_TYPE_PROCEDURE_CALLOUT; + l_entries[1].proc_callout.iv_procedure = fapi2::ProcedureCallouts::CODE; + l_entries[1].proc_callout.iv_calloutPriority = + fapi2::CalloutPriorities::MEDIUM; + l_entries[2].iv_type = fapi2::EI_TYPE_BUS_CALLOUT; + l_entries[2].bus_callout.iv_endpoint1ObjIndex = 1; + l_entries[2].bus_callout.iv_endpoint2ObjIndex = 2; + l_entries[2].bus_callout.iv_calloutPriority = + fapi2::CalloutPriorities::MEDIUM; + l_entries[3].iv_type = fapi2::EI_TYPE_CDG; + l_entries[3].target_cdg.iv_targetObjIndex = 1; + l_entries[3].target_cdg.iv_callout = 1; + l_entries[3].target_cdg.iv_deconfigure = 1; + l_entries[3].target_cdg.iv_gard = 0; + l_entries[3].target_cdg.iv_calloutPriority = fapi2::CalloutPriorities::HIGH; + l_entries[4].iv_type = fapi2::EI_TYPE_CHILDREN_CDG; + l_entries[4].children_cdg.iv_parentObjIndex = 1; + l_entries[4].children_cdg.iv_callout = 0; + l_entries[4].children_cdg.iv_deconfigure = 1; + l_entries[4].children_cdg.iv_childType = fapi2::TARGET_TYPE_ABUS_ENDPOINT; + l_entries[4].children_cdg.iv_gard = 0; + l_entries[4].children_cdg.iv_calloutPriority = + fapi2::CalloutPriorities::HIGH; + l_entries[5].iv_type = fapi2::EI_TYPE_HW_CALLOUT; + l_entries[5].hw_callout.iv_hw = fapi2::HwCallouts::MEM_REF_CLOCK; + l_entries[5].hw_callout.iv_calloutPriority = fapi2::CalloutPriorities::LOW; + l_entries[5].hw_callout.iv_refObjIndex = 0xff; + l_entries[6].iv_type = fapi2::EI_TYPE_HW_CALLOUT; + l_entries[6].hw_callout.iv_hw = fapi2::HwCallouts::FLASH_CONTROLLER_PART; + l_entries[6].hw_callout.iv_calloutPriority = fapi2::CalloutPriorities::LOW; + l_entries[6].hw_callout.iv_refObjIndex = 0xff; + + l_rc.addErrorInfo(l_objects, l_entries, 7); + + do + { + // Check that the Error Info can be retrieved + const ErrorInfo * l_pErrInfo = NULL; + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo == NULL) + { + FAPI_ERR("rcTestErrorInfo. getErrorInfo returned NULL"); + l_result = 1; + break; + } + + // Check the FFDC error information + if (l_pErrInfo->iv_ffdcs.size() != 1) + { + FAPI_ERR("rcTestErrorInfo. %d FFDCs", l_pErrInfo->iv_ffdcs.size()); + l_result = 2; + break; + } + + uint32_t l_size = 0; + const void * l_pFfdc = NULL; + + l_pFfdc = l_pErrInfo->iv_ffdcs[0]->getData(l_size); + + if (l_size != sizeof(l_ffdc)) + { + FAPI_ERR("rcTestErrorInfo. FFDC size is %d", l_size); + l_result = 3; + break; + } + + const uint8_t * l_pFfdcCheck = static_cast(l_pFfdc); + if (*l_pFfdcCheck != 0x12) + { + FAPI_ERR("rcTestErrorInfo. FFDC is 0x%x", *l_pFfdcCheck); + l_result = 4; + break; + } + // Check the callout/deconfigure/gard error information + if (l_pErrInfo->iv_CDGs.size() != 1) + { + FAPI_ERR("rcTestErrorInfo. %d CDGs", l_pErrInfo->iv_CDGs.size()); + l_result = 5; + break; + } + if (l_pErrInfo->iv_CDGs[0]->iv_target.get() != l_target) + { + FAPI_ERR("rcTestErrorInfo. CDG target mismatch"); + l_result = 6; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_callout != true) + { + FAPI_ERR("rcTestErrorInfo. callout not set"); + l_result = 7; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_calloutPriority != + CalloutPriorities::HIGH) + { + FAPI_ERR("rcTestErrorInfo. CDG callout priority mismatch (%d)", + l_pErrInfo->iv_CDGs[0]->iv_calloutPriority); + l_result = 8; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_deconfigure != true) + { + FAPI_ERR("rcTestErrorInfo. deconfigure not set"); + l_result = 9; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_gard != false) + { + FAPI_ERR("rcTestErrorInfo. GARD set"); + l_result = 10; + break; + } + + // Additional procedure called out due to Bus Callout + if (l_pErrInfo->iv_procedureCallouts.size() != 2) + { + FAPI_ERR("rcTestErrorInfo. %d proc-callouts", + l_pErrInfo->iv_procedureCallouts.size()); + l_result = 11; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[0]->iv_procedure != + ProcedureCallouts::CODE) + { + FAPI_ERR("rcTestErrorInfo. procedure callout[0] mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[0]->iv_procedure); + l_result = 12; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[0]->iv_calloutPriority != + CalloutPriorities::MEDIUM) + { + FAPI_ERR("rcTestErrorInfo. procedure callout[0] priority " + " mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[0]->iv_calloutPriority); + l_result = 13; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[1]->iv_procedure != + ProcedureCallouts::BUS_CALLOUT) + { + FAPI_ERR("rcTestErrorInfo. procedure callout[1] mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[1]->iv_procedure); + l_result = 14; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[1]->iv_calloutPriority != + CalloutPriorities::MEDIUM) + { + FAPI_ERR("rcTestErrorInfo. procedure callout[1] priority " + "mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[1]->iv_calloutPriority); + l_result = 15; + break; + } + + if (l_pErrInfo->iv_busCallouts.size() != 1) + { + FAPI_ERR("rcTestErrorInfo. %d bus-callouts", + l_pErrInfo->iv_busCallouts.size()); + l_result = 16; + break; + } + + if (l_pErrInfo->iv_busCallouts[0]->iv_target1.get() != l_target) + { + FAPI_ERR("rcTestErrorInfo. bus target mismatch 1"); + l_result = 17; + break; + } + + if (l_pErrInfo->iv_busCallouts[0]->iv_target2.get() != l_target2) + { + FAPI_ERR("rcTestErrorInfo. bus target mismatch 2"); + l_result = 18; + break; + } + + if (l_pErrInfo->iv_busCallouts[0]->iv_calloutPriority != + CalloutPriorities::LOW) + { + FAPI_ERR("rcTestErrorInfo. bus callout priority mismatch (%d)", + l_pErrInfo->iv_busCallouts[0]->iv_calloutPriority); + l_result = 19; + break; + } + + if (l_pErrInfo->iv_childrenCDGs.size() != 1) + { + FAPI_ERR("rcTestErrorInfo. %d children-cdgs", + l_pErrInfo->iv_childrenCDGs.size()); + l_result = 20; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_parent.get() != l_target) + { + FAPI_ERR("rcTestErrorInfo. parent chip mismatch"); + l_result = 21; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_childType != + fapi2::TARGET_TYPE_ABUS_ENDPOINT) + { + FAPI_ERR("rcTestErrorInfo. child type mismatch (0x%08x)", + l_pErrInfo->iv_childrenCDGs[0]->iv_childType); + l_result = 22; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_calloutPriority != + CalloutPriorities::HIGH) + { + FAPI_ERR("rcTestErrorInfo. child cdg priority mismatch (%d)", + l_pErrInfo->iv_childrenCDGs[0]->iv_calloutPriority); + l_result = 23; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_callout != false) + { + FAPI_ERR("rcTestErrorInfo. child cdg callout set"); + l_result = 24; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_deconfigure != true) + { + FAPI_ERR("rcTestErrorInfo. child cdg deconfigure not set"); + l_result = 25; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_gard != false) + { + FAPI_ERR("rcTestErrorInfo. child cdg GARD set"); + l_result = 26; + break; + } + + if (l_pErrInfo->iv_hwCallouts.size() != 2) + { + FAPI_ERR("rcTestErrorInfo. %d hw-callouts", + l_pErrInfo->iv_hwCallouts.size()); + l_result = 27; + break; + } + + if (l_pErrInfo->iv_hwCallouts[0]->iv_hw != + HwCallouts::MEM_REF_CLOCK) + { + FAPI_ERR("rcTestErrorInfo. hw callout mismatch (%d)", + l_pErrInfo->iv_hwCallouts[0]->iv_hw); + l_result = 28; + break; + } + + if (l_pErrInfo->iv_hwCallouts[0]->iv_calloutPriority != + CalloutPriorities::LOW) + { + FAPI_ERR("rcTestErrorInfo. hw callout priority mismatch (%d)", + l_pErrInfo->iv_hwCallouts[0]->iv_calloutPriority); + l_result = 29; + break; + } + + FAPI_INF("rcTestErrorInfo. Success!"); + } + while(0); + + return l_result; +} + +//****************************************************************************** +// rcTestCopyConstructorwithErrorInfo. Ensures that the copy constructor works +// when there is ErrorInfo +//****************************************************************************** +uint32_t rcTestCopyConstructorwithErrorInfo() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + //TODO RTC 143127:fapi2 ReturnCode support in hostboot + //l_rc.setPlatError(NULL, FAPI2_RC_PLAT_ERR_SEE_DATA); + l_rc._setHwpError(RC_FAPI2_SAMPLE); + + TARGETING::Target * l_pTarget = NULL; + TARGETING::targetService().getTopLevelTarget(l_pTarget); + + fapi2::Target l_target(l_pTarget); + + // Add error information to the ReturnCode + const void * l_objects[] = {&l_target}; + fapi2::ErrorInfoEntry l_entries[1]; + l_entries[0].iv_type = fapi2::EI_TYPE_CDG; + l_entries[0].target_cdg.iv_targetObjIndex = 0; + l_entries[0].target_cdg.iv_callout = 0; + l_entries[0].target_cdg.iv_deconfigure = 0; + l_entries[0].target_cdg.iv_gard = 1; + l_entries[0].target_cdg.iv_calloutPriority = fapi2::CalloutPriorities::LOW; + + l_rc.addErrorInfo(l_objects, l_entries, 1); + + // Create a ReturnCode using the copy constructor + ReturnCode l_rc2(l_rc); + + do + { + // Ensure that the two ReturnCodes are the same + if (l_rc != l_rc2) + { + FAPI_ERR("rcTestCopyConstructorwithErrorInfo. ReturnCodes differ"); + l_result = 1; + break; + } + + // Ensure that getErrorInfo returns correct information from l_rc + const ErrorInfo * l_pErrInfo = NULL; + + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo == NULL) + { + FAPI_ERR("rcTestCopyConstructorwithErrorInfo. getErrorInfo " + "returned NULL"); + l_result = 2; + break; + } + + if (l_pErrInfo->iv_CDGs.size() != 1) + { + FAPI_ERR("rcTestCopyConstructorwithErrorInfo. %d CDGs", + l_pErrInfo->iv_CDGs.size()); + l_result = 3; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_target.get() != l_target) + { + FAPI_ERR("rcTestCopyConstructorwithErrorInfo. CDG target mismatch"); + l_result = 4; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_gard != true) + { + FAPI_ERR("rcTestCopyConstructorwithErrorInfo. GARD not set"); + l_result = 5; + break; + } + + // Ensure that getErrorInfo from l_rc2 returns the same pointer + const ErrorInfo * l_pErrInfo2 = l_rc2.getErrorInfo(); + + if (l_pErrInfo != l_pErrInfo2) + { + FAPI_ERR("rcTestCopyConstructorwithErrorInfo. error info mismatch"); + l_result = 5; + break; + } + + FAPI_INF("rcTestCopyConstructorwithErrorInfo. Success!"); + } + while(0); + + return l_result; +} + +//****************************************************************************** +// rcTestAssignmentOperatorwithErrorInfo. Ensures that the assignment operator +// works when there ErrorInfo +//****************************************************************************** +uint32_t rcTestAssignmentOperatorwithErrorInfo() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + //TODO RTC 143127:fapi2 ReturnCode support in hostboot + //l_rc.setPlatError(NULL, FAPI2_RC_PLAT_ERR_SEE_DATA); + l_rc._setHwpError(RC_FAPI2_SAMPLE); + + TARGETING::Target * l_pTarget = NULL; + TARGETING::targetService().getTopLevelTarget(l_pTarget); + + fapi2::Target l_target(l_pTarget); + + // Add error information to the ReturnCode + const void * l_objects[] = {&l_target}; + fapi2::ErrorInfoEntry l_entries[1]; + l_entries[0].iv_type = fapi2::EI_TYPE_CDG; + l_entries[0].target_cdg.iv_targetObjIndex = 0; + l_entries[0].target_cdg.iv_callout = 0; + l_entries[0].target_cdg.iv_deconfigure = 0; + l_entries[0].target_cdg.iv_gard = 1; + l_entries[0].target_cdg.iv_calloutPriority = fapi2::CalloutPriorities::LOW; + + l_rc.addErrorInfo(l_objects, l_entries, 1); + + // Create a ReturnCode using the assignment operator + ReturnCode l_rc2; + l_rc2 = l_rc; + + do + { + // Ensure that the two ReturnCodes are the same + if (l_rc != l_rc2) + { + FAPI_ERR("rcTestAssignmentOperatorwithErrorInfo. ReturnCodes " + "differ"); + l_result = 1; + break; + } + + // Ensure that getErrorInfo returns correct information from l_rc + const ErrorInfo * l_pErrInfo = NULL; + + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo == NULL) + { + FAPI_ERR("rcTestAssignmentOperatorwithErrorInfo. getErrorInfo " + "returned NULL"); + l_result = 2; + break; + } + + if (l_pErrInfo->iv_CDGs.size() != 1) + { + FAPI_ERR("rcTestAssignmentOperatorwithErrorInfo. %d CDGs", + l_pErrInfo->iv_CDGs.size()); + l_result = 3; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_target.get() != l_target) + { + FAPI_ERR("rcTestAssignmentOperatorwithErrorInfo. CDG target " + "mismatch"); + l_result = 4; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_gard != true) + { + FAPI_ERR("rcTestAssignmentOperatorwithErrorInfo. GARD not set"); + l_result = 5; + break; + } + + // Ensure that getErrorInfo from l_rc2 returns the same pointer + const ErrorInfo * l_pErrInfo2 = l_rc2.getErrorInfo(); + + if (l_pErrInfo != l_pErrInfo2) + { + FAPI_ERR("rcTestAssignmentOperatorwithErrorInfo. error " + "info mismatch"); + l_result = 5; + break; + } + + FAPI_INF("rcTestAssignmentOperatorwithErrorInfo. Success!"); + } + while(0); + + return l_result; +} + +//****************************************************************************** +// rcTestClearErrorInfo. Ensures that setting the ReturnCode to success clears +// ErrorInfo +//****************************************************************************** +uint32_t rcTestClearErrorInfo() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + //TODO RTC 143127:fapi2 ReturnCode support in hostboot + //l_rc.setPlatError(NULL, FAPI2_RC_PLAT_ERR_SEE_DATA); + l_rc._setHwpError(RC_FAPI2_SAMPLE); + + TARGETING::Target * l_pTarget = NULL; + TARGETING::targetService().getTopLevelTarget(l_pTarget); + + fapi2::Target l_target(l_pTarget); + + // Add error information to the ReturnCode + const void * l_objects[] = {&l_target}; + fapi2::ErrorInfoEntry l_entries[1]; + l_entries[0].iv_type = fapi2::EI_TYPE_CDG; + l_entries[0].target_cdg.iv_targetObjIndex = 0; + l_entries[0].target_cdg.iv_callout = 0; + l_entries[0].target_cdg.iv_deconfigure = 0; + l_entries[0].target_cdg.iv_gard = 1; + l_entries[0].target_cdg.iv_calloutPriority = fapi2::CalloutPriorities::LOW; + + l_rc.addErrorInfo(l_objects, l_entries, 1); + + // Set the ReturnCode to success + l_rc = FAPI2_RC_SUCCESS; + + // Check that there is no ErrorInfo + const ErrorInfo * l_pErrInfo = NULL; + + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo != NULL) + { + FAPI_ERR("rcTestClearErrorInfo. getErrorInfo returned NULL"); + l_result = 1; + } + else + { + FAPI_INF("rcTestClearErrorInfo. Success!"); + } + + return l_result; +} + +//****************************************************************************** +// rcTestAddErrorInfo.Ensures that multiple Error Info of each type can be added +//****************************************************************************** +uint32_t rcTestAddErrorInfo() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc; + //TODO RTC 143127:fapi2 ReturnCode support in hostboot + //l_rc.setPlatError(NULL, FAPI2_RC_PLAT_ERR_SEE_DATA); + l_rc._setHwpError(RC_FAPI2_SAMPLE); + + TARGETING::Target * l_pTarget = NULL; + TARGETING::targetService().getTopLevelTarget(l_pTarget); + + fapi2::Target l_target(l_pTarget); + + TARGETING::Target* l_masterProc = NULL; + TARGETING::targetService().masterProcChipTargetHandle( l_masterProc ); + + fapi2::Target l_target2(l_masterProc); + + + // Create 2 FFDCs + uint8_t l_ffdc = 0x12; + uint32_t l_ffdc2 = 0x12345678; + + // Add error information to the ReturnCode + const void * l_objects[] = {&l_ffdc, &l_ffdc2, &l_target, + &l_target2}; + fapi2::ErrorInfoEntry l_entries[10]; + l_entries[0].iv_type = fapi2::EI_TYPE_FFDC; + l_entries[0].ffdc.iv_ffdcObjIndex = 0; + l_entries[0].ffdc.iv_ffdcId = 0x22334455; + l_entries[0].ffdc.iv_ffdcSize = + fapi2::getErrorInfoFfdcSize(l_ffdc); + l_entries[1].iv_type = fapi2::EI_TYPE_FFDC; + l_entries[1].ffdc.iv_ffdcObjIndex = 1; + l_entries[1].ffdc.iv_ffdcId = 0x33445566; + l_entries[1].ffdc.iv_ffdcSize = + fapi2::getErrorInfoFfdcSize(l_ffdc2); + l_entries[2].iv_type = fapi2::EI_TYPE_CDG; + l_entries[2].target_cdg.iv_targetObjIndex = 2; + l_entries[2].target_cdg.iv_callout = 0; + l_entries[2].target_cdg.iv_deconfigure = 1; + l_entries[2].target_cdg.iv_gard = 0; + l_entries[2].target_cdg.iv_calloutPriority = fapi2::CalloutPriorities::HIGH; + l_entries[3].iv_type = fapi2::EI_TYPE_CDG; + l_entries[3].target_cdg.iv_targetObjIndex = 3; + l_entries[3].target_cdg.iv_callout = 0; + l_entries[3].target_cdg.iv_deconfigure = 0; + l_entries[3].target_cdg.iv_gard = 1; + l_entries[3].target_cdg.iv_calloutPriority = + fapi2::CalloutPriorities::MEDIUM; + l_entries[4].iv_type = fapi2::EI_TYPE_PROCEDURE_CALLOUT; + l_entries[4].proc_callout.iv_procedure = fapi2::ProcedureCallouts::CODE; + l_entries[4].proc_callout.iv_calloutPriority = + fapi2::CalloutPriorities::MEDIUM; + l_entries[5].iv_type = fapi2::EI_TYPE_PROCEDURE_CALLOUT; + l_entries[5].proc_callout.iv_procedure = + fapi2::ProcedureCallouts::LVL_SUPPORT; + l_entries[5].proc_callout.iv_calloutPriority = + fapi2::CalloutPriorities::LOW; + l_entries[6].iv_type = fapi2::EI_TYPE_BUS_CALLOUT; + l_entries[6].bus_callout.iv_endpoint1ObjIndex = 2; + l_entries[6].bus_callout.iv_endpoint2ObjIndex = 3; + l_entries[6].bus_callout.iv_calloutPriority = fapi2::CalloutPriorities::LOW; + l_entries[7].iv_type = fapi2::EI_TYPE_BUS_CALLOUT; + l_entries[7].bus_callout.iv_endpoint1ObjIndex = 2; + l_entries[7].bus_callout.iv_endpoint2ObjIndex = 3; + l_entries[7].bus_callout.iv_calloutPriority = + fapi2::CalloutPriorities::HIGH; + l_entries[8].iv_type = fapi2::EI_TYPE_CHILDREN_CDG; + l_entries[8].children_cdg.iv_parentObjIndex = 2; + l_entries[8].children_cdg.iv_callout = 1; + l_entries[8].children_cdg.iv_deconfigure = 1; + l_entries[8].children_cdg.iv_childType = fapi2::TARGET_TYPE_ABUS_ENDPOINT; + l_entries[8].children_cdg.iv_gard = 0; + l_entries[8].children_cdg.iv_calloutPriority = + fapi2::CalloutPriorities::HIGH; + l_entries[9].iv_type = fapi2::EI_TYPE_CHILDREN_CDG; + l_entries[9].children_cdg.iv_parentObjIndex = 3; + l_entries[9].children_cdg.iv_callout = 1; + l_entries[9].children_cdg.iv_deconfigure = 0; + l_entries[9].children_cdg.iv_childType = fapi2::TARGET_TYPE_MBA_CHIPLET; + l_entries[9].children_cdg.iv_gard = 1; + l_entries[9].children_cdg.iv_calloutPriority = + fapi2::CalloutPriorities::MEDIUM; + + l_rc.addErrorInfo(l_objects, l_entries, 10); + + do + { + // Check that the Error Info can be retrieved + const ErrorInfo * l_pErrInfo = NULL; + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo == NULL) + { + FAPI_ERR("rcTestAddErrorInfo. getErrorInfo returned NULL"); + l_result = 1; + break; + } + + // Check the FFDC error information + if (l_pErrInfo->iv_ffdcs.size() != 2) + { + FAPI_ERR("rcTestAddErrorInfo.%d FFDCs",l_pErrInfo->iv_ffdcs.size()); + l_result = 2; + break; + } + + uint32_t l_size = 0; + const void * l_pFfdc = NULL; + + l_pFfdc = l_pErrInfo->iv_ffdcs[0]->getData(l_size); + + if (l_size != sizeof(l_ffdc)) + { + FAPI_ERR("rcTestAddErrorInfo. FFDC[0] size is %d", l_size); + l_result = 3; + break; + } + + const uint8_t * l_pFfdcCheck = static_cast(l_pFfdc); + if (*l_pFfdcCheck != 0x12) + { + FAPI_ERR("rcTestAddErrorInfo. FFDC[0] is 0x%x", *l_pFfdcCheck); + l_result = 4; + break; + } + + l_pFfdc = l_pErrInfo->iv_ffdcs[1]->getData(l_size); + + if (l_size != sizeof(l_ffdc2)) + { + FAPI_ERR("rcTestAddErrorInfo. FFDC[1] size is %d", l_size); + l_result = 5; + break; + } + + const uint32_t * l_pFfdc2Check = static_cast(l_pFfdc); + if (*l_pFfdc2Check != 0x12345678) + { + FAPI_ERR("rcTestAddErrorInfo. FFDC[1] is 0x%x", *l_pFfdc2Check); + l_result = 6; + break; + } + + // Check the callout/deconfigure/GARD error information + if (l_pErrInfo->iv_CDGs.size() != 2) + { + FAPI_ERR("rcTestAddErrorInfo. %d CDGs", l_pErrInfo->iv_CDGs.size()); + l_result = 7; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_target.get() != l_target) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[0] target mismatch"); + l_result = 8; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_callout != false) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[0] callout set"); + l_result = 9; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_calloutPriority != + CalloutPriorities::HIGH) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[0] callout priority mismatch"); + l_result = 10; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_deconfigure != true) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[0] deconfigure not set"); + l_result = 11; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_gard != false) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[0] gard set"); + l_result = 12; + break; + } + + if (l_pErrInfo->iv_CDGs[1]->iv_target.get() != l_target2) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[1] target mismatch"); + l_result = 13; + break; + } + + if (l_pErrInfo->iv_CDGs[1]->iv_callout != false) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[0] callout set"); + l_result = 14; + break; + } + + if (l_pErrInfo->iv_CDGs[1]->iv_calloutPriority != + CalloutPriorities::MEDIUM) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[1] callout priority mismatch"); + l_result = 15; + break; + } + + if (l_pErrInfo->iv_CDGs[1]->iv_deconfigure != false) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[1] deconfigure set"); + l_result = 16; + break; + } + + if (l_pErrInfo->iv_CDGs[1]->iv_gard != true) + { + FAPI_ERR("rcTestAddErrorInfo. CDG[1] gard not set"); + l_result = 17; + break; + } + + // Additional procedures called out due to Bus Callout + if (l_pErrInfo->iv_procedureCallouts.size() != 4) + { + FAPI_ERR("rcTestAddErrorInfo. %d proc-callouts", + l_pErrInfo->iv_procedureCallouts.size()); + l_result = 18; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[0]->iv_procedure != + ProcedureCallouts::CODE) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[0] callout mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[0]->iv_procedure); + l_result = 19; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[0]->iv_calloutPriority != + CalloutPriorities::MEDIUM) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[0] callout priority " + "mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[0]->iv_calloutPriority); + l_result = 20; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[1]->iv_procedure != + ProcedureCallouts::LVL_SUPPORT) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[1] callout mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[1]->iv_procedure); + l_result = 21; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[1]->iv_calloutPriority != + CalloutPriorities::LOW) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[1] callout priority " + "mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[1]->iv_calloutPriority); + l_result = 22; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[2]->iv_procedure != + ProcedureCallouts::BUS_CALLOUT) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[2] callout mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[2]->iv_procedure); + l_result = 23; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[2]->iv_calloutPriority != + CalloutPriorities::LOW) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[2] callout priority " + "mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[2]->iv_calloutPriority); + l_result = 24; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[3]->iv_procedure != + ProcedureCallouts::BUS_CALLOUT) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[3] callout mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[3]->iv_procedure); + l_result = 25; + break; + } + + if (l_pErrInfo->iv_procedureCallouts[3]->iv_calloutPriority != + CalloutPriorities::HIGH) + { + FAPI_ERR("rcTestAddErrorInfo. procedure[3] callout priority " + "mismatch (%d)", + l_pErrInfo->iv_procedureCallouts[3]->iv_calloutPriority); + l_result = 26; + break; + } + + if (l_pErrInfo->iv_busCallouts.size() != 2) + { + FAPI_ERR("rcTestAddErrorInfo. %d bus-callouts", + l_pErrInfo->iv_busCallouts.size()); + l_result = 27; + break; + } + + if (l_pErrInfo->iv_busCallouts[0]->iv_target1.get() != l_target) + { + FAPI_ERR("rcTestAddErrorInfo. bus target mismatch 1"); + l_result = 28; + break; + } + + if (l_pErrInfo->iv_busCallouts[0]->iv_target2.get() != l_target2) + { + FAPI_ERR("rcTestAddErrorInfo. bus target mismatch 2"); + l_result = 29; + break; + } + + if (l_pErrInfo->iv_busCallouts[0]->iv_calloutPriority != + CalloutPriorities::LOW) + { + FAPI_ERR("rcTestAddErrorInfo. bus callout priority mismatch 1 (%d)", + l_pErrInfo->iv_busCallouts[0]->iv_calloutPriority); + l_result = 30; + break; + } + + if (l_pErrInfo->iv_busCallouts[1]->iv_target1.get() != l_target) + { + FAPI_ERR("rcTestAddErrorInfo. bus target mismatch 3"); + l_result = 31; + break; + } + + if (l_pErrInfo->iv_busCallouts[1]->iv_target2.get() != l_target2) + { + FAPI_ERR("rcTestAddErrorInfo. bus target mismatch 4"); + l_result = 32; + break; + } + + if (l_pErrInfo->iv_busCallouts[1]->iv_calloutPriority != + CalloutPriorities::MEDIUM) + { + FAPI_ERR("rcTestAddErrorInfo. bus callout priority mismatch 2 (%d)", + l_pErrInfo->iv_busCallouts[1]->iv_calloutPriority); + l_result = 33; + break; + } + + if (l_pErrInfo->iv_childrenCDGs.size() != 2) + { + FAPI_ERR("rcTestAddErrorInfo. %d children-cdgs", + l_pErrInfo->iv_childrenCDGs.size()); + l_result = 34; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_parent.get() != l_target) + { + FAPI_ERR("rcTestAddErrorInfo. parent chip mismatch 1"); + l_result = 35; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_childType != + fapi2::TARGET_TYPE_ABUS_ENDPOINT) + { + FAPI_ERR("rcTestAddErrorInfo. child type mismatch 1 (0x%08x)", + l_pErrInfo->iv_childrenCDGs[0]->iv_childType); + l_result = 36; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_calloutPriority != + CalloutPriorities::HIGH) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg priority mismatch 1 (%d)", + l_pErrInfo->iv_childrenCDGs[0]->iv_calloutPriority); + l_result = 37; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_callout != true) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg callout not set 1"); + l_result = 38; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_deconfigure != true) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg deconfigure not set 1"); + l_result = 39; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[0]->iv_gard != false) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg GARD set 1"); + l_result = 40; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[1]->iv_childType != + fapi2::TARGET_TYPE_MBA_CHIPLET) + { + FAPI_ERR("rcTestAddErrorInfo. child type mismatch 2 (0x%08x)", + l_pErrInfo->iv_childrenCDGs[1]->iv_childType); + l_result = 41; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[1]->iv_calloutPriority != + CalloutPriorities::MEDIUM) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg priority mismatch 2 (%d)", + l_pErrInfo->iv_childrenCDGs[1]->iv_calloutPriority); + l_result = 42; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[1]->iv_callout != true) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg callout not set 2"); + l_result = 43; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[1]->iv_deconfigure != false) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg deconfigure set 2"); + l_result = 44; + break; + } + + if (l_pErrInfo->iv_childrenCDGs[1]->iv_gard != true) + { + FAPI_ERR("rcTestAddErrorInfo. child cdg GARD not set 2"); + l_result = 45; + break; + } + + FAPI_INF("rcTestAddErrorInfo. Success!"); + } + while(0); + + return l_result; +} + +//****************************************************************************** +// rcTestStaticCast. Ensures that static_cast can be applied to a ReturnCode +//****************************************************************************** +uint32_t rcTestStaticCast() +{ + uint32_t l_result = 0; + + // Create a ReturnCode + ReturnCode l_rc(FAPI2_RC_INVALID_ATTR_GET); + + uint64_t l_check = static_cast(l_rc); + + if (l_check != FAPI2_RC_INVALID_ATTR_GET) + { + FAPI_ERR("rcTestStaticCast. RC is not FAPI2_RC_INVALID_ATTR_GET, " + " it is 0x%x", + l_check); + l_result = 1; + } + else + { + FAPI_INF("rcTestStaticCast. Success!"); + } + + return l_result; +} + +#ifdef fips +uint32_t rcTestRcToErrl() +{ + uint32_t l_result = 0; + + // Create a FAPI ReturnCode + ReturnCode l_rc(FAPI2_RC_INVALID_ATTR_GET); + + // Create Target of functional processor chip + TARGETING::Target *l_proc = NULL; + + // Use PredicateIsFunctional (formerly HwasPredicate) to filter + // only functional chips + TARGETING::PredicateIsFunctional l_isFunctional; + do + { + + // filter for functional Proc Chips + TARGETING::PredicateCTM l_procChipFilter(TARGETING::CLASS_CHIP, + TARGETING::TYPE_PROC ); + + // declare a postfix expression + TARGETING::PredicatePostfixExpr l_functionalAndProcChipFilter; + + // is-a-proc-chip is-functional AND + l_functionalAndProcChipFilter.push(&l_procChipFilter). + push(&l_isFunctional).And(); + + // loop through all the targets, applying the filter, + // and put the results in l_pFuncProc + TARGETING::TargetRangeFilter l_pFuncProcFilter( + TARGETING::targetService().begin(), + TARGETING::targetService().end(), + &l_functionalAndProcChipFilter); + + // Get a pointer to that first function proc + if(!l_pFuncProcFilter) + { + l_result = 1; + FAPI_ERR("rcTestRcToErrl:No functional processors found"); + break; + } + + l_proc = *l_pFuncProcFilter; + TARGETING::Target* l_pConstTarget = + const_cast(l_proc); + + fapi2::Target l_procTarget( + reinterpret_cast(l_pConstTarget)); + + const void * l_objects[] = { &l_fapiTarget}; + + l_rc._setHwpError(RC_FAPI2_SAMPLE); + fapi2::ErrorInfoEntry l_entries[1]; + l_entries[0].iv_type = fapi2::EI_TYPE_CDG; + l_entries[0].target_cdg.iv_targetObjIndex = 0; + l_entries[0].target_cdg.iv_callout = 0; + l_entries[0].target_cdg.iv_deconfigure = 0; + l_entries[0].target_cdg.iv_gard = 1; + l_entries[0].target_cdg.iv_calloutPriority = + fapi2::CalloutPriorities::LOW; + + + // Add the error info + l_rc.addErrorInfo(l_objects, l_entries, 1); + + // Check that the Error Info can be retrieved + const ErrorInfo * l_pErrInfo = NULL; + l_pErrInfo = l_rc.getErrorInfo(); + + if (l_pErrInfo == NULL) + { + FAPI_ERR("rcTestRcToErrl:getErrorInfo returned NULL"); + l_result = 2; + break; + } + + // Check the callout/deconfigure/GARD error information + if (l_pErrInfo->iv_CDGs[0]->iv_target != l_fapiTarget) + { + FAPI_ERR("rcTestRcToErrl:CDG[0] target mismatch"); + l_result = 3; + break; + } + + if (l_pErrInfo->iv_CDGs[0]->iv_gard == false) + { + FAPI_ERR("rcTestRcToErrl:CDG[0] gard not set"); + l_result = 4; + break; + } + + // fapiRcToErrl is implicitly calling processEICDGs + errlHndl_t pError = fapi2::rcToErrl(l_rc); + if(pError == NULL) + { + FAPI_ERR("rcTestRcToErrl:fapiRcToErrl returnd No Errorlog handle"); + l_result = 5; + break; + } + + srciIdx_t l_calloutCnt = 0; + const SrciSrc* pSRC = pError->getSRC(); + pSRC->Callouts(l_calloutCnt); + if(l_calloutCnt < 1) + { + l_result = 6; + FAPI_ERR("Error. No Callout from fapiRcToErrl"); + break; + } + + // TODO RTC 79353 + // Garded Target must be UnGard here. + + FAPI_INF("rcTestRcToErrl:Deconfig/Gard HWP callout TC success"); + if(pError != NULL) + { + delete pError; + pError = NULL; + } + + }while(0); + return l_result; +} +#endif //fips + +} diff --git a/src/usr/fapi2/test/rcTest.H b/src/usr/fapi2/test/rcTest.H new file mode 100644 index 000000000..1e9e3d315 --- /dev/null +++ b/src/usr/fapi2/test/rcTest.H @@ -0,0 +1,170 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: src/usr/fapi2/test/rcTest.H $ */ +/* */ +/* OpenPOWER HostBoot Project */ +/* */ +/* Contributors Listed Below - COPYRIGHT 2011,2016 */ +/* [+] International Business Machines Corp. */ +/* */ +/* */ +/* Licensed under the Apache License, Version 2.0 (the "License"); */ +/* you may not use this file except in compliance with the License. */ +/* You may obtain a copy of the License at */ +/* */ +/* http://www.apache.org/licenses/LICENSE-2.0 */ +/* */ +/* Unless required by applicable law or agreed to in writing, software */ +/* distributed under the License is distributed on an "AS IS" BASIS, */ +/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ +/* implied. See the License for the specific language governing */ +/* permissions and limitations under the License. */ +/* */ +/* IBM_PROLOG_END_TAG */ +#ifndef __rcTest_H +#define __rcTest_H + +/** + * @file rcTest.H + * + * @brief Test case for FAPI2 return codes +*/ + +#include +#include +#include "rcTest.C" + +using namespace fapi2; + +class test_Fapi2ReturnCode: public CxxTest::TestSuite +{ +public: + + /** + * @brief Test FAPI2 return codes #1 + */ + void testFapi2ReturnCode1(void) + { + uint32_t l_res = rcTestDefaultConstructor(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode1. Fail l_res=%d", l_res); + } + } + + + /** + * @brief Test FAPI2 return codes #5 + */ + void testFapi2ReturnCode5() + { + uint32_t l_res = rcTestComparisonOperatorWithRCValue(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode5. Fail l_res=%d", l_res); + } + return; + } + + /** + * @brief Test FAPI2 return codes #11 + */ + void testFapi2ReturnCode11(void) + { + uint32_t l_res = rcTestGetErrorInfo(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode11. Fail l_res=%d", l_res); + } + } + + + /** + * @brief Test FAPI2 return codes #12 + */ + void testFapi2ReturnCode12() + { + uint32_t l_res = rcTestErrorInfo(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode12. Fail l_res=%d", l_res); + } + } + + /** + * @brief Test FAPI2 return codes #13 + */ + void testFapi2ReturnCode13() + { + uint32_t l_res = rcTestCopyConstructorwithErrorInfo(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode13. Fail l_res=%d", l_res); + } + return; + } + + /** + * @brief Test FAPI2 return codes #14 + */ + void testFapi2ReturnCode14() + { + uint32_t l_res = rcTestAssignmentOperatorwithErrorInfo(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode14. Fail l_res=%d", l_res); + } + return; + } + + /** + * @brief Test FAPI2 return codes #15 + */ + void testFapi2ReturnCode15() + { + uint32_t l_res = rcTestClearErrorInfo(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode15. Fail l_res=%d", l_res); + } + return; + } + + /** + * @brief Test FAPI2 return codes #16 + */ + void testFapi2ReturnCode16() + { + uint32_t l_res = rcTestAddErrorInfo(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode16. Fail l_res=%d", l_res); + } + return; + } + + /** + * @brief Test FAPI2 return codes #17 + */ + void testFapi2ReturnCode17() + { + uint32_t l_res = rcTestStaticCast(); + + if (l_res != 0) + { + TS_FAIL("testFapi2ReturnCode17. Fail l_res=%d", l_res); + } + return; + } +}; + +#endif -- cgit v1.2.1