/*
 * 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"
#include "MCF52259_UART.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
 */
unsigned char uart_getchar (int channel)
{
    /* Wait until character has been received */
    while (!(MCF_UART_USR(channel) & MCF_UART_USR_RXRDY)) 
    {
       
    };

    return (unsigned 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;
}

#endif /* ENABLE_UART_SUPPORT */
