diff --git a/Makefile.am b/Makefile.am
index e2a2d96..406e1bc 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1 +1 @@
-SUBDIRS = libpldm test
+SUBDIRS = libpldm libpldmresponder test
diff --git a/configure.ac b/configure.ac
index 88c4d9b..53d9228 100644
--- a/configure.ac
+++ b/configure.ac
@@ -20,6 +20,9 @@
 # For linking
 LT_INIT
 
+# Check for needed modules
+PKG_CHECK_MODULES([PHOSPHOR_LOGGING], [phosphor-logging])
+
 # Check/set gtest specific functions.
 AX_PTHREAD([GTEST_CPPFLAGS="-DGTEST_HAS_PTHREAD=1"],[GTEST_CPPFLAGS="-DGTEST_HAS_PTHREAD=0"])
 AC_SUBST(GTEST_CPPFLAGS)
@@ -42,5 +45,5 @@
 )
 
 # Create configured output
-AC_CONFIG_FILES([Makefile libpldm/Makefile test/Makefile])
+AC_CONFIG_FILES([Makefile libpldm/Makefile libpldmresponder/Makefile test/Makefile])
 AC_OUTPUT
diff --git a/libpldmresponder/Makefile.am b/libpldmresponder/Makefile.am
new file mode 100644
index 0000000..597cbd3
--- /dev/null
+++ b/libpldmresponder/Makefile.am
@@ -0,0 +1,10 @@
+libpldmoemresponder_LTLIBRARIES = libpldmoemresponder.la
+libpldmoemresponderdir = ${libdir}
+libpldmoemresponder_la_SOURCES = \
+	file_io.cpp
+
+libpldmoemresponder_la_LIBADD = \
+	../libpldm/libpldmoem.la
+libpldmoemresponder_la_LDFLAGS = \
+	-version-info 1:0:0 -shared \
+        -lstdc++fs
diff --git a/libpldmresponder/file_io.cpp b/libpldmresponder/file_io.cpp
new file mode 100644
index 0000000..9caa45a
--- /dev/null
+++ b/libpldmresponder/file_io.cpp
@@ -0,0 +1,178 @@
+#include "file_io.hpp"
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <fstream>
+#include <phosphor-logging/log.hpp>
+
+#include "libpldm/base.h"
+
+namespace pldm
+{
+
+namespace responder
+{
+
+namespace fs = std::filesystem;
+using namespace phosphor::logging;
+
+int transferDatatoHost(const fs::path& file, uint32_t offset, uint32_t length,
+                       uint64_t address)
+{
+    // Align the length of the memory mapping to the page size.
+    static const size_t pageSize = getpagesize();
+    uint32_t numPages = length / pageSize;
+    uint32_t pageLength = numPages * pageSize;
+    if (length > pageLength)
+    {
+        pageLength += pageSize;
+    }
+
+    auto mmapCleanup = [pageLength](void* vgaMem) {
+        munmap(vgaMem, pageLength);
+    };
+
+    int fd = -1;
+    int rc = 0;
+    fd = open(dma::xdmaDev, O_RDWR);
+    if (fd < 0)
+    {
+        log<level::ERR>("Opening the xdma device failed", entry("RC=%d", rc));
+        return rc;
+    }
+    auto xdmaFDPtr = std::make_unique<utils::CustomFD>(fd);
+    auto& xdmaFD = *(xdmaFDPtr.get());
+
+    void* vgaMem = nullptr;
+
+    vgaMem = mmap(nullptr, pageLength, PROT_WRITE, MAP_SHARED, xdmaFD(), 0);
+    if (MAP_FAILED == vgaMem)
+    {
+        rc = -errno;
+        log<level::ERR>("mmap operation failed", entry("RC=%d", rc));
+        return rc;
+    }
+    std::unique_ptr<void, decltype(mmapCleanup)> vgaMemPtr(vgaMem, mmapCleanup);
+
+    // Populate the VGA memory with the contents of the file
+    std::ifstream stream(file.string());
+    stream.seekg(offset);
+    stream.read(static_cast<char*>(vgaMemPtr.get()), length);
+    if (stream.gcount() != length)
+    {
+        log<level::ERR>(
+            "mismatch between number of characters to read and the length read",
+            entry("LENGTH=%d", length), entry("COUNT=%d", stream.gcount()));
+        return -1;
+    }
+
+    struct dma::AspeedXdmaOp xdmaOp
+    {
+    };
+    xdmaOp.upstream = true;
+    xdmaOp.hostAddr = address;
+    xdmaOp.len = length;
+
+    // Initiate the DMA operation
+    rc = write(xdmaFD(), &xdmaOp, sizeof(xdmaOp));
+    if (rc < 0)
+    {
+        rc = -errno;
+        log<level::ERR>("the dma operation failed", entry("RC=%d", rc),
+                        entry("UPSTREAM=%d", xdmaOp.upstream),
+                        entry("ADDRESS=%lld", address),
+                        entry("LENGTH=%d", length));
+        return rc;
+    }
+
+    return rc;
+}
+
+void readFileIntoMemory(const uint8_t* request, size_t payloadLength,
+                        pldm_msg* response)
+{
+    uint32_t fileHandle = 0;
+    uint32_t offset = 0;
+    uint32_t length = 0;
+    uint64_t address = 0;
+
+    if (payloadLength != PLDM_READ_FILE_MEM_REQ_BYTES)
+    {
+        encode_read_file_memory_resp(0, PLDM_ERROR_INVALID_LENGTH, 0, response);
+        return;
+    }
+
+    decode_read_file_memory_req(request, payloadLength, &fileHandle, &offset,
+                                &length, &address);
+
+    constexpr auto readFilePath = "";
+
+    fs::path path{readFilePath};
+    if (!fs::exists(path))
+    {
+        log<level::ERR>("File does not exist", entry("HANDLE=%d", fileHandle));
+        encode_read_file_memory_resp(0, PLDM_INVALID_FILE_HANDLE, 0, response);
+        return;
+    }
+
+    auto fileSize = fs::file_size(path);
+
+    if (offset >= fileSize)
+    {
+        log<level::ERR>("Offset exceeds file size", entry("OFFSET=%d", offset),
+                        entry("FILE_SIZE=%d", fileSize));
+        encode_read_file_memory_resp(0, PLDM_DATA_OUT_OF_RANGE, 0, response);
+        return;
+    }
+
+    if (offset + length > fileSize)
+    {
+        length = fileSize - offset;
+    }
+
+    if (length % dma::minSize)
+    {
+        log<level::ERR>("Readlength is not a multiple of DMA minSize",
+                        entry("LENGTH=%d", length));
+        encode_read_file_memory_resp(0, PLDM_INVALID_READ_LENGTH, 0, response);
+        return;
+    }
+
+    uint32_t origLength = length;
+
+    while (length > 0)
+    {
+        if (length > dma::maxSize)
+        {
+            auto rc =
+                dma::transferDatatoHost(path, offset, dma::maxSize, address);
+            if (rc < 0)
+            {
+                encode_read_file_memory_resp(0, PLDM_ERROR, 0, response);
+                return;
+            }
+            offset += dma::maxSize;
+            length -= dma::maxSize;
+            address += dma::maxSize;
+        }
+        else
+        {
+            auto rc = dma::transferDatatoHost(path, offset, length, address);
+            if (rc < 0)
+            {
+                encode_read_file_memory_resp(0, PLDM_ERROR, 0, response);
+                return;
+            }
+            encode_read_file_memory_resp(0, PLDM_SUCCESS, origLength, response);
+            return;
+        }
+    }
+}
+
+} // namespace responder
+} // namespace pldm
diff --git a/libpldmresponder/file_io.hpp b/libpldmresponder/file_io.hpp
new file mode 100644
index 0000000..a983963
--- /dev/null
+++ b/libpldmresponder/file_io.hpp
@@ -0,0 +1,103 @@
+#pragma once
+
+#include <stdint.h>
+#include <unistd.h>
+
+#include <filesystem>
+
+#include "libpldm/base.h"
+#include "libpldm/file_io.h"
+
+namespace pldm
+{
+
+namespace responder
+{
+
+namespace utils
+{
+
+/** @struct CustomFD
+ *
+ *  RAII wrapper for file descriptor.
+ */
+struct CustomFD
+{
+    CustomFD(const CustomFD&) = delete;
+    CustomFD& operator=(const CustomFD&) = delete;
+    CustomFD(CustomFD&&) = delete;
+    CustomFD& operator=(CustomFD&&) = delete;
+
+    CustomFD(int fd) : fd(fd)
+    {
+    }
+
+    ~CustomFD()
+    {
+        if (fd >= 0)
+        {
+            close(fd);
+        }
+    }
+
+    int operator()() const
+    {
+        return fd;
+    }
+
+  private:
+    int fd = -1;
+};
+
+} // namespace utils
+
+namespace dma
+{
+
+/** @struct AspeedXdmaOp
+ *
+ * Structure representing XDMA operation
+ */
+struct AspeedXdmaOp
+{
+    uint8_t upstream;  //!< boolean indicating the direction of the DMA
+                       //!< operation, true means a transfer from BMC to host.
+    uint64_t hostAddr; //!< the DMA address on the host side, configured by
+                       //!< PCI subsystem.
+    uint32_t len;      //!< the size of the transfer in bytes, it should be a
+                       //!< multiple of 16 bytes
+} __attribute__((packed));
+
+constexpr auto xdmaDev = "/dev/xdma";
+
+// The minimum data size of dma transfer in bytes
+constexpr uint32_t minSize = 16;
+
+// 16MB - 4096B (16773120 bytes) is the maximum data size of DMA transfer
+constexpr size_t maxSize = (16 * 1024 * 1024) - 4096;
+
+namespace fs = std::filesystem;
+
+/** @brief API to transfer data from BMC to host using DMA
+ *
+ *  @param[in] file - pathname of the file from which to DMA data
+ *  @param[in] offset - offset in the file
+ *  @param[in] length - length of data to read from the file
+ *  @param[in] address - dma address on the host side to transfer data
+ */
+int transferDatatoHost(const fs::path& file, uint32_t offset, uint32_t length,
+                       uint64_t address);
+
+} // namespace dma
+
+/** @brief Handler for readFileIntoMemory command
+ *
+ *  @param[in] request - pointer to PLDM request payload
+ *  @param[in] payloadLength - length of the message payload
+ *  @param[out] response - response message location
+ */
+void readFileIntoMemory(const uint8_t* request, size_t payloadLength,
+                        pldm_msg* response);
+
+} // namespace responder
+} // namespace pldm