/* "power up" COM by switching back to DMA interrupts */
void COM_InternalPowerUp()
{
#ifdef COM_USART0_ENABLE
USART_IntClear(USART0, USART_IF_RXDATAV);
USART_IntDisable(USART0, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ( USART0_RX_IRQn );
NVIC_DisableIRQ( USART0_RX_IRQn );
#endif
#ifdef COM_USART1_ENABLE
USART_IntClear(USART1, USART_IF_RXDATAV);
USART_IntDisable(USART1, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ( USART1_RX_IRQn );
NVIC_DisableIRQ( USART1_RX_IRQn );
#endif
#ifdef COM_USART2_ENABLE
USART_IntClear(USART2, USART_IF_RXDATAV);
USART_IntDisable(USART2, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ( USART2_RX_IRQn );
NVIC_DisableIRQ( USART2_RX_IRQn );
#endif
if (dma_IEN!=0)
{
DMA_REG->IEN = dma_IEN;
}
}
/**
* Initialize the UART.
*
*/
void
usart2_init(unsigned long baudrate)
{
USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
/* Configure controller */
// Enable clocks
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_USART2, true);
init.enable = usartDisable;
init.baudrate = baudrate;
USART_InitAsync(USART2, &init);
/* Enable pins at USART2 location */
USART2->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN |
(USART2_LOCATION << _USART_ROUTE_LOCATION_SHIFT);
/* Clear previous RX interrupts */
USART_IntClear(USART2, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ(USART2_RX_IRQn);
/* Enable RX interrupts */
USART_IntEnable(USART2, USART_IF_RXDATAV);
NVIC_EnableIRQ(USART2_RX_IRQn);
/* Finally enable it */
USART_Enable(USART2, usartEnable);
}
/***************************************************************************//**
* @brief
* SPI/USART Initialization
*
* @param[in] bit_rate
* Bit rate for SPI Bus in MHz: Either 2000000 or 12000000
*
******************************************************************************/
void spi_init(int bit_rate)
{
CMU_ClockEnable(cmuClock_GPIO, true);
CMU_ClockEnable(SPI_cmuClock, true);
gpio_init(spi_pins, sizeof(spi_pins)/sizeof(gpio_init_t));
USART_Reset(SPI_PORT);
USART_InitSync(SPI_PORT, &spiInit);
SPI_PORT->CTRL |= USART_CTRL_TXBIL_HALFFULL;
SPI_PORT->ROUTE = USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_CLKPEN | (USART_LOC << _USART_ROUTE_LOCATION_SHIFT);
if (bit_rate)
USART_BaudrateSyncSet(SPI_PORT, 0, bit_rate);
USART_IntClear(SPI_PORT, USART_IF_RXDATAV | USART_IF_TXBL);
NVIC_ClearPendingIRQ(SPI_TX_IRQn);
NVIC_EnableIRQ(SPI_TX_IRQn);
NVIC_ClearPendingIRQ(SPI_RX_IRQn);
NVIC_EnableIRQ(SPI_RX_IRQn);
so_busy = false;
so_irq_count = 0;
so_spurious_irq_count = 0;
so_irq_fake_count = 0;
// register (but don't enable) rx pin GPIO interrupt
gpio_irq_handler_install(RX_PORT, RX_PIN, SO_IRQ, NULL);
}
static int uart_gecko_irq_tx_complete(struct device *dev)
{
const struct uart_gecko_config *config = dev->config->config_info;
u32_t flags = USART_IntGet(config->base);
USART_IntClear(config->base, USART_IF_TXC);
return (flags & USART_IF_TXC) != 0;
}
/**************************************************************************//**
* @brief Intializes UART/LEUART
*****************************************************************************/
void UART1_SerialInit(void)
{
/* Configure GPIO pins */
CMU_ClockEnable(cmuClock_GPIO, true);
/* To avoid false start, configure output as high */
GPIO_PinModeSet(gpioPortB, 9, gpioModePushPull, 1);
GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0);
USART_TypeDef *usart = UART1;
USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
/* Enable EFM32GG_DK3750 RS232/UART switch */
BSP_PeripheralAccess(BSP_RS232_UART, true);
/* Enable peripheral clocks */
CMU_ClockEnable(cmuClock_HFPER, true);
CMU_ClockEnable(cmuClock_UART1, true);
/* Configure USART for basic async operation */
init.enable = usartDisable;
USART_InitAsync(usart, &init);
/* Enable pins at UART1 location #2 */
usart->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | USART_ROUTE_LOCATION_LOC2;
/* Clear previous RX interrupts */
USART_IntClear(UART1, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ(UART1_RX_IRQn);
/* Enable RX interrupts */
USART_IntEnable(UART1, USART_IF_RXDATAV);
NVIC_EnableIRQ(UART1_RX_IRQn);
/* Finally enable it */
USART_Enable(usart, usartEnable);
#if !defined(__CROSSWORKS_ARM) && defined(__GNUC__)
setvbuf(stdout, NULL, _IONBF, 0); /*Set unbuffered mode for stdout (newlib)*/
#endif
initialized = true;
}
/******************************************************************************
* @brief usartSetup function
*
******************************************************************************/
void usartSetup(void)
{
cmuSetup();
/* Configure GPIO pin as open drain */
GPIO_PinModeSet(SC_GPIO_DATA_PORT, SC_GPIO_DATA_PIN, gpioModeWiredAndPullUp, 1);
/* Prepare struct for initializing USART in asynchronous mode*/
usartInit.enable = usartDisable; /* Don't enable USART upon intialization */
usartInit.refFreq = 0; /* Provide information on reference frequency. When set to 0, the reference frequency is */
usartInit.baudrate = SC_BAUD_RATE; /* Baud rate */
usartInit.oversampling = usartOVS16; /* Oversampling. Range is 4x, 6x, 8x or 16x */
usartInit.databits = usartDatabits8; /* Number of data bits. Range is 4 to 10 */
usartInit.parity = usartEvenParity; /* Parity mode */
usartInit.stopbits = usartStopbits1p5; /* Number of stop bits. Range is 0 to 2, 1.5 for smartcard. */
usartInit.mvdis = false; /* Disable majority voting */
usartInit.prsRxEnable = false; /* Enable USART Rx via Peripheral Reflex System */
usartInit.prsRxCh = usartPrsRxCh0; /* Select PRS channel if enabled */
/* Initialize USART with usartInit struct */
USART_InitAsync(usart, &usartInit);
/* Smart card specific settings for T0 mode. */
usart->CTRL |= USART_CTRL_SCMODE | USART_CTRL_AUTOTRI | USART_CTRL_LOOPBK;
/* Prepare USART Rx interrupt */
USART_IntClear(usart, _USART_IF_MASK);
USART_IntEnable(usart, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ(USART1_RX_IRQn);
NVIC_EnableIRQ(USART1_RX_IRQn);
/* Enable I/O pins at USART1 location #2 */
usart->ROUTE = USART_ROUTE_TXPEN | SC_USART_LOCATION;
/* Disable reception before enabling uart to discard erroneus stuff while card is unpowered. */
usartFlushBuffer();
usartAcceptRX(false);
/* Enable USART */
USART_Enable(usart, usartEnable);
}
/**************************************************************************//**
* @brief USART1 RX IRQ Handler
*
* Set up the interrupt prior to use
*
* Note that this function handles overflows in a very simple way.
*
*****************************************************************************/
void USART1_RX_IRQHandler(void)
{
/* Check for RX data valid interrupt */
if (uart->STATUS & USART_STATUS_RXDATAV)
{
/* Copy data into RX Buffer */
uint8_t rxData = USART_Rx(uart);
rxBuf.data[rxBuf.wrI] = rxData;
rxBuf.wrI = (rxBuf.wrI + 1) % BUFFERSIZE;
rxBuf.pendingBytes++;
/* Flag Rx overflow */
if (rxBuf.pendingBytes > BUFFERSIZE)
{
rxBuf.overflow = true;
}
/* Clear RXDATAV interrupt */
USART_IntClear(USART1, USART_IF_RXDATAV);
}
}
/******************************************************************************
* @brief uartSetup function
*
******************************************************************************/
void uartSetup(void)
{
/* Enable clock for GPIO module (required for pin configuration) */
CMU_ClockEnable(cmuClock_GPIO, true);
/* Configure GPIO pins */
GPIO_PinModeSet(gpioPortB, 9, gpioModePushPull, 1);
GPIO_PinModeSet(gpioPortB, 10, gpioModeInput, 0);
/* Prepare struct for initializing UART in asynchronous mode*/
uartInit.enable = usartDisable; /* Don't enable UART upon intialization */
uartInit.refFreq = 0; /* Provide information on reference frequency. When set to 0, the reference frequency is */
uartInit.baudrate = 115200; /* Baud rate */
uartInit.oversampling = usartOVS16; /* Oversampling. Range is 4x, 6x, 8x or 16x */
uartInit.databits = usartDatabits8; /* Number of data bits. Range is 4 to 10 */
uartInit.parity = usartNoParity; /* Parity mode */
uartInit.stopbits = usartStopbits1; /* Number of stop bits. Range is 0 to 2 */
uartInit.mvdis = false; /* Disable majority voting */
uartInit.prsRxEnable = false; /* Enable USART Rx via Peripheral Reflex System */
uartInit.prsRxCh = usartPrsRxCh0; /* Select PRS channel if enabled */
/* Initialize USART with uartInit struct */
USART_InitAsync(uart, &uartInit);
/* Prepare UART Rx and Tx interrupts */
USART_IntClear(uart, _UART_IF_MASK);
USART_IntEnable(uart, UART_IF_RXDATAV);
NVIC_ClearPendingIRQ(UART1_RX_IRQn);
NVIC_ClearPendingIRQ(UART1_TX_IRQn);
NVIC_EnableIRQ(UART1_RX_IRQn);
NVIC_EnableIRQ(UART1_TX_IRQn);
/* Enable I/O pins at UART1 location #2 */
uart->ROUTE = UART_ROUTE_RXPEN | UART_ROUTE_TXPEN | UART_ROUTE_LOCATION_LOC2;
/* Enable UART */
USART_Enable(uart, usartEnable);
}
static int uart_gecko_err_check(struct device *dev)
{
const struct uart_gecko_config *config = dev->config->config_info;
u32_t flags = USART_IntGet(config->base);
int err = 0;
if (flags & USART_IF_RXOF) {
err |= UART_ERROR_OVERRUN;
}
if (flags & USART_IF_PERR) {
err |= UART_ERROR_PARITY;
}
if (flags & USART_IF_FERR) {
err |= UART_ERROR_FRAMING;
}
USART_IntClear(config->base, USART_IF_RXOF |
USART_IF_PERR |
USART_IF_FERR);
return err;
}
/**************************************************************************//**
* @brief UART/LEUART IRQ Handler
*****************************************************************************/
void RETARGET_IRQ_NAME(void)
{
#if defined(RETARGET_USART)
if (RETARGET_UART->STATUS & USART_STATUS_RXDATAV)
{
#else
if (RETARGET_UART->IF & LEUART_IF_RXDATAV)
{
#endif
/* Store Data */
rxBuffer[rxWriteIndex] = RETARGET_RX(RETARGET_UART);
rxWriteIndex++;
rxCount++;
if (rxWriteIndex == RXBUFSIZE)
{
rxWriteIndex = 0;
}
/* Check for overflow - flush buffer */
if (rxCount > RXBUFSIZE)
{
rxWriteIndex = 0;
rxCount = 0;
rxReadIndex = 0;
}
}
}
/** @} (end group RetargetIo) */
/**************************************************************************//**
* @brief UART/LEUART toggle LF to CRLF conversion
* @param on If non-zero, automatic LF to CRLF conversion will be enabled
*****************************************************************************/
void RETARGET_SerialCrLf(int on)
{
if (on)
LFtoCRLF = 1;
else
LFtoCRLF = 0;
}
/**************************************************************************//**
* @brief Intializes UART/LEUART
*****************************************************************************/
void RETARGET_SerialInit(void)
{
/* Enable peripheral clocks */
CMU_ClockEnable(cmuClock_HFPER, true);
/* Configure GPIO pins */
CMU_ClockEnable(cmuClock_GPIO, true);
/* To avoid false start, configure output as high */
GPIO_PinModeSet(RETARGET_TXPORT, RETARGET_TXPIN, gpioModePushPull, 1);
GPIO_PinModeSet(RETARGET_RXPORT, RETARGET_RXPIN, gpioModeInput, 0);
#if defined(RETARGET_USART)
USART_TypeDef *usart = RETARGET_UART;
USART_InitAsync_TypeDef init = USART_INITASYNC_DEFAULT;
/* Enable DK RS232/UART switch */
RETARGET_PERIPHERAL_ENABLE();
CMU_ClockEnable(RETARGET_CLK, true);
/* Configure USART for basic async operation */
init.enable = usartDisable;
USART_InitAsync(usart, &init);
/* Enable pins at correct UART/USART location. */
#if defined( USART_ROUTEPEN_RXPEN )
usart->ROUTEPEN = USART_ROUTEPEN_RXPEN | USART_ROUTEPEN_TXPEN;
usart->ROUTELOC0 = ( usart->ROUTELOC0 &
~( _USART_ROUTELOC0_TXLOC_MASK
| _USART_ROUTELOC0_RXLOC_MASK ) )
| ( RETARGET_TX_LOCATION << _USART_ROUTELOC0_TXLOC_SHIFT )
| ( RETARGET_RX_LOCATION << _USART_ROUTELOC0_RXLOC_SHIFT );
#else
usart->ROUTE = USART_ROUTE_RXPEN | USART_ROUTE_TXPEN | RETARGET_LOCATION;
#endif
/* Clear previous RX interrupts */
USART_IntClear(RETARGET_UART, USART_IF_RXDATAV);
NVIC_ClearPendingIRQ(RETARGET_IRQn);
/* Enable RX interrupts */
USART_IntEnable(RETARGET_UART, USART_IF_RXDATAV);
NVIC_EnableIRQ(RETARGET_IRQn);
/* Finally enable it */
USART_Enable(usart, usartEnable);
#else
LEUART_TypeDef *leuart = RETARGET_UART;
LEUART_Init_TypeDef init = LEUART_INIT_DEFAULT;
/* Enable DK LEUART/RS232 switch */
RETARGET_PERIPHERAL_ENABLE();
/* Enable CORE LE clock in order to access LE modules */
CMU_ClockEnable(cmuClock_CORELE, true);
#if defined(RETARGET_VCOM)
/* Select HFXO/2 for LEUARTs (and wait for it to stabilize) */
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_CORELEDIV2);
#else
/* Select LFXO for LEUARTs (and wait for it to stabilize) */
CMU_ClockSelectSet(cmuClock_LFB, cmuSelect_LFXO);
#endif
CMU_ClockEnable(RETARGET_CLK, true);
/* Do not prescale clock */
CMU_ClockDivSet(RETARGET_CLK, cmuClkDiv_1);
/* Configure LEUART */
init.enable = leuartDisable;
#if defined(RETARGET_VCOM)
init.baudrate = 115200;
#endif
LEUART_Init(leuart, &init);
/* Enable pins at default location */
leuart->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | RETARGET_LOCATION;
/* Clear previous RX interrupts */
LEUART_IntClear(RETARGET_UART, LEUART_IF_RXDATAV);
NVIC_ClearPendingIRQ(RETARGET_IRQn);
/* Enable RX interrupts */
LEUART_IntEnable(RETARGET_UART, LEUART_IF_RXDATAV);
NVIC_EnableIRQ(RETARGET_IRQn);
/* Finally enable it */
LEUART_Enable(leuart, leuartEnable);
#endif
#if !defined(__CROSSWORKS_ARM) && defined(__GNUC__)
setvbuf(stdout, NULL, _IONBF, 0); /*Set unbuffered mode for stdout (newlib)*/
#endif
initialized = true;
}
