Definition in file scif_uc3l.h.
#include "compiler.h"
Go to the source code of this file.
Data Structures | |
struct | scif_dfll_closedloop_conf_t |
DFLL closed-loop mode settings. More... | |
struct | scif_dfll_openloop_conf_t |
DFLL open-loop mode settings. More... | |
struct | scif_dfll_ssg_conf_t |
DFLL SSG settings. More... | |
struct | scif_gclk_opt_t |
Generic clock generation settings. More... | |
struct | scif_osc32_opt_t |
OSC32 startup options. More... | |
struct | scif_osc_opt_t |
OSC0/OSC1 startup options. More... | |
DFLL Control Functions | |
#define | scif_dfll0_closedloop_dither_gc_enable(pgc_conf) scif_dfll0_ssg_gc_enable(pgc_conf) |
Configure and enable the generic clock used by the closed-loop mode dithering stage and by the SSG. | |
#define | scif_dfll0_closedloop_mainref_gc_enable(pgc_conf) scif_start_gclk(AVR32_SCIF_GCLK_DFLL0_REF, pgc_conf) |
Configure and enable the closed-loop mode main reference generic clock. | |
#define | scif_dfll0_ssg_gc_enable(pgc_conf) scif_start_gclk(AVR32_SCIF_GCLK_DFLL0_SSG, pgc_conf) |
Configure and enable the SSG reference generic clock. | |
long int | scif_dfll0_closedloop_configure_and_start (const scif_gclk_opt_t *gc_dfllif_ref_opt, unsigned long long target_freq_hz, bool enable_ssg) |
Depending on the target frequency, compute the DFLL configuration parameters and start the DFLL0 in closed loop mode. | |
long int | scif_dfll0_closedloop_start (const scif_dfll_closedloop_conf_t *pdfllconfig) |
Configure and start the DFLL0 in closed loop mode. | |
long int | scif_dfll0_openloop_start (const scif_dfll_openloop_conf_t *pdfllconfig) |
Configure and start the DFLL0 in open loop mode. | |
long int | scif_dfll0_openloop_start_auto (unsigned long TargetFreqkHz) |
Automatic configuration and start of the DFLL0 in open loop mode. | |
long int | scif_dfll0_openloop_stop (void) |
Stop the DFLL0 in open loop mode. | |
long int | scif_dfll0_openloop_updatefreq (const scif_dfll_openloop_conf_t *pdfllconfig) |
Update the frequency of the DFLL0 in open loop mode. | |
long int | scif_dfll0_openloop_updatefreq_auto (unsigned long TargetFreq) |
Automatic configuration to update the frequency of the DFLL0 in open loop mode. | |
long int | scif_dfll0_ssg_enable (scif_dfll_ssg_conf_t *pssg_conf) |
Configure and enable the SSG. | |
Defines | |
#define | AVR32_SCIF_OSCCTRL0_OSCEN_DISABLE 0x00000000 |
#define | AVR32_SCIF_OSCCTRL0_OSCEN_ENABLE 0x00000001 |
#define | AVR32_SCIF_OSCCTRL32_OSC32EN_DISABLE 0x00000000 |
#define | AVR32_SCIF_OSCCTRL32_OSC32EN_ENABLE 0x00000001 |
#define | SCIF_DFLL_MAXFREQ_HZ 150000000L |
#define | SCIF_DFLL_MAXFREQ_KHZ 150000 |
The max DFLL output frequency. | |
#define | SCIF_DFLL_MINFREQ_HZ 20000000L |
#define | SCIF_DFLL_MINFREQ_KHZ 20000 |
The min DFLL output frequency. | |
#define | SCIF_EXT_CRYSTAL_MAX_FREQ_HZ 20000000 |
#define | SCIF_EXT_CRYSTAL_MIN_FREQ_HZ 4000000 |
Device-specific data. | |
#define | SCIF_NOT_SUPPORTED (-10000) |
Define "not supported" for the chosen implementation. | |
#define | SCIF_OSC32_FREQ_HZ 32768 |
The OSC32 frequency. | |
#define | SCIF_POLL_TIMEOUT 100000 |
The timeguard used for polling in ticks. | |
#define | SCIF_RC120M_FREQ_HZ 120000000L |
The RC120M frequency. | |
#define | SCIF_RC120M_FREQ_KHZ 120000 |
#define | SCIF_RC32K_FREQ_HZ 32768 |
The RC32K slow clock frequency. | |
#define | SCIF_RC32K_FREQ_KHZ (SCIF_RC32K_FREQ_HZ/100) |
#define | SCIF_SLOWCLOCK_FREQ_HZ AVR32_SCIF_RCOSC_FREQUENCY |
The RCSYS slow clock frequency. | |
#define | SCIF_SLOWCLOCK_FREQ_KHZ (SCIF_SLOWCLOCK_FREQ_HZ/100) |
#define | SCIF_UNLOCK(reg) (AVR32_SCIF.unlock = (AVR32_SCIF_UNLOCK_KEY_VALUE << AVR32_SCIF_UNLOCK_KEY_OFFSET)|(reg)) |
Unlock SCIF register macro. | |
Enumerations | |
enum | scif_gcctrl_oscsel_t { SCIF_GCCTRL_SLOWCLOCK = AVR32_SCIF_GC_USES_CLK_SLOW, SCIF_GCCTRL_OSC32K = AVR32_SCIF_GC_USES_CLK_32, SCIF_GCCTRL_DFLL0 = AVR32_SCIF_GC_USES_DFLL0, SCIF_GCCTRL_OSC0 = AVR32_SCIF_GC_USES_OSC0, SCIF_GCCTRL_RC120M = AVR32_SCIF_GC_USES_RC120M, SCIF_GCCTRL_CPUCLOCK = AVR32_SCIF_GC_USES_CLK_CPU, SCIF_GCCTRL_HSBCLOCK = AVR32_SCIF_GC_USES_CLK_HSB, SCIF_GCCTRL_PBACLOCK = AVR32_SCIF_GC_USES_CLK_PBA, SCIF_GCCTRL_PBBCLOCK = AVR32_SCIF_GC_USES_CLK_PBB, SCIF_GCCTRL_RC32K = AVR32_SCIF_GC_USES_RC32K, SCIF_GCCTRL_CRIPOSC = AVR32_SCIF_GC_USES_CRIPOSC, SCIF_GCCTRL_CLK1K = AVR32_SCIF_GC_USES_CLK_1K, SCIF_GCCTRL_OSCSEL_INVALID } |
The different clock source for the generic clocks. More... | |
enum | scif_osc_mode_t { SCIF_OSC_MODE_EXT_CLK = 0, SCIF_OSC_MODE_2PIN_CRYSTAL = 1, SCIF_OSC_MODE_2PIN_CRYSTAL_HICUR = 2, SCIF_OSC_MODE_EXT_CLK = 0, SCIF_OSC_MODE_2PIN_CRYSTAL = 1, SCIF_OSC_MODE_NOT_SUPPORTED_1 = 2, SCIF_OSC_MODE_NOT_SUPPORTED_2 = 3, SCIF_OSC_MODE_2PIN_CRYSTAL_HICUR = 4, SCIF_OSC_MODE_NOT_SUPPORTED_3 = 5, SCIF_OSC_MODE_NOT_SUPPORTED_4 = 6, SCIF_OSC_MODE_NOT_SUPPORTED_5 = 7 } |
The different oscillator modes. More... | |
enum | scif_osc_t { SCIF_OSC0 = 0, SCIF_OSC1 = 1, SCIF_OSC0 = 0, SCIF_OSC1 = 1 } |
The different oscillators. More... | |
Functions | |
Interrupt Functions | |
__inline__ void | scif_clear_interrupts_status (unsigned long mask) |
Clear raised interrupts from the SCIF. | |
__inline__ void | scif_disable_interrupts (unsigned long mask) |
Disable SCIF interrupts. | |
__inline__ void | scif_enable_interrupts (unsigned long mask) |
Enable SCIF interrupts. | |
__inline__ unsigned long | scif_get_enabled_interrupts (void) |
Read the SCIF currently enabled interrupts. | |
__inline__ unsigned long | scif_get_interrupts_status (void) |
Read the interrupt status of the SCIF. | |
OSC0/OSC1 Functions | |
long int | scif_configure_osc_crystalmode (scif_osc_t osc, unsigned int fcrystal) |
Configure an oscillator in crystal mode. | |
long int | scif_enable_osc (scif_osc_t osc, unsigned int startup, bool wait_for_ready) |
Enable an oscillator with a given startup time. | |
bool | scif_is_osc_ready (scif_osc_t osc) |
Is an oscillator stable and ready to be used as clock source? | |
long int | scif_start_osc (scif_osc_t osc, const scif_osc_opt_t *opt, bool wait_for_ready) |
Configure and start an OSC0/OSC1 oscillator. | |
long int | scif_stop_osc (scif_osc_t osc) |
Stop an oscillator. | |
32kHz internal RCosc (RC32K) Functions | |
void | scif_disable_rc32out (void) |
Unforce the RC32 signal from being output on the dedicated pin (PB04 on revB, PA20 on revC and later). | |
void | scif_start_rc32k (void) |
Start the 32kHz internal RCosc (RC32K) clock. | |
void | scif_stop_rc32k (void) |
Stop the 32kHz internal RCosc (RC32K) clock. | |
Generic Clock Functions | |
long int | scif_gc_enable (unsigned int gclk) |
Enable a generic clock. | |
long int | scif_gc_setup (unsigned int gclk, scif_gcctrl_oscsel_t clk_src, unsigned int diven, unsigned int divfactor) |
Setup a generic clock. | |
long int | scif_start_gclk (unsigned int gclk, const scif_gclk_opt_t *opt) |
Setup and start a generic clock. | |
long int | scif_stop_gclk (unsigned int gclk) |
Stop a generic clock. | |
Power and Clocks Status Functions | |
__inline__ unsigned long | scif_get_pclk_status (void) |
Read the Power and Clocks Status of the SCIF. | |
OSC32 Functions | |
__inline__ bool | scif_is_osc32_ready () |
Is OSC32 stable and ready to be used as clock source? | |
__inline__ void | scif_osc32_1kout_dis () |
Disable the 1kHz output of the OSC32 oscillator. | |
__inline__ void | scif_osc32_1kout_ena () |
Enable the 1kHz output of the OSC32 oscillator. | |
__inline__ void | scif_osc32_32kout_dis () |
Disable the 32kHz output of the OSC32 oscillator. | |
__inline__ void | scif_osc32_32kout_ena () |
Enable the 32kHz output of the OSC32 oscillator. | |
long int | scif_start_osc32 (const scif_osc32_opt_t *opt, bool wait_for_ready) |
Configure and start the OSC32 oscillator. | |
long int | scif_stop_osc32 () |
Stop the OSC32 oscillator. | |
Miscellaneous Functions | |
long int | scif_pclksr_statushigh_wait (unsigned long statusMask) |
Wait for a status high in the Power and Clocks status register. | |
120MHz RCosc Functions | |
void | scif_start_rc120M (void) |
Start the 120MHz internal RCosc (RC120M) clock. | |
void | scif_stop_rc120M (void) |
Stop the 120MHz internal RCosc (RC120M) clock. |
#define AVR32_SCIF_OSCCTRL0_OSCEN_DISABLE 0x00000000 |
Definition at line 62 of file scif_uc3l.h.
#define AVR32_SCIF_OSCCTRL0_OSCEN_ENABLE 0x00000001 |
Definition at line 61 of file scif_uc3l.h.
#define AVR32_SCIF_OSCCTRL32_OSC32EN_DISABLE 0x00000000 |
#define AVR32_SCIF_OSCCTRL32_OSC32EN_ENABLE 0x00000001 |
Definition at line 63 of file scif_uc3l.h.
#define scif_dfll0_closedloop_dither_gc_enable | ( | pgc_conf | ) | scif_dfll0_ssg_gc_enable(pgc_conf) |
Configure and enable the generic clock used by the closed-loop mode dithering stage and by the SSG.
pgc_conf | The settings for the generic clock [INPUT] |
0 | Dithering & SSG reference generic clock configured and started successfully. | |
<0 | Error. |
Definition at line 591 of file scif_uc3l.h.
#define scif_dfll0_closedloop_mainref_gc_enable | ( | pgc_conf | ) | scif_start_gclk(AVR32_SCIF_GCLK_DFLL0_REF, pgc_conf) |
Configure and enable the closed-loop mode main reference generic clock.
pgc_conf | The settings for the generic clock [INPUT] |
0 | Main reference generic clock configured and started successfully. | |
<0 | Error. |
Definition at line 548 of file scif_uc3l.h.
Referenced by scif_dfll0_closedloop_configure_and_start().
#define scif_dfll0_ssg_gc_enable | ( | pgc_conf | ) | scif_start_gclk(AVR32_SCIF_GCLK_DFLL0_SSG, pgc_conf) |
Configure and enable the SSG reference generic clock.
pgc_conf | The settings for the generic clock [INPUT] |
0 | SSG Generic clock configured and started successfully. | |
<0 | Error. |
Definition at line 526 of file scif_uc3l.h.
#define SCIF_DFLL_MAXFREQ_HZ 150000000L |
Definition at line 101 of file scif_uc3l.h.
Referenced by scif_dfll0_closedloop_configure_and_start().
#define SCIF_DFLL_MAXFREQ_KHZ 150000 |
The max DFLL output frequency.
Definition at line 100 of file scif_uc3l.h.
Referenced by scif_dfll0_openloop_start_auto().
#define SCIF_DFLL_MINFREQ_HZ 20000000L |
Definition at line 97 of file scif_uc3l.h.
Referenced by scif_dfll0_closedloop_configure_and_start().
#define SCIF_DFLL_MINFREQ_KHZ 20000 |
The min DFLL output frequency.
Definition at line 96 of file scif_uc3l.h.
Referenced by scif_dfll0_openloop_start_auto().
#define SCIF_EXT_CRYSTAL_MAX_FREQ_HZ 20000000 |
#define SCIF_EXT_CRYSTAL_MIN_FREQ_HZ 4000000 |
Device-specific data.
< External crystal/clock min frequency (in Herz) External crystal/clock max frequency (in Herz)
Definition at line 73 of file scif_uc3l.h.
Referenced by scif_start_osc(), and scif_start_osc32().
#define SCIF_NOT_SUPPORTED (-10000) |
#define SCIF_OSC32_FREQ_HZ 32768 |
#define SCIF_POLL_TIMEOUT 100000 |
#define SCIF_RC120M_FREQ_HZ 120000000L |
The RC120M frequency.
Definition at line 112 of file scif_uc3l.h.
Referenced by scif_dfll0_closedloop_configure_and_start().
#define SCIF_RC120M_FREQ_KHZ 120000 |
Definition at line 113 of file scif_uc3l.h.
#define SCIF_RC32K_FREQ_HZ 32768 |
The RC32K slow clock frequency.
Definition at line 108 of file scif_uc3l.h.
Referenced by scif_dfll0_closedloop_configure_and_start().
#define SCIF_RC32K_FREQ_KHZ (SCIF_RC32K_FREQ_HZ/100) |
Definition at line 109 of file scif_uc3l.h.
#define SCIF_SLOWCLOCK_FREQ_HZ AVR32_SCIF_RCOSC_FREQUENCY |
The RCSYS slow clock frequency.
Definition at line 104 of file scif_uc3l.h.
Referenced by scif_dfll0_closedloop_configure_and_start().
#define SCIF_SLOWCLOCK_FREQ_KHZ (SCIF_SLOWCLOCK_FREQ_HZ/100) |
Definition at line 105 of file scif_uc3l.h.
#define SCIF_UNLOCK | ( | reg | ) | (AVR32_SCIF.unlock = (AVR32_SCIF_UNLOCK_KEY_VALUE << AVR32_SCIF_UNLOCK_KEY_OFFSET)|(reg)) |
enum scif_gcctrl_oscsel_t |
The different clock source for the generic clocks.
Definition at line 78 of file scif_uc3l.h.
00079 { 00080 SCIF_GCCTRL_SLOWCLOCK = AVR32_SCIF_GC_USES_CLK_SLOW, 00081 SCIF_GCCTRL_OSC32K = AVR32_SCIF_GC_USES_CLK_32, 00082 SCIF_GCCTRL_DFLL0 = AVR32_SCIF_GC_USES_DFLL0, 00083 SCIF_GCCTRL_OSC0 = AVR32_SCIF_GC_USES_OSC0, 00084 SCIF_GCCTRL_RC120M = AVR32_SCIF_GC_USES_RC120M, 00085 SCIF_GCCTRL_CPUCLOCK = AVR32_SCIF_GC_USES_CLK_CPU, 00086 SCIF_GCCTRL_HSBCLOCK = AVR32_SCIF_GC_USES_CLK_HSB, 00087 SCIF_GCCTRL_PBACLOCK = AVR32_SCIF_GC_USES_CLK_PBA, 00088 SCIF_GCCTRL_PBBCLOCK = AVR32_SCIF_GC_USES_CLK_PBB, 00089 SCIF_GCCTRL_RC32K = AVR32_SCIF_GC_USES_RC32K, 00090 SCIF_GCCTRL_CRIPOSC = AVR32_SCIF_GC_USES_CRIPOSC, 00091 SCIF_GCCTRL_CLK1K = AVR32_SCIF_GC_USES_CLK_1K, 00092 SCIF_GCCTRL_OSCSEL_INVALID 00093 } scif_gcctrl_oscsel_t;
enum scif_osc_mode_t |
The different oscillator modes.
Definition at line 136 of file scif_uc3l.h.
00137 { 00138 SCIF_OSC_MODE_EXT_CLK = 0, // For both OSC0 & OSC32 00139 SCIF_OSC_MODE_2PIN_CRYSTAL = 1, // For both OSC0 and OSC32 00140 SCIF_OSC_MODE_NOT_SUPPORTED_1 = 2, 00141 SCIF_OSC_MODE_NOT_SUPPORTED_2 = 3, 00142 SCIF_OSC_MODE_2PIN_CRYSTAL_HICUR = 4, // For OSC32 only 00143 SCIF_OSC_MODE_NOT_SUPPORTED_3 = 5, 00144 SCIF_OSC_MODE_NOT_SUPPORTED_4 = 6, 00145 SCIF_OSC_MODE_NOT_SUPPORTED_5 = 7 00146 } scif_osc_mode_t;
enum scif_osc_t |
The different oscillators.
Definition at line 129 of file scif_uc3l.h.
00130 { 00131 SCIF_OSC0 = 0, 00132 SCIF_OSC1 = 1 00133 } scif_osc_t;
__inline__ void scif_clear_interrupts_status | ( | unsigned long | mask | ) |
Clear raised interrupts from the SCIF.
mask | The interrupts to clear. |
Definition at line 284 of file scif_uc3l.h.
long int scif_configure_osc_crystalmode | ( | scif_osc_t | osc, | |
unsigned int | fcrystal | |||
) |
Configure an oscillator in crystal mode.
osc | The oscillator to configure [INPUT] | |
fcrystal | Crystal frequency (Hz) [INPUT] |
0 | Oscillator successfully configured. | |
<0 | Error configuring the oscillator. |
Definition at line 228 of file scif_uc3c.c.
References u_avr32_scif_oscctrl_t::OSCCTRL, u_avr32_scif_oscctrl0_t::oscctrl0, u_avr32_scif_oscctrl0_t::OSCCTRL0, SCIF_OSC0, SCIF_OSC1, SCIF_OSC_MODE_2PIN_CRYSTAL, and SCIF_UNLOCK.
00229 { 00230 u_avr32_scif_oscctrl_t u_avr32_scif_oscctrl; 00231 00232 if (osc == SCIF_OSC0) 00233 { 00234 // Read Register 00235 u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC0] = AVR32_SCIF.OSCCTRL[SCIF_OSC0] ; 00236 // Modify : Configure the oscillator mode to crystal and set the gain according to the 00237 // cyrstal frequency. 00238 u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC0].mode = SCIF_OSC_MODE_2PIN_CRYSTAL; 00239 u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC0].gain = (fcrystal < 900000) ? AVR32_SCIF_OSCCTRL0_GAIN_G0 : 00240 (fcrystal < 3000000) ? AVR32_SCIF_OSCCTRL0_GAIN_G1 : 00241 (fcrystal < 8000000) ? AVR32_SCIF_OSCCTRL0_GAIN_G2 : 00242 AVR32_SCIF_OSCCTRL0_GAIN_G3; 00243 AVR32_ENTER_CRITICAL_REGION( ); 00244 // Unlock the write-protected OSCCTRL0 register 00245 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL); 00246 // Write Back 00247 AVR32_SCIF.OSCCTRL[SCIF_OSC0] = u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC0]; 00248 AVR32_LEAVE_CRITICAL_REGION( ); 00249 } 00250 else 00251 { 00252 // Read Register 00253 u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC1] = AVR32_SCIF.OSCCTRL[SCIF_OSC1] ; 00254 // Modify : Configure the oscillator mode to crystal and set the gain according to the 00255 // cyrstal frequency. 00256 u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC1].mode = SCIF_OSC_MODE_2PIN_CRYSTAL; 00257 u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC1].gain = (fcrystal < 900000) ? AVR32_SCIF_OSCCTRL1_GAIN_G0 : 00258 (fcrystal < 3000000) ? AVR32_SCIF_OSCCTRL1_GAIN_G1 : 00259 (fcrystal < 8000000) ? AVR32_SCIF_OSCCTRL1_GAIN_G2 : 00260 AVR32_SCIF_OSCCTRL1_GAIN_G3; 00261 AVR32_ENTER_CRITICAL_REGION( ); 00262 // Unlock the write-protected OSCCTRL1 register 00263 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL + 4); 00264 // Write Back 00265 AVR32_SCIF.OSCCTRL[SCIF_OSC1] = u_avr32_scif_oscctrl.OSCCTRL[SCIF_OSC1]; 00266 AVR32_LEAVE_CRITICAL_REGION( ); 00267 } 00268 00269 return PASS; 00270 }
long int scif_dfll0_closedloop_configure_and_start | ( | const scif_gclk_opt_t * | gc_dfllif_ref_opt, | |
unsigned long long | target_freq_hz, | |||
bool | enable_ssg | |||
) |
Depending on the target frequency, compute the DFLL configuration parameters and start the DFLL0 in closed loop mode.
This function only supports the following source clocks for the CLK_DFLLIF_REF generic clock: SCIF_GCCTRL_SLOWCLOCK (aka RCSYS), SCIF_GCCTRL_OSC32K, SCIF_GCCTRL_RC32K, SCIF_GCCTRL_OSC0, SCIF_GCCTRL_RC120M, SCIF_GCCTRL_CLK1K.
gc_dfllif_ref_opt | The settings for the CLK_DFLLIF_REF generic clock [INPUT] | |
target_freq_hz | The target frequency (in Hz) [INPUT] | |
enable_ssg | Enable/disable the SSG feature [INPUT] |
0 | DFLL0 configured and started successfully. | |
<0 | Error. |
Definition at line 600 of file scif_uc3l.c.
References scif_gclk_opt_t::clock_source, scif_dfll_closedloop_conf_t::coarse, scif_gclk_opt_t::diven, scif_gclk_opt_t::divider, scif_gclk_opt_t::extosc_f, scif_dfll_closedloop_conf_t::fmul, scif_dfll_closedloop_conf_t::maxstep, scif_dfll0_closedloop_mainref_gc_enable, scif_dfll0_closedloop_start(), SCIF_DFLL_MAXFREQ_HZ, SCIF_DFLL_MINFREQ_HZ, SCIF_GCCTRL_CLK1K, SCIF_GCCTRL_OSC0, SCIF_GCCTRL_OSC32K, SCIF_GCCTRL_RC120M, SCIF_GCCTRL_RC32K, SCIF_GCCTRL_SLOWCLOCK, SCIF_RC120M_FREQ_HZ, SCIF_RC32K_FREQ_HZ, and SCIF_SLOWCLOCK_FREQ_HZ.
00603 { 00604 scif_dfll_closedloop_conf_t DfllConfig; 00605 int gc_source_clock_freq_hz; 00606 00607 // This function only supports the following source clocks for the CLK_DFLLIF_REF generic clock: 00608 // SCIF_GCCTRL_SLOWCLOCK (aka RCSYS), SCIF_GCCTRL_OSC32K, SCIF_GCCTRL_RC32K, 00609 // SCIF_GCCTRL_OSC0, SCIF_GCCTRL_RC120M, SCIF_GCCTRL_CLK1K. 00610 if(SCIF_GCCTRL_SLOWCLOCK == gc_dfllif_ref_opt->clock_source) 00611 gc_source_clock_freq_hz = SCIF_SLOWCLOCK_FREQ_HZ; 00612 else if((SCIF_GCCTRL_OSC32K == gc_dfllif_ref_opt->clock_source) || (SCIF_GCCTRL_RC32K == gc_dfllif_ref_opt->clock_source)) 00613 gc_source_clock_freq_hz = SCIF_RC32K_FREQ_HZ; 00614 else if(SCIF_GCCTRL_OSC0 == gc_dfllif_ref_opt->clock_source) 00615 gc_source_clock_freq_hz = gc_dfllif_ref_opt->extosc_f; 00616 else if(SCIF_GCCTRL_RC120M == gc_dfllif_ref_opt->clock_source) 00617 gc_source_clock_freq_hz = SCIF_RC120M_FREQ_HZ; 00618 else if(SCIF_GCCTRL_CLK1K == gc_dfllif_ref_opt->clock_source) 00619 gc_source_clock_freq_hz = 1000; 00620 else 00621 return -1; 00622 00623 // Configure and start the DFLL main reference generic clock (CLK_DFLLIF_REF). 00624 if(scif_dfll0_closedloop_mainref_gc_enable(gc_dfllif_ref_opt)) 00625 return(-1); 00626 00627 // Configure the DFLL. 00628 // The coarse value (= (dfll_f - SCIF_DFLL_MINFREQ_KHZ)*255/(SCIF_DFLL_MAXFREQ_KHZ - SCIF_DFLL_MINFREQ_KHZ)) 00629 DfllConfig.coarse = ((unsigned long long)(target_freq_hz - SCIF_DFLL_MINFREQ_HZ)*255)/(SCIF_DFLL_MAXFREQ_HZ - SCIF_DFLL_MINFREQ_HZ); 00630 00631 // The fmul value (= (fDFLL*2^16)/fref, with fref being the frequency of the 00632 // DFLL main reference generic clock) 00633 if(0 == gc_dfllif_ref_opt->diven) 00634 DfllConfig.fmul = ((unsigned long long)target_freq_hz<<16)/gc_source_clock_freq_hz; 00635 else 00636 DfllConfig.fmul = ((((unsigned long long)target_freq_hz<<16)/gc_source_clock_freq_hz)<<1)*(1+gc_dfllif_ref_opt->divider); 00637 00638 // The maxstep value 00639 #if (defined(__GNUC__) \ 00640 && (defined(__AVR32_UC3L064__) || defined(__AVR32_UC3L032__) || defined(__AVR32_UC3L016__))) \ 00641 ||((defined(__ICCAVR32__) || defined(__AAVR32__)) \ 00642 && (defined(__AT32UC3L064__) || defined(__AT32UC3L032__) || defined(__AT32UC3L016__))) 00643 // UC3L revC or later 00644 DfllConfig.maxstep = 0x0040004; 00645 #else 00646 // UC3L revB 00647 //+ Errata UC3L revB: 35.2.7 SCIF.12 DFLLIF indicates coarse lock too early 00648 //+ The DFLLIF might indicate coarse lock too early, the DFLL will lose 00649 //+ coarse lock and regain it later. 00650 //+ Fix/Workaround 00651 //+ Use max step size (DFLL0MAXSTEP.MAXSTEP) of 4 or higher. 00652 DfllConfig.maxstep = 0x0040004; 00653 #endif 00654 00655 // Dithering disabled. 00656 //+ Errata UC3L revB: 35.2.7 SCIF.13 DFLLIF dithering does not work 00657 //+ The DFLLIF dithering does not work. 00658 //+ Fix/Workaround 00659 //+ None. 00660 00661 // Configure and start the DFLL0 in closed loop mode. 00662 if(scif_dfll0_closedloop_start(&DfllConfig)) 00663 return -1; 00664 00665 // TODO: Future implementation note: add use of the generic clock CLK_DFLLIF_DITHER 00666 // as a reference for the SSG feature. 00667 if(TRUE == enable_ssg) 00668 { 00669 ; 00670 } 00671 return PASS; 00672 }
long int scif_dfll0_closedloop_start | ( | const scif_dfll_closedloop_conf_t * | pdfllconfig | ) |
Configure and start the DFLL0 in closed loop mode.
pdfllconfig | The DFLL parameters in closed loop mode [INPUT] |
0 | DFLL0 configured and started successfully. | |
<0 | Error. |
Definition at line 536 of file scif_uc3l.c.
References scif_dfll_closedloop_conf_t::coarse, u_avr32_scif_dfll0conf_t::dfll0conf, u_avr32_scif_dfll0conf_t::DFLL0CONF, scif_dfll_closedloop_conf_t::fmul, scif_dfll_closedloop_conf_t::maxstep, SCIF_DFLL0_MODE_CLOSEDLOOP, scif_pclksr_statushigh_wait(), and SCIF_UNLOCK.
Referenced by scif_dfll0_closedloop_configure_and_start().
00537 { 00538 u_avr32_scif_dfll0conf_t u_avr32_scif_dfll0conf = {AVR32_SCIF.dfll0conf}; 00539 00540 00541 #ifdef AVR32SFW_INPUT_CHECK 00542 if((pdfllconfig->coarse >> AVR32_SCIF_DFLL0CONF_COARSE_SIZE)) 00543 return -1; 00544 if((pdfllconfig->maxstep >> AVR32_SCIF_DFLL0STEP_MAXSTEP_SIZE)) 00545 return -1; 00546 #endif 00547 00548 // Enable the DFLL0: DFLL0CONF.EN=1 00549 u_avr32_scif_dfll0conf.DFLL0CONF.en = ENABLE; 00550 AVR32_ENTER_CRITICAL_REGION( ); 00551 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00552 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00553 AVR32_LEAVE_CRITICAL_REGION( ); 00554 00555 // Wait for PCLKSR.DFLL0RDY is high 00556 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00557 return -1; 00558 00559 // Set the maxstep 00560 AVR32_ENTER_CRITICAL_REGION( ); 00561 SCIF_UNLOCK(AVR32_SCIF_MAXSTEP); 00562 AVR32_SCIF.dfll0step = (pdfllconfig->maxstep << AVR32_SCIF_DFLL0STEP_MAXSTEP_OFFSET)&AVR32_SCIF_DFLL0STEP_MAXSTEP_MASK; 00563 AVR32_LEAVE_CRITICAL_REGION( ); 00564 00565 // Wait for PCLKSR.DFLL0RDY is high 00566 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00567 return -1; 00568 00569 // Set the fmul 00570 AVR32_ENTER_CRITICAL_REGION( ); 00571 SCIF_UNLOCK(AVR32_SCIF_DFLL0FMUL); 00572 AVR32_SCIF.dfll0fmul = (pdfllconfig->fmul << AVR32_SCIF_DFLL0FMUL_FMUL_OFFSET)&AVR32_SCIF_DFLL0FMUL_FMUL_MASK; 00573 AVR32_LEAVE_CRITICAL_REGION( ); 00574 00575 // Wait for PCLKSR.DFLL0RDY is high 00576 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00577 return -1; 00578 00579 // Set the DFLL0 to operate in closed-loop mode: DFLL0CONF.MODE=1 00580 u_avr32_scif_dfll0conf.DFLL0CONF.mode = SCIF_DFLL0_MODE_CLOSEDLOOP; 00581 u_avr32_scif_dfll0conf.DFLL0CONF.coarse = pdfllconfig->coarse; 00582 AVR32_ENTER_CRITICAL_REGION( ); 00583 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00584 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00585 AVR32_LEAVE_CRITICAL_REGION( ); 00586 00587 // Wait for PCLKSR.DFLL0RDY is high 00588 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00589 return -1; 00590 00591 // Wait until the DFLL is locked on Fine value, and is ready to be selected as 00592 // clock source with a highly accurate output clock. 00593 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0LOCKF_MASK)) 00594 return -1; 00595 00596 return PASS; 00597 }
long int scif_dfll0_openloop_start | ( | const scif_dfll_openloop_conf_t * | pdfllconfig | ) |
Configure and start the DFLL0 in open loop mode.
pdfllconfig | The DFLL parameters in open loop mode [INPUT] |
0 | DFLL0 configured and started successfully. | |
<0 | Error. |
Definition at line 358 of file scif_uc3l.c.
References scif_dfll_openloop_conf_t::coarse, u_avr32_scif_dfll0conf_t::dfll0conf, u_avr32_scif_dfll0conf_t::DFLL0CONF, scif_dfll_openloop_conf_t::fine, SCIF_DFLL0_MODE_OPENLOOP, scif_pclksr_statushigh_wait(), and SCIF_UNLOCK.
Referenced by scif_dfll0_openloop_start_auto().
00359 { 00360 u_avr32_scif_dfll0conf_t u_avr32_scif_dfll0conf = {AVR32_SCIF.dfll0conf}; 00361 00362 00363 #ifdef AVR32SFW_INPUT_CHECK 00364 if((pdfllconfig->fine >> AVR32_SCIF_DFLL0CONF_FINE_SIZE)) 00365 return -1; 00366 if((pdfllconfig->coarse >> AVR32_SCIF_DFLL0CONF_COARSE_SIZE)) 00367 return -1; 00368 #endif 00369 00370 // Enable the DFLL0: DFLL0CONF.EN=1 00371 u_avr32_scif_dfll0conf.DFLL0CONF.en = ENABLE; 00372 AVR32_ENTER_CRITICAL_REGION( ); 00373 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00374 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00375 AVR32_LEAVE_CRITICAL_REGION( ); 00376 00377 // Wait for PCLKSR.DFLL0RDY is high 00378 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00379 return -1; 00380 00381 // Set the DFLL0 to operate in open mode: DFLL0CONF.MODE=0 00382 u_avr32_scif_dfll0conf.DFLL0CONF.mode = SCIF_DFLL0_MODE_OPENLOOP; 00383 AVR32_ENTER_CRITICAL_REGION( ); 00384 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00385 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00386 AVR32_LEAVE_CRITICAL_REGION( ); 00387 00388 // Wait for PCLKSR.DFLL0RDY is high 00389 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00390 return -1; 00391 00392 // Write DFLL0CONF.COARSE & DFLL0CONF.FINE 00393 u_avr32_scif_dfll0conf.DFLL0CONF.coarse = pdfllconfig->coarse; 00394 u_avr32_scif_dfll0conf.DFLL0CONF.fine = pdfllconfig->fine; 00395 AVR32_ENTER_CRITICAL_REGION( ); 00396 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00397 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00398 AVR32_LEAVE_CRITICAL_REGION( ); 00399 00400 // Wait for PCLKSR.DFLL0RDY is high 00401 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00402 return -1; 00403 00404 return PASS; 00405 }
long int scif_dfll0_openloop_start_auto | ( | unsigned long | TargetFreqkHz | ) |
Automatic configuration and start of the DFLL0 in open loop mode.
TargetFreqkHz | The DFLL target frequency (in kHz) [INPUT] |
0 | DFLL0 configured and started successfully. | |
<0 | Error. |
Definition at line 411 of file scif_uc3l.c.
References scif_dfll_openloop_conf_t::coarse, scif_dfll_openloop_conf_t::fine, scif_dfll0_openloop_start(), SCIF_DFLL_COARSE_MAX, SCIF_DFLL_FINE_HALF, SCIF_DFLL_FINE_MAX, SCIF_DFLL_MAXFREQ_KHZ, and SCIF_DFLL_MINFREQ_KHZ.
00412 { 00413 scif_dfll_openloop_conf_t Dfll0Conf; 00414 unsigned long Coarse; 00415 unsigned long Fine; 00416 unsigned long CoarseFreq; 00417 unsigned long DeltaFreq; 00418 00419 00420 #ifdef AVR32SFW_INPUT_CHECK 00421 if((TargetFreqkHz < SCIF_DFLL_MINFREQ_KHZ) || (TargetFreqkHz > SCIF_DFLL_MAXFREQ_KHZ)) 00422 return -1; 00423 #endif 00424 00425 //** 00426 //** Dynamically compute the COARSE and FINE values. 00427 //** 00428 // Fdfll = (Fmin+(Fmax-Fmin)*(COARSE/0xFF))*(1+X*(FINE-0x100)/0x1FF)=CoarseFreq*(1+X*(FINE-0x100)/0x1FF) 00429 00430 // Compute the COARSE value. 00431 Coarse = ((TargetFreqkHz - SCIF_DFLL_MINFREQ_KHZ)*SCIF_DFLL_COARSE_MAX)/(SCIF_DFLL_MAXFREQ_KHZ - SCIF_DFLL_MINFREQ_KHZ); 00432 // Compute the COARSE DFLL frequency. 00433 CoarseFreq = SCIF_DFLL_MINFREQ_KHZ + (((SCIF_DFLL_MAXFREQ_KHZ - SCIF_DFLL_MINFREQ_KHZ)/SCIF_DFLL_COARSE_MAX)*Coarse); 00434 // Compute the coarse error. 00435 DeltaFreq = TargetFreqkHz - CoarseFreq; 00436 // Compute the FINE value. 00437 // Fine = ((DeltaFreq*SCIF_DFLL_FINE_MAX)*10/CoarseFreq) + SCIF_DFLL_FINE_HALF; 00438 // Theorical equation don't work on silicon: the best was to use X=5/2 to 00439 // find FINE, then do FINE/4. 00440 Fine = ((DeltaFreq*SCIF_DFLL_FINE_MAX)*2/CoarseFreq*5) + SCIF_DFLL_FINE_HALF; 00441 Fine >>=2; 00442 00443 Dfll0Conf.coarse = Coarse; 00444 Dfll0Conf.fine = Fine; 00445 return(scif_dfll0_openloop_start(&Dfll0Conf)); 00446 }
long int scif_dfll0_openloop_stop | ( | void | ) |
Stop the DFLL0 in open loop mode.
0 | DFLL0 successfully stopped. | |
<0 | Error. |
Definition at line 480 of file scif_uc3l.c.
References u_avr32_scif_dfll0conf_t::dfll0conf, u_avr32_scif_dfll0conf_t::DFLL0CONF, scif_pclksr_statushigh_wait(), and SCIF_UNLOCK.
00481 { 00482 u_avr32_scif_dfll0conf_t u_avr32_scif_dfll0conf = {AVR32_SCIF.dfll0conf}; 00483 00484 00485 // Before disabling the DFLL, the output freq of the DFLL should be set to a 00486 // minimum: set COARSE to 0x00. 00487 00488 // Wait for PCLKSR.DFLL0RDY is high 00489 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00490 return -1; 00491 00492 // Write DFLL0CONF.COARSE 00493 u_avr32_scif_dfll0conf.DFLL0CONF.coarse = 0; 00494 AVR32_ENTER_CRITICAL_REGION( ); 00495 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00496 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00497 AVR32_LEAVE_CRITICAL_REGION( ); 00498 00499 // Wait for PCLKSR.DFLL0RDY is high 00500 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00501 return -1; 00502 00503 // Disable the DFLL 00504 u_avr32_scif_dfll0conf.DFLL0CONF.en = 0; 00505 AVR32_ENTER_CRITICAL_REGION( ); 00506 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00507 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00508 AVR32_LEAVE_CRITICAL_REGION( ); 00509 00510 // Wait for PCLKSR.DFLL0RDY is high 00511 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00512 return -1; 00513 00514 return PASS; 00515 }
long int scif_dfll0_openloop_updatefreq | ( | const scif_dfll_openloop_conf_t * | pdfllconfig | ) |
Update the frequency of the DFLL0 in open loop mode.
pdfllconfig | The DFLL parameters in open loop mode [INPUT] |
0 | DFLL0 frequency updated successfully. | |
<0 | Error. |
Definition at line 448 of file scif_uc3l.c.
References scif_dfll_openloop_conf_t::coarse, u_avr32_scif_dfll0conf_t::dfll0conf, u_avr32_scif_dfll0conf_t::DFLL0CONF, scif_dfll_openloop_conf_t::fine, scif_pclksr_statushigh_wait(), and SCIF_UNLOCK.
00449 { 00450 u_avr32_scif_dfll0conf_t u_avr32_scif_dfll0conf = {AVR32_SCIF.dfll0conf}; 00451 00452 00453 #ifdef AVR32SFW_INPUT_CHECK 00454 if((pdfllconfig->fine >> AVR32_SCIF_DFLL0CONF_FINE_SIZE)) 00455 return -1; 00456 #endif 00457 00458 // It is assumed that the DFLL is enabled and operates in open-loop mode. 00459 00460 // Wait for PCLKSR.DFLL0RDY is high 00461 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00462 return -1; 00463 00464 // Write DFLL0CONF.COARSE & DFLL0CONF.FINE 00465 u_avr32_scif_dfll0conf.DFLL0CONF.coarse = pdfllconfig->coarse; 00466 u_avr32_scif_dfll0conf.DFLL0CONF.fine = pdfllconfig->fine; 00467 AVR32_ENTER_CRITICAL_REGION( ); 00468 SCIF_UNLOCK(AVR32_SCIF_DFLL0CONF); 00469 AVR32_SCIF.dfll0conf = u_avr32_scif_dfll0conf.dfll0conf; 00470 AVR32_LEAVE_CRITICAL_REGION( ); 00471 00472 // Wait for PCLKSR.DFLL0RDY is high 00473 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_DFLL0RDY_MASK)) 00474 return -1; 00475 00476 return PASS; 00477 }
long int scif_dfll0_openloop_updatefreq_auto | ( | unsigned long | TargetFreq | ) |
Automatic configuration to update the frequency of the DFLL0 in open loop mode.
TargetFreq | The DFLL target frequency (in kHz) [INPUT] |
0 | DFLL0 frequency updated successfully. | |
<0 | Error. |
long int scif_dfll0_ssg_enable | ( | scif_dfll_ssg_conf_t * | pssg_conf | ) |
Configure and enable the SSG.
pssg_conf | The settings for the SCIF.DFLL0SSG register [INPUT] |
0 | SSG Generic clock configured and started successfully. | |
<0 | Error. |
Definition at line 518 of file scif_uc3l.c.
References scif_dfll_ssg_conf_t::amplitude, u_avr32_scif_dfll0ssg_t::dfll0ssg, u_avr32_scif_dfll0ssg_t::DFLL0SSG, SCIF_UNLOCK, scif_dfll_ssg_conf_t::step_size, and scif_dfll_ssg_conf_t::use_random.
00519 { 00520 u_avr32_scif_dfll0ssg_t u_avr32_scif_dfll0ssg = {AVR32_SCIF.dfll0ssg}; 00521 00522 00523 u_avr32_scif_dfll0ssg.DFLL0SSG.en = ENABLE; 00524 u_avr32_scif_dfll0ssg.DFLL0SSG.prbs = pssg_conf->use_random; 00525 u_avr32_scif_dfll0ssg.DFLL0SSG.amplitude = pssg_conf->amplitude; 00526 u_avr32_scif_dfll0ssg.DFLL0SSG.stepsize = pssg_conf->step_size; 00527 AVR32_ENTER_CRITICAL_REGION( ); 00528 SCIF_UNLOCK(AVR32_SCIF_DFLL0SSG); 00529 AVR32_SCIF.dfll0ssg = u_avr32_scif_dfll0ssg.dfll0ssg; 00530 AVR32_LEAVE_CRITICAL_REGION( ); 00531 00532 return PASS; 00533 }
__inline__ void scif_disable_interrupts | ( | unsigned long | mask | ) |
Disable SCIF interrupts.
mask | the interrupts to disable. |
Definition at line 248 of file scif_uc3l.h.
void scif_disable_rc32out | ( | void | ) |
Unforce the RC32 signal from being output on the dedicated pin (PB04 on revB, PA20 on revC and later).
Definition at line 735 of file scif_uc3l.c.
Referenced by scif_start_osc32().
00736 { 00737 unsigned long temp; 00738 AVR32_ENTER_CRITICAL_REGION( ); 00739 temp = AVR32_PM.ppcr & (~AVR32_PM_PPCR_FRC32_MASK); 00740 // Unforce the RC32 signal from being output on the dedicated pin (PB04 on revB, PA20 on revC and later). 00741 AVR32_PM.unlock = 0xAA000000 | AVR32_PM_PPCR; 00742 AVR32_PM.ppcr = temp; 00743 AVR32_LEAVE_CRITICAL_REGION( ); 00744 }
__inline__ void scif_enable_interrupts | ( | unsigned long | mask | ) |
Enable SCIF interrupts.
mask | the interrupts to enable. |
Definition at line 236 of file scif_uc3l.h.
long int scif_enable_osc | ( | scif_osc_t | osc, | |
unsigned int | startup, | |||
bool | wait_for_ready | |||
) |
Enable an oscillator with a given startup time.
osc | The oscillator to configure [INPUT] | |
startup | Oscillator startup time (one of AVR32_SCIF_OSCCTRLx_STARTUP_x_RCOSC) [INPUT] | |
wait_for_ready | Wait for the oscillator to be stable before return [INPUT] |
0 | Oscillator successfully started | |
<0 | Error starting the oscillator. |
Definition at line 291 of file scif_uc3c.c.
References u_avr32_scif_oscctrl_t::OSCCTRL, u_avr32_scif_oscctrl0_t::oscctrl0, u_avr32_scif_oscctrl0_t::OSCCTRL0, scif_pclksr_statushigh_wait(), and SCIF_UNLOCK.
00292 { 00293 00294 u_avr32_scif_oscctrl_t u_avr32_scif_oscctrl; 00295 00296 // Read Register 00297 u_avr32_scif_oscctrl.OSCCTRL[osc] = AVR32_SCIF.OSCCTRL[osc] ; 00298 // Modify: Configure the oscillator startup and enable the osc. 00299 u_avr32_scif_oscctrl.OSCCTRL[osc].startup = startup; 00300 u_avr32_scif_oscctrl.OSCCTRL[osc].oscen = ENABLE; 00301 AVR32_ENTER_CRITICAL_REGION( ); 00302 // Unlock the write-protected OSCCTRL0 register 00303 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL + 4*osc); 00304 // Write Back 00305 AVR32_SCIF.OSCCTRL[osc] = u_avr32_scif_oscctrl.OSCCTRL[osc]; 00306 AVR32_LEAVE_CRITICAL_REGION( ); 00307 00308 if(true == wait_for_ready) 00309 { 00310 // Wait until OSC0 is stable and ready to be used. 00311 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_OSC0RDY_MASK)) 00312 return -1; 00313 } 00314 00315 return PASS; 00316 }
long int scif_gc_enable | ( | unsigned int | gclk | ) |
Enable a generic clock.
gclk | generic clock number (0 for gc0...) |
0 | Success. | |
<0 | An error occured. |
Definition at line 662 of file scif_uc3c.c.
00663 { 00664 #ifdef AVR32SFW_INPUT_CHECK 00665 // Check that the generic clock number is correct 00666 if( gclk > AVR32_SCIF_GCLK_NUM ) 00667 { 00668 return -1; 00669 } 00670 #endif // AVR32SFW_INPUT_CHECK 00671 00672 // If the generic clock is already enabled, do nothing. 00673 if(!(AVR32_SCIF.gcctrl[gclk] & AVR32_SCIF_GCCTRL_CEN_MASK)) 00674 AVR32_SCIF.gcctrl[gclk] |= AVR32_SCIF_GCCTRL_CEN_MASK; 00675 00676 return PASS; 00677 00678 }
long int scif_gc_setup | ( | unsigned int | gclk, | |
scif_gcctrl_oscsel_t | clk_src, | |||
unsigned int | diven, | |||
unsigned int | divfactor | |||
) |
Setup a generic clock.
gclk | generic clock number (0 for gc0...) | |
clk_src | The input clock source to use for the generic clock | |
diven | Generic clock divisor enable | |
divfactor | Generic clock divisor |
0 | Success. | |
<0 | An error occured. |
Definition at line 614 of file scif_uc3c.c.
References SCIF_GCCTRL_OSCSEL_INVALID, and scif_stop_gclk().
00615 { 00616 int restart_gc = false; 00617 00618 00619 // Change the division factor to conform to the equation: fgclk = fsrc/divfactor = fsrc/(2*(div+1)) 00620 divfactor = (divfactor>>1) -1; 00621 00622 #ifdef AVR32SFW_INPUT_CHECK 00623 // Check that the generic clock number is correct 00624 if( gclk > AVR32_SCIF_GCLK_NUM ) 00625 { 00626 return -1; 00627 } 00628 // Check that the clock source for the generic clock is correct. 00629 if(( clk_src >= SCIF_GCCTRL_OSCSEL_INVALID ) || ( clk_src < 0 )) 00630 { 00631 return -1; 00632 } 00633 // Check that the required division factor is correct. 00634 if(diven) 00635 { 00636 if(divfactor >= (1<<AVR32_SCIF_GCCTRL_DIV_SIZE)) 00637 return -1; 00638 } 00639 #endif // AVR32SFW_INPUT_CHECK 00640 00641 // If the generic clock is already enabled, disable it before changing its setup. 00642 if(AVR32_SCIF.gcctrl[gclk] & AVR32_SCIF_GCCTRL_CEN_MASK) 00643 { 00644 restart_gc = true; 00645 if(scif_stop_gclk(gclk) < 0) 00646 return -1; // Could not stop the generic clock. 00647 } 00648 00649 // Setup the generic clock. 00650 AVR32_SCIF.gcctrl[gclk] = ((divfactor << AVR32_SCIF_GCCTRL_DIV_OFFSET)&AVR32_SCIF_GCCTRL_DIV_MASK) 00651 |((diven << AVR32_SCIF_GCCTRL_DIVEN_OFFSET)&AVR32_SCIF_GCCTRL_DIVEN_MASK) 00652 |((clk_src << AVR32_SCIF_GCCTRL_OSCSEL_OFFSET)&AVR32_SCIF_GCCTRL_OSCSEL_MASK); 00653 00654 // Restart the gc if it previously was enabled. 00655 if(true == restart_gc) 00656 AVR32_SCIF.gcctrl[gclk] |= AVR32_SCIF_GCCTRL_CEN_MASK ; 00657 00658 return PASS; 00659 }
__inline__ unsigned long scif_get_enabled_interrupts | ( | void | ) |
Read the SCIF currently enabled interrupts.
Definition at line 260 of file scif_uc3l.h.
__inline__ unsigned long scif_get_interrupts_status | ( | void | ) |
Read the interrupt status of the SCIF.
Definition at line 272 of file scif_uc3l.h.
__inline__ unsigned long scif_get_pclk_status | ( | void | ) |
Read the Power and Clocks Status of the SCIF.
Definition at line 303 of file scif_uc3l.h.
__inline__ bool scif_is_osc32_ready | ( | ) |
Is OSC32 stable and ready to be used as clock source?
true | oscillator stable and ready | |
false | oscillator not enabled or not ready. |
Definition at line 403 of file scif_uc3l.h.
00404 { 00405 return((AVR32_SCIF.pclksr & AVR32_SCIF_PCLKSR_OSC32RDY_MASK)>>AVR32_SCIF_PCLKSR_OSC32RDY_OFFSET); 00406 }
bool scif_is_osc_ready | ( | scif_osc_t | osc | ) |
Is an oscillator stable and ready to be used as clock source?
osc | The oscillator [INPUT] |
true | oscillator stable and ready | |
false | oscillator not enabled or not ready. |
Definition at line 197 of file scif_uc3c.c.
References SCIF_OSC0.
00198 { 00199 if (osc == SCIF_OSC0) 00200 { 00201 return((AVR32_SCIF.pclksr & AVR32_SCIF_PCLKSR_OSC0RDY_MASK)>>AVR32_SCIF_PCLKSR_OSC0RDY_OFFSET); 00202 } 00203 else 00204 { 00205 return((AVR32_SCIF.pclksr & AVR32_SCIF_PCLKSR_OSC1RDY_MASK)>>AVR32_SCIF_PCLKSR_OSC1RDY_OFFSET); 00206 } 00207 }
__inline__ void scif_osc32_1kout_dis | ( | ) |
__inline__ void scif_osc32_1kout_ena | ( | ) |
__inline__ void scif_osc32_32kout_dis | ( | ) |
__inline__ void scif_osc32_32kout_ena | ( | ) |
long int scif_pclksr_statushigh_wait | ( | unsigned long | statusMask | ) |
Wait for a status high in the Power and Clocks status register.
statusMask | Mask field of the status to poll [INPUT] |
0 | Status is high. | |
<0 | SCIF_POLL_TIMEOUT Timeout expired before the status was high. |
Misc
Wait for a status high in the Power and Clocks status register.
statusMask | Mask field of the status to poll [INPUT] |
0 | Status is high. | |
<0 | SCIF_POLL_TIMEOUT Timeout expired before the status was high. |
Definition at line 887 of file scif_uc3l.c.
References SCIF_POLL_TIMEOUT.
00888 { 00889 unsigned int timeout = SCIF_POLL_TIMEOUT; 00890 00891 while(!(AVR32_SCIF.pclksr & statusMask)) 00892 { 00893 if(--timeout == 0) 00894 return -1; 00895 } 00896 return PASS; 00897 }
long int scif_start_gclk | ( | unsigned int | gclk, | |
const scif_gclk_opt_t * | opt | |||
) |
Setup and start a generic clock.
gclk | The generic clock number to setup and start (cf. datasheet) | |
opt | The settings for the generic clock. |
0 | Success. | |
<0 | An error occured. |
Definition at line 559 of file scif_uc3c.c.
References scif_gclk_opt_t::clock_source, scif_gclk_opt_t::diven, scif_gclk_opt_t::divider, and SCIF_GCCTRL_OSCSEL_INVALID.
Referenced by local_start_gc().
00560 { 00561 #ifdef AVR32SFW_INPUT_CHECK 00562 // Check that the generic clock number is correct 00563 if( gclk > AVR32_SCIF_GCLK_NUM ) 00564 { 00565 return -1; 00566 } 00567 // Check that the clock source for the generic clock is correct. 00568 if(( opt->clock_source >= SCIF_GCCTRL_OSCSEL_INVALID ) || ( opt->clock_source < 0 )) 00569 { 00570 return -1; 00571 } 00572 #endif // AVR32SFW_INPUT_CHECK 00573 00574 // If the generic clock is already enabled, return an error. 00575 if(AVR32_SCIF.gcctrl[gclk] & AVR32_SCIF_GCCTRL_CEN_MASK) 00576 return -1; 00577 00578 // Configure & start the generic clock. 00579 AVR32_SCIF.gcctrl[gclk] = ((opt->divider << AVR32_SCIF_GCCTRL_DIV_OFFSET)&AVR32_SCIF_GCCTRL_DIV_MASK) 00580 |((opt->diven << AVR32_SCIF_GCCTRL_DIVEN_OFFSET)&AVR32_SCIF_GCCTRL_DIVEN_MASK) 00581 |((opt->clock_source << AVR32_SCIF_GCCTRL_OSCSEL_OFFSET)&AVR32_SCIF_GCCTRL_OSCSEL_MASK) 00582 |(AVR32_SCIF_GCCTRL_CEN_MASK); 00583 00584 return PASS; 00585 }
long int scif_start_osc | ( | scif_osc_t | osc, | |
const scif_osc_opt_t * | opt, | |||
bool | wait_for_ready | |||
) |
Configure and start an OSC0/OSC1 oscillator.
osc | The oscillator to start [INPUT] | |
opt | The configuration of the oscillator [INPUT] | |
wait_for_ready | Wait for the oscillator to be stable before return [INPUT] |
0 | Oscillator start successfull. | |
<0 | Error starting the oscillator. |
Power and Clocks Status Functions OSC0/OSC1 Functions
Definition at line 128 of file scif_uc3c.c.
References scif_osc_opt_t::freq_hz, scif_osc_opt_t::gain, scif_osc_opt_t::mode, u_avr32_scif_oscctrl_t::OSCCTRL, u_avr32_scif_oscctrl0_t::oscctrl0, u_avr32_scif_oscctrl0_t::OSCCTRL0, SCIF_EXT_CRYSTAL_MAX_FREQ_HZ, SCIF_EXT_CRYSTAL_MIN_FREQ_HZ, SCIF_OSC0, SCIF_OSC_MODE_2PIN_CRYSTAL, SCIF_OSC_MODE_EXT_CLK, scif_pclksr_statushigh_wait(), SCIF_UNLOCK, and scif_osc_opt_t::startup.
00129 { 00130 u_avr32_scif_oscctrl_t u_avr32_scif_oscctrl; 00131 00132 #ifdef AVR32SFW_INPUT_CHECK 00133 // Check that the input frequency is in the supported frequency range. 00134 if( (opt->freq_hz < SCIF_EXT_CRYSTAL_MIN_FREQ_HZ) 00135 || (opt->freq_hz > SCIF_EXT_CRYSTAL_MAX_FREQ_HZ)) 00136 { 00137 return -1; 00138 } 00139 // Check : for OSC0/OSC1, only 2 modes are supported 00140 if( (opt->mode != SCIF_OSC_MODE_EXT_CLK) 00141 && (opt->mode != SCIF_OSC_MODE_2PIN_CRYSTAL)) 00142 { 00143 return -1; 00144 } 00145 00146 if (osc == SCIF_OSC0) 00147 { 00148 // Check that the startup value is in the supported range. 00149 if(opt->startup > (unsigned char)AVR32_SCIF_OSCCTRL0_STARTUP_16384_RCOSC) 00150 { 00151 return -1; 00152 } 00153 // Check that the gain value is in the supported range. 00154 if(opt->gain > AVR32_SCIF_OSCCTRL0_GAIN_G3) 00155 { 00156 return -1; 00157 } 00158 } 00159 else 00160 { 00161 // Check that the startup value is in the supported range. 00162 if(opt->startup > (unsigned char)AVR32_SCIF_OSCCTRL1_STARTUP_16384_RCOSC) 00163 { 00164 return -1; 00165 } 00166 // Check that the gain value is in the supported range. 00167 if(opt->gain > AVR32_SCIF_OSCCTRL1_GAIN_G3) 00168 { 00169 return -1; 00170 } 00171 } 00172 #endif // AVR32SFW_INPUT_CHECK 00173 // Read Register 00174 u_avr32_scif_oscctrl.OSCCTRL[osc] = AVR32_SCIF.OSCCTRL[osc] ; 00175 // Modify: Configure & start OSC0. 00176 u_avr32_scif_oscctrl.OSCCTRL[osc].mode = opt->mode; 00177 u_avr32_scif_oscctrl.OSCCTRL[osc].gain = opt->gain; 00178 u_avr32_scif_oscctrl.OSCCTRL[osc].startup = opt->startup; 00179 u_avr32_scif_oscctrl.OSCCTRL[osc].oscen = ENABLE; 00180 AVR32_ENTER_CRITICAL_REGION( ); 00181 // Unlock the write-protected OSCCTRL0 register 00182 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL + 4*osc); 00183 // Write Back 00184 AVR32_SCIF.OSCCTRL[osc] = u_avr32_scif_oscctrl.OSCCTRL[osc]; 00185 AVR32_LEAVE_CRITICAL_REGION( ); 00186 00187 if(true == wait_for_ready) 00188 { 00189 // Wait until OSC0 is stable and ready to be used. 00190 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_OSC0RDY_MASK)) 00191 return -1; 00192 } 00193 return PASS; 00194 }
long int scif_start_osc32 | ( | const scif_osc32_opt_t * | opt, | |
bool | wait_for_ready | |||
) |
Configure and start the OSC32 oscillator.
opt | The configuration of the oscillator [INPUT] | |
wait_for_ready | Wait for the oscillator to be stable before return [INPUT] |
0 | Oscillator start successfull. | |
<0 | Error starting the oscillator. |
Definition at line 422 of file scif_uc3c.c.
References scif_osc32_opt_t::en1k, scif_osc32_opt_t::en32k, scif_osc32_opt_t::freq_hz, scif_osc32_opt_t::mode, u_avr32_scif_oscctrl32_t::OSCCTRL32, u_avr32_scif_oscctrl32_t::oscctrl32, scif_osc32_opt_t::pinsel, scif_disable_rc32out(), SCIF_EXT_CRYSTAL_MAX_FREQ_HZ, SCIF_EXT_CRYSTAL_MIN_FREQ_HZ, SCIF_OSC_MODE_2PIN_CRYSTAL, SCIF_OSC_MODE_EXT_CLK, SCIF_OSC_MODE_NOT_SUPPORTED_1, SCIF_OSC_MODE_NOT_SUPPORTED_2, scif_pclksr_statushigh_wait(), SCIF_UNLOCK, and scif_osc32_opt_t::startup.
Referenced by main().
00423 { 00424 u_avr32_scif_oscctrl32_t u_avr32_scif_oscctrl32; 00425 00426 00427 #ifdef AVR32SFW_INPUT_CHECK 00428 // Check that the input frequency is in the supported frequency range. 00429 if( (opt->freq_hz < SCIF_EXT_CRYSTAL_MIN_FREQ_HZ) 00430 || (opt->freq_hz > SCIF_EXT_CRYSTAL_MAX_FREQ_HZ)) 00431 { 00432 return -1; 00433 } 00434 // Check : for OSC0/OSC1, only 2 modes are supported 00435 if( (opt->mode < SCIF_OSC_MODE_EXT_CLK) 00436 || (opt->mode > SCIF_OSC_MODE_2PIN_CRYSTAL) 00437 || (opt->mode == SCIF_OSC_MODE_NOT_SUPPORTED_1) 00438 || (opt->mode == SCIF_OSC_MODE_NOT_SUPPORTED_2) ) 00439 { 00440 return -1; 00441 } 00442 // Check that the startup value is in the supported range. 00443 if(opt->startup > (unsigned char)AVR32_SCIF_OSCCTRL32_STARTUP_524288_RCOSC) 00444 { 00445 return -1; 00446 } 00447 #endif // AVR32SFW_INPUT_CHECK 00448 00449 // Read Register 00450 u_avr32_scif_oscctrl32.oscctrl32 = AVR32_SCIF.oscctrl32 ; 00451 00452 // Modify : Configure & start OSC32. 00453 u_avr32_scif_oscctrl32.OSCCTRL32.mode = opt->mode; 00454 u_avr32_scif_oscctrl32.OSCCTRL32.startup = opt->startup; 00455 u_avr32_scif_oscctrl32.OSCCTRL32.osc32en = ENABLE; 00456 00457 AVR32_ENTER_CRITICAL_REGION( ); 00458 // Unlock the write-protected OSCCTRL32 register 00459 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL32); 00460 00461 // Write Back 00462 AVR32_SCIF.oscctrl32 = u_avr32_scif_oscctrl32.oscctrl32; 00463 AVR32_LEAVE_CRITICAL_REGION( ); 00464 00465 if(true == wait_for_ready) 00466 { 00467 // Wait until OSC32 is stable and ready to be used. 00468 if(scif_pclksr_statushigh_wait(AVR32_SCIF_PCLKSR_OSC32RDY_MASK)) 00469 return -1; 00470 } 00471 00472 return PASS; 00473 }
void scif_start_rc120M | ( | void | ) |
Start the 120MHz internal RCosc (RC120M) clock.
Start the 120MHz internal RCosc (RC120M) clock.
Critical Path Oscillator Functions 120MHz RCosc Functions
Definition at line 532 of file scif_uc3c.c.
References SCIF_UNLOCK.
00533 { 00534 AVR32_ENTER_CRITICAL_REGION( ); 00535 // Unlock the write-protected RC120MCR register 00536 SCIF_UNLOCK(AVR32_SCIF_RC120MCR); 00537 AVR32_SCIF.rc120mcr = AVR32_SCIF_RC120MCR_EN_MASK; 00538 AVR32_LEAVE_CRITICAL_REGION( ); 00539 }
void scif_start_rc32k | ( | void | ) |
Start the 32kHz internal RCosc (RC32K) clock.
Definition at line 714 of file scif_uc3l.c.
References SCIF_UNLOCK.
00715 { 00716 AVR32_ENTER_CRITICAL_REGION( ); 00717 // Unlock the write-protected RC32KCR register 00718 SCIF_UNLOCK(AVR32_SCIF_RC32KCR); 00719 AVR32_SCIF.rc32kcr = AVR32_SCIF_RC32KCR_EN_MASK; 00720 AVR32_LEAVE_CRITICAL_REGION( ); 00721 }
long int scif_stop_gclk | ( | unsigned int | gclk | ) |
Stop a generic clock.
gclk | The generic clock number to stop. |
0 | Success. | |
<0 | Unable to stop generic clock. |
Definition at line 588 of file scif_uc3c.c.
References SCIF_POLL_TIMEOUT.
Referenced by scif_gc_setup().
00589 { 00590 unsigned int timeout = SCIF_POLL_TIMEOUT; 00591 00592 #ifdef AVR32SFW_INPUT_CHECK 00593 // Check that the generic clock number is correct 00594 if( gclk > AVR32_SCIF_GCLK_NUM ) 00595 { 00596 return -1; 00597 } 00598 #endif // AVR32SFW_INPUT_CHECK 00599 00600 // Stop the generic clock. 00601 AVR32_SCIF.gcctrl[gclk] &= ~AVR32_SCIF_GCCTRL_CEN_MASK; 00602 00603 // Wait until the generic clock is actually stopped. 00604 while(AVR32_SCIF.gcctrl[gclk] & AVR32_SCIF_GCCTRL_CEN_MASK) 00605 { 00606 if(--timeout == 0) 00607 return -1; 00608 } 00609 00610 return PASS; 00611 }
long int scif_stop_osc | ( | scif_osc_t | osc | ) |
Stop an oscillator.
osc | The oscillator to stop |
0 | Oscillator successfully stopped. | |
<0 | An error occured when stopping the oscillator. |
Definition at line 210 of file scif_uc3c.c.
References SCIF_UNLOCK.
00211 { 00212 00213 unsigned long temp; 00214 00215 temp = AVR32_SCIF.oscctrl[osc]; 00216 temp &= ~(AVR32_SCIF_OSCCTRL_OSCEN_DISABLE << AVR32_SCIF_OSCCTRL_OSCEN_OFFSET); 00217 AVR32_ENTER_CRITICAL_REGION( ); 00218 // Unlock the write-protected OSCCTRL0 register 00219 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL + 4*osc); 00220 // Stop OSC0. 00221 AVR32_SCIF.oscctrl[osc] = temp; 00222 AVR32_LEAVE_CRITICAL_REGION( ); 00223 00224 return PASS; 00225 }
long int scif_stop_osc32 | ( | ) |
Stop the OSC32 oscillator.
0 | Oscillator successfully stopped. | |
<0 | An error occured when stopping the oscillator. |
Definition at line 476 of file scif_uc3c.c.
References AVR32_SCIF_OSCCTRL32_OSC32EN_DISABLE, and SCIF_UNLOCK.
00477 { 00478 unsigned long temp = AVR32_SCIF.oscctrl32; 00479 temp &= ~(AVR32_SCIF_OSCCTRL32_OSC32EN_DISABLE << AVR32_SCIF_OSCCTRL32_OSC32EN_OFFSET); 00480 00481 AVR32_ENTER_CRITICAL_REGION( ); 00482 // Unlock the write-protected OSCCTRL32 register 00483 SCIF_UNLOCK(AVR32_SCIF_OSCCTRL32); 00484 00485 // Stop OSC32. 00486 AVR32_SCIF.oscctrl32 = temp; 00487 AVR32_LEAVE_CRITICAL_REGION( ); 00488 00489 return PASS; 00490 }
void scif_stop_rc120M | ( | void | ) |
Stop the 120MHz internal RCosc (RC120M) clock.
Definition at line 541 of file scif_uc3c.c.
References SCIF_UNLOCK.
00542 { 00543 unsigned long temp = AVR32_SCIF.rc120mcr; 00544 00545 AVR32_ENTER_CRITICAL_REGION( ); 00546 // Unlock the write-protected RC120MCR register 00547 SCIF_UNLOCK(AVR32_SCIF_RC120MCR); 00548 temp &= ~AVR32_SCIF_RC120MCR_EN_MASK; 00549 AVR32_SCIF.rc120mcr = temp; 00550 AVR32_LEAVE_CRITICAL_REGION( ); 00551 }
void scif_stop_rc32k | ( | void | ) |
Stop the 32kHz internal RCosc (RC32K) clock.
Definition at line 723 of file scif_uc3l.c.
References SCIF_UNLOCK.
00724 { 00725 unsigned long temp = AVR32_SCIF.rc32kcr; 00726 00727 temp &= ~AVR32_SCIF_RC32KCR_EN_MASK; 00728 AVR32_ENTER_CRITICAL_REGION( ); 00729 // Unlock the write-protected RC32KCR register 00730 SCIF_UNLOCK(AVR32_SCIF_RC32KCR); 00731 AVR32_SCIF.rc32kcr = temp; 00732 AVR32_LEAVE_CRITICAL_REGION( ); 00733 }