sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
8fdbb1e0a4
nuttx/drivers/wireless/spirit/lib/spirit_radio.c
Gregory Nutt 936df1bcb5 Adds new OS internal functions nxsig_sleep() and nxsig_usleep. These differ from the standard sleep() and usleep() in that (1) they don't cause cancellation points, and (2) don't set the errno variable (if applicable). All calls to sleep() and usleep() changed to calls to nxsig_sleep() and nxsig_usleep(). 
Squashed commit of the following:

    Change all calls to usleep() in the OS proper to calls to nxsig_usleep()

    sched/signal:  Add a new OS internal function nxsig_usleep() that is functionally equivalent to usleep() but does not cause a cancellaption point and does not modify the errno variable.

    sched/signal:  Add a new OS internal function nxsig_sleep() that is functionally equivalent to sleep() but does not cause a cancellaption point.
2017-10-06 10:15:01 -06:00

4758 lines
129 KiB
C
Raw Blame History

/******************************************************************************
* drivers/wireless/spirit/lib/spirit_radio.c
* This file provides all the low level API to manage Analog and Digital radio
* part of SPIRIT.
*
* Copyright(c) 2015 STMicroelectronics
* Author: VMA division - AMS
* Version 3.2.2 08-July-2015
*
* Adapted for NuttX by:
* Author: Gregory Nutt <gnutt@nuttx.org>
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/******************************************************************************
* Included Files
******************************************************************************/
#include <sys/types.h>
#include <stdint.h>
#include <unistd.h>
#include <math.h>
#include <assert.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/signal.h>
#include "spirit_config.h"
#include "spirit_types.h"
#include "spirit_management.h"
#include "spirit_calibration.h"
#include "spirit_radio.h"
#include "spirit_spi.h"
/******************************************************************************
* Pre-processor Definitions
******************************************************************************/
#define XTAL_FLAG(xtalFrequency) \
(xtalFrequency >= 25e6) ? XTAL_FLAG_26_MHz : XTAL_FLAG_24_MHz
#define ROUND(a) \
(((a - (uint32_t)a) > 0.5) ? (uint32_t)a + 1 : (uint32_t)a)
/* Returns the absolute value. */
#define S_ABS(a) ((a) > 0 ? (a) : -(a))
/******************************************************************************
* Private Data
******************************************************************************/
/* Factor is: B/2 used in the formula for SYNTH word calculation */
static const uint8_t g_vectc_bhalf[4] =
{
(HIGH_BAND_FACTOR / 2),
(MIDDLE_BAND_FACTOR / 2),
(LOW_BAND_FACTOR / 2),
(VERY_LOW_BAND_FACTOR / 2)
};
/* BS value to write in the SYNT0 register according to the selected band */
static const uint8_t g_vectc_bandval[4] =
{
SYNT0_BS_6, SYNT0_BS_12, SYNT0_BS_16, SYNT0_BS_32
};
/* It represents the available channel bandwidth times 10 for 26 Mhz xtal.
* NOTE: The channel bandwidth for others xtal frequencies can be computed
* since this table multiplying the current table by a factor
* xtal_frequency/26e6.
*/
static const uint16_t g_vectn_bandwidth[90] =
{
8001, 7951, 7684, 7368, 7051, 6709, 6423, 5867, 5414,
4509, 4259, 4032, 3808, 3621, 3417, 3254, 2945, 2703,
2247, 2124, 2015, 1900, 1807, 1706, 1624, 1471, 1350,
1123, 1062, 1005, 950, 903, 853, 812, 735, 675,
561, 530, 502, 474, 451, 426, 406, 367, 337,
280, 265, 251, 237, 226, 213, 203, 184, 169,
140, 133, 126, 119, 113, 106, 101, 92, 84,
70, 66, 63, 59, 56, 53, 51, 46, 42,
35, 33, 31, 30, 28, 27, 25, 23, 21,
18, 17, 16, 15, 14, 13, 13, 12, 11
};
/* These values are used to interpolate the power curves. Interpolation
* curves are linear in the following 3 regions:
*
* - reg value: 1 to 13 (up region)
* - reg value: 13 to 40 (mid region)
* - reg value: 41 to 90 (low region)
*
* power_reg = m*power_dBm + q
*
* For each band the order is: {m-up, q-up, m-mid, q-mid, m-low, q-low}.
*
* NOTE: The power interpolation curves have been extracted by
* measurements done on the divisional evaluation boards.
*/
static const float g_power_factors[5][6] =
{
{-2.11, 25.66, -2.11, 25.66, -2.00, 31.28}, /* 915 */
{-2.04, 23.45, -2.04, 23.45, -1.95, 27.66}, /* 868 */
{-3.48, 38.45, -1.89, 27.66, -1.92, 30.23}, /* 433 */
{-3.27, 35.43, -1.80, 26.31, -1.89, 29.61}, /* 315 */
{-4.18, 50.66, -1.80, 30.04, -1.86, 32.22}, /* 169 */
};
/* It represents the available VCO frequencies */
static const uint16_t g_vectn_vcofreq[16] =
{
4644, 4708, 4772, 4836, 4902, 4966, 5030, 5095,
5161, 5232, 5303, 5375, 5448, 5519, 5592, 5663
};
/******************************************************************************
* Public Functions
******************************************************************************/
/******************************************************************************
* Name: spirit_radio_initialize
*
* Description:
* Initializes the SPIRIT analog and digital radio part according to the
* specified parameters in the radioinit.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* radioinit - Pointer to a struct radio_init_s that contains the
*
* Returned Value:
* Error code: 0=no error, <0=error during calibration of VCO.
*
******************************************************************************/
int spirit_radio_initialize(FAR struct spirit_library_s *spirit,
FAR const struct radio_init_s *radioinit)
{
float ifoff;
int32_t offset;
int16_t fcoffset;
uint8_t anaoffset;
uint8_t digregs[4];
uint8_t anaregs[8];
uint8_t drm;
uint8_t dre;
uint8_t fdevm;
uint8_t fdeve;
uint8_t bwm;
uint8_t bwe;
uint8_t regval;
uint8_t value;
int ret;
/* Workaround for Vtune */
value = 0xa0;
ret = spirit_reg_write(spirit, 0x9f, &value, 1);
if (ret < 0)
{
return ret;
}
/* Calculates the offset respect to RF frequency and according to xtal_ppm
* parameter: (xtal_ppm*FBase)/10^6
*/
offset = (int32_t)(((float)radioinit->foffset * radioinit->base_frequency) /
PPM_FACTOR);
/* Check the parameters */
DEBUGASSERT(IS_FREQUENCY_BAND(radioinit->base_frequency));
DEBUGASSERT(IS_MODULATION_SELECTED(radioinit->modselect));
DEBUGASSERT(IS_DATARATE(radioinit->datarate));
DEBUGASSERT(IS_FREQUENCY_OFFSET(offset, spirit->xtal_frequency));
DEBUGASSERT(IS_CHANNEL_SPACE(radioinit->chspace, spirit->xtal_frequency));
DEBUGASSERT(IS_F_DEV(radioinit->freqdev, spirit->xtal_frequency));
/* Make sure that we are in the READY state */
ret = spirit_waitstatus(spirit, MC_STATE_READY, 5);
if (ret < 0)
{
wlerr("ERROR: Failed to go to READY state: %d\n", ret);
return ret;
}
/* Disable the digital, ADC, SMPS reference clock divider if fXO > 24MHz or
* fXO < 26MHz
*/
ret = spirit_command(spirit, COMMAND_STANDBY);
if (ret < 0)
{
return ret;
}
/* Delay for state transition */
nxsig_usleep(100);
/* Wait for the device to enter STANDBY */
ret = spirit_waitstatus(spirit, MC_STATE_STANDBY, 5);
if (ret < 0)
{
wlerr("ERROR: Failed to go to STANDBY state: %d\n", ret);
return ret;
}
if (spirit->xtal_frequency < DOUBLE_XTAL_THR)
{
ret = spirit_radio_enable_digdivider(spirit, S_DISABLE);
DEBUGASSERT(IS_CH_BW(radioinit->bandwidth, spirit->xtal_frequency));
}
else
{
ret = spirit_radio_enable_digdivider(spirit, S_ENABLE);
DEBUGASSERT(IS_CH_BW(radioinit->bandwidth, (spirit->xtal_frequency >> 1)));
}
if (ret < 0)
{
return ret;
}
/* Go to READY state */
ret = spirit_command(spirit, COMMAND_READY);
if (ret < 0)
{
return ret;
}
/* Delay for state transition */
nxsig_usleep(100);
/* Make sure that the device becomes READY */
ret = spirit_waitstatus(spirit, MC_STATE_READY, 5);
if (ret < 0)
{
wlerr("ERROR: Failed to go to READY state: %d\n", ret);
return ret;
}
/* Calculates the FC_OFFSET parameter and cast as signed int: offset =
* (Fxtal/2^18)*FC_OFFSET
*/
fcoffset = (int16_t)(((float)offset * FBASE_DIVIDER) /
spirit->xtal_frequency);
anaregs[2] = (uint8_t)((((uint16_t)fcoffset) >> 8) & 0x0f);
anaregs[3] = (uint8_t)fcoffset;
/* Calculates the channel space factor */
anaregs[0] = ((uint32_t)radioinit->chspace << 9) /
(spirit->xtal_frequency >> 6) + 1;
spirit_management_initcommstate(spirit, radioinit->base_frequency);
/* 2nd order DEM algorithm enabling */
ret = spirit_reg_read(spirit, 0xa3, &regval, 1);
if (ret < 0)
{
return ret;
}
regval &= ~0x02;
ret = spirit_reg_write(spirit, 0xa3, &regval, 1);
if (ret < 0)
{
return ret;
}
/* Check the channel center frequency is in one of the possible range */
DEBUGASSERT(IS_FREQUENCY_BAND((radioinit->base_frequency +
((fcoffset * spirit->xtal_frequency) / FBASE_DIVIDER) +
radioinit->chspace * radioinit->chnum)));
/* Calculates the datarate mantissa and exponent */
ret = spirit_radio_convert_datarate(spirit, radioinit->datarate,
&drm, &dre);
if (ret < 0)
{
return ret;
}
digregs[0] = (uint8_t)(drm);
digregs[1] = (uint8_t)(radioinit->modselect | dre);
/* Read the fdev register to preserve the clock recovery algo bit */
ret = spirit_reg_read(spirit, 0x1c, &regval, 1);
if (ret < 0)
{
return ret;
}
/* Calculates the frequency deviation mantissa and exponent */
ret = spirit_radio_convert_freqdev(spirit, radioinit->freqdev,
&fdevm, &fdeve);
if (ret < 0)
{
return ret;
}
digregs[2] = (uint8_t)((fdeve << 4) | (regval & 0x08) | fdevm);
/* Calculates the channel filter mantissa and exponent */
ret = spirit_radio_convert_chbandwidth(spirit, radioinit->bandwidth,
&bwm, &bwe);
if (ret < 0)
{
return ret;
}
digregs[3] = (uint8_t)((bwm << 4) | bwe);
ifoff = (3.0 * 480140) / (spirit->xtal_frequency >> 12) - 64;
anaoffset = ROUND(ifoff);
if (spirit->xtal_frequency < DOUBLE_XTAL_THR)
{
/* if offset digital is the same in case of single xtal */
anaregs[1] = anaoffset;
}
else
{
ifoff = (3.0 * 480140) / (spirit->xtal_frequency >> 13) - 64;
/* ... otherwise recompute it */
anaregs[1] = ROUND(ifoff);
}
#if 0
if (spirit->xtal_frequency == 24000000)
{
anaoffset = 0xb6;
anaregs[1] = 0xb6;
}
if (spirit->xtal_frequency == 25000000)
{
anaoffset = 0xac;
anaregs[1] = 0xac;
}
if (spirit->xtal_frequency == 26000000)
{
anaoffset = 0xa3;
anaregs[1] = 0xa3;
}
if (spirit->xtal_frequency == 48000000)
{
anaoffset = 0x3b;
anaregs[1] = 0xb6;
}
if (spirit->xtal_frequency == 50000000)
{
anaoffset = 0x36;
anaregs[1] = 0xac;
}
if (spirit->xtal_frequency == 52000000)
{
anaoffset = 0x31;
anaregs[1] = 0xa3;
}
#endif
ret = spirit_reg_write(spirit, IF_OFFSET_ANA_BASE, &anaoffset, 1);
if (ret < 0)
{
return ret;
}
/* Set Xtal configuration */
if (spirit->xtal_frequency > DOUBLE_XTAL_THR)
{
enum xtal_flag_e xtlflag = XTAL_FLAG((spirit->xtal_frequency / 2));
ret = spirit_radio_set_xtalflag(spirit, xtlflag);
}
else
{
enum xtal_flag_e xtlflag = XTAL_FLAG(spirit->xtal_frequency);
ret = spirit_radio_set_xtalflag(spirit, xtlflag);
}
if (ret < 0)
{
return ret;
}
/* Sets the channel number in the corresponding register */
ret = spirit_reg_write(spirit, CHNUM_BASE, &radioinit->chnum, 1);
if (ret < 0)
{
return ret;
}
/* Configures the Analog Radio registers */
ret = spirit_reg_write(spirit, CHSPACE_BASE, anaregs, 4);
if (ret < 0)
{
return ret;
}
/* Configures the Digital Radio registers */
ret = spirit_reg_write(spirit, MOD1_BASE, digregs, 4);
if (ret < 0)
{
return ret;
}
/* Enable the freeze option of the AFC on the SYNC word */
ret = spirit_radio_afcfreezeonsync(spirit, S_ENABLE);
if (ret < 0)
{
return ret;
}
/* Set the IQC correction optimal value */
anaregs[0] = 0x80;
anaregs[1] = 0xe3;
ret = spirit_reg_write(spirit, 0x99, anaregs, 2);
if (ret < 0)
{
return ret;
}
return spirit_radio_set_basefrequency(spirit, radioinit->base_frequency);
}
/******************************************************************************
* Name: spirit_radio_get_setup
*
* Description:
* Returns the SPIRIT analog and digital radio structure according to the
* registers value.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* radioinit pointer to a struct radio_init_s that
* contains the configuration information for the analog radio part of SPIRIT.
*
* Returned Value:
* Zero (OK) returned on success; a negated errno value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_get_setup(FAR struct spirit_library_s *spirit,
FAR struct radio_init_s *radioinit)
{
uint32_t synthword;
uint16_t xtaloff;
int16_t fcoffset;
uint8_t anaregs[8];
uint8_t digregs[4];
uint8_t refdiv;
uint8_t fdevm;
uint8_t fdeve;
uint8_t bwm;
uint8_t bwe;
uint8_t divider;
enum spirit_bandselect_e band;
int ret;
#if 0
/* Get the RF board version */
enum spirit_version_e spirit_version = spirit_general_get_version(spirit);
#endif
/* Read the Analog Radio registers */
ret = spirit_reg_read(spirit, SYNT3_BASE, anaregs, 8);
if (ret < 0)
{
return ret;
}
/* Read the Digital Radio registers */
ret = spirit_reg_read(spirit, MOD1_BASE, digregs, 4);
if (ret < 0)
{
return ret;
}
/* Get the operating band masking the Band selected field */
if ((anaregs[3] & 0x07) == SYNT0_BS_6)
{
band = HIGH_BAND;
}
else if ((anaregs[3] & 0x07) == SYNT0_BS_12)
{
band = MIDDLE_BAND;
}
else if ((anaregs[3] & 0x07) == SYNT0_BS_16)
{
band = LOW_BAND;
}
else if ((anaregs[3] & 0x07) == SYNT0_BS_32)
{
band = VERY_LOW_BAND;
}
else
{
uint8_t regval;
/* If it is another value, set it to a valid one in order to avoid access
* violation
*/
regval = (anaregs[3] & 0xf8) | SYNT0_BS_6;
ret = spirit_reg_write(spirit, SYNT0_BASE, &regval, 1);
if (ret < 0)
{
return ret;
}
band = HIGH_BAND;
}
/* Compute the synth word */
synthword = ((((uint32_t)(anaregs[0] & 0x1f)) << 21) +
(((uint32_t)(anaregs[1])) << 13) +
(((uint32_t)(anaregs[2])) << 5) +
(((uint32_t)(anaregs[3])) >> 3));
/* Calculate the frequency base */
refdiv = (uint8_t)spirit_radio_get_refdiv(spirit) + 1;
radioinit->base_frequency = (uint32_t)
round(synthword * (((double)spirit->xtal_frequency) /
(FBASE_DIVIDER * refdiv * g_vectc_bhalf[band])));
/* Calculate the Offset Factor */
xtaloff = (((uint16_t)anaregs[6] << 8) | (uint16_t)anaregs[7]);
/* If a negative number then convert the 12 bit 2-complement in a 16 bit
* number
*/
if ((xtaloff & 0x0800) != 0)
{
xtaloff = xtaloff | 0xf000;
}
else
{
xtaloff = xtaloff & 0x0fff;
}
fcoffset = (int16_t)xtaloff;
/* Calculate the frequency offset in ppm */
radioinit->foffset = (int16_t)
((uint32_t)fcoffset * spirit->xtal_frequency * PPM_FACTOR) /
((uint32_t)FBASE_DIVIDER * radioinit->base_frequency);
/* Channel space */
radioinit->chspace = anaregs[4] * (spirit->xtal_frequency >> 15);
/* Channel number */
radioinit->chnum = spirit_radio_get_channel(spirit);
/* Modulation select */
radioinit->modselect = (enum modulation_select_e)(digregs[1] & 0x70);
/* Get the frequency deviation for mantissa and exponent */
fdevm = digregs[2] & 0x07;
fdeve = (digregs[2] & 0xf0) >> 4;
/* Get the channel filter register for mantissa and exponent */
bwm = (digregs[3] & 0xf0) >> 4;
bwe = digregs[3] & 0x0f;
divider = spirit_radio_isenabled_digdivider(spirit);
/* Calculate the datarate */
radioinit->datarate =
((spirit->xtal_frequency >> (5 + divider)) *
(256 + digregs[0])) >> (23 - (digregs[1] & 0x0f));
/* Calculates the frequency deviation */
radioinit->freqdev = (uint32_t)
((float)spirit->xtal_frequency / (((uint32_t) 1) << 18) *
(uint32_t)((8.0 + fdevm) / 2 * (1 << fdeve)));
/* Get the channel filter bandwidth from the look-up table and return it */
radioinit->bandwidth = (uint32_t)
(100.0 * g_vectn_bandwidth[bwm + (bwe * 9)] *
((spirit->xtal_frequency >> divider) / 26e6));
return OK;
}
/******************************************************************************
* Name: spirit_radio_set_xtalflag
*
* Description:
* Sets the Xtal configuration in the ANA_FUNC_CONF0 register.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* xtalflag - One of the possible value of the enum type xtal_flag_e.
* XTAL_FLAG_24_MHz: in case of 24 MHz crystal
* XTAL_FLAG_26_MHz: in case of 26 MHz crystal
*
* Returned Value:
* Error code: 0=no error, <0=error during calibration of VCO.
*
******************************************************************************/
int spirit_radio_set_xtalflag(FAR struct spirit_library_s *spirit,
enum xtal_flag_e xtalflag)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_XTAL_FLAG(xtalflag));
/* Read the ANA_FUNC_CONF_0 register */
ret = spirit_reg_read(spirit, ANA_FUNC_CONF0_BASE, &regval, 1);
if (ret >= 0)
{
if (xtalflag == XTAL_FLAG_26_MHz)
{
regval |= SELECT_24_26_MHZ_MASK;
}
else
{
regval &= (~SELECT_24_26_MHZ_MASK);
}
/* Sets the 24_26MHz_SELECT field in the ANA_FUNC_CONF_0 register */
ret = spirit_reg_write(spirit, ANA_FUNC_CONF0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_xtalflag
*
* Description:
* Returns the Xtal configuration in the ANA_FUNC_CONF0 register.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* XtalFrequency Settled Xtal configuration.
*
******************************************************************************/
enum xtal_flag_e spirit_radio_get_xtalflag(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the Xtal configuration in the ANA_FUNC_CONF_0 register and return
* the value.
*/
(void)spirit_reg_read(spirit, ANA_FUNC_CONF0_BASE, &regval, 1);
return (enum xtal_flag_e)((regval & 0x40) >> 6);
}
/******************************************************************************
* Name: spirit_radio_search_wcp
*
* Description:
* Returns the charge pump word for a given VCO frequency.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* fc - Channel center frequency expressed in Hz. This parameter may
* be a value in one of the following ranges:
*
* High_Band: from 779 MHz to 915 MHz
* Middle Band: from 387 MHz to 470 MHz
* Low Band: from 300 MHz to 348 MHz
* Very low Band: from 150 MHz to 174 MHz
*
* Returned Value:
* Charge pump word.
*
******************************************************************************/
uint8_t spirit_radio_search_wcp(FAR struct spirit_library_s *spirit,
uint32_t fc)
{
uint32_t vcofreq;
uint8_t bfactor;
int8_t i;
/* Check the channel center frequency is in one of the possible range */
DEBUGASSERT(IS_FREQUENCY_BAND(fc));
/* Search the operating band */
if (IS_FREQUENCY_BAND_HIGH(fc))
{
bfactor = HIGH_BAND_FACTOR;
}
else if (IS_FREQUENCY_BAND_MIDDLE(fc))
{
bfactor = MIDDLE_BAND_FACTOR;
}
else if (IS_FREQUENCY_BAND_LOW(fc))
{
bfactor = LOW_BAND_FACTOR;
}
else
{
bfactor = VERY_LOW_BAND_FACTOR;
}
/* Calculates the VCO frequency VCOFreq = fc*B */
vcofreq = (fc / 1000000) * bfactor;
/* Search in the vco frequency array the charge pump word */
if (vcofreq >= g_vectn_vcofreq[15])
{
i = 15;
}
else
{
/* Search the value */
for (i = 0; i < 15 && vcofreq > g_vectn_vcofreq[i]; i++);
/* Be sure that it is the best approssimation */
if (i != 0 &&
g_vectn_vcofreq[i] - vcofreq > vcofreq - g_vectn_vcofreq[i - 1])
{
i--;
}
}
/* Return index */
return (i & 7);
}
/******************************************************************************
* Name: spirit_radio_get_synthword
*
* Description:
* Returns the synth word.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* 32-bit Synth word. Errors are not reported.
*
******************************************************************************/
uint32_t spirit_radio_get_synthword(FAR struct spirit_library_s *spirit)
{
uint8_t regvalues[4];
/* Read the SYNTH registers, build the synth word and return it */
(void)spirit_reg_read(spirit, SYNT3_BASE, regvalues, 4);
return ((((uint32_t)(regvalues[0] & 0x1f)) << 21) +
(((uint32_t)(regvalues[1])) << 13) +
(((uint32_t)(regvalues[2])) << 5) +
(((uint32_t)(regvalues[3])) >> 3));
}
/******************************************************************************
* Name: spirit_radio_set_synthword
*
* Description:
* Sets the SYNTH registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* synthword - The synth word to write in the SYNTH[3:0] registers.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_set_synthword(FAR struct spirit_library_s *spirit,
uint32_t synthword)
{
uint8_t regvalues[4];
uint8_t synt0;
int ret;
/* Read the SYNT0 register */
ret = spirit_reg_read(spirit, SYNT0_BASE, &synt0, 1);
if (ret < 0)
{
return ret;
}
/* Mask the Band selected field */
synt0 &= 0x07;
/* Build the array for SYNTH registers */
regvalues[0] = (uint8_t)((synthword >> 21) & (0x0000001f));
regvalues[1] = (uint8_t)((synthword >> 13) & (0x000000ff));
regvalues[2] = (uint8_t)((synthword >> 5) & (0x000000ff));
regvalues[3] = (uint8_t)(((synthword & 0x0000001f) << 3) | synt0);
/* Write the synth word to the SYNTH registers */
ret = spirit_reg_write(spirit, SYNT3_BASE, regvalues, 4);
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_band
*
* Description:
* Sets the operating band.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* band - The band to set. This parameter can be one of following values:
* HIGH_BAND High_Band selected: from 779 MHz to 915 MHz
* MIDDLE_BAND: Middle Band selected: from 387 MHz to 470 MHz
* LOW_BAND: Low Band selected: from 300 MHz to 348 MHz
* VERY_LOW_BAND: Very low Band selected: from 150 MHz to 174 MHz
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_set_band(FAR struct spirit_library_s *spirit,
enum spirit_bandselect_e band)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_BAND_SELECTED(band));
/* Read the SYNT0 register */
ret = spirit_reg_read(spirit, SYNT0_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the SYNTH[4;0] field and write the BS value */
regval &= 0xf8;
regval |= g_vectc_bandval[band];
/* Configures the SYNT0 register setting the operating band */
ret = spirit_reg_write(spirit, SYNT0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_band
*
* Description:
* Returns the operating band.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* BandSelect Settled band. This returned value may be one of the
* following values:
* HIGH_BAND High_Band selected: from 779 MHz to 915 MHz
* MIDDLE_BAND: Middle Band selected: from 387 MHz to 470 MHz
* LOW_BAND: Low Band selected: from 300 MHz to 348 MHz
* VERY_LOW_BAND: Very low Band selected: from 150 MHz to 174 MHz
*
******************************************************************************/
enum spirit_bandselect_e
spirit_radio_get_band(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the SYNT0 register */
(void)spirit_reg_read(spirit, SYNT0_BASE, &regval, 1);
/* Mask the Band selected field */
if ((regval & 0x07) == SYNT0_BS_6)
{
return HIGH_BAND;
}
else if ((regval & 0x07) == SYNT0_BS_12)
{
return MIDDLE_BAND;
}
else if ((regval & 0x07) == SYNT0_BS_16)
{
return LOW_BAND;
}
else
{
return VERY_LOW_BAND;
}
}
/******************************************************************************
* Name: spirit_radio_set_channel
*
* Description:
* Sets the channel number.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* chnum the channel number.
*
* Returned Value:
* Zero (OK) is returned on success. A negated errno value is returned on
* any failure.
*
******************************************************************************/
int spirit_radio_set_channel(FAR struct spirit_library_s *spirit,
uint8_t chnum)
{
/* Write the CHNUM register */
return spirit_reg_write(spirit, CHNUM_BASE, &chnum, 1);
}
/******************************************************************************
* Name: spirit_radio_get_channel
*
* Description:
* Returns the actual channel number.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Actual channel number.
*
******************************************************************************/
uint8_t spirit_radio_get_channel(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the CHNUM register and return the value */
(void)spirit_reg_read(spirit, CHNUM_BASE, &regval, 1);
return regval;
}
/******************************************************************************
* Name: spirit_radio_set_chspace
*
* Description:
* Sets the channel space factor in channel space register. The channel
* spacing step is computed as F_Xo/32768.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* chspace - The channel space expressed in Hz.
*
* Returned Value:
* Zero (OK) is returned on success; a negated errno value is returned on
* any failure.
*
******************************************************************************/
int spirit_radio_set_chspace(FAR struct spirit_library_s *spirit,
uint32_t chspace)
{
uint8_t factor;
/* Round to the nearest integer */
factor = ((uint32_t)chspace * CHSPACE_DIVIDER) / spirit->xtal_frequency;
/* Write value into the register */
return spirit_reg_write(spirit, CHSPACE_BASE, &factor, 1);
}
/******************************************************************************
* Name: spirit_radio_get_chspace
*
* Description:
* Returns the channel space register.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Channel space. The channel space is:
*
* CS = channel_space_factor x XtalFrequency/2^15
*
* where channel_space_factor is the CHSPACE register value.
*
******************************************************************************/
uint32_t spirit_radio_get_chspace(FAR struct spirit_library_s *spirit)
{
uint8_t factor;
/* Read the CHSPACE register, calculate the channel space and return it */
(void)spirit_reg_read(spirit, CHSPACE_BASE, &factor, 1);
/* Compute the Hertz value and return it */
return ((factor * spirit->xtal_frequency) / CHSPACE_DIVIDER);
}
/******************************************************************************
* Name: spirit_radio_set_foffset_ppm
*
* Description:
* Sets the FC OFFSET register starting from xtal ppm value.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* xtaloffset - The xtal offset expressed in ppm.
*
* Returned Value:
* Zero (OK) returned on success; a negated errno value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_foffset_ppm(FAR struct spirit_library_s *spirit,
int16_t xtaloffset)
{
enum spirit_bandselect_e band;
uint32_t synthword;
uint32_t fbase;
int32_t offset;
int16_t fcoffset;
uint8_t refdiv;
uint8_t tmp[2];
/* Get the synth word */
synthword = spirit_radio_get_synthword(spirit);
/* Get the operating band */
band = spirit_radio_get_band(spirit);
/* Calculate the frequency base */
refdiv = (uint8_t)spirit_radio_get_refdiv(spirit) + 1;
fbase = synthword * (spirit->xtal_frequency /
(g_vectc_bhalf[band] * refdiv) /
FBASE_DIVIDER);
/* Calculate the offset respect to RF frequency and according to xtal_ppm
* parameter */
offset = (int32_t)(((float)xtaloffset * fbase) / PPM_FACTOR);
/* Check the Offset is in the correct range */
DEBUGASSERT(IS_FREQUENCY_OFFSET(offset, spirit->xtal_frequency));
/* Calculate the FC_OFFSET value to write in the corresponding register */
fcoffset = (int16_t)(((float)offset * FBASE_DIVIDER) /
spirit->xtal_frequency);
/* Build the array related to the FC_OFFSET_1 and FC_OFFSET_0 register */
tmp[0] = (uint8_t)((((uint16_t) fcoffset) >> 8) & 0x0f);
tmp[1] = (uint8_t)fcoffset;
/* Write the FC_OFFSET registers */
return spirit_reg_write(spirit, FC_OFFSET1_BASE, tmp, 2);
}
/******************************************************************************
* Name: spirit_radio_set_foffset_hz
*
* Description:
* Sets the FC OFFSET register starting from frequency offset expressed in Hz.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* foffset - Frequency offset expressed in Hz as signed word.
*
* Returned Value:
* Zero (OK) returned on success; a negated errno value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_foffset_hz(FAR struct spirit_library_s *spirit,
int32_t foffset)
{
uint8_t tmp[2];
int16_t offset;
/* Check that the Offset is in the correct range */
DEBUGASSERT(IS_FREQUENCY_OFFSET(foffset, spirit->xtal_frequency));
/* Calculates the offset value to write in the FC_OFFSET register */
offset = (int16_t)(((float)foffset * FBASE_DIVIDER) /
spirit->xtal_frequency);
/* Build the array related to the FC_OFFSET_1 and FC_OFFSET_0 register */
tmp[0] = (uint8_t)((((uint16_t) offset) >> 8) & 0x0f);
tmp[1] = (uint8_t)offset;
/* Write the FC_OFFSET registers */
return spirit_reg_write(spirit, FC_OFFSET1_BASE, tmp, 2);
}
/******************************************************************************
* Name: spirit_radio_get_foffset
*
* Description:
* Returns the actual frequency offset.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Frequency offset expressed in Hz as signed word.
*
******************************************************************************/
int32_t spirit_radio_get_foffset(FAR struct spirit_library_s *spirit)
{
uint16_t offtmp;
int16_t fcoffset;
uint8_t tmp[2];
/* Read the FC_OFFSET registers */
(void)spirit_reg_read(spirit, FC_OFFSET1_BASE, tmp, 2);
/* Calculates the Offset Factor */
offtmp = (((uint16_t)tmp[0] << 8) + (uint16_t)tmp[1]);
if ((offtmp & 0x0800) != 0)
{
offtmp |= 0xf000;
}
else
{
offtmp &= 0x0fff;
}
fcoffset = *((int16_t *)(&offtmp));
/* Calculates the frequency offset and return it */
return ((int32_t)(fcoffset * spirit->xtal_frequency) / FBASE_DIVIDER);
}
/******************************************************************************
* Name: spirit_radio_set_basefrequency
*
* Description:
* Sets the Synth word and the Band Select register according to desired
* base carrier frequency. In this API the Xtal configuration is read out
* from the corresponding register. The user shall fix it before call this
* API.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* fbase - The base carrier frequency expressed in Hz as unsigned word.
*
* Returned Value:
* Error code: 0=no error, <0=error during calibration of VCO.
*
******************************************************************************/
int spirit_radio_set_basefrequency(FAR struct spirit_library_s *spirit,
uint32_t fbase)
{
int32_t foffset;
uint32_t synthword;
uint32_t chspace;
uint32_t fc;
uint8_t anaregs[4];
uint8_t refdiv;
uint8_t band;
uint8_t wcp;
uint8_t chnum;
int ret;
/* Check the parameter */
DEBUGASSERT(IS_FREQUENCY_BAND(fbase));
/* Search the operating band */
if (IS_FREQUENCY_BAND_HIGH(fbase))
{
band = HIGH_BAND;
}
else if (IS_FREQUENCY_BAND_MIDDLE(fbase))
{
band = MIDDLE_BAND;
}
else if (IS_FREQUENCY_BAND_LOW(fbase))
{
band = LOW_BAND;
}
else
{
band = VERY_LOW_BAND;
}
foffset = spirit_radio_get_foffset(spirit);
chspace = spirit_radio_get_chspace(spirit);
chnum = spirit_radio_get_channel(spirit);
/* Calculates the channel center frequency */
fc = fbase + foffset + chspace * chnum;
/* Read the reference divider */
refdiv = (uint8_t)spirit_radio_get_refdiv(spirit) + 1;
/* Selects the VCO */
switch (band)
{
case VERY_LOW_BAND:
if (fc < 161281250)
{
spirit_calib_select_vco(spirit, VCO_L);
}
else
{
spirit_calib_select_vco(spirit, VCO_H);
}
break;
case LOW_BAND:
if (fc < 322562500)
{
spirit_calib_select_vco(spirit, VCO_L);
}
else
{
spirit_calib_select_vco(spirit, VCO_H);
}
break;
case MIDDLE_BAND:
if (fc < 430083334)
{
spirit_calib_select_vco(spirit, VCO_L);
}
else
{
spirit_calib_select_vco(spirit, VCO_H);
}
break;
case HIGH_BAND:
if (fc < 860166667)
{
spirit_calib_select_vco(spirit, VCO_L);
}
else
{
spirit_calib_select_vco(spirit, VCO_H);
}
}
/* Search the VCO charge pump word and set the corresponding register */
wcp = spirit_radio_search_wcp(spirit, fc);
synthword = (uint32_t)(fbase * g_vectc_bhalf[band] *
(((double)(FBASE_DIVIDER * refdiv)) /
spirit->xtal_frequency));
/* Build the array of registers values for the analog part */
anaregs[0] = (uint8_t)(((synthword >> 21) & 0x0000001f) | (wcp << 5));
anaregs[1] = (uint8_t)((synthword >> 13) & 0x000000ff);
anaregs[2] = (uint8_t)((synthword >> 5) & 0x000000ff);
anaregs[3] = (uint8_t)(((synthword & 0x0000001f) << 3) | g_vectc_bandval[band]);
/* Configures the needed Analog Radio registers */
ret = spirit_reg_write(spirit, SYNT3_BASE, anaregs, 4);
if (ret < 0)
{
return ret;
}
/* Should be perform the VCO calibration WA? */
if (spirit->vcocalib == S_ENABLE)
{
return spirit_managment_wavco_calibration(spirit);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_enable_wavco_calibration
*
* Description:
* Enable/disabe the VCO calibration WA at the end of
* spirit_radio_set_basefrequency()
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* S_ENABLE or S_DISABLE the WA procedure.
*
* Returned Value:
* None.
*
******************************************************************************/
void spirit_radio_enable_wavco_calibration(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
spirit->vcocalib = newstate;
}
/******************************************************************************
* Name: spirit_radio_get_basefrequency
*
* Description:
* Returns the base carrier frequency.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Base carrier frequency expressed in Hz as unsigned word.
*
******************************************************************************/
uint32_t spirit_radio_get_basefrequency(FAR struct spirit_library_s *spirit)
{
enum spirit_bandselect_e band;
uint32_t synthword;
uint8_t refdiv;
/* Read the synth word */
synthword = spirit_radio_get_synthword(spirit);
/* Read the operating band */
band = spirit_radio_get_band(spirit);
refdiv = (uint8_t)spirit_radio_get_refdiv(spirit) + 1;
/* Calculates the frequency base and return it */
return (uint32_t) round(synthword * (((double)spirit->xtal_frequency) /
(FBASE_DIVIDER * refdiv *
g_vectc_bhalf[band])));
}
/******************************************************************************
* Name: spirit_radio_get_centerfreq
*
* Description:
* Returns the actual channel center frequency.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Actual channel center frequency expressed in Hz.
*
******************************************************************************/
uint32_t spirit_radio_get_centerfreq(FAR struct spirit_library_s *spirit)
{
int32_t offset;
uint8_t channel;
uint32_t fbase;
uint32_t chspace;
/* Get the frequency base */
fbase = spirit_radio_get_basefrequency(spirit);
/* Get the frequency offset */
offset = spirit_radio_get_foffset(spirit);
/* Get the channel space */
chspace = spirit_radio_get_chspace(spirit);
/* Get the channel number */
channel = spirit_radio_get_channel(spirit);
/* Calculate the channel center frequency and return it */
return (uint32_t)(fbase + offset + (uint32_t)(chspace * channel));
}
/******************************************************************************
* Name: spirit_radio_convert_datarate
*
* Description:
* Returns the mantissa and exponent, whose value used in the datarate
* formula will give the datarate value closer to the given datarate.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* datarate - datarate expressed in bps. This parameter ranging between 100 and 500000.
* pcm - pointer to the returned mantissa value.
* pce - pointer to the returned exponent value.
*
* Returned Value:
* Error code: 0=no error, <0=error during calibration of VCO.
*
******************************************************************************/
int spirit_radio_convert_datarate(FAR struct spirit_library_s *spirit,
uint32_t datarate, FAR uint8_t *pcm,
FAR uint8_t *pce)
{
int16_t intermediate[3];
uint16_t delta;
uint8_t mantissa;
uint8_t divider = 0;
int8_t i = 15;
uint8_t j;
volatile bool find = false;
/* Check the parameters */
DEBUGASSERT(IS_DATARATE(datarate));
divider = (uint8_t)spirit_radio_isenabled_digdivider(spirit);
/* Search in the datarate array the exponent value */
while (!find && i >= 0)
{
if (datarate >= (spirit->xtal_frequency >> (20 - i + divider)))
{
find = true;
}
else
{
i--;
}
}
i < 0 ? i = 0 : i;
*pce = i;
/* Calculates the mantissa value according to the datarate formula */
mantissa = (datarate * ((uint32_t)1 << (23 - i))) /
(spirit->xtal_frequency >> (5 + divider)) - 256;
/* Finds the mantissa value with less approximation */
for (j = 0; j < 3; j++)
{
if ((mantissa + j - 1))
{
intermediate[j] = datarate - (((256 + mantissa + j - 1) *
(spirit->xtal_frequency >> (5 + divider))) >>
(23 - i));
}
else
{
intermediate[j] = 0x7fff;
}
}
delta = 0xffff;
for (j = 0; j < 3; j++)
{
if (S_ABS(intermediate[j]) < delta)
{
delta = S_ABS(intermediate[j]);
*pcm = mantissa + j - 1;
}
}
return OK;
}
/******************************************************************************
* Name: spirit_radio_convert_chbandwidth
*
* Description:
* Returns the mantissa and exponent for a given bandwidth. Even if it is
* possible to pass as parameter any value in the below mentioned range, the
* API will search the closer value according to a fixed table of channel
* bandwidth values (@ref s_vectnBandwidth), as defined in the datasheet,
* returning the corresponding mantissa and exponent value.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* bandwidth - bandwidth expressed in Hz. This parameter ranging between
* 1100 and 800100.
* pcm - pointer to the returned mantissa value.
* pce - pointer to the returned exponent value.
*
* Returned Value:
* Error code: 0=no error, <0=error during calibration of VCO.
*
******************************************************************************/
int spirit_radio_convert_chbandwidth(FAR struct spirit_library_s *spirit,
uint32_t bandwidth, FAR uint8_t *pcm,
FAR uint8_t *pce)
{
uint32_t chfltfactor;
int16_t intermediate[3];
uint16_t delta;
uint8_t divider = 1;
int8_t tmp;
int8_t i;
int8_t j;
/* Search in the channel filter bandwidth table the exponent value */
if (spirit_radio_isenabled_digdivider(spirit) != S_DISABLE)
{
divider = 2;
}
else
{
divider = 1;
}
DEBUGASSERT(IS_CH_BW(bandwidth, spirit->xtal_frequency / divider));
chfltfactor = (spirit->xtal_frequency / divider) / 100;
for (i = 0;
i < 90 && (bandwidth < (uint32_t)((g_vectn_bandwidth[i] *
chfltfactor) / 2600));
i++);
if (i != 0)
{
/* Finds the mantissa value with less approximation */
tmp = i;
for (j = 0; j < 3; j++)
{
if (((tmp + j - 1) >= 0) || ((tmp + j - 1) <= 89))
{
intermediate[j] = bandwidth -
(uint32_t)((g_vectn_bandwidth[tmp + j - 1] *
chfltfactor) / 2600);
}
else
{
intermediate[j] = 0x7fff;
}
}
delta = 0xFFFF;
for (j = 0; j < 3; j++)
{
if (S_ABS(intermediate[j]) < delta)
{
delta = S_ABS(intermediate[j]);
i = tmp + j - 1;
}
}
}
*pce = (uint8_t)(i / 9);
*pcm = (uint8_t)(i % 9);
return OK;
}
/******************************************************************************
* Name: spirit_radio_convert_freqdev
*
* Description:
* Returns the mantissa and exponent, whose value used in the frequency
* deviation formula will give a frequency deviation value most closer to
* the given frequency deviation.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* fdev - Frequency deviation expressed in Hz. This parameter can be a
* value in the range [F_Xo*8/2^18, F_Xo*7680/2^18].
* pcm - pointer to the returned mantissa value.
* pce - pointer to the returned exponent value.
*
* Returned Value:
* Error code: 0=no error, <0=error during calibration of VCO.
*
******************************************************************************/
int spirit_radio_convert_freqdev(FAR struct spirit_library_s *spirit,
uint32_t fdev, FAR uint8_t *pcm,
FAR uint8_t *pce)
{
uint32_t a;
uint32_t bp;
uint32_t b = 0;
uint8_t i;
float xtalDivtmp = (float)spirit->xtal_frequency / (((uint32_t) 1) << 18);
/* Check the parameters */
DEBUGASSERT(IS_F_DEV(fdev, spirit->xtal_frequency));
for (i = 0; i < 10; i++)
{
a = (uint32_t)(xtalDivtmp * (uint32_t)(7.5 * (1 << i)));
if (fdev < a)
{
break;
}
}
*pce = i;
for (i = 0; i < 8; i++)
{
bp = b;
b = (uint32_t)(xtalDivtmp * (uint32_t)((8.0 + i) / 2 * (1 << (*pce))));
if (fdev < b)
{
break;
}
}
if ((fdev - bp) < (b - fdev))
{
i--;
}
*pcm = i;
return OK;
}
/******************************************************************************
* Name: spirit_radio_set_datarate
*
* Description:
* Sets the datarate.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* datarate - Datarate expressed in bps. This value must be in the range
* [100 500000].
*
* Returned Value:
* Zero (OK) is returned on succes; a negated errnor value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_datarate(FAR struct spirit_library_s *spirit,
uint32_t datarate)
{
uint8_t dre, regval[2];
int ret;
/* Check the parameters */
DEBUGASSERT(IS_DATARATE(datarate));
/* Calculate the datarate mantissa and exponent */
ret = spirit_radio_convert_datarate(spirit, datarate, &regval[0], &dre);
if (ret >= 0)
{
/* Read the MOD_O register */
spirit_reg_read(spirit, MOD0_BASE, &regval[1], 1);
/* Mask the other fields and set the datarate exponent */
regval[1] &= 0xf0;
regval[1] |= dre;
/* Write the Datarate registers */
ret = spirit_reg_write(spirit, MOD1_BASE, regval, 2);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_datarate
*
* Description:
* Returns the datarate.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Settled datarate expressed in bps.
*
******************************************************************************/
uint32_t spirit_radio_get_datarate(FAR struct spirit_library_s *spirit)
{
uint8_t regval[2];
uint8_t divider = 0;
/* Read the datarate registers for mantissa and exponent */
(void)spirit_reg_read(spirit, MOD1_BASE, regval, 2);
/* Calculates the datarate */
divider = (uint8_t) spirit_radio_isenabled_digdivider(spirit);
return (((spirit->xtal_frequency >> (5 + divider)) *
(256 + regval[0])) >> (23 - (regval[1] & 0x0f)));
}
/******************************************************************************
* Name: spirit_radio_set_freqdev
*
* Description:
* Sets the frequency deviation.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* fdev - Frequency deviation expressed in Hz. Be sure that this value
* is in the correct range [F_Xo*8/2^18, F_Xo*7680/2^18] Hz.
*
* Returned Value:
* Zero (OK) is returned on succes; a negated errnor value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_freqdev(FAR struct spirit_library_s *spirit,
uint32_t fdev)
{
uint8_t fdevm;
uint8_t fdeve;
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_F_DEV(fdev, spirit->xtal_frequency));
/* Calculates the frequency deviation mantissa and exponent */
ret = spirit_radio_convert_freqdev(spirit, fdev, &fdevm, &fdeve);
if (ret < 0)
{
return ret;
}
/* Read the FDEV0 register */
ret = spirit_reg_read(spirit, FDEV0_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the other fields and set the frequency deviation mantissa and
* exponent
*/
regval &= 0x08;
regval |= ((fdeve << 4) | (fdevm));
/* Write the Frequency deviation register */
ret = spirit_reg_write(spirit, FDEV0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_freqdev
*
* Description:
* Returns the frequency deviation.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Frequency deviation value expressed in Hz.
* This value will be in the range [F_Xo*8/2^18, F_Xo*7680/2^18] Hz.
*
******************************************************************************/
uint32_t spirit_radio_get_freqdev(FAR struct spirit_library_s *spirit)
{
uint8_t fdevm;
uint8_t fdeve;
uint8_t regval;
/* Read the frequency deviation register for mantissa and exponent */
(void)spirit_reg_read(spirit, FDEV0_BASE, &regval, 1);
fdevm = regval & 0x07;
fdeve = (regval & 0xf0) >> 4;
/* Calculates the frequency deviation and return it */
return (uint32_t)((float)spirit->xtal_frequency / (((uint32_t) 1) << 18) *
(uint32_t)((8.0 + fdevm) / 2 * (1 << fdeve)));
}
/******************************************************************************
* Name: spirit_radio_set_chfilterbw
*
* Description:
* Sets the channel filter bandwidth.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* bandwidth - Channel filter bandwidth expressed in Hz. This parameter
* must be in the range [1100 800100]. The API will search the
* closest value according to a fixed table of channel bandwidth
* values, as defined in the datasheet. To verify the settled
* channel bandwidth it is possible to use the
* spirit_radio_get_chfilterbw() API.
*
* Returned Value:
* Zero (OK) is returned on succes; a negated errnor value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_chfilterbw(FAR struct spirit_library_s *spirit,
uint32_t bandwidth)
{
uint8_t bwm;
uint8_t bwe;
uint8_t regval;
int ret;
/* Search in the channel filter bandwidth table the exponent value */
if (spirit_radio_isenabled_digdivider(spirit))
{
DEBUGASSERT(IS_CH_BW(bandwidth, (spirit->xtal_frequency / 2)));
}
else
{
DEBUGASSERT(IS_CH_BW(bandwidth, (spirit->xtal_frequency)));
}
/* Calculates the channel bandwidth mantissa and exponent */
ret = spirit_radio_convert_chbandwidth(spirit, bandwidth, &bwm, &bwe);
if (ret >= 0)
{
regval = (bwm << 4) | (bwe);
/* Write the Channel filter register */
ret = spirit_reg_write(spirit, CHFLT_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_chfilterbw
*
* Description:
* Returns the channel filter bandwidth.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Channel filter bandwidth expressed in Hz.
*
******************************************************************************/
uint32_t spirit_radio_get_chfilterbw(FAR struct spirit_library_s *spirit)
{
uint8_t regval, bwm, bwe;
/* Read the channel filter register for mantissa and exponent */
(void)spirit_reg_read(spirit, CHFLT_BASE, &regval, 1);
bwm = (regval & 0xf0) >> 4;
bwe = regval & 0x0f;
/* Read the channel filter bandwidth from the look-up table and return it */
return (uint32_t)(100.0 * g_vectn_bandwidth[bwm + (bwe * 9)] *
spirit->xtal_frequency / 26e6);
}
/******************************************************************************
* Name: spirit_radio_set_modulation
*
* Description:
* Sets the modulation type.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* modulation - Modulation to set.
*
* Returned Value:
* Zero (OK) is returned on succes; a negated errnor value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_modulation(FAR struct spirit_library_s *spirit,
enum modulation_select_e modulation)
{
uint8_t regval;
/* Check the parameters */
DEBUGASSERT(IS_MODULATION_SELECTED(modulation));
/* Read the modulation register */
spirit_reg_read(spirit, MOD0_BASE, &regval, 1);
/* Mask the other fields and set the modulation type */
regval &= 0x8f;
regval |= modulation;
/* Write the modulation register */
return spirit_reg_write(spirit, MOD0_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_modulation
*
* Description:
* Returns the modulation type used.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Settled modulation type.
*
******************************************************************************/
enum modulation_select_e
spirit_radio_get_modulation(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the modulation register MOD0 */
(void)spirit_reg_read(spirit, MOD0_BASE, &regval, 1);
/* Return the modulation type */
return (enum modulation_select_e)(regval & 0x70);
}
/******************************************************************************
* Name: spirit_radio_enable_cwtxmode
*
* Description:
* Enables or Disables the Continuous Wave transmit mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for power ramping. This parameter can be: S_ENABLE
* or S_DISABLE .
*
* Returned Value:
* Zero (OK) is returned on succes; a negated errnor value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_enable_cwtxmode(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the modulation register MOD0 and mask the CW field */
ret = spirit_reg_read(spirit, MOD0_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= MOD0_CW;
}
else
{
regval &= (~MOD0_CW);
}
/* Write the new value to the MOD0 register */
ret = spirit_reg_write(spirit, MOD0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_ookpeackdecay
*
* Description:
* Sets the OOK Peak Decay.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* ookdelay - Peak decay control for OOK.
*
* Returned Value:
* Zero (OK) is returned on succes; a negated errnor value is returned on any
* failure.
*
******************************************************************************/
int spirit_radio_set_ookpeackdecay(FAR struct spirit_library_s *spirit,
enum spirit_ookpeakdelay_e ookdelay)
{
uint8_t regval;
/* Check the parameters */
DEBUGASSERT(IS_OOK_PEAK_DECAY(ookdelay));
/* Read the RSSI_FLT register */
spirit_reg_read(spirit, RSSI_FLT_BASE, &regval, 1);
/* Mask the other fields and set OOK Peak Decay */
regval &= 0xfc;
regval |= ookdelay;
/* Write the RSSI_FLT register to set the new OOK peak dacay value */
return spirit_reg_write(spirit, RSSI_FLT_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_ookpeackdecay
*
* Description:
* Returns the OOK Peak Decay.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Ook peak decay value.
*
******************************************************************************/
enum spirit_ookpeakdelay_e
spirit_radio_get_ookpeackdecay(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the OOK peak decay register RSSI_FLT_BASE */
(void)spirit_reg_read(spirit, RSSI_FLT_BASE, &regval, 1);
/* Returns the OOK peak decay */
return (enum spirit_ookpeakdelay_e)(regval & 0x03);
}
/******************************************************************************
* Name: spirit_radio_convert_power2reg
*
* Description:
* Returns the PA register value that corresponds to the passed dBm power.
*
* NOTE: The power interpolation curves used by this function have been
* extracted by measurements done on the divisional evaluation boards.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* fbase - Frequency base expressed in Hz.
* power - Desired power in dBm.
*
* Returned Value:
* Register value as byte.
*
******************************************************************************/
uint8_t spirit_radio_convert_power2reg(FAR struct spirit_library_s *spirit,
uint32_t fbase, float power)
{
float pavalue;
uint8_t i = 0;
uint8_t j = 0;
if (IS_FREQUENCY_BAND_HIGH(fbase))
{
i = 0;
if (fbase < 900000000)
{
i = 1; /* 868 */
}
}
else if (IS_FREQUENCY_BAND_MIDDLE(fbase))
{
i = 2;
}
else if (IS_FREQUENCY_BAND_LOW(fbase))
{
i = 3;
}
else if (IS_FREQUENCY_BAND_VERY_LOW(fbase))
{
i = 4;
}
j = 1;
if (power > 0 &&
13.0 / g_power_factors[i][2] - g_power_factors[i][3] /
g_power_factors[i][2] < power)
{
j = 0;
}
else if (power <= 0 &&
40.0 / g_power_factors[i][2] - g_power_factors[i][3] /
g_power_factors[i][2] > power)
{
j = 2;
}
pavalue = g_power_factors[i][2 * j] * power +
g_power_factors[i][2 * j + 1];
if (pavalue < 1)
{
pavalue = 1;
}
else if (pavalue > 90)
{
pavalue = 90;
}
return (uint8_t)pavalue;
}
/******************************************************************************
* Name: spirit_radio_convert_reg2power
*
* Description:
* Returns the dBm power that corresponds to the value of PA register.
*
* NOTE: The power interpolation curves used by this function have been
* extracted by measurements done on the divisional evaluation boards.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* fbase - Frequency base expressed in Hz.
* regval - Register value of the PA.
*
* Returned Value:
* Power in dBm as float.
*
******************************************************************************/
float spirit_radio_convert_reg2power(FAR struct spirit_library_s *spirit,
uint32_t fbase, uint8_t regval)
{
uint8_t i = 0;
uint8_t j = 0;
float power;
if (regval == 0 || regval > 90)
{
return -130.0;
}
if (IS_FREQUENCY_BAND_HIGH(fbase))
{
i = 0;
if (fbase < 900000000)
{
i = 1; /* 868 */
}
}
else if (IS_FREQUENCY_BAND_MIDDLE(fbase))
{
i = 2;
}
else if (IS_FREQUENCY_BAND_LOW(fbase))
{
i = 3;
}
else if (IS_FREQUENCY_BAND_VERY_LOW(fbase))
{
i = 4;
}
j = 1;
if (regval < 13)
{
j = 0;
}
else if (regval > 40)
{
j = 2;
}
power = (((float)regval) / g_power_factors[i][2 * j] -
g_power_factors[i][2 * j + 1] / g_power_factors[i][2 * j]);
return power;
}
/******************************************************************************
* Name: spirit_radio_config_patable_dbm
*
* Description:
* Configures the Power Amplifier Table and registers with value expressed
* in dBm.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* nlevels - Number of levels to set. This parameter must be in the range
* [0:7].
* width - Step width expressed in terms of bit period units Tb/8. This
* parameter must be in the range [1:4].
* load - The of the possible value of the enum type enum
* pirit_paload_capacitor_e.
*
* LOAD_0_PF No additional PA load capacitor
* LOAD_1_2_PF 1.2pF additional PA load capacitor
* LOAD_2_4_PF 2.4pF additional PA load capacitor
* LOAD_3_6_PF 3.6pF additional PA load capacitor
*
* table - Pointer to an array of PA values in dbm between
* [-PA_LOWER_LIMIT: PA_UPPER_LIMIT] dbm. The first element must
* be the lower level (PA_LEVEL[0]) value and the last element
* the higher level one (PA_LEVEL[paLevelMaxIndex]).
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_config_patable_dbm(FAR struct spirit_library_s *spirit,
uint8_t nlevels, uint8_t width,
enum spirit_paload_capacitor_e load,
FAR float *table)
{
uint8_t palevel[9];
uint8_t regaddr;
uint8_t value;
uint32_t fbase = spirit_radio_get_basefrequency(spirit);
int i;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(nlevels));
DEBUGASSERT(IS_PA_STEP_WIDTH(width));
DEBUGASSERT(IS_PA_LOAD_CAP(load));
/* Check the PA level in dBm is in the range and calculate the PA_LEVEL value
* to write in the corresponding register using the linearization formula */
for (i = 0; i <= nlevels; i++)
{
DEBUGASSERT(IS_PAPOWER_DBM(*table));
value = spirit_radio_convert_power2reg(spirit, fbase, *table);
palevel[nlevels - i] = value;
table++;
}
/* Set the PA_POWER[0] register */
palevel[nlevels + 1] = load | (width - 1) << 3 | nlevels;
/* Get the base address */
regaddr = PA_POWER8_BASE + 7 - nlevels;
/* Configuresthe PA_POWER registers */
return spirit_reg_write(spirit, regaddr, palevel, nlevels + 2);
}
/******************************************************************************
* Name: spirit_radio_get_patable_dbm
*
* Description:
* Returns the Power Amplifier Table and registers, returning values in dBm.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* nlevels - Pointer to the number of levels settled. This parameter must
* be in the range [0:7].
* table - Pointer to an array of 8 elements containing the PA value in dbm.
* The first element will be the PA_LEVEL_0 and the last element
* will be PA_LEVEL_7. Any value higher than PA_UPPER_LIMIT implies
( no output power (output stage is in high impedance).
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_get_patable_dbm(FAR struct spirit_library_s *spirit,
FAR uint8_t *nlevels, FAR float *table)
{
uint32_t fbase = spirit_radio_get_basefrequency(spirit);
uint8_t palevel[9];
int ret;
int i;
/* Reads the PA_LEVEL_x registers and the PA_POWER_0 register */
ret = spirit_reg_read(spirit, PA_POWER8_BASE, palevel, 9);
if (ret >= 0)
{
/* Fill the PAtable */
for (i = 7; i >= 0; i--)
{
*table++ = spirit_radio_convert_reg2power(spirit, fbase, palevel[i]);
}
/* Return the settled index */
*nlevels = palevel[8] & 0x07;
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_palevel_dbm
*
* Description:
* Sets a specific PA_LEVEL register, with a value given in dBm.
*
* NOTE: This function makes use of the spirit_radio_convert_power2reg fcn
* to interpolate the power value.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* ndx - PA_LEVEL to set. This parameter shall be in the range [0:7].
* power - PA value to write expressed in dBm . Be sure that this values
* is in the correct range [-PA_LOWER_LIMIT: PA_UPPER_LIMIT] dBm.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_palevel_dbm(FAR struct spirit_library_s *spirit,
uint8_t ndx, float power)
{
uint32_t basefrequency;
uint8_t address;
uint8_t level;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(ndx));
DEBUGASSERT(IS_PAPOWER_DBM(power));
/* Interpolate the power level */
basefrequency = spirit_radio_get_basefrequency(spirit);
level = spirit_radio_convert_power2reg(spirit, basefrequency, power);
/* Sets the base address */
address = PA_POWER8_BASE + 7 - ndx;
/* Configures the PA_LEVEL register */
return spirit_reg_write(spirit, address, &level, 1);
}
/******************************************************************************
* Name: spirit_radio_get_palevel_dbm
*
* Description:
* Returns a specific PA_LEVEL register, returning a value in dBm.
*
* NOTE: This function makes use of the @ref spirit_radio_convert_reg2power fcn to
* interpolate the power value.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* ndx - PA_LEVEL to read. This parameter shall be in the range [0:7]
*
* Returned Value:
* Settled power level expressed in dBm. A value higher than PA_UPPER_LIMIT
* dBm implies no output power (output stage is in high impedance).
*
******************************************************************************/
float spirit_radio_get_palevel_dbm(FAR struct spirit_library_s *spirit,
uint8_t ndx)
{
uint8_t regaddr;
uint8_t value;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(ndx));
/* Sets the base address */
regaddr = PA_POWER8_BASE + 7 - ndx;
/* Reads the PA_LEVEL[ndx] register */
(void)spirit_reg_read(spirit, regaddr, &value, 1);
return spirit_radio_convert_reg2power(spirit,
spirit_radio_get_basefrequency(spirit),
value);
}
/******************************************************************************
* Name: spirit_radio_config_patable
*
* Description:
* Configures the Power Amplifier Table and registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* nlevels - Number of levels to set. This parameter must be in the range
* [0:7].
* width - Step width expressed in terms of bit period units Tb/8. This
* parameter must be in the range [1:4].
* load - One of the possible value of the enum type enum
* spirit_paload_capacitor_e.
*
* LOAD_0_PF No additional PA load capacitor
* LOAD_1_2_PF 1.2pF additional PA load capacitor
* LOAD_2_4_PF 2.4pF additional PA load capacitor
* LOAD_3_6_PF 3.6pF additional PA load capacitor
*
* table - Pointer to an array of PA values in the range [0: 90], where
* 0 implies no output power, 1 will be the maximum level and 90
* the minimum one. The first element must be the lower level
* (PA_LEVEL[0]) value and the last element the higher level one
* (PA_LEVEL[paLevelMaxIndex]).
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_config_patable(FAR struct spirit_library_s *spirit,
uint8_t nlevels, uint8_t width,
enum spirit_paload_capacitor_e load,
FAR uint8_t *table)
{
uint8_t palevel[9];
uint8_t regaddr;
int i;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(nlevels));
DEBUGASSERT(IS_PA_STEP_WIDTH(width));
DEBUGASSERT(IS_PA_LOAD_CAP(load));
/* Check the PA levels are in the range */
for (i = 0; i <= nlevels; i++)
{
DEBUGASSERT(IS_PAPOWER(*table));
palevel[nlevels - i] = *table;
table++;
}
/* Sets the PA_POWER[0] register */
palevel[nlevels + 1] = load | ((width - 1) << 3) | nlevels;
/* Sets the base address */
regaddr = PA_POWER8_BASE + 7 - nlevels;
/* Configures the PA_POWER registers */
return spirit_reg_write(spirit, regaddr, palevel, nlevels + 2);
}
/******************************************************************************
* Name: spirit_radio_get_patable
*
* Description:
* Returns the Power Amplifier Table and registers.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* nlevels - Pointer to the number of levels settled. This parameter must
* be in the range [0:7].
* table - Pointer to an array of 8 elements containing the PA value. The
* first element will be the PA_LEVEL_0 and the last element will
* be PA_LEVEL_7. Any value equals to 0 implies that level has no
* output power (output stage is in high impedance).
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_get_patable(FAR struct spirit_library_s *spirit,
FAR uint8_t *nlevels, FAR uint8_t *table)
{
uint8_t palevels[9];
int ret;
int i;
/* Reads the PA_LEVEL_x registers and the PA_POWER_0 register */
ret = spirit_reg_read(spirit, PA_POWER8_BASE, palevels, 9);
if (ret >= 0)
{
/* Fill the PAtable */
for (i = 7; i >= 0; i--)
{
*table++ = palevels[i];
}
/* Return the settled index */
*nlevels = palevels[8] & 0x07;
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_palevel
*
* Description:
* Sets a specific PA_LEVEL register.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* ndx - PA_LEVEL to set. This parameter shall be in the range [0:7].
* power - PA value to write in the register. Be sure that this values is
* in the correct range [0 : 90].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_palevel(FAR struct spirit_library_s *spirit,
uint8_t ndx, uint8_t power)
{
uint8_t regaddr;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(ndx));
DEBUGASSERT(IS_PAPOWER(power));
/* Sets the base address */
regaddr = PA_POWER8_BASE + 7 - ndx;
/* Configures the PA_LEVEL register */
return spirit_reg_write(spirit, regaddr, &power, 1);
}
/******************************************************************************
* Name: spirit_radio_get_palevel
*
* Description:
* Returns a specific PA_LEVEL register.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* ndx - PA_LEVEL to read. This parameter shall be in the range [0:7].
*
* Returned Value:
* PA_LEVEL value. A value equal to zero
* implies no output power (output stage is in high impedance).
*
******************************************************************************/
uint8_t spirit_radio_get_palevel(FAR struct spirit_library_s *spirit,
uint8_t ndx)
{
uint8_t regaddr;
uint8_t regval;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(ndx));
/* Sets the base address */
regaddr = PA_POWER8_BASE + 7 - ndx;
/* Reads the PA_LEVEL[ndx] register and return the value */
(void)spirit_reg_read(spirit, regaddr, &regval, 1);
return regval;
}
/******************************************************************************
* Name: spirit_radio_set_outputload
*
* Description:
* Sets the output stage additional load capacitor bank.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* load one of the possible value of the enum type enum spirit_paload_capacitor_e.
* LOAD_0_PF No additional PA load capacitor
* LOAD_1_2_PF 1.2pF additional PA load capacitor
* LOAD_2_4_PF 2.4pF additional PA load capacitor
* LOAD_3_6_PF 3.6pF additional PA load capacitor
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_outputload(FAR struct spirit_library_s *spirit,
enum spirit_paload_capacitor_e load)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_PA_LOAD_CAP(load));
/* Read the PA_POWER_0 register */
ret = spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the CWC[1:0] field and write the new value */
regval &= 0x3f;
regval |= load;
/* Configures the PA_POWER_0 register */
ret = spirit_reg_write(spirit, PA_POWER0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_outputload
*
* Description:
* Returns the output stage additional load capacitor bank.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Output stage additional load capacitor bank. This value may be:
*
* LOAD_0_PF No additional PA load capacitor
* LOAD_1_2_PF 1.2pF additional PA load capacitor
* LOAD_2_4_PF 2.4pF additional PA load capacitor
* LOAD_3_6_PF 3.6pF additional PA load capacitor
*
******************************************************************************/
enum spirit_paload_capacitor_e
spirit_radio_get_outputload(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the PA_POWER_0 register */
(void)spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
/* Mask the CWC[1:0] field and return the value */
return (enum spirit_paload_capacitor_e)(regval & 0xc0);
}
/******************************************************************************
* Name: spirit_radio_set_palevel_maxindex
*
* Description:
* Sets a specific PA_LEVEL_MAX_INDEX.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* ndx - PA_LEVEL_MAX_INDEX to set. This parameter must be in the range
* [0:7].
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_set_palevel_maxindex(FAR struct spirit_library_s *spirit,
uint8_t ndx)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_PA_MAX_INDEX(ndx));
/* Read the PA_POWER_0 register */
ret = spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the PA_LEVEL_MAX_INDEX[1:0] field and write the new value */
regval &= 0xf8;
regval |= ndx;
/* Configures the PA_POWER_0 register */
ret = spirit_reg_write(spirit, PA_POWER0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_palevel_maxindex
*
* Description:
* Returns the actual PA_LEVEL_MAX_INDEX.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Actual PA_LEVEL_MAX_INDEX. This value will be in the range [0:7].
*
******************************************************************************/
uint8_t spirit_radio_get_palevel_maxindex(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the PA_POWER_0 register */
(void)spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
/* Mask the PA_LEVEL_MAX_INDEX[1:0] field and return the value */
return (regval & 0x07);
}
/******************************************************************************
* Name: spirit_radio_set_pastep_width
*
* Description:
* Sets a specific PA_RAMP_STEP_WIDTH.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* width - Step width expressed in terms of bit period units Tb/8. This
* value must be in the range [1:4].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_pastep_width(FAR struct spirit_library_s *spirit,
uint8_t width)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_PA_STEP_WIDTH(width));
/* Read the PA_POWER_0 register */
ret = spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the PA_RAMP_STEP_WIDTH[1:0] field and write the new value */
regval &= 0xe7;
regval |= (width - 1) << 3;
/* Configures the PA_POWER_0 register */
ret = spirit_reg_write(spirit, PA_POWER0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_pastep_width
*
* Description:
* Returns the actual PA_RAMP_STEP_WIDTH.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Step width value expressed in terms of bit period units Tb/8. This
* value will be in the range [1:4].
*
******************************************************************************/
uint8_t spirit_radio_get_pastep_width(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the PA_POWER_0 register */
(void)spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
/* Mask the PA_RAMP_STEP_WIDTH[1:0] field and return the value */
regval &= 0x18;
return ((regval >> 3) + 1);
}
/******************************************************************************
* Name: spirit_radio_enable_paramp
*
* Description:
* Enables or Disables the Power Ramping.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for power ramping. This value can be: S_ENABLE
* or S_DISABLE.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_enable_paramp(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the PA_POWER_0 register and configure the PA_RAMP_ENABLE field */
ret = spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= PA_POWER0_PA_RAMP_MASK;
}
else
{
regval &= (~PA_POWER0_PA_RAMP_MASK);
}
/* Set the PA_POWER_0 register */
ret = spirit_reg_write(spirit, PA_POWER0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_isenabled_paramp
*
* Description:
* Returns the state of the Power Ramping enable bit.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for power ramping. This value can be: S_ENABLE
* or S_DISABLE.
*
* Returned Value:
* Power Ramping enable state.
*
******************************************************************************/
enum spirit_functional_state_e
spirit_radio_isenabled_paramp(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the PA_POWER_0 register and configure the PA_RAMP_ENABLE field */
(void)spirit_reg_read(spirit, PA_POWER0_BASE, &regval, 1);
/* Mask and return data */
return (enum spirit_functional_state_e)((regval >> 5) & 0x01);
}
/******************************************************************************
* Name: spirit_radio_enable_afc
*
* Description:
* Enables or Disables the AFC.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for AFC. This value can be: S_ENABLE or
* S_DISABLE.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_enable_afc(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the AFC_2 register and configure the AFC Enabled field */
ret = spirit_reg_read(spirit, AFC2_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= AFC2_AFC_MASK;
}
else
{
regval &= (~AFC2_AFC_MASK);
}
/* Set the AFC_2 register */
ret = spirit_reg_write(spirit, AFC2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_afcfreezeonsync
*
* Description:
* Enables or Disables the AFC freeze on sync word detection.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - new state for AFC freeze on sync word detection.
* This parameter can be: S_ENABLE or S_DISABLE.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_afcfreezeonsync(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the AFC_2 register and configure the AFC Freeze on Sync field */
ret = spirit_reg_read(spirit, AFC2_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= AFC2_AFC_FREEZE_ON_SYNC_MASK;
}
else
{
regval &= (~AFC2_AFC_FREEZE_ON_SYNC_MASK);
}
/* Sets the AFC_2 register */
ret = spirit_reg_write(spirit, AFC2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_afcmode
*
* Description:
* Sets the AFC working mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* mode - The AFC mode. This value can be one of the values defined in
* enum spirit_afcmode_e:
*
* AFC_SLICER_CORRECTION AFC loop closed on slicer
* AFC_2ND_IF_CORRECTION AFC loop closed on 2nd conversion stage
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_afcmode(FAR struct spirit_library_s *spirit,
enum spirit_afcmode_e mode)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_AFC_MODE(mode));
/* Read the AFC_2 register and configure the AFC Mode field */
ret = spirit_reg_read(spirit, AFC2_BASE, &regval, 1);
if (ret >= 0)
{
if (mode == AFC_2ND_IF_CORRECTION)
{
regval |= AFC_2ND_IF_CORRECTION;
}
else
{
regval &= (~AFC_2ND_IF_CORRECTION);
}
/* Set the AFC_2 register */
ret = spirit_reg_write(spirit, AFC2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_afcmode
*
* Description:
* Returns the AFC working mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Settled AFC mode. This value will be one of the values defined in
* enum spirit_afcmode_e:
*
* AFC_SLICER_CORRECTION AFC loop closed on slicer
* AFC_2ND_IF_CORRECTION AFC loop closed on 2nd conversion stage
*
******************************************************************************/
enum spirit_afcmode_e
spirit_radio_get_afcmode(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AFC_2 register */
(void)spirit_reg_read(spirit, AFC2_BASE, &regval, 1);
/* Mask the AFC Mode field and returns the value */
return (enum spirit_afcmode_e)(regval & 0x20);
}
/******************************************************************************
* Name: spirit_radio_set_afcpdleakage
*
* Description:
* Sets the AFC peak detector leakage.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* leakage - The peak detector leakage. This value must be in the
* range: [0:31].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_afcpdleakage(FAR struct spirit_library_s *spirit,
uint8_t leakage)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_AFC_PD_LEAKAGE(leakage));
/* Read the AFC_2 register and configure the AFC PD leakage field */
ret = spirit_reg_read(spirit, AFC2_BASE, &regval, 1);
if (ret >= 0)
{
regval &= 0xe0;
regval |= leakage;
/* Set the AFC_2 register */
ret = spirit_reg_write(spirit, AFC2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_afcpdleakage
*
* Description:
* Returns the AFC peak detector leakage.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Peak detector leakage value. This value will be in the range: [0:31].
*
******************************************************************************/
uint8_t spirit_radio_get_afcpdleakage(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AFC_2 register */
(void)spirit_reg_read(spirit, AFC2_BASE, &regval, 1);
/* Mask the AFC PD leakage field and return the value */
return (regval & 0x1f);
}
/******************************************************************************
* Name: spirit_radio_set_afcfastperiod
*
* Description:
* Sets the length of the AFC fast period expressed as number of samples.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* length - Length of the fast period in number of samples.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_afcfastperiod(FAR struct spirit_library_s *spirit,
uint8_t length)
{
/* Set the AFC_1 register */
return spirit_reg_write(spirit, AFC1_BASE, &length, 1);
}
/******************************************************************************
* Name: spirit_radio_get_afcfastperiod
*
* Description:
* Returns the AFC fast period expressed as number of samples.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Length of the fast period in number of samples.
*
******************************************************************************/
uint8_t spirit_radio_get_afcfastperiod(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AFC 1 register and return the value */
(void)spirit_reg_read(spirit, AFC1_BASE, &regval, 1);
return regval;
}
/******************************************************************************
* Name: spirit_radio_set_afcfastgain
*
* Description:
* Sets the AFC loop gain in fast mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* gain - AFC loop gain in fast mode. This value must be in the range:
* [0:15].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_afcfastgain(FAR struct spirit_library_s *spirit,
uint8_t gain)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_AFC_FAST_GAIN(gain));
/* Read the AFC_0 register and configure the AFC Fast Gain field */
ret = spirit_reg_read(spirit, AFC0_BASE, &regval, 1);
if (ret >= 0)
{
regval &= 0x0f;
regval |= gain << 4;
/* Set the AFC_0 register */
ret = spirit_reg_write(spirit, AFC0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_afcfastgain
*
* Description:
* Returns the AFC loop gain in fast mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* uint8_t AFC loop gain in fast mode. This value will be in the range:
* [0:15].
*
******************************************************************************/
uint8_t spirit_radio_get_afcfastgain(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AFC_0 register, mask the AFC Fast Gain field and return the
* value.
*/
(void)spirit_reg_read(spirit, AFC0_BASE, &regval, 1);
return ((regval & 0xf0) >> 4);
}
/******************************************************************************
* Name: spirit_radio_set_afclowgain
*
* Description:
* Sets the AFC loop gain in slow mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* gain - AFC loop gain in slow mode. This value must be in the range:
* [0:15].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_afclowgain(FAR struct spirit_library_s *spirit,
uint8_t gain)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_AFC_SLOW_GAIN(gain));
/* Read the AFC_0 register and configure the AFC Slow Gain field */
ret = spirit_reg_read(spirit, AFC0_BASE, &regval, 1);
if (ret >= 0)
{
regval &= 0xf0;
regval |= gain;
/* Set the AFC_0 register */
ret = spirit_reg_write(spirit, AFC0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_afclowgain
*
* Description:
* Returns the AFC loop gain in slow mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AFC loop gain in slow mode. This value will be in the range: [0:15].
*
******************************************************************************/
uint8_t spirit_radio_get_afclowgain(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AFC_0 register, mask the AFC Slow Gain field and return the
* value */
(void)spirit_reg_read(spirit, AFC0_BASE, &regval, 1);
return (regval & 0x0f);
}
/******************************************************************************
* Name: spirit_radio_get_afccorrection
*
* Description:
* Returns the AFC correction from the corresponding register.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AFC correction, read from the corresponding register. This value
* will be in the range [-128:127].
*
******************************************************************************/
int8_t spirit_radio_get_afccorrection(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AFC_CORR register, cast the read value as signed char and return
* it.
*/
(void)spirit_reg_read(spirit, AFC_CORR_BASE, &regval, 1);
return (int8_t)regval;
}
/******************************************************************************
* Name: spirit_radio_get_afccorrection_hz
*
* Description:
* Returns the AFC correction expressed in Hz.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AFC correction expressed in Hz according to the following formula:
*
* Fafc[Hz]= (Fdig/(12*2^10))*AFC_CORR
*
* where AFC_CORR is the value read in the AFC_CORR register
*
******************************************************************************/
int32_t spirit_radio_get_afccorrection_hz(FAR struct spirit_library_s *spirit)
{
int8_t correction;
uint32_t xtal = spirit->xtal_frequency;
/* Read the AFC correction register */
correction = spirit_radio_get_afccorrection(spirit);
if (xtal > DOUBLE_XTAL_THR)
{
xtal /= 2;
}
/* Calculates and return the Frequency Correction */
return (int32_t)(xtal / (12 * pow(2, 10)) * correction);
}
/******************************************************************************
* Name: spirit_radio_enable_agc
*
* Description:
* Enables or Disables the AGC.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for AGC.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_enable_agc(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the AGCCTRL_0 register and configure the AGC Enabled field */
ret = spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= AGCCTRL0_AGC_MASK;
}
else
{
regval &= (~AGCCTRL0_AGC_MASK);
}
/* Set the AGCCTRL_0 register */
ret = spirit_reg_write(spirit, AGCCTRL0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_agcmode
*
* Description:
* Sets the AGC working mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* mode - The AGC mode. This value can be one of the values defined in
* enum spirit_agcmode_e:
*
* AGC_LINEAR_MODE AGC works in linear mode
* AGC_BINARY_MODE AGC works in binary mode
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agcmode(FAR struct spirit_library_s *spirit,
enum spirit_agcmode_e mode)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_AGC_MODE(mode));
/* Read the AGCCTRL_0 register and configure the AGC Mode field */
ret = spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
if (ret >= 0)
{
if (mode == AGC_BINARY_MODE)
{
regval |= AGC_BINARY_MODE;
}
else
{
regval &= (~AGC_BINARY_MODE);
}
/* Set the AGCCTRL_0 register */
ret = spirit_reg_write(spirit, AGCCTRL0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_agcmode
*
* Description:
* Returns the AGC working mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Settled AGC mode. This value can be one of the values defined in
* enum spirit_agcmode_e:
*
* AGC_LINEAR_MODE AGC works in linear mode
* AGC_BINARY_MODE AGC works in binary mode
*
******************************************************************************/
enum spirit_agcmode_e
spirit_radio_get_agcmode(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AGCCTRL_0 register, mask the AGC Mode field and return the value */
(void)spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
return (enum spirit_agcmode_e)(regval & 0x40);
}
/******************************************************************************
* Name: spirit_radio_enable_agcfreeze_steady
*
* Description:
* Enables or Disables the AGC freeze on steady state.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for AGC freeze on steady state.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_enable_agcfreeze_steady(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the AGCCTRL_2 register and configure the AGC Freeze On Steady field */
ret = spirit_reg_read(spirit, AGCCTRL2_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= AGCCTRL2_FREEZE_ON_STEADY_MASK;
}
else
{
regval &= (~AGCCTRL2_FREEZE_ON_STEADY_MASK);
}
/* Set the AGCCTRL_2 register */
ret = spirit_reg_write(spirit, AGCCTRL2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_enable_agcfreeze_sync
*
* Description:
* Enable or Disable the AGC freeze on sync detection.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for AGC freeze on sync detection.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_enable_agcfreeze_sync(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the AGCCTRL_2 register and configure the AGC Freeze On Sync field */
ret = spirit_reg_read(spirit, AGCCTRL2_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= AGCCTRL2_FREEZE_ON_SYNC_MASK;
}
else
{
regval &= (~AGCCTRL2_FREEZE_ON_SYNC_MASK);
}
/* Set the AGCCTRL_2 register */
ret = spirit_reg_write(spirit, AGCCTRL2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_enable_agcfreeze_maxatten
*
* Description:
* Enable or Disable the AGC to start with max attenuation.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for AGC start with max attenuation mode.
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_enable_agcfreeze_maxatten(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the AGCCTRL_2 register and configure the AGC Start Max Attenuation
* field */
ret = spirit_reg_read(spirit, AGCCTRL2_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= AGCCTRL2_START_MAX_ATTENUATION_MASK;
}
else
{
regval &= (~AGCCTRL2_START_MAX_ATTENUATION_MASK);
}
/* Set the AGCCTRL_2 register */
ret = spirit_reg_write(spirit, AGCCTRL2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_agcmeasure_us
*
* Description:
* Sets the AGC measure time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* time - AGC measure time expressed in us. This value must be in the
* range [0, 393216/F_Xo].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agcmeasure_us(FAR struct spirit_library_s *spirit,
uint16_t time)
{
uint8_t regval;
uint8_t measure;
int ret;
/* Check the parameter */
DEBUGASSERT(IS_AGC_MEASURE_TIME_US(time, spirit->xtal_frequency));
/* Read the AGCCTRL_2 register */
ret = spirit_reg_read(spirit, AGCCTRL2_BASE, &regval, 1);
if (ret >= 0)
{
/* Calculates the measure time value to write in the register */
measure = (uint8_t)
lroundf(log2((float)time / 1e6 * spirit->xtal_frequency / 12));
if (measure > 15)
{
measure = 15;
}
/* Mask the MEAS_TIME field and write the new value */
regval &= 0xf0;
regval |= measure;
/* Set the AGCCTRL_2 register */
ret = spirit_reg_write(spirit, AGCCTRL2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_agcmeasure_us
*
* Description:
* Returns the AGC measure time in microseconds.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AGC measure time expressed in microseconds. This value will be in
* the range [0, 393216/Fxo].
*
******************************************************************************/
uint16_t spirit_radio_get_agcmeasure_us(FAR struct spirit_library_s *spirit)
{
uint8_t measure;
/* Read the AGCCTRL_2 register */
(void)spirit_reg_read(spirit, AGCCTRL2_BASE, &measure, 1);
/* Mask the MEAS_TIME field */
measure &= 0x0f;
/* Calculates the measure time value to write in the register */
return (uint16_t)((12.0 / spirit->xtal_frequency) * (float)pow(2, measure) * 1e6);
}
/******************************************************************************
* Name: spirit_radio_set_agcmeasure
*
* Description:
* Sets the AGC measure time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* time - AGC measure time to write in the MEAS_TIME field of AGCCTRL_2
* register. This value must be in the range [0:15].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agcmeasure(FAR struct spirit_library_s *spirit,
uint8_t time)
{
uint8_t regval;
int ret;
/* Check the parameter */
DEBUGASSERT(IS_AGC_MEASURE_TIME(time));
/* Read the AGCCTRL_2 register */
ret = spirit_reg_read(spirit, AGCCTRL2_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the MEAS_TIME field and write the new value */
regval &= 0xf0;
regval |= time;
/* Set the AGCCTRL_2 register */
ret = spirit_reg_write(spirit, AGCCTRL2_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_agcmeasure
*
* Description:
* Returns the AGC measure time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AGC measure time read from the MEAS_TIME field of AGCCTRL_2 register.
* This value will be in the range [0:15].
*
******************************************************************************/
uint8_t spirit_radio_get_agcmeasure(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AGCCTRL_2 register, mask the MEAS_TIME field and return the
* value.
*/
(void)spirit_reg_read(spirit, AGCCTRL2_BASE, &regval, 1);
return (regval & 0x0f);
}
/******************************************************************************
* Name: spirit_radio_set_agcholdtime_us
*
* Description:
* Sets the AGC hold time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* time - AGC hold time expressed in us. This value must be in the
* range [0, 756/F_Xo].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agcholdtime_us(FAR struct spirit_library_s *spirit,
uint8_t time)
{
uint8_t regval, hold;
/* Check the parameter */
DEBUGASSERT(IS_AGC_HOLD_TIME_US(time, spirit->xtal_frequency));
/* Read the AGCCTRL_0 register */
spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
/* Calculates the hold time value to write in the register */
hold = (uint8_t) lroundf(((float)time / 1e6 * spirit->xtal_frequency) / 12);
(hold > 63) ? (hold = 63) : (hold);
/* Mask the HOLD_TIME field and write the new value */
regval &= 0xc0;
regval |= hold;
/* Set the AGCCTRL_0 register */
return spirit_reg_write(spirit, AGCCTRL0_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_agcholdtime_us
*
* Description:
* Returns the AGC hold time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AGC hold time expressed in us. This value will be in the range:
* [0, 756/F_Xo].
*
******************************************************************************/
uint8_t spirit_radio_get_agcholdtime_us(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AGCCTRL_0 register */
(void)spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
/* Mask the HOLD_TIME field */
regval &= 0x3f;
/* Calculates the hold time value and return it */
return (uint8_t) lroundf((12.0 / spirit->xtal_frequency) * (regval * 1e6));
}
/******************************************************************************
* Name: spirit_radio_set_agcholdtime
*
* Description:
* Sets the AGC hold time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* time - AGC hold time to write in the HOLD_TIME field of AGCCTRL_0
* register. This value must be in the range [0:63].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agcholdtime(FAR struct spirit_library_s *spirit,
uint8_t time)
{
uint8_t regval;
int ret;
/* Check the parameter */
DEBUGASSERT(IS_AGC_HOLD_TIME(time));
/* Read the AGCCTRL_0 register */
ret = spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
if (ret >= 0)
{
/* Mask the HOLD_TIME field and write the new value */
regval &= 0xc0;
regval |= time;
/* Set the AGCCTRL_0 register */
ret = spirit_reg_write(spirit, AGCCTRL0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_agcholdtime
*
* Description:
* Returns the AGC hold time.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AGC hold time read from the HOLD_TIME field of AGCCTRL_0 register. This
* value will be in the range [0:63].
*
******************************************************************************/
uint8_t spirit_radio_get_agcholdtime(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AGCCTRL_0 register, mask the MEAS_TIME field and return the
* value.
*/
(void)spirit_reg_read(spirit, AGCCTRL0_BASE, &regval, 1);
return (regval & 0x3f);
}
/******************************************************************************
* Name: spirit_radio_set_agchighthres
*
* Description:
* Sets the AGC high threshold.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* highthres - AGC high threshold to write in the THRESHOLD_HIGH field of
* AGCCTRL_1 register. This value must be in the range
* [0:15].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agchighthres(FAR struct spirit_library_s *spirit,
uint8_t highthres)
{
uint8_t regval;
/* Check the parameter */
DEBUGASSERT(IS_AGC_THRESHOLD(highthres));
/* Read the AGCCTRL_1 register */
spirit_reg_read(spirit, AGCCTRL1_BASE, &regval, 1);
/* Mask the THRESHOLD_HIGH field and write the new value */
regval &= 0x0f;
regval |= highthres << 4;
/* Set the AGCCTRL_1 register */
return spirit_reg_write(spirit, AGCCTRL1_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_agchighthres
*
* Description:
* Returns the AGC high threshold.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AGC high threshold read from the THRESHOLD_HIGH field of AGCCTRL_1
* register. This value will be in the range [0:15].
*
******************************************************************************/
uint8_t spirit_radio_get_agchighthres(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AGCCTRL_1 register, mask the THRESHOLD_HIGH field and return the
* value */
(void)spirit_reg_read(spirit, AGCCTRL1_BASE, &regval, 1);
return ((regval & 0xf0) >> 4);
}
/******************************************************************************
* Name: spirit_radio_set_agclowthres
*
* Description:
* Sets the AGC low threshold.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* lowthres - AGC low threshold to write in the THRESHOLD_LOW field of
* AGCCTRL_1 register. This value must be in the range
* 0:15].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_agclowthres(FAR struct spirit_library_s *spirit,
uint8_t lowthres)
{
uint8_t regval;
/* Check the parameter */
DEBUGASSERT(IS_AGC_THRESHOLD(lowthres));
/* Read the AGCCTRL_1 register */
spirit_reg_read(spirit, AGCCTRL1_BASE, &regval, 1);
/* Mask the THRESHOLD_LOW field and write the new value */
regval &= 0xf0;
regval |= lowthres;
/* Set the AGCCTRL_1 register */
return spirit_reg_write(spirit, AGCCTRL1_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_agclowthres
*
* Description:
* Returns the AGC low threshold.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* AGC low threshold read from the THRESHOLD_LOW field of AGCCTRL_1 register.
* This value will be in the range [0:15].
*
******************************************************************************/
uint8_t spirit_radio_get_agclowthres(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the AGCCTRL_1 register, mask the THRESHOLD_LOW field and return the
* value */
(void)spirit_reg_read(spirit, AGCCTRL1_BASE, &regval, 1);
return (regval & 0x0f);
}
/******************************************************************************
* Name: spirit_radio_set_clkrecmode
*
* Description:
* Sets the clock recovery algorithm.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* mode - The Clock Recovery mode. This value can be one of the values
* defined in enum spirit_clkrecmode_e :
*
* CLK_REC_PLL PLL alogrithm for clock recovery
* CLK_REC_DLL DLL alogrithm for clock recovery
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_clkrecmode(FAR struct spirit_library_s *spirit,
enum spirit_clkrecmode_e mode)
{
uint8_t regval;
/* Check the parameter */
DEBUGASSERT(IS_CLK_REC_MODE(mode));
/* Read the FDEV_0 register */
spirit_reg_read(spirit, FDEV0_BASE, &regval, 1);
/* Mask the CLOCK_REC_ALGO_SEL field and write the new value */
regval &= 0xf7;
regval |= (uint8_t) mode;
/* Set the FDEV_0 register */
return spirit_reg_write(spirit, FDEV0_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_clkrecmode
*
* Description:
* Returns the Clock Recovery working mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Clock Recovery mode. This value can be one of the values defined in
* enum spirit_clkrecmode_e:
*
* CLK_REC_PLL PLL alogrithm for clock recovery
* CLK_REC_DLL DLL alogrithm for clock recovery
*
******************************************************************************/
enum spirit_clkrecmode_e
spirit_radio_get_clkrecmode(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the FDEV_0 register, mask the CLOCK_REC_ALGO_SEL field and return
* the value */
(void)spirit_reg_read(spirit, FDEV0_BASE, &regval, 1);
return (enum spirit_clkrecmode_e)(regval & 0x08);
}
/******************************************************************************
* Name: spirit_radio_set_clkrecgain
*
* Description:
* Sets the clock recovery proportional gain.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* pgain - The Clock Recovery proportional gain to write in the
* CLK_REC_P_GAIN field of CLOCKREC register. This is the log2
* value of the clock recovery proportional gain. This value
* must be in the range [0:7].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_clkrecgain(FAR struct spirit_library_s *spirit,
uint8_t pgain)
{
uint8_t regval;
/* Check the parameter */
DEBUGASSERT(IS_CLK_REC_P_GAIN(pgain));
/* Read the CLOCKREC register */
spirit_reg_read(spirit, CLOCKREC_BASE, &regval, 1);
/* Mask the CLK_REC_P_GAIN field and write the new value */
regval &= 0x1f;
regval |= (pgain << 5);
/* Set the CLOCKREC register */
return spirit_reg_write(spirit, CLOCKREC_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_clkrecgain
*
* Description:
* Returns the log2 of the clock recovery proportional gain.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Clock Recovery proportional gain read from the CLK_REC_P_GAIN field of
* CLOCKREC register. This value will be in the range [0:7].
*
******************************************************************************/
uint8_t spirit_radio_get_clkrecgain(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the CLOCKREC register, mask the CLK_REC_P_GAIN field and return the
* value */
(void)spirit_reg_read(spirit, CLOCKREC_BASE, &regval, 1);
return ((regval & 0xef) >> 5);
}
/******************************************************************************
* Name: spirit_radio_set_clkrecigain
*
* Description:
* Sets the clock recovery integral gain.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* igain - The Clock Recovery integral gain to write in the CLK_REC_I_GAIN
* field of CLOCKREC register. This value must be in the range
* [0:15].
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_clkrecigain(FAR struct spirit_library_s *spirit,
uint8_t igain)
{
uint8_t regval;
/* Check the parameter */
DEBUGASSERT(IS_CLK_REC_I_GAIN(igain));
/* Read the CLOCKREC register */
spirit_reg_read(spirit, CLOCKREC_BASE, &regval, 1);
/* Mask the CLK_REC_P_GAIN field and write the new value */
regval &= 0xf0;
regval |= igain;
/* Set the CLOCKREC register */
return spirit_reg_write(spirit, CLOCKREC_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_clkrecigain
*
* Description:
* Returns the clock recovery integral gain.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Clock Recovery integral gain read from the CLK_REC_I_GAIN field of
* CLOCKREC register. This value will be in the range [0:15].
*
******************************************************************************/
uint8_t spirit_radio_get_clkrecigain(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the CLOCKREC register, mask the CLK_REC_I_GAIN field and return the
* value.
*/
(void)spirit_reg_read(spirit, CLOCKREC_BASE, &regval, 1);
return (regval & 0x0f);
}
/******************************************************************************
* Name: spirit_radio_set_clkrecpstfltlen
*
* Description:
* Sets the postfilter length for clock recovery algorithm.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* length - The postfilter length in symbols. This value can be one of
* the values defined in enum spirit_pstfltlen_e :
*
* PSTFLT_LENGTH_8 Postfilter length is 8 symbols
* PSTFLT_LENGTH_16 Postfilter length is 16 symbols
*
* Returned Value:
* Zero (OK) on success. A negated errno value is returned on any failure.
*
******************************************************************************/
int spirit_radio_set_clkrecpstfltlen(FAR struct spirit_library_s *spirit,
enum spirit_pstfltlen_e length)
{
uint8_t regval;
/* Check the parameter */
DEBUGASSERT(IS_PST_FLT_LENGTH(length));
/* Read the CLOCKREC register */
spirit_reg_read(spirit, CLOCKREC_BASE, &regval, 1);
/* Mask the PSTFLT_LEN field and write the new value */
regval &= 0xef;
regval |= (uint8_t) length;
/* Set the CLOCKREC register */
return spirit_reg_write(spirit, CLOCKREC_BASE, &regval, 1);
}
/******************************************************************************
* Name: spirit_radio_get_clkrecpstfltlen
*
* Description:
* Returns the postfilter length for clock recovery algorithm.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* Postfilter length in symbols. This value can be one of the values
* defined in enum spirit_pstfltlen_e:
*
* PSTFLT_LENGTH_8 Postfilter length is 8 symbols
* PSTFLT_LENGTH_16 Postfilter length is 16 symbols
*
******************************************************************************/
enum spirit_pstfltlen_e
spirit_radio_get_clkrecpstfltlen(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
/* Read the CLOCKREC register, mask the PSTFLT_LEN field and return the
* value */
(void)spirit_reg_read(spirit, CLOCKREC_BASE, &regval, 1);
return (enum spirit_pstfltlen_e)(regval & 0x10);
}
/******************************************************************************
* Name: spirit_radio_enable_csblanking
*
* Description:
* Enables or Disables the received data blanking when the CS is under the
* threshold.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state of this mode.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_enable_csblanking(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the ANT_SELECT_CONF_BASE and mask the CS_BLANKING BIT field */
ret = spirit_reg_read(spirit, ANT_SELECT_CONF_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= ANT_SELECT_CS_BLANKING_MASK;
}
else
{
regval &= (~ANT_SELECT_CS_BLANKING_MASK);
}
/* Write the new value to the ANT_SELECT_CONF register */
ret = spirit_reg_write(spirit, ANT_SELECT_CONF_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_persistentrx
*
* Description:
* Enables or Disables the persistent RX mode.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state of this mode.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_persistentrx(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval = 0;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the PROTOCOL0_BASE and mask the PROTOCOL0_PERS_RX_MASK bitfield */
ret = spirit_reg_read(spirit, PROTOCOL0_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= PROTOCOL0_PERS_RX_MASK;
}
else
{
regval &= (~PROTOCOL0_PERS_RX_MASK);
}
/* Write the new value to the PROTOCOL0_BASE register */
ret = spirit_reg_write(spirit, PROTOCOL0_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_set_refdiv
*
* Description:
* Enables or Disables the synthesizer reference divider.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate new state for synthesizer reference divider.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_set_refdiv(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the SYNTH_CONFIG1_BASE and mask the REFDIV bit field */
ret = spirit_reg_read(spirit, SYNTH_CONFIG1_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval |= 0x80;
}
else
{
regval &= 0x7f;
}
/* Write the new value to the SYNTH_CONFIG1_BASE register */
ret = spirit_reg_write(spirit, SYNTH_CONFIG1_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_get_refdiv
*
* Description:
* Get the the synthesizer reference divider state.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* S_ENABLE or S_DISABLE. Errors are not reported.
*
******************************************************************************/
enum spirit_functional_state_e
spirit_radio_get_refdiv(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
(void)spirit_reg_read(spirit, SYNTH_CONFIG1_BASE, &regval, 1);
if (((regval >> 7) & 0x1) != 0)
{
return S_ENABLE;
}
else
{
return S_DISABLE;
}
}
/******************************************************************************
* Name: spirit_radio_enable_digdivider
*
* Description:
* Enables or Disables the synthesizer reference divider.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
* newstate - New state for synthesizer reference divider.
*
* Returned Value:
* Zero (OK) on success; a negated errno value on failure.
*
******************************************************************************/
int spirit_radio_enable_digdivider(FAR struct spirit_library_s *spirit,
enum spirit_functional_state_e newstate)
{
uint8_t regval;
int ret;
/* Check the parameters */
DEBUGASSERT(IS_SPIRIT_FUNCTIONAL_STATE(newstate));
/* Read the XO_RCO_TEST_BASE and mask the PD_CLKDIV bit field */
ret = spirit_reg_read(spirit, XO_RCO_TEST_BASE, &regval, 1);
if (ret >= 0)
{
if (newstate == S_ENABLE)
{
regval &= 0xf7;
}
else
{
regval |= 0x08;
}
/* Write the new value to the XO_RCO_TEST_BASE register */
ret = spirit_reg_write(spirit, XO_RCO_TEST_BASE, &regval, 1);
}
return ret;
}
/******************************************************************************
* Name: spirit_radio_isenabled_digdivider
*
* Description:
* Get the the synthesizer reference divider state.
*
* Input Parameters:
* spirit - Reference to a Spirit library state structure instance
*
* Returned Value:
* S_ENABLE or S_DISABLE. Error conditions are not detected.
*
******************************************************************************/
enum spirit_functional_state_e
spirit_radio_isenabled_digdivider(FAR struct spirit_library_s *spirit)
{
uint8_t regval;
(void)spirit_reg_read(spirit, XO_RCO_TEST_BASE, &regval, 1);
if (((regval >> 3) & 0x1) != 0)
{
return S_DISABLE;
}
else
{
return S_ENABLE;
}
}
Reference in New Issue View Git Blame Copy Permalink