diff --git a/presence/anyof.cpp b/presence/anyof.cpp
index 4dc2ec3..54a0ec0 100644
--- a/presence/anyof.cpp
+++ b/presence/anyof.cpp
@@ -34,8 +34,9 @@
 static const auto powerOnDelayTime = 5s;
 
 AnyOf::AnyOf(const Fan& fan,
-             const std::vector<std::reference_wrapper<PresenceSensor>>& s) :
-    RedundancyPolicy(fan),
+             const std::vector<std::reference_wrapper<PresenceSensor>>& s,
+             std::unique_ptr<EEPROMDevice> e) :
+    RedundancyPolicy(fan, std::move(e)),
     state(), _powerState(getPowerStateObject()),
     _powerOnDelayTimer(sdeventplus::Event::get_default(),
                        std::bind(&AnyOf::delayedAfterPowerOn, this)),
@@ -78,6 +79,18 @@
                         [](const auto& s) { return std::get<presentPos>(s); });
         setPresence(fan, newState);
 
+        if (eepromDevice && (newState != origState))
+        {
+            if (newState)
+            {
+                eepromDevice->bind();
+            }
+            else
+            {
+                eepromDevice->unbind();
+            }
+        }
+
         // At least 1 sensor said a fan was present, check if any disagree.
         if (newState)
         {
diff --git a/presence/anyof.hpp b/presence/anyof.hpp
index 91865b0..03fd1a4 100644
--- a/presence/anyof.hpp
+++ b/presence/anyof.hpp
@@ -41,9 +41,11 @@
      *
      * @param[in] fan - The fan associated with the policy.
      * @param[in] s - The set of sensors associated with the policy.
+     * @param[in] e - EEPROM device instance
      */
     AnyOf(const Fan& fan,
-          const std::vector<std::reference_wrapper<PresenceSensor>>& s);
+          const std::vector<std::reference_wrapper<PresenceSensor>>& s,
+          std::unique_ptr<EEPROMDevice> e);
 
     /**
      * @brief stateChanged
diff --git a/presence/config_files/p10bmc/ibm,everest/config.json b/presence/config_files/p10bmc/ibm,everest/config.json
index 928eca2..3ee7500 100644
--- a/presence/config_files/p10bmc/ibm,everest/config.json
+++ b/presence/config_files/p10bmc/ibm,everest/config.json
@@ -19,6 +19,11 @@
       ],
       "rpolicy": {
          "type": "anyof"
+      },
+      "eeprom": {
+          "bus_address": "31-0050",
+          "driver_name": "at24",
+          "bind_delay_ms": 1000
       }
    },
    {
@@ -41,6 +46,11 @@
       ],
       "rpolicy": {
          "type": "anyof"
+      },
+      "eeprom": {
+          "bus_address": "32-0050",
+          "driver_name": "at24",
+          "bind_delay_ms": 1000
       }
    },
    {
@@ -63,6 +73,11 @@
       ],
       "rpolicy": {
          "type": "anyof"
+      },
+      "eeprom": {
+          "bus_address": "33-0050",
+          "driver_name": "at24",
+          "bind_delay_ms": 1000
       }
    },
    {
@@ -85,6 +100,11 @@
       ],
       "rpolicy": {
          "type": "anyof"
+      },
+      "eeprom": {
+          "bus_address": "34-0050",
+          "driver_name": "at24",
+          "bind_delay_ms": 1000
       }
    }
 ]
diff --git a/presence/eeprom_device.hpp b/presence/eeprom_device.hpp
new file mode 100644
index 0000000..883cc17
--- /dev/null
+++ b/presence/eeprom_device.hpp
@@ -0,0 +1,141 @@
+#pragma once
+
+#include "sdeventplus.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+#include <sdeventplus/clock.hpp>
+#include <sdeventplus/utility/timer.hpp>
+
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+namespace phosphor::fan::presence
+{
+using namespace phosphor::fan::util;
+
+/**
+ * @class EEPROMDevice
+ *
+ * Provides an API to bind an EEPROM driver to a device, after waiting
+ * a configurable amount of time in case the device needs time
+ * to initialize after being plugged into a system.
+ */
+class EEPROMDevice
+{
+  public:
+    EEPROMDevice() = delete;
+    ~EEPROMDevice() = default;
+    EEPROMDevice(const EEPROMDevice&) = delete;
+    EEPROMDevice& operator=(const EEPROMDevice&) = delete;
+    EEPROMDevice(EEPROMDevice&&) = delete;
+    EEPROMDevice& operator=(EEPROMDevice&&) = delete;
+
+    /**
+     * @brief Constructor
+     * @param[in] address - The bus-address string as used by drivers
+     *                      in sysfs.
+     * @param[in] driver - The I2C driver name in sysfs
+     * @param[in] bindDelayInMS - The time in milliseconds to wait
+     *            before actually doing the bind.
+     */
+    EEPROMDevice(const std::string& address, const std::string& driver,
+                 size_t bindDelayInMS) :
+        address(address),
+        path(baseDriverPath / driver), bindDelay(bindDelayInMS),
+        timer(SDEventPlus::getEvent(),
+              std::bind(std::mem_fn(&EEPROMDevice::bindTimerExpired), this))
+    {}
+
+    /**
+     * @brief Kicks off the timer to do the actual bind
+     */
+    void bind()
+    {
+        timer.restartOnce(std::chrono::milliseconds{bindDelay});
+    }
+
+    /**
+     * @brief Stops the bind timer if running and unbinds the device
+     */
+    void unbind()
+    {
+        if (timer.isEnabled())
+        {
+            timer.setEnabled(false);
+        }
+
+        unbindDevice();
+    }
+
+  private:
+    /**
+     * @brief When the bind timer expires it will bind the device.
+     */
+    void bindTimerExpired() const
+    {
+        unbindDevice();
+
+        auto bindPath = path / "bind";
+        std::ofstream bind{bindPath};
+        if (bind.good())
+        {
+            lg2::info("Binding fan EEPROM device with address {ADDRESS}",
+                      "ADDRESS", address);
+            bind << address;
+        }
+
+        if (bind.fail())
+        {
+            lg2::error("Error while binding fan EEPROM device with path {PATH}"
+                       " and address {ADDR}",
+                       "PATH", bindPath, "ADDR", address);
+        }
+    }
+
+    /**
+     * @brief Unbinds the device.
+     */
+    void unbindDevice() const
+    {
+        auto devicePath = path / address;
+        if (!std::filesystem::exists(devicePath))
+        {
+            return;
+        }
+
+        auto unbindPath = path / "unbind";
+        std::ofstream unbind{unbindPath};
+        if (unbind.good())
+        {
+            unbind << address;
+        }
+
+        if (unbind.fail())
+        {
+            lg2::error("Error while unbinding fan EEPROM device with path"
+                       " {PATH} and address {ADDR}",
+                       "PATH", unbindPath, "ADDR", address);
+        }
+    }
+
+    /** @brief The base I2C drivers directory in sysfs */
+    const std::filesystem::path baseDriverPath{"/sys/bus/i2c/drivers"};
+
+    /**
+     * @brief The address string with the i2c bus and address.
+     * Example: '32-0050'
+     */
+    const std::string address;
+
+    /** @brief The path to the driver dir, like /sys/bus/i2c/drivers/at24 */
+    const std::filesystem::path path;
+
+    /** @brief Number of milliseconds to delay to actually do the bind. */
+    const size_t bindDelay{};
+
+    /** @brief The timer to do the delay with */
+    sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic> timer;
+};
+
+} // namespace phosphor::fan::presence
diff --git a/presence/fallback.cpp b/presence/fallback.cpp
index 36824fc..a3c5e72 100644
--- a/presence/fallback.cpp
+++ b/presence/fallback.cpp
@@ -62,6 +62,18 @@
     }
 
     setPresence(fan, present);
+
+    if (eepromDevice)
+    {
+        if (present)
+        {
+            eepromDevice->bind();
+        }
+        else
+        {
+            eepromDevice->unbind();
+        }
+    }
 }
 
 void Fallback::monitor()
diff --git a/presence/fallback.hpp b/presence/fallback.hpp
index d6bad02..db661e0 100644
--- a/presence/fallback.hpp
+++ b/presence/fallback.hpp
@@ -39,10 +39,12 @@
      *
      * @param[in] fan - The fan associated with the policy.
      * @param[in] s - The set of sensors associated with the policy.
+     * @param[in] e - EEPROM device instance
      */
     Fallback(const Fan& fan,
-             const std::vector<std::reference_wrapper<PresenceSensor>>& s) :
-        RedundancyPolicy(fan),
+             const std::vector<std::reference_wrapper<PresenceSensor>>& s,
+             std::unique_ptr<EEPROMDevice> e) :
+        RedundancyPolicy(fan, std::move(e)),
         sensors(s)
     {
         activeSensor = sensors.begin();
diff --git a/presence/json_parser.cpp b/presence/json_parser.cpp
index 02c9a11..dbdc54b 100644
--- a/presence/json_parser.cpp
+++ b/presence/json_parser.cpp
@@ -168,13 +168,37 @@
             timeUntilError = member["fan_missing_error_time"].get<size_t>();
         }
 
+        std::unique_ptr<EEPROMDevice> eepromDevice;
+        if (member.contains("eeprom"))
+        {
+            const auto& eeprom = member.at("eeprom");
+            if (!eeprom.contains("bus_address") ||
+                !eeprom.contains("driver_name") ||
+                !eeprom.contains("bind_delay_ms"))
+            {
+                log<level::ERR>(
+                    "Missing address, driver_name, or bind_delay_ms in eeprom "
+                    "section",
+                    entry("FAN_NAME=%s",
+                          member["name"].get<std::string>().c_str()));
+
+                throw std::runtime_error("Missing address, driver_name, or "
+                                         "bind_delay_ms in eeprom section");
+            }
+            eepromDevice = std::make_unique<EEPROMDevice>(
+                eeprom["bus_address"].get<std::string>(),
+                eeprom["driver_name"].get<std::string>(),
+                eeprom["bind_delay_ms"].get<size_t>());
+        }
+
         auto fan =
             std::make_tuple(member["name"], member["path"], timeUntilError);
         // Create a fan object
         fans.emplace_back(std::make_tuple(fan, std::move(sensors)));
 
         // Add fan presence policy
-        auto policy = getPolicy(member["rpolicy"], fans.back());
+        auto policy =
+            getPolicy(member["rpolicy"], fans.back(), std::move(eepromDevice));
         if (policy)
         {
             policies.emplace_back(std::move(policy));
@@ -199,7 +223,8 @@
 }
 
 std::unique_ptr<RedundancyPolicy>
-    JsonConfig::getPolicy(const json& rpolicy, const fanPolicy& fpolicy)
+    JsonConfig::getPolicy(const json& rpolicy, const fanPolicy& fpolicy,
+                          std::unique_ptr<EEPROMDevice> eepromDevice)
 {
     if (!rpolicy.contains("type"))
     {
@@ -219,7 +244,7 @@
     if (func != _rpolicies.end())
     {
         // Call function for redundancy policy type and return the policy
-        return func->second(fpolicy);
+        return func->second(fpolicy, std::move(eepromDevice));
     }
     else
     {
@@ -326,7 +351,8 @@
 namespace rpolicy
 {
 // Get an `Anyof` redundancy policy for the fan
-std::unique_ptr<RedundancyPolicy> getAnyof(const fanPolicy& fan)
+std::unique_ptr<RedundancyPolicy>
+    getAnyof(const fanPolicy& fan, std::unique_ptr<EEPROMDevice> eepromDevice)
 {
     std::vector<std::reference_wrapper<PresenceSensor>> pSensors;
     for (auto& fanSensor : std::get<fanPolicySensorListPos>(fan))
@@ -334,11 +360,14 @@
         pSensors.emplace_back(*fanSensor);
     }
 
-    return std::make_unique<AnyOf>(std::get<fanPolicyFanPos>(fan), pSensors);
+    return std::make_unique<AnyOf>(std::get<fanPolicyFanPos>(fan), pSensors,
+                                   std::move(eepromDevice));
 }
 
 // Get a `Fallback` redundancy policy for the fan
-std::unique_ptr<RedundancyPolicy> getFallback(const fanPolicy& fan)
+std::unique_ptr<RedundancyPolicy>
+    getFallback(const fanPolicy& fan,
+                std::unique_ptr<EEPROMDevice> eepromDevice)
 {
     std::vector<std::reference_wrapper<PresenceSensor>> pSensors;
     for (auto& fanSensor : std::get<fanPolicySensorListPos>(fan))
@@ -347,7 +376,8 @@
         pSensors.emplace_back(*fanSensor);
     }
 
-    return std::make_unique<Fallback>(std::get<fanPolicyFanPos>(fan), pSensors);
+    return std::make_unique<Fallback>(std::get<fanPolicyFanPos>(fan), pSensors,
+                                      std::move(eepromDevice));
 }
 
 } // namespace rpolicy
diff --git a/presence/json_parser.hpp b/presence/json_parser.hpp
index 7dbe115..9fe5645 100644
--- a/presence/json_parser.hpp
+++ b/presence/json_parser.hpp
@@ -37,8 +37,8 @@
 using methodHandler =
     std::function<std::unique_ptr<PresenceSensor>(size_t, const json&)>;
 // Presence redundancy policy handler function
-using rpolicyHandler =
-    std::function<std::unique_ptr<RedundancyPolicy>(const fanPolicy&)>;
+using rpolicyHandler = std::function<std::unique_ptr<RedundancyPolicy>(
+    const fanPolicy&, std::unique_ptr<EEPROMDevice>)>;
 
 class JsonConfig
 {
@@ -123,11 +123,13 @@
      *
      * @param[in] rpolicy - policy type to construct
      * @param[in] fpolicy - fan policy object
+     * @param[in] eepromDevice - EEPROM device object
      *
      * @return - The constructed redundancy policy type for the fan
      */
-    std::unique_ptr<RedundancyPolicy> getPolicy(const json& rpolicy,
-                                                const fanPolicy& fpolicy);
+    std::unique_ptr<RedundancyPolicy>
+        getPolicy(const json& rpolicy, const fanPolicy& fpolicy,
+                  std::unique_ptr<EEPROMDevice> eepromDevice);
 };
 
 /**
@@ -167,20 +169,25 @@
  * sensors for a fan
  *
  * @param[in] fan - fan policy object with the presence sensors for the fan
+ * @param[in] eepromDevice - EEPROM device object
  *
  * @return - An `Anyof` redundancy policy
  */
-std::unique_ptr<RedundancyPolicy> getAnyof(const fanPolicy& fan);
+std::unique_ptr<RedundancyPolicy>
+    getAnyof(const fanPolicy& fan, std::unique_ptr<EEPROMDevice> eepromDevice);
 
 /**
  * @brief Create a `Fallback` redundancy policy on the created presence
  * sensors for a fan
  *
  * @param[in] fan - fan policy object with the presence sensors for the fan
+ * @param[in] eepromDevice - EEPROM device object
  *
  * @return - A `Fallback` redundancy policy
  */
-std::unique_ptr<RedundancyPolicy> getFallback(const fanPolicy& fan);
+std::unique_ptr<RedundancyPolicy>
+    getFallback(const fanPolicy& fan,
+                std::unique_ptr<EEPROMDevice> eepromDevice);
 
 } // namespace rpolicy
 
diff --git a/presence/rpolicy.hpp b/presence/rpolicy.hpp
index d596dfa..e190029 100644
--- a/presence/rpolicy.hpp
+++ b/presence/rpolicy.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "eeprom_device.hpp"
 #include "fan.hpp"
 
 namespace phosphor
@@ -35,8 +36,12 @@
      * @brief Construct a new Redundancy Policy.
      *
      * @param[in] fan - The fan associated with this policy.
+     * @param[in] eeprom - EEPROM device instance
      */
-    explicit RedundancyPolicy(const Fan& f) : fan(f)
+    explicit RedundancyPolicy(const Fan& f,
+                              std::unique_ptr<EEPROMDevice> eeprom) :
+        fan(f),
+        eepromDevice(std::move(eeprom))
     {}
 
     /**
@@ -62,6 +67,12 @@
   protected:
     /** @brief Fan name and inventory path. */
     const Fan& fan;
+
+    /**
+     * @brief Handles binding the EEPROM driver on fan plug
+     *        if configured to do so.
+     */
+    std::unique_ptr<EEPROMDevice> eepromDevice;
 };
 
 /**