软件环境：windows7旗舰版,IAR V6105(EWARM-EV-WEB-6105) 
ARM芯片：飞思卡尔K60N512VMD100 （cortex-m4核心）

示例程序：飞思卡尔官方的 KINETIS512_SC
======================

最近分析了一下飞思卡尔官方提供的k60系列demo程序在IAR上的启动流程，现写一下笔记，以备以后参考。先看一下K60N512VMD100内部存储器的分布情况，飞思卡尔K60N512VMD100有512K的flash和128k的SRAM.其中： 

Flash地址空间：
0x00000000--0x00080000,共512k

SRAM地址空间：
SRAM1 0x1FFF0000--0x20000000 64k

SRAM2 0x20000000--0x20010000 64k

总共的SRAM大小是128k 

我要在RAM中调试代码，下面以代码的执行过程为顺序分析一下启动流程。 

首先看一下源文件中提供的128KB_Ram.icf文件。*.icf文件是IAR中的分散描述文件，相当于ADS中的*.src文件或keil中的*.sct文件或GNU中的*.lds链接脚本文件。

这个文件中前面部分是各个变量的定义，关键看后面部分：
1./*128KB_Ram.icf后面部分*/
2. ***********
3.place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec };
4. place at address mem:__code_start__ { readonly section .noinit };
5.
6. place in RAM_region { readonly, block CodeRelocate };
7.
8. place in RAM_region { readwrite, block CodeRelocateRam,
9. block CSTACK, block HEAP };
10. ************ 

①place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec }

这段代码表示要把.intvec代码段中的只读部分放在存储空间（mem，前面已定义的名称）中__ICFEDIT_intvec_start__ 地址上，前面部分已经定义__ICFEDIT_intvec_start__=0x1fff0000，是SRAM的起始地址。也就是先把向量表放到内存中的最前面。 .intvec 这个段是在vectors.c文件中出现的，
1./*vectors.c片段*/
2.

3.typedef void (*vector_entry)(void);

4.
5.     #pragma location = ".intvec"
6.     const vector_entry __vector_table[] = //@ ".intvec" =
7.
8.{
9.   VECTOR_000, /* Initial SP */
10.   VECTOR_001, /* Initial PC */
11.   VECTOR_002,
12.   VECTOR_003,
13.   ......(中间省略)
14.   VECTOR_254,
15.   VECTOR_255,
16.   CONFIG_1,
17.   CONFIG_2,
18.   CONFIG_3,
19.   CONFIG_4,
20.
21.}; 

从源文件中可以看到这里定义了一个向量表__vector_table（前面的const 很重要不能省，这样才能保证向量表是只读的），向量表中的每一项都是一个指向函数的指针，这里总共有256+4=260个指针，所以占据空间为260*4=1040=0x410.

所以SRAM空间的前0x410的空间已经被向量表占据。即占据了0x1fff0000--0x1fff0410. 

②place at address mem:__code_start__ { readonly section .noinit }

这段代码表示要把 .noinit段中的只读部分放到地址空间 __code_start__ 开始的地址上，前面有定义 __code_start__= 0x1fff0410 ，也就是把 .noinit段放到0x1fff0410开始的地址上。所以在内存中代码就连续了，先是向量表，接着的是.noinitd 段。

.noinit 段在crt0.s汇编文件中出现：
1.
SECTION .noinit : CODE
2.
 EXPORT __startup
3. __startup
4.
5.
 MOV r0,#0 ; Initialize the GPRs
6.
 MOV r1,#0
7.
 MOV r2,#0
8.
 MOV r3,#0
9.
 MOV r4,#0
10.
 MOV r5,#0
11.
 MOV r6,#0
12.
 MOV r7,#0
13.
 MOV r8,#0
14.
 MOV r9,#0
15.
 MOV r10,#0
16.
 MOV r11,#0
17.
 MOV r12,#0
18.
 CPSIE i ; Unmask interrupts
19.
 import start
20.
 BL start ; call the C code
21. __done
22.
 B __done
23.
24.
25.
END 

这段代码算是芯片复位后执行的第一段代码（如果没有其他异常的话）。作为一个通常的规则，推荐先把通用寄存器（R0-R12）清零。然后是使能中断，跳转到start标号（或函数）处继续执行。 

======================== 

在start.c文件中找到了start函数：

1./*start.c片段*/

2.void start(void)

3.{
4.     /* Disable the watchdog timer */
5.     wdog_disable();
6.
7.     /* Copy any vector or data sections that need to be in RAM */
8.     common_startup();
9.
10.     /* Perform processor initialization */
11.     sysinit();
12.
13.     printf("\n\n");
14.
15.     /* Determine the last cause(s) of reset */
16.     if (MC_SRSH & MC_SRSH_SW_MASK)
17.         printf("Software Reset\n");
18.     if (MC_SRSH & MC_SRSH_LOCKUP_MASK)
19.         printf("Core Lockup Event Reset\n");
20.     if (MC_SRSH & MC_SRSH_JTAG_MASK)
21.         printf("JTAG Reset\n");
22.
23.     if (MC_SRSL & MC_SRSL_POR_MASK)
24.         printf("Power-on Reset\n");
25.     if (MC_SRSL & MC_SRSL_PIN_MASK)
26.         printf("External Pin Reset\n");
27.     if (MC_SRSL & MC_SRSL_COP_MASK)
28.         printf("Watchdog(COP) Reset\n");
29.     if (MC_SRSL & MC_SRSL_LOC_MASK)
30.         printf("Loss of Clock Reset\n");
31.     if (MC_SRSL & MC_SRSL_LVD_MASK)
32.         printf("Low-voltage Detect Reset\n");
33.     if (MC_SRSL & MC_SRSL_WAKEUP_MASK)
34.         printf("LLWU Reset\n");
35.
36.
37.     /* Determine specific Kinetis device and revision */
38.     cpu_identify();
39.
40.     /* Jump to main process */
41.     main();
42.
43.     /* No actions to perform after this so wait forever */
44.     while(1);
45.} 

start函数中，首先执行 wdog_disable()函数来禁用看门狗，然后调用 common_startup()函数初始化RAM(复制向量表、清零.bss段等，为C语言运行环境做准备)，接着执行sysinit()函数初始化芯片（时钟、用到的外设等）。下面依次分析这3个函数。

①wdog_disable()

对系统的设定无非是对各个寄存器值的修改。wdog_disable()函数在wdog.c文件中
1./*wdog.c片段*/
2.
3.void wdog_disable(void)

4.{
5.     /* First unlock the watchdog so that we can write to registers */
6.     wdog_unlock();
7.
8.     /* Clear the WDOGEN bit to disable the watchdog */
9.     WDOG_STCTRLH &= ~WDOG_STCTRLH_WDOGEN_MASK;
10.}
11.

12. void wdog_unlock(void)
13.{
14.   /* NOTE: DO NOT SINGLE STEP THROUGH THIS */
15.   /* There are timing requirements for the execution of the unlock. If
16.   * you single step through the code you will cause the CPU to reset.
17.   */
18.
19.     /* This sequence must execute within 20 clock cycles, so disable
20.         * interrupts will keep the code atomic and ensure the timing.
21.         */
22.         DisableInterrupts;
23.
24.     /* Write 0xC520 to the unlock register */
25.     WDOG_UNLOCK = 0xC520;
26.
27.     /* Followed by 0xD928 to complete the unlock */
28.     WDOG_UNLOCK = 0xD928;
29.
30.     /* Re-enable interrupts now that we are done */
31.           EnableInterrupts;
32.} 

禁用看门狗流程很简单：先是解锁寄存器，然后更改看门狗寄存器里面的值来禁用看门狗。解锁看门狗寄存器：向解锁寄存器里连续写入0xC520和0xD928，两次写入的时间必须小于20个时钟周期。所以在解锁过程中不能单步运行，期间也不能被中断打断，解锁函数是 wdog_unlock()。上面DisableInterrupts和EnableInterrupts已经在arm_cm4.h中定义过：

#define DisableInterrupts asm(" CPSID i");

#define EnableInterrupts asm(" CPSIE i");

解锁看门狗寄存器后，向看门狗寄存器里写入适当的值就可以禁用看门狗了。

也就是把WDOG_STCTRLH 寄存器（地址是0x40052000）的第0位置0. 

②common_startup

初始化RAM(复制向量表、清零.bss段等，为C语言运行环境做准备)。
1.    1 /* File: startup.c */

2.     2 #include "common.h"
3.
4.     3 #pragma section = ".data"
5.     4 #pragma section = ".data_init"
6.     5 #pragma section = ".bss"
7.     6 #pragma section = "CodeRelocate"
8.     7 #pragma section = "CodeRelocateRam"
9.
10.     8 /********************************************************************/
11.     9 void
12.     10 common_startup(void)
13.     11 {
14.
15.     12 /* Declare a counter we'll use in all of the copy loops */
16.     13 uint32 n;
17.
18.     14 /* Declare pointers for various data sections. These pointers
19.     15 * are initialized using values pulled in from the linker file
20.     16 */
21.     17 uint8 * data_ram, * data_rom, * data_rom_end;
22.     18 uint8 * bss_start, * bss_end;
23.
24.     19 /* Addresses for VECTOR_TABLE and VECTOR_RAM come from the linker file */
25.     20 extern uint32 __VECTOR_TABLE[];
26.     21 extern uint32 __VECTOR_RAM[];
27.
28.     22 /* Copy the vector table to RAM */
29.     23 if (__VECTOR_RAM != __VECTOR_TABLE)
30.     24 {
31.     25 for (n = 0; n < 0x410; n++)
32.     26 __VECTOR_RAM[n] = __VECTOR_TABLE[n];
33.     27 }
34.
35.     28 /* Point the VTOR to the new copy of the vector table */
36.     29 write_vtor((uint32)__VECTOR_RAM);
37.
38.     30 /* Get the addresses for the .data section (initialized data section) */
39.     31 data_ram = __section_begin(".data");
40.     32 data_rom = __section_begin(".data_init");
41.     33 data_rom_end = __section_end(".data_init");
42.     34 n = data_rom_end - data_rom;
43.
44.     35 /* Copy initialized data from ROM to RAM */
45.     36 while (n--)
46.     37 *data_ram++ = *data_rom++;
47.
48.     38 /* Get the addresses for the .bss section (zero-initialized data) */
49.     39 bss_start = __section_begin(".bss");
50.     40 bss_end = __section_end(".bss");
51.
52.     41 /* Clear the zero-initialized data section */
53.     42 n = bss_end - bss_start;
54.     43 while(n--)
55.     44 *bss_start++ = 0;
56.
57.     45 /* Get addresses for any code sections that need to be copied from ROM to RAM.
58.     46 * The IAR tools have a predefined keyword that can be used to mark individual
59.     47 * functions for execution from RAM. Add "__ramfunc" before the return type in
60.     48 * the function prototype for any routines you need to execute from RAM instead
61.     49 * of ROM. ex: __ramfunc void foo(void);
62.     50 */
63.     51 uint8* code_relocate_ram = __section_begin("CodeRelocateRam");
64.     52 uint8* code_relocate = __section_begin("CodeRelocate");
65.     53 uint8* code_relocate_end = __section_end("CodeRelocate");
66.
67.     54 /* Copy functions from ROM to RAM */
68.     55 n = code_relocate_end - code_relocate;
69.     56 while (n--)
70.     57 *code_relocate_ram++ = *code_relocate++;
71.     58 }

在IAR中, #pragma section="NAME" [align] 用来在C语言中指定一个名称是NAME的段，align指定对齐方式。指定的段可以被段操作符来引用，段操作符包括 __section_begin, __section_end, 和 __section_size.  个人理解.date、.date_init和.bss应该是IAR中保留的段名称，.date代表数据段中的常量，.date_init代表数据段中已初始化的变量，.bss代表未初始化的变量(zero)。

上面代码中，先是指定了5个不同名称的段(前3个是保留段名称，代表这些段是从这里开始的)，CodeRelocate和CodeRelocateRam是在*.icf文件中定义的块(block)：
define block CodeRelocate { section .textrw_init }; define block CodeRelocateRam { section .textrw };
quote:
The _
 _ramfunc keyword makes a function execute in RAM. Two code 
 sections will be created: one for the RAM execution (.textrw), and one for the ROM initialization (.textrw_init). 

外部变量引用
extern uint32 __VECTOR_TABLE[]; extern uint32 __VECTOR_RAM[];
来自IAR的链接文件（.icf），在.icf文件中已经定义了变量 __VECTOR_TABLE 和 __VECTOR_RAM 其值都是0x1fff0000."Copy the vector table to RAM"这段代码进行判断，如果向量表不在RAM中，则把向量表拷贝到RAM开始的地址上，这里由于在RAM中调试，代码是直接下载到RAM中的，所以不用拷贝。

向量表已经在RAM中了，接下来要重定向向量表，以便在发生异常时到RAM中取得异常入口地址（默认情况下是在0x0取）。  write_vtor((uint32)__VECTOR_RAM) 这个函数用来写向量表偏移寄存器（VTOR，地址0xE000_ED08），这里写入的是RAM起始地址0x1FFF0000。注意这个地址是有要求的，并不是所有地址都能作为向量表起始地址，0x1FFF0000满足要求（这个要求就是：必须先求出系统中共有多少个向量，再把这个数字向上增大到是 2 的整次幂，而起始地址必须对齐到后者的边界上。例如，如果一共有 32 个中断，则共有 32+16（系统异常）=48个向量，向上增大到 2的整次幂后值为 64，因此地址地址必须能被 64*4=256整除，从而合法的起始地址可以是：0x0,0x100,0x200 等----参见ARM Contex-M3权威指南）。另外，如果向量表在RAM区(相对于code区)，需把bit[29]置位，这里0x1FFF0000也满足要求。

后面的代码是拷贝数据到RAM中，搭建好C语言运行环境。

上次写了飞思卡尔官方给出的demo程序的启动流程的前面部分：

在存储器最前面放置好向量表-->把通用寄存器清零-->开中断-->跳转到start函数继续执行初始化。在start函数中，顺次执行三个函数：禁用看门狗-->初始化C语言环境（向量表重定向、拷贝数据段到RAM、清零bss段等）-->系统外设初始化。 
③系统外设初始化函数 sysinit()

1.#include "common.h"

2.#include "sysinit.h"

3.#include "uart.h"

4.

5./********************************************************************/

6.

7./* Actual system clock frequency */

8.int core_clk_khz;

9.int core_clk_mhz;

10.int periph_clk_khz;

11.

12./********************************************************************/

13.void sysinit (void)

14.{

15.        /*

16.         * Enable all of the port clocks. These have to be enabled to configure

17.         * pin muxing options, so most code will need all of these on anyway.

18.         */

19.        SIM_SCGC5 |= (SIM_SCGC5_PORTA_MASK

20.                      | SIM_SCGC5_PORTB_MASK

21.                      | SIM_SCGC5_PORTC_MASK

22.                      | SIM_SCGC5_PORTD_MASK

23.                      | SIM_SCGC5_PORTE_MASK );

24.

25.     /* Ramp up the system clock */

26.    core_clk_mhz = pll_init(CORE_CLK_MHZ, REF_CLK);

27.

28.    /*

29.         * Use the value obtained from the pll_init function to define variables

30.     * for the core clock in kHz and also the peripheral clock. These

31.     * variables can be used by other functions that need awareness of the

32.     * system frequency.

33.     */

34.    core_clk_khz = core_clk_mhz * 1000;

35.      periph_clk_khz = core_clk_khz / (((SIM_CLKDIV1 & SIM_CLKDIV1_OUTDIV2_MASK) >> 24)+ 1);

36.

37.      /* For debugging purposes, enable the trace clock and/or FB_CLK so that

38.       * we'll be able to monitor clocks and know the PLL is at the frequency

39.       * that we expect.

40.       */

41.    trace_clk_init();

42.      fb_clk_init();

43.

44.      /* Enable the pins for the selected UART */

45.         if (TERM_PORT == UART0_BASE_PTR)

46.         {

47.            /* Enable the UART0_TXD function on PTD6 */

48.            PORTD_PCR6 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

49.

50.            /* Enable the UART0_RXD function on PTD7 */

51.            PORTD_PCR7 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

52.         }

53.

54.         if (TERM_PORT == UART1_BASE_PTR)

55.       {

56.                 /* Enable the UART1_TXD function on PTC4 */

57.          PORTC_PCR4 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

58.

59.          /* Enable the UART1_RXD function on PTC3 */

60.          PORTC_PCR3 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

61.      }

62.

63.      if (TERM_PORT == UART2_BASE_PTR)

64.      {

65.                 /* Enable the UART2_TXD function on PTD3 */

66.          PORTD_PCR3 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

67.

68.          /* Enable the UART2_RXD function on PTD2 */

69.          PORTD_PCR2 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

70.      }

71.

72.      if (TERM_PORT == UART3_BASE_PTR)

73.      {

74.                 /* Enable the UART3_TXD function on PTC17 */

75.          PORTC_PCR17 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

76.

77.          /* Enable the UART3_RXD function on PTC16 */

78.          PORTC_PCR16 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

79.      }

80.      if (TERM_PORT == UART4_BASE_PTR)

81.      {

82.                 /* Enable the UART3_TXD function on PTC17 */

83.          PORTE_PCR24 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

84.

85.          /* Enable the UART3_RXD function on PTC16 */

86.          PORTE_PCR25 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

87.      }

88.      if (TERM_PORT == UART5_BASE_PTR)

89.      {

90.                 /* Enable the UART3_TXD function on PTC17 */

91.          PORTE_PCR8 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

92.

93.          /* Enable the UART3_RXD function on PTC16 */

94.          PORTE_PCR9 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

95.      }

96.      /* UART0 and UART1 are clocked from the core clock, but all other UARTs are

97.         * clocked from the peripheral clock. So we have to determine which clock

98.         * to send to the uart_init function.

99.         */

100.        if ((TERM_PORT == UART0_BASE_PTR) | (TERM_PORT == UART1_BASE_PTR))

101.            uart_init (TERM_PORT, core_clk_khz, TERMINAL_BAUD);

102.        else

103.       uart_init (TERM_PORT, periph_clk_khz, TERMINAL_BAUD);

104.}

105./********************************************************************/

106.void trace_clk_init(void)

107.{

108.    /* Set the trace clock to the core clock frequency */

109.    SIM_SOPT2 |= SIM_SOPT2_TRACECLKSEL_MASK;

110.

111.    /* Enable the TRACE_CLKOUT pin function on PTA6 (alt7 function) */

112.    PORTA_PCR6 = ( PORT_PCR_MUX(0x7));

113.}

114./********************************************************************/

115.void fb_clk_init(void)

116.{

117.    /* Enable the clock to the FlexBus module */

118.        SIM_SCGC7 |= SIM_SCGC7_FLEXBUS_MASK;

119.

120.     /* Enable the FB_CLKOUT function on PTC3 (alt5 function) */

121.    PORTC_PCR3 = ( PORT_PCR_MUX(0x5));

122.}

123./********************************************************************/

首先写SIM_SCGC5寄存器。SCGC5表示的是System Clock Gating Control Register 5（系统时钟门控制寄存器5）.系统集成模块 --System integration module (SIM)--控制寄存器组中共有8个SCGC寄存器，它们分别控制不同外设所需要的时钟的开关，SCGC5寄存器控制的是PORTA~PORTE、TSI、REGFILE和LPTIMER时钟的开关，向对应的位写入1表示使能时钟。第一段代码分别打开了PORTA~PORTE的时钟开关。

上面pll_init（unsigned char,unsigned char）函数用来增加系统时钟。

1.unsigned char pll_init(unsigned char clk_option, unsigned char crystal_val)

2.{

3.  unsigned char pll_freq;

4.

5.  if (clk_option > 3) {return 0;} //return 0 if one of the available options is not selected

6.  if (crystal_val > 15) {return 1;} // return 1 if one of the available crystal options is not available

7.//This assumes that the MCG is in default FEI mode out of reset.

8.

9.// First move to FBE mode

10.#if (defined(K60_CLK) || defined(ASB817))

11.     MCG_C2 = 0;

12.#else

13.// Enable external oscillator, RANGE=2, HGO=1, EREFS=1, LP=0, IRCS=0

14.    MCG_C2 = MCG_C2_RANGE(2) | MCG_C2_HGO_MASK | MCG_C2_EREFS_MASK;

15.#endif

16.

17.// after initialization of oscillator release latched state of oscillator and GPIO

18.    SIM_SCGC4 |= SIM_SCGC4_LLWU_MASK;

19.    LLWU_CS |= LLWU_CS_ACKISO_MASK;

20. 

21.// Select external oscilator and Reference Divider and clear IREFS to start ext osc

22.// CLKS=2, FRDIV=3, IREFS=0, IRCLKEN=0, IREFSTEN=0

23.  MCG_C1 = MCG_C1_CLKS(2) | MCG_C1_FRDIV(3);

24.

25.  /* if we aren't using an osc input we don't need to wait for the osc to init */

26.#if (!defined(K60_CLK) && !defined(ASB817))

27.    while (!(MCG_S & MCG_S_OSCINIT_MASK)){}; // wait for oscillator to initialize

28.#endif

29.

30.  while (MCG_S & MCG_S_IREFST_MASK){}; // wait for Reference clock Status bit to clear

31.

32.  while (((MCG_S & MCG_S_CLKST_MASK) >> MCG_S_CLKST_SHIFT) != 0x2){}; // Wait for clock status bits to show clock source is ext ref clk

33.

34.// Now in FBE

35.

36.#if (defined(K60_CLK))

37.   MCG_C5 = MCG_C5_PRDIV(0x18);

38.#else

39.// Configure PLL Ref Divider, PLLCLKEN=0, PLLSTEN=0, PRDIV=5

40.// The crystal frequency is used to select the PRDIV value. Only even frequency crystals are supported

41.// that will produce a 2MHz reference clock to the PLL.

42.  MCG_C5 = MCG_C5_PRDIV(crystal_val); // Set PLL ref divider to match the crystal used

43.#endif

44.

45.  // Ensure MCG_C6 is at the reset default of 0. LOLIE disabled, PLL disabled, clk monitor disabled, PLL VCO divider is clear

46.  MCG_C6 = 0x0;

47.// Select the PLL VCO divider and system clock dividers depending on clocking option

48.  switch (clk_option) {

49.    case 0:

50.      // Set system options dividers

51.      //MCG=PLL, core = MCG, bus = MCG, FlexBus = MCG, Flash clock= MCG/2

52.      set_sys_dividers(0,0,0,1);

53.      // Set the VCO divider and enable the PLL for 50MHz, LOLIE=0, PLLS=1, CME=0, VDIV=1

54.      MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(1); //VDIV = 1 (x25)

55.      pll_freq = 50;

56.      break;

57.   case 1:

58.      // Set system options dividers

59.      //MCG=PLL, core = MCG, bus = MCG/2, FlexBus = MCG/2, Flash clock= MCG/4

60.     set_sys_dividers(0,1,1,3);

61.      // Set the VCO divider and enable the PLL for 100MHz, LOLIE=0, PLLS=1, CME=0, VDIV=26

62.      MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(26); //VDIV = 26 (x50)

63.      pll_freq = 100;

64.      break;

65.    case 2:

66.      // Set system options dividers

67.      //MCG=PLL, core = MCG, bus = MCG/2, FlexBus = MCG/2, Flash clock= MCG/4

68.      set_sys_dividers(0,1,1,3);

69.      // Set the VCO divider and enable the PLL for 96MHz, LOLIE=0, PLLS=1, CME=0, VDIV=24

70.      MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(24); //VDIV = 24 (x48)

71.      pll_freq = 96;

72.      break;

73.   case 3:

74.      // Set system options dividers

75.      //MCG=PLL, core = MCG, bus = MCG, FlexBus = MCG, Flash clock= MCG/2

76.      set_sys_dividers(0,0,0,1);

77.      // Set the VCO divider and enable the PLL for 48MHz, LOLIE=0, PLLS=1, CME=0, VDIV=0

78.      MCG_C6 = MCG_C6_PLLS_MASK; //VDIV = 0 (x24)

79.      pll_freq = 48;

80.      break;

81.  }

82.  while (!(MCG_S & MCG_S_PLLST_MASK)){}; // wait for PLL status bit to set

83.

84.  while (!(MCG_S & MCG_S_LOCK_MASK)){}; // Wait for LOCK bit to set

85.

86.// Now running PBE Mode

87.

88.// Transition into PEE by setting CLKS to 0

89.// CLKS=0, FRDIV=3, IREFS=0, IRCLKEN=0, IREFSTEN=0

90.  MCG_C1 &= ~MCG_C1_CLKS_MASK;

91.

92.// Wait for clock status bits to update

93.  while (((MCG_S & MCG_S_CLKST_MASK) >> MCG_S_CLKST_SHIFT) != 0x3){};

94.

95.// Now running PEE Mode

96.

97.return pll_freq;

98.} //pll_init

这个函数中两个参数clk_option和crystal_val是两个枚举变量（enum），从它们的定义来看它们的取值范围是0~3和0~15.所以函数开始先进行有效性判断。

MCG表示的是 Multipurpose Clock Generator（多用途时钟发生器）.MCG模块向MCU提供几个时钟源选择。这个模块包含了一个 frequency-locked loop (FLL)和一个 phase-locked loop (PLL).FLL可以通过内部的或外部的参考时钟源来控制，PLL可以通过外部参考时钟来控制。模块可以选择FLL或PLL的输出时钟或者内部或外部时钟源作为MCU的系统时钟。上面MCG_2指的是 MCG Control 2 Register. MCG一共有9种操作模式：FEI, FEE, FBI, FBE, PBE, PEE, BLPI,BLPE,and Stop. 不同运行模式的功耗互不相同，要进入各个模式需要写MCG_1~MCG_6寄存器组中某几个寄存器中的某几个位。  我们可以这样说，采用内部组件的模式所消耗的功率少于采用外部组件的模式。而MCG包括两种专门为低功率应用设计的模式——旁通低功耗内部（BLPI）和旁通低功耗外部（BLPE）。驱动BLPI模式的总线频率要比BLPE 模式低，因此BLPI 模式消耗的功率最小。下图2总结了每一种运行模式的功耗。

在sysinit()函数中对pll_init(unsigned char,unsigned char)函数的引用包含两个参数：CORE_CLK_MHZ和REF_CLK，从其定义可以看出其值分别为PLL96和XTAL8，分别代表2和3.K60_CLK 被定义为1.因此，在引用pll_init(unsigned char,unsigned char)函数时根据条件编译，执行的语句依次是：

1.// First move to FBE mode

2.MCG_C2 = 0;

3.

4.// after initialization of oscillator release latched state of oscillator and GPIO

5.    SIM_SCGC4 |= SIM_SCGC4_LLWU_MASK;

6.    LLWU_CS |= LLWU_CS_ACKISO_MASK;

7.

8.// Select external oscilator and Reference Divider and clear IREFS to start ext osc

9.// CLKS=2, FRDIV=3, IREFS=0, IRCLKEN=0, IREFSTEN=0

10.  MCG_C1 = MCG_C1_CLKS(2) | MCG_C1_FRDIV(3);

11.

12.// wait for Reference clock Status bit to clear

13.while (MCG_S & MCG_S_IREFST_MASK){};

14.

15.// Wait for clock status bits to show clock source is ext ref clk

16.while (((MCG_S & MCG_S_CLKST_MASK) >> MCG_S_CLKST_SHIFT) != 0x2){};

17.

18.MCG_C5 = MCG_C5_PRDIV(0x18);

19.

20./* Ensure MCG_C6 is at the reset default of 0. LOLIE disabled, PLL disabled, clk monitor disabled, PLL VCO divider is clear*/

21.  MCG_C6 = 0x0;

22.

23.// Set system options dividers

24.//MCG=PLL, core = MCG, bus = MCG/2, FlexBus = MCG/2, Flash clock= MCG/4

25.   set_sys_dividers(0,1,1,3);

26.// Set the VCO divider and enable the PLL for 96MHz, LOLIE=0, PLLS=1, CME=0, VDIV=24

27.      MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(24); //VDIV = 24 (x48)

28.      pll_freq = 96;

29.

30.while (!(MCG_S & MCG_S_PLLST_MASK)){}; // wait for PLL status bit to set

31.

32.  while (!(MCG_S & MCG_S_LOCK_MASK)){}; // Wait for LOCK bit to set

33.

34.// Now running PBE Mode

35.

36.// Transition into PEE by setting CLKS to 0

37.// CLKS=0, FRDIV=3, IREFS=0, IRCLKEN=0, IREFSTEN=0

38.  MCG_C1 &= ~MCG_C1_CLKS_MASK;

39.

40.// Wait for clock status bits to update

41.  while (((MCG_S & MCG_S_CLKST_MASK) >> MCG_S_CLKST_SHIFT) != 0x3){};

42.

43.// Now running PEE Mode

44.

45.return pll_freq;

最后，系统运行在PEE模式下。