diff options
Diffstat (limited to 'src/usr/i2c/test/eepromddtest.H')
-rwxr-xr-x | src/usr/i2c/test/eepromddtest.H | 417 |
1 files changed, 330 insertions, 87 deletions
diff --git a/src/usr/i2c/test/eepromddtest.H b/src/usr/i2c/test/eepromddtest.H index 48b6329cc..d8e0fef9f 100755 --- a/src/usr/i2c/test/eepromddtest.H +++ b/src/usr/i2c/test/eepromddtest.H @@ -28,14 +28,15 @@ * * @brief Test cases for the eeprom dd code */ -#include <sys/time.h> +#include <sys/time.h> #include <cxxtest/TestSuite.H> #include <errl/errlmanager.H> #include <errl/errlentry.H> #include <devicefw/driverif.H> #include <i2c/eepromddreasoncodes.H> #include <targeting/common/commontargeting.H> +#include <pnor/pnorif.H> #include "i2ctest.H" #include "../eepromdd.H" @@ -47,7 +48,6 @@ using namespace TARGETING; using namespace EEPROM; - class EEPROMTest: public CxxTest::TestSuite { public: @@ -63,10 +63,6 @@ class EEPROMTest: public CxxTest::TestSuite int fails = 0; int num_ops = 0; - uint8_t* testBuffer = NULL; - uint8_t* testBuffer_read = NULL; - - TRACFCOMP( g_trac_eeprom, "testEEPROMReadWrite - Start" ); @@ -151,8 +147,8 @@ class EEPROMTest: public CxxTest::TestSuite for( uint32_t j = 0; j < fullList.size(); j++ ) { // Skip this target if EEPROM isn't available. or if non functional - if( !isI2CAvailable( fullList[j] ) || - !fullList[j]->getAttr<TARGETING::ATTR_HWAS_STATE>().functional) + if( !fullList[j]->getAttr<TARGETING::ATTR_HWAS_STATE>()\ + .functional) { continue; } @@ -208,93 +204,256 @@ class EEPROMTest: public CxxTest::TestSuite } } - // Test EEPROM Write of large size - // @todo RTC:69113 - will clean this up: - // 1) Make its own testcase function - // 2) Will use a larger data set: Plan on using 4K header of - // test_signed_container and putting it into un-used area of - // SBE_BACKUP - // 3) Will restore original data just in case - uint64_t testBufLen = 0xF1; - testBuffer = static_cast<uint8_t*>(malloc(testBufLen)); - memset(testBuffer, 0xFE, testBufLen); - - // Randomize the Data a bit - for (uint64_t i = 0; - i < ((testBufLen / 8) + 1); - i++) - testBuffer[i*8] = i; - - for (uint64_t k = 0; k < 8; k++) - testBuffer[k] = k; - - // do the Write operation - err = deviceOp( DeviceFW::WRITE, - fullList[0], - testBuffer, - testBufLen, - DEVICE_EEPROM_ADDRESS(SBE_BACKUP,0x0)); - if( err ) - { - TS_FAIL( "testEEPROMReadWrite - FAIL on large Data Write"); - errlCommit( err, - EEPROM_COMP_ID ); - delete err; - break; - } + } while( 0 ); - // Read Back and Compare - testBuffer_read = static_cast<uint8_t*>(malloc( testBufLen )); + TRACFCOMP( g_trac_eeprom, + "testEEPROMReadWrite - End: %d/%d fails", + fails, num_ops ); + } - // clear read buffer - memset (testBuffer_read, 0, testBufLen); - // do the Read operation - err = deviceOp( DeviceFW::READ, - fullList[0], - testBuffer_read, - testBufLen, - DEVICE_EEPROM_ADDRESS(SBE_BACKUP,0x0)); + /** + * @brief EEPROM Read/Write Large Test + * This test will read and write 1KB of data to SBE Backup + * VPD. It will attempt to restore the original data at + * the end of the test. + * + * Note: 1st 1K of SBE EEPROM data is currently blank, so this + * test will read and write to that address space + */ + void testEEPROMReadWriteLarge ( void ) + { + errlHndl_t err = NULL; + int fails = 0; + int num_ops = 0; + int cmds = 0; + + // Create 1KB buffers + size_t testBufLen = 1024; + uint8_t testBuffer[testBufLen]; + uint8_t new_data[testBufLen]; + uint8_t original_data[testBufLen]; + + + TRACFCOMP( g_trac_eeprom, + "testEEPROMReadWriteLarge - Start" ); + + // Skipping EEPROM test altogether in VBU/VPO environment + if( TARGETING::is_vpo() ) + { + return; + } + + do + { + // Get a processor Target + TARGETING::TargetService& l_targetService = + TARGETING::targetService(); + TARGETING::Target* testTarget = NULL; + l_targetService.masterProcChipTargetHandle( testTarget ); + assert(testTarget != NULL); + TargetHandleList fullList; + fullList.push_back( testTarget ); + + // 5 operations of 1K data per target (details below) + const uint32_t NUM_CMDS = 5; + + // Number of total operations + num_ops = fullList.size() * NUM_CMDS; + + /************************************************************/ + /* Using PNOR to return the extended image to use as new_data */ + /**************************************************************/ + // Jumping 32K into extended image for more dense data + static const uint64_t HEADER_OFFSET = 0x8000; + PNOR::SectionInfo_t pnorSectionInfo; - if( err ) + err = PNOR::getSectionInfo(PNOR::HB_EXT_CODE, + PNOR::CURRENT_SIDE, + pnorSectionInfo); + + if ( err || + (pnorSectionInfo.size < HEADER_OFFSET + testBufLen) + ) { - TS_FAIL( "testEEPROMReadWrite - FAIL on large Data Read"); - errlCommit( err, - EEPROM_COMP_ID ); + TS_FAIL("testEEPROMReadWriteLarge: PNOR::getSectionInfo failed or size too small: pnorSize=0x%X, HEADER_OFFSET=0x%X, testBufLen = 0x%X", pnorSectionInfo.size, HEADER_OFFSET, testBufLen); + errlCommit(err, EEPROM_COMP_ID); delete err; + fails++; break; } - // Compare the data - if ( memcmp( testBuffer, testBuffer_read, testBufLen) ) + void* tmp_ptr = reinterpret_cast<void*>(pnorSectionInfo.vaddr + + HEADER_OFFSET); + + if (tmp_ptr == NULL) { - TS_FAIL( "testEEPROMReadWrite - MISCOMPARE on large Data"); + TS_FAIL("testEEPROMReadWriteLarge: Couldn't get tmp_ptr for new data"); + errlCommit(err, EEPROM_COMP_ID); + delete err; + fails++; break; + } - else + + // Valid Buffer, so memcpy the first 1KB + memcpy( new_data, tmp_ptr, testBufLen ); + + + /************************************************************/ + /* Loop through targets and perform operations */ + /************************************************************/ + + for( uint32_t i = 0; i < fullList.size(); i++ ) { - TRACUCOMP( g_trac_eeprom, "testEEPROMReadWrite - large " - "Data R/W Successful"); - } + // Skip this target if EEPROM isn't available + // or if non functional + if( !fullList[i]->getAttr<TARGETING::ATTR_HWAS_STATE>()\ + .functional) + { + continue; + } - } while( 0 ); - // Clean up malloc'ed buffers - if ( testBuffer != NULL) - { - free(testBuffer); - } + // Before starting, clear original data buffer + memset(original_data, 0x0, testBufLen); - if ( testBuffer_read != NULL) - { - free(testBuffer_read); - } + for (uint8_t j = 1; j <= NUM_CMDS; j++) + { + + // Details: 5 operations of 1K data per target + // 1) Read Original Data and Save It + // 2) Write New Data + // 3) Read New Data and Compare + // 4) Write Back Original Data + // 5) Read Back Original Data and Compare + + // Clear data buffer before reads + if ( (j == 1) || (j == 3) || (j == 5) ) + { + memset(testBuffer, 0x0, testBufLen); + } + + // For Loop 2: set data to new data + if ( j == 2 ) + { + memcpy(testBuffer, new_data, testBufLen); + } + // For Loop 4: set data to original_data + if ( j == 4 ) + { + memcpy(testBuffer, original_data, testBufLen); + } + + // increment cmd op counter + cmds++; + + // do the Operation + err = deviceOp( + (j%2) ? DeviceFW::READ : DeviceFW::WRITE, + fullList[0], + testBuffer, + testBufLen, + DEVICE_EEPROM_ADDRESS(SBE_BACKUP,0x0)); + + if( err ) + { + TS_FAIL( "testEEPROMReadWriteLarge = OP %d FAILED " + "- cmd %d out of %d", + j, i, NUM_CMDS ); + errlCommit( err, + EEPROM_COMP_ID ); + delete err; + fails++; + continue; + } + + + // Handle loop-specific results + + // For Loop 1: save original data + if ( j == 1 ) + { + memcpy(original_data, testBuffer, testBufLen); + + TRACUCOMP(g_trac_eeprom,"testEEPROMReadWriteLarge:" + " saving original data. i=%d, j=%d", + i, j); + } + + // For Loop 3: compare new data + if ( j == 3 ) + { + // Compare the data + if ( memcmp(testBuffer, new_data, testBufLen) ) + { + TRACFCOMP(g_trac_eeprom, + "testEEPROMReadWriteLarge: MISCOMPARE" + " of new data, len=0x%X", testBufLen); + + TRACFBIN( g_trac_eeprom, "testBuffer=", + testBuffer, testBufLen); + TRACFBIN( g_trac_eeprom, "new_data=", + new_data, testBufLen); + TS_FAIL( "testEEPROMReadWriteLarge - MISCOMPARE" + " on writing new data"); + fails++; + + // Don't break - try to write back original data + continue; + } + else + { + TRACUCOMP(g_trac_eeprom, + "testEEPROMReadWriteLarge: New " + "Data R/W Successful i=%d,j=%d", + i, j); + } + } + + + // For Loop 5: compare writing-back original data + if ( j == 5 ) + { + // Compare the data + if ( memcmp(testBuffer, original_data, testBufLen) ) + { + TRACFCOMP(g_trac_eeprom, + "testEEPROMReadWriteLarge: MISCOMPARE" + " of original data, len=0x%X", + testBufLen); + + TRACFBIN( g_trac_eeprom, "testBuffer=", + testBuffer, testBufLen); + TRACFBIN( g_trac_eeprom, "orig_data=", + original_data, testBufLen); + + TS_FAIL( "testEEPROMReadWriteLarge - MISCOMPARE" + " on writing back original data"); + fails++; + + break; + } + else + { + TRACUCOMP(g_trac_eeprom, + "testEEPROMReadWriteLarge: Original " + "Data R/W Successful i=%d,j=%d", + i, j); + } + } + + } // end of 'j' loop: 5 ops per target + + } // end of 'i' loop: target loop + + } while( 0 ); TRACFCOMP( g_trac_eeprom, - "testEEPROMReadWrite - %d/%d fails", + "testEEPROMReadWriteLarge - End: %d/%d fails", fails, num_ops ); } @@ -310,6 +469,9 @@ class EEPROMTest: public CxxTest::TestSuite uint64_t data = 0x0ull; size_t dataSize = 8; + TRACFCOMP( g_trac_eeprom, + "testEEPROMInvalidOperation - Start" ); + do { // Get a processor Target @@ -318,10 +480,9 @@ class EEPROMTest: public CxxTest::TestSuite tS.masterProcChipTargetHandle( testTarget ); assert(testTarget != NULL); - // Skip this target if EEPROM isn't available or target is non - // functional - if( !isI2CAvailable( testTarget ) || - !testTarget->getAttr<TARGETING::ATTR_HWAS_STATE>().functional) + // Skip this target if target is non-functional + if(!testTarget->getAttr<TARGETING::ATTR_HWAS_STATE>().\ + functional) { continue; } @@ -337,23 +498,96 @@ class EEPROMTest: public CxxTest::TestSuite if( NULL == err ) { fails++; - TS_FAIL( "Error should've resulted in Operation type of LAST_OP_TYPE!" ); + TS_FAIL( "testEEPROMInvalidOperation - Error should've " + " resulted in Operation type of LAST_OP_TYPE!" ); } else { + TRACUCOMP(g_trac_eeprom, "testEEPROMInvalidOperation - " + "Error log returned as expected. RC=0x%X", + err->reasonCode() ); delete err; err = NULL; } } while( 0 ); TRACFCOMP( g_trac_eeprom, - "testEEPROMInvalidOperation - %d/%d fails", + "testEEPROMInvalidOperation - End: %d/%d fails", fails, num_ops ); } + + /** + * @brief EEPROM Overflow Test + * This test will pass in a target which does not have an + * EEPROM attribute associated with it. It is expected that i + * an error log is to be returned. + */ + void testEEPROMOverflow ( void ) + { + errlHndl_t err = NULL; + int64_t fails = 0, num_ops = 0; + uint64_t data = 0x0ull; + size_t dataSize = 0; + uint64_t offset = 0x0ull; + + TRACFCOMP( g_trac_eeprom, + "testEEPROMOverflow - Start" ); + + do + { + // Get a processor Target + TARGETING::TargetService& tS = TARGETING::targetService(); + TARGETING::Target* testTarget = NULL; + tS.masterProcChipTargetHandle( testTarget ); + assert(testTarget != NULL); + + // Skip this target if target is non-functional + if(!testTarget->getAttr<TARGETING::ATTR_HWAS_STATE>() + .functional) + { + continue; + } + + // Set max length and offset + dataSize = 0xFFFFFFFFFFFFFFFF; + offset = 0xFFFFFFFFFFFFFFFF; + + num_ops++; + err = deviceOp( DeviceFW::WRITE, + testTarget, + &data, + dataSize, + DEVICE_EEPROM_ADDRESS( 0x0, + offset ) ); + + if( NULL == err ) + { + fails++; + TS_FAIL( "testEEPROMOverflow - Error should've " + "resulted from overflow offset and length: " + "offset=0x%X, length = 0x%x", + offset, dataSize); + } + else + { + TRACUCOMP(g_trac_eeprom, "testEEPROMOverflow - " + "Error log returned as expectede. RC=0x%X", + err->reasonCode() ); + delete err; + err = NULL; + } + } while( 0 ); + + TRACFCOMP( g_trac_eeprom, + "testEEPROMInvalidChip - End: %d/%d fails", + fails, num_ops ); + } + + /** * @brief EEPROM Invalid Chip Test * This test will pass in an invalid chip identifier which should - * result in an error being returned back from + * result in an error being returned. */ void testEEPROMInvalidChip ( void ) { @@ -362,19 +596,21 @@ class EEPROMTest: public CxxTest::TestSuite uint64_t data = 0x0ull; size_t dataSize = 8; + TRACFCOMP( g_trac_eeprom, + "testEEPROMInvalidChip - Start" ); do { + // Get a processor Target TARGETING::TargetService& tS = TARGETING::targetService(); TARGETING::Target* testTarget = NULL; tS.masterProcChipTargetHandle( testTarget ); assert(testTarget != NULL); - // Skip this target if EEPROM isn't available. or target is non - // functional - if( !isI2CAvailable( testTarget ) || - !testTarget->getAttr<TARGETING::ATTR_HWAS_STATE>().functional) + // Skip this target if target is non-functional + if(!testTarget->getAttr<TARGETING::ATTR_HWAS_STATE>() + .functional) { continue; } @@ -390,21 +626,28 @@ class EEPROMTest: public CxxTest::TestSuite if( NULL == err ) { fails++; - TS_FAIL( "Error should've resulted in using EEPROM chip %d!", + TS_FAIL( "testEEPROMInvalidChip - Error should've " + "resulted in using EEPROM chip %d!", LAST_CHIP_TYPE ); } else { + TRACUCOMP(g_trac_eeprom, "testEEPROMInvalidChip - " + "Error log returned as expected. RC=0x%x ", + err->reasonCode() ); delete err; err = NULL; } + } while( 0 ); TRACFCOMP( g_trac_eeprom, - "testEEPROMInvalidChip - %d/%d fails", + "testEEPROMInvalidChip - End: %d/%d fails", fails, num_ops ); } + + }; #endif |