uart.h

Go to the documentation of this file.

/******************************************************************************
 *  Filename:       uart.h
 *
 *  Description:    Defines and prototypes for the UART peripheral.
 *
 *  Copyright (c) 2022-2025 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_uart.h"
#include "../inc/hw_memmap.h"
#include "../inc/hw_ints.h"
#include "interrupt.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        (UART_IMSC_EOT_M)        
#define UART_INT_OE         (UART_IMSC_OE_M)         
#define UART_INT_BE         (UART_IMSC_BE_M)         
#define UART_INT_PE         (UART_IMSC_PE_M)         
#define UART_INT_FE         (UART_IMSC_FE_M)         
#define UART_INT_RT         (UART_IMSC_RT_M)         
#define UART_INT_RX         (UART_IMSC_RX_M)         
#define UART_INT_TX         (UART_IMSC_TX_M)         
#define UART_INT_CTS        (UART_IMSC_CTSM_M)       
#define UART_INT_TXDMADONE  (UART_IMSC_TXDMADONE_M)  
#define UART_INT_RXDMADONE  (UART_IMSC_RXDMADONE_M)  
#define UART_INT_LINBRK     (UART_IMSC_LINBRK_M)     
#define UART_INT_LINBRKTOE  (UART_IMSC_LINBRKTOE_M)  
#define UART_INT_LINSYNCTOE (UART_IMSC_LINSYNCTOE_M) 

//*****************************************************************************
//
// Values that can be passed to UARTConfigSetExpClk as the config parameter
// and returned by UARTConfigGetExpClk in the pconfig parameter.
//
//*****************************************************************************
#define UART_CONFIG_WLEN_MASK UART_LCRH_WLEN_M     
#define UART_CONFIG_WLEN_8    UART_LCRH_WLEN_BITL8 
#define UART_CONFIG_WLEN_7    UART_LCRH_WLEN_BITL7 
#define UART_CONFIG_WLEN_6    UART_LCRH_WLEN_BITL6 
#define UART_CONFIG_WLEN_5    UART_LCRH_WLEN_BITL5 
#define UART_CONFIG_STOP_MASK UART_LCRH_STP2_M     
#define UART_CONFIG_STOP_ONE  0x00000000           
#define UART_CONFIG_STOP_TWO  UART_LCRH_STP2       
#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 UARTSetFifoLevel as the txLevel parameter
//
//*****************************************************************************
#define UART_FIFO_TX2_8 UART_IFLS_TXSEL_QUARTER 
#define UART_FIFO_TX4_8 UART_IFLS_TXSEL_HALF    
#define UART_FIFO_TX6_8 UART_IFLS_TXSEL_THREEQU 

//*****************************************************************************
//
// Values that can be passed to UARTSetFifoLevel as the rxLevel parameter
//
//*****************************************************************************
#define UART_FIFO_RX2_8 UART_IFLS_RXSEL_QUARTER 
#define UART_FIFO_RX4_8 UART_IFLS_RXSEL_HALF    
#define UART_FIFO_RX6_8 UART_IFLS_RXSEL_THREEQU 

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

//*****************************************************************************
//
// Values that can be passed to UARTSetLINDelimiterLength().
//
//*****************************************************************************
#define UART_LIN_DELIM_LEN1BIT UART_LCRH_DELIM_LEN_1 
#define UART_LIN_DELIM_LEN2BIT UART_LCRH_DELIM_LEN_2 
#define UART_LIN_DELIM_LEN3BIT UART_LCRH_DELIM_LEN_3 
#define UART_LIN_DELIM_LEN4BIT UART_LCRH_DELIM_LEN_4 

//*****************************************************************************
//
// Values returned from UARTGetRxError().
//
//*****************************************************************************
#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 + UART_O_IFLS) = txLevel | rxLevel;
}

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

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

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

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableFIFO(uint32_t base)
{
    // Disable the FIFO.
    HWREG(base + UART_O_LCRH) &= ~(UART_LCRH_FEN);
}

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

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

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

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

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTPutCharNonBlocking(uint32_t base, uint8_t data)
{
    // Write this character to the transmit FIFO.
    HWREG(base + UART_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 + UART_O_FR) & UART_FR_BUSY) ? true : false);
}

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

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

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

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTClearInt(uint32_t base, uint32_t intFlags)
{
    // Clear the requested interrupt sources
    HWREG(base + UART_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 + UART_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 + UART_O_DMACTL) &= ~dmaFlags;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE uint32_t UARTGetRxError(uint32_t base)
{
    // Return the current value of the receive status register.
    return (HWREG(base + UART_O_RSR_ECR) & 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 + UART_O_RSR_ECR) = 0;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableCTS(uint32_t base)
{
    HWREG(base + UART_O_CTL) |= (UART_CTL_CTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableRTS(uint32_t base)
{
    HWREG(base + UART_O_CTL) |= (UART_CTL_RTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableCTS(uint32_t base)
{
    HWREG(base + UART_O_CTL) &= ~(UART_CTL_CTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableRTS(uint32_t base)
{
    HWREG(base + UART_O_CTL) &= ~(UART_CTL_RTSEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableLIN(uint32_t base)
{
    // Set the LINEN bit in the UART CTL register.
    HWREG(base + UART_O_CTL) |= UART_CTL_LINEN;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableLIN(uint32_t base)
{
    // Clear the LINEN bit in the UART CTL register.
    HWREG(base + UART_O_CTL) &= ~(UART_CTL_LINEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableLINDormant(uint32_t base)
{
    // Set the DORMEN bit in the UART CTL register.
    HWREG(base + UART_O_CTL) |= UART_CTL_DORMEN;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableLINDormant(uint32_t base)
{
    // Clear the DORMEN bit in the UART CTL register.
    HWREG(base + UART_O_CTL) &= ~(UART_CTL_DORMEN);
}

//*****************************************************************************
//
//
//*****************************************************************************
extern void UARTSetLINDelimiterLength(uint32_t base, uint32_t length);

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTEnableLINBreakSync(uint32_t base)
{
    HWREG(base + UART_O_LCRH) |= UART_LCRH_TXBRKSYNC;
}

//*****************************************************************************
//
//
//*****************************************************************************
__STATIC_INLINE void UARTDisableLINBreakSync(uint32_t base)
{
    HWREG(base + UART_O_LCRH) &= ~(UART_LCRH_TXBRKSYNC);
}
//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

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

#endif //  __UART_H__