diff --git a/src/appcommands.cpp b/src/appcommands.cpp
index 8f470fe..3b633b0 100644
--- a/src/appcommands.cpp
+++ b/src/appcommands.cpp
@@ -49,12 +49,16 @@
 static SysInfoParam sysInfoParams;
 nlohmann::json appData __attribute__((init_priority(101)));
 
+// Custom completion codes can be defined in individual modules for command
+// specific errors in the 0x80-0xBE range
+constexpr ipmi::Cc ccSystemInfoParameterNotSupported = 0x80;
+
 int sendBicCmd(uint8_t, uint8_t, uint8_t, std::vector<uint8_t>&,
                std::vector<uint8_t>&);
 
 static inline auto responseSystemInfoParamterNotSupportCommand()
 {
-    return response(IPMI_CC_SYSTEM_INFO_PARAMETER_NOT_SUPPORTED);
+    return response(ccSystemInfoParameterNotSupported);
 }
 
 void printGUID(uint8_t* guid, off_t offset)
@@ -143,7 +147,7 @@
 
     *data_len = 2;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -155,7 +159,7 @@
 {
     uint8_t* req = reinterpret_cast<uint8_t*>(request);
     std::string mfrTest = "sled-cycle";
-    ipmi_ret_t rc = IPMI_CC_OK;
+    ipmi_ret_t rc = ipmi::ccSuccess;
 
     if (!memcmp(req, mfrTest.data(), mfrTest.length()) &&
         (*data_len == mfrTest.length()))
@@ -164,12 +168,12 @@
         auto ret = system("/usr/sbin/power-util sled-cycle");
         if (ret)
         {
-            rc = IPMI_CC_UNSPECIFIED_ERROR;
+            rc = ipmi::ccUnspecifiedError;
         }
     }
     else
     {
-        rc = IPMI_CC_SYSTEM_INFO_PARAMETER_NOT_SUPPORTED;
+        rc = ccSystemInfoParameterNotSupported;
     }
 
     *data_len = 0;
@@ -189,7 +193,7 @@
     globEna = *req;
     *data_len = 0;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -204,7 +208,7 @@
     *data_len = 1;
     *res++ = globEna;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -217,7 +221,7 @@
     // Do Nothing and just return success
     *data_len = 0;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -246,10 +250,10 @@
     uint8_t* res = reinterpret_cast<uint8_t*>(response);
     if (getSystemGUID(res))
     {
-        return IPMI_CC_UNSPECIFIED_ERROR;
+        return ipmi::ccUnspecifiedError;
     }
     *data_len = GUID_SIZE;
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 #endif
diff --git a/src/oemcommands.cpp b/src/oemcommands.cpp
index 9bb1e77..a356ecb 100644
--- a/src/oemcommands.cpp
+++ b/src/oemcommands.cpp
@@ -434,7 +434,7 @@
 
 ipmi_ret_t getNetworkData(uint8_t lan_param, char* data)
 {
-    ipmi_ret_t rc = IPMI_CC_OK;
+    ipmi_ret_t rc = ipmi::ccSuccess;
     sdbusplus::bus_t bus(ipmid_get_sd_bus_connection());
 
     const std::string ethdevice = "eth0";
@@ -496,7 +496,7 @@
         break;
 
         default:
-            rc = IPMI_CC_PARM_OUT_OF_RANGE;
+            rc = ipmi::ccParmOutOfRange;
     }
     return rc;
 }
@@ -813,7 +813,7 @@
     res[SIZE_IANA_ID] = num_frames;
     *data_len = SIZE_IANA_ID + 1;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -835,7 +835,7 @@
     res[SIZE_IANA_ID + 2] = 2; // cri sel update
     res[SIZE_IANA_ID + 3] = 3; // cri sensor update
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -862,7 +862,7 @@
     {
         memcpy(res, req, SIZE_IANA_ID); // IANA ID
         *data_len = SIZE_IANA_ID;
-        return IPMI_CC_UNSPECIFIED_ERROR;
+        return ipmi::ccUnspecifiedError;
     }
 
     memcpy(res, req, SIZE_IANA_ID); // IANA ID
@@ -873,7 +873,7 @@
     res[7] = descLen;
     *data_len = SIZE_IANA_ID + 5 + descLen;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -901,7 +901,7 @@
     {
         memcpy(res, req, SIZE_IANA_ID); // IANA ID
         *data_len = SIZE_IANA_ID;
-        return IPMI_CC_UNSPECIFIED_ERROR;
+        return ipmi::ccUnspecifiedError;
     }
 
     memcpy(res, req, SIZE_IANA_ID); // IANA ID
@@ -912,7 +912,7 @@
     res[7] = descLen;
     *data_len = SIZE_IANA_ID + 5 + descLen;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -938,7 +938,7 @@
     {
         memcpy(res, req, SIZE_IANA_ID); // IANA ID
         *data_len = SIZE_IANA_ID;
-        return IPMI_CC_UNSPECIFIED_ERROR;
+        return ipmi::ccUnspecifiedError;
     }
 
     memcpy(res, req, SIZE_IANA_ID); // IANA ID
@@ -948,7 +948,7 @@
     res[6] = count;
     *data_len = SIZE_IANA_ID + 4 + count;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1009,7 +1009,7 @@
 
     *data_len = 0;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1022,7 +1022,7 @@
     /* TODO: Needs to implement this after GPIO implementation */
     *data_len = 0;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1154,7 +1154,7 @@
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Invalid machine configuration length received");
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
 
     if (req->chassis_type >= sizeof(chassisType) / sizeof(uint8_t*))
@@ -1217,7 +1217,7 @@
 
     flushOemData();
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1231,7 +1231,7 @@
 
     /* Do nothing, return success */
     *data_len = 0;
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1255,7 +1255,7 @@
     // Sync time with system
     // TODO: Add code for syncing time
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1288,7 +1288,7 @@
     oemData[KEY_PPIN_INFO] = ppinStr.c_str();
     flushOemData();
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1300,7 +1300,7 @@
 {
     /* Do nothing, return success */
     *data_len = 0;
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 // Helper function to set guid at offset in EEPROM
@@ -1388,16 +1388,16 @@
     if (*data_len != GUID_SIZE) // 16bytes
     {
         *data_len = 0;
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
 
     *data_len = 0;
 
     if (setGUID(OFFSET_SYS_GUID, req))
     {
-        return IPMI_CC_UNSPECIFIED_ERROR;
+        return ipmi::ccUnspecifiedError;
     }
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 #endif
 
@@ -1410,7 +1410,7 @@
 {
     /* Do nothing, return success */
     *data_len = 0;
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1449,20 +1449,20 @@
             break;
         case PPR_ROW_COUNT:
             if (req[1] > 100)
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             oemData[KEY_PPR][KEY_PPR_ROW_COUNT] = req[1];
             break;
         case PPR_ROW_ADDR:
             pprIndex = req[1];
             if (pprIndex > 100)
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             if (len < PPR_ROW_ADDR_LEN + 1)
             {
                 phosphor::logging::log<phosphor::logging::level::ERR>(
                     "Invalid PPR Row Address length received");
-                return IPMI_CC_REQ_DATA_LEN_INVALID;
+                return ipmi::ccReqDataLenInvalid;
             }
 
             ss << std::hex;
@@ -1476,13 +1476,13 @@
         case PPR_HISTORY_DATA:
             pprIndex = req[1];
             if (pprIndex > 100)
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             if (len < PPR_HST_DATA_LEN + 1)
             {
                 phosphor::logging::log<phosphor::logging::level::ERR>(
                     "Invalid PPR history data length received");
-                return IPMI_CC_REQ_DATA_LEN_INVALID;
+                return ipmi::ccReqDataLenInvalid;
             }
 
             ss << std::hex;
@@ -1494,13 +1494,13 @@
             oemData[KEY_PPR][ss.str()][KEY_PPR_HST_DATA] = str.c_str();
             break;
         default:
-            return IPMI_CC_PARM_OUT_OF_RANGE;
+            return ipmi::ccParmOutOfRange;
             break;
     }
 
     flushOemData();
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -1550,17 +1550,17 @@
         case PPR_ROW_ADDR:
             pprIndex = req[1];
             if (pprIndex > 100)
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             ss << std::hex;
             ss << std::setw(2) << std::setfill('0') << (int)pprIndex;
 
             if (oemData[KEY_PPR].find(ss.str()) == oemData[KEY_PPR].end())
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             if (oemData[KEY_PPR][ss.str()].find(KEY_PPR_ROW_ADDR) ==
                 oemData[KEY_PPR][ss.str()].end())
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             str = oemData[KEY_PPR][ss.str()][KEY_PPR_ROW_ADDR];
             *data_len = strToBytes(str, res);
@@ -1568,27 +1568,27 @@
         case PPR_HISTORY_DATA:
             pprIndex = req[1];
             if (pprIndex > 100)
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             ss << std::hex;
             ss << std::setw(2) << std::setfill('0') << (int)pprIndex;
 
             if (oemData[KEY_PPR].find(ss.str()) == oemData[KEY_PPR].end())
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             if (oemData[KEY_PPR][ss.str()].find(KEY_PPR_HST_DATA) ==
                 oemData[KEY_PPR][ss.str()].end())
-                return IPMI_CC_PARM_OUT_OF_RANGE;
+                return ipmi::ccParmOutOfRange;
 
             str = oemData[KEY_PPR][ss.str()][KEY_PPR_HST_DATA];
             *data_len = strToBytes(str, res);
             break;
         default:
-            return IPMI_CC_PARM_OUT_OF_RANGE;
+            return ipmi::ccParmOutOfRange;
             break;
     }
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 /* FB OEM QC Commands */
@@ -1997,7 +1997,7 @@
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Invalid parameter received");
-        return IPMI_CC_PARM_OUT_OF_RANGE;
+        return ipmi::ccParmOutOfRange;
     }
 
     len = len - 6; // Get Actual data length
@@ -2013,7 +2013,7 @@
            [driveInfoKey[req->paramSel]] = str.c_str();
     flushOemData();
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 //----------------------------------------------------------------------
@@ -2056,7 +2056,7 @@
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "Invalid parameter received");
-        return IPMI_CC_PARM_OUT_OF_RANGE;
+        return ipmi::ccParmOutOfRange;
     }
 
     if (oemData[KEY_Q_DRIVE_INFO].find(ctrlTypeKey[ctrlType]) ==
@@ -2079,7 +2079,7 @@
                  [dimmInfoKey[req->paramSel]];
     *data_len = strToBytes(str, res);
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 /* Helper function for sending DCMI commands to ME/BIC and
@@ -2236,11 +2236,11 @@
         case CrdState::free:
             break;
         default:
-            return IPMI_CC_UNSPECIFIED_ERROR;
+            return ipmi::ccUnspecifiedError;
     }
     currState = newState;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static ipmi_ret_t handleMcaBank(const CrashDumpHdr& hdr,
@@ -2248,7 +2248,7 @@
                                 CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(CrdMcaBank))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2270,7 +2270,7 @@
     ss << std::format(" MCA_MISC1     : 0x{:016X}\n", pBank->mcaMisc1);
     ss << "\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 template <typename T>
@@ -2278,12 +2278,12 @@
                                     CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(T))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     const auto* pBank = reinterpret_cast<const T*>(data.data());
 
     if (data.size() < sizeof(T) + sizeof(BankCorePair) * pBank->mcaCount)
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2310,14 +2310,14 @@
     }
     ss << "\n\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static ipmi_ret_t handleCpuWdtBank(std::span<const uint8_t> data,
                                    CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(CrdCpuWdtBank))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2344,7 +2344,7 @@
     }
     ss << "\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 template <size_t N>
@@ -2353,7 +2353,7 @@
                                      CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(CrdHwAssertBank<N>))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2376,14 +2376,14 @@
     }
     ss << "\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static ipmi_ret_t handlePcieAerBank(std::span<const uint8_t> data,
                                     CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(CrdPcieAerBank))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2438,18 +2438,18 @@
                       pBank->laneErrSts);
     ss << "\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static ipmi_ret_t handleWdtRegBank(std::span<const uint8_t> data,
                                    CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(CrdWdtRegBank))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     const auto* pBank = reinterpret_cast<const CrdWdtRegBank*>(data.data());
     if (data.size() < sizeof(CrdWdtRegBank) + sizeof(uint32_t) * pBank->count)
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2465,14 +2465,14 @@
     }
     ss << "\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static ipmi_ret_t handleCrdHdrBank(std::span<const uint8_t> data,
                                    CrdState& currState, std::stringstream& ss)
 {
     if (data.size() < sizeof(CrdHdrBank))
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     ipmi_ret_t res = setDumpState(currState, CrdState::waitData);
     if (res)
@@ -2494,7 +2494,7 @@
                       (pBank->pmio & 0x10) >> 4);
     ss << "\n";
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static std::string getFilename(const std::filesystem::path& dir,
@@ -2527,7 +2527,7 @@
                                  CrdState& currState, std::stringstream& ss)
 {
     if (data.empty())
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
 
     switch (static_cast<CrdCtrl>(data[0]))
     {
@@ -2543,7 +2543,7 @@
             std::string filename = getFilename(dumpDir, "crashdump_");
             std::ofstream outFile(dumpDir / filename);
             if (!outFile.is_open())
-                return IPMI_CC_UNSPECIFIED_ERROR;
+                return ipmi::ccUnspecifiedError;
 
             auto now = std::chrono::system_clock::to_time_t(
                 std::chrono::system_clock::now());
@@ -2561,7 +2561,7 @@
             return ccInvalidParam;
     }
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi::RspType<std::vector<uint8_t>> ipmiOemCrashdump(
@@ -2620,7 +2620,7 @@
             break;
         case BankType::ctrl:
             res = handleCtrlBank(bData, dumpState, ss);
-            if (res == IPMI_CC_OK &&
+            if (res == ipmi::ccSuccess &&
                 static_cast<CrdCtrl>(bData[0]) == CrdCtrl::getState)
             {
                 return ipmi::responseSuccess(
diff --git a/src/storagecommands.cpp b/src/storagecommands.cpp
index 1c6f36f..33c38b2 100644
--- a/src/storagecommands.cpp
+++ b/src/storagecommands.cpp
@@ -209,7 +209,7 @@
     bool timerRunning = (cacheTimer != nullptr) && !cacheTimer->isExpired();
     if (lastDevId == devId && timerRunning)
     {
-        return IPMI_CC_OK; // cache already up to date
+        return ipmi::ccSuccess; // cache already up to date
     }
     // if timer is running, stop it and writeFru manually
     else if (timerRunning)
@@ -231,7 +231,7 @@
     {
         phosphor::logging::log<phosphor::logging::level::ERR>(
             "replaceCacheFru: error getting managed objects");
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
 
     deviceHashes.clear();
@@ -277,7 +277,7 @@
     auto deviceFind = deviceHashes.find(devId);
     if (deviceFind == deviceHashes.end())
     {
-        return IPMI_CC_SENSOR_INVALID;
+        return ipmi::ccSensorInvalid;
     }
 
     fruCache.clear();
@@ -297,11 +297,11 @@
         lastDevId = 0xFF;
         cacheBus = 0xFFFF;
         cacheAddr = 0xFF;
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
 
     lastDevId = devId;
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi_ret_t ipmiStorageReadFRUData(
@@ -311,7 +311,7 @@
     if (*dataLen != 4)
     {
         *dataLen = 0;
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
     *dataLen = 0; // default to 0 in case of an error
 
@@ -319,11 +319,11 @@
 
     if (req->countToRead > maxMessageSize - 1)
     {
-        return IPMI_CC_INVALID_FIELD_REQUEST;
+        return ipmi::ccInvalidFieldRequest;
     }
     ipmi_ret_t status = replaceCacheFru(req->fruDeviceID);
 
-    if (status != IPMI_CC_OK)
+    if (status != ipmi::ccSuccess)
     {
         return status;
     }
@@ -351,7 +351,7 @@
     }
     *dataLen = fromFRUByteLen + 1;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi_ret_t ipmiStorageWriteFRUData(
@@ -364,7 +364,7 @@
                       // byte of data after the three request data bytes
     {
         *dataLen = 0;
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
 
     auto req = static_cast<WriteFRUDataReq*>(request);
@@ -372,7 +372,7 @@
     *dataLen = 0; // default to 0 in case of an error
 
     ipmi_ret_t status = replaceCacheFru(req->fruDeviceID);
-    if (status != IPMI_CC_OK)
+    if (status != ipmi::ccSuccess)
     {
         return status;
     }
@@ -419,7 +419,7 @@
         cacheTimer->stop();
         if (!writeFru())
         {
-            return IPMI_CC_INVALID_FIELD_REQUEST;
+            return ipmi::ccInvalidFieldRequest;
         }
         *respPtr = std::min(fruCache.size(), static_cast<size_t>(0xFF));
     }
@@ -435,30 +435,30 @@
 
     *dataLen = 1;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi_ret_t getFruSdrCount(size_t& count)
 {
     ipmi_ret_t ret = replaceCacheFru(0);
-    if (ret != IPMI_CC_OK)
+    if (ret != ipmi::ccSuccess)
     {
         return ret;
     }
     count = deviceHashes.size();
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi_ret_t getFruSdrs(size_t index, get_sdr::SensorDataFruRecord& resp)
 {
     ipmi_ret_t ret = replaceCacheFru(0); // this will update the hash list
-    if (ret != IPMI_CC_OK)
+    if (ret != ipmi::ccSuccess)
     {
         return ret;
     }
     if (deviceHashes.size() < index)
     {
-        return IPMI_CC_INVALID_FIELD_REQUEST;
+        return ipmi::ccInvalidFieldRequest;
     }
     auto device = deviceHashes.begin() + index;
     uint8_t& bus = device->second.first;
@@ -476,7 +476,7 @@
     }
     catch (const sdbusplus::exception_t&)
     {
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
     boost::container::flat_map<std::string, DbusVariant>* fruData = nullptr;
     auto fru = std::find_if(
@@ -508,7 +508,7 @@
         });
     if (fru == frus.end())
     {
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
     std::string name;
     auto findProductName = fruData->find("BOARD_PRODUCT_NAME");
@@ -548,7 +548,7 @@
     resp.body.deviceIDLen = name.size();
     name.copy(resp.body.deviceID, name.size());
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi_ret_t ipmiStorageReserveSDR(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
@@ -560,7 +560,7 @@
     if (*dataLen)
     {
         *dataLen = 0;
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
     *dataLen = 0; // default to 0 in case of an error
     sdrReservationID++;
@@ -573,7 +573,7 @@
     resp[0] = sdrReservationID & 0xFF;
     resp[1] = sdrReservationID >> 8;
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 ipmi_ret_t ipmiStorageGetSDR(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
@@ -585,7 +585,7 @@
     if (*dataLen != 6)
     {
         *dataLen = 0;
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
     auto requestedSize = *dataLen;
     *dataLen = 0; // default to 0 in case of an error
@@ -598,17 +598,17 @@
     if ((sdrReservationID == 0 || req->reservationID != sdrReservationID) &&
         req->offset)
     {
-        return IPMI_CC_INVALID_RESERVATION_ID;
+        return ipmi::ccInvalidReservationId;
     }
 
     if (!getSensorSubtree(sensorTree) && sensorTree.empty())
     {
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
 
     size_t fruCount = 0;
     ipmi_ret_t ret = ipmi::storage::getFruSdrCount(fruCount);
-    if (ret != IPMI_CC_OK)
+    if (ret != ipmi::ccSuccess)
     {
         return ret;
     }
@@ -620,7 +620,7 @@
     }
     if (req->recordID > lastRecord)
     {
-        return IPMI_CC_INVALID_FIELD_REQUEST;
+        return ipmi::ccInvalidFieldRequest;
     }
 
     uint16_t nextRecord = lastRecord >= static_cast<size_t>(req->recordID + 1)
@@ -639,15 +639,15 @@
         size_t fruIndex = req->recordID - sensorTree.size();
         if (fruIndex >= fruCount)
         {
-            return IPMI_CC_INVALID_FIELD_REQUEST;
+            return ipmi::ccInvalidFieldRequest;
         }
         get_sdr::SensorDataFruRecord data;
         if (req->offset > sizeof(data))
         {
-            return IPMI_CC_INVALID_FIELD_REQUEST;
+            return ipmi::ccInvalidFieldRequest;
         }
         ret = ipmi::storage::getFruSdrs(fruIndex, data);
-        if (ret != IPMI_CC_OK)
+        if (ret != ipmi::ccSuccess)
         {
             return ret;
         }
@@ -660,7 +660,7 @@
         *dataLen = req->bytesToRead + 2; // next record
         std::memcpy(&resp->record_data, (char*)&data + req->offset,
                     req->bytesToRead);
-        return IPMI_CC_OK;
+        return ipmi::ccSuccess;
     }
 
     std::string connection;
@@ -672,7 +672,7 @@
         {
             if (!sensor.second.size())
             {
-                return IPMI_CC_RESPONSE_ERROR;
+                return ipmi::ccResponseError;
             }
             connection = sensor.second.begin()->first;
             path = sensor.first;
@@ -683,7 +683,7 @@
     SensorMap sensorMap;
     if (!getSensorMap(connection, path, sensorMap))
     {
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
     uint8_t sensornumber = (req->recordID & 0xFF);
     get_sdr::SensorDataFullRecord record = {};
@@ -716,7 +716,7 @@
     auto sensorObject = sensorMap.find("xyz.openbmc_project.Sensor.Value");
     if (sensorObject == sensorMap.end())
     {
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
 
     auto maxObject = sensorObject->second.find("MaxValue");
@@ -741,7 +741,7 @@
 
     if (!getSensorAttributes(max, min, mValue, rExp, bValue, bExp, bSigned))
     {
-        return IPMI_CC_RESPONSE_ERROR;
+        return ipmi::ccResponseError;
     }
 
     // apply M, B, and exponents, M and B are 10 bit values, exponents are 4
@@ -817,7 +817,7 @@
     std::memcpy(&resp->record_data, (char*)&record + req->offset,
                 req->bytesToRead);
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 static int getSensorConnectionByName(std::string& name, std::string& connection,
@@ -975,18 +975,18 @@
     if (*dataLen != 1)
     {
         *dataLen = 0;
-        return IPMI_CC_REQ_DATA_LEN_INVALID;
+        return ipmi::ccReqDataLenInvalid;
     }
     *dataLen = 0; // default to 0 in case of an error
 
     uint8_t reqDev = *(static_cast<uint8_t*>(request));
     if (reqDev == 0xFF)
     {
-        return IPMI_CC_INVALID_FIELD_REQUEST;
+        return ipmi::ccInvalidFieldRequest;
     }
     ipmi_ret_t status = replaceCacheFru(reqDev);
 
-    if (status != IPMI_CC_OK)
+    if (status != ipmi::ccSuccess)
     {
         return status;
     }
@@ -997,7 +997,7 @@
     respPtr->accessType = static_cast<uint8_t>(GetFRUAreaAccessType::byte);
 
     *dataLen = sizeof(GetFRUAreaResp);
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 void registerStorageFunctions()
diff --git a/src/transportcommands.cpp b/src/transportcommands.cpp
index d7f632b..77c55f6 100644
--- a/src/transportcommands.cpp
+++ b/src/transportcommands.cpp
@@ -17,8 +17,9 @@
 #include <ipmid/api.h>
 
 #include <commandutils.hpp>
+#include <ipmid/api-types.hpp>
 
-#define IPMI_CC_PARAMETER_NOT_SUPPORTED 0x80
+constexpr ipmi::Cc ccParameterNotSupported = 0x80;
 
 namespace ipmi
 {
@@ -62,7 +63,7 @@
      * with only one byte of data
      */
     if (param & 0x80)
-        return IPMI_CC_OK;
+        return ipmi::ccSuccess;
 
     switch (paramSel)
     {
@@ -98,11 +99,11 @@
             break;
         default:
             *data_len = 0;
-            return IPMI_CC_PARAMETER_NOT_SUPPORTED;
+            return ccParameterNotSupported;
             break;
     }
 
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 void registerTransportFunctions()
diff --git a/src/usb-dbg.cpp b/src/usb-dbg.cpp
index d125016..70b69a0 100644
--- a/src/usb-dbg.cpp
+++ b/src/usb-dbg.cpp
@@ -1004,11 +1004,11 @@
                                    uint8_t* buffer)
 {
     if (cur_panel > panelNum || cur_panel < std::to_underlying(panel::MAIN))
-        return IPMI_CC_PARM_OUT_OF_RANGE;
+        return ipmi::ccParmOutOfRange;
 
     // No more item; End of item list
     if (item > panels[cur_panel].item_num)
-        return IPMI_CC_PARM_OUT_OF_RANGE;
+        return ipmi::ccParmOutOfRange;
 
     switch (operation)
     {
@@ -1023,7 +1023,7 @@
             item = 0;
             break;
         default:
-            return IPMI_CC_PARM_OUT_OF_RANGE;
+            return ipmi::ccParmOutOfRange;
     }
 
     buffer[0] = cur_panel;
@@ -1036,7 +1036,7 @@
                     buffer[2]);
     }
     *count = buffer[2] + 3;
-    return IPMI_CC_OK;
+    return ipmi::ccSuccess;
 }
 
 } // end of namespace ipmi