diff --git a/phosphor-power-sequencer/src/meson.build b/phosphor-power-sequencer/src/meson.build
index ee6057e..02084c9 100644
--- a/phosphor-power-sequencer/src/meson.build
+++ b/phosphor-power-sequencer/src/meson.build
@@ -10,6 +10,7 @@
     'rail.cpp',
     'services.cpp',
     'standard_device.cpp',
+    'ucd90x_device.cpp',
     implicit_include_directories: false,
     dependencies: [
         nlohmann_json_dep,
diff --git a/phosphor-power-sequencer/src/ucd90x_device.cpp b/phosphor-power-sequencer/src/ucd90x_device.cpp
new file mode 100644
index 0000000..26e96f7
--- /dev/null
+++ b/phosphor-power-sequencer/src/ucd90x_device.cpp
@@ -0,0 +1,68 @@
+/**
+ * Copyright © 2024 IBM Corporation
+ *
+ * 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.
+ */
+
+#include "ucd90x_device.hpp"
+
+#include "pmbus.hpp"
+
+#include <exception>
+#include <format>
+#include <stdexcept>
+
+namespace phosphor::power::sequencer
+{
+
+using namespace pmbus;
+
+uint64_t UCD90xDevice::getMfrStatus()
+{
+    uint64_t value{0};
+    try
+    {
+        std::string fileName{"mfr_status"};
+        value = pmbusInterface->read(fileName, Type::HwmonDeviceDebug);
+    }
+    catch (const std::exception& e)
+    {
+        throw std::runtime_error{std::format(
+            "Unable to read MFR_STATUS for device {}: {}", name, e.what())};
+    }
+    return value;
+}
+
+void UCD90xDevice::storePgoodFaultDebugData(
+    Services& services, const std::vector<int>& gpioValues,
+    std::map<std::string, std::string>& additionalData)
+{
+    // Store manufacturer-specific MFR_STATUS command value
+    try
+    {
+        uint64_t value = getMfrStatus();
+        services.logInfoMsg(
+            std::format("Device {} MFR_STATUS: {:#014x}", name, value));
+        additionalData.emplace("MFR_STATUS", std::format("{:#014x}", value));
+    }
+    catch (...)
+    {
+        // Ignore error; don't interrupt pgood fault handling
+    }
+
+    // Call parent class method to store standard data
+    PMBusDriverDevice::storePgoodFaultDebugData(services, gpioValues,
+                                                additionalData);
+}
+
+} // namespace phosphor::power::sequencer
diff --git a/phosphor-power-sequencer/src/ucd90x_device.hpp b/phosphor-power-sequencer/src/ucd90x_device.hpp
new file mode 100644
index 0000000..f5044c8
--- /dev/null
+++ b/phosphor-power-sequencer/src/ucd90x_device.hpp
@@ -0,0 +1,96 @@
+/**
+ * Copyright © 2024 IBM Corporation
+ *
+ * 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.
+ */
+#pragma once
+
+#include "pmbus_driver_device.hpp"
+#include "rail.hpp"
+#include "services.hpp"
+
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace phosphor::power::sequencer
+{
+
+/**
+ * @class UCD90xDevice
+ *
+ * PMBusDriverDevice sub-class for the UCD90X family of power sequencer devices.
+ *
+ * These devices share a common device driver.
+ */
+class UCD90xDevice : public PMBusDriverDevice
+{
+  public:
+    // Specify which compiler-generated methods we want
+    UCD90xDevice() = delete;
+    UCD90xDevice(const UCD90xDevice&) = delete;
+    UCD90xDevice(UCD90xDevice&&) = delete;
+    UCD90xDevice& operator=(const UCD90xDevice&) = delete;
+    UCD90xDevice& operator=(UCD90xDevice&&) = delete;
+    virtual ~UCD90xDevice() = default;
+
+    /**
+     * Constructor.
+     *
+     * @param name Device name
+     * @param rails Voltage rails that are enabled and monitored by this device
+     * @param services System services like hardware presence and the journal
+     * @param bus I2C bus for the device
+     * @param address I2C address for the device
+     */
+    explicit UCD90xDevice(const std::string& name,
+                          std::vector<std::unique_ptr<Rail>> rails,
+                          Services& services, uint8_t bus, uint16_t address) :
+        PMBusDriverDevice(name, std::move(rails), services, bus, address,
+                          driverName)
+    {}
+
+    /**
+     * Returns the value of the PMBus MFR_STATUS command.
+     *
+     * This is a manufacturer-specific command that replaces the standard
+     * STATUS_MFR_SPECIFIC command on UCD90x devices.
+     *
+     * The returned value is in host-endian order.
+     *
+     * Note that the UCD90x documentation states that this is a paged command.
+     * This means that the PMBus PAGE should be set, and some of the bits in the
+     * command value are page-specific.  However, the current device driver only
+     * provides a single file in sysfs, and the driver always sets the PAGE to
+     * 0.  Thus, the bits that are page-specific in the returned value are
+     * always for PAGE 0.
+     *
+     * Throws an exception if the value could not be obtained.
+     *
+     * @return MFR_STATUS value
+     */
+    virtual uint64_t getMfrStatus();
+
+    constexpr static std::string driverName{"ucd9000"};
+
+  protected:
+    /** @copydoc PMBusDriverDevice::storePgoodFaultDebugData() */
+    virtual void storePgoodFaultDebugData(
+        Services& services, const std::vector<int>& gpioValues,
+        std::map<std::string, std::string>& additionalData) override;
+};
+
+} // namespace phosphor::power::sequencer
diff --git a/phosphor-power-sequencer/test/meson.build b/phosphor-power-sequencer/test/meson.build
index 2a15f0a..b915859 100644
--- a/phosphor-power-sequencer/test/meson.build
+++ b/phosphor-power-sequencer/test/meson.build
@@ -6,6 +6,7 @@
                 'pmbus_driver_device_tests.cpp',
                 'rail_tests.cpp',
                 'standard_device_tests.cpp',
+                'ucd90x_device_tests.cpp',
                 dependencies: [
                     gmock,
                     gtest,
diff --git a/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp b/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp
index 322499e..92f7916 100644
--- a/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp
+++ b/phosphor-power-sequencer/test/pmbus_driver_device_tests.cpp
@@ -802,6 +802,10 @@
     createFile("in1_label"); // PAGE 6 -> file number 1
 
     MockServices services;
+    std::vector<int> gpioValues{1, 1, 1};
+    EXPECT_CALL(services, getGPIOValues("xyz_pseq"))
+        .Times(1)
+        .WillOnce(Return(gpioValues));
 
     std::string name{"xyz_pseq"};
     std::vector<std::unique_ptr<Rail>> rails;
diff --git a/phosphor-power-sequencer/test/ucd90x_device_tests.cpp b/phosphor-power-sequencer/test/ucd90x_device_tests.cpp
new file mode 100644
index 0000000..2ec8b2e
--- /dev/null
+++ b/phosphor-power-sequencer/test/ucd90x_device_tests.cpp
@@ -0,0 +1,249 @@
+/**
+ * Copyright © 2024 IBM Corporation
+ *
+ * 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.
+ */
+
+#include "mock_pmbus.hpp"
+#include "mock_services.hpp"
+#include "pmbus.hpp"
+#include "rail.hpp"
+#include "services.hpp"
+#include "ucd90x_device.hpp"
+
+#include <cstdint>
+#include <exception>
+#include <map>
+#include <memory>
+#include <optional>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace phosphor::power::sequencer;
+using namespace phosphor::pmbus;
+
+using ::testing::Return;
+using ::testing::Throw;
+
+/**
+ * Creates a Rail object that checks for a pgood fault using a GPIO.
+ *
+ * @param name Unique name for the rail
+ * @param gpio GPIO line to read to determine the pgood status of the rail
+ * @return Rail object
+ */
+std::unique_ptr<Rail> createRail(const std::string& name, unsigned int gpioLine)
+{
+    std::optional<std::string> presence{};
+    std::optional<uint8_t> page{};
+    bool isPowerSupplyRail{false};
+    bool checkStatusVout{false};
+    bool compareVoltageToLimit{false};
+    bool activeLow{false};
+    std::optional<GPIO> gpio{GPIO{gpioLine, activeLow}};
+    return std::make_unique<Rail>(name, presence, page, isPowerSupplyRail,
+                                  checkStatusVout, compareVoltageToLimit, gpio);
+}
+
+TEST(UCD90xDeviceTests, Constructor)
+{
+    MockServices services;
+
+    std::string name{"ucd90320"};
+    std::vector<std::unique_ptr<Rail>> rails;
+    rails.emplace_back(createRail("VDD", 5));
+    rails.emplace_back(createRail("VIO", 7));
+    uint8_t bus{3};
+    uint16_t address{0x72};
+    UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+    EXPECT_EQ(device.getName(), name);
+    EXPECT_EQ(device.getRails().size(), 2);
+    EXPECT_EQ(device.getRails()[0]->getName(), "VDD");
+    EXPECT_EQ(device.getRails()[1]->getName(), "VIO");
+    EXPECT_EQ(device.getBus(), bus);
+    EXPECT_EQ(device.getAddress(), address);
+    EXPECT_EQ(device.getDriverName(), "ucd9000");
+    EXPECT_EQ(device.getInstance(), 0);
+    EXPECT_NE(&(device.getPMBusInterface()), nullptr);
+}
+
+TEST(UCD90xDeviceTests, GetMfrStatus)
+{
+    // Test where works
+    {
+        MockServices services;
+
+        std::string name{"ucd90320"};
+        std::vector<std::unique_ptr<Rail>> rails;
+        uint8_t bus{3};
+        uint16_t address{0x72};
+        UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+        MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+        uint64_t mfrStatus{0x123456789abcull};
+        EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+            .Times(1)
+            .WillOnce(Return(mfrStatus));
+
+        EXPECT_EQ(device.getMfrStatus(), mfrStatus);
+    }
+
+    // Test where fails with exception
+    {
+        MockServices services;
+
+        std::string name{"ucd90320"};
+        std::vector<std::unique_ptr<Rail>> rails;
+        uint8_t bus{3};
+        uint16_t address{0x72};
+        UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+        MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+        EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+            .Times(1)
+            .WillOnce(Throw(std::runtime_error{"File does not exist"}));
+
+        try
+        {
+            device.getMfrStatus();
+            ADD_FAILURE() << "Should not have reached this line.";
+        }
+        catch (const std::exception& e)
+        {
+            EXPECT_STREQ(e.what(),
+                         "Unable to read MFR_STATUS for device ucd90320: "
+                         "File does not exist");
+        }
+    }
+}
+
+TEST(UCD90xDeviceTests, StorePgoodFaultDebugData)
+{
+    // This is a protected method and cannot be called directly from a gtest.
+    // Call findPgoodFault() which calls storePgoodFaultDebugData().
+
+    // Test where works
+    {
+        MockServices services;
+        std::vector<int> gpioValues{1, 1, 0};
+        EXPECT_CALL(services, getGPIOValues("ucd90320"))
+            .Times(1)
+            .WillOnce(Return(gpioValues));
+        EXPECT_CALL(services,
+                    logInfoMsg("Device ucd90320 GPIO values: [1, 1, 0]"))
+            .Times(1);
+        EXPECT_CALL(services,
+                    logInfoMsg("Device ucd90320 MFR_STATUS: 0x123456789abc"))
+            .Times(1);
+        EXPECT_CALL(
+            services,
+            logErrorMsg(
+                "Pgood fault found in rail monitored by device ucd90320"))
+            .Times(1);
+        EXPECT_CALL(services, logErrorMsg("Pgood fault detected in rail VDD"))
+            .Times(1);
+        EXPECT_CALL(
+            services,
+            logErrorMsg(
+                "Rail VDD pgood GPIO line offset 2 has inactive value 0"))
+            .Times(1);
+
+        std::string name{"ucd90320"};
+        std::vector<std::unique_ptr<Rail>> rails;
+        rails.emplace_back(createRail("VDD", 2));
+        uint8_t bus{3};
+        uint16_t address{0x72};
+        UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+        MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+        EXPECT_CALL(pmbus, getPath(Type::Hwmon))
+            .Times(1)
+            .WillOnce(Return("/tmp"));
+        EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+            .Times(1)
+            .WillOnce(Return(0x123456789abcull));
+
+        // Call findPgoodFault() which calls storePgoodFaultDebugData()
+        std::string powerSupplyError{};
+        std::map<std::string, std::string> additionalData{};
+        std::string error = device.findPgoodFault(services, powerSupplyError,
+                                                  additionalData);
+        EXPECT_EQ(error,
+                  "xyz.openbmc_project.Power.Error.PowerSequencerVoltageFault");
+        EXPECT_EQ(additionalData.size(), 6);
+        EXPECT_EQ(additionalData["MFR_STATUS"], "0x123456789abc");
+        EXPECT_EQ(additionalData["DEVICE_NAME"], "ucd90320");
+        EXPECT_EQ(additionalData["GPIO_VALUES"], "[1, 1, 0]");
+        EXPECT_EQ(additionalData["RAIL_NAME"], "VDD");
+        EXPECT_EQ(additionalData["GPIO_LINE"], "2");
+        EXPECT_EQ(additionalData["GPIO_VALUE"], "0");
+    }
+
+    // Test where exception thrown trying to get MFR_STATUS
+    {
+        MockServices services;
+        std::vector<int> gpioValues{1, 1, 0};
+        EXPECT_CALL(services, getGPIOValues("ucd90320"))
+            .Times(1)
+            .WillOnce(Return(gpioValues));
+        EXPECT_CALL(services,
+                    logInfoMsg("Device ucd90320 GPIO values: [1, 1, 0]"))
+            .Times(1);
+        EXPECT_CALL(
+            services,
+            logErrorMsg(
+                "Pgood fault found in rail monitored by device ucd90320"))
+            .Times(1);
+        EXPECT_CALL(services, logErrorMsg("Pgood fault detected in rail VDD"))
+            .Times(1);
+        EXPECT_CALL(
+            services,
+            logErrorMsg(
+                "Rail VDD pgood GPIO line offset 2 has inactive value 0"))
+            .Times(1);
+
+        std::string name{"ucd90320"};
+        std::vector<std::unique_ptr<Rail>> rails;
+        rails.emplace_back(createRail("VDD", 2));
+        uint8_t bus{3};
+        uint16_t address{0x72};
+        UCD90xDevice device{name, std::move(rails), services, bus, address};
+
+        MockPMBus& pmbus = static_cast<MockPMBus&>(device.getPMBusInterface());
+        EXPECT_CALL(pmbus, getPath(Type::Hwmon))
+            .Times(1)
+            .WillOnce(Return("/tmp"));
+        EXPECT_CALL(pmbus, read("mfr_status", Type::HwmonDeviceDebug, true))
+            .Times(1)
+            .WillOnce(Throw(std::runtime_error{"File does not exist"}));
+
+        // Call findPgoodFault() which calls storePgoodFaultDebugData()
+        std::string powerSupplyError{};
+        std::map<std::string, std::string> additionalData{};
+        std::string error = device.findPgoodFault(services, powerSupplyError,
+                                                  additionalData);
+        EXPECT_EQ(error,
+                  "xyz.openbmc_project.Power.Error.PowerSequencerVoltageFault");
+        EXPECT_EQ(additionalData.size(), 5);
+        EXPECT_EQ(additionalData["DEVICE_NAME"], "ucd90320");
+        EXPECT_EQ(additionalData["GPIO_VALUES"], "[1, 1, 0]");
+        EXPECT_EQ(additionalData["RAIL_NAME"], "VDD");
+        EXPECT_EQ(additionalData["GPIO_LINE"], "2");
+        EXPECT_EQ(additionalData["GPIO_VALUE"], "0");
+    }
+}