2557 lines
116 KiB
C
Executable File
2557 lines
116 KiB
C
Executable File
/**
|
|
* \file talise_rx.c
|
|
* \brief Contains functions to support Talise Rx and Observation Rx data path
|
|
* control
|
|
*
|
|
* Talise API version: 3.5.0.2
|
|
*
|
|
* Copyright 2015-2017 Analog Devices Inc.
|
|
* Released under the AD9378-AD9379 API license, for more information see the "LICENSE.txt" file in this zip file.
|
|
*/
|
|
|
|
#include "talise_rx.h"
|
|
#include "talise_gpio.h"
|
|
#include "talise_reg_addr_macros.h"
|
|
#include "talise_arm_macros.h"
|
|
#include "talise_hal.h"
|
|
#include "talise_user.h"
|
|
#include "talise_error.h"
|
|
#include "talise.h"
|
|
#include "talise_gpio.h"
|
|
|
|
uint32_t TALISE_programRxGainTable(taliseDevice_t *device, taliseRxGainTable_t *gainTablePtr, uint8_t numGainIndexesInTable, taliseRxChannels_t rxChannel)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t tableRowIndex = 0;
|
|
uint8_t ctlReg = 0;
|
|
uint8_t i = 0;
|
|
uint32_t addrIndex = 0;
|
|
uint32_t spiBufferSize = (((HAL_SPIWRITEARRAY_BUFFERSIZE / 8) - 1) * 8);
|
|
uint16_t addrArray[HAL_SPIWRITEARRAY_BUFFERSIZE] = {0};
|
|
uint8_t dataArray[HAL_SPIWRITEARRAY_BUFFERSIZE] = {0};
|
|
static const uint8_t EN_TABLECLK = 0x05;
|
|
uint8_t digGainSign = 0;
|
|
uint16_t digGainMag = 0;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_programRxGainTable()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
if ((rxChannel == TAL_RX1) ||
|
|
(rxChannel == TAL_RX2) ||
|
|
(rxChannel == TAL_RX1RX2))
|
|
{
|
|
/* Verify Rx profile is valid before allowing to set the Rx gain table, this
|
|
* ensures the device->rx structure pointers are valid
|
|
*/
|
|
if ((device->devStateInfo.profilesValid & RX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_RXGAINTABLE_INV_PROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check for proper mapping for gain table and passed table number of indexes */
|
|
if (numGainIndexesInTable > ((START_RX_GAIN_INDEX - MIN_RX_GAIN_TABLE_INDEX) + 1))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_RXGAINTABLE_INV_GAIN_INDEX_RANGE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_RXGAINTABLE_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (gainTablePtr == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_PROGRAM_RXGAIN_TABLE_NULL_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check for channel and the logic behind it */
|
|
if ((rxChannel == TAL_RX1) ||
|
|
(rxChannel == TAL_RX1RX2))
|
|
{
|
|
/* normalize min/max index in device structure to 255 index = max gain */
|
|
device->devStateInfo.gainIndexes.rx1MaxGainIndex = MAX_GAIN_TABLE_INDEX;
|
|
device->devStateInfo.gainIndexes.rx1MinGainIndex = MAX_GAIN_TABLE_INDEX - numGainIndexesInTable + 1;
|
|
}
|
|
|
|
if ((rxChannel == TAL_RX2) ||
|
|
(rxChannel == TAL_RX1RX2))
|
|
{
|
|
/* normalize min/max index in device structure to 255 index = max gain */
|
|
device->devStateInfo.gainIndexes.rx2MaxGainIndex = MAX_GAIN_TABLE_INDEX;
|
|
device->devStateInfo.gainIndexes.rx2MinGainIndex = MAX_GAIN_TABLE_INDEX - numGainIndexesInTable + 1;
|
|
}
|
|
|
|
/* starting the gain table clock and read from gain table address bits */
|
|
ctlReg = (uint8_t)((rxChannel << 3) | EN_TABLECLK);
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, ctlReg);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* programming a table selected by rxChannel enum type */
|
|
addrIndex = 0;
|
|
|
|
for(i = START_RX_GAIN_INDEX; i > START_RX_GAIN_INDEX - numGainIndexesInTable; i--)
|
|
{
|
|
tableRowIndex = START_RX_GAIN_INDEX - i;
|
|
|
|
/* set current gain table index (address) */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_ADDRESS;
|
|
dataArray[addrIndex++] = i;
|
|
|
|
/* Set Rx Front End gain[7:0] */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_RXFE;
|
|
dataArray[addrIndex++] = gainTablePtr[tableRowIndex].rxFeGain;
|
|
|
|
/* Set external control [3:0] */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_EXT;
|
|
dataArray[addrIndex++] = gainTablePtr[tableRowIndex].extControl;
|
|
|
|
digGainSign = (gainTablePtr[tableRowIndex].digGain < 0) ? 1 : 0;
|
|
digGainMag = (uint16_t)((digGainSign > 0) ? (-gainTablePtr[tableRowIndex].digGain) : gainTablePtr[tableRowIndex].digGain);
|
|
|
|
/* Set digital attenuation/gain[10:4] */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_DIG;
|
|
dataArray[addrIndex++] = ((digGainSign & 0x01) << 6) | (((uint8_t)(digGainMag >> 4 )) & 0x3F);
|
|
|
|
/* Set digital attenuation/gain[3:0], TIA control */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_DIG2;
|
|
dataArray[addrIndex++] = ((gainTablePtr[tableRowIndex].adcTiaGain & 0x03) << 4) | ((uint8_t)(digGainMag & 0x0F));
|
|
|
|
/* Set Phase offset if Rx gain table */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_PHASE_OFFSET;
|
|
dataArray[addrIndex++] = (uint8_t)(gainTablePtr[tableRowIndex].phaseOffset & 0xFF);
|
|
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_PHASE_OFFSET2;
|
|
dataArray[addrIndex++] = (uint8_t)((gainTablePtr[tableRowIndex].phaseOffset >> 8) & 0xFF);
|
|
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_CONFIGURATION;
|
|
dataArray[addrIndex++] = (ctlReg | 0x02);
|
|
|
|
if (addrIndex >= spiBufferSize)
|
|
{
|
|
halError = talSpiWriteBytes(device->devHalInfo, &addrArray[0], &dataArray[0], addrIndex);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
addrIndex = 0;
|
|
}
|
|
}
|
|
|
|
if (addrIndex > 0)
|
|
{
|
|
halError = talSpiWriteBytes(device->devHalInfo, &addrArray[0], &dataArray[0], addrIndex);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
}
|
|
|
|
/* disabling the gain table clock */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, 0x00);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_programOrxGainTable(taliseDevice_t *device, taliseOrxGainTable_t *gainTablePtr, uint8_t numGainIndexesInTable, taliseObsRxChannels_t orxChannel)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t tableRowIndex = 0;
|
|
uint8_t ctlReg = 0;
|
|
uint8_t i = 0;
|
|
uint32_t addrIndex = 0;
|
|
uint32_t spiBufferSize = (((HAL_SPIWRITEARRAY_BUFFERSIZE / 6) - 1) * 6);
|
|
uint16_t addrArray[HAL_SPIWRITEARRAY_BUFFERSIZE] = {0};
|
|
uint8_t dataArray[HAL_SPIWRITEARRAY_BUFFERSIZE] = {0};
|
|
static const uint8_t EN_TABLECLK = 0x05;
|
|
uint8_t digGainSign = 0;
|
|
uint16_t digGainMag = 0;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_programOrxGainTable()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
if ((orxChannel == TAL_ORX1) ||
|
|
(orxChannel == TAL_ORX2) ||
|
|
(orxChannel == TAL_ORX1ORX2))
|
|
{
|
|
/* Verify ORx profile is valid before allowing to set the ORx gain table, this
|
|
* ensures the device->obsRx structure pointers are valid
|
|
*/
|
|
if ((device->devStateInfo.profilesValid & ORX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_ORXGAINTABLE_INV_PROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check for proper mapping for gain table and passed table number of indexes */
|
|
if (numGainIndexesInTable > ((START_ORX_GAIN_INDEX - MIN_ORX_GAIN_TABLE_INDEX) + 1))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_ORXGAINTABLE_INV_GAIN_INDEX_RANGE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_ORXGAINTABLE_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (gainTablePtr == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_PROGRAM_ORXGAIN_TABLE_NULL_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check for channel and the logic behind it */
|
|
if ((orxChannel == TAL_ORX1) ||
|
|
(orxChannel == TAL_ORX1ORX2))
|
|
{
|
|
/* normalize min/max index in device structure to 255 index = max gain */
|
|
device->devStateInfo.gainIndexes.orx1MaxGainIndex = MAX_GAIN_TABLE_INDEX;
|
|
device->devStateInfo.gainIndexes.orx1MinGainIndex = MAX_GAIN_TABLE_INDEX - numGainIndexesInTable + 1;
|
|
}
|
|
|
|
if ((orxChannel == TAL_ORX2) ||
|
|
(orxChannel == TAL_ORX1ORX2))
|
|
{
|
|
/* normalize min/max index in device structure to 255 index = max gain */
|
|
device->devStateInfo.gainIndexes.orx2MaxGainIndex = MAX_GAIN_TABLE_INDEX;
|
|
device->devStateInfo.gainIndexes.orx2MinGainIndex = MAX_GAIN_TABLE_INDEX - numGainIndexesInTable + 1;
|
|
}
|
|
|
|
/* starting the gain table clock and read from gain table address bits */
|
|
ctlReg = (uint8_t)((orxChannel << 3) | EN_TABLECLK);
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, ctlReg);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* programming a table selected by rxChannel enum type */
|
|
addrIndex = 0;
|
|
|
|
for(i = START_ORX_GAIN_INDEX; i > START_ORX_GAIN_INDEX - numGainIndexesInTable; i--)
|
|
{
|
|
tableRowIndex = START_ORX_GAIN_INDEX - i;
|
|
|
|
/* set current gain table index (address) */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_ADDRESS;
|
|
dataArray[addrIndex++] = i;
|
|
|
|
/* Set Rx Front End gain[7:0] */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_RXFE;
|
|
dataArray[addrIndex++] = gainTablePtr[tableRowIndex].rxFeGain;
|
|
|
|
/* Set external control [3:0] */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_EXT;
|
|
dataArray[addrIndex++] = gainTablePtr[tableRowIndex].extControl;
|
|
|
|
digGainSign = (gainTablePtr[tableRowIndex].digGain < 0) ? 1 : 0;
|
|
digGainMag = (uint16_t)((digGainSign > 0) ? (-gainTablePtr[tableRowIndex].digGain) : gainTablePtr[tableRowIndex].digGain);
|
|
|
|
/* Set digital attenuation/gain[10:4] */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_DIG;
|
|
dataArray[addrIndex++] = ((digGainSign & 0x01) << 6) | (((uint8_t)(digGainMag >> 4 )) & 0x3F);
|
|
|
|
/* Set digital attenuation/gain[3:0], TIA control */
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_WORD_DATA_DIG2;
|
|
dataArray[addrIndex++] = ((gainTablePtr[tableRowIndex].adcTiaGain & 0x03) << 4) | ((uint8_t)(digGainMag & 0x0F));
|
|
|
|
addrArray[addrIndex] = TALISE_ADDR_GAIN_TABLE_CONFIGURATION;
|
|
dataArray[addrIndex++] = (ctlReg | 0x02);
|
|
|
|
if (addrIndex >= spiBufferSize)
|
|
{
|
|
halError = talSpiWriteBytes(device->devHalInfo, &addrArray[0], &dataArray[0], addrIndex);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
addrIndex = 0;
|
|
}
|
|
}
|
|
|
|
if (addrIndex > 0)
|
|
{
|
|
halError = talSpiWriteBytes(device->devHalInfo, &addrArray[0], &dataArray[0], addrIndex);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
}
|
|
|
|
/* disabling the gain table clock */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, 0x00);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_setRxManualGain(taliseDevice_t *device, taliseRxChannels_t rxChannel, uint8_t gainIndex)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setRxManualGain()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
/* Verify Rx profile is valid */
|
|
if ((device->devStateInfo.profilesValid & RX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXGAIN_RXPROFILE_INVALID, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxChannel == TAL_RX1)
|
|
{
|
|
if ((gainIndex < device->devStateInfo.gainIndexes.rx1MinGainIndex) ||
|
|
(gainIndex > device->devStateInfo.gainIndexes.rx1MaxGainIndex))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRX1GAIN_INV_GAIN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_MANUAL_GAIN_INDEX_RX1, (START_RX_GAIN_INDEX - (MAX_GAIN_TABLE_INDEX - gainIndex)));
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
}
|
|
else if (rxChannel == TAL_RX2)
|
|
{
|
|
if ((gainIndex < device->devStateInfo.gainIndexes.rx2MinGainIndex) ||
|
|
(gainIndex > device->devStateInfo.gainIndexes.rx2MaxGainIndex))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRX2GAIN_INV_GAIN_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_MANUAL_GAIN_INDEX_RX2, (START_RX_GAIN_INDEX - (MAX_GAIN_TABLE_INDEX - gainIndex)));
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXGAIN_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_getRxGain(taliseDevice_t *device, taliseRxChannels_t rxChannel, uint8_t *rxGainIndex)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t readData = 0;
|
|
uint16_t regGainCh = TALISE_ADDR_RX1_GAIN_INDEX;
|
|
uint8_t channelMaxGainIndex = START_RX_GAIN_INDEX;
|
|
uint8_t channelMinGainIndex = MIN_RX_GAIN_TABLE_INDEX;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getRxGain()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
if ((device->devStateInfo.profilesValid & RX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETRXGAIN_INV_RXPROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxChannel == TAL_RX1)
|
|
{
|
|
regGainCh = TALISE_ADDR_RX1_GAIN_INDEX;
|
|
}
|
|
else if (rxChannel == TAL_RX2)
|
|
{
|
|
regGainCh = TALISE_ADDR_RX2_GAIN_INDEX;
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETRXGAIN_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Write the readback register to update the value */
|
|
halError = talSpiWriteByte(device->devHalInfo, regGainCh, 0x00);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read back the current gain index for the required channel */
|
|
halError = talSpiReadByte(device->devHalInfo, regGainCh, &readData);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* range check the gain against the max and min expected values */
|
|
if ((readData > channelMaxGainIndex) ||
|
|
(readData < channelMinGainIndex))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETRXGAIN_GAIN_RANGE_EXCEEDED, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* normalize channel's gain index to 255 max gain index */
|
|
readData = (MAX_GAIN_TABLE_INDEX - (channelMaxGainIndex - readData));
|
|
|
|
if (rxGainIndex != NULL)
|
|
{
|
|
*rxGainIndex = readData;
|
|
}
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_setObsRxManualGain(taliseDevice_t *device, taliseObsRxChannels_t obsRxCh, uint8_t gainIndex)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint16_t manualGainIndexSpiAddr = 0;
|
|
uint8_t orxGainIndex = 0;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setObsRxManualGain()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
/* Verify ORx profile is valid, also verifies device data struct pointers
|
|
* used below are valid
|
|
*/
|
|
if ((device->devStateInfo.profilesValid & ORX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETORXGAIN_INV_ORXPROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* check for valid channel and assign address */
|
|
switch(obsRxCh)
|
|
{
|
|
case TAL_ORX1:
|
|
if ((gainIndex < device->devStateInfo.gainIndexes.orx1MinGainIndex) ||
|
|
(gainIndex > device->devStateInfo.gainIndexes.orx1MaxGainIndex))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETORXGAIN_INV_ORX1GAIN, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* GainIndex in data struct is normalized to 255 = max gain index */
|
|
orxGainIndex = (START_ORX_GAIN_INDEX - (MAX_GAIN_TABLE_INDEX - gainIndex));
|
|
manualGainIndexSpiAddr = TALISE_ADDR_MANUAL_GAIN_INDEX_ORX_RX1;
|
|
break;
|
|
|
|
case TAL_ORX2:
|
|
if ((gainIndex < device->devStateInfo.gainIndexes.orx2MinGainIndex) ||
|
|
(gainIndex > device->devStateInfo.gainIndexes.orx2MaxGainIndex))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETORXGAIN_INV_ORX2GAIN, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* GainIndex in data struct is normalized to 255 = max gain index */
|
|
orxGainIndex = (START_ORX_GAIN_INDEX - (MAX_GAIN_TABLE_INDEX - gainIndex));
|
|
manualGainIndexSpiAddr = TALISE_ADDR_MANUAL_GAIN_INDEX_ORX_RX2;
|
|
break;
|
|
|
|
default:
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETORXGAIN_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
|
|
}
|
|
|
|
/* update the value in the device data structure, and write to device.*/
|
|
halError = talSpiWriteByte(device->devHalInfo, manualGainIndexSpiAddr, orxGainIndex);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_getObsRxGain(taliseDevice_t *device, taliseObsRxChannels_t obsRxChannel, uint8_t *obsRxGainIndex)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t readData = 0;
|
|
uint16_t regGainCh = TALISE_ADDR_ORX1_GAIN_INDEX;
|
|
uint8_t channelMaxGainIndex = START_ORX_GAIN_INDEX;
|
|
uint8_t channelMinGainIndex = MIN_ORX_GAIN_TABLE_INDEX;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getObsRxGain()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
if ((device->devStateInfo.profilesValid & ORX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETOBSRXGAIN_INV_ORXPROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (obsRxChannel == TAL_ORX1)
|
|
{
|
|
regGainCh = TALISE_ADDR_ORX1_GAIN_INDEX;
|
|
}
|
|
else if (obsRxChannel == TAL_ORX2)
|
|
{
|
|
regGainCh = TALISE_ADDR_ORX2_GAIN_INDEX;
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETOBSRXGAIN_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Write the readback register to update the value */
|
|
halError = talSpiWriteByte(device->devHalInfo, regGainCh, 0x00);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read back the current gain index for the required channel */
|
|
halError = talSpiReadByte(device->devHalInfo, regGainCh, &readData);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* range check the gain against the max and min expected values */
|
|
if ((readData > channelMaxGainIndex) ||
|
|
(readData < channelMinGainIndex))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETOBSRXGAIN_GAIN_RANGE_EXCEEDED, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* normalize channel's gain index to 255 max gain index */
|
|
readData = (MAX_GAIN_TABLE_INDEX - (channelMaxGainIndex - readData));
|
|
|
|
if (obsRxGainIndex != NULL)
|
|
{
|
|
*obsRxGainIndex = readData;
|
|
}
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_setRxGainControlMode(taliseDevice_t *device, taliseGainMode_t mode)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
static const uint8_t rxGainTypeBitMask = 0x03;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setRxGainControlMode()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
/* performing AGC type check */
|
|
switch (mode)
|
|
{
|
|
case TAL_MGC:
|
|
break;
|
|
case TAL_AGCSLOW:
|
|
break;
|
|
case TAL_AGCFAST: /* Fall through to next case */
|
|
case TAL_HYBRID:
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_UNSUPPORTED_RX_GAIN_MODE_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
default:
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_INV_RX_GAIN_MODE_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* read, modify, write AGC type for Rx1 */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_AGC_CONFIG_RX1, (uint8_t)mode, rxGainTypeBitMask, 0);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read, modify, write AGC type for Rx2 */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_AGC_CONFIG_RX2, (uint8_t)mode, rxGainTypeBitMask, 0);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* writing mode setting to device state information container */
|
|
device->devStateInfo.gainMode = mode;
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_setRxDataFormat (taliseDevice_t *device, taliseRxDataFormat_t *rxDataFormat)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
|
|
uint8_t fpConfig = 0;
|
|
uint8_t fpAtten = 0;
|
|
uint8_t gainConfig = 0;
|
|
uint8_t intConfig = 0;
|
|
uint8_t slicerConfig = 0;
|
|
uint8_t rx1GpioSelect = 0;
|
|
uint8_t rx2GpioSelect = 0;
|
|
uint8_t rx1Gpio = 0;
|
|
uint8_t rx2Gpio = 0;
|
|
uint8_t rx1SendGpio = 0;
|
|
uint8_t rx2SendGpio = 0;
|
|
uint8_t dualConfig = 0;
|
|
uint8_t dualModeBit = 0;
|
|
uint8_t combineDualband = 0;
|
|
uint32_t srcCntrl = 0;
|
|
uint32_t gpioAssignMask = 0;
|
|
uint32_t gpioFreeMask = 0;
|
|
uint32_t npCheck = 0;
|
|
|
|
taliseRx1ExtSlicerGpioSelect_t rx1GpioConfig = TAL_EXTSLICER_RX1_GPIO_DISABLE;
|
|
taliseRx2ExtSlicerGpioSelect_t rx2GpioConfig = TAL_EXTSLICER_RX2_GPIO_DISABLE;
|
|
|
|
static const uint8_t rxChannelMask = 0x03;
|
|
static const uint8_t GAIN_COMP_EN_BITM = 0x01;
|
|
static const uint8_t PIN_CONTROL_BITM = 0x20;
|
|
static const uint8_t SLICER_NUMBERBITS_BITM = 0x20;
|
|
static const uint8_t SLICER_BIT_POSITION_BITM = 0x10;
|
|
static const uint8_t SLICER_EMBED_EN_BITM = 0x08;
|
|
static const uint8_t DATA_RESOLUTION_BITM = 0x06;
|
|
static const uint8_t DATA_RESOLUTION_16BIT = 0x02;
|
|
static const uint8_t DATA_RESOLUTION_24BIT = 0x04;
|
|
static const uint8_t SIGNED_MAGNITUDE_BITM = 0x01;
|
|
static const uint32_t GPIO0_1_2_BITM = 0x00000007;
|
|
static const uint32_t GPIO5_6_7_BITM = 0x000000E0;
|
|
static const uint32_t GPIO8_9_10_BITM = 0x00000700;
|
|
static const uint32_t GPIO11_12_13_BITM = 0x00003800;
|
|
static const uint32_t GPIO12_13_14_BITM = 0x00007000;
|
|
static const uint32_t GPIO_OE_BITM = 0x7FFFF;
|
|
static const uint32_t INTSLICER_NIBBLE_SOURCE = ((((uint32_t)TAL_GPIO_SLICER_OUT_MODE) << 12) | (((uint32_t)TAL_GPIO_SLICER_OUT_MODE) << 8));
|
|
static const uint32_t INTSLICER_NIBBLE_CLEAR_BITM = 0xFFFF00FF;
|
|
static const uint8_t DUALBANDENABLE = 1;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setRxDataFormat()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
/* Range check the configuration structure */
|
|
if (rxDataFormat == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_NULL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->formatSelect > TAL_GAIN_WITH_EXTERNAL_SLICER)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FORMATSELECT_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->tempCompensationEnable > 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_TEMPCOMP_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->intEmbeddedBits > TAL_EMBED_2_SLICERBITS_AT_LSB)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_INTEMBEDDEDBITS_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->intSampleResolution > TAL_INTEGER_24BIT_SIGNED)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_INTSAMPLERESOLUTION_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->extPinStepSize > TAL_EXTSLICER_STEPSIZE_4DB)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_PINSTEPSIZE_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->rx1GpioSelect > TAL_EXTSLICER_RX1_GPIO_DISABLE)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RX1GPIOSELECT_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((rxDataFormat->rx2GpioSelect != TAL_EXTSLICER_RX2_GPIO11_12_13) &&
|
|
(rxDataFormat->rx2GpioSelect != TAL_EXTSLICER_RX2_GPIO5_6_7) &&
|
|
(rxDataFormat->rx2GpioSelect != TAL_EXTSLICER_RX2_GPIO_DISABLE))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RX2GPIOSELECT_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->externalLnaGain > 1)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_EXTERNALLNAGAIN_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Calculate dualBandMode settings */
|
|
if (device->devStateInfo.rxDualBandEnabled == DUALBANDENABLE)
|
|
{
|
|
|
|
/* if single Rx channel enabled then combine bands if M=2, separate bands if M=4 */
|
|
if (((device->devStateInfo.initializedChannels & rxChannelMask) == 1) ||
|
|
((device->devStateInfo.initializedChannels & rxChannelMask) == 2))
|
|
{
|
|
combineDualband = (device->devStateInfo.rxTotalM == 2) ? 1 : 0;
|
|
}
|
|
|
|
/* if both Rx channels enabled then combine if M=4, separate if M=8 */
|
|
else if ((device->devStateInfo.initializedChannels & rxChannelMask) == 3)
|
|
{
|
|
combineDualband = (device->devStateInfo.rxTotalM == 4) ? 1 : 0;
|
|
}
|
|
|
|
/* throw an error if no Rx channel enabled */
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RXCHAN_DISABLED, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* For floating point dualmode is set if combineDualband is set, cleared if combineDualband is clear */
|
|
if (rxDataFormat->formatSelect == TAL_GAIN_WITH_FLOATING_POINT)
|
|
{
|
|
dualModeBit = combineDualband;
|
|
}
|
|
/* for internal slicer dualmode is set if no embedded bits, set if bits are embedded and combineDualband is set */
|
|
else if ((rxDataFormat->formatSelect == TAL_GAIN_WITH_INTSLICER) ||
|
|
(rxDataFormat->formatSelect == TAL_GAIN_WITH_INTSLICER_NOGPIO))
|
|
{
|
|
if (rxDataFormat->intEmbeddedBits == TAL_NO_EMBEDDED_SLICER_BITS)
|
|
{
|
|
dualModeBit = 1;
|
|
}
|
|
else
|
|
{
|
|
dualModeBit = combineDualband;
|
|
}
|
|
}
|
|
/* for external slicer dualMode is always cleared */
|
|
else
|
|
{
|
|
dualModeBit = 0;
|
|
}
|
|
}
|
|
/* dualMode is cleared for TAL_RXDDC_DEC2 not selected */
|
|
else
|
|
{
|
|
dualModeBit = 0;
|
|
}
|
|
|
|
dualConfig = (dualModeBit << 2) | ((rxDataFormat->externalLnaGain << 1) | (rxDataFormat->tempCompensationEnable));
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_COMPENSATION_AND_SLICER_CONFIG2, dualConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read the Rx1 gpio config */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_RX1_SLICER_GPIO_CONFIG, &rx1SendGpio);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
rx1GpioConfig = (taliseRx1ExtSlicerGpioSelect_t)rx1SendGpio;
|
|
|
|
/* deassign any rx1 gpios already in use */
|
|
if (rx1GpioConfig == TAL_EXTSLICER_RX1_GPIO0_1_2)
|
|
{
|
|
gpioFreeMask = GPIO0_1_2_BITM;
|
|
}
|
|
else if (rx1GpioConfig == TAL_EXTSLICER_RX1_GPIO5_6_7)
|
|
{
|
|
gpioFreeMask = GPIO5_6_7_BITM;
|
|
}
|
|
else if (rx1GpioConfig == TAL_EXTSLICER_RX1_GPIO8_9_10)
|
|
{
|
|
gpioFreeMask = GPIO8_9_10_BITM;
|
|
}
|
|
else
|
|
{
|
|
gpioFreeMask = 0;
|
|
}
|
|
|
|
/* free the unused GPIOs */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, (~gpioFreeMask & GPIO_OE_BITM), gpioFreeMask);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
device->devStateInfo.usedGpiopins &= ~gpioFreeMask;
|
|
|
|
rx1GpioSelect = TAL_EXTSLICER_RX1_GPIO_DISABLE;
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_SLICER_GPIO_CONFIG, rx1GpioSelect);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read the Rx2 gpio config */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_RX2_SLICER_GPIO_CONFIG, &rx2SendGpio);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
rx2GpioConfig = (taliseRx2ExtSlicerGpioSelect_t)rx2SendGpio;
|
|
|
|
/* deassign any rx1 gpios already in use */
|
|
if (rx2GpioConfig == TAL_EXTSLICER_RX2_GPIO5_6_7)
|
|
{
|
|
gpioFreeMask = GPIO5_6_7_BITM;
|
|
}
|
|
else if (rx2GpioConfig == TAL_EXTSLICER_RX2_GPIO11_12_13)
|
|
{
|
|
gpioFreeMask |= GPIO11_12_13_BITM;
|
|
}
|
|
else
|
|
{
|
|
gpioFreeMask = 0;
|
|
}
|
|
|
|
/* free the unused GPIOs */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, (~gpioFreeMask & GPIO_OE_BITM), gpioFreeMask);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
device->devStateInfo.usedGpiopins &= ~gpioFreeMask;
|
|
|
|
rx2GpioSelect = TAL_EXTSLICER_RX2_GPIO_DISABLE;
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_SLICER_GPIO_CONFIG, rx2GpioSelect);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read the Gpio External Pin Configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, &slicerConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* if pin control is internal then check nibble source to see if gpios are in use */
|
|
/* use case: integer with internal slicer outputting position on Gpios */
|
|
if ((slicerConfig & PIN_CONTROL_BITM) == 0)
|
|
{
|
|
/* read nibble source */
|
|
retVal = (talRecoveryActions_t)TALISE_getGpioSourceCtrl(device, &srcCntrl);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* modify the nibble source control if gpios in use*/
|
|
if ((srcCntrl & INTSLICER_NIBBLE_SOURCE) == INTSLICER_NIBBLE_SOURCE)
|
|
{
|
|
srcCntrl &= ~(INTSLICER_NIBBLE_SOURCE);
|
|
|
|
/* write nibble source to clear nibbles */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioSourceCtrl(device, srcCntrl);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* turn unused pins to input */
|
|
gpioAssignMask = GPIO8_9_10_BITM | GPIO12_13_14_BITM;
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, 0x00, gpioAssignMask);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* free the gpios */
|
|
device->devStateInfo.usedGpiopins &= ~gpioAssignMask;
|
|
}
|
|
}
|
|
|
|
/* set the configurations per selected mode type Floating Point */
|
|
if (rxDataFormat->formatSelect == TAL_GAIN_WITH_FLOATING_POINT)
|
|
{
|
|
if (rxDataFormat->fpRoundMode > TAL_ROUND_FROM_EVEN)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_ROUNDMODE_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->fpDataFormat > 1)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FPDATAFRMT_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->fpEncodeNan > 1)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FPENCNAN_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->fpNumExpBits > TAL_5_EXPONENTBITS)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FPEXPBITS_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxDataFormat->fpHideLeadingOne > 1)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FPHIDELEADINGONE_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((rxDataFormat->fpRx1Atten != TAL_FPATTEN_MINUS18DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_MINUS12DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_MINUS6DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_0DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_6DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_12DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_18DB) &&
|
|
(rxDataFormat->fpRx1Atten != TAL_FPATTEN_24DB))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FPRX1ATTEN_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((rxDataFormat->fpRx2Atten != TAL_FPATTEN_MINUS18DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_MINUS12DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_MINUS6DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_0DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_6DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_12DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_18DB) &&
|
|
(rxDataFormat->fpRx2Atten != TAL_FPATTEN_24DB))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_FPRX2ATTEN_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* force embedded bits to zeros */
|
|
/* write integer configuration register */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_INTEGER_FORMAT_CONFIG, 0x02);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* assemble and write float point config register */
|
|
fpConfig = ((((((uint8_t)rxDataFormat->fpRoundMode << 5) | (rxDataFormat->fpDataFormat << 4)) |
|
|
(rxDataFormat->fpEncodeNan << 3)) | ((uint8_t)rxDataFormat->fpNumExpBits << 1)) | rxDataFormat->fpHideLeadingOne);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_CONFIG, fpConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* assemble and write rx attenuation register */
|
|
fpAtten = (((rxDataFormat->fpRx2Atten & 0x07) << 3) | (rxDataFormat->fpRx1Atten & 0x07));
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_CONTROL, fpAtten);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* write the floating point enable to FP on */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_ENABLE, 0x03);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read for gain configuration register */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, &gainConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
gainConfig |= GAIN_COMP_EN_BITM; /* gain compensation on */
|
|
gainConfig &= ~PIN_CONTROL_BITM; /* pin control internal */
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, gainConfig, 0xE1, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
} /* end FP */
|
|
|
|
/* Integer Mode or disabled */
|
|
else
|
|
{
|
|
|
|
if (rxDataFormat->intEmbeddedBits == TAL_NO_EMBEDDED_SLICER_BITS)
|
|
{
|
|
intConfig &= ~SLICER_NUMBERBITS_BITM; /* Set to default */
|
|
intConfig &= ~SLICER_BIT_POSITION_BITM; /* Set to default */
|
|
intConfig &= ~SLICER_EMBED_EN_BITM; /* Disable embedding slicer in data sample */
|
|
}
|
|
else if (rxDataFormat->intEmbeddedBits == TAL_EMBED_1_SLICERBIT_AT_MSB)
|
|
{
|
|
intConfig |= SLICER_NUMBERBITS_BITM; /* 1 bit on I, 1 bit on Q */
|
|
intConfig &= ~SLICER_BIT_POSITION_BITM; /* bits after sign at MSB */
|
|
intConfig |= SLICER_EMBED_EN_BITM; /* slicer embed enabled */
|
|
}
|
|
else if (rxDataFormat->intEmbeddedBits == TAL_EMBED_1_SLICERBIT_AT_LSB)
|
|
{
|
|
intConfig |= SLICER_NUMBERBITS_BITM; /* 1 bit on I, 1 bit on Q */
|
|
intConfig |= SLICER_BIT_POSITION_BITM; /* bits at LSB */
|
|
intConfig |= SLICER_EMBED_EN_BITM; /* slicer embed enabled */
|
|
}
|
|
else if (rxDataFormat->intEmbeddedBits == TAL_EMBED_2_SLICERBITS_AT_MSB)
|
|
{
|
|
intConfig &= ~SLICER_NUMBERBITS_BITM; /* 2 bit on I, 2 bit on Q */
|
|
intConfig &= ~SLICER_BIT_POSITION_BITM; /* bits after sign at MSB */
|
|
intConfig |= SLICER_EMBED_EN_BITM; /* slicer embed enabled */
|
|
}
|
|
else if (rxDataFormat->intEmbeddedBits == TAL_EMBED_2_SLICERBITS_AT_LSB)
|
|
{
|
|
intConfig &= ~SLICER_NUMBERBITS_BITM; /* 2 bit on I, 2 bit on Q */
|
|
intConfig |= SLICER_BIT_POSITION_BITM; /* bits at LSB */
|
|
intConfig |= SLICER_EMBED_EN_BITM; /* slicer embed enabled */
|
|
}
|
|
|
|
if (rxDataFormat->intSampleResolution == TAL_INTEGER_12BIT_2SCOMP)
|
|
{
|
|
intConfig &= ~DATA_RESOLUTION_BITM; /* 12 bit */
|
|
intConfig &= ~SIGNED_MAGNITUDE_BITM; /* 2s comp */
|
|
npCheck = 12;
|
|
}
|
|
else if (rxDataFormat->intSampleResolution == TAL_INTEGER_12BIT_SIGNED)
|
|
{
|
|
intConfig &= ~DATA_RESOLUTION_BITM; /* 12 bit */
|
|
intConfig |= SIGNED_MAGNITUDE_BITM; /* signed */
|
|
npCheck = 12;
|
|
}
|
|
else if (rxDataFormat->intSampleResolution == TAL_INTEGER_16BIT_2SCOMP)
|
|
{
|
|
intConfig |= DATA_RESOLUTION_16BIT; /* 16 bit */
|
|
intConfig &= ~SIGNED_MAGNITUDE_BITM; /* 2s comp */
|
|
npCheck = 16;
|
|
}
|
|
else if (rxDataFormat->intSampleResolution == TAL_INTEGER_16BIT_SIGNED)
|
|
{
|
|
intConfig |= DATA_RESOLUTION_16BIT; /* 16 bit */
|
|
intConfig |= SIGNED_MAGNITUDE_BITM; /* signed */
|
|
npCheck = 16;
|
|
}
|
|
else if (rxDataFormat->intSampleResolution == TAL_INTEGER_24BIT_2SCOMP)
|
|
{
|
|
intConfig |= DATA_RESOLUTION_24BIT; /* 16 bit */
|
|
intConfig &= ~SIGNED_MAGNITUDE_BITM; /* 2s comp */
|
|
npCheck = 24;
|
|
}
|
|
else
|
|
{
|
|
intConfig |= DATA_RESOLUTION_24BIT; /* 16 bit */
|
|
intConfig |= SIGNED_MAGNITUDE_BITM; /* signed */
|
|
npCheck = 24;
|
|
}
|
|
|
|
if (rxDataFormat->formatSelect == TAL_GAIN_COMPENSATION_DISABLED)
|
|
{
|
|
intConfig &= ~SLICER_NUMBERBITS_BITM; /* 2 bit on I, 2 bit on Q */
|
|
intConfig &= ~SLICER_BIT_POSITION_BITM; /* bits after sign at MSB */
|
|
intConfig &= ~SLICER_EMBED_EN_BITM; /* slicer embed disable */
|
|
}
|
|
|
|
/* JESD204 Framer Nprime must be greater than or equal to the intSampleResolution */
|
|
if (((device->devStateInfo.profilesValid & RX_PROFILE_VALID) > 0) &&
|
|
(device->devStateInfo.rxFramerNp < npCheck))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_DATARES_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* JESD204 Framer Nprime must be greater than or equal to the intSampleResolution */
|
|
if (((device->devStateInfo.profilesValid & ORX_PROFILE_VALID) > 0) &&
|
|
(device->devStateInfo.orxFramerNp < npCheck))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_DATARES_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* write the floating point enable to FP off */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_ENABLE, 0x00);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* write integer configuration register */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_INTEGER_FORMAT_CONFIG, intConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
if (rxDataFormat->formatSelect == TAL_GAIN_WITH_INTSLICER)
|
|
{
|
|
/* verify needed GPIOs are unused */
|
|
gpioAssignMask = GPIO8_9_10_BITM | GPIO12_13_14_BITM;
|
|
if ((device->devStateInfo.usedGpiopins & gpioAssignMask) > 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RX1GPIO_INUSE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
slicerConfig = 0;
|
|
slicerConfig |= GAIN_COMP_EN_BITM; /* gain compensation on */
|
|
slicerConfig &= ~PIN_CONTROL_BITM; /* pin control internal */
|
|
slicerConfig |= ((uint8_t)rxDataFormat->extPinStepSize << 6); /* set gain step size */
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, slicerConfig, 0xE1, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* read nibble source */
|
|
retVal = (talRecoveryActions_t)TALISE_getGpioSourceCtrl(device, &srcCntrl);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* modify the nibble source control to allow outputs on GPIO 8,9,10, 12,13,14 */
|
|
srcCntrl &= INTSLICER_NIBBLE_CLEAR_BITM; /* clear bits [15:8] */
|
|
srcCntrl |= INTSLICER_NIBBLE_SOURCE;
|
|
|
|
/* write nibble source */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioSourceCtrl(device, srcCntrl);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* set used Gpios to output */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, gpioAssignMask, gpioAssignMask);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* success so assign the gpios */
|
|
device->devStateInfo.usedGpiopins |= gpioAssignMask;
|
|
} /* end intslicer */
|
|
else if (rxDataFormat->formatSelect == TAL_GAIN_WITH_INTSLICER_NOGPIO)
|
|
{
|
|
slicerConfig = 0;
|
|
slicerConfig |= GAIN_COMP_EN_BITM; /* gain compensation on */
|
|
slicerConfig &= ~PIN_CONTROL_BITM; /* pin control internal */
|
|
slicerConfig |= ((uint8_t)rxDataFormat->extPinStepSize << 6); /* set gain step size */
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, slicerConfig, 0xE1, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
} /* end nogpio */
|
|
else if (rxDataFormat->formatSelect == TAL_GAIN_WITH_EXTERNAL_SLICER)
|
|
{
|
|
/* verify that rx1 GPIOs are not disabled */
|
|
if (rxDataFormat->rx1GpioSelect == TAL_EXTSLICER_RX1_GPIO_DISABLE)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_EXTSLICER_RX1GPIO_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* verify that rx2 GPIOs are not disabled */
|
|
if (rxDataFormat->rx2GpioSelect == TAL_EXTSLICER_RX2_GPIO_DISABLE)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_EXTSLICER_RX2GPIO_INVPARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
slicerConfig = 0;
|
|
slicerConfig |= GAIN_COMP_EN_BITM; /* gain compensation on */
|
|
slicerConfig |= PIN_CONTROL_BITM; /* pin control external */
|
|
slicerConfig |= ((uint8_t)rxDataFormat->extPinStepSize << 6); /* set gain step size */
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, slicerConfig, 0xE1, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
if (rxDataFormat->rx1GpioSelect == TAL_EXTSLICER_RX1_GPIO0_1_2)
|
|
{
|
|
gpioAssignMask = GPIO0_1_2_BITM;
|
|
rx1Gpio = TAL_EXTSLICER_RX1_GPIO0_1_2;
|
|
}
|
|
else if (rxDataFormat->rx1GpioSelect == TAL_EXTSLICER_RX1_GPIO5_6_7)
|
|
{
|
|
gpioAssignMask = GPIO5_6_7_BITM;
|
|
rx1Gpio = TAL_EXTSLICER_RX1_GPIO5_6_7;
|
|
}
|
|
else if (rxDataFormat->rx1GpioSelect == TAL_EXTSLICER_RX1_GPIO8_9_10)
|
|
{
|
|
gpioAssignMask = GPIO8_9_10_BITM;
|
|
rx1Gpio = TAL_EXTSLICER_RX1_GPIO8_9_10;
|
|
}
|
|
|
|
if ((device->devStateInfo.usedGpiopins & gpioAssignMask) > 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RX1GPIO_INUSE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* success so assign the gpios */
|
|
device->devStateInfo.usedGpiopins |= gpioAssignMask;
|
|
|
|
/* write the slicer register contents */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_SLICER_GPIO_CONFIG, rx1Gpio);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
rx1GpioConfig = (taliseRx1ExtSlicerGpioSelect_t) rx1Gpio;
|
|
|
|
if (rxDataFormat->rx2GpioSelect == TAL_EXTSLICER_RX2_GPIO11_12_13)
|
|
{
|
|
gpioAssignMask = GPIO11_12_13_BITM;
|
|
rx2Gpio = TAL_EXTSLICER_RX2_GPIO11_12_13;
|
|
}
|
|
else if (rxDataFormat->rx2GpioSelect == TAL_EXTSLICER_RX2_GPIO5_6_7)
|
|
{
|
|
gpioAssignMask = GPIO5_6_7_BITM;
|
|
rx2Gpio = TAL_EXTSLICER_RX2_GPIO5_6_7;
|
|
}
|
|
|
|
/* check for special case of Rx1 and Rx2 slicer output on same GPIOs */
|
|
if (((device->devStateInfo.usedGpiopins & gpioAssignMask) > 0) &&
|
|
(rx1GpioConfig != ((int32_t) TAL_EXTSLICER_RX1_GPIO5_6_7)) &&
|
|
(rxDataFormat->rx2GpioSelect == TAL_EXTSLICER_RX2_GPIO5_6_7))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RX2GPIO_INUSE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
else if (((device->devStateInfo.usedGpiopins & gpioAssignMask) > 0) &&
|
|
(rxDataFormat->rx2GpioSelect == TAL_EXTSLICER_RX2_GPIO11_12_13))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_SET_RXDATAFRMT_RX2GPIO_INUSE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Insure Gpios to input */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, (~gpioAssignMask & GPIO_OE_BITM), gpioAssignMask);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* success so assign the gpios */
|
|
device->devStateInfo.usedGpiopins |= gpioAssignMask;
|
|
|
|
/* write the slicer register contents */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_SLICER_GPIO_CONFIG, rx2Gpio);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
} /* end external */
|
|
/* disable gain compensation */
|
|
else if (rxDataFormat->formatSelect == TAL_GAIN_COMPENSATION_DISABLED)
|
|
{
|
|
/* read for gain configuration register */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, &gainConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
gainConfig &= ~GAIN_COMP_EN_BITM; /* gain compensation off */
|
|
gainConfig &= ~PIN_CONTROL_BITM; /* pin control internal */
|
|
|
|
/* write gain configuration register */
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, gainConfig, 0xE1, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
}
|
|
} /* end integer mode */
|
|
|
|
return (uint32_t)retVal;
|
|
} /* end TALISE_setRxDataFormat */
|
|
|
|
uint32_t TALISE_getRxDataFormat(taliseDevice_t *device, taliseRxDataFormat_t *rxDataFormat)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
|
|
uint8_t config = 0;
|
|
uint8_t fpEnable = 0;
|
|
uint8_t intConfig = 0;
|
|
uint8_t intResolution = 0;
|
|
uint8_t gainEn = 0;
|
|
uint32_t srcCntrl = 0;
|
|
|
|
static const uint8_t GAIN_COMP_EN_BITM = 0x01;
|
|
static const uint8_t PIN_CONTROL_BITM = 0x20;
|
|
static const uint8_t EXT_LNA_COMP_BITM = 0x02;
|
|
static const uint8_t TEMP_GAIN_BITM = 0x01;
|
|
static const uint8_t ROUND_MODE_BITM = 0xE0;
|
|
static const uint8_t MSBLSB_FORMAT_BITM = 0x10;
|
|
static const uint8_t NUM_EXPBITS_BITM = 0x06;
|
|
static const uint8_t FP_ENCNAN_BITM = 0x08;
|
|
static const uint8_t FP_ENABLE_BITM = 0x03;
|
|
static const uint8_t HIDE_LEADING_ONES_BITM = 0x01;
|
|
static const uint8_t RX2_ATTEN_BITM = 0x38;
|
|
static const uint8_t RX1_ATTEN_BITM = 0x07;
|
|
static const uint8_t SLICER_NUMBER_BITM = 0x20;
|
|
static const uint8_t SLICER_POSITION_BITM = 0x10;
|
|
static const uint8_t EMBED_SLICER_BITM = 0x08;
|
|
static const uint8_t SLICER_STEPSIZE_BITM = 0xC0;
|
|
static const uint8_t DATA_RESOLUTION_BITM = 0x06;
|
|
static const uint8_t DATA_RESOLUTION_16BIT = 0x02;
|
|
static const uint8_t DATA_RESOLUTION_24BIT = 0x04;
|
|
static const uint8_t SIGNED_MAGNITUDE_BITM = 0x01;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getRxDataFormat()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
if (rxDataFormat == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_GET_DATAFORMAT_NULL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* fetch the floating point configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_CONFIG, &config);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
rxDataFormat->fpRoundMode = (taliseFpRoundModes_t) ((config & ROUND_MODE_BITM) >> 5);
|
|
rxDataFormat->fpDataFormat = ((config & MSBLSB_FORMAT_BITM) >> 4);
|
|
rxDataFormat->fpEncodeNan = ((config & FP_ENCNAN_BITM) >> 3);
|
|
rxDataFormat->fpNumExpBits = (taliseFpExponentModes_t) ((config & NUM_EXPBITS_BITM) >> 1);
|
|
rxDataFormat->fpHideLeadingOne = (config & HIDE_LEADING_ONES_BITM);
|
|
|
|
/* fetch the Rx Attenuation */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_CONTROL, &config);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
rxDataFormat->fpRx2Atten = (taliseFpAttenSteps_t) ((config & RX2_ATTEN_BITM) >> 3);
|
|
rxDataFormat->fpRx1Atten = (taliseFpAttenSteps_t) (config & RX1_ATTEN_BITM);
|
|
|
|
/* fetch the Integer configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_INTEGER_FORMAT_CONFIG, &intConfig);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
if ((intConfig & EMBED_SLICER_BITM) > 0)
|
|
{
|
|
if (((intConfig & SLICER_NUMBER_BITM) > 0) &&
|
|
((intConfig & SLICER_POSITION_BITM) > 0))
|
|
{
|
|
rxDataFormat->intEmbeddedBits = TAL_EMBED_1_SLICERBIT_AT_LSB;
|
|
}
|
|
else if (((intConfig & SLICER_NUMBER_BITM) == 0) &&
|
|
((intConfig & SLICER_POSITION_BITM) > 0))
|
|
{
|
|
rxDataFormat->intEmbeddedBits = TAL_EMBED_2_SLICERBITS_AT_LSB;
|
|
}
|
|
else if (((intConfig & SLICER_NUMBER_BITM) > 0) &&
|
|
((intConfig & SLICER_POSITION_BITM) == 0))
|
|
{
|
|
rxDataFormat->intEmbeddedBits = TAL_EMBED_1_SLICERBIT_AT_MSB;
|
|
}
|
|
else
|
|
{
|
|
rxDataFormat->intEmbeddedBits = TAL_EMBED_2_SLICERBITS_AT_MSB;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rxDataFormat->intEmbeddedBits = TAL_NO_EMBEDDED_SLICER_BITS;
|
|
}
|
|
|
|
/* fetch the Integer data resolution */
|
|
intResolution = intConfig;
|
|
|
|
if (((intResolution & DATA_RESOLUTION_BITM) == 0) &&
|
|
((intResolution & SIGNED_MAGNITUDE_BITM) > 0))
|
|
{
|
|
rxDataFormat->intSampleResolution = TAL_INTEGER_12BIT_SIGNED;
|
|
}
|
|
else if (((intResolution & DATA_RESOLUTION_BITM) == 0) &&
|
|
((intResolution & SIGNED_MAGNITUDE_BITM) == 0))
|
|
{
|
|
rxDataFormat->intSampleResolution = TAL_INTEGER_12BIT_2SCOMP;
|
|
}
|
|
else if (((intResolution & DATA_RESOLUTION_BITM) == DATA_RESOLUTION_16BIT) &&
|
|
((intResolution & SIGNED_MAGNITUDE_BITM) > 0))
|
|
{
|
|
rxDataFormat->intSampleResolution = TAL_INTEGER_16BIT_SIGNED;
|
|
}
|
|
else if (((intResolution & DATA_RESOLUTION_BITM) == DATA_RESOLUTION_16BIT) &&
|
|
((intResolution & SIGNED_MAGNITUDE_BITM) == 0))
|
|
{
|
|
rxDataFormat->intSampleResolution = TAL_INTEGER_16BIT_2SCOMP;
|
|
}
|
|
else if (((intResolution & DATA_RESOLUTION_BITM) == DATA_RESOLUTION_24BIT) &&
|
|
((intResolution & SIGNED_MAGNITUDE_BITM) > 0))
|
|
{
|
|
rxDataFormat->intSampleResolution = TAL_INTEGER_24BIT_SIGNED;
|
|
}
|
|
else
|
|
{
|
|
rxDataFormat->intSampleResolution = TAL_INTEGER_24BIT_2SCOMP;
|
|
}
|
|
|
|
/* fetch the Floating Point enable */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_FLOATING_POINT_ENABLE, &fpEnable);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* fetch the gain control configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_GAIN_COMPENATION_AND_SLICER_CONFIG, &gainEn);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
rxDataFormat->extPinStepSize = (taliseGainStepSize_t) ((gainEn & SLICER_STEPSIZE_BITM) >> 6);
|
|
|
|
/* fetch the rx1 gpio configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_RX1_SLICER_GPIO_CONFIG, &config);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
rxDataFormat->rx1GpioSelect = (taliseRx1ExtSlicerGpioSelect_t) config;
|
|
|
|
/* fetch the rx2 gpio configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_RX2_SLICER_GPIO_CONFIG, &config);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
rxDataFormat->rx2GpioSelect = (taliseRx2ExtSlicerGpioSelect_t) config;
|
|
|
|
if ((gainEn & GAIN_COMP_EN_BITM) > 0)
|
|
{
|
|
if ((fpEnable & FP_ENABLE_BITM) > 0)
|
|
{
|
|
rxDataFormat->formatSelect = TAL_GAIN_WITH_FLOATING_POINT;
|
|
}
|
|
else if ((gainEn & PIN_CONTROL_BITM) > 0)
|
|
{
|
|
rxDataFormat->formatSelect = TAL_GAIN_WITH_EXTERNAL_SLICER;
|
|
}
|
|
else
|
|
{
|
|
/* read nibble source */
|
|
retVal = (talRecoveryActions_t)TALISE_getGpioSourceCtrl(device, &srcCntrl);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* modify the nibble source control */
|
|
if ((srcCntrl & 0xFF00) == ((TAL_GPIO_SLICER_OUT_MODE << 12) | (TAL_GPIO_SLICER_OUT_MODE << 8)))
|
|
{
|
|
rxDataFormat->formatSelect = TAL_GAIN_WITH_INTSLICER;
|
|
}
|
|
else
|
|
{
|
|
rxDataFormat->formatSelect = TAL_GAIN_WITH_INTSLICER_NOGPIO;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rxDataFormat->formatSelect = TAL_GAIN_COMPENSATION_DISABLED;
|
|
}
|
|
|
|
/* fetch the misc gain configuration */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_GAIN_COMPENSATION_AND_SLICER_CONFIG2, &config);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
rxDataFormat->externalLnaGain = ((config & EXT_LNA_COMP_BITM) >> 1);
|
|
rxDataFormat->tempCompensationEnable = (config & TEMP_GAIN_BITM);
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_getSlicerPosition(taliseDevice_t *device, uint8_t *rx1SlicerPosition, uint8_t *rx2SlicerPosition)
|
|
{
|
|
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t slicerPosition = 0;
|
|
static const uint8_t POSITION_MASK = 0x07;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getSlicerPosition()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
if ((rx1SlicerPosition == NULL) ||
|
|
(rx2SlicerPosition == NULL))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_GET_SLICERPOS_NULL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* read the slicer positions */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_RXDP_SLICER_READBACK, &slicerPosition);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
*rx1SlicerPosition = slicerPosition & POSITION_MASK;
|
|
*rx2SlicerPosition = (slicerPosition >> 3) & POSITION_MASK;
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
static talRecoveryActions_t talSetRx1GainCtrlPin (taliseDevice_t *device, uint8_t enable, taliseGpioPinSel_t rxGainIncPin, taliseGpioPinSel_t rxGainDecPin)
|
|
{
|
|
uint8_t registerValue = 0;
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint32_t usedGpiopins = 0;
|
|
uint32_t gpioFreeMask = 0;
|
|
uint32_t gpioUsedMask = 0;
|
|
|
|
static const uint16_t TAL_RX1_INC_GAIN_GPIO0 = 0x00;
|
|
static const uint16_t TAL_RX1_INC_GAIN_GPIO10 = 0x01;
|
|
static const uint16_t TAL_RX1_INC_GAIN_DISABLE = 0x03;
|
|
static const uint16_t TAL_RX1_DEC_GAIN_GPIO1 = 0x00;
|
|
static const uint16_t TAL_RX1_DEC_GAIN_GPIO11 = 0x01;
|
|
static const uint16_t TAL_RX1_DEC_GAIN_DISABLE = 0x03;
|
|
|
|
|
|
uint16_t rx1GainIncPinSel = TAL_RX1_INC_GAIN_DISABLE;
|
|
uint16_t rx1GainDecPinSel = TAL_RX1_DEC_GAIN_DISABLE;
|
|
|
|
/* Free all used GPIO's based on current configuration*/
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_AGC_MANUAL_GAIN_CONTROL_CONFIG_RX1, ®isterValue);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
rx1GainIncPinSel = (uint16_t)((registerValue >> 4) & 0x03);
|
|
rx1GainDecPinSel = (uint16_t)((registerValue >> 2) & 0x03);
|
|
|
|
if (rx1GainIncPinSel == TAL_RX1_INC_GAIN_GPIO0)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_00);
|
|
}
|
|
|
|
else if (rx1GainIncPinSel == TAL_RX1_INC_GAIN_GPIO10)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_10);
|
|
}
|
|
|
|
if (rx1GainDecPinSel == TAL_RX1_DEC_GAIN_GPIO1)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_01);
|
|
}
|
|
|
|
else if (rx1GainDecPinSel == TAL_RX1_DEC_GAIN_GPIO11)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_11);
|
|
}
|
|
|
|
usedGpiopins = device->devStateInfo.usedGpiopins & ~gpioFreeMask;
|
|
|
|
/* check if GPIO's are available for the new configuration*/
|
|
if (enable > 0)
|
|
{
|
|
gpioUsedMask |= (1 << rxGainIncPin);
|
|
gpioUsedMask |= (1 << rxGainDecPin);
|
|
|
|
if ((usedGpiopins & gpioUsedMask) != 0)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_RX1_GPIO_IN_USE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
usedGpiopins |= gpioUsedMask;
|
|
rx1GainIncPinSel = (rxGainIncPin == TAL_GPIO_00) ? TAL_RX1_INC_GAIN_GPIO0 : TAL_RX1_INC_GAIN_GPIO10;
|
|
rx1GainDecPinSel = (rxGainDecPin == TAL_GPIO_01) ? TAL_RX1_DEC_GAIN_GPIO1 : TAL_RX1_DEC_GAIN_GPIO11;
|
|
}
|
|
else
|
|
{
|
|
rx1GainIncPinSel = TAL_RX1_INC_GAIN_DISABLE;
|
|
rx1GainDecPinSel = TAL_RX1_DEC_GAIN_DISABLE;
|
|
}
|
|
|
|
/* Program Pin mode configuration */
|
|
registerValue = (((uint8_t)rx1GainIncPinSel) << 4) | (((uint8_t)rx1GainDecPinSel) << 2) | ((enable > 0) ? 0x01 : 0x00);
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_AGC_MANUAL_GAIN_CONTROL_CONFIG_RX1, registerValue, 0x3D, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Set GPIO input enables */
|
|
/* - Set OE for all freed GPIO's to 0 (input) */
|
|
/* - Set OE for all used GPIO's to 0 (input) */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, 0, (gpioUsedMask | gpioFreeMask));
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Update used and freed GPIO's */
|
|
device->devStateInfo.usedGpiopins = usedGpiopins;
|
|
|
|
return retVal;
|
|
}
|
|
|
|
static talRecoveryActions_t talSetRx2GainCtrlPin (taliseDevice_t *device, uint8_t enable, taliseGpioPinSel_t rxGainIncPin, taliseGpioPinSel_t rxGainDecPin)
|
|
{
|
|
uint8_t registerValue = 0;
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint32_t usedGpiopins = 0;
|
|
uint32_t gpioFreeMask = 0;
|
|
uint32_t gpioUsedMask = 0;
|
|
|
|
static const uint16_t TAL_RX2_INC_GAIN_GPIO3 = 0x00;
|
|
static const uint16_t TAL_RX2_INC_GAIN_GPIO13 = 0x01;
|
|
static const uint16_t TAL_RX2_INC_GAIN_DISABLE = 0x03;
|
|
static const uint16_t TAL_RX2_DEC_GAIN_GPIO4 = 0x00;
|
|
static const uint16_t TAL_RX2_DEC_GAIN_GPIO14 = 0x01;
|
|
static const uint16_t TAL_RX2_DEC_GAIN_DISABLE = 0x03;
|
|
|
|
uint16_t rx2GainIncPinSel = TAL_RX2_INC_GAIN_DISABLE;
|
|
uint16_t rx2GainDecPinSel = TAL_RX2_DEC_GAIN_DISABLE;
|
|
|
|
/* Free all used GPIO's based on current configuration*/
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_AGC_MANUAL_GAIN_CONTROL_CONFIG_RX2, ®isterValue);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
rx2GainIncPinSel = (uint16_t)((registerValue >> 4) & 0x03);
|
|
rx2GainDecPinSel = (uint16_t)((registerValue >> 2) & 0x03);
|
|
|
|
if (rx2GainIncPinSel == TAL_RX2_INC_GAIN_GPIO3)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_03);
|
|
}
|
|
|
|
else if (rx2GainIncPinSel == TAL_RX2_INC_GAIN_GPIO13)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_13);
|
|
}
|
|
|
|
if (rx2GainDecPinSel == TAL_RX2_DEC_GAIN_GPIO4)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_04);
|
|
}
|
|
|
|
else if (rx2GainDecPinSel == TAL_RX2_DEC_GAIN_GPIO14)
|
|
{
|
|
gpioFreeMask |= (1 << TAL_GPIO_14);
|
|
}
|
|
|
|
usedGpiopins = device->devStateInfo.usedGpiopins & ~gpioFreeMask;
|
|
|
|
/* check if GPIO's are available for the new configuration*/
|
|
if (enable > 0)
|
|
{
|
|
gpioUsedMask |= (1 << rxGainIncPin);
|
|
gpioUsedMask |= (1 << rxGainDecPin);
|
|
|
|
if ((usedGpiopins & gpioUsedMask) != 0)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_RX2_GPIO_IN_USE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
usedGpiopins |= gpioUsedMask;
|
|
rx2GainIncPinSel = (rxGainIncPin == TAL_GPIO_03) ? TAL_RX2_INC_GAIN_GPIO3 : TAL_RX2_INC_GAIN_GPIO13;
|
|
rx2GainDecPinSel = (rxGainDecPin == TAL_GPIO_04) ? TAL_RX2_DEC_GAIN_GPIO4 : TAL_RX2_DEC_GAIN_GPIO14;
|
|
}
|
|
else
|
|
{
|
|
rx2GainIncPinSel = TAL_RX2_INC_GAIN_DISABLE;
|
|
rx2GainDecPinSel = TAL_RX2_DEC_GAIN_DISABLE;
|
|
}
|
|
|
|
/* Program Pin mode configuration */
|
|
registerValue = (((uint8_t)rx2GainIncPinSel) << 4) | (((uint8_t)rx2GainDecPinSel) << 2) | ((enable > 0) ? 0x01 : 0x00);
|
|
halError = talSpiWriteField(device->devHalInfo, TALISE_ADDR_AGC_MANUAL_GAIN_CONTROL_CONFIG_RX2, registerValue, 0x3D, 0);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Set GPIO input enables */
|
|
/* - Set OE for all freed GPIO's to 0 (input) */
|
|
/* - Set OE for all used GPIO's to 0 (input) */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpioOe(device, 0, (gpioUsedMask | gpioFreeMask));
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Update used and freed GPIO's */
|
|
device->devStateInfo.usedGpiopins = usedGpiopins;
|
|
|
|
return retVal;
|
|
}
|
|
|
|
uint32_t TALISE_setRxGainCtrlPin(taliseDevice_t *device, taliseRxChannels_t rxChannel, taliseRxGainCtrlPin_t *rxGainCtrlPin)
|
|
{
|
|
uint8_t regVal = 0;
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
static const uint8_t MAX_STEP = 0x07;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError =talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_setRxGainCtrlPin()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
switch (rxChannel)
|
|
{
|
|
case TAL_RX1:
|
|
if ( rxGainCtrlPin->enable > 0 )
|
|
{
|
|
if ((rxGainCtrlPin->rxGainIncPin != TAL_GPIO_00) && (rxGainCtrlPin->rxGainIncPin != TAL_GPIO_10))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_RX1_INC_PIN, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((rxGainCtrlPin->rxGainDecPin != TAL_GPIO_01) && (rxGainCtrlPin->rxGainDecPin != TAL_GPIO_11))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_RX1_DEC_PIN, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
retVal = talSetRx1GainCtrlPin(device, rxGainCtrlPin->enable, rxGainCtrlPin->rxGainIncPin, rxGainCtrlPin->rxGainDecPin);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
break;
|
|
|
|
case TAL_RX2:
|
|
if (rxGainCtrlPin->enable > 0)
|
|
{
|
|
if ((rxGainCtrlPin->rxGainIncPin != TAL_GPIO_03) && (rxGainCtrlPin->rxGainIncPin != TAL_GPIO_13))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_RX2_INC_PIN, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((rxGainCtrlPin->rxGainDecPin != TAL_GPIO_04) && (rxGainCtrlPin->rxGainDecPin != TAL_GPIO_14))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_RX2_DEC_PIN, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
retVal = talSetRx2GainCtrlPin(device, rxGainCtrlPin->enable, rxGainCtrlPin->rxGainIncPin, rxGainCtrlPin->rxGainDecPin);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
break;
|
|
|
|
default:
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
|
|
/* Error checking for gain steps. */
|
|
if (rxGainCtrlPin->incStep > MAX_STEP)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_INC_STEP, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxGainCtrlPin->decStep > MAX_STEP)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETRXMGCPINCTRL_INV_DEC_STEP, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Write Gain step */
|
|
regVal = (rxGainCtrlPin->incStep << 3) | rxGainCtrlPin->decStep;
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_MANUAL_GAIN_CONFIG, regVal);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_getRxGainCtrlPin(taliseDevice_t *device, taliseRxChannels_t rxChannel, taliseRxGainCtrlPin_t *rxGainCtrlPin)
|
|
{
|
|
uint8_t regVal = 0;
|
|
uint8_t pinSel = 0;
|
|
uint16_t mgcConfigAddr = 0;
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError =talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getRxGainCtrlPin()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
/* Read current value of Gain inc/dec and enable */
|
|
switch (rxChannel)
|
|
{
|
|
case TAL_RX1:
|
|
mgcConfigAddr = TALISE_ADDR_AGC_MANUAL_GAIN_CONTROL_CONFIG_RX1;
|
|
break;
|
|
|
|
case TAL_RX2:
|
|
mgcConfigAddr = TALISE_ADDR_AGC_MANUAL_GAIN_CONTROL_CONFIG_RX2;
|
|
break;
|
|
|
|
default:
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETRXMGCPINCTRL_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
|
|
/*Check passed pointers for NULL */
|
|
if (rxGainCtrlPin == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_GETRXMGCPINCTRL_NULL_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Gain Inc, Gain dec, enable */
|
|
halError = talSpiReadByte(device->devHalInfo, mgcConfigAddr, ®Val);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
pinSel = (regVal >> 4) & 0x03;
|
|
rxGainCtrlPin->rxGainIncPin = (rxChannel == TAL_RX1) ? ((pinSel == 0x00) ? TAL_GPIO_00 : (( pinSel == 0x01) ? TAL_GPIO_10 : TAL_GPIO_INVALID))
|
|
: ((pinSel == 0x00) ? TAL_GPIO_03 : (( pinSel == 0x01) ? TAL_GPIO_13 : TAL_GPIO_INVALID));
|
|
pinSel = (regVal >> 2) & 0x03;
|
|
rxGainCtrlPin->rxGainDecPin = (rxChannel == TAL_RX1) ? ((pinSel == 0x00) ? TAL_GPIO_01 : (( pinSel == 0x01) ? TAL_GPIO_11 : TAL_GPIO_INVALID))
|
|
: ((pinSel == 0x00) ? TAL_GPIO_04 : (( pinSel == 0x01) ? TAL_GPIO_14 : TAL_GPIO_INVALID));
|
|
rxGainCtrlPin->enable = regVal & 0x01;
|
|
|
|
/* Gain step */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_MANUAL_GAIN_CONFIG, ®Val);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
rxGainCtrlPin->incStep = (regVal >> 3) & 0x7;
|
|
rxGainCtrlPin->decStep = regVal & 0x7;
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
talRecoveryActions_t talSetDualBandSettings(taliseDevice_t *device, taliseInit_t *init)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
int32_t pfirFs_kHz = 0;
|
|
int32_t pfirFsDiv2_kHz = 0;
|
|
int32_t outFs_kHz = 0;
|
|
int32_t outFsDiv2_kHz = 0;
|
|
int32_t upperBandBandwidthDiv2_kHz = 0;
|
|
int32_t lowerBandBandwidthDiv2_kHz = 0;
|
|
int32_t bandSeparation_kHz = 0;
|
|
int32_t maxLowerBandShiftCenterFreq_kHz = 0;
|
|
int32_t minLowerBandShiftCenterFreq_kHz = 0;
|
|
int32_t lowerBandShiftCenterFreq_kHz = 0;
|
|
int32_t lowerBandNco1Freq_kHz = 0;
|
|
int32_t maxUpperBandShiftCenterFreq_kHz = 0;
|
|
int32_t minUpperBandShiftCenterFreq_kHz = 0;
|
|
int32_t upperBandShiftCenterFreq_kHz = 0;
|
|
int32_t upperBandNco1Freq_kHz = 0;
|
|
int32_t lowerBandNco2Freq_kHz = 0;
|
|
int32_t upperBandNco2Freq_kHz = 0;
|
|
uint32_t lowerBandNco1FreqUnsigned_kHz = 0;
|
|
uint32_t upperBandNco1FreqUnsigned_kHz = 0;
|
|
uint32_t lowerBandNco2FreqUnsigned_kHz = 0;
|
|
uint32_t upperBandNco2FreqUnsigned_kHz = 0;
|
|
uint64_t lowerBandNco1Ftw = 0;
|
|
uint64_t upperBandNco1Ftw = 0;
|
|
uint64_t lowerBandNco2Ftw = 0;
|
|
uint64_t upperBandNco2Ftw = 0;
|
|
|
|
int32_t inUpperBandCenterFreq_kHz = 0;
|
|
int32_t inLowerBandCenterFreq_kHz = 0;
|
|
int32_t outUpperBandCenterFreq_kHz = 0;
|
|
int32_t outLowerBandCenterFreq_kHz = 0;
|
|
|
|
static const uint64_t POW_2_32 = ((uint64_t)1) << 32;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "talSetDualBandSettings()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
inUpperBandCenterFreq_kHz = init->rx.rxProfile.rxNcoShifterCfg.bandAInputCenterFreq_kHz;
|
|
inLowerBandCenterFreq_kHz = init->rx.rxProfile.rxNcoShifterCfg.bandBInputCenterFreq_kHz;
|
|
|
|
outUpperBandCenterFreq_kHz = inUpperBandCenterFreq_kHz + init->rx.rxProfile.rxNcoShifterCfg.bandANco1Freq_kHz +
|
|
init->rx.rxProfile.rxNcoShifterCfg.bandANco2Freq_kHz;
|
|
outLowerBandCenterFreq_kHz = inLowerBandCenterFreq_kHz + init->rx.rxProfile.rxNcoShifterCfg.bandBNco1Freq_kHz +
|
|
init->rx.rxProfile.rxNcoShifterCfg.bandBNco2Freq_kHz;
|
|
|
|
/* Fs at output of PFIR : Twice output rate due to decimation in DDC */
|
|
pfirFsDiv2_kHz = device->devStateInfo.rxOutputRate_kHz;
|
|
pfirFs_kHz = pfirFsDiv2_kHz << 1;
|
|
|
|
/* Output Fs and Fs/2 */
|
|
outFs_kHz = pfirFsDiv2_kHz;
|
|
outFsDiv2_kHz = outFs_kHz >> 1;
|
|
|
|
/* Bandwidth /2 */
|
|
upperBandBandwidthDiv2_kHz = (init->rx.rxProfile.rxNcoShifterCfg.bandAInputBandWidth_kHz >> 1);
|
|
lowerBandBandwidthDiv2_kHz = (init->rx.rxProfile.rxNcoShifterCfg.bandBInputBandWidth_kHz >> 1);
|
|
|
|
/* Check : Center frequency of input lower band is less than input upper band */
|
|
if (inLowerBandCenterFreq_kHz > inUpperBandCenterFreq_kHz)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_INV_CENTER_FREQ, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check : Band should be separated by at least 1 khz */
|
|
if (((inUpperBandCenterFreq_kHz - upperBandBandwidthDiv2_kHz) -
|
|
(inLowerBandCenterFreq_kHz + lowerBandBandwidthDiv2_kHz)) < 0)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_INV_BAND_SEP, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check : Upper end of upper band input is less than +PfirFs/2 */
|
|
if ((inUpperBandCenterFreq_kHz + upperBandBandwidthDiv2_kHz) > pfirFsDiv2_kHz)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_INV_IN_UPPER_FREQ, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check : Lower end of lower band input is more than -PfirFs/2 */
|
|
if ((inLowerBandCenterFreq_kHz - lowerBandBandwidthDiv2_kHz) < -pfirFsDiv2_kHz)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_INV_IN_LOWER_FREQ, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check : upper band output is between -OutFs/2 and +OutFs/2 */
|
|
if (((outUpperBandCenterFreq_kHz + upperBandBandwidthDiv2_kHz) > outFsDiv2_kHz) ||
|
|
((outUpperBandCenterFreq_kHz - upperBandBandwidthDiv2_kHz) < -outFsDiv2_kHz))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_INV_OUT_UPPER_FREQ, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check : lower band output is between -OutFs/2 and +OutFs/2 */
|
|
if (((outLowerBandCenterFreq_kHz + lowerBandBandwidthDiv2_kHz) > outFsDiv2_kHz) ||
|
|
((outLowerBandCenterFreq_kHz - lowerBandBandwidthDiv2_kHz) < -outFsDiv2_kHz))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_INV_OUT_LOWER_FREQ, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check: Output upper and lower bands dont overlap */
|
|
/* Error if 'lower end of lowerBand' < 'higher end of upperBand' and 'lower end of upperBand' < 'higher end of lowerBand' */
|
|
if (((outLowerBandCenterFreq_kHz - lowerBandBandwidthDiv2_kHz) <
|
|
(outUpperBandCenterFreq_kHz + upperBandBandwidthDiv2_kHz)) &&
|
|
((outUpperBandCenterFreq_kHz - upperBandBandwidthDiv2_kHz) <
|
|
(outLowerBandCenterFreq_kHz + lowerBandBandwidthDiv2_kHz)))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_OUT_OVERLAP, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Separation between the two bands */
|
|
bandSeparation_kHz = (pfirFs_kHz - lowerBandBandwidthDiv2_kHz - upperBandBandwidthDiv2_kHz -
|
|
(inUpperBandCenterFreq_kHz - inLowerBandCenterFreq_kHz));
|
|
|
|
/* Move lower band up to the upper end of DEC2 passband. */
|
|
/* This value assumes that the upper band does not alias back into the lower side of DEC2 passband */
|
|
maxLowerBandShiftCenterFreq_kHz = (outFsDiv2_kHz - lowerBandBandwidthDiv2_kHz);
|
|
|
|
/* This value assumes that upper band can alias back into lower side of DEC2 passband. The shift is hence limited by band separation */
|
|
minLowerBandShiftCenterFreq_kHz = (-outFsDiv2_kHz + bandSeparation_kHz + lowerBandBandwidthDiv2_kHz);
|
|
|
|
/* The value that the lower band can be shifted upwards is the minimum of the two values */
|
|
lowerBandShiftCenterFreq_kHz = (maxLowerBandShiftCenterFreq_kHz < minLowerBandShiftCenterFreq_kHz) ? maxLowerBandShiftCenterFreq_kHz : minLowerBandShiftCenterFreq_kHz;
|
|
|
|
/* NCO1 Frequency to tune to for lower band: NCO frequency = Fout - Fin , since I and Q are swapped */
|
|
lowerBandNco1Freq_kHz = (lowerBandShiftCenterFreq_kHz - inLowerBandCenterFreq_kHz);
|
|
|
|
/* Move upper band down to the lower end of DEC2 passband. */
|
|
/* This value assumes that the lower band does not alias back into the upper side of DEC2 passband */
|
|
maxUpperBandShiftCenterFreq_kHz = (-outFsDiv2_kHz + upperBandBandwidthDiv2_kHz);
|
|
|
|
/* This value assumes that lower band can alias back into upper side of DEC2 passband. The shift is hence limited by band separation */
|
|
minUpperBandShiftCenterFreq_kHz = (outFsDiv2_kHz - bandSeparation_kHz - upperBandBandwidthDiv2_kHz) ;
|
|
|
|
/* The value that the Upper band can be shifted downwards is the max of the two values */
|
|
upperBandShiftCenterFreq_kHz = (maxUpperBandShiftCenterFreq_kHz > minUpperBandShiftCenterFreq_kHz) ? maxUpperBandShiftCenterFreq_kHz : minUpperBandShiftCenterFreq_kHz;
|
|
|
|
/* NCO1 Frequency to tune to for upper: NCO frequency = Fout - Fin , since I and Q are swapped*/
|
|
upperBandNco1Freq_kHz = (upperBandShiftCenterFreq_kHz - inUpperBandCenterFreq_kHz);
|
|
|
|
/* To convert from lowerBandShiftCenterFreq_kHz to outLowerBandCenterFreq_kHz */
|
|
lowerBandNco2Freq_kHz = (outLowerBandCenterFreq_kHz - lowerBandShiftCenterFreq_kHz);
|
|
|
|
/* To convert from upperBandShiftCenterFreq_kHz to outUpperBandCenterFreq_kHz */
|
|
upperBandNco2Freq_kHz = (outUpperBandCenterFreq_kHz - upperBandShiftCenterFreq_kHz);
|
|
|
|
/* Convert negative to positive frequencies */
|
|
lowerBandNco1FreqUnsigned_kHz = (lowerBandNco1Freq_kHz > 0) ? lowerBandNco1Freq_kHz : (pfirFs_kHz + lowerBandNco1Freq_kHz);
|
|
upperBandNco1FreqUnsigned_kHz = (upperBandNco1Freq_kHz > 0) ? upperBandNco1Freq_kHz : (pfirFs_kHz + upperBandNco1Freq_kHz);
|
|
lowerBandNco2FreqUnsigned_kHz = (lowerBandNco2Freq_kHz > 0) ? lowerBandNco2Freq_kHz : (outFs_kHz + lowerBandNco2Freq_kHz);
|
|
upperBandNco2FreqUnsigned_kHz = (upperBandNco2Freq_kHz > 0) ? upperBandNco2Freq_kHz : (outFs_kHz + upperBandNco2Freq_kHz);
|
|
|
|
/* Convert positive frequencies to their FTW equivalents */
|
|
lowerBandNco1Ftw = ((((uint64_t)lowerBandNco1FreqUnsigned_kHz * POW_2_32) << 1) + pfirFs_kHz) / (pfirFs_kHz << 1); /* integer rounding */
|
|
upperBandNco1Ftw = ((((uint64_t)upperBandNco1FreqUnsigned_kHz * POW_2_32) << 1) + pfirFs_kHz) / (pfirFs_kHz << 1); /* integer rounding */
|
|
lowerBandNco2Ftw = ((((uint64_t)lowerBandNco2FreqUnsigned_kHz * POW_2_32) << 1) + outFs_kHz) / (outFs_kHz << 1); /* integer rounding */
|
|
upperBandNco2Ftw = ((((uint64_t)upperBandNco2FreqUnsigned_kHz * POW_2_32) << 1) + outFs_kHz) / (outFs_kHz << 1); /* integer rounding */
|
|
|
|
/* Check FTW is not more than 32 bits */
|
|
if ((lowerBandNco1Ftw >= POW_2_32) || (upperBandNco1Ftw >= POW_2_32) ||
|
|
(lowerBandNco2Ftw >= POW_2_32) || (upperBandNco2Ftw >= POW_2_32))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETDUALBANDSETTINGS_FTW_OVRG, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Write to FTW - lower Band NCO 1*/
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH1_FTW_BYTE4, (uint8_t)(lowerBandNco1Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH1_FTW_BYTE3, (uint8_t)(lowerBandNco1Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH1_FTW_BYTE2, (uint8_t)(lowerBandNco1Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH1_FTW_BYTE1, (uint8_t)(lowerBandNco1Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH2_FTW_BYTE4, (uint8_t)(lowerBandNco1Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH2_FTW_BYTE3, (uint8_t)(lowerBandNco1Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH2_FTW_BYTE2, (uint8_t)(lowerBandNco1Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_CH2_FTW_BYTE1, (uint8_t)(lowerBandNco1Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Write to FTW - upper Band NCO 1*/
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO1_FTW_BYTE4, (uint8_t)(upperBandNco1Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO1_FTW_BYTE3, (uint8_t)(upperBandNco1Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO1_FTW_BYTE2, (uint8_t)(upperBandNco1Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO1_FTW_BYTE1, (uint8_t)(upperBandNco1Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO1_FTW_BYTE4, (uint8_t)(upperBandNco1Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO1_FTW_BYTE3, (uint8_t)(upperBandNco1Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO1_FTW_BYTE2, (uint8_t)(upperBandNco1Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO1_FTW_BYTE1, (uint8_t)(upperBandNco1Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Write to FTW - lower Band NCO 2*/
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_A_NCO2_FTW_BYTE4, (uint8_t)(lowerBandNco2Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_A_NCO2_FTW_BYTE3, (uint8_t)(lowerBandNco2Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_A_NCO2_FTW_BYTE2, (uint8_t)(lowerBandNco2Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_A_NCO2_FTW_BYTE1, (uint8_t)(lowerBandNco2Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_A_NCO2_FTW_BYTE4, (uint8_t)(lowerBandNco2Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_A_NCO2_FTW_BYTE3, (uint8_t)(lowerBandNco2Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_A_NCO2_FTW_BYTE2, (uint8_t)(lowerBandNco2Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_A_NCO2_FTW_BYTE1, (uint8_t)(lowerBandNco2Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Write to FTW - upper Band NCO 2*/
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO2_FTW_BYTE4, (uint8_t)(upperBandNco2Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO2_FTW_BYTE3, (uint8_t)(upperBandNco2Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO2_FTW_BYTE2, (uint8_t)(upperBandNco2Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_BAND_B_NCO2_FTW_BYTE1, (uint8_t)(upperBandNco2Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO2_FTW_BYTE4, (uint8_t)(upperBandNco2Ftw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO2_FTW_BYTE3, (uint8_t)(upperBandNco2Ftw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO2_FTW_BYTE2, (uint8_t)(upperBandNco2Ftw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_BAND_B_NCO2_FTW_BYTE1, (uint8_t)(upperBandNco2Ftw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Update FTW words */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_FTW_UPDATE_CONTROL, 0xFF);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
static talRecoveryActions_t talSetRxNcoFtw(taliseDevice_t *device, taliseRxNcoChannel_t rxNcoChannel, uint32_t ncoFtw)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint16_t spiAddr = 0;
|
|
|
|
switch(rxNcoChannel)
|
|
{
|
|
case TAL_RX1_NCO1A: spiAddr = TALISE_ADDR_RX_NCO_CH1_FTW_BYTE4; break;
|
|
case TAL_RX1_NCO1B: spiAddr = TALISE_ADDR_RX1_BAND_B_NCO1_FTW_BYTE4; break;
|
|
case TAL_RX1_NCO2A: spiAddr = TALISE_ADDR_RX1_BAND_A_NCO2_FTW_BYTE4; break;
|
|
case TAL_RX1_NCO2B: spiAddr = TALISE_ADDR_RX1_BAND_B_NCO2_FTW_BYTE4; break;
|
|
case TAL_RX2_NCO1A: spiAddr = TALISE_ADDR_RX_NCO_CH2_FTW_BYTE4; break;
|
|
case TAL_RX2_NCO1B: spiAddr = TALISE_ADDR_RX2_BAND_B_NCO1_FTW_BYTE4; break;
|
|
case TAL_RX2_NCO2A: spiAddr = TALISE_ADDR_RX2_BAND_A_NCO2_FTW_BYTE4; break;
|
|
case TAL_RX2_NCO2B: spiAddr = TALISE_ADDR_RX2_BAND_B_NCO2_FTW_BYTE4; break;
|
|
default:
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_RXNCOFTW_INVNCO, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Write to FTW - NCO 1*/
|
|
halError = talSpiWriteByte(device->devHalInfo, spiAddr, (uint8_t)(ncoFtw >> 24));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, (spiAddr + 1), (uint8_t)(ncoFtw >> 16));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, (spiAddr + 2), (uint8_t)(ncoFtw >> 8));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, (spiAddr + 3), (uint8_t)(ncoFtw));
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
talRecoveryActions_t talSetupNcoShifter(taliseDevice_t *device, taliseInit_t *init)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
int32_t pfirFs_kHz = 0;
|
|
int32_t outFs_kHz = 0;
|
|
int32_t ddcOutFsDiv2_kHz = 0;
|
|
uint32_t nco1FreqUnsigned_kHz = 0;
|
|
uint64_t nco1Ftw = 0;
|
|
uint32_t nco2FreqUnsigned_kHz = 0;
|
|
uint64_t nco2Ftw = 0;
|
|
int32_t inputCenterFreq_kHz = 0;
|
|
int32_t nco1OutputCenterFreq_khz = 0;
|
|
int32_t nco2OutputCenterFreq_khz = 0;
|
|
int32_t bandWidthDiv2 = 0;
|
|
uint8_t ddcHbEnabled = 0;
|
|
int32_t ddcHbCorner_kHz = 0;
|
|
int32_t pfirCorner_kHz = 0;
|
|
uint8_t ncoUpdateFtw = 0;
|
|
|
|
static const uint64_t POW_2_32 = ((uint64_t)1) << 32;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "talRecoveryActions_t()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
bandWidthDiv2 = init->rx.rxProfile.rxNcoShifterCfg.bandAInputBandWidth_kHz >> 1;
|
|
|
|
inputCenterFreq_kHz = init->rx.rxProfile.rxNcoShifterCfg.bandAInputCenterFreq_kHz;
|
|
nco1OutputCenterFreq_khz = inputCenterFreq_kHz + init->rx.rxProfile.rxNcoShifterCfg.bandANco1Freq_kHz;
|
|
nco2OutputCenterFreq_khz = nco1OutputCenterFreq_khz + init->rx.rxProfile.rxNcoShifterCfg.bandANco2Freq_kHz;
|
|
|
|
/* scale the pfirFs for the selected DDC mode */
|
|
/* Fs at output of PFIR : Twice output rate due to decimation in DDC */
|
|
if ((init->rx.rxProfile.rxDdcMode == TAL_RXDDC_DEC2) ||
|
|
(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_DEC2_REALIF))
|
|
{
|
|
pfirFs_kHz = device->devStateInfo.rxOutputRate_kHz << 1;
|
|
ddcHbEnabled = 1;
|
|
|
|
/* DDC HB corner is at 0.4 * rx output rate. 0.4 = 2/5 */
|
|
ddcHbCorner_kHz = (int32_t)(device->devStateInfo.rxOutputRate_kHz << 1) / 5;
|
|
}
|
|
else if ((init->rx.rxProfile.rxDdcMode == TAL_RXDDC_INT2) ||
|
|
(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_INT2_REALIF))
|
|
{
|
|
pfirFs_kHz = device->devStateInfo.rxOutputRate_kHz >> 1;
|
|
ddcHbEnabled = 1;
|
|
|
|
/* DDC HB corner is at 0.4 * (rx output rate/2). 0.4 = 2/5 */
|
|
ddcHbCorner_kHz = (int32_t)(device->devStateInfo.rxOutputRate_kHz) / 5;
|
|
}
|
|
else if ((init->rx.rxProfile.rxDdcMode == TAL_RXDDC_FILTERONLY) ||
|
|
(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_FILTERONLY_REALIF))
|
|
{
|
|
pfirFs_kHz = device->devStateInfo.rxOutputRate_kHz;
|
|
ddcHbEnabled = 1;
|
|
|
|
/* DDC HB corner is at 0.4 * (rx output rate/2). 0.4 = 2/5 */
|
|
ddcHbCorner_kHz = (int32_t)(device->devStateInfo.rxOutputRate_kHz) / 5;
|
|
}
|
|
else if ((init->rx.rxProfile.rxDdcMode == TAL_RXDDC_BYPASS) ||
|
|
(init->rx.rxProfile.rxDdcMode == TAL_RXDDC_BYPASS_REALIF))
|
|
{
|
|
pfirFs_kHz = device->devStateInfo.rxOutputRate_kHz;
|
|
ddcHbEnabled = 0;
|
|
|
|
/* DDC HB corner is at the Pfir corner since HalfBand is disabled */
|
|
ddcHbCorner_kHz = (int32_t)((init->rx.rxProfile.rfBandwidth_Hz / 1000) >> 1);;
|
|
}
|
|
|
|
outFs_kHz = device->devStateInfo.rxOutputRate_kHz;
|
|
ddcOutFsDiv2_kHz = (outFs_kHz >> 1);
|
|
|
|
pfirCorner_kHz = ((init->rx.rxProfile.rfBandwidth_Hz / 1000) >> 1);
|
|
|
|
|
|
/* Range check that signal passband edges are within Rx PFIR corners */
|
|
if (((inputCenterFreq_kHz + bandWidthDiv2) > pfirCorner_kHz) ||
|
|
((inputCenterFreq_kHz - bandWidthDiv2) < -pfirCorner_kHz))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETUPNCOSHIFTER_INV_PFIR_CORNER, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* If DDC HB enabled, verify that input signal after possible NCO1 shift is in passband of DDC HB */
|
|
if (ddcHbEnabled > 0)
|
|
{
|
|
if (((nco1OutputCenterFreq_khz + bandWidthDiv2) > ddcHbCorner_kHz) ||
|
|
((nco1OutputCenterFreq_khz - bandWidthDiv2) < -ddcHbCorner_kHz))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETUPNCOSHIFTER_INV_DDCHB_CORNER, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
|
|
/* Range check NCO2 shifted output is within -Fs/2 to Fs/2 of Rx output rate */
|
|
if (((nco2OutputCenterFreq_khz + bandWidthDiv2) > ddcOutFsDiv2_kHz) ||
|
|
((nco2OutputCenterFreq_khz - bandWidthDiv2) < -ddcOutFsDiv2_kHz))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETUPNCOSHIFTER_INV_NCO2SHIFT, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* if nco1 shift */
|
|
if (init->rx.rxProfile.rxNcoShifterCfg.bandANco1Freq_kHz != 0)
|
|
{
|
|
/* Convert from -ve frequencies to their positive equivalents */
|
|
nco1FreqUnsigned_kHz = (init->rx.rxProfile.rxNcoShifterCfg.bandANco1Freq_kHz >= 0)
|
|
? init->rx.rxProfile.rxNcoShifterCfg.bandANco1Freq_kHz
|
|
: (pfirFs_kHz + init->rx.rxProfile.rxNcoShifterCfg.bandANco1Freq_kHz) ;
|
|
|
|
/* Convert positive frequencies to their FTW equivalents */
|
|
nco1Ftw = ((((uint64_t)nco1FreqUnsigned_kHz * POW_2_32) << 1) + pfirFs_kHz) / (pfirFs_kHz << 1); /* integer rounding */
|
|
|
|
/* Check FTW is not more than 32 bits */
|
|
if (nco1Ftw >= POW_2_32)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETUPNCOSHIFTER_FTW_OVRG, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
retVal = talSetRxNcoFtw(device, TAL_RX1_NCO1A, (uint32_t)nco1Ftw);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
retVal = talSetRxNcoFtw(device, TAL_RX2_NCO1A, (uint32_t)nco1Ftw);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Update FTW words - write at bottom of function */
|
|
ncoUpdateFtw |= 0x11;
|
|
}
|
|
|
|
/* if nco2 shift */
|
|
if (init->rx.rxProfile.rxNcoShifterCfg.bandANco2Freq_kHz != 0)
|
|
{
|
|
/* Convert from -ve frequencies to their positive equivalents */
|
|
|
|
nco2FreqUnsigned_kHz = (init->rx.rxProfile.rxNcoShifterCfg.bandANco2Freq_kHz >= 0)
|
|
? init->rx.rxProfile.rxNcoShifterCfg.bandANco2Freq_kHz
|
|
: (outFs_kHz + init->rx.rxProfile.rxNcoShifterCfg.bandANco2Freq_kHz);
|
|
|
|
/* Convert positive frequencies to their FTW equivalents */
|
|
nco2Ftw = ((((uint64_t)nco2FreqUnsigned_kHz * POW_2_32) << 1) + outFs_kHz) / (outFs_kHz << 1); /* integer rounding */
|
|
|
|
/* Check FTW is not more than 32 bits */
|
|
if (nco2Ftw >= POW_2_32)
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETUPNCOSHIFTER_FTW_OVRG, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
retVal = talSetRxNcoFtw(device, TAL_RX1_NCO2A, (uint32_t)nco2Ftw);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
retVal = talSetRxNcoFtw(device, TAL_RX2_NCO2A, (uint32_t)nco2Ftw);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Update NCO2 FTW words */
|
|
ncoUpdateFtw |= 0x44;
|
|
}
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX_NCO_FTW_UPDATE_CONTROL, ncoUpdateFtw);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
return retVal;
|
|
}
|
|
|
|
uint32_t TALISE_programDualBandLnaGainTable( taliseDevice_t *device, taliseDualBandLnaGainTable_t *gainTablePtr, uint8_t numGainIndexesInTable, taliseRxChannels_t rxChannel)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t registerValue = 0;
|
|
uint8_t gtConfigReg = 0;
|
|
uint8_t count = 0;
|
|
|
|
static const uint8_t MAX_LNA_GAIN_TABLE_ENTRIES = 4;
|
|
static const uint8_t EN_TABLECLK = 0x05;
|
|
static const uint8_t EN_WRSTB = 0x02;
|
|
|
|
if ((rxChannel == TAL_RX1) ||
|
|
(rxChannel == TAL_RX2) ||
|
|
(rxChannel == TAL_RX1RX2))
|
|
{
|
|
/* Verify Rx profile is valid before allowing to set the Rx gain table, this
|
|
* ensures the device->rx structure pointers are valid
|
|
*/
|
|
if ((device->devStateInfo.profilesValid & RX_PROFILE_VALID) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_DUALBAND_LNA_TABLE_INV_PROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check for proper mapping for gain table and passed table number of indexes */
|
|
if ((numGainIndexesInTable > MAX_LNA_GAIN_TABLE_ENTRIES) ||
|
|
(numGainIndexesInTable == 0))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_DUALBAND_LNA_TABLE_INV_INDEX, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_DUALBAND_LNA_TABLE_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (gainTablePtr == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_DUALBAND_LNA_TABLE_NULL_PARM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* starting the gain table clock and read from gain table address bits */
|
|
gtConfigReg = ((uint8_t)rxChannel << 3) | EN_TABLECLK;
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, gtConfigReg);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* The write strobe to gain table configuration register */
|
|
gtConfigReg |= EN_WRSTB;
|
|
|
|
/* Load gain table */
|
|
for (count = 0; count < numGainIndexesInTable; count ++)
|
|
{
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_WORD_ADDRESS, count);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
registerValue = ((gainTablePtr[count].dualbandGain & 0x3F) << 2) | (gainTablePtr[count].dualbandControl & 0x03);
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_WORD_DATA_DUALBAND, registerValue);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, gtConfigReg);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
}
|
|
|
|
/* disabling the gain table clock */
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GAIN_TABLE_CONFIGURATION, 0x00);
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Set Max LNA indices in Rx1 AGC to match the number of gain table indices */
|
|
if ((rxChannel == TAL_RX1) ||
|
|
(rxChannel == TAL_RX1RX2))
|
|
{
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX1_SLOWLOOP_CONFIG, (uint8_t)(numGainIndexesInTable-1));
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
}
|
|
|
|
/* Set Max LNA indices in Rx2 AGC to match the number of gain table indices */
|
|
if ((rxChannel == TAL_RX2) ||
|
|
(rxChannel == TAL_RX1RX2))
|
|
{
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_RX2_SLOWLOOP_CONFIG, (uint8_t)(numGainIndexesInTable-1));
|
|
retVal = talApiErrHandler(device,TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
}
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_setGainTableExtCtrlPins(taliseDevice_t *device, taliseRxChannels_t rxChannel, uint8_t enable3p3vGpios)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint8_t curr3p3SrcCtrl = 0x00;
|
|
uint16_t currGpio3p3Oe = 0;
|
|
uint16_t usedGpio3p3pins = 0;
|
|
uint16_t gpio3p3FreeMask = 0;
|
|
uint16_t gpio3p3UsedMask = 0;
|
|
static const uint8_t GPIO3P3_RX1_EXT_CTRL_WORD_EN = 0x04;
|
|
static const uint8_t GPIO3P3_RX2_EXT_CTRL_WORD_EN = 0x40;
|
|
static const uint8_t GPIO3P3_RX1_EXT_CTRL_WORD_OE = 0x0F;
|
|
static const uint8_t GPIO3P3_RX2_EXT_CTRL_WORD_OE = 0xF0;
|
|
static const uint8_t GPIO3P3_LOWERBYTE_LOWERNIBBLE_SRCCTRL_MASK = 0x0F;
|
|
static const uint8_t GPIO3P3_LOWERBYTE_UPPERNIBBLE_SRCCTRL_MASK = 0xF0;
|
|
static const uint8_t ENABLE_EXT_CTRL_WORD_GPIOS = 0x01;
|
|
static const uint32_t SWTEST_SIMULATE_RX1_GPIO3P3_INP = 0x01;
|
|
static const uint32_t SWTEST_SIMULATE_RX2_GPIO3P3_INP = 0x02;
|
|
|
|
/*Ensure that the requested channel is valid*/
|
|
if ((rxChannel != TAL_RX1) && (rxChannel != TAL_RX2) && (rxChannel != TAL_RX1RX2))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_INV_CHANNEL,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/*Ensure that if channel Rx1 is requested, it is initialized*/
|
|
if (((((uint8_t)rxChannel & (uint8_t)TAL_RX1) == (uint8_t)TAL_RX1) &&
|
|
((device->devStateInfo.initializedChannels & (uint8_t)TAL_RX1) != (uint8_t)TAL_RX1)))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_UNINITIALIZED_RX1,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/*Ensure that if channel Rx2 is requested, it is initialized*/
|
|
if (((((uint8_t)rxChannel & (uint8_t)TAL_RX2) == (uint8_t)TAL_RX2) &&
|
|
((device->devStateInfo.initializedChannels & (uint8_t)TAL_RX2) != (uint8_t)TAL_RX2)))
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_UNINITIALIZED_RX2,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/*Verify that the GPIO pins requested are not already in use*/
|
|
|
|
/* Read current configuration of GPIO 3.3s */
|
|
halError = talSpiReadByte(device->devHalInfo, TALISE_ADDR_GPIO_3P3V_LOWER_BYTE_SOURCE_CONTROL, &curr3p3SrcCtrl);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
retVal = (talRecoveryActions_t)TALISE_getGpio3v3Oe(device, &currGpio3p3Oe);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
usedGpio3p3pins = device->devStateInfo.usedGpio3p3pins;
|
|
|
|
if(device->devStateInfo.swTest == SWTEST_SIMULATE_RX1_GPIO3P3_INP)
|
|
{
|
|
curr3p3SrcCtrl = 0;
|
|
usedGpio3p3pins |= 0x01;
|
|
}
|
|
|
|
if(device->devStateInfo.swTest == SWTEST_SIMULATE_RX2_GPIO3P3_INP)
|
|
{
|
|
curr3p3SrcCtrl = 0;
|
|
usedGpio3p3pins |= (0x01 << 4);
|
|
}
|
|
|
|
/*Check that if
|
|
* Channel requested for Ext Ctrl Word GPIO output is Rx1
|
|
* GPIO 3p3 [3:0] pins are already in use
|
|
* GPIO 3p3 [3:0] pins are not used by this feature
|
|
* then throw an exception
|
|
* */
|
|
if ((((uint8_t)rxChannel & (uint8_t)TAL_RX1) == (uint8_t)TAL_RX1) &&
|
|
((currGpio3p3Oe & GPIO3P3_RX1_EXT_CTRL_WORD_OE) == GPIO3P3_RX1_EXT_CTRL_WORD_OE) &&
|
|
((curr3p3SrcCtrl & GPIO3P3_LOWERBYTE_LOWERNIBBLE_SRCCTRL_MASK) != GPIO3P3_RX1_EXT_CTRL_WORD_EN))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_GPIO_IN_USE_RX1,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((((uint8_t)rxChannel & (uint8_t)TAL_RX1) == (uint8_t)TAL_RX1) &&
|
|
((usedGpio3p3pins & GPIO3P3_RX1_EXT_CTRL_WORD_OE) != 0) &&
|
|
((curr3p3SrcCtrl & GPIO3P3_LOWERBYTE_LOWERNIBBLE_SRCCTRL_MASK) != GPIO3P3_RX1_EXT_CTRL_WORD_EN))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_GPIO_IN_USE_RX1,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/*Check that if
|
|
* Channel requested for Ext Ctrl Word GPIO output is Rx2
|
|
* GPIO 3p3 [7:4] pins are already in use
|
|
* GPIO 3p3 [7:4] pins are not used by this feature
|
|
* then throw an exception
|
|
* */
|
|
if ((((uint8_t)rxChannel & (uint8_t)TAL_RX2) == (uint8_t)TAL_RX2) &&
|
|
((currGpio3p3Oe & GPIO3P3_RX2_EXT_CTRL_WORD_OE) == GPIO3P3_RX2_EXT_CTRL_WORD_OE) &&
|
|
((curr3p3SrcCtrl & GPIO3P3_LOWERBYTE_UPPERNIBBLE_SRCCTRL_MASK) != GPIO3P3_RX2_EXT_CTRL_WORD_EN))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_GPIO_IN_USE_RX2,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if ((((uint8_t)rxChannel & (uint8_t)TAL_RX2) == (uint8_t)TAL_RX2) &&
|
|
((usedGpio3p3pins & GPIO3P3_RX2_EXT_CTRL_WORD_OE) != 0) &&
|
|
((curr3p3SrcCtrl & GPIO3P3_LOWERBYTE_UPPERNIBBLE_SRCCTRL_MASK) != GPIO3P3_RX2_EXT_CTRL_WORD_EN))
|
|
{
|
|
return talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM, TAL_ERR_SETEXTWORDCTRLGPIO_GPIO_IN_USE_RX2,
|
|
retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/*Clear current GPIO configuration and setup again if enable requested*/
|
|
if ((rxChannel == TAL_RX1) || (rxChannel == TAL_RX1RX2))
|
|
{
|
|
/* Free GPIO3P3[3:0] if used */
|
|
gpio3p3FreeMask |= GPIO3P3_RX1_EXT_CTRL_WORD_OE;
|
|
curr3p3SrcCtrl &= ~GPIO3P3_LOWERBYTE_LOWERNIBBLE_SRCCTRL_MASK;
|
|
|
|
if (enable3p3vGpios >= ENABLE_EXT_CTRL_WORD_GPIOS)
|
|
{
|
|
/* Enable GPIO3P3[3:0] if requested */
|
|
gpio3p3UsedMask |= GPIO3P3_RX1_EXT_CTRL_WORD_OE;
|
|
curr3p3SrcCtrl |= GPIO3P3_RX1_EXT_CTRL_WORD_EN;
|
|
}
|
|
}
|
|
|
|
if ((rxChannel == TAL_RX2) || (rxChannel == TAL_RX1RX2))
|
|
{
|
|
/* Free GPIO3P3[7:4] if used */
|
|
gpio3p3FreeMask |= GPIO3P3_RX2_EXT_CTRL_WORD_OE;
|
|
curr3p3SrcCtrl &= ~GPIO3P3_LOWERBYTE_UPPERNIBBLE_SRCCTRL_MASK;
|
|
|
|
if (enable3p3vGpios >= ENABLE_EXT_CTRL_WORD_GPIOS)
|
|
{
|
|
/* Enable GPIO3P3[7:4] if requested */
|
|
gpio3p3UsedMask |= GPIO3P3_RX2_EXT_CTRL_WORD_OE;
|
|
curr3p3SrcCtrl |= GPIO3P3_RX2_EXT_CTRL_WORD_EN;
|
|
}
|
|
}
|
|
|
|
usedGpio3p3pins = device->devStateInfo.usedGpio3p3pins & ~gpio3p3FreeMask;
|
|
usedGpio3p3pins |= gpio3p3UsedMask;
|
|
|
|
/*Update the Source Control Register*/
|
|
halError = talSpiWriteByte(device->devHalInfo, TALISE_ADDR_GPIO_3P3V_LOWER_BYTE_SOURCE_CONTROL, curr3p3SrcCtrl);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Set GPIO input enables */
|
|
/* - Set OE for all freed GPIO3p3's to 0 (input) */
|
|
/* - Set OE for all used GPIO3p3's to 1 (output) */
|
|
retVal = (talRecoveryActions_t)TALISE_setGpio3v3Oe(device, gpio3p3UsedMask, (gpio3p3UsedMask | gpio3p3FreeMask));
|
|
IF_ERR_RETURN(retVal);
|
|
|
|
/* Update used and freed GPIO's */
|
|
device->devStateInfo.usedGpio3p3pins = usedGpio3p3pins;
|
|
|
|
return (uint32_t)retVal;
|
|
}
|
|
|
|
uint32_t TALISE_getRxDecPower(taliseDevice_t *device, taliseRxChannels_t rxChannel, uint16_t *rxDecPower_mdBFS)
|
|
{
|
|
talRecoveryActions_t retVal = TALACT_NO_ACTION;
|
|
adiHalErr_t halError = ADIHAL_OK;
|
|
uint16_t decPowerAddr = 0;
|
|
uint8_t rxDecPower_dBFS = 0;
|
|
|
|
#if TALISE_VERBOSE
|
|
halError = talWriteToLog(device->devHalInfo, ADIHAL_LOG_MSG, TAL_ERR_OK, "TALISE_getRxDecPower()\n");
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_LOG, halError, retVal, TALACT_WARN_RESET_LOG);
|
|
#endif
|
|
|
|
/* null pointer check */
|
|
if (rxDecPower_mdBFS == NULL)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_INV_RX_DEC_POWER_PARAM, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
if (rxChannel == TAL_RX1)
|
|
{
|
|
decPowerAddr = TALISE_ADDR_DEC_POWER_CH1;
|
|
}
|
|
else if (rxChannel == TAL_RX2)
|
|
{
|
|
decPowerAddr = TALISE_ADDR_DEC_POWER_CH2;
|
|
}
|
|
else
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_GETRXDECPOWER_INV_CHANNEL, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Check that rx profile is valid in current config */
|
|
if (((device->devStateInfo.profilesValid & RX_PROFILE_VALID) == 0)
|
|
|| (device->devStateInfo.initializedChannels & (uint32_t)rxChannel) == 0)
|
|
{
|
|
return (uint32_t)talApiErrHandler(device, TAL_ERRHDL_INVALID_PARAM,
|
|
TAL_ERR_GETRXDECPOWER_INV_PROFILE, retVal, TALACT_ERR_CHECK_PARAM);
|
|
}
|
|
|
|
/* Write some value to generate a strobe to latch the value */
|
|
halError = talSpiWriteByte(device->devHalInfo, decPowerAddr, 0x01);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
/* Read Rx1 Dec Power register */
|
|
halError = talSpiReadByte(device->devHalInfo, decPowerAddr, &rxDecPower_dBFS);
|
|
retVal = talApiErrHandler(device, TAL_ERRHDL_HAL_SPI, halError, retVal, TALACT_ERR_RESET_SPI);
|
|
IF_ERR_RETURN_U32(retVal);
|
|
|
|
*rxDecPower_mdBFS = ((uint16_t)rxDecPower_dBFS) * 250; /* 250 = 1000 * 0.25dB */
|
|
|
|
return (uint32_t)retVal;
|
|
} |