Skip to content

Commit

Permalink
Fix fapi spd testcases
Browse files Browse the repository at this point in the history 
Fixed a few places where the Axone path was getting skipped
incorrectly, then fixed the resulting latent errors.

Change-Id: I917b9a0b6f4ff1491ff384dc924e29f688548873
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/85688
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Reviewed-by: Zachary Clark <zach@ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Christian R Geddes <crgeddes@us.ibm.com>
Reviewed-by: William G Hoffa <wghoffa@us.ibm.com>
  • Loading branch information
@dcrowell77 @wghoffa
dcrowell77 authored and wghoffa committed Nov 6, 2019
1 parent a501159 commit 9c7a264
Show file tree
Hide file tree
Showing 2 changed files with 123 additions and 170 deletions.
3 changes: 2 additions & 1 deletion src/usr/fapi2/test/fapi2DdimmGetEfdTest.C
View file
Expand Up @@ -111,7 +111,8 @@ fapi2DdimmGetEfdTest::fapi2DdimmGetEfdTest()
{
FAPI_INF(">> fapi2DdimmGetEfdTest");

if(TARGETING::MODEL_AXONE != TARGETING::targetService().getProcessorModel())
iv_attrModel = TARGETING::targetService().getProcessorModel();
if(TARGETING::MODEL_AXONE != iv_attrModel)
{
FAPI_INF("<< fapi2DdimmGetEfdTest: This is not AXONE. "
"Skipping AXONE tests.");
Expand Down
290 changes: 121 additions & 169 deletions src/usr/fapi2/test/fapi2SpdTestCxx.H
View file
Expand Up @@ -53,175 +53,127 @@ class SPDTest: public CxxTest::TestSuite
{
public:

/**
* @brief Test SPD get Interface DIMMs.
*/
void testGetSPD ( void )
{
fapi2::ReturnCode l_rc;
size_t l_size = 0;
uint8_t * l_blobData = NULL;

FAPI_INF( "testGetSPD - Enter" );

do
{
TARGETING::Target * i_pTarget = NULL;

// Get DIMM Targets
TargetHandleList dimmList;
getDIMMTargets( dimmList );

// Should get atleast one
if( ( 0 == dimmList.size() ) ||
( NULL == dimmList[0] ) )
{
FAPI_INF( "testGetSPD- No DIMMs found!");
break;
}

// Work on the first DIMM target
i_pTarget = dimmList[0];

// convert to fapi2 target
fapi2::Target<fapi2::TARGET_TYPE_DIMM> fapi2_Target(i_pTarget);

// SPD interface call with NULL blob to get size data
l_rc = fapi2::getSPD(fapi2_Target, NULL, l_size);

// Expect to return the size or non failure
if( !l_size || (l_rc != fapi2::FAPI2_RC_SUCCESS) )
{
TS_FAIL("testGetSPD: Failed getting the size of the mem buffer");
break;
}

// allocate the blob data of mem size length to hold data
l_blobData = reinterpret_cast<uint8_t *>(malloc(l_size));
memset(l_blobData,0,l_size);

l_rc = fapi2::getSPD(fapi2_Target,l_blobData, l_size);
if ( l_rc != fapi2::FAPI2_RC_SUCCESS )
{
TS_FAIL( "testGetSPD- Failed to read data from DIMM with HUID= 0x%x",
TARGETING::get_huid(i_pTarget));
break;
}

uint8_t l_memModule = 0x0;
size_t l_memSize = sizeof(uint8_t);

auto l_errl = deviceRead(i_pTarget,
(void *)&l_memModule,
l_memSize,
DEVICE_SPD_ADDRESS(SPD::MODULE_TYPE));

if ( l_errl )
{
TS_FAIL( "testGetSPD- Failed to deviceRead with HUID= 0x%x",
TARGETING::get_huid(i_pTarget));
break;
}

uint8_t l_memGen = 0x0;
l_errl = deviceRead(i_pTarget,
(void *)&l_memGen,
l_memSize,
DEVICE_SPD_ADDRESS(SPD::BASIC_MEMORY_TYPE));

if ( l_errl )
{
TS_FAIL( "testGetSPD- Failed to deviceRead with HUID= 0x%x",
TARGETING::get_huid(i_pTarget));
break;
}

auto l_chipModel = i_pTarget->getAttr<TARGETING::ATTR_MODEL>();

if( l_chipModel == TARGETING::MODEL_AXONE )
{
// Assumes Axone is strictly DDR4, so not taking into
// account DDR3 or any other DRAM generation
if( l_memModule == SPD::MEM_DDIMM )
{
if ( l_size != SPD::DDIMM_DDR4_SPD_SIZE )
{
TS_FAIL( "testGetSPD- expected size %d != actual size %d with HUID= 0x%x",
SPD::DDIMM_DDR4_SPD_SIZE,
l_size,
TARGETING::get_huid(i_pTarget));
break;
}
}
else
{
if ( l_size != SPD::DDR4_SPD_SIZE )
{
TS_FAIL( "testGetSPD- expected size %d != actual size %d with HUID= 0x%x",
SPD::DDR4_SPD_SIZE,
l_size,
TARGETING::get_huid(i_pTarget));
break;
}
}
}
else if ( l_chipModel == TARGETING::MODEL_NIMBUS )
{
// Nimbus only suppported DDR4 and SPD size was
// DIMM BASE_MODULE_TYPE agnostic.
if ( l_size != SPD::DDR4_SPD_SIZE )
{
TS_FAIL( "testGetSPD- expected size %d != actual size %d with HUID= 0x%x",
SPD::DDR4_SPD_SIZE,
l_size,
TARGETING::get_huid(i_pTarget));
break;
}
}
else if( l_chipModel == TARGETING::MODEL_CUMULUS )
{
// BASE_MODULE_TYPE (RDIMM, LRDIMM, etc) isn't being
// taken into account because the SPD size isn't dependent
// on it for Cumulus.
if( l_memGen == SPD::MEM_DDR4 )
{
if ( l_size != SPD::DDR4_SPD_SIZE )
{
TS_FAIL( "testGetSPD- expected size %d != actual size %d with HUID= 0x%x",
SPD::DDR4_SPD_SIZE,
l_size,
TARGETING::get_huid(i_pTarget));
break;
}
}
else
{
if ( l_size != SPD::DDR3_SPD_SIZE )
{
TS_FAIL( "testGetSPD- expected size %d != actual size %d with HUID= 0x%x",
SPD::DDR3_SPD_SIZE,
l_size,
TARGETING::get_huid(i_pTarget));
break;
}
}
}

FAPI_DBG("getSPD: SPD data for DIMM with HUID=0x%.8X Size %d Blob %d",
TARGETING::get_huid(i_pTarget),
l_size,
l_blobData);

} while(0);

if( NULL != l_blobData )
{
free( l_blobData );
l_blobData = NULL;
}

FAPI_INF( "testGetSPD - Exit" );
}
/**
* @brief Test SPD get Interface DIMMs.
*/
void testGetSPD ( void )
{
fapi2::ReturnCode l_rc;
size_t l_spdSize = 0;
uint8_t * l_blobData = NULL;

FAPI_INF( "testGetSPD - Enter" );

// Get DIMM Targets
TargetHandleList dimmList;
getDIMMTargets( dimmList );

// Should get atleast one
if( ( 0 == dimmList.size() ) ||
( NULL == dimmList[0] ) )
{
TS_FAIL( "testGetSPD- No DIMMs found!");
}

for( auto l_tDimm : dimmList )
{

// convert to fapi2 target
fapi2::Target<fapi2::TARGET_TYPE_DIMM> l_fDimm(l_tDimm);

// SPD interface call with NULL blob to get size data
l_rc = fapi2::getSPD(l_fDimm, NULL, l_spdSize);

// Expect to return the size or non failure
if( !l_spdSize || (l_rc != fapi2::FAPI2_RC_SUCCESS) )
{
TS_FAIL("testGetSPD: Failed getting the size of the mem buffer - Dimm %.8X", TARGETING::get_huid(l_tDimm));
continue;
}

// allocate the blob data of mem size length to hold data
l_blobData = reinterpret_cast<uint8_t *>(malloc(l_spdSize));
memset(l_blobData,0,l_spdSize);

l_rc = fapi2::getSPD(l_fDimm,l_blobData, l_spdSize);
if ( l_rc != fapi2::FAPI2_RC_SUCCESS )
{
TS_FAIL( "testGetSPD- Failed to read data from DIMM with HUID= 0x%x",
TARGETING::get_huid(l_tDimm));
continue;
}

uint8_t l_memModule = 0x0;
size_t l_memSize = sizeof(uint8_t);

auto l_errl = deviceRead(l_tDimm,
(void *)&l_memModule,
l_memSize,
DEVICE_SPD_ADDRESS(SPD::MODULE_TYPE));

if ( l_errl )
{
TS_FAIL( "testGetSPD- Failed to deviceRead with HUID= 0x%x",
TARGETING::get_huid(l_tDimm));
continue;
}

uint8_t l_memGen = 0x0;
l_errl = deviceRead(l_tDimm,
(void *)&l_memGen,
l_memSize,
DEVICE_SPD_ADDRESS(SPD::BASIC_MEMORY_TYPE));

if ( l_errl )
{
TS_FAIL( "testGetSPD- Failed to deviceRead with HUID= 0x%x",
TARGETING::get_huid(l_tDimm));
continue;
}

// figure out the expected size based on the memory type
size_t l_compareSize = 0;
if( (l_memModule == SPD::MEM_DDIMM) && (l_memGen == SPD::MEM_DDR4) )
{
l_compareSize = SPD::OCMB_SPD_EFD_COMBINED_SIZE;
}
else if( (l_memModule != SPD::MEM_DDIMM) && (l_memGen == SPD::MEM_DDR4) )
{
l_compareSize = SPD::DDR4_SPD_SIZE;
}
else if( l_memGen == SPD::MEM_DDR3 )
{
l_compareSize = SPD::DDR3_SPD_SIZE;
}
else
{
TS_FAIL( "testGetSPD - Unknown memory type for %.8X : module=0x%X, gen=0x%X",
TARGETING::get_huid(l_tDimm), l_memModule, l_memGen );
continue;
}

if( l_compareSize != l_spdSize )
{
TS_FAIL( "testGetSPD - Wrong SPD size for %.8X : module=0x%X, gen=0x%X, exp=%d, act=%d",
TARGETING::get_huid(l_tDimm), l_memModule, l_memGen,
l_compareSize, l_spdSize);
continue;
}

FAPI_DBG("getSPD: SPD data for DIMM with HUID=0x%.8X Size %d Blob %d",
TARGETING::get_huid(l_tDimm),
l_spdSize,
l_blobData);
}

if( NULL != l_blobData )
{
free( l_blobData );
l_blobData = NULL;
}

FAPI_INF( "testGetSPD - Exit" );
}

};

Expand Down

0 comments on commit 9c7a264

Please sign in to comment.