mbed-dev - added prescaler for 16 bit pwm in LPC1347 target

Users » JojoS » Code » mbed-dev

added prescaler for 16 bit pwm in LPC1347 target

targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/serial_api.c@147:ba84b7dc41a7, 2016-09-10 (annotated)

Committer:: JojoS
Date:: Sat Sep 10 15:32:04 2016 +0000
Revision:: 147:ba84b7dc41a7
Parent:: 144:ef7eb2e8f9f7

added prescaler for 16 bit timers (solution as in LPC11xx), default prescaler 31 for max 28 ms period time

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	10 Sep 2016
Imports:	1
Forks:	0
Commits:	148
Dependents:	0
Dependencies:	0
Followers:	1

targets/hal/TARGET_Silicon_Labs/TARGET_EFM32/serial_api.c@147:ba84b7dc41a7, 2016-09-10 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning