uart.h

Go to the documentation of this file.

/******************************************************************************
 *  Filename:       uart.h
 *
 *  Description:    Defines and prototypes for the UART peripheral.
 *
 *  Copyright (c) 2022-2024 Texas Instruments Incorporated
 *
 *  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.
 *
 ******************************************************************************/

#ifndef __UART_H__
#define __UART_H__

//*****************************************************************************
//
//
//*****************************************************************************

#include <stdbool.h>
#include <stdint.h>
#include "../inc/hw_types.h"
#include "../inc/hw_memmap.h"
#include "../inc/hw_uartlin.h"
#include "debug.h"

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C" {
#endif

//*****************************************************************************
//
// Values that can be passed to UARTEnableInt, UARTDisableInt, and UARTClearInt
// as the intFlags parameter, and returned from UARTIntStatus.
//
//*****************************************************************************
#define UART_INT_EOT       UARTLIN_IMSC_EOT_M       
#define UART_INT_OE        UARTLIN_IMSC_OE_M        
#define UART_INT_BE        UARTLIN_IMSC_BE_M        
#define UART_INT_PE        UARTLIN_IMSC_PE_M        
#define UART_INT_FE        UARTLIN_IMSC_FE_M        
#define UART_INT_RT        UARTLIN_IMSC_RT_M        
#define UART_INT_RX        UARTLIN_IMSC_RX_M        
#define UART_INT_TX        UARTLIN_IMSC_TX_M        
#define UART_INT_CTS       UARTLIN_IMSC_CTSM_M      
#define UART_INT_TXDMADONE UARTLIN_IMSC_TXDMADONE_M 
#define UART_INT_RXDMADONE UARTLIN_IMSC_RXDMADONE_M 

#define UART_INT_ALL                                                                                                  \
    (UART_INT_EOT | UART_INT_OE | UART_INT_BE | UART_INT_PE | UART_INT_FE | UART_INT_RT | UART_INT_RX | UART_INT_TX | \
     UART_INT_CTS | UART_INT_TXDMADONE | UART_INT_RXDMADONE)

//*****************************************************************************
//
// Values that can be passed to UARTConfigSetExpClk as the config parameter
// and returned by UARTConfigGetExpClk in the pconfig parameter.
//
//*****************************************************************************
#define UART_CONFIG_WLEN_MASK 0x00000060 
#define UART_CONFIG_WLEN_8    0x00000060 
#define UART_CONFIG_WLEN_7    0x00000040 
#define UART_CONFIG_WLEN_6    0x00000020 
#define UART_CONFIG_WLEN_5    0x00000000 
#define UART_CONFIG_STOP_MASK 0x00000008 
#define UART_CONFIG_STOP_ONE  0x00000000 
#define UART_CONFIG_STOP_TWO  0x00000008 
#define UART_CONFIG_PAR_MASK  0x00000086 
#define UART_CONFIG_PAR_NONE  0x00000000 
#define UART_CONFIG_PAR_EVEN  0x00000006 
#define UART_CONFIG_PAR_ODD   0x00000002 
#define UART_CONFIG_PAR_ONE   0x00000082 
#define UART_CONFIG_PAR_ZERO  0x00000086 

//*****************************************************************************
//
// Values that can be passed to UARTFIFOLevelSet as the txLevel parameter
//
//*****************************************************************************
#define UART_FIFO_TX2_8 0x00000001 
#define UART_FIFO_TX4_8 0x00000002 
#define UART_FIFO_TX6_8 0x00000003 

//*****************************************************************************
//
// Values that can be passed to UARTFIFOLevelSet as the rxLevel parameter
//
//*****************************************************************************
#define UART_FIFO_RX2_8 0x00000008 
#define UART_FIFO_RX4_8 0x00000010 
#define UART_FIFO_RX6_8 0x00000018 

//*****************************************************************************
//
// Values that can be passed to UARTDMAEnable() and UARTDMADisable().
//
//*****************************************************************************
#define UART_DMA_ERR_RXSTOP 0x00000004 
#define UART_DMA_TX         0x00000002 
#define UART_DMA_RX         0x00000001 

//*****************************************************************************
//
// Values returned by UARTRxErrorGet().
//
//*****************************************************************************
#define UART_RXERROR_OVERRUN 0x00000008
#define UART_RXERROR_BREAK   0x00000004
#define UART_RXERROR_PARITY  0x00000002
#define UART_RXERROR_FRAMING 0x00000001

//*****************************************************************************
//
// API Functions and prototypes
//
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTSetFifoLevel(uint32_t base, uint32_t txLevel, uint32_t rxLevel)
{
    // Check the arguments.
    ASSERT((txLevel == UART_FIFO_TX2_8) || (txLevel == UART_FIFO_TX4_8) || (txLevel == UART_FIFO_TX6_8));
    ASSERT((rxLevel == UART_FIFO_RX2_8) || (rxLevel == UART_FIFO_RX4_8) || (rxLevel == UART_FIFO_RX6_8));

    // Set the FIFO interrupt levels.
    HWREG(base + UARTLIN_O_IFLS) = txLevel | rxLevel;
}

//*****************************************************************************
//
//
//*****************************************************************************
void UARTClockCtrl(uint32_t base, bool clkEnable);

//*****************************************************************************
//
//
//*****************************************************************************
extern void UARTConfigSetExpClk(uint32_t base, uint32_t UARTClkFreq, uint32_t baudFreq, uint32_t config);

//*****************************************************************************
//
//
//*****************************************************************************
extern void UARTDisable(uint32_t base);

//*****************************************************************************
//
//
//*****************************************************************************
extern void UARTEnable(uint32_t base);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableFifo(uint32_t base)
{
    // Enable the FIFO.
    HWREG(base + UARTLIN_O_LCRH) |= UARTLIN_LCRH_FEN;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableFifo(uint32_t base)
{
    // Disable the FIFO.
    HWREG(base + UARTLIN_O_LCRH) &= ~(UARTLIN_LCRH_FEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE bool UARTCharAvailable(uint32_t base)
{
    // Return the availability of characters.
    return ((HWREG(base + UARTLIN_O_FR) & UARTLIN_FR_RXFE) ? false : true);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint8_t UARTGetCharNonBlocking(uint32_t base)
{
    // Return a character from the data register
    return (HWREGB(base + UARTLIN_O_DR));
}

//*****************************************************************************
//
//
//*****************************************************************************
extern uint8_t UARTGetChar(uint32_t base);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE bool UARTSpaceAvailable(uint32_t base)
{
    // Return the availability of space.
    return ((HWREG(base + UARTLIN_O_FR) & UARTLIN_FR_TXFF) ? false : true);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTPutCharNonBlocking(uint32_t base, uint8_t data)
{
    // Write this character to the transmit FIFO.
    HWREG(base + UARTLIN_O_DR) = data;
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void UARTPutChar(uint32_t base, uint8_t data);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE bool UARTBusy(uint32_t base)
{
    // Determine if the UART is busy.
    return ((HWREG(base + UARTLIN_O_FR) & UARTLIN_FR_BUSY) ? true : false);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableInt(uint32_t base, uint32_t intFlags)
{
    // Enable the specified interrupts.
    HWREG(base + UARTLIN_O_IMSC) |= intFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableInt(uint32_t base, uint32_t intFlags)
{
    // Disable the specified interrupts.
    HWREG(base + UARTLIN_O_IMSC) &= ~(intFlags);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t UARTIntStatus(uint32_t base, bool masked)
{
    // Return either the masked interrupt status or the raw interrupt status as
    // requested.
    if (masked)
    {
        return (HWREG(base + UARTLIN_O_MIS));
    }
    else
    {
        return (HWREG(base + UARTLIN_O_RIS));
    }
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTClearInt(uint32_t base, uint32_t intFlags)
{
    // Clear the requested interrupt sources
    HWREG(base + UARTLIN_O_ICR) = intFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableDma(uint32_t base, uint32_t dmaFlags)
{
    // Set the requested bits in the UART DMA control register.
    HWREG(base + UARTLIN_O_DMACTL) |= dmaFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableDma(uint32_t base, uint32_t dmaFlags)
{
    // Clear the requested bits in the UART DMA control register.
    HWREG(base + UARTLIN_O_DMACTL) &= ~dmaFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t UARTGetRxError(uint32_t base)
{
    // Return the current value of the receive status register.
    return (HWREG(base + UARTLIN_O_RSRECR) & 0x0000000F);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTClearRxError(uint32_t base)
{
    // Any write to the Error Clear Register will clear all bits which are
    // currently set.
    HWREG(base + UARTLIN_O_RSRECR) = 0;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableCts(uint32_t base)
{
    HWREG(base + UARTLIN_O_CTL) |= (UARTLIN_CTL_CTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableRts(uint32_t base)
{
    HWREG(base + UARTLIN_O_CTL) |= (UARTLIN_CTL_RTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableCts(uint32_t base)
{
    HWREG(base + UARTLIN_O_CTL) &= ~(UARTLIN_CTL_CTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableRts(uint32_t base)
{
    HWREG(base + UARTLIN_O_CTL) &= ~(UARTLIN_CTL_RTSEN);
}

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

//*****************************************************************************
//
//
//*****************************************************************************

#endif //  __UART_H__