From eb883ed93f8552358239a0a8b813706e77f2712e Mon Sep 17 00:00:00 2001 From: Robin Mueller Date: Wed, 17 Apr 2024 14:32:36 +0200 Subject: [PATCH] added new verify boot cmd --- linux/payload/FreshMpsocHandler.cpp | 197 ++++++++++++++++------------ linux/payload/FreshMpsocHandler.h | 33 ++--- linux/payload/plocMpsocHelpers.h | 15 ++- tmtc | 2 +- 4 files changed, 138 insertions(+), 109 deletions(-) diff --git a/linux/payload/FreshMpsocHandler.cpp b/linux/payload/FreshMpsocHandler.cpp index d6ab2fd3..ef293ae1 100644 --- a/linux/payload/FreshMpsocHandler.cpp +++ b/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; diff --git a/linux/payload/FreshMpsocHandler.h b/linux/payload/FreshMpsocHandler.h index cab4e789..9d9ec1d6 100644 --- a/linux/payload/FreshMpsocHandler.h +++ b/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(); diff --git a/linux/payload/plocMpsocHelpers.h b/linux/payload/plocMpsocHelpers.h index 344851f3..a06b2b1e 100644 --- a/linux/payload/plocMpsocHelpers.h +++ b/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; diff --git a/tmtc b/tmtc index fc5fb0ee..18860ec2 160000 --- a/tmtc +++ b/tmtc @@ -1 +1 @@ -Subproject commit fc5fb0eed333a46407c59e40cc9ca018ab3e217c +Subproject commit 18860ec2c670230722f47a149a2486377a75da52