clock_config.c File Reference

Functions
static void	CLOCK_CONFIG_FircSafeConfig (const scg_firc_config_t *fircConfig)
static bool	ke1xf_clock_is_external (kinetis_clock_type_e ct)
static bool	ke1xf_clock_is_high_speed (kinetis_clock_type_e ct)
static void	setClockConfig (kinetis_clock_type_e ct)
void	ke1xf_clock_init (kinetis_clock_type_e ct)
	This function executes the configuration of clocks.
kinetis_clock_type_e	ke1xf_clock_get_current_type (void)

Variables
static kinetis_clock_type_e	clockType = kinetis_clock_default_firc
const scg_sys_clk_config_t	g_sysClkConfig_BOARD_BootClockRUN_HS
const scg_sys_clk_config_t	g_sysClkConfig_BOARD_BootClockRUN
const scg_sosc_config_t	g_scgSysOscConfig_BOARD_BootClockRUN
const scg_sirc_config_t	g_scgSircConfig_BOARD_BootClockRUN
const scg_firc_config_t	g_scgFircConfig_EXT_BOARD_BootClockRUN
const scg_spll_config_t	g_scgSysPllConfig_EXT_BOARD_BootClockRUN
const scg_firc_config_t	g_scgFircConfig_INT_BOARD_BootClockRUN
const scg_spll_config_t	g_scgSysPllConfig_INT_BOARD_BootClockRUN

Function Documentation

CLOCK_CONFIG_FircSafeConfig()

static void CLOCK_CONFIG_FircSafeConfig ( const scg_firc_config_t *  fircConfig )

static

Definition at line 103 of file clock_config.c.

                                                                             {
    scg_sys_clk_config_t curConfig;
    const scg_sirc_config_t scgSircConfig = {
        .enableMode = kSCG_SircEnable,
        .div1 = kSCG_AsyncClkDisable,
        .div2 = kSCG_AsyncClkDivBy2,
        .range = kSCG_SircRangeHigh
    };
    scg_sys_clk_config_t sysClkSafeConfigSource = {
         .divSlow = kSCG_SysClkDivBy4, /* Slow clock divider */
         .divBus = kSCG_SysClkDivBy1,  /* Bus clock divider */
         .divCore = kSCG_SysClkDivBy1, /* Core clock divider */
         .src = kSCG_SysClkSrcSirc     /* System clock source */
    };
    /* Init Sirc. */
    CLOCK_InitSirc(&scgSircConfig);
    /* Change to use SIRC as system clock source to prepare to change FIRCCFG register. */
    CLOCK_SetRunModeSysClkConfig(&sysClkSafeConfigSource);
    /* Wait for clock source switch finished. */
    do {
         CLOCK_GetCurSysClkConfig(&curConfig);
    } while (curConfig.src != sysClkSafeConfigSource.src);
 
    /* Init Firc. */
    CLOCK_InitFirc(fircConfig);
    /* Change back to use FIRC as system clock source in order to configure SIRC if needed. */
    sysClkSafeConfigSource.src = kSCG_SysClkSrcFirc;
    CLOCK_SetRunModeSysClkConfig(&sysClkSafeConfigSource);
    /* Wait for clock source switch finished. */
    do {
         CLOCK_GetCurSysClkConfig(&curConfig);
    } while (curConfig.src != sysClkSafeConfigSource.src);
}

Referenced by ke1xf_clock_init().

Here is the call graph for this function:

Here is the caller graph for this function:

ke1xf_clock_get_current_type()

kinetis_clock_type_e ke1xf_clock_get_current_type

(

void

)

Definition at line 249 of file clock_config.c.

                                                        {
    return clockType;
}

Referenced by flashUnlock().

Here is the caller graph for this function:

ke1xf_clock_init()

void ke1xf_clock_init

(

kinetis_clock_type_e

ct

)

This function executes the configuration of clocks.

Definition at line 168 of file clock_config.c.

                                               {
    // Init External Osc.
    if (ke1xf_clock_is_external(ct)) {
        // Init SOSC according to board configuration.
        CLOCK_InitSysOsc(&g_scgSysOscConfig_BOARD_BootClockRUN);
        // Set the XTAL0 frequency based on board settings.
        CLOCK_SetXtal0Freq(g_scgSysOscConfig_BOARD_BootClockRUN.freq);
    }
    // Init FIRC.
    if (clockType == kinetis_clock_default_firc) {
        CLOCK_CONFIG_FircSafeConfig(ke1xf_clock_is_external(ct) ? &g_scgFircConfig_EXT_BOARD_BootClockRUN : &g_scgFircConfig_INT_BOARD_BootClockRUN);
    }
 
    if (ke1xf_clock_is_high_speed(ct)) {
        // Set HSRUN power mode.
        SMC_SetPowerModeProtection(SMC, kSMC_AllowPowerModeAll);
        SMC_SetPowerModeHsrun(SMC);
        while (SMC_GetPowerModeState(SMC) != kSMC_PowerStateHsrun) {
        }
    } else {
        // If we've already started and want to change the mode, then we have to lower the frequency first:
        // [RTFM: "Before exiting HSRUN mode, clock frequencies should be reduced back down to those acceptable in RUN mode."]
        if (ke1xf_clock_is_high_speed(clockType)) {
            setClockConfig(ct);
        }
 
        SMC_SetPowerModeRun(SMC);
        while (SMC_GetPowerModeState(SMC) != kSMC_PowerStateRun) {
        }
    }
 
    // Now the mode is "officially" changed!
    clockType = ct;
 
    // Init SIRC.
    //CLOCK_InitSirc(&g_scgSircConfig_BOARD_BootClockRUN);
    
    // Init SysPll.
    CLOCK_InitSysPll(ke1xf_clock_is_external(ct) ? &g_scgSysPllConfig_EXT_BOARD_BootClockRUN : &g_scgSysPllConfig_INT_BOARD_BootClockRUN);
 
    // Set SCG to SPLL mode.
    setClockConfig(ct);
    
    /* Set SystemCoreClock variable. */
    //SystemCoreClock = KINETIS_PLL_FREQ;
 
    /* Set PCC ADC0 selection */
    CLOCK_SetIpSrc(kCLOCK_Adc0, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC ADC1 selection */
    CLOCK_SetIpSrc(kCLOCK_Adc1, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC ADC2 selection */
    CLOCK_SetIpSrc(kCLOCK_Adc2, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC LPSPI0 selection */
    CLOCK_SetIpSrc(kCLOCK_Lpspi0, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC LPSPI1 selection */
    CLOCK_SetIpSrc(kCLOCK_Lpspi1, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC LPUART0 selection */
    CLOCK_SetIpSrc(kCLOCK_Lpuart0, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC LPUART1 selection */
    CLOCK_SetIpSrc(kCLOCK_Lpuart1, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC LPTMR0 selection */
    CLOCK_SetIpSrc(kCLOCK_Lptmr0, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC LPIT0 selection */
    CLOCK_SetIpSrc(kCLOCK_Lpit0, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC FTM0 selection */
    CLOCK_SetIpSrc(kCLOCK_Ftm0, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC FTM1 selection */
    CLOCK_SetIpSrc(kCLOCK_Ftm1, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC FTM2 selection */
    CLOCK_SetIpSrc(kCLOCK_Ftm2, kCLOCK_IpSrcSysPllAsync);
    /* Set PCC FTM3 selection */
    CLOCK_SetIpSrc(kCLOCK_Ftm3, kCLOCK_IpSrcSysPllAsync);
 
#if 0
    if (clockType != kinetis_clock_default_firc) {
        // try to restore the UART if the frequency has been changed
        LPUART_SetBaudRate(LPUART0, CLOCK_SYS_GetUartFreq(UART0_IDX), KINETIS_UART_FREQUENCY);
    }
#endif
}

Referenced by __late_init(), flashLock(), and flashUnlock().

Here is the call graph for this function:

Here is the caller graph for this function:

ke1xf_clock_is_external()

static bool ke1xf_clock_is_external ( kinetis_clock_type_e  ct )

static

Definition at line 137 of file clock_config.c.

                                                             {
    return (ct == kinetis_clock_ext_osc_hs);
}

Referenced by ke1xf_clock_init().

Here is the caller graph for this function:

ke1xf_clock_is_high_speed()

static bool ke1xf_clock_is_high_speed ( kinetis_clock_type_e  ct )

static

Definition at line 141 of file clock_config.c.

                                                               {
    return (ct == kinetis_clock_int_osc_hs || ct == kinetis_clock_ext_osc_hs);
}

Referenced by ke1xf_clock_init(), and setClockConfig().

Here is the caller graph for this function:

setClockConfig()

static void setClockConfig ( kinetis_clock_type_e  ct )

static

Definition at line 145 of file clock_config.c.

                                                    {
    scg_sys_clk_config_t curConfig;
 
    // set a new config
    const scg_sys_clk_config_t *sysClkConfig = ke1xf_clock_is_high_speed(ct) ? 
        &g_sysClkConfig_BOARD_BootClockRUN_HS : &g_sysClkConfig_BOARD_BootClockRUN;
    
    // Update config depending on the current speed mode
    if (ke1xf_clock_is_high_speed(clockType)) {
        CLOCK_SetHsrunModeSysClkConfig(sysClkConfig);
    } else {
        CLOCK_SetRunModeSysClkConfig(sysClkConfig);
    }
    
    // Wait for clock source switch finished.
    do {
         CLOCK_GetCurSysClkConfig(&curConfig);
    } while (curConfig.src != sysClkConfig->src);
}

Referenced by ke1xf_clock_init().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

clockType

kinetis_clock_type_e clockType = kinetis_clock_default_firc

static

Definition at line 26 of file clock_config.c.

Referenced by ke1xf_clock_get_current_type(), ke1xf_clock_init(), and setClockConfig().

g_scgFircConfig_EXT_BOARD_BootClockRUN

const scg_firc_config_t g_scgFircConfig_EXT_BOARD_BootClockRUN

Initial value:

= {
        .enableMode = kSCG_FircDisableRegulator,  
        .div1 = kSCG_AsyncClkDisable,             
        .div2 = kSCG_AsyncClkDisable,             
        .range = kSCG_FircRange48M,               
        .trimConfig = NULL,                       
}

Definition at line 58 of file clock_config.c.

                                                                 {
        .enableMode = kSCG_FircDisableRegulator,  /* Enable FIRC clock */
        .div1 = kSCG_AsyncClkDisable,             /* Fast IRC Clock Divider 1: Clock output is disabled */
        .div2 = kSCG_AsyncClkDisable,             /* Fast IRC Clock Divider 2: Clock output is disabled */
        .range = kSCG_FircRange48M,               /* Fast IRC is trimmed to 48MHz */
        .trimConfig = NULL,                       /* Fast IRC Trim disabled */
};

Referenced by ke1xf_clock_init().

g_scgFircConfig_INT_BOARD_BootClockRUN

const scg_firc_config_t g_scgFircConfig_INT_BOARD_BootClockRUN

Initial value:

= {
        .enableMode = kSCG_FircEnable,            
        .div1 = kSCG_AsyncClkDisable,             
        .div2 = kSCG_AsyncClkDisable,             
        .range = kSCG_FircRange48M,               
        .trimConfig = NULL,                       
}

Definition at line 75 of file clock_config.c.

                                                                 {
        .enableMode = kSCG_FircEnable,            /* Enable FIRC clock */
        .div1 = kSCG_AsyncClkDisable,             /* Fast IRC Clock Divider 1: Clock output is disabled */
        .div2 = kSCG_AsyncClkDisable,             /* Fast IRC Clock Divider 2: Clock output is disabled */
        .range = kSCG_FircRange48M,               /* Fast IRC is trimmed to 48MHz */
        .trimConfig = NULL,                       /* Fast IRC Trim disabled */
};

Referenced by ke1xf_clock_init().

g_scgSircConfig_BOARD_BootClockRUN

const scg_sirc_config_t g_scgSircConfig_BOARD_BootClockRUN

Initial value:

= {
        .enableMode = kSCG_SircEnableInLowPower,
        .div1 = kSCG_AsyncClkDisable,             
        .div2 = kSCG_AsyncClkDisable,             
        .range = kSCG_SircRangeHigh,              
}

Definition at line 52 of file clock_config.c.

                                                             {
        .enableMode = kSCG_SircEnableInLowPower,/* Enable SIRC clock, Enable SIRC in low power mode */
        .div1 = kSCG_AsyncClkDisable,             /* Slow IRC Clock Divider 1: Clock output is disabled */
        .div2 = kSCG_AsyncClkDisable,             /* Slow IRC Clock Divider 2: Clock output is disabled */
        .range = kSCG_SircRangeHigh,              /* Slow IRC high range clock (8 MHz) */
};

g_scgSysOscConfig_BOARD_BootClockRUN

const scg_sosc_config_t g_scgSysOscConfig_BOARD_BootClockRUN

Initial value:

= {
        .freq = KINETIS_CLK,                      
        .enableMode = kSCG_SysOscEnable,          
        .monitorMode = kSCG_SysOscMonitorDisable, 
        .div1 = kSCG_AsyncClkDisable,             
        .div2 = kSCG_AsyncClkDisable,             
        .workMode = kSCG_SysOscModeExt,           
}

Definition at line 44 of file clock_config.c.

                                                               {
        .freq = KINETIS_CLK,                      /* System Oscillator frequency: 8000000Hz */
        .enableMode = kSCG_SysOscEnable,          /* Enable System OSC clock */
        .monitorMode = kSCG_SysOscMonitorDisable, /* Monitor disabled */
        .div1 = kSCG_AsyncClkDisable,             /* System OSC Clock Divider 1: Clock output is disabled */
        .div2 = kSCG_AsyncClkDisable,             /* System OSC Clock Divider 2: Clock output is disabled */
        .workMode = kSCG_SysOscModeExt,           /* Use external clock */
};

Referenced by ke1xf_clock_init().

g_scgSysPllConfig_EXT_BOARD_BootClockRUN

const scg_spll_config_t g_scgSysPllConfig_EXT_BOARD_BootClockRUN

Initial value:

= {
        .enableMode = kSCG_SysPllEnable,          
        .monitorMode = kSCG_SysPllMonitorDisable, 
        .div1 = kSCG_AsyncClkDivBy64,             
        .div2 = kSCG_AsyncClkDivBy8,              
        .src = kSCG_SysPllSrcSysOsc,              
        .prediv = KINETIS_EXT_PLL_DIV,            
        .mult = KINETIS_EXT_PLL_MUL,              
}

Definition at line 65 of file clock_config.c.

                                                                   {
        .enableMode = kSCG_SysPllEnable,          /* Enable SPLL clock */
        .monitorMode = kSCG_SysPllMonitorDisable, /* Monitor disabled */
        .div1 = kSCG_AsyncClkDivBy64,             /* System PLL Clock Divider 1: divided by 64 */
        .div2 = kSCG_AsyncClkDivBy8,              /* System PLL Clock Divider 2: divided by 8 */
        .src = kSCG_SysPllSrcSysOsc,              /* System PLL clock source is System OSC */
        .prediv = KINETIS_EXT_PLL_DIV,            /* 0=Divided by 1 */
        .mult = KINETIS_EXT_PLL_MUL,              /* Multiply Factor */
};

Referenced by ke1xf_clock_init().

g_scgSysPllConfig_INT_BOARD_BootClockRUN

const scg_spll_config_t g_scgSysPllConfig_INT_BOARD_BootClockRUN

Initial value:

= {
        .enableMode = kSCG_SysPllEnable,          
        .monitorMode = kSCG_SysPllMonitorDisable, 
        .div1 = kSCG_AsyncClkDivBy64,             
        .div2 = kSCG_AsyncClkDivBy8,              
        .src = kSCG_SysPllSrcFirc,                
        .prediv = KINETIS_INT_PLL_DIV,            
        .mult = KINETIS_INT_PLL_MUL,              
}

Definition at line 82 of file clock_config.c.

                                                                   {
        .enableMode = kSCG_SysPllEnable,          /* Enable SPLL clock */
        .monitorMode = kSCG_SysPllMonitorDisable, /* Monitor disabled */
        .div1 = kSCG_AsyncClkDivBy64,             /* System PLL Clock Divider 1: divided by 64 */
        .div2 = kSCG_AsyncClkDivBy8,              /* System PLL Clock Divider 2: divided by 8 */
        .src = kSCG_SysPllSrcFirc,                /* System PLL clock source is Fast IRC */
        .prediv = KINETIS_INT_PLL_DIV,            /* Divided by Factor */
        .mult = KINETIS_INT_PLL_MUL,              /* Multiply Factor */
};

Referenced by ke1xf_clock_init().

g_sysClkConfig_BOARD_BootClockRUN

const scg_sys_clk_config_t g_sysClkConfig_BOARD_BootClockRUN

Initial value:

= {
        .divSlow = kSCG_SysClkDivBy7,             
        .divBus = kSCG_SysClkDivBy8,              
        .divCore = kSCG_SysClkDivBy2,             
        .src = kSCG_SysClkSrcSysPll,              
    }

Definition at line 37 of file clock_config.c.

                                                               {
        .divSlow = kSCG_SysClkDivBy7,             /* Slow Clock Divider: divided by 7 */
        .divBus = kSCG_SysClkDivBy8,              /* Bus Clock Divider: divided by 8 */
        .divCore = kSCG_SysClkDivBy2,             /* Core Clock Divider: divided by 2 */
        .src = kSCG_SysClkSrcSysPll,              /* System PLL is selected as System Clock Source */
    };

Referenced by setClockConfig().

g_sysClkConfig_BOARD_BootClockRUN_HS

const scg_sys_clk_config_t g_sysClkConfig_BOARD_BootClockRUN_HS

Initial value:

= {
        .divSlow = kSCG_SysClkDivBy7,             
        .divBus = kSCG_SysClkDivBy8,              
        .divCore = kSCG_SysClkDivBy1,             
        .src = kSCG_SysClkSrcSysPll,              
}

Definition at line 29 of file clock_config.c.

                                                                  {
        .divSlow = kSCG_SysClkDivBy7,             /* Slow Clock Divider: divided by 7 */
        .divBus = kSCG_SysClkDivBy8,              /* Bus Clock Divider: divided by 8 */
        .divCore = kSCG_SysClkDivBy1,             /* Core Clock Divider: divided by 1 */
        .src = kSCG_SysClkSrcSysPll,              /* System PLL is selected as System Clock Source */
};

Referenced by setClockConfig().

Go to the source code of this file.