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/argument.cpp b/argument.cpp
index 3a59f68..74bdda2 100644
--- a/argument.cpp
+++ b/argument.cpp
@@ -14,11 +14,12 @@
  * limitations under the License.
  */
 
-#include <iostream>
-#include <iterator>
+#include "argument.hpp"
+
 #include <algorithm>
 #include <cassert>
-#include "argument.hpp"
+#include <iostream>
+#include <iterator>
 
 namespace phosphor
 {
@@ -31,21 +32,21 @@
 const std::string ArgumentParser::emptyString = ""s;
 
 const char* ArgumentParser::optionStr = "p:k:r:t:?h";
-const option ArgumentParser::options[] =
-{
-    { "path",     required_argument,  nullptr,   'p' },
-    { "key",      required_argument,  nullptr,   'k' },
-    { "polarity", required_argument,  nullptr,   'r' },
-    { "target",   required_argument,  nullptr,   't' },
-    { "continue", no_argument,        nullptr,   'c' },
-    { "help",     no_argument,        nullptr,   'h' },
-    { 0, 0, 0, 0},
+const option ArgumentParser::options[] = {
+    {"path", required_argument, nullptr, 'p'},
+    {"key", required_argument, nullptr, 'k'},
+    {"polarity", required_argument, nullptr, 'r'},
+    {"target", required_argument, nullptr, 't'},
+    {"continue", no_argument, nullptr, 'c'},
+    {"help", no_argument, nullptr, 'h'},
+    {0, 0, 0, 0},
 };
 
 ArgumentParser::ArgumentParser(int argc, char** argv)
 {
     int option = 0;
-    while (-1 != (option = getopt_long(argc, argv, optionStr, options, nullptr)))
+    while (-1 !=
+           (option = getopt_long(argc, argv, optionStr, options, nullptr)))
     {
         if ((option == '?') || (option == 'h'))
         {
@@ -88,14 +89,14 @@
     std::cerr << "Options:\n";
     std::cerr << "  --help                  Print this menu\n";
     std::cerr << "  --path=<path>           Path of input device."
-                                            " Ex: /dev/input/event2\n";
+                 " Ex: /dev/input/event2\n";
     std::cerr << "  --key=<key>             Input GPIO key number\n";
     std::cerr << "  --polarity=<polarity>   Asertion polarity to look for."
-                                            " This is 0 / 1 \n";
+                 " This is 0 / 1 \n";
     std::cerr << "  --target=<systemd unit> Systemd unit to be called on GPIO"
-                                            " state change\n";
+                 " state change\n";
     std::cerr << "  [--continue]            Whether or not to continue"
-                                            " after key pressed\n";
+                 " after key pressed\n";
 }
 } // namespace gpio
 } // namespace phosphor
diff --git a/argument.hpp b/argument.hpp
index 3debea5..7917b8a 100644
--- a/argument.hpp
+++ b/argument.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <getopt.h>
+
 #include <map>
 #include <string>
 
@@ -13,51 +14,51 @@
  */
 class ArgumentParser
 {
-    public:
-        ArgumentParser() = delete;
-        ~ArgumentParser() = default;
-        ArgumentParser(const ArgumentParser&) = delete;
-        ArgumentParser& operator=(const ArgumentParser&) = delete;
-        ArgumentParser(ArgumentParser&&) = default;
-        ArgumentParser& operator=(ArgumentParser&&) = default;
+  public:
+    ArgumentParser() = delete;
+    ~ArgumentParser() = default;
+    ArgumentParser(const ArgumentParser&) = delete;
+    ArgumentParser& operator=(const ArgumentParser&) = delete;
+    ArgumentParser(ArgumentParser&&) = default;
+    ArgumentParser& operator=(ArgumentParser&&) = default;
 
-        /** @brief Constructs Argument object
-         *
-         *  @param argc - the main function's argc passed as is
-         *  @param argv - the main function's argv passed as is
-         *  @return Object constructed
-         */
-        ArgumentParser(int argc, char** argv);
+    /** @brief Constructs Argument object
+     *
+     *  @param argc - the main function's argc passed as is
+     *  @param argv - the main function's argv passed as is
+     *  @return Object constructed
+     */
+    ArgumentParser(int argc, char** argv);
 
-        /** @brief Given an option, returns its argument(optarg)
-         *
-         *  @param opt - command line option string
-         *
-         *  @return argument which is a standard optarg
-         */
-        const std::string& operator[](const std::string& opt);
+    /** @brief Given an option, returns its argument(optarg)
+     *
+     *  @param opt - command line option string
+     *
+     *  @return argument which is a standard optarg
+     */
+    const std::string& operator[](const std::string& opt);
 
-        /** @brief Displays usage
-         *
-         *  @param argv - the main function's argv passed as is
-         */
-        static void usage(char** argv);
+    /** @brief Displays usage
+     *
+     *  @param argv - the main function's argv passed as is
+     */
+    static void usage(char** argv);
 
-        /** @brief Set to 'true' when an option is passed */
-        static const std::string trueString;
+    /** @brief Set to 'true' when an option is passed */
+    static const std::string trueString;
 
-        /** @brief Set to '' when an option is not passed */
-        static const std::string emptyString;
+    /** @brief Set to '' when an option is not passed */
+    static const std::string emptyString;
 
-    private:
-        /** @brief Option to argument mapping */
-        std::map<const std::string, std::string> arguments;
+  private:
+    /** @brief Option to argument mapping */
+    std::map<const std::string, std::string> arguments;
 
-        /** @brief Array of struct options as needed by getopt_long */
-        static const option options[];
+    /** @brief Array of struct options as needed by getopt_long */
+    static const option options[];
 
-        /** @brief optstring as needed by getopt_long */
-        static const char* optionStr;
+    /** @brief optstring as needed by getopt_long */
+    static const char* optionStr;
 };
 
 } // namespace gpio
diff --git a/evdev.cpp b/evdev.cpp
index e8e98e2..056093a 100644
--- a/evdev.cpp
+++ b/evdev.cpp
@@ -1,10 +1,13 @@
-#include <libevdev/libevdev.h>
+#include "evdev.hpp"
+
+#include "xyz/openbmc_project/Common/error.hpp"
+
 #include <fcntl.h>
+#include <libevdev/libevdev.h>
+
+#include <phosphor-logging/elog-errors.hpp>
 #include <phosphor-logging/elog.hpp>
 #include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include "xyz/openbmc_project/Common/error.hpp"
-#include "evdev.hpp"
 
 namespace phosphor
 {
@@ -56,8 +59,8 @@
 void Evdev::registerCallback()
 {
     decltype(eventSource.get()) sourcePtr = nullptr;
-    auto rc = sd_event_add_io(event.get(), &sourcePtr, (fd)(),
-                              EPOLLIN, callbackHandler, this);
+    auto rc = sd_event_add_io(event.get(), &sourcePtr, (fd)(), EPOLLIN,
+                              callbackHandler, this);
     eventSource.reset(sourcePtr);
 
     if (rc < 0)
diff --git a/evdev.hpp b/evdev.hpp
index 353c593..eb7781b 100644
--- a/evdev.hpp
+++ b/evdev.hpp
@@ -1,9 +1,14 @@
 #pragma once
-#include <string>
-#include <systemd/sd-event.h>
-#include <libevdev/libevdev.h>
 #include "file.hpp"
 
+#include <libevdev/libevdev.h>
+#include <systemd/sd-event.h>
+
+#include <map>
+#include <memory>
+#include <sdbusplus/message.hpp>
+#include <string>
+
 namespace phosphor
 {
 namespace gpio
@@ -46,85 +51,79 @@
 class Evdev
 {
 
-        using Property = std::string;
-        using Value = sdbusplus::message::variant<bool, std::string>;
-        // Association between property and its value
-        using PropertyMap = std::map<Property, Value>;
-        using Interface = std::string;
-        // Association between interface and the D-Bus property
-        using InterfaceMap = std::map<Interface, PropertyMap>;
-        using Object = sdbusplus::message::object_path;
-        // Association between object and the interface
-        using ObjectMap = std::map<Object, InterfaceMap>;
+    using Property = std::string;
+    using Value = sdbusplus::message::variant<bool, std::string>;
+    // Association between property and its value
+    using PropertyMap = std::map<Property, Value>;
+    using Interface = std::string;
+    // Association between interface and the D-Bus property
+    using InterfaceMap = std::map<Interface, PropertyMap>;
+    using Object = sdbusplus::message::object_path;
+    // Association between object and the interface
+    using ObjectMap = std::map<Object, InterfaceMap>;
 
-    public:
-        Evdev() = delete;
-        ~Evdev() = default;
-        Evdev(const Evdev&) = delete;
-        Evdev& operator=(const Evdev&) = delete;
-        Evdev(Evdev&&) = delete;
-        Evdev& operator=(Evdev&&) = delete;
+  public:
+    Evdev() = delete;
+    ~Evdev() = default;
+    Evdev(const Evdev&) = delete;
+    Evdev& operator=(const Evdev&) = delete;
+    Evdev(Evdev&&) = delete;
+    Evdev& operator=(Evdev&&) = delete;
 
-        /** @brief Constructs Evdev object.
-         *
-         *  @param[in] path      - Device path to read for GPIO pin state
-         *  @param[in] key       - GPIO key to monitor
-         *  @param[in] event     - sd_event handler
-         *  @param[in] handler   - IO callback handler.
-         *  @param[in] useEvDev  - Whether to use EvDev to retrieve events
-         */
-        Evdev(const std::string& path,
-              const unsigned int key,
-              EventPtr& event,
-              sd_event_io_handler_t handler,
-              bool useEvDev = true) :
-            path(path),
-            key(key),
-            event(event),
-            callbackHandler(handler),
-            fd(openDevice())
+    /** @brief Constructs Evdev object.
+     *
+     *  @param[in] path      - Device path to read for GPIO pin state
+     *  @param[in] key       - GPIO key to monitor
+     *  @param[in] event     - sd_event handler
+     *  @param[in] handler   - IO callback handler.
+     *  @param[in] useEvDev  - Whether to use EvDev to retrieve events
+     */
+    Evdev(const std::string& path, const unsigned int key, EventPtr& event,
+          sd_event_io_handler_t handler, bool useEvDev = true) :
+        path(path),
+        key(key), event(event), callbackHandler(handler), fd(openDevice())
 
+    {
+        if (useEvDev)
         {
-            if (useEvDev)
-            {
-                // If we are asked to use EvDev, do that initialization.
-                initEvDev();
-            }
-
-            // Register callback handler when FD has some data
-            registerCallback();
+            // If we are asked to use EvDev, do that initialization.
+            initEvDev();
         }
 
-    protected:
-        /** @brief Device path to read for GPIO pin state */
-        const std::string path;
+        // Register callback handler when FD has some data
+        registerCallback();
+    }
 
-        /** @brief GPIO key to monitor */
-        const unsigned int key;
+  protected:
+    /** @brief Device path to read for GPIO pin state */
+    const std::string path;
 
-        /** @brief Event structure */
-        EvdevPtr devicePtr;
+    /** @brief GPIO key to monitor */
+    const unsigned int key;
 
-        /** @brief Monitor to sd_event */
-        EventPtr& event;
+    /** @brief Event structure */
+    EvdevPtr devicePtr;
 
-        /** @brief Callback handler when the FD has some data */
-        sd_event_io_handler_t callbackHandler;
+    /** @brief Monitor to sd_event */
+    EventPtr& event;
 
-        /** @brief event source */
-        EventSourcePtr eventSource;
+    /** @brief Callback handler when the FD has some data */
+    sd_event_io_handler_t callbackHandler;
 
-        /** @brief Opens the device and populates the descriptor */
-        int openDevice();
+    /** @brief event source */
+    EventSourcePtr eventSource;
 
-        /** @brief attaches FD to events and sets up callback handler */
-        void registerCallback();
+    /** @brief Opens the device and populates the descriptor */
+    int openDevice();
 
-        /** @brief File descriptor manager */
-        FileDescriptor fd;
+    /** @brief attaches FD to events and sets up callback handler */
+    void registerCallback();
 
-        /** @brief Initializes evdev handle with the fd */
-        void initEvDev();
+    /** @brief File descriptor manager */
+    FileDescriptor fd;
+
+    /** @brief Initializes evdev handle with the fd */
+    void initEvDev();
 };
 
 } // namespace gpio
diff --git a/file.hpp b/file.hpp
index ee8fd4b..500d8be 100644
--- a/file.hpp
+++ b/file.hpp
@@ -10,48 +10,48 @@
  */
 class FileDescriptor
 {
-    private:
-        /** @brief File descriptor for the gpio input device */
-        int fd = -1;
+  private:
+    /** @brief File descriptor for the gpio input device */
+    int fd = -1;
 
-    public:
-        FileDescriptor() = default;
-        FileDescriptor(const FileDescriptor&) = delete;
-        FileDescriptor& operator=(const FileDescriptor&) = delete;
-        FileDescriptor(FileDescriptor&&) = delete;
-        FileDescriptor& operator=(FileDescriptor&&) = delete;
+  public:
+    FileDescriptor() = default;
+    FileDescriptor(const FileDescriptor&) = delete;
+    FileDescriptor& operator=(const FileDescriptor&) = delete;
+    FileDescriptor(FileDescriptor&&) = delete;
+    FileDescriptor& operator=(FileDescriptor&&) = delete;
 
-        /** @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;
-        }
+    operator bool() const
+    {
+        return fd != -1;
+    }
 
-        operator bool() const
-        {
-            return fd != -1;
-        }
-
-        void set(int descriptor)
-        {
-            fd = descriptor;
-        }
+    void set(int descriptor)
+    {
+        fd = descriptor;
+    }
 };
 
 } // namespace gpio
diff --git a/gpio-util/argument.cpp b/gpio-util/argument.cpp
index 222b7d3..913313c 100644
--- a/gpio-util/argument.cpp
+++ b/gpio-util/argument.cpp
@@ -13,10 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "argument.hpp"
+
+#include <algorithm>
 #include <iostream>
 #include <iterator>
-#include <algorithm>
-#include "argument.hpp"
 
 namespace phosphor
 {
@@ -67,23 +68,22 @@
     std::cerr << "    --help            Print this menu.\n";
     std::cerr << "    --gpio=<gpio>     The GPIO number.  Example: 1\n";
     std::cerr << "    --path=<path>     The path to the GPIO device."
-                                        "  Example: /dev/gpiochip0\n";
+                 "  Example: /dev/gpiochip0\n";
     std::cerr << "    --delay=<delay>   The delay in ms in between a toggle."
-                                        "  Example: 5\n";
+                 "  Example: 5\n";
     std::cerr << "    --action=<action> The action to do.\n";
     std::cerr << "                      Valid actions: low, high, low_high, "
-                                        "high_low\n";
+                 "high_low\n";
     std::cerr << std::flush;
 }
 
-const option ArgumentParser::options[] =
-{
-    { "action", required_argument, NULL, 'a' },
-    { "gpio",   required_argument, NULL, 'g' },
-    { "delay",  required_argument, NULL, 'd' },
-    { "path",   required_argument, NULL, 'p' },
-    { "help",   no_argument,       NULL, 'h' },
-    { 0, 0, 0, 0},
+const option ArgumentParser::options[] = {
+    {"action", required_argument, NULL, 'a'},
+    {"gpio", required_argument, NULL, 'g'},
+    {"delay", required_argument, NULL, 'd'},
+    {"path", required_argument, NULL, 'p'},
+    {"help", no_argument, NULL, 'h'},
+    {0, 0, 0, 0},
 };
 
 const char* ArgumentParser::optionStr = "a:g:d:p:h?";
@@ -91,5 +91,5 @@
 const std::string ArgumentParser::trueString = "true";
 const std::string ArgumentParser::emptyString = "";
 
-}
-}
+} // namespace gpio
+} // namespace phosphor
diff --git a/gpio-util/argument.hpp b/gpio-util/argument.hpp
index 3debea5..7917b8a 100644
--- a/gpio-util/argument.hpp
+++ b/gpio-util/argument.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <getopt.h>
+
 #include <map>
 #include <string>
 
@@ -13,51 +14,51 @@
  */
 class ArgumentParser
 {
-    public:
-        ArgumentParser() = delete;
-        ~ArgumentParser() = default;
-        ArgumentParser(const ArgumentParser&) = delete;
-        ArgumentParser& operator=(const ArgumentParser&) = delete;
-        ArgumentParser(ArgumentParser&&) = default;
-        ArgumentParser& operator=(ArgumentParser&&) = default;
+  public:
+    ArgumentParser() = delete;
+    ~ArgumentParser() = default;
+    ArgumentParser(const ArgumentParser&) = delete;
+    ArgumentParser& operator=(const ArgumentParser&) = delete;
+    ArgumentParser(ArgumentParser&&) = default;
+    ArgumentParser& operator=(ArgumentParser&&) = default;
 
-        /** @brief Constructs Argument object
-         *
-         *  @param argc - the main function's argc passed as is
-         *  @param argv - the main function's argv passed as is
-         *  @return Object constructed
-         */
-        ArgumentParser(int argc, char** argv);
+    /** @brief Constructs Argument object
+     *
+     *  @param argc - the main function's argc passed as is
+     *  @param argv - the main function's argv passed as is
+     *  @return Object constructed
+     */
+    ArgumentParser(int argc, char** argv);
 
-        /** @brief Given an option, returns its argument(optarg)
-         *
-         *  @param opt - command line option string
-         *
-         *  @return argument which is a standard optarg
-         */
-        const std::string& operator[](const std::string& opt);
+    /** @brief Given an option, returns its argument(optarg)
+     *
+     *  @param opt - command line option string
+     *
+     *  @return argument which is a standard optarg
+     */
+    const std::string& operator[](const std::string& opt);
 
-        /** @brief Displays usage
-         *
-         *  @param argv - the main function's argv passed as is
-         */
-        static void usage(char** argv);
+    /** @brief Displays usage
+     *
+     *  @param argv - the main function's argv passed as is
+     */
+    static void usage(char** argv);
 
-        /** @brief Set to 'true' when an option is passed */
-        static const std::string trueString;
+    /** @brief Set to 'true' when an option is passed */
+    static const std::string trueString;
 
-        /** @brief Set to '' when an option is not passed */
-        static const std::string emptyString;
+    /** @brief Set to '' when an option is not passed */
+    static const std::string emptyString;
 
-    private:
-        /** @brief Option to argument mapping */
-        std::map<const std::string, std::string> arguments;
+  private:
+    /** @brief Option to argument mapping */
+    std::map<const std::string, std::string> arguments;
 
-        /** @brief Array of struct options as needed by getopt_long */
-        static const option options[];
+    /** @brief Array of struct options as needed by getopt_long */
+    static const option options[];
 
-        /** @brief optstring as needed by getopt_long */
-        static const char* optionStr;
+    /** @brief optstring as needed by getopt_long */
+    static const char* optionStr;
 };
 
 } // namespace gpio
diff --git a/gpio-util/gpio.cpp b/gpio-util/gpio.cpp
index 080ab99..da5801e 100644
--- a/gpio-util/gpio.cpp
+++ b/gpio-util/gpio.cpp
@@ -13,11 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <fcntl.h>
-#include <phosphor-logging/log.hpp>
-#include <sys/ioctl.h>
 #include "gpio.hpp"
 
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+#include <phosphor-logging/log.hpp>
+
 namespace phosphor
 {
 namespace gpio
@@ -38,16 +40,14 @@
     if (rc == -1)
     {
         auto e = errno;
-        log<level::ERR>("Failed SET_LINE_VALUES ioctl",
-                        entry("ERRNO=%d", e));
+        log<level::ERR>("Failed SET_LINE_VALUES ioctl", entry("ERRNO=%d", e));
         throw std::runtime_error("Failed SET_LINE_VALUES ioctl");
     }
 }
 
-
 void GPIO::requestLine(Value defaultValue)
 {
-    //Only need to do this once
+    // Only need to do this once
     if (lineFD)
     {
         return;
@@ -63,15 +63,14 @@
         throw std::runtime_error("Failed opening GPIO device");
     }
 
-    //Make an ioctl call to request the GPIO line, which will
-    //return the descriptor to use to access it.
+    // Make an ioctl call to request the GPIO line, which will
+    // return the descriptor to use to access it.
     gpiohandle_request request{};
-    strncpy(request.consumer_label,
-            "phosphor-gpio-util",
+    strncpy(request.consumer_label, "phosphor-gpio-util",
             sizeof(request.consumer_label));
 
-    request.flags = (direction == Direction::output) ?
-        GPIOHANDLE_REQUEST_OUTPUT : GPIOHANDLE_REQUEST_INPUT;
+    request.flags = (direction == Direction::output) ? GPIOHANDLE_REQUEST_OUTPUT
+                                                     : GPIOHANDLE_REQUEST_INPUT;
 
     request.lineoffsets[0] = gpio;
     request.lines = 1;
@@ -85,8 +84,7 @@
     if (rc == -1)
     {
         auto e = errno;
-        log<level::ERR>("Failed GET_LINEHANDLE ioctl",
-                        entry("GPIO=%d", gpio),
+        log<level::ERR>("Failed GET_LINEHANDLE ioctl", entry("GPIO=%d", gpio),
                         entry("ERRNO=%d", e));
         throw std::runtime_error("Failed GET_LINEHANDLE ioctl");
     }
@@ -94,5 +92,5 @@
     lineFD.set(request.fd);
 }
 
-}
-}
+} // namespace gpio
+} // namespace phosphor
diff --git a/gpio-util/gpio.hpp b/gpio-util/gpio.hpp
index ba8cce3..d4ac47b 100644
--- a/gpio-util/gpio.hpp
+++ b/gpio-util/gpio.hpp
@@ -1,18 +1,22 @@
 #pragma once
 
-#include <linux/gpio.h>
 #include "file.hpp"
 
+#include <linux/gpio.h>
+
+#include <string>
+#include <type_traits>
+
 namespace phosphor
 {
 namespace gpio
 {
 
- typedef std::remove_reference<decltype(
-         gpiohandle_request::lineoffsets[0])>::type gpioNum_t;
+typedef std::remove_reference<decltype(
+    gpiohandle_request::lineoffsets[0])>::type gpioNum_t;
 
- typedef std::remove_reference<decltype(
-         gpiohandle_data::values[0])>::type gpioValue_t;
+typedef std::remove_reference<decltype(gpiohandle_data::values[0])>::type
+    gpioValue_t;
 
 /**
  * Represents a GPIO.
@@ -23,86 +27,80 @@
  */
 class GPIO
 {
-    public:
+  public:
+    /**
+     * If the GPIO is an input or output
+     */
+    enum class Direction
+    {
+        input,
+        output
+    };
 
-        /**
-         * If the GPIO is an input or output
-         */
-        enum class Direction
-        {
-            input,
-            output
-        };
+    /**
+     * The possible values - low or high
+     */
+    enum class Value
+    {
+        low,
+        high
+    };
 
-        /**
-         * The possible values - low or high
-         */
-        enum class Value
-        {
-            low,
-            high
-        };
+    GPIO() = delete;
+    GPIO(const GPIO&) = delete;
+    GPIO(GPIO&&) = default;
+    GPIO& operator=(const GPIO&) = delete;
+    GPIO& operator=(GPIO&&) = default;
+    ~GPIO() = default;
 
-        GPIO() = delete;
-        GPIO(const GPIO&) = delete;
-        GPIO(GPIO&&) = default;
-        GPIO& operator=(const GPIO&) = delete;
-        GPIO& operator=(GPIO&&) = default;
-        ~GPIO() = default;
+    /**
+     * Constructor
+     *
+     * @param[in] device - the GPIO device file
+     * @param[in] gpio - the GPIO number
+     * @param[in] direction - the GPIO direction
+     */
+    GPIO(const std::string& device, gpioNum_t gpio, Direction direction) :
+        device(device), gpio(gpio), direction(direction)
+    {
+    }
 
-        /**
-         * Constructor
-         *
-         * @param[in] device - the GPIO device file
-         * @param[in] gpio - the GPIO number
-         * @param[in] direction - the GPIO direction
-         */
-        GPIO(const std::string& device,
-             gpioNum_t gpio,
-             Direction direction) :
-            device(device),
-            gpio(gpio),
-            direction(direction)
-        {
-        }
+    /**
+     * Sets the GPIO value
+     *
+     * Requests the GPIO line if it hasn't been done already.
+     */
+    void set(Value value);
 
-        /**
-         * Sets the GPIO value
-         *
-         * Requests the GPIO line if it hasn't been done already.
-         */
-        void set(Value value);
+  private:
+    /**
+     * Requests a GPIO line from the GPIO device
+     *
+     * @param[in] defaultValue - The default value, required for
+     *                           output GPIOs only.
+     */
+    void requestLine(Value defaultValue = Value::high);
 
-    private:
+    /**
+     * The GPIO device name, like /dev/gpiochip0
+     */
+    const std::string device;
 
-        /**
-         * Requests a GPIO line from the GPIO device
-         *
-         * @param[in] defaultValue - The default value, required for
-         *                           output GPIOs only.
-         */
-        void requestLine(Value defaultValue = Value::high);
+    /**
+     * The GPIO number
+     */
+    const gpioNum_t gpio;
 
-        /**
-         * The GPIO device name, like /dev/gpiochip0
-         */
-        const std::string device;
+    /**
+     * The GPIO direction
+     */
+    const Direction direction;
 
-        /**
-         * The GPIO number
-         */
-        const gpioNum_t gpio;
-
-        /**
-         * The GPIO direction
-         */
-        const Direction direction;
-
-        /**
-         * File descriptor for the GPIO line
-         */
-        FileDescriptor lineFD;
+    /**
+     * File descriptor for the GPIO line
+     */
+    FileDescriptor lineFD;
 };
 
-}
-}
+} // namespace gpio
+} // namespace phosphor
diff --git a/gpio-util/main.cpp b/gpio-util/main.cpp
index fb56e66..89e61f9 100644
--- a/gpio-util/main.cpp
+++ b/gpio-util/main.cpp
@@ -23,14 +23,15 @@
  *   high_low: Set a GPIO high, delay if requested, set it low
  */
 
+#include "argument.hpp"
+#include "gpio.hpp"
+
 #include <algorithm>
 #include <chrono>
 #include <iostream>
 #include <map>
-#include <thread>
 #include <phosphor-logging/log.hpp>
-#include "argument.hpp"
-#include "gpio.hpp"
+#include <thread>
 
 using namespace phosphor::gpio;
 using namespace phosphor::logging;
@@ -49,7 +50,6 @@
     gpio.set(GPIO::Value::low);
 }
 
-
 /**
  * Sets a GPIO high
  *
@@ -61,7 +61,6 @@
     gpio.set(GPIO::Value::high);
 }
 
-
 /**
  * Sets a GPIO high, then delays, then sets it low
  *
@@ -78,7 +77,6 @@
     gpio.set(GPIO::Value::low);
 }
 
-
 /**
  * Sets a GPIO low, then delays, then sets it high
  *
@@ -95,18 +93,11 @@
     gpio.set(GPIO::Value::high);
 }
 
-
 /**
  * The actions supported by this program
  */
-static const gpioFunctionMap functions
-{
-    {"low", low},
-    {"high", high},
-    {"low_high", lowHigh},
-    {"high_low", highLow}
-};
-
+static const gpioFunctionMap functions{
+    {"low", low}, {"high", high}, {"low_high", lowHigh}, {"high_low", highLow}};
 
 /**
  * Prints usage and exits the program
@@ -121,7 +112,6 @@
     exit(EXIT_FAILURE);
 }
 
-
 /**
  * Returns the number value of the argument passed in.
  *
@@ -129,15 +119,13 @@
  * @param[in] parser - the argument parser
  * @param[in] argv - arv from main()
  */
-template<typename T>
-T getValueFromArg(const char* name,
-                  ArgumentParser& parser,
-                  char** argv)
+template <typename T>
+T getValueFromArg(const char* name, ArgumentParser& parser, char** argv)
 {
     char* p = NULL;
     auto val = strtol(parser[name].c_str(), &p, 10);
 
-    //strol sets p on error, also we don't allow negative values
+    // strol sets p on error, also we don't allow negative values
     if (*p || (val < 0))
     {
         using namespace std::string_literals;
@@ -147,7 +135,6 @@
     return static_cast<T>(val);
 }
 
-
 int main(int argc, char** argv)
 {
     ArgumentParser args(argc, argv);
@@ -171,7 +158,7 @@
 
     auto gpioNum = getValueFromArg<gpioNum_t>("gpio", args, argv);
 
-    //Not all actions require a delay, so not required
+    // Not all actions require a delay, so not required
     unsigned int delay = 0;
     if (args["delay"] != ArgumentParser::emptyString)
     {
diff --git a/mainapp.cpp b/mainapp.cpp
index 9ecaad2..2663f8f 100644
--- a/mainapp.cpp
+++ b/mainapp.cpp
@@ -14,13 +14,15 @@
  * limitations under the License.
  */
 
-#include <iostream>
-#include <string>
-#include <systemd/sd-event.h>
-#include <phosphor-logging/log.hpp>
 #include "argument.hpp"
 #include "monitor.hpp"
 
+#include <systemd/sd-event.h>
+
+#include <iostream>
+#include <phosphor-logging/log.hpp>
+#include <string>
+
 using namespace phosphor::logging;
 static void exitWithError(const char* err, char** argv)
 {
@@ -63,7 +65,7 @@
     auto target = (options)["target"];
 
     bool continueRun =
-      (options["continue"] == phosphor::gpio::ArgumentParser::trueString);
+        (options["continue"] == phosphor::gpio::ArgumentParser::trueString);
 
     sd_event* event = nullptr;
     auto r = sd_event_default(&event);
@@ -76,23 +78,19 @@
     event = nullptr;
 
     // Create a monitor object and let it do all the rest
-    phosphor::gpio::Monitor monitor(path,
-                                    std::stoi(key),
-                                    std::stoi(polarity),
-                                    target,
-                                    eventP,
-                                    continueRun);
+    phosphor::gpio::Monitor monitor(path, std::stoi(key), std::stoi(polarity),
+                                    target, eventP, continueRun);
 
     // Wait for client requests until this application has processed
     // at least one expected GPIO state change
-    while(!monitor.completed())
+    while (!monitor.completed())
     {
         // -1 denotes wait for ever
         r = sd_event_run(eventP.get(), (uint64_t)-1);
         if (r < 0)
         {
             log<level::ERR>("Failure in processing request",
-                    entry("ERROR=%s", strerror(-r)));
+                            entry("ERROR=%s", strerror(-r)));
             break;
         }
     }
diff --git a/monitor.cpp b/monitor.cpp
index 159127d..dd96fe9 100644
--- a/monitor.cpp
+++ b/monitor.cpp
@@ -14,26 +14,29 @@
  * limitations under the License.
  */
 
-#include <fcntl.h>
-#include <phosphor-logging/log.hpp>
-#include "monitor.hpp"
 #include "config.h"
 
+#include "monitor.hpp"
+
+#include <fcntl.h>
+
+#include <phosphor-logging/log.hpp>
+
 namespace phosphor
 {
 namespace gpio
 {
 
 // systemd service to kick start a target.
-constexpr auto SYSTEMD_SERVICE        = "org.freedesktop.systemd1";
-constexpr auto SYSTEMD_ROOT           = "/org/freedesktop/systemd1";
-constexpr auto SYSTEMD_INTERFACE      = "org.freedesktop.systemd1.Manager";
+constexpr auto SYSTEMD_SERVICE = "org.freedesktop.systemd1";
+constexpr auto SYSTEMD_ROOT = "/org/freedesktop/systemd1";
+constexpr auto SYSTEMD_INTERFACE = "org.freedesktop.systemd1.Manager";
 
 using namespace phosphor::logging;
 
 // Callback handler when there is an activity on the FD
-int Monitor::processEvents(sd_event_source* es, int fd,
-                           uint32_t revents, void* userData)
+int Monitor::processEvents(sd_event_source* es, int fd, uint32_t revents,
+                           void* userData)
 {
     log<level::INFO>("GPIO line altered");
     auto monitor = static_cast<Monitor*>(userData);
@@ -46,7 +49,9 @@
 void Monitor::analyzeEvent()
 {
     // Data returned
-    struct input_event ev{};
+    struct input_event ev
+    {
+    };
     int rc = 0;
 
     // While testing, observed that not having a loop here was leading
@@ -54,8 +59,8 @@
     while (rc >= 0)
     {
         // Wait until no more events are available on the device.
-        rc = libevdev_next_event(devicePtr.get(),
-                                 LIBEVDEV_READ_FLAG_NORMAL, &ev);
+        rc = libevdev_next_event(devicePtr.get(), LIBEVDEV_READ_FLAG_NORMAL,
+                                 &ev);
         if (rc < 0)
         {
             // There was an error waiting for events, mostly that there are no
@@ -76,10 +81,9 @@
                 if (!target.empty())
                 {
                     auto bus = sdbusplus::bus::new_default();
-                    auto method = bus.new_method_call(SYSTEMD_SERVICE,
-                                                      SYSTEMD_ROOT,
-                                                      SYSTEMD_INTERFACE,
-                                                      "StartUnit");
+                    auto method =
+                        bus.new_method_call(SYSTEMD_SERVICE, SYSTEMD_ROOT,
+                                            SYSTEMD_INTERFACE, "StartUnit");
                     method.append(target);
                     method.append("replace");
 
diff --git a/monitor.hpp b/monitor.hpp
index f4b07de..771492a 100644
--- a/monitor.hpp
+++ b/monitor.hpp
@@ -1,11 +1,13 @@
 #pragma once
 
-#include <unistd.h>
-#include <string>
+#include "evdev.hpp"
+
 #include <linux/input.h>
 #include <systemd/sd-event.h>
+#include <unistd.h>
+
 #include <sdbusplus/bus.hpp>
-#include "evdev.hpp"
+#include <string>
 
 namespace phosphor
 {
@@ -18,74 +20,70 @@
  */
 class Monitor : public Evdev
 {
-    public:
-        Monitor() = delete;
-        ~Monitor() = default;
-        Monitor(const Monitor&) = delete;
-        Monitor& operator=(const Monitor&) = delete;
-        Monitor(Monitor&&) = delete;
-        Monitor& operator=(Monitor&&) = delete;
+  public:
+    Monitor() = delete;
+    ~Monitor() = default;
+    Monitor(const Monitor&) = delete;
+    Monitor& operator=(const Monitor&) = delete;
+    Monitor(Monitor&&) = delete;
+    Monitor& operator=(Monitor&&) = delete;
 
-        /** @brief Constructs Monitor object.
-         *
-         *  @param[in] path     - Path to gpio input device
-         *  @param[in] key      - GPIO key to monitor
-         *  @param[in] polarity - GPIO assertion polarity to look for
-         *  @param[in] target   - systemd unit to be started on GPIO
-         *                        value change
-         *  @param[in] event    - sd_event handler
-         *  @param[in] continueRun - Whether to continue after key pressed
-         *  @param[in] handler  - IO callback handler. Defaults to one in this
-         *                        class
-         *  @param[in] useEvDev - Whether to use EvDev to retrieve events
-         */
-        Monitor(const std::string& path,
-                decltype(input_event::code) key,
-                decltype(input_event::value) polarity,
-                const std::string& target,
-                EventPtr& event,
-                bool continueRun,
-                sd_event_io_handler_t handler = Monitor::processEvents,
-                bool useEvDev = true)
-            : Evdev(path, key, event, handler, useEvDev),
-              polarity(polarity),
-              target(target),
-              continueAfterKeyPress(continueRun) {};
+    /** @brief Constructs Monitor object.
+     *
+     *  @param[in] path     - Path to gpio input device
+     *  @param[in] key      - GPIO key to monitor
+     *  @param[in] polarity - GPIO assertion polarity to look for
+     *  @param[in] target   - systemd unit to be started on GPIO
+     *                        value change
+     *  @param[in] event    - sd_event handler
+     *  @param[in] continueRun - Whether to continue after key pressed
+     *  @param[in] handler  - IO callback handler. Defaults to one in this
+     *                        class
+     *  @param[in] useEvDev - Whether to use EvDev to retrieve events
+     */
+    Monitor(const std::string& path, decltype(input_event::code) key,
+            decltype(input_event::value) polarity, const std::string& target,
+            EventPtr& event, bool continueRun,
+            sd_event_io_handler_t handler = Monitor::processEvents,
+            bool useEvDev = true) :
+        Evdev(path, key, event, handler, useEvDev),
+        polarity(polarity), target(target),
+        continueAfterKeyPress(continueRun){};
 
-        /** @brief Callback handler when the FD has some activity on it
-         *
-         *  @param[in] es       - Populated event source
-         *  @param[in] fd       - Associated File descriptor
-         *  @param[in] revents  - Type of event
-         *  @param[in] userData - User data that was passed during registration
-         *
-         *  @return             - 0 or positive number on success and negative
-         *                        errno otherwise
-         */
-        static int processEvents(sd_event_source* es, int fd,
-                                 uint32_t revents, void* userData);
+    /** @brief Callback handler when the FD has some activity on it
+     *
+     *  @param[in] es       - Populated event source
+     *  @param[in] fd       - Associated File descriptor
+     *  @param[in] revents  - Type of event
+     *  @param[in] userData - User data that was passed during registration
+     *
+     *  @return             - 0 or positive number on success and negative
+     *                        errno otherwise
+     */
+    static int processEvents(sd_event_source* es, int fd, uint32_t revents,
+                             void* userData);
 
-        /** @brief Returns the completion state of this handler */
-        inline auto completed() const
-        {
-            return complete;
-        }
+    /** @brief Returns the completion state of this handler */
+    inline auto completed() const
+    {
+        return complete;
+    }
 
-    private:
-        /** @brief GPIO key value that is of interest */
-        decltype(input_event::value) polarity;
+  private:
+    /** @brief GPIO key value that is of interest */
+    decltype(input_event::value) polarity;
 
-        /** @brief Systemd unit to be started when the condition is met */
-        const std::string& target;
+    /** @brief Systemd unit to be started when the condition is met */
+    const std::string& target;
 
-        /** @brief If the monitor should continue after key press */
-        bool continueAfterKeyPress;
+    /** @brief If the monitor should continue after key press */
+    bool continueAfterKeyPress;
 
-        /** @brief Completion indicator */
-        bool complete = false;
+    /** @brief Completion indicator */
+    bool complete = false;
 
-        /** @brief Analyzes the GPIO event and starts configured target */
-        void analyzeEvent();
+    /** @brief Analyzes the GPIO event and starts configured target */
+    void analyzeEvent();
 };
 
 } // namespace gpio
diff --git a/presence/argument.cpp b/presence/argument.cpp
index a4b664e..e256426 100644
--- a/presence/argument.cpp
+++ b/presence/argument.cpp
@@ -14,10 +14,11 @@
  * limitations under the License.
  */
 
+#include "argument.hpp"
+
+#include <algorithm>
 #include <iostream>
 #include <iterator>
-#include <algorithm>
-#include "argument.hpp"
 
 namespace phosphor
 {
@@ -30,22 +31,21 @@
 const std::string ArgumentParser::emptyString = ""s;
 
 const char* ArgumentParser::optionStr = "p:k:n:i:d:?h";
-const option ArgumentParser::options[] =
-{
-    { "path",      required_argument,  nullptr,   'p' },
-    { "key",       required_argument,  nullptr,   'k' },
-    { "name",      required_argument,  nullptr,   'n' },
-    { "inventory", required_argument,  nullptr,   'i' },
-    { "drivers",   required_argument,  nullptr,   'd' },
-    { "help",      no_argument,        nullptr,   'h' },
-    { 0, 0, 0, 0},
+const option ArgumentParser::options[] = {
+    {"path", required_argument, nullptr, 'p'},
+    {"key", required_argument, nullptr, 'k'},
+    {"name", required_argument, nullptr, 'n'},
+    {"inventory", required_argument, nullptr, 'i'},
+    {"drivers", required_argument, nullptr, 'd'},
+    {"help", no_argument, nullptr, 'h'},
+    {0, 0, 0, 0},
 };
 
 ArgumentParser::ArgumentParser(int argc, char** argv)
 {
     auto option = 0;
-    while (-1 != (option = getopt_long(argc, argv,
-                                       optionStr, options, nullptr)))
+    while (-1 !=
+           (option = getopt_long(argc, argv, optionStr, options, nullptr)))
     {
         if ((option == '?') || (option == 'h'))
         {
@@ -85,16 +85,16 @@
     std::cerr << "Options:\n";
     std::cerr << "  --help                  Print this menu\n";
     std::cerr << "  --inventory=<inventory> Object path under inventory"
-              " that will be created\n";
+                 " that will be created\n";
     std::cerr << "  --path=<path>           Path of device to read for GPIO pin"
-              " state to determine presence of inventory item\n";
+                 " state to determine presence of inventory item\n";
     std::cerr << "  --key=<key>             Input GPIO key number\n";
     std::cerr << "  --name=<name>           Pretty name of the inventory"
-              " item\n";
+                 " item\n";
     std::cerr << "  --drivers=<drivers>     List of drivers to bind when card"
-              " is added and unbind when card is removed\n";
+                 " is added and unbind when card is removed\n";
     std::cerr << "                          Format is a space separated list"
-              " of path,device pairs.  For example:\n";
+                 " of path,device pairs.  For example:\n";
     std::cerr << "                          "
                  "/sys/bus/i2c/drivers/some-driver,3-0068\n";
     std::cerr << std::flush;
diff --git a/presence/gpio_presence.cpp b/presence/gpio_presence.cpp
index 4a11d98..1671721 100644
--- a/presence/gpio_presence.cpp
+++ b/presence/gpio_presence.cpp
@@ -1,11 +1,14 @@
+#include "gpio_presence.hpp"
+
+#include "xyz/openbmc_project/Common/error.hpp"
+
 #include <fcntl.h>
-#include <fstream>
 #include <libevdev/libevdev.h>
+
+#include <fstream>
+#include <phosphor-logging/elog-errors.hpp>
 #include <phosphor-logging/elog.hpp>
 #include <phosphor-logging/log.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include "xyz/openbmc_project/Common/error.hpp"
-#include "gpio_presence.hpp"
 
 namespace phosphor
 {
@@ -24,14 +27,11 @@
 constexpr auto MAPPER_PATH = "/xyz/openbmc_project/object_mapper";
 constexpr auto MAPPER_INTERFACE = "xyz.openbmc_project.ObjectMapper";
 
-std::string getService(const std::string& path,
-                       const std::string& interface,
+std::string getService(const std::string& path, const std::string& interface,
                        sdbusplus::bus::bus& bus)
 {
-    auto mapperCall = bus.new_method_call(MAPPER_BUSNAME,
-                                          MAPPER_PATH,
-                                          MAPPER_INTERFACE,
-                                          "GetObject");
+    auto mapperCall = bus.new_method_call(MAPPER_BUSNAME, MAPPER_PATH,
+                                          MAPPER_INTERFACE, "GetObject");
 
     mapperCall.append(path);
     mapperCall.append(std::vector<std::string>({interface}));
@@ -45,16 +45,14 @@
         elog<InternalFailure>();
     }
 
-
     std::map<std::string, std::vector<std::string>> mapperResponse;
     mapperResponseMsg.read(mapperResponse);
 
     if (mapperResponse.empty())
     {
-        log<level::ERR>(
-            "Error in mapper response for getting service name",
-            entry("PATH=%s", path.c_str()),
-            entry("INTERFACE=%s", interface.c_str()));
+        log<level::ERR>("Error in mapper response for getting service name",
+                        entry("PATH=%s", path.c_str()),
+                        entry("INTERFACE=%s", interface.c_str()));
         elog<InternalFailure>();
     }
 
@@ -65,8 +63,8 @@
 {
     auto present = false;
     auto value = static_cast<int>(0);
-    auto fetch_rc = libevdev_fetch_event_value(devicePtr.get(), EV_KEY,
-                    key, &value);
+    auto fetch_rc =
+        libevdev_fetch_event_value(devicePtr.get(), EV_KEY, key, &value);
     if (0 == fetch_rc)
     {
         log<level::ERR>("Device does not support event type",
@@ -83,8 +81,8 @@
 }
 
 // Callback handler when there is an activity on the FD
-int Presence::processEvents(sd_event_source* es, int fd,
-                            uint32_t revents, void* userData)
+int Presence::processEvents(sd_event_source* es, int fd, uint32_t revents,
+                            void* userData)
 {
     auto presence = static_cast<Presence*>(userData);
 
@@ -92,13 +90,14 @@
     return 0;
 }
 
-
 // Analyzes the GPIO event
 void Presence::analyzeEvent()
 {
 
     // Data returned
-    struct input_event ev {};
+    struct input_event ev
+    {
+    };
     int rc = 0;
 
     // While testing, observed that not having a loop here was leading
@@ -106,8 +105,8 @@
     while (rc >= 0)
     {
         // Wait until no more events are available on the device.
-        rc = libevdev_next_event(devicePtr.get(),
-                                 LIBEVDEV_READ_FLAG_NORMAL, &ev);
+        rc = libevdev_next_event(devicePtr.get(), LIBEVDEV_READ_FLAG_NORMAL,
+                                 &ev);
         if (rc < 0)
         {
             // There was an error waiting for events, mostly that there are no
@@ -145,8 +144,7 @@
 
     invProp.emplace("Present", present);
     invProp.emplace("PrettyName", name);
-    invIntf.emplace("xyz.openbmc_project.Inventory.Item",
-                    std::move(invProp));
+    invIntf.emplace("xyz.openbmc_project.Inventory.Item", std::move(invProp));
     invObj.emplace(std::move(inventory), std::move(invIntf));
 
     return invObj;
@@ -163,19 +161,15 @@
     auto invService = getService(INVENTORY_PATH, INVENTORY_INTF, bus);
 
     // Update inventory
-    auto invMsg = bus.new_method_call(invService.c_str(),
-                                      INVENTORY_PATH,
-                                      INVENTORY_INTF,
-                                      "Notify");
+    auto invMsg = bus.new_method_call(invService.c_str(), INVENTORY_PATH,
+                                      INVENTORY_INTF, "Notify");
     invMsg.append(std::move(invObj));
     auto invMgrResponseMsg = bus.call(invMsg);
     if (invMgrResponseMsg.is_method_error())
     {
-        log<level::ERR>(
-            "Error in inventory manager call to update inventory");
+        log<level::ERR>("Error in inventory manager call to update inventory");
         elog<InternalFailure>();
     }
-
 }
 
 void Presence::bindOrUnbindDrivers(bool present)
@@ -189,25 +183,21 @@
 
         if (present)
         {
-            log<level::INFO>(
-                    "Binding a device driver",
-                    entry("PATH=%s", path.c_str()),
-                    entry("DEVICE=%s", device.c_str()));
+            log<level::INFO>("Binding a device driver",
+                             entry("PATH=%s", path.c_str()),
+                             entry("DEVICE=%s", device.c_str()));
         }
         else
         {
-            log<level::INFO>(
-                    "Unbinding a device driver",
-                    entry("PATH=%s", path.c_str()),
-                    entry("DEVICE=%s", device.c_str()));
+            log<level::INFO>("Unbinding a device driver",
+                             entry("PATH=%s", path.c_str()),
+                             entry("DEVICE=%s", device.c_str()));
         }
 
         std::ofstream file;
 
-        file.exceptions(
-                std::ofstream::failbit |
-                std::ofstream::badbit |
-                std::ofstream::eofbit);
+        file.exceptions(std::ofstream::failbit | std::ofstream::badbit |
+                        std::ofstream::eofbit);
 
         try
         {
@@ -228,8 +218,6 @@
     }
 }
 
-
 } // namespace presence
 } // namespace gpio
 } // namespace phosphor
-
diff --git a/presence/gpio_presence.hpp b/presence/gpio_presence.hpp
index b5feddd..834a171 100644
--- a/presence/gpio_presence.hpp
+++ b/presence/gpio_presence.hpp
@@ -1,8 +1,10 @@
 #pragma once
+#include "evdev.hpp"
+
+#include <systemd/sd-event.h>
+
 #include <experimental/filesystem>
 #include <string>
-#include <systemd/sd-event.h>
-#include "evdev.hpp"
 
 namespace phosphor
 {
@@ -25,120 +27,114 @@
 class Presence : public Evdev
 {
 
-        using Property = std::string;
-        using Value = sdbusplus::message::variant<bool, std::string>;
-        // Association between property and its value
-        using PropertyMap = std::map<Property, Value>;
-        using Interface = std::string;
-        // Association between interface and the D-Bus property
-        using InterfaceMap = std::map<Interface, PropertyMap>;
-        using Object = sdbusplus::message::object_path;
-        // Association between object and the interface
-        using ObjectMap = std::map<Object, InterfaceMap>;
+    using Property = std::string;
+    using Value = sdbusplus::message::variant<bool, std::string>;
+    // Association between property and its value
+    using PropertyMap = std::map<Property, Value>;
+    using Interface = std::string;
+    // Association between interface and the D-Bus property
+    using InterfaceMap = std::map<Interface, PropertyMap>;
+    using Object = sdbusplus::message::object_path;
+    // Association between object and the interface
+    using ObjectMap = std::map<Object, InterfaceMap>;
 
-    public:
-        Presence() = delete;
-        ~Presence() = default;
-        Presence(const Presence&) = delete;
-        Presence& operator=(const Presence&) = delete;
-        Presence(Presence&&) = delete;
-        Presence& operator=(Presence&&) = delete;
+  public:
+    Presence() = delete;
+    ~Presence() = default;
+    Presence(const Presence&) = delete;
+    Presence& operator=(const Presence&) = delete;
+    Presence(Presence&&) = delete;
+    Presence& operator=(Presence&&) = delete;
 
-        /** @brief Constructs Presence object.
-         *
-         *  @param[in] bus       - D-Bus bus Object
-         *  @param[in] inventory - Object path under inventory
-                                   to display this inventory item
-         *  @param[in] path      - Device path to read for GPIO pin state
-                                   to determine presence of inventory item
-         *  @param[in] key       - GPIO key to monitor
-         *  @param[in] name      - Pretty name of the inventory item
-         *  @param[in] event     - sd_event handler
-         *  @param[in] drivers   - list of device drivers to bind and unbind
-         *  @param[in] handler   - IO callback handler. Defaults to one in this
-         *                        class
-         */
-        Presence(sdbusplus::bus::bus& bus,
-                 const std::string& inventory,
-                 const std::string& path,
-                 const unsigned int key,
-                 const std::string& name,
-                 EventPtr& event,
-                 const std::vector<Driver>& drivers,
-                 sd_event_io_handler_t handler = Presence::processEvents) :
-            Evdev(path, key, event, handler, true),
-            bus(bus),
-            inventory(inventory),
-            name(name),
-            drivers(drivers)
-        {
-            determinePresence();
-        }
+    /** @brief Constructs Presence object.
+     *
+     *  @param[in] bus       - D-Bus bus Object
+     *  @param[in] inventory - Object path under inventory
+                               to display this inventory item
+     *  @param[in] path      - Device path to read for GPIO pin state
+                               to determine presence of inventory item
+     *  @param[in] key       - GPIO key to monitor
+     *  @param[in] name      - Pretty name of the inventory item
+     *  @param[in] event     - sd_event handler
+     *  @param[in] drivers   - list of device drivers to bind and unbind
+     *  @param[in] handler   - IO callback handler. Defaults to one in this
+     *                        class
+     */
+    Presence(sdbusplus::bus::bus& bus, const std::string& inventory,
+             const std::string& path, const unsigned int key,
+             const std::string& name, EventPtr& event,
+             const std::vector<Driver>& drivers,
+             sd_event_io_handler_t handler = Presence::processEvents) :
+        Evdev(path, key, event, handler, true),
+        bus(bus), inventory(inventory), name(name), drivers(drivers)
+    {
+        determinePresence();
+    }
 
-        /** @brief Callback handler when the FD has some activity on it
-         *
-         *  @param[in] es       - Populated event source
-         *  @param[in] fd       - Associated File descriptor
-         *  @param[in] revents  - Type of event
-         *  @param[in] userData - User data that was passed during registration
-         *
-         *  @return             - 0 or positive number on success and negative
-         *                        errno otherwise
-         */
-        static int processEvents(sd_event_source* es, int fd,
-                                 uint32_t revents, void* userData);
+    /** @brief Callback handler when the FD has some activity on it
+     *
+     *  @param[in] es       - Populated event source
+     *  @param[in] fd       - Associated File descriptor
+     *  @param[in] revents  - Type of event
+     *  @param[in] userData - User data that was passed during registration
+     *
+     *  @return             - 0 or positive number on success and negative
+     *                        errno otherwise
+     */
+    static int processEvents(sd_event_source* es, int fd, uint32_t revents,
+                             void* userData);
 
-    private:
-        /**
-         * @brief Update the present property for the inventory item.
-         *
-         * @param[in] present - What the present property should be set to.
-         */
-        void updateInventory(bool present);
+  private:
+    /**
+     * @brief Update the present property for the inventory item.
+     *
+     * @param[in] present - What the present property should be set to.
+     */
+    void updateInventory(bool present);
 
-        /**
-         * @brief Construct the inventory object map for the inventory item.
-         *
-         * @param[in] present - What the present property should be set to.
-         *
-         * @return The inventory object map to update inventory
-         */
-        ObjectMap getObjectMap(bool present);
+    /**
+     * @brief Construct the inventory object map for the inventory item.
+     *
+     * @param[in] present - What the present property should be set to.
+     *
+     * @return The inventory object map to update inventory
+     */
+    ObjectMap getObjectMap(bool present);
 
-        /** @brief Connection for sdbusplus bus */
-        sdbusplus::bus::bus& bus;
+    /** @brief Connection for sdbusplus bus */
+    sdbusplus::bus::bus& bus;
 
-        /**
-         * @brief Read the GPIO device to determine initial presence and set
-         *        present property at D-Bus path.
-         */
-        void determinePresence();
+    /**
+     * @brief Read the GPIO device to determine initial presence and set
+     *        present property at D-Bus path.
+     */
+    void determinePresence();
 
-        /** @brief Object path under inventory to display this inventory item */
-        const std::string inventory;
+    /** @brief Object path under inventory to display this inventory item */
+    const std::string inventory;
 
-        /** @brief Pretty name of the inventory item*/
-        const std::string name;
+    /** @brief Pretty name of the inventory item*/
+    const std::string name;
 
-        /** @brief Analyzes the GPIO event and update present property*/
-        void analyzeEvent();
+    /** @brief Analyzes the GPIO event and update present property*/
+    void analyzeEvent();
 
-        /** @brief  Vector of path and device tuples to bind/unbind*/
-        const std::vector<Driver> drivers;
+    /** @brief  Vector of path and device tuples to bind/unbind*/
+    const std::vector<Driver> drivers;
 
-        /**
-         * @brief Binds or unbinds drivers
-         *
-         * Called when a presence change is detected to either
-         * bind the drivers for the new card or unbind them for
-         * the just removed card.  Operates on the drivers vector.
-         *
-         * Writes <device> to <path>/bind (or unbind)
-         *
-         * @param present - when true, will bind the drivers
-         *                  when false, will unbind them
-         */
-        void bindOrUnbindDrivers(bool present);
+    /**
+     * @brief Binds or unbinds drivers
+     *
+     * Called when a presence change is detected to either
+     * bind the drivers for the new card or unbind them for
+     * the just removed card.  Operates on the drivers vector.
+     *
+     * Writes <device> to <path>/bind (or unbind)
+     *
+     * @param present - when true, will bind the drivers
+     *                  when false, will unbind them
+     */
+    void bindOrUnbindDrivers(bool present);
 };
 
 /**
@@ -151,11 +147,9 @@
  *
  * @return The service name
  */
-std::string getService(const std::string& path,
-                       const std::string& interface,
+std::string getService(const std::string& path, const std::string& interface,
                        sdbusplus::bus::bus& bus);
 
 } // namespace presence
 } // namespace gpio
 } // namespace phosphor
-
diff --git a/presence/main.cpp b/presence/main.cpp
index 1eaa18b..16866d4 100644
--- a/presence/main.cpp
+++ b/presence/main.cpp
@@ -1,9 +1,11 @@
-#include <iostream>
-#include <systemd/sd-event.h>
-#include <phosphor-logging/log.hpp>
 #include "argument.hpp"
 #include "gpio_presence.hpp"
 
+#include <systemd/sd-event.h>
+
+#include <iostream>
+#include <phosphor-logging/log.hpp>
+
 using namespace phosphor::logging;
 using namespace phosphor::gpio;
 using namespace phosphor::gpio::presence;
@@ -27,7 +29,7 @@
     {
         std::string entry;
 
-        //Extract each path,device pair
+        // Extract each path,device pair
         stream >> entry;
 
         if (entry.empty())
@@ -35,7 +37,7 @@
             break;
         }
 
-        //Extract the path and device and save them
+        // Extract the path and device and save them
         auto pos = entry.rfind(',');
         if (pos != std::string::npos)
         {
@@ -88,7 +90,7 @@
 
     std::vector<Driver> driverList;
 
-    //Driver list is optional
+    // Driver list is optional
     if (drivers != ArgumentParser::emptyString)
     {
         if (getDrivers(drivers, driverList) < 0)
@@ -110,13 +112,13 @@
     event = nullptr;
 
     auto name = options["name"];
-    Presence presence(
-            bus, inventory, path, std::stoul(key), name, eventP, driverList);
+    Presence presence(bus, inventory, path, std::stoul(key), name, eventP,
+                      driverList);
 
     while (true)
     {
         // -1 denotes wait forever
-        rc = sd_event_run(eventP.get(), (uint64_t) - 1);
+        rc = sd_event_run(eventP.get(), (uint64_t)-1);
         if (rc < 0)
         {
             log<level::ERR>("Failure in processing request",
@@ -126,4 +128,3 @@
     }
     return rc;
 }
-
diff --git a/test/utest.cpp b/test/utest.cpp
index a023cde..5fb870f 100644
--- a/test/utest.cpp
+++ b/test/utest.cpp
@@ -1,63 +1,65 @@
-#include <iostream>
-#include <sys/types.h>
-#include <chrono>
-#include <string>
-#include <linux/input.h>
-#include <gtest/gtest.h>
-#include "monitor.hpp"
 #include "evdev.hpp"
+#include "monitor.hpp"
+
+#include <linux/input.h>
+#include <sys/types.h>
+
+#include <chrono>
+#include <iostream>
+#include <string>
+
+#include <gtest/gtest.h>
 
 using namespace phosphor::gpio;
 
 // Exit helper. Ideally should be class but need
 // this to be used inside a static method.
-bool completed {};
+bool completed{};
 
 class GpioTest : public ::testing::Test
 {
-    public:
-        static constexpr auto DEVICE = "/tmp/test_fifo";
+  public:
+    static constexpr auto DEVICE = "/tmp/test_fifo";
 
-        // systemd event handler
-        sd_event* events;
+    // systemd event handler
+    sd_event* events;
 
-        // Really needed just for the constructor
-        decltype(input_event::code) code = 10;
+    // Really needed just for the constructor
+    decltype(input_event::code) code = 10;
 
-        // Really needed just for the constructor
-        decltype(input_event::value) value = 10;
+    // Really needed just for the constructor
+    decltype(input_event::value) value = 10;
 
-        // Need this so that events can be initialized.
-        int rc;
+    // Need this so that events can be initialized.
+    int rc;
 
-        // Gets called as part of each TEST_F construction
-        GpioTest()
-              : rc(sd_event_default(&events))
-        {
-            // Check for successful creation of event handler
-            EXPECT_GE(rc, 0);
+    // Gets called as part of each TEST_F construction
+    GpioTest() : rc(sd_event_default(&events))
+    {
+        // Check for successful creation of event handler
+        EXPECT_GE(rc, 0);
 
-            // FIFO created to simulate data available
-            EXPECT_EQ(0, mknod(DEVICE, S_IFIFO|0666, 0));
-        }
+        // FIFO created to simulate data available
+        EXPECT_EQ(0, mknod(DEVICE, S_IFIFO | 0666, 0));
+    }
 
-        // Gets called as part of each TEST_F destruction
-        ~GpioTest()
-        {
-            EXPECT_EQ(0, remove(DEVICE));
+    // Gets called as part of each TEST_F destruction
+    ~GpioTest()
+    {
+        EXPECT_EQ(0, remove(DEVICE));
 
-            events = sd_event_unref(events);
-            EXPECT_EQ(events, nullptr);
-        }
+        events = sd_event_unref(events);
+        EXPECT_EQ(events, nullptr);
+    }
 
-        // Callback handler on data
-        static int callbackHandler(sd_event_source* es, int fd,
-                                   uint32_t revents, void* userData)
-        {
-            std::cout <<"Event fired" << std::endl;
-            completed = true;
-            return 0;
-        }
+    // Callback handler on data
+    static int callbackHandler(sd_event_source* es, int fd, uint32_t revents,
+                               void* userData)
+    {
+        std::cout << "Event fired" << std::endl;
+        completed = true;
+        return 0;
+    }
 };
 
 /** @brief Makes sure that event never comes for 3 seconds
@@ -66,20 +68,20 @@
 {
     using namespace std::chrono;
 
-    phosphor::gpio::EventPtr eventP { events };
+    phosphor::gpio::EventPtr eventP{events};
     events = nullptr;
 
     const std::string emptyTarget = "";
-    Monitor gpio(DEVICE, code, value, emptyTarget,
-                 eventP, false, callbackHandler, false);
+    Monitor gpio(DEVICE, code, value, emptyTarget, eventP, false,
+                 callbackHandler, false);
 
     // Waiting 3 seconds and check if the completion status is set
     int count = 0;
-    while(count < 3)
+    while (count < 3)
     {
         // Returns -0- on timeout and positive number on dispatch
         auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if(!sd_event_run(eventP.get(), sleepTime.count()))
+        if (!sd_event_run(eventP.get(), sleepTime.count()))
         {
             count++;
         }
@@ -95,16 +97,16 @@
 {
     using namespace std::chrono;
 
-    phosphor::gpio::EventPtr eventP { events };
+    phosphor::gpio::EventPtr eventP{events};
     events = nullptr;
 
     const std::string emptyTarget = "";
-    Monitor gpio(DEVICE, code, value, emptyTarget,
-                 eventP, false, callbackHandler, false);
+    Monitor gpio(DEVICE, code, value, emptyTarget, eventP, false,
+                 callbackHandler, false);
 
     // Pump the data in the middle
     int count = 0;
-    while(count < 2 && !completed)
+    while (count < 2 && !completed)
     {
         if (count == 1)
         {
@@ -114,7 +116,7 @@
 
         // Returns -0- on timeout
         auto sleepTime = duration_cast<microseconds>(seconds(1));
-        if(!sd_event_run(eventP.get(), sleepTime.count()))
+        if (!sd_event_run(eventP.get(), sleepTime.count()))
         {
             count++;
         }