uart.c

ST5100 driver files for ST chipset

/*****************************************************************************

File name	: uart.c

Description	: UART functions

COPYRIGHT (C) 2004 STMicroelectronics

*****************************************************************************/

/* Includes --------------------------------------------------------------- */
#ifdef REPORT_TO_CONSOLE
   #include <stdio.h>
#endif
#include <string.h>

#include "stdevice.h"
#include "stsys.h"

#include "app_data.h"
#include "common.h"
#include "errors.h"     /* error code related functions */
#include "pio.h"
#include "sections.h"   /* memory partitions */
#include "uart.h"

#define UART_END_OF_LIST 0xff

/* Private Types ------------------------------------------------------ */

/* Private Constants -------------------------------------------------- */

/* Private Variables -------------------------------------------------- */
static U8 InitList[] = { DATA_UART_DEV, MODEM_UART_DEV, SC0_UART_DEV, SC1_UART_DEV, UART_END_OF_LIST };

/* Private Macros ----------------------------------------------------- */

/* Private Function prototypes ---------------------------------------- */

/* Global ----------------------------------------------------------------- */

ST_DeviceName_t UART_DeviceName[] = {"UART0","UART1","UART2","UART3", "UART4"};

STUART_Handle_t UART_Handle[UART_DEVICES];

#define NUMBER_PIO              6
#define NUMBER_ASC              4

#define ASC_DEVICE_SC0          ASC_DEVICE_0
#define ASC_DEVICE_SC1          ASC_DEVICE_2
#define ASC_DEVICE_DATA         ASC_DEVICE_3
#define ASC_DEVICE_MODEM        ASC_DEVICE_2

static STUART_InitParams_t  UartInitParams;

#if defined(MODULE_HMC)
static STUART_InitParams_t  UartInitParams2;
static STUART_InitParams_t  UartInitParams3;
#endif

/* Functions ---------------------------------------------------------- */


/*-------------------------------------------------------------------------
 * Function : uart_init
 *          : Initialise the UART driver
 * Input    : Instance
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t UART_Setup( void)
{
	ST_ErrorCode_t      ST_ErrorCode = ST_NO_ERROR;
	STUART_Params_t UartDefaultParams;
#if defined(MODULE_HMC)
	STUART_Params_t UartDefaultParams2;
	STUART_Params_t UartDefaultParams3;	
#endif

	memset((void *)&UartInitParams, 0, sizeof(STUART_InitParams_t));
	memset((void *)&UartDefaultParams, 0, sizeof(STUART_Params_t));

	/* Setup clock info */
	(void)ST_GetClockInfo(&ST_ClockInfo);

	/* Global setup of uart init. params */
	/* Zero port definitions */
	UartInitParams.RXD.PortName[0] = '\0';
	UartInitParams.TXD.PortName[0] = '\0';
	UartInitParams.RTS.PortName[0] = '\0';
	UartInitParams.CTS.PortName[0] = '\0';

	UartDefaultParams.RxMode.DataBits = STUART_8BITS_NO_PARITY;
	UartDefaultParams.RxMode.StopBits = STUART_STOP_1_0;
	UartDefaultParams.RxMode.FlowControl = STUART_NO_FLOW_CONTROL;
#if defined(_CARD_SHARING_NEW_)
	UartDefaultParams.RxMode.BaudRate = 19200;
#else
	UartDefaultParams.RxMode.BaudRate = 115200;
#endif
	UartDefaultParams.RxMode.NotifyFunction = NULL;
	UartDefaultParams.RxMode.TermString     = NULL;
	UartDefaultParams.RxMode.TimeOut        = 1;      /* As short as possible */
	UartDefaultParams.TxMode.DataBits = STUART_8BITS_NO_PARITY;
	UartDefaultParams.TxMode.StopBits = STUART_STOP_1_0;
	UartDefaultParams.TxMode.FlowControl = UartDefaultParams.RxMode.FlowControl;
#if defined(_CARD_SHARING_NEW_)
	UartDefaultParams.TxMode.BaudRate = 19200;
#else
	UartDefaultParams.TxMode.BaudRate = 115200;
#endif
	UartDefaultParams.TxMode.TermString = NULL;
	UartDefaultParams.TxMode.TimeOut        = 0;    /* No time-out            */
	UartDefaultParams.TxMode.NotifyFunction = NULL;
	UartDefaultParams.SmartCardModeEnabled = FALSE;
	UartDefaultParams.GuardTime = 0;
	UartDefaultParams.NACKSignalDisabled    = FALSE; /* Not used, only for smartcard */
	UartDefaultParams.HWFifoDisabled        = FALSE; /* Not used, only for smartcard */

	UartInitParams.UARTType        = ASC_DEVICE_TYPE;
	UartInitParams.DriverPartition = (ST_Partition_t *)system_partition;
	UartInitParams.BaseAddress     = (U32 *)ASC_3_BASE_ADDRESS;
	UartInitParams.InterruptNumber = ASC_3_INTERRUPT;
	UartInitParams.InterruptLevel  = ASC_3_INTERRUPT_LEVEL;
	UartInitParams.ClockFrequency  = ST_ClockInfo.CommsBlock;

	UartInitParams.SwFIFOEnable    = TRUE;
	UartInitParams.FIFOLength      = 256;
	strcpy(UartInitParams.RXD.PortName, PIO_GET_DEVICENAME(ASC_3_RXD_DEV));
	UartInitParams.RXD.BitMask     = ASC_3_RXD_BIT;
	strcpy(UartInitParams.TXD.PortName, PIO_GET_DEVICENAME(ASC_3_TXD_DEV));
	UartInitParams.TXD.BitMask     = ASC_3_TXD_BIT;
	strcpy(UartInitParams.RTS.PortName, PIO_GET_DEVICENAME(ASC_3_RTS_DEV));
	UartInitParams.RTS.BitMask     = ASC_3_RTS_BIT;
	strcpy(UartInitParams.CTS.PortName, PIO_GET_DEVICENAME(ASC_3_CTS_DEV));
	UartInitParams.CTS.BitMask     = ASC_3_CTS_BIT;

	UartInitParams.DefaultParams   = &UartDefaultParams; 

	ST_ErrorCode = STUART_Init("UART3", &UartInitParams);
#ifdef STTBX_PRINT
	if(ST_ErrorCode != ST_NO_ERROR)
	{
		/*STUART is not initialized*/
		printf("STUART ERROR\n");
	}
	LOCAL_PRINT(("STUART_Init()=%s\n",GetErrorText(ST_ErrorCode)));
#endif

#if defined(MODULE_HMC)
	/* Uart Init STB < -- > Front Comunication */
	memset((void *)&UartInitParams2, 0, sizeof(STUART_InitParams_t));
	memset((void *)&UartDefaultParams2, 0, sizeof(STUART_Params_t));

	/* Global setup of uart init. params */
	/* Zero port definitions */
	UartInitParams2.RXD.PortName[0] = '\0';
	UartInitParams2.TXD.PortName[0] = '\0';
	UartInitParams2.RTS.PortName[0] = '\0';
	UartInitParams2.CTS.PortName[0] = '\0';

	UartDefaultParams2.RxMode.DataBits = STUART_8BITS_NO_PARITY;
	UartDefaultParams2.RxMode.StopBits = STUART_STOP_2_0;
	UartDefaultParams2.RxMode.FlowControl = STUART_NO_FLOW_CONTROL;
	UartDefaultParams2.RxMode.BaudRate = 2400;
	UartDefaultParams2.RxMode.NotifyFunction = NULL;
	UartDefaultParams2.RxMode.TermString     = NULL;
	UartDefaultParams2.RxMode.TimeOut        = 0;      /* As short as possible */
	UartDefaultParams2.TxMode.DataBits = STUART_8BITS_NO_PARITY;
	UartDefaultParams2.TxMode.StopBits = STUART_STOP_2_0;
	UartDefaultParams2.TxMode.FlowControl = UartDefaultParams2.RxMode.FlowControl;
	UartDefaultParams2.TxMode.BaudRate = 2400;
	UartDefaultParams2.TxMode.TermString = NULL;
	UartDefaultParams2.TxMode.TimeOut        = 0;    /* No time-out            */
	UartDefaultParams2.TxMode.NotifyFunction = NULL;
	UartDefaultParams2.SmartCardModeEnabled = FALSE;
	UartDefaultParams2.GuardTime = 0;
	UartDefaultParams2.NACKSignalDisabled    = FALSE; /* Not used, only for smartcard */
	UartDefaultParams2.HWFifoDisabled        = FALSE; /* Not used, only for smartcard */

	UartInitParams2.UARTType        = ASC_DEVICE_TYPE;
	UartInitParams2.DriverPartition = (ST_Partition_t *)system_partition;
	UartInitParams2.BaseAddress     = (U32 *)ASC_1_BASE_ADDRESS;
	UartInitParams2.InterruptNumber = ASC_1_INTERRUPT;
	UartInitParams2.InterruptLevel  = ASC_1_INTERRUPT_LEVEL;
	UartInitParams2.ClockFrequency  = ST_ClockInfo.CommsBlock;

	UartInitParams2.SwFIFOEnable    = TRUE;
	UartInitParams2.FIFOLength      = 256;
	strcpy(UartInitParams2.RXD.PortName, PIO_GET_DEVICENAME(ASC_1_RXD_DEV));
	UartInitParams2.RXD.BitMask     = ASC_1_RXD_BIT;
	strcpy(UartInitParams2.TXD.PortName, PIO_GET_DEVICENAME(ASC_1_TXD_DEV));
	UartInitParams2.TXD.BitMask     = ASC_1_TXD_BIT;
	strcpy(UartInitParams2.RTS.PortName, PIO_GET_DEVICENAME(ASC_1_RTS_DEV));
	UartInitParams2.RTS.BitMask     = ASC_1_RTS_BIT;
	strcpy(UartInitParams2.CTS.PortName, PIO_GET_DEVICENAME(ASC_1_CTS_DEV));
	UartInitParams2.CTS.BitMask     = ASC_1_CTS_BIT;

	UartInitParams2.DefaultParams   = &UartDefaultParams2; 

	ST_ErrorCode = STUART_Init("UART1", &UartInitParams2);
#ifdef STTBX_PRINT
	if(ST_ErrorCode != ST_NO_ERROR)
	{
		/*STUART is not initialized*/
		printf("STUART1 Front ERROR\n");
	}
	LOCAL_PRINT(("STUART1_Init(FRONT)=%s\n",GetErrorText(ST_ErrorCode)));
#endif

	/* Uart Init STB < -- > PC Comunication */
	memset((void *)&UartInitParams3, 0, sizeof(STUART_InitParams_t));
	memset((void *)&UartDefaultParams3, 0, sizeof(STUART_Params_t));

	/* Global setup of uart init. params */
	/* Zero port definitions */
	UartInitParams3.RXD.PortName[0] = '\0';
	UartInitParams3.TXD.PortName[0] = '\0';
	UartInitParams3.RTS.PortName[0] = '\0';
	UartInitParams3.CTS.PortName[0] = '\0';

	UartDefaultParams3.RxMode.DataBits = STUART_8BITS_NO_PARITY;
	UartDefaultParams3.RxMode.StopBits = STUART_STOP_2_0;
	UartDefaultParams3.RxMode.FlowControl = STUART_NO_FLOW_CONTROL;
	UartDefaultParams3.RxMode.BaudRate = 19200;
	UartDefaultParams3.RxMode.NotifyFunction = NULL;
	UartDefaultParams3.RxMode.TermString     = NULL;
	UartDefaultParams3.RxMode.TimeOut        = 0;      /* As short as possible */
	UartDefaultParams3.TxMode.DataBits = STUART_8BITS_NO_PARITY;
	UartDefaultParams3.TxMode.StopBits = STUART_STOP_2_0;
	UartDefaultParams3.TxMode.FlowControl = UartDefaultParams3.RxMode.FlowControl;
	UartDefaultParams3.TxMode.BaudRate = 19200;
	UartDefaultParams3.TxMode.TermString = NULL;
	UartDefaultParams3.TxMode.TimeOut        = 0;    /* No time-out            */
	UartDefaultParams3.TxMode.NotifyFunction = NULL;
	UartDefaultParams3.SmartCardModeEnabled = FALSE;
	UartDefaultParams3.GuardTime = 0;
	UartDefaultParams3.NACKSignalDisabled    = FALSE; /* Not used, only for smartcard */
	UartDefaultParams3.HWFifoDisabled        = FALSE; /* Not used, only for smartcard */

	UartInitParams3.UARTType        = ASC_DEVICE_TYPE;
	UartInitParams3.DriverPartition = (ST_Partition_t *)system_partition;
	UartInitParams3.BaseAddress     = (U32 *)ASC_2_BASE_ADDRESS;
	UartInitParams3.InterruptNumber = ASC_2_INTERRUPT;
	UartInitParams3.InterruptLevel  = ASC_2_INTERRUPT_LEVEL;
	UartInitParams3.ClockFrequency  = ST_ClockInfo.CommsBlock;

	UartInitParams3.SwFIFOEnable    = TRUE;
	UartInitParams3.FIFOLength      = 256;
	strcpy(UartInitParams3.RXD.PortName, PIO_GET_DEVICENAME(ASC_2_RXD_DEV));
	UartInitParams3.RXD.BitMask     = ASC_2_RXD_BIT;
	strcpy(UartInitParams3.TXD.PortName, PIO_GET_DEVICENAME(ASC_2_TXD_DEV));
	UartInitParams3.TXD.BitMask     = ASC_2_TXD_BIT;
	strcpy(UartInitParams3.RTS.PortName, PIO_GET_DEVICENAME(ASC_2_RTS_DEV));
	UartInitParams3.RTS.BitMask     = ASC_2_RTS_BIT;
	strcpy(UartInitParams3.CTS.PortName, PIO_GET_DEVICENAME(ASC_2_CTS_DEV));
	UartInitParams3.CTS.BitMask     = ASC_2_CTS_BIT;

	UartInitParams3.DefaultParams   = &UartDefaultParams3; 

	ST_ErrorCode = STUART_Init("UART2", &UartInitParams3);
#ifdef STTBX_PRINT
	if(ST_ErrorCode != ST_NO_ERROR)
	{
		/*STUART is not initialized*/
		printf("STUART1 PC ERROR\n");
	}
	LOCAL_PRINT(("STUART1_Init(PC)=%s\n",GetErrorText(ST_ErrorCode)));
#endif
#endif /*MODULE_HMC */

	return (ST_ErrorCode);
}

/*-------------------------------------------------------------------------
 * Function : UART_Term
 *          :
 * Input    :
 * Output   :
 * Return   : Error Code
 * ----------------------------------------------------------------------*/
ST_ErrorCode_t UART_Term(void)
{
    ST_ErrorCode_t ST_ErrorCode = ST_NO_ERROR;
    U8 Index;

    STUART_TermParams_t UART_TermParams;
    UART_TermParams.ForceTerminate = TRUE;
    for ( Index = 0; InitList[Index] != UART_END_OF_LIST; Index++ )
    {
        ST_ErrorCode |= STUART_Term(UART_DeviceName[InitList[Index]], &UART_TermParams);;
    }

    return ( ST_ErrorCode );
}



/* EOF --------------------------------------------------------------------- */