Add new path in EEPROM device op to allow reading from new EECACHE

Recently a new EECACHE section was introduced to Hostboot. This section
gets populated with a copy of every PRIMARY_VPD eeprom (someday could
contain other eeprom roles also) during host_discover_targets. This
commit add support to allow users to select where they want to perform
their EEPROM device operation. If they pass CACHE to the deviceOp macro
then a read will come from the pnor cache, writes will write to pnor
cache and then also write to the eeprom HW. If HARDWARE is passed in
then reads and writes will be directly done on the eeprom hardware.
If AUTOSELECT is passed the code will check our cache to see if we have
a copy of the eeprom in question, if we have a copy we will go the
CACHE path, if no copy exists we will go the HARDWARE path. Along with
this change some reorganization was done w/ the eeprom related files.

RTC: 196805
Change-Id: If2c4e5d3e338a1a10780740c1a019eb4af003b73
Reviewed-on: http://rchgit01.rchland.ibm.com/gerrit1/70822
Reviewed-by: Matt Derksen <mderkse1@us.ibm.com>
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Roland Veloz <rveloz@us.ibm.com>
Tested-by: Jenkins OP HW <op-hw-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

9 files changed, 329 insertions, 134 deletions

diff --git a/src/include/usr/devicefw/userif.H b/src/include/usr/devicefw/userif.H
index 523537cfb..d626d49c0 100644
--- a/src/include/usr/devicefw/userif.H
+++ b/src/include/usr/devicefw/userif.H
@@ -326,12 +326,14 @@ namespace DeviceFW
     /**
      * Construct the device addressing parameters for the EEPROM device ops.
      * @param[in] i_eeprom_enum - The chip number of the EEPROM to access. See
-     *                            eeprom_chip_types_t in eepromif.H
+     *                            EEPROM_ROLE in eeprom_const.H
      * @param[in] i_offset - The internal offset of the EEPROM slave device.
+     * @param[in] i_deviceSelect - Choose which device you want to perform op on:
+     *                             AUTOSELECT , CACHE, or HARDWARE
      */
-    #define DEVICE_EEPROM_ADDRESS( i_eeprom_enum, i_offset )\
+    #define DEVICE_EEPROM_ADDRESS( i_eeprom_enum, i_offset, i_deviceSelect )\
         DeviceFW::EEPROM, static_cast<uint64_t>(( i_eeprom_enum )),\
-            static_cast<uint64_t>(( i_offset ))
+            static_cast<uint64_t>(( i_offset )), static_cast<uint64_t>((i_deviceSelect))
 
     /**
      * Construct the device addressing parameters for the TPM device ops.
diff --git a/src/include/usr/errl/errli2c.H b/src/include/usr/errl/errli2c.H
index bc1617e13..3875c9f4e 100644
--- a/src/include/usr/errl/errli2c.H
+++ b/src/include/usr/errl/errli2c.H
@@ -62,7 +62,7 @@ struct I2cMatchingInfo_t
     uint8_t port;
     uint8_t devAddr;
     uint8_t chipCount;
-    EEPROM::eeprom_chip_types_t chipType;
+    EEPROM::EEPROM_ROLE chipType;
     const TARGETING::Target* tgt;
     uint8_t targetAncestryDepth;
 };
diff --git a/src/include/usr/i2c/eepromCache_const.H b/src/include/usr/i2c/eepromCache_const.H
deleted file mode 100644
index e94798b79..000000000
--- a/src/include/usr/i2c/eepromCache_const.H
+++ /dev/null
@@ -1,73 +0,0 @@
-/* IBM_PROLOG_BEGIN_TAG                                                   */
-/* This is an automatically generated prolog.                             */
-/*                                                                        */
-/* $Source: src/include/usr/i2c/eepromCache_const.H $                     */
-/*                                                                        */
-/* OpenPOWER HostBoot Project                                             */
-/*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2019                             */
-/* [+] International Business Machines Corp.                              */
-/*                                                                        */
-/*                                                                        */
-/* 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 EEPROM_CACHE_CONST_H
-#define __EEPROM_CACHE_CONST_H
-
-constexpr uint8_t MAX_EEPROMS_VERSION_1 = 50;
-constexpr uint8_t INVALID_EEPROM_INDEX  = 0xFF;
-constexpr uint32_t UNSET_INTERNAL_OFFSET_VALUE = 0xFFFFFFFF;
-constexpr uint32_t UNSET_END_OF_CACHE_VALUE = UNSET_INTERNAL_OFFSET_VALUE;
-
-enum EECACHE_VERSION
-{
-    EECACHE_VERSION_UNSET   = 0xFF,
-    EECACHE_VERSION_1       = 0x01,
-    EECACHE_VERSION_LATEST  = EECACHE_VERSION_1,
-};
-
-enum EEPROM_ATTRIBUTE_MASK : uint8_t
-{
-  HAS_EEPROM_NV_INFO           = 0x01,
-  HAS_EEPROM_SBE_BACKUP_INFO   = 0x02,
-  HAS_EEPROM_SBE_PRIMARY_INFO  = 0x04,
-  HAS_EEPROM_VPD_BACKUP_INFO   = 0x08,
-  HAS_EEPROM_VPD_PRIMARY_INFO  = 0x10,
-};
-
-
-struct eepromRecordHeader
-{
-    uint32_t target_huid;
-    uint8_t  port;
-    uint8_t  engine;
-    uint8_t  devAddr;
-    uint32_t mux_huid;
-    uint8_t  mux_select;
-    uint32_t record_size;
-    uint32_t internal_offset;
-    uint8_t  record_valid;
-} PACKED ;
-                                                                    //record_size      // internal_offset //record_valid
-constexpr size_t RECORD_COMPARE_SIZE = sizeof(eepromRecordHeader) - sizeof(uint32_t) - sizeof(uint32_t) - sizeof(uint8_t);
-
-struct eecacheSectionHeader
-{
-    uint8_t version;
-    uint32_t end_of_cache;
-    eepromRecordHeader recordHeaders[MAX_EEPROMS_VERSION_1];
-} PACKED ;
-
-
-#endif
\ No newline at end of file
diff --git a/src/include/usr/i2c/eeprom_const.H b/src/include/usr/i2c/eeprom_const.H
new file mode 100644
index 000000000..e9e157757
--- /dev/null
+++ b/src/include/usr/i2c/eeprom_const.H
@@ -0,0 +1,239 @@
+/* IBM_PROLOG_BEGIN_TAG                                                   */
+/* This is an automatically generated prolog.                             */
+/*                                                                        */
+/* $Source: src/include/usr/i2c/eeprom_const.H $                          */
+/*                                                                        */
+/* OpenPOWER HostBoot Project                                             */
+/*                                                                        */
+/* Contributors Listed Below - COPYRIGHT 2019                             */
+/* [+] International Business Machines Corp.                              */
+/*                                                                        */
+/*                                                                        */
+/* 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 __EEPROM_CONST_H
+#define __EEPROM_CONST_H
+
+#include <devicefw/driverif.H>
+#include <targeting/common/entitypath.H>
+#include <string.h>
+
+namespace EEPROM
+{
+
+// Hardware OP related consts
+constexpr uint16_t EEPROM_PAGE_SIZE = 0x100;
+constexpr uint8_t  EEPROM_DEVADDR_INC = 2;
+constexpr uint8_t MAX_BYTE_ADDR = 2;
+constexpr uint8_t EEPROM_MAX_RETRIES = 2;
+
+// EECACHE OP related consts
+constexpr uint8_t  INVALID_EEPROM_INDEX  = 0xFF;
+constexpr uint32_t UNSET_INTERNAL_OFFSET_VALUE = 0xFFFFFFFF;
+constexpr uint32_t UNSET_END_OF_CACHE_VALUE = UNSET_INTERNAL_OFFSET_VALUE;
+constexpr uint8_t  NUM_BYTE_UNIQUE_ID = 12;
+constexpr uint8_t  MAX_EEPROMS_VERSION_1 = 50;
+
+/**
+ * @brief Enumerations to link EEPROM types to EEPROM's chip number behind
+ *        a device
+*/
+enum EEPROM_ROLE
+{
+  VPD_PRIMARY   = 0,
+  VPD_BACKUP    = 1,
+  SBE_PRIMARY   = 2,
+  SBE_BACKUP    = 3,
+  LAST_CHIP_TYPE,
+  // Useful Enums
+  INVALID_CHIP_TYPE = LAST_CHIP_TYPE,
+  FIRST_CHIP_TYPE = VPD_PRIMARY
+};
+
+/**
+ * @brief Enumerations to help direct if we want to perform a given op on
+ *        the eeprom cache in pnor or the actual hardware. Or if the user
+ *        wants the driver to determine if reading from cache is possible, and
+ *        if not fall back to doing the op on HW (AUTOSELECT)
+*/
+enum EEPROM_SOURCE
+{
+    AUTOSELECT = 0x0000,
+    CACHE      = 0x0001,
+    HARDWARE   = 0x0002,
+};
+
+/**
+* @brief Enumerations to describe the type of devices to be accessed.
+*/
+typedef enum
+{
+    ZERO_BYTE_ADDR             = 0,
+    ONE_BYTE_ADDR_PAGESELECT   = 1,  // page select
+    TWO_BYTE_ADDR              = 2,
+    ONE_BYTE_ADDR              = 3,
+    LAST_DEVICE_TYPE
+} eeprom_addr_size_t;
+
+/**
+* @brief Enumerations to describe version of the eepromRecordHeader
+*        and eecacheSectionHeader structs
+*/
+enum EECACHE_VERSION
+{
+    EECACHE_VERSION_UNSET = 0xFF,
+    EECACHE_VERSION_1     = 0x01,
+    // Useful Enum
+    EECACHE_VERSION_LATEST = EECACHE_VERSION_1,
+};
+
+/**
+* @brief Handy union of two structs which represents the layout
+*        of bits to describe a record in the EECACHE ToC. The
+*        EECACHE ToC will have room for multiple of these record
+*        headers.
+*
+*        completeRecord is the standard way to access data in the union.
+*
+*        uniqueRecord is useful if you want to quickly compare the "unique"
+*        bits of a header entry which includes the target_huid, port, engine,
+*        devAddr, mux_huid, and mux_select.
+*
+*/
+union eepromRecordHeader
+{
+    struct completeRecord
+    {
+        uint32_t i2c_master_huid;   // HUID of i2c Master
+        uint8_t  port;              // I2C Port
+        uint8_t  engine;            // I2C Engine
+        uint8_t  devAddr;           // I2C Device Address
+        uint8_t  mux_select;        // Some I2C devices are behind a mux, this says
+                                    // what setting on the mux is required
+        uint32_t cache_copy_size;   // Size of data saved in cache (in KB)
+        uint32_t internal_offset;   // offset from start of EECACHE section where cached
+                                    // data exists
+        uint8_t  cached_copy_valid; // if == 0 , cached data is invalid
+    } PACKED completeRecord;
+
+    struct uniqueRecord
+    {
+        uint8_t uniqueID [NUM_BYTE_UNIQUE_ID];
+        uint8_t metaData [sizeof(completeRecord) - NUM_BYTE_UNIQUE_ID];
+    } PACKED uniqueRecord;
+
+    inline bool operator<(const eepromRecordHeader& rhs) const{
+      return memcmp(this->uniqueRecord.uniqueID, rhs.uniqueRecord.uniqueID, NUM_BYTE_UNIQUE_ID) < 0;
+    }
+
+    // Default ctor
+    eepromRecordHeader()
+    {
+        memset(this, 0, sizeof(eepromRecordHeader));
+    };
+
+} PACKED;
+
+/**
+* @brief Struct which represents the Table of Contents (ToC) for
+*        the EECACHE section in pnor
+*
+*/
+struct eecacheSectionHeader
+{
+    uint8_t version;         // EECACHE_VERSION
+    uint32_t end_of_cache;   // End point of the last cache entry
+    eepromRecordHeader recordHeaders[MAX_EEPROMS_VERSION_1];
+} PACKED ;
+
+/**
+ * @brief Structure of common parameters describing a unqiue eeprom.
+ *        This is used all over the eeprom code, often functions will
+ *        fill in information they know and pass on the struct.
+ *
+ *        Some functions require fields to be filled in prior to being
+ *        passed to said function.
+ */
+struct eeprom_addr_t
+{
+    uint64_t port;
+    uint64_t engine;
+    uint64_t devAddr;
+    int64_t  eepromRole;
+    uint64_t offset;
+    eeprom_addr_size_t addrSize;
+    TARGETING::EntityPath i2cMasterPath;
+    uint64_t writePageSize;  // in bytes
+    uint64_t devSize_KB;     // in kilobytes
+    uint64_t chipCount;      // number of chips making up eeprom device
+    uint64_t writeCycleTime;  // in milliseconds
+    uint8_t i2cMuxBusSelector;
+    TARGETING::EntityPath i2cMuxPath;
+
+    /**
+     *  @brief Construct a default eeprom_addr_t
+     */
+    eeprom_addr_t()
+        : port(0),
+          engine(0),
+          devAddr(0),
+          eepromRole(INVALID_CHIP_TYPE),
+          offset(0),
+          addrSize(LAST_DEVICE_TYPE),
+          i2cMasterPath(TARGETING::EntityPath::PATH_NA),
+          writePageSize(0),
+          devSize_KB(0),
+          chipCount(0),
+          writeCycleTime(0),
+          i2cMuxBusSelector(I2C_MUX::NOT_APPLICABLE),
+          i2cMuxPath(TARGETING::EntityPath::PATH_NA)
+    {
+    }
+};
+
+
+/**
+ * @brief Define a set of information about all EEPROMs in the
+ *        system (primarily used to populate HDAT)
+ */
+struct EepromInfo_t
+{
+    TARGETING::Target* i2cMaster; //< I2C Master chip
+    uint64_t engine; //< I2C engine (relative to master chip)
+    uint64_t port; //< I2C port (relative to engine)
+    uint64_t busFreq; //< Bus speed in Hz
+    uint64_t devAddr; //< I2C device address (relative to port)
+    uint64_t sizeKB; //< Total eeprom size in KB
+    uint64_t chipCount; //< Number of chips making up eeprom device
+    uint64_t addrBytes; //< Number of bytes required for addressing
+    EEPROM_ROLE device; //< Identifies role of eeprom
+    TARGETING::Target* assocTarg; //< Target associated with this device
+
+    EepromInfo_t()
+      : i2cMaster(nullptr),
+        engine(0),
+        port(0),
+        busFreq(0),
+        devAddr(0),
+        sizeKB(0),
+        chipCount(0),
+        addrBytes(0),
+        device(INVALID_CHIP_TYPE),
+        assocTarg(nullptr)
+    {
+    }
+};
+
+}
+#endif
\ No newline at end of file
diff --git a/src/include/usr/i2c/eepromddreasoncodes.H b/src/include/usr/i2c/eepromddreasoncodes.H
index 454d10851..a2c7b1c83 100644
--- a/src/include/usr/i2c/eepromddreasoncodes.H
+++ b/src/include/usr/i2c/eepromddreasoncodes.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2011,2015                        */
+/* Contributors Listed Below - COPYRIGHT 2011,2019                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -54,6 +54,9 @@ enum eepromModuleId
     EEPROM_PREPAREADDRESS                   = 0x04,
     EEPROM_READATTRIBUTES                   = 0x05,
     EEPROM_GETI2CMASTERTARGET               = 0x06,
+    EEPROM_CACHE_EEPROM                     = 0x07,
+    EEPROM_CLEAR_EECACHE                    = 0x08,
+    EEPROM_CACHE_PERFORM_OP                 = 0x09,
 };
 
 /**
@@ -74,12 +77,22 @@ enum eepromReasonCode
     EEPROM_INVALID_ADDR_OFFSET_SIZE         = EEPROM_COMP_ID | 0x07,
     EEPROM_OVERFLOW_ERROR                   = EEPROM_COMP_ID | 0x08,
     EEPROM_I2C_WRITE_PAGE_SIZE_ZERO         = EEPROM_COMP_ID | 0x09,
+    EEPROM_FAILED_TO_FLUSH_CONTENTS         = EEPROM_COMP_ID | 0x0A,   // Error occured while trying to flush the mmio pages out
+                                                                       // containing contents of an EEPROM's cached data in the EECACHE
+                                                                       // PNOR section
+    EEPROM_FAILED_TO_FLUSH_HEADER           = EEPROM_COMP_ID | 0x0B,   // Error occured while trying to flush the mmio page out
+                                                                       // containing EECACHE header the to pnor
+    EEPROM_I2C_MUX_PATH_ERROR               = EEPROM_COMP_ID | 0x0C,
+    EEPROM_NOT_IN_CACHE                     = EEPROM_COMP_ID | 0x0D,
+    EEPROM_NEW_DEVICE_DETECTED              = EEPROM_COMP_ID | 0x0E,   // While looking up a part, found that current EEPROM size does not
+                                                                       // match what we have seen in previous IPLs indicating a new part has
+                                                                       // been installed on the system.
 };
 
 enum UserDetailsTypes
 {
-        EEPROM_UDT_NO_FORMAT       = 0x0,
-        EEPROM_UDT_PARAMETERS      = 0x1,
+    EEPROM_UDT_NO_FORMAT       = 0x0,
+    EEPROM_UDT_PARAMETERS      = 0x1,
 };
 
 };  // end EEPROM
diff --git a/src/include/usr/i2c/eepromif.H b/src/include/usr/i2c/eepromif.H
index 62618e195..63b8422f3 100644
--- a/src/include/usr/i2c/eepromif.H
+++ b/src/include/usr/i2c/eepromif.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2018                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2019                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -26,35 +26,12 @@
 #define __EEPROMIF_H
 
 #include <list>
+#include <i2c/eeprom_const.H>
 
 namespace EEPROM
 {
 
 /**
- * @brief Enumerations to link EEPROM types to EEPROM's chip number behind
- *        a device
-*/
-typedef enum
-{
-  VPD_PRIMARY   = 0,
-  VPD_BACKUP    = 1,
-  SBE_PRIMARY   = 2,
-  SBE_BACKUP    = 3,
-  LAST_CHIP_TYPE,
-  INVALID_CHIP_TYPE = LAST_CHIP_TYPE,
-  FIRST_CHIP_TYPE = VPD_PRIMARY
-} eeprom_chip_types_t;
-
-/*
- * @brief Miscellaneous enums for EEPROM
- */
-enum
-{
-    EEPROM_PAGE_SIZE = 0x100,
-    EEPROM_DEVADDR_INC = 2
-};
-
-/**
  * @brief This function tests to see if the VPD_PRIMARY eeprom is present
  *        for the specific target.
  *
@@ -65,26 +42,49 @@ enum
 bool eepromPresence ( TARGETING::Target * i_target );
 
 /**
- * @brief Define a set of information about all EEPROMs in the
- *        system (primarily used to populate HDAT)
+ * @brief this function will read all of the associated attributes needed
+ *      to access the intended EEPROM.  These attributes will be used to
+ *      determine the type of I2C device as well as how to address it via
+ *      the I2C device driver.
+ *
+ * @param[in] i_target - Target device.
+ *
+ * @param[out] o_i2cInfo - The structure that will contain the attribute data
+ *      read from the target device.
+ *
+ * @return errlHndl_t - NULL if successful, otherwise a pointer to the
+ *      error log.
  */
-struct EepromInfo_t
-{
-    TARGETING::Target* i2cMaster; //< I2C Master chip
-    uint64_t engine; //< I2C engine (relative to master chip)
-    uint64_t port; //< I2C port (relative to engine)
-    uint64_t busFreq; //< Bus speed in Hz
-    uint64_t devAddr; //< I2C device address (relative to port)
-    uint64_t sizeKB; //< Total eeprom size in KB
-    uint64_t chipCount; //< Number of chips making up eeprom device
-    uint64_t addrBytes; //< Number of bytes required for addressing
-    eeprom_chip_types_t device; //< Identifies role of eeprom
-    TARGETING::Target* assocTarg; //< Target associated with this device
-};
+errlHndl_t eepromReadAttributes ( TARGETING::Target * i_target,
+                                  eeprom_addr_t & o_i2cInfo );
+
+
+/**
+ * @brief This function determines whether or not the i2cMasterPath provided
+ *        along with i_i2cInfo points to a valid target. If it does not,
+ *        o_target will result as NULL. If the target is valid then the
+ *        o_target will point to the target pointer which i2cMasterPath
+ *        represents.
+ *
+ * @param[in] i_target - The current Target.
+ *
+ * @param[in] i_i2cInfo - Structure of I2C parameters needed to execute
+ *      the command to the I2C device driver.
+ *      NOTE: it is expected i2cMasterPath member is filled out
+ *
+ * @param[out] o_target - The "new" target that will be used for all operations
+ *      from this point on.
+ *
+ * @return errlHndl_t - NULL if successful, otherwise a pointer to the
+ *      error log.
+ */
+errlHndl_t eepromGetI2CMasterTarget ( TARGETING::Target * i_target,
+                                      const eeprom_addr_t & i_i2cInfo,
+                                      TARGETING::Target * &o_target );
 
 /**
  * @brief Return a set of information related to every unique
- *        EEPROM in the system
+ *        EEPROM in the system (currently used to build HDAT structure)
  *
  * @param[out] o_info - list of EEPROM Information
  *
@@ -93,6 +93,26 @@ struct EepromInfo_t
  */
 void getEEPROMs( std::list<EepromInfo_t>& o_info );
 
+/**
+ *
+ * @brief A useful utility to dump (trace out) the EepromVpdPrimaryInfo data.
+ *        Use as needed.
+ *
+ * @param [in] i_i2cInfo - The EepromVpdPrimaryInfo data to dump for user
+ *
+ */
+void dumpEepromData(const TARGETING::EepromVpdPrimaryInfo & i_i2cInfo);
+
+/**
+ *
+ * @brief A useful utility to dump (trace out) the eeprom_addr_t data.
+ *         Use as needed.
+ *
+ * @param [in] i_i2cInfo - The eeprom_addr_t data to dump for user
+ *
+ */
+void dumpEepromData(const eeprom_addr_t & i_i2cInfo);
+
 };  // end namespace EEPROM
 
 #endif  // end __EEPROMIF_H
diff --git a/src/include/usr/i2c/i2creasoncodes.H b/src/include/usr/i2c/i2creasoncodes.H
index a723e4ec8..6b08aefc2 100644
--- a/src/include/usr/i2c/i2creasoncodes.H
+++ b/src/include/usr/i2c/i2creasoncodes.H
@@ -66,8 +66,6 @@ enum i2cModuleId
     READ_I2C_ATTRIBUTES                 = 0x10,
     I2C_ACCESS_MUX                      = 0x11,
     I2C_GENERIC_PRES_DETECT             = 0x12,
-    I2C_CACHE_EEPROM                    = 0x13,
-    I2C_CLEAR_EECACHE                   = 0x14,
 };
 
 
@@ -103,11 +101,7 @@ enum i2cReasonCode
     I2C_MUX_TARGET_NON_FUNCTIONAL        = I2C_COMP_ID | 0x15,   // The MUX target is non functional
     I2C_INVALID_LENGTH                   = I2C_COMP_ID | 0x16,   // Invalid data buffer length passed to function
     I2C_NULL_MASTER_TARGET               = I2C_COMP_ID | 0x17,   // Target Service's toPath() returned nullptr for target
-    I2C_FAILED_TO_FLUSH_CONTENTS         = I2C_COMP_ID | 0x18,   // Error occured while trying to flush the mmio pages out
-                                                                 // containing contents of an EEPROM's cached data in the EECACHE
-                                                                 // PNOR section
-    I2C_FAILED_TO_FLUSH_HEADER           = I2C_COMP_ID | 0x19,   // Error occured while trying to flush the mmio page out
-};                                                               // containing EECACHE header the to pnor
+};
 
 
 enum UserDetailsTypes
diff --git a/src/include/usr/sbe/sbe_update.H b/src/include/usr/sbe/sbe_update.H
index f4dc648b7..b388c4cae 100644
--- a/src/include/usr/sbe/sbe_update.H
+++ b/src/include/usr/sbe/sbe_update.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2018                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2019                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -31,7 +31,7 @@
 #include <errl/errlentry.H>           // errlHndl_t
 #include <errl/hberrltypes.H>         // ERRORLOG::errlSeverity_t
 #include <targeting/common/target.H>  // Target
-#include <i2c/eepromif.H>             // eeprom_chip_types_t
+#include <i2c/eepromif.H>             // EEPROM_ROLE
 #include <pnor/ecc.H>                 // PNOR::ECC::eccStatus
 #include <util/utilxipimage.H>        // Util::imageBuild_t
 #include <p9_infrastruct_help.H>      // MAX_RING_BUF_SIZE, etc
@@ -175,7 +175,7 @@ namespace SBE
 
         // Update Fields and New Fields to be Written to the Target
         sbeUpdateActions_t            update_actions;
-        EEPROM::eeprom_chip_types_t   seeprom_side_to_update;
+        EEPROM::EEPROM_ROLE   seeprom_side_to_update;
 
         sbeSeepromVersionInfo_t       new_seeprom_ver;
         bool                          new_readBack_check;
@@ -342,7 +342,7 @@ namespace SBE
      * @return errlHndl_t    Error log handle on failure.
      */
     errlHndl_t getSeepromSideVersionViaI2c(TARGETING::Target* i_target,
-                                     EEPROM::eeprom_chip_types_t i_seepromSide,
+                                     EEPROM::EEPROM_ROLE i_seepromSide,
                                      sbeSeepromVersionInfo_t& o_info,
                                      bool& o_seeprom_ver_ECC_fail);
     /**
diff --git a/src/include/usr/sbe/sbeif.H b/src/include/usr/sbe/sbeif.H
index 022be1d72..0fa909f4a 100644
--- a/src/include/usr/sbe/sbeif.H
+++ b/src/include/usr/sbe/sbeif.H
@@ -5,7 +5,7 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* Contributors Listed Below - COPYRIGHT 2013,2018                        */
+/* Contributors Listed Below - COPYRIGHT 2013,2019                        */
 /* [+] International Business Machines Corp.                              */
 /*                                                                        */
 /*                                                                        */
@@ -146,7 +146,7 @@ namespace SBE
      * @return errlHndl_t     Error log handle on failure; otherwise nullptr
      */
     errlHndl_t getHwKeyHashFromSbeImage(TARGETING::Target* i_target,
-                                        EEPROM::eeprom_chip_types_t i_seeprom,
+                                        EEPROM::EEPROM_ROLE i_seeprom,
                                         sbeSeepromSide_t i_bootSide,
                                         SHA512_t o_hash,
                                         const void * i_image_ptr = nullptr);