summaryrefslogtreecommitdiffstats
path: root/src/usr/i2c/eepromCache.C
diff options
context:
space:
mode:
Diffstat (limited to 'src/usr/i2c/eepromCache.C')
-rw-r--r--src/usr/i2c/eepromCache.C588
1 files changed, 144 insertions, 444 deletions
diff --git a/src/usr/i2c/eepromCache.C b/src/usr/i2c/eepromCache.C
index 6993f35ee..b50f899bf 100644
--- a/src/usr/i2c/eepromCache.C
+++ b/src/usr/i2c/eepromCache.C
@@ -34,7 +34,7 @@
#include "i2c.H"
#include "eepromCache.H"
#include <i2c/i2cif.H>
-#include <i2c/eepromif.H>
+
#include <i2c/eepromddreasoncodes.H>
#include <initservice/initserviceif.H>
#include <initservice/initsvcreasoncodes.H>
@@ -55,6 +55,10 @@ extern trace_desc_t* g_trac_eeprom;
namespace EEPROM
{
+// Any time we access either any of the global variables defined below we want
+// to wrap the call in this mutex to avoid multi-threading issues
+mutex_t g_eecacheMutex = MUTEX_INITIALIZER;
+
// Global variable that will keep track of the virtual address which
// points to the start of the EECACHE section, and the size of this section.
// It is handy to keep these around so we do not need to look them up in the
@@ -70,287 +74,6 @@ uint64_t g_eecachePnorSize = 0;
// if this eeprom's hardware has changed this IPL
std::map<eepromRecordHeader, EeepromEntryMetaData_t> g_cachedEeproms;
-// Any time we access either any of the global variables defined above we want
-// to wrap the call in this mutex to avoid multi-threading issues
-mutex_t g_eecacheMutex = MUTEX_INITIALIZER;
-
-uint64_t lookupEepromCacheAddr(const eepromRecordHeader& i_eepromRecordHeader)
-{
- uint64_t l_vaddr = 0;
- std::map<eepromRecordHeader, EeepromEntryMetaData_t>::iterator l_it;
-
- // Wrap lookup in mutex because reads are not thread safe
- mutex_lock(&g_eecacheMutex);
- l_it = g_cachedEeproms.find(i_eepromRecordHeader);
- mutex_unlock(&g_eecacheMutex);
-
- if(l_it != g_cachedEeproms.end())
- {
- l_vaddr = l_it->second.cache_entry_address;
- }
- return l_vaddr;
-}
-
-uint64_t lookupEepromHeaderAddr(const eepromRecordHeader& i_eepromRecordHeader)
-{
- uint64_t l_vaddr = 0;
- std::map<eepromRecordHeader, EeepromEntryMetaData_t>::iterator l_it;
-
- // Wrap lookup in mutex because reads are not thread safe
- mutex_lock(&g_eecacheMutex);
- l_it = g_cachedEeproms.find(i_eepromRecordHeader);
-
- if(l_it != g_cachedEeproms.end())
- {
- l_vaddr = l_it->second.header_entry_address;
- }
- mutex_unlock(&g_eecacheMutex);
-
- if(l_vaddr == 0)
- {
- TRACFCOMP( g_trac_eeprom,
- "lookupEepromHeaderAddr() failed to find"
- " I2CM Huid: 0x%.08X, Port: 0x%.02X,"
- " Engine: 0x%.02X, Dev Addr: 0x%.02X,"
- " Mux Select: 0x%.02X, Size: 0x%.08X"
- "in g_cachedEeproms",
- i_eepromRecordHeader.completeRecord.i2c_master_huid,
- i_eepromRecordHeader.completeRecord.port,
- i_eepromRecordHeader.completeRecord.engine,
- i_eepromRecordHeader.completeRecord.devAddr,
- i_eepromRecordHeader.completeRecord.mux_select,
- i_eepromRecordHeader.completeRecord.cache_copy_size);
- }
- return l_vaddr;
-}
-
-errlHndl_t buildEepromRecordHeader(TARGETING::Target * i_target,
- eeprom_addr_t & io_eepromInfo,
- eepromRecordHeader & o_eepromRecordHeader)
-{
-
- TARGETING::Target * l_muxTarget = nullptr;
- TARGETING::Target * l_i2cMasterTarget = nullptr;
- TARGETING::TargetService& l_targetService = TARGETING::targetService();
- errlHndl_t l_errl = nullptr;
-
- do{
-
- l_errl = eepromReadAttributes(i_target, io_eepromInfo);
- if(l_errl)
- {
- TRACFCOMP( g_trac_eeprom,
- "buildEepromRecordHeader() error occured reading eeprom attributes for eepromType %d, target 0x%.08X, returning!!",
- io_eepromInfo.eepromRole,
- TARGETING::get_huid(i_target));
- l_errl->collectTrace(EEPROM_COMP_NAME);
- break;
- }
-
- // Grab the I2C mux target so we can read the HUID, if the target is NULL we will not be able
- // to lookup attribute to uniquely ID this eeprom so we will not cache it
- l_muxTarget = l_targetService.toTarget( io_eepromInfo.i2cMuxPath);
- if(l_muxTarget == nullptr)
- {
- TRACFCOMP( g_trac_eeprom,
- "buildEepromRecordHeader() Mux target associated with target 0x%.08X resolved to a nullptr , check attribute for eepromType %d. Skipping Cache",
- TARGETING::get_huid(i_target),
- io_eepromInfo.eepromRole);
- /*@
- * @errortype
- * @moduleid EEPROM_CACHE_EEPROM
- * @reasoncode EEPROM_I2C_MUX_PATH_ERROR
- * @userdata1 HUID of target we want to cache
- * @userdata2 Type of EEPROM we are caching
- * @devdesc buildEepromRecordHeader invalid mux target
- */
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_UNRECOVERABLE,
- EEPROM_CACHE_EEPROM,
- EEPROM_I2C_MUX_PATH_ERROR,
- TARGETING::get_huid(i_target),
- io_eepromInfo.eepromRole,
- ERRORLOG::ErrlEntry::ADD_SW_CALLOUT);
- l_errl->collectTrace(EEPROM_COMP_NAME);
- break;
- }
-
- // Grab the I2C master target so we can read the HUID, if the target is NULL we will not be able
- // to lookup attribute to uniquely ID this eeprom so we will not cache it
- l_i2cMasterTarget = l_targetService.toTarget( io_eepromInfo.i2cMasterPath );
- if(l_i2cMasterTarget == nullptr)
- {
- TRACFCOMP( g_trac_eeprom,
- "buildEepromRecordHeader() I2C Master target associated with target 0x%.08X resolved to a nullptr , check attribute for eepromType %d. Skipping Cache ",
- TARGETING::get_huid(i_target),
- io_eepromInfo.eepromRole);
- /*@
- * @errortype
- * @moduleid EEPROM_CACHE_EEPROM
- * @reasoncode EEPROM_I2C_MASTER_PATH_ERROR
- * @userdata1 HUID of target we want to cache
- * @userdata2 Type of EEPROM we are caching
- * @devdesc buildEepromRecordHeader invalid master target
- */
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_UNRECOVERABLE,
- EEPROM_CACHE_EEPROM,
- EEPROM_I2C_MASTER_PATH_ERROR,
- TARGETING::get_huid(i_target),
- io_eepromInfo.eepromRole,
- ERRORLOG::ErrlEntry::ADD_SW_CALLOUT);
- l_errl->collectTrace(EEPROM_COMP_NAME);
- break;
- }
-
- // This is what we will compare w/ when we are going through the existing
- // caches in the eeprom to see if we have already cached something
- // Or if no matches are found we will copy this into the header
- o_eepromRecordHeader.completeRecord.i2c_master_huid = l_i2cMasterTarget->getAttr<TARGETING::ATTR_HUID>();
- o_eepromRecordHeader.completeRecord.port = static_cast<uint8_t>(io_eepromInfo.port);
- o_eepromRecordHeader.completeRecord.engine = static_cast<uint8_t>(io_eepromInfo.engine);
- o_eepromRecordHeader.completeRecord.devAddr = static_cast<uint8_t>(io_eepromInfo.devAddr);
- o_eepromRecordHeader.completeRecord.mux_select = static_cast<uint8_t>(io_eepromInfo.i2cMuxBusSelector);
- o_eepromRecordHeader.completeRecord.cache_copy_size = static_cast<uint32_t>(io_eepromInfo.devSize_KB);
-
- // Do not set valid bit nor internal offset here as we do not have
- // enough information availible to determine
-
- }while(0);
-
- return l_errl;
-}
-
-// Do NOT allow adding/removing eeproms to cache during RT
-#ifndef __HOSTBOOT_RUNTIME
-
-void printTableOfContents(void)
-{
- eecacheSectionHeader * l_eecacheSectionHeaderPtr =
- reinterpret_cast<eecacheSectionHeader*>(g_eecachePnorVaddr);
-
- TRACFCOMP( g_trac_eeprom,
- "printTableOfContents(): Version = 0x%.02X"
- " End of Cache = 0x.08X",
- l_eecacheSectionHeaderPtr->version,
- l_eecacheSectionHeaderPtr->end_of_cache);
-
- for(uint8_t i = 0; i < MAX_EEPROMS_VERSION_1; i++)
- {
- eepromRecordHeader l_currentRecordHeader =
- l_eecacheSectionHeaderPtr->recordHeaders[i];
-
- if( l_currentRecordHeader.completeRecord.internal_offset !=
- UNSET_INTERNAL_OFFSET_VALUE)
- {
- TRACFCOMP( g_trac_eeprom,
- "printTableOfContents(): I2CM Huid: 0x%.08X, Port: 0x%.02X,"
- " Engine: 0x%.02X, Dev Addr: 0x%.02X,"
- " Mux Select: 0x%.02X, Size: 0x%.08X",
- l_currentRecordHeader.completeRecord.i2c_master_huid,
- l_currentRecordHeader.completeRecord.port,
- l_currentRecordHeader.completeRecord.engine,
- l_currentRecordHeader.completeRecord.devAddr,
- l_currentRecordHeader.completeRecord.mux_select,
- l_currentRecordHeader.completeRecord.cache_copy_size);
-
- TRACFCOMP( g_trac_eeprom,
- " "
- "Internal Offset: 0x%.08X, Cache Valid: 0x%.02X",
- l_currentRecordHeader.completeRecord.internal_offset,
- l_currentRecordHeader.completeRecord.cached_copy_valid);
- }
- }
-
-}
-
-/**
-*
-* @brief Lookup a given i_eepromRecordHeader in the global map of eeprom
-* caches and check if the eeprom has changed this IPL or not
-*
-* @param[in] i_eepromRecordHeader we want to look up
-*
-* @return bool Return TRUE if eeprom is found in map AND mark_target_changed
- was set to true for the eeprom entry. Return FALSE otherwise.
-*
-*/
-bool hasEeepromChanged(const eepromRecordHeader & i_eepromRecordHeader)
-{
- bool l_eepromHasChanged = false;
-
- // Map accesses are not thread safe, make sure this is always wrapped in mutex
- mutex_lock(&g_eecacheMutex);
-
- if(g_cachedEeproms.find(i_eepromRecordHeader) != g_cachedEeproms.end())
- {
- l_eepromHasChanged = g_cachedEeproms[i_eepromRecordHeader].mark_target_changed;
- }
-
- mutex_unlock(&g_eecacheMutex);
-
- return l_eepromHasChanged;
-}
-
-/**
-*
-* @brief Lookup a given i_eepromRecordHeader in the global map of eeprom
-* caches and mark that it has changed this IPL
-*
-* @param[in] i_eepromRecordHeader we want to mark as changed
-*
-* @return void
-*/
-void setEeepromChanged(const eepromRecordHeader & i_eepromRecordHeader)
-{
-
- // Map accesses are not thread safe, make sure this is always wrapped in mutex
- mutex_lock(&g_eecacheMutex);
-
- if(g_cachedEeproms.find(i_eepromRecordHeader) != g_cachedEeproms.end())
- {
- g_cachedEeproms[i_eepromRecordHeader].mark_target_changed = true;
- }
-
- mutex_unlock(&g_eecacheMutex);
-
-}
-
-bool addEepromToCachedList(const eepromRecordHeader & i_eepromRecordHeader,
- const uint64_t i_recordHeaderVaddr)
-{
- bool l_matchFound = true;
-
- // Map accesses are not thread safe, make sure this is always wrapped in mutex
- mutex_lock(&g_eecacheMutex);
-
- if(g_cachedEeproms.find(i_eepromRecordHeader) == g_cachedEeproms.end())
- {
- g_cachedEeproms[i_eepromRecordHeader].cache_entry_address =
- g_eecachePnorVaddr + i_eepromRecordHeader.completeRecord.internal_offset;
-
- g_cachedEeproms[i_eepromRecordHeader].header_entry_address =
- i_recordHeaderVaddr;
-
- TRACSSCOMP( g_trac_eeprom,
- "addEepromToCachedList() Adding I2CM Huid: 0x%.08X, Port: 0x%.02X,"
- " Engine: 0x%.02X, Dev Addr: 0x%.02X, Mux Select: 0x%.02X,"
- " Size: 0x%.08X to g_cachedEeproms",
- i_eepromRecordHeader.completeRecord.i2c_master_huid,
- i_eepromRecordHeader.completeRecord.port,
- i_eepromRecordHeader.completeRecord.engine,
- i_eepromRecordHeader.completeRecord.devAddr,
- i_eepromRecordHeader.completeRecord.mux_select,
- i_eepromRecordHeader.completeRecord.cache_copy_size);
-
- l_matchFound = false;
- }
-
- mutex_unlock(&g_eecacheMutex);
-
- return l_matchFound;
-}
-
/**
* @brief Lookup I2C information for given eeprom, check if eeprom exists in cache.
* If it exists already determine if any updates are required. If it is not
@@ -1066,186 +789,163 @@ errlHndl_t setIsValidCacheEntry(const eepromRecordHeader& i_eepromRecordHeader,
return l_errl;
}
-#endif
-
-errlHndl_t eepromPerformOpCache(DeviceFW::OperationType i_opType,
- TARGETING::Target * i_target,
- void * io_buffer,
- size_t& io_buflen,
- eeprom_addr_t &i_eepromInfo)
+bool addEepromToCachedList(const eepromRecordHeader & i_eepromRecordHeader,
+ const uint64_t i_recordHeaderVaddr)
{
- errlHndl_t l_errl = nullptr;
- eepromRecordHeader l_eepromRecordHeader;
+ bool l_matchFound = true;
- do{
+ // Map accesses are not thread safe, make sure this is always wrapped in mutex
+ mutex_lock(&g_eecacheMutex);
+
+ if(g_cachedEeproms.find(i_eepromRecordHeader) == g_cachedEeproms.end())
+ {
+ g_cachedEeproms[i_eepromRecordHeader].cache_entry_address =
+ g_eecachePnorVaddr + i_eepromRecordHeader.completeRecord.internal_offset;
+
+ g_cachedEeproms[i_eepromRecordHeader].header_entry_address =
+ i_recordHeaderVaddr;
- TRACSSCOMP( g_trac_eeprom, ENTER_MRK"eepromPerformOpCache() "
- "Target HUID 0x%.08X Enter", TARGETING::get_huid(i_target));
+ TRACSSCOMP( g_trac_eeprom,
+ "addEepromToCachedList() Adding I2CM Huid: 0x%.08X, Port: 0x%.02X,"
+ " Engine: 0x%.02X, Dev Addr: 0x%.02X, Mux Select: 0x%.02X,"
+ " Size: 0x%.08X to g_cachedEeproms",
+ i_eepromRecordHeader.completeRecord.i2c_master_huid,
+ i_eepromRecordHeader.completeRecord.port,
+ i_eepromRecordHeader.completeRecord.engine,
+ i_eepromRecordHeader.completeRecord.devAddr,
+ i_eepromRecordHeader.completeRecord.mux_select,
+ i_eepromRecordHeader.completeRecord.cache_copy_size);
- l_errl = buildEepromRecordHeader(i_target,
- i_eepromInfo,
- l_eepromRecordHeader);
+ l_matchFound = false;
+ }
- if(l_errl)
+ mutex_unlock(&g_eecacheMutex);
+
+ return l_matchFound;
+}
+
+void printTableOfContents(void)
+{
+ eecacheSectionHeader * l_eecacheSectionHeaderPtr =
+ reinterpret_cast<eecacheSectionHeader*>(g_eecachePnorVaddr);
+
+ TRACFCOMP( g_trac_eeprom,
+ "printTableOfContents(): Version = 0x%.02X"
+ " End of Cache = 0x.08X",
+ l_eecacheSectionHeaderPtr->version,
+ l_eecacheSectionHeaderPtr->end_of_cache);
+
+ for(uint8_t i = 0; i < MAX_EEPROMS_VERSION_1; i++)
+ {
+ eepromRecordHeader l_currentRecordHeader =
+ l_eecacheSectionHeaderPtr->recordHeaders[i];
+
+ if( l_currentRecordHeader.completeRecord.internal_offset !=
+ UNSET_INTERNAL_OFFSET_VALUE)
{
- // buildEepromRecordHeader should have traced any relavent information if
- // it was needed, just break out and pass the error along
- break;
+ TRACFCOMP( g_trac_eeprom,
+ "printTableOfContents(): I2CM Huid: 0x%.08X, Port: 0x%.02X,"
+ " Engine: 0x%.02X, Dev Addr: 0x%.02X,"
+ " Mux Select: 0x%.02X, Size: 0x%.08X",
+ l_currentRecordHeader.completeRecord.i2c_master_huid,
+ l_currentRecordHeader.completeRecord.port,
+ l_currentRecordHeader.completeRecord.engine,
+ l_currentRecordHeader.completeRecord.devAddr,
+ l_currentRecordHeader.completeRecord.mux_select,
+ l_currentRecordHeader.completeRecord.cache_copy_size);
+
+ TRACFCOMP( g_trac_eeprom,
+ " "
+ "Internal Offset: 0x%.08X, Cache Valid: 0x%.02X",
+ l_currentRecordHeader.completeRecord.internal_offset,
+ l_currentRecordHeader.completeRecord.cached_copy_valid);
}
+ }
- uint64_t l_eepromCacheVaddr = lookupEepromCacheAddr(l_eepromRecordHeader);
+}
- // Ensure that a copy of the eeprom exists in our map of cached eeproms
- if(l_eepromCacheVaddr)
- {
- // First check if io_buffer is a nullptr, if so then assume user is
- // requesting size back in io_bufferlen
- if(io_buffer == nullptr)
- {
- io_buflen = l_eepromRecordHeader.completeRecord.cache_copy_size * KILOBYTE;
- TRACSSCOMP( g_trac_eeprom, "eepromPerformOpCache() "
- "io_buffer == nullptr , returning io_buflen as 0x%lx",
- io_buflen);
- break;
- }
+bool hasEeepromChanged(const eepromRecordHeader & i_eepromRecordHeader)
+{
+ bool l_eepromHasChanged = false;
- TRACSSCOMP( g_trac_eeprom, "eepromPerformOpCache() "
- "Performing %s on target 0x%.08X offset 0x%lx length 0x%x vaddr 0x%lx",
- (i_opType == DeviceFW::READ) ? "READ" : "WRITE",
- TARGETING::get_huid(i_target),
- i_eepromInfo.offset, io_buflen, l_eepromCacheVaddr);
+ // Map accesses are not thread safe, make sure this is always wrapped in mutex
+ mutex_lock(&g_eecacheMutex);
- // Make sure that offset + buflen are less than the total size of the eeprom
- if(i_eepromInfo.offset + io_buflen >
- (l_eepromRecordHeader.completeRecord.cache_copy_size * KILOBYTE))
- {
- TRACFCOMP(g_trac_eeprom,
- ERR_MRK"eepromPerformOpCache: i_eepromInfo.offset + i_offset is greater than size of eeprom (0x%x KB)",
- l_eepromRecordHeader.completeRecord.cache_copy_size);
- /*@
- * @errortype
- * @moduleid EEPROM_CACHE_PERFORM_OP
- * @reasoncode EEPROM_OVERFLOW_ERROR
- * @userdata1 Length of Operation
- * @userdata2 Offset we are attempting to read/write
- * @custdesc Soft error in Firmware
- * @devdesc cacheEeprom invalid op type
- */
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_UNRECOVERABLE,
- EEPROM_CACHE_PERFORM_OP,
- EEPROM_OVERFLOW_ERROR,
- TO_UINT64(io_buflen),
- TO_UINT64(i_eepromInfo.offset),
- ERRORLOG::ErrlEntry::ADD_SW_CALLOUT);
- ERRORLOG::ErrlUserDetailsTarget(i_target).addToLog(l_errl);
- l_errl->collectTrace( EEPROM_COMP_NAME );
+ if(g_cachedEeproms.find(i_eepromRecordHeader) != g_cachedEeproms.end())
+ {
+ l_eepromHasChanged = g_cachedEeproms[i_eepromRecordHeader].mark_target_changed;
+ }
- break;
- }
+ mutex_unlock(&g_eecacheMutex);
- if(i_opType == DeviceFW::READ)
- {
- memcpy(io_buffer,
- reinterpret_cast<void *>(l_eepromCacheVaddr + i_eepromInfo.offset),
- io_buflen);
- }
- else if(i_opType == DeviceFW::WRITE)
- {
- memcpy(reinterpret_cast<void *>(l_eepromCacheVaddr + i_eepromInfo.offset),
- io_buffer,
- io_buflen);
+ return l_eepromHasChanged;
+}
- #ifndef __HOSTBOOT_RUNTIME
+void setEeepromChanged(const eepromRecordHeader & i_eepromRecordHeader)
+{
- // Perform flush to ensure pnor is updated
- int rc = mm_remove_pages( FLUSH,
- reinterpret_cast<void *>(l_eepromCacheVaddr + i_eepromInfo.offset),
- io_buflen );
- if( rc )
- {
- TRACFCOMP(g_trac_eeprom,
- ERR_MRK"eepromPerformOpCache: Error from mm_remove_pages trying for flush contents write to pnor! rc=%d",
- rc);
- /*@
- * @errortype
- * @moduleid EEPROM_CACHE_PERFORM_OP
- * @reasoncode EEPROM_FAILED_TO_FLUSH_CONTENTS
- * @userdata1 Requested Address
- * @userdata2 rc from mm_remove_pages
- * @devdesc cacheEeprom mm_remove_pages FLUSH failed
- */
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_UNRECOVERABLE,
- EEPROM_CACHE_PERFORM_OP,
- EEPROM_FAILED_TO_FLUSH_CONTENTS,
- (l_eepromCacheVaddr + i_eepromInfo.offset),
- TO_UINT64(rc),
- ERRORLOG::ErrlEntry::ADD_SW_CALLOUT);
- l_errl->collectTrace( EEPROM_COMP_NAME );
- }
- #endif //__HOSTBOOT_RUNTIME
- }
- else
- {
- TRACFCOMP(g_trac_eeprom,
- ERR_MRK"eepromPerformOpCache: Invalid OP_TYPE passed to function, i_opType=%d",
- i_opType);
- /*@
- * @errortype
- * @moduleid EEPROM_CACHE_PERFORM_OP
- * @reasoncode EEPROM_INVALID_OPERATION
- * @userdata1[0:31] Op Type that was invalid
- * @userdata1[32:63] Eeprom Role
- * @userdata2 Offset we are attempting to perfrom op on
- * @custdesc Soft error in Firmware
- * @devdesc cacheEeprom invalid op type
- */
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_UNRECOVERABLE,
- EEPROM_CACHE_PERFORM_OP,
- EEPROM_INVALID_OPERATION,
- TWO_UINT32_TO_UINT64(i_opType,
- i_eepromInfo.eepromRole),
- TO_UINT64(i_eepromInfo.offset),
- ERRORLOG::ErrlEntry::ADD_SW_CALLOUT);
- ERRORLOG::ErrlUserDetailsTarget(i_target).addToLog(l_errl);
- l_errl->collectTrace( EEPROM_COMP_NAME );
- }
- }
- else
- {
- TRACFCOMP( g_trac_eeprom,"eepromPerformOpCache: Failed to find entry in cache for 0x%.08X, %s failed",
- TARGETING::get_huid(i_target),
- (i_opType == DeviceFW::READ) ? "READ" : "WRITE");
- /*@
- * @errortype
- * @moduleid EEPROM_CACHE_PERFORM_OP
- * @reasoncode EEPROM_NOT_IN_CACHE
- * @userdata1[0:31] Op Type
- * @userdata1[32:63] Eeprom Role
- * @userdata2 Offset we are attempting to read/write
- * @custdesc Soft error in Firmware
- * @devdesc Tried to lookup eeprom not in cache
- */
- l_errl = new ERRORLOG::ErrlEntry(
- ERRORLOG::ERRL_SEV_UNRECOVERABLE,
- EEPROM_CACHE_PERFORM_OP,
- EEPROM_NOT_IN_CACHE,
- TWO_UINT32_TO_UINT64(i_opType,
- i_eepromInfo.eepromRole),
- TO_UINT64(i_eepromInfo.offset),
- ERRORLOG::ErrlEntry::ADD_SW_CALLOUT);
- ERRORLOG::ErrlUserDetailsTarget(i_target).addToLog(l_errl);
- l_errl->collectTrace( EEPROM_COMP_NAME );
- }
+ // Map accesses are not thread safe, make sure this is always wrapped in mutex
+ mutex_lock(&g_eecacheMutex);
+
+ if(g_cachedEeproms.find(i_eepromRecordHeader) != g_cachedEeproms.end())
+ {
+ g_cachedEeproms[i_eepromRecordHeader].mark_target_changed = true;
+ }
- TRACSSCOMP( g_trac_eeprom, EXIT_MRK"eepromPerformOpCache() "
- "Target HUID 0x%.08X Exit", TARGETING::get_huid(i_target));
+ mutex_unlock(&g_eecacheMutex);
- }while(0);
+}
- return l_errl;
+uint64_t lookupEepromCacheAddr(const eepromRecordHeader& i_eepromRecordHeader)
+{
+ uint64_t l_vaddr = 0;
+ std::map<eepromRecordHeader, EeepromEntryMetaData_t>::iterator l_it;
+
+ // Wrap lookup in mutex because reads are not thread safe
+ mutex_lock(&g_eecacheMutex);
+ l_it = g_cachedEeproms.find(i_eepromRecordHeader);
+
+ if(l_it != g_cachedEeproms.end())
+ {
+ l_vaddr = l_it->second.cache_entry_address;
+ }
+
+ mutex_unlock(&g_eecacheMutex);
+
+ return l_vaddr;
+}
+
+uint64_t lookupEepromHeaderAddr(const eepromRecordHeader& i_eepromRecordHeader)
+{
+ uint64_t l_vaddr = 0;
+ std::map<eepromRecordHeader, EeepromEntryMetaData_t>::iterator l_it;
+
+ // Wrap lookup in mutex because reads are not thread safe
+ mutex_lock(&g_eecacheMutex);
+ l_it = g_cachedEeproms.find(i_eepromRecordHeader);
+
+ if(l_it != g_cachedEeproms.end())
+ {
+ l_vaddr = l_it->second.header_entry_address;
+ }
+ mutex_unlock(&g_eecacheMutex);
+
+ if(l_vaddr == 0)
+ {
+ TRACFCOMP( g_trac_eeprom,
+ "lookupEepromHeaderAddr() failed to find"
+ " I2CM Huid: 0x%.08X, Port: 0x%.02X,"
+ " Engine: 0x%.02X, Dev Addr: 0x%.02X,"
+ " Mux Select: 0x%.02X, Size: 0x%.08X"
+ "in g_cachedEeproms",
+ i_eepromRecordHeader.completeRecord.i2c_master_huid,
+ i_eepromRecordHeader.completeRecord.port,
+ i_eepromRecordHeader.completeRecord.engine,
+ i_eepromRecordHeader.completeRecord.devAddr,
+ i_eepromRecordHeader.completeRecord.mux_select,
+ i_eepromRecordHeader.completeRecord.cache_copy_size);
+ }
+ return l_vaddr;
}
}
OpenPOWER on IntegriCloud