mbed official / mbed-src

mbed library sources

Dependents:   Encrypted my_mbed lklk CyaSSL_DTLS_Cellular ... more

Superseded

This library was superseded by mbed-dev - https://os.mbed.com/users/mbed_official/code/mbed-dev/.

Development branch of the mbed library sources. This library is kept in synch with the latest changes from the mbed SDK and it is not guaranteed to work.

If you are looking for a stable and tested release, please import one of the official mbed library releases:

Import librarymbed

The official Mbed 2 C/C++ SDK provides the software platform and libraries to build your applications.

Last commit 20 Feb 2019 by mbed official

targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/serial_api.c@627:4fa1328d9c60, 2015-09-25 (annotated)

Committer:
mbed_official
Date:
Fri Sep 25 14:15:10 2015 +0100
Revision:
627:4fa1328d9c60
Parent:
563:536c9fb088a0 
Synchronized with git revision fe238a91ab7a4d1d72c4cab9da04967c619d54ad



Full URL: https://github.com/mbedmicro/mbed/commit/fe238a91ab7a4d1d72c4cab9da04967c619d54ad/



Silicon Labs - Add support for low-power async Serial

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 627:4fa1328d9c60 1 /***************************************************************************//**
mbed_official 627:4fa1328d9c60 2 * @file serial_api.c
mbed_official 627:4fa1328d9c60 3 *******************************************************************************
mbed_official 627:4fa1328d9c60 4 * @section License
mbed_official 627:4fa1328d9c60 5 * <b>(C) Copyright 2015 Silicon Labs, http://www.silabs.com</b>
mbed_official 627:4fa1328d9c60 6 *******************************************************************************
mbed_official 525:c320967f86b9 7 *
mbed_official 627:4fa1328d9c60 8 * Permission is granted to anyone to use this software for any purpose,
mbed_official 627:4fa1328d9c60 9 * including commercial applications, and to alter it and redistribute it
mbed_official 627:4fa1328d9c60 10 * freely, subject to the following restrictions:
mbed_official 525:c320967f86b9 11 *
mbed_official 627:4fa1328d9c60 12 * 1. The origin of this software must not be misrepresented; you must not
mbed_official 627:4fa1328d9c60 13 * claim that you wrote the original software.
mbed_official 627:4fa1328d9c60 14 * 2. Altered source versions must be plainly marked as such, and must not be
mbed_official 627:4fa1328d9c60 15 * misrepresented as being the original software.
mbed_official 627:4fa1328d9c60 16 * 3. This notice may not be removed or altered from any source distribution.
mbed_official 525:c320967f86b9 17 *
mbed_official 627:4fa1328d9c60 18 * DISCLAIMER OF WARRANTY/LIMITATION OF REMEDIES: Silicon Labs has no
mbed_official 627:4fa1328d9c60 19 * obligation to support this Software. Silicon Labs is providing the
mbed_official 627:4fa1328d9c60 20 * Software "AS IS", with no express or implied warranties of any kind,
mbed_official 627:4fa1328d9c60 21 * including, but not limited to, any implied warranties of merchantability
mbed_official 627:4fa1328d9c60 22 * or fitness for any particular purpose or warranties against infringement
mbed_official 627:4fa1328d9c60 23 * of any proprietary rights of a third party.
mbed_official 627:4fa1328d9c60 24 *
mbed_official 627:4fa1328d9c60 25 * Silicon Labs will not be liable for any consequential, incidental, or
mbed_official 627:4fa1328d9c60 26 * special damages, or any other relief, or for any claim by any third party,
mbed_official 627:4fa1328d9c60 27 * arising from your use of this Software.
mbed_official 627:4fa1328d9c60 28 *
mbed_official 627:4fa1328d9c60 29 ******************************************************************************/
mbed_official 525:c320967f86b9 30
mbed_official 525:c320967f86b9 31 #include "device.h"
mbed_official 525:c320967f86b9 32 #include "clocking.h"
mbed_official 525:c320967f86b9 33 #if DEVICE_SERIAL
mbed_official 525:c320967f86b9 34
mbed_official 525:c320967f86b9 35 #include "mbed_assert.h"
mbed_official 525:c320967f86b9 36 #include "serial_api.h"
mbed_official 525:c320967f86b9 37 #include <string.h>
mbed_official 525:c320967f86b9 38 #include <stdbool.h>
mbed_official 525:c320967f86b9 39
mbed_official 525:c320967f86b9 40 #include "pinmap.h"
mbed_official 525:c320967f86b9 41 #include "pinmap_function.h"
mbed_official 525:c320967f86b9 42 #include "PeripheralPins.h"
mbed_official 525:c320967f86b9 43 #include "PeripheralNames.h"
mbed_official 525:c320967f86b9 44
mbed_official 525:c320967f86b9 45 #include "em_usart.h"
mbed_official 525:c320967f86b9 46 #include "em_leuart.h"
mbed_official 525:c320967f86b9 47 #include "em_cmu.h"
mbed_official 525:c320967f86b9 48 #include "em_dma.h"
mbed_official 525:c320967f86b9 49 #include "dma_api_HAL.h"
mbed_official 525:c320967f86b9 50 #include "dma_api.h"
mbed_official 525:c320967f86b9 51 #include "sleep_api.h"
mbed_official 525:c320967f86b9 52 #include "buffer.h"
mbed_official 526:7c4bdfe6a168 53 #include "sleepmodes.h"
mbed_official 525:c320967f86b9 54
mbed_official 525:c320967f86b9 55 #define SERIAL_LEAST_ACTIVE_SLEEPMODE EM1
mbed_official 525:c320967f86b9 56 #define SERIAL_LEAST_ACTIVE_SLEEPMODE_LEUART EM2
mbed_official 525:c320967f86b9 57
mbed_official 525:c320967f86b9 58 /** Validation of LEUART register block pointer reference
mbed_official 525:c320967f86b9 59 * for assert statements. */
mbed_official 525:c320967f86b9 60 #if !defined(LEUART_COUNT)
mbed_official 525:c320967f86b9 61 #define LEUART_REF_VALID(ref) (0)
mbed_official 525:c320967f86b9 62 #elif (LEUART_COUNT == 1)
mbed_official 525:c320967f86b9 63 #define LEUART_REF_VALID(ref) ((ref) == LEUART0)
mbed_official 525:c320967f86b9 64 #elif (LEUART_COUNT == 2)
mbed_official 525:c320967f86b9 65 #define LEUART_REF_VALID(ref) (((ref) == LEUART0) || ((ref) == LEUART1))
mbed_official 525:c320967f86b9 66 #else
mbed_official 525:c320967f86b9 67 #error Undefined number of low energy UARTs (LEUART).
mbed_official 525:c320967f86b9 68 #endif
mbed_official 525:c320967f86b9 69
mbed_official 525:c320967f86b9 70 /* Store IRQ id for each UART */
mbed_official 525:c320967f86b9 71 static uint32_t serial_irq_ids[SERIAL_NUM_UARTS] = { 0 };
mbed_official 525:c320967f86b9 72 /* Interrupt handler from mbed common */
mbed_official 525:c320967f86b9 73 static uart_irq_handler irq_handler;
mbed_official 525:c320967f86b9 74 /* Keep track of incoming DMA IRQ's */
mbed_official 525:c320967f86b9 75 static bool serial_dma_irq_fired[DMACTRL_CH_CNT] = { false };
mbed_official 525:c320967f86b9 76
mbed_official 525:c320967f86b9 77 /* Serial interface on USBTX/USBRX retargets stdio */
mbed_official 525:c320967f86b9 78 int stdio_uart_inited = 0;
mbed_official 525:c320967f86b9 79 serial_t stdio_uart;
mbed_official 525:c320967f86b9 80
mbed_official 525:c320967f86b9 81 static void uart_irq(UARTName, int, SerialIrq);
mbed_official 525:c320967f86b9 82 uint8_t serial_get_index(serial_t *obj);
mbed_official 547:88c982c8f758 83 void serial_enable(serial_t *obj, uint8_t enable);
mbed_official 547:88c982c8f758 84 void serial_enable_pins(serial_t *obj, uint8_t enable);
mbed_official 525:c320967f86b9 85 IRQn_Type serial_get_rx_irq_index(serial_t *obj);
mbed_official 525:c320967f86b9 86 IRQn_Type serial_get_tx_irq_index(serial_t *obj);
mbed_official 525:c320967f86b9 87 CMU_Clock_TypeDef serial_get_clock(serial_t *obj);
mbed_official 525:c320967f86b9 88
mbed_official 525:c320967f86b9 89 /* ISRs for RX and TX events */
mbed_official 525:c320967f86b9 90 #ifdef UART0
mbed_official 525:c320967f86b9 91 static void uart0_rx_irq() { uart_irq(UART_0, 0, RxIrq); }
mbed_official 525:c320967f86b9 92 static void uart0_tx_irq() { uart_irq(UART_0, 0, TxIrq); USART_IntClear((USART_TypeDef*)UART_0, USART_IFC_TXC);}
mbed_official 525:c320967f86b9 93 #endif
mbed_official 525:c320967f86b9 94 #ifdef UART1
mbed_official 525:c320967f86b9 95 static void uart1_rx_irq() { uart_irq(UART_1, 1, RxIrq); }
mbed_official 525:c320967f86b9 96 static void uart1_tx_irq() { uart_irq(UART_1, 1, TxIrq); USART_IntClear((USART_TypeDef*)UART_1, USART_IFC_TXC);}
mbed_official 525:c320967f86b9 97 #endif
mbed_official 525:c320967f86b9 98 #ifdef USART0
mbed_official 525:c320967f86b9 99 static void usart0_rx_irq() { uart_irq(USART_0, 2, RxIrq); }
mbed_official 525:c320967f86b9 100 static void usart0_tx_irq() { uart_irq(USART_0, 2, TxIrq); USART_IntClear((USART_TypeDef*)USART_0, USART_IFC_TXC);}
mbed_official 525:c320967f86b9 101 #endif
mbed_official 525:c320967f86b9 102 #ifdef USART1
mbed_official 525:c320967f86b9 103 static void usart1_rx_irq() { uart_irq(USART_1, 3, RxIrq); }
mbed_official 525:c320967f86b9 104 static void usart1_tx_irq() { uart_irq(USART_1, 3, TxIrq); USART_IntClear((USART_TypeDef*)USART_1, USART_IFC_TXC);}
mbed_official 525:c320967f86b9 105 #endif
mbed_official 525:c320967f86b9 106 #ifdef USART2
mbed_official 525:c320967f86b9 107 static void usart2_rx_irq() { uart_irq(USART_2, 4, RxIrq); }
mbed_official 525:c320967f86b9 108 static void usart2_tx_irq() { uart_irq(USART_2, 4, TxIrq); USART_IntClear((USART_TypeDef*)USART_2, USART_IFC_TXC);}
mbed_official 525:c320967f86b9 109 #endif
mbed_official 525:c320967f86b9 110 #ifdef LEUART0
mbed_official 548:1abac31e188e 111 static void leuart0_irq()
mbed_official 548:1abac31e188e 112 {
mbed_official 525:c320967f86b9 113 if(LEUART_IntGetEnabled(LEUART0) && (LEUART_IF_RXDATAV | LEUART_IF_FERR | LEUART_IFC_PERR | LEUART_IF_RXOF)) {
mbed_official 548:1abac31e188e 114 uart_irq(LEUART_0, 5, RxIrq);
mbed_official 525:c320967f86b9 115 } else {
mbed_official 525:c320967f86b9 116 uart_irq(LEUART_0, 5, TxIrq);
mbed_official 525:c320967f86b9 117 }
mbed_official 525:c320967f86b9 118 }
mbed_official 525:c320967f86b9 119 #endif
mbed_official 525:c320967f86b9 120 #ifdef LEUART1
mbed_official 548:1abac31e188e 121 static void leuart1_irq()
mbed_official 548:1abac31e188e 122 {
mbed_official 525:c320967f86b9 123 if(LEUART_IntGetEnabled(LEUART1) && (LEUART_IF_RXDATAV | LEUART_IF_FERR | LEUART_IFC_PERR | LEUART_IF_RXOF)) {
mbed_official 548:1abac31e188e 124 uart_irq(LEUART_1, 6, RxIrq);
mbed_official 525:c320967f86b9 125 } else {
mbed_official 525:c320967f86b9 126 uart_irq(LEUART_1, 6, TxIrq);
mbed_official 525:c320967f86b9 127 }
mbed_official 525:c320967f86b9 128 }
mbed_official 525:c320967f86b9 129 #endif
mbed_official 525:c320967f86b9 130
mbed_official 525:c320967f86b9 131 /**
mbed_official 525:c320967f86b9 132 * Initialize the UART using default settings, overridden by settings from serial object
mbed_official 525:c320967f86b9 133 *
mbed_official 525:c320967f86b9 134 * @param obj pointer to serial object
mbed_official 525:c320967f86b9 135 */
mbed_official 525:c320967f86b9 136 static void uart_init(serial_t *obj)
mbed_official 525:c320967f86b9 137 {
mbed_official 525:c320967f86b9 138 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 139 LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT;
mbed_official 525:c320967f86b9 140
mbed_official 525:c320967f86b9 141 init.enable = leuartDisable;
mbed_official 525:c320967f86b9 142 init.baudrate = 9600;
mbed_official 525:c320967f86b9 143 init.databits = leuartDatabits8;
mbed_official 525:c320967f86b9 144 init.parity = leuartNoParity;
mbed_official 525:c320967f86b9 145 init.stopbits = leuartStopbits1;
mbed_official 627:4fa1328d9c60 146 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 147 init.refFreq = LEUART_LF_REF_FREQ;
mbed_official 627:4fa1328d9c60 148 #else
mbed_official 525:c320967f86b9 149 init.refFreq = LEUART_REF_FREQ;
mbed_official 627:4fa1328d9c60 150 #endif
mbed_official 525:c320967f86b9 151 LEUART_Init(obj->serial.periph.leuart, &init);
mbed_official 525:c320967f86b9 152 } else {
mbed_official 525:c320967f86b9 153 USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
mbed_official 525:c320967f86b9 154
mbed_official 525:c320967f86b9 155 init.enable = usartDisable;
mbed_official 525:c320967f86b9 156 init.baudrate = 9600;
mbed_official 525:c320967f86b9 157 init.oversampling = usartOVS16;
mbed_official 525:c320967f86b9 158 init.databits = usartDatabits8;
mbed_official 525:c320967f86b9 159 init.parity = usartNoParity;
mbed_official 525:c320967f86b9 160 init.stopbits = usartStopbits1;
mbed_official 525:c320967f86b9 161
mbed_official 525:c320967f86b9 162 /* Determine the reference clock, because the correct clock is not set up at init time */
mbed_official 525:c320967f86b9 163 init.refFreq = REFERENCE_FREQUENCY;
mbed_official 525:c320967f86b9 164
mbed_official 525:c320967f86b9 165 USART_InitAsync(obj->serial.periph.uart, &init);
mbed_official 525:c320967f86b9 166 }
mbed_official 525:c320967f86b9 167 }
mbed_official 525:c320967f86b9 168
mbed_official 525:c320967f86b9 169 /**
mbed_official 525:c320967f86b9 170 * Get index of serial object, relating it to the physical peripheral.
mbed_official 525:c320967f86b9 171 *
mbed_official 525:c320967f86b9 172 * @param obj pointer to serial object
mbed_official 525:c320967f86b9 173 * @return internal index of U(S)ART peripheral
mbed_official 525:c320967f86b9 174 */
mbed_official 525:c320967f86b9 175 inline uint8_t serial_get_index(serial_t *obj)
mbed_official 525:c320967f86b9 176 {
mbed_official 525:c320967f86b9 177 switch ((uint32_t)obj->serial.periph.uart) {
mbed_official 525:c320967f86b9 178 #ifdef UART0
mbed_official 525:c320967f86b9 179 case UART_0:
mbed_official 525:c320967f86b9 180 return 0;
mbed_official 525:c320967f86b9 181 #endif
mbed_official 525:c320967f86b9 182 #ifdef UART1
mbed_official 525:c320967f86b9 183 case UART_1:
mbed_official 525:c320967f86b9 184 return 1;
mbed_official 525:c320967f86b9 185 #endif
mbed_official 525:c320967f86b9 186 #ifdef USART0
mbed_official 525:c320967f86b9 187 case USART_0:
mbed_official 525:c320967f86b9 188 return 2;
mbed_official 525:c320967f86b9 189 #endif
mbed_official 525:c320967f86b9 190 #ifdef USART1
mbed_official 525:c320967f86b9 191 case USART_1:
mbed_official 525:c320967f86b9 192 return 3;
mbed_official 525:c320967f86b9 193 #endif
mbed_official 525:c320967f86b9 194 #ifdef USART2
mbed_official 525:c320967f86b9 195 case USART_2:
mbed_official 525:c320967f86b9 196 return 4;
mbed_official 525:c320967f86b9 197 #endif
mbed_official 525:c320967f86b9 198 #ifdef LEUART0
mbed_official 525:c320967f86b9 199 case LEUART_0:
mbed_official 525:c320967f86b9 200 return 5;
mbed_official 525:c320967f86b9 201 #endif
mbed_official 525:c320967f86b9 202 #ifdef LEUART1
mbed_official 525:c320967f86b9 203 case LEUART_1:
mbed_official 525:c320967f86b9 204 return 6;
mbed_official 525:c320967f86b9 205 #endif
mbed_official 525:c320967f86b9 206 }
mbed_official 525:c320967f86b9 207 return 0;
mbed_official 525:c320967f86b9 208 }
mbed_official 525:c320967f86b9 209
mbed_official 525:c320967f86b9 210 /**
mbed_official 525:c320967f86b9 211 * Get index of serial object RX IRQ, relating it to the physical peripheral.
mbed_official 525:c320967f86b9 212 *
mbed_official 525:c320967f86b9 213 * @param obj pointer to serial object
mbed_official 525:c320967f86b9 214 * @return internal NVIC RX IRQ index of U(S)ART peripheral
mbed_official 525:c320967f86b9 215 */
mbed_official 525:c320967f86b9 216 inline IRQn_Type serial_get_rx_irq_index(serial_t *obj)
mbed_official 525:c320967f86b9 217 {
mbed_official 525:c320967f86b9 218 switch ((uint32_t)obj->serial.periph.uart) {
mbed_official 525:c320967f86b9 219 #ifdef UART0
mbed_official 525:c320967f86b9 220 case UART_0:
mbed_official 525:c320967f86b9 221 return UART0_RX_IRQn;
mbed_official 525:c320967f86b9 222 #endif
mbed_official 525:c320967f86b9 223 #ifdef UART1
mbed_official 525:c320967f86b9 224 case UART_1:
mbed_official 525:c320967f86b9 225 return UART1_RX_IRQn;
mbed_official 525:c320967f86b9 226 #endif
mbed_official 525:c320967f86b9 227 #ifdef USART0
mbed_official 525:c320967f86b9 228 case USART_0:
mbed_official 525:c320967f86b9 229 return USART0_RX_IRQn;
mbed_official 525:c320967f86b9 230 #endif
mbed_official 525:c320967f86b9 231 #ifdef USART1
mbed_official 525:c320967f86b9 232 case USART_1:
mbed_official 525:c320967f86b9 233 return USART1_RX_IRQn;
mbed_official 525:c320967f86b9 234 #endif
mbed_official 525:c320967f86b9 235 #ifdef USART2
mbed_official 525:c320967f86b9 236 case USART_2:
mbed_official 525:c320967f86b9 237 return USART2_RX_IRQn;
mbed_official 525:c320967f86b9 238 #endif
mbed_official 525:c320967f86b9 239 #ifdef LEUART0
mbed_official 525:c320967f86b9 240 case LEUART_0:
mbed_official 525:c320967f86b9 241 return LEUART0_IRQn;
mbed_official 525:c320967f86b9 242 #endif
mbed_official 525:c320967f86b9 243 #ifdef LEUART1
mbed_official 525:c320967f86b9 244 case LEUART_1:
mbed_official 525:c320967f86b9 245 return LEUART1_IRQn;
mbed_official 525:c320967f86b9 246 #endif
mbed_official 525:c320967f86b9 247 default:
mbed_official 525:c320967f86b9 248 MBED_ASSERT(0);
mbed_official 525:c320967f86b9 249 }
mbed_official 526:7c4bdfe6a168 250 return (IRQn_Type)0;
mbed_official 525:c320967f86b9 251 }
mbed_official 525:c320967f86b9 252
mbed_official 525:c320967f86b9 253 /**
mbed_official 525:c320967f86b9 254 * Get index of serial object TX IRQ, relating it to the physical peripheral.
mbed_official 525:c320967f86b9 255 *
mbed_official 525:c320967f86b9 256 * @param obj pointer to serial object
mbed_official 525:c320967f86b9 257 * @return internal NVIC TX IRQ index of U(S)ART peripheral
mbed_official 525:c320967f86b9 258 */
mbed_official 525:c320967f86b9 259 inline IRQn_Type serial_get_tx_irq_index(serial_t *obj)
mbed_official 525:c320967f86b9 260 {
mbed_official 525:c320967f86b9 261 switch ((uint32_t)obj->serial.periph.uart) {
mbed_official 525:c320967f86b9 262 #ifdef UART0
mbed_official 525:c320967f86b9 263 case UART_0:
mbed_official 525:c320967f86b9 264 return UART0_TX_IRQn;
mbed_official 525:c320967f86b9 265 #endif
mbed_official 525:c320967f86b9 266 #ifdef UART1
mbed_official 525:c320967f86b9 267 case UART_1:
mbed_official 525:c320967f86b9 268 return UART1_TX_IRQn;
mbed_official 525:c320967f86b9 269 #endif
mbed_official 525:c320967f86b9 270 #ifdef USART0
mbed_official 525:c320967f86b9 271 case USART_0:
mbed_official 525:c320967f86b9 272 return USART0_TX_IRQn;
mbed_official 525:c320967f86b9 273 #endif
mbed_official 525:c320967f86b9 274 #ifdef USART1
mbed_official 525:c320967f86b9 275 case USART_1:
mbed_official 525:c320967f86b9 276 return USART1_TX_IRQn;
mbed_official 525:c320967f86b9 277 #endif
mbed_official 525:c320967f86b9 278 #ifdef USART2
mbed_official 525:c320967f86b9 279 case USART_2:
mbed_official 525:c320967f86b9 280 return USART2_TX_IRQn;
mbed_official 525:c320967f86b9 281 #endif
mbed_official 525:c320967f86b9 282 #ifdef LEUART0
mbed_official 525:c320967f86b9 283 case LEUART_0:
mbed_official 525:c320967f86b9 284 return LEUART0_IRQn;
mbed_official 525:c320967f86b9 285 #endif
mbed_official 525:c320967f86b9 286 #ifdef LEUART1
mbed_official 525:c320967f86b9 287 case LEUART_1:
mbed_official 525:c320967f86b9 288 return LEUART1_IRQn;
mbed_official 525:c320967f86b9 289 #endif
mbed_official 525:c320967f86b9 290 default:
mbed_official 525:c320967f86b9 291 MBED_ASSERT(0);
mbed_official 525:c320967f86b9 292 }
mbed_official 526:7c4bdfe6a168 293 return (IRQn_Type)0;
mbed_official 525:c320967f86b9 294 }
mbed_official 525:c320967f86b9 295
mbed_official 525:c320967f86b9 296 /**
mbed_official 525:c320967f86b9 297 * Get clock tree for serial peripheral pointed to by obj.
mbed_official 548:1abac31e188e 298 *
mbed_official 525:c320967f86b9 299 * @param obj pointer to serial object
mbed_official 525:c320967f86b9 300 * @return CMU_Clock_TypeDef for U(S)ART
mbed_official 525:c320967f86b9 301 */
mbed_official 525:c320967f86b9 302 inline CMU_Clock_TypeDef serial_get_clock(serial_t *obj)
mbed_official 525:c320967f86b9 303 {
mbed_official 525:c320967f86b9 304 switch ((uint32_t)obj->serial.periph.uart) {
mbed_official 525:c320967f86b9 305 #ifdef UART0
mbed_official 525:c320967f86b9 306 case UART_0:
mbed_official 525:c320967f86b9 307 return cmuClock_UART0;
mbed_official 525:c320967f86b9 308 #endif
mbed_official 525:c320967f86b9 309 #ifdef UART1
mbed_official 525:c320967f86b9 310 case UART_1:
mbed_official 525:c320967f86b9 311 return cmuClock_UART1;
mbed_official 525:c320967f86b9 312 #endif
mbed_official 525:c320967f86b9 313 #ifdef USART0
mbed_official 525:c320967f86b9 314 case USART_0:
mbed_official 525:c320967f86b9 315 return cmuClock_USART0;
mbed_official 525:c320967f86b9 316 #endif
mbed_official 525:c320967f86b9 317 #ifdef USART1
mbed_official 525:c320967f86b9 318 case USART_1:
mbed_official 525:c320967f86b9 319 return cmuClock_USART1;
mbed_official 525:c320967f86b9 320 #endif
mbed_official 525:c320967f86b9 321 #ifdef USART2
mbed_official 525:c320967f86b9 322 case USART_2:
mbed_official 525:c320967f86b9 323 return cmuClock_USART2;
mbed_official 525:c320967f86b9 324 #endif
mbed_official 525:c320967f86b9 325 #ifdef LEUART0
mbed_official 525:c320967f86b9 326 case LEUART_0:
mbed_official 525:c320967f86b9 327 return cmuClock_LEUART0;
mbed_official 525:c320967f86b9 328 #endif
mbed_official 525:c320967f86b9 329 #ifdef LEUART1
mbed_official 525:c320967f86b9 330 case LEUART_1:
mbed_official 525:c320967f86b9 331 return cmuClock_LEUART1;
mbed_official 525:c320967f86b9 332 #endif
mbed_official 525:c320967f86b9 333 default:
mbed_official 525:c320967f86b9 334 return cmuClock_HFPER;
mbed_official 525:c320967f86b9 335 }
mbed_official 525:c320967f86b9 336 }
mbed_official 525:c320967f86b9 337
mbed_official 525:c320967f86b9 338 void serial_preinit(serial_t *obj, PinName tx, PinName rx)
mbed_official 525:c320967f86b9 339 {
mbed_official 525:c320967f86b9 340 /* Get UART object connected to the given pins */
mbed_official 525:c320967f86b9 341 UARTName uart_tx = (UARTName) pinmap_peripheral(tx, PinMap_UART_TX);
mbed_official 525:c320967f86b9 342 UARTName uart_rx = (UARTName) pinmap_peripheral(rx, PinMap_UART_RX);
mbed_official 525:c320967f86b9 343 /* Check that pins are connected to same UART */
mbed_official 525:c320967f86b9 344 UARTName uart = (UARTName) pinmap_merge(uart_tx, uart_rx);
mbed_official 525:c320967f86b9 345 MBED_ASSERT((int) uart != NC);
mbed_official 525:c320967f86b9 346
mbed_official 525:c320967f86b9 347 obj->serial.periph.uart = (USART_TypeDef *) uart;
mbed_official 525:c320967f86b9 348
mbed_official 525:c320967f86b9 349 /* Get location */
mbed_official 525:c320967f86b9 350 uint32_t uart_tx_loc = pin_location(tx, PinMap_UART_TX);
mbed_official 525:c320967f86b9 351 uint32_t uart_rx_loc = pin_location(rx, PinMap_UART_RX);
mbed_official 525:c320967f86b9 352 /* Check that pins are used by same location for the given UART */
mbed_official 525:c320967f86b9 353 obj->serial.location = pinmap_merge(uart_tx_loc, uart_rx_loc);
mbed_official 525:c320967f86b9 354 MBED_ASSERT(obj->serial.location != (uint32_t)NC);
mbed_official 525:c320967f86b9 355
mbed_official 525:c320967f86b9 356 /* Store pins in object for easy disabling in serial_free() */
mbed_official 525:c320967f86b9 357 obj->serial.rx_pin = rx;
mbed_official 525:c320967f86b9 358 obj->serial.tx_pin = tx;
mbed_official 525:c320967f86b9 359
mbed_official 525:c320967f86b9 360 /* Select interrupt */
mbed_official 525:c320967f86b9 361 switch ((uint32_t)obj->serial.periph.uart) {
mbed_official 525:c320967f86b9 362 #ifdef UART0
mbed_official 525:c320967f86b9 363 case UART_0:
mbed_official 525:c320967f86b9 364 NVIC_SetVector(UART0_RX_IRQn, (uint32_t) &uart0_rx_irq);
mbed_official 525:c320967f86b9 365 NVIC_SetVector(UART0_TX_IRQn, (uint32_t) &uart0_tx_irq);
mbed_official 525:c320967f86b9 366 NVIC_SetPriority(UART0_TX_IRQn, 1);
mbed_official 525:c320967f86b9 367 break;
mbed_official 525:c320967f86b9 368 #endif
mbed_official 525:c320967f86b9 369 #ifdef UART1
mbed_official 525:c320967f86b9 370 case UART_1:
mbed_official 525:c320967f86b9 371 NVIC_SetVector(UART1_RX_IRQn, (uint32_t) &uart1_rx_irq);
mbed_official 525:c320967f86b9 372 NVIC_SetVector(UART1_TX_IRQn, (uint32_t) &uart1_tx_irq);
mbed_official 525:c320967f86b9 373 NVIC_SetPriority(UART1_TX_IRQn, 1);
mbed_official 525:c320967f86b9 374 break;
mbed_official 525:c320967f86b9 375 #endif
mbed_official 525:c320967f86b9 376 #ifdef USART0
mbed_official 525:c320967f86b9 377 case USART_0:
mbed_official 525:c320967f86b9 378 NVIC_SetVector(USART0_RX_IRQn, (uint32_t) &usart0_rx_irq);
mbed_official 525:c320967f86b9 379 NVIC_SetVector(USART0_TX_IRQn, (uint32_t) &usart0_tx_irq);
mbed_official 525:c320967f86b9 380 NVIC_SetPriority(USART0_TX_IRQn, 1);
mbed_official 525:c320967f86b9 381 break;
mbed_official 525:c320967f86b9 382 #endif
mbed_official 525:c320967f86b9 383 #ifdef USART1
mbed_official 525:c320967f86b9 384 case USART_1:
mbed_official 525:c320967f86b9 385 NVIC_SetVector(USART1_RX_IRQn, (uint32_t) &usart1_rx_irq);
mbed_official 525:c320967f86b9 386 NVIC_SetVector(USART1_TX_IRQn, (uint32_t) &usart1_tx_irq);
mbed_official 525:c320967f86b9 387 NVIC_SetPriority(USART1_TX_IRQn, 1);
mbed_official 525:c320967f86b9 388 break;
mbed_official 525:c320967f86b9 389 #endif
mbed_official 525:c320967f86b9 390 #ifdef USART2
mbed_official 525:c320967f86b9 391 case USART_2:
mbed_official 525:c320967f86b9 392 NVIC_SetVector(USART2_RX_IRQn, (uint32_t) &usart2_rx_irq);
mbed_official 525:c320967f86b9 393 NVIC_SetVector(USART2_TX_IRQn, (uint32_t) &usart2_tx_irq);
mbed_official 525:c320967f86b9 394 NVIC_SetPriority(USART2_TX_IRQn, 1);
mbed_official 525:c320967f86b9 395 break;
mbed_official 525:c320967f86b9 396 #endif
mbed_official 525:c320967f86b9 397 #ifdef LEUART0
mbed_official 525:c320967f86b9 398 case LEUART_0:
mbed_official 525:c320967f86b9 399 NVIC_SetVector(LEUART0_IRQn, (uint32_t) &leuart0_irq);
mbed_official 525:c320967f86b9 400 break;
mbed_official 525:c320967f86b9 401 #endif
mbed_official 525:c320967f86b9 402 #ifdef LEUART1
mbed_official 525:c320967f86b9 403 case LEUART_1:
mbed_official 525:c320967f86b9 404 NVIC_SetVector(LEUART1_IRQn, (uint32_t) &leuart1_irq);
mbed_official 525:c320967f86b9 405 break;
mbed_official 525:c320967f86b9 406 #endif
mbed_official 525:c320967f86b9 407 }
mbed_official 525:c320967f86b9 408 }
mbed_official 525:c320967f86b9 409
mbed_official 525:c320967f86b9 410 void serial_enable_pins(serial_t *obj, uint8_t enable)
mbed_official 525:c320967f86b9 411 {
mbed_official 525:c320967f86b9 412 if (enable) {
mbed_official 525:c320967f86b9 413 /* Configure GPIO pins*/
mbed_official 525:c320967f86b9 414 pin_mode(obj->serial.rx_pin, Input);
mbed_official 525:c320967f86b9 415 /* 0x10 sets DOUT. Prevents false start. */
mbed_official 525:c320967f86b9 416 pin_mode(obj->serial.tx_pin, PushPull | 0x10);
mbed_official 525:c320967f86b9 417 } else {
mbed_official 525:c320967f86b9 418 pin_mode(obj->serial.rx_pin, Disabled);
mbed_official 525:c320967f86b9 419 pin_mode(obj->serial.tx_pin, Disabled);
mbed_official 525:c320967f86b9 420 }
mbed_official 525:c320967f86b9 421 }
mbed_official 525:c320967f86b9 422
mbed_official 525:c320967f86b9 423 void serial_init(serial_t *obj, PinName tx, PinName rx)
mbed_official 525:c320967f86b9 424 {
mbed_official 548:1abac31e188e 425 serial_preinit(obj, tx, rx);
mbed_official 548:1abac31e188e 426
mbed_official 525:c320967f86b9 427 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 428 // Set up LEUART clock tree
mbed_official 627:4fa1328d9c60 429 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 430 //set to use LFXO
mbed_official 627:4fa1328d9c60 431 CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
mbed_official 627:4fa1328d9c60 432 CMU_ClockEnable(cmuClock_CORELE, true);
mbed_official 627:4fa1328d9c60 433 #else
mbed_official 627:4fa1328d9c60 434 //set to use high-speed clock
mbed_official 525:c320967f86b9 435 CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_CORELEDIV2);
mbed_official 627:4fa1328d9c60 436 #endif
mbed_official 525:c320967f86b9 437 }
mbed_official 548:1abac31e188e 438
mbed_official 525:c320967f86b9 439 CMU_ClockEnable(serial_get_clock(obj), true);
mbed_official 548:1abac31e188e 440
mbed_official 525:c320967f86b9 441 /* Configure UART for async operation */
mbed_official 525:c320967f86b9 442 uart_init(obj);
mbed_official 525:c320967f86b9 443
mbed_official 525:c320967f86b9 444 /* Limitations of board controller: CDC port only supports 115kbaud */
mbed_official 525:c320967f86b9 445 if((tx == STDIO_UART_TX) && (rx == STDIO_UART_RX) && (obj->serial.periph.uart == (USART_TypeDef*)STDIO_UART )) {
mbed_official 525:c320967f86b9 446 serial_baud(obj, 115200);
mbed_official 525:c320967f86b9 447 }
mbed_official 548:1abac31e188e 448
mbed_official 525:c320967f86b9 449 /* Enable pins for UART at correct location */
mbed_official 525:c320967f86b9 450 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 451 obj->serial.periph.leuart->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | (obj->serial.location << _LEUART_ROUTE_LOCATION_SHIFT);
mbed_official 525:c320967f86b9 452 obj->serial.periph.leuart->IFC = LEUART_IFC_TXC;
mbed_official 627:4fa1328d9c60 453 obj->serial.periph.leuart->CTRL |= LEUART_CTRL_RXDMAWU | LEUART_CTRL_TXDMAWU;
mbed_official 525:c320967f86b9 454 } else {
mbed_official 525:c320967f86b9 455 obj->serial.periph.uart->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | (obj->serial.location << _USART_ROUTE_LOCATION_SHIFT);
mbed_official 525:c320967f86b9 456 obj->serial.periph.uart->IFC = USART_IFC_TXC;
mbed_official 525:c320967f86b9 457 }
mbed_official 548:1abac31e188e 458
mbed_official 525:c320967f86b9 459 /* If this is the UART to be used for stdio, copy it to the stdio_uart struct */
mbed_official 525:c320967f86b9 460 if (obj->serial.periph.uart == (USART_TypeDef*)STDIO_UART ) {
mbed_official 525:c320967f86b9 461 stdio_uart_inited = 1;
mbed_official 525:c320967f86b9 462 memcpy(&stdio_uart, obj, sizeof(serial_t));
mbed_official 525:c320967f86b9 463 }
mbed_official 525:c320967f86b9 464
mbed_official 525:c320967f86b9 465 serial_enable_pins(obj, true);
mbed_official 547:88c982c8f758 466 serial_enable(obj, true);
mbed_official 548:1abac31e188e 467
mbed_official 525:c320967f86b9 468
mbed_official 525:c320967f86b9 469 obj->serial.dmaOptionsTX.dmaChannel = -1;
mbed_official 525:c320967f86b9 470 obj->serial.dmaOptionsTX.dmaUsageState = DMA_USAGE_OPPORTUNISTIC;
mbed_official 525:c320967f86b9 471
mbed_official 548:1abac31e188e 472 obj->serial.dmaOptionsRX.dmaChannel = -1;
mbed_official 548:1abac31e188e 473 obj->serial.dmaOptionsRX.dmaUsageState = DMA_USAGE_OPPORTUNISTIC;
mbed_official 525:c320967f86b9 474
mbed_official 525:c320967f86b9 475 }
mbed_official 525:c320967f86b9 476
mbed_official 525:c320967f86b9 477 void serial_enable(serial_t *obj, uint8_t enable)
mbed_official 525:c320967f86b9 478 {
mbed_official 525:c320967f86b9 479 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 480 if (enable) {
mbed_official 525:c320967f86b9 481 LEUART_Enable(obj->serial.periph.leuart, leuartEnable);
mbed_official 525:c320967f86b9 482 } else {
mbed_official 525:c320967f86b9 483 LEUART_Enable(obj->serial.periph.leuart, leuartDisable);
mbed_official 525:c320967f86b9 484 }
mbed_official 525:c320967f86b9 485 } else {
mbed_official 525:c320967f86b9 486 if (enable) {
mbed_official 525:c320967f86b9 487 USART_Enable(obj->serial.periph.uart, usartEnable);
mbed_official 525:c320967f86b9 488 } else {
mbed_official 525:c320967f86b9 489 USART_Enable(obj->serial.periph.uart, usartDisable);
mbed_official 525:c320967f86b9 490 }
mbed_official 525:c320967f86b9 491 }
mbed_official 525:c320967f86b9 492 serial_irq_ids[serial_get_index(obj)] = 0;
mbed_official 525:c320967f86b9 493 }
mbed_official 525:c320967f86b9 494
mbed_official 525:c320967f86b9 495 /**
mbed_official 525:c320967f86b9 496 * Set UART baud rate
mbed_official 525:c320967f86b9 497 */
mbed_official 525:c320967f86b9 498 void serial_baud(serial_t *obj, int baudrate)
mbed_official 525:c320967f86b9 499 {
mbed_official 525:c320967f86b9 500 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 501 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 502
mbed_official 627:4fa1328d9c60 503 /* check if baudrate is within allowed range */
mbed_official 627:4fa1328d9c60 504 MBED_ASSERT(baudrate >= (LEUART_LF_REF_FREQ >> 7));
mbed_official 627:4fa1328d9c60 505
mbed_official 627:4fa1328d9c60 506 if(baudrate > (LEUART_LF_REF_FREQ >> 1)){
mbed_official 627:4fa1328d9c60 507 /* check if baudrate is within allowed range */
mbed_official 627:4fa1328d9c60 508 MBED_ASSERT((baudrate <= (LEUART_HF_REF_FREQ >> 1)) && (baudrate > (LEUART_HF_REF_FREQ >> 10)));
mbed_official 627:4fa1328d9c60 509
mbed_official 627:4fa1328d9c60 510 CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_CORELEDIV2);
mbed_official 627:4fa1328d9c60 511 uint8_t divisor = 1;
mbed_official 627:4fa1328d9c60 512
mbed_official 627:4fa1328d9c60 513 if(baudrate > (LEUART_HF_REF_FREQ >> 7)){
mbed_official 627:4fa1328d9c60 514 divisor = 1;
mbed_official 627:4fa1328d9c60 515 }else if(baudrate > (LEUART_HF_REF_FREQ >> 8)){
mbed_official 627:4fa1328d9c60 516 divisor = 2;
mbed_official 627:4fa1328d9c60 517 }else if(baudrate > (LEUART_HF_REF_FREQ >> 9)){
mbed_official 627:4fa1328d9c60 518 divisor = 4;
mbed_official 627:4fa1328d9c60 519 }else{
mbed_official 627:4fa1328d9c60 520 divisor = 8;
mbed_official 627:4fa1328d9c60 521 }
mbed_official 627:4fa1328d9c60 522 CMU_ClockDivSet(serial_get_clock(obj), divisor);
mbed_official 627:4fa1328d9c60 523 LEUART_BaudrateSet(obj->serial.periph.leuart, LEUART_HF_REF_FREQ/divisor, (uint32_t)baudrate);
mbed_official 627:4fa1328d9c60 524 }else{
mbed_official 627:4fa1328d9c60 525 CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
mbed_official 627:4fa1328d9c60 526 CMU_ClockDivSet(serial_get_clock(obj), 1);
mbed_official 627:4fa1328d9c60 527 LEUART_BaudrateSet(obj->serial.periph.leuart, LEUART_LF_REF_FREQ, (uint32_t)baudrate);
mbed_official 627:4fa1328d9c60 528 }
mbed_official 627:4fa1328d9c60 529 #else
mbed_official 627:4fa1328d9c60 530 /* check if baudrate is within allowed range */
mbed_official 627:4fa1328d9c60 531 MBED_ASSERT((baudrate > (LEUART_REF_FREQ >> 10)) && (baudrate <= (LEUART_REF_FREQ >> 1)));
mbed_official 627:4fa1328d9c60 532 uint8_t divisor = 1;
mbed_official 627:4fa1328d9c60 533 if(baudrate > (LEUART_REF_FREQ >> 7)){
mbed_official 627:4fa1328d9c60 534 divisor = 1;
mbed_official 627:4fa1328d9c60 535 }else if(baudrate > (LEUART_REF_FREQ >> 8)){
mbed_official 627:4fa1328d9c60 536 divisor = 2;
mbed_official 627:4fa1328d9c60 537 }else if(baudrate > (LEUART_REF_FREQ >> 9)){
mbed_official 627:4fa1328d9c60 538 divisor = 4;
mbed_official 627:4fa1328d9c60 539 }else{
mbed_official 627:4fa1328d9c60 540 divisor = 8;
mbed_official 627:4fa1328d9c60 541 }
mbed_official 627:4fa1328d9c60 542 CMU_ClockDivSet(serial_get_clock(obj), divisor);
mbed_official 627:4fa1328d9c60 543 LEUART_BaudrateSet(obj->serial.periph.leuart, LEUART_REF_FREQ/divisor, (uint32_t)baudrate);
mbed_official 627:4fa1328d9c60 544 #endif
mbed_official 525:c320967f86b9 545 } else {
mbed_official 525:c320967f86b9 546 USART_BaudrateAsyncSet(obj->serial.periph.uart, REFERENCE_FREQUENCY, (uint32_t)baudrate, usartOVS16);
mbed_official 525:c320967f86b9 547 }
mbed_official 525:c320967f86b9 548 }
mbed_official 525:c320967f86b9 549
mbed_official 525:c320967f86b9 550 /**
mbed_official 525:c320967f86b9 551 * Set UART format by re-initializing the peripheral.
mbed_official 525:c320967f86b9 552 */
mbed_official 525:c320967f86b9 553 void serial_format(serial_t *obj, int data_bits, SerialParity parity, int stop_bits)
mbed_official 525:c320967f86b9 554 {
mbed_official 525:c320967f86b9 555 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 556 /* Save the serial state */
mbed_official 525:c320967f86b9 557 uint8_t was_enabled = LEUART_StatusGet(obj->serial.periph.leuart) & (LEUART_STATUS_TXENS | LEUART_STATUS_RXENS);
mbed_official 525:c320967f86b9 558 uint32_t enabled_interrupts = obj->serial.periph.leuart->IEN;
mbed_official 548:1abac31e188e 559
mbed_official 525:c320967f86b9 560 LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT;
mbed_official 548:1abac31e188e 561
mbed_official 525:c320967f86b9 562 /* We support 8 data bits ONLY on LEUART*/
mbed_official 525:c320967f86b9 563 MBED_ASSERT(data_bits == 8);
mbed_official 548:1abac31e188e 564
mbed_official 525:c320967f86b9 565 /* Re-init the UART */
mbed_official 525:c320967f86b9 566 init.enable = (was_enabled == 0 ? leuartDisable : leuartEnable);
mbed_official 525:c320967f86b9 567 init.baudrate = LEUART_BaudrateGet(obj->serial.periph.leuart);
mbed_official 525:c320967f86b9 568 if (stop_bits == 2) {
mbed_official 525:c320967f86b9 569 init.stopbits = leuartStopbits2;
mbed_official 525:c320967f86b9 570 } else {
mbed_official 525:c320967f86b9 571 init.stopbits = leuartStopbits1;
mbed_official 525:c320967f86b9 572 }
mbed_official 525:c320967f86b9 573 switch (parity) {
mbed_official 525:c320967f86b9 574 case ParityOdd:
mbed_official 525:c320967f86b9 575 case ParityForced0:
mbed_official 525:c320967f86b9 576 init.parity = leuartOddParity;
mbed_official 525:c320967f86b9 577 break;
mbed_official 525:c320967f86b9 578 case ParityEven:
mbed_official 525:c320967f86b9 579 case ParityForced1:
mbed_official 525:c320967f86b9 580 init.parity = leuartEvenParity;
mbed_official 525:c320967f86b9 581 break;
mbed_official 525:c320967f86b9 582 default: /* ParityNone */
mbed_official 525:c320967f86b9 583 init.parity = leuartNoParity;
mbed_official 525:c320967f86b9 584 break;
mbed_official 525:c320967f86b9 585 }
mbed_official 525:c320967f86b9 586
mbed_official 525:c320967f86b9 587 LEUART_Init(obj->serial.periph.leuart, &init);
mbed_official 525:c320967f86b9 588
mbed_official 525:c320967f86b9 589 /* Re-enable pins for UART at correct location */
mbed_official 525:c320967f86b9 590 obj->serial.periph.leuart->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | (obj->serial.location << _LEUART_ROUTE_LOCATION_SHIFT);
mbed_official 548:1abac31e188e 591
mbed_official 525:c320967f86b9 592 /* Re-enable interrupts */
mbed_official 525:c320967f86b9 593 if(was_enabled != 0) {
mbed_official 525:c320967f86b9 594 obj->serial.periph.leuart->IFC = LEUART_IFC_TXC;
mbed_official 525:c320967f86b9 595 obj->serial.periph.leuart->IEN = enabled_interrupts;
mbed_official 525:c320967f86b9 596 }
mbed_official 525:c320967f86b9 597 } else {
mbed_official 525:c320967f86b9 598 /* Save the serial state */
mbed_official 525:c320967f86b9 599 uint8_t was_enabled = USART_StatusGet(obj->serial.periph.uart) & (USART_STATUS_TXENS | USART_STATUS_RXENS);
mbed_official 525:c320967f86b9 600 uint32_t enabled_interrupts = obj->serial.periph.uart->IEN;
mbed_official 548:1abac31e188e 601
mbed_official 525:c320967f86b9 602
mbed_official 525:c320967f86b9 603 USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
mbed_official 548:1abac31e188e 604
mbed_official 525:c320967f86b9 605 /* We support 4 to 8 data bits */
mbed_official 525:c320967f86b9 606 MBED_ASSERT(data_bits >= 4 && data_bits <= 8);
mbed_official 548:1abac31e188e 607
mbed_official 525:c320967f86b9 608 /* Re-init the UART */
mbed_official 525:c320967f86b9 609 init.enable = (was_enabled == 0 ? usartDisable : usartEnable);
mbed_official 525:c320967f86b9 610 init.baudrate = USART_BaudrateGet(obj->serial.periph.uart);
mbed_official 525:c320967f86b9 611 init.oversampling = usartOVS16;
mbed_official 525:c320967f86b9 612 init.databits = (USART_Databits_TypeDef)((data_bits - 3) << _USART_FRAME_DATABITS_SHIFT);
mbed_official 525:c320967f86b9 613 if (stop_bits == 2) {
mbed_official 525:c320967f86b9 614 init.stopbits = usartStopbits2;
mbed_official 525:c320967f86b9 615 } else {
mbed_official 525:c320967f86b9 616 init.stopbits = usartStopbits1;
mbed_official 525:c320967f86b9 617 }
mbed_official 525:c320967f86b9 618 switch (parity) {
mbed_official 525:c320967f86b9 619 case ParityOdd:
mbed_official 525:c320967f86b9 620 case ParityForced0:
mbed_official 525:c320967f86b9 621 init.parity = usartOddParity;
mbed_official 525:c320967f86b9 622 break;
mbed_official 525:c320967f86b9 623 case ParityEven:
mbed_official 525:c320967f86b9 624 case ParityForced1:
mbed_official 525:c320967f86b9 625 init.parity = usartEvenParity;
mbed_official 525:c320967f86b9 626 break;
mbed_official 525:c320967f86b9 627 default: /* ParityNone */
mbed_official 525:c320967f86b9 628 init.parity = usartNoParity;
mbed_official 525:c320967f86b9 629 break;
mbed_official 525:c320967f86b9 630 }
mbed_official 525:c320967f86b9 631
mbed_official 525:c320967f86b9 632 USART_InitAsync(obj->serial.periph.uart, &init);
mbed_official 525:c320967f86b9 633
mbed_official 525:c320967f86b9 634 /* Re-enable pins for UART at correct location */
mbed_official 525:c320967f86b9 635 obj->serial.periph.uart->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | (obj->serial.location << _USART_ROUTE_LOCATION_SHIFT);
mbed_official 548:1abac31e188e 636
mbed_official 525:c320967f86b9 637 /* Re-enable interrupts */
mbed_official 525:c320967f86b9 638 if(was_enabled != 0) {
mbed_official 525:c320967f86b9 639 obj->serial.periph.uart->IFC = USART_IFC_TXC;
mbed_official 525:c320967f86b9 640 obj->serial.periph.uart->IEN = enabled_interrupts;
mbed_official 525:c320967f86b9 641 }
mbed_official 525:c320967f86b9 642 }
mbed_official 525:c320967f86b9 643 }
mbed_official 525:c320967f86b9 644
mbed_official 525:c320967f86b9 645 /******************************************************************************
mbed_official 525:c320967f86b9 646 * INTERRUPTS *
mbed_official 525:c320967f86b9 647 ******************************************************************************/
mbed_official 525:c320967f86b9 648 uint8_t serial_tx_ready(serial_t *obj)
mbed_official 525:c320967f86b9 649 {
mbed_official 525:c320967f86b9 650 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 651 return (obj->serial.periph.leuart->STATUS & LEUART_STATUS_TXBL) ? true : false;
mbed_official 525:c320967f86b9 652 } else {
mbed_official 525:c320967f86b9 653 return (obj->serial.periph.uart->STATUS & USART_STATUS_TXBL) ? true : false;
mbed_official 525:c320967f86b9 654 }
mbed_official 525:c320967f86b9 655 }
mbed_official 525:c320967f86b9 656
mbed_official 525:c320967f86b9 657 uint8_t serial_rx_ready(serial_t *obj)
mbed_official 525:c320967f86b9 658 {
mbed_official 525:c320967f86b9 659 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 660 return (obj->serial.periph.leuart->STATUS & LEUART_STATUS_RXDATAV) ? true : false;
mbed_official 525:c320967f86b9 661 } else {
mbed_official 525:c320967f86b9 662 return (obj->serial.periph.uart->STATUS & USART_STATUS_RXDATAV) ? true : false;
mbed_official 525:c320967f86b9 663 }
mbed_official 525:c320967f86b9 664 }
mbed_official 525:c320967f86b9 665
mbed_official 525:c320967f86b9 666 void serial_write_asynch(serial_t *obj, int data)
mbed_official 525:c320967f86b9 667 {
mbed_official 525:c320967f86b9 668 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 669 obj->serial.periph.leuart->TXDATA = (uint32_t)data;
mbed_official 525:c320967f86b9 670 } else {
mbed_official 525:c320967f86b9 671 obj->serial.periph.uart->TXDATA = (uint32_t)data;
mbed_official 525:c320967f86b9 672 }
mbed_official 525:c320967f86b9 673 }
mbed_official 525:c320967f86b9 674
mbed_official 525:c320967f86b9 675 int serial_read_asynch(serial_t *obj)
mbed_official 525:c320967f86b9 676 {
mbed_official 525:c320967f86b9 677 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 678 return (int)obj->serial.periph.leuart->RXDATA;
mbed_official 525:c320967f86b9 679 } else {
mbed_official 525:c320967f86b9 680 return (int)obj->serial.periph.uart->RXDATA;
mbed_official 548:1abac31e188e 681 }
mbed_official 525:c320967f86b9 682 }
mbed_official 525:c320967f86b9 683
mbed_official 525:c320967f86b9 684 uint8_t serial_tx_int_flag(serial_t *obj)
mbed_official 525:c320967f86b9 685 {
mbed_official 525:c320967f86b9 686 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 687 return (obj->serial.periph.leuart->IF & LEUART_IF_TXBL) ? true : false;
mbed_official 525:c320967f86b9 688 } else {
mbed_official 525:c320967f86b9 689 return (obj->serial.periph.uart->IF & USART_IF_TXBL) ? true : false;
mbed_official 548:1abac31e188e 690 }
mbed_official 525:c320967f86b9 691 }
mbed_official 525:c320967f86b9 692
mbed_official 525:c320967f86b9 693 uint8_t serial_rx_int_flag(serial_t *obj)
mbed_official 525:c320967f86b9 694 {
mbed_official 525:c320967f86b9 695 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 696 return (obj->serial.periph.leuart->IF & LEUART_IF_RXDATAV) ? true : false;
mbed_official 525:c320967f86b9 697 } else {
mbed_official 525:c320967f86b9 698 return (obj->serial.periph.uart->IF & USART_IF_RXDATAV) ? true : false;
mbed_official 548:1abac31e188e 699 }
mbed_official 525:c320967f86b9 700 }
mbed_official 525:c320967f86b9 701
mbed_official 525:c320967f86b9 702 void serial_read_asynch_complete(serial_t *obj)
mbed_official 525:c320967f86b9 703 {
mbed_official 525:c320967f86b9 704 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 705 obj->serial.periph.leuart->IFC |= LEUART_IFC_RXOF; // in case it got full
mbed_official 525:c320967f86b9 706 } else {
mbed_official 525:c320967f86b9 707 obj->serial.periph.uart->IFC |= USART_IFC_RXFULL; // in case it got full
mbed_official 525:c320967f86b9 708 }
mbed_official 525:c320967f86b9 709 }
mbed_official 525:c320967f86b9 710
mbed_official 525:c320967f86b9 711 void serial_write_asynch_complete(serial_t *obj)
mbed_official 525:c320967f86b9 712 {
mbed_official 525:c320967f86b9 713 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 714 obj->serial.periph.leuart->IFC |= LEUART_IFC_TXC;
mbed_official 525:c320967f86b9 715 } else {
mbed_official 525:c320967f86b9 716 obj->serial.periph.uart->IFC |= USART_IFC_TXC;
mbed_official 525:c320967f86b9 717 }
mbed_official 525:c320967f86b9 718 }
mbed_official 525:c320967f86b9 719
mbed_official 525:c320967f86b9 720 /** Enable and set the interrupt handler for write (TX)
mbed_official 525:c320967f86b9 721 *
mbed_official 525:c320967f86b9 722 * @param obj The serial object
mbed_official 525:c320967f86b9 723 * @param address The address of TX handler
mbed_official 525:c320967f86b9 724 * @param enable Set to non-zero to enable or zero to disable
mbed_official 525:c320967f86b9 725 */
mbed_official 525:c320967f86b9 726 void serial_write_enable_interrupt(serial_t *obj, uint32_t address, uint8_t enable)
mbed_official 525:c320967f86b9 727 {
mbed_official 525:c320967f86b9 728 NVIC_SetVector(serial_get_tx_irq_index(obj), address);
mbed_official 525:c320967f86b9 729 serial_irq_set(obj, (SerialIrq)1, enable);
mbed_official 525:c320967f86b9 730 }
mbed_official 525:c320967f86b9 731
mbed_official 525:c320967f86b9 732 /** Enable and set the interrupt handler for read (RX)
mbed_official 525:c320967f86b9 733 *
mbed_official 525:c320967f86b9 734 * @param obj The serial object
mbed_official 525:c320967f86b9 735 * @param address The address of RX handler
mbed_official 525:c320967f86b9 736 * @param enable Set to non-zero to enable or zero to disable
mbed_official 525:c320967f86b9 737 */
mbed_official 525:c320967f86b9 738 void serial_read_enable_interrupt(serial_t *obj, uint32_t address, uint8_t enable)
mbed_official 525:c320967f86b9 739 {
mbed_official 525:c320967f86b9 740 NVIC_SetVector(serial_get_rx_irq_index(obj), address);
mbed_official 525:c320967f86b9 741 serial_irq_set(obj, (SerialIrq)0, enable);
mbed_official 525:c320967f86b9 742 }
mbed_official 525:c320967f86b9 743
mbed_official 525:c320967f86b9 744 uint8_t serial_interrupt_enabled(serial_t *obj)
mbed_official 525:c320967f86b9 745 {
mbed_official 525:c320967f86b9 746 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 747 return (obj->serial.periph.leuart->IEN & (LEUART_IEN_RXDATAV | LEUART_IEN_TXBL)) ? true : false;
mbed_official 525:c320967f86b9 748 } else {
mbed_official 525:c320967f86b9 749 return (obj->serial.periph.uart->IEN & (USART_IEN_RXDATAV | USART_IEN_TXBL)) ? true : false;
mbed_official 525:c320967f86b9 750 }
mbed_official 525:c320967f86b9 751 }
mbed_official 525:c320967f86b9 752
mbed_official 525:c320967f86b9 753 /**
mbed_official 525:c320967f86b9 754 * Set handler for all serial interrupts (is probably SerialBase::_handler())
mbed_official 525:c320967f86b9 755 * and store IRQ ID to be returned to the handler upon interrupt. ID is
mbed_official 525:c320967f86b9 756 * probably a pointer to the calling Serial object.
mbed_official 525:c320967f86b9 757 */
mbed_official 525:c320967f86b9 758 void serial_irq_handler(serial_t *obj, uart_irq_handler handler, uint32_t id)
mbed_official 525:c320967f86b9 759 {
mbed_official 525:c320967f86b9 760 irq_handler = handler;
mbed_official 525:c320967f86b9 761 serial_irq_ids[serial_get_index(obj)] = id;
mbed_official 525:c320967f86b9 762 }
mbed_official 525:c320967f86b9 763
mbed_official 525:c320967f86b9 764 /**
mbed_official 525:c320967f86b9 765 * Generic ISR for all UARTs, both TX and RX
mbed_official 525:c320967f86b9 766 */
mbed_official 525:c320967f86b9 767 static void uart_irq(UARTName name, int index, SerialIrq irq)
mbed_official 525:c320967f86b9 768 {
mbed_official 525:c320967f86b9 769 if (serial_irq_ids[index] != 0) {
mbed_official 525:c320967f86b9 770 /* Pass interrupt on to mbed common handler */
mbed_official 525:c320967f86b9 771 irq_handler(serial_irq_ids[index], irq);
mbed_official 525:c320967f86b9 772 /* Clearing interrupt not necessary */
mbed_official 525:c320967f86b9 773 }
mbed_official 525:c320967f86b9 774 }
mbed_official 525:c320967f86b9 775
mbed_official 525:c320967f86b9 776 /**
mbed_official 525:c320967f86b9 777 * Set ISR for a given UART and interrupt event (TX or RX)
mbed_official 525:c320967f86b9 778 */
mbed_official 525:c320967f86b9 779 void serial_irq_set(serial_t *obj, SerialIrq irq, uint32_t enable)
mbed_official 525:c320967f86b9 780 {
mbed_official 525:c320967f86b9 781 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 782 /* Enable or disable interrupt */
mbed_official 525:c320967f86b9 783 if (enable) {
mbed_official 525:c320967f86b9 784 if (irq == RxIrq) { /* RX */
mbed_official 525:c320967f86b9 785 obj->serial.periph.leuart->IEN |= LEUART_IEN_RXDATAV;
mbed_official 525:c320967f86b9 786 NVIC_ClearPendingIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 787 NVIC_EnableIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 788 } else { /* TX */
mbed_official 525:c320967f86b9 789 obj->serial.periph.leuart->IEN |= LEUART_IEN_TXC;
mbed_official 525:c320967f86b9 790 NVIC_ClearPendingIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 791 NVIC_SetPriority(serial_get_tx_irq_index(obj), 1);
mbed_official 525:c320967f86b9 792 NVIC_EnableIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 793 }
mbed_official 525:c320967f86b9 794 } else {
mbed_official 525:c320967f86b9 795 if (irq == RxIrq) { /* RX */
mbed_official 525:c320967f86b9 796 obj->serial.periph.leuart->IEN &= ~LEUART_IEN_RXDATAV;
mbed_official 525:c320967f86b9 797 NVIC_DisableIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 798 } else { /* TX */
mbed_official 525:c320967f86b9 799 obj->serial.periph.leuart->IEN &= ~LEUART_IEN_TXC;
mbed_official 525:c320967f86b9 800 NVIC_DisableIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 801 }
mbed_official 525:c320967f86b9 802 }
mbed_official 525:c320967f86b9 803 } else {
mbed_official 525:c320967f86b9 804 /* Enable or disable interrupt */
mbed_official 525:c320967f86b9 805 if (enable) {
mbed_official 525:c320967f86b9 806 if (irq == RxIrq) { /* RX */
mbed_official 525:c320967f86b9 807 obj->serial.periph.uart->IEN |= USART_IEN_RXDATAV;
mbed_official 525:c320967f86b9 808 NVIC_ClearPendingIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 809 NVIC_EnableIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 810 } else { /* TX */
mbed_official 525:c320967f86b9 811 obj->serial.periph.uart->IEN |= USART_IEN_TXC;
mbed_official 525:c320967f86b9 812 NVIC_ClearPendingIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 813 NVIC_SetPriority(serial_get_tx_irq_index(obj), 1);
mbed_official 525:c320967f86b9 814 NVIC_EnableIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 815 }
mbed_official 525:c320967f86b9 816 } else {
mbed_official 525:c320967f86b9 817 if (irq == RxIrq) { /* RX */
mbed_official 525:c320967f86b9 818 obj->serial.periph.uart->IEN &= ~USART_IEN_RXDATAV;
mbed_official 525:c320967f86b9 819 NVIC_DisableIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 820 } else { /* TX */
mbed_official 525:c320967f86b9 821 obj->serial.periph.uart->IEN &= ~USART_IEN_TXC;
mbed_official 525:c320967f86b9 822 NVIC_DisableIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 823 }
mbed_official 525:c320967f86b9 824 }
mbed_official 525:c320967f86b9 825 }
mbed_official 525:c320967f86b9 826 }
mbed_official 525:c320967f86b9 827
mbed_official 525:c320967f86b9 828 /******************************************************************************
mbed_official 525:c320967f86b9 829 * READ/WRITE *
mbed_official 525:c320967f86b9 830 ******************************************************************************/
mbed_official 525:c320967f86b9 831
mbed_official 525:c320967f86b9 832 /**
mbed_official 525:c320967f86b9 833 * Get one char from serial link
mbed_official 525:c320967f86b9 834 */
mbed_official 525:c320967f86b9 835 int serial_getc(serial_t *obj)
mbed_official 525:c320967f86b9 836 {
mbed_official 525:c320967f86b9 837 /* Emlib USART_Rx blocks until data is available, so we don't need to use
mbed_official 525:c320967f86b9 838 * serial_readable(). Use USART_RxDataGet() to read register directly. */
mbed_official 525:c320967f86b9 839 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 840 return LEUART_Rx(obj->serial.periph.leuart);
mbed_official 525:c320967f86b9 841 } else {
mbed_official 525:c320967f86b9 842 return USART_Rx(obj->serial.periph.uart);
mbed_official 525:c320967f86b9 843 }
mbed_official 525:c320967f86b9 844 }
mbed_official 525:c320967f86b9 845
mbed_official 525:c320967f86b9 846 /*
mbed_official 525:c320967f86b9 847 * Send one char over serial link
mbed_official 525:c320967f86b9 848 */
mbed_official 525:c320967f86b9 849 void serial_putc(serial_t *obj, int c)
mbed_official 525:c320967f86b9 850 {
mbed_official 525:c320967f86b9 851 /* Emlib USART_Tx blocks until buffer is writable (non-full), so we don't
mbed_official 525:c320967f86b9 852 * need to use serial_writable(). */
mbed_official 525:c320967f86b9 853 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 854 LEUART_Tx(obj->serial.periph.leuart, (uint8_t)(c));
mbed_official 525:c320967f86b9 855 } else {
mbed_official 525:c320967f86b9 856 USART_Tx(obj->serial.periph.uart, (uint8_t)(c));
mbed_official 525:c320967f86b9 857 }
mbed_official 525:c320967f86b9 858 }
mbed_official 525:c320967f86b9 859
mbed_official 525:c320967f86b9 860 /**
mbed_official 525:c320967f86b9 861 * Check if data is available in RX data vector
mbed_official 525:c320967f86b9 862 */
mbed_official 525:c320967f86b9 863 int serial_readable(serial_t *obj)
mbed_official 525:c320967f86b9 864 {
mbed_official 525:c320967f86b9 865 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 866 return obj->serial.periph.leuart->STATUS & LEUART_STATUS_RXDATAV;
mbed_official 525:c320967f86b9 867 } else {
mbed_official 525:c320967f86b9 868 return obj->serial.periph.uart->STATUS & USART_STATUS_RXDATAV;
mbed_official 548:1abac31e188e 869 }
mbed_official 525:c320967f86b9 870 }
mbed_official 525:c320967f86b9 871
mbed_official 525:c320967f86b9 872 /**
mbed_official 525:c320967f86b9 873 * Check if TX buffer is empty
mbed_official 525:c320967f86b9 874 */
mbed_official 525:c320967f86b9 875 int serial_writable(serial_t *obj)
mbed_official 525:c320967f86b9 876 {
mbed_official 525:c320967f86b9 877 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 878 return obj->serial.periph.leuart->STATUS & LEUART_STATUS_TXBL;
mbed_official 525:c320967f86b9 879 } else {
mbed_official 525:c320967f86b9 880 return obj->serial.periph.uart->STATUS & USART_STATUS_TXBL;
mbed_official 525:c320967f86b9 881 }
mbed_official 525:c320967f86b9 882 }
mbed_official 525:c320967f86b9 883
mbed_official 525:c320967f86b9 884 /**
mbed_official 525:c320967f86b9 885 * Clear UART interrupts
mbed_official 525:c320967f86b9 886 */
mbed_official 525:c320967f86b9 887 void serial_clear(serial_t *obj)
mbed_official 525:c320967f86b9 888 {
mbed_official 525:c320967f86b9 889 /* Interrupts automatically clear when condition is not met anymore */
mbed_official 525:c320967f86b9 890 }
mbed_official 525:c320967f86b9 891
mbed_official 525:c320967f86b9 892 void serial_break_set(serial_t *obj)
mbed_official 525:c320967f86b9 893 {
mbed_official 525:c320967f86b9 894 /* Send transmission break */
mbed_official 525:c320967f86b9 895 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 896 obj->serial.periph.leuart->TXDATAX = LEUART_TXDATAX_TXBREAK;
mbed_official 525:c320967f86b9 897 } else {
mbed_official 525:c320967f86b9 898 obj->serial.periph.uart->TXDATAX = USART_TXDATAX_TXBREAK;
mbed_official 525:c320967f86b9 899 }
mbed_official 525:c320967f86b9 900 }
mbed_official 525:c320967f86b9 901
mbed_official 525:c320967f86b9 902 void serial_break_clear(serial_t *obj)
mbed_official 525:c320967f86b9 903 {
mbed_official 525:c320967f86b9 904 /* No need to clear break, it is automatically cleared after one frame.
mbed_official 525:c320967f86b9 905 * From the reference manual:
mbed_official 525:c320967f86b9 906 *
mbed_official 525:c320967f86b9 907 * By setting TXBREAK, the output will be held low during the stop-bit
mbed_official 525:c320967f86b9 908 * period to generate a framing error. A receiver that supports break
mbed_official 525:c320967f86b9 909 * detection detects this state, allowing it to be used e.g. for framing
mbed_official 525:c320967f86b9 910 * of larger data packets. The line is driven high before the next frame
mbed_official 525:c320967f86b9 911 * is transmitted so the next start condition can be identified correctly
mbed_official 525:c320967f86b9 912 * by the recipient. Continuous breaks lasting longer than a USART frame
mbed_official 525:c320967f86b9 913 * are thus not supported by the USART. GPIO can be used for this.
mbed_official 525:c320967f86b9 914 */
mbed_official 525:c320967f86b9 915 }
mbed_official 525:c320967f86b9 916
mbed_official 525:c320967f86b9 917 void serial_pinout_tx(PinName tx)
mbed_official 525:c320967f86b9 918 {
mbed_official 525:c320967f86b9 919 /* 0x10 sets DOUT high. Prevents false start. */
mbed_official 525:c320967f86b9 920 pin_mode(tx, PushPull | 0x10);
mbed_official 525:c320967f86b9 921 }
mbed_official 525:c320967f86b9 922
mbed_official 525:c320967f86b9 923 /************************************************************************************
mbed_official 627:4fa1328d9c60 924 * DMA helper functions *
mbed_official 525:c320967f86b9 925 ************************************************************************************/
mbed_official 525:c320967f86b9 926 /******************************************
mbed_official 525:c320967f86b9 927 * static void serial_dmaTransferComplete(uint channel, bool primary, void* user)
mbed_official 525:c320967f86b9 928 *
mbed_official 525:c320967f86b9 929 * Callback function which gets called upon DMA transfer completion
mbed_official 525:c320967f86b9 930 * the user-defined pointer is pointing to the CPP-land thunk
mbed_official 525:c320967f86b9 931 ******************************************/
mbed_official 525:c320967f86b9 932 static void serial_dmaTransferComplete(unsigned int channel, bool primary, void *user)
mbed_official 525:c320967f86b9 933 {
mbed_official 548:1abac31e188e 934 /* Store information about which channel triggered because CPP doesn't take arguments */
mbed_official 548:1abac31e188e 935 serial_dma_irq_fired[channel] = true;
mbed_official 525:c320967f86b9 936
mbed_official 525:c320967f86b9 937 /* User pointer should be a thunk to CPP land */
mbed_official 525:c320967f86b9 938 if (user != NULL) {
mbed_official 525:c320967f86b9 939 ((DMACallback)user)();
mbed_official 525:c320967f86b9 940 }
mbed_official 525:c320967f86b9 941 }
mbed_official 525:c320967f86b9 942
mbed_official 525:c320967f86b9 943 /******************************************
mbed_official 525:c320967f86b9 944 * static void serial_setupDmaChannel(serial_t *obj, bool tx_nrx)
mbed_official 525:c320967f86b9 945 *
mbed_official 525:c320967f86b9 946 * Sets up the DMA configuration block for the assigned channel
mbed_official 525:c320967f86b9 947 * tx_nrx: true if configuring TX, false if configuring RX.
mbed_official 525:c320967f86b9 948 ******************************************/
mbed_official 548:1abac31e188e 949 static void serial_dmaSetupChannel(serial_t *obj, bool tx_nrx)
mbed_official 548:1abac31e188e 950 {
mbed_official 548:1abac31e188e 951 DMA_CfgChannel_TypeDef channelConfig;
mbed_official 525:c320967f86b9 952
mbed_official 548:1abac31e188e 953 if(tx_nrx) {
mbed_official 548:1abac31e188e 954 //setup TX channel
mbed_official 548:1abac31e188e 955 channelConfig.highPri = false;
mbed_official 548:1abac31e188e 956 channelConfig.enableInt = true;
mbed_official 548:1abac31e188e 957 channelConfig.cb = &(obj->serial.dmaOptionsTX.dmaCallback);
mbed_official 525:c320967f86b9 958
mbed_official 548:1abac31e188e 959 switch((uint32_t)(obj->serial.periph.uart)) {
mbed_official 525:c320967f86b9 960 #ifdef UART0
mbed_official 548:1abac31e188e 961 case UART_0:
mbed_official 548:1abac31e188e 962 channelConfig.select = DMAREQ_UART0_TXBL;
mbed_official 548:1abac31e188e 963 break;
mbed_official 525:c320967f86b9 964 #endif
mbed_official 525:c320967f86b9 965 #ifdef UART1
mbed_official 548:1abac31e188e 966 case UART_1:
mbed_official 548:1abac31e188e 967 channelConfig.select = DMAREQ_UART1_TXBL;
mbed_official 548:1abac31e188e 968 break;
mbed_official 525:c320967f86b9 969 #endif
mbed_official 525:c320967f86b9 970 #ifdef USART0
mbed_official 548:1abac31e188e 971 case USART_0:
mbed_official 548:1abac31e188e 972 channelConfig.select = DMAREQ_USART0_TXBL;
mbed_official 548:1abac31e188e 973 break;
mbed_official 525:c320967f86b9 974 #endif
mbed_official 525:c320967f86b9 975 #ifdef USART1
mbed_official 548:1abac31e188e 976 case USART_1:
mbed_official 548:1abac31e188e 977 channelConfig.select = DMAREQ_USART1_TXBL;
mbed_official 548:1abac31e188e 978 break;
mbed_official 525:c320967f86b9 979 #endif
mbed_official 525:c320967f86b9 980 #ifdef USART2
mbed_official 548:1abac31e188e 981 case USART_2:
mbed_official 548:1abac31e188e 982 channelConfig.select = DMAREQ_USART2_TXBL;
mbed_official 548:1abac31e188e 983 break;
mbed_official 525:c320967f86b9 984 #endif
mbed_official 525:c320967f86b9 985 #ifdef LEUART0
mbed_official 548:1abac31e188e 986 case LEUART_0:
mbed_official 548:1abac31e188e 987 channelConfig.select = DMAREQ_LEUART0_TXBL;
mbed_official 548:1abac31e188e 988 break;
mbed_official 525:c320967f86b9 989 #endif
mbed_official 525:c320967f86b9 990 #ifdef LEUART1
mbed_official 548:1abac31e188e 991 case LEUART_1:
mbed_official 548:1abac31e188e 992 channelConfig.select = DMAREQ_LEUART1_TXBL;
mbed_official 548:1abac31e188e 993 break;
mbed_official 525:c320967f86b9 994 #endif
mbed_official 548:1abac31e188e 995 }
mbed_official 525:c320967f86b9 996
mbed_official 548:1abac31e188e 997 DMA_CfgChannel(obj->serial.dmaOptionsTX.dmaChannel, &channelConfig);
mbed_official 548:1abac31e188e 998 } else {
mbed_official 548:1abac31e188e 999 //setup RX channel
mbed_official 548:1abac31e188e 1000 channelConfig.highPri = true;
mbed_official 548:1abac31e188e 1001 channelConfig.enableInt = true;
mbed_official 548:1abac31e188e 1002 channelConfig.cb = &(obj->serial.dmaOptionsRX.dmaCallback);
mbed_official 525:c320967f86b9 1003
mbed_official 548:1abac31e188e 1004 switch((uint32_t)(obj->serial.periph.uart)) {
mbed_official 525:c320967f86b9 1005 #ifdef UART0
mbed_official 548:1abac31e188e 1006 case UART_0:
mbed_official 548:1abac31e188e 1007 channelConfig.select = DMAREQ_UART0_RXDATAV;
mbed_official 548:1abac31e188e 1008 break;
mbed_official 525:c320967f86b9 1009 #endif
mbed_official 525:c320967f86b9 1010 #ifdef UART1
mbed_official 548:1abac31e188e 1011 case UART_1:
mbed_official 548:1abac31e188e 1012 channelConfig.select = DMAREQ_UART1_RXDATAV;
mbed_official 548:1abac31e188e 1013 break;
mbed_official 525:c320967f86b9 1014 #endif
mbed_official 525:c320967f86b9 1015 #ifdef USART0
mbed_official 548:1abac31e188e 1016 case USART_0:
mbed_official 548:1abac31e188e 1017 channelConfig.select = DMAREQ_USART0_RXDATAV;
mbed_official 548:1abac31e188e 1018 break;
mbed_official 525:c320967f86b9 1019 #endif
mbed_official 525:c320967f86b9 1020 #ifdef USART1
mbed_official 548:1abac31e188e 1021 case USART_1:
mbed_official 548:1abac31e188e 1022 channelConfig.select = DMAREQ_USART1_RXDATAV;
mbed_official 548:1abac31e188e 1023 break;
mbed_official 525:c320967f86b9 1024 #endif
mbed_official 525:c320967f86b9 1025 #ifdef USART2
mbed_official 548:1abac31e188e 1026 case USART_2:
mbed_official 548:1abac31e188e 1027 channelConfig.select = DMAREQ_USART2_RXDATAV;
mbed_official 548:1abac31e188e 1028 break;
mbed_official 525:c320967f86b9 1029 #endif
mbed_official 525:c320967f86b9 1030 #ifdef LEUART0
mbed_official 548:1abac31e188e 1031 case LEUART_0:
mbed_official 548:1abac31e188e 1032 channelConfig.select = DMAREQ_LEUART0_RXDATAV;
mbed_official 548:1abac31e188e 1033 break;
mbed_official 525:c320967f86b9 1034 #endif
mbed_official 525:c320967f86b9 1035 #ifdef LEUART1
mbed_official 548:1abac31e188e 1036 case LEUART_1:
mbed_official 548:1abac31e188e 1037 channelConfig.select = DMAREQ_LEUART1_RXDATAV;
mbed_official 548:1abac31e188e 1038 break;
mbed_official 525:c320967f86b9 1039 #endif
mbed_official 548:1abac31e188e 1040 }
mbed_official 525:c320967f86b9 1041
mbed_official 548:1abac31e188e 1042 DMA_CfgChannel(obj->serial.dmaOptionsRX.dmaChannel, &channelConfig);
mbed_official 548:1abac31e188e 1043 }
mbed_official 525:c320967f86b9 1044
mbed_official 525:c320967f86b9 1045
mbed_official 525:c320967f86b9 1046 }
mbed_official 525:c320967f86b9 1047
mbed_official 525:c320967f86b9 1048 /******************************************
mbed_official 525:c320967f86b9 1049 * static void serial_dmaTrySetState(DMA_OPTIONS_t *obj, DMAUsage requestedState)
mbed_official 525:c320967f86b9 1050 *
mbed_official 525:c320967f86b9 1051 * Tries to set the passed DMA state to the requested state.
mbed_official 525:c320967f86b9 1052 *
mbed_official 525:c320967f86b9 1053 * requested state possibilities:
mbed_official 627:4fa1328d9c60 1054 * * NEVER:
mbed_official 627:4fa1328d9c60 1055 * if the previous state was always, will deallocate the channel
mbed_official 627:4fa1328d9c60 1056 * * OPPORTUNISTIC:
mbed_official 627:4fa1328d9c60 1057 * If the previous state was always, will reuse that channel but free upon next completion.
mbed_official 627:4fa1328d9c60 1058 * If not, will try to acquire a channel.
mbed_official 627:4fa1328d9c60 1059 * When allocated, state changes to DMA_USAGE_TEMPORARY_ALLOCATED.
mbed_official 627:4fa1328d9c60 1060 * * ALWAYS:
mbed_official 627:4fa1328d9c60 1061 * Will try to allocate a channel and keep it.
mbed_official 627:4fa1328d9c60 1062 * If succesfully allocated, state changes to DMA_USAGE_ALLOCATED.
mbed_official 525:c320967f86b9 1063 ******************************************/
mbed_official 548:1abac31e188e 1064 static void serial_dmaTrySetState(DMA_OPTIONS_t *obj, DMAUsage requestedState, serial_t *serialPtr, bool tx_nrx)
mbed_official 548:1abac31e188e 1065 {
mbed_official 548:1abac31e188e 1066 DMAUsage currentState = obj->dmaUsageState;
mbed_official 548:1abac31e188e 1067 int tempDMAChannel = -1;
mbed_official 525:c320967f86b9 1068
mbed_official 548:1abac31e188e 1069 if ((requestedState == DMA_USAGE_ALWAYS) && (currentState != DMA_USAGE_ALLOCATED)) {
mbed_official 548:1abac31e188e 1070 /* Try to allocate channel */
mbed_official 548:1abac31e188e 1071 tempDMAChannel = dma_channel_allocate(DMA_CAP_NONE);
mbed_official 548:1abac31e188e 1072 if(tempDMAChannel >= 0) {
mbed_official 548:1abac31e188e 1073 obj->dmaChannel = tempDMAChannel;
mbed_official 548:1abac31e188e 1074 obj->dmaUsageState = DMA_USAGE_ALLOCATED;
mbed_official 548:1abac31e188e 1075 dma_init();
mbed_official 548:1abac31e188e 1076 serial_dmaSetupChannel(serialPtr, tx_nrx);
mbed_official 548:1abac31e188e 1077 }
mbed_official 548:1abac31e188e 1078 } else if (requestedState == DMA_USAGE_OPPORTUNISTIC) {
mbed_official 548:1abac31e188e 1079 if (currentState == DMA_USAGE_ALLOCATED) {
mbed_official 548:1abac31e188e 1080 /* Channels have already been allocated previously by an ALWAYS state, so after this transfer, we will release them */
mbed_official 548:1abac31e188e 1081 obj->dmaUsageState = DMA_USAGE_TEMPORARY_ALLOCATED;
mbed_official 548:1abac31e188e 1082 } else {
mbed_official 548:1abac31e188e 1083 /* Try to allocate channel */
mbed_official 548:1abac31e188e 1084 tempDMAChannel = dma_channel_allocate(DMA_CAP_NONE);
mbed_official 548:1abac31e188e 1085 if(tempDMAChannel >= 0) {
mbed_official 548:1abac31e188e 1086 obj->dmaChannel = tempDMAChannel;
mbed_official 548:1abac31e188e 1087 obj->dmaUsageState = DMA_USAGE_TEMPORARY_ALLOCATED;
mbed_official 548:1abac31e188e 1088 dma_init();
mbed_official 548:1abac31e188e 1089 serial_dmaSetupChannel(serialPtr, tx_nrx);
mbed_official 548:1abac31e188e 1090 }
mbed_official 548:1abac31e188e 1091 }
mbed_official 548:1abac31e188e 1092 } else if (requestedState == DMA_USAGE_NEVER) {
mbed_official 548:1abac31e188e 1093 /* If channel is allocated, get rid of it */
mbed_official 548:1abac31e188e 1094 dma_channel_free(obj->dmaChannel);
mbed_official 548:1abac31e188e 1095 obj->dmaChannel = -1;
mbed_official 548:1abac31e188e 1096 obj->dmaUsageState = DMA_USAGE_NEVER;
mbed_official 548:1abac31e188e 1097 }
mbed_official 525:c320967f86b9 1098 }
mbed_official 525:c320967f86b9 1099
mbed_official 548:1abac31e188e 1100 static void serial_dmaActivate(serial_t *obj, void* cb, void* buffer, int length, bool tx_nrx)
mbed_official 548:1abac31e188e 1101 {
mbed_official 548:1abac31e188e 1102 DMA_CfgDescr_TypeDef channelConfig;
mbed_official 525:c320967f86b9 1103
mbed_official 548:1abac31e188e 1104 if(tx_nrx) {
mbed_official 548:1abac31e188e 1105 // Set DMA callback
mbed_official 548:1abac31e188e 1106 obj->serial.dmaOptionsTX.dmaCallback.cbFunc = serial_dmaTransferComplete;
mbed_official 548:1abac31e188e 1107 obj->serial.dmaOptionsTX.dmaCallback.userPtr = cb;
mbed_official 525:c320967f86b9 1108
mbed_official 548:1abac31e188e 1109 // Set up configuration structure
mbed_official 548:1abac31e188e 1110 channelConfig.dstInc = dmaDataIncNone;
mbed_official 548:1abac31e188e 1111 channelConfig.srcInc = dmaDataInc1;
mbed_official 548:1abac31e188e 1112 channelConfig.size = dmaDataSize1;
mbed_official 548:1abac31e188e 1113 channelConfig.arbRate = dmaArbitrate1;
mbed_official 548:1abac31e188e 1114 channelConfig.hprot = 0;
mbed_official 525:c320967f86b9 1115
mbed_official 548:1abac31e188e 1116 DMA_CfgDescr(obj->serial.dmaOptionsTX.dmaChannel, true, &channelConfig);
mbed_official 525:c320967f86b9 1117 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 1118 // Activate TX
mbed_official 525:c320967f86b9 1119 obj->serial.periph.leuart->CMD = LEUART_CMD_TXEN;
mbed_official 627:4fa1328d9c60 1120 while(obj->serial.periph.leuart->SYNCBUSY & LEUART_SYNCBUSY_CMD);
mbed_official 548:1abac31e188e 1121
mbed_official 525:c320967f86b9 1122 // Kick off TX DMA
mbed_official 525:c320967f86b9 1123 DMA_ActivateBasic(obj->serial.dmaOptionsTX.dmaChannel, true, false, (void*) &(obj->serial.periph.leuart->TXDATA), buffer, length - 1);
mbed_official 525:c320967f86b9 1124 } else {
mbed_official 627:4fa1328d9c60 1125 // Activate TX amd clear TX buffer
mbed_official 627:4fa1328d9c60 1126 obj->serial.periph.uart->CMD = USART_CMD_TXEN | USART_CMD_CLEARTX;
mbed_official 548:1abac31e188e 1127
mbed_official 525:c320967f86b9 1128 // Kick off TX DMA
mbed_official 525:c320967f86b9 1129 DMA_ActivateBasic(obj->serial.dmaOptionsTX.dmaChannel, true, false, (void*) &(obj->serial.periph.uart->TXDATA), buffer, length - 1);
mbed_official 525:c320967f86b9 1130 }
mbed_official 548:1abac31e188e 1131 } else {
mbed_official 548:1abac31e188e 1132 // Set DMA callback
mbed_official 548:1abac31e188e 1133 obj->serial.dmaOptionsRX.dmaCallback.cbFunc = serial_dmaTransferComplete;
mbed_official 548:1abac31e188e 1134 obj->serial.dmaOptionsRX.dmaCallback.userPtr = cb;
mbed_official 525:c320967f86b9 1135
mbed_official 548:1abac31e188e 1136 // Set up configuration structure
mbed_official 548:1abac31e188e 1137 channelConfig.dstInc = dmaDataInc1;
mbed_official 548:1abac31e188e 1138 channelConfig.srcInc = dmaDataIncNone;
mbed_official 548:1abac31e188e 1139 channelConfig.size = dmaDataSize1;
mbed_official 548:1abac31e188e 1140 channelConfig.arbRate = dmaArbitrate1;
mbed_official 548:1abac31e188e 1141 channelConfig.hprot = 0;
mbed_official 525:c320967f86b9 1142
mbed_official 548:1abac31e188e 1143 DMA_CfgDescr(obj->serial.dmaOptionsRX.dmaChannel, true, &channelConfig);
mbed_official 548:1abac31e188e 1144
mbed_official 525:c320967f86b9 1145 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1146 // Activate RX and clear RX buffer
mbed_official 627:4fa1328d9c60 1147 obj->serial.periph.leuart->CMD = LEUART_CMD_RXEN | LEUART_CMD_CLEARRX;
mbed_official 627:4fa1328d9c60 1148 while(obj->serial.periph.leuart->SYNCBUSY & LEUART_SYNCBUSY_CMD);
mbed_official 525:c320967f86b9 1149
mbed_official 525:c320967f86b9 1150 // Kick off RX DMA
mbed_official 525:c320967f86b9 1151 DMA_ActivateBasic(obj->serial.dmaOptionsRX.dmaChannel, true, false, buffer, (void*) &(obj->serial.periph.leuart->RXDATA), length - 1);
mbed_official 525:c320967f86b9 1152 } else {
mbed_official 627:4fa1328d9c60 1153 // Activate RX and clear RX buffer
mbed_official 627:4fa1328d9c60 1154 obj->serial.periph.uart->CMD = USART_CMD_RXEN | USART_CMD_CLEARRX;
mbed_official 525:c320967f86b9 1155
mbed_official 525:c320967f86b9 1156 // Kick off RX DMA
mbed_official 525:c320967f86b9 1157 DMA_ActivateBasic(obj->serial.dmaOptionsRX.dmaChannel, true, false, buffer, (void*) &(obj->serial.periph.uart->RXDATA), length - 1);
mbed_official 525:c320967f86b9 1158 }
mbed_official 548:1abac31e188e 1159 }
mbed_official 525:c320967f86b9 1160 }
mbed_official 525:c320967f86b9 1161
mbed_official 525:c320967f86b9 1162 /************************************************************************************
mbed_official 627:4fa1328d9c60 1163 * ASYNCHRONOUS HAL *
mbed_official 525:c320967f86b9 1164 ************************************************************************************/
mbed_official 525:c320967f86b9 1165
mbed_official 525:c320967f86b9 1166 #if DEVICE_SERIAL_ASYNCH
mbed_official 525:c320967f86b9 1167
mbed_official 525:c320967f86b9 1168 /************************************
mbed_official 627:4fa1328d9c60 1169 * HELPER FUNCTIONS *
mbed_official 525:c320967f86b9 1170 ***********************************/
mbed_official 525:c320967f86b9 1171
mbed_official 525:c320967f86b9 1172 /** Configure TX events
mbed_official 525:c320967f86b9 1173 *
mbed_official 525:c320967f86b9 1174 * @param obj The serial object
mbed_official 525:c320967f86b9 1175 * @param event The logical OR of the TX events to configure
mbed_official 525:c320967f86b9 1176 * @param enable Set to non-zero to enable events, or zero to disable them
mbed_official 525:c320967f86b9 1177 */
mbed_official 548:1abac31e188e 1178 void serial_tx_enable_event(serial_t *obj, int event, uint8_t enable)
mbed_official 548:1abac31e188e 1179 {
mbed_official 548:1abac31e188e 1180 // Shouldn't have to enable TX interrupt here, just need to keep track of the requested events.
mbed_official 548:1abac31e188e 1181 if(enable) obj->serial.events |= event;
mbed_official 548:1abac31e188e 1182 else obj->serial.events &= ~event;
mbed_official 525:c320967f86b9 1183 }
mbed_official 525:c320967f86b9 1184
mbed_official 525:c320967f86b9 1185 /**
mbed_official 525:c320967f86b9 1186 * @param obj The serial object.
mbed_official 525:c320967f86b9 1187 * @param event The logical OR of the RX events to configure
mbed_official 525:c320967f86b9 1188 * @param enable Set to non-zero to enable events, or zero to disable them
mbed_official 525:c320967f86b9 1189 */
mbed_official 548:1abac31e188e 1190 void serial_rx_enable_event(serial_t *obj, int event, uint8_t enable)
mbed_official 548:1abac31e188e 1191 {
mbed_official 548:1abac31e188e 1192 if(enable) {
mbed_official 548:1abac31e188e 1193 obj->serial.events |= event;
mbed_official 548:1abac31e188e 1194 } else {
mbed_official 548:1abac31e188e 1195 obj->serial.events &= ~event;
mbed_official 548:1abac31e188e 1196 }
mbed_official 525:c320967f86b9 1197 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 1198 if(event & SERIAL_EVENT_RX_FRAMING_ERROR) {
mbed_official 525:c320967f86b9 1199 //FERR interrupt source
mbed_official 525:c320967f86b9 1200 if(enable) obj->serial.periph.leuart->IEN |= LEUART_IEN_FERR;
mbed_official 525:c320967f86b9 1201 else obj->serial.periph.leuart->IEN &= ~LEUART_IEN_FERR;
mbed_official 525:c320967f86b9 1202 }
mbed_official 525:c320967f86b9 1203 if(event & SERIAL_EVENT_RX_PARITY_ERROR) {
mbed_official 525:c320967f86b9 1204 //PERR interrupt source
mbed_official 525:c320967f86b9 1205 if(enable) obj->serial.periph.leuart->IEN |= LEUART_IEN_PERR;
mbed_official 525:c320967f86b9 1206 else obj->serial.periph.leuart->IEN &= ~LEUART_IEN_PERR;
mbed_official 525:c320967f86b9 1207 }
mbed_official 525:c320967f86b9 1208 if(event & SERIAL_EVENT_RX_OVERFLOW) {
mbed_official 525:c320967f86b9 1209 //RXOF interrupt source
mbed_official 525:c320967f86b9 1210 if(enable) obj->serial.periph.leuart->IEN |= LEUART_IEN_RXOF;
mbed_official 525:c320967f86b9 1211 else obj->serial.periph.leuart->IEN &= ~LEUART_IEN_RXOF;
mbed_official 525:c320967f86b9 1212 }
mbed_official 525:c320967f86b9 1213 } else {
mbed_official 525:c320967f86b9 1214 if(event & SERIAL_EVENT_RX_FRAMING_ERROR) {
mbed_official 525:c320967f86b9 1215 //FERR interrupt source
mbed_official 525:c320967f86b9 1216 if(enable) obj->serial.periph.uart->IEN |= USART_IEN_FERR;
mbed_official 525:c320967f86b9 1217 else obj->serial.periph.uart->IEN &= ~USART_IEN_FERR;
mbed_official 525:c320967f86b9 1218 }
mbed_official 525:c320967f86b9 1219 if(event & SERIAL_EVENT_RX_PARITY_ERROR) {
mbed_official 525:c320967f86b9 1220 //PERR interrupt source
mbed_official 525:c320967f86b9 1221 if(enable) obj->serial.periph.uart->IEN |= USART_IEN_PERR;
mbed_official 525:c320967f86b9 1222 else obj->serial.periph.uart->IEN &= ~USART_IEN_PERR;
mbed_official 525:c320967f86b9 1223 }
mbed_official 525:c320967f86b9 1224 if(event & SERIAL_EVENT_RX_OVERFLOW) {
mbed_official 525:c320967f86b9 1225 //RXOF interrupt source
mbed_official 525:c320967f86b9 1226 if(enable) obj->serial.periph.uart->IEN |= USART_IEN_RXOF;
mbed_official 525:c320967f86b9 1227 else obj->serial.periph.uart->IEN &= ~USART_IEN_RXOF;
mbed_official 525:c320967f86b9 1228 }
mbed_official 525:c320967f86b9 1229 }
mbed_official 525:c320967f86b9 1230 }
mbed_official 525:c320967f86b9 1231
mbed_official 525:c320967f86b9 1232 /** Configure the TX buffer for an asynchronous write serial transaction
mbed_official 525:c320967f86b9 1233 *
mbed_official 525:c320967f86b9 1234 * @param obj The serial object.
mbed_official 525:c320967f86b9 1235 * @param tx The buffer for sending.
mbed_official 525:c320967f86b9 1236 * @param tx_length The number of words to transmit.
mbed_official 525:c320967f86b9 1237 */
mbed_official 548:1abac31e188e 1238 void serial_tx_buffer_set(serial_t *obj, void *tx, int tx_length, uint8_t width)
mbed_official 548:1abac31e188e 1239 {
mbed_official 548:1abac31e188e 1240 // We only support byte buffers for now
mbed_official 548:1abac31e188e 1241 MBED_ASSERT(width == 8);
mbed_official 525:c320967f86b9 1242
mbed_official 548:1abac31e188e 1243 if(serial_tx_active(obj)) return;
mbed_official 525:c320967f86b9 1244
mbed_official 548:1abac31e188e 1245 obj->tx_buff.buffer = tx;
mbed_official 548:1abac31e188e 1246 obj->tx_buff.length = tx_length;
mbed_official 548:1abac31e188e 1247 obj->tx_buff.pos = 0;
mbed_official 548:1abac31e188e 1248
mbed_official 548:1abac31e188e 1249 return;
mbed_official 525:c320967f86b9 1250 }
mbed_official 525:c320967f86b9 1251
mbed_official 525:c320967f86b9 1252 /** Configure the TX buffer for an asynchronous read serial transaction
mbed_official 525:c320967f86b9 1253 *
mbed_official 525:c320967f86b9 1254 * @param obj The serial object.
mbed_official 525:c320967f86b9 1255 * @param rx The buffer for receiving.
mbed_official 525:c320967f86b9 1256 * @param rx_length The number of words to read.
mbed_official 525:c320967f86b9 1257 */
mbed_official 548:1abac31e188e 1258 void serial_rx_buffer_set(serial_t *obj, void *rx, int rx_length, uint8_t width)
mbed_official 548:1abac31e188e 1259 {
mbed_official 548:1abac31e188e 1260 // We only support byte buffers for now
mbed_official 548:1abac31e188e 1261 MBED_ASSERT(width == 8);
mbed_official 525:c320967f86b9 1262
mbed_official 548:1abac31e188e 1263 if(serial_rx_active(obj)) return;
mbed_official 525:c320967f86b9 1264
mbed_official 548:1abac31e188e 1265 obj->rx_buff.buffer = rx;
mbed_official 548:1abac31e188e 1266 obj->rx_buff.length = rx_length;
mbed_official 548:1abac31e188e 1267 obj->rx_buff.pos = 0;
mbed_official 548:1abac31e188e 1268
mbed_official 548:1abac31e188e 1269 return;
mbed_official 525:c320967f86b9 1270 }
mbed_official 525:c320967f86b9 1271
mbed_official 525:c320967f86b9 1272 /************************************
mbed_official 627:4fa1328d9c60 1273 * TRANSFER FUNCTIONS *
mbed_official 525:c320967f86b9 1274 ***********************************/
mbed_official 525:c320967f86b9 1275
mbed_official 525:c320967f86b9 1276 /** Begin asynchronous TX transfer. The used buffer is specified in the serial object,
mbed_official 525:c320967f86b9 1277 * tx_buff
mbed_official 525:c320967f86b9 1278 *
mbed_official 525:c320967f86b9 1279 * @param obj The serial object
mbed_official 525:c320967f86b9 1280 * @param cb The function to call when an event occurs
mbed_official 525:c320967f86b9 1281 * @param hint A suggestion for how to use DMA with this transfer
mbed_official 525:c320967f86b9 1282 * @return Returns number of data transfered, or 0 otherwise
mbed_official 525:c320967f86b9 1283 */
mbed_official 563:536c9fb088a0 1284 int serial_tx_asynch(serial_t *obj, const void *tx, size_t tx_length, uint8_t tx_width, uint32_t handler, uint32_t event, DMAUsage hint)
mbed_official 548:1abac31e188e 1285 {
mbed_official 548:1abac31e188e 1286 // Check that a buffer has indeed been set up
mbed_official 548:1abac31e188e 1287 MBED_ASSERT(tx != (void*)0);
mbed_official 548:1abac31e188e 1288 if(tx_length == 0) return 0;
mbed_official 525:c320967f86b9 1289
mbed_official 548:1abac31e188e 1290 // Set up buffer
mbed_official 563:536c9fb088a0 1291 serial_tx_buffer_set(obj, (void *)tx, tx_length, tx_width);
mbed_official 525:c320967f86b9 1292
mbed_official 548:1abac31e188e 1293 // Set up events
mbed_official 548:1abac31e188e 1294 serial_tx_enable_event(obj, SERIAL_EVENT_TX_ALL, false);
mbed_official 548:1abac31e188e 1295 serial_tx_enable_event(obj, event, true);
mbed_official 525:c320967f86b9 1296
mbed_official 548:1abac31e188e 1297 // Set up sleepmode
mbed_official 627:4fa1328d9c60 1298 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 1299 if(LEUART_REF_VALID(obj->serial.periph.leuart) && (LEUART_BaudrateGet(obj->serial.periph.leuart) <= (LEUART_LF_REF_FREQ/2))){
mbed_official 627:4fa1328d9c60 1300 blockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE_LEUART);
mbed_official 627:4fa1328d9c60 1301 }else{
mbed_official 627:4fa1328d9c60 1302 blockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1303 }
mbed_official 627:4fa1328d9c60 1304 #else
mbed_official 548:1abac31e188e 1305 blockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1306 #endif
mbed_official 525:c320967f86b9 1307
mbed_official 548:1abac31e188e 1308 // Determine DMA strategy
mbed_official 548:1abac31e188e 1309 serial_dmaTrySetState(&(obj->serial.dmaOptionsTX), hint, obj, true);
mbed_official 525:c320967f86b9 1310
mbed_official 548:1abac31e188e 1311 // If DMA, kick off DMA transfer
mbed_official 548:1abac31e188e 1312 if(obj->serial.dmaOptionsTX.dmaChannel >= 0) {
mbed_official 548:1abac31e188e 1313 serial_dmaActivate(obj, (void*)handler, obj->tx_buff.buffer, obj->tx_buff.length, true);
mbed_official 548:1abac31e188e 1314 }
mbed_official 548:1abac31e188e 1315 // Else, activate interrupt. TXBL will take care of buffer filling through ISR.
mbed_official 548:1abac31e188e 1316 else {
mbed_official 548:1abac31e188e 1317 // Store callback
mbed_official 548:1abac31e188e 1318 NVIC_ClearPendingIRQ(serial_get_tx_irq_index(obj));
mbed_official 548:1abac31e188e 1319 NVIC_DisableIRQ(serial_get_tx_irq_index(obj));
mbed_official 548:1abac31e188e 1320 NVIC_SetPriority(serial_get_tx_irq_index(obj), 1);
mbed_official 548:1abac31e188e 1321 NVIC_SetVector(serial_get_tx_irq_index(obj), (uint32_t)handler);
mbed_official 548:1abac31e188e 1322 NVIC_EnableIRQ(serial_get_tx_irq_index(obj));
mbed_official 525:c320967f86b9 1323
mbed_official 525:c320967f86b9 1324 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1325 // Activate TX and clear TX buffer
mbed_official 627:4fa1328d9c60 1326 obj->serial.periph.leuart->CMD = LEUART_CMD_TXEN | LEUART_CMD_CLEARTX;
mbed_official 627:4fa1328d9c60 1327 while(obj->serial.periph.leuart->SYNCBUSY & LEUART_SYNCBUSY_CMD);
mbed_official 525:c320967f86b9 1328
mbed_official 525:c320967f86b9 1329 // Enable interrupt
mbed_official 525:c320967f86b9 1330 LEUART_IntEnable(obj->serial.periph.leuart, LEUART_IEN_TXBL);
mbed_official 525:c320967f86b9 1331 } else {
mbed_official 627:4fa1328d9c60 1332 // Activate TX and clear TX buffer
mbed_official 627:4fa1328d9c60 1333 obj->serial.periph.uart->CMD = USART_CMD_TXEN | USART_CMD_CLEARTX;
mbed_official 525:c320967f86b9 1334
mbed_official 525:c320967f86b9 1335 // Enable interrupt
mbed_official 525:c320967f86b9 1336 USART_IntEnable(obj->serial.periph.uart, USART_IEN_TXBL);
mbed_official 525:c320967f86b9 1337 }
mbed_official 548:1abac31e188e 1338 }
mbed_official 525:c320967f86b9 1339
mbed_official 548:1abac31e188e 1340 return 0;
mbed_official 525:c320967f86b9 1341 }
mbed_official 525:c320967f86b9 1342
mbed_official 525:c320967f86b9 1343 /** Begin asynchronous RX transfer (enable interrupt for data collecting)
mbed_official 525:c320967f86b9 1344 * The used buffer is specified in the serial object - rx_buff
mbed_official 525:c320967f86b9 1345 *
mbed_official 525:c320967f86b9 1346 * @param obj The serial object
mbed_official 525:c320967f86b9 1347 * @param cb The function to call when an event occurs
mbed_official 525:c320967f86b9 1348 * @param hint A suggestion for how to use DMA with this transfer
mbed_official 525:c320967f86b9 1349 */
mbed_official 548:1abac31e188e 1350 void serial_rx_asynch(serial_t *obj, void *rx, size_t rx_length, uint8_t rx_width, uint32_t handler, uint32_t event, uint8_t char_match, DMAUsage hint)
mbed_official 548:1abac31e188e 1351 {
mbed_official 548:1abac31e188e 1352 // Check that a buffer has indeed been set up
mbed_official 548:1abac31e188e 1353 MBED_ASSERT(rx != (void*)0);
mbed_official 548:1abac31e188e 1354 if(rx_length == 0) return;
mbed_official 525:c320967f86b9 1355
mbed_official 548:1abac31e188e 1356 // Set up buffer
mbed_official 627:4fa1328d9c60 1357 serial_rx_buffer_set(obj,(void*) rx, rx_length, rx_width);
mbed_official 627:4fa1328d9c60 1358
mbed_official 627:4fa1328d9c60 1359 //disable character match if no character is specified
mbed_official 627:4fa1328d9c60 1360 if(char_match == SERIAL_RESERVED_CHAR_MATCH){
mbed_official 627:4fa1328d9c60 1361 event &= ~SERIAL_EVENT_RX_CHARACTER_MATCH;
mbed_official 627:4fa1328d9c60 1362 }
mbed_official 627:4fa1328d9c60 1363
mbed_official 627:4fa1328d9c60 1364 /*clear all set interrupts*/
mbed_official 627:4fa1328d9c60 1365 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1366 LEUART_IntClear(obj->serial.periph.leuart, LEUART_IFC_PERR | LEUART_IFC_FERR | LEUART_IFC_RXOF);
mbed_official 627:4fa1328d9c60 1367 }else{
mbed_official 627:4fa1328d9c60 1368 USART_IntClear(obj->serial.periph.uart, USART_IFC_PERR | USART_IFC_FERR | USART_IFC_RXOF);
mbed_official 627:4fa1328d9c60 1369 }
mbed_official 525:c320967f86b9 1370
mbed_official 548:1abac31e188e 1371 // Set up events
mbed_official 548:1abac31e188e 1372 serial_rx_enable_event(obj, SERIAL_EVENT_RX_ALL, false);
mbed_official 548:1abac31e188e 1373 serial_rx_enable_event(obj, event, true);
mbed_official 627:4fa1328d9c60 1374 obj->char_match = char_match;
mbed_official 548:1abac31e188e 1375
mbed_official 548:1abac31e188e 1376 // Set up sleepmode
mbed_official 627:4fa1328d9c60 1377 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 1378 if(LEUART_REF_VALID(obj->serial.periph.leuart) && (LEUART_BaudrateGet(obj->serial.periph.leuart) <= (LEUART_LF_REF_FREQ/2))){
mbed_official 627:4fa1328d9c60 1379 blockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE_LEUART);
mbed_official 627:4fa1328d9c60 1380 }else{
mbed_official 627:4fa1328d9c60 1381 blockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1382 }
mbed_official 627:4fa1328d9c60 1383 #else
mbed_official 548:1abac31e188e 1384 blockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1385 #endif
mbed_official 525:c320967f86b9 1386
mbed_official 548:1abac31e188e 1387 // Determine DMA strategy
mbed_official 548:1abac31e188e 1388 // If character match is enabled, we can't use DMA, sadly. We could when using LEUART though, but that support is not in here yet.
mbed_official 627:4fa1328d9c60 1389 // TODO: add DMA support for character matching with leuart
mbed_official 548:1abac31e188e 1390 if(!(event & SERIAL_EVENT_RX_CHARACTER_MATCH)) {
mbed_official 548:1abac31e188e 1391 serial_dmaTrySetState(&(obj->serial.dmaOptionsRX), hint, obj, false);
mbed_official 627:4fa1328d9c60 1392 }else{
mbed_official 627:4fa1328d9c60 1393 serial_dmaTrySetState(&(obj->serial.dmaOptionsRX), DMA_USAGE_NEVER, obj, false);
mbed_official 548:1abac31e188e 1394 }
mbed_official 525:c320967f86b9 1395
mbed_official 548:1abac31e188e 1396 // If DMA, kick off DMA
mbed_official 548:1abac31e188e 1397 if(obj->serial.dmaOptionsRX.dmaChannel >= 0) {
mbed_official 548:1abac31e188e 1398 serial_dmaActivate(obj, (void*)handler, obj->rx_buff.buffer, obj->rx_buff.length, false);
mbed_official 548:1abac31e188e 1399 }
mbed_official 548:1abac31e188e 1400 // Else, activate interrupt. RXDATAV is responsible for incoming data notification.
mbed_official 548:1abac31e188e 1401 else {
mbed_official 548:1abac31e188e 1402 // Store callback
mbed_official 548:1abac31e188e 1403 NVIC_ClearPendingIRQ(serial_get_rx_irq_index(obj));
mbed_official 548:1abac31e188e 1404 NVIC_SetVector(serial_get_rx_irq_index(obj), (uint32_t)handler);
mbed_official 548:1abac31e188e 1405 NVIC_EnableIRQ(serial_get_rx_irq_index(obj));
mbed_official 525:c320967f86b9 1406
mbed_official 525:c320967f86b9 1407 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1408 // Activate RX and clear RX buffer
mbed_official 627:4fa1328d9c60 1409 obj->serial.periph.leuart->CMD = LEUART_CMD_RXEN | LEUART_CMD_CLEARRX;
mbed_official 627:4fa1328d9c60 1410 while(obj->serial.periph.leuart->SYNCBUSY & LEUART_SYNCBUSY_CMD);
mbed_official 525:c320967f86b9 1411
mbed_official 525:c320967f86b9 1412 // Enable interrupt
mbed_official 525:c320967f86b9 1413 LEUART_IntEnable(obj->serial.periph.leuart, LEUART_IEN_RXDATAV);
mbed_official 525:c320967f86b9 1414 } else {
mbed_official 627:4fa1328d9c60 1415 // Activate RX and clear RX buffer
mbed_official 627:4fa1328d9c60 1416 obj->serial.periph.uart->CMD = USART_CMD_RXEN | USART_CMD_CLEARRX;
mbed_official 525:c320967f86b9 1417
mbed_official 525:c320967f86b9 1418 // Clear RXFULL
mbed_official 525:c320967f86b9 1419 USART_IntClear(obj->serial.periph.uart, USART_IFC_RXFULL);
mbed_official 525:c320967f86b9 1420
mbed_official 525:c320967f86b9 1421 // Enable interrupt
mbed_official 525:c320967f86b9 1422 USART_IntEnable(obj->serial.periph.uart, USART_IEN_RXDATAV);
mbed_official 525:c320967f86b9 1423 }
mbed_official 548:1abac31e188e 1424 }
mbed_official 525:c320967f86b9 1425
mbed_official 548:1abac31e188e 1426 return;
mbed_official 525:c320967f86b9 1427 }
mbed_official 525:c320967f86b9 1428
mbed_official 525:c320967f86b9 1429 /** Attempts to determine if the serial peripheral is already in use for TX
mbed_official 525:c320967f86b9 1430 *
mbed_official 525:c320967f86b9 1431 * @param obj The serial object
mbed_official 525:c320967f86b9 1432 * @return Non-zero if the TX transaction is ongoing, 0 otherwise
mbed_official 525:c320967f86b9 1433 */
mbed_official 548:1abac31e188e 1434 uint8_t serial_tx_active(serial_t *obj)
mbed_official 548:1abac31e188e 1435 {
mbed_official 548:1abac31e188e 1436 switch(obj->serial.dmaOptionsTX.dmaUsageState) {
mbed_official 548:1abac31e188e 1437 case DMA_USAGE_TEMPORARY_ALLOCATED:
mbed_official 548:1abac31e188e 1438 /* Temporary allocation always means its active, as this state gets cleared afterwards */
mbed_official 548:1abac31e188e 1439 return 1;
mbed_official 548:1abac31e188e 1440 case DMA_USAGE_ALLOCATED:
mbed_official 548:1abac31e188e 1441 /* Check whether the allocated DMA channel is active by checking the DMA transfer */
mbed_official 548:1abac31e188e 1442 return(DMA_ChannelEnabled(obj->serial.dmaOptionsTX.dmaChannel));
mbed_official 548:1abac31e188e 1443 default:
mbed_official 548:1abac31e188e 1444 /* Check whether interrupt for serial TX is enabled */
mbed_official 525:c320967f86b9 1445 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 1446 return (obj->serial.periph.leuart->IEN & (LEUART_IEN_TXBL)) ? true : false;
mbed_official 525:c320967f86b9 1447 } else {
mbed_official 525:c320967f86b9 1448 return (obj->serial.periph.uart->IEN & (USART_IEN_TXBL)) ? true : false;
mbed_official 525:c320967f86b9 1449 }
mbed_official 548:1abac31e188e 1450 }
mbed_official 525:c320967f86b9 1451 }
mbed_official 525:c320967f86b9 1452
mbed_official 525:c320967f86b9 1453 /** Attempts to determine if the serial peripheral is already in use for RX
mbed_official 525:c320967f86b9 1454 *
mbed_official 525:c320967f86b9 1455 * @param obj The serial object
mbed_official 525:c320967f86b9 1456 * @return Non-zero if the RX transaction is ongoing, 0 otherwise
mbed_official 525:c320967f86b9 1457 */
mbed_official 548:1abac31e188e 1458 uint8_t serial_rx_active(serial_t *obj)
mbed_official 548:1abac31e188e 1459 {
mbed_official 548:1abac31e188e 1460 switch(obj->serial.dmaOptionsRX.dmaUsageState) {
mbed_official 548:1abac31e188e 1461 case DMA_USAGE_TEMPORARY_ALLOCATED:
mbed_official 548:1abac31e188e 1462 /* Temporary allocation always means its active, as this state gets cleared afterwards */
mbed_official 548:1abac31e188e 1463 return 1;
mbed_official 548:1abac31e188e 1464 case DMA_USAGE_ALLOCATED:
mbed_official 548:1abac31e188e 1465 /* Check whether the allocated DMA channel is active by checking the DMA transfer */
mbed_official 548:1abac31e188e 1466 return(DMA_ChannelEnabled(obj->serial.dmaOptionsRX.dmaChannel));
mbed_official 548:1abac31e188e 1467 default:
mbed_official 548:1abac31e188e 1468 /* Check whether interrupt for serial TX is enabled */
mbed_official 525:c320967f86b9 1469 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 1470 return (obj->serial.periph.leuart->IEN & (LEUART_IEN_RXDATAV)) ? true : false;
mbed_official 525:c320967f86b9 1471 } else {
mbed_official 525:c320967f86b9 1472 return (obj->serial.periph.uart->IEN & (USART_IEN_RXDATAV)) ? true : false;
mbed_official 525:c320967f86b9 1473 }
mbed_official 548:1abac31e188e 1474 }
mbed_official 525:c320967f86b9 1475 }
mbed_official 525:c320967f86b9 1476
mbed_official 525:c320967f86b9 1477 /** The asynchronous TX handler. Writes to the TX FIFO and checks for events.
mbed_official 525:c320967f86b9 1478 * If any TX event has occured, the TX abort function is called.
mbed_official 525:c320967f86b9 1479 *
mbed_official 525:c320967f86b9 1480 * @param obj The serial object
mbed_official 525:c320967f86b9 1481 * @return Returns event flags if a TX transfer termination condition was met or 0 otherwise
mbed_official 525:c320967f86b9 1482 */
mbed_official 548:1abac31e188e 1483 int serial_tx_irq_handler_asynch(serial_t *obj)
mbed_official 548:1abac31e188e 1484 {
mbed_official 548:1abac31e188e 1485 /* This interrupt handler is called from USART irq */
mbed_official 548:1abac31e188e 1486 uint8_t *buf = obj->tx_buff.buffer;
mbed_official 525:c320967f86b9 1487
mbed_official 627:4fa1328d9c60 1488 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1489 if(obj->serial.periph.leuart->IEN & LEUART_IEN_TXBL){
mbed_official 627:4fa1328d9c60 1490 /* There is still data to send */
mbed_official 525:c320967f86b9 1491 while((LEUART_StatusGet(obj->serial.periph.leuart) & LEUART_STATUS_TXBL) && (obj->tx_buff.pos <= (obj->tx_buff.length - 1))) {
mbed_official 627:4fa1328d9c60 1492 while (obj->serial.periph.leuart->SYNCBUSY);
mbed_official 525:c320967f86b9 1493 LEUART_Tx(obj->serial.periph.leuart, buf[obj->tx_buff.pos]);
mbed_official 525:c320967f86b9 1494 obj->tx_buff.pos++;
mbed_official 525:c320967f86b9 1495 }
mbed_official 627:4fa1328d9c60 1496 if(obj->tx_buff.pos >= obj->tx_buff.length){
mbed_official 627:4fa1328d9c60 1497 /* Last byte has been put in TX, set up TXC interrupt */
mbed_official 627:4fa1328d9c60 1498 LEUART_IntDisable(obj->serial.periph.leuart, LEUART_IEN_TXBL);
mbed_official 627:4fa1328d9c60 1499 LEUART_IntEnable(obj->serial.periph.leuart, LEUART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1500 }
mbed_official 627:4fa1328d9c60 1501 }else if (obj->serial.periph.leuart->IF & LEUART_IF_TXC){
mbed_official 627:4fa1328d9c60 1502 /* Last byte has been successfully transmitted. Stop the procedure */
mbed_official 627:4fa1328d9c60 1503 serial_tx_abort_asynch(obj);
mbed_official 627:4fa1328d9c60 1504 return SERIAL_EVENT_TX_COMPLETE & obj->serial.events;
mbed_official 627:4fa1328d9c60 1505 }
mbed_official 627:4fa1328d9c60 1506 } else {
mbed_official 627:4fa1328d9c60 1507 if(obj->serial.periph.uart->IEN & USART_IEN_TXBL){
mbed_official 627:4fa1328d9c60 1508 /* There is still data to send */
mbed_official 525:c320967f86b9 1509 while((USART_StatusGet(obj->serial.periph.uart) & USART_STATUS_TXBL) && (obj->tx_buff.pos <= (obj->tx_buff.length - 1))) {
mbed_official 525:c320967f86b9 1510 USART_Tx(obj->serial.periph.uart, buf[obj->tx_buff.pos]);
mbed_official 525:c320967f86b9 1511 obj->tx_buff.pos++;
mbed_official 525:c320967f86b9 1512 }
mbed_official 627:4fa1328d9c60 1513 if(obj->tx_buff.pos >= obj->tx_buff.length){
mbed_official 627:4fa1328d9c60 1514 /* Last byte has been put in TX, set up TXC interrupt */
mbed_official 627:4fa1328d9c60 1515 USART_IntDisable(obj->serial.periph.uart, USART_IEN_TXBL);
mbed_official 627:4fa1328d9c60 1516 USART_IntEnable(obj->serial.periph.uart, USART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1517 }
mbed_official 627:4fa1328d9c60 1518 } else if (obj->serial.periph.uart->IF & USART_IF_TXC) {
mbed_official 627:4fa1328d9c60 1519 /* Last byte has been successfully transmitted. Stop the procedure */
mbed_official 627:4fa1328d9c60 1520 serial_tx_abort_asynch(obj);
mbed_official 627:4fa1328d9c60 1521 return SERIAL_EVENT_TX_COMPLETE & obj->serial.events;
mbed_official 525:c320967f86b9 1522 }
mbed_official 548:1abac31e188e 1523 }
mbed_official 548:1abac31e188e 1524 return 0;
mbed_official 525:c320967f86b9 1525 }
mbed_official 525:c320967f86b9 1526
mbed_official 525:c320967f86b9 1527 /** The asynchronous RX handler. Reads from the RX FIFOF and checks for events.
mbed_official 525:c320967f86b9 1528 * If any RX event has occured, the RX abort function is called.
mbed_official 525:c320967f86b9 1529 *
mbed_official 525:c320967f86b9 1530 * @param obj The serial object
mbed_official 525:c320967f86b9 1531 * @return Returns event flags if a RX transfer termination condition was met or 0 otherwise
mbed_official 525:c320967f86b9 1532 */
mbed_official 548:1abac31e188e 1533 int serial_rx_irq_handler_asynch(serial_t *obj)
mbed_official 548:1abac31e188e 1534 {
mbed_official 548:1abac31e188e 1535 int event = 0;
mbed_official 525:c320967f86b9 1536
mbed_official 548:1abac31e188e 1537 /* This interrupt handler is called from USART irq */
mbed_official 548:1abac31e188e 1538 uint8_t *buf = (uint8_t*)obj->rx_buff.buffer;
mbed_official 525:c320967f86b9 1539
mbed_official 525:c320967f86b9 1540 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 1541 /* Determine the source of the interrupt */
mbed_official 525:c320967f86b9 1542 if(LEUART_IntGetEnabled(obj->serial.periph.leuart) & LEUART_IF_PERR) {
mbed_official 525:c320967f86b9 1543 /* Parity error has occurred, and we are notifying. */
mbed_official 525:c320967f86b9 1544 LEUART_IntClear(obj->serial.periph.leuart, LEUART_IFC_PERR);
mbed_official 525:c320967f86b9 1545 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1546 return SERIAL_EVENT_RX_PARITY_ERROR;
mbed_official 525:c320967f86b9 1547 }
mbed_official 525:c320967f86b9 1548
mbed_official 525:c320967f86b9 1549 if(LEUART_IntGetEnabled(obj->serial.periph.leuart) & LEUART_IF_FERR) {
mbed_official 525:c320967f86b9 1550 /* Framing error has occurred, and we are notifying */
mbed_official 525:c320967f86b9 1551 LEUART_IntClear(obj->serial.periph.leuart, LEUART_IFC_FERR);
mbed_official 525:c320967f86b9 1552 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1553 return SERIAL_EVENT_RX_FRAMING_ERROR;
mbed_official 525:c320967f86b9 1554 }
mbed_official 525:c320967f86b9 1555
mbed_official 525:c320967f86b9 1556 if(LEUART_IntGetEnabled(obj->serial.periph.leuart) & LEUART_IF_RXOF) {
mbed_official 525:c320967f86b9 1557 /* RX buffer overflow has occurred, and we are notifying */
mbed_official 525:c320967f86b9 1558 LEUART_IntClear(obj->serial.periph.leuart, LEUART_IFC_RXOF);
mbed_official 525:c320967f86b9 1559 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1560 return SERIAL_EVENT_RX_OVERFLOW;
mbed_official 525:c320967f86b9 1561 }
mbed_official 548:1abac31e188e 1562
mbed_official 525:c320967f86b9 1563 if((LEUART_IntGetEnabled(obj->serial.periph.leuart) & LEUART_IF_RXDATAV) || (LEUART_StatusGet(obj->serial.periph.leuart) & LEUART_STATUS_RXDATAV)) {
mbed_official 525:c320967f86b9 1564 /* Valid data in buffer. Determine course of action: continue receiving or interrupt */
mbed_official 525:c320967f86b9 1565 if(obj->rx_buff.pos >= (obj->rx_buff.length - 1)) {
mbed_official 525:c320967f86b9 1566 /* Last char, transfer complete. Switch off interrupt and return event. */
mbed_official 525:c320967f86b9 1567 buf[obj->rx_buff.pos] = LEUART_RxDataGet(obj->serial.periph.leuart);
mbed_official 525:c320967f86b9 1568
mbed_official 525:c320967f86b9 1569 event |= SERIAL_EVENT_RX_COMPLETE;
mbed_official 525:c320967f86b9 1570
mbed_official 525:c320967f86b9 1571 if((buf[obj->rx_buff.pos] == obj->char_match) && (obj->serial.events & SERIAL_EVENT_RX_CHARACTER_MATCH)) event |= SERIAL_EVENT_RX_CHARACTER_MATCH;
mbed_official 525:c320967f86b9 1572
mbed_official 525:c320967f86b9 1573 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1574 return event & obj->serial.events;
mbed_official 525:c320967f86b9 1575 } else {
mbed_official 525:c320967f86b9 1576 /* There's still space in the receive buffer */
mbed_official 525:c320967f86b9 1577 while((LEUART_StatusGet(obj->serial.periph.leuart) & LEUART_STATUS_RXDATAV) && (obj->rx_buff.pos <= (obj->rx_buff.length - 1))) {
mbed_official 627:4fa1328d9c60 1578 bool aborting = false;
mbed_official 525:c320967f86b9 1579 buf[obj->rx_buff.pos] = LEUART_RxDataGet(obj->serial.periph.leuart);
mbed_official 525:c320967f86b9 1580 obj->rx_buff.pos++;
mbed_official 525:c320967f86b9 1581
mbed_official 525:c320967f86b9 1582 /* Check for character match event */
mbed_official 525:c320967f86b9 1583 if((buf[obj->rx_buff.pos - 1] == obj->char_match) && (obj->serial.events & SERIAL_EVENT_RX_CHARACTER_MATCH)) {
mbed_official 627:4fa1328d9c60 1584 aborting = true;
mbed_official 525:c320967f86b9 1585 event |= SERIAL_EVENT_RX_CHARACTER_MATCH;
mbed_official 525:c320967f86b9 1586 }
mbed_official 525:c320967f86b9 1587
mbed_official 525:c320967f86b9 1588 /* Check for final char event */
mbed_official 525:c320967f86b9 1589 if(obj->rx_buff.pos >= (obj->rx_buff.length)) {
mbed_official 627:4fa1328d9c60 1590 aborting = true;
mbed_official 525:c320967f86b9 1591 event |= SERIAL_EVENT_RX_COMPLETE & obj->serial.events;
mbed_official 525:c320967f86b9 1592 }
mbed_official 525:c320967f86b9 1593
mbed_official 627:4fa1328d9c60 1594 if(aborting) {
mbed_official 525:c320967f86b9 1595 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1596 return event & obj->serial.events;
mbed_official 525:c320967f86b9 1597 }
mbed_official 525:c320967f86b9 1598 }
mbed_official 525:c320967f86b9 1599 }
mbed_official 525:c320967f86b9 1600 }
mbed_official 525:c320967f86b9 1601 } else {
mbed_official 525:c320967f86b9 1602 /* Determine the source of the interrupt */
mbed_official 525:c320967f86b9 1603 if(USART_IntGetEnabled(obj->serial.periph.uart) & USART_IF_PERR) {
mbed_official 525:c320967f86b9 1604 /* Parity error has occurred, and we are notifying. */
mbed_official 525:c320967f86b9 1605 USART_IntClear(obj->serial.periph.uart, USART_IFC_PERR);
mbed_official 525:c320967f86b9 1606 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1607 return SERIAL_EVENT_RX_PARITY_ERROR;
mbed_official 525:c320967f86b9 1608 }
mbed_official 525:c320967f86b9 1609
mbed_official 525:c320967f86b9 1610 if(USART_IntGetEnabled(obj->serial.periph.uart) & USART_IF_FERR) {
mbed_official 525:c320967f86b9 1611 /* Framing error has occurred, and we are notifying */
mbed_official 525:c320967f86b9 1612 USART_IntClear(obj->serial.periph.uart, USART_IFC_FERR);
mbed_official 525:c320967f86b9 1613 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1614 return SERIAL_EVENT_RX_FRAMING_ERROR;
mbed_official 525:c320967f86b9 1615 }
mbed_official 525:c320967f86b9 1616
mbed_official 525:c320967f86b9 1617 if(USART_IntGetEnabled(obj->serial.periph.uart) & USART_IF_RXOF) {
mbed_official 525:c320967f86b9 1618 /* RX buffer overflow has occurred, and we are notifying */
mbed_official 525:c320967f86b9 1619 USART_IntClear(obj->serial.periph.uart, USART_IFC_RXOF);
mbed_official 525:c320967f86b9 1620 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1621 return SERIAL_EVENT_RX_OVERFLOW;
mbed_official 525:c320967f86b9 1622 }
mbed_official 525:c320967f86b9 1623
mbed_official 525:c320967f86b9 1624 if((USART_IntGetEnabled(obj->serial.periph.uart) & USART_IF_RXDATAV) || (USART_StatusGet(obj->serial.periph.uart) & USART_STATUS_RXFULL)) {
mbed_official 525:c320967f86b9 1625 /* Valid data in buffer. Determine course of action: continue receiving or interrupt */
mbed_official 525:c320967f86b9 1626 if(obj->rx_buff.pos >= (obj->rx_buff.length - 1)) {
mbed_official 525:c320967f86b9 1627 /* Last char, transfer complete. Switch off interrupt and return event. */
mbed_official 525:c320967f86b9 1628 buf[obj->rx_buff.pos] = USART_RxDataGet(obj->serial.periph.uart);
mbed_official 525:c320967f86b9 1629
mbed_official 525:c320967f86b9 1630 event |= SERIAL_EVENT_RX_COMPLETE;
mbed_official 525:c320967f86b9 1631
mbed_official 525:c320967f86b9 1632 if((buf[obj->rx_buff.pos] == obj->char_match) && (obj->serial.events & SERIAL_EVENT_RX_CHARACTER_MATCH)) event |= SERIAL_EVENT_RX_CHARACTER_MATCH;
mbed_official 525:c320967f86b9 1633
mbed_official 525:c320967f86b9 1634 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1635 return event & obj->serial.events;
mbed_official 525:c320967f86b9 1636 } else {
mbed_official 525:c320967f86b9 1637 /* There's still space in the receive buffer */
mbed_official 525:c320967f86b9 1638 while(((USART_StatusGet(obj->serial.periph.uart) & USART_STATUS_RXDATAV) || (USART_StatusGet(obj->serial.periph.uart) & USART_IF_RXFULL)) && (obj->rx_buff.pos <= (obj->rx_buff.length - 1))) {
mbed_official 627:4fa1328d9c60 1639 bool aborting = false;
mbed_official 525:c320967f86b9 1640 buf[obj->rx_buff.pos] = USART_RxDataGet(obj->serial.periph.uart);
mbed_official 525:c320967f86b9 1641 obj->rx_buff.pos++;
mbed_official 525:c320967f86b9 1642
mbed_official 525:c320967f86b9 1643 /* Check for character match event */
mbed_official 525:c320967f86b9 1644 if((buf[obj->rx_buff.pos - 1] == obj->char_match) && (obj->serial.events & SERIAL_EVENT_RX_CHARACTER_MATCH)) {
mbed_official 627:4fa1328d9c60 1645 aborting = true;
mbed_official 525:c320967f86b9 1646 event |= SERIAL_EVENT_RX_CHARACTER_MATCH;
mbed_official 525:c320967f86b9 1647 }
mbed_official 525:c320967f86b9 1648
mbed_official 525:c320967f86b9 1649 /* Check for final char event */
mbed_official 525:c320967f86b9 1650 if(obj->rx_buff.pos >= (obj->rx_buff.length)) {
mbed_official 627:4fa1328d9c60 1651 aborting = true;
mbed_official 525:c320967f86b9 1652 event |= SERIAL_EVENT_RX_COMPLETE & obj->serial.events;
mbed_official 525:c320967f86b9 1653 }
mbed_official 525:c320967f86b9 1654
mbed_official 627:4fa1328d9c60 1655 if(aborting) {
mbed_official 525:c320967f86b9 1656 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1657 return event & obj->serial.events;
mbed_official 525:c320967f86b9 1658 }
mbed_official 525:c320967f86b9 1659 }
mbed_official 525:c320967f86b9 1660 }
mbed_official 525:c320967f86b9 1661 }
mbed_official 525:c320967f86b9 1662 }
mbed_official 548:1abac31e188e 1663
mbed_official 548:1abac31e188e 1664 /* All events should have generated a return, if no return has happened, no event has been caught */
mbed_official 548:1abac31e188e 1665 return 0;
mbed_official 525:c320967f86b9 1666 }
mbed_official 525:c320967f86b9 1667
mbed_official 525:c320967f86b9 1668 /** Unified IRQ handler. Determines the appropriate handler to execute and returns the flags.
mbed_official 525:c320967f86b9 1669 *
mbed_official 525:c320967f86b9 1670 * WARNING: this code should be stateless, as re-entrancy is very possible in interrupt-based mode.
mbed_official 525:c320967f86b9 1671 */
mbed_official 548:1abac31e188e 1672 int serial_irq_handler_asynch(serial_t *obj)
mbed_official 548:1abac31e188e 1673 {
mbed_official 548:1abac31e188e 1674 /* First, check if we're running in DMA mode */
mbed_official 548:1abac31e188e 1675 if(serial_dma_irq_fired[obj->serial.dmaOptionsRX.dmaChannel]) {
mbed_official 548:1abac31e188e 1676 /* Clean up */
mbed_official 548:1abac31e188e 1677 serial_dma_irq_fired[obj->serial.dmaOptionsRX.dmaChannel] = false;
mbed_official 548:1abac31e188e 1678 serial_rx_abort_asynch(obj);
mbed_official 525:c320967f86b9 1679
mbed_official 548:1abac31e188e 1680 /* Notify CPP land of RX completion */
mbed_official 548:1abac31e188e 1681 return SERIAL_EVENT_RX_COMPLETE & obj->serial.events;
mbed_official 548:1abac31e188e 1682 } else if (serial_dma_irq_fired[obj->serial.dmaOptionsTX.dmaChannel]) {
mbed_official 627:4fa1328d9c60 1683 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1684 if(obj->serial.periph.leuart->IEN & LEUART_IEN_TXC){
mbed_official 627:4fa1328d9c60 1685 LEUART_IntDisable(obj->serial.periph.leuart,LEUART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1686 /* Clean up */
mbed_official 627:4fa1328d9c60 1687 serial_dma_irq_fired[obj->serial.dmaOptionsTX.dmaChannel] = false;
mbed_official 627:4fa1328d9c60 1688 serial_tx_abort_asynch(obj);
mbed_official 627:4fa1328d9c60 1689 /* Notify CPP land of completion */
mbed_official 627:4fa1328d9c60 1690 return SERIAL_EVENT_TX_COMPLETE & obj->serial.events;
mbed_official 627:4fa1328d9c60 1691 }else{
mbed_official 627:4fa1328d9c60 1692 LEUART_IntEnable(obj->serial.periph.leuart,LEUART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1693 }
mbed_official 627:4fa1328d9c60 1694 }else{
mbed_official 627:4fa1328d9c60 1695 if(obj->serial.periph.uart->IEN & USART_IEN_TXC){
mbed_official 627:4fa1328d9c60 1696 USART_IntDisable(obj->serial.periph.leuart,USART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1697 /* Clean up */
mbed_official 627:4fa1328d9c60 1698 serial_dma_irq_fired[obj->serial.dmaOptionsTX.dmaChannel] = false;
mbed_official 627:4fa1328d9c60 1699 serial_tx_abort_asynch(obj);
mbed_official 627:4fa1328d9c60 1700 /* Notify CPP land of completion */
mbed_official 627:4fa1328d9c60 1701 return SERIAL_EVENT_TX_COMPLETE & obj->serial.events;
mbed_official 627:4fa1328d9c60 1702 }else{
mbed_official 627:4fa1328d9c60 1703 USART_IntEnable(obj->serial.periph.leuart,USART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1704 }
mbed_official 627:4fa1328d9c60 1705 }
mbed_official 548:1abac31e188e 1706 } else {
mbed_official 548:1abac31e188e 1707 /* Check the NVIC to see which interrupt we're running from
mbed_official 548:1abac31e188e 1708 * Also make sure to prioritize RX */
mbed_official 525:c320967f86b9 1709 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 525:c320967f86b9 1710 //Different method of checking tx vs rx for LEUART
mbed_official 627:4fa1328d9c60 1711 if(LEUART_IntGetEnabled(obj->serial.periph.leuart) & (LEUART_IF_RXDATAV | LEUART_IF_FERR | LEUART_IF_PERR | LEUART_IF_RXOF)) {
mbed_official 525:c320967f86b9 1712 return serial_rx_irq_handler_asynch(obj);
mbed_official 627:4fa1328d9c60 1713 } else if(LEUART_StatusGet(obj->serial.periph.leuart) & (LEUART_STATUS_TXBL | LEUART_STATUS_TXC)) {
mbed_official 525:c320967f86b9 1714 return serial_tx_irq_handler_asynch(obj);
mbed_official 525:c320967f86b9 1715 }
mbed_official 525:c320967f86b9 1716 } else {
mbed_official 525:c320967f86b9 1717 if(USART_IntGetEnabled(obj->serial.periph.uart) & (USART_IF_RXDATAV | USART_IF_RXOF | USART_IF_PERR | USART_IF_FERR)) {
mbed_official 525:c320967f86b9 1718 return serial_rx_irq_handler_asynch(obj);
mbed_official 627:4fa1328d9c60 1719 } else if(USART_StatusGet(obj->serial.periph.uart) & (USART_STATUS_TXBL | USART_STATUS_TXC)){
mbed_official 525:c320967f86b9 1720 return serial_tx_irq_handler_asynch(obj);
mbed_official 525:c320967f86b9 1721 }
mbed_official 525:c320967f86b9 1722 }
mbed_official 548:1abac31e188e 1723 }
mbed_official 525:c320967f86b9 1724
mbed_official 548:1abac31e188e 1725 // All should be done now
mbed_official 548:1abac31e188e 1726 return 0;
mbed_official 525:c320967f86b9 1727 }
mbed_official 525:c320967f86b9 1728
mbed_official 525:c320967f86b9 1729 /** Abort the ongoing TX transaction. It disables the enabled interupt for TX and
mbed_official 525:c320967f86b9 1730 * flush TX hardware buffer if TX FIFO is used
mbed_official 525:c320967f86b9 1731 *
mbed_official 525:c320967f86b9 1732 * @param obj The serial object
mbed_official 525:c320967f86b9 1733 */
mbed_official 548:1abac31e188e 1734 void serial_tx_abort_asynch(serial_t *obj)
mbed_official 548:1abac31e188e 1735 {
mbed_official 548:1abac31e188e 1736 /* Stop transmitter */
mbed_official 548:1abac31e188e 1737 //obj->serial.periph.uart->CMD |= USART_CMD_TXDIS;
mbed_official 525:c320967f86b9 1738
mbed_official 548:1abac31e188e 1739 /* Clean up */
mbed_official 548:1abac31e188e 1740 switch(obj->serial.dmaOptionsTX.dmaUsageState) {
mbed_official 548:1abac31e188e 1741 case DMA_USAGE_ALLOCATED:
mbed_official 548:1abac31e188e 1742 /* stop DMA transfer */
mbed_official 548:1abac31e188e 1743 DMA_ChannelEnable(obj->serial.dmaOptionsTX.dmaChannel, false);
mbed_official 548:1abac31e188e 1744 break;
mbed_official 548:1abac31e188e 1745 case DMA_USAGE_TEMPORARY_ALLOCATED:
mbed_official 548:1abac31e188e 1746 /* stop DMA transfer and release channel */
mbed_official 548:1abac31e188e 1747 DMA_ChannelEnable(obj->serial.dmaOptionsTX.dmaChannel, false);
mbed_official 548:1abac31e188e 1748 dma_channel_free(obj->serial.dmaOptionsTX.dmaChannel);
mbed_official 548:1abac31e188e 1749 obj->serial.dmaOptionsTX.dmaChannel = -1;
mbed_official 548:1abac31e188e 1750 obj->serial.dmaOptionsTX.dmaUsageState = DMA_USAGE_OPPORTUNISTIC;
mbed_official 548:1abac31e188e 1751 break;
mbed_official 548:1abac31e188e 1752 default:
mbed_official 548:1abac31e188e 1753 /* stop interrupting */
mbed_official 548:1abac31e188e 1754 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1755 LEUART_IntDisable(obj->serial.periph.leuart, LEUART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1756 LEUART_IntClear(obj->serial.periph.leuart, LEUART_IFC_TXC);
mbed_official 548:1abac31e188e 1757 } else {
mbed_official 627:4fa1328d9c60 1758 USART_IntDisable(obj->serial.periph.uart, USART_IEN_TXC);
mbed_official 627:4fa1328d9c60 1759 USART_IntClear(obj->serial.periph.uart, USART_IFC_TXC);
mbed_official 548:1abac31e188e 1760 }
mbed_official 548:1abac31e188e 1761 break;
mbed_official 548:1abac31e188e 1762 }
mbed_official 525:c320967f86b9 1763
mbed_official 627:4fa1328d9c60 1764 /* Say that we can stop using this emode */
mbed_official 627:4fa1328d9c60 1765 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 1766 if(LEUART_REF_VALID(obj->serial.periph.leuart) && (LEUART_BaudrateGet(obj->serial.periph.leuart) <= (LEUART_LF_REF_FREQ/2))){
mbed_official 627:4fa1328d9c60 1767 unblockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE_LEUART);
mbed_official 627:4fa1328d9c60 1768 }else{
mbed_official 627:4fa1328d9c60 1769 unblockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1770 }
mbed_official 627:4fa1328d9c60 1771 #else
mbed_official 548:1abac31e188e 1772 unblockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1773 #endif
mbed_official 525:c320967f86b9 1774 }
mbed_official 525:c320967f86b9 1775
mbed_official 525:c320967f86b9 1776 /** Abort the ongoing RX transaction It disables the enabled interrupt for RX and
mbed_official 525:c320967f86b9 1777 * flush RX hardware buffer if RX FIFO is used
mbed_official 525:c320967f86b9 1778 *
mbed_official 525:c320967f86b9 1779 * @param obj The serial object
mbed_official 525:c320967f86b9 1780 */
mbed_official 548:1abac31e188e 1781 void serial_rx_abort_asynch(serial_t *obj)
mbed_official 548:1abac31e188e 1782 {
mbed_official 548:1abac31e188e 1783 /* Stop receiver */
mbed_official 548:1abac31e188e 1784 obj->serial.periph.uart->CMD |= USART_CMD_RXDIS;
mbed_official 525:c320967f86b9 1785
mbed_official 548:1abac31e188e 1786 /* Clean up */
mbed_official 548:1abac31e188e 1787 switch(obj->serial.dmaOptionsRX.dmaUsageState) {
mbed_official 548:1abac31e188e 1788 case DMA_USAGE_ALLOCATED:
mbed_official 548:1abac31e188e 1789 /* stop DMA transfer */
mbed_official 548:1abac31e188e 1790 DMA_ChannelEnable(obj->serial.dmaOptionsRX.dmaChannel, false);
mbed_official 548:1abac31e188e 1791 break;
mbed_official 548:1abac31e188e 1792 case DMA_USAGE_TEMPORARY_ALLOCATED:
mbed_official 548:1abac31e188e 1793 /* stop DMA transfer and release channel */
mbed_official 548:1abac31e188e 1794 DMA_ChannelEnable(obj->serial.dmaOptionsRX.dmaChannel, false);
mbed_official 548:1abac31e188e 1795 dma_channel_free(obj->serial.dmaOptionsRX.dmaChannel);
mbed_official 548:1abac31e188e 1796 obj->serial.dmaOptionsRX.dmaChannel = -1;
mbed_official 548:1abac31e188e 1797 obj->serial.dmaOptionsRX.dmaUsageState = DMA_USAGE_OPPORTUNISTIC;
mbed_official 548:1abac31e188e 1798 break;
mbed_official 548:1abac31e188e 1799 default:
mbed_official 548:1abac31e188e 1800 /* stop interrupting */
mbed_official 548:1abac31e188e 1801 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1802 LEUART_IntDisable(obj->serial.periph.leuart, LEUART_IEN_RXDATAV | LEUART_IEN_PERR | LEUART_IEN_FERR | LEUART_IEN_RXOF);
mbed_official 548:1abac31e188e 1803 } else {
mbed_official 548:1abac31e188e 1804 USART_IntDisable(obj->serial.periph.uart, USART_IEN_RXDATAV | USART_IEN_PERR | USART_IEN_FERR | USART_IEN_RXOF);
mbed_official 548:1abac31e188e 1805 }
mbed_official 548:1abac31e188e 1806 break;
mbed_official 548:1abac31e188e 1807 }
mbed_official 525:c320967f86b9 1808
mbed_official 627:4fa1328d9c60 1809 /*clear all set interrupts*/
mbed_official 627:4fa1328d9c60 1810 if(LEUART_REF_VALID(obj->serial.periph.leuart)) {
mbed_official 627:4fa1328d9c60 1811 LEUART_IntClear(obj->serial.periph.leuart, LEUART_IFC_PERR | LEUART_IFC_FERR | LEUART_IFC_RXOF);
mbed_official 627:4fa1328d9c60 1812 }else{
mbed_official 627:4fa1328d9c60 1813 USART_IntClear(obj->serial.periph.uart, USART_IFC_PERR | USART_IFC_FERR | USART_IFC_RXOF);
mbed_official 627:4fa1328d9c60 1814 }
mbed_official 627:4fa1328d9c60 1815
mbed_official 548:1abac31e188e 1816 /* Say that we can stop using this emode */
mbed_official 627:4fa1328d9c60 1817 #ifdef LEUART_USING_LFXO
mbed_official 627:4fa1328d9c60 1818 if(LEUART_REF_VALID(obj->serial.periph.leuart) && (LEUART_BaudrateGet(obj->serial.periph.leuart) <= (LEUART_LF_REF_FREQ/2))){
mbed_official 627:4fa1328d9c60 1819 unblockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE_LEUART);
mbed_official 627:4fa1328d9c60 1820 }else{
mbed_official 627:4fa1328d9c60 1821 unblockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1822 }
mbed_official 627:4fa1328d9c60 1823 #else
mbed_official 548:1abac31e188e 1824 unblockSleepMode(SERIAL_LEAST_ACTIVE_SLEEPMODE);
mbed_official 627:4fa1328d9c60 1825 #endif
mbed_official 525:c320967f86b9 1826 }
mbed_official 525:c320967f86b9 1827
mbed_official 525:c320967f86b9 1828 #endif //DEVICE_SERIAL_ASYNCH
mbed_official 525:c320967f86b9 1829 #endif //DEVICE_SERIAL