fsl_flexio_uart.h

/*
 * Copyright (c) 2015-2016, Freescale Semiconductor, Inc.
 * Copyright 2016-2021 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_FLEXIO_UART_H_
#define _FSL_FLEXIO_UART_H_
 
#include "fsl_common.h"
#include "fsl_flexio.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_FLEXIO_UART_DRIVER_VERSION (MAKE_VERSION(2, 4, 0))
#ifndef UART_RETRY_TIMES
#define UART_RETRY_TIMES 0U /* Defining to zero means to keep waiting for the flag until it is assert/deassert. */
#endif
 
enum
{
    kStatus_FLEXIO_UART_TxBusy = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 0), 
    kStatus_FLEXIO_UART_RxBusy = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 1), 
    kStatus_FLEXIO_UART_TxIdle = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 2), 
    kStatus_FLEXIO_UART_RxIdle = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 3), 
    kStatus_FLEXIO_UART_ERROR  = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 4), 
    kStatus_FLEXIO_UART_RxRingBufferOverrun =
        MAKE_STATUS(kStatusGroup_FLEXIO_UART, 5), 
    kStatus_FLEXIO_UART_RxHardwareOverrun = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 6), 
    kStatus_FLEXIO_UART_Timeout           = MAKE_STATUS(kStatusGroup_FLEXIO_UART, 7), 
    kStatus_FLEXIO_UART_BaudrateNotSupport =
        MAKE_STATUS(kStatusGroup_FLEXIO_UART, 8) 
};
 
typedef enum _flexio_uart_bit_count_per_char
{
    kFLEXIO_UART_7BitsPerChar = 7U, 
    kFLEXIO_UART_8BitsPerChar = 8U, 
    kFLEXIO_UART_9BitsPerChar = 9U, 
} flexio_uart_bit_count_per_char_t;
 
enum _flexio_uart_interrupt_enable
{
    kFLEXIO_UART_TxDataRegEmptyInterruptEnable = 0x1U, 
    kFLEXIO_UART_RxDataRegFullInterruptEnable  = 0x2U, 
};
 
enum _flexio_uart_status_flags
{
    kFLEXIO_UART_TxDataRegEmptyFlag = 0x1U, 
    kFLEXIO_UART_RxDataRegFullFlag  = 0x2U, 
    kFLEXIO_UART_RxOverRunFlag      = 0x4U, 
};
 
typedef struct _flexio_uart_type
{
    FLEXIO_Type *flexioBase; 
    uint8_t TxPinIndex;      
    uint8_t RxPinIndex;      
    uint8_t shifterIndex[2]; 
    uint8_t timerIndex[2];   
} FLEXIO_UART_Type;
 
typedef struct _flexio_uart_config
{
    bool enableUart;                                  
    bool enableInDoze;                                
    bool enableInDebug;                               
    bool enableFastAccess;                            
    uint32_t baudRate_Bps;                            
    flexio_uart_bit_count_per_char_t bitCountPerChar; 
} flexio_uart_config_t;
 
typedef struct _flexio_uart_transfer
{
    /*
     * Use separate TX and RX data pointer, because TX data is const data.
     * The member data is kept for backward compatibility.
     */
    union
    {
        uint8_t *data;         
        uint8_t *rxData;       
        const uint8_t *txData; 
    };
    size_t dataSize; 
} flexio_uart_transfer_t;
 
/* Forward declaration of the handle typedef. */
typedef struct _flexio_uart_handle flexio_uart_handle_t;
 
typedef void (*flexio_uart_transfer_callback_t)(FLEXIO_UART_Type *base,
                                                flexio_uart_handle_t *handle,
                                                status_t status,
                                                void *userData);
 
struct _flexio_uart_handle
{
    const uint8_t *volatile txData; 
    volatile size_t txDataSize;     
    uint8_t *volatile rxData;       
    volatile size_t rxDataSize;     
    size_t txDataSizeAll;           
    size_t rxDataSizeAll;           
    uint8_t *rxRingBuffer;              
    size_t rxRingBufferSize;            
    volatile uint16_t rxRingBufferHead; 
    volatile uint16_t rxRingBufferTail; 
    flexio_uart_transfer_callback_t callback; 
    void *userData;                           
    volatile uint8_t txState; 
    volatile uint8_t rxState; 
};
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/
 
status_t FLEXIO_UART_Init(FLEXIO_UART_Type *base, const flexio_uart_config_t *userConfig, uint32_t srcClock_Hz);
 
void FLEXIO_UART_Deinit(FLEXIO_UART_Type *base);
 
void FLEXIO_UART_GetDefaultConfig(flexio_uart_config_t *userConfig);
 
/* @} */
 
uint32_t FLEXIO_UART_GetStatusFlags(FLEXIO_UART_Type *base);
 
void FLEXIO_UART_ClearStatusFlags(FLEXIO_UART_Type *base, uint32_t mask);
 
/* @} */
 
void FLEXIO_UART_EnableInterrupts(FLEXIO_UART_Type *base, uint32_t mask);
 
void FLEXIO_UART_DisableInterrupts(FLEXIO_UART_Type *base, uint32_t mask);
 
/* @} */
 
static inline uint32_t FLEXIO_UART_GetTxDataRegisterAddress(FLEXIO_UART_Type *base)
{
    return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBuffer, base->shifterIndex[0]);
}
 
static inline uint32_t FLEXIO_UART_GetRxDataRegisterAddress(FLEXIO_UART_Type *base)
{
    return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBufferByteSwapped, base->shifterIndex[1]);
}
 
static inline void FLEXIO_UART_EnableTxDMA(FLEXIO_UART_Type *base, bool enable)
{
    FLEXIO_EnableShifterStatusDMA(base->flexioBase, 1UL << base->shifterIndex[0], enable);
}
 
static inline void FLEXIO_UART_EnableRxDMA(FLEXIO_UART_Type *base, bool enable)
{
    FLEXIO_EnableShifterStatusDMA(base->flexioBase, 1UL << base->shifterIndex[1], enable);
}
 
/* @} */
 
static inline void FLEXIO_UART_Enable(FLEXIO_UART_Type *base, bool enable)
{
    if (enable)
    {
        base->flexioBase->CTRL |= FLEXIO_CTRL_FLEXEN_MASK;
    }
}
 
static inline void FLEXIO_UART_WriteByte(FLEXIO_UART_Type *base, const uint8_t *buffer)
{
    base->flexioBase->SHIFTBUF[base->shifterIndex[0]] = *buffer;
}
 
static inline void FLEXIO_UART_ReadByte(FLEXIO_UART_Type *base, uint8_t *buffer)
{
    *buffer = (uint8_t)(base->flexioBase->SHIFTBUFBYS[base->shifterIndex[1]]);
}
 
status_t FLEXIO_UART_WriteBlocking(FLEXIO_UART_Type *base, const uint8_t *txData, size_t txSize);
 
status_t FLEXIO_UART_ReadBlocking(FLEXIO_UART_Type *base, uint8_t *rxData, size_t rxSize);
 
/* @} */
 
status_t FLEXIO_UART_TransferCreateHandle(FLEXIO_UART_Type *base,
                                          flexio_uart_handle_t *handle,
                                          flexio_uart_transfer_callback_t callback,
                                          void *userData);
 
void FLEXIO_UART_TransferStartRingBuffer(FLEXIO_UART_Type *base,
                                         flexio_uart_handle_t *handle,
                                         uint8_t *ringBuffer,
                                         size_t ringBufferSize);
 
void FLEXIO_UART_TransferStopRingBuffer(FLEXIO_UART_Type *base, flexio_uart_handle_t *handle);
 
status_t FLEXIO_UART_TransferSendNonBlocking(FLEXIO_UART_Type *base,
                                             flexio_uart_handle_t *handle,
                                             flexio_uart_transfer_t *xfer);
 
void FLEXIO_UART_TransferAbortSend(FLEXIO_UART_Type *base, flexio_uart_handle_t *handle);
 
status_t FLEXIO_UART_TransferGetSendCount(FLEXIO_UART_Type *base, flexio_uart_handle_t *handle, size_t *count);
 
status_t FLEXIO_UART_TransferReceiveNonBlocking(FLEXIO_UART_Type *base,
                                                flexio_uart_handle_t *handle,
                                                flexio_uart_transfer_t *xfer,
                                                size_t *receivedBytes);
 
void FLEXIO_UART_TransferAbortReceive(FLEXIO_UART_Type *base, flexio_uart_handle_t *handle);
 
status_t FLEXIO_UART_TransferGetReceiveCount(FLEXIO_UART_Type *base, flexio_uart_handle_t *handle, size_t *count);
 
void FLEXIO_UART_TransferHandleIRQ(void *uartType, void *uartHandle);
 
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
#endif /*_FSL_FLEXIO_UART_H_*/