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@50:a417edff4437, 2016-01-15 (annotated)

Committer:
mbed_official
Date:
Fri Jan 15 07:45:16 2016 +0000
Revision:
50:a417edff4437
Parent:
0:9b334a45a8ff
Child:
144:ef7eb2e8f9f7
Synchronized with git revision 6010f32619bfcbb01cc73747d4ff9040863482d9



Full URL: https://github.com/mbedmicro/mbed/commit/6010f32619bfcbb01cc73747d4ff9040863482d9/



Remove doubling of buffer size in realiseEndpoint()

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