/*--------------------------------------------------------*/
/*  SPECTRUM DIGITAL INC.				                  */
/*--------------------------------------------------------*/
/* Onchip UART test for EVM320LF2407			          */
/*--------------------------------------------------------*/
/*							                              */
/* This test requires a loopback connector		          */
/*							                              */
/* filename:	uart1.c 				                  */
/* original:	02/17/1999   by: mls			          */
/* last update: 02/18/2000   by: rrp for 2407		      */
/*--------------------------------------------------------*/


#include "sci2407.h"
#include "ioreg.h"
#include "prot2407.h"

#define  TESTING_OUTPUT  0
#define  TEST_UART	 0


typedef volatile struct sci SCI_STRUCT;

unsigned int uart_send_char;
unsigned int uart_rec_char;

SCI_STRUCT *sciptr;             /* pointer to sci defined structure */

unsigned char uart1_test_msg[] = {"This is a test message from uart #1"};

void init_uart1(void)
{
   volatile unsigned int OCRAReg;

   sciptr = (SCI_STRUCT *)SCI;     /* overlay structure over the hardware */
				    /* 0x7050 for C2407 */

                                    /* 1 stop, no parity, 8 data, async */
                                    /* 0x17 */

   /* Reset the uart */
   sciptr->ctl1 = 0;

   wait_ms( 1 );

   sciptr->ctl1 = SW_RESET;


                                    /* reset low, clock internal,  */
                                    /* xmit enable, rec enable */
                                    /* 0x13 */



   sciptr->ccr = (unsigned int) (  SCI_CHAR2 | SCI_CHAR1 | SCI_CHAR0);

                                    
                                    
                                    /* enable TX & RX ints */
                                    /* 0x03 */

/* sciptr->ctl2 = (unsigned int) (RX_INT_EN | TX_INT_EN);   */
   sciptr->ctl2 = (unsigned int) 0x0000;   /* no interrupts */

                                    /* load the baud rate */
   sciptr->baud_hi = (unsigned int) (BAUD_9600 / 0x100);  
   sciptr->baud_lo = (unsigned int) (BAUD_9600 % 0x100); 

  /* set SCIRXD & SCITXD as fn pins */
  /* in OCRA Register  */

  OCRAReg = *(volatile unsigned int *)OCRA;
  OCRAReg = (TXD_FUNCTION | RXD_FUNCTION);
  *(volatile unsigned int *)OCRA = OCRAReg;

   /*-------------------------------------------------------------*/
   /* Set mode to soft						  */
   /*-------------------------------------------------------------*/

   sciptr->pri = PRI_SOFT;

   /*-------------------------------------------------------------*/
   /* xmit enable, rec enable					  */
   /*-------------------------------------------------------------*/
   sciptr->ctl1 = (unsigned int) (SW_RESET | TX_ENA | RX_ENA);


}



unsigned int chk_uart1_rec_full(void)
{
  unsigned int ctr, rec_full_status;

  rec_full_status = 0;
  ctr = 10000;

  while ((!rec_full_status) && (ctr--))
  {
    rec_full_status = sciptr->rxst;
    rec_full_status &= RXRDY;
  }
  if (!ctr)
  {
    rec_full_status = 0;
  }
  return(rec_full_status);
}

unsigned int chk_uart1_xmit_empty(void)
{
  unsigned int ctr, xmit_empty_status;

  xmit_empty_status = 0;
  ctr = 10000;
  while ((!xmit_empty_status) && (ctr--))
  {
    xmit_empty_status = sciptr->ctl2;  /* read xmit status */
    xmit_empty_status &= TX_EMPTY;
  }
  if (!ctr)
  {
    xmit_empty_status = 0;
  }
  return(xmit_empty_status);
}

unsigned int uart1_get_char(void)
{
  unsigned int ctr, rec_full_status;
  unsigned int in_char;

  rec_full_status = chk_uart1_rec_full();
  if (rec_full_status)
  {
    in_char = sciptr->rxbuf;            /* get data from rec buffer */
    in_char &= 0x00ff;
    return (in_char);                   /* return data */
  }
  return((unsigned int)0x8000);
}


unsigned int uart1_put_char(unsigned int out_char)
{
  unsigned int send_char_status;
  
  send_char_status = chk_uart1_xmit_empty();
  if (send_char_status)
  {
    sciptr->txbuf =  (0x00ff & out_char);  /* send data */
    return ((unsigned int) 0);             /* return no error */
  }
  return( (unsigned int) 0xffff);   /* return error */
                                       /* write out character here */
}

unsigned int uart1_put_string(unsigned char * out_string)
{
  unsigned int out_data;
  unsigned int send_string_status;

  while(*out_string)                     /* null terminated */
  {
     send_string_status = chk_uart1_xmit_empty();
     if (send_string_status)
     {
       out_data = *out_string++;         /* get character */
       uart1_put_char(out_data);        /* send data */
     }
     else
     {
       return( (unsigned int) 0xffff);   /* return error */
     }
  }
  return ((unsigned int) 0);             /* return no error */

}


unsigned int uart1test(void)
{
  unsigned int uart_status;
  unsigned int uart_ctr;
  unsigned int uart1_err;
   
  uart1_err = 0;                    /* show no error */

  init_uart1();            /* set up uart 9600, no parity, 1 stop */

  uart_ctr = wait_ms( 2 );

                                               /* put out a test string */
#if TESTING_OUTPUT
  while ( 1 )
  {
      uart1_err = uart1_put_string(uart1_test_msg);
      wait_ms( 100 );
  }

#endif

  uart_send_char = 0x00;             /* do 256 patterns */

#if TEST_UART
while ( 1)
{
  uart_send_char = 0x00;             /* do 256 patterns */
#endif

  while (uart_send_char < 0x100)
  {
    uart1_put_char(uart_send_char);

                                     /* check for error */
    uart_rec_char = uart1_get_char();      
    if (uart_rec_char == 0x8000)           
    {                                      
      uart1_err = 1;                       
      return(uart1_err);                   
    }                                      
    if (uart_rec_char != uart_send_char)   
    {                                      
      uart1_err = 2;                       
      return(uart1_err);                        /* show error */
    }                                      
    uart_send_char++; 
  }

#if TEST_UART
  }
#endif


  return(uart1_err);
}




unsigned int read_uart(void)
{
    unsigned int rcv_status = 0;
    unsigned int in_char;

    while ( !rcv_status )
    {
       rcv_status = sciptr->rxst;
       rcv_status &= RXRDY;
    }

     in_char = sciptr->rxbuf;		 /* get data from rec buffer */
    in_char &= 0x00ff;
    return (in_char);			/* return data */

}


unsigned int write_uart(unsigned int out_char)
{
  unsigned int xmit_status = 0;
  
  while( !xmit_status )
  {
      xmit_status = sciptr->ctl2;    /* read xmit status */
	xmit_status &= TX_EMPTY;
  /*	xmit_status &= TX_RDY;	  */
  }


  sciptr->txbuf =  (0x00ff & out_char);    /* send data */
  return ((unsigned int) 0);		   /* return no error */

}



unsigned int write_string(unsigned char * out_string)
{
  unsigned int out_data;
  unsigned int send_string_status;

  while(*out_string)                     /* null terminated */
  {
     out_data = *out_string++;	       /* get character */
     write_uart(out_data);	  /* send data */
  }
  return( 0 );
}