added new verify boot cmd

linux/payload/FreshMpsocHandler.cpp

@@ -9,6 +9,7 @@
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/serialize/SerializeAdapter.h"
 #include "linux/payload/MpsocCommunication.h"
 #include "linux/payload/plocMpsocHelpers.h"
 #include "linux/payload/plocSupvDefs.h"
@@ -54,21 +55,26 @@ void FreshMpsocHandler::performDeviceOperation(uint8_t opCode) {
 }
 
 void FreshMpsocHandler::performDefaultDeviceOperation() {
-  handleQueue();
-  if (transitionState == TransitionState::TO_ON) {
-    handleTransitionToOn();
-  } else if (transitionState == TransitionState::TO_OFF) {
-    handleTransitionToOff();
-  } else if (transitionState == TransitionState::SUBMODE) {
-    if (!activeCmdInfo.pending) {
-      commandSubmodeTransition();
+  if (transitionState != TransitionState::NONE) {
+    if (transitionState == TransitionState::TO_ON) {
+      handleTransitionToOn();
+    } else if (transitionState == TransitionState::TO_OFF) {
+      handleTransitionToOff();
+    } else if (transitionState == TransitionState::SUBMODE) {
+      if (!activeCmdInfo.pending) {
+        commandSubmodeTransition();
+      }
+    } else {
+      // This should never happen.
+      sif::error << "FreshMpsocHandler: Invalid transition mode: " << targetMode << std::endl;
+      targetMode = MODE_OFF;
+      targetSubmode = 0;
+      handleTransitionToOff();
+    }
+    if (modeHelper.isTimedOut()) {
+      // Set old mode and submode.
+      setMode(mode, submode);
     }
-  } else {
-    // This should never happen.
-    sif::error << "FreshMpsocHandler: Invalid transition mode: " << targetMode << std::endl;
-    targetMode = MODE_OFF;
-    targetSubmode = 0;
-    handleTransitionToOff();
   }
 
   if (mode == MODE_NORMAL and not activeCmdInfo.pending) {
@@ -219,6 +225,7 @@ ReturnValue_t FreshMpsocHandler::checkModeCommand(Mode_t mode, Submode_t submode
       return HasModesIF::INVALID_SUBMODE;
     }
   }
+  *msToReachTheMode = MPSOC_MODE_CMD_TIMEOUT_MS;
   return returnvalue::OK;
 }
 
@@ -305,11 +312,10 @@ void FreshMpsocHandler::startTransition(Mode_t newMode, Submode_t submode) {
   // We are already on and only a submode change is commanded.
   if ((mode == MODE_ON or mode == MODE_NORMAL) && (newMode == MODE_ON or newMode == MODE_NORMAL)) {
     transitionState = TransitionState::SUBMODE;
-  }
-  if (newMode == MODE_ON && ((mode == MODE_OFF) or (mode == MODE_UNDEFINED))) {
+  } else if ((newMode == MODE_ON or newMode == MODE_NORMAL) &&
+             ((mode == MODE_OFF) or (mode == MODE_UNDEFINED))) {
     transitionState = TransitionState::TO_ON;
-  }
-  if (newMode == MODE_OFF) {
+  } else if (newMode == MODE_OFF) {
     transitionState = TransitionState::TO_OFF;
   }
   targetMode = newMode;
@@ -321,14 +327,14 @@ ReturnValue_t FreshMpsocHandler::performDeviceOperationPreQueueHandling(uint8_t
 }
 
 void FreshMpsocHandler::commandSubmodeTransition() {
-  if (targetSubmode != mpsoc::Submode::IDLE_OR_NONE) {
-    if (targetSubmode == mpsoc::Submode::SNAPSHOT) {
-      commandTcModeSnapshot();
-    } else if (targetSubmode == mpsoc::Submode::REPLAY) {
-      commandTcModeReplay();
-    } else {
-      sif::error << "FreshMpsocHandler::handleTransitionToOn: Invalid submode" << std::endl;
-    }
+  if (targetSubmode == mpsoc::Submode::IDLE_OR_NONE) {
+    commandTcModeIdle();
+  } else if (targetSubmode == mpsoc::Submode::SNAPSHOT) {
+    commandTcModeSnapshot();
+  } else if (targetSubmode == mpsoc::Submode::REPLAY) {
+    commandTcModeReplay();
+  } else {
+    sif::error << "FreshMpsocHandler::handleTransitionToOn: Invalid submode" << std::endl;
   }
 }
 
@@ -452,71 +458,69 @@ ReturnValue_t FreshMpsocHandler::executeRegularCmd(ActionId_t actionId,
   ReturnValue_t result;
   switch (actionId) {
     case (mpsoc::TC_MEM_WRITE): {
-      result = prepareTcMemWrite(commandData, commandDataLen);
+      result = commandTcMemWrite(commandData, commandDataLen);
       break;
     }
+    case (mpsoc::TC_VERIFY_BOOT): {
+      uint8_t cmdData[6]{};
+      size_t serLen = 0;
+      uint16_t wordLen = 1;
+      SerializeAdapter::serialize(&mpsoc::DEADBEEF_ADDR, cmdData, &serLen, 4,
+                                  SerializeIF::Endianness::NETWORK);
+      SerializeAdapter::serialize(&wordLen, cmdData + 4, &serLen, 2,
+                                  SerializeIF::Endianness::NETWORK);
+      result = commandTcMemRead(commandData, commandDataLen);
+    }
     case (mpsoc::TC_MEM_READ): {
-      result = prepareTcMemRead(commandData, commandDataLen);
+      result = commandTcMemRead(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_FLASHDELETE): {
-      result = prepareTcFlashDelete(commandData, commandDataLen);
+      result = commandTcFlashDelete(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_REPLAY_START): {
-      result = prepareTcReplayStart(commandData, commandDataLen);
+      result = commandTcReplayStart(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_REPLAY_STOP): {
-      result = prepareTcReplayStop();
+      result = commandTcReplayStop();
       break;
     }
     case (mpsoc::TC_DOWNLINK_PWR_ON): {
-      result = prepareTcDownlinkPwrOn(commandData, commandDataLen);
+      result = commandTcDownlinkPwrOn(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_DOWNLINK_PWR_OFF): {
-      result = prepareTcDownlinkPwrOff();
+      result = commandTcDownlinkPwrOff();
       break;
     }
     case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): {
-      result = prepareTcReplayWriteSequence(commandData, commandDataLen);
+      result = commandTcReplayWriteSequence(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_GET_HK_REPORT): {
-      result = prepareTcGetHkReport();
+      result = commandTcGetHkReport();
       break;
     }
     case (mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT): {
-      result = prepareTcGetDirContent(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_MODE_REPLAY_LEGACY): {
-      result = commandTcModeReplay();
-      break;
-    }
-    case (mpsoc::TC_MODE_IDLE_LEGACY): {
-      result = commandTcModeIdle();
+      result = commandTcGetDirContent(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_CAM_CMD_SEND): {
-      result = prepareTcCamCmdSend(commandData, commandDataLen);
+      result = commandTcCamCmdSend(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_CAM_TAKE_PIC): {
-      result = prepareTcCamTakePic(commandData, commandDataLen);
+      result = commandTcCamTakePic(commandData, commandDataLen);
       break;
     }
-    case (mpsoc::TC_SIMPLEX_SEND_FILE): {
-      result = prepareTcSimplexSendFile(commandData, commandDataLen);
+    case (mpsoc::TC_SIMPLEX_STREAM_FILE): {
+      result = commandTcSimplexSendFile(commandData, commandDataLen);
       break;
     }
     case (mpsoc::TC_DOWNLINK_DATA_MODULATE): {
-      result = prepareTcDownlinkDataModulate(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_MODE_SNAPSHOT_LEGACY): {
-      result = commandTcModeSnapshot();
+      result = commandTcDownlinkDataModulate(commandData, commandDataLen);
       break;
     }
     default:
@@ -537,7 +541,7 @@ ReturnValue_t FreshMpsocHandler::executeRegularCmd(ActionId_t actionId,
   return result;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcMemWrite(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcMemWrite(const uint8_t* commandData,
                                                    size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcMemWrite tcMemWrite(spParams, commandSequenceCount);
@@ -545,11 +549,11 @@ ReturnValue_t FreshMpsocHandler::prepareTcMemWrite(const uint8_t* commandData,
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcMemWrite);
+  finishAndSendTc(mpsoc::TC_MEM_WRITE, tcMemWrite);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcMemRead(const uint8_t* commandData,
                                                   size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcMemRead tcMemRead(spParams, commandSequenceCount);
@@ -557,12 +561,12 @@ ReturnValue_t FreshMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcMemRead);
+  finishAndSendTc(mpsoc::TC_MEM_READ, tcMemRead);
   tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE;
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcFlashDelete(const uint8_t* commandData,
                                                       size_t commandDataLen) {
   if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
     return mpsoc::NAME_TOO_LONG;
@@ -574,11 +578,11 @@ ReturnValue_t FreshMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcFlashDelete);
+  finishAndSendTc(mpsoc::TC_FLASHDELETE, tcFlashDelete);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcReplayStart(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcReplayStart(const uint8_t* commandData,
                                                       size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcReplayStart tcReplayStart(spParams, commandSequenceCount);
@@ -586,17 +590,17 @@ ReturnValue_t FreshMpsocHandler::prepareTcReplayStart(const uint8_t* commandData
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcReplayStart);
+  finishAndSendTc(mpsoc::TC_REPLAY_START, tcReplayStart);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcReplayStop() {
+ReturnValue_t FreshMpsocHandler::commandTcReplayStop() {
   mpsoc::TcReplayStop tcReplayStop(spParams, commandSequenceCount);
-  finishAndSendTc(tcReplayStop);
+  finishAndSendTc(mpsoc::TC_REPLAY_STOP, tcReplayStop);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcDownlinkPwrOn(const uint8_t* commandData,
                                                         size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(spParams, commandSequenceCount);
@@ -604,107 +608,107 @@ ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOn(const uint8_t* commandDa
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcDownlinkPwrOn);
+  finishAndSendTc(mpsoc::TC_DOWNLINK_PWR_ON, tcDownlinkPwrOn);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcDownlinkPwrOff() {
+ReturnValue_t FreshMpsocHandler::commandTcDownlinkPwrOff() {
   mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(spParams, commandSequenceCount);
-  finishAndSendTc(tcDownlinkPwrOff);
+  finishAndSendTc(mpsoc::TC_DOWNLINK_PWR_OFF, tcDownlinkPwrOff);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcGetHkReport() {
+ReturnValue_t FreshMpsocHandler::commandTcGetHkReport() {
   mpsoc::TcGetHkReport tcGetHkReport(spParams, commandSequenceCount);
-  finishAndSendTc(tcGetHkReport);
+  finishAndSendTc(mpsoc::TC_GET_HK_REPORT, tcGetHkReport);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcReplayWriteSequence(const uint8_t* commandData,
                                                               size_t commandDataLen) {
   mpsoc::TcReplayWriteSeq tcReplayWriteSeq(spParams, commandSequenceCount);
   ReturnValue_t result = tcReplayWriteSeq.setPayload(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcReplayWriteSeq);
+  finishAndSendTc(mpsoc::TC_REPLAY_WRITE_SEQUENCE, tcReplayWriteSeq);
   return returnvalue::OK;
 }
 
 ReturnValue_t FreshMpsocHandler::commandTcModeReplay() {
   mpsoc::TcModeReplay tcModeReplay(spParams, commandSequenceCount);
-  finishAndSendTc(tcModeReplay);
+  finishAndSendTc(mpsoc::TC_MODE_REPLAY, tcModeReplay);
   return returnvalue::OK;
 }
 
 ReturnValue_t FreshMpsocHandler::commandTcModeIdle() {
   mpsoc::TcModeIdle tcModeIdle(spParams, commandSequenceCount);
-  finishAndSendTc(tcModeIdle);
+  finishAndSendTc(mpsoc::TC_MODE_IDLE, tcModeIdle);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcCamCmdSend(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcCamCmdSend(const uint8_t* commandData,
                                                      size_t commandDataLen) {
   mpsoc::TcCamcmdSend tcCamCmdSend(spParams, commandSequenceCount);
   ReturnValue_t result = tcCamCmdSend.setPayload(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcCamCmdSend);
+  finishAndSendTc(mpsoc::TC_CAM_CMD_SEND, tcCamCmdSend);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcCamTakePic(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcCamTakePic(const uint8_t* commandData,
                                                      size_t commandDataLen) {
   mpsoc::TcCamTakePic tcCamTakePic(spParams, commandSequenceCount);
   ReturnValue_t result = tcCamTakePic.setPayload(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcCamTakePic);
+  finishAndSendTc(mpsoc::TC_CAM_TAKE_PIC, tcCamTakePic);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcSimplexSendFile(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcSimplexSendFile(const uint8_t* commandData,
                                                           size_t commandDataLen) {
   mpsoc::TcSimplexSendFile tcSimplexSendFile(spParams, commandSequenceCount);
   ReturnValue_t result = tcSimplexSendFile.setPayload(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcSimplexSendFile);
+  finishAndSendTc(mpsoc::TC_SIMPLEX_STREAM_FILE, tcSimplexSendFile);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcGetDirContent(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcGetDirContent(const uint8_t* commandData,
                                                         size_t commandDataLen) {
   mpsoc::TcGetDirContent tcGetDirContent(spParams, commandSequenceCount);
   ReturnValue_t result = tcGetDirContent.setPayload(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcGetDirContent);
+  finishAndSendTc(mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT, tcGetDirContent);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::prepareTcDownlinkDataModulate(const uint8_t* commandData,
+ReturnValue_t FreshMpsocHandler::commandTcDownlinkDataModulate(const uint8_t* commandData,
                                                                size_t commandDataLen) {
   mpsoc::TcDownlinkDataModulate tcDownlinkDataModulate(spParams, commandSequenceCount);
   ReturnValue_t result = tcDownlinkDataModulate.setPayload(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
-  finishAndSendTc(tcDownlinkDataModulate);
+  finishAndSendTc(mpsoc::TC_DOWNLINK_DATA_MODULATE, tcDownlinkDataModulate);
   return returnvalue::OK;
 }
 
 ReturnValue_t FreshMpsocHandler::commandTcModeSnapshot() {
   mpsoc::TcModeSnapshot tcModeSnapshot(spParams, commandSequenceCount);
-  finishAndSendTc(tcModeSnapshot);
+  finishAndSendTc(mpsoc::TC_MODE_SNAPSHOT, tcModeSnapshot);
   return returnvalue::OK;
 }
 
-ReturnValue_t FreshMpsocHandler::finishAndSendTc(mpsoc::TcBase& tcBase) {
+ReturnValue_t FreshMpsocHandler::finishAndSendTc(DeviceCommandId_t cmdId, mpsoc::TcBase& tcBase) {
   ReturnValue_t result = tcBase.finishPacket();
   if (result != returnvalue::OK) {
     return result;
@@ -718,6 +722,9 @@ ReturnValue_t FreshMpsocHandler::finishAndSendTc(mpsoc::TcBase& tcBase) {
                << tcBase.getSeqCount() << std::endl;
   }
   activeCmdInfo.cmdCountdown.resetTimer();
+  activeCmdInfo.pending = true;
+  activeCmdInfo.pendingCmd = cmdId;
+  activeCmdInfo.pendingCmdMpsocApid = tcBase.getApid();
   return comInterface.send(tcBase.getFullPacket(), tcBase.getFullPacketLen());
 }
 
@@ -745,7 +752,7 @@ void FreshMpsocHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
     }
     transitionState = TransitionState::NONE;
   }
-  if (activeCmdInfo.commandedBy != MessageQueueIF::NO_QUEUE) {
+  if (activeCmdInfo.pending && (activeCmdInfo.commandedBy != MessageQueueIF::NO_QUEUE)) {
     actionHelper.finish(success, activeCmdInfo.commandedBy, activeCmdInfo.pendingCmd, result);
   }
   activeCmdInfo.reset();
@@ -774,6 +781,22 @@ ReturnValue_t FreshMpsocHandler::handleDeviceReply() {
     case (mpsoc::apid::ACK_FAILURE):
       break;
     case (mpsoc::apid::TM_MEMORY_READ_REPORT):
+      if (activeCmdInfo.pendingCmd == mpsoc::TC_VERIFY_BOOT) {
+        // 6 byte header, 4 byte address, 2 byte read width, 4 byte read back value
+        if (replyReader.getFullPacketLen() >= 6 + 4 + 2 + 4) {
+          uint32_t readBack = 0;
+          size_t deserLen = 0;
+          ReturnValue_t result =
+              SerializeAdapter::deSerialize(&readBack, replyReader.getFullData() + 6 + 4 + 2,
+                                            &deserLen, SerializeIF::Endianness::NETWORK);
+          if (result != returnvalue::OK or readBack != mpsoc::DEADBEEF_VALUE) {
+            cmdDoneHandler(false, result);
+          }
+          cmdDoneHandler(true, returnvalue::OK);
+        } else {
+          cmdDoneHandler(false, result);
+        }
+      }
       result = reportReplyData(mpsoc::TM_MEMORY_READ_REPORT);
       break;
     case (mpsoc::apid::TM_CAM_CMD_RPT):
@@ -835,7 +858,7 @@ ReturnValue_t FreshMpsocHandler::handleExecutionReport() {
         }
       }
       if (commandId == DeviceHandlerIF::NO_COMMAND_ID) {
-        sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl;
+        sif::warning << "FreshMpsocHandler::handleExecutionReport: Unknown Command ID" << std::endl;
       }
       uint16_t status = mpsoc::getStatusFromRawData(replyReader.getFullData());
       sif::warning << "MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;

linux/payload/FreshMpsocHandler.h

@@ -17,6 +17,7 @@ static constexpr bool MPSOC_RX_WIRETAPPING = true;
 class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsIF {
  public:
   enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 };
+  static constexpr uint32_t MPSOC_MODE_CMD_TIMEOUT_MS = 120000;
 
   FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface,
                     PlocMpsocSpecialComHelper& specialComHelper, Gpio uartIsolatorSwitch,
@@ -43,7 +44,7 @@ class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsI
   enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE;
   enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE };
 
-  enum TransitionState { NONE, TO_ON, TO_OFF, SUBMODE } transitionState;
+  enum TransitionState { NONE, TO_ON, TO_OFF, SUBMODE } transitionState = TransitionState::NONE;
   MpsocCommunication& comInterface;
   PlocMpsocSpecialComHelper& specialComHelper;
   MessageQueueIF* eventQueue = nullptr;
@@ -169,24 +170,24 @@ class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsI
   void handleTransitionToOff();
 
   ReturnValue_t commandTcModeReplay();
-  ReturnValue_t prepareTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcMemRead(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcReplayStop();
-  ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcDownlinkPwrOff();
-  ReturnValue_t prepareTcGetHkReport();
-  ReturnValue_t prepareTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcMemRead(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcReplayStop();
+  ReturnValue_t commandTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcDownlinkPwrOff();
+  ReturnValue_t commandTcGetHkReport();
+  ReturnValue_t commandTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t commandTcModeIdle();
-  ReturnValue_t prepareTcCamTakePic(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcSimplexSendFile(const uint8_t* commandData, size_t commandDataLen);
-  ReturnValue_t prepareTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcCamTakePic(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcSimplexSendFile(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t commandTcModeSnapshot();
 
-  ReturnValue_t finishAndSendTc(mpsoc::TcBase& tcBase);
+  ReturnValue_t finishAndSendTc(DeviceCommandId_t cmdId, mpsoc::TcBase& tcBase);
   void handleEvent(EventMessage* eventMessage);
   void cmdDoneHandler(bool success, ReturnValue_t result);
   ReturnValue_t handleDeviceReply();

linux/payload/plocMpsocHelpers.h

@@ -80,6 +80,8 @@ enum FileAccessModes : uint8_t {
 };
 
 static constexpr uint32_t HK_SET_ID = 0;
+static constexpr uint32_t DEADBEEF_ADDR = 0x40000004;
+static constexpr uint32_t DEADBEEF_VALUE= 0xdeadbeef;
 
 namespace poolid {
 enum {
@@ -135,23 +137,26 @@ static const DeviceCommandId_t TC_REPLAY_STOP = 12;
 static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13;
 static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14;
 static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15;
+static const DeviceCommandId_t TC_MODE_REPLAY = 16;
 static const DeviceCommandId_t TC_CAM_CMD_SEND = 17;
+static const DeviceCommandId_t TC_MODE_IDLE = 18;
 static const DeviceCommandId_t TM_CAM_CMD_RPT = 19;
 static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20;
 static const DeviceCommandId_t RELEASE_UART_TX = 21;
 static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
-static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23;
+// Stream file down using E-Band component directly.
+static const DeviceCommandId_t TC_SIMPLEX_STREAM_FILE = 23;
 static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
+static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
 static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
 static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
 static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
 static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
 static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30;
+// Store file on MPSoC.
+static const DeviceCommandId_t TC_SIMPLEX_STORE_FILE = 31;
+static const DeviceCommandId_t TC_VERIFY_BOOT = 32;
 
-// Do not use those, use submode instead.
-static const DeviceCommandId_t TC_MODE_REPLAY_LEGACY = 16;
-static const DeviceCommandId_t TC_MODE_IDLE_LEGACY = 18;
-static const DeviceCommandId_t TC_MODE_SNAPSHOT_LEGACY = 25;
 
 // Will reset the sequence count of the OBSW. Not required anymore after MPSoC update.
 static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT_LEGACY = 50;

tmtc

@@ -1 +1 @@
-Subproject commit fc5fb0eed333a46407c59e40cc9ca018ab3e217c
+Subproject commit 18860ec2c670230722f47a149a2486377a75da52