diff --git a/common/include/pmbus.hpp b/common/include/pmbus.hpp
new file mode 100644
index 0000000..d62db4d
--- /dev/null
+++ b/common/include/pmbus.hpp
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <cstdint>
+
+enum class PMBusCmd : uint8_t
+{
+    page = 0x00,
+    writeProtect = 0x10,
+    storeUserCode = 0x17,
+    mfrId = 0x99,
+    mfrSerial = 0x9E,
+    icDeviceId = 0xAD,
+};
diff --git a/common/include/utils.hpp b/common/include/utils.hpp
index 65d7022..9325678 100644
--- a/common/include/utils.hpp
+++ b/common/include/utils.hpp
@@ -14,3 +14,92 @@
 sdbusplus::async::task<bool> asyncSystem(
     sdbusplus::async::context& ctx, const std::string& cmd,
     std::optional<std::reference_wrapper<std::string>> result = std::nullopt);
+
+/**
+ * @brief Convert bytes to an integer of the given type.
+ *
+ * @tparam IntegerType Output integer type (e.g., uint16_t, uint32_t).
+ * @tparam Container A container of uint8_t bytes.
+ * @param data Byte data to convert.
+ * @param bigEndian Set true for big-endian order; false for little-endian.
+ * @return Converted integer.
+ */
+template <typename IntegerType, typename Container>
+IntegerType bytesToInt(const Container& data, bool bigEndian = false)
+{
+    static_assert(std::is_integral_v<IntegerType>,
+                  "IntegerType must be an integral type");
+    static_assert(std::is_same_v<typename Container::value_type, uint8_t>,
+                  "Container must hold uint8_t elements");
+
+    constexpr size_t maxBytes = sizeof(IntegerType);
+    size_t size = std::min(data.size(), maxBytes);
+
+    IntegerType result = 0;
+    for (size_t i = 0; i < size; ++i)
+    {
+        size_t shift = bigEndian ? (size - 1 - i) * 8 : i * 8;
+        result |= static_cast<IntegerType>(data[i]) << shift;
+    }
+
+    return result;
+}
+
+template <typename>
+inline constexpr bool always_false = false;
+
+/**
+ * @brief Constructs a vector of bytes (`std::vector<uint8_t>`) from a variable
+ *        number of arguments, which can include enums, integral values,
+ *        and initializer lists.
+ *
+ * This function is useful when building byte packets or command sequences
+ * to be sent over communication protocols (e.g., I2C, UART, SPI).
+ *
+ * @tparam Args Types of arguments to convert into bytes
+ * @param args The values to encode into the byte vector
+ * @return std::vector<uint8_t> A flattened list of bytes
+ *
+ * @note Passing unsupported types will trigger a compile-time static_assert.
+ * @note Endianness: Multi-byte integers use little-endian order.
+ *
+ * @code
+ * enum class Command : uint8_t { Start = 0x01 };
+ * auto buf = buildByteVector(Command::Start, 0x1234, {0xAA, 0xBB});
+ * // Result: { 0x01, 0x34, 0x12, 0xAA, 0xBB }
+ * @endcode
+ */
+template <typename... Args>
+std::vector<uint8_t> buildByteVector(Args&&... args)
+{
+    std::vector<uint8_t> buf;
+
+    auto append = [&](auto&& value) {
+        using T = std::decay_t<decltype(value)>;
+
+        if constexpr (std::is_enum_v<T>)
+        {
+            buf.push_back(static_cast<uint8_t>(value));
+        }
+        else if constexpr (std::is_integral_v<T>)
+        {
+            for (size_t i = 0; i < sizeof(T); ++i)
+            {
+                buf.push_back(static_cast<uint8_t>(value >> (i * 8)));
+            }
+        }
+        else if constexpr (std::is_same_v<T, std::initializer_list<uint8_t>>)
+        {
+            buf.insert(buf.end(), value.begin(), value.end());
+        }
+        else
+        {
+            static_assert(always_false<T>,
+                          "Unsupported type in buildByteVector");
+        }
+    };
+
+    (append(std::forward<Args>(args)), ...);
+
+    return buf;
+}
diff --git a/i2c-vr/i2cvr_software_manager.cpp b/i2c-vr/i2cvr_software_manager.cpp
index 691a20d..45955f0 100644
--- a/i2c-vr/i2cvr_software_manager.cpp
+++ b/i2c-vr/i2cvr_software_manager.cpp
@@ -20,8 +20,8 @@
 namespace ManagerInf = phosphor::software::manager;
 
 const std::string configDBusName = "I2CVR";
-const std::vector<std::string> emConfigTypes = {"XDPE1X2XXFirmware",
-                                                "ISL69269Firmware"};
+const std::vector<std::string> emConfigTypes = {
+    "XDPE1X2XXFirmware", "ISL69269Firmware", "MP2X6XXFirmware"};
 
 I2CVRSoftwareManager::I2CVRSoftwareManager(sdbusplus::async::context& ctx) :
     ManagerInf::SoftwareManager(ctx, configDBusName)
diff --git a/i2c-vr/meson.build b/i2c-vr/meson.build
index 0e292f5..483dfd7 100644
--- a/i2c-vr/meson.build
+++ b/i2c-vr/meson.build
@@ -1,6 +1,11 @@
 i2cvr_src = files('i2cvr_device.cpp', 'i2cvr_software_manager.cpp', 'vr.cpp')
 
-regulators_src = files('isl69269/isl69269.cpp', 'xdpe1x2xx/xdpe1x2xx.cpp')
+regulators_src = files(
+    'isl69269/isl69269.cpp',
+    'mps/mp2x6xx.cpp',
+    'mps/mps.cpp',
+    'xdpe1x2xx/xdpe1x2xx.cpp',
+)
 
 i2cvr_include = include_directories('.')
 
diff --git a/i2c-vr/mps/mp2x6xx.cpp b/i2c-vr/mps/mp2x6xx.cpp
new file mode 100644
index 0000000..a558f04
--- /dev/null
+++ b/i2c-vr/mps/mp2x6xx.cpp
@@ -0,0 +1,437 @@
+#include "mp2x6xx.hpp"
+
+#include "common/include/utils.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+
+PHOSPHOR_LOG2_USING;
+
+namespace phosphor::software::VR
+{
+
+static constexpr size_t vendorIdLength = 3;
+static constexpr size_t deviceIdLength = 4;
+static constexpr size_t configIdLength = 2;
+static constexpr size_t statusByteLength = 1;
+static constexpr size_t crcLength = 2;
+
+static constexpr std::string_view productIdRegName = "TRIM_MFR_PRODUCT_ID2";
+static constexpr std::string_view crcUserRegName = "CRC_USER";
+
+static constexpr uint8_t pageMask = 0x0F;
+static constexpr uint8_t configMask = 0xF0;
+
+static constexpr uint8_t disableWriteProtect = 0x00;
+static constexpr uint16_t disablePage2WriteProtect = 0x128C;
+static constexpr uint16_t disablePage3WriteProtect = 0x0082;
+
+enum class MP2X6XXCmd : uint8_t
+{
+    // Page 0 commands
+    readCRCReg = 0xED,
+    // Page 1 commands
+    mfrMTPMemoryCtrl = 0xCC,
+    // Page 2 commands
+    selectConfigCtrl = 0x1A,
+    // Page 3 commands
+    mfrMTPMemoryCtrlPage3 = 0x81,
+};
+
+sdbusplus::async::task<bool> MP2X6XX::parseDeviceConfiguration()
+{
+    if (!configuration)
+    {
+        error("Device configuration not initialized");
+        co_return false;
+    }
+
+    configuration->vendorId = 0x4D5053;
+
+    for (const auto& tokens : parser->lineTokens)
+    {
+        if (!parser->isValidDataTokens(tokens))
+        {
+            continue;
+        }
+
+        auto regName = parser->getVal<std::string>(tokens, ATE::regName);
+        if (regName == productIdRegName)
+        {
+            configuration->productId =
+                parser->getVal<uint32_t>(tokens, ATE::regDataHex);
+            configuration->configId =
+                parser->getVal<uint32_t>(tokens, ATE::configId);
+        }
+        else if (regName == crcUserRegName)
+        {
+            configuration->crcUser =
+                parser->getVal<uint32_t>(tokens, ATE::regDataHex);
+            break;
+        }
+    }
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::verifyImage(const uint8_t* image,
+                                                  size_t imageSize)
+{
+    if (!co_await parseImage(image, imageSize))
+    {
+        error("Image verification failed: image parsing failed");
+        co_return false;
+    }
+
+    if (configuration->registersData.empty())
+    {
+        error("Image verification failed - no data found");
+        co_return false;
+    }
+
+    if (configuration->productId == 0 || configuration->configId == 0)
+    {
+        error("Image verification failed - missing product or config ID");
+        co_return false;
+    }
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::checkId(PMBusCmd pmBusCmd,
+                                              uint32_t expected)
+{
+    const uint8_t cmd = static_cast<uint8_t>(pmBusCmd);
+    size_t idLen = 0;
+    bool blockRead = false;
+
+    switch (pmBusCmd)
+    {
+        case PMBusCmd::mfrId:
+            idLen = vendorIdLength;
+            blockRead = true;
+            break;
+        case PMBusCmd::icDeviceId:
+            idLen = deviceIdLength;
+            blockRead = true;
+            break;
+        case PMBusCmd::mfrSerial:
+            idLen = configIdLength;
+            break;
+        default:
+            error("Invalid command for ID check: {CMD}", "CMD", lg2::hex, cmd);
+            co_return false;
+    }
+
+    std::vector<uint8_t> rbuf;
+    std::vector<uint8_t> tbuf;
+
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page0);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 0 for ID check");
+        co_return false;
+    }
+
+    tbuf = {cmd};
+    rbuf.resize(idLen + (blockRead ? statusByteLength : 0));
+
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("I2C failure during ID check, cmd {CMD}", "CMD", lg2::hex, cmd);
+        co_return false;
+    }
+
+    auto idBytes = std::span(rbuf).subspan(blockRead ? statusByteLength : 0);
+    uint32_t id = bytesToInt<uint32_t>(idBytes);
+
+    if (id != expected)
+    {
+        error("ID check failed for cmd {CMD}: got {ID}, expected {EXP}", "CMD",
+              lg2::hex, cmd, "ID", lg2::hex, id, "EXP", lg2::hex, expected);
+        co_return false;
+    }
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::unlockWriteProtect()
+{
+    std::vector<uint8_t> tbuf;
+    std::vector<uint8_t> rbuf;
+
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page0);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 0 for unlocking write protect");
+        co_return false;
+    }
+
+    tbuf = buildByteVector(PMBusCmd::writeProtect, disableWriteProtect);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to disable write protect");
+        co_return false;
+    }
+
+    // unlock page 2 write protect
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page1);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 1 for unlocking write protect for page 2");
+        co_return false;
+    }
+
+    tbuf =
+        buildByteVector(MP2X6XXCmd::mfrMTPMemoryCtrl, disablePage2WriteProtect);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to unlock page 2 write protect");
+        co_return false;
+    }
+
+    // unlock page 3 write protect
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page3);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 3 for unlocking write protect for page 3");
+        co_return false;
+    }
+
+    tbuf = buildByteVector(MP2X6XXCmd::mfrMTPMemoryCtrlPage3,
+                           disablePage3WriteProtect);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to unlock page 3 write protect");
+        co_return false;
+    }
+
+    debug("Unlocked write protect");
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::selectConfig(uint8_t config)
+{
+    // MPS config select command:
+    // Writes to Page 2 @ 0x1A: value = 0x0F00 | ((config + 7) << 4)
+    // For config 1–6 → result: 0x0F80 to 0x0FD0
+
+    std::vector<uint8_t> tbuf;
+    std::vector<uint8_t> rbuf;
+
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page2);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 2 for configuration switch");
+        co_return false;
+    }
+
+    constexpr uint8_t baseOffset = 7;
+    uint8_t encodedNibble = static_cast<uint8_t>((config + baseOffset) << 4);
+    uint16_t command = 0x0F00 | encodedNibble;
+
+    tbuf = buildByteVector(MP2X6XXCmd::selectConfigCtrl, command);
+
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to write config select command {CMD} for config {CONFIG}",
+              "CMD", lg2::hex, command, "CONFIG", config);
+        co_return false;
+    }
+
+    debug("Switched to config {CONFIG}", "CONFIG", config);
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::programConfigData(
+    const std::vector<MPSData>& gdata)
+{
+    std::vector<uint8_t> tbuf;
+    std::vector<uint8_t> rbuf;
+
+    for (const auto& data : gdata)
+    {
+        uint8_t page = data.page & pageMask;
+
+        tbuf = buildByteVector(PMBusCmd::page, page);
+        if (!i2cInterface.sendReceive(tbuf, rbuf))
+        {
+            error("Failed to set page {PAGE} for register {REG}", "PAGE", page,
+                  "REG", lg2::hex, data.addr);
+            co_return false;
+        }
+
+        tbuf = {data.addr};
+        tbuf.insert(tbuf.end(), data.data.begin(),
+                    data.data.begin() + data.length);
+
+        if (!i2cInterface.sendReceive(tbuf, rbuf))
+        {
+            error(
+                "Failed to write data {DATA} to register {REG} on page {PAGE}",
+                "DATA", lg2::hex, bytesToInt<uint32_t>(data.data), "REG",
+                lg2::hex, data.addr, "PAGE", page);
+            co_return false;
+        }
+    }
+
+    if (!co_await storeUserCode())
+    {
+        error("Failed to store user code after programming config data");
+        co_return false;
+    }
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::configAllRegisters()
+{
+    for (const auto& [config, gdata] : getGroupedConfigData(configMask, 4))
+    {
+        debug("Configuring registers for config {CONFIG}", "CONFIG", config);
+
+        // Select the appropriate config before programming its registers
+        if (config > 0 && !co_await selectConfig(config))
+        {
+            co_return false;
+        }
+
+        if (!co_await programConfigData(gdata))
+        {
+            error("Failed to program configuration {CONFIG}", "CONFIG", config);
+            co_return false;
+        }
+
+        debug("Configured {SIZE} registers for config {CONFIG}", "SIZE",
+              gdata.size(), "CONFIG", config);
+    }
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::storeUserCode()
+{
+    std::vector<uint8_t> tbuf;
+    std::vector<uint8_t> rbuf;
+
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page0);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 0 for storing user code");
+        co_return false;
+    }
+
+    tbuf = buildByteVector(PMBusCmd::storeUserCode);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to store user code");
+        co_return false;
+    }
+
+    // Wait store user code
+    co_await sdbusplus::async::sleep_for(ctx, std::chrono::milliseconds(500));
+
+    debug("Stored user code");
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::getCRC(uint32_t* checksum)
+{
+    if (checksum == nullptr)
+    {
+        error("getCRC() called with null checksum pointer");
+        co_return false;
+    }
+
+    std::vector<uint8_t> tbuf;
+    std::vector<uint8_t> rbuf;
+
+    tbuf = buildByteVector(PMBusCmd::page, MPSPage::page0);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to set page 0 for CRC read");
+        co_return false;
+    }
+
+    tbuf = buildByteVector(MP2X6XXCmd::readCRCReg);
+    rbuf.resize(crcLength);
+    if (!i2cInterface.sendReceive(tbuf, rbuf))
+    {
+        error("Failed to read CRC from device");
+        co_return false;
+    }
+
+    if (rbuf.size() < crcLength)
+    {
+        error("CRC read returned insufficient data");
+        co_return false;
+    }
+
+    *checksum = bytesToInt<uint32_t>(rbuf);
+
+    debug("Read CRC: {CRC}", "CRC", lg2::hex, *checksum);
+
+    co_return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::checkMTPCRC()
+{
+    uint32_t crc = 0;
+    // NOLINTBEGIN(clang-analyzer-core.uninitialized.Branch)
+    if (!co_await getCRC(&crc))
+    // NOLINTEND(clang-analyzer-core.uninitialized.Branch)
+    {
+        error("Failed to get CRC for MTP check");
+        co_return false;
+    }
+
+    debug("MTP CRC: {CRC}, Expected: {EXP}", "CRC", lg2::hex, crc, "EXP",
+          lg2::hex, configuration->crcUser);
+
+    co_return configuration->crcUser == crc;
+}
+
+bool MP2X6XX::forcedUpdateAllowed()
+{
+    return true;
+}
+
+sdbusplus::async::task<bool> MP2X6XX::updateFirmware(bool force)
+{
+    (void)force;
+
+    if (!co_await checkId(PMBusCmd::mfrId, configuration->vendorId))
+    {
+        co_return false;
+    }
+
+    if (!co_await checkId(PMBusCmd::icDeviceId, configuration->productId))
+    {
+        co_return false;
+    }
+
+    if (!co_await checkId(PMBusCmd::mfrSerial, configuration->configId))
+    {
+        co_return false;
+    }
+
+    if (!co_await unlockWriteProtect())
+    {
+        co_return false;
+    }
+
+    if (!co_await configAllRegisters())
+    {
+        co_return false;
+    }
+
+    if (!(co_await checkMTPCRC()))
+    {
+        co_return false;
+    }
+
+    co_return true;
+}
+
+} // namespace phosphor::software::VR
diff --git a/i2c-vr/mps/mp2x6xx.hpp b/i2c-vr/mps/mp2x6xx.hpp
new file mode 100644
index 0000000..8c504a4
--- /dev/null
+++ b/i2c-vr/mps/mp2x6xx.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include "common/include/pmbus.hpp"
+#include "mps.hpp"
+
+namespace phosphor::software::VR
+{
+
+class MP2X6XX : public MPSVoltageRegulator
+{
+  public:
+    MP2X6XX(sdbusplus::async::context& ctx, uint16_t bus, uint16_t address) :
+        MPSVoltageRegulator(ctx, bus, address)
+    {}
+
+    sdbusplus::async::task<bool> verifyImage(const uint8_t* image,
+                                             size_t imageSize) final;
+    sdbusplus::async::task<bool> updateFirmware(bool force) final;
+    sdbusplus::async::task<bool> getCRC(uint32_t* checksum) final;
+    sdbusplus::async::task<bool> parseDeviceConfiguration() final;
+    bool forcedUpdateAllowed() final;
+
+  private:
+    sdbusplus::async::task<bool> checkId(PMBusCmd pmBusCmd, uint32_t expected);
+    sdbusplus::async::task<bool> unlockWriteProtect();
+    sdbusplus::async::task<bool> storeUserCode();
+    sdbusplus::async::task<bool> checkMTPCRC();
+    sdbusplus::async::task<bool> selectConfig(uint8_t config);
+    sdbusplus::async::task<bool> configAllRegisters();
+    sdbusplus::async::task<bool> programConfigData(
+        const std::vector<MPSData>& gdata);
+};
+
+} // namespace phosphor::software::VR
diff --git a/i2c-vr/mps/mps.cpp b/i2c-vr/mps/mps.cpp
new file mode 100644
index 0000000..ee0abf9
--- /dev/null
+++ b/i2c-vr/mps/mps.cpp
@@ -0,0 +1,93 @@
+#include "mps.hpp"
+
+namespace phosphor::software::VR
+{
+
+bool MPSImageParser::isValidDataTokens(
+    const std::vector<std::string_view>& tokens)
+{
+    return tokens.size() > static_cast<size_t>(ATE::regName) &&
+           !tokens[0].starts_with('*');
+}
+
+MPSData MPSImageParser::extractData(const std::vector<std::string_view>& tokens)
+{
+    MPSData data;
+    data.page = getVal<uint8_t>(tokens, ATE::pageNum);
+    data.addr = getVal<uint8_t>(tokens, ATE::regAddrHex);
+
+    std::string regData = getVal<std::string>(tokens, ATE::regDataHex);
+    size_t byteCount = std::min(regData.length() / 2, size_t(4));
+    for (size_t i = 0; i < byteCount; ++i)
+    {
+        data.data[byteCount - 1 - i] = static_cast<uint8_t>(
+            std::stoul(regData.substr(i * 2, 2), nullptr, 16));
+    }
+
+    data.length = static_cast<uint8_t>(byteCount);
+    return data;
+}
+
+std::vector<MPSData> MPSImageParser::getRegistersData()
+{
+    std::vector<MPSData> registersData;
+    for (const auto& tokens : lineTokens)
+    {
+        if (tokens[0].starts_with("END"))
+        {
+            break;
+        }
+
+        if (isValidDataTokens(tokens))
+        {
+            registersData.push_back(extractData(tokens));
+        }
+    }
+    return registersData;
+}
+
+sdbusplus::async::task<bool> MPSVoltageRegulator::parseImage(
+    const uint8_t* image, size_t imageSize)
+{
+    parser = std::make_unique<MPSImageParser>(image, imageSize);
+
+    configuration = std::make_unique<MPSConfig>();
+    configuration->registersData = parser->getRegistersData();
+
+    if (!co_await parseDeviceConfiguration())
+    {
+        co_return false;
+    }
+
+    lg2::debug(
+        "Parsed configuration: Data Size={SIZE}, Vendor ID={VID}, "
+        "Product ID={PID}, Config ID={CID}, CRC User={CRCUSR}, "
+        "CRC Multi={CRCMULTI}",
+        "SIZE", configuration->registersData.size(), "VID", lg2::hex,
+        configuration->vendorId, "PID", lg2::hex, configuration->productId,
+        "CID", lg2::hex, configuration->configId, "CRCUSR", lg2::hex,
+        configuration->crcUser, "CRCMULTI", lg2::hex, configuration->crcMulti);
+
+    co_return true;
+}
+
+std::map<uint8_t, std::vector<MPSData>>
+    MPSVoltageRegulator::getGroupedConfigData(uint8_t configMask, uint8_t shift)
+{
+    std::map<uint8_t, std::vector<MPSData>> groupedData;
+
+    if (!configuration)
+    {
+        return groupedData;
+    }
+
+    for (const auto& data : configuration->registersData)
+    {
+        uint8_t config = (data.page & configMask) >> shift;
+        groupedData[config].push_back(data);
+    }
+
+    return groupedData;
+}
+
+} // namespace phosphor::software::VR
diff --git a/i2c-vr/mps/mps.hpp b/i2c-vr/mps/mps.hpp
new file mode 100644
index 0000000..da6f854
--- /dev/null
+++ b/i2c-vr/mps/mps.hpp
@@ -0,0 +1,290 @@
+#pragma once
+
+#include "common/include/i2c/i2c.hpp"
+#include "i2c-vr/vr.hpp"
+
+#include <phosphor-logging/lg2.hpp>
+
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <string_view>
+#include <vector>
+
+namespace phosphor::software::VR
+{
+
+/**
+ * @brief
+ * Columns of an Automated Test Equipment (ATE) format configuration file.
+ * Each enumerator corresponds to a tab-separated column index.
+ */
+enum class ATE : uint8_t
+{
+    configId = 0,
+    pageNum,
+    regAddrHex,
+    regAddrDec,
+    regName,
+    regDataHex,
+    regDataDec,
+    writeType,
+    colCount,
+};
+
+enum class MPSPage : uint8_t
+{
+    page0 = 0,
+    page1,
+    page2,
+    page3,
+    page4,
+};
+
+struct MPSData
+{
+    uint8_t page = 0;
+    uint8_t addr = 0;
+    uint8_t length = 0;
+    std::array<uint8_t, 4> data{};
+};
+
+struct MPSConfig
+{
+    uint32_t vendorId = 0;
+    uint32_t productId = 0;
+    uint32_t configId = 0;
+    uint32_t crcUser = 0;
+    uint32_t crcMulti = 0;
+    std::vector<MPSData> registersData;
+};
+
+/**
+ * @brief
+ * Utility class to iterate over lines and tokenize them by tab characters.
+ */
+class TokenizedLines
+{
+  public:
+    TokenizedLines(const uint8_t* d, size_t s) :
+        data(reinterpret_cast<const char*>(d), s)
+    {}
+    /**
+     * @brief Iterator over tokenized lines.
+     */
+    struct Iterator
+    {
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = std::vector<std::string_view>;
+        using difference_type = std::ptrdiff_t;
+        using pointer = const value_type*;
+        using reference = const value_type&;
+
+        Iterator() = default; // End iterator
+        Iterator(std::string_view sv) : remaining(sv)
+        {
+            next();
+        }
+
+        reference operator*() const
+        {
+            return currentTokens;
+        }
+
+        pointer operator->() const
+        {
+            return &currentTokens;
+        }
+
+        Iterator& operator++()
+        {
+            next();
+            return *this;
+        }
+
+        Iterator operator++(int)
+        {
+            auto result = *this;
+            ++(*this);
+            return result;
+        }
+
+        friend bool operator==(const Iterator& a, const Iterator& b)
+        {
+            return a.remaining.empty() && b.remaining.empty();
+        }
+
+        friend bool operator!=(const Iterator& a, const Iterator& b)
+        {
+            return !(a == b);
+        }
+
+      private:
+        std::string_view remaining;
+        std::vector<std::string_view> currentTokens;
+
+        void next()
+        {
+            currentTokens.clear();
+            if (remaining.empty())
+            {
+                return;
+            }
+
+            // Extract current line
+            auto newlinePos = remaining.find('\n');
+            std::string_view line = remaining.substr(0, newlinePos);
+            remaining = (newlinePos == std::string_view::npos)
+                            ? std::string_view{}
+                            : remaining.substr(newlinePos + 1);
+
+            // Tokenize by tab
+            size_t start = 0;
+            while (start < line.size())
+            {
+                start = line.find_first_not_of('\t', start);
+                if (start == std::string_view::npos)
+                {
+                    break;
+                }
+
+                auto end = line.find('\t', start);
+                currentTokens.emplace_back(line.substr(start, end - start));
+                start = (end == std::string_view::npos) ? line.size() : end;
+            }
+        }
+    };
+
+    Iterator begin() const
+    {
+        return Iterator(data);
+    }
+
+    static Iterator end()
+    {
+        return Iterator();
+    }
+
+  private:
+    std::string_view data;
+};
+
+/**
+ * @brief Base parser for MPS configuration images.
+ */
+class MPSImageParser
+{
+  public:
+    MPSImageParser(const uint8_t* image, size_t imageSize) :
+        lineTokens(image, imageSize)
+    {}
+
+    template <typename>
+    inline static constexpr bool always_false = false;
+
+    /**
+     * @brief Extract a typed value from a tokenized line.
+     * @tparam T Return type (string or integral type)
+     * @param tokens Tokenized line
+     * @param index Column index (ATE enum)
+     * @return Parsed value or default if invalid
+     */
+    template <typename T>
+    T getVal(const std::vector<std::string_view>& tokens, ATE index)
+    {
+        size_t idx = static_cast<size_t>(index);
+
+        if (tokens.size() <= idx)
+        {
+            lg2::error("Index out of range for ATE enum: {INDEX}", "INDEX",
+                       static_cast<uint32_t>(idx));
+            return T{};
+        }
+
+        std::string_view token = tokens[idx];
+
+        if constexpr (std::is_same_v<T, std::string>)
+        {
+            return std::string(token);
+        }
+        else if constexpr (std::is_integral_v<T>)
+        {
+            unsigned long val = 0;
+            try
+            {
+                val = std::stoul(std::string(token), nullptr, 16);
+            }
+            catch (...)
+            {
+                lg2::error("Invalid hex value: {INDEX}", "INDEX",
+                           static_cast<uint32_t>(idx));
+                return T{};
+            }
+            return static_cast<T>(val);
+        }
+        else
+        {
+            static_assert(always_false<T>, "Unsupported type in getVal");
+        }
+    }
+
+    /**
+     * @brief Check if a tokenized line contains valid register data.
+     */
+    static bool isValidDataTokens(const std::vector<std::string_view>& tokens);
+
+    /**
+     * @brief Convert tokenized line into MPSData structure.
+     */
+    MPSData extractData(const std::vector<std::string_view>& tokens);
+
+    /**
+     * @brief Collect all register data entries from the parsed image.
+     */
+    std::vector<MPSData> getRegistersData();
+
+    TokenizedLines lineTokens;
+};
+
+/**
+ * @brief Base class for MPS Voltage Regulators.
+ */
+class MPSVoltageRegulator : public VoltageRegulator
+{
+  public:
+    MPSVoltageRegulator(sdbusplus::async::context& ctx, uint16_t bus,
+                        uint16_t address) :
+        VoltageRegulator(ctx), i2cInterface(phosphor::i2c::I2C(bus, address))
+    {}
+
+    /**
+     * @brief Parse device-specific configuration from the loaded image.
+     * @return async task returning true if parsing succeeds
+     */
+    virtual sdbusplus::async::task<bool> parseDeviceConfiguration() = 0;
+
+    /**
+     * @brief Parse an image file into internal MPS configuration.
+     * @param image Pointer to the image data
+     * @param imageSize Size of the image data
+     * @return async task returning true if parsing succeeds
+     */
+    sdbusplus::async::task<bool> parseImage(const uint8_t* image,
+                                            size_t imageSize);
+
+    /**
+     * @brief Group register data by page, optionally masked and shifted.
+     * @param configMask Bitmask to select relevant page bits (default 0xFF)
+     * @param shift Number of bits to shift masked value to obtain group key
+     * @return map of page keys to vector of MPSData
+     */
+    std::map<uint8_t, std::vector<MPSData>> getGroupedConfigData(
+        uint8_t configMask = 0xFF, uint8_t shift = 0);
+
+  protected:
+    phosphor::i2c::I2C i2cInterface;
+    std::unique_ptr<MPSImageParser> parser;
+    std::unique_ptr<MPSConfig> configuration;
+};
+
+} // namespace phosphor::software::VR
diff --git a/i2c-vr/vr.cpp b/i2c-vr/vr.cpp
index 7280f91..796c9df 100644
--- a/i2c-vr/vr.cpp
+++ b/i2c-vr/vr.cpp
@@ -1,6 +1,7 @@
 #include "vr.hpp"
 
 #include "isl69269/isl69269.hpp"
+#include "mps/mp2x6xx.hpp"
 #include "xdpe1x2xx/xdpe1x2xx.hpp"
 
 #include <map>
@@ -12,19 +13,17 @@
                                          enum VRType vrType, uint16_t bus,
                                          uint16_t address)
 {
-    std::unique_ptr<VoltageRegulator> ret;
     switch (vrType)
     {
         case VRType::XDPE1X2XX:
-            ret = std::make_unique<XDPE1X2XX>(ctx, bus, address);
-            break;
+            return std::make_unique<XDPE1X2XX>(ctx, bus, address);
         case VRType::ISL69269:
-            ret = std::make_unique<ISL69269>(ctx, bus, address);
-            break;
+            return std::make_unique<ISL69269>(ctx, bus, address);
+        case VRType::MP2X6XX:
+            return std::make_unique<MP2X6XX>(ctx, bus, address);
         default:
-            return NULL;
+            return nullptr;
     }
-    return ret;
 }
 
 bool stringToEnum(std::string& vrStr, VRType& vrType)
@@ -32,7 +31,7 @@
     std::map<std::string, enum VRType> VRTypeToString{
         {"XDPE1X2XXFirmware", VRType::XDPE1X2XX},
         {"ISL69269Firmware", VRType::ISL69269},
-    };
+        {"MP2X6XXFirmware", VRType::MP2X6XX}};
 
     if (VRTypeToString.contains(vrStr))
     {
diff --git a/i2c-vr/vr.hpp b/i2c-vr/vr.hpp
index 1212a39..2e224f8 100644
--- a/i2c-vr/vr.hpp
+++ b/i2c-vr/vr.hpp
@@ -13,6 +13,7 @@
 {
     XDPE1X2XX,
     ISL69269,
+    MP2X6XX,
 };
 
 class VoltageRegulator