IAR中cortex-m4启动流程分析

软件环境: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链接脚本文件。


这个文件中前面部分是各个变量的定义,关键看后面部分:

  • /*128KB_Ram.icf后面部分*/
  • ***********
  • place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec };
  • place at address mem:__code_start__ { readonly section .noinit };
  • place in RAM_region { readonly, block CodeRelocate };
  • place in RAM_region { readwrite, block CodeRelocateRam,
  • block CSTACK, block HEAP };
  • ************



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

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

  • /*vectors.c片段*/

  • typedef void (*vector_entry)(void);
  •     #pragma location = ".intvec"
  •     const vector_entry __vector_table[] = //@ ".intvec" =
  • {
  •   VECTOR_000, /* Initial SP */
  •   VECTOR_001, /* Initial PC */
  •   VECTOR_002,
  •   VECTOR_003,
  •   ......(中间省略)
  •   VECTOR_254,
  •   VECTOR_255,
  •   CONFIG_1,
  •   CONFIG_2,
  •   CONFIG_3,
  •   CONFIG_4,
  • };



从源文件中可以看到这里定义了一个向量表__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汇编文件中出现:


  • SECTION .noinit : CODE

  • EXPORT __startup
  • __startup

  • MOV r0,#0 ; Initialize the GPRs

  • MOV r1,#0

  • MOV r2,#0

  • MOV r3,#0

  • MOV r4,#0

  • MOV r5,#0

  • MOV r6,#0

  • MOV r7,#0

  • MOV r8,#0

  • MOV r9,#0

  • MOV r10,#0

  • MOV r11,#0

  • MOV r12,#0

  • CPSIE i ; Unmask interrupts

  • import start

  • BL start ; call the C code
  • __done

  • B __done

  • END



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



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



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



  • /*start.c片段*/
  • void start(void)
  • {
  •     /* Disable the watchdog timer */
  •     wdog_disable();
  •     /* Copy any vector or data sections that need to be in RAM */
  •     common_startup();
  •     /* Perform processor initialization */
  •     sysinit();
  •     printf("\n\n");
  •     /* Determine the last cause(s) of reset */
  •     if (MC_SRSH & MC_SRSH_SW_MASK)
  •         printf("Software Reset\n");
  •     if (MC_SRSH & MC_SRSH_LOCKUP_MASK)
  •         printf("Core Lockup Event Reset\n");
  •     if (MC_SRSH & MC_SRSH_JTAG_MASK)
  •         printf("JTAG Reset\n");
  •     if (MC_SRSL & MC_SRSL_POR_MASK)
  •         printf("Power-on Reset\n");
  •     if (MC_SRSL & MC_SRSL_PIN_MASK)
  •         printf("External Pin Reset\n");
  •     if (MC_SRSL & MC_SRSL_COP_MASK)
  •         printf("Watchdog(COP) Reset\n");
  •     if (MC_SRSL & MC_SRSL_LOC_MASK)
  •         printf("Loss of Clock Reset\n");
  •     if (MC_SRSL & MC_SRSL_LVD_MASK)
  •         printf("Low-voltage Detect Reset\n");
  •     if (MC_SRSL & MC_SRSL_WAKEUP_MASK)
  •         printf("LLWU Reset\n");
  •     /* Determine specific Kinetis device and revision */
  •     cpu_identify();
  •     /* Jump to main process */
  •     main();
  •     /* No actions to perform after this so wait forever */
  •     while(1);
  • }



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

①wdog_disable()


对系统的设定无非是对各个寄存器值的修改。wdog_disable()函数在wdog.c文件中

  • /*wdog.c片段*/
  • void wdog_disable(void)
  • {
  •     /* First unlock the watchdog so that we can write to registers */
  •     wdog_unlock();
  •     /* Clear the WDOGEN bit to disable the watchdog */
  •     WDOG_STCTRLH &= ~WDOG_STCTRLH_WDOGEN_MASK;
  • }

  • void wdog_unlock(void)
  • {
  •   /* NOTE: DO NOT SINGLE STEP THROUGH THIS */
  •   /* There are timing requirements for the execution of the unlock. If
  •   * you single step through the code you will cause the CPU to reset.
  •   */
  •     /* This sequence must execute within 20 clock cycles, so disable
  •         * interrupts will keep the code atomic and ensure the timing.
  •         */
  •         DisableInterrupts;
  •     /* Write 0xC520 to the unlock register */
  •     WDOG_UNLOCK = 0xC520;
  •     /* Followed by 0xD928 to complete the unlock */
  •     WDOG_UNLOCK = 0xD928;
  •     /* Re-enable interrupts now that we are done */
  •           EnableInterrupts;
  • }



禁用看门狗流程很简单:先是解锁寄存器,然后更改看门狗寄存器里面的值来禁用看门狗。解锁看门狗寄存器:向解锁寄存器里连续写入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 /* File: startup.*/
  •     2 #include "common.h"
  •     3 #pragma section = ".data"
  •     4 #pragma section = ".data_init"
  •     5 #pragma section = ".bss"
  •     6 #pragma section = "CodeRelocate"
  •     7 #pragma section = "CodeRelocateRam"
  •     8 /********************************************************************/
  •     9 void
  •     10 common_startup(void)
  •     11 {
  •     12 /* Declare a counter we'll use in all of the copy loops */
  •     13 uint32 n;
  •     14 /* Declare pointers for various data sections. These pointers
  •     15 * are initialized using values pulled in from the linker file
  •     16 */
  •     17 uint8 * data_ram, * data_rom, * data_rom_end;
  •     18 uint8 * bss_start, * bss_end;
  •     19 /* Addresses for VECTOR_TABLE and VECTOR_RAM come from the linker file */
  •     20 extern uint32 __VECTOR_TABLE[];
  •     21 extern uint32 __VECTOR_RAM[];
  •     22 /* Copy the vector table to RAM */
  •     23 if (__VECTOR_RAM != __VECTOR_TABLE)
  •     24 {
  •     25 for (= 0; n < 0x410; n++)
  •     26 __VECTOR_RAM[n] = __VECTOR_TABLE[n];
  •     27 }
  •     28 /* Point the VTOR to the new copy of the vector table */
  •     29 write_vtor((uint32)__VECTOR_RAM);
  •     30 /* Get the addresses for the .data section (initialized data section) */
  •     31 data_ram = __section_begin(".data");
  •     32 data_rom = __section_begin(".data_init");
  •     33 data_rom_end = __section_end(".data_init");
  •     34 n = data_rom_end - data_rom;
  •     35 /* Copy initialized data from ROM to RAM */
  •     36 while (n--)
  •     37 *data_ram++ = *data_rom++;
  •     38 /* Get the addresses for the .bss section (zero-initialized data) */
  •     39 bss_start = __section_begin(".bss");
  •     40 bss_end = __section_end(".bss");
  •     41 /* Clear the zero-initialized data section */
  •     42 n = bss_end - bss_start;
  •     43 while(n--)
  •     44 *bss_start++ = 0;
  •     45 /* Get addresses for any code sections that need to be copied from ROM to RAM.
  •     46 * The IAR tools have a predefined keyword that can be used to mark individual
  •     47 * functions for execution from RAM. Add "__ramfunc" before the return type in
  •     48 * the function prototype for any routines you need to execute from RAM instead
  •     49 * of ROM. ex: __ramfunc void foo(void);
  •     50 */
  •     51 uint8* code_relocate_ram = __section_begin("CodeRelocateRam");
  •     52 uint8* code_relocate = __section_begin("CodeRelocate");
  •     53 uint8* code_relocate_end = __section_end("CodeRelocate");
  •     54 /* Copy functions from ROM to RAM */
  •     55 n = code_relocate_end - code_relocate;
  •     56 while (n--)
  •     57 *code_relocate_ram++ = *code_relocate++;
  •     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. /* Actual system clock frequency */
  6. int core_clk_khz;
  7. int core_clk_mhz;
  8. int periph_clk_khz;

  9. /********************************************************************/
  10. void sysinit (void)
  11. {
  12.         /*
  13.          * Enable all of the port clocks. These have to be enabled to configure
  14.          * pin muxing options, so most code will need all of these on anyway.
  15.          */
  16.         SIM_SCGC5 |= (SIM_SCGC5_PORTA_MASK
  17.                       | SIM_SCGC5_PORTB_MASK
  18.                       | SIM_SCGC5_PORTC_MASK
  19.                       | SIM_SCGC5_PORTD_MASK
  20.                       | SIM_SCGC5_PORTE_MASK );

  21.      /* Ramp up the system clock */
  22.     core_clk_mhz = pll_init(CORE_CLK_MHZ, REF_CLK);

  23.     /*
  24.          * Use the value obtained from the pll_init function to define variables
  25.      * for the core clock in kHz and also the peripheral clock. These
  26.      * variables can be used by other functions that need awareness of the
  27.      * system frequency.
  28.      */
  29.     core_clk_khz = core_clk_mhz * 1000;
  30.       periph_clk_khz = core_clk_khz / (((SIM_CLKDIV1 & SIM_CLKDIV1_OUTDIV2_MASK) >> 24)+ 1);

  31.       /* For debugging purposes, enable the trace clock and/or FB_CLK so that
  32.        * we'll be able to monitor clocks and know the PLL is at the frequency
  33.        * that we expect.
  34.        */
  35.     trace_clk_init();
  36.       fb_clk_init();

  37.       /* Enable the pins for the selected UART */
  38.          if (TERM_PORT == UART0_BASE_PTR)
  39.          {
  40.             /* Enable the UART0_TXD function on PTD6 */
  41.             PORTD_PCR6 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

  42.             /* Enable the UART0_RXD function on PTD7 */
  43.             PORTD_PCR7 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin
  44.          }

  45.          if (TERM_PORT == UART1_BASE_PTR)
  46.        {
  47.                  /* Enable the UART1_TXD function on PTC4 */
  48.           PORTC_PCR4 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

  49.           /* Enable the UART1_RXD function on PTC3 */
  50.           PORTC_PCR3 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin
  51.       }

  52.       if (TERM_PORT == UART2_BASE_PTR)
  53.       {
  54.                  /* Enable the UART2_TXD function on PTD3 */
  55.           PORTD_PCR3 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

  56.           /* Enable the UART2_RXD function on PTD2 */
  57.           PORTD_PCR2 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin
  58.       }

  59.       if (TERM_PORT == UART3_BASE_PTR)
  60.       {
  61.                  /* Enable the UART3_TXD function on PTC17 */
  62.           PORTC_PCR17 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

  63.           /* Enable the UART3_RXD function on PTC16 */
  64.           PORTC_PCR16 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin
  65.       }
  66.       if (TERM_PORT == UART4_BASE_PTR)
  67.       {
  68.                  /* Enable the UART3_TXD function on PTC17 */
  69.           PORTE_PCR24 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

  70.           /* Enable the UART3_RXD function on PTC16 */
  71.           PORTE_PCR25 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin
  72.       }
  73.       if (TERM_PORT == UART5_BASE_PTR)
  74.       {
  75.                  /* Enable the UART3_TXD function on PTC17 */
  76.           PORTE_PCR8 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin

  77.           /* Enable the UART3_RXD function on PTC16 */
  78.           PORTE_PCR9 = PORT_PCR_MUX(0x3); // UART is alt3 function for this pin
  79.       }
  80.       /* UART0 and UART1 are clocked from the core clock, but all other UARTs are
  81.          * clocked from the peripheral clock. So we have to determine which clock
  82.          * to send to the uart_init function.
  83.          */
  84.         if ((TERM_PORT == UART0_BASE_PTR) | (TERM_PORT == UART1_BASE_PTR))
  85.             uart_init (TERM_PORT, core_clk_khz, TERMINAL_BAUD);
  86.         else
  87.        uart_init (TERM_PORT, periph_clk_khz, TERMINAL_BAUD);
  88. }
  89. /********************************************************************/
  90. void trace_clk_init(void)
  91. {
  92.     /* Set the trace clock to the core clock frequency */
  93.     SIM_SOPT2 |= SIM_SOPT2_TRACECLKSEL_MASK;

  94.     /* Enable the TRACE_CLKOUT pin function on PTA6 (alt7 function) */
  95.     PORTA_PCR6 = ( PORT_PCR_MUX(0x7));
  96. }
  97. /********************************************************************/
  98. void fb_clk_init(void)
  99. {
  100.     /* Enable the clock to the FlexBus module */
  101.         SIM_SCGC7 |= SIM_SCGC7_FLEXBUS_MASK;

  102.      /* Enable the FB_CLKOUT function on PTC3 (alt5 function) */
  103.     PORTC_PCR3 = ( PORT_PCR_MUX(0x5));
  104. }
  105. /********************************************************************/
首先写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.   if (clk_option > 3) {return 0;} //return 0 if one of the available options is not selected
  5.   if (crystal_val > 15) {return 1;} // return 1 if one of the available crystal options is not available
  6. //This assumes that the MCG is in default FEI mode out of reset.

  7. // First move to FBE mode
  8. #if (defined(K60_CLK) || defined(ASB817))
  9.      MCG_C2 = 0;
  10. #else
  11. // Enable external oscillator, RANGE=2, HGO=1, EREFS=1, LP=0, IRCS=0
  12.     MCG_C2 = MCG_C2_RANGE(2) | MCG_C2_HGO_MASK | MCG_C2_EREFS_MASK;
  13. #endif

  14. // after initialization of oscillator release latched state of oscillator and GPIO
  15.     SIM_SCGC4 |= SIM_SCGC4_LLWU_MASK;
  16.     LLWU_CS |= LLWU_CS_ACKISO_MASK;
  17.   
  18. // Select external oscilator and Reference Divider and clear IREFS to start ext osc
  19. // CLKS=2, FRDIV=3, IREFS=0, IRCLKEN=0, IREFSTEN=0
  20.   MCG_C1 = MCG_C1_CLKS(2) | MCG_C1_FRDIV(3);

  21.   /* if we aren't using an osc input we don't need to wait for the osc to init */
  22. #if (!defined(K60_CLK) && !defined(ASB817))
  23.     while (!(MCG_S & MCG_S_OSCINIT_MASK)){}; // wait for oscillator to initialize
  24. #endif

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

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

  27. // Now in FBE

  28. #if (defined(K60_CLK))
  29.    MCG_C5 = MCG_C5_PRDIV(0x18);
  30. #else
  31. // Configure PLL Ref Divider, PLLCLKEN=0, PLLSTEN=0, PRDIV=5
  32. // The crystal frequency is used to select the PRDIV value. Only even frequency crystals are supported
  33. // that will produce a 2MHz reference clock to the PLL.
  34.   MCG_C5 = MCG_C5_PRDIV(crystal_val); // Set PLL ref divider to match the crystal used
  35. #endif

  36.   // Ensure MCG_C6 is at the reset default of 0. LOLIE disabled, PLL disabled, clk monitor disabled, PLL VCO divider is clear
  37.   MCG_C6 = 0x0;
  38. // Select the PLL VCO divider and system clock dividers depending on clocking option
  39.   switch (clk_option) {
  40.     case 0:
  41.       // Set system options dividers
  42.       //MCG=PLL, core = MCG, bus = MCG, FlexBus = MCG, Flash clock= MCG/2
  43.       set_sys_dividers(0,0,0,1);
  44.       // Set the VCO divider and enable the PLL for 50MHz, LOLIE=0, PLLS=1, CME=0, VDIV=1
  45.       MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(1); //VDIV = 1 (x25)
  46.       pll_freq = 50;
  47.       break;
  48.    case 1:
  49.       // Set system options dividers
  50.       //MCG=PLL, core = MCG, bus = MCG/2, FlexBus = MCG/2, Flash clock= MCG/4
  51.      set_sys_dividers(0,1,1,3);
  52.       // Set the VCO divider and enable the PLL for 100MHz, LOLIE=0, PLLS=1, CME=0, VDIV=26
  53.       MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(26); //VDIV = 26 (x50)
  54.       pll_freq = 100;
  55.       break;
  56.     case 2:
  57.       // Set system options dividers
  58.       //MCG=PLL, core = MCG, bus = MCG/2, FlexBus = MCG/2, Flash clock= MCG/4
  59.       set_sys_dividers(0,1,1,3);
  60.       // Set the VCO divider and enable the PLL for 96MHz, LOLIE=0, PLLS=1, CME=0, VDIV=24
  61.       MCG_C6 = MCG_C6_PLLS_MASK | MCG_C6_VDIV(24); //VDIV = 24 (x48)
  62.       pll_freq = 96;
  63.       break;
  64.    case 3:
  65.       // Set system options dividers
  66.       //MCG=PLL, core = MCG, bus = MCG, FlexBus = MCG, Flash clock= MCG/2
  67.       set_sys_dividers(0,0,0,1);
  68.       // Set the VCO divider and enable the PLL for 48MHz, LOLIE=0, PLLS=1, CME=0, VDIV=0
  69.       MCG_C6 = MCG_C6_PLLS_MASK; //VDIV = 0 (x24)
  70.       pll_freq = 48;
  71.       break;
  72.   }
  73.   while (!(MCG_S & MCG_S_PLLST_MASK)){}; // wait for PLL status bit to set

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

  75. // Now running PBE Mode

  76. // Transition into PEE by setting CLKS to 0
  77. // CLKS=0, FRDIV=3, IREFS=0, IRCLKEN=0, IREFSTEN=0
  78.   MCG_C1 &= ~MCG_C1_CLKS_MASK;

  79. // Wait for clock status bits to update
  80.   while (((MCG_S & MCG_S_CLKST_MASK) >> MCG_S_CLKST_SHIFT) != 0x3){};

  81. // Now running PEE Mode

  82. return pll_freq;
  83. } //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总结了每一种运行模式的功耗。

你可能感兴趣的:(IAR中cortex-m4启动流程分析)