401 lines
13 KiB
C
401 lines
13 KiB
C
/*
|
|
* Copyright (c) 2012, Texas Instruments Incorporated - http://www.ti.com/
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/**
|
|
* \addtogroup cc2538-uart
|
|
* @{
|
|
*
|
|
* \file
|
|
* Implementation of the cc2538 UART driver
|
|
*/
|
|
#include "contiki.h"
|
|
#include "sys/energest.h"
|
|
#include "dev/sys-ctrl.h"
|
|
#include "dev/ioc.h"
|
|
#include "dev/gpio.h"
|
|
#include "dev/uart.h"
|
|
#include "lpm.h"
|
|
#include "reg.h"
|
|
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
#ifndef UART0_RX_PORT
|
|
#define UART0_RX_PORT (-1)
|
|
#endif
|
|
#ifndef UART0_RX_PIN
|
|
#define UART0_RX_PIN (-1)
|
|
#endif
|
|
#if UART0_RX_PORT >= 0 && UART0_RX_PIN < 0 || \
|
|
UART0_RX_PORT < 0 && UART0_RX_PIN >= 0
|
|
#error Both UART0_RX_PORT and UART0_RX_PIN must be valid or invalid
|
|
#endif
|
|
|
|
#ifndef UART0_TX_PORT
|
|
#define UART0_TX_PORT (-1)
|
|
#endif
|
|
#ifndef UART0_TX_PIN
|
|
#define UART0_TX_PIN (-1)
|
|
#endif
|
|
#if UART0_TX_PORT >= 0 && UART0_TX_PIN < 0 || \
|
|
UART0_TX_PORT < 0 && UART0_TX_PIN >= 0
|
|
#error Both UART0_TX_PORT and UART0_TX_PIN must be valid or invalid
|
|
#endif
|
|
|
|
#if UART0_RX_PORT >= 0 && UART0_TX_PORT < 0 || \
|
|
UART0_RX_PORT < 0 && UART0_TX_PORT >= 0
|
|
#error Both UART0_RX and UART0_TX pads must be valid or invalid
|
|
#endif
|
|
|
|
#if UART_IN_USE(0) && UART0_RX_PORT < 0
|
|
#error Contiki is configured to use UART0, but its pads are not valid
|
|
#endif
|
|
|
|
#ifndef UART1_RX_PORT
|
|
#define UART1_RX_PORT (-1)
|
|
#endif
|
|
#ifndef UART1_RX_PIN
|
|
#define UART1_RX_PIN (-1)
|
|
#endif
|
|
#if UART1_RX_PORT >= 0 && UART1_RX_PIN < 0 || \
|
|
UART1_RX_PORT < 0 && UART1_RX_PIN >= 0
|
|
#error Both UART1_RX_PORT and UART1_RX_PIN must be valid or invalid
|
|
#endif
|
|
|
|
#ifndef UART1_TX_PORT
|
|
#define UART1_TX_PORT (-1)
|
|
#endif
|
|
#ifndef UART1_TX_PIN
|
|
#define UART1_TX_PIN (-1)
|
|
#endif
|
|
#if UART1_TX_PORT >= 0 && UART1_TX_PIN < 0 || \
|
|
UART1_TX_PORT < 0 && UART1_TX_PIN >= 0
|
|
#error Both UART1_TX_PORT and UART1_TX_PIN must be valid or invalid
|
|
#endif
|
|
|
|
#if UART1_RX_PORT >= 0 && UART1_TX_PORT < 0 || \
|
|
UART1_RX_PORT < 0 && UART1_TX_PORT >= 0
|
|
#error Both UART1_RX and UART1_TX pads must be valid or invalid
|
|
#endif
|
|
|
|
#if UART_IN_USE(1) && UART1_RX_PORT < 0
|
|
#error Contiki is configured to use UART1, but its pads are not valid
|
|
#endif
|
|
|
|
#ifndef UART1_CTS_PORT
|
|
#define UART1_CTS_PORT (-1)
|
|
#endif
|
|
#ifndef UART1_CTS_PIN
|
|
#define UART1_CTS_PIN (-1)
|
|
#endif
|
|
#if UART1_CTS_PORT >= 0 && UART1_CTS_PIN < 0 || \
|
|
UART1_CTS_PORT < 0 && UART1_CTS_PIN >= 0
|
|
#error Both UART1_CTS_PORT and UART1_CTS_PIN must be valid or invalid
|
|
#endif
|
|
|
|
#ifndef UART1_RTS_PORT
|
|
#define UART1_RTS_PORT (-1)
|
|
#endif
|
|
#ifndef UART1_RTS_PIN
|
|
#define UART1_RTS_PIN (-1)
|
|
#endif
|
|
#if UART1_RTS_PORT >= 0 && UART1_RTS_PIN < 0 || \
|
|
UART1_RTS_PORT < 0 && UART1_RTS_PIN >= 0
|
|
#error Both UART1_RTS_PORT and UART1_RTS_PIN must be valid or invalid
|
|
#endif
|
|
/*---------------------------------------------------------------------------*/
|
|
/*
|
|
* Baud rate defines used in uart_init() to set the values of UART_IBRD and
|
|
* UART_FBRD in order to achieve the configured baud rates.
|
|
*/
|
|
#define UART_CLOCK_RATE 16000000 /* 16 MHz */
|
|
#define UART_CTL_HSE_VALUE 0
|
|
#define UART_CTL_VALUE (UART_CTL_RXE | UART_CTL_TXE | (UART_CTL_HSE_VALUE << 5))
|
|
|
|
/* DIV_ROUND() divides integers while avoiding a rounding error: */
|
|
#define DIV_ROUND(num, denom) (((num) + (denom) / 2) / (denom))
|
|
|
|
#define BAUD2BRD(baud) DIV_ROUND(UART_CLOCK_RATE << (UART_CTL_HSE_VALUE + 2), (baud))
|
|
#define BAUD2IBRD(baud) (BAUD2BRD(baud) >> 6)
|
|
#define BAUD2FBRD(baud) (BAUD2BRD(baud) & 0x3f)
|
|
/*---------------------------------------------------------------------------*/
|
|
typedef struct {
|
|
int8_t port;
|
|
int8_t pin;
|
|
} uart_pad_t;
|
|
typedef struct {
|
|
uint32_t sys_ctrl_rcgcuart_uart;
|
|
uint32_t sys_ctrl_scgcuart_uart;
|
|
uint32_t sys_ctrl_dcgcuart_uart;
|
|
uint32_t base;
|
|
uint32_t ioc_uartrxd_uart;
|
|
uint32_t ioc_pxx_sel_uart_txd;
|
|
uint32_t ibrd;
|
|
uint32_t fbrd;
|
|
uart_pad_t rx;
|
|
uart_pad_t tx;
|
|
uart_pad_t cts;
|
|
uart_pad_t rts;
|
|
uint8_t nvic_int;
|
|
} uart_regs_t;
|
|
/*---------------------------------------------------------------------------*/
|
|
static const uart_regs_t uart_regs[UART_INSTANCE_COUNT] = {
|
|
{
|
|
.sys_ctrl_rcgcuart_uart = SYS_CTRL_RCGCUART_UART0,
|
|
.sys_ctrl_scgcuart_uart = SYS_CTRL_SCGCUART_UART0,
|
|
.sys_ctrl_dcgcuart_uart = SYS_CTRL_DCGCUART_UART0,
|
|
.base = UART_0_BASE,
|
|
.ioc_uartrxd_uart = IOC_UARTRXD_UART0,
|
|
.ioc_pxx_sel_uart_txd = IOC_PXX_SEL_UART0_TXD,
|
|
.ibrd = BAUD2IBRD(UART0_CONF_BAUD_RATE),
|
|
.fbrd = BAUD2FBRD(UART0_CONF_BAUD_RATE),
|
|
.rx = {UART0_RX_PORT, UART0_RX_PIN},
|
|
.tx = {UART0_TX_PORT, UART0_TX_PIN},
|
|
.cts = {-1, -1},
|
|
.rts = {-1, -1},
|
|
.nvic_int = NVIC_INT_UART0
|
|
}, {
|
|
.sys_ctrl_rcgcuart_uart = SYS_CTRL_RCGCUART_UART1,
|
|
.sys_ctrl_scgcuart_uart = SYS_CTRL_SCGCUART_UART1,
|
|
.sys_ctrl_dcgcuart_uart = SYS_CTRL_DCGCUART_UART1,
|
|
.base = UART_1_BASE,
|
|
.ioc_uartrxd_uart = IOC_UARTRXD_UART1,
|
|
.ioc_pxx_sel_uart_txd = IOC_PXX_SEL_UART1_TXD,
|
|
.ibrd = BAUD2IBRD(UART1_CONF_BAUD_RATE),
|
|
.fbrd = BAUD2FBRD(UART1_CONF_BAUD_RATE),
|
|
.rx = {UART1_RX_PORT, UART1_RX_PIN},
|
|
.tx = {UART1_TX_PORT, UART1_TX_PIN},
|
|
.cts = {UART1_CTS_PORT, UART1_CTS_PIN},
|
|
.rts = {UART1_RTS_PORT, UART1_RTS_PIN},
|
|
.nvic_int = NVIC_INT_UART1
|
|
}
|
|
};
|
|
static int (* input_handler[UART_INSTANCE_COUNT])(unsigned char c);
|
|
/*---------------------------------------------------------------------------*/
|
|
static void
|
|
reset(uint32_t uart_base)
|
|
{
|
|
uint32_t lchr;
|
|
|
|
/* Make sure the UART is disabled before trying to configure it */
|
|
REG(uart_base | UART_CTL) = UART_CTL_VALUE;
|
|
|
|
/* Clear error status */
|
|
REG(uart_base | UART_ECR) = 0xFF;
|
|
|
|
/* Store LCHR configuration */
|
|
lchr = REG(uart_base | UART_LCRH);
|
|
|
|
/* Flush FIFOs by clearing LCHR.FEN */
|
|
REG(uart_base | UART_LCRH) = 0;
|
|
|
|
/* Restore LCHR configuration */
|
|
REG(uart_base | UART_LCRH) = lchr;
|
|
|
|
/* UART Enable */
|
|
REG(uart_base | UART_CTL) |= UART_CTL_UARTEN;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
static bool
|
|
permit_pm1(void)
|
|
{
|
|
const uart_regs_t *regs;
|
|
|
|
for(regs = &uart_regs[0]; regs < &uart_regs[UART_INSTANCE_COUNT]; regs++) {
|
|
/* Note: UART_FR.TXFE reads 0 if the UART clock is gated. */
|
|
if((REG(SYS_CTRL_RCGCUART) & regs->sys_ctrl_rcgcuart_uart) != 0 &&
|
|
(REG(regs->base | UART_FR) & UART_FR_TXFE) == 0) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
uart_init(uint8_t uart)
|
|
{
|
|
const uart_regs_t *regs;
|
|
|
|
if(uart >= UART_INSTANCE_COUNT) {
|
|
return;
|
|
}
|
|
regs = &uart_regs[uart];
|
|
if(regs->rx.port < 0 || regs->tx.port < 0) {
|
|
return;
|
|
}
|
|
|
|
lpm_register_peripheral(permit_pm1);
|
|
|
|
/* Enable clock for the UART while Running, in Sleep and Deep Sleep */
|
|
REG(SYS_CTRL_RCGCUART) |= regs->sys_ctrl_rcgcuart_uart;
|
|
REG(SYS_CTRL_SCGCUART) |= regs->sys_ctrl_scgcuart_uart;
|
|
REG(SYS_CTRL_DCGCUART) |= regs->sys_ctrl_dcgcuart_uart;
|
|
|
|
/* Run on SYS_DIV */
|
|
REG(regs->base | UART_CC) = 0;
|
|
|
|
/*
|
|
* Select the UARTx RX pin by writing to the IOC_UARTRXD_UARTn register
|
|
*
|
|
* The value to be written will be on of the IOC_INPUT_SEL_Pxn defines from
|
|
* ioc.h. The value can also be calculated as:
|
|
*
|
|
* (port << 3) + pin
|
|
*/
|
|
REG(regs->ioc_uartrxd_uart) = (regs->rx.port << 3) + regs->rx.pin;
|
|
|
|
/*
|
|
* Pad Control for the TX pin:
|
|
* - Set function to UARTn TX
|
|
* - Output Enable
|
|
*/
|
|
ioc_set_sel(regs->tx.port, regs->tx.pin, regs->ioc_pxx_sel_uart_txd);
|
|
ioc_set_over(regs->tx.port, regs->tx.pin, IOC_OVERRIDE_OE);
|
|
|
|
/* Set RX and TX pins to peripheral mode */
|
|
GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->tx.port),
|
|
GPIO_PIN_MASK(regs->tx.pin));
|
|
GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->rx.port),
|
|
GPIO_PIN_MASK(regs->rx.pin));
|
|
|
|
/*
|
|
* UART Interrupt Masks:
|
|
* Acknowledge RX and RX Timeout
|
|
* Acknowledge Framing, Overrun and Break Errors
|
|
*/
|
|
REG(regs->base | UART_IM) = UART_IM_RXIM | UART_IM_RTIM;
|
|
REG(regs->base | UART_IM) |= UART_IM_OEIM | UART_IM_BEIM | UART_IM_FEIM;
|
|
|
|
REG(regs->base | UART_IFLS) =
|
|
UART_IFLS_RXIFLSEL_1_8 | UART_IFLS_TXIFLSEL_1_2;
|
|
|
|
/* Make sure the UART is disabled before trying to configure it */
|
|
REG(regs->base | UART_CTL) = UART_CTL_VALUE;
|
|
|
|
/* Baud Rate Generation */
|
|
REG(regs->base | UART_IBRD) = regs->ibrd;
|
|
REG(regs->base | UART_FBRD) = regs->fbrd;
|
|
|
|
/* UART Control: 8N1 with FIFOs */
|
|
REG(regs->base | UART_LCRH) = UART_LCRH_WLEN_8 | UART_LCRH_FEN;
|
|
|
|
/*
|
|
* Enable hardware flow control (RTS/CTS) if requested.
|
|
* Note that hardware flow control is available only on UART1.
|
|
*/
|
|
if(regs->cts.port >= 0) {
|
|
REG(IOC_UARTCTS_UART1) = ioc_input_sel(regs->cts.port, regs->cts.pin);
|
|
GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->cts.port), GPIO_PIN_MASK(regs->cts.pin));
|
|
ioc_set_over(regs->cts.port, regs->cts.pin, IOC_OVERRIDE_DIS);
|
|
REG(UART_1_BASE | UART_CTL) |= UART_CTL_CTSEN;
|
|
}
|
|
|
|
if(regs->rts.port >= 0) {
|
|
ioc_set_sel(regs->rts.port, regs->rts.pin, IOC_PXX_SEL_UART1_RTS);
|
|
GPIO_PERIPHERAL_CONTROL(GPIO_PORT_TO_BASE(regs->rts.port), GPIO_PIN_MASK(regs->rts.pin));
|
|
ioc_set_over(regs->rts.port, regs->rts.pin, IOC_OVERRIDE_OE);
|
|
REG(UART_1_BASE | UART_CTL) |= UART_CTL_RTSEN;
|
|
}
|
|
|
|
/* UART Enable */
|
|
REG(regs->base | UART_CTL) |= UART_CTL_UARTEN;
|
|
|
|
/* Enable UART0 Interrupts */
|
|
nvic_interrupt_enable(regs->nvic_int);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
uart_set_input(uint8_t uart, int (* input)(unsigned char c))
|
|
{
|
|
if(uart >= UART_INSTANCE_COUNT) {
|
|
return;
|
|
}
|
|
|
|
input_handler[uart] = input;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
uart_write_byte(uint8_t uart, uint8_t b)
|
|
{
|
|
uint32_t uart_base;
|
|
|
|
if(uart >= UART_INSTANCE_COUNT) {
|
|
return;
|
|
}
|
|
uart_base = uart_regs[uart].base;
|
|
|
|
/* Block if the TX FIFO is full */
|
|
while(REG(uart_base | UART_FR) & UART_FR_TXFF);
|
|
|
|
REG(uart_base | UART_DR) = b;
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
void
|
|
uart_isr(uint8_t uart)
|
|
{
|
|
uint32_t uart_base;
|
|
uint16_t mis;
|
|
|
|
ENERGEST_ON(ENERGEST_TYPE_IRQ);
|
|
|
|
uart_base = uart_regs[uart].base;
|
|
|
|
/* Store the current MIS and clear all flags early, except the RTM flag.
|
|
* This will clear itself when we read out the entire FIFO contents */
|
|
mis = REG(uart_base | UART_MIS) & 0x0000FFFF;
|
|
|
|
REG(uart_base | UART_ICR) = 0x0000FFBF;
|
|
|
|
if(mis & (UART_MIS_RXMIS | UART_MIS_RTMIS)) {
|
|
while(!(REG(uart_base | UART_FR) & UART_FR_RXFE)) {
|
|
if(input_handler[uart] != NULL) {
|
|
input_handler[uart]((unsigned char)(REG(uart_base | UART_DR) & 0xFF));
|
|
} else {
|
|
/* To prevent an Overrun Error, we need to flush the FIFO even if we
|
|
* don't have an input_handler. Use mis as a data trash can */
|
|
mis = REG(uart_base | UART_DR);
|
|
}
|
|
}
|
|
} else if(mis & (UART_MIS_OEMIS | UART_MIS_BEMIS | UART_MIS_FEMIS)) {
|
|
/* ISR triggered due to some error condition */
|
|
reset(uart_base);
|
|
}
|
|
|
|
ENERGEST_OFF(ENERGEST_TYPE_IRQ);
|
|
}
|
|
/*---------------------------------------------------------------------------*/
|
|
#define UART_ISR(u) void uart##u##_isr(void) { uart_isr(u); }
|
|
UART_ISR(0)
|
|
UART_ISR(1)
|
|
|
|
/** @} */
|