diff --git a/procedures/openfsi/scan.cpp b/procedures/openfsi/scan.cpp
index e616e7f..a9693fb 100644
--- a/procedures/openfsi/scan.cpp
+++ b/procedures/openfsi/scan.cpp
@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "registration.hpp"
+
 #include <experimental/filesystem>
 #include <fstream>
 #include <org/open_power/Proc/FSI/error.hpp>
 #include <phosphor-logging/log.hpp>
-#include "registration.hpp"
 
 namespace openpower
 {
@@ -29,16 +30,14 @@
 namespace fsi_error = sdbusplus::org::open_power::Proc::FSI::Error;
 
 constexpr auto masterScanPath =
-        "/sys/bus/platform/devices/gpio-fsi/fsi0/rescan";
+    "/sys/bus/platform/devices/gpio-fsi/fsi0/rescan";
 
-constexpr auto hubScanPath =
-        "/sys/devices/platform/gpio-fsi/fsi0/slave@00:00/"
-        "00:00:00:0a/fsi1/rescan";
+constexpr auto hubScanPath = "/sys/devices/platform/gpio-fsi/fsi0/slave@00:00/"
+                             "00:00:00:0a/fsi1/rescan";
 
 constexpr auto masterCalloutPath =
     "/sys/devices/platform/gpio-fsi/fsi0/slave@00:00/raw";
 
-
 /**
  * Writes a 1 to the sysfs file passed in to trigger
  * the device driver to do an FSI scan.
@@ -49,9 +48,9 @@
 {
     std::ofstream file;
 
-    file.exceptions(std::ofstream::failbit | //logic error on operation
-                    std::ofstream::badbit |  //read/write error on operation
-                    std::ofstream::eofbit);  //end of file reached
+    file.exceptions(std::ofstream::failbit | // logic error on operation
+                    std::ofstream::badbit |  // read/write error on operation
+                    std::ofstream::eofbit);  // end of file reached
     try
     {
         file.open(path);
@@ -72,12 +71,12 @@
  */
 void scan()
 {
-    //Note: Currently the FSI device driver will always return success on both
-    //the master and hub scans.  The only way we can detect something
-    //went wrong is if the master scan didn't create the hub scan file, so
-    //we will check for that.
-    //It is possible the driver will be updated in the future to actually
-    //return a failure so the code will still check for them.
+    // Note: Currently the FSI device driver will always return success on both
+    // the master and hub scans.  The only way we can detect something
+    // went wrong is if the master scan didn't create the hub scan file, so
+    // we will check for that.
+    // It is possible the driver will be updated in the future to actually
+    // return a failure so the code will still check for them.
 
     try
     {
@@ -90,8 +89,8 @@
         using metadata = org::open_power::Proc::FSI::MasterDetectionFailure;
 
         elog<fsi_error::MasterDetectionFailure>(
-                metadata::CALLOUT_ERRNO(e.code().value()),
-                metadata::CALLOUT_DEVICE_PATH(masterCalloutPath));
+            metadata::CALLOUT_ERRNO(e.code().value()),
+            metadata::CALLOUT_DEVICE_PATH(masterCalloutPath));
     }
 
     if (!fs::exists(hubScanPath))
@@ -101,8 +100,8 @@
         using metadata = org::open_power::Proc::FSI::MasterDetectionFailure;
 
         elog<fsi_error::MasterDetectionFailure>(
-                metadata::CALLOUT_ERRNO(0),
-                metadata::CALLOUT_DEVICE_PATH(masterCalloutPath));
+            metadata::CALLOUT_ERRNO(0),
+            metadata::CALLOUT_DEVICE_PATH(masterCalloutPath));
     }
 
     try
@@ -111,22 +110,22 @@
     }
     catch (std::system_error& e)
     {
-        //If the device driver is ever updated in the future to fail the sysfs
-        //write call on a scan failure then it should also provide some hints
-        //about which hardware failed so we can do an appropriate callout
-        //here.  At this point in time, the driver shouldn't ever fail so
-        //we won't worry about guessing at the callout.
+        // If the device driver is ever updated in the future to fail the sysfs
+        // write call on a scan failure then it should also provide some hints
+        // about which hardware failed so we can do an appropriate callout
+        // here.  At this point in time, the driver shouldn't ever fail so
+        // we won't worry about guessing at the callout.
 
         log<level::ERR>("Failed to run the FSI hub scan");
 
         using metadata = org::open_power::Proc::FSI::SlaveDetectionFailure;
 
         elog<fsi_error::SlaveDetectionFailure>(
-                metadata::ERRNO(e.code().value()));
+            metadata::ERRNO(e.code().value()));
     }
 }
 
 REGISTER_PROCEDURE("scanFSI", scan);
 
-}
-}
+} // namespace openfsi
+} // namespace openpower
diff --git a/procedures/p9/cfam_overrides.cpp b/procedures/p9/cfam_overrides.cpp
index a594e0c..13f7659 100644
--- a/procedures/p9/cfam_overrides.cpp
+++ b/procedures/p9/cfam_overrides.cpp
@@ -1,12 +1,13 @@
-#include <fstream>
-#include <sstream>
-#include <iostream>
 #include "cfam_access.hpp"
 #include "p9_cfam.hpp"
 #include "registration.hpp"
 #include "targeting.hpp"
-#include <phosphor-logging/elog.hpp>
+
+#include <fstream>
+#include <iostream>
 #include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/elog.hpp>
+#include <sstream>
 #include <xyz/openbmc_project/Common/error.hpp>
 
 /* File /var/lib/obmc/cfam_overrides requires whitespace-separated parameters
@@ -24,7 +25,8 @@
 using namespace openpower::targeting;
 using namespace openpower::util;
 
-void CFAMOverride() {
+void CFAMOverride()
+{
     int pos = 0;
     cfam_address_t address = 0;
     cfam_data_t data = 0;
@@ -38,7 +40,7 @@
 
     if (overrides.is_open())
     {
-        while (std::getline(overrides,line))
+        while (std::getline(overrides, line))
         {
             if (!line.empty())
             {
@@ -47,7 +49,7 @@
                 {
                     mask = 0xFFFFFFFF;
                     if (sscanf(line.c_str(), "%x %hx %x %x", &pos, &address,
-                        &data, &mask) >= 3)
+                               &data, &mask) >= 3)
                     {
                         const auto& target = targets.getTarget(pos);
                         writeRegWithMask(target, address, data, mask);
@@ -60,7 +62,8 @@
                             phosphor::logging::xyz::openbmc_project::Common;
                         phosphor::logging::elog<error::InvalidArgument>(
                             metadata::InvalidArgument::ARGUMENT_NAME("line"),
-                            metadata::InvalidArgument::ARGUMENT_VALUE(line.c_str()));
+                            metadata::InvalidArgument::ARGUMENT_VALUE(
+                                line.c_str()));
                     }
                 }
             }
@@ -73,5 +76,5 @@
 
 REGISTER_PROCEDURE("CFAMOverride", CFAMOverride);
 
-}
-}
+} // namespace p9
+} // namespace openpower
diff --git a/procedures/p9/cleanup_pcie.cpp b/procedures/p9/cleanup_pcie.cpp
index bfeb472..a0be3f5 100644
--- a/procedures/p9/cleanup_pcie.cpp
+++ b/procedures/p9/cleanup_pcie.cpp
@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <phosphor-logging/log.hpp>
 #include "cfam_access.hpp"
 #include "p9_cfam.hpp"
 #include "registration.hpp"
 #include "targeting.hpp"
 
+#include <phosphor-logging/log.hpp>
+
 namespace openpower
 {
 namespace p9
@@ -46,5 +47,5 @@
 
 REGISTER_PROCEDURE("cleanupPcie", cleanupPcie);
 
-}
-}
+} // namespace p9
+} // namespace openpower
diff --git a/procedures/p9/collect_sbe_hb_data.cpp b/procedures/p9/collect_sbe_hb_data.cpp
index 436a379..b29d194 100644
--- a/procedures/p9/collect_sbe_hb_data.cpp
+++ b/procedures/p9/collect_sbe_hb_data.cpp
@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <phosphor-logging/log.hpp>
 #include "cfam_access.hpp"
 #include "p9_cfam.hpp"
 #include "registration.hpp"
 #include "targeting.hpp"
 
+#include <phosphor-logging/log.hpp>
+
 namespace openpower
 {
 namespace p9
@@ -61,21 +62,21 @@
     struct
     {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-        uint32_t minorStep           :8;    //24:31
-        uint32_t majorStep           :8;    //16:23
-        uint32_t internalStep        :4;    //12:15
-        uint32_t reserved            :2;    //10:11
-        uint32_t stepFinish          :1;    //9
-        uint32_t stepStart           :1;    //8
-        uint32_t magic               :8;    //0:7
+        uint32_t minorStep : 8;    // 24:31
+        uint32_t majorStep : 8;    // 16:23
+        uint32_t internalStep : 4; // 12:15
+        uint32_t reserved : 2;     // 10:11
+        uint32_t stepFinish : 1;   // 9
+        uint32_t stepStart : 1;    // 8
+        uint32_t magic : 8;        // 0:7
 #else
-        uint32_t magic               :8;    //0:7
-        uint32_t stepStart           :1;    //8
-        uint32_t stepFinish          :1;    //9
-        uint32_t reserved            :2;    //10:11
-        uint32_t internalStep        :4;    //12:15
-        uint32_t majorStep           :8;    //16:23
-        uint32_t minorStep           :8;    //24:31
+        uint32_t magic : 8;        // 0:7
+        uint32_t stepStart : 1;    // 8
+        uint32_t stepFinish : 1;   // 9
+        uint32_t reserved : 2;     // 10:11
+        uint32_t internalStep : 4; // 12:15
+        uint32_t majorStep : 8;    // 16:23
+        uint32_t minorStep : 8;    // 24:31
 #endif
     } PACKED;
 };
@@ -95,7 +96,7 @@
 
     Targeting targets;
 
-    for (const auto& proc: targets)
+    for (const auto& proc : targets)
     {
         // Read and parse SBE messaging register
         try
@@ -103,14 +104,10 @@
             auto readData = readReg(proc, P9_SBE_MSG_REGISTER);
             auto msg = reinterpret_cast<const sbeMsgReg_t*>(&readData);
             log<level::INFO>("SBE status register",
-                             entry("PROC=%d",
-                                    proc->getPos()),
-                             entry("SBE_MAJOR_ISTEP=%d",
-                                    msg->PACKED.majorStep),
-                             entry("SBE_MINOR_ISTEP=%d",
-                                    msg->PACKED.minorStep),
-                             entry("REG_VAL=0x%08X",
-                                    msg->data32));
+                             entry("PROC=%d", proc->getPos()),
+                             entry("SBE_MAJOR_ISTEP=%d", msg->PACKED.majorStep),
+                             entry("SBE_MINOR_ISTEP=%d", msg->PACKED.minorStep),
+                             entry("REG_VAL=0x%08X", msg->data32));
         }
         catch (const std::exception& e)
         {
@@ -128,12 +125,9 @@
         if (HB_MBX5_VALID_FLAG == msg->PACKED.magic)
         {
             log<level::INFO>("HB MBOX 5 register",
-                             entry("HB_MAJOR_ISTEP=%d",
-                                    msg->PACKED.majorStep),
-                             entry("HB_MINOR_ISTEP=%d",
-                                    msg->PACKED.minorStep),
-                             entry("REG_VAL=0x%08X",
-                                    msg->data32));
+                             entry("HB_MAJOR_ISTEP=%d", msg->PACKED.majorStep),
+                             entry("HB_MINOR_ISTEP=%d", msg->PACKED.minorStep),
+                             entry("REG_VAL=0x%08X", msg->data32));
         }
     }
     catch (const std::exception& e)
diff --git a/procedures/p9/set_sync_fsi_clock_mode.cpp b/procedures/p9/set_sync_fsi_clock_mode.cpp
index b17aec5..4ffff9f 100644
--- a/procedures/p9/set_sync_fsi_clock_mode.cpp
+++ b/procedures/p9/set_sync_fsi_clock_mode.cpp
@@ -27,7 +27,6 @@
 using namespace openpower::cfam::p9;
 using namespace openpower::targeting;
 
-
 /**
  * @Brief Sets the P9 FSI clock to synchronous mode.
  */
@@ -36,13 +35,11 @@
     Targeting targets;
     const auto& master = *(targets.begin());
 
-    //Set bit 31 to 0
+    // Set bit 31 to 0
     writeRegWithMask(master, P9_LL_MODE_REG, 0x00000000, 0x00000001);
 }
 
-
 REGISTER_PROCEDURE("setSyncFSIClock", setSynchronousFSIClock);
 
-}
-}
-
+} // namespace p9
+} // namespace openpower
diff --git a/procedures/p9/start_host.cpp b/procedures/p9/start_host.cpp
index 07020df..f959ce7 100644
--- a/procedures/p9/start_host.cpp
+++ b/procedures/p9/start_host.cpp
@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <phosphor-logging/log.hpp>
 #include "cfam_access.hpp"
+#include "ext_interface.hpp"
 #include "p9_cfam.hpp"
 #include "registration.hpp"
 #include "targeting.hpp"
-#include "ext_interface.hpp"
+
+#include <phosphor-logging/log.hpp>
 
 namespace openpower
 {
@@ -30,7 +31,6 @@
 using namespace openpower::cfam::p9;
 using namespace openpower::targeting;
 
-
 /**
  * @brief Starts the self boot engine on P9 position 0 to kick off a boot.
  * @return void
@@ -43,55 +43,54 @@
     log<level::INFO>("Running P9 procedure startHost",
                      entry("NUM_PROCS=%d", targets.size()));
 
-    //Ensure asynchronous clock mode is set
+    // Ensure asynchronous clock mode is set
     writeReg(master, P9_LL_MODE_REG, 0x00000001);
 
-    //Clock mux select override
+    // Clock mux select override
     for (const auto& t : targets)
     {
-        writeRegWithMask(t, P9_ROOT_CTRL8,
-                         0x0000000C, 0x0000000C);
+        writeRegWithMask(t, P9_ROOT_CTRL8, 0x0000000C, 0x0000000C);
     }
 
-    //Enable P9 checkstop to be reported to the BMC
+    // Enable P9 checkstop to be reported to the BMC
 
-    //Setup FSI2PIB to report checkstop
+    // Setup FSI2PIB to report checkstop
     writeReg(master, P9_FSI_A_SI1S, 0x20000000);
 
-    //Enable Xstop/ATTN interrupt
+    // Enable Xstop/ATTN interrupt
     writeReg(master, P9_FSI2PIB_TRUE_MASK, 0x60000000);
 
-    //Arm it
+    // Arm it
     writeReg(master, P9_FSI2PIB_INTERRUPT, 0xFFFFFFFF);
 
-    //Kick off the SBE to start the boot
+    // Kick off the SBE to start the boot
 
     // Choose seeprom side to boot from
     cfam_data_t sbeSide = 0;
-    if(getBootCount() > 0)
+    if (getBootCount() > 0)
     {
         sbeSide = 0;
         log<level::INFO>("Setting SBE seeprom side to 0",
-                entry("SBE_SIDE_SELECT=%d", 0));
+                         entry("SBE_SIDE_SELECT=%d", 0));
     }
     else
     {
         sbeSide = 0x00004000;
         log<level::INFO>("Setting SBE seeprom side to 1",
-                entry("SBE_SIDE_SELECT=%d", 1));
+                         entry("SBE_SIDE_SELECT=%d", 1));
     }
     // Bit 17 of the ctrl status reg indicates sbe seeprom boot side
     // 0 -> Side 0, 1 -> Side 1
     writeRegWithMask(master, P9_SBE_CTRL_STATUS, sbeSide, 0x00004000);
 
-    //Ensure ISTEP stepping isn't enabled
+    // Ensure ISTEP stepping isn't enabled
     writeRegWithMask(master, P9_SCRATCH_REGISTER_8, 0x20000000, 0x20000000);
 
-    //Start the SBE
+    // Start the SBE
     writeRegWithMask(master, P9_CBS_CS, 0x80000000, 0x80000000);
 }
 
 REGISTER_PROCEDURE("startHost", startHost);
 
-}
-}
+} // namespace p9
+} // namespace openpower
diff --git a/procedures/p9/vcs_workaround.cpp b/procedures/p9/vcs_workaround.cpp
index e418971..fe3da3c 100644
--- a/procedures/p9/vcs_workaround.cpp
+++ b/procedures/p9/vcs_workaround.cpp
@@ -13,12 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <phosphor-logging/log.hpp>
 #include "cfam_access.hpp"
 #include "p9_cfam.hpp"
 #include "registration.hpp"
 #include "targeting.hpp"
 
+#include <phosphor-logging/log.hpp>
+
 namespace openpower
 {
 namespace p9
@@ -29,7 +30,6 @@
 using namespace openpower::cfam::p9;
 using namespace openpower::targeting;
 
-
 /**
  * @brief Performs the 'VCS Workaround' on all P9s in the system.
  * @return void
@@ -54,26 +54,23 @@
     log<level::INFO>("Running P9 procedure vcsWorkaround",
                      entry("NUM_PROCS=%d", targets.size()));
 
-    //Set asynchronous clock mode
+    // Set asynchronous clock mode
     writeReg(master, P9_LL_MODE_REG, 0x00000001);
 
     for (const auto& t : targets)
     {
-        //Unfence PLL controls
-        writeRegWithMask(t, P9_ROOT_CTRL0,
-                         0x00000000, 0x00010000);
+        // Unfence PLL controls
+        writeRegWithMask(t, P9_ROOT_CTRL0, 0x00000000, 0x00010000);
 
-        //Assert Perv chiplet endpoint reset
-        writeRegWithMask(t, P9_PERV_CTRL0,
-                         0x40000000, 0x40000000);
+        // Assert Perv chiplet endpoint reset
+        writeRegWithMask(t, P9_PERV_CTRL0, 0x40000000, 0x40000000);
 
-        //Enable Nest PLL
-        writeRegWithMask(t, P9_PERV_CTRL0,
-                         0x00000001, 0x00000001);
+        // Enable Nest PLL
+        writeRegWithMask(t, P9_PERV_CTRL0, 0x00000001, 0x00000001);
     }
 }
 
 REGISTER_PROCEDURE("vcsWorkaround", vcsWorkaround);
 
-}
-}
+} // namespace p9
+} // namespace openpower