lpc177x_8x_uart.c

NXPl788上lwip的无操作系统移植,基于Embest开发板

/**********************************************************************
* $Id$		lpc177x_8x_uart.c			2011-06-02
*//**
* @file		lpc177x_8x_uart.c
* @brief	Contains all functions support for UART firmware library
*			on LPC177x_8x
* @version	1.0
* @date		02. June. 2011
* @author	NXP MCU SW Application Team
* 
* Copyright(C) 2011, NXP Semiconductor
* All rights reserved.
*
***********************************************************************
* Software that is described herein is for illustrative purposes only
* which provides customers with programming information regarding the
* products. This software is supplied "AS IS" without any warranties.
* NXP Semiconductors assumes no responsibility or liability for the
* use of the software, conveys no license or title under any patent,
* copyright, or mask work right to the product. NXP Semiconductors
* reserves the right to make changes in the software without
* notification. NXP Semiconductors also make no representation or
* warranty that such application will be suitable for the specified
* use without further testing or modification.
* Permission to use, copy, modify, and distribute this software and its
* documentation is hereby granted, under NXP Semiconductors'
* relevant copyright in the software, without fee, provided that it
* is used in conjunction with NXP Semiconductors microcontrollers.  This
* copyright, permission, and disclaimer notice must appear in all copies of
* this code.
**********************************************************************/

/* Peripheral group ----------------------------------------------------------- */
/** @addtogroup UART
 * @{
 */
#ifdef __BUILD_WITH_EXAMPLE__
#include "lpc177x_8x_libcfg.h"
#else
#include "lpc177x_8x_libcfg_default.h"
#endif /* __BUILD_WITH_EXAMPLE__ */
#ifdef _UART

/* Includes ------------------------------------------------------------------- */
#include "lpc177x_8x_uart.h"
#include "lpc177x_8x_clkpwr.h"

/* Private Functions ---------------------------------------------------------- */

static Status uart_set_divisors(UART_ID_Type UartID, uint32_t baudrate);
static LPC_UART_TypeDef *uart_get_pointer(UART_ID_Type UartID);


/*********************************************************************//**
 * @brief		Determines best dividers to get a target clock rate
 * @param[in]	UARTx	Pointer to selected UART peripheral, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	baudrate Desired UART baud rate.
 * @return 		Error status, could be:
 * 				- SUCCESS
 * 				- ERROR
 **********************************************************************/
static Status uart_set_divisors(UART_ID_Type UartID, uint32_t baudrate)
{
	Status errorStatus = ERROR;

	uint32_t uClk;
	uint32_t d, m, bestd, bestm, tmp;
	uint64_t best_divisor, divisor;
	uint32_t current_error, best_error;
	uint32_t recalcbaud;

	/* get UART block clock */
	uClk = CLKPWR_GetCLK(CLKPWR_CLKTYPE_PER);

	/* In the Uart IP block, baud rate is calculated using FDR and DLL-DLM registers
	* The formula is :
	* BaudRate= uClk * (mulFracDiv/(mulFracDiv+dividerAddFracDiv) / (16 * (DLL)
	* It involves floating point calculations. That's the reason the formulae are adjusted with
	* Multiply and divide method.*/
	
	/* The value of mulFracDiv and dividerAddFracDiv should comply to the following expressions:
	* 0 < mulFracDiv <= 15, 0 <= dividerAddFracDiv <= 15 */
	best_error = 0xFFFFFFFF; /* Worst case */
	bestd = 0;
	bestm = 0;
	best_divisor = 0;
	
	for (m = 1 ; m <= 15 ;m++)
	{
		for (d = 0 ; d < m ; d++)
		{
			divisor = ((uint64_t)uClk << 28)*m / (baudrate*(m+d));
			current_error = divisor & 0xFFFFFFFF;

			tmp = divisor>>32;

			/* Adjust error */
			if(current_error > ((uint32_t)1<<31))
			{
				current_error = -current_error;
				tmp++;
			}

			/* Out of range */
			if(tmp < 1 || tmp > 65536)
				continue;

			if( current_error < best_error)
			{
				best_error = current_error;
				best_divisor = tmp;
				bestd = d;
				bestm = m;
				
				if(best_error == 0) 
					break;
			}
		} /* end of inner for loop */

		if (best_error == 0)
			break;
	} /* end of outer for loop  */

	/* can not find best match */
	if(best_divisor == 0) 
		return ERROR;

	recalcbaud = (uClk >> 4) * bestm / (best_divisor * (bestm + bestd));

	/* reuse best_error to evaluate baud error*/
	if(baudrate > recalcbaud) 
		best_error = baudrate - recalcbaud;
	else 
		best_error = recalcbaud -baudrate;

	best_error = best_error * 100 / baudrate;

	if (best_error < UART_ACCEPTED_BAUDRATE_ERROR)
	{
		if (UartID == UART_1)
		{
			LPC_UART1->LCR |= UART_LCR_DLAB_EN;
			
			LPC_UART1->DLM = UART_LOAD_DLM(best_divisor);
			
			LPC_UART1->DLL = UART_LOAD_DLL(best_divisor);
			
			/* Then reset DLAB bit */
			LPC_UART1->LCR &= (~UART_LCR_DLAB_EN) & UART_LCR_BITMASK;
			
			LPC_UART1->FDR = (UART_FDR_MULVAL(bestm)
													| UART_FDR_DIVADDVAL(bestd)) & UART_FDR_BITMASK;
		}
		else if (UartID == UART_4)
		{
			LPC_UART4->LCR |= UART_LCR_DLAB_EN;
			
			LPC_UART4->DLM = UART_LOAD_DLM(best_divisor);
			
			LPC_UART4->DLL = UART_LOAD_DLL(best_divisor);
			
			/* Then reset DLAB bit */
			LPC_UART4->LCR &= (~UART_LCR_DLAB_EN) & UART_LCR_BITMASK;
			
			LPC_UART4->FDR = (UART_FDR_MULVAL(bestm)
													| UART_FDR_DIVADDVAL(bestd)) & UART_FDR_BITMASK;
		}
			
		else
		{
            LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
			UARTx->LCR |= UART_LCR_DLAB_EN;
			
			UARTx->DLM = UART_LOAD_DLM(best_divisor);
			
			UARTx->DLL = UART_LOAD_DLL(best_divisor);
			
			/* Then reset DLAB bit */
			UARTx->LCR &= (~UART_LCR_DLAB_EN) & UART_LCR_BITMASK;
			
			UARTx->FDR = (UART_FDR_MULVAL(bestm) \
							| UART_FDR_DIVADDVAL(bestd)) & UART_FDR_BITMASK;
		}
		errorStatus = SUCCESS;
	}

	return errorStatus;
}
/*********************************************************************//**
 * @brief		Get the pointer of a given Uart
 * @param[in]	UARTx	Pointer to selected UART peripheral, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @return 		LPC_UART0~LPC_UART4
 **********************************************************************/
LPC_UART_TypeDef *uart_get_pointer(UART_ID_Type UartID)
{
	LPC_UART_TypeDef *UARTx = NULL;
	switch(UartID)
	{
		case UART_0:
			UARTx = LPC_UART0;
			break;
		case UART_2:
			UARTx = LPC_UART2;
			break;
		case UART_3:
			UARTx = LPC_UART3;
			break;
		default:
			break;
	}
	return UARTx;
}

/* End of Private Functions ---------------------------------------------------- */


/* Public Functions ----------------------------------------------------------- */
/** @addtogroup UART_Public_Functions
 * @{
 */
/* UART Init/DeInit functions -------------------------------------------------*/
/********************************************************************//**
 * @brief		Initializes the UARTx peripheral according to the specified
 *               parameters in the UART_ConfigStruct.
 * @param[in]	UARTx	UART peripheral selected, should be:
 *				- UART_0: UART0 peripheral
 *				- UART_1: UART1 peripheral
 *				- UART_2: UART2 peripheral
 *				- UART_3: UART3 peripheral
 *				- UART_4: UART4 peripheral
 * @param[in]	UART_ConfigStruct Pointer to a UART_CFG_Type structure
*                    that contains the configuration information for the
*                    specified UART peripheral.
 * @return 		None
 *********************************************************************/
void UART_Init(UART_ID_Type UartID, UART_CFG_Type *UART_ConfigStruct)
{
	uint32_t tmp;
	switch (UartID)
	{
		case UART_0:
		case UART_2:
		case UART_3:
		{
			LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
			if(UartID == UART_0)
				/* Set up clock and power for UART module */
				CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART0, ENABLE);
			else if(UartID == UART_2)
				/* Set up clock and power for UART module */
				CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART2, ENABLE);
			else if(UartID == UART_3)
				/* Set up clock and power for UART module */
				CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART3, ENABLE);;
			/* FIFOs are empty */
			UARTx->FCR = ( UART_FCR_FIFO_EN | UART_FCR_RX_RS | UART_FCR_TX_RS);

			// Disable FIFO
			UARTx->FCR = 0;

			// Dummy reading
			while (UARTx->LSR & UART_LSR_RDR)
			{
				tmp = UARTx->RBR;
			}

			UARTx->TER = UART_TER_TXEN;

			// Wait for current transmit complete
			while (!(UARTx->LSR & UART_LSR_THRE));

			// Disable Tx
			UARTx->TER = 0;

			// Disable interrupt
			UARTx->IER = 0;

			// Set LCR to default state
			UARTx->LCR = 0;

			// Set ACR to default state
			UARTx->ACR = 0;

			// Set RS485 control to default state
			UARTx->RS485CTRL = 0;

			// Set RS485 delay timer to default state
			UARTx->RS485DLY = 0;

			// Set RS485 addr match to default state
			UARTx->ADRMATCH = 0;

			// Dummy reading
			tmp = UARTx->LSR;
		}
		break;
		case UART_1:
		{
			/* Set up clock and power for UART module */
			CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART1, ENABLE);

			/* FIFOs are empty */
			LPC_UART1->FCR = ( UART_FCR_FIFO_EN | UART_FCR_RX_RS | UART_FCR_TX_RS);

			// Disable FIFO
			LPC_UART1->FCR = 0;

			// Dummy reading
			while (LPC_UART1->LSR & UART_LSR_RDR)
			{
				tmp = LPC_UART1->RBR;
			}

			LPC_UART1->TER = UART_TER_TXEN;

			// Wait for current transmit complete
			while (!(LPC_UART1->LSR & UART_LSR_THRE));

			// Disable Tx
			LPC_UART1->TER = 0;

			// Disable interrupt
			LPC_UART1->IER = 0;

			// Set LCR to default state
			LPC_UART1->LCR = 0;

			// Set ACR to default state
			LPC_UART1->ACR = 0;

			// Set RS485 control to default state
			LPC_UART1->RS485CTRL = 0;

			// Set RS485 delay timer to default state
			LPC_UART1->RS485DLY = 0;

			// Set RS485 addr match to default state
			LPC_UART1->ADRMATCH = 0;

			// Dummy reading
			tmp = LPC_UART1->LSR;

			// Set Modem Control to default state
			LPC_UART1->MCR = 0;

			//Dummy Reading to Clear Status
			tmp = LPC_UART1->MSR;
		}
		break;
		case UART_4:
	    {
			/* Set up clock and power for UART module */
			CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCUART4, ENABLE);

			/* FIFOs are empty */
			LPC_UART4->FCR = ( UART_FCR_FIFO_EN | UART_FCR_RX_RS | UART_FCR_TX_RS);

			// Disable FIFO
			LPC_UART4->FCR = 0;

			// Dummy reading
			while (LPC_UART4->LSR & UART_LSR_RDR)
			{
				tmp = LPC_UART4->RBR;
			}

			LPC_UART4->TER = UART4_TER_TXEN;

			// Wait for current transmit complete
			while (!(LPC_UART4->LSR & UART_LSR_THRE));

			// Disable Tx
			LPC_UART4->TER = 0;

			// Disable interrupt
			LPC_UART4->IER = 0;

			// Set LCR to default state
			LPC_UART4->LCR = 0;

			// Set ACR to default state
			LPC_UART4->ACR = 0;

			// Set RS485 control to default state
			LPC_UART4->RS485CTRL = 0;

			// Set RS485 delay timer to default state
			LPC_UART4->RS485DLY = 0;

			// Set RS485 addr match to default state
			LPC_UART4->ADRMATCH = 0;

			// Dummy reading
			tmp = LPC_UART4->LSR;

			// Set IrDA Mode to default state
			LPC_UART4->ICR = 0;
		}
		break;
	}

	// Set Line Control register ----------------------------

	uart_set_divisors(UartID, (UART_ConfigStruct->Baud_rate));

	if (UartID == UART_1)
	{
		tmp = (LPC_UART1->LCR & (UART_LCR_DLAB_EN | UART_LCR_BREAK_EN)) \
													& UART_LCR_BITMASK;
	}
	else if (UartID == UART_4)
	{
		tmp = (LPC_UART4->LCR & (UART_LCR_DLAB_EN | UART_LCR_BREAK_EN)) \
													& UART_LCR_BITMASK;
	}	
	else
	{
		LPC_UART_TypeDef *UARTx = uart_get_pointer(UartID);
		tmp = (UARTx->LCR & (UART_LCR_DLAB_EN | UART_LCR_BREAK_EN)) & UART_LCR_BITMASK;
	}

	switch (UART_ConfigStruct->Databits)
	{
		case UART_DATABIT_5:
			tmp |= UART_LCR_WLEN5;
			break;

		case UART_DATABIT_6:
			tmp |= UART_LCR_WLEN6;
			break;

		case UART_DATABIT_7:
			tmp |= UART_LCR_WLEN7;
			break;