EFM32G232F64時鐘樹
1.為了熟悉MCU的時鐘樹，先看看EFM32G232F64的CMU（ClockManagementUnit）
時鐘管理單元（CMU）用於管控晶振（時鐘源）和各個時鐘節點。出於降低功耗和啟動時間的目的，EFM32G的時鐘源支持數個不同規格的晶振。另外還有一個獨立的RC振蕩器用於燒寫Flash和調試。當然，時鐘管理單元也從硬件級別上支持RC振蕩器的校準。
晶振和系統時鐘樹，對於降低MCU的系統功耗有巨大意義。有了低功耗的晶振再結合彈性的時鐘控制策略，就可以在各種應用場合下降低功耗。不使用的外設就關掉它的時鐘源以節能。
時鐘管理單元，能夠配置選擇不同的時鐘源，使能和失能單個時鐘分支和所有外設的時鐘源，還能為不同的時鐘分支設置預分頻系數。短的晶振啟動時間使得從非低功耗模式（active）到低功耗模式（EM2~EM4）的占空比變得非常高效。RC震蕩校準特性保證了其高精度的RC震蕩頻率。
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO); //使能時鐘分支
CMU_ClockEnable(cmuClock_LEUART0, true); //使能某個外設的時鐘
1.1邏輯圖
1.2 實際圖
2.
從公司的硬件工程師那裏得知，項目的PCB原理圖上只外接了32.768KHz的低速晶振到15和16腳，那個13.56MHz的晶振不是給EFM32G232F64用的，而是給射頻芯片THM3070射頻芯片用的。所以，可以推測，EFM32G還是用了內部自帶的高速時鐘源。
2.1 從代碼裏找時鐘樹的配置細節
找時鐘樹配置是從公司的某個項目代碼中找的。參考了以下博文，沒有明顯發現，但是博文還是值得一看。
2.2 CMU外設庫函數 - CMU_ClockSelectSet
void CMU_ClockSelectSet(CMU_Clock_TypeDef clock, CMU_Select_TypeDef ref)中，clock是時鐘分支，ref是外界的時鐘輸入源。
《EMF32G-RM》page97上說，默認HFCLK分支的時鐘來源選擇HFRCO，但是在多數應用時，推薦使用高頻晶振，可以修改 HFCLKSEL in CMU_CMD（寄存器）去配置HFCLK的時鐘源。
也就是說，在為各個時鐘分支選好時鐘源之後，剩下的就是配置各個時鐘分支的分頻系數了。這裏沒有發現PLL。選擇時鐘源使用函數CMU_ClockSelectSet。
補充：
周立功的資料上說，默認所有的外設時鐘都是關閉的。
2. 常見問題解答
2.1 EFM32 系列MCU
1. 當我向某個控制寄存器寫入數據然後讀此寄存器，發現全部是 0，不知是什麽原
因？
A：默認情況下， EFM32 系列 MCU 內部外設的時鐘都是關閉的。如果要設置某個外設
的 寄 存 器 ， 必 須 先 通 過 CMU_HFPERCLKEN0 、 HFCORECLKEN0 、 LFACLKEN 或
LFBCLKEN 來使能相關外設的時鐘。若使用低頻外設，還需在 CMU_HFCORECLKEN0 寄
存器中使能 LE 時鐘。
附錄
[轉發]在main()之前，IAR都做了啥？
【原文鏈接】http://www.cnblogs.com/mssql/archive/2011/01/29/tt146.html
最近要在Cortex-M3上寫一個簡單的操作系統，打算使用IAR，為了寫好啟動代碼，花了一些時間了解了IAR在main()以前做了些什麽事。
首先系統復位時，Cortex-M3從代碼區偏移0x0000‘0000處獲取棧頂地址，用來初始化MSP寄存器的值。
接下來從代碼區偏移0x0000‘0004獲取第一個指令的跳轉地址。這些地址，是CM3要求放置中斷向量表的地方。
這裏是一個程序的啟動區的反匯編：
__vector_table:
08004000 2600
08004002 2000
08004004 7E1D
08004006 0800
這個程序是由IAP程序來啟動的，IAP程序獲取0x0800‘4000處的MSP值(0x20002600)，並設置為MSP的值，即主堆棧最大範圍是0x2000‘0000~0x2000‘25FF。接下來IAP程序獲取0x0800‘4004處的Reset_Handler的地址(0x0800‘7E1D)，並跳轉到Reset_Handler()執行。
IAP在這裏完全是模仿了Cortex-M3的復位序列，也就是說，在沒有IAP的系統上，CM3只能從0x0800‘0000獲取MSP，從0x0800‘0004獲取第一條指令所處地址。而IAP就存在在0x0800‘0000這個地址上，IAP的啟動，已經消耗掉了這個復位序列，所以IAP要啟動UserApp程序的時候，也是完全模仿Cortex-M3的復位序列的。
接下來我們看看復位後第一句指令——Reset_Handler()函數裏有什麽。
若我們使用的是ST公司標準外設庫，那麽已經有了現成的Reset_Handler，不過他是弱定義——PUBWEAK，可以被我們重寫的同名函數覆蓋。一般來說，我們使用的都是ST提供的Reset_Handler，在V3.4版本的庫中，可以在startup_stm32f10x_xx.s中找到這個函數：
PUBWEAK Reset_Handler
SECTION .text:CODE:REORDER(2)
Reset_Handler
LDR R0, =SystemInit
BLX R0
LDR R0, =__iar_program_start
BX R0
看來ST沒有做太多的事，他只調用了自家庫提供的SystemInit函數進行系統時鐘、Flash讀取的初始化，並把大權交給了__iar_program_start這個IAR提供的“內部函數”了，我們就跟緊這個__iar_program_start跳轉，看看IAR做了什麽，上面一段代碼的反匯編如下：
Reset_Handler:
__iar_section$$root:
08007E1C 4801 LDR R0, [PC, #0x4]; LDR R0, =SystemInit
08007E1E 4780 BLX R0;BLX R0
08007E20 4801 LDR R0, [PC, #0x4];LDR R0, =__iar_program_start
08007E22 4700 BX R0;BX R0
08007E24 6C69
08007E26 0800
08007E28 7D8D
08007E2A 0800
細心的觀眾會發現地址是0x0800‘7E1C，比我們查到的0x0800‘7E1D差了1，這是ARM家族的遺留問題，因為ARM處理器的指令至少是半字對齊的(16位THUMB指令集 or 32位ARM指令集)，所以PC指針的LSB是常為0的，為了充分利用寄存器，ARM公司給PC的LSB了一個重要的使命，那就是在執行分支跳轉時，PC的LSB=1，表示使用THUMB模式，LSB=0，表示使用ARM模式，但在最新的Cortex-M3內核上，只使用了THUMB-2指令集挑大梁，所以這一位要常保持1，所以我們查到的地址是0x0800‘7E1D(C=1100,D=1101)，放心，我們的CM3內核會忽略掉LSB(除非為0，那麽會引起一個fault)，從而正確跳轉到0x0800‘7E1C。
從0x0800‘7E20處的加載指令，我們可以算出__iar_program_start所處的位置，就是當前PC指針(0x0800‘7E24)，再加上4，即0x0800‘7E28處的所指向的地址——0x0800‘7D8D(0x0800‘7D8C)，我們跟緊著跳轉，__iar_program_start果然在這裏：
__iar_program_start:
08007D8C F000F88C BL __low_level_init
08007D90 2800 CMP R0, #0x0
08007D92 D001 BEQ __iar_init$$done
08007D94 F7FFFFDE BL __iar_data_init2
08007D98 2000 MOVS R0, #0x0
08007D9A F7FDFC49 BL main
我們看到IAR提供了__low_level_init這個函數進行了“底層”的初始化，進一步跟蹤，我們可以查到__low_level_init這個函數做了些什麽，不是不是我們想象中的不可告人。
__low_level_init:
08007EA8 2001 MOVS R0, #0x1
08007EAA 4770 BX LR
__low_level_init出乎想象的簡單，只是往R0寄存器寫入了1，就立即執行"BX LR"回到調用處了，接下來，__iar_program_start檢查了R0是否為0，為0，則執行__iar_init$$done，若不是0，就執行__iar_data_init2。__iar_init$$done這個函數很簡單，只有2句話，第一句是把R0清零，第二句就直接"BL main"，跳轉到main()函數了。不過既然__low_level_init已經往R0寫入了1，那麽我們還是得走下遠路——看看__iar_data_init2做了些什麽，雖然距離main只有一步之遙，不過這中間隱藏了編譯器的思想，我們得耐心看下去。
__iar_data_init2:
08007D54 B510 PUSH {R4,LR}
08007D56 4804 LDR R0, [PC, #0x10]
08007D58 4C04 LDR R4, [PC, #0x10]
08007D5A E002 B 0x8007D62
08007D5C F8501B04 LDR R1, [R0], #0x4
08007D60 4788 BLX R1
08007D62 42A0 CMP R0, R4
08007D64 D1FA BNE 0x8007D5C
08007D66 BD10 POP {R4,PC}
08007D68 7C78
08007D6A 0800
08007D6C 7C9C
08007D6E 0800
看來IAR遲遲不執行main()函數，就是為了執行__iar_data_init2，我們來分析分析IAR都幹了些什麽壞事~
首先壓R4，LR入棧，然後加載0x0800‘7C78至R0，0x0800‘7C9C至R4，馬上跳轉到0x0800‘7D62執行R0，R4的比較，結果若是相等，則彈出R4，PC，然後立即進入main()。不過IAR請君入甕是自不會那麽快放我們出來的——結果不相等，跳轉到0x0800‘7D5C執行，在這裏，把R0指向的地址——0x0800‘7C78中的值——0x0800‘7D71加載到R1，並且R0中的值自加4，更新為0x0800‘7C7C，並跳轉到R1指向的地址處執行，這裏是另一個IAR函數：__iar_zero_init2：
__iar_zero_init2:
08007D70 2300 MOVS R3, #0x0
08007D72 E005 B 0x8007D80
08007D74 F8501B04 LDR R1, [R0], #0x4
08007D78 F8413B04 STR R3, [R1], #0x4
08007D7C 1F12 SUBS R2, R2, #0x4
08007D7E D1FB BNE 0x8007D78
08007D80 F8502B04 LDR R2, [R0], #0x4
08007D84 2A00 CMP R2, #0x0
08007D86 D1F5 BNE 0x8007D74
08007D88 4770 BX LR
08007D8A 0000 MOVS R0, R0
__iar_data_init2還沒執行完畢，就跳轉到了這個__iar_zero_inti2，且看我們慢慢分析這個幫兇——__iar_zero_inti2做了什麽。
__iar_zero_inti2將R3寄存器清零，立即跳轉到0x0800‘7D80執行‘LDR R2, [R0], #0x4‘，這句指令與剛才在__iar_data_init2見到的‘LDR R1, [R0], #0x4‘很類似，都為“後索引”。這回，將R0指向的地址——0x0800‘7C7C中的值——0x0000‘02F4加載到R2寄存器，然後R0中的值自加4，更新為0x0800‘7C80。接下來的指令檢查了R2是否為0，顯然這個函數沒那麽簡單想放我我們，R2的值為2F4，我們又被帶到了0x0800‘7D74處，隨後4條指令做了如下的事情：
1、將R0指向的地址——0x0800‘7C80中的值——0x2000‘27D4加載到R1寄存器，然後R0中的值自加4，更新為0x0800‘7C84。
2、將R1指向的地址——0x2000‘27D4中的值——改寫為R3寄存器的值——0，然後R1中的值自加4，更新為0x2000‘27D8。
3、R2自減4
4、檢查R2是否為0，不為0，跳轉到第二條執行。不為，則執行下一條。
這簡直就是一個循環！——C語言的循環for(r2=0x2F4;r2-=4;r!=0){...}，我們看看循環中做了什麽。
第一條指令把一個地址加載到了R1——0x2000‘27D4 是一個RAM地址，以這個為起點，在循環中，對長度為2F4的RAM空間進行了清零的操作。那為什麽IAR要做這個事情呢？消除什麽記錄麽？用Jlink查看這片內存區域，可以發現這片區域是我們定義的全局變量的所在地。也就是說，IAR在每次系統復位後，都會自動將我們定義的全局變量清零0。
清零完畢後，接下來的指令"LDR R2, [R0], #0x4"將R0指向的地址——0x0800‘7C84中的值——0加載到R2寄存器，然後R0中的值自加4，更新為0x0800‘7C88。隨後檢查R2是否為0，這裏R2為0，執行‘BX LR‘返回到__iar_data_init2函數，若是不為0，我們可以發現又會跳轉至“4指令”處進行一個循環清零的操作。
讀到這裏，我們應該可以猜到IAR的意圖了：__iar_data_init2一開始加載了0x0800‘7C78至R0，0x0800‘7C9C至R4，[R0,R4]就是一段啟動代碼區，在這個區域內保存了要“處理”的所有地址與信息——執行的函數地址或者參數，實際上，這片區域也有一個名字，叫做：Region$$Table$$Base。在這個區域內，程序以R0為索引，R4為上限，當R0=R4，__iar_data_init2執行完畢，跳轉至main()函數。
好了，保持我們這個猜想，繼續跟蹤我們的PC指針——我們回到了__iar_data_init2函數中，第一件事就是比較R0，R4的值，可惜的是，仍然不相等，我們又被帶到了0x0800‘7D5C，至此，我們應該能看出這是一個__iar_data_init2的“主循環”，這也驗證了我們對IAR意圖的猜想~
__iar_data_init2中的“主循環”:
08007D5C F8501B04 LDR R1, [R0], #0x4
08007D60 4788 BLX R1
08007D62 42A0 CMP R0, R4
我們可以等價寫為:for(r0=0x0800‘7C78,r4=0x0800‘7C9C;r0!=r4;r0+=4){...}
此時，我們的R0為0x0800‘7C88，經過“指令1”，R0變為0x0800‘7C8C，R1為0x0800‘7C55。我們來看看，7C55處，IAR又要執行何種操作。
__iar_copy_init2:
08007C54 B418 PUSH {R3,R4}
08007C56 E009 B 0x8007C6C
08007C58 F8501B04 LDR R1, [R0], #0x4
08007C5C F8502B04 LDR R2, [R0], #0x4
08007C60 F8514B04 LDR R4, [R1], #0x4
08007C64 F8424B04 STR R4, [R2], #0x4
08007C68 1F1B SUBS R3, R3, #0x4
08007C6A D1F9 BNE 0x8007C60
08007C6C F8503B04 LDR R3, [R0], #0x4
08007C70 2B00 CMP R3, #0x0
08007C72 D1F1 BNE 0x8007C58
08007C74 BC12 POP {R1,R4}
08007C76 4770 BX LR
這是一個名為__iar_copy_init2的函數，他執行了什麽"copy"操作呢？
首先壓R3,R4入棧，然後跳轉到0x0800‘7C6C，從R0——Region$$Table$$Base中取出參數0x238放入R3，接下來的指令大家應該都熟悉了，0x238不為0，所以我們被帶至7C58處，再次從Region$$Table$$Base中取出參數0x0800‘7F14放入R1，從Region$$Table$$Base取出參數0x2000‘2AC8放入R2處。細心的觀眾應該能察覺這和__iar_zero_init2中取參數的幾乎一樣：先取出大小，隨後取出了地址——只不過這裏多出了1個地址，沒錯這就是"copy"，隨後的指令
08007C60 F8514B04 LDR R4, [R1], #0x4
08007C64 F8424B04 STR R4, [R2], #0x4
08007C68 1F1B SUBS R3, R3, #0x4
08007C6A D1F9 BNE 0x8007C60
則是另一個“4指令”，指令1將R1指向地址的數據讀到R4，指令2將R2指向地址的數據改寫為R4的數據，指令3、4是完成一個循環。
說到這裏大家都應該明白了——這就是一個"copy"的操作，從Flash地址0x0800‘7F14起，將長度0x238的數據拷貝到RAM地址0x2000‘2AC8中。
通過Jlink，我們可以看到這片區域是我們定義的並且已初始化的全局變量。也就是說，每次復位後，IAR在此處進行全局變量的初始化。
在這“4指令”執行完畢後，再次從Region$$Table$$Base中取出參數，為0，比較之後條件符合，函數返回__iar_data_init2。
此時的R0已經為0x0800‘7C9C與R4相等，__iar_data_init2終於完成它的使命。
08007D98 2000 MOVS R0, #0x0
08007D9A F7FDFC49 BL main
將R0清零以後，IAR放棄主動權，把PC指針交給了用戶程序的入口——main()。
但請註意，這裏使用的是BL指令進行main跳轉，也就是說，main函數只是IAR手中的一個子程序，若是main函數執行到了結尾，接下來則會執行exit等IAR提供的“退出”函數。這些函數，等待下回分解~
總之，IAR在啟動main()函數以前，執行了Reset_Handler，調用SystemInit()(ST庫提供)進行時鐘，Flash讀取初始化，並轉入__iar_program_start中執行__low_level_init與__iar_data_init2，並在__iar_data_init2中，先後調用__iar_zero_init2與__iar_copy_init2對全局變量、全局已初始化變量進行相應的初始化操作。最後，調用main()函數執行。
這就是IAR在啟動main()函數之前做的事情，它並沒有那麽神秘，只要花些時間，就可以跟跟蹤分析出這個過程。
/***************************************************************************//**
* @brief
* Select reference clock/oscillator used for a clock branch.
*
* @details
* Notice that if a selected reference is not enabled prior to selecting its
* use, it will be enabled, and this function will wait for the selected
* oscillator to be stable. It will however NOT be disabled if another
* reference clock is selected later.
*
* This feature is particularly important if selecting a new reference
* clock for the clock branch clocking the core, otherwise the system
* may halt.
*
* @param[in] clock
* Clock branch to select reference clock for. One of:
* @li #cmuClock_HF
* @li #cmuClock_LFA
* @li #cmuClock_LFB @if _CMU_LFCLKSEL_LFAE_ULFRCO
* @li #cmuClock_LFC
* @endif @if _SILICON_LABS_32B_PLATFORM_2
* @li #cmuClock_LFE
* @endif
* @li #cmuClock_DBG @if DOXYDOC_USB_PRESENT
* @li #cmuClock_USBC
* @endif
*
* @param[in] ref
* Reference selected for clocking, please refer to reference manual for
* for details on which reference is available for a specific clock branch.
* @li #cmuSelect_HFRCO
* @li #cmuSelect_LFRCO
* @li #cmuSelect_HFXO
* @li #cmuSelect_LFXO
* @li #cmuSelect_HFCLKLE
* @li #cmuSelect_AUXHFRCO
* @li #cmuSelect_HFCLK @ifnot DOXYDOC_EFM32_GECKO_FAMILY
* @li #cmuSelect_ULFRCO
* @endif
******************************************************************************/
void CMU_ClockSelectSet(CMU_Clock_TypeDef clock, CMU_Select_TypeDef ref)
{
uint32_t select = cmuOsc_HFRCO;
CMU_Osc_TypeDef osc = cmuOsc_HFRCO;
uint32_t freq;
uint32_t tmp;
uint32_t selRegId;
#if defined( _SILICON_LABS_32B_PLATFORM_2 )
volatile uint32_t *selReg = NULL;
#endif
#if defined( CMU_LFCLKSEL_LFAE_ULFRCO )
uint32_t lfExtended = 0;
#endif
selRegId = (clock >> CMU_SEL_REG_POS) & CMU_SEL_REG_MASK;
switch (selRegId)
{
case CMU_HFCLKSEL_REG:
switch (ref)
{
case cmuSelect_LFXO:
#if defined( _SILICON_LABS_32B_PLATFORM_2 )
select = CMU_HFCLKSEL_HF_LFXO;
#elif defined( _SILICON_LABS_32B_PLATFORM_1 )
select = CMU_CMD_HFCLKSEL_LFXO;
#endif
osc = cmuOsc_LFXO;
break;
case cmuSelect_LFRCO:
#if defined( _SILICON_LABS_32B_PLATFORM_2 )
select = CMU_HFCLKSEL_HF_LFRCO;
#elif defined( _SILICON_LABS_32B_PLATFORM_1 )
select = CMU_CMD_HFCLKSEL_LFRCO;
#endif
osc = cmuOsc_LFRCO;
break;
case cmuSelect_HFXO:
#if defined( CMU_HFCLKSEL_HF_HFXO )
select = CMU_HFCLKSEL_HF_HFXO;
#elif defined( CMU_CMD_HFCLKSEL_HFXO )
select = CMU_CMD_HFCLKSEL_HFXO;
#endif
osc = cmuOsc_HFXO;
#if defined( CMU_MAX_FREQ_HFLE )
/* Set 1 HFLE wait-state until the new HFCLKLE frequency is known.
This is known after ‘select‘ is written below. */
setHfLeConfig(CMU_MAX_FREQ_HFLE + 1, CMU_MAX_FREQ_HFLE);
#endif
#if defined( CMU_CTRL_HFXOBUFCUR_BOOSTABOVE32MHZ )
/* Adjust HFXO buffer current for frequencies above 32MHz */
if (SystemHFXOClockGet() > 32000000)
{
CMU->CTRL = (CMU->CTRL & ~_CMU_CTRL_HFXOBUFCUR_MASK)
| CMU_CTRL_HFXOBUFCUR_BOOSTABOVE32MHZ;
}
else
{
CMU->CTRL = (CMU->CTRL & ~_CMU_CTRL_HFXOBUFCUR_MASK)
| CMU_CTRL_HFXOBUFCUR_BOOSTUPTO32MHZ;
}
#endif
break;
case cmuSelect_HFRCO:
#if defined( _SILICON_LABS_32B_PLATFORM_2 )
select = CMU_HFCLKSEL_HF_HFRCO;
#elif defined( _SILICON_LABS_32B_PLATFORM_1 )
select = CMU_CMD_HFCLKSEL_HFRCO;
#endif
osc = cmuOsc_HFRCO;
#if defined( CMU_MAX_FREQ_HFLE )
/* Set 1 HFLE wait-state until the new HFCLKLE frequency is known.
This is known after ‘select‘ is written below. */
setHfLeConfig(CMU_MAX_FREQ_HFLE + 1, CMU_MAX_FREQ_HFLE);
#endif
break;
#if defined( CMU_CMD_HFCLKSEL_USHFRCODIV2 )
case cmuSelect_USHFRCODIV2:
select = CMU_CMD_HFCLKSEL_USHFRCODIV2;
osc = cmuOsc_USHFRCO;
break;
#endif
#if defined( CMU_LFCLKSEL_LFAE_ULFRCO ) || defined( CMU_LFACLKSEL_LFA_ULFRCO )
case cmuSelect_ULFRCO:
/* ULFRCO cannot be used as HFCLK */
EFM_ASSERT(0);
return;
#endif
default:
EFM_ASSERT(0);
return;
}
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(osc, true, true);
/* Configure worst case wait states for flash access before selecting */
flashWaitStateMax();
/* Switch to selected oscillator */
#if defined( _CMU_HFCLKSEL_MASK )
CMU->HFCLKSEL = select;
#else
CMU->CMD = select;
#endif
#if defined( CMU_MAX_FREQ_HFLE )
/* Update HFLE configuration after ‘select‘ is set.
Note that the HFCLKLE clock is connected differently on planform 1 and 2 */
setHfLeConfig(CMU_ClockFreqGet(cmuClock_HFLE), CMU_MAX_FREQ_HFLE);
#endif
/* Keep EMU module informed */
EMU_UpdateOscConfig();
/* Update CMSIS core clock variable */
/* (The function will update the global variable) */
freq = SystemCoreClockGet();
/* Optimize flash access wait state setting for currently selected core clk */
flashWaitStateControl(freq);
break;
#if defined( _SILICON_LABS_32B_PLATFORM_2 )
case CMU_LFACLKSEL_REG:
selReg = (selReg == NULL) ? &CMU->LFACLKSEL : selReg;
#if !defined( _CMU_LFACLKSEL_LFA_HFCLKLE )
/* HFCLKCLE can not be used as LFACLK */
EFM_ASSERT(ref != cmuSelect_HFCLKLE);
#endif
/* Fall through and select clock source */
case CMU_LFECLKSEL_REG:
selReg = (selReg == NULL) ? &CMU->LFECLKSEL : selReg;
#if !defined( _CMU_LFECLKSEL_LFE_HFCLKLE )
/* HFCLKCLE can not be used as LFECLK */
EFM_ASSERT(ref != cmuSelect_HFCLKLE);
#endif
/* Fall through and select clock source */
case CMU_LFBCLKSEL_REG:
selReg = (selReg == NULL) ? &CMU->LFBCLKSEL : selReg;
switch (ref)
{
case cmuSelect_Disabled:
tmp = _CMU_LFACLKSEL_LFA_DISABLED;
break;
case cmuSelect_LFXO:
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
tmp = _CMU_LFACLKSEL_LFA_LFXO;
break;
case cmuSelect_LFRCO:
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFRCO, true, true);
tmp = _CMU_LFACLKSEL_LFA_LFRCO;
break;
case cmuSelect_HFCLKLE:
/* Ensure correct HFLE wait-states and enable HFCLK to LE */
setHfLeConfig(SystemCoreClockGet(), CMU_MAX_FREQ_HFLE);
BUS_RegBitWrite(&CMU->HFBUSCLKEN0, _CMU_HFBUSCLKEN0_LE_SHIFT, 1);
tmp = _CMU_LFBCLKSEL_LFB_HFCLKLE;
break;
case cmuSelect_ULFRCO:
/* ULFRCO is always on, there is no need to enable it. */
tmp = _CMU_LFACLKSEL_LFA_ULFRCO;
break;
default:
EFM_ASSERT(0);
return;
}
*selReg = tmp;
break;
#elif defined( _SILICON_LABS_32B_PLATFORM_1 )
case CMU_LFACLKSEL_REG:
case CMU_LFBCLKSEL_REG:
switch (ref)
{
case cmuSelect_Disabled:
tmp = _CMU_LFCLKSEL_LFA_DISABLED;
break;
case cmuSelect_LFXO:
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
tmp = _CMU_LFCLKSEL_LFA_LFXO;
break;
case cmuSelect_LFRCO:
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFRCO, true, true);
tmp = _CMU_LFCLKSEL_LFA_LFRCO;
break;
case cmuSelect_HFCLKLE:
#if defined( CMU_MAX_FREQ_HFLE )
/* Set HFLE wait-state and divider */
freq = SystemCoreClockGet();
setHfLeConfig(freq, CMU_MAX_FREQ_HFLE);
#endif
/* Ensure HFCORE to LE clocking is enabled */
BUS_RegBitWrite(&CMU->HFCORECLKEN0, _CMU_HFCORECLKEN0_LE_SHIFT, 1);
tmp = _CMU_LFCLKSEL_LFA_HFCORECLKLEDIV2;
break;
#if defined( CMU_LFCLKSEL_LFAE_ULFRCO )
case cmuSelect_ULFRCO:
/* ULFRCO is always enabled */
tmp = _CMU_LFCLKSEL_LFA_DISABLED;
lfExtended = 1;
break;
#endif
default:
/* Illegal clock source for LFA/LFB selected */
EFM_ASSERT(0);
return;
}
/* Apply select */
if (selRegId == CMU_LFACLKSEL_REG)
{
#if defined( _CMU_LFCLKSEL_LFAE_MASK )
CMU->LFCLKSEL = (CMU->LFCLKSEL
& ~(_CMU_LFCLKSEL_LFA_MASK | _CMU_LFCLKSEL_LFAE_MASK))
| (tmp << _CMU_LFCLKSEL_LFA_SHIFT)
| (lfExtended << _CMU_LFCLKSEL_LFAE_SHIFT);
#else
CMU->LFCLKSEL = (CMU->LFCLKSEL & ~_CMU_LFCLKSEL_LFA_MASK)
| (tmp << _CMU_LFCLKSEL_LFA_SHIFT);
#endif
}
else
{
#if defined( _CMU_LFCLKSEL_LFBE_MASK )
CMU->LFCLKSEL = (CMU->LFCLKSEL
& ~(_CMU_LFCLKSEL_LFB_MASK | _CMU_LFCLKSEL_LFBE_MASK))
| (tmp << _CMU_LFCLKSEL_LFB_SHIFT)
| (lfExtended << _CMU_LFCLKSEL_LFBE_SHIFT);
#else
CMU->LFCLKSEL = (CMU->LFCLKSEL & ~_CMU_LFCLKSEL_LFB_MASK)
| (tmp << _CMU_LFCLKSEL_LFB_SHIFT);
#endif
}
break;
#if defined( _CMU_LFCLKSEL_LFC_MASK )
case CMU_LFCCLKSEL_REG:
switch(ref)
{
case cmuSelect_Disabled:
tmp = _CMU_LFCLKSEL_LFA_DISABLED;
break;
case cmuSelect_LFXO:
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
tmp = _CMU_LFCLKSEL_LFC_LFXO;
break;
case cmuSelect_LFRCO:
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFRCO, true, true);
tmp = _CMU_LFCLKSEL_LFC_LFRCO;
break;
default:
/* Illegal clock source for LFC selected */
EFM_ASSERT(0);
return;
}
/* Apply select */
CMU->LFCLKSEL = (CMU->LFCLKSEL & ~_CMU_LFCLKSEL_LFC_MASK)
| (tmp << _CMU_LFCLKSEL_LFC_SHIFT);
break;
#endif
#endif
#if defined( CMU_DBGCLKSEL_DBG ) || defined( CMU_CTRL_DBGCLK )
case CMU_DBGCLKSEL_REG:
switch(ref)
{
#if defined( CMU_DBGCLKSEL_DBG )
case cmuSelect_AUXHFRCO:
/* Select AUXHFRCO as debug clock */
CMU->DBGCLKSEL = CMU_DBGCLKSEL_DBG_AUXHFRCO;
break;
case cmuSelect_HFCLK:
/* Select divided HFCLK as debug clock */
CMU->DBGCLKSEL = CMU_DBGCLKSEL_DBG_HFCLK;
break;
#endif
#if defined( CMU_CTRL_DBGCLK )
case cmuSelect_AUXHFRCO:
/* Select AUXHFRCO as debug clock */
CMU->CTRL = (CMU->CTRL & ~(_CMU_CTRL_DBGCLK_MASK))
| CMU_CTRL_DBGCLK_AUXHFRCO;
break;
case cmuSelect_HFCLK:
/* Select divided HFCLK as debug clock */
CMU->CTRL = (CMU->CTRL & ~(_CMU_CTRL_DBGCLK_MASK))
| CMU_CTRL_DBGCLK_HFCLK;
break;
#endif
default:
/* Illegal clock source for debug selected */
EFM_ASSERT(0);
return;
}
break;
#endif
#if defined( USB_PRESENT )
case CMU_USBCCLKSEL_REG:
switch(ref)
{
case cmuSelect_LFXO:
/* Select LFXO as clock source for USB, can only be used in sleep mode */
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFXO, true, true);
/* Switch oscillator */
CMU->CMD = CMU_CMD_USBCCLKSEL_LFXO;
/* Wait until clock is activated */
while((CMU->STATUS & CMU_STATUS_USBCLFXOSEL)==0)
{
}
break;
case cmuSelect_LFRCO:
/* Select LFRCO as clock source for USB, can only be used in sleep mode */
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_LFRCO, true, true);
/* Switch oscillator */
CMU->CMD = CMU_CMD_USBCCLKSEL_LFRCO;
/* Wait until clock is activated */
while((CMU->STATUS & CMU_STATUS_USBCLFRCOSEL)==0)
{
}
break;
#if defined( CMU_STATUS_USBCHFCLKSEL )
case cmuSelect_HFCLK:
/* Select undivided HFCLK as clock source for USB */
/* Oscillator must already be enabled to avoid a core lockup */
CMU->CMD = CMU_CMD_USBCCLKSEL_HFCLKNODIV;
/* Wait until clock is activated */
while((CMU->STATUS & CMU_STATUS_USBCHFCLKSEL)==0)
{
}
break;
#endif
#if defined( CMU_CMD_USBCCLKSEL_USHFRCO )
case cmuSelect_USHFRCO:
/* Select USHFRCO as clock source for USB */
/* Ensure selected oscillator is enabled, waiting for it to stabilize */
CMU_OscillatorEnable(cmuOsc_USHFRCO, true, true);
/* Switch oscillator */
CMU->CMD = CMU_CMD_USBCCLKSEL_USHFRCO;
/* Wait until clock is activated */
while((CMU->STATUS & CMU_STATUS_USBCUSHFRCOSEL)==0)
{
}
break;
#endif
default:
/* Illegal clock source for USB */
EFM_ASSERT(0);
return;
}
break;
#endif
default:
EFM_ASSERT(0);
break;
}
#if defined( CMU_MAX_FREQ_HFLE )
/* Get to assert wait-state config. */
getHfLeConfig();
#endif
}
EFM32G232F64時鐘樹