mbed-dev - mbed library sources. Supersedes mbed-src.

Users » mbed_official » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_Silicon_Labs/TARGET_EFM32/serial_api.c@150:02e0a0aed4ec, 2016-11-08 (annotated)

Committer:: <>
Date:: Tue Nov 08 17:45:16 2016 +0000
Revision:: 150:02e0a0aed4ec
Parent:: 149:156823d33999
Child:: 179:b0033dcd6934

This updates the lib to the mbed lib v129

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