diff options
Diffstat (limited to 'src/usr/vpd/spd.C')
-rwxr-xr-x | src/usr/vpd/spd.C | 763 |
1 files changed, 463 insertions, 300 deletions
diff --git a/src/usr/vpd/spd.C b/src/usr/vpd/spd.C index c62bd91f4..a102ed7bd 100755 --- a/src/usr/vpd/spd.C +++ b/src/usr/vpd/spd.C @@ -42,6 +42,7 @@ #include <algorithm> #include "spd.H" #include "spdDDR3.H" +#include "spdDDR4.H" // ---------------------------------------------- // Trace definitions @@ -110,6 +111,22 @@ errlHndl_t getMemType ( uint8_t & o_memType, TARGETING::Target * i_target ); /** + * @brief This function will read the DIMM module type. + * + * @param[out] o_modType - The module type value to return. + * + * @param[in] i_target - The target to read data from. + * + * @param[in] i_memType - The memory type + * + * @return errlHndl_t - NULL if successful, otherwise a pointer + * to the error log. + */ +errlHndl_t getModType ( modSpecTypes_t & o_memType, + TARGETING::Target * i_target, + uint64_t i_memType ); + +/** * @brief This function will scan the table and return the entry * corresponding to the keyword being requested. * @@ -124,7 +141,7 @@ errlHndl_t getMemType ( uint8_t & o_memType, */ errlHndl_t getKeywordEntry ( uint64_t i_keyword, uint64_t i_memType, - KeywordData *& o_entry ); + const KeywordData *& o_entry ); // Register the perform Op with the routing code for DIMMs. @@ -170,14 +187,13 @@ errlHndl_t spdGetKeywordValue ( DeviceFW::OperationType i_opType, INFO_MRK"Mem Type: %04x", memType ); - // Check the Basic Memory Type to be sure its valid before - // continuing. - if( SPD_DDR3 == memType ) + // Check the Basic Memory Type + if(( SPD_DDR3 == memType ) || ( SPD_DDR4 == memType )) { // If the user wanted the Basic memory type, return this now. if( BASIC_MEMORY_TYPE == keyword ) { - io_buflen = MEM_TYPE_ADDR_SZ; + io_buflen = MEM_TYPE_SZ; memcpy( io_buffer, &memType, io_buflen ); break; } @@ -254,8 +270,8 @@ errlHndl_t spdWriteKeywordValue ( DeviceFW::OperationType i_opType, break; } - // Check DDR3 - if( SPD_DDR3 == memType ) + // Check the Basic Memory Type + if(( SPD_DDR3 == memType ) || ( SPD_DDR4 == memType )) { err = spdWriteValue( keyword, io_buffer, @@ -441,7 +457,7 @@ errlHndl_t spdGetValue ( uint64_t i_keyword, do { - KeywordData * entry = NULL; + const KeywordData * entry = NULL; err = getKeywordEntry( i_keyword, i_DDRRev, entry ); @@ -489,19 +505,6 @@ errlHndl_t spdGetValue ( uint64_t i_keyword, break; } - if( entry->isSpecialCase ) - { - // Handle special cases where data isn't sequential - // or is in reverse order from what would be read. - err = spdSpecialCases( (*entry), - io_buffer, - io_buflen, - i_target, - i_DDRRev ); - - break; - } - // Check io_buflen versus size in table err = spdCheckSize( io_buflen, (*entry).length, @@ -512,27 +515,43 @@ errlHndl_t spdGetValue ( uint64_t i_keyword, break; } - // Read length requested - err = spdFetchData( (*entry).offset, - (*entry).length, - tmpBuffer, - i_target ); - - if( err ) + if( entry->isSpecialCase ) { - break; - } + // Handle special cases where data isn't sequential + // or is in reverse order from what would be read. + err = spdSpecialCases( (*entry), + io_buffer, + i_target, + i_DDRRev ); - // if useBitmask set, mask and then shift data - if( (*entry).useBitMask ) + if (err) + { + break; + } + } + else { - // Any bit mask/shifting will always be on a <1 Byte value - // thus, we touch only byte 0. - tmpBuffer[0] = tmpBuffer[0] & (*entry).bitMask; - tmpBuffer[0] = tmpBuffer[0] >> (*entry).shift; + // Read length requested + err = spdFetchData( (*entry).offset, + (*entry).length, + tmpBuffer, + i_target ); + + if( err ) + { + break; + } + + // if useBitmask set, mask and then shift data + if( (*entry).bitMask ) + { + // Any bit mask/shifting is only applied to the first byte + tmpBuffer[0] = tmpBuffer[0] & (*entry).bitMask; + tmpBuffer[0] = tmpBuffer[0] >> (*entry).shift; + } } - // Set length read + // Set length read to the size in the table io_buflen = (*entry).length; } while( 0 ); @@ -566,7 +585,7 @@ errlHndl_t spdWriteValue ( uint64_t i_keyword, do { - KeywordData * entry = NULL; + const KeywordData * entry = NULL; err = getKeywordEntry( i_keyword, i_DDRRev, entry ); @@ -644,7 +663,7 @@ errlHndl_t spdWriteValue ( uint64_t i_keyword, // We are not handling writes that are not on a byte // boundary until we absolutely need to. There are // no writable keywords that are not on byte boundaries - if( entry->useBitMask ) + if( entry->bitMask ) { // Error if not writable TRACFCOMP( g_trac_spd, @@ -709,18 +728,251 @@ errlHndl_t spdWriteValue ( uint64_t i_keyword, return err; } +// ------------------------------------------------------------------ +// ddr3SpecialCases +// ------------------------------------------------------------------ +errlHndl_t ddr3SpecialCases(const KeywordData & i_kwdData, + void * io_buffer, + TARGETING::Target * i_target) +{ + errlHndl_t err = NULL; + uint8_t * tmpBuffer = static_cast<uint8_t *>(io_buffer); + + TRACSSCOMP( g_trac_spd, ENTER_MRK"ddr3SpecialCases()" ); + + switch( i_kwdData.keyword ) + { + // ================================================== + // 2 byte - LSB then MSB + case CAS_LATENCIES_SUPPORTED: + case TRFC_MIN: + case MODULE_MANUFACTURER_ID: + case MODULE_REVISION_CODE: + case DRAM_MANUFACTURER_ID: + case MODULE_CRC: + case RMM_MFR_ID_CODE: + case LRMM_MFR_ID_CODE: + // Get MSB + err = spdFetchData( i_kwdData.offset, + 1, /* Read 1 byte at a time */ + &tmpBuffer[0], + i_target ); + + if( err ) break; + + // Mask and shift if needed + if( i_kwdData.bitMask ) + { + tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; + tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; + } + + // Get LSB + err = spdFetchData( (i_kwdData.offset - 1), + 1, /* Read 1 byte at a time */ + &tmpBuffer[1], + i_target ); + break; + + // ================================================== + // 2 byte - MSB with mask then LSB is 2 more than MSB + case TRC_MIN: + // Get MSB + err = spdFetchData( i_kwdData.offset, + 1, /* Read 1 byte at a time */ + &tmpBuffer[0], + i_target ); + + if( err ) break; + + // Mask and shift if needed + if( i_kwdData.bitMask ) + { + tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; + tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; + } + + // Get LSB + err = spdFetchData( (i_kwdData.offset + 2), + 1, /* Read 1 byte at a time */ + &tmpBuffer[1], + i_target ); + break; + + // ================================================== + default: + TRACFCOMP( g_trac_spd, + ERR_MRK"Unknown keyword (0x%04x) for DDR3 special cases!", + i_kwdData.keyword ); + + /*@ + * @errortype + * @reasoncode VPD::VPD_INVALID_SPD_KEYWORD + * @severity ERRORLOG::ERRL_SEV_UNRECOVERABLE + * @moduleid VPD::VPD_SPD_DDR3_SPECIAL_CASES + * @userdata1 SPD Keyword + * @userdata2 UNUSED + * @devdesc Keyword is not a special case keyword. + */ + err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_DDR3_SPECIAL_CASES, + VPD::VPD_INVALID_SPD_KEYWORD, + i_kwdData.keyword, + 0x0 ); + break; + }; + + TRACSSCOMP( g_trac_spd, EXIT_MRK"ddr4SpecialCases()" ); + return err; +} + +// ------------------------------------------------------------------ +// ddr4SpecialCases +// ------------------------------------------------------------------ +errlHndl_t ddr4SpecialCases(const KeywordData & i_kwdData, + void * io_buffer, + TARGETING::Target * i_target) +{ + errlHndl_t err = NULL; + uint8_t * tmpBuffer = static_cast<uint8_t *>(io_buffer); + + TRACSSCOMP( g_trac_spd, ENTER_MRK"ddr4SpecialCases()" ); + + switch( i_kwdData.keyword ) + { + // ================================================== + // 2 byte - LSB then MSB + case TRFC1_MIN: + case TRFC2_MIN: + case TRFC4_MIN: + case BASE_CONFIG_CRC: + case MODULE_MANUFACTURER_ID: + case MODULE_REVISION_CODE: + case DRAM_MANUFACTURER_ID: + case MANUFACTURING_SECTION_CRC: + case UMM_CRC: + case RMM_MFR_ID_CODE: + case RMM_CRC: + case LRMM_MFR_ID_CODE: + case LRMM_CRC: + // Get MSB + err = spdFetchData( i_kwdData.offset, + 1, /* Read 1 byte at a time */ + &tmpBuffer[0], + i_target ); + + if( err ) break; + + // Mask and shift if needed + if( i_kwdData.bitMask ) + { + tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; + tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; + } + + // Get LSB + err = spdFetchData( (i_kwdData.offset - 1), + 1, /* Read 1 byte at a time */ + &tmpBuffer[1], + i_target ); + break; + + // ================================================== + // 2 byte - MSB with mask then LSB is 2 more than MSB + case TRC_MIN: + // Get MSB + err = spdFetchData( i_kwdData.offset, + 1, /* Read 1 byte at a time */ + &tmpBuffer[0], + i_target ); + + if( err ) break; + + // Mask and shift if needed + if( i_kwdData.bitMask ) + { + tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; + tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; + } + + // Get LSB + err = spdFetchData( (i_kwdData.offset + 2), + 1, /* Read 1 byte at a time */ + &tmpBuffer[1], + i_target ); + break; + + // ================================================== + // 4 byte - LSB first, no mask + case CAS_LATENCIES_SUPPORTED: + // Get 4th byte + err = spdFetchData( i_kwdData.offset, + 1, /* Read 1 byte at a time */ + &tmpBuffer[0], + i_target ); + + if( err ) break; + + // Get 3rd Byte + err = spdFetchData( (i_kwdData.offset - 1), + 1, /* Read 1 byte at a time */ + &tmpBuffer[1], + i_target ); + + if( err ) break; + + // Get 2nd Byte + err = spdFetchData( (i_kwdData.offset - 2), + 1, /* Read 1 byte at a time */ + &tmpBuffer[2], + i_target ); + + if( err ) break; + + // Get 1st Byte + err = spdFetchData( (i_kwdData.offset - 3), + 1, /* Read 1 byte at a time */ + &tmpBuffer[3], + i_target ); + break; + + // ================================================== + default: + TRACFCOMP( g_trac_spd, + ERR_MRK"Unknown keyword (0x%04x) for DDR4 special cases!", + i_kwdData.keyword ); + + /*@ + * @errortype + * @reasoncode VPD::VPD_INVALID_SPD_KEYWORD + * @severity ERRORLOG::ERRL_SEV_UNRECOVERABLE + * @moduleid VPD::VPD_SPD_DDR4_SPECIAL_CASES + * @userdata1 SPD Keyword + * @userdata2 UNUSED + * @devdesc Keyword is not a special case keyword. + */ + err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_DDR4_SPECIAL_CASES, + VPD::VPD_INVALID_SPD_KEYWORD, + i_kwdData.keyword, + 0x0 ); + break; + }; + + TRACSSCOMP( g_trac_spd, EXIT_MRK"ddr4SpecialCases()" ); + return err; +} + // ------------------------------------------------------------------ // spdSpecialCases // ------------------------------------------------------------------ -errlHndl_t spdSpecialCases ( KeywordData i_kwdData, +errlHndl_t spdSpecialCases ( const KeywordData & i_kwdData, void * io_buffer, - size_t & io_buflen, TARGETING::Target * i_target, uint64_t i_DDRRev ) { errlHndl_t err = NULL; - uint8_t * tmpBuffer = static_cast<uint8_t *>(io_buffer); TRACSSCOMP( g_trac_spd, ENTER_MRK"spdSpecialCases()" ); @@ -730,147 +982,11 @@ errlHndl_t spdSpecialCases ( KeywordData i_kwdData, // Handle each of the special cases here if( SPD_DDR3 == i_DDRRev ) { - switch( i_kwdData.keyword ) - { - // ================================================== - // 2 byte - LSB then MSB - case CAS_LATENCIES_SUPPORTED: - case TRFC_MIN: - case MODULE_MANUFACTURER_ID: - case DRAM_MANUFACTURER_ID: - case RMM_MFR_ID_CODE: - case LRMM_MFR_ID_CODE: - // Check Size of buffer - err = spdCheckSize( io_buflen, - i_kwdData.length, - i_kwdData.keyword ); - - if( err ) break; - - // Get MSB - err = spdFetchData( i_kwdData.offset, - 1, /* Read 1 byte at a time */ - &tmpBuffer[0], - i_target ); - - if( err ) break; - - // Mask and shift if needed - if( i_kwdData.useBitMask ) - { - tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; - tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; - } - - // Get LSB - err = spdFetchData( (i_kwdData.offset - 1), - 1, /* Read 1 byte at a time */ - &tmpBuffer[1], - i_target ); - - if( err ) break; - - // Set number of bytes read - io_buflen = i_kwdData.length; - break; - - // ================================================== - // 2 byte - MSB with mask then LSB is 2 more than MSB - case TRC_MIN: - // Check Size of buffer - err = spdCheckSize( io_buflen, - i_kwdData.length, - i_kwdData.keyword ); - - if( err ) break; - - // Get MSB - err = spdFetchData( i_kwdData.offset, - 1, /* Read 1 byte at a time */ - &tmpBuffer[0], - i_target ); - - if( err ) break; - - // Mask and shift if needed - if( i_kwdData.useBitMask ) - { - tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; - tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; - } - - // Get LSB - err = spdFetchData( (i_kwdData.offset + 2), - 1, /* Read 1 byte at a time */ - &tmpBuffer[1], - i_target ); - - if( err ) break; - - // Set number of bytes read - io_buflen = i_kwdData.length; - break; - - // ================================================== - // 2 byte - MSB then LSB - case TRAS_MIN: - case TFAW_MIN: - // Check size of buffer - err = spdCheckSize( io_buflen, - i_kwdData.length, - i_kwdData.keyword ); - - if( err ) break; - - // Get MSB - err = spdFetchData( i_kwdData.offset, - 1, /* Read 1 byte at a time */ - &tmpBuffer[0], - i_target ); - - if( err ) break; - - // Mask and shift if needed - if( i_kwdData.useBitMask ) - { - tmpBuffer[0] = tmpBuffer[0] & i_kwdData.bitMask; - tmpBuffer[0] = tmpBuffer[0] >> i_kwdData.shift; - } - - // Get LSB - err = spdFetchData( (i_kwdData.offset + 1), - 1, /* Read 1 byte at a time */ - &tmpBuffer[1], - i_target ); - - if( err ) break; - - // Set number of bytes read - io_buflen = i_kwdData.length; - break; - - // ================================================== - default: - TRACFCOMP( g_trac_spd, - ERR_MRK"Unknown keyword (0x%04x) for DDR3 special cases!", - i_kwdData.keyword ); - - /*@ - * @errortype - * @reasoncode VPD::VPD_INVALID_SPD_KEYWORD - * @severity ERRORLOG::ERRL_SEV_UNRECOVERABLE - * @moduleid VPD::VPD_SPD_SPECIAL_CASES - * @userdata1 SPD Keyword - * @userdata2 UNUSED - * @devdesc Keyword is not a special case keyword. - */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_SPECIAL_CASES, - VPD::VPD_INVALID_SPD_KEYWORD, - i_kwdData.keyword, - 0x0 ); - break; - }; + err = ddr3SpecialCases(i_kwdData,io_buffer,i_target); + } + else if (SPD_DDR4 == i_DDRRev) + { + err = ddr4SpecialCases(i_kwdData,io_buffer,i_target); } else { @@ -1097,46 +1213,10 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, break; } - KeywordData * modTypeEntry = NULL; - err = getKeywordEntry( MODULE_TYPE, - i_memType, - modTypeEntry ); - - if( err ) - { - break; - } - - if( NULL == modTypeEntry ) - { - TRACFCOMP( g_trac_spd, - ERR_MRK"Keyword Entry pointer is NULL!" ); - - /*@ - * @errortype - * @reasoncode VPD::VPD_NULL_ENTRY - * @severity ERRORLOG::ERRL_SEV_UNRECOVERABLE - * @moduleid VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD - * @userdata1 i_memType - * @userdata2 <UNUSED> - * @devdesc Entry to get Module type is NULL - */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, - VPD::VPD_NULL_ENTRY, - i_memType, - 0x0 ); - - break; - } - - // To check the module specific flags, also need the Module Type - // value. - uint8_t modType = 0x0; - err = spdFetchData( modTypeEntry->offset, - modTypeEntry->length, - &modType, - i_target ); + // Check that a Module Specific keyword is being accessed from a DIMM + // of the correct Module Type. + modSpecTypes_t modType = NA; + err = getModType(modType, i_target, i_memType); if( err ) { @@ -1144,21 +1224,13 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, } // Check Unbuffered Memory Module (UMM) - if( (SPD_DDR3 == i_memType) && - ( (0x2 == modType) || - (0x3 == modType) || - (0x4 == modType) || - (0x6 == modType) || - (0x8 == modType) || - (0xc == modType) || - (0xd == modType) ) ) + if (UMM == modType) { - if( 0 == (i_kwdData.modSpec & UMM) ) + if (UMM != i_kwdData.modSpec) { TRACFCOMP( g_trac_spd, ERR_MRK"Keyword (0x%04x) is not valid with UMM modules!", i_kwdData.keyword ); - /*@ * @errortype * @reasoncode VPD::VPD_MOD_SPECIFIC_MISMATCH_UMM @@ -1170,28 +1242,24 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, * @userdata2[32:63] Module Specific flag * @devdesc Keyword requested was not UMM Module specific. */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, - VPD::VPD_MOD_SPECIFIC_MISMATCH_UMM, - TWO_UINT32_TO_UINT64( modType, i_memType ), - TWO_UINT32_TO_UINT64( i_kwdData.keyword, - i_kwdData.modSpec ) ); - + err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, + VPD::VPD_MOD_SPECIFIC_MISMATCH_UMM, + TWO_UINT32_TO_UINT64( modType, i_memType ), + TWO_UINT32_TO_UINT64( i_kwdData.keyword, + i_kwdData.modSpec ) ); break; } } // Check Registered Memory Module (RMM) - else if( (SPD_DDR3 == i_memType) && - ( (0x1 == modType) || - (0x5 == modType) || - (0x9 == modType) ) ) + else if (RMM == modType) { - if( 0 == (i_kwdData.modSpec & RMM) ) + if (RMM != i_kwdData.modSpec) { TRACFCOMP( g_trac_spd, ERR_MRK"Keyword (0x%04x) is not valid with RMM modules!", i_kwdData.keyword ); - /*@ * @errortype * @reasoncode VPD::VPD_MOD_SPECIFIC_MISMATCH_RMM @@ -1203,27 +1271,24 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, * @userdata2[32:63] Module Specific flag * @devdesc Keyword requested was not RMM Module specific. */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, - VPD::VPD_MOD_SPECIFIC_MISMATCH_RMM, - TWO_UINT32_TO_UINT64( modType, i_memType ), - TWO_UINT32_TO_UINT64( i_kwdData.keyword, - i_kwdData.modSpec ) ); - + err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, + VPD::VPD_MOD_SPECIFIC_MISMATCH_RMM, + TWO_UINT32_TO_UINT64( modType, i_memType ), + TWO_UINT32_TO_UINT64( i_kwdData.keyword, + i_kwdData.modSpec ) ); break; } } // Check Clocked Memory Module (CMM) - else if( (SPD_DDR3 == i_memType) && - ( (0x7 == modType) || - (0xa == modType) ) ) + else if (CMM == modType) { - if( 0 == (i_kwdData.modSpec & CMM) ) + if (CMM != i_kwdData.modSpec) { TRACFCOMP( g_trac_spd, ERR_MRK"Keyword (0x%04x) is not valid with CMM modules!", i_kwdData.keyword ); - /*@ * @errortype * @reasoncode VPD::VPD_MOD_SPECIFIC_MISMATCH_CMM @@ -1235,26 +1300,24 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, * @userdata2[32:63] Module Specific flag * @devdesc Keyword requested was not CMM Module specific. */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, - VPD::VPD_MOD_SPECIFIC_MISMATCH_CMM, - TWO_UINT32_TO_UINT64( modType, i_memType ), - TWO_UINT32_TO_UINT64( i_kwdData.keyword, - i_kwdData.modSpec ) ); - + err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, + VPD::VPD_MOD_SPECIFIC_MISMATCH_CMM, + TWO_UINT32_TO_UINT64( modType, i_memType ), + TWO_UINT32_TO_UINT64( i_kwdData.keyword, + i_kwdData.modSpec ) ); break; } } // Check Load Reduction Memory Module (LRMM) - else if( (SPD_DDR3 == i_memType) && - ( (0xb == modType) ) ) + else if (LRMM == modType) { - if( 0 == (i_kwdData.modSpec & LRMM) ) + if (LRMM != i_kwdData.modSpec) { TRACFCOMP( g_trac_spd, ERR_MRK"Keyword (0x%04x) is not valid with LRMM modules!", i_kwdData.keyword ); - /*@ * @errortype * @reasoncode VPD::VPD_MOD_SPECIFIC_MISMATCH_LRMM @@ -1266,13 +1329,13 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, * @userdata2[32:63] Module Specific flag * @devdesc Keyword requested was not LRMM Module specific. */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, - VPD::VPD_MOD_SPECIFIC_MISMATCH_LRMM, - TWO_UINT32_TO_UINT64( modType, i_memType ), - TWO_UINT32_TO_UINT64( i_kwdData.keyword, - i_kwdData.modSpec ) ); - + err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, + VPD::VPD_MOD_SPECIFIC_MISMATCH_LRMM, + TWO_UINT32_TO_UINT64( modType, i_memType ), + TWO_UINT32_TO_UINT64( i_kwdData.keyword, + i_kwdData.modSpec ) ); break; } } @@ -1286,27 +1349,25 @@ errlHndl_t checkModSpecificKeyword ( KeywordData i_kwdData, i_memType, modType, i_kwdData.keyword ); - /*@ * @errortype * @reasoncode VPD::VPD_MOD_SPECIFIC_UNSUPPORTED * @severity ERRORLOG::ERRL_SEV_UNRECOVERABLE * @moduleid VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD - * @userdata1[0:31] Module Type (byte 3[3:0]) - * @userdata1[32:63] Memory Type (byte 2) - * @userdata2[0:31] SPD Keyword - * @userdata2[32:63] Module Specific flag - * @devdesc Unsupported Module Specific setup. + * @userdata1 Module Type + * @userdata2 Memory Type (byte 2) + * @devdesc Unsupported Module Type. */ - err = new ERRORLOG::ErrlEntry( ERRORLOG::ERRL_SEV_UNRECOVERABLE, - VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, - VPD::VPD_MOD_SPECIFIC_UNSUPPORTED, - TWO_UINT32_TO_UINT64( modType, i_memType ), - TWO_UINT32_TO_UINT64( i_kwdData.keyword, - i_kwdData.modSpec ) ); - + err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_CHECK_MODULE_SPECIFIC_KEYWORD, + VPD::VPD_MOD_SPECIFIC_UNSUPPORTED, + TWO_UINT32_TO_UINT64( modType, i_memType ), + TWO_UINT32_TO_UINT64( i_kwdData.keyword, + i_kwdData.modSpec ) ); break; } + } while( 0 ); TRACSSCOMP( g_trac_spd, @@ -1325,7 +1386,7 @@ errlHndl_t getMemType ( uint8_t & o_memType, errlHndl_t err = NULL; err = spdFetchData( MEM_TYPE_ADDR, - MEM_TYPE_ADDR_SZ, + MEM_TYPE_SZ, &o_memType, i_target ); @@ -1337,29 +1398,131 @@ errlHndl_t getMemType ( uint8_t & o_memType, return err; } +// ------------------------------------------------------------------ +// getModType +// ------------------------------------------------------------------ +errlHndl_t getModType ( modSpecTypes_t & o_modType, + TARGETING::Target * i_target, + uint64_t i_memType ) +{ + errlHndl_t err = NULL; + o_modType = NA; + + uint8_t modTypeVal = 0; + err = spdFetchData( MOD_TYPE_ADDR, + MOD_TYPE_SZ, + &modTypeVal, + i_target ); + + if (err) + { + TRACFCOMP( g_trac_spd, + ERR_MRK"SPD::getModType() - Error querying ModType" ); + } + else + { + modTypeVal &= MOD_TYPE_MASK; + + if (SPD_DDR3 == i_memType) + { + if ((MOD_TYPE_DDR3_UDIMM == modTypeVal) || + (MOD_TYPE_DDR3_SO_DIMM == modTypeVal) || + (MOD_TYPE_DDR3_MICRO_DIMM == modTypeVal) || + (MOD_TYPE_DDR3_MINI_UDIMM == modTypeVal) || + (MOD_TYPE_DDR3_SO_UDIMM == modTypeVal)) + { + o_modType = UMM; + } + else if ((MOD_TYPE_DDR3_RDIMM == modTypeVal) || + (MOD_TYPE_DDR3_MINI_RDIMM == modTypeVal) || + (MOD_TYPE_DDR3_SO_RDIMM == modTypeVal)) + { + o_modType = RMM; + } + else if ((MOD_TYPE_DDR3_MINI_CDIMM == modTypeVal) || + (MOD_TYPE_DDR3_SO_CDIMM == modTypeVal)) + { + o_modType = CMM; + } + else if (MOD_TYPE_DDR3_LRDIMM == modTypeVal) + { + o_modType = LRMM; + } + } + else if (SPD_DDR4 == i_memType) + { + if ((MOD_TYPE_DDR4_UDIMM == modTypeVal) || + (MOD_TYPE_DDR4_SO_DIMM == modTypeVal)) + { + o_modType = UMM; + } + else if (MOD_TYPE_DDR4_RDIMM == modTypeVal) + { + o_modType = RMM; + } + else if (MOD_TYPE_DDR4_LRDIMM == modTypeVal) + { + o_modType = LRMM; + } + } + + if (o_modType == NA) + { + TRACFCOMP( g_trac_spd, + ERR_MRK"Module type 0x%02x unrecognized", modTypeVal ); + + /*@ + * @errortype + * @reasoncode VPD::VPD_MOD_SPECIFIC_UNSUPPORTED + * @severity ERRORLOG::ERRL_SEV_UNRECOVERABLE + * @moduleid VPD::VPD_SPD_GET_MOD_TYPE + * @userdata1 Module Type (byte 3[3:0]) + * @userdata2 Memory Type (byte 2) + * @devdesc Unrecognized Module Type. + */ + err = new ERRORLOG::ErrlEntry( + ERRORLOG::ERRL_SEV_UNRECOVERABLE, + VPD::VPD_SPD_GET_MOD_TYPE, + VPD::VPD_MOD_SPECIFIC_UNSUPPORTED, + modTypeVal, i_memType); + } + else + { + TRACUCOMP( g_trac_spd, + "SPD::getModType() - Val: 0x%02x, ModType: 0x%02x", + modTypeVal, o_modType); + } + } + + return err; +} + // ------------------------------------------------------------------ // getKeywordEntry // ------------------------------------------------------------------ errlHndl_t getKeywordEntry ( uint64_t i_keyword, uint64_t i_memType, - KeywordData *& o_entry ) + const KeywordData *& o_entry ) { errlHndl_t err = NULL; - KeywordData * kwdData; + const KeywordData * kwdData; uint32_t arraySize = 0x0; - TRACSSCOMP( g_trac_spd, - ENTER_MRK"getKeywordEntry()" ); + TRACSSCOMP( g_trac_spd, ENTER_MRK"getKeywordEntry()" ); do { - if( SPD_DDR3 == i_memType ) + if ( SPD_DDR3 == i_memType ) { - // Put the table into an array arraySize = (sizeof(ddr3Data)/sizeof(ddr3Data[0])); kwdData = ddr3Data; } + else if ( SPD_DDR4 == i_memType ) + { + arraySize = (sizeof(ddr4Data)/sizeof(ddr4Data[0])); + kwdData = ddr4Data; + } else { TRACFCOMP( g_trac_spd, @@ -1387,10 +1550,10 @@ errlHndl_t getKeywordEntry ( uint64_t i_keyword, // Set the searching structure equal to the keyword we're looking for. KeywordData tmpKwdData; tmpKwdData.keyword = i_keyword; - KeywordData * entry = std::lower_bound( kwdData, - &kwdData[arraySize], - tmpKwdData, - compareEntries ); + const KeywordData * entry = std::lower_bound( kwdData, + &kwdData[arraySize], + tmpKwdData, + compareEntries ); if( ( entry == &kwdData[arraySize] ) || ( i_keyword != entry->keyword ) ) |