[osc.h] Oscillator

Data Structures
struct	XoscLf_Params_t
	A structure that defines the polynomial coefficients for calculating the XOSC LF ppm offset as function of temperature. More...
struct	HposcDebugData_t
	Data structure for experimental HPOSC polynomials calculation. More...

Functions
static void	OSCXHfPowerModeSet (uint32_t ui32Mode)
	Set Power Mode for High Frequency XTAL Oscillator. More...
static void	OSCClockLossEventEnable (void)
	Enables OSC clock loss event detection. More...
static void	OSCClockLossEventDisable (void)
	Disables OSC clock loss event detection. More...
void	OSCClockSourceSet (uint32_t ui32SrcClk, uint32_t ui32Osc)
	Configure the oscillator input to the a source clock. More...
uint32_t	OSCClockSourceGet (uint32_t ui32SrcClk)
	Get the source clock settings. More...
static bool	OSCHfSourceReady (void)
	Check if the HF clock source is ready to be switched. More...
static void	OSCHfSourceSwitch (void)
	Switch the high frequency clock. More...
static bool	OSC_IsHPOSCEnabled (void)
	Identifies if HPOSC is enabled. More...
static bool	OSC_IsHPOSCEnabledWithHfDerivedLfClock (void)
	Identifies if HPOSC is enabled and that SCLK_LF is derived from XOSC_HF. More...
uint32_t	OSCHF_GetStartupTime (uint32_t timeUntilWakeupInMs)
	Returns maximum startup time (in microseconds) of XOSC_HF. More...
void	OSCHF_TurnOnXosc (void)
	Turns on XOSC_HF (but without switching to XOSC_HF). More...
bool	OSCHF_AttemptToSwitchToXosc (void)
	Switch to XOSC_HF if XOSC_HF is ready. More...
void	OSCHF_SwitchToRcOscTurnOffXosc (void)
	Switch to RCOSC_HF and turn off XOSC_HF. More...
uint32_t	OSCHF_DebugGetCrystalAmplitude (void)
	Get crystal amplitude (assuming crystal is running). More...
uint32_t	OSCHF_DebugGetExpectedAverageCrystalAmplitude (void)
	Get the expected average crystal amplitude. More...
uint32_t	OSCHF_DebugGetCrystalStartupTime (void)
	Measure the crystal startup time. More...
void	OSC_HPOSCInitializeFrequencyOffsetParameters (void)
	HPOSC initialization function. Must always be called before using HPOSC. More...
void	OSC_HPOSC_Debug_InitFreqOffsetParams (HposcDebugData_t *pDebugData)
	Debug function to calculate the HPOSC polynomials for experimental data sets. More...
void	OSC_HPOSCInitializeSingleInsertionFreqOffsParams (uint32_t measFieldAddress)
	Special HPOSC initialization function for single temperature compensation. More...
int32_t	OSC_HPOSCRelativeFrequencyOffsetGet (int32_t tempDegC)
	Calculate the temperature dependent relative frequency offset of HPOSC. More...
void	OSC_CapArrayAdjustWorkaround_Boot (void)
	Special XOSC_HF workaround adjustment for CC13x2 / CC26x2 XOSC_CAPARRAY_DELTA setting in CCFG (Customer configuration) More...
void	OSC_AdjustXoscHfCapArray (int32_t capArrDelta)
	Adjust the XOSC HF cap array relative to the factory setting. More...
int16_t	OSC_HPOSCRelativeFrequencyOffsetToRFCoreFormatConvert (int32_t HPOSC_RelFreqOffset)
	Converts the relative frequency offset of HPOSC to the RF Core parameter format. More...
void	OSC_HPOSCRtcCompensate (int32_t relFreqOffset)
	Compensate the RTC increment based on the relative frequency offset of HPOSC. More...
void	OSC_LFXOSCInitStaticOffset (void)
	Initialize device specific coefficient for XOSC LF RTC compensation. More...
int32_t	OSC_LFXOSCRelativeFrequencyOffsetGet (int32_t temperature)
	Calculates the ppm offset of XOSC LF for a given temperature. More...

Detailed Description

Function Documentation

OSC_AdjustXoscHfCapArray()

void OSC_AdjustXoscHfCapArray

(

int32_t

capArrDelta

)

Adjust the XOSC HF cap array relative to the factory setting.

The cap array factory setting (FCFG) can be converted to a number in the range 0 - 63. Both this function and the customer configuration (CCFG) setting can apply a delta to the FCFG setting. The CCFG setting is automatically applied at boot time (See ../startup_files/ccfg.c). Calling this function will discard the CCFG setting and adjust relative to the FCFG setting.

Note

Adjusted value will not take effect before XOSC_HF is stopped and restarted

Parameters

capArrDelta

specifies number of step to adjust the cap array relative to the factory setting.

Returns

None

{
    if ( SpecialCapArrayWorkaroundEnabledAndNeeded() ) {
        // Workaround for chip settings like 0x701F0 and 0x701FE which get readjusted with baseline 7001F/6.1pF
        InternCapArrayAdjustWithBaseline7001F( capArrDelta );
    } else
    {
        // Read the MODE_CONF register in CCFG
        uint32_t ccfg_ModeConfReg = HWREG( CCFG_BASE + CCFG_O_MODE_CONF );
        // Clear CAP_MODE and the CAPARRAY_DELATA field
        ccfg_ModeConfReg &= ~( CCFG_MODE_CONF_XOSC_CAPARRAY_DELTA_M | CCFG_MODE_CONF_XOSC_CAP_MOD_M );
        // Insert new delta value
        ccfg_ModeConfReg |= ((((uint32_t)capArrDelta) << CCFG_MODE_CONF_XOSC_CAPARRAY_DELTA_S ) & CCFG_MODE_CONF_XOSC_CAPARRAY_DELTA_M );
        // Update the HW register with the new delta value
        DDI32RegWrite(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_ANABYPASSVAL1, SetupGetTrimForAnabypassValue1( ccfg_ModeConfReg ));
    }
}

Here is the call graph for this function:

OSC_CapArrayAdjustWorkaround_Boot()

void OSC_CapArrayAdjustWorkaround_Boot

(

void

)

Special XOSC_HF workaround adjustment for CC13x2 / CC26x2 XOSC_CAPARRAY_DELTA setting in CCFG (Customer configuration)

Implements a workaround for devices with an unfortunate XOSH_HF CAPARRAY factory configuration (FCFG1 setting). The workaround is done only if both enabled and needed (enabled by setting CCFG_SIZE_AND_DIS_FLAGS_DIS_LINEAR_CAPARRAY_DELTA_WORKAROUND = 0) The factory configuration works fine on its own but does not comply with the requirements of the CCFG:XOSC_CAPARRAY_DELTA mechanism. Without this workaround, there will be a larger jump in capacitance (and frequency) between XOSC_CAPARRAY_DELTA setting 7 and 8.

Returns

None

See also

OSC_AdjustXoscHfCapArray()

Referenced by TrimAfterColdResetWakeupFromShutDown().

{
    uint32_t    ccfg_ModeConfReg    ;
    int32_t     ccfg_CapArrayDelta  ;

    if ( SpecialCapArrayWorkaroundEnabledAndNeeded() ) {
        // Workaround for chip settings like 0x701F0 and 0x701FE which get readjusted with baseline 7001F/6.1pF
        ccfg_CapArrayDelta = 0 ;
        ccfg_ModeConfReg = HWREG( CCFG_BASE + CCFG_O_MODE_CONF );
        if (( ccfg_ModeConfReg & CCFG_MODE_CONF_XOSC_CAP_MOD ) == 0 ) {
            // CCFG CapArrayDelta is enabled get sign-extended delta
            ccfg_CapArrayDelta =
                (((int32_t)( ccfg_ModeConfReg << ( 32 - CCFG_MODE_CONF_XOSC_CAPARRAY_DELTA_W - CCFG_MODE_CONF_XOSC_CAPARRAY_DELTA_S )))
                                              >> ( 32 - CCFG_MODE_CONF_XOSC_CAPARRAY_DELTA_W ));
        }
        InternCapArrayAdjustWithBaseline7001F( ccfg_CapArrayDelta );
    }
}

Here is the call graph for this function:

OSC_HPOSC_Debug_InitFreqOffsetParams()

void OSC_HPOSC_Debug_InitFreqOffsetParams

(

HposcDebugData_t *

pDebugData

)

Debug function to calculate the HPOSC polynomials for experimental data sets.

Parameters

pDebugData

pointer to the input data collected in HposcDebugData_t

Returns

None

See also

OSC_HPOSCInitializeFrequencyOffsetParameters()

{
    /* Initialize HPOSC internal parameter */
    hposc_insertions_t  hposcMeas;
    int64_t pu0[3],pu1[3],pu2[3] = {0};
    hposc_param_t hposcParm =
    {
        .pu0b = {42, 32, 27, 20},
        .pu0c = {-284,-184,536,-104798},
        .pu1b = {36, 32, 27, 20},
        .pu1c = {-1155,44130,-319090,-3563},
        .pu2b = {36, 32, 27, 20},
        .pu2c = {-3410,261727,-32194,-116627}
    };

    /* Retrieve insertions from FCFG */
    readTempAndFreq((uint32_t)&pDebugData->meas_1, &hposcMeas.temp[0], &hposcMeas.dFreq[0], pDebugData->offsetD1);
    readTempAndFreq((uint32_t)&pDebugData->meas_2, &hposcMeas.temp[1], &hposcMeas.dFreq[1], pDebugData->offsetD2);
    readTempAndFreq((uint32_t)&pDebugData->meas_3, &hposcMeas.temp[2], &hposcMeas.dFreq[2], pDebugData->offsetD3);

    /* Compute HPOSC polynomial coefficients */
    findHposcPc(hposcParm.pu0c, hposcParm.pu0b, &hposcMeas.temp[0], 3, pu0);
    findHposcPc(hposcParm.pu1c, hposcParm.pu1b, &hposcMeas.temp[0], 3, pu1);
    findHposcPc(hposcParm.pu2c, hposcParm.pu2b, &hposcMeas.temp[0], 3, pu2);
    findHposcCoefficients(&hposcMeas.dFreq[0], pu0, pu1, pu2, &hposcParm);
}

Here is the call graph for this function:

OSC_HPOSCInitializeFrequencyOffsetParameters()

void OSC_HPOSCInitializeFrequencyOffsetParameters

(

void

)

HPOSC initialization function. Must always be called before using HPOSC.

Calculates the fitting curve parameters (polynomials) to be used by the HPOSC temperature compensation.

Returns

None

See also

OSC_HPOSC_Debug_InitFreqOffsetParams(), OSC_HPOSCInitializeSingleInsertionFreqOffsParams()

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock().

{
    /* Initialize HPOSC internal parameter */
    hposc_insertions_t  hposcMeas;
    int64_t pu0[3],pu1[3],pu2[3] = {0};
    hposc_param_t hposcParm =
    {
        .pu0b = {42, 32, 27, 20},
        .pu0c = {-284,-184,536,-104798},
        .pu1b = {36, 32, 27, 20},
        .pu1c = {-1155,44130,-319090,-3563},
        .pu2b = {36, 32, 27, 20},
        .pu2c = {-3410,261727,-32194,-116627}
    };

    /* Retrieve insertions from FCFG */
    readTempAndFreq(FCFG1_BASE + FCFG1_O_HPOSC_MEAS_1, &hposcMeas.temp[0], &hposcMeas.dFreq[0], D1OFFSET_25C);
    readTempAndFreq(FCFG1_BASE + FCFG1_O_HPOSC_MEAS_2, &hposcMeas.temp[1], &hposcMeas.dFreq[1], D2OFFSET_85C);
    readTempAndFreq(FCFG1_BASE + FCFG1_O_HPOSC_MEAS_3, &hposcMeas.temp[2], &hposcMeas.dFreq[2], D3OFFSET_n40C);

    /* Compute HPOSC polynomial coefficients */
    findHposcPc(hposcParm.pu0c, hposcParm.pu0b, &hposcMeas.temp[0], 3, pu0);
    findHposcPc(hposcParm.pu1c, hposcParm.pu1b, &hposcMeas.temp[0], 3, pu1);
    findHposcPc(hposcParm.pu2c, hposcParm.pu2b, &hposcMeas.temp[0], 3, pu2);
    findHposcCoefficients(&hposcMeas.dFreq[0], pu0, pu1, pu2, &hposcParm);
}

Here is the call graph for this function:

OSC_HPOSCInitializeSingleInsertionFreqOffsParams()

void OSC_HPOSCInitializeSingleInsertionFreqOffsParams

(

uint32_t

measFieldAddress

)

Special HPOSC initialization function for single temperature compensation.

Used when a single temperature offset measurement is available. This is espesially designed to get a better crystal performance (SW TCXO) on the SiP module but can also be usful to get better crystal performance over the entire temperature range on a standard design as well.

Returns

None

See also

OSC_HPOSCInitializeFrequencyOffsetParameters()

{
    /* Initialize HPOSC internal parameter */
    hposc_insertions_t  hposcMeas;
    int64_t pu0;
    hposc_param_t hposcParm =
    {
        /* Coefficients for SW-TCXO */
        .pu0b = {44, 44, 27, 20},
        .pu0c = {8183, -2546, -210, -104866}
    };

    /* Retrieve insertions from FCFG */
    readTempAndFreq( measFieldAddress, &hposcMeas.temp[0], &hposcMeas.dFreq[0], 0);

    /* Compute HPOSC polynomial coefficients */
    findHposcPc(hposcParm.pu0c, hposcParm.pu0b, &hposcMeas.temp[0], 1, &pu0);
    findHposcCoefficients(&hposcMeas.dFreq[0], &pu0, NULL, NULL, &hposcParm);
}

Here is the call graph for this function:

OSC_HPOSCRelativeFrequencyOffsetGet()

int32_t OSC_HPOSCRelativeFrequencyOffsetGet

(

int32_t

tempDegC

)

Calculate the temperature dependent relative frequency offset of HPOSC.

The HPOSC (High Precision Oscillator) frequency will vary slightly with chip temperature. The frequency offset from the nominal value can be predicted based on second order linear interpolation using coefficients measured in chip production and stored as factory configuration parameters.

This function calculates the relative frequency offset, defined as:

    F_HPOSC = F_nom * (1 + d/(2^22))

where

• F_HPOSC is the current HPOSC frequency.
• F_nom is the nominal oscillator frequency, assumed to be 48.000 MHz.
• d is the relative frequency offset (the value returned).

By knowing the relative frequency offset it is then possible to compensate any timing related values accordingly.

Parameters

tempDegC

is the chip temperature in degrees Celsius. Use the function AONBatMonTemperatureGetDegC() to get current chip temperature.

Returns

Returns the relative frequency offset parameter d.

See also

OSC_HPOSCRelativeFrequencyOffsetToRFCoreFormatConvert(), AONBatMonTemperatureGetDegC()

{
    // Estimate HPOSC frequency offset, using temperature and curve fitting parameters

    // Now we can find the HPOSC freq offset, given as a signed variable d, expressed by:
    //
    //    F_HPOSC = F_nom * (1 + d/(2^22))    , where: F_HPOSC = HPOSC frequency
    //                                                 F_nom = nominal clock source frequency (e.g. 48.000 MHz)
    //                                                 d = describes relative freq offset

    // We can estimate the d variable, using temperature compensation parameters:
    //
    //    d = P[3]*(t - T0)^3 + P[2]*(t - T0)^2 + P[1]*(t - T0) + P[0], where: P0,P1,P2,P3 are curve fitting parameters
    //                                                                  t = current temperature (from temp sensor) in deg C
    //                                                                  T0 = 27 deg C (fixed temperature constant)

    int32_t d,t1,t2,t3;

    t1 = tempDegC - 27;
    t2 = t1 * t1;
    t3 = t2 * t1;

    d =  ((((int64_t)_hposcCoeffs[3]*t3 + (int64_t)_hposcCoeffs[2]*t2 + (int64_t)_hposcCoeffs[1]*t1) >> HPOSC_COEFF0_SHIFT) +
            (int64_t)_hposcCoeffs[0]) >> HPOSC_COEFF0_BITS;

    return ( d );
}

OSC_HPOSCRelativeFrequencyOffsetToRFCoreFormatConvert()

int16_t OSC_HPOSCRelativeFrequencyOffsetToRFCoreFormatConvert

(

int32_t

HPOSC_RelFreqOffset

)

Converts the relative frequency offset of HPOSC to the RF Core parameter format.

The HPOSC (High Precision Oscillator) clock is used by the RF Core. To compensate for a frequency offset in the frequency of the clock source, a frequency offset parameter can be provided as part of the radio configuration override setting list to enable compensation of the RF synthesizer frequency, symbol timing, and radio timer to still achieve correct frequencies.

The RF Core takes a relative frequency offset parameter defined differently compared to the relative frequency offset parameter returned from function OSC_HPOSCRelativeFrequencyOffsetGet() and thus needs to be converted:

    F_nom = F_HPOSC * (1 + RfCoreRelFreqOffset/(2^22))

where

• F_nom is the nominal oscillator frequency, assumed to be 48.000 MHz.
• F_HPOSC is the current HPOSC frequency.
• RfCoreRelFreqOffset is the relative frequency offset in the "RF Core" format (the value returned).

Parameters

HPOSC_RelFreqOffset

is the relative frequency offset parameter d returned from OSC_HPOSCRelativeFrequencyOffsetGet()

Returns

Returns the relative frequency offset in RF Core format.

See also

OSC_HPOSCRelativeFrequencyOffsetGet()

{
   // The input argument, hereby referred to simply as "d", describes the frequency offset
   // of the HPOSC relative to the nominal frequency in this way:
   //
   //    F_HPOSC = F_nom * (1 + d/(2^22))
   //
   // But for use by the radio, to compensate the frequency error, we need to find the
   // frequency offset "rfcFreqOffset" defined in the following format:
   //
   //    F_nom = F_HPOSC * (1 + rfCoreFreqOffset/(2^22))
   //
   // To derive "rfCoreFreqOffset" from "d" we combine the two above equations and get:
   //
   //    (1 + rfCoreFreqOffset/(2^22)) = (1 + d/(2^22))^-1
   //
   // Which can be rewritten into:
   //
   //    rfCoreFreqOffset = -d*(2^22) / ((2^22) + d)
   //
   //               = -d * [ 1 / (1 + d/(2^22)) ]
   //
   // To avoid doing a 64-bit division due to the (1 + d/(2^22))^-1 expression,
   // we can use Taylor series (Maclaurin series) to approximate it:
   //
   //       1 / (1 - x) ~= 1 + x + x^2 + x^3 + x^4 + ... etc      (Maclaurin series)
   //
   // In our case, we have x = - d/(2^22), and we only include up to the first
   // order term of the series, as the second order term ((d^2)/(2^44)) is very small:
   //
   //       freqError ~= -d + d^2/(2^22)   (+ small approximation error)
   //
   // The approximation error is negligible for our use.

   int32_t rfCoreFreqOffset = -HPOSC_RelFreqOffset + (( HPOSC_RelFreqOffset * HPOSC_RelFreqOffset ) >> 22 );

   return ( rfCoreFreqOffset );
}

OSC_HPOSCRtcCompensate()

void OSC_HPOSCRtcCompensate

(

int32_t

relFreqOffset

)

Compensate the RTC increment based on the relative frequency offset of HPOSC.

The HPOSC (High Precision Oscillator) frequency will vary slightly with chip temperature. This variation forces the RTC increment to be compensated if SCLK_LF is configured to be derived from the HF clock of HPOSC. This function must only be called if SCLK_LF is configured to be derived from the HF clock of HPOSC. The status of this configuration can be determined by calling the OSC_IsHPOSCEnabledWithHfDerivedLfClock() function.

This function first calculates the HPOSC frequency, defined as:

    F_HPOSC = F_nom * (1 + d/(2^22))

where

• F_HPOSC is the current HPOSC frequency.
• F_nom is the nominal oscillator frequency, assumed to be 48.000 MHz.
• d is the relative frequency offset given by the input argument relFreqOffset. Then the SCLK_LF frequency is calculated, defined as:

      F_SCLK_LF = F_HPOSC / 1536
  

  Then the RTC increment SUBSECINC is calculated, defined as;

      SUBSECINC = (2^38) / F_SCLK_LF
  

  Finally the RTC module is updated with the calculated SUBSECINC value.

Parameters

relFreqOffset

is the relative frequency offset parameter d returned from OSC_HPOSCRelativeFrequencyOffsetGet()

Returns

None

{
    uint32_t rtcSubSecInc;
    uint32_t lfClkFrequency;
    uint32_t hfFreq;
    int64_t  calcFactor;

    // Calculate SCLK_HF frequency, defined as:
    // hfFreq = 48000000 * (1 + relFreqOffset/(2^22))
    if( relFreqOffset >= 0 )
    {
        calcFactor = ( ( 48000000 * (int64_t)relFreqOffset ) + 0x200000 ) / 0x400000;
    }
    else
    {
        calcFactor = ( ( 48000000 * (int64_t)relFreqOffset ) - 0x200000 ) / 0x400000;
    }
    hfFreq = 48000000 + calcFactor;

    // Calculate SCLK_LF frequency, defined as SCLK_LF_FREQ = SCLK_HF_FREQ / 1536
    lfClkFrequency = ( hfFreq + 768 ) / 1536;

    // Calculate SUBSECINC, defined as: SUBSECINC = 2^38 / SCLK_LF_FREQ
    rtcSubSecInc = 0x4000000000 / lfClkFrequency;

    /* Update SUBSECINC value */
    SetupSetAonRtcSubSecInc(rtcSubSecInc);
}

Here is the call graph for this function:

OSC_IsHPOSCEnabled()

static bool OSC_IsHPOSCEnabled ( void  )

inlinestatic

Identifies if HPOSC is enabled.

This function checks if the device supports HPOSC and that HPOSC is selected as HF oscillator for use when the radio is active.

Returns

Returns status of HPOSC functionality:

• true : HPOSC is enabled.
• false : HPOSC is not enabled.

{
    bool enabled = false;

    if((( HWREG(CCFG_BASE + CCFG_O_MODE_CONF) & CCFG_MODE_CONF_XOSC_FREQ_M) == CCFG_MODE_CONF_XOSC_FREQ_HPOSC) &&
       (( HWREG(FCFG1_BASE + FCFG1_O_OSC_CONF) & FCFG1_OSC_CONF_HPOSC_OPTION) == 0))
    {
        enabled = true;
    }

    return (enabled);
}

OSC_IsHPOSCEnabledWithHfDerivedLfClock()

static bool OSC_IsHPOSCEnabledWithHfDerivedLfClock ( void  )

inlinestatic

Identifies if HPOSC is enabled and that SCLK_LF is derived from XOSC_HF.

This function checks if the device supports HPOSC and that HPOSC is selected as HF oscillator for use when the radio is active and also that SCLK_LF is derived from XOSC_HF.

Returns

Returns status of HPOSC and SCLK_LF configuration:

• true : HPOSC is enabled and SCLK_LF is derived from XOSC_HF.
• false : Either HPOSC not enabled or SCLK_LF is not derived from XOSC_HF.

{
    bool enabled = false;

    // Check configuration by reading lower half of the 32-bit CTL0 register
    uint16_t regVal = HWREGH(AUX_DDI0_OSC_BASE + DDI_0_OSC_O_CTL0);
    if( ( ( regVal & DDI_0_OSC_CTL0_SCLK_LF_SRC_SEL_M ) == DDI_0_OSC_CTL0_SCLK_LF_SRC_SEL_XOSCHFDLF ) &&
        ( ( regVal & DDI_0_OSC_CTL0_HPOSC_MODE_EN_M   ) == DDI_0_OSC_CTL0_HPOSC_MODE_EN             )   )
    {
            enabled = true;
    }

    return (enabled);
}

Here is the call graph for this function:

OSC_LFXOSCInitStaticOffset()

void OSC_LFXOSCInitStaticOffset

(

void

)

Initialize device specific coefficient for XOSC LF RTC compensation.

Calculates the device specific static offset of XOSC LF and stores it as a coefficient in the internal _lfXoscParams polynomial structure.

Warning

_lfXoscParams must be defined and populated with polynomial coefficients a, b, and c if this function is called.

Note

This function must be called once, before calling OSC_LFXOSCRelativeFrequencyOffsetGet.

Returns

None

{
    int16_t xoscLfCorrection;
    int8_t xoscLfCorrectionTemperature;

    /* If device is untrimmed, apply default values */
    if (HWREG(FCFG1_BASE + FCFG1_O_HPOSC_MEAS_5) == 0xFFFFFFFF)
    {
        /* These values correspond to a 0 ppm offset measurement at 25 degC */
        xoscLfCorrection            = 0;
        xoscLfCorrectionTemperature = 25;
    }
    else
    {
        xoscLfCorrection = (int16_t)((HWREG(FCFG1_BASE + FCFG1_O_HPOSC_MEAS_5) & FCFG1_HPOSC_MEAS_5_HPOSC_D5_M) >>
                                      FCFG1_HPOSC_MEAS_5_HPOSC_D5_S);
        xoscLfCorrectionTemperature = (int8_t)((
            HWREG(FCFG1_BASE + FCFG1_O_HPOSC_MEAS_5) & FCFG1_HPOSC_MEAS_5_HPOSC_T5_M) >>
            FCFG1_HPOSC_MEAS_5_HPOSC_T5_S);
        /* Temperature in FCFG is offset by 27 degrees */
        xoscLfCorrectionTemperature += 27;
    }

    /* Calculate the difference between expected offset at FCFG1 temperature, vs actual offset at FCFG1 temperature.
     * This becomes a static offset whenever a new temperature offset is calculated.
     * ppm(T) = a*T^2 + b*T + c - d, where d represents a device specific offset from the ideal polynomial
     * d = ppm(T_trim) - ppm_trim, where ppm_trim is the actual ppm offset measured at production, at the temperature T_trim
     * ppm_trim is found from FCFG1_HPOSC_MEAS_5_HPOSC_D5 in FCFG, where FCFG1_HPOSC_MEAS_5_HPOSC_D5 = (f/32768 - 1) * 2^22
     */
    _lfXoscParams.coeffD = (_lfXoscParams.coeffA * xoscLfCorrectionTemperature * xoscLfCorrectionTemperature +
                            _lfXoscParams.coeffB * xoscLfCorrectionTemperature + _lfXoscParams.coeffC) -
                           (int32_t)((int64_t)xoscLfCorrection * (1000000LL << _lfXoscParams.shift) / 4194304LL);
}

OSC_LFXOSCRelativeFrequencyOffsetGet()

int32_t OSC_LFXOSCRelativeFrequencyOffsetGet

(

int32_t

temperature

)

Calculates the ppm offset of XOSC LF for a given temperature.

The offset (measured in ppm) is given by a second order polynomial function of temperature, T: ppm(T) = a*T^2 + b*T + c - d. The coefficients a, b, c, and d are taken from _lfXoscParams.coeffA, _lfoXscParams.coeffB, _lfXoscParams.coeffC and _lfXoscParams.coeffD and scaled down for fixed point arithmetic by a factor of 2^_lfXoscParams.shift. _lfXoscParams must be defined by the application, and must be fully initialized by calling OSC_LFXOSCInitStaticOffset once, before this function is called.

Note

OSC_LFXOSCInitStaticOffset should be called once, before this function is used.

Parameters

temperature

is the on-chip temperature in degrees Celcius.

Returns

Returns the offset in XOSC LF from the nominal frequency, in ppm.

{
    /* The offset (ppm) is given by
     * ppm(T) = a*T^2 + b*T + c - d
     * The coefficients a, b, c and d are taken from the internal structure _lfXoscParams, which
     * must be defined and initialised before this function is called.
     */
    return ((_lfXoscParams.coeffA * temperature * temperature) + (_lfXoscParams.coeffB * temperature) +
            _lfXoscParams.coeffC - _lfXoscParams.coeffD) >>
           _lfXoscParams.shift;
}

OSCClockLossEventDisable()

static void OSCClockLossEventDisable ( void  )

inlinestatic

Disables OSC clock loss event detection.

Disabling the OSC clock loss event does also clear the clock loss event flag.

Note

OSC clock loss event must be disabled before SCLK_LF clock source is changed (by calling OSCClockSourceSet()) and remain disabled until the change is confirmed (by calling OSCClockSourceGet()).

Returns

None

See also

OSCClockLossEventEnable()

{
    DDI16BitfieldWrite( AUX_DDI0_OSC_BASE, DDI_0_OSC_O_CTL0,
        DDI_0_OSC_CTL0_CLK_LOSS_EN_M,
        DDI_0_OSC_CTL0_CLK_LOSS_EN_S, 0 );
}

Here is the call graph for this function:

OSCClockLossEventEnable()

static void OSCClockLossEventEnable ( void  )

inlinestatic

Enables OSC clock loss event detection.

Enables the clock loss event flag to be raised if a clock loss is detected.

Note

OSC clock loss event must be disabled before SCLK_LF clock source is changed (by calling OSCClockSourceSet()) and remain disabled until the change is confirmed (by calling OSCClockSourceGet()).

Returns

None

See also

OSCClockLossEventDisable()

{
    DDI16BitfieldWrite( AUX_DDI0_OSC_BASE, DDI_0_OSC_O_CTL0,
        DDI_0_OSC_CTL0_CLK_LOSS_EN_M,
        DDI_0_OSC_CTL0_CLK_LOSS_EN_S, 1 );
}

Here is the call graph for this function:

OSCClockSourceGet()

uint32_t OSCClockSourceGet

(

uint32_t

ui32SrcClk

)

Get the source clock settings.

Use this function to get the oscillator source for one of the system source clocks.

Parameters

ui32SrcClk

is the source clock to check. OSC_SRC_CLK_HF OSC_SRC_CLK_LF

Returns

Returns the type of oscillator that drives the clock source.

• OSC_RCOSC_HF
• OSC_XOSC_HF
• OSC_RCOSC_LF
• OSC_XOSC_LF

See also

OSCClockSourceSet(), OSCHfSourceSwitch()

Referenced by OSCClockLossEventDisable(), OSCHF_AttemptToSwitchToXosc(), OSCHF_SwitchToRcOscTurnOffXosc(), and SetupAfterColdResetWakeupFromShutDownCfg3().

{
    uint32_t ui32ClockSource;

    // Check the arguments.
    ASSERT((ui32SrcClk & OSC_SRC_CLK_LF) ||
           (ui32SrcClk & OSC_SRC_CLK_HF));

    // Return the source for the selected clock.
    if(ui32SrcClk == OSC_SRC_CLK_LF)
    {
        ui32ClockSource = DDI16BitfieldRead(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_STAT0,
                                            DDI_0_OSC_STAT0_SCLK_LF_SRC_M,
                                            DDI_0_OSC_STAT0_SCLK_LF_SRC_S);
    }
    else
    {
        ui32ClockSource = DDI16BitfieldRead(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_STAT0,
                                            DDI_0_OSC_STAT0_SCLK_HF_SRC_M,
                                            DDI_0_OSC_STAT0_SCLK_HF_SRC_S);
    }
    return ( ui32ClockSource );
}

Here is the call graph for this function:

OSCClockSourceSet()

void OSCClockSourceSet	(	uint32_t	ui32SrcClk,
		uint32_t	ui32Osc
	)

Configure the oscillator input to the a source clock.

Use this function to set the oscillator source for one or more of the system source clocks.

When selecting the high frequency clock source (OSC_SRC_CLK_HF), this function will not do the actual switch. Enabling the high frequency XTAL can take several hundred micro seconds, so the actual switch is done in a separate function, OSCHfSourceSwitch(), leaving System CPU free to perform other tasks as the XTAL starts up.

Note

The High Frequency (OSC_SRC_CLK_HF) can only be derived from the high frequency oscillator. The Low Frequency source clock (OSC_SRC_CLK_LF) can be derived from all 4 oscillators.

If enabling OSC_XOSC_LF it is not safe to go to powerdown/shutdown until the LF clock is running which can be checked using OSCClockSourceGet().

Clock loss reset generation must be disabled before SCLK_LF (OSC_SRC_CLK_LF) clock source is changed and remain disabled until the change is confirmed.

Parameters

ui32SrcClk	is the source clocks to configure. OSC_SRC_CLK_HF OSC_SRC_CLK_LF
ui32Osc	is the oscillator that drives the source clock. OSC_RCOSC_HF OSC_XOSC_HF OSC_RCOSC_LF (only when ui32SrcClk is OSC_SRC_CLK_LF) OSC_XOSC_LF (only when ui32SrcClk is OSC_SRC_CLK_LF)

See also

OSCClockSourceGet(), OSCHfSourceSwitch()

Returns

None

Referenced by OSCClockLossEventDisable(), OSCHF_SwitchToRcOscTurnOffXosc(), OSCHF_TurnOnXosc(), and SetupAfterColdResetWakeupFromShutDownCfg3().

{
    // Check the arguments.
    ASSERT((ui32SrcClk & OSC_SRC_CLK_LF) ||
           (ui32SrcClk & OSC_SRC_CLK_HF));
    ASSERT((ui32Osc == OSC_RCOSC_HF) ||
           (ui32Osc == OSC_RCOSC_LF) ||
           (ui32Osc == OSC_XOSC_HF) ||
           (ui32Osc == OSC_XOSC_LF));

    // Request the high frequency source clock (using 24 MHz XTAL)
    if(ui32SrcClk & OSC_SRC_CLK_HF)
    {
        // Enable the HF XTAL as HF clock source
        DDI16BitfieldWrite(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_CTL0,
                           DDI_0_OSC_CTL0_SCLK_HF_SRC_SEL_M,
                           DDI_0_OSC_CTL0_SCLK_HF_SRC_SEL_S,
                           ui32Osc);
    }

    // Configure the low frequency source clock.
    if(ui32SrcClk & OSC_SRC_CLK_LF)
    {
        // Change the clock source.
        DDI16BitfieldWrite(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_CTL0,
                           DDI_0_OSC_CTL0_SCLK_LF_SRC_SEL_M,
                           DDI_0_OSC_CTL0_SCLK_LF_SRC_SEL_S,
                           ui32Osc);
    }
}

Here is the call graph for this function:

OSCHF_AttemptToSwitchToXosc()

bool OSCHF_AttemptToSwitchToXosc

(

void

)

Switch to XOSC_HF if XOSC_HF is ready.

This is a non-blocking function checking if the XOSC_HF is ready and performs the switching if ready. The function is somewhat blocking in the case where switching is performed.

Returns

Returns status of the XOSC_HF switching:

• true : Switching to XOSC_HF has occurred.
• false : Switching has not occurred.

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock(), and OSCHF_DebugGetCrystalStartupTime().

{
   uint32_t startupTimeInUs;
   uint32_t prevLimmit25InUs;

#if ( defined( ROM_OSCClockSourceGet ))
   if ( ROM_OSCClockSourceGet( OSC_SRC_CLK_HF ) == OSC_XOSC_HF )
#else
   if ( OSCClockSourceGet( OSC_SRC_CLK_HF ) == OSC_XOSC_HF )
#endif
   {
      // Already on XOSC - nothing to do
      return ( 1 );
   }
   if ( OSCHfSourceReady()) {
      OSCHfSourceSwitch();

      // Store startup time, but limit to 25 percent reduction each time.
      oscHfGlobals.timeXoscStable_CV  = AONRTCCurrentCompareValueGet();
      startupTimeInUs   = RTC_CV_TO_US( oscHfGlobals.timeXoscStable_CV - oscHfGlobals.timeXoscOn_CV );
      prevLimmit25InUs  = oscHfGlobals.previousStartupTimeInUs;
      prevLimmit25InUs -= ( prevLimmit25InUs >> 2 ); // 25 percent margin
      oscHfGlobals.previousStartupTimeInUs = startupTimeInUs;
      if ( prevLimmit25InUs > startupTimeInUs ) {
         oscHfGlobals.previousStartupTimeInUs = prevLimmit25InUs;
      }
      return ( 1 );
   }
   return ( 0 );
}

Here is the call graph for this function:

OSCHF_DebugGetCrystalAmplitude()

uint32_t OSCHF_DebugGetCrystalAmplitude

(

void

)

Get crystal amplitude (assuming crystal is running).

Note

This is a debug function only. It is hence not recommended to call this function in normal operation.

This function uses an on-chip ADC and peak detector for reading the crystal amplitude. The measurement time is set to 4 milliseconds and this function does not return before the measurement is done.

Expected value is OSCHF_DebugGetExpectedAverageCrystalAmplitude +/- 50 millivolt.

Returns

Returns crystal amplitude in millivolt.

See also

OSCHF_DebugGetExpectedAverageCrystalAmplitude()

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock().

{
   uint32_t oscCfgRegCopy  ;
   uint32_t startTime      ;
   uint32_t deltaTime      ;
   uint32_t ampValue       ;

   // The specified method is as follows:
   // 1. Set minimum interval between oscillator amplitude calibrations.
   //    (Done by setting PER_M=0 and PER_E=1)
   // 2. Wait approximately 4 milliseconds in order to measure over a
   //    moderately large number of calibrations.
   // 3. Read out the crystal amplitude value from the peek detector.
   // 4. Restore original oscillator amplitude calibrations interval.
   // 5. Return crystal amplitude value converted to millivolt.

   oscCfgRegCopy = HWREG( AON_PMCTL_BASE + AON_PMCTL_O_OSCCFG );
   HWREG( AON_PMCTL_BASE + AON_PMCTL_O_OSCCFG ) = ( 1 << AON_PMCTL_OSCCFG_PER_E_S );

   startTime = AONRTCCurrentCompareValueGet();
   do {
      deltaTime = AONRTCCurrentCompareValueGet() - startTime;
   } while ( deltaTime < ((uint32_t)( 0.004 * FACTOR_SEC_TO_COMP_VAL_FORMAT )));
   ampValue = ( HWREG( AUX_DDI0_OSC_BASE + DDI_0_OSC_O_STAT1 ) &
      DDI_0_OSC_STAT1_HPM_UPDATE_AMP_M ) >>
      DDI_0_OSC_STAT1_HPM_UPDATE_AMP_S ;

   HWREG( AON_PMCTL_BASE + AON_PMCTL_O_OSCCFG ) = oscCfgRegCopy;

   return ( ampValue * 15 );
}

Here is the call graph for this function:

OSCHF_DebugGetCrystalStartupTime()

uint32_t OSCHF_DebugGetCrystalStartupTime

(

void

)

Measure the crystal startup time.

Note

This is a debug function that should not be needed in normal operation.

This function assumes that the chip is running on RCOSC_HF when called. It then switches to XOSC_HF while measuring number of LF-clock edges before XOSC_HF has started and are ready to be used. After that, the function switches back to RCOSC_HF and returns number of LF-edges found.

The length in time between the LF clock edges is approximately 15 microseconds. Or more exactly: LF_clock_edges / ( 32768 * 2 ) seconds.

Please note that the startup time, in addition to the crystal itself also can vary depending on the time since the crystal was stopped and the frequency of the RCOSC_HF oscillator. Calling this function intensively will show a shorter startup time than in typical use cases. When running with TI-RTOS there is a background task (optional but default on) adjusting RCOSC_HF to be as equal as possible to the crystal frequency, giving the shortest possible startup time.

Returns

Returns number of LF-clock edges from starting the crystal until it's ready to be used.

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock().

{
   uint32_t lfEdgesFound = 0 ;

   // Start operation in sync with the LF clock
   HWREG( AON_RTC_BASE + AON_RTC_O_SYNCLF );

   OSCHF_TurnOnXosc();
   while ( ! OSCHF_AttemptToSwitchToXosc() ) {
      HWREG( AON_RTC_BASE + AON_RTC_O_SYNCLF );
      lfEdgesFound ++ ;
   }
   OSCHF_SwitchToRcOscTurnOffXosc();

   return ( lfEdgesFound );
}

Here is the call graph for this function:

OSCHF_DebugGetExpectedAverageCrystalAmplitude()

uint32_t OSCHF_DebugGetExpectedAverageCrystalAmplitude

(

void

)

Get the expected average crystal amplitude.

Note

This is a debug function only. It is hence not recommended to call this function in normal operation.

This function read the configured high and low thresholds and returns the mean value converted to millivolt.

Returns

Returns expected average crystal amplitude in millivolt.

See also

OSCHF_DebugGetCrystalAmplitude()

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock().

{
   uint32_t ampCompTh1    ;
   uint32_t highThreshold ;
   uint32_t lowThreshold  ;

   ampCompTh1 = HWREG( AUX_DDI0_OSC_BASE + DDI_0_OSC_O_AMPCOMPTH1 );
   highThreshold = ( ampCompTh1 & DDI_0_OSC_AMPCOMPTH1_HPMRAMP3_HTH_M ) >>
                                  DDI_0_OSC_AMPCOMPTH1_HPMRAMP3_HTH_S ;
   lowThreshold  = ( ampCompTh1 & DDI_0_OSC_AMPCOMPTH1_HPMRAMP3_LTH_M ) >>
                                  DDI_0_OSC_AMPCOMPTH1_HPMRAMP3_LTH_S ;

   return ((( highThreshold + lowThreshold ) * 15 ) >> 1 );
}

OSCHF_GetStartupTime()

uint32_t OSCHF_GetStartupTime

(

uint32_t

timeUntilWakeupInMs

)

Returns maximum startup time (in microseconds) of XOSC_HF.

The startup time depends on several factors. This function calculates the maximum startup time based on statistical information.

Parameters

timeUntilWakeupInMs

indicates how long time (milliseconds) to the startup will occur.

Returns

Time margin to use in microseconds.

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock().

{
   uint32_t deltaTimeSinceXoscOnInMs   ;
   int32_t  deltaTempSinceXoscOn       ;
   uint32_t newStartupTimeInUs         ;

    // Check CCFG to determine if device is configured for TCXO.
    if( ( HWREG( CCFG_BASE + CCFG_O_MODE_CONF ) & CCFG_MODE_CONF_XOSC_FREQ_M ) == CCFG_MODE_CONF_XOSC_FREQ_TCXO )
    {
        // Device configured for TCXO. Report fixed startup time located in CCFG with
        // coversion from number of 100us to number of us.
        newStartupTimeInUs = (( HWREG( CCFG_BASE + CCFG_O_MODE_CONF_1 ) & CCFG_MODE_CONF_1_TCXO_MAX_START_M ) >>
                                                                          CCFG_MODE_CONF_1_TCXO_MAX_START_S ) * 100;
    }
    else
    {
       deltaTimeSinceXoscOnInMs = RTC_CV_TO_MS( AONRTCCurrentCompareValueGet() - oscHfGlobals.timeXoscOn_CV );
       deltaTempSinceXoscOn     = AONBatMonTemperatureGetDegC() - oscHfGlobals.tempXoscOff;

       if ( deltaTempSinceXoscOn < 0 ) {
          deltaTempSinceXoscOn = -deltaTempSinceXoscOn;
       }

       if (  (( timeUntilWakeupInMs + deltaTimeSinceXoscOnInMs )     > 3000 ) ||
             ( deltaTempSinceXoscOn                                  >    5 ) ||
             ( oscHfGlobals.timeXoscStable_CV < oscHfGlobals.timeXoscOn_CV  ) ||
             ( oscHfGlobals.previousStartupTimeInUs                  ==   0 )    )
       {
          newStartupTimeInUs = 2000;
          if (( HWREG( CCFG_BASE + CCFG_O_SIZE_AND_DIS_FLAGS ) & CCFG_SIZE_AND_DIS_FLAGS_DIS_XOSC_OVR_M ) == 0 ) {
             newStartupTimeInUs = (( HWREG( CCFG_BASE + CCFG_O_MODE_CONF_1 ) &
                CCFG_MODE_CONF_1_XOSC_MAX_START_M ) >>
                CCFG_MODE_CONF_1_XOSC_MAX_START_S ) * 125;
                // Note: CCFG startup time is "in units of 100us" adding 25% margin results in *125
          }
       } else {
          newStartupTimeInUs = RTC_CV_TO_US( oscHfGlobals.timeXoscStable_CV - oscHfGlobals.timeXoscOn_CV );
          newStartupTimeInUs += ( newStartupTimeInUs >> 2 ); // Add 25 percent margin
          if ( newStartupTimeInUs < oscHfGlobals.previousStartupTimeInUs ) {
             newStartupTimeInUs = oscHfGlobals.previousStartupTimeInUs;
          }
       }

       if ( newStartupTimeInUs < 200 ) {
          newStartupTimeInUs = 200;
       }
       if ( newStartupTimeInUs > 4000 ) {
          newStartupTimeInUs = 4000;
       }
   }
   return ( newStartupTimeInUs );
}

Here is the call graph for this function:

OSCHF_SwitchToRcOscTurnOffXosc()

void OSCHF_SwitchToRcOscTurnOffXosc

(

void

)

Switch to RCOSC_HF and turn off XOSC_HF.

This operation takes approximately 50 microseconds (can be shorter if RCOSC_HF already was running).

Returns

None

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock(), and OSCHF_DebugGetCrystalStartupTime().

{
#if ( defined( ROM_OSCClockSourceSet ))
   ROM_OSCClockSourceSet( OSC_SRC_CLK_HF, OSC_RCOSC_HF );
#else
   OSCClockSourceSet( OSC_SRC_CLK_HF, OSC_RCOSC_HF );
#endif

   // Do the switching if not already running on RCOSC_HF
#if ( defined( ROM_OSCClockSourceGet ))
   if ( ROM_OSCClockSourceGet( OSC_SRC_CLK_HF ) != OSC_RCOSC_HF )
#else
   if ( OSCClockSourceGet( OSC_SRC_CLK_HF ) != OSC_RCOSC_HF )
#endif
   {
      OSCHfSourceSwitch();
   }

   oscHfGlobals.timeXoscOff_CV  = AONRTCCurrentCompareValueGet();
   oscHfGlobals.tempXoscOff     = AONBatMonTemperatureGetDegC();
}

Here is the call graph for this function:

OSCHF_TurnOnXosc()

void OSCHF_TurnOnXosc

(

void

)

Turns on XOSC_HF (but without switching to XOSC_HF).

This function simply indicates the need for XOSC_HF to the hardware which initiates the XOSC_HF startup.

Returns

None

Referenced by OSC_IsHPOSCEnabledWithHfDerivedLfClock(), and OSCHF_DebugGetCrystalStartupTime().

{
#if ( defined( ROM_OSCClockSourceSet ))
   ROM_OSCClockSourceSet( OSC_SRC_CLK_HF, OSC_XOSC_HF );
#else
   OSCClockSourceSet( OSC_SRC_CLK_HF, OSC_XOSC_HF );
#endif
   oscHfGlobals.timeXoscOn_CV  = AONRTCCurrentCompareValueGet();
}

Here is the call graph for this function:

OSCHfSourceReady()

static bool OSCHfSourceReady ( void  )

inlinestatic

Check if the HF clock source is ready to be switched.

If a request to switch the HF clock source has been made, this function can be used to check if the clock source is ready to be switched.

Once the HF clock source is ready the switch can be performed by calling the OSCHfSourceSwitch()

Returns

Returns status of HF clock source:

• true : HF clock source is ready.
• false : HF clock source is not ready.

Referenced by OSCHF_AttemptToSwitchToXosc().

{
    // Return the readiness of the HF clock source
    return (DDI16BitfieldRead(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_STAT0,
                              DDI_0_OSC_STAT0_PENDINGSCLKHFSWITCHING_M,
                              DDI_0_OSC_STAT0_PENDINGSCLKHFSWITCHING_S)) ?
        true : false;
}

Here is the call graph for this function:

OSCHfSourceSwitch()

static void OSCHfSourceSwitch ( void  )

inlinestatic

Switch the high frequency clock.

When switching the HF clock source the clock period might be prolonged leaving the clock 'stuck-at' high or low for a few cycles. To ensure that this does not coincide with a read access to the Flash, potentially freezing the device, the HF clock source switch must be executed from ROM.

Note

This function will not return until the clock source has been switched. It is left to the programmer to ensure, that there is a pending request for a HF clock source switch before this function is called.

Returns

None

See also

OSCClockSourceSet()

Referenced by OSCHF_AttemptToSwitchToXosc(), and OSCHF_SwitchToRcOscTurnOffXosc().

{
    // Read target clock (lower half of the 32-bit CTL0 register)
    uint16_t hfSrc = HWREGH(AUX_DDI0_OSC_BASE + DDI_0_OSC_O_CTL0) & DDI_0_OSC_CTL0_SCLK_HF_SRC_SEL_M;

    // If target clock source is RCOSC, change clock source for DCDC to RCOSC
    if(hfSrc == DDI_0_OSC_CTL0_SCLK_HF_SRC_SEL_RCOSC)
    {
        // Force DCDC to use RCOSC before switching SCLK_HF to RCOSC
        HWREG(AUX_DDI0_OSC_BASE + DDI_O_MASK16B + (DDI_0_OSC_O_CTL0 << 1) + 4) = DDI_0_OSC_CTL0_CLK_DCDC_SRC_SEL_M | (DDI_0_OSC_CTL0_CLK_DCDC_SRC_SEL_M >> 16);
        // Dummy read to ensure that the write has propagated
        HWREGH(AUX_DDI0_OSC_BASE + DDI_0_OSC_O_CTL0);
    }

    // Switch the HF clock source
    HapiHFSourceSafeSwitch();

    // If target clock source is XOSC, change clock source for DCDC to "auto"
    if(hfSrc == DDI_0_OSC_CTL0_SCLK_HF_SRC_SEL_XOSC)
    {
        // Set DCDC clock source back to "auto" after SCLK_HF was switched to XOSC
        HWREG(AUX_DDI0_OSC_BASE + DDI_O_MASK16B + (DDI_0_OSC_O_CTL0 << 1) + 4) = DDI_0_OSC_CTL0_CLK_DCDC_SRC_SEL_M;
    }
}

OSCXHfPowerModeSet()

static void OSCXHfPowerModeSet ( uint32_t  ui32Mode )

inlinestatic

Set Power Mode for High Frequency XTAL Oscillator.

Parameters

ui32Mode

is the power mode for the HF XTAL. LOW_POWER_XOSC HIGH_POWER_XOSC

Returns

None

{
    // Check the arguments.
    ASSERT((ui32Mode == LOW_POWER_XOSC) ||
           (ui32Mode == HIGH_POWER_XOSC));

    // Change the power mode.
    DDI16BitWrite(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_CTL0, DDI_0_OSC_CTL0_XOSC_HF_POWER_MODE,
                  ui32Mode);
}

Here is the call graph for this function:

Macro Definition Documentation

HIGH_POWER_XOSC

#define HIGH_POWER_XOSC   0

Referenced by OSCXHfPowerModeSet().

LOW_POWER_XOSC

#define LOW_POWER_XOSC   1

Referenced by OSCXHfPowerModeSet().

OSC_RCOSC_HF

#define OSC_RCOSC_HF   0x00000000

Referenced by OSCClockSourceSet(), and OSCHF_SwitchToRcOscTurnOffXosc().

OSC_RCOSC_LF

#define OSC_RCOSC_LF   0x00000002

Referenced by OSCClockSourceSet(), and SetupAfterColdResetWakeupFromShutDownCfg3().

OSC_SRC_CLK_HF

#define OSC_SRC_CLK_HF   0x00000001

Referenced by OSCClockSourceGet(), OSCClockSourceSet(), OSCHF_AttemptToSwitchToXosc(), OSCHF_SwitchToRcOscTurnOffXosc(), OSCHF_TurnOnXosc(), and SetupAfterColdResetWakeupFromShutDownCfg3().

OSC_SRC_CLK_LF

#define OSC_SRC_CLK_LF   0x00000004

Referenced by OSCClockSourceGet(), OSCClockSourceSet(), and SetupAfterColdResetWakeupFromShutDownCfg3().

OSC_XOSC_HF

#define OSC_XOSC_HF   0x00000001

Referenced by OSCClockSourceSet(), OSCHF_AttemptToSwitchToXosc(), OSCHF_TurnOnXosc(), and SetupAfterColdResetWakeupFromShutDownCfg3().

OSC_XOSC_LF

#define OSC_XOSC_LF   0x00000003

Referenced by OSCClockSourceSet(), and SetupAfterColdResetWakeupFromShutDownCfg3().

SCLK_HF_RCOSC_HF

#define SCLK_HF_RCOSC_HF   0

SCLK_HF_XOSC_HF

#define SCLK_HF_XOSC_HF   1

SCLK_LF_FROM_RCOSC_HF

#define SCLK_LF_FROM_RCOSC_HF   0

SCLK_LF_FROM_RCOSC_LF

#define SCLK_LF_FROM_RCOSC_LF   2

SCLK_LF_FROM_XOSC_HF

#define SCLK_LF_FROM_XOSC_HF   1

SCLK_LF_FROM_XOSC_LF

#define SCLK_LF_FROM_XOSC_LF   3