572 lines
22 KiB
C
572 lines
22 KiB
C
|
/**
|
||
|
|
* @file hal_uart.h
|
||
|
|
* @author XRADIO IOT WLAN Team
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Copyright (C) 2017 XRADIO TECHNOLOGY CO., LTD. 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 XRADIO TECHNOLOGY CO., LTD. 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
|
||
|
|
* OWNER 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 _DRIVER_CHIP_HAL_UART_H_
|
||
|
|
#define _DRIVER_CHIP_HAL_UART_H_
|
||
|
|
|
||
|
|
#include "driver/chip/hal_def.h"
|
||
|
|
#include "driver/chip/hal_dma.h"
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
extern "C" {
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifndef CONFIG_BOOTLOADER
|
||
|
|
#define HAL_UART_OPT_IT 1 /* support interrupt mode */
|
||
|
|
#define HAL_UART_OPT_DMA 1 /* support DMA mode */
|
||
|
|
#else
|
||
|
|
#define HAL_UART_OPT_IT 0 /* support interrupt mode */
|
||
|
|
#define HAL_UART_OPT_DMA 0 /* support DMA mode */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief UART ID definition
|
||
|
|
*/
|
||
|
|
typedef enum {
|
||
|
|
UART0_ID = 0U,
|
||
|
|
UART1_ID,
|
||
|
|
#if (CONFIG_CHIP_ARCH_VER > 1)
|
||
|
|
UART2_ID,
|
||
|
|
#endif
|
||
|
|
UART_NUM,
|
||
|
|
UART_INVALID_ID = 0xFFU
|
||
|
|
} UART_ID;
|
||
|
|
|
||
|
|
typedef enum {
|
||
|
|
UART_Pin_USER_UART = 0,
|
||
|
|
UART_Pin_USER_LPUART = 1,
|
||
|
|
UART_Pin_USER_NUM = 2
|
||
|
|
} UART_Pin_User;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief UART register block structure
|
||
|
|
*/
|
||
|
|
typedef struct {
|
||
|
|
union {
|
||
|
|
__I uint32_t RX_BUF; /* offset: 0x00, UART receive buffer register, 8-bit valid, RO */
|
||
|
|
__O uint32_t TX_HOLD; /* offset: 0x00, UART transmit holding register, 8-bit valid, WO */
|
||
|
|
__IO uint32_t DIV_LOW; /* offset: 0x00, UART divisor latch low register, 8-bit valid, R/W */
|
||
|
|
} RBR_THR_DLL; /* offset: 0x00, UART receive buffer/transmit holding/divisor latch low register */
|
||
|
|
union {
|
||
|
|
__IO uint32_t DIV_HIGH; /* offset: 0x04, UART divisor latch high register, 8-bit valid, R/W */
|
||
|
|
__IO uint32_t IRQ_EN; /* offset: 0x04, UART interrupt enable register, R/W */
|
||
|
|
} DLH_IER; /* offset: 0x04, UART divisor latch high/IRQ enable register */
|
||
|
|
union {
|
||
|
|
__I uint32_t IRQ_ID; /* offset: 0x08, UART interrupt identity register, RO */
|
||
|
|
__O uint32_t FIFO_CTRL; /* offset: 0x08, UART FIFO control register, WO */
|
||
|
|
} IIR_FCR; /* offset: 0x08, UART interrupt identity/FIFO control register */
|
||
|
|
__IO uint32_t LINE_CTRL; /* offset: 0x0C, UART line control register */
|
||
|
|
__IO uint32_t MODEM_CTRL; /* offset: 0x10, UART modem control register */
|
||
|
|
__I uint32_t LINE_STATUS; /* offset: 0x14, UART line status register */
|
||
|
|
__I uint32_t MODEM_STATUS; /* offset: 0x18, UART modem stauts register */
|
||
|
|
__IO uint32_t SCRATCH; /* offset: 0x1C, UART scratch register */
|
||
|
|
uint32_t RESERVED1[23];
|
||
|
|
__I uint32_t STATUS; /* offset: 0x7C, UART status register */
|
||
|
|
__I uint32_t TX_FIFO_LEVEL; /* offset: 0x80, UART transmit FIFO level register */
|
||
|
|
__I uint32_t RX_FIFO_LEVEL; /* offset: 0x84, UART receive FIFO level register */
|
||
|
|
uint32_t RESERVED2[7];
|
||
|
|
__IO uint32_t HALT; /* offset: 0xA4, UART halt register */
|
||
|
|
uint32_t RESERVED3[9];
|
||
|
|
__IO uint32_t TX_DELAY; /* offset: 0xCC, UART TX delay register */
|
||
|
|
uint32_t RESERVED4[1];
|
||
|
|
__IO uint32_t BAUD_DECT_CTRL; /* offset: 0xD4, UART baudrate detection control register */
|
||
|
|
__IO uint32_t BAUD_DECT_VAL_LOW; /* offset: 0xD8, UART baudrate detection counter low register */
|
||
|
|
__IO uint32_t BAUD_DECT_VAL_HIGH; /* offset: 0xDC, UART baudrate detection counter high register */
|
||
|
|
} UART_T;
|
||
|
|
|
||
|
|
#define UART0 ((UART_T *)UART0_BASE) /* address: 0x40040C00 */
|
||
|
|
#define UART1 ((UART_T *)UART1_BASE) /* address: 0x40041000 */
|
||
|
|
#if (CONFIG_CHIP_ARCH_VER > 1)
|
||
|
|
#define UART2 ((UART_T *)UART2_BASE) /* address: 0x40041400 */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/* UARTx->RBR_THR_DLL.RX_BUF, R */
|
||
|
|
#define UART_RX_DATA_MASK 0xFFU
|
||
|
|
|
||
|
|
/* UARTx->RBR_THR_DLL.TX_HOLD, W */
|
||
|
|
#define UART_TX_DATA_MASK 0xFFU
|
||
|
|
|
||
|
|
/* UARTx->RBR_THR_DLL.DIV_LOW, R/W */
|
||
|
|
#define UART_DIV_LOW_MASK 0xFFU
|
||
|
|
|
||
|
|
/* UARTx->DLH_IER.DIV_HIGH, R/W */
|
||
|
|
#define UART_DIV_HIGH_MASK 0xFFU
|
||
|
|
|
||
|
|
/* UARTx->DLH_IER.IRQ_EN, R/W */
|
||
|
|
#define UART_TX_FIFO_TRIG_MODE_EN_BIT HAL_BIT(7)
|
||
|
|
#define UART_RS485_IRQ_EN_BIT HAL_BIT(4)
|
||
|
|
#define UART_MODEM_STATUS_IRQ_EN_BIT HAL_BIT(3)
|
||
|
|
#define UART_LINE_STATUS_IRQ_EN_BIT HAL_BIT(2)
|
||
|
|
#define UART_TX_READY_IRQ_EN_BIT HAL_BIT(1)
|
||
|
|
#define UART_RX_READY_IRQ_EN_BIT HAL_BIT(0)
|
||
|
|
|
||
|
|
/* UARTx->IIR_FCR.IRQ_ID, R */
|
||
|
|
#define UART_IID_SHIFT 0
|
||
|
|
#define UART_IID_MASK (0xFU << UART_IID_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_IID_MODEM_STATUS = (0x0U << UART_IID_SHIFT),
|
||
|
|
UART_IID_NONE = (0x1U << UART_IID_SHIFT),
|
||
|
|
UART_IID_TX_READY = (0x2U << UART_IID_SHIFT),
|
||
|
|
UART_IID_RS485 = (0x3U << UART_IID_SHIFT),
|
||
|
|
UART_IID_RX_READY = (0x4U << UART_IID_SHIFT),
|
||
|
|
UART_IID_LINE_STATUS = (0x6U << UART_IID_SHIFT),
|
||
|
|
UART_IID_BUSY_DETECT = (0x7U << UART_IID_SHIFT),
|
||
|
|
UART_IID_CHAR_TIMEOUT = (0xCU << UART_IID_SHIFT),
|
||
|
|
} UART_IIDType;
|
||
|
|
|
||
|
|
/* UARTx->IIR_FCR.FIFO_CTRL, W */
|
||
|
|
#define UART_RX_FIFO_TRIG_LEVEL_SHIFT 6
|
||
|
|
#define UART_RX_FIFO_TRIG_LEVEL_MASK (0x3 << UART_RX_FIFO_TRIG_LEVEL_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_RX_FIFO_TRIG_LEVEL_ONE_CHAR = (0x0 << UART_RX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
UART_RX_FIFO_TRIG_LEVEL_QUARTER_FULL = (0x1 << UART_RX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
UART_RX_FIFO_TRIG_LEVEL_HALF_FULL = (0x2 << UART_RX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
UART_RX_FIFO_TRIG_LEVEL_NEARLY_FULL = (0x3 << UART_RX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
} UART_RxFifoTrigLevel;
|
||
|
|
|
||
|
|
#define UART_TX_FIFO_TRIG_LEVEL_SHIFT 4
|
||
|
|
#define UART_TX_FIFO_TRIG_LEVEL_MASK (0x3 << UART_TX_FIFO_TRIG_LEVEL_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_TX_FIFO_TRIG_LEVEL_EMPTY = (0x0 << UART_TX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
UART_TX_FIFO_TRIG_LEVEL_TWO_CHAR = (0x1 << UART_TX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
UART_TX_FIFO_TRIG_LEVEL_QUARTER_FULL = (0x2 << UART_TX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
UART_TX_FIFO_TRIG_LEVEL_HALF_FULL = (0x3 << UART_TX_FIFO_TRIG_LEVEL_SHIFT),
|
||
|
|
} UART_TxFifoTrigLevel;
|
||
|
|
|
||
|
|
#define UART_DMA_MODE_SHIFT 3
|
||
|
|
#define UART_DMA_MODE_MASK (1U << UART_DMA_MODE_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_DMA_MODE_0 = (0U << UART_DMA_MODE_SHIFT),
|
||
|
|
UART_DMA_MODE_1 = (1U << UART_DMA_MODE_SHIFT)
|
||
|
|
} UART_DMAMode;
|
||
|
|
|
||
|
|
#define UART_TX_FIFO_RESET_BIT HAL_BIT(2)
|
||
|
|
#define UART_RX_FIFO_RESET_BIT HAL_BIT(1)
|
||
|
|
#define UART_FIFO_EN_BIT HAL_BIT(0)
|
||
|
|
|
||
|
|
/* UARTx->LINE_CTRL, R/W */
|
||
|
|
#define UART_DIV_ACCESS_BIT HAL_BIT(7)
|
||
|
|
#define UART_BREAK_CTRL_BIT HAL_BIT(6)
|
||
|
|
|
||
|
|
#define UART_PARITY_EN_BIT HAL_BIT(3)
|
||
|
|
#define UART_PARITY_SEL_SHIFT 4
|
||
|
|
#define UART_PARITY_SEL_MASK (0x3U << UART_PARITY_SEL_SHIFT)
|
||
|
|
#define UART_PARITY_MASK (UART_PARITY_EN_BIT | UART_PARITY_SEL_MASK)
|
||
|
|
typedef enum {
|
||
|
|
UART_PARITY_NONE = 0U,
|
||
|
|
UART_PARITY_ODD = UART_PARITY_EN_BIT | (0x0U << UART_PARITY_SEL_SHIFT),
|
||
|
|
UART_PARITY_EVEN = UART_PARITY_EN_BIT | (0x1U << UART_PARITY_SEL_SHIFT)
|
||
|
|
} UART_Parity;
|
||
|
|
|
||
|
|
#define UART_STOP_BITS_SHIFT 2
|
||
|
|
#define UART_STOP_BITS_MASK (0x1U << UART_STOP_BITS_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_STOP_BITS_1 = (0x0U << UART_STOP_BITS_SHIFT),
|
||
|
|
UART_STOP_BITS_2 = (0x1U << UART_STOP_BITS_SHIFT)
|
||
|
|
} UART_StopBits; /* UART_STOP_BITS_2 is 1.5 stop bits for UART_DATA_BITS_5 */
|
||
|
|
|
||
|
|
#define UART_DATA_BITS_SHIFT 0
|
||
|
|
#define UART_DATA_BITS_MASK (0x3U << UART_DATA_BITS_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_DATA_BITS_5 = (0x0U << UART_DATA_BITS_SHIFT),
|
||
|
|
UART_DATA_BITS_6 = (0x1U << UART_DATA_BITS_SHIFT),
|
||
|
|
UART_DATA_BITS_7 = (0x2U << UART_DATA_BITS_SHIFT),
|
||
|
|
UART_DATA_BITS_8 = (0x3U << UART_DATA_BITS_SHIFT)
|
||
|
|
} UART_DataBits;
|
||
|
|
|
||
|
|
/* UARTx->MODEM_CTRL, R/W */
|
||
|
|
#define UART_WORK_MODE_SHIFT 6
|
||
|
|
#define UART_WORK_MODE_MASK (0x3U << UART_WORK_MODE_SHIFT)
|
||
|
|
typedef enum {
|
||
|
|
UART_WORK_MODE_UART = (0x0U << UART_WORK_MODE_SHIFT),
|
||
|
|
UART_WORK_MODE_IRDA = (0x1U << UART_WORK_MODE_SHIFT),
|
||
|
|
UART_WORK_MODE_RS485 = (0x2U << UART_WORK_MODE_SHIFT),
|
||
|
|
} UART_WorkMode;
|
||
|
|
|
||
|
|
#define UART_AUTO_FLOW_CTRL_EN_BIT HAL_BIT(5)
|
||
|
|
#define UART_LOOP_BACK_EN_BIT HAL_BIT(4)
|
||
|
|
#define UART_RTS_ASSERT_BIT HAL_BIT(1)
|
||
|
|
#define UART_DTR_ASSERT_BIT HAL_BIT(0)
|
||
|
|
|
||
|
|
/* UARTx->LINE_STATUS, R */
|
||
|
|
#define UART_FIFO_ERROR_BIT HAL_BIT(7)
|
||
|
|
#define UART_TX_EMPTY_BIT HAL_BIT(6)
|
||
|
|
#define UART_TX_HOLD_EMPTY_BIT HAL_BIT(5)
|
||
|
|
#define UART_BREAK_IRQ_BIT HAL_BIT(4)
|
||
|
|
#define UART_FRAME_ERROR_BIT HAL_BIT(3)
|
||
|
|
#define UART_PARITY_ERROR_BIT HAL_BIT(2)
|
||
|
|
#define UART_OVERRUN_ERROR_BIT HAL_BIT(1)
|
||
|
|
#define UART_RX_READY_BIT HAL_BIT(0)
|
||
|
|
#define UART_LINE_STATUS_MASK 0xFFU
|
||
|
|
|
||
|
|
/* UARTx->MODEM_STATUS, R */
|
||
|
|
#define UART_CTS_ASSERTED_BIT HAL_BIT(4)
|
||
|
|
#define UART_DELTA_CTS_BIT HAL_BIT(0)
|
||
|
|
#define UART_MODEM_STATUS_MASK 0xF3U
|
||
|
|
|
||
|
|
/* UARTx->STATUS, R */
|
||
|
|
#define UART_RX_FIFO_FULL_BIT HAL_BIT(4)
|
||
|
|
#define UART_RX_FIFO_NOT_EMPTY_BIT HAL_BIT(3)
|
||
|
|
#define UART_TX_FIFO_EMPTY_BIT HAL_BIT(2)
|
||
|
|
#define UART_TX_FIFO_NOT_FULL_BIT HAL_BIT(1)
|
||
|
|
#define UART_BUSY_BIT HAL_BIT(0)
|
||
|
|
#define UART_STATUS_MASK 0x1FU
|
||
|
|
|
||
|
|
/* UARTx->TX_FIFO_LEVEL, R */
|
||
|
|
#define UART_TX_FIFO_LEVEL_SHIFT 0
|
||
|
|
#define UART_TX_FIFO_LEVEL_VMASK 0x7FU
|
||
|
|
|
||
|
|
/* UARTx->RX_FIFO_LEVEL, R */
|
||
|
|
#define UART_RX_FIFO_LEVEL_SHIFT 0
|
||
|
|
#define UART_RX_FIFO_LEVEL_VMASK 0x7FU
|
||
|
|
|
||
|
|
/* UARTx->HALT, R/W */
|
||
|
|
#define UART_DMA_PTE_RX_BIT HAL_BIT(7)
|
||
|
|
#define UART_DMA_PTE_TX_BIT HAL_BIT(6)
|
||
|
|
|
||
|
|
#define UART_CHANGE_UPDATE_BIT HAL_BIT(2)
|
||
|
|
#define UART_CHANGE_AT_BUSY_BIT HAL_BIT(1)
|
||
|
|
|
||
|
|
#define UART_HALT_TX_EN_BIT HAL_BIT(0)
|
||
|
|
|
||
|
|
/* UARTx->TX_DELAY, R/W */
|
||
|
|
#define UART_TX_DELAY_SHIFT 0
|
||
|
|
#define UART_TX_DELAY_VMASK 0xFFU
|
||
|
|
#define UART_TX_DELAY_MASK (UART_TX_DELAY_VMASK << UART_TX_DELAY_SHIFT)
|
||
|
|
|
||
|
|
/******************************************************************************/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief UART initialization parameters
|
||
|
|
*/
|
||
|
|
typedef struct {
|
||
|
|
uint32_t baudRate; /* Baud rate, in bps */
|
||
|
|
UART_Parity parity; /* Parity */
|
||
|
|
UART_StopBits stopBits; /* Stop bits */
|
||
|
|
UART_DataBits dataBits; /* Data bits */
|
||
|
|
int8_t isAutoHwFlowCtrl; /* Enable auto hardware flow control or not */
|
||
|
|
} UART_InitParam;
|
||
|
|
|
||
|
|
#if HAL_UART_OPT_IT
|
||
|
|
/** @brief Type define of UART receive ready callback function */
|
||
|
|
typedef void (*UART_RxReadyCallback) (void *arg);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Get UART hardware instance by the specified UART ID
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @return UART hardware instance
|
||
|
|
*/
|
||
|
|
UART_T *HAL_UART_GetInstance(UART_ID uartID);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Check whether the specified UART can transmit data or not
|
||
|
|
* @param[in] uart UART hardware instance
|
||
|
|
* @return 1 The UART can transmit data
|
||
|
|
* @return 0 The UART cannot transmit data
|
||
|
|
*/
|
||
|
|
int HAL_UART_IsTxReady(UART_T *uart);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Check whether the transmit FIFO of the specified UART is empty or not
|
||
|
|
* @param[in] uart UART hardware instance
|
||
|
|
* @return 1 The UART transmit FIFO is empty
|
||
|
|
* @return 0 The UART transmit FIFO is not empty
|
||
|
|
*/
|
||
|
|
int HAL_UART_IsTxEmpty(UART_T *uart);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Check whether the specified UART has receive data or not
|
||
|
|
* @param[in] uart UART hardware instance
|
||
|
|
* @return 1 The UART has receive data
|
||
|
|
* @return 0 The UART has no receive data
|
||
|
|
*/
|
||
|
|
int HAL_UART_IsRxReady(UART_T *uart);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Get one byte received data of the specified UART
|
||
|
|
* @param[in] uart UART hardware instance
|
||
|
|
* @return One byte received data
|
||
|
|
*
|
||
|
|
* @note Before calling this function, make sure the specified UART has
|
||
|
|
* receive data by calling HAL_UART_IsRxReady()
|
||
|
|
*/
|
||
|
|
uint8_t HAL_UART_GetRxData(UART_T *uart);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Transmit one byte data for the specified UART
|
||
|
|
* @param[in] uart UART hardware instance
|
||
|
|
* @param[in] data one byte data
|
||
|
|
* @return None
|
||
|
|
*
|
||
|
|
* @note Before calling this function, make sure the specified UART can
|
||
|
|
* transmit data by calling HAL_UART_IsTxReady()
|
||
|
|
*/
|
||
|
|
void HAL_UART_PutTxData(UART_T *uart, uint8_t data);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Initialize the UART according to the specified parameters
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] param Pointer to UART_InitParam structure
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_Init(UART_ID uartID, const UART_InitParam *param);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief DeInitialize the specified UART
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_DeInit(UART_ID uartID);
|
||
|
|
|
||
|
|
#if HAL_UART_OPT_IT
|
||
|
|
/**
|
||
|
|
* @brief Transmit an amount of data in interrupt mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] buf Pointer to the data buffer
|
||
|
|
* @param[in] size Number of bytes to be transmitted
|
||
|
|
* @return Number of bytes transmitted, -1 on error
|
||
|
|
*
|
||
|
|
* @note This function is not thread safe. If using the UART transmit series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
*/
|
||
|
|
int32_t HAL_UART_Transmit_IT(UART_ID uartID, const uint8_t *buf, int32_t size);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Receive an amount of data in interrupt mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[out] buf Pointer to the data buffer
|
||
|
|
* @param[in] size The maximum number of bytes to be received.
|
||
|
|
* The actual received bytes can be less than this.
|
||
|
|
* @param[in] msec Timeout value in millisecond to receive data.
|
||
|
|
* HAL_WAIT_FOREVER for no timeout.
|
||
|
|
* @return Number of bytes received, -1 on error
|
||
|
|
*
|
||
|
|
* @note This function is not thread safe. If using the UART receive series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
*/
|
||
|
|
int32_t HAL_UART_Receive_IT(UART_ID uartID, uint8_t *buf, int32_t size, uint32_t msec);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Enable receive ready callback function for the specified UART
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] cb The UART receive ready callback function
|
||
|
|
* @param[in] arg Argument of the UART receive ready callback function
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*
|
||
|
|
* @note To handle receive data externally, use this function to enable the
|
||
|
|
* receive ready callback function, then receive and process the data in
|
||
|
|
* the callback function.
|
||
|
|
* @note If the receive ready callback function is enabled, all other receive
|
||
|
|
* series functions cannot be used to receive data.
|
||
|
|
* @note This function is not thread safe. If using the UART receive series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_EnableRxCallback(UART_ID uartID, UART_RxReadyCallback cb, void *arg);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Disable receive ready callback function for the specified UART
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_DisableRxCallback(UART_ID uartID);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#if HAL_UART_OPT_DMA
|
||
|
|
HAL_Status HAL_UART_InitTxDMA(UART_ID uartID, const DMA_ChannelInitParam *param);
|
||
|
|
HAL_Status HAL_UART_InitRxDMA(UART_ID uartID, const DMA_ChannelInitParam *param);
|
||
|
|
HAL_Status HAL_UART_DeInitTxDMA(UART_ID uartID);
|
||
|
|
HAL_Status HAL_UART_DeInitRxDMA(UART_ID uartID);
|
||
|
|
HAL_Status HAL_UART_StartTransmit_DMA(UART_ID uartID, const uint8_t *buf, int32_t size);
|
||
|
|
int32_t HAL_UART_StopTransmit_DMA(UART_ID uartID);
|
||
|
|
HAL_Status HAL_UART_StartReceive_DMA(UART_ID uartID, uint8_t *buf, int32_t size);
|
||
|
|
int32_t HAL_UART_StopReceive_DMA(UART_ID uartID);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Enable UART transmitting data in DMA mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @retval HAL_Status, HAL_OK on success, HAL_ERROR on no valid DMA channel
|
||
|
|
*
|
||
|
|
* @note To transmit data in DMA mode, a DMA channel for the specified
|
||
|
|
* UART to transmit data MUST be configured first by this function.
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_EnableTxDMA(UART_ID uartID);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Enable UART receiving data in DMA mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @retval HAL_Status, HAL_OK on success, HAL_ERROR on no valid DMA channel
|
||
|
|
*
|
||
|
|
* @note To reveive data in DMA mode, a DMA channel for the specified
|
||
|
|
* UART to receive data MUST be configured first by this function.
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_EnableRxDMA(UART_ID uartID);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Disable UART transmitting data in DMA mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_DisableTxDMA(UART_ID uartID);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Disable UART receiving data in DMA mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_DisableRxDMA(UART_ID uartID);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Transmit an amount of data in DMA mode
|
||
|
|
*
|
||
|
|
* Steps to transmit data in DMA mode:
|
||
|
|
* - use HAL_UART_EnableTxDMA() to enable UART transmit DMA mode
|
||
|
|
* - use HAL_UART_Transmit_DMA() to transmit data, it can be called
|
||
|
|
* repeatedly after HAL_UART_EnableTxDMA()
|
||
|
|
* - use HAL_UART_DisableTxDMA() to disable UART transmit DMA mode if needed
|
||
|
|
*
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] buf Pointer to the data buffer
|
||
|
|
* @param[in] size Number of bytes to be transmitted
|
||
|
|
* @return Number of bytes transmitted, -1 on error
|
||
|
|
*
|
||
|
|
* @note This function is not thread safe. If using the UART transmit series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
* @note To transmit data in DMA mode, HAL_UART_EnableTxDMA() MUST be executed
|
||
|
|
* before calling this function.
|
||
|
|
*/
|
||
|
|
int32_t HAL_UART_Transmit_DMA(UART_ID uartID, const uint8_t *buf, int32_t size);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Receive an amount of data in DMA mode
|
||
|
|
*
|
||
|
|
* Steps to receive data in DMA mode:
|
||
|
|
* - use HAL_UART_EnableRxDMA() to enable UART receive DMA mode
|
||
|
|
* - use HAL_UART_Receive_DMA() to receive data, it can be called
|
||
|
|
* repeatedly after HAL_UART_EnableRxDMA()
|
||
|
|
* - use HAL_UART_DisableRxDMA() to disable UART receive DMA mode if needed
|
||
|
|
*
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[out] buf Pointer to the data buffer
|
||
|
|
* @param[in] size The maximum number of bytes to be received.
|
||
|
|
* The actual received bytes can be less than this.
|
||
|
|
* @param[in] msec Timeout value in millisecond to receive data.
|
||
|
|
* HAL_WAIT_FOREVER for no timeout.
|
||
|
|
* @return Number of bytes received, -1 on error
|
||
|
|
*
|
||
|
|
* @note This function is not thread safe. If using the UART receive series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
* @note To receive data in DMA mode, HAL_UART_EnableRxDMA() MUST be executed
|
||
|
|
* before calling this function.
|
||
|
|
*/
|
||
|
|
int32_t HAL_UART_Receive_DMA(UART_ID uartID, uint8_t *buf, int32_t size, uint32_t msec);
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Transmit an amount of data in polling mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] buf Pointer to the data buffer
|
||
|
|
* @param[in] size Number of bytes to be transmitted
|
||
|
|
* @param[in] sleep when tx no ready
|
||
|
|
* @return Number of bytes transmitted, -1 on error
|
||
|
|
*
|
||
|
|
* @note This function is not thread safe. If using the UART transmit series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
*/
|
||
|
|
int32_t HAL_UART_Transmit_PollRaw(UART_ID uartID, const uint8_t *buf, int32_t size, int32_t sleep);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Receive an amount of data in polling mode
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[out] buf Pointer to the data buffer
|
||
|
|
* @param[in] size The maximum number of bytes to be received.
|
||
|
|
* The actual received bytes can be less than this.
|
||
|
|
* @param[in] msec Timeout value in millisecond to receive data.
|
||
|
|
* HAL_WAIT_FOREVER for no timeout.
|
||
|
|
* @return Number of bytes received, -1 on error
|
||
|
|
*
|
||
|
|
* @note This function is not thread safe. If using the UART receive series
|
||
|
|
* functions in multi-thread, make sure they are executed exclusively.
|
||
|
|
*/
|
||
|
|
int32_t HAL_UART_Receive_Poll(UART_ID uartID, uint8_t *buf, int32_t size, uint32_t msec);
|
||
|
|
|
||
|
|
__STATIC_INLINE int32_t HAL_UART_Transmit_Poll(UART_ID uartID, const uint8_t *buf, int32_t size)
|
||
|
|
{
|
||
|
|
return HAL_UART_Transmit_PollRaw(uartID, buf, size, 0);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Start or stop to transmit break characters
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] isSet
|
||
|
|
* @arg !0 Start to transmit break characters
|
||
|
|
* @arg 0 Stop to transmit break characters
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_SetBreakCmd(UART_ID uartID, int8_t isSet);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Set PM mode to be bypassed
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] mode Bit mask of PM mode to be bypassed
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_SetBypassPmMode(UART_ID uartID, uint8_t mode);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Set the UART's configuration according to the specified parameters
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] param Pointer to UART_InitParam structure
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_SetConfig(UART_ID uartID, const UART_InitParam *param);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @brief Set the delay parameter between two transmitting bytes
|
||
|
|
* @param[in] uartID ID of the specified UART
|
||
|
|
* @param[in] txDelay The delay parameter between two transmitting bytes
|
||
|
|
* @retval HAL_Status, HAL_OK on success
|
||
|
|
*/
|
||
|
|
HAL_Status HAL_UART_SetTxDelay(UART_ID uartID, uint8_t txDelay);
|
||
|
|
|
||
|
|
void HAL_UART_SetPinmuxStatus(uint8_t uartID, UART_Pin_User user);
|
||
|
|
void HAL_UART_ClrPinmuxStatus(uint8_t uartID, UART_Pin_User user);
|
||
|
|
uint32_t HAL_UART_GetPinmuxStatus(uint8_t uartID);
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#endif /* _DRIVER_CHIP_HAL_UART_H_ */
|