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

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

int32_t	OSC_HPOSCRelativeFrequencyOffsetGet (int32_t tempDegC)
	Calculate the temperature dependent relative frequency offset of HPOSC. More...

int16_t	OSC_HPOSCRelativeFrequencyOffsetToRFCoreFormatConvert (int32_t HPOSC_RelFreqOffset)
	Converts the relative frequency offset of HPOSC to the RF Core parameter format. More...

Detailed Description

Function Documentation

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
    uint32_t fitParams = HWREG(FCFG1_BASE + FCFG1_O_FREQ_OFFSET);
    // Extract the P0,P1,P2 params, and sign extend them via shifting up/down
    int32_t paramP0 = ((((int32_t) fitParams) << (32 - FCFG1_FREQ_OFFSET_HPOSC_COMP_P0_W - FCFG1_FREQ_OFFSET_HPOSC_COMP_P0_S))
                                              >> (32 - FCFG1_FREQ_OFFSET_HPOSC_COMP_P0_W));
    int32_t paramP1 = ((((int32_t) fitParams) << (32 - FCFG1_FREQ_OFFSET_HPOSC_COMP_P1_W - FCFG1_FREQ_OFFSET_HPOSC_COMP_P1_S))
                                              >> (32 - FCFG1_FREQ_OFFSET_HPOSC_COMP_P1_W));
    int32_t paramP2 = ((((int32_t) fitParams) << (32 - FCFG1_FREQ_OFFSET_HPOSC_COMP_P2_W - FCFG1_FREQ_OFFSET_HPOSC_COMP_P2_S))
                                              >> (32 - FCFG1_FREQ_OFFSET_HPOSC_COMP_P2_W));
    int32_t paramP3 = ((((int32_t) HWREG(FCFG1_BASE + FCFG1_O_MISC_CONF_2))
                                              << (32 - FCFG1_MISC_CONF_2_HPOSC_COMP_P3_W - FCFG1_MISC_CONF_2_HPOSC_COMP_P3_S))
                                              >> (32 - FCFG1_MISC_CONF_2_HPOSC_COMP_P3_W));
 
    // 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).

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

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, this function will not do the actual switch. Enabling the high frequency XTAL can take several hundred micro seconds, so the actual switch is split into a separate function, leaving System CPU free to perform other tasks as the XTAL starts up.

Note: The High Frequency (OSC_SRC_CLK_HF) and Medium Frequency (OSC_SRC_CLK_MF) 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_MF 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()

Returns: None

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

 {
     // Check the arguments.
     ASSERT((ui32SrcClk & OSC_SRC_CLK_LF) ||
            (ui32SrcClk & OSC_SRC_CLK_MF) ||
            (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 medium frequency source clock
     if(ui32SrcClk & OSC_SRC_CLK_MF)
     {
         DDI16BitfieldWrite(AUX_DDI0_OSC_BASE, DDI_0_OSC_O_CTL0,
                            DDI_0_OSC_CTL0_SCLK_MF_SRC_SEL_M,
                            DDI_0_OSC_CTL0_SCLK_MF_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_WUC_BASE + AON_WUC_O_OSCCFG );
    HWREG( AON_WUC_BASE + AON_WUC_O_OSCCFG ) = ( 1 << AON_WUC_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_WUC_BASE + AON_WUC_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         ;
 
    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

 {
    // Set SCLK_HF and SCLK_MF to RCOSC_HF without checking
    // Doing this anyway to keep HF and MF in sync
 #if ( defined( ROM_OSCClockSourceSet ))
    ROM_OSCClockSourceSet( OSC_SRC_CLK_HF | OSC_SRC_CLK_MF, OSC_RCOSC_HF );
 #else
    OSCClockSourceSet( OSC_SRC_CLK_HF | OSC_SRC_CLK_MF, 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_SRC_CLK_MF, OSC_XOSC_HF );
 #else
    OSCClockSourceSet( OSC_SRC_CLK_HF | OSC_SRC_CLK_MF, 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().

 {
     // Switch the HF clock source
     HapiHFSourceSafeSwitch();
 }

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