diff --git a/dbus/dbuspassive.cpp b/dbus/dbuspassive.cpp
index c350ea3..7e86790 100644
--- a/dbus/dbuspassive.cpp
+++ b/dbus/dbuspassive.cpp
@@ -32,7 +32,7 @@
     {
         return nullptr;
     }
-    if (!ValidType(type))
+    if (!validType(type))
     {
         return nullptr;
     }
@@ -43,13 +43,13 @@
 DbusPassive::DbusPassive(sdbusplus::bus::bus& bus, const std::string& type,
                          const std::string& id, DbusHelperInterface* helper) :
     ReadInterface(),
-    _bus(bus), _signal(bus, GetMatch(type, id).c_str(), DbusHandleSignal, this),
+    _bus(bus), _signal(bus, getMatch(type, id).c_str(), dbusHandleSignal, this),
     _id(id), _helper(helper)
 {
     /* Need to get the scale and initial value */
     auto tempBus = sdbusplus::bus::new_default();
     /* service == busname */
-    std::string path = GetSensorPath(type, id);
+    std::string path = getSensorPath(type, id);
 
     /* getService can except, should this be in the factory? */
     std::string service = _helper->getService(tempBus, sensorintf, path);
@@ -100,7 +100,7 @@
     return _id;
 }
 
-int HandleSensorValue(sdbusplus::message::message& msg, DbusPassive* owner)
+int handleSensorValue(sdbusplus::message::message& msg, DbusPassive* owner)
 {
     std::string msgSensor;
     std::map<std::string, sdbusplus::message::variant<int64_t, double, bool>>
@@ -151,10 +151,10 @@
     return 0;
 }
 
-int DbusHandleSignal(sd_bus_message* msg, void* usrData, sd_bus_error* err)
+int dbusHandleSignal(sd_bus_message* msg, void* usrData, sd_bus_error* err)
 {
     auto sdbpMsg = sdbusplus::message::message(msg);
     DbusPassive* obj = static_cast<DbusPassive*>(usrData);
 
-    return HandleSensorValue(sdbpMsg, obj);
+    return handleSensorValue(sdbpMsg, obj);
 }
diff --git a/dbus/dbuspassive.hpp b/dbus/dbuspassive.hpp
index 801722d..02e395c 100644
--- a/dbus/dbuspassive.hpp
+++ b/dbus/dbuspassive.hpp
@@ -17,7 +17,7 @@
 #include <tuple>
 #include <vector>
 
-int DbusHandleSignal(sd_bus_message* msg, void* data, sd_bus_error* err);
+int dbusHandleSignal(sd_bus_message* msg, void* data, sd_bus_error* err);
 
 /*
  * This ReadInterface will passively listen for Value updates from whomever
@@ -62,4 +62,4 @@
     std::chrono::high_resolution_clock::time_point _updated;
 };
 
-int HandleSensorValue(sdbusplus::message::message& msg, DbusPassive* owner);
+int handleSensorValue(sdbusplus::message::message& msg, DbusPassive* owner);
diff --git a/dbus/util.cpp b/dbus/util.cpp
index 080f39a..23f06fd 100644
--- a/dbus/util.cpp
+++ b/dbus/util.cpp
@@ -143,7 +143,7 @@
     return asserted;
 }
 
-std::string GetSensorPath(const std::string& type, const std::string& id)
+std::string getSensorPath(const std::string& type, const std::string& id)
 {
     std::string layer = type;
     if (type == "fan")
@@ -162,16 +162,16 @@
     return std::string("/xyz/openbmc_project/sensors/" + layer + "/" + id);
 }
 
-std::string GetMatch(const std::string& type, const std::string& id)
+std::string getMatch(const std::string& type, const std::string& id)
 {
     return std::string("type='signal',"
                        "interface='org.freedesktop.DBus.Properties',"
                        "member='PropertiesChanged',"
                        "path='" +
-                       GetSensorPath(type, id) + "'");
+                       getSensorPath(type, id) + "'");
 }
 
-bool ValidType(const std::string& type)
+bool validType(const std::string& type)
 {
     static std::set<std::string> valid = {"fan", "temp"};
     return (valid.find(type) != valid.end());
diff --git a/dbus/util.hpp b/dbus/util.hpp
index 41a0af1..67125b9 100644
--- a/dbus/util.hpp
+++ b/dbus/util.hpp
@@ -77,9 +77,9 @@
                             const std::string& path) override;
 };
 
-std::string GetSensorPath(const std::string& type, const std::string& id);
-std::string GetMatch(const std::string& type, const std::string& id);
-bool ValidType(const std::string& type);
+std::string getSensorPath(const std::string& type, const std::string& id);
+std::string getMatch(const std::string& type, const std::string& id);
+bool validType(const std::string& type);
 
 struct VariantToFloatVisitor
 {
diff --git a/ipmi/manualcmds.cpp b/ipmi/manualcmds.cpp
index 031e1c4..dd0c0e6 100644
--- a/ipmi/manualcmds.cpp
+++ b/ipmi/manualcmds.cpp
@@ -57,7 +57,7 @@
 using PropertyMap = std::map<Property, Value>;
 
 /* The following was copied directly from my manual thread handler. */
-static std::string GetControlPath(int8_t zone)
+static std::string getControlPath(int8_t zone)
 {
     return std::string(objectPath) + std::to_string(zone);
 }
@@ -72,10 +72,10 @@
  * a{sv} 2 "Manual" b false "FailSafe" b false
  */
 
-static ipmi_ret_t GetFanCtrlProperty(uint8_t zoneId, bool* value,
+static ipmi_ret_t getFanCtrlProperty(uint8_t zoneId, bool* value,
                                      const std::string& property)
 {
-    std::string path = GetControlPath(zoneId);
+    std::string path = getControlPath(zoneId);
 
     auto propertyReadBus = sdbusplus::bus::new_default();
     auto pimMsg = propertyReadBus.new_method_call(busName, path.c_str(),
@@ -101,7 +101,7 @@
     return IPMI_CC_OK;
 }
 
-static ipmi_ret_t GetFailsafeModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
+static ipmi_ret_t getFailsafeModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
                                        size_t* dataLen)
 {
     ipmi_ret_t rc = IPMI_CC_OK;
@@ -115,7 +115,7 @@
     const auto request =
         reinterpret_cast<const struct FanCtrlRequest*>(&reqBuf[0]);
 
-    rc = GetFanCtrlProperty(request->zone, &current, failsafeProperty);
+    rc = getFanCtrlProperty(request->zone, &current, failsafeProperty);
     if (rc)
     {
         return rc;
@@ -132,7 +132,7 @@
  *   <arg name="properties" direction="out" type="a{sv}"/>
  * </method>
  */
-static ipmi_ret_t GetManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
+static ipmi_ret_t getManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
                                      size_t* dataLen)
 {
     ipmi_ret_t rc = IPMI_CC_OK;
@@ -146,7 +146,7 @@
     const auto request =
         reinterpret_cast<const struct FanCtrlRequest*>(&reqBuf[0]);
 
-    rc = GetFanCtrlProperty(request->zone, &current, manualProperty);
+    rc = getFanCtrlProperty(request->zone, &current, manualProperty);
     if (rc)
     {
         return rc;
@@ -164,7 +164,7 @@
  *   <arg name="value" direction="in" type="v"/>
  * </method>
  */
-static ipmi_ret_t SetManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
+static ipmi_ret_t setManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
                                      size_t* dataLen)
 {
     ipmi_ret_t rc = IPMI_CC_OK;
@@ -184,7 +184,7 @@
 
     auto PropertyWriteBus = sdbusplus::bus::new_default();
 
-    std::string path = GetControlPath(request->zone);
+    std::string path = getControlPath(request->zone);
 
     auto pimMsg = PropertyWriteBus.new_method_call(busName, path.c_str(),
                                                    propertiesintf, "Set");
@@ -206,7 +206,7 @@
 }
 
 /* Three command packages: get, set true, set false */
-static ipmi_ret_t ManualModeControl(ipmi_cmd_t cmd, const uint8_t* reqBuf,
+static ipmi_ret_t manualModeControl(ipmi_cmd_t cmd, const uint8_t* reqBuf,
                                     uint8_t* replyCmdBuf, size_t* dataLen)
 {
     ipmi_ret_t rc = IPMI_CC_OK;
@@ -222,11 +222,11 @@
     switch (request->command)
     {
         case GET_CONTROL_STATE:
-            return GetManualModeState(reqBuf, replyCmdBuf, dataLen);
+            return getManualModeState(reqBuf, replyCmdBuf, dataLen);
         case SET_CONTROL_STATE:
-            return SetManualModeState(reqBuf, replyCmdBuf, dataLen);
+            return setManualModeState(reqBuf, replyCmdBuf, dataLen);
         case GET_FAILSAFE_STATE:
-            return GetFailsafeModeState(reqBuf, replyCmdBuf, dataLen);
+            return getFailsafeModeState(reqBuf, replyCmdBuf, dataLen);
         default:
             rc = IPMI_CC_INVALID;
     }
@@ -245,5 +245,5 @@
             oem::obmcOemNumber, oem::Cmd::fanManualCmd);
 
     router->registerHandler(oem::obmcOemNumber, oem::Cmd::fanManualCmd,
-                            ManualModeControl);
+                            manualModeControl);
 }
diff --git a/main.cpp b/main.cpp
index 6b3a417..6c3209d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -106,8 +106,8 @@
     {
         try
         {
-            mgmr = BuildSensorsFromConfig(configPath);
-            zones = BuildZonesFromConfig(configPath, mgmr, ModeControlBus);
+            mgmr = buildSensorsFromConfig(configPath);
+            zones = buildZonesFromConfig(configPath, mgmr, ModeControlBus);
         }
         catch (const std::exception& e)
         {
@@ -117,8 +117,8 @@
     }
     else
     {
-        mgmr = BuildSensors(SensorConfig);
-        zones = BuildZones(ZoneConfig, ZoneDetailsConfig, mgmr, ModeControlBus);
+        mgmr = buildSensors(SensorConfig);
+        zones = buildZones(ZoneConfig, ZoneDetailsConfig, mgmr, ModeControlBus);
     }
 
     if (0 == zones.size())
@@ -161,7 +161,7 @@
     for (const auto& i : zones)
     {
         std::cerr << "pushing zone" << std::endl;
-        zoneThreads.push_back(std::thread(PIDControlThread, i.second.get()));
+        zoneThreads.push_back(std::thread(pidControlThread, i.second.get()));
     }
 
     l.join();
diff --git a/pid/builder.cpp b/pid/builder.cpp
index 7b67795..58ef8df 100644
--- a/pid/builder.cpp
+++ b/pid/builder.cpp
@@ -30,13 +30,13 @@
 static constexpr bool deferSignals = true;
 static constexpr auto objectPath = "/xyz/openbmc_project/settings/fanctrl/zone";
 
-static std::string GetControlPath(int64_t zone)
+static std::string getControlPath(int64_t zone)
 {
     return std::string(objectPath) + std::to_string(zone);
 }
 
 std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
-    BuildZones(std::map<int64_t, PIDConf>& zonePids,
+    buildZones(std::map<int64_t, PIDConf>& zonePids,
                std::map<int64_t, struct ZoneConfig>& zoneConfigs,
                SensorManager& mgr, sdbusplus::bus::bus& modeControlBus)
 {
@@ -65,7 +65,7 @@
         auto zone = std::make_unique<PIDZone>(
             zoneId, zoneConf->second.minthermalrpm,
             zoneConf->second.failsafepercent, mgr, modeControlBus,
-            GetControlPath(zi.first).c_str(), deferSignals);
+            getControlPath(zi.first).c_str(), deferSignals);
 
         std::cerr << "Zone Id: " << zone->getZoneId() << "\n";
 
diff --git a/pid/builder.hpp b/pid/builder.hpp
index 8891531..2b28663 100644
--- a/pid/builder.hpp
+++ b/pid/builder.hpp
@@ -8,6 +8,6 @@
 #include <unordered_map>
 
 std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
-    BuildZones(std::map<int64_t, PIDConf>& zonePids,
+    buildZones(std::map<int64_t, PIDConf>& zonePids,
                std::map<int64_t, struct ZoneConfig>& zoneConfigs,
                SensorManager& mgr, sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/builderconfig.cpp b/pid/builderconfig.cpp
index 4909713..665e2dd 100644
--- a/pid/builderconfig.cpp
+++ b/pid/builderconfig.cpp
@@ -28,7 +28,7 @@
 #include <unordered_map>
 
 std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
-    BuildZonesFromConfig(const std::string& path, SensorManager& mgr,
+    buildZonesFromConfig(const std::string& path, SensorManager& mgr,
                          sdbusplus::bus::bus& modeControlBus)
 {
     using namespace libconfig;
@@ -149,5 +149,5 @@
         throw;
     }
 
-    return BuildZones(pidConfig, zoneConfig, mgr, modeControlBus);
+    return buildZones(pidConfig, zoneConfig, mgr, modeControlBus);
 }
diff --git a/pid/builderconfig.hpp b/pid/builderconfig.hpp
index a7f41f8..8390bee 100644
--- a/pid/builderconfig.hpp
+++ b/pid/builderconfig.hpp
@@ -9,5 +9,5 @@
 #include <unordered_map>
 
 std::unordered_map<int64_t, std::unique_ptr<PIDZone>>
-    BuildZonesFromConfig(const std::string& path, SensorManager& mgr,
+    buildZonesFromConfig(const std::string& path, SensorManager& mgr,
                          sdbusplus::bus::bus& modeControlBus);
diff --git a/pid/fancontroller.cpp b/pid/fancontroller.cpp
index 3a56f95..ce08185 100644
--- a/pid/fancontroller.cpp
+++ b/pid/fancontroller.cpp
@@ -34,7 +34,7 @@
     auto fan = std::make_unique<FanController>(id, inputs, owner);
     ec::pid_info_t* info = fan->getPIDInfo();
 
-    InitializePIDStruct(info, initial);
+    initializePIDStruct(info, initial);
 
     return fan;
 }
diff --git a/pid/pidthread.cpp b/pid/pidthread.cpp
index dc53bdb..7d27e42 100644
--- a/pid/pidthread.cpp
+++ b/pid/pidthread.cpp
@@ -25,7 +25,7 @@
 #include <thread>
 #include <vector>
 
-static void ProcessThermals(PIDZone* zone)
+static void processThermals(PIDZone* zone)
 {
     // Get the latest margins.
     zone->updateSensors();
@@ -37,7 +37,7 @@
     zone->determineMaxRPMRequest();
 }
 
-void PIDControlThread(PIDZone* zone)
+void pidControlThread(PIDZone* zone)
 {
     int ms100cnt = 0;
     /*
@@ -66,7 +66,7 @@
     zone->initializeLog();
 #endif
     zone->initializeCache();
-    ProcessThermals(zone);
+    processThermals(zone);
 
     while (true)
     {
@@ -86,7 +86,7 @@
         {
             ms100cnt = 0;
 
-            ProcessThermals(zone);
+            processThermals(zone);
         }
 
         // Run the fan PIDs every iteration.
diff --git a/pid/pidthread.hpp b/pid/pidthread.hpp
index 37c416a..94865c0 100644
--- a/pid/pidthread.hpp
+++ b/pid/pidthread.hpp
@@ -3,4 +3,4 @@
 #include "pid/zone.hpp"
 
 /* Given a zone, run through the loops. */
-void PIDControlThread(PIDZone* zone);
+void pidControlThread(PIDZone* zone);
diff --git a/pid/thermalcontroller.cpp b/pid/thermalcontroller.cpp
index cc6c1f9..5388823 100644
--- a/pid/thermalcontroller.cpp
+++ b/pid/thermalcontroller.cpp
@@ -35,7 +35,7 @@
     ec::pid_info_t* info = thermal->getPIDInfo();
     thermal->setSetpoint(setpoint);
 
-    InitializePIDStruct(info, initial);
+    initializePIDStruct(info, initial);
 
     return thermal;
 }
diff --git a/pid/util.cpp b/pid/util.cpp
index 8b24fb2..9d666ef 100644
--- a/pid/util.cpp
+++ b/pid/util.cpp
@@ -19,7 +19,7 @@
 #include <cstring>
 #include <iostream>
 
-void InitializePIDStruct(ec::pid_info_t* info, const ec::pidinfo& initial)
+void initializePIDStruct(ec::pid_info_t* info, const ec::pidinfo& initial)
 {
     std::memset(info, 0x00, sizeof(ec::pid_info_t));
 
@@ -36,7 +36,7 @@
     info->slew_pos = initial.slew_pos;
 }
 
-void DumpPIDStruct(ec::pid_info_t* info)
+void dumpPIDStruct(ec::pid_info_t* info)
 {
     std::cerr << " ts: " << info->ts << " p_c: " << info->p_c
               << " i_c: " << info->i_c << " ff_off: " << info->ff_off
diff --git a/pid/util.hpp b/pid/util.hpp
index a80e07f..c35f0b8 100644
--- a/pid/util.hpp
+++ b/pid/util.hpp
@@ -6,6 +6,6 @@
  * Given a configuration structure, fill out the information we use within the
  * PID loop.
  */
-void InitializePIDStruct(ec::pid_info_t* info, const ec::pidinfo& initial);
+void initializePIDStruct(ec::pid_info_t* info, const ec::pidinfo& initial);
 
-void DumpPIDStruct(ec::pid_info_t* info);
+void dumpPIDStruct(ec::pid_info_t* info);
diff --git a/sensors/builder.cpp b/sensors/builder.cpp
index 2d8154a..15d479c 100644
--- a/sensors/builder.cpp
+++ b/sensors/builder.cpp
@@ -37,7 +37,7 @@
 static DbusHelper helper;
 
 SensorManager
-    BuildSensors(const std::map<std::string, struct SensorConfig>& config)
+    buildSensors(const std::map<std::string, struct SensorConfig>& config)
 {
     SensorManager mgmr;
     auto& HostSensorBus = mgmr.getHostBus();
@@ -54,8 +54,8 @@
         std::cerr << "Sensor: " << name << " " << info->type << " ";
         std::cerr << info->readpath << " " << info->writepath << "\n";
 
-        IOInterfaceType rtype = GetReadInterfaceType(info->readpath);
-        IOInterfaceType wtype = GetWriteInterfaceType(info->writepath);
+        IOInterfaceType rtype = getReadInterfaceType(info->readpath);
+        IOInterfaceType wtype = getWriteInterfaceType(info->writepath);
 
         // fan sensors can be ready any way and written others.
         // fan sensors are the only sensors this is designed to write.
diff --git a/sensors/builder.hpp b/sensors/builder.hpp
index fdf1c9b..d646223 100644
--- a/sensors/builder.hpp
+++ b/sensors/builder.hpp
@@ -10,4 +10,4 @@
  * Build the sensors and associate them with a SensorManager.
  */
 SensorManager
-    BuildSensors(const std::map<std::string, struct SensorConfig>& config);
+    buildSensors(const std::map<std::string, struct SensorConfig>& config);
diff --git a/sensors/builderconfig.cpp b/sensors/builderconfig.cpp
index f87e572..0c6ed68 100644
--- a/sensors/builderconfig.cpp
+++ b/sensors/builderconfig.cpp
@@ -29,7 +29,7 @@
  * parsing.  I should just ditch the compile-time version to reduce the
  * probability of sync bugs.
  */
-SensorManager BuildSensorsFromConfig(const std::string& path)
+SensorManager buildSensorsFromConfig(const std::string& path)
 {
     using namespace libconfig;
 
@@ -110,5 +110,5 @@
         throw;
     }
 
-    return BuildSensors(config);
+    return buildSensors(config);
 }
diff --git a/sensors/builderconfig.hpp b/sensors/builderconfig.hpp
index 649ca70..da5306f 100644
--- a/sensors/builderconfig.hpp
+++ b/sensors/builderconfig.hpp
@@ -8,4 +8,4 @@
  * Given a configuration file, parsable by libconfig++, parse it and then pass
  * the information onto BuildSensors.
  */
-SensorManager BuildSensorsFromConfig(const std::string& path);
+SensorManager buildSensorsFromConfig(const std::string& path);
diff --git a/test/dbus_passive_unittest.cpp b/test/dbus_passive_unittest.cpp
index 777a623..6826ce1 100644
--- a/test/dbus_passive_unittest.cpp
+++ b/test/dbus_passive_unittest.cpp
@@ -202,7 +202,7 @@
         .WillOnce(Return(0))  /* std::pair */
         .WillOnce(Return(0)); /* std::map */
 
-    int rv = HandleSensorValue(msg, passive);
+    int rv = handleSensorValue(msg, passive);
     EXPECT_EQ(rv, 0); // It's always 0.
 
     ReadReturn r = passive->read();
@@ -272,7 +272,7 @@
         .WillOnce(Return(0))  /* std::pair */
         .WillOnce(Return(0)); /* std::map */
 
-    int rv = HandleSensorValue(msg, passive);
+    int rv = handleSensorValue(msg, passive);
     EXPECT_EQ(rv, 0); // It's always 0.
 
     ReadReturn r = passive->read();
@@ -346,7 +346,7 @@
         .WillOnce(Return(0))  /* std::pair */
         .WillOnce(Return(0)); /* std::map */
 
-    int rv = HandleSensorValue(msg, passive);
+    int rv = handleSensorValue(msg, passive);
     EXPECT_EQ(rv, 0); // It's always 0.
     bool failed = passive->getFailed();
     EXPECT_EQ(failed, true);
@@ -421,7 +421,7 @@
         .WillOnce(Return(0))  /* std::pair */
         .WillOnce(Return(0)); /* std::map */
 
-    int rv = HandleSensorValue(msg, passive);
+    int rv = handleSensorValue(msg, passive);
     EXPECT_EQ(rv, 0); // It's always 0.
     bool failed = passive->getFailed();
     EXPECT_EQ(failed, false);
diff --git a/test/util_unittest.cpp b/test/util_unittest.cpp
index 6fe77b2..6e5e548 100644
--- a/test/util_unittest.cpp
+++ b/test/util_unittest.cpp
@@ -9,14 +9,14 @@
 {
     // Verify it responds to an empty string.
 
-    EXPECT_EQ(IOInterfaceType::NONE, GetWriteInterfaceType(""));
+    EXPECT_EQ(IOInterfaceType::NONE, getWriteInterfaceType(""));
 }
 
 TEST(UtilTest, WriteTypeNonePath_ReturnsNONE)
 {
     // Verify it responds to a path of "None"
 
-    EXPECT_EQ(IOInterfaceType::NONE, GetWriteInterfaceType("None"));
+    EXPECT_EQ(IOInterfaceType::NONE, getWriteInterfaceType("None"));
 }
 
 TEST(UtilTest, WriteTypeSysfs_ReturnsSYSFS)
@@ -24,7 +24,7 @@
     // Verify the sysfs type is determined with an expected path
 
     std::string path = "/sys/devices/asfdadsf";
-    EXPECT_EQ(IOInterfaceType::SYSFS, GetWriteInterfaceType(path));
+    EXPECT_EQ(IOInterfaceType::SYSFS, getWriteInterfaceType(path));
 }
 
 TEST(UtilTest, WriteTypeUnknown_ReturnsUNKNOWN)
@@ -32,21 +32,21 @@
     // Verify it reports unknown by default.
 
     std::string path = "/xyz/openbmc_project";
-    EXPECT_EQ(IOInterfaceType::UNKNOWN, GetWriteInterfaceType(path));
+    EXPECT_EQ(IOInterfaceType::UNKNOWN, getWriteInterfaceType(path));
 }
 
 TEST(UtilTest, ReadTypeEmptyString_ReturnsNONE)
 {
     // Verify it responds to an empty string.
 
-    EXPECT_EQ(IOInterfaceType::NONE, GetReadInterfaceType(""));
+    EXPECT_EQ(IOInterfaceType::NONE, getReadInterfaceType(""));
 }
 
 TEST(UtilTest, ReadTypeNonePath_ReturnsNONE)
 {
     // Verify it responds to a path of "None"
 
-    EXPECT_EQ(IOInterfaceType::NONE, GetReadInterfaceType("None"));
+    EXPECT_EQ(IOInterfaceType::NONE, getReadInterfaceType("None"));
 }
 
 TEST(UtilTest, ReadTypeExternalSensors_ReturnsEXTERNAL)
@@ -54,7 +54,7 @@
     // Verify it responds to a path that represents a host sensor.
 
     std::string path = "/xyz/openbmc_project/extsensors/temperature/fleeting0";
-    EXPECT_EQ(IOInterfaceType::EXTERNAL, GetReadInterfaceType(path));
+    EXPECT_EQ(IOInterfaceType::EXTERNAL, getReadInterfaceType(path));
 }
 
 TEST(UtilTest, ReadTypeOpenBMCSensor_ReturnsDBUSPASSIVE)
@@ -62,7 +62,7 @@
     // Verify it responds to a path that represents a dbus sensor.
 
     std::string path = "/xyz/openbmc_project/sensors/fan_tach/fan1";
-    EXPECT_EQ(IOInterfaceType::DBUSPASSIVE, GetReadInterfaceType(path));
+    EXPECT_EQ(IOInterfaceType::DBUSPASSIVE, getReadInterfaceType(path));
 }
 
 TEST(UtilTest, ReadTypeSysfsPath_ReturnsSYSFS)
@@ -70,7 +70,7 @@
     // Verify the sysfs type is determined with an expected path
 
     std::string path = "/sys/devices/asdf/asdf0";
-    EXPECT_EQ(IOInterfaceType::SYSFS, GetReadInterfaceType(path));
+    EXPECT_EQ(IOInterfaceType::SYSFS, getReadInterfaceType(path));
 }
 
 TEST(UtilTest, ReadTypeUnknownDefault_ReturnsUNKNOWN)
@@ -78,5 +78,5 @@
     // Verify it reports unknown by default.
 
     std::string path = "asdf09as0df9a0fd";
-    EXPECT_EQ(IOInterfaceType::UNKNOWN, GetReadInterfaceType(path));
+    EXPECT_EQ(IOInterfaceType::UNKNOWN, getReadInterfaceType(path));
 }
diff --git a/util.cpp b/util.cpp
index f95d851..f66f20b 100644
--- a/util.cpp
+++ b/util.cpp
@@ -24,7 +24,7 @@
 static constexpr auto dbus_pwm = "/xyz/openbmc_project/control/fanpwm/";
 static constexpr auto sysfs = "/sys/";
 
-IOInterfaceType GetWriteInterfaceType(const std::string& path)
+IOInterfaceType getWriteInterfaceType(const std::string& path)
 {
     if (path.empty() || "None" == path)
     {
@@ -45,7 +45,7 @@
     return IOInterfaceType::UNKNOWN;
 }
 
-IOInterfaceType GetReadInterfaceType(const std::string& path)
+IOInterfaceType getReadInterfaceType(const std::string& path)
 {
     if (path.empty() || "None" == path)
     {
diff --git a/util.hpp b/util.hpp
index 7d3307b..fdc7772 100644
--- a/util.hpp
+++ b/util.hpp
@@ -21,6 +21,6 @@
 };
 
 /* WriteInterfaceType is different because Dbusactive/passive. how to know... */
-IOInterfaceType GetWriteInterfaceType(const std::string& path);
+IOInterfaceType getWriteInterfaceType(const std::string& path);
 
-IOInterfaceType GetReadInterfaceType(const std::string& path);
+IOInterfaceType getReadInterfaceType(const std::string& path);