/**
  ******************************************************************************
  * @file     xl_uart.c
  * @author   Kirk 
  * @version  4.5.2
  * @date     Fri Mar 26 17:29:12 2021
  * @brief    This file provide function about UART firmware program 
  ******************************************************************************
  * @attention
  *
  * 2019 by Chipways Communications,Inc. All Rights Reserved.
  * This software is supplied under the terms of a license
  * agreement or non-disclosure agreement with Chipways.
  * Passing on and copying of this document,and communication
  * of its contents is not permitted without prior written
  * authorization.
  *
  * <h2><center>&copy; COPYRIGHT 2019 Chipways</center></h2>
  ******************************************************************************
  */
#if defined(__cplusplus)
extern "C" {
#endif
/* Includes ---------------------------------------------------------------*/
#include "xl_uart.h"

/** @addtogroup XL6600_StdPeriph_Driver
  * @{
  */

/** @defgroup UART UART Module
  * @brief UART Driver Modules Library
  * @{
  */

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/	
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

/** @defgroup UART_Private_Functions
  * @brief 
  * @{
  */ 

/**
  * @brief  ÅäÖÃUARTxÍâÉè¼Ä´æÆ÷ΪĬÈÏÖµ
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
	*		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval None
  */
void UART_DeInit(UART_Type* UARTx)
{
	/* Deinitializes to default reset values */
	UARTx->LCR = 0x00;
	UARTx->DLH = 0x00;
	UARTx->DLL = 0x00;
	UARTx->SGW = 0x00;
}

/**
  * @brief  ÅäÖÃUARTxͨѶ²¨ÌØÂÊ£¬¾²Ì¬º¯Êý
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  SourceClk: ÍâÉèʱÖÓƵÂÊ
  * @param  BaudRate: ͨѶ²¨ÌØÂÊ
  * @retval None
  */
static void UART_SetBaudRate(UART_Type *UARTx, uint32_t SourceClk, uint32_t BaudRate)
{
    uint32_t DivisorLatch;
	uint32_t Fractional;
	  
	/* the serial clock frequency divided by sixteen times the value of the baud rate divisor */
	DivisorLatch=(SourceClk>>4u)/BaudRate;
	Fractional =(((SourceClk>>4u) - (BaudRate*DivisorLatch))<<4u)/BaudRate;
	
	/* Divisor Latch Low */
	UARTx->DLL=DivisorLatch;
	
	/* Divisor Latch High */
	UARTx->DLH=DivisorLatch>>8u;
	
	UARTx->DLF = Fractional;
}

/**
  * @brief  ¸ù¾ÝUART_InitStructÖÐÖ¸¶¨µÄ²ÎÊý³õʼ»¯UARTxÍâÉè
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_InitStruct: UART³õʼ»¯ÅäÖýṹÌå
  * @retval None
  */
void UART_Init(UART_Type* UARTx, const UART_InitTypeDef* UART_InitStruct)
{
	uint32_t temp;
	uint32_t temp1;
	/* set the DLAB bit (LCR[7]) */
	UARTx->LCR |= UART_LCR_DLAB_MASK;
	
	/* Set the baudrate */
	UART_SetBaudRate(UARTx,UART_InitStruct->UART_SourceClk,UART_InitStruct->UART_BaudRate);

	
	temp1 = UARTx->LCR;
	
	temp1 &= ~UART_LCR_DLAB_MASK;
	
	temp1 |= ((uint32_t)UART_InitStruct->UART_DataLength | (uint32_t)UART_InitStruct->UART_StopBits | (uint32_t)UART_InitStruct->UART_Parity);
	
	UARTx->LCR = temp1;
	
	temp = UARTx->FCR;
	
	/* first clear the TET and RT bit */
	temp &= ~(UART_FCR_RT_MASK | UART_FCR_TET_MASK);

	/* select the empty threshold level at which the THRE Interrupts */
	temp |= UART_InitStruct->UART_TET;

	/* select the trigger level in the receiver FIFO at which the Received Data */
	temp |= UART_InitStruct->UART_RT;			
	
	UARTx->FCR = temp;
}

/**
  * @brief  ¸ù¾ÝUART_FIFOInitStructÖÐÖ¸¶¨µÄ²ÎÊý³õʼ»¯UARTxÍâÉè
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_FIFOInitStruct: UART³õʼ»¯ÅäÖýṹÌå
  * @retval None
  */
void UART_FIFOInit(UART_Type* UARTx, const UART_FIFOInitTypeDef* UART_FIFOInitStruct)
{
	uint32_t temp;
	
	temp = (uint32_t)UART_FIFOInitStruct->UART_RT | (uint32_t)UART_FIFOInitStruct->UART_TET | \
					(uint32_t)UART_FIFOInitStruct->UART_FIFO_Enable;
	
	UARTx->FCR = temp;
}

/**
  * @brief  »ñÈ¡UARTµÄFTFO¹¦ÄÜʹÄÜ״̬
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval (ENABLE or DISABLE)
  */
FunctionalState UART_GetFIFOEnableStatus(const UART_Type* UARTx)
{
	FunctionalState ret;
	
	if((UARTx->IIR & UART_IIR_FIFOSE_MASK) == UART_IIR_FIFOSE_MASK)
	{
		ret = ENABLE;
	}
	else
	{
		ret = DISABLE;
	}
	
	return ret;
}


/**
  * @brief  ʹÄÜUARTxÍâÉè
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  * 		@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  State: UARTxʹÄÜ״̬
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg ENABLE: UARTxʹÄÜ
  *			@arg DISABLE: UARTxʧÄÜ
  * @retval None
  */
void UART_EnableCmd(UART_Type* UARTx, FunctionalState State)
{
	if(State == ENABLE)
	{
		UARTx->SGW |= UART_SGW_EN_MASK;
	}
	else
	{
		UARTx->SGW &= ~UART_SGW_EN_MASK;
	}
}


/**
  * @brief  ·¢ËÍLINͬ²½¼ä¸ô¶Î
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval None
  */
void UART_SendLinBreak(UART_Type* UARTx)
{
	UARTx->PATTERN |= UART_PATTERN_BC_MASK;
}

/**
  * @brief  ÉèÖÃUARTxͬ²½¼ä¸ô¶Î³¤¶È
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_BreakLength: Ö¸¶¨Í¬²½¼ä¸ô¶Î³¤¶È
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_LINBreakLength_10b: ÖÁÉÙÉú³É10bitͬ²½¼ä¸ô¶Î³¤¶È
  *			@arg UART_LINBreakLength_13b: ÖÁÉÙÉú³É13bitͬ²½¼ä¸ô¶Î³¤¶È
  * @retval None
  */
void UART_LINBreakLengthConfig(UART_Type* UARTx, uint8_t UART_BreakLength)
{
	UARTx->LCR &= ~UART_LCR_BRK13_MASK;
	UARTx->LCR |= UART_BreakLength;
}

/**
  * @brief  ͨ¹ýUARTx·¢ËÍÒ»¸öÊý¾Ý
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  Data: ´ý·¢ËÍÊý¾Ý
  * @retval None
  */
void UART_SendData(UART_Type *UARTx,uint8_t Data)
{
	UARTx->THR = Data;
}

/**
  * @brief  ͨ¹ýUARTx½ÓÊÕÒ»¸öÊý¾Ý
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval ·µ»ØÊý¾Ý
  */
uint8_t UART_ReceiveData(const UART_Type *UARTx)
{
	return (uint8_t)UARTx->RBR;
}

/**
  * @brief  ʹÄÜUARTxÍâÉèÖ¸¶¨ÖжÏ
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param UART_Interrupt£ºÖжÏÀàÐÍ
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_RDataAvailableIntEN: ½ÓÊÕÊý¾ÝÖжÏ
  *			@arg UART_THoldingEmptyIntEN£º·¢ËͼĴæÆ÷¿ÕÖжÏ
  *			@arg UART_RLineStatusIntEN£º Ïß·״̬ÖжÏ
  *			@arg UART_ModenStatusIntEN£º µ÷ÖÆÖжÏ
  *			@arg UART_THREIntEN£ºTHREÖжÏ
  * @param  State: UARTx ÖжÏʹÄÜ״̬
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg ENABLE: UARTx Ö¸¶¨ÖжÏʹÄÜ
  *			@arg DISABLE: UARTx Ö¸¶¨ÖжÏʧÄÜ
  * @retval None 
  */
void UART_EnableInterruptCmd(UART_Type *UARTx, uint8_t UART_Interrupt, FunctionalState State)
{
	if(State == ENABLE)
	{
		UARTx->IER |= UART_Interrupt;
	}
	else
	{
		UARTx->IER &= ~UART_Interrupt;
	}
}

/**
  * @brief  »ñÈ¡UARTxÍâÉèÖ¸¶¨ÖжÏʹÄÜ״̬
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param UART_Interrupt£ºÖжÏÀàÐÍ
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_RDataAvailableIntEN: ½ÓÊÕÊý¾ÝÖжÏ
  *			@arg UART_THoldingEmptyIntEN£º·¢ËͼĴæÆ÷¿ÕÖжÏ
  *			@arg UART_RLineStatusIntEN£º Ïß·״̬ÖжÏ
  *			@arg UART_ModenStatusIntEN£º µ÷ÖÆÖжÏ
  *			@arg UART_THREIntEN£ºTHREÖжÏ
  * @retval µ±Ç°×´Ì¬(SET or RESET) 
  */
FlagStatus UART_GetInterruptCmd(const UART_Type *UARTx, uint8_t UART_Interrupt)
{
	FlagStatus ret = RESET;
	if(0u != (UARTx->IER & UART_Interrupt))
	{
		ret = SET;
	}
	
	return ret;
}

/**
  * @brief  »ñÈ¡UARTxÍâÉèÖжÏ״̬
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval  IID: ÖжÏID£¬Ö¸Ê¾²úÉúÖжϵÄÀàÐÍ
  *			@arg UART_IID_NONE: ÎÞÖжϵȴý
  *			@arg UART_IID_TxHoldingEmpty: THRΪ¿Õ
  *			@arg UART_IID_RxDataAvailable: ½ÓÊÕµÄÊý¾Ý¿ÉÓÃ
  *			@arg UART_IID_RxLineStatus: ½ÓÊÕÏß·״̬
  *			@arg UART_IID_Busy: æÖжÏ
  *			@arg UART_IID_Overtime: ×Ö·û³¬Ê±
  */
uint8_t UART_GetInterruptStatus (const UART_Type *UARTx)
{
	uint8_t IntIdentityTemp;
	IntIdentityTemp =(uint8_t)UARTx->IIR ;
	
	return IntIdentityTemp;
	
}

/**
  * @brief  ʹÄÜUARTxÍâÉèÔÝÍ£´«Êä
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  State: UARTx ÔÝÍ£´«ÊäʹÄÜ״̬
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg ENABLE: UARTx ÔÝÍ£´«ÊäʹÄÜ
  *			@arg DISABLE: UARTx ÔÝÍ£´«ÊäʧÄÜ
  * @retval None 
  */
void UART_EnableHaltTransmitCmd(UART_Type *UARTx, FunctionalState State)
{
	if(State == ENABLE)
	{
		UARTx->HTX |= UART_HTX_HTX_MASK;
	}
	else
	{
		UARTx->HTX &= ~UART_HTX_HTX_MASK;
	}
}

/**
  * @brief  »ñÈ¡UARTxÍâÉè·¢ËÍFIFOÊý¾Ý¸öÊý
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval TxFIFOÊý¾Ý¸öÊý  
  */
uint8_t UART_GetTxFIFOLevel(const UART_Type *UARTx)
{
	return (uint8_t)UARTx->TFL&UART_TFL_TFIFOL_MASK;
}

/**
  * @brief  »ñÈ¡UARTxÍâÉè½ÓÊÕFIFOÊý¾Ý¸öÊý
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @retval RxFIFOÊý¾Ý¸öÊý 
  */
uint8_t UART_GetRxFIFOLevel(const UART_Type *UARTx)
{
	return (uint8_t)UARTx->RFL&UART_RFL_RFIFOL_MASK;
}
	
/**
  * @brief  »ñÈ¡UARTxÍâÉèÖ¸¶¨×´Ì¬
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_StatusType: ״̬ÀàÐÍ
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_Busy: UARTæ
  *			@arg UART_TransmitFIFONotFull: ·¢ËÍFIFOδÂú
  *			@arg UART_TransmitFIFOEmpty: ·¢ËÍFIFOΪ¿Õ
  *			@arg UART_ReceiveFIFONotEmpty: ½ÓÊÕFIFO²»Îª¿Õ
  *			@arg UART_ReceiveFIFOFull: ½ÓÊÕFIFOÂú
  *			@arg UART_BusIdle: UART×ÜÏß´¦ÓÚIDLE״̬
  * @retval µ±Ç°×´Ì¬(SET or RESET) 
  */
FlagStatus UART_GetStatus(const UART_Type *UARTx, uint8_t UART_StatusType)
{
	FlagStatus ret;
	
	if( ( (UARTx->USR >> UART_StatusType)&(uint32_t)0x01) != 0u)
	{
		ret = SET;
	}
	else
	{
		ret = RESET;
	}
	
	return ret;
}

/**
  * @brief  »ñÈ¡UARTxÍâÉèÖ´ÐÐÏß·״̬
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_LineStatusType: Ïß·״̬ÀàÐÍ
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_LSRDataReady: Êý¾Ý×¼±¸ºÃ
  *			@arg UART_LSROverrunErr: Òç³ö´íÎó
  *			@arg UART_LSRParityErr: ÆæżУÑé´íÎó
  *			@arg UART_LSRFrameErr: Ö¡´íÎó
  *			@arg UART_LSRBreakIntr: ¼ä¸ô·û¼ì²âÖжÏ
  *			@arg UART_LSRTHREmpty: ·¢Ëͱ£³Ö¼Ä´æÆ÷Ϊ¿Õλ
  *			@arg UART_LSRTransmitterEmpty: ·¢ËÍÆ÷¿Õ
  *			@arg UART_LSRReceiverFIFOErr: ½ÓÊÕÆ÷FIFO´íÎó
  * @retval µ±Ç°×´Ì¬(TRUE or FALSE) 
  */
FlagStatus UART_GetLineStatus(const UART_Type *UARTx,uint8_t UART_LineStatusType)
{
	FlagStatus ret;
	
	if( ( (UARTx->LSR >> UART_LineStatusType)&(uint32_t)0x01) != 0u)
	{
		ret = SET;
	}
	else
	{
		ret = RESET;
	}
	
	return ret;
}

/**
  * @brief  µ¥ÏßģʽÏÂÉèÖÃUARTxÍâÉèTxDÒý½Å·½Ïò
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  * 		@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_SingleLineDirection: Ö¸¶¨TxDÒý½Å·½Ïò
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_SingleLineDirection_Input: TxDÒý½ÅÔÚµ¥ÏßģʽÏÂÉèÖÃΪÊäÈë
  *			@arg UART_SingleLineDirection_Output: TxDÒý½ÅÔÚµ¥ÏßģʽÏÂÉèÖÃΪÊä³ö
  * @retval None
  */
void UART_SingleLineDirectionConfig(UART_Type *UARTx, bool_t UART_SingleLineDirection)
{
	if(UART_SingleLineDirection)
	{
		UARTx->SGW |= UART_SGW_TXDIR_MASK;
	}
	else
	{
		UARTx->SGW &= ~UART_SGW_TXDIR_MASK;
	}
}

/**
  * @brief  ÉèÖÃUARTxÍâÉèģʽ
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  UART_ModeType: Ö¸¶¨UARTxÍâÉèģʽ
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART_Mode_Normal: Õý³£Ä£Ê½
  *			@arg UART_Mode_SingleLine: µ¥Ïßģʽ
  *			@arg UART_Mode_Loop: »·»Øģʽ
  * @retval None
  */
void UART_SetMode(UART_Type *UARTx , uint8_t UART_ModeType)
{
	if(UART_ModeType == UART_Mode_Normal)
	{
		UARTx->SGW &= ~UART_SGW_LOOPS_MASK;
	}
	else if(UART_ModeType == UART_Mode_SingleLine)
	{
		UARTx->SGW |= UART_SGW_LOOPS_MASK;
		UARTx->SGW |= UART_SGW_RSRC_MASK;
	}
	else
	{
		UARTx->SGW |= UART_SGW_LOOPS_MASK;
		UARTx->SGW &= ~UART_SGW_RSRC_MASK;
	}
}

/**
  * @brief  ʹÄÜDMAģʽÈí¼þÈ·ÈÏ
  * @param  UARTx: Ñ¡ÔñUARTÍâÉè
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg UART0: UART0ÍâÉè
  *			@arg UART1: UART1ÍâÉè
  *			@arg UART2: UART2ÍâÉè
  * @param  State: UARTx Èí¼þÓ¦´ðʹÄÜ״̬
  *		Õâ¸ö²ÎÊý¿ÉÒÔÈ¡ÏÂÃæµÄÖµ:
  *			@arg ENABLE: UARTx Èí¼þÓ¦´ðʹÄÜ
  *			@arg DISABLE: UARTx Èí¼þÓ¦´ðʧÄÜ
  * @retval None
  */
void UART_DMASoftwareAckEnableCmd(UART_Type *UARTx, FunctionalState State)
{
	if(State == ENABLE)
	{
		UARTx->DMASA |= UART_DMASA_DMASA_MASK;
	}
	else
	{
		UARTx->DMASA &= ~UART_DMASA_DMASA_MASK;
	}
	
}

/**
  * @}
  */

/**
  * @}
  */

/**
  * @}
  */
#ifdef __cplusplus
}
#endif /* __cplusplus */