diff --git a/include/HwmonTempSensor.hpp b/include/HwmonTempSensor.hpp
index af275ec..276f37d 100644
--- a/include/HwmonTempSensor.hpp
+++ b/include/HwmonTempSensor.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <DeviceMgmt.hpp>
 #include <Thresholds.hpp>
 #include <boost/asio/random_access_file.hpp>
 #include <sdbusplus/asio/object_server.hpp>
@@ -30,14 +31,20 @@
                     std::vector<thresholds::Threshold>&& thresholds,
                     const struct SensorParams& thisSensorParameters,
                     float pollRate, const std::string& sensorConfiguration,
-                    PowerState powerState);
+                    PowerState powerState,
+                    const std::shared_ptr<I2CDevice>& i2cDevice);
     ~HwmonTempSensor() override;
     void setupRead(void);
+    void activate(const std::string& newPath,
+                  const std::shared_ptr<I2CDevice>& newI2CDevice);
+    void deactivate(void);
+    bool isActive(void);
 
   private:
     // Ordering is important here; readBuf is first so that it's not destroyed
     // while async operations from other member fields might still be using it.
     std::array<char, 128> readBuf{};
+    std::shared_ptr<I2CDevice> i2cDevice;
     sdbusplus::asio::object_server& objServer;
     boost::asio::random_access_file inputDev;
     boost::asio::steady_timer waitTimer;
diff --git a/src/HwmonTempMain.cpp b/src/HwmonTempMain.cpp
index 79db947..e1b0d62 100644
--- a/src/HwmonTempMain.cpp
+++ b/src/HwmonTempMain.cpp
@@ -240,22 +240,95 @@
     return configMap;
 }
 
+boost::container::flat_map<std::string, std::shared_ptr<I2CDevice>>
+    instantiateDevices(
+        const ManagedObjectType& sensorConfigs,
+        const boost::container::flat_map<
+            std::string, std::shared_ptr<HwmonTempSensor>>& sensors)
+{
+    boost::container::flat_map<std::string, std::shared_ptr<I2CDevice>>
+        newSensors;
+    for (const auto& [path, sensor] : sensorConfigs)
+    {
+        for (const auto& [name, cfg] : sensor)
+        {
+            PowerState powerState = getPowerState(cfg);
+            if (!readingStateGood(powerState))
+            {
+                continue;
+            }
+
+            auto findSensorName = cfg.find("Name");
+            if (findSensorName == cfg.end())
+            {
+                continue;
+            }
+            std::string sensorName =
+                std::get<std::string>(findSensorName->second);
+
+            auto findSensor = sensors.find(sensorName);
+            if (findSensor != sensors.end() && findSensor->second != nullptr &&
+                findSensor->second->isActive())
+            {
+                continue;
+            }
+
+            std::optional<I2CDeviceParams> params =
+                getI2CDeviceParams(sensorTypes, cfg);
+            if (params.has_value() && !params->deviceStatic())
+            {
+                // There exist error cases in which a sensor device that we
+                // need is already instantiated, but needs to be destroyed and
+                // re-created in order to be useful (for example if we crash
+                // after instantiating a device and the sensor device's power
+                // is cut before we get restarted, leaving it "present" but
+                // not really usable).  To be on the safe side, instantiate a
+                // temporary device that's immediately destroyed so as to
+                // ensure that we end up with a fresh instance of it.
+                if (params->devicePresent())
+                {
+                    std::cerr << "Clearing out previous instance for "
+                              << path.str << "\n";
+                    I2CDevice tmp(*params);
+                }
+
+                try
+                {
+                    newSensors.emplace(path.str,
+                                       std::make_shared<I2CDevice>(*params));
+                }
+                catch (std::runtime_error&)
+                {
+                    std::cerr << "Failed to instantiate " << params->type->name
+                              << " at address " << params->address << " on bus "
+                              << params->bus << "\n";
+                }
+            }
+        }
+    }
+    return newSensors;
+}
+
 void createSensors(
     boost::asio::io_service& io, sdbusplus::asio::object_server& objectServer,
     boost::container::flat_map<std::string, std::shared_ptr<HwmonTempSensor>>&
         sensors,
     std::shared_ptr<sdbusplus::asio::connection>& dbusConnection,
     const std::shared_ptr<boost::container::flat_set<std::string>>&
-        sensorsChanged)
+        sensorsChanged,
+    bool activateOnly)
 {
     auto getter = std::make_shared<GetSensorConfiguration>(
         dbusConnection,
-        [&io, &objectServer, &sensors, &dbusConnection,
-         sensorsChanged](const ManagedObjectType& sensorConfigurations) {
+        [&io, &objectServer, &sensors, &dbusConnection, sensorsChanged,
+         activateOnly](const ManagedObjectType& sensorConfigurations) {
         bool firstScan = sensorsChanged == nullptr;
 
         SensorConfigMap configMap = buildSensorConfigMap(sensorConfigurations);
 
+        boost::container::flat_map<std::string, std::shared_ptr<I2CDevice>>
+            newSensors = instantiateDevices(sensorConfigurations, sensors);
+
         // IIO _raw devices look like this on sysfs:
         //     /sys/bus/iio/devices/iio:device0/in_temp_raw
         //     /sys/bus/iio/devices/iio:device0/in_temp_offset
@@ -324,6 +397,18 @@
             }
 
             const std::string& interfacePath = findSensorCfg->second.sensorPath;
+            auto findI2CDev = newSensors.find(interfacePath);
+            if (activateOnly && findI2CDev == newSensors.end())
+            {
+                continue;
+            }
+
+            std::shared_ptr<I2CDevice> i2cDev;
+            if (findI2CDev != newSensors.end())
+            {
+                i2cDev = findI2CDev->second;
+            }
+
             const SensorData& sensorData = findSensorCfg->second.sensorData;
             const std::string& sensorType = findSensorCfg->second.interface;
             const SensorBaseConfigMap& baseConfigMap =
@@ -385,7 +470,10 @@
 
             auto permitSet = getPermitSet(baseConfigMap);
             auto& sensor = sensors[sensorName];
-            sensor = nullptr;
+            if (!activateOnly)
+            {
+                sensor = nullptr;
+            }
             auto hwmonFile =
                 getFullHwmonFilePath(directory.string(), "temp1", permitSet);
             if (pathStr.starts_with("/sys/bus/iio/devices"))
@@ -394,11 +482,19 @@
             }
             if (hwmonFile)
             {
-                sensor = std::make_shared<HwmonTempSensor>(
-                    *hwmonFile, sensorType, objectServer, dbusConnection, io,
-                    sensorName, std::move(sensorThresholds),
-                    thisSensorParameters, pollRate, interfacePath, readState);
-                sensor->setupRead();
+                if (sensor != nullptr)
+                {
+                    sensor->activate(*hwmonFile, i2cDev);
+                }
+                else
+                {
+                    sensor = std::make_shared<HwmonTempSensor>(
+                        *hwmonFile, sensorType, objectServer, dbusConnection,
+                        io, sensorName, std::move(sensorThresholds),
+                        thisSensorParameters, pollRate, interfacePath,
+                        readState, i2cDev);
+                    sensor->setupRead();
+                }
             }
             hwmonName.erase(
                 remove(hwmonName.begin(), hwmonName.end(), sensorName),
@@ -440,13 +536,24 @@
                     }
 
                     auto& sensor = sensors[sensorName];
-                    sensor = nullptr;
-                    sensor = std::make_shared<HwmonTempSensor>(
-                        *hwmonFile, sensorType, objectServer, dbusConnection,
-                        io, sensorName, std::move(thresholds),
-                        thisSensorParameters, pollRate, interfacePath,
-                        readState);
-                    sensor->setupRead();
+                    if (!activateOnly)
+                    {
+                        sensor = nullptr;
+                    }
+
+                    if (sensor != nullptr)
+                    {
+                        sensor->activate(*hwmonFile, i2cDev);
+                    }
+                    else
+                    {
+                        sensor = std::make_shared<HwmonTempSensor>(
+                            *hwmonFile, sensorType, objectServer,
+                            dbusConnection, io, sensorName,
+                            std::move(thresholds), thisSensorParameters,
+                            pollRate, interfacePath, readState, i2cDev);
+                        sensor->setupRead();
+                    }
                 }
 
                 hwmonName.erase(
@@ -501,6 +608,29 @@
     }
 }
 
+static void powerStateChanged(
+    PowerState type, bool newState,
+    boost::container::flat_map<std::string, std::shared_ptr<HwmonTempSensor>>&
+        sensors,
+    boost::asio::io_service& io, sdbusplus::asio::object_server& objectServer,
+    std::shared_ptr<sdbusplus::asio::connection>& dbusConnection)
+{
+    if (newState)
+    {
+        createSensors(io, objectServer, sensors, dbusConnection, nullptr, true);
+    }
+    else
+    {
+        for (auto& [path, sensor] : sensors)
+        {
+            if (sensor != nullptr && sensor->readState == type)
+            {
+                sensor->deactivate();
+            }
+        }
+    }
+}
+
 int main()
 {
     boost::asio::io_service io;
@@ -514,8 +644,14 @@
     auto sensorsChanged =
         std::make_shared<boost::container::flat_set<std::string>>();
 
+    auto powerCallBack = [&sensors, &io, &objectServer,
+                          &systemBus](PowerState type, bool state) {
+        powerStateChanged(type, state, sensors, io, objectServer, systemBus);
+    };
+    setupPowerMatchCallback(systemBus, powerCallBack);
+
     io.post([&]() {
-        createSensors(io, objectServer, sensors, systemBus, nullptr);
+        createSensors(io, objectServer, sensors, systemBus, nullptr, false);
     });
 
     boost::asio::steady_timer filterTimer(io);
@@ -541,7 +677,8 @@
                 std::cerr << "timer error\n";
                 return;
             }
-            createSensors(io, objectServer, sensors, systemBus, sensorsChanged);
+            createSensors(io, objectServer, sensors, systemBus, sensorsChanged,
+                          false);
         });
     };
 
diff --git a/src/HwmonTempSensor.cpp b/src/HwmonTempSensor.cpp
index ee096ea..144f9d9 100644
--- a/src/HwmonTempSensor.cpp
+++ b/src/HwmonTempSensor.cpp
@@ -27,6 +27,7 @@
 #include <limits>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 // Temperatures are read in milli degrees Celsius, we need degrees Celsius.
@@ -45,12 +46,13 @@
     boost::asio::io_service& io, const std::string& sensorName,
     std::vector<thresholds::Threshold>&& thresholdsIn,
     const struct SensorParams& thisSensorParameters, const float pollRate,
-    const std::string& sensorConfiguration, const PowerState powerState) :
+    const std::string& sensorConfiguration, const PowerState powerState,
+    const std::shared_ptr<I2CDevice>& i2cDevice) :
     Sensor(boost::replace_all_copy(sensorName, " ", "_"),
            std::move(thresholdsIn), sensorConfiguration, objectType, false,
            false, thisSensorParameters.maxValue, thisSensorParameters.minValue,
            conn, powerState),
-    objServer(objectServer),
+    i2cDevice(i2cDevice), objServer(objectServer),
     inputDev(io, path, boost::asio::random_access_file::read_only),
     waitTimer(io), path(path), offsetValue(thisSensorParameters.offsetValue),
     scaleValue(thisSensorParameters.scaleValue),
@@ -77,11 +79,35 @@
     setInitialProperties(thisSensorParameters.units);
 }
 
-HwmonTempSensor::~HwmonTempSensor()
+bool HwmonTempSensor::isActive()
 {
+    return inputDev.is_open();
+}
+
+void HwmonTempSensor::activate(const std::string& newPath,
+                               const std::shared_ptr<I2CDevice>& newI2CDevice)
+{
+    path = newPath;
+    i2cDevice = newI2CDevice;
+    inputDev.open(path, boost::asio::random_access_file::read_only);
+    markAvailable(true);
+    setupRead();
+}
+
+void HwmonTempSensor::deactivate()
+{
+    markAvailable(false);
     // close the input dev to cancel async operations
     inputDev.close();
     waitTimer.cancel();
+    i2cDevice = nullptr;
+    path = "";
+}
+
+HwmonTempSensor::~HwmonTempSensor()
+{
+    deactivate();
+
     for (const auto& iface : thresholdInterfaces)
     {
         objServer.remove_interface(iface);
diff --git a/src/meson.build b/src/meson.build
index e420b27..e2af923 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -82,6 +82,7 @@
         'HwmonTempSensor.cpp',
         dependencies: [
             default_deps,
+            devicemgmt_dep,
             thresholds_dep,
             utils_dep,
         ],