diff --git a/include/oemcommands.hpp b/include/oemcommands.hpp
index ed4b57a..e988d03 100644
--- a/include/oemcommands.hpp
+++ b/include/oemcommands.hpp
@@ -16,16 +16,20 @@
 
 #pragma once
 
-enum IPMINetfnIntelOEMGeneralCmd
+enum class IPMINetfnIntelOEMGeneralCmd
 {
     cmdSetBIOSID = 0x26,
     cmdGetOEMDeviceInfo = 0x27,
-    cmdGetAICSlotFRUIDRecords = 0x31,
+    cmdGetAICSlotFRUIDSlotPosRecords = 0x31,
     cmdSetSystemGUID = 0x41,
+    cmdSetPowerRestoreDelay = 0x54,
+    cmdGetPowerRestoreDelay = 0x55,
     cmdGetChassisIdentifier = 0x92,
+    cmdGetProcessorErrConfig = 0x9A,
+    cmdSetProcessorErrConfig = 0x9B,
 };
 
-enum IPMIIntelOEMReturnCodes
+enum class IPMIIntelOEMReturnCodes
 {
     ipmiCCPayloadActive = 0x80,
     ipmiCCInvalidPCIESlotID = 0x80,
@@ -51,7 +55,7 @@
 
 };
 
-enum IPMIReturnCodeExt
+enum class IPMIReturnCodeExt
 {
     ipmiCCInvalidLUN = 0xC2,
     ipmiCCTimeout = 0xC3,
@@ -64,17 +68,28 @@
     ipmiCCParamterNotSupportInPresentState = 0xD5,
 };
 
-constexpr unsigned char netfunIntelAppOEM = 0x3E;
-static constexpr ipmi_netfn_t netfunIntcOEMGeneral =
+constexpr const uint8_t netfunIntelAppOEM = 0x3E;
+static constexpr ipmi_netfn_t netfnIntcOEMGeneral =
     NETFUN_NONE; // Netfun_none. In our platform, we use it as "intel oem
                  // general". The code is 0x30
-static constexpr unsigned char maxBiosIdLength = 0xFF;
-static constexpr char* biosObjPath = (char*)"/xyz/openbmc_project/bios";
-static constexpr char* biosIntf =
-    (char*)"xyz.openbmc_project.Inventory.Item.Bios";
-static constexpr char* biosProp = (char*)"BiosId";
+static constexpr const uint8_t maxBIOSIDLength = 0xFF;
+static constexpr const uint8_t maxCPUNum = 4;
+static constexpr const char* biosObjPath = "/xyz/openbmc_project/bios";
+static constexpr const char* biosIntf =
+    "xyz.openbmc_project.Inventory.Item.Bios";
+static constexpr const char* biosProp = "BiosId";
 
-enum IPMINetfnIntelOEMAppCmd
+static constexpr const char* powerRestoreDelayObjPath =
+    "/xyz/openbmc_project/control/power_restore_delay";
+static constexpr const char* powerRestoreDelayIntf =
+    "xyz.openbmc_project.Control.Power.RestoreDelay";
+static constexpr const char* powerRestoreDelayProp = "PowerRestoreDelay";
+static constexpr const char* processorErrConfigObjPath =
+    "/xyz/openbmc_project/control/processor_error_config";
+static constexpr const char* processorErrConfigIntf =
+    "xyz.openbmc_project.Control.Processor.ErrConfig";
+
+enum class IPMINetfnIntelOEMAppCmd
 {
     mdrStatus = 0x20,
     mdrComplete = 0x21,
@@ -96,32 +111,15 @@
     mdr2SendDataBlock = 0x3d,
 };
 
-typedef enum
+enum class OEMDevEntityType
 {
     biosId,
     devVer,
     sdrVer,
-} OEMDevEntityType;
+};
 
-typedef union
-{
-    typedef struct
-    {
-        uint8_t bBrdSlotNum : 3;  // Bits 2:0
-        uint8_t riserSlotNum : 3; // Bits 5:3
-        uint8_t protocol : 1;     // Bit 6, FRU type
-        uint8_t reserved : 1;     // Bit 7
-    } bits;
-    uint8_t byte;
-} __attribute__((packed)) AICFruRec;
-
-typedef struct
-{
-    AICFruRec u8SlotPosition;
-    uint8_t u8FruID;
-} __attribute__((packed)) FRUSlotPosRecord;
-
-typedef struct
+#pragma pack(push, 1)
+struct GUIDData
 {
     uint8_t node1;
     uint8_t node2;
@@ -139,23 +137,76 @@
     uint8_t timeLow2;
     uint8_t timeLow3;
     uint8_t timeLow4;
-} __attribute__((packed)) GUIDData;
+};
 
-typedef struct
+struct DeviceInfo
 {
-    uint8_t biosIdLength;
-    uint8_t biosId[maxBiosIdLength];
-} __attribute__((packed)) DeviceInfo;
+    uint8_t biosIDLength;
+    uint8_t biosId[maxBIOSIDLength];
+};
 
-typedef struct
+struct SetPowerRestoreDelayReq
+{
+    uint8_t byteMSB;
+    uint8_t byteLSB;
+};
+
+struct GetPowerRestoreDelayRes
+{
+    uint8_t byteMSB;
+    uint8_t byteLSB;
+};
+
+struct GetOemDeviceInfoReq
 {
     uint8_t entityType;
     uint8_t countToRead;
     uint8_t offset;
-} __attribute__((packed)) GetOemDeviceInfoReq;
+};
 
-typedef struct
+struct GetOemDeviceInfoRes
 {
     uint8_t resDatalen;
-    uint8_t data[maxBiosIdLength];
-} __attribute__((packed)) GetOemDeviceInfoRes;
+    uint8_t data[maxBIOSIDLength];
+};
+
+struct SetProcessorErrConfigReq
+{
+    uint8_t resetCfg; // Reset Configuration
+                      //   [0]:   CATERR Reset Enabled
+                      //               0b: Disabled
+                      //               1b: Enabled
+                      //   [1]:   ERR2 Reset Enabled
+                      //               0b: Disabled
+                      //               1b: Enabled
+                      //   [7:2]: Reserved
+    uint8_t reserved; // Reserved
+    uint8_t
+        resetErrorOccurrenceCounts; // Reset Error Occurrence Counts
+                                    //[0]: Reset CPU Error Counts
+                                    //    0b: Keep CPU Error Counts
+                                    //    1b: Reset all CPU Error Counts to zero
+                                    //[7:1]: Reserved
+};
+
+struct GetProcessorErrConfigRes
+{
+    uint8_t resetCfg;             // Reset Configuration
+                                  //   [0]:   CATERR Reset Enabled
+                                  //               0b: Disabled
+                                  //               1b: Enabled
+                                  //   [1]:   ERR2 Reset Enabled
+                                  //               0b: Disabled
+                                  //               1b: Enabled
+                                  //   [7:2]: Reserved
+    uint8_t reserved;             // Reserved
+    char caterrStatus[maxCPUNum]; // for all CPUs including the non-legacy
+                                  // socket CPU CPU CATERR (Core Error)
+                                  // occurrence
+                                  //     [5:0]: Error Occurrence Count
+                                  //     [7:6]: CPU Status
+                                  //                 00b: Disabled
+                                  //                 01b: Enabled
+                                  //                 11b: Not Present
+};
+#pragma pack(pop)
\ No newline at end of file
diff --git a/src/oemcommands.cpp b/src/oemcommands.cpp
index 6b38579..781f6ba 100644
--- a/src/oemcommands.cpp
+++ b/src/oemcommands.cpp
@@ -14,24 +14,25 @@
 // limitations under the License.
 */
 
+#include "xyz/openbmc_project/Common/error.hpp"
+
 #include <host-ipmid/ipmid-api.h>
 
 #include <array>
+#include <commandutils.hpp>
 #include <iostream>
 #include <oemcommands.hpp>
 #include <phosphor-ipmi-host/utils.hpp>
 #include <phosphor-logging/log.hpp>
 #include <sdbusplus/bus.hpp>
-#include <sstream>
 #include <string>
 #include <vector>
-#include <xyz/openbmc_project/Common/error.hpp>
 
 namespace ipmi
 {
-static void register_netfn_firmware_functions() __attribute__((constructor));
-sdbusplus::bus::bus _dbus(ipmid_get_sd_bus_connection()); // from ipmid-api.h
-static constexpr size_t maxFruStringLength = 0x3F;
+static void registerOEMFunctions() __attribute__((constructor));
+sdbusplus::bus::bus dbus(ipmid_get_sd_bus_connection()); // from ipmid-api.h
+static constexpr size_t maxFRUStringLength = 0x3F;
 
 // return code: 0 successful
 int8_t getChassisSerialNumber(sdbusplus::bus::bus& bus, std::string& serial)
@@ -48,7 +49,7 @@
         return -1;
     }
 
-    for (auto& item : valueTree)
+    for (const auto& item : valueTree)
     {
         auto interface = item.second.find("xyz.openbmc_project.FruDevice");
         if (interface == item.second.end())
@@ -65,39 +66,34 @@
         try
         {
             Value variant = property->second;
-            std::string& result = variant.get<std::string>();
-            if (result.size() > maxFruStringLength)
+            std::string& result =
+                sdbusplus::message::variant_ns::get<std::string>(variant);
+            if (result.size() > maxFRUStringLength)
             {
                 phosphor::logging::log<phosphor::logging::level::ERR>(
                     "FRU serial number exceed maximum length");
-
                 return -1;
             }
-            else
-            {
-                serial = result;
-            }
+            serial = result;
             return 0;
         }
-        catch (mapbox::util::bad_variant_access& e)
+        catch (sdbusplus::message::variant_ns::bad_variant_access& e)
         {
-            std::cerr << e.what() << std::endl;
+            phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
             return -1;
         }
     }
     return -1;
 }
+
 ipmi_ret_t ipmiOEMWildcard(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                            ipmi_request_t request, ipmi_response_t response,
-                           ipmi_data_len_t data_len, ipmi_context_t context)
+                           ipmi_data_len_t dataLen, ipmi_context_t context)
 {
-    phosphor::logging::log<phosphor::logging::level::INFO>(
-        "Handling OEM WILDCARD", phosphor::logging::entry("NETFN=%x", netfn),
-        phosphor::logging::entry("CMD=%x", cmd));
-
+    printCommand(+netfn, +cmd);
     // Status code.
     ipmi_ret_t rc = IPMI_CC_INVALID;
-    *data_len = 0;
+    *dataLen = 0;
     return rc;
 }
 
@@ -105,46 +101,43 @@
 ipmi_ret_t ipmiOEMGetChassisIdentifier(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                                        ipmi_request_t request,
                                        ipmi_response_t response,
-                                       ipmi_data_len_t data_len,
+                                       ipmi_data_len_t dataLen,
                                        ipmi_context_t context)
 {
     std::string serial;
-    if (*data_len != 0) // invalid request if there are extra parameters
+    if (*dataLen != 0) // invalid request if there are extra parameters
     {
+        *dataLen = 0;
         return IPMI_CC_REQ_DATA_LEN_INVALID;
     }
-    if (getChassisSerialNumber(_dbus, serial) == 0)
+    if (getChassisSerialNumber(dbus, serial) == 0)
     {
-        *data_len = serial.size(); // length will never exceed response length
-                                   // as it is checked in getChassisSerialNumber
+        *dataLen = serial.size(); // length will never exceed response length
+                                  // as it is checked in getChassisSerialNumber
         char* resp = static_cast<char*>(response);
-        serial.copy(resp, *data_len);
+        serial.copy(resp, *dataLen);
         return IPMI_CC_OK;
     }
-    else
-    {
-        *data_len = 0;
-        return IPMI_CC_RESPONSE_ERROR;
-    }
+    *dataLen = 0;
+    return IPMI_CC_RESPONSE_ERROR;
 }
 
 ipmi_ret_t ipmiOEMSetSystemGUID(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
                                 ipmi_request_t request,
                                 ipmi_response_t response,
-                                ipmi_data_len_t data_len,
-                                ipmi_context_t context)
+                                ipmi_data_len_t dataLen, ipmi_context_t context)
 {
     static constexpr size_t safeBufferLength = 50;
     char buf[safeBufferLength] = {0};
     GUIDData* Data = reinterpret_cast<GUIDData*>(request);
 
-    if (*data_len != sizeof(GUIDData)) // 16bytes
+    if (*dataLen != sizeof(GUIDData)) // 16bytes
     {
-        *data_len = 0;
+        *dataLen = 0;
         return IPMI_CC_REQ_DATA_LEN_INVALID;
     }
 
-    *data_len = 0;
+    *dataLen = 0;
 
     snprintf(
         buf, safeBufferLength,
@@ -155,13 +148,11 @@
         Data->node3, Data->node2, Data->node1);
     // UUID is in RFC4122 format. Ex: 61a39523-78f2-11e5-9862-e6402cfc3223
     std::string guid = buf;
-    phosphor::logging::log<phosphor::logging::level::INFO>(
-        "Set System GUID", phosphor::logging::entry("GUID=%s", guid.c_str()));
 
     std::string objpath = "/xyz/openbmc_project/control/host0/systemGUID";
     std::string intf = "xyz.openbmc_project.Common.UUID";
-    std::string service = getService(_dbus, intf, objpath);
-    setDbusProperty(_dbus, service, objpath, intf, "UUID", guid);
+    std::string service = getService(dbus, intf, objpath);
+    setDbusProperty(dbus, service, objpath, intf, "UUID", guid);
     return IPMI_CC_OK;
 }
 
@@ -171,22 +162,18 @@
 {
     DeviceInfo* data = reinterpret_cast<DeviceInfo*>(request);
 
-    if ((*dataLen < 2) || (*dataLen != (1 + data->biosIdLength)))
+    if ((*dataLen < 2) || (*dataLen != (1 + data->biosIDLength)))
     {
-        phosphor::logging::log<phosphor::logging::level::ERR>(
-            "Invalid parameter", phosphor::logging::entry("LEN=%d", *dataLen),
-            phosphor::logging::entry("BIOSIDLEN=%d", data->biosIdLength));
-
         *dataLen = 0;
         return IPMI_CC_REQ_DATA_LEN_INVALID;
     }
-    std::string idString((char*)data->biosId, data->biosIdLength);
+    std::string idString((char*)data->biosId, data->biosIDLength);
 
-    std::string service = getService(_dbus, biosIntf, biosObjPath);
-    setDbusProperty(_dbus, service, biosObjPath, biosIntf, biosProp, idString);
+    std::string service = getService(dbus, biosIntf, biosObjPath);
+    setDbusProperty(dbus, service, biosObjPath, biosIntf, biosProp, idString);
     uint8_t* bytesWritten = static_cast<uint8_t*>(response);
     *bytesWritten =
-        data->biosIdLength; // how many bytes are written into storage
+        data->biosIDLength; // how many bytes are written into storage
     *dataLen = 1;
     return IPMI_CC_OK;
 }
@@ -201,71 +188,55 @@
 
     if (*dataLen == 0)
     {
-        phosphor::logging::log<phosphor::logging::level::ERR>(
-            "Paramter length should be at least one byte");
+        *dataLen = 0;
         return IPMI_CC_REQ_DATA_LEN_INVALID;
     }
 
     size_t reqDataLen = *dataLen;
     *dataLen = 0;
-    if (req->entityType > OEMDevEntityType::sdrVer)
+    if (req->entityType > static_cast<uint8_t>(OEMDevEntityType::sdrVer))
     {
-        phosphor::logging::log<phosphor::logging::level::ERR>(
-            "Out of range",
-            phosphor::logging::entry("TYPE=%x", req->entityType));
-
         return IPMI_CC_INVALID_FIELD_REQUEST;
     }
 
     // handle OEM command items
-    switch (req->entityType)
+    switch (OEMDevEntityType(req->entityType))
     {
         case OEMDevEntityType::biosId:
         {
             if (sizeof(GetOemDeviceInfoReq) != reqDataLen)
             {
-                phosphor::logging::log<phosphor::logging::level::ERR>(
-                    "Data length does not match request",
-                    phosphor::logging::entry("REQLEN=%d", reqDataLen),
-                    phosphor::logging::entry("LEN=%d",
-                                             sizeof(GetOemDeviceInfoReq)));
                 return IPMI_CC_REQ_DATA_LEN_INVALID;
             }
 
-            std::string service = getService(_dbus, biosIntf, biosObjPath);
+            std::string service = getService(dbus, biosIntf, biosObjPath);
             try
             {
-                Value variant = getDbusProperty(_dbus, service, biosObjPath,
+                Value variant = getDbusProperty(dbus, service, biosObjPath,
                                                 biosIntf, biosProp);
-                std::string& idString = variant.get<std::string>();
+                std::string& idString =
+                    sdbusplus::message::variant_ns::get<std::string>(variant);
                 if (req->offset >= idString.size())
                 {
-                    phosphor::logging::log<phosphor::logging::level::ERR>(
-                        "offset exceed range",
-                        phosphor::logging::entry("OFFSET=%d", req->offset),
-                        phosphor::logging::entry("IDLEN=%d", idString.size()));
                     return IPMI_CC_PARM_OUT_OF_RANGE;
                 }
+                size_t length = 0;
+                if (req->countToRead > (idString.size() - req->offset))
+                {
+                    length = idString.size() - req->offset;
+                }
                 else
                 {
-                    size_t length = 0;
-                    if (req->countToRead > (idString.size() - req->offset))
-                    {
-                        length = idString.size() - req->offset;
-                    }
-                    else
-                    {
-                        length = req->countToRead;
-                    }
-                    std::copy(idString.begin() + req->offset, idString.end(),
-                              res->data);
-                    res->resDatalen = length;
-                    *dataLen = res->resDatalen + 1;
+                    length = req->countToRead;
                 }
+                std::copy(idString.begin() + req->offset, idString.end(),
+                          res->data);
+                res->resDatalen = length;
+                *dataLen = res->resDatalen + 1;
             }
-            catch (mapbox::util::bad_variant_access& e)
+            catch (sdbusplus::message::variant_ns::bad_variant_access& e)
             {
-                std::cerr << e.what() << std::endl;
+                phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
                 return IPMI_CC_UNSPECIFIED_ERROR;
             }
         }
@@ -287,8 +258,7 @@
 {
     if (*dataLen != 0)
     {
-        phosphor::logging::log<phosphor::logging::level::ERR>(
-            "This command should not have any paramter");
+        *dataLen = 0;
         return IPMI_CC_REQ_DATA_LEN_INVALID;
     }
 
@@ -301,35 +271,196 @@
     return IPMI_CC_OK;
 }
 
-void ipmi_register(ipmi_netfn_t netfn, ipmi_cmd_t cmd, ipmi_context_t context,
-                   ipmid_callback_t handler, ipmi_cmd_privilege_t priv)
+ipmi_ret_t ipmiOEMGetPowerRestoreDelay(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
+                                       ipmi_request_t request,
+                                       ipmi_response_t response,
+                                       ipmi_data_len_t dataLen,
+                                       ipmi_context_t context)
 {
-    std::ostringstream os;
-    os << "Registering NetFn:[0x" << std::hex << std::uppercase << netfn
-       << "], Cmd:[0x" << cmd << "]\n";
-    phosphor::logging::log<phosphor::logging::level::INFO>(os.str().c_str());
-    ipmi_register_callback(netfn, cmd, context, handler, priv);
+    GetPowerRestoreDelayRes* resp =
+        reinterpret_cast<GetPowerRestoreDelayRes*>(response);
+
+    if (*dataLen != 0)
+    {
+        *dataLen = 0;
+        return IPMI_CC_REQ_DATA_LEN_INVALID;
+    }
+
+    std::string service =
+        getService(dbus, powerRestoreDelayIntf, powerRestoreDelayObjPath);
+    Value variant =
+        getDbusProperty(dbus, service, powerRestoreDelayObjPath,
+                        powerRestoreDelayIntf, powerRestoreDelayProp);
+
+    uint16_t delay = sdbusplus::message::variant_ns::get<uint16_t>(variant);
+    resp->byteLSB = delay;
+    resp->byteMSB = delay >> 8;
+
+    *dataLen = sizeof(GetPowerRestoreDelayRes);
+
+    return IPMI_CC_OK;
 }
 
-static void register_netfn_firmware_functions(void)
+ipmi_ret_t ipmiOEMSetPowerRestoreDelay(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
+                                       ipmi_request_t request,
+                                       ipmi_response_t response,
+                                       ipmi_data_len_t dataLen,
+                                       ipmi_context_t context)
+{
+    SetPowerRestoreDelayReq* data =
+        reinterpret_cast<SetPowerRestoreDelayReq*>(request);
+    uint16_t delay = 0;
+
+    if (*dataLen != sizeof(SetPowerRestoreDelayReq))
+    {
+        *dataLen = 0;
+        return IPMI_CC_REQ_DATA_LEN_INVALID;
+    }
+    delay = data->byteMSB;
+    delay = (delay << 8) | data->byteLSB;
+    std::string service =
+        getService(dbus, powerRestoreDelayIntf, powerRestoreDelayObjPath);
+    setDbusProperty(dbus, service, powerRestoreDelayObjPath,
+                    powerRestoreDelayIntf, powerRestoreDelayProp, delay);
+    *dataLen = 0;
+
+    return IPMI_CC_OK;
+}
+
+ipmi_ret_t ipmiOEMGetProcessorErrConfig(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
+                                        ipmi_request_t request,
+                                        ipmi_response_t response,
+                                        ipmi_data_len_t dataLen,
+                                        ipmi_context_t context)
+{
+    GetProcessorErrConfigRes* resp =
+        reinterpret_cast<GetProcessorErrConfigRes*>(response);
+
+    if (*dataLen != 0)
+    {
+        *dataLen = 0;
+        return IPMI_CC_REQ_DATA_LEN_INVALID;
+    }
+
+    std::string service =
+        getService(dbus, processorErrConfigIntf, processorErrConfigObjPath);
+    Value variant = getDbusProperty(dbus, service, processorErrConfigObjPath,
+                                    processorErrConfigIntf, "ResetCfg");
+    resp->resetCfg = sdbusplus::message::variant_ns::get<uint8_t>(variant);
+
+    std::vector<uint8_t> caterrStatus;
+
+    auto method =
+        dbus.new_method_call(service.c_str(), processorErrConfigObjPath,
+                             "org.freedesktop.DBus.Properties", "Get");
+
+    method.append(processorErrConfigIntf, "CATERRStatus");
+
+    try
+    {
+        auto reply = dbus.call(method);
+        reply.read(caterrStatus);
+    }
+    catch (sdbusplus::exception_t&)
+    {
+        phosphor::logging::log<phosphor::logging::level::DEBUG>(
+            "ipmiOEMGetProcessorErrConfig: error on dbus",
+            phosphor::logging::entry("PRORPERTY=CATERRStatus"),
+            phosphor::logging::entry("PATH=%s", processorErrConfigObjPath),
+            phosphor::logging::entry("INTERFACE=%s", processorErrConfigIntf));
+        return IPMI_CC_UNSPECIFIED_ERROR;
+    }
+
+    size_t len =
+        maxCPUNum <= caterrStatus.size() ? maxCPUNum : caterrStatus.size();
+    caterrStatus.resize(len);
+    std::copy(caterrStatus.begin(), caterrStatus.end(), resp->caterrStatus);
+    *dataLen = sizeof(GetProcessorErrConfigRes);
+
+    return IPMI_CC_OK;
+}
+
+ipmi_ret_t ipmiOEMSetProcessorErrConfig(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
+                                        ipmi_request_t request,
+                                        ipmi_response_t response,
+                                        ipmi_data_len_t dataLen,
+                                        ipmi_context_t context)
+{
+    SetProcessorErrConfigReq* req =
+        reinterpret_cast<SetProcessorErrConfigReq*>(request);
+
+    if (*dataLen != sizeof(SetProcessorErrConfigReq))
+    {
+        *dataLen = 0;
+        return IPMI_CC_REQ_DATA_LEN_INVALID;
+    }
+    std::string service =
+        getService(dbus, processorErrConfigIntf, processorErrConfigObjPath);
+    setDbusProperty(dbus, service, processorErrConfigObjPath,
+                    processorErrConfigIntf, "ResetCfg", req->resetCfg);
+
+    setDbusProperty(dbus, service, processorErrConfigObjPath,
+                    processorErrConfigIntf, "ResetErrorOccurrenceCounts",
+                    req->resetErrorOccurrenceCounts);
+    *dataLen = 0;
+
+    return IPMI_CC_OK;
+}
+
+static void registerOEMFunctions(void)
 {
     phosphor::logging::log<phosphor::logging::level::INFO>(
         "Registering OEM commands");
-    ipmi_register(netfunIntcOEMGeneral, IPMI_CMD_WILDCARD, NULL,
-                  ipmiOEMWildcard,
-                  PRIVILEGE_USER); // wildcard default handler
-    ipmi_register(netfunIntcOEMGeneral, cmdGetChassisIdentifier, NULL,
-                  ipmiOEMGetChassisIdentifier,
-                  PRIVILEGE_USER); // get chassis identifier
-    ipmi_register(netfunIntcOEMGeneral, cmdSetSystemGUID, NULL,
-                  ipmiOEMSetSystemGUID,
-                  PRIVILEGE_ADMIN); // set system guid
-    ipmi_register(netfunIntcOEMGeneral, cmdSetBIOSID, NULL, ipmiOEMSetBIOSID,
-                  PRIVILEGE_ADMIN);
-    ipmi_register(netfunIntcOEMGeneral, cmdGetOEMDeviceInfo, NULL,
-                  ipmiOEMGetDeviceInfo, PRIVILEGE_USER);
-    ipmi_register(netfunIntcOEMGeneral, cmdGetAICSlotFRUIDRecords, NULL,
-                  ipmiOEMGetAICFRU, PRIVILEGE_USER);
+    ipmiPrintAndRegister(netfnIntcOEMGeneral, IPMI_CMD_WILDCARD, NULL,
+                         ipmiOEMWildcard,
+                         PRIVILEGE_USER); // wildcard default handler
+    ipmiPrintAndRegister(netfunIntelAppOEM, IPMI_CMD_WILDCARD, NULL,
+                         ipmiOEMWildcard,
+                         PRIVILEGE_USER); // wildcard default handler
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(
+            IPMINetfnIntelOEMGeneralCmd::cmdGetChassisIdentifier),
+        NULL, ipmiOEMGetChassisIdentifier,
+        PRIVILEGE_USER); // get chassis identifier
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(IPMINetfnIntelOEMGeneralCmd::cmdSetSystemGUID),
+        NULL, ipmiOEMSetSystemGUID,
+        PRIVILEGE_ADMIN); // set system guid
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(IPMINetfnIntelOEMGeneralCmd::cmdSetBIOSID),
+        NULL, ipmiOEMSetBIOSID, PRIVILEGE_ADMIN);
+    ipmiPrintAndRegister(netfnIntcOEMGeneral,
+                         static_cast<ipmi_cmd_t>(
+                             IPMINetfnIntelOEMGeneralCmd::cmdGetOEMDeviceInfo),
+                         NULL, ipmiOEMGetDeviceInfo, PRIVILEGE_USER);
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(
+            IPMINetfnIntelOEMGeneralCmd::cmdGetAICSlotFRUIDSlotPosRecords),
+        NULL, ipmiOEMGetAICFRU, PRIVILEGE_USER);
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(
+            IPMINetfnIntelOEMGeneralCmd::cmdSetPowerRestoreDelay),
+        NULL, ipmiOEMSetPowerRestoreDelay, PRIVILEGE_OPERATOR);
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(
+            IPMINetfnIntelOEMGeneralCmd::cmdGetPowerRestoreDelay),
+        NULL, ipmiOEMGetPowerRestoreDelay, PRIVILEGE_USER);
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(
+            IPMINetfnIntelOEMGeneralCmd::cmdGetProcessorErrConfig),
+        NULL, ipmiOEMGetProcessorErrConfig, PRIVILEGE_USER);
+    ipmiPrintAndRegister(
+        netfnIntcOEMGeneral,
+        static_cast<ipmi_cmd_t>(
+            IPMINetfnIntelOEMGeneralCmd::cmdSetProcessorErrConfig),
+        NULL, ipmiOEMSetProcessorErrConfig, PRIVILEGE_ADMIN);
     return;
 }