diff --git a/Makefile.am b/Makefile.am
index 554c8ad..cfaa17b 100755
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,10 +1,14 @@
 include_HEADERS = \
- sbe_interfaces.hpp
+    sbe_interfaces.hpp
+
+noinst_HEADERS = \
+    sbe_chipOp_handler.hpp
 
 libsbeinterfacedir = ${libdir}/sbe-interface
 libsbeinterface_LTLIBRARIES = libsbeinterface.la
 
 libsbeinterface_la_SOURCES = \
- sbe_interfaces.cpp
+    sbe_interfaces.cpp \
+    sbe_chipOp_handler.cpp
 
 libsbeinterface_la_LDFLAGS = -version-info 0:0:0 -shared
diff --git a/sbe_chipOp_handler.cpp b/sbe_chipOp_handler.cpp
new file mode 100644
index 0000000..f662690
--- /dev/null
+++ b/sbe_chipOp_handler.cpp
@@ -0,0 +1,116 @@
+#include <stdexcept>
+#include <array>
+#include <sbe_chipOp_handler.hpp>
+namespace openpower
+{
+namespace sbe
+{
+namespace internal
+{
+/*! \union sbeRespHeader_t
+ *  Defines the breakup of the SBE FIFO chip operation response header.
+ */
+union sbeRespHeader_t
+{
+    uint32_t commandWord; /**<Entire 32 bit command word */
+    struct
+    {
+        uint8_t command: 8; /**<command value for which response is obtained */
+        uint8_t commandClass: 8; /**< Class of the command */
+        uint16_t magic: 16; /**< Magic code obtained in the response */
+    };
+} __attribute__((packed));
+
+
+constexpr uint16_t MAGIC_CODE = 0xC0DE;
+constexpr auto SBE_OPERATION_SUCCESSFUL = 0;
+constexpr auto LENGTH_OF_DISTANCE_HEADER_IN_WORDS = 0x1;
+constexpr auto LENGTH_OF_RESP_HEADER_IN_WORDS = 0x2;
+constexpr auto SBEI_SBE_RESPONSE_SIZE_IN_WORDS = ((sizeof(sbeRespHeader_t) + \
+        sizeof(sbe_word_t)) / 4);
+constexpr auto DISTANCE_TO_RESP_CODE = 0x1;
+
+std::vector<sbe_word_t> write(const char* devPath,
+                              const sbe_word_t* cmdBuffer,
+                              size_t cmdBufLen,
+                              size_t respBufLen)
+{
+    //TODO: Add support for reading and writing from the FIFO device
+    std::vector<sbe_word_t> response(respBufLen);
+    return response;
+}
+
+std::vector<sbe_word_t> parseResponse(
+    const std::vector<sbe_word_t>& sbeDataBuf)
+{
+
+    //Number of 32-bit words obtained from the SBE
+    size_t lengthObtained = sbeDataBuf.size();
+
+    //Fetch the SBE header and SBE chiop primary and secondary status
+    //Last value in the buffer will have the offset for the SBE header
+    size_t distanceToStatusHeader =  sbeDataBuf[sbeDataBuf.size() - 1];
+
+    if (lengthObtained < distanceToStatusHeader)
+    {
+        //TODO:use elog infrastructure
+        std::ostringstream errMsg;
+        errMsg << "Distance to SBE status header value " <<
+               distanceToStatusHeader << " is greater then total lenght of "
+               "response buffer " << lengthObtained;
+        throw std::runtime_error(errMsg.str().c_str());
+    }
+
+    //Fetch the response header contents
+    sbeRespHeader_t l_respHeader{};
+    auto iter = sbeDataBuf.begin();
+    std::advance(iter, (lengthObtained - distanceToStatusHeader));
+    l_respHeader.commandWord = *iter;
+
+    //Fetch the primary and secondary response code
+    std::advance(iter, DISTANCE_TO_RESP_CODE);
+    auto l_priSecResp = *iter;
+
+    //Validate the magic code obtained in the response
+    if (l_respHeader.magic != MAGIC_CODE)
+    {
+        //TODO:use elog infrastructure
+        std::ostringstream errMsg;
+        errMsg << "Invalid MAGIC keyword in the response header (" <<
+               l_respHeader.magic << "),expected keyword " << MAGIC_CODE;
+        throw std::runtime_error(errMsg.str().c_str());
+    }
+
+    //Validate the Primary and Secondary response value
+    if (l_priSecResp != SBE_OPERATION_SUCCESSFUL)
+    {
+        //Extract the SBE FFDC and throw it to the caller
+        size_t ffdcLen = (distanceToStatusHeader -
+                          SBEI_SBE_RESPONSE_SIZE_IN_WORDS -
+                          LENGTH_OF_DISTANCE_HEADER_IN_WORDS);
+        if (ffdcLen)
+        {
+            std::vector<sbe_word_t> ffdcData(ffdcLen);
+            //Fetch the offset of FFDC data
+            auto ffdcOffset = (lengthObtained - distanceToStatusHeader) +
+                              LENGTH_OF_RESP_HEADER_IN_WORDS;
+            std::copy_n((sbeDataBuf.begin() + ffdcOffset), ffdcLen,
+                        ffdcData.begin());
+        }
+
+        //TODO:use elog infrastructure to return the SBE and Hardware procedure
+        //FFDC container back to the caller.
+        std::ostringstream errMsg;
+        errMsg << "Chip operation failed with SBE response code:" << l_priSecResp
+               << ".Length of FFDC data of obtained:" << ffdcLen;
+        throw std::runtime_error(errMsg.str().c_str());
+    }
+    return sbeDataBuf;
+
+}
+
+}
+}
+}
+
+
diff --git a/sbe_chipOp_handler.hpp b/sbe_chipOp_handler.hpp
new file mode 100644
index 0000000..565c6fd
--- /dev/null
+++ b/sbe_chipOp_handler.hpp
@@ -0,0 +1,100 @@
+#pragma once
+
+#include <stdexcept>
+#include <array>
+#include <sstream>
+#include <algorithm>
+#include <vector>
+
+namespace openpower
+{
+namespace sbe
+{
+
+using sbe_word_t = uint32_t;
+
+namespace internal
+{
+
+/**
+ * @brief Helper function for invokeSBEChipOperation(),to write to the SBE FIFO
+ * device and obtain the expected response .Internal device driver failures
+ * will be conveyed via respective exceptions.
+ *
+ * Exceptions thrown for:
+ * - Device driver internal failures
+ *
+ * @param[in] FIFO device path associated with SBE.
+ * @param[in] Command buffer to be written to the SBE FIFO
+ * @param[in] Length of command buffer
+ * @param[in] Expected response buffer length
+ *
+ * @return Response buffer returned by the SBE for the input command.
+ */
+std::vector<sbe_word_t> write(const char* devPath,
+                              const sbe_word_t* cmdBuffer,
+                              size_t cmdBufLen,
+                              size_t respBufLen);
+
+/**
+ * @brief Helper function for invokeSBEChipOperation(), to parse the data
+ * obtained from the SBE. The header and SBE response will be verified and on
+ * success the required data will be returned to the caller. SBE interface
+ * failure will be conveyed via respective exceptions.
+ *
+ * Exceptions thrown for:
+ * - SBE Internal failures
+ *
+ * @param[in] SBE data obtained from the SBE FIFO device
+ * @return Valid chip operation response obtained by SBE.
+ */
+std::vector<sbe_word_t> parseResponse(
+    const std::vector<sbe_word_t>& sbeDataBuf);
+
+}//end of internal namespace
+
+/**
+ * @brief Interface to invoke a SBE chip operation.It calls internal API to
+ * write to the SBE FIFO and validates the data obtained by the SBE. It throws
+ * exception for any SBE internal failures.
+ *
+ * Runtime exceptions thrown for:
+ * - Device driver failures
+ * - SBE internal failures
+ *
+ * @param[in] FIFO device path associated with the SBE.
+ * @param[in] Request packet for the data to be read.
+ * @param[in] Data obtained by the SBE.
+ * @tparam S1 Length of request buffer to be send to SBE
+ * @tparam S2 Expected length of data from the SBE
+ */
+template<size_t S1, size_t S2>
+inline void invokeSBEChipOperation(const char* devPath,
+                                   const std::array<sbe_word_t, S1>& request,
+                                   std::array<sbe_word_t, S2>& chipOpData)
+{
+    //Write and read from the FIFO device.
+    auto sbeFifoResp = internal::write(devPath, request.data(), request.size(),
+                                       chipOpData.size());
+
+    //Parse the obtained data
+    auto response = internal::parseResponse(sbeFifoResp);
+
+    if (response.size() != chipOpData.size())
+    {
+        //TODO:use elog infrastructure
+        std::ostringstream errMsg;
+        errMsg << "Obtained chip operation response length (" << response.size()
+               << "from SBE is not equal to the expected length of data (" <<
+               chipOpData.size();
+
+        throw std::runtime_error(errMsg.str().c_str());
+    }
+
+    //Move the contents of response buffer into the output buffer.
+    std::move(response.begin(), response.end(), chipOpData.begin());
+}
+
+}
+}
+
diff --git a/sbe_interfaces.cpp b/sbe_interfaces.cpp
index 8e63b53..28f0bb9 100755
--- a/sbe_interfaces.cpp
+++ b/sbe_interfaces.cpp
@@ -2,12 +2,15 @@
 #include <stdexcept>
 #include <array>
 #include "sbe_interfaces.hpp"
+#include "sbe_chipOp_handler.hpp"
 
 namespace openpower
 {
 namespace sbe
 {
 
+constexpr size_t RESP_HEADER_LEN = 0x3;
+
 //Helper interfaces
 static inline uint32_t upper(uint64_t value)
 {
@@ -29,6 +32,7 @@
 static constexpr sbe_word_t WRITE_OPCODE = 0x0000A202;
 static constexpr size_t READ_CMD_LENGTH = 0x4;
 static constexpr size_t WRITE_CMD_LENGTH = 0x6;
+static constexpr size_t READ_RESP_LENGTH = 0x2;
 
 //Reading SCOM Registers
 uint64_t read(const char* devPath,
@@ -51,11 +55,16 @@
         lower(address)
     };
 
-    std::cout << "Size of read command buffer:" << command.size();
+    //Buffer to hold the response data along with the SBE header
+    const size_t respLength = RESP_HEADER_LEN + READ_RESP_LENGTH ;
+    std::array<sbe_word_t, respLength> response = {};
 
-    // TODO: Call an interface to read the command to the SBE FIFO and read the
-    // response from the SBE FIFO device
+    //Write the command buffer to the SBE FIFO and obtain the response from the
+    //SBE FIFO device.This interface will parse the obtained SBE response and
+    //any internal SBE failures will be communicated via exceptions
+    invokeSBEChipOperation(devPath, command, response);
 
+    value = (((static_cast<uint64_t>(response[0])) << 32) | response[1]);
     return value;
 }
 
@@ -80,11 +89,14 @@
         lower(data)
     };
 
-    std::cout << "Size of write command buffer:" << command.size();
- 
-    // TODO: Call an interface to write the command to the SBE FIFO and read the
-    // response from the SBE FIFO device
+    //Buffer to hold the SBE response status
+    const size_t respLength = RESP_HEADER_LEN;
+    std::array<sbe_word_t, respLength> response = {};
 
+    //Write the command buffer to the SBE FIFO and obtain the response from the
+    //SBE FIFO device.This interface will parse the obtained SBE response and
+    //any internal SBE failures will be communicated via exceptions
+    invokeSBEChipOperation(devPath, command, response);
 }
 
 } // namespace scom