this does not make sense

linux/payload/PlocMpsocHandler.cpp

@@ -8,8 +8,8 @@
 #include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/globalfunctions/CRC.h"
 
-PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid,
-                                   CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper,
+PlocMpsocHandler::PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid,
+                                   CookieIF* comCookie, PlocMpsocSpecialComHelper* plocMPSoCHelper,
                                    Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
     : DeviceHandlerBase(objectId, uartComIFid, comCookie),
       hkReport(this),
@@ -27,9 +27,9 @@ PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid
   spParams.buf = commandBuffer;
 }
 
-PlocMPSoCHandler::~PlocMPSoCHandler() {}
+PlocMpsocHandler::~PlocMpsocHandler() {}
 
-ReturnValue_t PlocMPSoCHandler::initialize() {
+ReturnValue_t PlocMpsocHandler::initialize() {
   ReturnValue_t result = returnvalue::OK;
   result = DeviceHandlerBase::initialize();
   if (result != returnvalue::OK) {
@@ -54,8 +54,8 @@ ReturnValue_t PlocMPSoCHandler::initialize() {
     return result;
   }
   result = manager->subscribeToEventRange(
-      eventQueue->getId(), event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_FAILED),
-      event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
+      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_FAILED),
+      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
   if (result != returnvalue::OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "PlocMPSoCHandler::initialize: Failed to subscribe to events from "
@@ -78,7 +78,7 @@ ReturnValue_t PlocMPSoCHandler::initialize() {
   return result;
 }
 
-void PlocMPSoCHandler::performOperationHook() {
+void PlocMpsocHandler::performOperationHook() {
   if (commandIsPending and cmdCountdown.hasTimedOut()) {
     commandIsPending = false;
     // TODO: Better returnvalue?
@@ -107,7 +107,7 @@ void PlocMPSoCHandler::performOperationHook() {
   }
 }
 
-ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+ReturnValue_t PlocMpsocHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                               const uint8_t* data, size_t size) {
   ReturnValue_t result = returnvalue::OK;
   switch (actionId) {
@@ -176,7 +176,7 @@ ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueI
   return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
 }
 
-void PlocMPSoCHandler::doStartUp() {
+void PlocMpsocHandler::doStartUp() {
   if (startupState == StartupState::IDLE) {
     startupState = StartupState::HW_INIT;
   }
@@ -220,7 +220,7 @@ void PlocMPSoCHandler::doStartUp() {
   }
 }
 
-void PlocMPSoCHandler::doShutDown() {
+void PlocMpsocHandler::doShutDown() {
 #ifdef XIPHOS_Q7S
 #if not OBSW_MPSOC_JTAG_BOOT == 1
   switch (powerState) {
@@ -248,7 +248,7 @@ void PlocMPSoCHandler::doShutDown() {
   startupState = StartupState::IDLE;
 }
 
-ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+ReturnValue_t PlocMpsocHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   if (not commandIsPending and not plocMPSoCHelperExecuting) {
     *id = mpsoc::TC_GET_HK_REPORT;
     commandIsPending = true;
@@ -258,11 +258,11 @@ ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id)
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+ReturnValue_t PlocMpsocHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+ReturnValue_t PlocMpsocHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                         const uint8_t* commandData,
                                                         size_t commandDataLen) {
   spParams.buf = commandBuffer;
@@ -353,7 +353,7 @@ ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t device
   return result;
 }
 
-void PlocMPSoCHandler::fillCommandAndReplyMap() {
+void PlocMpsocHandler::fillCommandAndReplyMap() {
   this->insertInCommandMap(mpsoc::TC_MEM_WRITE);
   this->insertInCommandMap(mpsoc::TC_MEM_READ);
   this->insertInCommandMap(mpsoc::TC_FLASHDELETE);
@@ -383,7 +383,7 @@ void PlocMPSoCHandler::fillCommandAndReplyMap() {
   this->insertInReplyMap(mpsoc::TM_FLASH_DIRECTORY_CONTENT, 2, nullptr, mpsoc::SP_MAX_SIZE);
 }
 
-ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize,
+ReturnValue_t PlocMpsocHandler::scanForReply(const uint8_t* start, size_t remainingSize,
                                              DeviceCommandId_t* foundId, size_t* foundLen) {
   ReturnValue_t result = returnvalue::OK;
 
@@ -454,7 +454,7 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
   return result;
 }
 
-ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
+ReturnValue_t PlocMpsocHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
   ReturnValue_t result = returnvalue::OK;
 
   switch (id) {
@@ -499,14 +499,14 @@ ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const
   return result;
 }
 
-void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {
+void PlocMpsocHandler::setNormalDatapoolEntriesInvalid() {
   PoolReadGuard pg(&hkReport);
   hkReport.setValidity(false, true);
 }
 
-uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; }
+uint32_t PlocMpsocHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; }
 
-ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+ReturnValue_t PlocMpsocHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                         LocalDataPoolManager& poolManager) {
   localDataPoolMap.emplace(mpsoc::poolid::STATUS, &peStatus);
   localDataPoolMap.emplace(mpsoc::poolid::MODE, &peMode);
@@ -547,7 +547,7 @@ ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& loc
   return returnvalue::OK;
 }
 
-void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
+void PlocMpsocHandler::handleEvent(EventMessage* eventMessage) {
   object_id_t objectId = eventMessage->getReporter();
   switch (objectId) {
     case objects::PLOC_MPSOC_HELPER: {
@@ -560,7 +560,7 @@ void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
   }
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcMemWrite(const uint8_t* commandData,
                                                   size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcMemWrite tcMemWrite(spParams, sequenceCount);
@@ -572,7 +572,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
                                                  size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcMemRead tcMemRead(spParams, sequenceCount);
@@ -585,7 +585,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData,
                                                      size_t commandDataLen) {
   if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
     return MPSoCReturnValuesIF::NAME_TOO_LONG;
@@ -601,7 +601,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcReplayStart(const uint8_t* commandData,
                                                      size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcReplayStart tcReplayStart(spParams, sequenceCount);
@@ -613,7 +613,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
+ReturnValue_t PlocMpsocHandler::prepareTcReplayStop() {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcReplayStop tcReplayStop(spParams, sequenceCount);
   result = tcReplayStop.buildPacket();
@@ -624,7 +624,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
                                                        size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, sequenceCount);
@@ -636,7 +636,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandDat
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
+ReturnValue_t PlocMpsocHandler::prepareTcDownlinkPwrOff() {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, sequenceCount);
   result = tcDownlinkPwrOff.buildPacket();
@@ -647,7 +647,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcGetHkReport() {
+ReturnValue_t PlocMpsocHandler::prepareTcGetHkReport() {
   mpsoc::TcGetHkReport tcGetHkReport(spParams, sequenceCount);
   ReturnValue_t result = tcGetHkReport.buildPacket();
   if (result != returnvalue::OK) {
@@ -657,7 +657,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcGetHkReport() {
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
                                                              size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, sequenceCount);
@@ -669,7 +669,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* comm
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
+ReturnValue_t PlocMpsocHandler::prepareTcModeReplay() {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcModeReplay tcModeReplay(spParams, sequenceCount);
   result = tcModeReplay.buildPacket();
@@ -680,7 +680,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
+ReturnValue_t PlocMpsocHandler::prepareTcModeIdle() {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcModeIdle tcModeIdle(spParams, sequenceCount);
   result = tcModeIdle.buildPacket();
@@ -691,7 +691,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcCamCmdSend(const uint8_t* commandData,
                                                     size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcCamcmdSend tcCamCmdSend(spParams, sequenceCount);
@@ -704,7 +704,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData,
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcCamTakePic(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcCamTakePic(const uint8_t* commandData,
                                                     size_t commandDataLen) {
   mpsoc::TcCamTakePic tcCamTakePic(spParams, sequenceCount);
   ReturnValue_t result = tcCamTakePic.buildPacket(commandData, commandDataLen);
@@ -715,7 +715,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcCamTakePic(const uint8_t* commandData,
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcSimplexSendFile(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcSimplexSendFile(const uint8_t* commandData,
                                                          size_t commandDataLen) {
   mpsoc::TcSimplexSendFile tcSimplexSendFile(spParams, sequenceCount);
   ReturnValue_t result = tcSimplexSendFile.buildPacket(commandData, commandDataLen);
@@ -726,7 +726,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcSimplexSendFile(const uint8_t* commandD
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcGetDirContent(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcGetDirContent(const uint8_t* commandData,
                                                        size_t commandDataLen) {
   mpsoc::TcGetDirContent tcGetDirContent(spParams, sequenceCount);
   ReturnValue_t result = tcGetDirContent.buildPacket(commandData, commandDataLen);
@@ -737,7 +737,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcGetDirContent(const uint8_t* commandDat
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkDataModulate(const uint8_t* commandData,
+ReturnValue_t PlocMpsocHandler::prepareTcDownlinkDataModulate(const uint8_t* commandData,
                                                               size_t commandDataLen) {
   mpsoc::TcDownlinkDataModulate tcDownlinkDataModulate(spParams, sequenceCount);
   ReturnValue_t result = tcDownlinkDataModulate.buildPacket(commandData, commandDataLen);
@@ -748,7 +748,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkDataModulate(const uint8_t* com
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcModeSnapshot() {
+ReturnValue_t PlocMpsocHandler::prepareTcModeSnapshot() {
   mpsoc::TcModeSnapshot tcModeSnapshot(spParams, sequenceCount);
   ReturnValue_t result = tcModeSnapshot.buildPacket();
   if (result != returnvalue::OK) {
@@ -758,21 +758,21 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeSnapshot() {
   return returnvalue::OK;
 }
 
-void PlocMPSoCHandler::finishTcPrep(size_t packetLen) {
+void PlocMpsocHandler::finishTcPrep(size_t packetLen) {
   nextReplyId = mpsoc::ACK_REPORT;
   rawPacket = commandBuffer;
   rawPacketLen = packetLen;
   sequenceCount++;
 }
 
-ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
+ReturnValue_t PlocMpsocHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
   if (CRC::crc16ccitt(start, foundLen) != 0) {
     return MPSoCReturnValuesIF::CRC_FAILURE;
   }
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
+ReturnValue_t PlocMpsocHandler::handleAckReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
   result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT);
@@ -792,7 +792,7 @@ ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
     case mpsoc::apid::ACK_FAILURE: {
       sif::debug << "PlocMPSoCHandler::handleAckReport: Received Ack failure report" << std::endl;
       DeviceCommandId_t commandId = getPendingCommand();
-      uint16_t status = getStatus(data);
+      uint16_t status = mpsoc::getStatusFromRawData(data);
       sif::warning << "Verification report status: " << mpsoc::getStatusString(status) << std::endl;
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(ACK_FAILURE, commandId, status);
@@ -817,7 +817,7 @@ ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
   return result;
 }
 
-ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
+ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
   result = verifyPacket(data, mpsoc::SIZE_EXE_REPORT);
@@ -842,7 +842,7 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
       if (commandId == DeviceHandlerIF::NO_COMMAND_ID) {
         sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl;
       }
-      uint16_t status = getStatus(data);
+      uint16_t status = mpsoc::getStatusFromRawData(data);
       sif::warning << "Verification report status: " << mpsoc::getStatusString(status) << std::endl;
       triggerEvent(EXE_FAILURE, commandId, status);
       sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
@@ -860,7 +860,7 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
   return result;
 }
 
-ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
+ReturnValue_t PlocMpsocHandler::handleMemoryReadReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
   result = verifyPacket(data, tmMemReadReport.rememberRequestedSize);
   if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
@@ -876,7 +876,7 @@ ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
   return result;
 }
 
-ReturnValue_t PlocMPSoCHandler::handleGetHkReport(const uint8_t* data) {
+ReturnValue_t PlocMpsocHandler::handleGetHkReport(const uint8_t* data) {
   ReturnValue_t result = verifyPacket(data, foundPacketLen);
   if (result != returnvalue::OK) {
     return result;
@@ -1054,7 +1054,7 @@ ReturnValue_t PlocMPSoCHandler::handleGetHkReport(const uint8_t* data) {
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::handleCamCmdRpt(const uint8_t* data) {
+ReturnValue_t PlocMpsocHandler::handleCamCmdRpt(const uint8_t* data) {
   ReturnValue_t result = verifyPacket(data, foundPacketLen);
   if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleCamCmdRpt: CRC failure" << std::endl;
@@ -1074,7 +1074,7 @@ ReturnValue_t PlocMPSoCHandler::handleCamCmdRpt(const uint8_t* data) {
   return result;
 }
 
-ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
+ReturnValue_t PlocMpsocHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
                                                       uint8_t expectedReplies, bool useAlternateId,
                                                       DeviceCommandId_t alternateReplyID) {
   ReturnValue_t result = returnvalue::OK;
@@ -1190,7 +1190,7 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
   return returnvalue::OK;
 }
 
-void PlocMPSoCHandler::setNextReplyId() {
+void PlocMpsocHandler::setNextReplyId() {
   switch (getPendingCommand()) {
     case mpsoc::TC_MEM_READ:
       nextReplyId = mpsoc::TM_MEMORY_READ_REPORT;
@@ -1210,7 +1210,7 @@ void PlocMPSoCHandler::setNextReplyId() {
   }
 }
 
-size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
+size_t PlocMpsocHandler::getNextReplyLength(DeviceCommandId_t commandId) {
   size_t replyLen = 0;
 
   if (nextReplyId == mpsoc::NONE) {
@@ -1251,7 +1251,7 @@ size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
   return replyLen;
 }
 
-ReturnValue_t PlocMPSoCHandler::doSendReadHook() {
+ReturnValue_t PlocMpsocHandler::doSendReadHook() {
   // Prevent DHB from polling UART during commands executed by the mpsoc helper task
   if (plocMPSoCHelperExecuting) {
     return returnvalue::FAILED;
@@ -1259,11 +1259,11 @@ ReturnValue_t PlocMPSoCHandler::doSendReadHook() {
   return returnvalue::OK;
 }
 
-MessageQueueIF* PlocMPSoCHandler::getCommandQueuePtr() { return commandActionHelperQueue; }
+MessageQueueIF* PlocMpsocHandler::getCommandQueuePtr() { return commandActionHelperQueue; }
 
-void PlocMPSoCHandler::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) { return; }
+void PlocMpsocHandler::stepSuccessfulReceived(ActionId_t actionId, uint8_t step) { return; }
 
-void PlocMPSoCHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
+void PlocMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
                                           ReturnValue_t returnCode) {
   switch (actionId) {
     case supv::START_MPSOC: {
@@ -1286,11 +1286,11 @@ void PlocMPSoCHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
   }
 }
 
-void PlocMPSoCHandler::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
+void PlocMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
   return;
 }
 
-void PlocMPSoCHandler::completionSuccessfulReceived(ActionId_t actionId) {
+void PlocMpsocHandler::completionSuccessfulReceived(ActionId_t actionId) {
   if (actionId != supv::EXE_REPORT) {
     sif::debug << "PlocMPSoCHandler::completionSuccessfulReceived: Did not expect this action "
                << "ID" << std::endl;
@@ -1311,11 +1311,11 @@ void PlocMPSoCHandler::completionSuccessfulReceived(ActionId_t actionId) {
   }
 }
 
-void PlocMPSoCHandler::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
+void PlocMpsocHandler::completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) {
   handleActionCommandFailure(actionId);
 }
 
-void PlocMPSoCHandler::handleDeviceTm(const uint8_t* data, size_t dataSize,
+void PlocMpsocHandler::handleDeviceTm(const uint8_t* data, size_t dataSize,
                                       DeviceCommandId_t replyId) {
   ReturnValue_t result = returnvalue::OK;
 
@@ -1341,7 +1341,7 @@ void PlocMPSoCHandler::handleDeviceTm(const uint8_t* data, size_t dataSize,
   }
 }
 
-void PlocMPSoCHandler::disableAllReplies() {
+void PlocMpsocHandler::disableAllReplies() {
   using namespace mpsoc;
   DeviceReplyMap::iterator iter;
 
@@ -1404,7 +1404,7 @@ void PlocMPSoCHandler::disableAllReplies() {
   nextReplyId = mpsoc::NONE;
 }
 
-void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
+void PlocMpsocHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
   if (iter == deviceReplyMap.end()) {
     sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply not in reply map" << std::endl;
@@ -1421,7 +1421,7 @@ void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_
   info->isExecuting = false;
 }
 
-void PlocMPSoCHandler::disableExeReportReply() {
+void PlocMpsocHandler::disableExeReportReply() {
   DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
   DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
@@ -1430,11 +1430,7 @@ void PlocMPSoCHandler::disableExeReportReply() {
   info->command->second.expectedReplies = 0;
 }
 
-uint16_t PlocMPSoCHandler::getStatus(const uint8_t* data) {
-  return (*(data + STATUS_OFFSET) << 8) | *(data + STATUS_OFFSET + 1);
-}
-
-void PlocMPSoCHandler::handleActionCommandFailure(ActionId_t actionId) {
+void PlocMpsocHandler::handleActionCommandFailure(ActionId_t actionId) {
   switch (actionId) {
     case supv::ACK_REPORT:
     case supv::EXE_REPORT:
@@ -1467,20 +1463,20 @@ void PlocMPSoCHandler::handleActionCommandFailure(ActionId_t actionId) {
   return;
 }
 
-LocalPoolDataSetBase* PlocMPSoCHandler::getDataSetHandle(sid_t sid) {
+LocalPoolDataSetBase* PlocMpsocHandler::getDataSetHandle(sid_t sid) {
   if (sid == hkReport.getSid()) {
     return &hkReport;
   }
   return nullptr;
 }
 
-bool PlocMPSoCHandler::dontCheckQueue() {
+bool PlocMpsocHandler::dontCheckQueue() {
   // The TC and TMs need to be handled strictly sequentially, so while a command is pending,
   // more specifically while replies are still expected, do not check the queue.s
   return commandIsPending;
 }
 
-void PlocMPSoCHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
+void PlocMpsocHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
   commandIsPending = false;
   auto commandIter = deviceCommandMap.find(getPendingCommand());
   if (commandIter != deviceCommandMap.end()) {