diff --git a/libpldm/file_io.c b/libpldm/file_io.c
index 426033a..ca33cef 100644
--- a/libpldm/file_io.c
+++ b/libpldm/file_io.c
@@ -2,16 +2,16 @@
 #include <endian.h>
 #include <string.h>
 
-int decode_read_file_memory_req(const uint8_t *msg, size_t payload_length,
-				uint32_t *file_handle, uint32_t *offset,
-				uint32_t *length, uint64_t *address)
+int decode_rw_file_memory_req(const uint8_t *msg, size_t payload_length,
+			      uint32_t *file_handle, uint32_t *offset,
+			      uint32_t *length, uint64_t *address)
 {
 	if (msg == NULL || file_handle == NULL || offset == NULL ||
 	    length == NULL || address == NULL) {
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	if (payload_length != PLDM_READ_FILE_MEM_REQ_BYTES) {
+	if (payload_length != PLDM_RW_FILE_MEM_REQ_BYTES) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
@@ -25,8 +25,9 @@
 	return PLDM_SUCCESS;
 }
 
-int encode_read_file_memory_resp(uint8_t instance_id, uint8_t completion_code,
-				 uint32_t length, struct pldm_msg *msg)
+int encode_rw_file_memory_resp(uint8_t instance_id, uint8_t command,
+			       uint8_t completion_code, uint32_t length,
+			       struct pldm_msg *msg)
 {
 	struct pldm_header_info header = {0};
 	int rc = PLDM_SUCCESS;
@@ -37,7 +38,7 @@
 	header.msg_type = PLDM_RESPONSE;
 	header.instance = instance_id;
 	header.pldm_type = PLDM_IBM_OEM_TYPE;
-	header.command = PLDM_READ_FILE_INTO_MEMORY;
+	header.command = command;
 
 	if ((rc = pack_pldm_header(&header, &(msg->hdr))) > PLDM_SUCCESS) {
 		return rc;
diff --git a/libpldm/file_io.h b/libpldm/file_io.h
index c273608..345b363 100644
--- a/libpldm/file_io.h
+++ b/libpldm/file_io.h
@@ -14,22 +14,25 @@
 
 /** @brief PLDM Commands in IBM OEM type
  */
-enum pldm_fileio_commands { PLDM_READ_FILE_INTO_MEMORY = 0x6 };
+enum pldm_fileio_commands {
+	PLDM_READ_FILE_INTO_MEMORY = 0x6,
+	PLDM_WRITE_FILE_FROM_MEMORY = 0x7,
+};
 
 /** @brief PLDM Command specific codes
  */
 enum pldm_fileio_completion_codes {
 	PLDM_INVALID_FILE_HANDLE = 0x80,
 	PLDM_DATA_OUT_OF_RANGE = 0x81,
-	PLDM_INVALID_READ_LENGTH = 0x82
+	PLDM_INVALID_READ_LENGTH = 0x82,
+	PLDM_INVALID_WRITE_LENGTH = 0x83,
 };
 
-#define PLDM_READ_FILE_MEM_REQ_BYTES 20
-#define PLDM_READ_FILE_MEM_RESP_BYTES 5
+#define PLDM_RW_FILE_MEM_REQ_BYTES 20
+#define PLDM_RW_FILE_MEM_RESP_BYTES 5
 
-/* ReadFileIntoMemory */
-
-/** @brief Decode ReadFileIntoMemory commands request data
+/** @brief Decode ReadFileIntoMemory and WriteFileFromMemory commands request
+ *         data
  *
  *  @param[in] msg - Pointer to PLDM request message payload
  *  @param[in] payload_length - Length of request payload
@@ -40,13 +43,15 @@
  *                        written to
  *  @return pldm_completion_codes
  */
-int decode_read_file_memory_req(const uint8_t *msg, size_t payload_length,
-				uint32_t *file_handle, uint32_t *offset,
-				uint32_t *length, uint64_t *address);
+int decode_rw_file_memory_req(const uint8_t *msg, size_t payload_length,
+			      uint32_t *file_handle, uint32_t *offset,
+			      uint32_t *length, uint64_t *address);
 
-/** @brief Create a PLDM response for ReadFileIntoMemory
+/** @brief Create a PLDM response for ReadFileIntoMemory and
+ *         WriteFileFromMemory
  *
  *  @param[in] instance_id - Message's instance id
+ *  @param[in] command - PLDM command
  *  @param[in] completion_code - PLDM completion code
  *  @param[in] length - Number of bytes read. This could be less than what the
 			 requester asked for.
@@ -54,8 +59,9 @@
  *  @return pldm_completion_codes
  *  @note  Caller is responsible for memory alloc and dealloc of param 'msg'
  */
-int encode_read_file_memory_resp(uint8_t instance_id, uint8_t completion_code,
-				 uint32_t length, struct pldm_msg *msg);
+int encode_rw_file_memory_resp(uint8_t instance_id, uint8_t command,
+			       uint8_t completion_code, uint32_t length,
+			       struct pldm_msg *msg);
 
 #ifdef __cplusplus
 }
diff --git a/libpldmresponder/file_io.cpp b/libpldmresponder/file_io.cpp
index 9caa45a..ed043c6 100644
--- a/libpldmresponder/file_io.cpp
+++ b/libpldmresponder/file_io.cpp
@@ -21,76 +21,141 @@
 namespace fs = std::filesystem;
 using namespace phosphor::logging;
 
-int transferDatatoHost(const fs::path& file, uint32_t offset, uint32_t length,
-                       uint64_t address)
+namespace dma
 {
-    // Align the length of the memory mapping to the page size.
+
+/** @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";
+
+int transferDataHost(const fs::path& path, uint32_t offset, uint32_t length,
+                     uint64_t address, bool upstream)
+{
     static const size_t pageSize = getpagesize();
     uint32_t numPages = length / pageSize;
-    uint32_t pageLength = numPages * pageSize;
-    if (length > pageLength)
+    uint32_t pageAlignedLength = numPages * pageSize;
+
+    if (length > pageAlignedLength)
     {
-        pageLength += pageSize;
+        pageAlignedLength += pageSize;
     }
 
-    auto mmapCleanup = [pageLength](void* vgaMem) {
-        munmap(vgaMem, pageLength);
+    auto mmapCleanup = [pageAlignedLength](void* vgaMem) {
+        munmap(vgaMem, pageAlignedLength);
     };
 
     int fd = -1;
     int rc = 0;
-    fd = open(dma::xdmaDev, O_RDWR);
+    fd = open(xdmaDev, O_RDWR);
     if (fd < 0)
     {
-        log<level::ERR>("Opening the xdma device failed", entry("RC=%d", rc));
+        rc = -errno;
+        log<level::ERR>("Failed to open the XDMA device", entry("RC=%d", rc));
         return rc;
     }
-    auto xdmaFDPtr = std::make_unique<utils::CustomFD>(fd);
-    auto& xdmaFD = *(xdmaFDPtr.get());
 
-    void* vgaMem = nullptr;
+    utils::CustomFD xdmaFd(fd);
 
-    vgaMem = mmap(nullptr, pageLength, PROT_WRITE, MAP_SHARED, xdmaFD(), 0);
+    void* vgaMem;
+    vgaMem = mmap(nullptr, pageAlignedLength, upstream ? PROT_WRITE : PROT_READ,
+                  MAP_SHARED, xdmaFd(), 0);
     if (MAP_FAILED == vgaMem)
     {
         rc = -errno;
-        log<level::ERR>("mmap operation failed", entry("RC=%d", rc));
+        log<level::ERR>("Failed to mmap the XDMA device", 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)
+    if (upstream)
     {
-        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;
+        std::ifstream stream(path.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;
+    AspeedXdmaOp xdmaOp;
+    xdmaOp.upstream = upstream ? 1 : 0;
     xdmaOp.hostAddr = address;
     xdmaOp.len = length;
 
-    // Initiate the DMA operation
-    rc = write(xdmaFD(), &xdmaOp, sizeof(xdmaOp));
+    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),
+        log<level::ERR>("Failed to execute the DMA operation",
+                        entry("RC=%d", rc), entry("UPSTREAM=%d", upstream),
                         entry("ADDRESS=%lld", address),
                         entry("LENGTH=%d", length));
         return rc;
     }
 
-    return rc;
+    if (!upstream)
+    {
+        std::ofstream stream(path.string());
+
+        stream.seekp(offset);
+        stream.write(static_cast<const char*>(vgaMemPtr.get()), length);
+    }
+
+    return 0;
+}
+
+} // namespace dma
+
+void transferAll(uint8_t command, fs::path& path, uint32_t offset,
+                 uint32_t length, uint64_t address, bool upstream,
+                 pldm_msg* response)
+{
+    uint32_t origLength = length;
+
+    while (length > dma::maxSize)
+    {
+        auto rc = dma::transferDataHost(path, offset, dma::maxSize, address,
+                                        upstream);
+        if (rc < 0)
+        {
+            encode_rw_file_memory_resp(0, command, PLDM_ERROR, 0, response);
+            return;
+        }
+
+        offset += dma::maxSize;
+        length -= dma::maxSize;
+        address += dma::maxSize;
+    }
+
+    auto rc = dma::transferDataHost(path, offset, length, address, upstream);
+    if (rc < 0)
+    {
+        encode_rw_file_memory_resp(0, command, PLDM_ERROR, 0, response);
+        return;
+    }
+
+    encode_rw_file_memory_resp(0, command, PLDM_SUCCESS, origLength, response);
+    return;
 }
 
 void readFileIntoMemory(const uint8_t* request, size_t payloadLength,
@@ -100,33 +165,33 @@
     uint32_t offset = 0;
     uint32_t length = 0;
     uint64_t address = 0;
+    fs::path path("");
 
-    if (payloadLength != PLDM_READ_FILE_MEM_REQ_BYTES)
+    if (payloadLength != PLDM_RW_FILE_MEM_REQ_BYTES)
     {
-        encode_read_file_memory_resp(0, PLDM_ERROR_INVALID_LENGTH, 0, response);
+        encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                   PLDM_ERROR_INVALID_LENGTH, 0, response);
         return;
     }
 
-    decode_read_file_memory_req(request, payloadLength, &fileHandle, &offset,
-                                &length, &address);
+    decode_rw_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);
+        encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                   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);
+        encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                   PLDM_DATA_OUT_OF_RANGE, 0, response);
         return;
     }
 
@@ -137,41 +202,65 @@
 
     if (length % dma::minSize)
     {
-        log<level::ERR>("Readlength is not a multiple of DMA minSize",
+        log<level::ERR>("Read length is not a multiple of DMA minSize",
                         entry("LENGTH=%d", length));
-        encode_read_file_memory_resp(0, PLDM_INVALID_READ_LENGTH, 0, response);
+        encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                   PLDM_INVALID_READ_LENGTH, 0, response);
         return;
     }
 
-    uint32_t origLength = length;
+    transferAll(PLDM_READ_FILE_INTO_MEMORY, path, offset, length, address, true,
+                response);
+}
 
-    while (length > 0)
+void writeFileFromMemory(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;
+    fs::path path("");
+
+    if (payloadLength != PLDM_RW_FILE_MEM_REQ_BYTES)
     {
-        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;
-        }
+        encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
+                                   PLDM_ERROR_INVALID_LENGTH, 0, response);
+        return;
     }
+
+    decode_rw_file_memory_req(request, payloadLength, &fileHandle, &offset,
+                              &length, &address);
+
+    if (length % dma::minSize)
+    {
+        log<level::ERR>("Write length is not a multiple of DMA minSize",
+                        entry("LENGTH=%d", length));
+        encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
+                                   PLDM_INVALID_WRITE_LENGTH, 0, response);
+        return;
+    }
+
+    if (!fs::exists(path))
+    {
+        log<level::ERR>("File does not exist", entry("HANDLE=%d", fileHandle));
+        encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
+                                   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_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
+                                   PLDM_DATA_OUT_OF_RANGE, 0, response);
+        return;
+    }
+
+    transferAll(PLDM_WRITE_FILE_FROM_MEMORY, path, offset, length, address,
+                false, response);
 }
 
 } // namespace responder
diff --git a/libpldmresponder/file_io.hpp b/libpldmresponder/file_io.hpp
index a983963..ae475b9 100644
--- a/libpldmresponder/file_io.hpp
+++ b/libpldmresponder/file_io.hpp
@@ -51,45 +51,51 @@
 
 } // namespace utils
 
+namespace fs = std::filesystem;
+
 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
+/** @brief API to transfer data between BMC and 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
+ * @param[in] path     - pathname of the file to transfer data from or to
+ * @param[in] offset   - offset in the file
+ * @param[in] length   - length of the data to transfer
+ * @param[in] address  - DMA address on the host
+ * @param[in] upstream - indicates directon of the transfer; true indicates
+ *                       transfer to the host
+ *
+ * @return             - returns 0 on success, negative errno on failure
  */
-int transferDatatoHost(const fs::path& file, uint32_t offset, uint32_t length,
-                       uint64_t address);
-
+int transferDataHost(const fs::path& path, uint32_t offset, uint32_t length,
+                     uint64_t address, bool upstream);
 } // namespace dma
 
+/** @brief Transfer the data between BMC and host using DMA.
+ *
+ *  There is a max size for each DMA operation, transferAll API abstracts this
+ *  and the requested length is broken down into multiple DMA operations if the
+ *  length exceed max size.
+ *
+ * @param[in] command  - PLDM command
+ * @param[in] path     - pathname of the file to transfer data from or to
+ * @param[in] offset   - offset in the file
+ * @param[in] length   - length of the data to transfer
+ * @param[in] address  - DMA address on the host
+ * @param[in] upstream - indicates direction of the transfer; true indicates
+ *                       transfer to the host
+ * @param[out] response - response message location
+ */
+void transferAll(uint8_t command, fs::path& path, uint32_t offset,
+                 uint32_t length, uint64_t address, bool upstream,
+                 pldm_msg* response);
+
 /** @brief Handler for readFileIntoMemory command
  *
  *  @param[in] request - pointer to PLDM request payload
@@ -99,5 +105,14 @@
 void readFileIntoMemory(const uint8_t* request, size_t payloadLength,
                         pldm_msg* response);
 
+/** @brief Handler for writeFileIntoMemory command
+ *
+ *  @param[in] request - pointer to PLDM request payload
+ *  @param[in] payloadLength - length of the message payload
+ *  @param[out] response - response message location
+ */
+void writeFileFromMemory(const uint8_t* request, size_t payloadLength,
+                         pldm_msg* response);
+
 } // namespace responder
 } // namespace pldm
diff --git a/test/libpldm_fileio_test.cpp b/test/libpldm_fileio_test.cpp
index 4968d39..2a5dce1 100644
--- a/test/libpldm_fileio_test.cpp
+++ b/test/libpldm_fileio_test.cpp
@@ -7,9 +7,9 @@
 
 #include <gtest/gtest.h>
 
-TEST(ReadFileIntoMemory, testGoodDecodeRequest)
+TEST(ReadWriteFileMemory, testGoodDecodeRequest)
 {
-    std::array<uint8_t, PLDM_READ_FILE_MEM_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
 
     // Random value for fileHandle, offset, length, address
     uint32_t fileHandle = 0x12345678;
@@ -31,9 +31,9 @@
     uint64_t retAddress = 0;
 
     // Invoke decode the read file memory request
-    auto rc = decode_read_file_memory_req(requestMsg.data(), requestMsg.size(),
-                                          &retFileHandle, &retOffset,
-                                          &retLength, &retAddress);
+    auto rc = decode_rw_file_memory_req(requestMsg.data(), requestMsg.size(),
+                                        &retFileHandle, &retOffset, &retLength,
+                                        &retAddress);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(fileHandle, retFileHandle);
@@ -42,7 +42,7 @@
     ASSERT_EQ(address, retAddress);
 }
 
-TEST(ReadFileIntoMemory, testBadDecodeRequest)
+TEST(ReadWriteFileMemory, testBadDecodeRequest)
 {
     uint32_t fileHandle = 0;
     uint32_t offset = 0;
@@ -50,31 +50,33 @@
     uint64_t address = 0;
 
     // Request payload message is missing
-    auto rc = decode_read_file_memory_req(NULL, 0, &fileHandle, &offset,
-                                          &length, &address);
+    auto rc = decode_rw_file_memory_req(NULL, 0, &fileHandle, &offset, &length,
+                                        &address);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
-    std::array<uint8_t, PLDM_READ_FILE_MEM_REQ_BYTES> requestMsg{};
+    std::array<uint8_t, PLDM_RW_FILE_MEM_REQ_BYTES> requestMsg{};
 
     // Address is NULL
-    rc = decode_read_file_memory_req(requestMsg.data(), requestMsg.size(),
-                                     &fileHandle, &offset, &length, NULL);
+    rc = decode_rw_file_memory_req(requestMsg.data(), requestMsg.size(),
+                                   &fileHandle, &offset, &length, NULL);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
 
     // Payload length is invalid
-    rc = decode_read_file_memory_req(requestMsg.data(), 0, &fileHandle, &offset,
-                                     &length, &address);
+    rc = decode_rw_file_memory_req(requestMsg.data(), 0, &fileHandle, &offset,
+                                   &length, &address);
     ASSERT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
 }
 
-TEST(ReadFileIntoMemory, testGoodEncodeResponse)
+TEST(ReadWriteFileMemory, testGoodEncodeResponse)
 {
-    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_MEM_RESP_BYTES>
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
         responseMsg{};
     uint32_t length = 0xFF00EE11;
     pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
-    auto rc = encode_read_file_memory_resp(0, PLDM_SUCCESS, length, response);
+    // ReadFileIntoMemory
+    auto rc = encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                         PLDM_SUCCESS, length, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
@@ -84,16 +86,31 @@
     ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
     ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
                         &length, sizeof(length)));
+
+    // WriteFileFromMemory
+    rc = encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY,
+                                    PLDM_SUCCESS, length, response);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(response->hdr.instance_id, 0);
+    ASSERT_EQ(response->hdr.type, PLDM_IBM_OEM_TYPE);
+    ASSERT_EQ(response->hdr.command, PLDM_WRITE_FILE_FROM_MEMORY);
+    ASSERT_EQ(response->payload[0], PLDM_SUCCESS);
+    ASSERT_EQ(0, memcmp(response->payload + sizeof(response->payload[0]),
+                        &length, sizeof(length)));
 }
 
-TEST(ReadFileIntoMemory, testBadEncodeResponse)
+TEST(ReadWriteFileMemory, testBadEncodeResponse)
 {
-    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_READ_FILE_MEM_RESP_BYTES>
+    std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_RW_FILE_MEM_RESP_BYTES>
         responseMsg{};
     uint32_t length = 0;
     pldm_msg* response = reinterpret_cast<pldm_msg*>(responseMsg.data());
 
-    auto rc = encode_read_file_memory_resp(0, PLDM_ERROR, length, response);
+    // ReadFileIntoMemory
+    auto rc = encode_rw_file_memory_resp(0, PLDM_READ_FILE_INTO_MEMORY,
+                                         PLDM_ERROR, length, response);
 
     ASSERT_EQ(rc, PLDM_SUCCESS);
     ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
@@ -101,4 +118,15 @@
     ASSERT_EQ(response->hdr.type, PLDM_IBM_OEM_TYPE);
     ASSERT_EQ(response->hdr.command, PLDM_READ_FILE_INTO_MEMORY);
     ASSERT_EQ(response->payload[0], PLDM_ERROR);
+
+    // WriteFileFromMemory
+    rc = encode_rw_file_memory_resp(0, PLDM_WRITE_FILE_FROM_MEMORY, PLDM_ERROR,
+                                    length, response);
+
+    ASSERT_EQ(rc, PLDM_SUCCESS);
+    ASSERT_EQ(response->hdr.request, PLDM_RESPONSE);
+    ASSERT_EQ(response->hdr.instance_id, 0);
+    ASSERT_EQ(response->hdr.type, PLDM_IBM_OEM_TYPE);
+    ASSERT_EQ(response->hdr.command, PLDM_WRITE_FILE_FROM_MEMORY);
+    ASSERT_EQ(response->payload[0], PLDM_ERROR);
 }