/* IBM_PROLOG_BEGIN_TAG */ /* This is an automatically generated prolog. */ /* */ /* $Source: src/usr/hwpf/test/hwpMvpdAccessorTest.H $ */ /* */ /* OpenPOWER HostBoot Project */ /* */ /* COPYRIGHT International Business Machines Corp. 2012,2014 */ /* */ /* 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 __HWPMVPDACCESSORTEST_H #define __HWPMVPDACCESSORTEST_H // set to 1 for doing unit tests, set to 0 for production #define HWPMVPDACCESSORTEST_UT 0 /** * @file hwpMvpdAccessorTest.H * * @brief Test cases for Mvpd HWP accessors. */ #include #include #include #include #include #include #include #include #include #include #include // pull in CompressedScanData def from proc_slw_build HWP #include using namespace fapi; using namespace TARGETING; class hwpMvpdAccessorTest: public CxxTest::TestSuite { public: /** * @brief call fapiGetMvpdField to fetch a mvpd records. * */ void testGetMvpd() { fapi::ReturnCode l_fapirc( fapi::FAPI_RC_SUCCESS ); uint8_t *l_pdRRecord = NULL; uint32_t l_pdRLen = 0; // list of MVPD records to test. Need to be in PNOR or procmvpd.dat // when g_usePNOR is false. struct _testMvpdRecords { fapi::MvpdRecord record; fapi::MvpdKeyword keyword; } l_mvpdRecords[] = { #if HWPMVPDACCESSORTEST_UT { MVPD_RECORD_CP00, MVPD_KEYWORD_PDG}, { MVPD_RECORD_MER0, MVPD_KEYWORD_PDI}, // { MVPD_RECORD_VER0, MVPD_KEYWORD_PDI}, //VER0 in spec,not supported #endif { MVPD_RECORD_VWML, MVPD_KEYWORD_PDI}, }; TS_TRACE( "testGetMvpd entry" ); TARGETING::TargetHandleList l_cpuTargetList; getAllChips(l_cpuTargetList, TYPE_PROC); TS_TRACE( "testGetMvpd l_cpuTargetList.size()= 0x%x ", l_cpuTargetList.size() ); // loop thru all the cpu's for (TargetHandleList::iterator l_cpu_iter = l_cpuTargetList.begin(); l_cpu_iter != l_cpuTargetList.end(); ++l_cpu_iter) { // make a local copy of the CPU target TARGETING::Target* l_cpu_target = *l_cpu_iter; TS_TRACE( "target HUID %.8X", TARGETING::get_huid(l_cpu_target)); // cast OUR type of target to a FAPI type of target. fapi::Target l_fapi_cpu_target( TARGET_TYPE_PROC_CHIP, (const_cast(l_cpu_target)) ); // loop through mvpd records of interest const uint32_t numRecords = sizeof(l_mvpdRecords)/sizeof(l_mvpdRecords[0]); for (uint8_t i=0;i(malloc(l_pdRLen) ); // call fapiGetMvpdField once with a valid pointer l_fapirc = fapiGetMvpdField(l_mvpdRecords[i].record, l_mvpdRecords[i].keyword, l_fapi_cpu_target, l_pdRRecord, l_pdRLen ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { TS_FAIL( "fapiGetMvpdField: expected FAPI_RC_SUCCESS" ); fapiLogError(l_fapirc); free( l_pdRRecord ); return; } // clean up memory free( l_pdRRecord ); } } TS_TRACE( "testGetMvpd exit" ); } // Structure used to save/restore the VPD typedef struct saveRestoreData_t { TARGETING::Target* target; uint8_t* CP00_pdG; size_t CP00_pdG_size; uint8_t* CP00_pdR; size_t CP00_pdR_size; } saveRestoreData_t; /** * @brief Test get and set of Repair Rings */ void testRepairRings() { fapi::ReturnCode l_fapirc = fapi::FAPI_RC_SUCCESS; uint8_t *l_pRingBuf = NULL; uint32_t l_ringBufsize = 0; uint32_t l_ringId = 0; uint32_t l_chipletId = 0; uint32_t l_bufsize = 0x200; errlHndl_t l_errhdl = NULL; // This data needs to be in sync with the procmvpd.dat file // the setMvpdFunc tests use the last row. The test // expects it to be a mid x20 byte ring in the #G keyword struct _testRRstr { fapi::MvpdKeyword keyword; uint32_t ringIdval; uint32_t chipletIdval; uint32_t size; uint32_t rc; } l_ringModifiers[] = { { MVPD_KEYWORD_PDG, 0xa4, 0xFF, 0x20, //last #G fapi::RC_REPAIR_RING_NOT_FOUND }, { MVPD_KEYWORD_PDR, 0xe0, 0x08, 0x20, //first #R FAPI_RC_SUCCESS }, { MVPD_KEYWORD_PDR, 0xe2, 0x16, 0x20, //big #R FAPI_RC_SUCCESS }, { MVPD_KEYWORD_PDG, 0xa2, 0x08, 0x20, //mid #G FAPI_RC_SUCCESS }, { MVPD_KEYWORD_PDR, 0xe1, 0x16, 0x20,//big #R FAPI_RC_SUCCESS }, }; const size_t VALID_INDEX = 2; const size_t TEST_INDEX = 4; TS_TRACE( "testRepairRings entry" ); std::list l_srData; TARGETING::TargetHandleList l_cpuTargetList; getAllChips(l_cpuTargetList, TYPE_PROC); // loop thru all the cpu's for (TargetHandleList::iterator l_cpu_iter = l_cpuTargetList.begin(); l_cpu_iter != l_cpuTargetList.end(); ++l_cpu_iter) { // make a local copy of the CPU target TARGETING::Target* l_cpu_target = *l_cpu_iter; TS_TRACE( "testRepairRings: " "target HUID %.8X", TARGETING::get_huid(l_cpu_target)); //-- Save the entire VPD record to restore later saveRestoreData_t tmpsave; tmpsave.target = l_cpu_target; // do a read with NULL buffer to get the record size l_errhdl = deviceRead( l_cpu_target, NULL, tmpsave.CP00_pdG_size, DEVICE_MVPD_ADDRESS( MVPD_RECORD_CP00, MVPD_KEYWORD_PDG ) ); if( l_errhdl ) { TS_FAIL("Error finding size of CP00/#G for %.8X", TARGETING::get_huid(l_cpu_target)); errlCommit( l_errhdl, VPD_COMP_ID ); continue; } // now go get the data tmpsave.CP00_pdG = new uint8_t[tmpsave.CP00_pdG_size]; l_errhdl = deviceRead( l_cpu_target, tmpsave.CP00_pdG, tmpsave.CP00_pdG_size, DEVICE_MVPD_ADDRESS( MVPD_RECORD_CP00, MVPD_KEYWORD_PDG ) ); if( l_errhdl ) { TS_FAIL("Error reading CP00/#G from %.8X", TARGETING::get_huid(l_cpu_target)); errlCommit( l_errhdl, VPD_COMP_ID ); delete[] tmpsave.CP00_pdG; continue; } // do a read with NULL buffer to get the record size l_errhdl = deviceRead( l_cpu_target, NULL, tmpsave.CP00_pdR_size, DEVICE_MVPD_ADDRESS( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR ) ); if( l_errhdl ) { TS_FAIL("Error finding size of CP00/#R for %.8X", TARGETING::get_huid(l_cpu_target)); errlCommit( l_errhdl, VPD_COMP_ID ); continue; } // now go get the data tmpsave.CP00_pdR = new uint8_t[tmpsave.CP00_pdR_size]; l_errhdl = deviceRead( l_cpu_target, tmpsave.CP00_pdR, tmpsave.CP00_pdR_size, DEVICE_MVPD_ADDRESS( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR ) ); if( l_errhdl ) { TS_FAIL("Error reading CP00/#R from %.8X", TARGETING::get_huid(l_cpu_target)); errlCommit( l_errhdl, VPD_COMP_ID ); delete[] tmpsave.CP00_pdR; continue; } // add to the master list l_srData.push_back(tmpsave); // cast OUR type of target to a FAPI type of target. fapi::Target l_fapi_cpu_target( TARGET_TYPE_PROC_CHIP, (const_cast(l_cpu_target)) ); // allocate some space to put the record(s) if( l_pRingBuf != NULL ) { delete[] l_pRingBuf; } l_pRingBuf = new uint8_t[l_bufsize]; // ---------------------------------------------------------------- // Pass in 0 for the ring modifier, should return with "not found" // error // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: pass in invalid ringId" ); l_ringBufsize = l_bufsize; l_ringId = 0; // ringId l_chipletId = 0; // chipletId l_fapirc = getMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); TS_TRACE("testRepairRings:ringId=0x%x chipletId=0x%x Bufsize=0x%x", l_ringId, l_chipletId, l_ringBufsize ); if ( l_fapirc != fapi::RC_REPAIR_RING_NOT_FOUND ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL("testRepairRings: expect not found rc FAIL: 0x%x, 0x%x", fapi::RC_REPAIR_RING_NOT_FOUND, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // Pass in a buffer size that is too small with a valid // ringId/chipletId, should return error with correct length // and invalid size return code.. // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: pass buffer too small %d ", VALID_INDEX ); l_ringBufsize = 0x0; l_ringId = l_ringModifiers[VALID_INDEX].ringIdval; l_chipletId = l_ringModifiers[VALID_INDEX].chipletIdval; l_fapirc = getMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); TS_TRACE("testRepairRings:ringId=0x%x chipletId=0x%x: Bufsize=0x%x", l_ringId, l_chipletId, l_ringBufsize ); if ( l_fapirc != fapi::RC_REPAIR_RING_INVALID_SIZE ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL("testRepairRings: expect invalid size FAIL: exp=0x%x," " act=0x%x, ring=0x%X", fapi::RC_REPAIR_RING_INVALID_SIZE, static_cast(l_fapirc), l_ringId); fapiLogError(l_fapirc); } else if ( l_ringBufsize != l_ringModifiers[VALID_INDEX].size ) { TS_FAIL( "testRepairRings: size mismatch FAIL1 on ring 0x%X:" " exp=0x%x, act=0x%x", l_ringId, l_ringModifiers[VALID_INDEX].size, l_ringBufsize ); } // ---------------------------------------------------------------- // Pass in a NULL pointer with a valid ringId/chipletId, should // return with correct length and successful return code. // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: get size of ring %d ", VALID_INDEX ); l_ringBufsize = 0x0; l_ringId = l_ringModifiers[VALID_INDEX].ringIdval; l_chipletId = l_ringModifiers[VALID_INDEX].chipletIdval; l_fapirc = getMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, NULL, l_ringBufsize ); TS_TRACE("testRepairRings:ringId=0x%x chipletId=0x%x: Bufsize=0x%x", l_ringId, l_chipletId, l_ringBufsize ); if ( l_fapirc ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: expect success rc FAIL: 0x%x, 0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc)); fapiLogError(l_fapirc); } else if ( l_ringBufsize != l_ringModifiers[VALID_INDEX].size ) { TS_FAIL( "testRepairRings: size mismatch FAIL2 on ring 0x%X:" " exp=0x%x, act=0x%x", l_ringId, l_ringModifiers[VALID_INDEX].size, l_ringBufsize ); } // ---------------------------------------------------------------- // Fetch rings // ---------------------------------------------------------------- const uint32_t numRings = sizeof(l_ringModifiers)/sizeof(l_ringModifiers[0]); for (size_t i=0;i(l_fapirc), l_ringId, l_chipletId, i ); fapiLogError(l_fapirc); continue; } else if( l_fapirc != fapi::FAPI_RC_SUCCESS ) { // not an error, but the next check isn't valid continue; } if ( l_ringBufsize != l_ringModifiers[i].size ) { TS_FAIL( "testRepairRings: size mismatch FAIL3 on ring %X:" " exp=0x%x, act=0x%x", l_ringId, l_ringModifiers[i].size, l_ringBufsize ); } // Dump ring buffer here. TRACDBIN(g_trac_test,"testRepairRings:Dump Repair Ring Buffer:", l_pRingBuf, l_ringBufsize ); } // ---------------------------------------------------------------- // write different data, read it back to verify, then put the // original data back. // ---------------------------------------------------------------- uint32_t l_offset =0; uint8_t l_data = 0; uint8_t *l_pData = NULL; // use data from last fetch test case. TS_TRACE( "testRepairRings: update in place ring %d", TEST_INDEX ); l_ringId = l_ringModifiers[TEST_INDEX].ringIdval; l_chipletId = l_ringModifiers[TEST_INDEX].chipletIdval; l_ringBufsize = l_ringModifiers[TEST_INDEX].size; // put in recognizable data for the debug data dump l_pData = l_pRingBuf+sizeof(CompressedScanData); for (l_offset = 0,l_data=0x10; l_offset < l_ringBufsize-sizeof(CompressedScanData); l_offset++) { *l_pData++ = l_data++; } TRACDBIN( g_trac_test, "testRepairRings: updated ring data:", l_pRingBuf, l_ringBufsize ); setMvpdRing_FP_t (l_setMvpdRing) = &setMvpdRing; //verify typedef l_fapirc = (*l_setMvpdRing)( MVPD_RECORD_CP00, l_ringModifiers[TEST_INDEX].keyword, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: setMvpdRing rc FAIL 1: exp=0x%x," " rc=0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // write back a smaller ring to cause a shift left in the record // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: shrink a ring %d", TEST_INDEX ); l_ringBufsize = l_ringModifiers[TEST_INDEX].size-4; reinterpret_cast(l_pRingBuf)-> iv_size = l_ringBufsize; // put in recognizable data for the debug data dump l_pData = l_pRingBuf+sizeof(CompressedScanData); for (l_offset = 0,l_data=0x20; l_offset < l_ringBufsize-sizeof(CompressedScanData); l_offset++) { *l_pData++ = l_data++; } TRACDBIN( g_trac_test, "testRepairRings: updated ring data:", l_pRingBuf, l_ringBufsize ); l_fapirc = setMvpdRing( MVPD_RECORD_CP00, l_ringModifiers[TEST_INDEX].keyword, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: setMvpdRing rc FAIL 2:" " exp=0x%x, rc=0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // write back a larger ring to cause a shift right in the record // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: grow a ring %d", TEST_INDEX ); l_ringBufsize = l_ringModifiers[TEST_INDEX].size+16; reinterpret_cast(l_pRingBuf)-> iv_size = l_ringBufsize; // put in recognizable data for the debug data dump l_pData = l_pRingBuf+sizeof(CompressedScanData); for (l_offset = 0,l_data=0x30; l_offset < l_ringBufsize-sizeof(CompressedScanData); l_offset++) { *l_pData++ = l_data++; } TRACDBIN( g_trac_test, "testRepairRings: updated ring data:", l_pRingBuf, l_ringBufsize ); l_fapirc = setMvpdRing( MVPD_RECORD_CP00, l_ringModifiers[TEST_INDEX].keyword, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: setMvpdRing rc FAIL 3: exp=0x%x," " rc=0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // append a ring that is not already there to the end // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: append a ring" ); l_ringId = 0x77; l_chipletId = 0x88; l_ringBufsize = l_ringModifiers[TEST_INDEX].size; reinterpret_cast(l_pRingBuf)-> iv_size = l_ringBufsize; reinterpret_cast(l_pRingBuf)-> iv_ringId = l_ringId; reinterpret_cast(l_pRingBuf)-> iv_chipletId = l_chipletId; // put in recognizable data for the debug data dump l_pData = l_pRingBuf+sizeof(CompressedScanData); for (l_offset = 0,l_data=0x50; l_offset < l_ringBufsize-sizeof(CompressedScanData); l_offset++) { *l_pData++ = l_data++; } TRACDBIN( g_trac_test, "testRepairRings: updated ring data:", l_pRingBuf, l_ringBufsize ); l_fapirc = setMvpdRing( MVPD_RECORD_CP00, l_ringModifiers[TEST_INDEX].keyword, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: setMvpdRing rc FAIL 4: exp=0x%x," " rc=0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } // read back data to prove the writes worked l_ringId = l_ringModifiers[TEST_INDEX].ringIdval; l_chipletId = l_ringModifiers[TEST_INDEX].chipletIdval; l_ringBufsize = l_ringModifiers[TEST_INDEX].size+16; l_fapirc = getMvpdRing( MVPD_RECORD_CP00, l_ringModifiers[TEST_INDEX].keyword, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { TS_FAIL( "testRepairRings: getMvpdRing rc FAIL 2: 0x%x, 0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } else { l_pData = l_pRingBuf+sizeof(CompressedScanData); for( l_offset = 0,l_data=0x30; l_offset < l_ringBufsize-sizeof(CompressedScanData); l_offset++) { if( l_pData[l_offset] != l_data++ ) { TS_FAIL("Mismatch after write on ring %X", l_ringId); TRACFBIN(g_trac_test, "ringdata=", l_pRingBuf,l_ringBufsize); } } } // read back data to prove the writes worked l_ringId = 0x77; l_chipletId = 0x88; l_ringBufsize = l_ringModifiers[TEST_INDEX].size; l_fapirc = getMvpdRing( MVPD_RECORD_CP00, l_ringModifiers[TEST_INDEX].keyword, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::FAPI_RC_SUCCESS ) { TS_FAIL( "testRepairRings: getMvpdRing rc FAIL 3: 0x%x, 0x%x", fapi::FAPI_RC_SUCCESS, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } else { l_pData = l_pRingBuf+sizeof(CompressedScanData); for (l_offset = 0,l_data=0x50; l_offset < l_ringBufsize-sizeof(CompressedScanData); l_offset++) { if( l_pData[l_offset] != l_data++ ) { TS_FAIL("Mismatch after write on ring %X", l_ringId); TRACFBIN(g_trac_test, "ringdata=", l_pRingBuf,l_ringBufsize); } } } // ---------------------------------------------------------------- // Pass in a buffer size that does not match the exact size // of the ringId/chipletId, should return with correct length // and invalid size return code. // ---------------------------------------------------------------- TS_TRACE("testRepairRing:bad size ring=0x%x chiplet=0x%x size=0x%x", l_ringId, l_chipletId, l_ringBufsize ); l_ringBufsize = l_bufsize; l_ringId = l_ringModifiers[TEST_INDEX].ringIdval; l_chipletId = l_ringModifiers[TEST_INDEX].chipletIdval; l_fapirc = setMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::RC_MVPD_RING_FUNC_INVALID_PARAMETER ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL("testRepairRings:invalid ring size rc FAIL:" " exp=0x%x, act=0x%x", fapi::RC_REPAIR_RING_INVALID_SIZE, static_cast(l_fapirc)); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // Pass in 0 for the ring modifier, should return with "not found" // error // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: pass in invalid ringId" ); l_ringBufsize = l_ringModifiers[TEST_INDEX].size; l_ringId = 0; // ringId l_chipletId = 0; // chipletId l_fapirc = setMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); TS_TRACE("testRepairRings:ringId=0x%x chipletId=0x%x size=0x%x", l_ringId, l_chipletId, l_ringBufsize ); if ( l_fapirc != fapi::RC_MVPD_RING_FUNC_INVALID_PARAMETER ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: rc FAIL: exp=0x%x, act=0x%x", fapi::RC_REPAIR_RING_NOT_FOUND, static_cast(l_fapirc) ); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // Pass in a NULL pointer with a valid ringId/chipletId, should // return with correct length and successful return code. // ---------------------------------------------------------------- TS_TRACE( "testRepairRings: get size of ring(from set) %d ", TEST_INDEX ); l_ringBufsize = 0x0; l_ringId = l_ringModifiers[TEST_INDEX].ringIdval; l_chipletId = l_ringModifiers[TEST_INDEX].chipletIdval; l_fapirc = setMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, NULL, l_ringBufsize ); TS_TRACE("testRepairRings:ringId=0x%x chipletId=0x%x size=0x%x", l_ringId, l_chipletId, l_ringBufsize ); if ( l_fapirc != fapi::RC_MVPD_RING_FUNC_INVALID_PARAMETER ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL( "testRepairRings: setMvpdRing rc FAIL 5:" " exp=0x%x, act=0x%x", fapi::RC_MVPD_RING_FUNC_INVALID_PARAMETER, static_cast(l_fapirc)); fapiLogError(l_fapirc); } // ---------------------------------------------------------------- // Pass in an invalid chiplet id with a valid ring, should fail // ---------------------------------------------------------------- l_ringBufsize = l_bufsize; l_ringId = l_ringModifiers[TEST_INDEX].ringIdval; l_chipletId = 0x22; TS_TRACE("testRepairRing:invalid chiplet ring=0x%X chiplet=0x%X" " size=0x%x", l_ringId, l_chipletId, l_ringBufsize ); l_fapirc = getMvpdRing( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR, l_fapi_cpu_target, l_chipletId, l_ringId, l_pRingBuf, l_ringBufsize ); if ( l_fapirc != fapi::RC_REPAIR_RING_NOT_FOUND ) { // note: "uint32_t" below is an _operator_ of fapi::ReturnCode TS_FAIL("testRepairRings:invalid chipletid rc FAIL:" " exp=0x%x, act=0x%x", fapi::RC_REPAIR_RING_NOT_FOUND, static_cast(l_fapirc)); fapiLogError(l_fapirc); } } //-- Put the original data back into the vpd for( std::list::iterator sv = l_srData.begin(); sv != l_srData.end(); ++sv ) { if( sv->target == NULL ) { continue; } if( sv->CP00_pdG != NULL ) { l_errhdl = deviceWrite( sv->target, sv->CP00_pdG, sv->CP00_pdG_size, DEVICE_MVPD_ADDRESS( MVPD_RECORD_CP00, MVPD_KEYWORD_PDG ) ); if( l_errhdl ) { TS_FAIL("Error restoring CP00/#G to %.8X", TARGETING::get_huid(sv->target)); errlCommit( l_errhdl, VPD_COMP_ID ); } delete[] sv->CP00_pdG; sv->CP00_pdG = NULL; } if( sv->CP00_pdR != NULL ) { l_errhdl = deviceWrite( sv->target, sv->CP00_pdR, sv->CP00_pdR_size, DEVICE_MVPD_ADDRESS( MVPD_RECORD_CP00, MVPD_KEYWORD_PDR ) ); if( l_errhdl ) { TS_FAIL("Error restoring CP00/#R to %.8X", TARGETING::get_huid(sv->target)); errlCommit( l_errhdl, VPD_COMP_ID ); } delete[] sv->CP00_pdR; sv->CP00_pdR = NULL; } } //-- // delete allocated space if( l_pRingBuf ) { delete[] l_pRingBuf; } for( std::list::iterator sv = l_srData.begin(); sv != l_srData.end(); ++sv ) { if( sv->CP00_pdG != NULL ) { delete[] sv->CP00_pdG; sv->CP00_pdG = NULL; } if( sv->CP00_pdR != NULL ) { delete[] sv->CP00_pdR; sv->CP00_pdR = NULL; } } TS_TRACE( "testRepairRings exit" ); } }; // end class #endif