eive/eive-obsw
eive/eive-obsw
13
4
Fork 0
Code Issues 4 Pull Requests 1 Releases 120 Wiki Activity

add SW IF for manipulating poll threshold #550

Merged
muellerr merged 4 commits from ptme_poll_threshold_register into develop 2023-04-02 15:35:40 +02:00
Conversation 0 Commits 4 Files Changed 7 +83 -106
5 changed files with 83 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit cab55c79dc - Show all commits

111
linux/ipcore/AxiPtmeConfig.cpp
View File

@ -1,5 +1,7 @@
#include "AxiPtmeConfig.h" #include "AxiPtmeConfig.h"
#include <fsfw/ipc/MutexGuard.h>
#include "fsfw/serviceinterface/ServiceInterface.h" #include "fsfw/serviceinterface/ServiceInterface.h"
#include "fsfw_hal/linux/uio/UioMapper.h" #include "fsfw_hal/linux/uio/UioMapper.h"
@ -39,97 +41,62 @@ ReturnValue_t AxiPtmeConfig::writeCaduRateReg(uint8_t rateVal) {
return returnvalue::OK; return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::enableTxclockManipulator() { void AxiPtmeConfig::enableTxclockManipulator() {
ReturnValue_t result = writeBit(COMMON_CONFIG_REG, true, BitPos::EN_TX_CLK_MANIPULATOR); writeBit(COMMON_CONFIG_REG, true, BitPos::EN_TX_CLK_MANIPULATOR);
if (result != returnvalue::OK) {
return result;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::disableTxclockManipulator() { void AxiPtmeConfig::disableTxclockManipulator() {
ReturnValue_t result = writeBit(COMMON_CONFIG_REG, false, BitPos::EN_TX_CLK_MANIPULATOR); writeBit(COMMON_CONFIG_REG, false, BitPos::EN_TX_CLK_MANIPULATOR);
if (result != returnvalue::OK) {
return result;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::enableTxclockInversion() { void AxiPtmeConfig::enableTxclockInversion() {
ReturnValue_t result = writeBit(COMMON_CONFIG_REG, true, BitPos::INVERT_CLOCK); writeBit(COMMON_CONFIG_REG, true, BitPos::INVERT_CLOCK);
if (result != returnvalue::OK) {
return result;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::disableTxclockInversion() { void AxiPtmeConfig::disableTxclockInversion() {
ReturnValue_t result = writeBit(COMMON_CONFIG_REG, false, BitPos::INVERT_CLOCK); writeBit(COMMON_CONFIG_REG, false, BitPos::INVERT_CLOCK);
if (result != returnvalue::OK) {
return result;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::enableBatPriorityBit() { void AxiPtmeConfig::enableBatPriorityBit() {
ReturnValue_t result = writeBit(COMMON_CONFIG_REG, true, BitPos::EN_BAT_PRIORITY); writeBit(COMMON_CONFIG_REG, true, BitPos::EN_BAT_PRIORITY);
if (result != returnvalue::OK) {
return result;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::disableBatPriorityBit() { void AxiPtmeConfig::disableBatPriorityBit() {
ReturnValue_t result = writeBit(COMMON_CONFIG_REG, false, BitPos::EN_BAT_PRIORITY); writeBit(COMMON_CONFIG_REG, false, BitPos::EN_BAT_PRIORITY);
if (result != returnvalue::OK) {
return result;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::writeReg(uint32_t regOffset, uint32_t writeVal) { void AxiPtmeConfig::writeReg(uint32_t regOffset, uint32_t writeVal) {
ReturnValue_t result = returnvalue::OK; MutexGuard mg(mutex, timeoutType, mutexTimeout);
result = mutex->lockMutex(timeoutType, mutexTimeout);
if (result != returnvalue::OK) {
sif::warning << "AxiPtmeConfig::readReg: Failed to lock mutex" << std::endl;
return returnvalue::FAILED;
}
*(baseAddress + regOffset / ADRESS_DIVIDER) = writeVal; *(baseAddress + regOffset / ADRESS_DIVIDER) = writeVal;
result = mutex->unlockMutex();
if (result != returnvalue::OK) {
sif::warning << "AxiPtmeConfig::readReg: Failed to unlock mutex" << std::endl;
return returnvalue::FAILED;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::readReg(uint32_t regOffset, uint32_t* readVal) { uint32_t AxiPtmeConfig::readReg(uint32_t regOffset) {
ReturnValue_t result = returnvalue::OK; MutexGuard mg(mutex, timeoutType, mutexTimeout);
result = mutex->lockMutex(timeoutType, mutexTimeout); return *(baseAddress + regOffset / ADRESS_DIVIDER);
if (result != returnvalue::OK) {
sif::warning << "AxiPtmeConfig::readReg: Failed to lock mutex" << std::endl;
return returnvalue::FAILED;
}
*readVal = *(baseAddress + regOffset / ADRESS_DIVIDER);
result = mutex->unlockMutex();
if (result != returnvalue::OK) {
sif::warning << "AxiPtmeConfig::readReg: Failed to unlock mutex" << std::endl;
return returnvalue::FAILED;
}
return returnvalue::OK;
} }
ReturnValue_t AxiPtmeConfig::writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos) { void AxiPtmeConfig::writePollThreshold(AxiPtmeConfig::IdlePollThreshold pollThreshold) {
uint32_t readVal = 0; MutexGuard mg(mutex, timeoutType, mutexTimeout);
ReturnValue_t result = readReg(regOffset, &readVal); uint32_t regVal = readCommonCfgReg();
if (result != returnvalue::OK) { // Clear bits first
return result; regVal &= ~(0b111 << 3);
regVal |= (static_cast<uint8_t>(pollThreshold) << 3);
writeCommonCfgReg(regVal);
} }
AxiPtmeConfig::IdlePollThreshold AxiPtmeConfig::readPollThreshold() {
uint32_t regVal = readCommonCfgReg();
return static_cast<AxiPtmeConfig::IdlePollThreshold>((regVal >> 3) & 0b111);
}
void AxiPtmeConfig::writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos) {
uint32_t readVal = readReg(regOffset);
uint32_t writeVal = uint32_t writeVal =
(readVal & ~(1 << static_cast<uint32_t>(bitPos))) | bitVal << static_cast<uint32_t>(bitPos); (readVal & ~(1 << static_cast<uint32_t>(bitPos))) | bitVal << static_cast<uint32_t>(bitPos);
result = writeReg(regOffset, writeVal); writeReg(regOffset, writeVal);
if (result != returnvalue::OK) {
return result;
} }
return returnvalue::OK;
uint32_t AxiPtmeConfig::readCommonCfgReg() {
MutexGuard mg(mutex, timeoutType, mutexTimeout);
return *(baseAddress + COMMON_CONFIG_REG / ADRESS_DIVIDER);
} }

34
linux/ipcore/AxiPtmeConfig.h
View File

@ -14,6 +14,16 @@
*/ */
class AxiPtmeConfig : public SystemObject { class AxiPtmeConfig : public SystemObject {
public: public:
enum IdlePollThreshold : uint8_t {
ALWAYS = 0b000,
POLL_1 = 0b001,
POLL_4 = 0b010,
POLL_16 = 0b011,
POLL_64 = 0b100,
POLL_256 = 0b101,
POLL_1024 = 0b110,
NEVER = 0b111
};
/** /**
* @brief Constructor * @brief Constructor
* @param axiUio Device file of UIO belonging to the AXI configuration interface. * @param axiUio Device file of UIO belonging to the AXI configuration interface.
@ -40,8 +50,8 @@ class AxiPtmeConfig : public SystemObject {
* Default: Enables TX clock manipulator * Default: Enables TX clock manipulator
* *
*/ */
ReturnValue_t enableTxclockManipulator(); void enableTxclockManipulator();
ReturnValue_t disableTxclockManipulator(); void disableTxclockManipulator();
/** /**
* @brief The next to functions control whether data will be updated on the rising or falling edge * @brief The next to functions control whether data will be updated on the rising or falling edge
@ -51,11 +61,14 @@ class AxiPtmeConfig : public SystemObject {
* Disable clock inversion. Data updated on rising edge. * Disable clock inversion. Data updated on rising edge.
* Default: Inversion is disabled * Default: Inversion is disabled
*/ */
ReturnValue_t enableTxclockInversion(); void enableTxclockInversion();
ReturnValue_t disableTxclockInversion(); void disableTxclockInversion();
ReturnValue_t enableBatPriorityBit(); void enableBatPriorityBit();
ReturnValue_t disableBatPriorityBit(); void disableBatPriorityBit();
void writePollThreshold(IdlePollThreshold pollThreshold);
IdlePollThreshold readPollThreshold();
private: private:
// Address of register storing the bitrate configuration parameter // Address of register storing the bitrate configuration parameter
@ -80,7 +93,7 @@ class AxiPtmeConfig : public SystemObject {
* *
* @param writeVal Value to write * @param writeVal Value to write
*/ */
ReturnValue_t writeReg(uint32_t regOffset, uint32_t writeVal); void writeReg(uint32_t regOffset, uint32_t writeVal);
/** /**
* @brief Reads value from configuration register * @brief Reads value from configuration register
@ -88,7 +101,10 @@ class AxiPtmeConfig : public SystemObject {
* @param regOffset Offset of register from base address to read from * @param regOffset Offset of register from base address to read from
* Qparam readVal Pointer to variable where read value will be written to * Qparam readVal Pointer to variable where read value will be written to
*/ */
ReturnValue_t readReg(uint32_t regOffset, uint32_t* readVal); uint32_t readReg(uint32_t regOffset);
uint32_t readCommonCfgReg();
uint32_t writeCommonCfgReg(uint32_t value);
/** /**
* @brief Sets one bit in a register * @brief Sets one bit in a register
@ -99,7 +115,7 @@ class AxiPtmeConfig : public SystemObject {
* *
* @return returnvalue::OK if successful, otherwise returnvalue::FAILED * @return returnvalue::OK if successful, otherwise returnvalue::FAILED
*/ */
ReturnValue_t writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos); void writeBit(uint32_t regOffset, bool bitVal, BitPos bitPos);
}; };
#endif /* LINUX_OBC_AXIPTMECONFIG_H_ */ #endif /* LINUX_OBC_AXIPTMECONFIG_H_ */

25
linux/ipcore/PtmeConfig.cpp
View File

@ -26,33 +26,26 @@ ReturnValue_t PtmeConfig::setRate(uint32_t bitRate) {
return axiPtmeConfig->writeCaduRateReg(static_cast<uint8_t>(rateVal)); return axiPtmeConfig->writeCaduRateReg(static_cast<uint8_t>(rateVal));
} }
ReturnValue_t PtmeConfig::invertTxClock(bool invert) { void PtmeConfig::invertTxClock(bool invert) {
ReturnValue_t result = returnvalue::OK;
if (invert) { if (invert) {
result = axiPtmeConfig->enableTxclockInversion(); axiPtmeConfig->enableTxclockInversion();
} else { } else {
result = axiPtmeConfig->disableTxclockInversion(); axiPtmeConfig->disableTxclockInversion();
} }
if (result != returnvalue::OK) {
return CLK_INVERSION_FAILED;
}
return result;
} }
ReturnValue_t PtmeConfig::configTxManipulator(bool enable) { void PtmeConfig::configTxManipulator(bool enable) {
ReturnValue_t result = returnvalue::OK;
if (enable) { if (enable) {
result = axiPtmeConfig->enableTxclockManipulator(); axiPtmeConfig->enableTxclockManipulator();
} else { } else {
result = axiPtmeConfig->disableTxclockManipulator(); axiPtmeConfig->disableTxclockManipulator();
} }
return result;
} }
ReturnValue_t PtmeConfig::enableBatPriorityBit(bool enable) { void PtmeConfig::enableBatPriorityBit(bool enable) {
if (enable) { if (enable) {
return axiPtmeConfig->enableBatPriorityBit(); axiPtmeConfig->enableBatPriorityBit();
} else { } else {
return axiPtmeConfig->disableBatPriorityBit(); axiPtmeConfig->disableBatPriorityBit();
} }
} }

6
linux/ipcore/PtmeConfig.h
View File

@ -43,7 +43,7 @@ class PtmeConfig : public SystemObject {
* *
* @return REUTRN_OK if successful, otherwise error return value * @return REUTRN_OK if successful, otherwise error return value
*/ */
ReturnValue_t invertTxClock(bool invert); void invertTxClock(bool invert);
/** /**
* @brief Controls the tx clock manipulator of the PTME wrapper component * @brief Controls the tx clock manipulator of the PTME wrapper component
@ -53,7 +53,7 @@ class PtmeConfig : public SystemObject {
* *
* @return REUTRN_OK if successful, otherwise error return value * @return REUTRN_OK if successful, otherwise error return value
*/ */
ReturnValue_t configTxManipulator(bool enable); void configTxManipulator(bool enable);
/** /**
* Enable the bat priority bit in the PTME wrapper component. * Enable the bat priority bit in the PTME wrapper component.
@ -62,7 +62,7 @@ class PtmeConfig : public SystemObject {
* @param enable * @param enable
* @return * @return
*/ */
ReturnValue_t enableBatPriorityBit(bool enable); void enableBatPriorityBit(bool enable);
private: private:
static const uint8_t INTERFACE_ID = CLASS_ID::RATE_SETTER; static const uint8_t INTERFACE_ID = CLASS_ID::RATE_SETTER;

9
mission/com/CcsdsIpCoreHandler.cpp
View File

@ -158,6 +158,7 @@ MessageQueueId_t CcsdsIpCoreHandler::getRequestQueue() const {
ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy, ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
const uint8_t* data, size_t size) { const uint8_t* data, size_t size) {
ReturnValue_t result = returnvalue::OK; ReturnValue_t result = returnvalue::OK;
// TODO: Update directly when off, otherwise set update context.
switch (actionId) { switch (actionId) {
case ARBITRARY_RATE: { case ARBITRARY_RATE: {
uint32_t bitrate = 0; uint32_t bitrate = 0;
@ -166,19 +167,19 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu
break; break;
} }
case ENABLE_TX_CLK_MANIPULATOR: { case ENABLE_TX_CLK_MANIPULATOR: {
result = ptmeConfig.configTxManipulator(true); ptmeConfig.configTxManipulator(true);
break; break;
} }
case DISABLE_TX_CLK_MANIPULATOR: { case DISABLE_TX_CLK_MANIPULATOR: {
result = ptmeConfig.configTxManipulator(false); ptmeConfig.configTxManipulator(false);
break; break;
} }
case UPDATE_ON_RISING_EDGE: { case UPDATE_ON_RISING_EDGE: {
result = ptmeConfig.invertTxClock(false); ptmeConfig.invertTxClock(false);
break; break;
} }
case UPDATE_ON_FALLING_EDGE: { case UPDATE_ON_FALLING_EDGE: {
result = ptmeConfig.invertTxClock(true); ptmeConfig.invertTxClock(true);
break; break;
} }
default: default: