diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000..ea71ad6
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,99 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlinesLeft: false
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  IndentBraces:    false
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Custom
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+PointerAlignment: Left
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex:           '^[<"](gtest|gmock)'
+    Priority:        5
+  - Regex:           '^"config.h"'
+    Priority:        -1
+  - Regex:           '^".*\.hpp"'
+    Priority:        1
+  - Regex:           '^<.*\.h>'
+    Priority:        2
+  - Regex:           '^<.*'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        4
+IndentCaseLabels: true
+IndentWidth:     4
+IndentWrappedFunctionNames: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        4
+UseTab:          Never
+...
+
diff --git a/file.hpp b/file.hpp
index 33df65f..7596db1 100644
--- a/file.hpp
+++ b/file.hpp
@@ -1,6 +1,9 @@
 #pragma once
 
 #include <unistd.h>
+
+#include <sstream>
+
 namespace openpower
 {
 namespace sbe
@@ -13,58 +16,57 @@
  */
 class FileDescriptor
 {
-    private:
-        /** @brief File descriptor for the SBE FIFO device */
-        int fd = -1;
+  private:
+    /** @brief File descriptor for the SBE FIFO device */
+    int fd = -1;
 
-    public:
-        FileDescriptor() = delete;
-        FileDescriptor(const FileDescriptor&) = delete;
-        FileDescriptor& operator=(const FileDescriptor&) = delete;
-        FileDescriptor(FileDescriptor&&) = delete;
-        FileDescriptor& operator=(FileDescriptor&&) = delete;
+  public:
+    FileDescriptor() = delete;
+    FileDescriptor(const FileDescriptor&) = delete;
+    FileDescriptor& operator=(const FileDescriptor&) = delete;
+    FileDescriptor(FileDescriptor&&) = delete;
+    FileDescriptor& operator=(FileDescriptor&&) = delete;
 
-        /** @brief Opens the input file and saves the file descriptor
-         *
-         *  @param[in] devPath - Path of the file
-         *  @para,[in] accessModes - File access modes
-         */
-        FileDescriptor(const char* devPath, int accessModes)
+    /** @brief Opens the input file and saves the file descriptor
+     *
+     *  @param[in] devPath - Path of the file
+     *  @para,[in] accessModes - File access modes
+     */
+    FileDescriptor(const char* devPath, int accessModes)
+    {
+        fd = open(devPath, accessModes);
+        if (fd < 0)
         {
-            fd = open(devPath, accessModes);
-            if (fd < 0)
-            {
-                //TODO:use elog infrastructure
-                std::ostringstream errMsg;
-                errMsg << "Opening the device with device path:" <<
-                       devPath << " and access modes:" << accessModes <<
-                       ",Failed with errno" << errno;
-                throw std::runtime_error(errMsg.str().c_str());
-            }
-
+            // TODO:use elog infrastructure
+            std::ostringstream errMsg;
+            errMsg << "Opening the device with device path:" << devPath
+                   << " and access modes:" << accessModes
+                   << ",Failed with errno" << errno;
+            throw std::runtime_error(errMsg.str().c_str());
         }
+    }
 
-        /** @brief Saves File descriptor and uses it to do file operation
-         *
-         *  @param[in] fd - File descriptor
-         */
-        FileDescriptor(int fd) : fd(fd)
+    /** @brief Saves File descriptor and uses it to do file operation
+     *
+     *  @param[in] fd - File descriptor
+     */
+    FileDescriptor(int fd) : fd(fd)
+    {
+        // Nothing
+    }
+
+    ~FileDescriptor()
+    {
+        if (fd >= 0)
         {
-            // Nothing
+            close(fd);
         }
+    }
 
-        ~FileDescriptor()
-        {
-            if (fd >= 0)
-            {
-                close(fd);
-            }
-        }
-
-        int operator()()
-        {
-            return fd;
-        }
+    int operator()()
+    {
+        return fd;
+    }
 };
 
 } // namespace internal
diff --git a/sbe_chipOp_handler.cpp b/sbe_chipOp_handler.cpp
index 361e9f4..dbed874 100644
--- a/sbe_chipOp_handler.cpp
+++ b/sbe_chipOp_handler.cpp
@@ -1,11 +1,12 @@
-#include <array>
+#include <endian.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <unistd.h>
 #include <poll.h>
-#include <endian.h>
-#include <sbe_chipOp_handler.hpp>
+#include <unistd.h>
+
+#include <array>
 #include <file.hpp>
+#include <sbe_chipOp_handler.hpp>
 namespace openpower
 {
 namespace sbe
@@ -23,17 +24,16 @@
 constexpr auto MAGIC_CODE_BITS = 16;
 std::vector<sbe_word_t> writeToFifo(const char* devPath,
                                     const sbe_word_t* cmdBuffer,
-                                    size_t cmdBufLen,
-                                    size_t respBufLen)
+                                    size_t cmdBufLen, size_t respBufLen)
 {
     ssize_t len = 0;
     std::vector<sbe_word_t> response;
     std::ostringstream errMsg;
 
-    //Open the device and obtain the file descriptor associated with it.
+    // Open the device and obtain the file descriptor associated with it.
     FileDescriptor fileFd(devPath, (O_RDWR | O_NONBLOCK));
 
-    //Wait for FIFO device and perform write operation
+    // Wait for FIFO device and perform write operation
     struct pollfd poll_fd = {};
     poll_fd.fd = fileFd();
     poll_fd.events = POLLOUT | POLLERR;
@@ -41,145 +41,150 @@
     int rc = 0;
     if ((rc = poll(&poll_fd, 1, -1)) < 0)
     {
-        //TODO:use elog infrastructure
+        // TODO:use elog infrastructure
         errMsg << "Waiting for FIFO device:" << devPath << "to write failed"
                << "rc=" << rc << "errno=" << errno;
         throw std::runtime_error(errMsg.str().c_str());
     }
     if (poll_fd.revents & POLLERR)
     {
-        //TODO:use elog infrastructure
+        // TODO:use elog infrastructure
         errMsg << "POLLERR while waiting for writeable FIFO,errno:" << errno;
         throw std::runtime_error(errMsg.str().c_str());
     }
     auto bytesToWrite = (cmdBufLen * WORD_SIZE);
-    //Perform the write operation
+    // Perform the write operation
     len = write(fileFd(), cmdBuffer, bytesToWrite);
     if (len < 0)
     {
-        //TODO:use elog infrastructure
-        errMsg << "Failed to write to FIFO device:" << devPath << " Length "
-               "returned= " << len << " errno=" << errno;
+        // TODO:use elog infrastructure
+        errMsg << "Failed to write to FIFO device:" << devPath
+               << " Length "
+                  "returned= "
+               << len << " errno=" << errno;
         throw std::runtime_error(errMsg.str().c_str());
     }
-    //Wait for FIFO device and perform read operation
+    // Wait for FIFO device and perform read operation
     poll_fd.fd = fileFd();
     poll_fd.events = POLLIN | POLLERR;
     if ((rc = poll(&poll_fd, 1, -1) < 0))
     {
-        //TODO:use elog infrastructure
+        // TODO:use elog infrastructure
         errMsg << "Waiting for FIFO device:" << devPath << "to read failed"
                << " rc=" << rc << " and errno=" << errno;
         throw std::runtime_error(errMsg.str().c_str());
     }
     if (poll_fd.revents & POLLERR)
     {
-        //TODO:use elog infrastructure
+        // TODO:use elog infrastructure
         errMsg << "POLLERR while waiting for readable FIFO,errno:" << errno;
         throw std::runtime_error(errMsg.str().c_str());
     }
-    //Derive the total read length which should include the FFDC, which SBE
-    //returns in case of failure.
+    // Derive the total read length which should include the FFDC, which SBE
+    // returns in case of failure.
     size_t totalReadLen = respBufLen + MAX_FFDC_LEN_IN_WORDS;
-    //Create a temporary buffer
+    // Create a temporary buffer
     std::vector<sbe_word_t> buffer(totalReadLen);
 
     ssize_t bytesToRead = (totalReadLen * WORD_SIZE);
     len = read(fileFd(), buffer.data(), bytesToRead);
     if (len < 0)
     {
-        //TODO:use elog infrastructure
-        errMsg << "Failed to read the FIFO device:" << devPath << "bytes read ="
-               << len << " errno=" << errno;
+        // TODO:use elog infrastructure
+        errMsg << "Failed to read the FIFO device:" << devPath
+               << "bytes read =" << len << " errno=" << errno;
         throw std::runtime_error(errMsg.str().c_str());
     }
 
-    //Extract the valid number of words read.
+    // Extract the valid number of words read.
     for (auto i = 0; i < (len / WORD_SIZE); ++i)
     {
         response.push_back(be32toh(buffer[i]));
     }
 
-    //Closing of the file descriptor will be handled when the FileDescriptor
-    //object will go out of scope.
+    // Closing of the file descriptor will be handled when the FileDescriptor
+    // object will go out of scope.
     return response;
 }
 
 void parseResponse(std::vector<sbe_word_t>& sbeDataBuf)
 {
-    //Number of 32-bit words obtained from the SBE
+    // 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];
+    // 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
+        // TODO:use elog infrastructure
         std::ostringstream errMsg;
-        errMsg << "Distance to SBE status header value " <<
-               distanceToStatusHeader << " is greater then total length of "
-               "response buffer " << lengthObtained;
+        errMsg << "Distance to SBE status header value "
+               << distanceToStatusHeader
+               << " is greater then total length of "
+                  "response buffer "
+               << lengthObtained;
         throw std::runtime_error(errMsg.str().c_str());
     }
 
-    //Fetch the response header contents
+    // Fetch the response header contents
     auto iter = sbeDataBuf.begin();
     std::advance(iter, (lengthObtained - distanceToStatusHeader));
 
-    //First header word will have 2 bytes of MAGIC CODE followed by
-    //Command class and command type
+    // First header word will have 2 bytes of MAGIC CODE followed by
+    // Command class and command type
     //|  MAGIC BYTES:0xCODE | COMMAND-CLASS | COMMAND-TYPE|
     sbe_word_t l_magicCode = (*iter >> MAGIC_CODE_BITS);
 
-    //Fetch the primary and secondary response code
+    // 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
+    // Validate the magic code obtained in the response
     if (l_magicCode != MAGIC_CODE)
     {
-        //TODO:use elog infrastructure
+        // TODO:use elog infrastructure
         std::ostringstream errMsg;
-        errMsg << "Invalid MAGIC keyword in the response header (" <<
-               l_magicCode << "),expected keyword " << MAGIC_CODE;
+        errMsg << "Invalid MAGIC keyword in the response header ("
+               << l_magicCode << "),expected keyword " << MAGIC_CODE;
         throw std::runtime_error(errMsg.str().c_str());
     }
 
-    //Validate the Primary and Secondary response value
+    // 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 -
-                          LENGTH_OF_RESP_HEADER_IN_WORDS -
-                          LENGTH_OF_DISTANCE_HEADER_IN_WORDS);
+        // Extract the SBE FFDC and throw it to the caller
+        size_t ffdcLen =
+            (distanceToStatusHeader - LENGTH_OF_RESP_HEADER_IN_WORDS -
+             LENGTH_OF_DISTANCE_HEADER_IN_WORDS);
         if (ffdcLen)
         {
             std::vector<sbe_word_t> ffdcData(ffdcLen);
-            //Fetch the offset of FFDC data
+            // 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.
+        // 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
+        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());
     }
 
-    //In case of success, remove the response header content and send only the
-    //data.Response header will be towards the end of the buffer.
+    // In case of success, remove the response header content and send only the
+    // data.Response header will be towards the end of the buffer.
     auto respLen = (lengthObtained - distanceToStatusHeader);
     iter = sbeDataBuf.begin();
-    std::advance(iter,respLen);
+    std::advance(iter, respLen);
     sbeDataBuf.erase(iter, sbeDataBuf.end());
 }
 
-}
-}
-}
+} // namespace internal
+} // namespace sbe
+} // namespace openpower
diff --git a/sbe_chipOp_handler.hpp b/sbe_chipOp_handler.hpp
index 3e29c1e..d90558a 100644
--- a/sbe_chipOp_handler.hpp
+++ b/sbe_chipOp_handler.hpp
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <stdexcept>
-#include <array>
-#include <sstream>
 #include <algorithm>
-#include <vector>
+#include <array>
 #include <sbe_interfaces.hpp>
+#include <sstream>
+#include <stdexcept>
+#include <vector>
 
 namespace openpower
 {
@@ -34,8 +34,7 @@
  */
 std::vector<sbe_word_t> writeToFifo(const char* devPath,
                                     const sbe_word_t* cmdBuffer,
-                                    size_t cmdBufLen,
-                                    size_t respBufLen);
+                                    size_t cmdBufLen, size_t respBufLen);
 
 /**
  * @brief Helper function for invokeSBEChipOperation(), to parse and validate
@@ -53,7 +52,7 @@
  */
 void parseResponse(std::vector<sbe_word_t>& sbeDataBuf);
 
-}//end of internal namespace
+} // namespace internal
 
 /**
  * @brief Interface to invoke a SBE chip operation.It calls internal API to
@@ -70,34 +69,35 @@
  * @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>
+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.
+    // Write and read from the FIFO device.
     auto sbeFifoResp = internal::writeToFifo(devPath, request.data(),
-                       request.size(), chipOpData.size());
+                                             request.size(), chipOpData.size());
 
-    //Parse the obtained data
+    // Parse the obtained data
     internal::parseResponse(sbeFifoResp);
-    //Above interface would have stripped the SBE header content from the input
-    //response buffer.
+    // Above interface would have stripped the SBE header content from the input
+    // response buffer.
     if (sbeFifoResp.size() > chipOpData.size())
     {
-        //TODO:use elog infrastructure
+        // TODO:use elog infrastructure
         std::ostringstream errMsg;
-        errMsg << "Obtained chip operation response length (" <<
-               sbeFifoResp.size() << "from SBE is greater than maximum expected"
-               " length:" << chipOpData.size();
+        errMsg << "Obtained chip operation response length ("
+               << sbeFifoResp.size()
+               << "from SBE is greater than maximum expected"
+                  " length:"
+               << chipOpData.size();
 
         throw std::runtime_error(errMsg.str().c_str());
     }
 
-    //Move the contents of response buffer into the output buffer.
+    // Move the contents of response buffer into the output buffer.
     std::move(sbeFifoResp.begin(), sbeFifoResp.end(), chipOpData.begin());
 }
 
-}
-}
-
+} // namespace sbe
+} // namespace openpower
diff --git a/sbe_interfaces.cpp b/sbe_interfaces.cpp
old mode 100755
new mode 100644
index 195c1f7..bf777b2
--- a/sbe_interfaces.cpp
+++ b/sbe_interfaces.cpp
@@ -1,9 +1,12 @@
+#include "sbe_interfaces.hpp"
+
+#include "sbe_chipOp_handler.hpp"
+
+#include <endian.h>
+
+#include <array>
 #include <iostream>
 #include <stdexcept>
-#include <array>
-#include <endian.h>
-#include "sbe_interfaces.hpp"
-#include "sbe_chipOp_handler.hpp"
 
 namespace openpower
 {
@@ -12,7 +15,7 @@
 
 constexpr size_t RESP_HEADER_LEN = 0x3;
 
-//Helper interfaces
+// Helper interfaces
 static inline uint32_t upper(uint64_t value)
 {
     return ((value & 0xFFFFFFFF00000000ull) >> 32);
@@ -28,79 +31,70 @@
 namespace scom
 {
 
-//Constants specific to SCOM operations
-static constexpr sbe_word_t READ_OPCODE  = 0x0000A201;
+// Constants specific to SCOM operations
+static constexpr sbe_word_t READ_OPCODE = 0x0000A201;
 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,
-              uint64_t address)
+// Reading SCOM Registers
+uint64_t read(const char* devPath, uint64_t address)
 {
     uint64_t value = 0;
 
-    //Validate input device path
+    // Validate input device path
     if (devPath == nullptr)
     {
         throw std::runtime_error("NULL FIFO device path");
     }
 
-    //Build SCOM read request command.
-    //Handle byte order mismatch ,SBE is big endian and BMC is
-    //little endian.
-    std::array<sbe_word_t, READ_CMD_LENGTH> command =
-    {
-        static_cast<sbe_word_t>(htobe32(READ_CMD_LENGTH)),
-        htobe32(READ_OPCODE),
-        htobe32(upper(address)),
-        htobe32(lower(address))
-    };
+    // Build SCOM read request command.
+    // Handle byte order mismatch ,SBE is big endian and BMC is
+    // little endian.
+    std::array<sbe_word_t, READ_CMD_LENGTH> command = {
+        static_cast<sbe_word_t>(htobe32(READ_CMD_LENGTH)), htobe32(READ_OPCODE),
+        htobe32(upper(address)), htobe32(lower(address))};
 
-    //Buffer to hold the response data along with the SBE header
-    const size_t respLength = RESP_HEADER_LEN + READ_RESP_LENGTH ;
+    // 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 = {};
 
-    //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
+    // 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;
 }
 
-void write(const char* devPath,
-           uint64_t address,
-           uint64_t data)
+void write(const char* devPath, uint64_t address, uint64_t data)
 {
-    //Validate input device path
+    // Validate input device path
     if (devPath == nullptr)
     {
         throw std::runtime_error("NULL FIFO device path");
     }
 
-    //Build SCOM write request command
-    //Handle byte order mismatch, SBE is big endian and BMC is
-    //little endian.
-    std::array<sbe_word_t, WRITE_CMD_LENGTH> command =
-    {
+    // Build SCOM write request command
+    // Handle byte order mismatch, SBE is big endian and BMC is
+    // little endian.
+    std::array<sbe_word_t, WRITE_CMD_LENGTH> command = {
         static_cast<sbe_word_t>(htobe32(WRITE_CMD_LENGTH)),
         htobe32(WRITE_OPCODE),
         htobe32(upper(address)),
         htobe32(lower(address)),
         htobe32(upper(data)),
-        htobe32(lower(data))
-    };
+        htobe32(lower(data))};
 
-    //Buffer to hold the SBE response status
+    // 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
+    // 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);
 }
 
diff --git a/sbe_interfaces.hpp b/sbe_interfaces.hpp
old mode 100755
new mode 100644
index ab3877e..61ff37c
--- a/sbe_interfaces.hpp
+++ b/sbe_interfaces.hpp
@@ -18,9 +18,7 @@
  * @param[in] SCOM register address.
  * @return The register data
  */
-uint64_t read(const char* devPath,
-              uint64_t address);
-
+uint64_t read(const char* devPath, uint64_t address);
 
 /**
  * @brief Write processor SCOM register.
@@ -31,10 +29,8 @@
  * @param[in] SCOM register address.
  * @param[in] Data to be written into the register.
  */
-void write(const char* devPath,
-           uint64_t address,
-           uint64_t data);
+void write(const char* devPath, uint64_t address, uint64_t data);
 
-}//namespace scom
-}//namespace sbe
-}//namespace openpower
+} // namespace scom
+} // namespace sbe
+} // namespace openpower