/*------------------------------------------------------------------------------
uPSD_UART.C

uPSD Serial IO Device Driver Functions
08/2002 Ver 0.1 - Initial Version

Copyright 2002 STMicroelectrons Inc.

This example demo code is provided as is and has no warranty,
implied or otherwise.  You are free to use/modify any of the provided
code at your own risk in your applications with the expressed limitation
of liability (see below) so long as your product using the code contains
at least one uPSD products (device).

LIMITATION OF LIABILITY:   NEITHER STMicroelectronics NOR ITS VENDORS OR 
AGENTS SHALL BE LIABLE FOR ANY LOSS OF PROFITS, LOSS OF USE, LOSS OF DATA,
INTERRUPTION OF BUSINESS, NOR FOR INDIRECT, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES OF ANY KIND WHETHER UNDER THIS AGREEMENT OR
OTHERWISE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
------------------------------------------------------------------------------*/
#pragma optimize(8,size)

//-------------- header files for UPSD -----------------
#include "upsd3200.h"
#include "upsd_hardware.h"
#include "upsd_uart.h"

/* --------------- UART0 --------------------------- */
xdata char tbuf [TBUF_SIZE];					//Data Buffer for UART0 Transmitter
xdata char rbuf [RBUF_SIZE];					//Data Buffer for UART0 Receiver
static xdata unsigned char t_in = 0;			//no. of data to be transimitted
static xdata unsigned char t_out = 0;			//no. of data transmitted
static xdata unsigned char t_disabled = 0;		// dsiabled bit to disable UART0 transmision

static xdata unsigned char r_in = 0;			//no. of data to be received
static xdata unsigned char r_out = 0;			//no. of data received

/* --------------- UART1 --------------------------- */
xdata char tbuf1 [TBUF_SIZE];					//Data Buffer for UART1 Transmitter
xdata char rbuf1 [RBUF_SIZE];					//Data Buffer for UART1 Receiver
static xdata unsigned char t_in1 = 0;			//no. of data to be transimitted
static xdata unsigned char t_out1 = 0;			//no. of data transmitted
static xdata unsigned char t_disabled1 = 0;		// dsiabled bit to disable UART1 transmision

static xdata unsigned char r_in1 = 0;			//no. of data to be received
static xdata unsigned char r_out1 = 0;			//no. of data received

/*------------------------------------------------------------------------------*/
//             UART 0 Interrupt service routine
/* ---------------------------------------------------------------------------- */
static void uPSD_uart0_isr (void) interrupt SIO_VECTOR using 2				
{
	/*------------------------------------------------
	Received data interrupt.
	------------------------------------------------*/

	if (RI != 0)
  	{
  		RI = 0;

  		if ((r_in + 1) != r_out)
    		rbuf [r_in++] = SBUF;
  	}

	/*------------------------------------------------
	Transmitted data interrupt.
	------------------------------------------------*/
	if (TI != 0)
 	 {
 		TI = 0;

  		if (t_in != t_out)
    		SBUF = tbuf [t_out++];
  		else t_disabled = 1;
  	}

}

/*------------------------------------------------------------------------------*/
//             UART 1 Interrupt service routine
/* ---------------------------------------------------------------------------- */
static void uPSD_uart1_isr (void) interrupt SIO1_VECTOR using 2		
{
/*------------------------------------------------
Received data interrupt.
------------------------------------------------*/
if ( (SCON2 & 0x01) != 0)
  {
  	SCON2 &= 0xFE;				//RI = 0;

  	if ((r_in1 + 1) != r_out1)
    	rbuf1 [r_in1++] = SBUF2;
  }

/*------------------------------------------------
Transmitted data interrupt.
------------------------------------------------*/
if ( (SCON2 & 0x02)  != 0)
  {
  	SCON2 &= 0xFD;				//TI = 0;

  	if (t_in1 != t_out1)
    	SBUF2 = tbuf1 [t_out1++];
  		else   	t_disabled1 = 1;
  }

}

/*------------------------------------------------------------------------------*/
/*                       UART0 & UART1 subroutines                              */
/* -----------------------------------------------------------------------------*/
// uart_no = 0 (uart0) else uart1 assumed
// timer_no = 0 (Timer 1) else Timer2 is assumed
unsigned int uPSD_UART_Timer (unsigned char uart_no, unsigned int baudrate, unsigned char timer_no)
{
	unsigned char baud_ratio;
	unsigned int timer_reg_value;
	bit ea_value;

	ea_value = EA;								// save EA state

	EA = 0;                             		// Disable Interrupts 
	
	if (uart_no)								//UART1
		{
		/*------------------------------------------------
		Clear transmit interrupt and buffer.
		------------------------------------------------*/
		SCON2 &= 0xFD;				  			// TI = 0: clear transmit interrupt 
		t_in1 = 0;			    				// empty transmit buffer 
		t_out1 = 0;
		t_disabled1 = 1;			    		// disable transmitter
		}
	else
	{									    //UART0
		/*------------------------------------------------
		Clear transmit interrupt and buffer.
		------------------------------------------------*/
		TI = 0;				    			// clear transmit interrupt 
		t_in = 0;			    			// empty transmit buffer 
		t_out = 0;
		t_disabled = 1;			    		// disable transmitter 

	}

	

	if ( (PCON & 0x80) )						// baud_ratio depends upon SMOD in PCON register: 
												// SMOD =1 : baud_ratio = 2,else buad_ratio = 1
		baud_ratio = 0x02 ;
		else baud_ratio = 0x01;
	
	if (!timer_no )								//uart_timer_ch=0: TIMER1; else TIMER2
		{
		/*------------------------------------------------
		Set timer 1 up as a baud rate generator.
		------------------------------------------------*/
		TR1 = 0;			    				// stop timer 1
		ET1 = 0;			    				// disable timer 1 interrupt 

		//timer_reg_value  = (unsigned char) (256 - (OSC * baud_ratio/ (32L * 12L * baudrate)));
		timer_reg_value  = (unsigned char) (256 - ( (FREQ_OSC * baud_ratio * 125L)/ (48L * baudrate)));

		}
	else {
		
				/*------------------------------------------------
				Set timer 2 up as a baud rate generator.
				------------------------------------------------*/
				TR2 = 0;			    		// stop timer 2 
				ET2 = 0;			    		// disable timer 2 interrupt 

			//	timer_reg_value = (unsigned int) (65536 - (OSC / (32L * baudrate)));
				timer_reg_value = (unsigned int) (65536 - ( (FREQ_OSC * 125L) / (4L * baudrate)));

		  }

	EA = ea_value;  							// return EA value
	return (timer_reg_value);

}

//=====================================================================
// uPSD_UART_Init - Initialize uart and set up timer for baud rate
// serial_info=[serial_mode,mp_en,receive_en,bit9_en,timer_ch,serial_ch]
//======================================================================
void upsd_init_serial(unsigned char serial_info,unsigned int timer_value)
{
	unsigned char serial_ch;			//serial_info[0]	
	unsigned char timer_ch;				//serial_info[2:1]
	unsigned char bit9_en;				//serial_info[3]
	unsigned char receive_en;			//serial_info[4]
	unsigned char mp_en;				//serial_info[5]
	unsigned char serial_mode;			//serial_info[7:6]
	unsigned char scon_buff;			//serial_info[7:4]

	serial_ch = serial_info & 0x01;		//serial comm. channel:0- UART0; 1-UART1
	timer_ch = serial_info & 0x06;		//timer channel is used to be baudrate generator: 
										//00-fixed baudrate;
										//01-TIMER1;
										//10- TIMER2

	bit9_en = serial_info & 0x08;		//9th data bit enable
										//0--9th data bit 0 (disable)
										//1--9th data bit 1 (enable)
	receive_en = serial_info & 0x10;	//receive enable:
										//1-- enable reception
										//0--disable reception (transmit enable)

	mp_en = serial_info & 0x20;			//multiprocess enable
	
	serial_mode = serial_info & 0xC0;	//serial comm. mode: 
										//00-mode0;
										//01-mode1;
										//10-mode2;
										//11- mode3
	
	scon_buff = serial_info & 0xF8;	
	

	// setup baud rate geneartor for UARTX in mode 1 & 3
	if (serial_mode & 0x40)
	{
		/*Timer x is being used to generate baud rates.*/
     		if (timer_ch == 0x02)			// Timer1
		{
			TMOD &= ~0xF0;			    // clear timer 1 mode bits 
			TMOD |= 0x20;			    // put timer 1 into MODE 2 
     			TH1 = timer_value;
     			TR1 = 1;            /*TCON.6*/
		}
		if (timer_ch == 0x04)			// Timer 2
		{
					
			RCAP2L = timer_value;
			RCAP2H = (timer_value >>8);
			if (serial_ch == 0) T2CON = 0x34;
			else PCON |= 0xC0;				//set RCLK1 & TCLK1
			TR2 = 1;
		}
	}

	// intial UARTx Registers     	
	if (serial_ch)						//UART1
	{
		SCON2 = scon_buff; 
 		IEA |= 0x10;	 				// ES1 = 1; IEA.4     
     		SCON2 &= 0xFE;					// RI1 = 0; SCON1.0     
	}
	else							//UART0
	{
		SCON = scon_buff;
     		ES = 1;            			//IE.4     
     		RI = 0;              		//SCON.0	
	}
	EA = 1;                             // Enable Interrupts
}


/*------------------------------------------------------------------------------*/
char uPSD_UART_Putchar (char c,bit uart_ch)
{
	/*------------------------------------------------
		If the buffer is full, return an error value.
	------------------------------------------------*/
	if ((TBUF_SIZE - uPSD_UART_Tbuflen(uart_ch)) <= 2)
  	return (-1);

	/*------------------------------------------------
		Add the data to the transmit buffer.  If the
		transmit interrupt is disabled, then enable it.
	------------------------------------------------*/
	EA = 0;                         	// Disable Interrupts 


if (uart_ch)
	{									//   UART1  
	
		tbuf1 [t_in1++] = c;

		if (t_disabled1)				// if transmitter is disabled
  			{
  			t_disabled1 = 0;

  			SCON2 |= 0x02;				// TI = 1; enable  it 
  			}


	}

	else {								//   UART0  
	
		tbuf [t_in++] = c;

		if (t_disabled)					// if transmitter is disabled 
  			{
  			t_disabled = 0;
  			TI = 1;						// enable it
  			}

	
		}

		EA = 1;                         // Enable Interrupts 

		return (0);

}

/*------------------------------------------------------------------------------*/
char uPSD_UART_Getchar (bit uart_ch)
{
char c;

if (uPSD_UART_Rbuflen (uart_ch) == 0)
  return (-1);

EA = 0;                         		// Disable Interrupts 
if (uart_ch) c=rbuf1[r_out1++];			// UART1              
	else c = rbuf [r_out++];			// UART0              
EA = 1;                         		// Enable Interrupts 

return (c);
}

/*------------------------------------------------------------------------------*/
unsigned char uPSD_UART_Rbuflen (bit uart_ch)
{
unsigned char rbuflen;

if (uart_ch)	rbuflen = r_in1 - r_out1;
	else rbuflen=r_in - r_out;
return (rbuflen);
}

/*------------------------------------------------------------------------------*/
unsigned char uPSD_UART_Tbuflen (bit uart_ch)
{
unsigned char tbuflen;

if (uart_ch) tbuflen = t_in1 - t_out1;
	else tbuflen = t_in - t_out;

return (tbuflen);
}
/*----------------------------------------------------------------------------- */