sn15test.c

ST5100 driver files for ST chipset

		//  thomson SSS_DBG(CH,_INFO_,("[CH] ParseDemodEvents() g_DiSEqCEvents = 0x%08x, \n\r", g_DiSEqCEvents )); 
		/* Processing DiSEqC Operation at here */
		//FE_DRV_main(SNIM_DRV_DISEQCDONE);
		//  thomson WM_SendMessage(g_ChannelInfo[CHANNEL0_DiSEqC_SESSION].msgHandle /*g_ChannelInfo[CHANNEL0_TUNE_SESSION].msgHandle*/, CH_CH_DISEQC_DISEQC_SET, g_DiSEqCEvents, 0, 0);  
	}

	if (DemodEvents& SNIM_EVENT_DISEQCWAIT)
		//  thomson SSS_DBG(CH,_INFO_,("ParseDemodEvents():: SNIM_EVENT_DISEQCWAIT!\t\t[%10d]!! \n\r", dwClock));

	if (DemodEvents& SNIM_ERROR_SCAN)
	{
		//  thomson SSS_DBG(CH,_ERROR_,("ParseDemodEvents():: SNIM_ERROR_SCAN!\t\t[%10d]!! \n\r", dwClock));

		/* Demod Command */
		SnimCommand(g_hTheSnim,SNIM_COMMAND_SCAN_ABORT);

		// search end.
		//  thomson DRV_CHANNEL_SCAN_End (WM_CH_BLIND_TUNE_END, 0, 0, 0);
		//  thomson g_isBlindScanning=FALSE;
		//  thomson g_BlindSearchProgress = 1000;


		//  thomson SSS_ASSERT(CI, (0));
	}


}

int Snim_Drv_Get_Strength(void)
{
	return SnimRead(g_hTheSnim,SNIM_DATA_AGC)/10;    
}

int Snim_Drv_Get_Quality(void)
{
	return SnimRead(g_hTheSnim,SNIM_DATA_EBNOx10);
}

int Snim_Drv_ScanContinue(void)
{
	return SnimCommand(g_hTheSnim,SNIM_COMMAND_SCAN_CONTINUE);
}

int Snim_Drv_ScanAbort(void)
{
	return SnimCommand(g_hTheSnim,SNIM_COMMAND_SCAN_ABORT);
}

void Snim_Drv_DiSEqCWrite(int count, unsigned char * pBuf)
{
	BOOL bResults;
	int i;
	SSnimDiSEqCMessage Message;           
	unsigned char buffer;

	Message.count = count;

	#if 0
	printSn15Error(("@@@ Snim_Drv_DiSEqCWrite @@@\n\r"));	
	for (i=0;i<count;i++) 
	{
		Message.data[i] = pBuf[i];
		printSn15Error(("0x%02X ",Message.data[i]));
	}
	printSn15Error(("\n@@@ @@@@@@@@@@@@@@@@ @@@\n\r"));	
	#else	
	for (i=0;i<count;i++) 
	{
		Message.data[i] = pBuf[i];
	}

	#endif
	Message.parity = 0;/* No Parity Error */

	bResults = SnimSendDiSEqC(g_hTheSnim, (SSnimDiSEqCMessage *)&Message);

	if(bResults)
	{		
		printSn15(("Snim_Drv_DiSEqCWrite(): COMMAND Data SUCCESSFULLY  [%x]!!!\n\r",pBuf[0]));
	}
	else
	{		
		printSn15Error(("Snim_Drv_DiSEqCWrite(): SET Command ERROR ==Unknown Value[%x]???\n\r",pBuf[0]));
	}

	bResults = SnimSetDiSEqCMode(g_hTheSnim, SNIM_DISEQC_MODE_XMITGO); //Set DiSEqC Mode and Start Transmission.
	if(bResults)
	{		
		printSn15(("Snim_Drv_DiSEqCWrite():: Set DiSEqC Mode and Start Transmission SUCCESSFULLY  [%x]!!!\n\r",pBuf[0]));
		
	}
	else
	{
		//printSn15Error(("Snim_Drv_DiSEqCWrite():: Set DiSEqC Mode and Start Transmission ERROR ==Unknown Value[%x]??????????\n\r",pBuf[0]));

	}

}

BOOL Snim_Drv_GetDiSEqCState(void)
{
	ESnimDiSEqCState sResult;
	sResult = SnimGetDiSEqCState(g_hTheSnim);
	if (sResult == SNIM_DISEQC_STATE_IDLE)//ZL10313 goes to 22KHz OFF mode when finishing transmission.
        {
            return TRUE;
        }
        else
        {            
            return FALSE;
        }           
	
}

BOOL Snim_Drv_SetDisEqCModeLNB22KHzTone(unsigned char ucValue)
{
	BOOL bResults;
	
	FE_Wait(17);
	
	if(ucValue == 1)//LNB22KHzTone_ON
	{
		bResults = SnimSetDiSEqCMode(g_hTheSnim, SNIM_DISEQC_MODE_HIBAND); //Set LOBAND .
		printSn15(("Snim_Drv_SetDisEqCMode : LNB22KHzTone_ON : Err : %x\n",bResults));
	}
	else
	{
		bResults = SnimSetDiSEqCMode(g_hTheSnim, SNIM_DISEQC_MODE_LOBAND); //Set LOBAND .
		printSn15(("Snim_Drv_SetDisEqCMode : LNB22KHzTone_OFF : Err : %x\n",bResults));
	}	
	return bResults;
}

BOOL Snim_Drv_SetDisEqCModeToneBurst(unsigned char ucValue)
{
	BOOL bResults;

	FE_Wait(17);
	
	if(ucValue == 1)//SNIM_DISEQC_MODE_BURSTA
	{
		bResults = SnimSetDiSEqCMode(g_hTheSnim, SNIM_DISEQC_MODE_BURSTA); //Set LOBAND .
		printSn15(("Snim_Drv_SetDisEqCMode : SNIM_DISEQC_MODE_BURSTA : Err : %x\n",bResults));
	}
	else if(ucValue == 2)//SNIM_DISEQC_MODE_BURSTB
	{
		bResults = SnimSetDiSEqCMode(g_hTheSnim, SNIM_DISEQC_MODE_BURSTB); //Set LOBAND .
		printSn15(("Snim_Drv_SetDisEqCMode : SNIM_DISEQC_MODE_BURSTA : Err : %x\n",bResults));
	}
	else
	{
		printSn15(("Snim_Drv_SetDisEqCMode : SNIM_DISEQC_MODE_BURSTA : Err : %x\n",bResults));
	}
}

unsigned char Snim_Drv_Set_CodeRate(unsigned char ucValue)
{
	printSn15(("@@@ Snim_Drv_Set_CodeRate ++ ucValue : %d \n\r",ucValue));
	
	switch (ucValue)
	{
		case 0://  1/2
			return  ( 1 & SCHANNELEXT_CODERATE);
		case 1://  2/3
			return  ( 2 & SCHANNELEXT_CODERATE);
		case 2://  3/4
			return  ( 3 & SCHANNELEXT_CODERATE);
		case 3://  5/6
			return  ( 5 & SCHANNELEXT_CODERATE);
		case 4://  7/8
			return  ( 7 & SCHANNELEXT_CODERATE);
		default:
			return  ( 1 & SCHANNELEXT_CODERATE);
		
	}	
	
}

void Snim_Drv_SetLNB(unsigned char ucAntType,unsigned int ulLnbFreq,unsigned int ulSnimFreq)
{
	SSnimLnb lnb = {0};
	printSn15(("Snim_Drv_SetLNB ++ ucAntType : %x ulLnbFreq : %d ulSnimFreq : %d \n\r",ucAntType,ulLnbFreq,ulSnimFreq));			
			
	ulLnbFreq = ulLnbFreq/1000;
	ulSnimFreq = ulSnimFreq/1000;
	printSn15(("Snim_Drv_SetLNB ++ ucAntType : %x ulLnbFreq : %d ulSnimFreq : %d \n\r",ucAntType,ulLnbFreq,ulSnimFreq));		
	lnb.LoBandLO=0;
	lnb.LoHiSwap=0;
	lnb.Delay_ms = 10;
	switch (ucAntType)
	{
		case  SNIM_LNB1:lnb.HiBandLO=10600;
						lnb.LoBandLO=9750;
						lnb.LoHiSwap=11700;
						break;
		case  SNIM_LNB2:lnb.HiBandLO=10750;
						lnb.LoBandLO=9750;
						lnb.LoHiSwap=11700;
						break;
		default:/* error keep the original*/
			{
				lnb.HiBandLO=ulLnbFreq;
				lnb.LoBandLO=ulLnbFreq;
				if(ulSnimFreq < 11700)
				{
					lnb.LoHiSwap=ulSnimFreq-50;
				}
				else
				{
					lnb.LoHiSwap=ulSnimFreq+50;
				}
			}
				
	}
	printSn15((">> lnb.HiBandLO : %d \n\r",lnb.HiBandLO));
	printSn15((">> lnb.LoBandLO : %d\n",lnb.LoBandLO));
	printSn15((">> lnb.LoHiSwap : %d\n",lnb.LoHiSwap));
	SnimSetLnb(g_hTheSnim,&lnb);	
		
	printSn15(("Snim_Drv_SetLNB --\n\r"));
}

unsigned char Snim_Drv_Set_SatAB(unsigned char ucValue)
{

	printSn15(("Snim_Drv_Set_SatAB ++ ucValue : %d \n\r",ucValue));
	//ToneBurst ON/OFF
	switch (ucValue)
	{
		case 1:
			return 0;
		case 2:
			return 1;
		default:
			return 0;
	}
}

unsigned char Snim_Drv_Set_Polarisation(unsigned char ucValue)
{
	switch (ucValue)
	{
		case 0://Ver
			return ( 0 & SCHANNELEXT_HORIZONTAL);
		case 1://Hor
			return ( 8 & SCHANNELEXT_HORIZONTAL);
		default:
			return ( 0 & SCHANNELEXT_HORIZONTAL);
	}
}


unsigned char Snim_Drv_Set_New_TuneData(DRV_TUNER_PARAM *pParam)
{

	PSSNIMCTL pNim = (PSSNIMCTL)g_hTheSnim;
	
	printSn15(("Snim_Drv_Set_New_TuneData ++\n\r"));
	printSn15((">>ulSnimFrequency : %d \n\r",pParam->Sat.ulSnimFrequency));
	printSn15((">>wSymbolRate : %d \n\r",pParam->Sat.wSymbolRate));
	printSn15((">>ulLnbFrequency : %d \n\r",pParam->Sat.ulLnbFrequency));
	printSn15((">>ucConvolutionCode : %d \n\r",pParam->Sat.ucConvolutionCode));
	
	
	pNim->Channel.MHz= (pParam->Sat.ulSnimFrequency/1000);//pTunerParams->TransponderFrequency;
	pNim->Channel.kRs= pParam->Sat.wSymbolRate;
	pNim->Channel.ucSat = Snim_Drv_Set_SatAB(pParam->Sat.ucToneBurst);	
	pNim->Channel.ucExt = Snim_Drv_Set_CodeRate(pParam->Sat.ucConvolutionCode);
	pNim->Channel.ucExt |= Snim_Drv_Set_Polarisation(pParam->Sat.ucPolarisation);

	Snim_Drv_SetLNB(pParam->Sat.ucLnbUniversal,pParam->Sat.ulLnbFrequency,pParam->Sat.ulSnimFrequency);

	printSn15(("Snim_Drv_Set_New_TuneData --\n\r"));
	
}


ESnimState Snim_Drv_GetDemodState(void)
{
	Sint32T DemodState;

	DemodState = Snim_GetDemodState(g_hTheSnim);

	switch(DemodState)
	{

		case SNIM_STATE_ERROR:/*psSnim sTructure has pointer errors*/
		case SNIM_STATE_OFF:/* MT312 not found or not powered*/
		case SNIM_STATE_STANDBY:/* MT312 powered but in standby power mode*/	
		case SNIM_STATE_IDLE:/* fully powered, but not doing anything*/
		case SNIM_STATE_WAITING:/* waiting for external operation (e.g. diseqc) to complete*/			
		case SNIM_STATE_SCANNING:/* scan is in progress*/		
		case SNIM_STATE_BUSY:/* system busy (resetting/waiting for lock/calibrating tuner*/ 
			{
				FE_Wait(30);		/*   */
				printSn15("Snim_Drv_GetDemodState():: !!!!!    Not     LOCK   !!!!!!!!!!!!!! \n\r");		
			}
			break;
			
		case SNIM_STATE_LOCKED:/* locked to a signal*/
			{
				SSnimChannel sChannel;
				printSn15("Snim_Drv_GetDemodState():: !!!!!    OK     LOCK   !!!!!!!!!!!!!! \n\r");
				SnimReadChannel(g_hTheSnim, &sChannel);
			}
			break;		
		default:
			break;
	}
		
	return DemodState;
}
	
unsigned char Snim_Drv_Run_Acquisition(void)
{
		unsigned char errCode;
		PSSNIMCHANNEL pTheSnimChannel   = (PSSNIMCHANNEL)&(((PSSNIMCTL)g_hTheSnim)->Channel);
		PSSNIMCTL pTheSnim              = (PSSNIMCTL)g_hTheSnim;

		printSn15(("Snim_Drv_Run_Acquisition ++\n\r"));
		printSn15(("Snim_Drv_Run_Acquisition():: FR[%5d]/SR[%5d]/EXT[%#02X]/SAT[%#02X]===\n\r",pTheSnimChannel->MHz,pTheSnimChannel->kRs,pTheSnimChannel->ucExt,pTheSnimChannel->ucSat));

		
		errCode = SnimAcquire(g_hTheSnim,pTheSnimChannel);//ACQUISITION
		if(errCode) 
		{

			printSn15((">> SNIM_DATA_TUNERFREQ : %d \n\r",SnimRead(g_hTheSnim,SNIM_DATA_TUNERFREQ)));
			printSn15(("Snim_Drv_Run_Acquisition   No Error during acquire []!!!!!!!!\n\r"));
			printSn15(("Snim_Drv_Run_Acquisition --\n\r"));
			return errCode;
		}
		else
		{
			printSn15(("FE_DRV_main():: SNIM_DRV_RUN_ACQUISITION   Error DemodFsmState[%d]n", Snim_GetDemodState(g_hTheSnim)));
			return errCode;
		}
		
}

unsigned char Snim_Drv_Run_Stop(void)
{

	int timeout = 100;
	Sint32T DemodState;
	
	printSn15((">> Snim_Drv_Run_Stop ++\n\r"));
	/* stop scanning by user */
	if (Snim_GetDemodState(g_hTheSnim) >= SNIM_STATE_WAITING)
	{
		printSn15(("[CH] **********SNIM_DRV_RUN_STOP*******\n\r"));
		SnimCommand(g_hTheSnim,SNIM_COMMAND_SCAN_ABORT);
	}

	while( (DemodState > SNIM_STATE_LOCKED) && timeout--)
	{
		DemodState = SnimRead(g_hTheSnim, SNIM_DATA_DEMODSTATE); //READ 
		printSn15(("FE_DRV_main():: SNIM_DRV_RUN_STOP!!!!!DemodState[%d]!!timeout[%d]! \n\r", DemodState,timeout));
		#if defined(TUNER_TIMING_SHORTEN)
		FE_Wait(2);
		#else
		FE_Wait(10);
		#endif
	}
	printSn15((">> Snim_Drv_Run_Stop --\n\r"));
}

void Snim_Drv_Stream_Disable(void)
{
		printSn15((">>> FE_DRV_main : SNIM_DRV_RESET_PROCESS !!!\n\r"));
		
		SnimCommand(g_hTheSnim,SNIM_COMMAND_MPEG_DISABLE);//stream disable STATE

}

void Snim_Drv_Stream_Enable(void)
{
		printSn15((">>> FE_DRV_main : SNIM_DRV_RESET_PROCESS !!!\n\r"));
		
		SnimCommand(g_hTheSnim,SNIM_COMMAND_MPEG_ENABLE);//stream enable STATE

}		

void Snim_Drv_Reset_Process(void)
{
		printSn15((">>> FE_DRV_main : SNIM_DRV_RESET_PROCESS !!!\n\r"));
		
		SnimCommand(g_hTheSnim,SNIM_COMMAND_POWER_OFF);//STANDBY STATE
		FE_Wait(250);
		SnimCommand(g_hTheSnim,SNIM_COMMAND_POWER_ON);//READY STATE

}		
void Snim_Drv_Get_TuningParameter(void)
{
		SSnimChannel sChannel;
		printSn15((">>> Snim_Drv_Get_TuningParameter !!!\n\r"));
		SnimReadChannel(g_hTheSnim, &sChannel);
		printSn15((">>> sChannel.MHz : %d \n\r",sChannel.MHz));
		printSn15((">>> sChannel.kRs : %d \n\r",sChannel.kRs));
		printSn15((">>> sChannel.ucExt : %d \n\r",sChannel.ucExt));
		printSn15((">>> sChannel.ucSat : %d \n\r",sChannel.ucSat));
    		printSn15(("##############################\n\r"));
}
Uint32T Snim_Drv_Run_Monitor(void)
{
	Uint32T dwDemodEvents;

	/* update the time(g_dwClock) */
	TestsnimUpdateClock(&g_dwClock);        /* update the time */
	/* run the demodulator state machine */	
	dwDemodEvents=SnimMain(g_hTheSnim,g_dwClock);	
	
	return dwDemodEvents;
	
}

BOOL TestsnimDiSEqCCallBack(Uint32T ulCammand)
{
	//g_DiSEqCEvents = ulCammand;
	printSn15(("[FE] TestsnimDiSEqCCallBack() g_DiSEqCEvents = 0x%08x, \n\r")); 
	return TRUE;
}

unsigned char Snim_Drv_Initailise(unsigned long unitId)//thomson  
{
	SSnimLnb lnb;