drv_ch_pio_com.c

ST5100 driver files for ST chipset

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

File Name   : drv_ch_pio.c

Description : Channel PIO(Parallel Input Output) driver functions

Copyright (C) 2004

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

#define DRV_CH_PIO_DEBUG_PRINT
/*=============================================================================
	Includes
=============================================================================*/
#if defined(CHIPSET_ST)
#include "stddefs.h"// 
#include "sttbx.h"
#include "stpio.h"// 
#else
#endif
#include "drv_ch_pio_com.h"
#include "ddi_channel.h"
#include "drv_tuner_com.h"
#if defined(NEO_S) || defined(NEO_ST)
#include "drv_tuner_sat.h"
#endif
#include "drv_channel_com.h"
#include "ddi_ch_common.h"

#include "vkernel.h"


#include "ddi_uart.h"

#include "app_data.h"//  7710_T
#include "pio.h"//  7710_T
#include "sttbx.h"

#define SUPPORT_ST_LNB_PROTECT
/*=============================================================================
	Debug Option
=============================================================================*/
//#define	DRV_CHANNEL_PIO_DEBUG
//#define	DRV_CHANNEL_PIO_ERROR

#ifdef	DRV_CHANNEL_PIO_DEBUG
#define	PrintInfo(_x_)	DDI_UART_Print _x_
#define	PrintDebug(_x_)	DDI_UART_Print _x_
#else
#define	PrintInfo(_x_)	
#define	PrintDebug(_x_)
#endif
#ifdef	DRV_CHANNEL_PIO_ERROR
#define	PrintError(_x_)	DDI_UART_Print _x_
#else
#define	PrintError(_x_)
#endif

//#define DRV_CH_PIO_DEBUG_PRINT

/*=============================================================================
	Definitions
=============================================================================*/
#define	DDI_CH_PIO_OK				(0)
#define	ADC_POWER_ON_OFF_MASK	  	0x40

#define OFDM0_RESET_GPIO		39	//GPIO45
#define OFDM1_RESET_GPIO		28	//GPIO47

#if defined(CHIPSET_ST)
STPIO_Handle_t g_CHVhHandle[2],g_CHLnbHandle[2];//,g_PIOHANDLE_CH_22KHz[2]; //  20051129
STPIO_Handle_t g_CHHwResetHandle[2];
STPIO_Handle_t g_CHTerHwResetHandle[2];
#if defined(SUPPORT_SELECT_TS)
STPIO_Handle_t g_CHEnableHandle[2];
STPIO_Handle_t g_CHTerEnableHandle[2];
#endif

#if defined(SUPPORT_ST_LNB_PROTECT)
STPIO_Handle_t g_CHLNBPROTECTHandle[2];	
unsigned char	g_CHLNBPROTECTPioPin[DDI_CHANNEL_NUM_TUNER];
unsigned char	g_CHLNBPROTECTFlag[DDI_CHANNEL_NUM_TUNER];
#endif

extern ST_DeviceName_t	g_PIODeviceName[];

#else
#endif
unsigned char	g_CH_LnbPioPin[2];
unsigned char	g_CH_VhPioPin[2];
unsigned char	g_CH_EnablePioPin[2];
unsigned char	g_CH_Ter_EnablePioPin[2];


/*=============================================================================
	Functions prototypes
=============================================================================*/

/*=============================================================================
	Function	: drv_Tuner_PioInit
	Description	: 
	Input		:
	Output		:
	Return		: Success if TRUE
=============================================================================*/
/*=============================================================================
	Function	: drv_Tuner_PioInit
	Description	: 
	Input		:
	Output		:
	Return		: Success if TRUE
=============================================================================*/
#if defined(SUPPORT_ST_LNB_PROTECT)
void DRV_CH_LNBPROTECT_Handle(STPIO_Handle_t Handle, STPIO_BitMask_t ActiveBits)
{
	int unitId;
	unsigned char 	data;	

	//DSI_UART_Init();
	//DSI_printf("DRV_CH_LNBPROTECT_Handle PIO %x \r\n",ActiveBits);
	if(g_CHLNBPROTECTHandle[0] == Handle)
	{	
		unitId = 0;
		g_CHLNBPROTECTFlag[0] = 1;
		//DSI_printf("1 DRV_CH_LNBPROTECT_Handle Device PIO[%x] %x \r\n",ActiveBits);
	}
	else if(g_CHLNBPROTECTHandle[1] == Handle)
	{
		unitId = 1;
		g_CHLNBPROTECTFlag[1] = 1;
		//DSI_printf("2 DRV_CH_LNBPROTECT_Handle Device PIO [%x] \r\n",ActiveBits);
	}
	else
	{
		unitId = 0;
		g_CHLNBPROTECTFlag[0] = 1;
		//DSI_printf("3 DRV_CH_LNBPROTECT_Handle Device PIO [%x] \r\n",ActiveBits);
	}
	#if 0//  usa 20070203 because polling do not delete
	if(ActiveBits == PIO_BIT_4)
	{
		STPIO_Read(Handle,&data);
		//DSI_printf(">>>>>>>>>>>>>>>>>>>>>>>>>>. g_pfnNotifyCarrier %d\r\n",(data&PIO_BIT_1));
		if(data&PIO_BIT_4)
		{
			//g_pfnNotifyCarrier[unitId] (unitId, g_ChInfoWork[unitId].ulRequestId, DRV_TUNER_CARRIER_LNB_OVERLOAD); 
			DRV_LNB_Protect(unitId);
		}
	}
	#endif		
}
unsigned char LnbProtected=0;//  lnb Protection
void DRV_CH_LNBPROTECT_ReadPio(unsigned char unitId)
{
	unsigned char 	data;	
	int				errCode;

//	if(g_CHLNBPROTECTFlag[unitId] != 0)
	{
		errCode = (ST_ErrorCode_t)STPIO_Read(g_CHLNBPROTECTHandle[unitId],&data);
		if(errCode == DDI_CH_PIO_OK)
		{//sttbx_Print(">>> DRV_CH_LNBPROTECT_ReadPio :%x : %x \n",data,g_CHLNBPROTECTPioPin[unitId]);
			if(g_CHLNBPROTECTPioPin[unitId] & data)
			{	

				


				////////////////////////////////////////////////////////////////////////////////

				// 20070326  
				// HD_9000 LNB Voltage OFF !!!
				// HD_8000 LNB Voltage No Action !!!
								
				#if defined(HD_9000)
				//sttbx_Print(">>> DRV_CH_LNBPROTECT Checked HD_9000 !!!\n");
				DRV_CH_Pio_LnbVoltage(unitId, 0);
				#endif
				//sttbx_Print(">>> DRV_CH_LNBPROTECT Checked HD_8000!!!\n");
				////////////////////////////////////////////////////////////////////////////////
				LnbProtected = 1;
				DRV_LNB_Protect(unitId);
				VK_TASK_Sleep(100);
				
				//  20070222 DRV_CH_Pio_LnbVoltage(unitId, 1);
			}
			else
			{
				//sttbx_Print(">>> DRV_CH_LNBPROTECT ^^ !!!\n");
			}
			g_CHLNBPROTECTFlag[unitId] = 0;
		}
	}
}

//   20070203 Do not delete
void DRV_CH_LNB_Protect_Init(void)
{
#if 0//defined(SUPPORT_ST_LNB_PROTECT)
    int    				ErrCode;
	STPIO_Compare_t		compareStatus;
	STPIO_OpenParams_t	PIOOpenParams;
	int					i;
	unsigned int 		lnbProtectHandle;

//	PIOOpenParams.IntHandler	= DRV_CH_LNBPROTECT_Handle;		
	PIOOpenParams.IntHandler	= NULL;		
	PIOOpenParams.ReservedBits 	= PIO_BIT_1;
	PIOOpenParams.BitConfigure[1]	= STPIO_BIT_INPUT;        // lnb protect pin.
	
	ErrCode = STPIO_Open(g_PIODeviceName[0], &PIOOpenParams, &lnbProtectHandle);
	if(ErrCode != DDI_CH_PIO_OK)
	{
		PrintError(("CommonPIO0_Init() Error : STPIO_Open(%s, %x, 0x%x) 0x%x \n" , g_PIODeviceName[0], PIOOpenParams.ReservedBits, lnbProtectHandle , ErrCode));
	}
	
	for(i=0; i<DDI_CHANNEL_NUM_TUNER; i++)
	{
		g_CHLNBPROTECTHandle[i] = lnbProtectHandle;
		g_CHLNBPROTECTPioPin[i] = (unsigned char)PIO_BIT_1;
		g_CHLNBPROTECTFlag[i] = 0;
	}
#endif
}

#endif


int DRV_CH_CommonPIO0_Init( unsigned char unitId , unsigned long type)
{
    int    					ErrCode;
#if defined(SUPPORT_ST_LNB_PROTECT)
	int i;
	STPIO_Compare_t		compareStatus;
#endif
#if defined(CHIPSET_ST)
	STPIO_OpenParams_t		PIOOpenParams;
#endif

	switch(type)
	{
		case DDI_CHANNEL_TYPE_SAT:
#if defined(SUPPORT_ST_LNB_PROTECT)
			
			PIOOpenParams.IntHandler		= NULL;//  20060928 DRV_CH_LNBPROTECT_Handle;		
			PIOOpenParams.ReservedBits 	= (PIO_BIT_4);
			PIOOpenParams.BitConfigure[4] 	= STPIO_BIT_INPUT;        // TTS_E
			
			ErrCode = STPIO_Open(PIO_GET_DEVICENAME(3), &PIOOpenParams, &g_CHLNBPROTECTHandle[unitId]);
			if(ErrCode != DDI_CH_PIO_OK)
				PrintError(("CommonPIO0_Init() Error : STPIO_Open(%s, %x, 0x%x) 0x%x \n" , PIO_GET_DEVICENAME(3), PIOOpenParams.ReservedBits, g_CHLNBPROTECTHandle[unitId] , ErrCode));

			for(i=0; i<DDI_CHANNEL_NUM_TUNER; i++)
			{
				g_CHLNBPROTECTHandle[i] = g_CHLNBPROTECTHandle[unitId];
				g_CHLNBPROTECTPioPin[i] = (unsigned char)PIO_BIT_4;
				g_CHLNBPROTECTFlag[i] = 0;
			}
#endif

			break;

		case DDI_CHANNEL_TYPE_TER:

#if defined(CHIPSET_ST)
		    PIOOpenParams.IntHandler       = NULL;
		#if defined(SUPPORT_SELECT_TS)
		    PIOOpenParams.ReservedBits = ( PIO_BIT_2);
		    PIOOpenParams.BitConfigure[2] = STPIO_BIT_OUTPUT;        // TTS_E
		    ErrCode = STPIO_Open(g_PIODeviceName[0], &PIOOpenParams, &g_CHTerEnableHandle[unitId] );
			if(ErrCode != DDI_CH_PIO_OK){
				PrintError(("CommonPIO0_Init() Error : STPIO_Open(%s, %x, 0x%x) 0x%x \n" , g_PIODeviceName[0], PIOOpenParams.ReservedBits, g_CHTerEnableHandle[unitId] , ErrCode));
			}
		    PIOOpenParams.ReservedBits = (PIO_BIT_6);
		    PIOOpenParams.BitConfigure[6] = STPIO_BIT_OUTPUT;        // TTS_RESET
		    ErrCode = STPIO_Open(g_PIODeviceName[0], &PIOOpenParams, &g_CHTerHwResetHandle[unitId] );
			if(ErrCode != DDI_CH_PIO_OK){
				PrintError(("CommonPIO0_Init() Error : STPIO_Open(%s, %x, 0x%x) 0x%x \n" , g_PIODeviceName[0], PIOOpenParams.ReservedBits, g_CHTerHwResetHandle[unitId] , ErrCode));
			}
		#endif
#else
#endif
			break;
			
		default:
			break;
	}
    return ( ErrCode );
}



int DRV_CH_CommonPIO2_Init( unsigned char unitId , unsigned long type)
{
    int    		ErrCode;
    int		TotalError;
#if defined(CHIPSET_ST)
	STPIO_OpenParams_t		PIOOpenParams;
#endif

	TotalError = 0;
	switch(type)
	{
		case DDI_CHANNEL_TYPE_SAT:
#if defined(CHIPSET_ST)
		    PIOOpenParams.IntHandler   = NULL;
		#if defined(SUPPORT_SELECT_TS)
		    PIOOpenParams.ReservedBits = ( PIO_BIT_5 );
		    PIOOpenParams.BitConfigure[5] = STPIO_BIT_OUTPUT;        // STS_E
		    ErrCode = STPIO_Open(g_PIODeviceName[2], &PIOOpenParams, &g_CHEnableHandle[unitId] );
			if(ErrCode != DDI_CH_PIO_OK){
				PrintError(("CommonPIO2_Init() Error : STPIO_Open(%s, %x, 0x%x) 0x%x \n" , g_PIODeviceName[2], PIOOpenParams.ReservedBits, g_CHEnableHandle[unitId] , ErrCode));
				TotalError |= ErrCode;
			}
		    PIOOpenParams.ReservedBits = ( PIO_BIT_6 );
		    PIOOpenParams.BitConfigure[6] = STPIO_BIT_OUTPUT;        // STS_RESET
		    ErrCode = STPIO_Open(g_PIODeviceName[2], &PIOOpenParams, &g_CHHwResetHandle[unitId] );
			if(ErrCode != DDI_CH_PIO_OK){
				PrintError(("CommonPIO2_Init() Error : STPIO_Open(%s, %x, 0x%x) 0x%x \n" , g_PIODeviceName[2], PIOOpenParams.ReservedBits, g_CHHwResetHandle[unitId] , ErrCode));
				TotalError |= ErrCode;
			}
		#endif


			//  7710_T PIOOpenParams.ReservedBits =  PIO_BIT_3;
			//  7710_T PIOOpenParams.BitConfigure[3] = STPIO_BIT_OUTPUT;		/* V_H */
			//  7710_T ErrCode = STPIO_Open(g_PIODeviceName[2], &PIOOpenParams, &g_CHVhHandle[unitId]);
			g_CH_VhPioPin[unitId] = PIO_BIT_5;
			PIOOpenParams.ReservedBits =  PIO_BIT_5;
			PIOOpenParams.BitConfigure[5] = STPIO_BIT_OUTPUT;		/* V_H */
			
			ErrCode = STPIO_Open(PIO_GET_DEVICENAME(2), &PIOOpenParams, &PIO_GET_HANDLE(2,CH_PIO_CH_VH_HANDLEID));
			if(ErrCode != DDI_CH_PIO_OK){
				PrintError(("CommonPIO2_Init() Error : STPIO_Open(%s, RerseveBit: 0x%x) Error : 0x%x \n" , PIO_GET_DEVICENAME(2), PIOOpenParams.ReservedBits , ErrCode));
				TotalError |= ErrCode;
			}
			//  7710_T g_CH_VhPioPin[unitId] = PIO_BIT_3;
			//  7710_T PIOOpenParams.ReservedBits =  PIO_BIT_2;
			//  7710_T PIOOpenParams.BitConfigure[2] = STPIO_BIT_OUTPUT;		/* LNB_ON */

			PIOOpenParams.ReservedBits =  PIO_BIT_6;
			PIOOpenParams.BitConfigure[6] = STPIO_BIT_OUTPUT;		/* LNB_ON */
			ErrCode = STPIO_Open(PIO_GET_DEVICENAME(2), &PIOOpenParams, (STPIO_Handle_t *)&PIO_GET_HANDLE(2,CH_PIO_CH_LNB_HANDLEID));
			if(ErrCode != DDI_CH_PIO_OK){
				PrintError(("CommonPIO2_Init() Error : STPIO_Open(%s, RerseveBit: 0x%x) 0x%x \n" ,PIO_GET_DEVICENAME(2), PIOOpenParams.ReservedBits, ErrCode));
				TotalError |= ErrCode;
			}
			g_CH_LnbPioPin[unitId] = PIO_BIT_6;
#else
#endif
			break;

		case DDI_CHANNEL_TYPE_TER	:
			break;
			
		default:
			break;
	}
    return ( ErrCode );
}


/*=============================================================================
	Function	: drv_ch_pio_Init
	Description	: STPIO_Open
	Input		:
	Output		:
	Return		: TRUE if error, FALSE if success
=============================================================================*/

int DRV_CH_Pio_Init(unsigned char unitId, unsigned long type)
{
	DRV_CH_CommonPIO0_Init(unitId, type);
	DRV_CH_CommonPIO2_Init(unitId, type);

	return 0;
} /* end of drv_ch_pio_Init */

static int DRV_CH_Pio_Set(unsigned long Handle,  unsigned char BitMask)
{
	int			ErrCode;

	ErrCode = 0;
	
#if defined(CHIPSET_ST)
	ErrCode = (int)STPIO_Set((STPIO_Handle_t)Handle, (STPIO_BitMask_t)BitMask);	
	if(ErrCode != DDI_CH_PIO_OK){
		PrintError(("DRV_CH_Pio_Set() Error : STPIO_Set(0x%x , 0x%x) 0x%x \n" , Handle , BitMask , ErrCode ));
	}
#else
#endif

	return ErrCode;
} /* end of DRV_CH_Pio_Set */


/*=============================================================================
	Function	: DRV_CH_Pio_Clear
	Description	: STPIO_Clear
	Input		:
	Output		:
	Return		: TRUE if error, FALSE if success
=============================================================================*/
static int DRV_CH_Pio_Clear(unsigned long Handle,  unsigned char BitMask)
{