blob: 8dfbdf433811d291b9b0ee21ce7202b4984df884 [file] [log] [blame]
/*
* File: uart_support.c
* Purpose: Implements UART basic support, Derivative Specific Interrupt handler and need function needed
* for MSL Support (printf\cout to terminal), defined in <UART.h>
*
* Notes:
*
*/
#include "support_common.h"
#include "uart_support.h"
#if ENABLE_UART_SUPPORT==1
#if UART_SUPPORT_TYPE==UART_PSC
/* 5475 & 5485 boards have different names for uart access registers */
void uart_init(int channel, unsigned long systemClockKHz, unsigned long baudRate)
{
register uint16 ubgs;
/*
* On Verdi, only PSC 0 & 1 are brought out to RS232 transceivers
*/
/* Put PSC in UART mode */
MCF_PSC_PSCSICR(channel) = MCF_PSC_PSCSICR_SIM_UART;
/* Rx and Tx baud rate from timers */
MCF_PSC_PSCCSR(channel) = (0
| MCF_PSC_PSCCSR_RCSEL_SYS_CLK
| MCF_PSC_PSCCSR_TCSEL_SYS_CLK);
/*
* Calculate baud settings
*/
ubgs = (uint16)((systemClockKHz * 1000)/(baudRate * 32));
MCF_PSC_PSCCTUR(channel) = (uint8) ((ubgs >> 8) & 0xFF);
MCF_PSC_PSCCTLR(channel) = (uint8) (ubgs & 0xFF);
/* Reset transmitter, receiver, mode register, and error conditions */
MCF_PSC_PSCCR(channel) = MCF_PSC_PSCCR_RESET_RX;
MCF_PSC_PSCCR(channel) = MCF_PSC_PSCCR_RESET_TX;
MCF_PSC_PSCCR(channel) = MCF_PSC_PSCCR_RESET_ERROR;
MCF_PSC_PSCCR(channel) = MCF_PSC_PSCCR_RESET_BKCHGINT;
MCF_PSC_PSCCR(channel) = MCF_PSC_PSCCR_RESET_MR;
/* 8-bit data, no parity */
MCF_PSC_PSCMR(channel) = (0
#ifdef UART_HARDWARE_FLOW_CONTROL
| MCF_PSC_PSCMR_RXRTS
#endif
| MCF_PSC_PSCMR_PM_NONE
| MCF_PSC_PSCMR_BC_8);
/* No echo or loopback, 1 stop bit */
MCF_PSC_PSCMR(channel) = (0
#ifdef UART_HARDWARE_FLOW_CONTROL
| MCF_PSC_PSCMR_TXCTS
#endif
| MCF_PSC_PSCMR_CM_NORMAL
| MCF_PSC_PSCMR_SB_STOP_BITS_1);
/* Mask all UART interrupts */
MCF_PSC_PSCIMR(channel) = 0x0000;
/* Enable RTS to send */
MCF_PSC_PSCOPSET(channel) = MCF_PSC_PSCOPSET_RTS;
/* Setup FIFO Alarms */
MCF_PSC_PSCRFAR(channel) = MCF_PSC_PSCRFAR_ALARM(248);
MCF_PSC_PSCTFAR(channel) = MCF_PSC_PSCTFAR_ALARM(248);
/* Enable receiver and transmitter */
MCF_PSC_PSCCR(channel) =(0
| MCF_PSC_PSCCR_RX_ENABLED
| MCF_PSC_PSCCR_TX_ENABLED);
}
/********************************************************************/
/*
* Wait for a character to be received on the specified UART
*
* Return Values:
* the received character
*/
char uart_getchar (int channel)
{
/* Wait until character has been received */
while (!(MCF_PSC_PSCSR(channel) & MCF_PSC_PSCSR_RXRDY))
{
}
return (char)(*((uint8 *) &MCF_PSC_PSCRB_8BIT(channel)));
}
/********************************************************************/
/*
* Wait for space in the UART Tx FIFO and then send a character
*/
void uart_putchar (int channel, char ch)
{
/* Wait until space is available in the FIFO */
while (!(MCF_PSC_PSCSR(channel) & MCF_PSC_PSCSR_TXRDY))
;
*((uint8 *) &MCF_PSC_PSCTB_8BIT(channel)) = (uint8)ch;
}
#else /* UART_SUPPORT_TYPE==UART_PSC */
#if UART_SUPPORT_TYPE == UART_5407
/********************************************************************/
/*
* 5407 derivative doesn't have macros to access URB/UTB by channel number
* because they have different sizes for UART0 & UART1
* But in UART mode only 8 bits of UART1 URB/UTB is used, so define these macros here
* if they doesn't defined before
*/
#ifndef MCF_UART_URB
#define MCF_UART_URB(x) (*(vuint8 *)(&__MBAR[0x1CC + ((x)*0x40)]))
#endif /* MCF_UART_URB */
#ifndef MCF_UART_UTB
#define MCF_UART_UTB(x) (*(vuint8 *)(&__MBAR[0x1CC + ((x)*0x40)]))
#endif /* MCF_UART_UTB */
#endif /* UART_SUPPORT_TYPE == UART_5407 */
void uart_init(int channel, unsigned long systemClockKHz, unsigned long baudRate)
{
/*
* Initialize UART for serial communications
*/
register uint16 ubgs;
#if UART_SUPPORT_TYPE==UART_54451
uint32 vco;
uint32 divider;
uint32 bus_clk;
divider = ((MCF_CLOCK_PCR & 0x000000F0) >> 4) + 1;
vco = ((MCF_CLOCK_PCR >> 24) * systemClockKHz * 1000);
bus_clk = (vco / divider);
#endif
/*
* Reset Transmitter
*/
MCF_UART_UCR(channel) = MCF_UART_UCR_RESET_TX;
/*
* Reset Receiver
*/
MCF_UART_UCR(channel) = MCF_UART_UCR_RESET_RX;
/*
* Reset Mode Register
*/
MCF_UART_UCR(channel) = MCF_UART_UCR_RESET_MR;
/*
* No parity, 8-bits per character
*/
MCF_UART_UMR(channel) = (0
| MCF_UART_UMR_PM_NONE
| MCF_UART_UMR_BC_8 );
/*
* No echo or loopback, 1 stop bit
*/
MCF_UART_UMR(channel) = (0
| MCF_UART_UMR_CM_NORMAL
| MCF_UART_UMR_SB_STOP_BITS_1);
/*
* Set Rx and Tx baud by SYSTEM CLOCK
*/
MCF_UART_UCSR(channel) = (0
| MCF_UART_UCSR_RCS_SYS_CLK
| MCF_UART_UCSR_TCS_SYS_CLK);
/*
* Mask all UART interrupts
*/
MCF_UART_UIMR(channel) = 0;
/*
* Calculate baud settings
*/
#if UART_SUPPORT_TYPE==UART_54451
ubgs = (uint16)(((bus_clk >> 5) + (baudRate >> 1)) / baudRate);
#else
ubgs = (uint16)((systemClockKHz * 1000)/(baudRate * 32));
#endif
#if UART_SUPPORT_TYPE==UART_DIVIDER || UART_SUPPORT_TYPE == UART_5407
MCF_UART_UDU(channel) = (uint8)((ubgs & 0xFF00) >> 8);
MCF_UART_UDL(channel) = (uint8)(ubgs & 0x00FF);
#else /* UART_SUPPORT_TYPE!=UART_DIVIDER */
MCF_UART_UBG1(channel) = (uint8)((ubgs & 0xFF00) >> 8);
MCF_UART_UBG2(channel) = (uint8)(ubgs & 0x00FF);
#endif /* UART_SUPPORT_TYPE==UART_DIVIDER */
/*
* Enable receiver and transmitter
*/
MCF_UART_UCR(channel) = (0
| MCF_UART_UCR_TX_ENABLED
| MCF_UART_UCR_RX_ENABLED);
}
/********************************************************************/
/*
* Wait for a character to be received on the specified UART
*
* Return Values:
* the received character
*/
char uart_getchar (int channel)
{
/* Wait until character has been received */
while (!(MCF_UART_USR(channel) & MCF_UART_USR_RXRDY))
{
};
return (char)MCF_UART_URB(channel);
}
/********************************************************************/
/*
* Wait for space in the UART Tx FIFO and then send a character
*/
void uart_putchar (int channel, char ch)
{
/* Wait until space is available in the FIFO */
while (!(MCF_UART_USR(channel) & MCF_UART_USR_TXRDY))
{
};
/* Send the character */
MCF_UART_UTB(channel) = (uint8)ch;
}
#endif /* UART_SUPPORT_TYPE==UART_PSC */
/********************************************************************/
/********************************************************************/
/** <UART.h> Neeeded functions **/
/********************************************************************/
/****************************************************************************/
/*
* Implementation for CodeWarror MSL interface to serial device (UART.h).
* Needed for printf, etc...
* Only InitializeUART, ReadUARTN, and WriteUARTN are implemented.
*
*/
UARTError InitializeUART(UARTBaudRate baudRate)
{
#if UART_SUPPORT_TYPE==UART_54451
baudRate = kBaud115200;
#endif
uart_init(TERMINAL_PORT, SYSTEM_CLOCK_KHZ, baudRate);
return kUARTNoError;
}
/****************************************************************************/
/*
ReadUARTN
Read N bytes from the UART.
bytes pointer to result buffer
limit size of buffer and # of bytes to read
*/
/****************************************************************************/
UARTError ReadUARTN(void* bytes, unsigned long limit)
{
int count;
for (count = 0; count < limit; count++) {
*( (char *)bytes + count ) = uart_getchar(TERMINAL_PORT);
}
return kUARTNoError;
}
/****************************************************************************/
UARTError WriteUARTN(const void* bytes, unsigned long length)
{
int count;
for (count = 0; count < length; count++) {
uart_putchar(TERMINAL_PORT, *( ((char *)bytes) + count));
}
return kUARTNoError;
}
#endif /* ENABLE_UART_SUPPORT */