Johannes Stratmann / mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

Fork of mbed-dev by mbed official

targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/emlib/src/em_leuart.c@0:9b334a45a8ff, 2015-10-01 (annotated)

Committer:
bogdanm
Date:
Thu Oct 01 15:25:22 2015 +0300
Revision:
0:9b334a45a8ff
Child:
50:a417edff4437
Initial commit on mbed-dev



Replaces mbed-src (now inactive)

Who changed what in which revision?

UserRevisionLine numberNew contents of line
bogdanm 0:9b334a45a8ff 1 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 2 * @file em_leuart.c
bogdanm 0:9b334a45a8ff 3 * @brief Low Energy Universal Asynchronous Receiver/Transmitter (LEUART)
bogdanm 0:9b334a45a8ff 4 * Peripheral API
bogdanm 0:9b334a45a8ff 5 * @version 3.20.12
bogdanm 0:9b334a45a8ff 6 *******************************************************************************
bogdanm 0:9b334a45a8ff 7 * @section License
bogdanm 0:9b334a45a8ff 8 * <b>(C) Copyright 2014 Silicon Labs, http://www.silabs.com</b>
bogdanm 0:9b334a45a8ff 9 *******************************************************************************
bogdanm 0:9b334a45a8ff 10 *
bogdanm 0:9b334a45a8ff 11 * Permission is granted to anyone to use this software for any purpose,
bogdanm 0:9b334a45a8ff 12 * including commercial applications, and to alter it and redistribute it
bogdanm 0:9b334a45a8ff 13 * freely, subject to the following restrictions:
bogdanm 0:9b334a45a8ff 14 *
bogdanm 0:9b334a45a8ff 15 * 1. The origin of this software must not be misrepresented; you must not
bogdanm 0:9b334a45a8ff 16 * claim that you wrote the original software.
bogdanm 0:9b334a45a8ff 17 * 2. Altered source versions must be plainly marked as such, and must not be
bogdanm 0:9b334a45a8ff 18 * misrepresented as being the original software.
bogdanm 0:9b334a45a8ff 19 * 3. This notice may not be removed or altered from any source distribution.
bogdanm 0:9b334a45a8ff 20 *
bogdanm 0:9b334a45a8ff 21 * DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no
bogdanm 0:9b334a45a8ff 22 * obligation to support this Software. Silicon Labs is providing the
bogdanm 0:9b334a45a8ff 23 * Software "AS IS", with no express or implied warranties of any kind,
bogdanm 0:9b334a45a8ff 24 * including, but not limited to, any implied warranties of merchantability
bogdanm 0:9b334a45a8ff 25 * or fitness for any particular purpose or warranties against infringement
bogdanm 0:9b334a45a8ff 26 * of any proprietary rights of a third party.
bogdanm 0:9b334a45a8ff 27 *
bogdanm 0:9b334a45a8ff 28 * Silicon Labs will not be liable for any consequential, incidental, or
bogdanm 0:9b334a45a8ff 29 * special damages, or any other relief, or for any claim by any third party,
bogdanm 0:9b334a45a8ff 30 * arising from your use of this Software.
bogdanm 0:9b334a45a8ff 31 *
bogdanm 0:9b334a45a8ff 32 ******************************************************************************/
bogdanm 0:9b334a45a8ff 33
bogdanm 0:9b334a45a8ff 34
bogdanm 0:9b334a45a8ff 35 #include "em_leuart.h"
bogdanm 0:9b334a45a8ff 36 #if defined(LEUART_COUNT) && (LEUART_COUNT > 0)
bogdanm 0:9b334a45a8ff 37
bogdanm 0:9b334a45a8ff 38 #include "em_cmu.h"
bogdanm 0:9b334a45a8ff 39 #include "em_assert.h"
bogdanm 0:9b334a45a8ff 40
bogdanm 0:9b334a45a8ff 41 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 42 * @addtogroup EM_Library
bogdanm 0:9b334a45a8ff 43 * @{
bogdanm 0:9b334a45a8ff 44 ******************************************************************************/
bogdanm 0:9b334a45a8ff 45
bogdanm 0:9b334a45a8ff 46 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 47 * @addtogroup LEUART
bogdanm 0:9b334a45a8ff 48 * @brief Low Energy Universal Asynchronous Receiver/Transmitter (LEUART)
bogdanm 0:9b334a45a8ff 49 * Peripheral API
bogdanm 0:9b334a45a8ff 50 * @{
bogdanm 0:9b334a45a8ff 51 ******************************************************************************/
bogdanm 0:9b334a45a8ff 52
bogdanm 0:9b334a45a8ff 53 /*******************************************************************************
bogdanm 0:9b334a45a8ff 54 ******************************* DEFINES ***********************************
bogdanm 0:9b334a45a8ff 55 ******************************************************************************/
bogdanm 0:9b334a45a8ff 56
bogdanm 0:9b334a45a8ff 57 /** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
bogdanm 0:9b334a45a8ff 58
bogdanm 0:9b334a45a8ff 59
bogdanm 0:9b334a45a8ff 60 /** Validation of LEUART register block pointer reference
bogdanm 0:9b334a45a8ff 61 * for assert statements. */
bogdanm 0:9b334a45a8ff 62 #if (LEUART_COUNT == 1)
bogdanm 0:9b334a45a8ff 63 #define LEUART_REF_VALID(ref) ((ref) == LEUART0)
bogdanm 0:9b334a45a8ff 64 #elif (LEUART_COUNT == 2)
bogdanm 0:9b334a45a8ff 65 #define LEUART_REF_VALID(ref) (((ref) == LEUART0) || ((ref) == LEUART1))
bogdanm 0:9b334a45a8ff 66 #else
bogdanm 0:9b334a45a8ff 67 #error Undefined number of low energy UARTs (LEUART).
bogdanm 0:9b334a45a8ff 68 #endif
bogdanm 0:9b334a45a8ff 69
bogdanm 0:9b334a45a8ff 70 /** @endcond */
bogdanm 0:9b334a45a8ff 71
bogdanm 0:9b334a45a8ff 72 /*******************************************************************************
bogdanm 0:9b334a45a8ff 73 ************************** LOCAL FUNCTIONS ********************************
bogdanm 0:9b334a45a8ff 74 ******************************************************************************/
bogdanm 0:9b334a45a8ff 75
bogdanm 0:9b334a45a8ff 76 /** @cond DO_NOT_INCLUDE_WITH_DOXYGEN */
bogdanm 0:9b334a45a8ff 77
bogdanm 0:9b334a45a8ff 78 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 79 * @brief
bogdanm 0:9b334a45a8ff 80 * Wait for ongoing sync of register(s) to low frequency domain to complete.
bogdanm 0:9b334a45a8ff 81 *
bogdanm 0:9b334a45a8ff 82 * @param[in] leuart
bogdanm 0:9b334a45a8ff 83 * Pointer to LEUART peripheral register block
bogdanm 0:9b334a45a8ff 84 *
bogdanm 0:9b334a45a8ff 85 * @param[in] mask
bogdanm 0:9b334a45a8ff 86 * Bitmask corresponding to SYNCBUSY register defined bits, indicating
bogdanm 0:9b334a45a8ff 87 * registers that must complete any ongoing synchronization.
bogdanm 0:9b334a45a8ff 88 ******************************************************************************/
bogdanm 0:9b334a45a8ff 89 __STATIC_INLINE void LEUART_Sync(LEUART_TypeDef *leuart, uint32_t mask)
bogdanm 0:9b334a45a8ff 90 {
bogdanm 0:9b334a45a8ff 91 /* Avoid deadlock if modifying the same register twice when freeze mode is */
bogdanm 0:9b334a45a8ff 92 /* activated. */
bogdanm 0:9b334a45a8ff 93 if (leuart->FREEZE & LEUART_FREEZE_REGFREEZE)
bogdanm 0:9b334a45a8ff 94 {
bogdanm 0:9b334a45a8ff 95 return;
bogdanm 0:9b334a45a8ff 96 }
bogdanm 0:9b334a45a8ff 97
bogdanm 0:9b334a45a8ff 98 /* Wait for any pending previous write operation to have been completed */
bogdanm 0:9b334a45a8ff 99 /* in low frequency domain */
bogdanm 0:9b334a45a8ff 100 while (leuart->SYNCBUSY & mask)
bogdanm 0:9b334a45a8ff 101 ;
bogdanm 0:9b334a45a8ff 102 }
bogdanm 0:9b334a45a8ff 103
bogdanm 0:9b334a45a8ff 104 /** @endcond */
bogdanm 0:9b334a45a8ff 105
bogdanm 0:9b334a45a8ff 106 /*******************************************************************************
bogdanm 0:9b334a45a8ff 107 ************************** GLOBAL FUNCTIONS *******************************
bogdanm 0:9b334a45a8ff 108 ******************************************************************************/
bogdanm 0:9b334a45a8ff 109
bogdanm 0:9b334a45a8ff 110 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 111 * @brief
bogdanm 0:9b334a45a8ff 112 * Calculate baudrate for LEUART given reference frequency and clock division.
bogdanm 0:9b334a45a8ff 113 *
bogdanm 0:9b334a45a8ff 114 * @details
bogdanm 0:9b334a45a8ff 115 * This function returns the baudrate that a LEUART module will use if
bogdanm 0:9b334a45a8ff 116 * configured with the given frequency and clock divisor. Notice that
bogdanm 0:9b334a45a8ff 117 * this function will not use actual HW configuration. It can be used
bogdanm 0:9b334a45a8ff 118 * to determinate if a given configuration is sufficiently accurate for the
bogdanm 0:9b334a45a8ff 119 * application.
bogdanm 0:9b334a45a8ff 120 *
bogdanm 0:9b334a45a8ff 121 * @param[in] refFreq
bogdanm 0:9b334a45a8ff 122 * LEUART peripheral frequency used.
bogdanm 0:9b334a45a8ff 123 *
bogdanm 0:9b334a45a8ff 124 * @param[in] clkdiv
bogdanm 0:9b334a45a8ff 125 * Clock division factor to be used.
bogdanm 0:9b334a45a8ff 126 *
bogdanm 0:9b334a45a8ff 127 * @return
bogdanm 0:9b334a45a8ff 128 * Baudrate with given settings.
bogdanm 0:9b334a45a8ff 129 ******************************************************************************/
bogdanm 0:9b334a45a8ff 130 uint32_t LEUART_BaudrateCalc(uint32_t refFreq, uint32_t clkdiv)
bogdanm 0:9b334a45a8ff 131 {
bogdanm 0:9b334a45a8ff 132 uint32_t divisor;
bogdanm 0:9b334a45a8ff 133 uint32_t remainder;
bogdanm 0:9b334a45a8ff 134 uint32_t quotient;
bogdanm 0:9b334a45a8ff 135 uint32_t br;
bogdanm 0:9b334a45a8ff 136
bogdanm 0:9b334a45a8ff 137 /* Mask out unused bits */
bogdanm 0:9b334a45a8ff 138 clkdiv &= _LEUART_CLKDIV_MASK;
bogdanm 0:9b334a45a8ff 139
bogdanm 0:9b334a45a8ff 140 /* We want to use integer division to avoid forcing in float division */
bogdanm 0:9b334a45a8ff 141 /* utils, and yet keep rounding effect errors to a minimum. */
bogdanm 0:9b334a45a8ff 142
bogdanm 0:9b334a45a8ff 143 /*
bogdanm 0:9b334a45a8ff 144 * Baudrate is given by:
bogdanm 0:9b334a45a8ff 145 *
bogdanm 0:9b334a45a8ff 146 * br = fLEUARTn/(1 + (CLKDIV / 256))
bogdanm 0:9b334a45a8ff 147 *
bogdanm 0:9b334a45a8ff 148 * which can be rewritten to
bogdanm 0:9b334a45a8ff 149 *
bogdanm 0:9b334a45a8ff 150 * br = (256 * fLEUARTn)/(256 + CLKDIV)
bogdanm 0:9b334a45a8ff 151 *
bogdanm 0:9b334a45a8ff 152 * Normally, with fLEUARTn appr 32768Hz, there is no problem with overflow
bogdanm 0:9b334a45a8ff 153 * if using 32 bit arithmetic. However, since fLEUARTn may be derived from
bogdanm 0:9b334a45a8ff 154 * HFCORECLK as well, we must consider overflow when using integer arithmetic.
bogdanm 0:9b334a45a8ff 155 */
bogdanm 0:9b334a45a8ff 156
bogdanm 0:9b334a45a8ff 157 /*
bogdanm 0:9b334a45a8ff 158 * The basic problem with integer division in the above formula is that
bogdanm 0:9b334a45a8ff 159 * the dividend (256 * fLEUARTn) may become higher than max 32 bit
bogdanm 0:9b334a45a8ff 160 * integer. Yet we want to evaluate dividend first before dividing in
bogdanm 0:9b334a45a8ff 161 * order to get as small rounding effects as possible. We do not want
bogdanm 0:9b334a45a8ff 162 * to make too harsh restrictions on max fLEUARTn value either.
bogdanm 0:9b334a45a8ff 163 *
bogdanm 0:9b334a45a8ff 164 * For division a/b, we can write
bogdanm 0:9b334a45a8ff 165 *
bogdanm 0:9b334a45a8ff 166 * a = qb + r
bogdanm 0:9b334a45a8ff 167 *
bogdanm 0:9b334a45a8ff 168 * where q is the quotient and r is the remainder, both integers.
bogdanm 0:9b334a45a8ff 169 *
bogdanm 0:9b334a45a8ff 170 * The orignal baudrate formula can be rewritten as
bogdanm 0:9b334a45a8ff 171 *
bogdanm 0:9b334a45a8ff 172 * br = 256a / b = 256(qb + r)/b = 256q + 256r/b
bogdanm 0:9b334a45a8ff 173 *
bogdanm 0:9b334a45a8ff 174 * where a is 'refFreq' and b is 'divisor', referring to variable names.
bogdanm 0:9b334a45a8ff 175 */
bogdanm 0:9b334a45a8ff 176
bogdanm 0:9b334a45a8ff 177 divisor = 256 + clkdiv;
bogdanm 0:9b334a45a8ff 178
bogdanm 0:9b334a45a8ff 179 quotient = refFreq / divisor;
bogdanm 0:9b334a45a8ff 180 remainder = refFreq % divisor;
bogdanm 0:9b334a45a8ff 181
bogdanm 0:9b334a45a8ff 182 /* Since divisor >= 256, the below cannot exceed max 32 bit value. */
bogdanm 0:9b334a45a8ff 183 br = 256 * quotient;
bogdanm 0:9b334a45a8ff 184
bogdanm 0:9b334a45a8ff 185 /*
bogdanm 0:9b334a45a8ff 186 * Remainder < (256 + clkdiv), which means dividend (256 * remainder) worst case is
bogdanm 0:9b334a45a8ff 187 * 256*(256 + 0x7ff8) = 0x80F800.
bogdanm 0:9b334a45a8ff 188 */
bogdanm 0:9b334a45a8ff 189 br += (256 * remainder) / divisor;
bogdanm 0:9b334a45a8ff 190
bogdanm 0:9b334a45a8ff 191 return br;
bogdanm 0:9b334a45a8ff 192 }
bogdanm 0:9b334a45a8ff 193
bogdanm 0:9b334a45a8ff 194
bogdanm 0:9b334a45a8ff 195 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 196 * @brief
bogdanm 0:9b334a45a8ff 197 * Get current baudrate for LEUART.
bogdanm 0:9b334a45a8ff 198 *
bogdanm 0:9b334a45a8ff 199 * @details
bogdanm 0:9b334a45a8ff 200 * This function returns the actual baudrate (not considering oscillator
bogdanm 0:9b334a45a8ff 201 * inaccuracies) used by a LEUART peripheral.
bogdanm 0:9b334a45a8ff 202 *
bogdanm 0:9b334a45a8ff 203 * @param[in] leuart
bogdanm 0:9b334a45a8ff 204 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 205 *
bogdanm 0:9b334a45a8ff 206 * @return
bogdanm 0:9b334a45a8ff 207 * Current baudrate.
bogdanm 0:9b334a45a8ff 208 ******************************************************************************/
bogdanm 0:9b334a45a8ff 209 uint32_t LEUART_BaudrateGet(LEUART_TypeDef *leuart)
bogdanm 0:9b334a45a8ff 210 {
bogdanm 0:9b334a45a8ff 211 uint32_t freq;
bogdanm 0:9b334a45a8ff 212 CMU_Clock_TypeDef clock;
bogdanm 0:9b334a45a8ff 213
bogdanm 0:9b334a45a8ff 214 /* Get current frequency */
bogdanm 0:9b334a45a8ff 215 if (leuart == LEUART0)
bogdanm 0:9b334a45a8ff 216 {
bogdanm 0:9b334a45a8ff 217 clock = cmuClock_LEUART0;
bogdanm 0:9b334a45a8ff 218 }
bogdanm 0:9b334a45a8ff 219 #if (LEUART_COUNT > 1)
bogdanm 0:9b334a45a8ff 220 else if (leuart == LEUART1)
bogdanm 0:9b334a45a8ff 221 {
bogdanm 0:9b334a45a8ff 222 clock = cmuClock_LEUART1;
bogdanm 0:9b334a45a8ff 223 }
bogdanm 0:9b334a45a8ff 224 #endif
bogdanm 0:9b334a45a8ff 225 else
bogdanm 0:9b334a45a8ff 226 {
bogdanm 0:9b334a45a8ff 227 EFM_ASSERT(0);
bogdanm 0:9b334a45a8ff 228 return 0;
bogdanm 0:9b334a45a8ff 229 }
bogdanm 0:9b334a45a8ff 230
bogdanm 0:9b334a45a8ff 231 freq = CMU_ClockFreqGet(clock);
bogdanm 0:9b334a45a8ff 232
bogdanm 0:9b334a45a8ff 233 return LEUART_BaudrateCalc(freq, leuart->CLKDIV);
bogdanm 0:9b334a45a8ff 234 }
bogdanm 0:9b334a45a8ff 235
bogdanm 0:9b334a45a8ff 236
bogdanm 0:9b334a45a8ff 237 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 238 * @brief
bogdanm 0:9b334a45a8ff 239 * Configure baudrate (or as close as possible to specified baudrate).
bogdanm 0:9b334a45a8ff 240 *
bogdanm 0:9b334a45a8ff 241 * @note
bogdanm 0:9b334a45a8ff 242 * The setting of a baudrate requires synchronization into the
bogdanm 0:9b334a45a8ff 243 * low frequency domain. If the same register is modified before a previous
bogdanm 0:9b334a45a8ff 244 * update has completed, this function will stall until the previous
bogdanm 0:9b334a45a8ff 245 * synchronization has completed.
bogdanm 0:9b334a45a8ff 246 *
bogdanm 0:9b334a45a8ff 247 * @param[in] leuart
bogdanm 0:9b334a45a8ff 248 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 249 *
bogdanm 0:9b334a45a8ff 250 * @param[in] refFreq
bogdanm 0:9b334a45a8ff 251 * LEUART reference clock frequency in Hz that will be used. If set to 0,
bogdanm 0:9b334a45a8ff 252 * the currently configured reference clock is assumed.
bogdanm 0:9b334a45a8ff 253 *
bogdanm 0:9b334a45a8ff 254 * @param[in] baudrate
bogdanm 0:9b334a45a8ff 255 * Baudrate to try to achieve for LEUART.
bogdanm 0:9b334a45a8ff 256 ******************************************************************************/
bogdanm 0:9b334a45a8ff 257 void LEUART_BaudrateSet(LEUART_TypeDef *leuart,
bogdanm 0:9b334a45a8ff 258 uint32_t refFreq,
bogdanm 0:9b334a45a8ff 259 uint32_t baudrate)
bogdanm 0:9b334a45a8ff 260 {
bogdanm 0:9b334a45a8ff 261 uint32_t clkdiv;
bogdanm 0:9b334a45a8ff 262 CMU_Clock_TypeDef clock;
bogdanm 0:9b334a45a8ff 263
bogdanm 0:9b334a45a8ff 264 /* Inhibit divide by 0 */
bogdanm 0:9b334a45a8ff 265 EFM_ASSERT(baudrate);
bogdanm 0:9b334a45a8ff 266
bogdanm 0:9b334a45a8ff 267 /*
bogdanm 0:9b334a45a8ff 268 * We want to use integer division to avoid forcing in float division
bogdanm 0:9b334a45a8ff 269 * utils, and yet keep rounding effect errors to a minimum.
bogdanm 0:9b334a45a8ff 270 *
bogdanm 0:9b334a45a8ff 271 * CLKDIV in asynchronous mode is given by:
bogdanm 0:9b334a45a8ff 272 *
bogdanm 0:9b334a45a8ff 273 * CLKDIV = 256*(fLEUARTn/br - 1) = ((256*fLEUARTn)/br) - 256
bogdanm 0:9b334a45a8ff 274 *
bogdanm 0:9b334a45a8ff 275 * Normally, with fLEUARTn appr 32768Hz, there is no problem with overflow
bogdanm 0:9b334a45a8ff 276 * if using 32 bit arithmetic. However, since fLEUARTn may be derived from
bogdanm 0:9b334a45a8ff 277 * HFCORECLK as well, we must consider overflow when using integer arithmetic.
bogdanm 0:9b334a45a8ff 278 *
bogdanm 0:9b334a45a8ff 279 * The basic problem with integer division in the above formula is that
bogdanm 0:9b334a45a8ff 280 * the dividend (256 * fLEUARTn) may become higher than max 32 bit
bogdanm 0:9b334a45a8ff 281 * integer. Yet, we want to evaluate dividend first before dividing in
bogdanm 0:9b334a45a8ff 282 * order to get as small rounding effects as possible. We do not want
bogdanm 0:9b334a45a8ff 283 * to make too harsh restrictions on max fLEUARTn value either.
bogdanm 0:9b334a45a8ff 284 *
bogdanm 0:9b334a45a8ff 285 * Since the last 3 bits of CLKDIV are don't care, we can base our
bogdanm 0:9b334a45a8ff 286 * integer arithmetic on the below formula
bogdanm 0:9b334a45a8ff 287 *
bogdanm 0:9b334a45a8ff 288 * CLKDIV/8 = ((32*fLEUARTn)/br) - 32
bogdanm 0:9b334a45a8ff 289 *
bogdanm 0:9b334a45a8ff 290 * and calculate 1/8 of CLKDIV first. This allows for fLEUARTn
bogdanm 0:9b334a45a8ff 291 * up to 128MHz without overflowing a 32 bit value!
bogdanm 0:9b334a45a8ff 292 */
bogdanm 0:9b334a45a8ff 293
bogdanm 0:9b334a45a8ff 294 /* Get current frequency? */
bogdanm 0:9b334a45a8ff 295 if (!refFreq)
bogdanm 0:9b334a45a8ff 296 {
bogdanm 0:9b334a45a8ff 297 if (leuart == LEUART0)
bogdanm 0:9b334a45a8ff 298 {
bogdanm 0:9b334a45a8ff 299 clock = cmuClock_LEUART0;
bogdanm 0:9b334a45a8ff 300 }
bogdanm 0:9b334a45a8ff 301 #if (LEUART_COUNT > 1)
bogdanm 0:9b334a45a8ff 302 else if (leuart == LEUART1)
bogdanm 0:9b334a45a8ff 303 {
bogdanm 0:9b334a45a8ff 304 clock = cmuClock_LEUART1;
bogdanm 0:9b334a45a8ff 305 }
bogdanm 0:9b334a45a8ff 306 #endif
bogdanm 0:9b334a45a8ff 307 else
bogdanm 0:9b334a45a8ff 308 {
bogdanm 0:9b334a45a8ff 309 EFM_ASSERT(0);
bogdanm 0:9b334a45a8ff 310 return;
bogdanm 0:9b334a45a8ff 311 }
bogdanm 0:9b334a45a8ff 312
bogdanm 0:9b334a45a8ff 313 refFreq = CMU_ClockFreqGet(clock);
bogdanm 0:9b334a45a8ff 314 }
bogdanm 0:9b334a45a8ff 315
bogdanm 0:9b334a45a8ff 316 /* Calculate and set CLKDIV with fractional bits */
bogdanm 0:9b334a45a8ff 317 clkdiv = (32 * refFreq) / baudrate;
bogdanm 0:9b334a45a8ff 318 clkdiv -= 32;
bogdanm 0:9b334a45a8ff 319 clkdiv *= 8;
bogdanm 0:9b334a45a8ff 320
bogdanm 0:9b334a45a8ff 321 /* Verify that resulting clock divider is within limits */
bogdanm 0:9b334a45a8ff 322 EFM_ASSERT(clkdiv <= _LEUART_CLKDIV_MASK);
bogdanm 0:9b334a45a8ff 323
bogdanm 0:9b334a45a8ff 324 /* If EFM_ASSERT is not enabled, make sure we don't write to reserved bits */
bogdanm 0:9b334a45a8ff 325 clkdiv &= _LEUART_CLKDIV_MASK;
bogdanm 0:9b334a45a8ff 326
bogdanm 0:9b334a45a8ff 327 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 328 LEUART_Sync(leuart, LEUART_SYNCBUSY_CLKDIV);
bogdanm 0:9b334a45a8ff 329
bogdanm 0:9b334a45a8ff 330 leuart->CLKDIV = clkdiv;
bogdanm 0:9b334a45a8ff 331 }
bogdanm 0:9b334a45a8ff 332
bogdanm 0:9b334a45a8ff 333
bogdanm 0:9b334a45a8ff 334 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 335 * @brief
bogdanm 0:9b334a45a8ff 336 * Enable/disable LEUART receiver and/or transmitter.
bogdanm 0:9b334a45a8ff 337 *
bogdanm 0:9b334a45a8ff 338 * @details
bogdanm 0:9b334a45a8ff 339 * Notice that this function does not do any configuration. Enabling should
bogdanm 0:9b334a45a8ff 340 * normally be done after initialization is done (if not enabled as part
bogdanm 0:9b334a45a8ff 341 * of init).
bogdanm 0:9b334a45a8ff 342 *
bogdanm 0:9b334a45a8ff 343 * @note
bogdanm 0:9b334a45a8ff 344 * Enabling/disabling requires synchronization into the low frequency domain.
bogdanm 0:9b334a45a8ff 345 * If the same register is modified before a previous update has completed,
bogdanm 0:9b334a45a8ff 346 * this function will stall until the previous synchronization has completed.
bogdanm 0:9b334a45a8ff 347 *
bogdanm 0:9b334a45a8ff 348 * @param[in] leuart
bogdanm 0:9b334a45a8ff 349 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 350 *
bogdanm 0:9b334a45a8ff 351 * @param[in] enable
bogdanm 0:9b334a45a8ff 352 * Select status for receiver/transmitter.
bogdanm 0:9b334a45a8ff 353 ******************************************************************************/
bogdanm 0:9b334a45a8ff 354 void LEUART_Enable(LEUART_TypeDef *leuart, LEUART_Enable_TypeDef enable)
bogdanm 0:9b334a45a8ff 355 {
bogdanm 0:9b334a45a8ff 356 uint32_t tmp;
bogdanm 0:9b334a45a8ff 357
bogdanm 0:9b334a45a8ff 358 /* Make sure the module exists on the selected chip */
bogdanm 0:9b334a45a8ff 359 EFM_ASSERT(LEUART_REF_VALID(leuart));
bogdanm 0:9b334a45a8ff 360
bogdanm 0:9b334a45a8ff 361 /* Disable as specified */
bogdanm 0:9b334a45a8ff 362 tmp = ~((uint32_t)(enable));
bogdanm 0:9b334a45a8ff 363 tmp &= (_LEUART_CMD_RXEN_MASK | _LEUART_CMD_TXEN_MASK);
bogdanm 0:9b334a45a8ff 364 tmp <<= 1;
bogdanm 0:9b334a45a8ff 365 /* Enable as specified */
bogdanm 0:9b334a45a8ff 366 tmp |= (uint32_t)(enable);
bogdanm 0:9b334a45a8ff 367
bogdanm 0:9b334a45a8ff 368 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 369 LEUART_Sync(leuart, LEUART_SYNCBUSY_CMD);
bogdanm 0:9b334a45a8ff 370
bogdanm 0:9b334a45a8ff 371 leuart->CMD = tmp;
bogdanm 0:9b334a45a8ff 372 }
bogdanm 0:9b334a45a8ff 373
bogdanm 0:9b334a45a8ff 374
bogdanm 0:9b334a45a8ff 375 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 376 * @brief
bogdanm 0:9b334a45a8ff 377 * LEUART register synchronization freeze control.
bogdanm 0:9b334a45a8ff 378 *
bogdanm 0:9b334a45a8ff 379 * @details
bogdanm 0:9b334a45a8ff 380 * Some LEUART registers require synchronization into the low frequency (LF)
bogdanm 0:9b334a45a8ff 381 * domain. The freeze feature allows for several such registers to be
bogdanm 0:9b334a45a8ff 382 * modified before passing them to the LF domain simultaneously (which
bogdanm 0:9b334a45a8ff 383 * takes place when the freeze mode is disabled).
bogdanm 0:9b334a45a8ff 384 *
bogdanm 0:9b334a45a8ff 385 * @note
bogdanm 0:9b334a45a8ff 386 * When enabling freeze mode, this function will wait for all current
bogdanm 0:9b334a45a8ff 387 * ongoing LEUART synchronization to LF domain to complete (Normally
bogdanm 0:9b334a45a8ff 388 * synchronization will not be in progress.) However for this reason, when
bogdanm 0:9b334a45a8ff 389 * using freeze mode, modifications of registers requiring LF synchronization
bogdanm 0:9b334a45a8ff 390 * should be done within one freeze enable/disable block to avoid unecessary
bogdanm 0:9b334a45a8ff 391 * stalling.
bogdanm 0:9b334a45a8ff 392 *
bogdanm 0:9b334a45a8ff 393 * @param[in] leuart
bogdanm 0:9b334a45a8ff 394 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 395 *
bogdanm 0:9b334a45a8ff 396 * @param[in] enable
bogdanm 0:9b334a45a8ff 397 * @li true - enable freeze, modified registers are not propagated to the
bogdanm 0:9b334a45a8ff 398 * LF domain
bogdanm 0:9b334a45a8ff 399 * @li false - disables freeze, modified registers are propagated to LF
bogdanm 0:9b334a45a8ff 400 * domain
bogdanm 0:9b334a45a8ff 401 ******************************************************************************/
bogdanm 0:9b334a45a8ff 402 void LEUART_FreezeEnable(LEUART_TypeDef *leuart, bool enable)
bogdanm 0:9b334a45a8ff 403 {
bogdanm 0:9b334a45a8ff 404 if (enable)
bogdanm 0:9b334a45a8ff 405 {
bogdanm 0:9b334a45a8ff 406 /*
bogdanm 0:9b334a45a8ff 407 * Wait for any ongoing LF synchronization to complete. This is just to
bogdanm 0:9b334a45a8ff 408 * protect against the rare case when a user
bogdanm 0:9b334a45a8ff 409 * - modifies a register requiring LF sync
bogdanm 0:9b334a45a8ff 410 * - then enables freeze before LF sync completed
bogdanm 0:9b334a45a8ff 411 * - then modifies the same register again
bogdanm 0:9b334a45a8ff 412 * since modifying a register while it is in sync progress should be
bogdanm 0:9b334a45a8ff 413 * avoided.
bogdanm 0:9b334a45a8ff 414 */
bogdanm 0:9b334a45a8ff 415 while (leuart->SYNCBUSY)
bogdanm 0:9b334a45a8ff 416 ;
bogdanm 0:9b334a45a8ff 417
bogdanm 0:9b334a45a8ff 418 leuart->FREEZE = LEUART_FREEZE_REGFREEZE;
bogdanm 0:9b334a45a8ff 419 }
bogdanm 0:9b334a45a8ff 420 else
bogdanm 0:9b334a45a8ff 421 {
bogdanm 0:9b334a45a8ff 422 leuart->FREEZE = 0;
bogdanm 0:9b334a45a8ff 423 }
bogdanm 0:9b334a45a8ff 424 }
bogdanm 0:9b334a45a8ff 425
bogdanm 0:9b334a45a8ff 426
bogdanm 0:9b334a45a8ff 427 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 428 * @brief
bogdanm 0:9b334a45a8ff 429 * Init LEUART.
bogdanm 0:9b334a45a8ff 430 *
bogdanm 0:9b334a45a8ff 431 * @details
bogdanm 0:9b334a45a8ff 432 * This function will configure basic settings in order to operate in normal
bogdanm 0:9b334a45a8ff 433 * asynchronous mode. Consider using LEUART_Reset() prior to this function if
bogdanm 0:9b334a45a8ff 434 * state of configuration is not known, since only configuration settings
bogdanm 0:9b334a45a8ff 435 * specified by @p init are set.
bogdanm 0:9b334a45a8ff 436 *
bogdanm 0:9b334a45a8ff 437 * Special control setup not covered by this function may be done either
bogdanm 0:9b334a45a8ff 438 * before or after using this function (but normally before enabling)
bogdanm 0:9b334a45a8ff 439 * by direct modification of the CTRL register.
bogdanm 0:9b334a45a8ff 440 *
bogdanm 0:9b334a45a8ff 441 * Notice that pins used by the LEUART module must be properly configured
bogdanm 0:9b334a45a8ff 442 * by the user explicitly, in order for the LEUART to work as intended.
bogdanm 0:9b334a45a8ff 443 * (When configuring pins, one should remember to consider the sequence of
bogdanm 0:9b334a45a8ff 444 * configuration, in order to avoid unintended pulses/glitches on output
bogdanm 0:9b334a45a8ff 445 * pins.)
bogdanm 0:9b334a45a8ff 446 *
bogdanm 0:9b334a45a8ff 447 * @note
bogdanm 0:9b334a45a8ff 448 * Initializing requires synchronization into the low frequency domain.
bogdanm 0:9b334a45a8ff 449 * If the same register is modified before a previous update has completed,
bogdanm 0:9b334a45a8ff 450 * this function will stall until the previous synchronization has completed.
bogdanm 0:9b334a45a8ff 451 *
bogdanm 0:9b334a45a8ff 452 * @param[in] leuart
bogdanm 0:9b334a45a8ff 453 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 454 *
bogdanm 0:9b334a45a8ff 455 * @param[in] init
bogdanm 0:9b334a45a8ff 456 * Pointer to initialization structure used to configure basic async setup.
bogdanm 0:9b334a45a8ff 457 ******************************************************************************/
bogdanm 0:9b334a45a8ff 458 void LEUART_Init(LEUART_TypeDef *leuart, LEUART_Init_TypeDef const *init)
bogdanm 0:9b334a45a8ff 459 {
bogdanm 0:9b334a45a8ff 460 /* Make sure the module exists on the selected chip */
bogdanm 0:9b334a45a8ff 461 EFM_ASSERT(LEUART_REF_VALID(leuart));
bogdanm 0:9b334a45a8ff 462
bogdanm 0:9b334a45a8ff 463 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 464 LEUART_Sync(leuart, LEUART_SYNCBUSY_CMD);
bogdanm 0:9b334a45a8ff 465
bogdanm 0:9b334a45a8ff 466 /* Ensure disabled while doing config */
bogdanm 0:9b334a45a8ff 467 leuart->CMD = LEUART_CMD_RXDIS | LEUART_CMD_TXDIS;
bogdanm 0:9b334a45a8ff 468
bogdanm 0:9b334a45a8ff 469 /* Freeze registers to avoid stalling for LF synchronization */
bogdanm 0:9b334a45a8ff 470 LEUART_FreezeEnable(leuart, true);
bogdanm 0:9b334a45a8ff 471
bogdanm 0:9b334a45a8ff 472 /* Configure databits and stopbits */
bogdanm 0:9b334a45a8ff 473 leuart->CTRL = (leuart->CTRL & ~(_LEUART_CTRL_PARITY_MASK |
bogdanm 0:9b334a45a8ff 474 _LEUART_CTRL_STOPBITS_MASK)) |
bogdanm 0:9b334a45a8ff 475 (uint32_t)(init->databits) |
bogdanm 0:9b334a45a8ff 476 (uint32_t)(init->parity) |
bogdanm 0:9b334a45a8ff 477 (uint32_t)(init->stopbits);
bogdanm 0:9b334a45a8ff 478
bogdanm 0:9b334a45a8ff 479 /* Configure baudrate */
bogdanm 0:9b334a45a8ff 480 LEUART_BaudrateSet(leuart, init->refFreq, init->baudrate);
bogdanm 0:9b334a45a8ff 481
bogdanm 0:9b334a45a8ff 482 /* Finally enable (as specified) */
bogdanm 0:9b334a45a8ff 483 leuart->CMD = (uint32_t)(init->enable);
bogdanm 0:9b334a45a8ff 484
bogdanm 0:9b334a45a8ff 485 /* Unfreeze registers, pass new settings on to LEUART */
bogdanm 0:9b334a45a8ff 486 LEUART_FreezeEnable(leuart, false);
bogdanm 0:9b334a45a8ff 487 }
bogdanm 0:9b334a45a8ff 488
bogdanm 0:9b334a45a8ff 489
bogdanm 0:9b334a45a8ff 490 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 491 * @brief
bogdanm 0:9b334a45a8ff 492 * Reset LEUART to same state as after a HW reset.
bogdanm 0:9b334a45a8ff 493 *
bogdanm 0:9b334a45a8ff 494 * @param[in] leuart
bogdanm 0:9b334a45a8ff 495 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 496 ******************************************************************************/
bogdanm 0:9b334a45a8ff 497 void LEUART_Reset(LEUART_TypeDef *leuart)
bogdanm 0:9b334a45a8ff 498 {
bogdanm 0:9b334a45a8ff 499 /* Make sure the module exists on the selected chip */
bogdanm 0:9b334a45a8ff 500 EFM_ASSERT(LEUART_REF_VALID(leuart));
bogdanm 0:9b334a45a8ff 501
bogdanm 0:9b334a45a8ff 502 /* Freeze registers to avoid stalling for LF synchronization */
bogdanm 0:9b334a45a8ff 503 LEUART_FreezeEnable(leuart, true);
bogdanm 0:9b334a45a8ff 504
bogdanm 0:9b334a45a8ff 505 /* Make sure disabled first, before resetting other registers */
bogdanm 0:9b334a45a8ff 506 leuart->CMD = LEUART_CMD_RXDIS | LEUART_CMD_TXDIS | LEUART_CMD_RXBLOCKDIS |
bogdanm 0:9b334a45a8ff 507 LEUART_CMD_CLEARTX | LEUART_CMD_CLEARRX;
bogdanm 0:9b334a45a8ff 508 leuart->CTRL = _LEUART_CTRL_RESETVALUE;
bogdanm 0:9b334a45a8ff 509 leuart->CLKDIV = _LEUART_CLKDIV_RESETVALUE;
bogdanm 0:9b334a45a8ff 510 leuart->STARTFRAME = _LEUART_STARTFRAME_RESETVALUE;
bogdanm 0:9b334a45a8ff 511 leuart->SIGFRAME = _LEUART_SIGFRAME_RESETVALUE;
bogdanm 0:9b334a45a8ff 512 leuart->IEN = _LEUART_IEN_RESETVALUE;
bogdanm 0:9b334a45a8ff 513 leuart->IFC = _LEUART_IFC_MASK;
bogdanm 0:9b334a45a8ff 514 leuart->PULSECTRL = _LEUART_PULSECTRL_RESETVALUE;
bogdanm 0:9b334a45a8ff 515 leuart->ROUTE = _LEUART_ROUTE_RESETVALUE;
bogdanm 0:9b334a45a8ff 516
bogdanm 0:9b334a45a8ff 517 /* Unfreeze registers, pass new settings on to LEUART */
bogdanm 0:9b334a45a8ff 518 LEUART_FreezeEnable(leuart, false);
bogdanm 0:9b334a45a8ff 519 }
bogdanm 0:9b334a45a8ff 520
bogdanm 0:9b334a45a8ff 521
bogdanm 0:9b334a45a8ff 522 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 523 * @brief
bogdanm 0:9b334a45a8ff 524 * Receive one 8 bit frame, (or part of 9 bit frame).
bogdanm 0:9b334a45a8ff 525 *
bogdanm 0:9b334a45a8ff 526 * @details
bogdanm 0:9b334a45a8ff 527 * This function is normally used to receive one frame when operating with
bogdanm 0:9b334a45a8ff 528 * frame length 8 bits. Please refer to LEUART_RxExt() for reception of
bogdanm 0:9b334a45a8ff 529 * 9 bit frames.
bogdanm 0:9b334a45a8ff 530 *
bogdanm 0:9b334a45a8ff 531 * Notice that possible parity/stop bits are not considered part of specified
bogdanm 0:9b334a45a8ff 532 * frame bit length.
bogdanm 0:9b334a45a8ff 533 *
bogdanm 0:9b334a45a8ff 534 * @note
bogdanm 0:9b334a45a8ff 535 * This function will stall if buffer is empty, until data is received.
bogdanm 0:9b334a45a8ff 536 *
bogdanm 0:9b334a45a8ff 537 * @param[in] leuart
bogdanm 0:9b334a45a8ff 538 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 539 *
bogdanm 0:9b334a45a8ff 540 * @return
bogdanm 0:9b334a45a8ff 541 * Data received.
bogdanm 0:9b334a45a8ff 542 ******************************************************************************/
bogdanm 0:9b334a45a8ff 543 uint8_t LEUART_Rx(LEUART_TypeDef *leuart)
bogdanm 0:9b334a45a8ff 544 {
bogdanm 0:9b334a45a8ff 545 while (!(leuart->STATUS & LEUART_STATUS_RXDATAV))
bogdanm 0:9b334a45a8ff 546 ;
bogdanm 0:9b334a45a8ff 547
bogdanm 0:9b334a45a8ff 548 return (uint8_t)(leuart->RXDATA);
bogdanm 0:9b334a45a8ff 549 }
bogdanm 0:9b334a45a8ff 550
bogdanm 0:9b334a45a8ff 551
bogdanm 0:9b334a45a8ff 552 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 553 * @brief
bogdanm 0:9b334a45a8ff 554 * Receive one 8-9 bit frame, with extended information.
bogdanm 0:9b334a45a8ff 555 *
bogdanm 0:9b334a45a8ff 556 * @details
bogdanm 0:9b334a45a8ff 557 * This function is normally used to receive one frame and additional RX
bogdanm 0:9b334a45a8ff 558 * status information is required.
bogdanm 0:9b334a45a8ff 559 *
bogdanm 0:9b334a45a8ff 560 * @note
bogdanm 0:9b334a45a8ff 561 * This function will stall if buffer is empty, until data is received.
bogdanm 0:9b334a45a8ff 562 *
bogdanm 0:9b334a45a8ff 563 * @param[in] leuart
bogdanm 0:9b334a45a8ff 564 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 565 *
bogdanm 0:9b334a45a8ff 566 * @return
bogdanm 0:9b334a45a8ff 567 * Data received.
bogdanm 0:9b334a45a8ff 568 ******************************************************************************/
bogdanm 0:9b334a45a8ff 569 uint16_t LEUART_RxExt(LEUART_TypeDef *leuart)
bogdanm 0:9b334a45a8ff 570 {
bogdanm 0:9b334a45a8ff 571 while (!(leuart->STATUS & LEUART_STATUS_RXDATAV))
bogdanm 0:9b334a45a8ff 572 ;
bogdanm 0:9b334a45a8ff 573
bogdanm 0:9b334a45a8ff 574 return (uint16_t)(leuart->RXDATAX);
bogdanm 0:9b334a45a8ff 575 }
bogdanm 0:9b334a45a8ff 576
bogdanm 0:9b334a45a8ff 577
bogdanm 0:9b334a45a8ff 578 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 579 * @brief
bogdanm 0:9b334a45a8ff 580 * Transmit one frame.
bogdanm 0:9b334a45a8ff 581 *
bogdanm 0:9b334a45a8ff 582 * @details
bogdanm 0:9b334a45a8ff 583 * Depending on frame length configuration, 8 (least significant) bits from
bogdanm 0:9b334a45a8ff 584 * @p data are transmitted. If frame length is 9, 8 bits are transmitted from
bogdanm 0:9b334a45a8ff 585 * @p data and one bit as specified by CTRL register, BIT8DV field. Please
bogdanm 0:9b334a45a8ff 586 * refer to LEUART_TxExt() for transmitting 9 bit frame with full control of
bogdanm 0:9b334a45a8ff 587 * all 9 bits.
bogdanm 0:9b334a45a8ff 588 *
bogdanm 0:9b334a45a8ff 589 * Notice that possible parity/stop bits in asynchronous mode are not
bogdanm 0:9b334a45a8ff 590 * considered part of specified frame bit length.
bogdanm 0:9b334a45a8ff 591 *
bogdanm 0:9b334a45a8ff 592 * @note
bogdanm 0:9b334a45a8ff 593 * This function will stall if buffer is full, until buffer becomes available.
bogdanm 0:9b334a45a8ff 594 *
bogdanm 0:9b334a45a8ff 595 * @param[in] leuart
bogdanm 0:9b334a45a8ff 596 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 597 *
bogdanm 0:9b334a45a8ff 598 * @param[in] data
bogdanm 0:9b334a45a8ff 599 * Data to transmit. See details above for further info.
bogdanm 0:9b334a45a8ff 600 ******************************************************************************/
bogdanm 0:9b334a45a8ff 601 void LEUART_Tx(LEUART_TypeDef *leuart, uint8_t data)
bogdanm 0:9b334a45a8ff 602 {
bogdanm 0:9b334a45a8ff 603 /* Check that transmit buffer is empty */
bogdanm 0:9b334a45a8ff 604 while (!(leuart->STATUS & LEUART_STATUS_TXBL))
bogdanm 0:9b334a45a8ff 605 ;
bogdanm 0:9b334a45a8ff 606
bogdanm 0:9b334a45a8ff 607 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 608 LEUART_Sync(leuart, LEUART_SYNCBUSY_TXDATA);
bogdanm 0:9b334a45a8ff 609
bogdanm 0:9b334a45a8ff 610 leuart->TXDATA = (uint32_t)data;
bogdanm 0:9b334a45a8ff 611 }
bogdanm 0:9b334a45a8ff 612
bogdanm 0:9b334a45a8ff 613
bogdanm 0:9b334a45a8ff 614 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 615 * @brief
bogdanm 0:9b334a45a8ff 616 * Transmit one 8-9 bit frame with extended control.
bogdanm 0:9b334a45a8ff 617 *
bogdanm 0:9b334a45a8ff 618 * @details
bogdanm 0:9b334a45a8ff 619 * Notice that possible parity/stop bits in asynchronous mode are not
bogdanm 0:9b334a45a8ff 620 * considered part of specified frame bit length.
bogdanm 0:9b334a45a8ff 621 *
bogdanm 0:9b334a45a8ff 622 * @note
bogdanm 0:9b334a45a8ff 623 * This function will stall if buffer is full, until buffer becomes available.
bogdanm 0:9b334a45a8ff 624 *
bogdanm 0:9b334a45a8ff 625 * @param[in] leuart
bogdanm 0:9b334a45a8ff 626 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 627 *
bogdanm 0:9b334a45a8ff 628 * @param[in] data
bogdanm 0:9b334a45a8ff 629 * Data to transmit with extended control. Least significant bits contains
bogdanm 0:9b334a45a8ff 630 * frame bits, and additional control bits are available as documented in
bogdanm 0:9b334a45a8ff 631 * the EFM32 reference manual (set to 0 if not used).
bogdanm 0:9b334a45a8ff 632 ******************************************************************************/
bogdanm 0:9b334a45a8ff 633 void LEUART_TxExt(LEUART_TypeDef *leuart, uint16_t data)
bogdanm 0:9b334a45a8ff 634 {
bogdanm 0:9b334a45a8ff 635 /* Check that transmit buffer is empty */
bogdanm 0:9b334a45a8ff 636 while (!(leuart->STATUS & LEUART_STATUS_TXBL))
bogdanm 0:9b334a45a8ff 637 ;
bogdanm 0:9b334a45a8ff 638
bogdanm 0:9b334a45a8ff 639 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 640 LEUART_Sync(leuart, LEUART_SYNCBUSY_TXDATAX);
bogdanm 0:9b334a45a8ff 641
bogdanm 0:9b334a45a8ff 642 leuart->TXDATAX = (uint32_t)data;
bogdanm 0:9b334a45a8ff 643 }
bogdanm 0:9b334a45a8ff 644
bogdanm 0:9b334a45a8ff 645 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 646 * @brief
bogdanm 0:9b334a45a8ff 647 * Enables handling of LEUART TX by DMA in EM2
bogdanm 0:9b334a45a8ff 648 *
bogdanm 0:9b334a45a8ff 649 * @param[in] leuart
bogdanm 0:9b334a45a8ff 650 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 651 *
bogdanm 0:9b334a45a8ff 652 * @param[in] enable
bogdanm 0:9b334a45a8ff 653 * true - enables functionality
bogdanm 0:9b334a45a8ff 654 * false - disables functionality
bogdanm 0:9b334a45a8ff 655 *
bogdanm 0:9b334a45a8ff 656 ******************************************************************************/
bogdanm 0:9b334a45a8ff 657 void LEUART_TxDmaInEM2Enable(LEUART_TypeDef *leuart, bool enable)
bogdanm 0:9b334a45a8ff 658 {
bogdanm 0:9b334a45a8ff 659 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 660 LEUART_Sync(leuart, LEUART_SYNCBUSY_CTRL);
bogdanm 0:9b334a45a8ff 661
bogdanm 0:9b334a45a8ff 662 if (enable)
bogdanm 0:9b334a45a8ff 663 {
bogdanm 0:9b334a45a8ff 664 leuart->CTRL |= LEUART_CTRL_TXDMAWU;
bogdanm 0:9b334a45a8ff 665 }
bogdanm 0:9b334a45a8ff 666 else
bogdanm 0:9b334a45a8ff 667 {
bogdanm 0:9b334a45a8ff 668 leuart->CTRL &= ~LEUART_CTRL_TXDMAWU;
bogdanm 0:9b334a45a8ff 669 }
bogdanm 0:9b334a45a8ff 670 }
bogdanm 0:9b334a45a8ff 671
bogdanm 0:9b334a45a8ff 672 /***************************************************************************//**
bogdanm 0:9b334a45a8ff 673 * @brief
bogdanm 0:9b334a45a8ff 674 * Enables handling of LEUART RX by DMA in EM2
bogdanm 0:9b334a45a8ff 675 *
bogdanm 0:9b334a45a8ff 676 * @param[in] leuart
bogdanm 0:9b334a45a8ff 677 * Pointer to LEUART peripheral register block.
bogdanm 0:9b334a45a8ff 678 *
bogdanm 0:9b334a45a8ff 679 * @param[in] enable
bogdanm 0:9b334a45a8ff 680 * true - enables functionality
bogdanm 0:9b334a45a8ff 681 * false - disables functionality
bogdanm 0:9b334a45a8ff 682 *
bogdanm 0:9b334a45a8ff 683 ******************************************************************************/
bogdanm 0:9b334a45a8ff 684 void LEUART_RxDmaInEM2Enable(LEUART_TypeDef *leuart, bool enable)
bogdanm 0:9b334a45a8ff 685 {
bogdanm 0:9b334a45a8ff 686 /* LF register about to be modified require sync. busy check */
bogdanm 0:9b334a45a8ff 687 LEUART_Sync(leuart, LEUART_SYNCBUSY_CTRL);
bogdanm 0:9b334a45a8ff 688
bogdanm 0:9b334a45a8ff 689 if (enable)
bogdanm 0:9b334a45a8ff 690 {
bogdanm 0:9b334a45a8ff 691 leuart->CTRL |= LEUART_CTRL_RXDMAWU;
bogdanm 0:9b334a45a8ff 692 }
bogdanm 0:9b334a45a8ff 693 else
bogdanm 0:9b334a45a8ff 694 {
bogdanm 0:9b334a45a8ff 695 leuart->CTRL &= ~LEUART_CTRL_RXDMAWU;
bogdanm 0:9b334a45a8ff 696 }
bogdanm 0:9b334a45a8ff 697 }
bogdanm 0:9b334a45a8ff 698
bogdanm 0:9b334a45a8ff 699
bogdanm 0:9b334a45a8ff 700 /** @} (end addtogroup LEUART) */
bogdanm 0:9b334a45a8ff 701 /** @} (end addtogroup EM_Library) */
bogdanm 0:9b334a45a8ff 702 #endif /* defined(LEUART_COUNT) && (LEUART_COUNT > 0) */