serial.c

NEC 的无线通讯方案

/*
* $Id: serial.c,v 1.27 2007/10/30 06:17:16 sunny Exp $
*/
/*
*******************************************************************************
**
**  This device driver was created by Applilet for the 78K0/KB2, 78K0/KC2,
**  78K0/KD2, 78K0/KE2 and 78K0/KF2 8-Bit Single-Chip Microcontrollers.
**
**  Copyright(C) NEC Electronics Corporation 2002 - 2005
**  All rights reserved by NEC Electronics Corporation.
**
**  This program should be used on your own responsibility.
**  NEC Electronics Corporation assumes no responsibility for any losses
**  incurred by customers or third parties arising from the use of this file.
**
**  Filename :	serial.c
**  Abstract :	This file implements device driver for SERIAL module.
**  APIlib :	NEC78K0KX2.lib V1.01 [09 Aug. 2005]
**
**  Device :	uPD78F0537, uPD78F0514
**
**  Compiler :	NEC/CC78K0
**
*******************************************************************************
*/
#pragma section @@DATA @@SERIAL
//#pragma inline  // enable memcpy() and memset() with direct inline expansion instead of function call

#include "config.h"

#if ENABLE_UART0
#pragma	interrupt	INTSR0		MD_INTSR0
#pragma	interrupt	INTST0		MD_INTST0
#endif // #if ENABLE_UART0

#if ENABLE_UART6
#pragma	interrupt	INTSR6		MD_INTSR6
#pragma	interrupt	INTST6		MD_INTST6
#pragma	interrupt	INTSRE6		MD_INTSRE6
#endif // #if ENABLE_UART6

#if ENABLE_CSI10
#pragma	interrupt	INTCSI10	MD_INTCSI10
#endif // #if ENABLE_CSI10

#if ENABLE_CSI11
#pragma	interrupt	INTCSI11	MD_INTCSI11
#endif // #if ENABLE_CSI10

/*
*******************************************************************************
**  Include files
*******************************************************************************
*/
#include "macrodriver.h"
#include "serial.h"
#include "debug.h"
#include "unet.h"
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#if ENABLE_CSI10
/* csi10 transmission */
volatile UCHAR*  CSI10_TX_ADDRESS;			/* csi10 transfer buffer address */
UCHAR   CSI10_TX_LEN;				/* csi10 transfer count number */
volatile UCHAR   CSI10_TX_CNT;

/* csi10 reception */
volatile UCHAR*  CSI10_RX_ADDRESS;			/* csi10 receive buffer address */
volatile UCHAR	CSI10_RX_LEN;				/* csi10 recive data count */
volatile UCHAR   CSI10_RX_CNT;
#endif // #if ENABLE_CSI10

#if ENABLE_CSI11
/* csi11 transmission */
volatile UCHAR*  CSI11_TX_ADDRESS;			/* csi11 transfer buffer address */
UCHAR   CSI11_TX_LEN;				/* csi11 transfer count number */
volatile UCHAR   CSI11_TX_CNT;

/* csi11 reception */
volatile UCHAR*  CSI11_RX_ADDRESS;			/* csi11 receive buffer head */
UCHAR	CSI11_RX_LEN;				/* csi11 recive data count */
volatile UCHAR   CSI11_RX_CNT;
#endif // #if ENABLE_CSI11

#if ENABLE_UART0
/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function initializes UART0 module.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
**-----------------------------------------------------------------------------
*/
void UART0_Init( void )
{
	char tmp;

	ASIM0 = 0;

	SetIORBit(P1, 0x01);
	ClrIORBit(PM1, 0x01);		/* port setting in reception/transmission mode */
	SetIORBit(ASIM0, 0x04);		/* data length  8 bits */
	ClrIORBit(ASIM0, 0x02);		/* stop length  1 bits */
	ClrIORBit(ASIM0, 0x18);		/* none parity mode */

	BRGC0 = UART_BAUDRATE_K0 |
		(UART_BAUDRATE_M0 << 6);	/* baudrate selection */

	ClrIORBit(IF1L, 0x02);
	ClrIORBit(MK1L, 0x02);		/* receive end interrupt enable */
	ClrIORBit(IF0H, 0x04);
	ClrIORBit(MK0H, 0x04);		/* transfer end interrupt enable */
	SetIORBit(PR1L, 0x02);		/* interrupt low */
	SetIORBit(PR0H, 0x04);		/* interrupt low */

	SetIORBit(ASIM0, 0x80);
	SetIORBit(ASIM0, 0x60);

	tmp = ASIS0;                   	// clear fake RX interrupt when power ON
	tmp = RXB0;
}

#if 0
/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function is responsible for UART0 data transfering.
**
**  Parameters:
**	txbuf:	transfer buffer pointer
**	txnum:	buffer size
**
**  Returns:
**	MD_OK
**	MD_ERROR
**
**-----------------------------------------------------------------------------
*/
MD_STATUS UART0_SendData( UCHAR* txbuf, UCHAR txnum )
{
	if( txnum < 1 ){
		return MD_ERROR;		/* 1 frame data at least */
	}

	UART0_TX_ADDRESS = txbuf;
	UART0_TX_CNT = txnum;

	TXS0 = *UART0_TX_ADDRESS++;

	return MD_OK;
}
#endif

/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function is the UART0 transfer end interrupt handler.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
**-----------------------------------------------------------------------------
*/
__interrupt void MD_INTST0( void )
{
#if 0
	UART0_TX_CNT--;

	if( UART0_TX_CNT == 0 ){
		/* transmit complete */
	//	CALL_UART0_Send();
	}
	else{
		TXS0 = *UART0_TX_ADDRESS++;
	}
#else
	uart_tx_isr();
#endif
}

/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function is the UART0 receive end interrupt handler.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
**-----------------------------------------------------------------------------
*/
__interrupt void MD_INTSR0( void )
{
#if 0
	UCHAR err_type;
	UINT8 tmp;
	UARTFIFO *rx = &uart0cb.rx;

	rx->buffer[tmp = rx->rear] = RXB0;

	if( err_type = ASIS0 ){
		/* error occured */
		if( err_type & 0x1 ){
			err_type = MD_OVERRUNERROR;		/* overrun error */
		}
		else if( err_type & 0x2 ){
			err_type = MD_FRAMEERROR;		/* framing error */
		}
		else{
			err_type = MD_PARITYERROR;		/* parity error */
		}

	//	CALL_UART0_Error( err_type );
	}
	else {
		tmp = (tmp + 1) & (UART_FIFO_SIZE - 1); // UART_FIFO_SIZE must be power of 2
		if(tmp != rx->front)
		        rx->rear = tmp;
	}
#else
	uart_rx_isr();
#endif
}
#endif // #if ENABLE_UART0

#if ENABLE_UART6
/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function initializes UART6 module.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
**-----------------------------------------------------------------------------
*/
void UART6_Init( void )
{
	char tmp;

	ASIM6 = 0;

	SetIORBit(P1, 0x08);			/* port setting in transmit/receive mode */
	ClrIORBit(PM1, 0x08);

	SetIORBit(ASIM6, 0x04);			/* data length 8 bits */
	ClrIORBit(ASIM6, 0x02);			/* stop length 1 bits */
	ClrIORBit(ASIM6, 0x01);
	ClrIORBit(ASIM6, 0x18);			/* none parity mode */
	SetIORBit(ASICL6, 0x02);		/* LSB first transfer */
	ClrIORBit(ASICL6, 0x01);		/* normal output of TxD6 */
	CKSR6 = UART_BAUDRATE_M6;		/* baudrate selection */
	BRGC6 = UART_BAUDRATE_K6;
	ClrIORBit(IF0H, 0x02);
	ClrIORBit(MK0H, 0x02);			/* transfer end interrupt enable */
	ClrIORBit(IF0H, 0x01);
	ClrIORBit(MK0H, 0x01);			/* receive end interrupt enable */
	SetIORBit(PR0H, 0x01);			/* interrupt low */
	SetIORBit(PR0H, 0x02);			/* interrupt low */
	ClrIORBit(IF0H, 0x80);
	ClrIORBit(MK0H, 0x80);			/* error interrupt enable */
	SetIORBit(PR0H, 0x80); 			/* interrupt low */

	SetIORBit(ASIM6, 0x80);
	SetIORBit(ASIM6, 0x60);			/* transmit/receive mode */

	tmp = ASIS6;                    	// clear fake RX interrupt when power ON
	tmp = RXB6;
}

#if 0
/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function is responsible for UART6 data transfering.
**
**  Parameters:
**	txbuf:	transfer buffer pointer
**	txnum:	buffer size
**
**  Returns:
**	MD_OK
**	MD_ERROR
**
**-----------------------------------------------------------------------------
*/
MD_STATUS UART6_SendData( UCHAR* txbuf, UCHAR txnum )
{
	if( txnum < 1 ){
		return MD_ERROR;	/* 1 frame data at least */
	}

	if(ASIF6 & 0x02) {
		return MD_DATAEXISTS;
	}

	UART6_TX_ADDRESS = txbuf;
	UART6_TX_CNT = txnum;

	TXB6 = *UART6_TX_ADDRESS++;
	return MD_OK;
}
#endif

/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function is the UART6 receive end interrupt handler.
**
**  Parameters:
**	None
**
**  Returns:
**	None
**
**-----------------------------------------------------------------------------
*/
__interrupt void MD_INTSR6( void )
{
#if 0
	UCHAR err_type;
	UINT8 tmp;
	UARTFIFO *rx = &UART_BUFF.rx;

	rx->buffer[tmp = rx->rear] = RXB6;

	if( err_type = ASIS6 ){
		if( err_type & 0x1 ){
			err_type = MD_OVERRUNERROR;		/* overrun error */
		}
		else if( err_type & 0x2 ){
			err_type = MD_FRAMEERROR;		/* framing error */
		}
		else{
			err_type = MD_PARITYERROR;		/* parity error */
		}

	//	CALL_UART6_Error( err_type );
	}
	else {
		tmp = (tmp + 1) & (UART_FIFO_SIZE - 1); // UART_FIFO_SIZE must be power of 2
		if(tmp != rx->front)
		        rx->rear = tmp;
	}
#else
	uart_rx_isr();
	if(is_CONSOLE_TxFlag()) {
		uart_tx_isr();
	}
#endif
}

/*
**-----------------------------------------------------------------------------
**
**  Abstract:
**	This function is the UART6 transfer end interrupt handler.
**
**  Parameters:
**	None
**
**  Returns:
**	None