dvb_sys.c

DVB软件,基于CT216软件的开发源程序.

	CT_GPIO_Initial();
	IOCFG_Initial();

	// io config is set by each ct module
	// init ct gpio
	DEV_IO_Initial();      //Marlin 20060616
	DEV_IO_Standby(FALSE); //Marlin 20060616

	//Initial ADC
    #ifndef CT956
	CT_ADC_Initial();
    #endif

	// key pad init and control
	DVB_FP_Init();
#ifndef P000_TEST	
	DVB_7SegOff();

	// Enable power led
	DVB_LEDShow(0, TRUE);
#endif	

	// init ct_iic before DVB_AVIO_Initialize, because Device AVIO may need IIC.
#if defined(CT216X)

    #if defined(CT216U) || defined(CT956)
    	if (CT_IIC_Initial(EN_CT_IIC_BUS_0, EN_CT_IIC_SPEED_80K) != DRV_OK)
    	{
    		SYS_MSG(("DEV_IIC_WARNING: CT_IIC_0_Initial Error\n"));
    	}	
    #endif

#else
    #ifdef ENABLE_SW_IIC
    	if (CT_SW_IIC_Initial(EN_CT_IIC_BUS_0, EN_CT_SW_IIC_SPEED_100K) != DRV_OK)
    	{
    		SYS_MSG(("DEV_IIC_WARNING: CT_SW_IIC_0_Initial Error\n"));
    	}	
    	else
    	{
    		EN_CT_GPIO_PORT	enIICSCLPort, enIICSDAPort;
    		EN_CT_GPIO_BIT	enIICSCLBit, enIICSDABit;

    	    if (IOCFG_GetIOLocation(EN_IIC_SCL0, &enIICSCLPort, &enIICSCLBit) != DRV_OK)
    	    {
    			enIICSCLPort = EN_CT_GPIO_PORT_INVALID;
    	    }
    	    if (IOCFG_GetIOLocation(EN_IIC_SDA0, &enIICSDAPort, &enIICSDABit) != DRV_OK)
    	    {
    			enIICSDAPort = EN_CT_GPIO_PORT_INVALID;
    	    }
    		CT_SW_IIC_SetSCLIOLocation(EN_CT_IIC_BUS_0, enIICSCLPort, enIICSCLBit);
    		CT_SW_IIC_SetSDAIOLocation(EN_CT_IIC_BUS_0, enIICSDAPort, enIICSDABit);
    	}

    	if (CT_SW_IIC_Initial(EN_CT_IIC_BUS_1, EN_CT_SW_IIC_SPEED_100K) != DRV_OK)
    	{
    		SYS_MSG(("DEV_IIC_WARNING: CT_SW_IIC_0_Initial Error\n"));
    	}	
    	else
    	{
    		EN_CT_GPIO_PORT	enIICSCLPort, enIICSDAPort;
    		EN_CT_GPIO_BIT	enIICSCLBit, enIICSDABit;

    	    if (IOCFG_GetIOLocation(EN_IIC_SCL1, &enIICSCLPort, &enIICSCLBit) != DRV_OK)
    	    {
    			enIICSCLPort = EN_CT_GPIO_PORT_INVALID;
    	    }
    	    if (IOCFG_GetIOLocation(EN_IIC_SDA1, &enIICSDAPort, &enIICSDABit) != DRV_OK)
    	    {
    			enIICSDAPort = EN_CT_GPIO_PORT_INVALID;
    	    }
    		CT_SW_IIC_SetSCLIOLocation(EN_CT_IIC_BUS_1, enIICSCLPort, enIICSCLBit);
    		CT_SW_IIC_SetSDAIOLocation(EN_CT_IIC_BUS_1, enIICSDAPort, enIICSDABit);
    	}
    #else
    	if (IOCFG_QueryIOFunction(EN_IIC_0) == DRV_OK)
    		if (CT_IIC_Initial(EN_CT_IIC_BUS_0, EN_CT_IIC_SPEED_80K) != DRV_OK)
    		{
    			SYS_MSG(("DEV_IIC_WARNING: CT_IIC_0_Initial Error\n"));
    		}	
    	if (IOCFG_QueryIOFunction(EN_IIC_1) == DRV_OK)
    		if (CT_IIC_Initial(EN_CT_IIC_BUS_1, EN_CT_IIC_SPEED_80K) != DRV_OK)
    		{
    			SYS_MSG(("DEV_IIC_WARNING: CT_IIC_1_Initial Error\n"));
    		}	
    #endif
#endif

	DVB_AVIO_Initialize();

#ifndef P000_TEST
	//    DVB_FlashLoadService();
	if (DVB_FlashCheckID(& stFlashInf) == TRUE) // no flash found
	{
#ifndef DBTOOL_ENABLE 	//reserved for old G2G update
#if !(defined(CT216S)||defined(CT216T) || defined (CT216H))

		{
			#include "xmodem.h"

			u8 u8ReceiveStatus;

			CT_OS_Local_Control_Interrupts(CTOS_DISABLE_INTERRUPTS);
			CT_UART_Enable_Interrupts(FALSE);
			u8ReceiveStatus = XmodemReceive();

			if (u8ReceiveStatus == 0)
			{
				while (1)
				{
					;
				}
			}

			CT_UART_Enable_Interrupts(TRUE);
			CT_OS_Local_Control_Interrupts(CTOS_ENABLE_INTERRUPTS);
		}
#endif
#endif
	}
	else
	{
		SYS_MSG(( "\n>> DVB_FlashCheckID() : Fail"));
	}
#endif /* end #ifndef P000_TEST */
#if (defined(CT216S)||defined(CT216T) || defined (CT216H))
    DVB_FilterInit(); // init filter before av
#endif    


#ifdef DSC_RESET_PER_SW_TP
    CT_DSC_Initial(DEMUX_DATAPATH_0);
#else

    #ifdef  CONAX
    	CT_DSC_Initial(DEMUX_DATAPATH_0);
    #endif
    #ifdef  TONGFANG
    	CT_DSC_Initial(DEMUX_DATAPATH_0);
    #endif
    #ifdef  TUI
    	CT_DSC_Initial(DEMUX_DATAPATH_0);
    #endif
#endif

	// init dvb_nim module
	DVB_TunerInit();
		
}

void DVB_SystemInit_First( void )
{
	DVB_AVInitParameters stAvInitParams;

	if( b8SystemInit_Zero==FALSE )
	{
		DVB_SystemInit_Zero();
	}

	if (pstSystemParameters != NULL)
	{
		stAvInitParams.enAudioPCMWordLength = pstSystemParameters->enAudioPCMWordLength;

		stAvInitParams.enAudioAlignFormat = pstSystemParameters->enAudioAlignFormat;
	}
	else
	{
		stAvInitParams.enAudioPCMWordLength = EN_AUDIO_PCM_LENGTH_24;

		stAvInitParams.enAudioAlignFormat = EN_AUDIO_ALIGN_FORMAT_I2S;
	}

#ifdef ATSC_SYSTEM
	stAvInitParams.b8VideoSystemPAL = FALSE;
#else
	stAvInitParams.b8VideoSystemPAL = TRUE;
#endif

#if !(defined(CT216S)||defined(CT216T) || defined (CT216H))

    #if defined(CT956)
    	if (
    	    IOCFG_QueryIOFunction(EN_UART_1_GPA) == DRV_OK ||
    	    IOCFG_QueryIOFunction(EN_UART_1_GPC) == DRV_OK ||
    	    IOCFG_QueryIOFunction(EN_UART_1_GPG) == DRV_OK
    	   )
    	{
    		CT_UART1_Initial();
    	}
    #else
    	if (IOCFG_QueryIOFunction(EN_UART_1) == DRV_OK)
    	{
    		CT_UART1_Initial();
    	}
    #endif

#endif

#ifdef CT216E
	if (IOCFG_QueryIOFunction(EN_UART_2) == DRV_OK)
	{
		CT_UART2_Initial();
	}

	CT_UCODE_Init();

	DVB_FilterInit(); // init demux before av
	DVB_AV_Init((DVB_AVInitParameters * )& stAvInitParams);
#endif


#if (defined(CT216S)||defined(CT216T) || defined (CT216H))
    SYS_MSG(("\n System Heap Size = %ld\n" ,CT_OS_GetHeapSize()));

    DVB_FilterInit(); // init filter before av

	DVB_AV_Init((DVB_AVInitParameters * )& stAvInitParams);


    if (DVB_TTX_VBI_Init () != TRUE)
    {
    	SYS_MSG(("\n\r>> DVB_TTX_VBI_Init: Fail!!"));
    }
#endif
#if (defined(CT216U)||defined(CT956))
    SYS_DBG(("\n System Heap Size = %d\n" ,CT_OS_GetHeapSize()));

	CT_DEMUX_Initial(); // init demux before av
	DVB_AV_Init((DVB_AVInitParameters * )& stAvInitParams);

    DVB_FilterInit(); // init filter after av
    if (DVB_TTX_VBI_Init () != TRUE)
    {
    	SYS_MSG(("\n\r>> DVB_TTX_VBI_Init: Fail!!"));
    }
#endif

#ifdef CT_OS_TASK_INFO
	EN_CTOS_STATUS  status;

	if(b8StackMonitorCreate == FALSE)
	{
	    status = CT_OS_CreateTimer(&StackMonitorTimer, "SMTIME", EN_CTOS_TIMER_CONTINUOUS, CT_OS_TaskUsage, 0, 50);
		if (status != EN_CTOS_SUCCESS)
		{
		    SYS_MSG(("\n\r##### [DVB_SystemInit_First] Create StackMonitorTimer Fail ##### "));
			return;
		}

		status = CT_OS_ControlTimer(&StackMonitorTimer, EN_CTOS_TIMER_ENABLE);
		if (status != EN_CTOS_SUCCESS)
		{
		    SYS_MSG(("\n\r##### DVB_SystemInit_First] Control StackMonitorTimer Fail ##### "));
		    return;
		}

		b8StackMonitorCreate = TRUE;
	}
	#endif

#if 1	
	DVB_SIBKInit();
	DVB_SIBK_Start();
#endif	
		
    #ifdef PVR_ENABLE
	//DVB_PVR_Initial();
	//DVB_PVR_CallBack_Initial();
    #endif

	#ifdef	D_UI
	DVB_SMC_Initial(EN_MODULE_SMC_0);
	#endif



}
/*******************************************************************************************/          

void DVB_SystemInit_Second( void )
{
	//RectanguleStrip_Init();

// 20080521 ism : It's un-necessary to show LOGO on video layer here.
#if 0
#ifndef P000_TEST
	#ifndef CT956
		DVB_IFrameShow(EN_IFRAM_VIDEO_LAYER, 0, 0);
	#endif /* end #ifndef CT216U */
#endif /* end #ifndef P000_TEST */	

	SYS_DBG(( ">>Show LOGO.\n"));
#endif

	//DVB_HardwareMute(FALSE);
#if 0	
	/* move to DVB_SystemInit_First, because it will be too late to start SIBK */	
	DVB_SIBKInit();
	DVB_SIBK_Start();
#endif	

}
/*******************************************************************************************/          

static bool8 ab8TimerTriggerEnable[8];
static bool8 ab8TimerEnable[8];
static u32 au32TimerTrigger[8];
static u16 au16TickValue[8] =
{
	100, 250, 500, 1000, 2000, 5000, 10000, 30000
};
/*******************************************************************************************/          

void DVB_TimerSetEvent( u8 u8TimerPeriod )
{
	u8 i;

	u32 u32CurrentTime;

	u32CurrentTime = DVB_TimerGet();

	if (CT_OS_WaitOnSemaphore(& stTimerSemaphore, CTOS_WAIT) != EN_CTOS_SUCCESS)
	{
		return;
	}

	for (i = 0; i<8; i++)
	{
		if (u8TimerPeriod&(1 << i))
		{
			ab8TimerEnable[i] = TRUE;
			au32TimerTrigger[i] = DVB_TimerPlus(u32CurrentTime, au16TickValue[i]);
			ab8TimerTriggerEnable[i] = FALSE;
		}
	}

	//    SYS_DBG(( "DVB_TimerSetEvent(%x)\n", u8TimerPeriod));

	// Free Semaphore
	CT_OS_FreeSemaphore(& stTimerSemaphore);
}
/*******************************************************************************************/          

void DVB_TimerClearEvent( u8 u8TimerPeriod )
{
	u8 i;

	if (CT_OS_WaitOnSemaphore(& stTimerSemaphore, CTOS_WAIT) != EN_CTOS_SUCCESS)
	{
		return;
	}

	for (i = 0; i<8; i++)
	{
		if (u8TimerPeriod&(1 << i))
		{
			ab8TimerEnable[i] = FALSE;
			ab8TimerTriggerEnable[i] = FALSE;
		}
	}

	// Free Semaphore
	CT_OS_FreeSemaphore(& stTimerSemaphore);

#ifdef CTOS_ECOS
	for (i = 0; i<8; i++)
	{
		if (u8TimerPeriod&(1 << i))
		{
		    while(ab8TimerTriggerEnable[i]==TRUE)
		    {
		        SYS_DBG(("waiting for dvb timer callback finish\n"));
		        CT_OS_Delay(1);
		    }
		}
	}
#endif

}
/*******************************************************************************************/          

static void _TimerCheck( void )
{
	u8 i;

	u32 u32CurrentTime;
	u8 u8PeriodType = 0;
	//EN_TIMER_EVENT_TYPE   TimeType;
	//static u32 u32Tick4SystemTime = 0;
	//static u32 u32KeepLastTick = 0;

	u32CurrentTime = DVB_TimerGet();

	if (CT_OS_WaitOnSemaphore(& stTimerSemaphore, CTOS_WAIT) != EN_CTOS_SUCCESS)
	{
		return;
	}

	for (i = 0; i<8; i++)
	{
		if (ab8TimerEnable[i] == TRUE && ab8TimerTriggerEnable[i] == FALSE)
		{
			//            SYS_DBG(( "_TimerCheck(%x, %x)\n", u32CurrentTime, au32TimerTrigger[i]));
			if (DVB_TimerAfter(u32CurrentTime, au32TimerTrigger[i]) == TRUE)
			{ /* if tiemr1(new) > timer2(old)  return true */
				u8PeriodType |= (1 << i);

				ab8TimerTriggerEnable[i] = TRUE;
			}
		}
	}

#ifdef CTOS_ECOS
	// Free Semaphore
	CT_OS_FreeSemaphore(& stTimerSemaphore);
#endif

	if (u8PeriodType != 0)
	{
		//			CT_OS_Change_Priority(&Sys_Task,EN_CTOS_PRIORITY_2);
		DVB_TimerEvent_Callback(u8PeriodType);
	//    		CT_OS_Change_Priority(&Sys_Task,DVB_SYS_TASK_PRIORITY);

	}

#ifdef CTOS_ECOS
	if (CT_OS_WaitOnSemaphore(& stTimerSemaphore, CTOS_WAIT) != EN_CTOS_SUCCESS)
	{
		return;
	}
#endif

	u32CurrentTime = DVB_TimerGet();

	for (i = 0; i<8; i++)
	{
		if (ab8TimerTriggerEnable[i] == TRUE)
		{
			au32TimerTrigger[i] = DVB_TimerPlus(u32CurrentTime, au16TickValue[i]);

			ab8TimerTriggerEnable[i] = FALSE;
		}
	}

	// Free Semaphore
	CT_OS_FreeSemaphore(& stTimerSemaphore);
}
/*******************************************************************************************/          

static void _TimerInit( void )
{
	u8 i;

	for (i = 0; i<8; i++)
	{
		ab8TimerEnable[i] = FALSE;

		ab8TimerTriggerEnable[i] = FALSE;
	}
}
/*******************************************************************************************/          

//CTOS_SEMAPHORE SysTimeSemaphore;
void _sys_task( u32 argc, void * argv )
{
	while (1)
	{
		_TimerCheck();

		CT_OS_Delay(_ms2tick(100));
	}
}
/*******************************************************************************************/          

bool8 DVB_System_AP_CH_SW_Suspend(void)
{
	if(_b8AP_CH_SW_Suspend == FALSE)
	{
		if(EN_CTOS_SUCCESS != CT_OS_SuspendTask(&AP_CH_SW_task_ctl))
		{
			return FALSE;
		}

		_b8AP_CH_SW_Suspend = TRUE;
	}

	return TRUE;
}

bool8 DVB_System_AP_CH_SW_Resume(void)
{
	if(_b8AP_CH_SW_Suspend == TRUE)
	{
		if(EN_CTOS_SUCCESS != CT_OS_ResumeTask(&AP_CH_SW_task_ctl))
		{
			return FALSE;
		}

		_b8AP_CH_SW_Suspend = FALSE;
	}
	
	return TRUE;
}

void DVB_SystemInit_Third( void )
{
	EN_CTOS_STATUS enStatus;

	#ifdef ENABLE_INSTANT_REPLAY
	EN_TSSTRM_INIT_STATUS enTsstrmStatus;
	#endif

	//    DVB_CleanKey();

#ifndef P000_TEST

#ifndef NO_INIT_SCART_IN_DVB	//(jin-035)
	DVB_ScartInit();
#endif							//(jin-036)

#endif /* end #ifndef P000_TEST */	
	//DVB_IFrameHide();
	// init ttx, subtitle

	// system clock
	enStatus = CT_OS_CreateTimer(& stSysTime, "SYSTIME", EN_CTOS_TIMER_CONTINUOUS, _dvb_SystemTimerRun, 0,
								 (u32)_ms2tick(1000));

	if (enStatus == EN_CTOS_SUCCESS)
	{
		CT_OS_ControlTimer(& stSysTime, EN_CTOS_TIMER_ENABLE);

		SYS_DBG(( "System Time Created\n"));
	}
	else
	{
		SYS_MSG(( "System Time Create Fail %d\n", enStatus));
	}

	// timer semaphore
	_TimerInit();

	enStatus = CT_OS_CreateSemaphore(& stTimerSemaphore, "SYSTIME", 1, EN_CTOS_SUSPEND_FIFO);

	if (enStatus == EN_CTOS_SUCCESS)
	{
		SYS_DBG(( "SysTimeSemaphore Created\n"));
	}
	else
	{
		SYS_MSG(( "SysTimeSemaphore Create Fail %d\n", enStatus));
	}

	// create channel switch task
	enStatus = CT_OS_CreateTask(& AP_CH_SW_task_ctl,   "AP_CH_SW",                    ap_ch_sw_task,
								& au8AP_CH_SWStack[0], DVB_CH_SWITCH_TASK_STACK_SIZE, DVB_CH_SWITCH_TASK_PRIORITY,
								DVB_CH_SWITCH_TASK_TIME_SLICE);

	if (enStatus != EN_CTOS_SUCCESS)
	{
		SYS_MSG(( "CH SW Task Create Fail %d\n", enStatus));
	}

	if (EN_CTOS_SUCCESS != CT_OS_ResumeTask(& AP_CH_SW_task_ctl))
	{
		SYS_MSG(( "System Task Resume Fail %d\n", enStatus));
	}

	//create sys task
	enStatus = CT_OS_CreateTask(& Sys_Task,            "DVBSYS", _sys_task, & au8SysStack[0], DVB_SYS_TASK_STACK_SIZE,
								DVB_SYS_TASK_PRIORITY, DVB_SYS_TASK_TIMESLICE);

	if (enStatus != EN_CTOS_SUCCESS)
	{
		SYS_MSG(( "System Task Create Fail %d\n", enStatus));
	}

	if (EN_CTOS_SUCCESS != CT_OS_ResumeTask(& Sys_Task))
	{
		SYS_MSG(( "System Task Resume Fail %d\n", enStatus));
	}

	//    DVB_AVIO_Initialize();

#if defined (TELETEXT_ON_OSD) || defined (CT216X)
	DVB_TTX_OSD_Init();
#endif


#ifdef ENABLE_SUBTITLE

	DVB_SbtlInit();

#endif


#ifdef ENABLE_INSTANT_REPLAY

	enTsstrmStatus = DVB_InstantReplayInit(TS_RING_BUFFER_SIZE, DVB_INSTANT_REPLAY_TASK_PRIORITY, DVB_INSTANT_REPLAY_TASK_TIME_SLICE);

	if (enTsstrmStatus != EN_TSSTRM_INIT_DONE)
	{
		SYS_MSG(( "Instant Replay Init Fail %d\n", enTsstrmStatus));
	}

#endif

//EITTestInit ();
// for Conax Ca Module
#ifdef  CONAX