Data Structures
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...

void	OSC_HPOSC_Debug_InitFreqOffsetParams (HposcDebugData_t *pDebugData)
	Debug function to calculate the HPOSC polynomials for experimental data sets. More...

void	OSC_HPOSCInitializeFrequencyOffsetParameters (void)
	HPOSC initialization function. Must always be called before using HPOSC. More...

int32_t	OSC_HPOSCRelativeFrequencyOffsetGet (int32_t tempDegC)
	Calculate the temperature dependent relative frequency offset of HPOSC. 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...

Detailed Description

Function Documentation

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

 {
    // 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:

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()

 {
    // Calculate the curve fitting parameters from temp insertion measurements
    // But first adjust the measurements with constants found in characterization
    insertion_t  pMeasurment[ 3 ];
 
    InitializeMeasurmentSet( &pMeasurment[ 0 ], (uint32_t)&pDebugData->meas_1, pDebugData->offsetD1, pDebugData->polyP3 );
    InitializeMeasurmentSet( &pMeasurment[ 1 ], (uint32_t)&pDebugData->meas_2, pDebugData->offsetD2, pDebugData->polyP3 );
    InitializeMeasurmentSet( &pMeasurment[ 2 ], (uint32_t)&pDebugData->meas_3, pDebugData->offsetD3, pDebugData->polyP3 );
 
    FindPolynomialsAndUpdateGlobals( pMeasurment );
 }

Here is the call graph for this function:

void OSC_HPOSCInitializeFrequencyOffsetParameters ( void )

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

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

Returns: None

See also: OSC_HPOSC_Debug_InitFreqOffsetParams()

 {
    {
       // Calculate the curve fitting parameters from temp insertion measurements
       // But first adjust the measurements with constants found in characterization
       insertion_t  pMeasurment[ 3 ];
 
       InitializeMeasurmentSet( &pMeasurment[ 0 ], FCFG1_BASE + FCFG1_O_HPOSC_MEAS_1, D1OFFSET_p25C, P3_POLYNOMIAL );
       InitializeMeasurmentSet( &pMeasurment[ 1 ], FCFG1_BASE + FCFG1_O_HPOSC_MEAS_2, D2OFFSET_p85C, P3_POLYNOMIAL );
       InitializeMeasurmentSet( &pMeasurment[ 2 ], FCFG1_BASE + FCFG1_O_HPOSC_MEAS_3, D3OFFSET_m40C, P3_POLYNOMIAL );
 
       FindPolynomialsAndUpdateGlobals( pMeasurment );
    }
 }

Here is the call graph for this function:

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, using temperature and curve fitting parameters
 
    int32_t paramP0 = _hpOscPolynomials[ 0 ];
    int32_t paramP1 = _hpOscPolynomials[ 1 ];
    int32_t paramP2 = _hpOscPolynomials[ 2 ];
    int32_t paramP3 = _hpOscPolynomials[ 3 ];
 
    // 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 = P0 + P1*(t - T0) + P2*(t - T0)^2 + P3*(t - T0)^3, where: P0,P1,P2,P3 are curve fitting parameters from FCFG1
    //                                                 t = current temperature (from temp sensor) in deg C
    //                                                 T0 = 27 deg C (fixed temperature constant)
    int32_t tempDelta = (tempDegC - 27);
    int32_t tempDeltaX2 = tempDelta * tempDelta;
    int32_t d = paramP0 + ((tempDelta*paramP1)>>3) + ((tempDeltaX2*paramP2)>>10) + ((tempDeltaX2*tempDelta*paramP3)>>18);
 
    return ( d );
 }

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 );
 }

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:

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);
 }

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);
 }

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:

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:

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.

Returns

Returns the type of oscillator that drives the clock source.

See also: OSCClockSourceSet(), OSCHfSourceSwitch()

Referenced by 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:

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 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:

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.

 {
    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:

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()

 {
    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:

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()

 {
    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 );
 }

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.

 {
    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:

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

 {
 #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:

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

 {
 #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:

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:

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;
     }
 }

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.

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);
 }