tunshdrv.c

st7710的tuner标准驱动

        Error = STTUNER_IOARCH_ReadWrite(Instance->IOHandle, Operation, SubAddr, Data, TransferSize, Timeout);
    }
    else    /* repeater */
    {
        Error = ST_ERROR_FEATURE_NOT_SUPPORTED; /* not supported for this tuner */
    }


#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
    STTBX_Print(("%s called\n", identity));
#endif
    return(Error);
}

/* ----------------------------------------------------------------------------
Name:   tuner_tuntdrv_Open_TD1336()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
#ifdef STTUNER_DRV_SHARED_TUN_TD1336 
ST_ErrorCode_t tuner_tunshdrv_Open_TD1336(ST_DeviceName_t *DeviceName, TUNER_OpenParams_t *OpenParams, TUNER_Capability_t *Capability, TUNER_Handle_t *Handle)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STTUNER tunshdrv.c tuner_tunshdrv_Open_TD1336()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    TUNSHDRV_InstanceData_t *Instance;
     int i;
     Error = tuner_tunshdrv_Open(DeviceName, OpenParams, Handle);
    if (Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail, Error=%d\n", identity, Error));
#endif
        return(Error);
    }
     SEM_LOCK(Lock_InitTermOpenClose);
    Instance = TUNSHDRV_GetInstFromHandle(*Handle);
    if (Instance->TunerType != STTUNER_TUNER_TD1336)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail no STTUNER_TUNER_TD1336 for name (%s)\n", identity, Instance->DeviceName ));
#endif
        return(ST_ERROR_BAD_PARAMETER);
    }
    
     Instance->TunerRegVal = memory_allocate_clear(Instance->MemoryPartition,  TD1336_NBREGS, sizeof( U8 ));

 
    
for ( i=0;i<TD1336_NBREGS;i++)

	{
	Instance->TunerRegVal[i]=TD1336_DefVal[i];
	
	}
    
    
    
   Instance->Status.IntermediateFrequency =44000;
   Instance->DeviceMap.Timeout   = IOREG_DEFAULT_TIMEOUT;
   Instance->DeviceMap.Registers = TD1336_NBREGS;
   Instance->DeviceMap.Fields = TD1336_NBFIELDS;
   Instance->DeviceMap.Mode = IOREG_MODE_NOSUBADR;
   Instance->DeviceMap.WrStart =RTD1336_DIV1;
   Instance->DeviceMap.WrSize = 4;
   Instance->DeviceMap.RdStart = RTD1336_STATUS;
   Instance->DeviceMap.RdSize =1;
   Error = STTUNER_IOREG_Open(&(Instance->DeviceMap));
   /*Check for error condition*/
 
   Error = STTUNER_IOREG_Reset(&(Instance->DeviceMap), Instance->IOHandle,TD1336_DefVal,TD1336_Address);
    /* now safe to unlock semaphore */
  SEM_UNLOCK(Lock_InitTermOpenClose);
    
  if (Error == ST_NO_ERROR)
   {
        Instance->TopLevelHandle = OpenParams->TopLevelHandle; /* mark as used */
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s opened ok\n", identity));
#endif
    }
    else
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail Error=%d\n", identity, Error));
#endif
    }
    return(Error);
}
#endif
/* ----------------------------------------------------------------------------
Name:   tuner_tuntdrv_Open_FQD1236()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
#ifdef STTUNER_DRV_SHARED_TUN_FQD1236 
ST_ErrorCode_t tuner_tunshdrv_Open_FQD1236(ST_DeviceName_t *DeviceName, TUNER_OpenParams_t *OpenParams, TUNER_Capability_t *Capability, TUNER_Handle_t *Handle)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STTUNER tunshdrv.c tuner_tunshdrv_Open_FQD1236()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    TUNSHDRV_InstanceData_t *Instance;
    int i;
    
    Error = tuner_tunshdrv_Open(DeviceName, OpenParams, Handle);
    if (Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail, Error=%d\n", identity, Error));
#endif
        return(Error);
    }
     SEM_LOCK(Lock_InitTermOpenClose);
    Instance = TUNSHDRV_GetInstFromHandle(*Handle);
    if (Instance->TunerType != STTUNER_TUNER_TD1336)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail no STTUNER_TUNER_TD1336 for name (%s)\n", identity, Instance->DeviceName ));
#endif
        return(ST_ERROR_BAD_PARAMETER);
    }
    
    
    Instance->TunerRegVal = memory_allocate_clear(Instance->MemoryPartition,  FQD1236_NBREGS, sizeof( U8 ));

 
    
for ( i=0;i<FQD1236_NBREGS;i++)

	{
	Instance->TunerRegVal[i]=FQD1236_DefVal[i];
	
	}

    
   Instance->Status.IntermediateFrequency =44000;
   Instance->DeviceMap.Timeout   = IOREG_DEFAULT_TIMEOUT;
   Instance->DeviceMap.Registers = FQD1236_NBREGS;
   Instance->DeviceMap.Fields = FQD1236_NBFIELDS;
   Instance->DeviceMap.Mode = IOREG_MODE_NOSUBADR;
   Instance->DeviceMap.WrStart =RFQD1236_DIV1;
   Instance->DeviceMap.WrSize = 4;
   Instance->DeviceMap.RdStart = RFQD1236_STATUS;
   Instance->DeviceMap.RdSize =1;
   Error = STTUNER_IOREG_Open(&(Instance->DeviceMap));
   /*Check for error condition*/
 
  Error = STTUNER_IOREG_Reset(&(Instance->DeviceMap), Instance->IOHandle,FQD1236_DefVal,FQD1236_Address);
    /* now safe to unlock semaphore */
  SEM_UNLOCK(Lock_InitTermOpenClose);
    
  if (Error == ST_NO_ERROR)
   {
        Instance->TopLevelHandle = OpenParams->TopLevelHandle; /* mark as used */
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s opened ok\n", identity));
#endif
    }
    else
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail Error=%d\n", identity, Error));
#endif
    }
    return(Error);
}
#endif
/* ----------------------------------------------------------------------------
Name:   tuner_tunshdrv_Open_T2000()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */
#ifdef STTUNER_DRV_SHARED_TUN_T2000 
ST_ErrorCode_t tuner_tunshdrv_Open_T2000(ST_DeviceName_t *DeviceName, TUNER_OpenParams_t *OpenParams, TUNER_Capability_t *Capability, TUNER_Handle_t *Handle)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STTUNER tunshdrv.c tuner_tunshdrv_Open_T2000()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    TUNSHDRV_InstanceData_t *Instance;
    int   i;
    
    Error = tuner_tunshdrv_Open(DeviceName, OpenParams, Handle);
    if (Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail, Error=%d\n", identity, Error));
#endif
        return(Error);
    }
     SEM_LOCK(Lock_InitTermOpenClose);
    Instance = TUNSHDRV_GetInstFromHandle(*Handle);
    if (Instance->TunerType != STTUNER_TUNER_TD1336)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail no STTUNER_TUNER_TD1336 for name (%s)\n", identity, Instance->DeviceName ));
#endif
        return(ST_ERROR_BAD_PARAMETER);
    }
    
      Instance->TunerRegVal = memory_allocate_clear(Instance->MemoryPartition,  T2000_NBREGS, sizeof( U8 ));

 
    
for ( i=0;i<T2000_NBREGS;i++)

	{
	Instance->TunerRegVal[i]=T2000_DefVal[i];
	
	}
    
   Instance->Status.IntermediateFrequency =44000;
   Instance->DeviceMap.Timeout   = IOREG_DEFAULT_TIMEOUT;
   Instance->DeviceMap.Registers = T2000_NBREGS;
   Instance->DeviceMap.Fields = T2000_NBFIELDS;
   Instance->DeviceMap.Mode = IOREG_MODE_NOSUBADR;
   Instance->DeviceMap.WrStart =RT2000_DIV1;
   Instance->DeviceMap.WrSize = 4;
   Instance->DeviceMap.RdStart = RT2000_STATUS;
   Instance->DeviceMap.RdSize =1;
   Error = STTUNER_IOREG_Open(&(Instance->DeviceMap));
   /*Check for error condition*/
 
  Error = STTUNER_IOREG_Reset(&(Instance->DeviceMap), Instance->IOHandle,T2000_DefVal,T2000_Address);
    /* now safe to unlock semaphore */
  SEM_UNLOCK(Lock_InitTermOpenClose);
    
  if (Error == ST_NO_ERROR)
   {
        Instance->TopLevelHandle = OpenParams->TopLevelHandle; /* mark as used */
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s opened ok\n", identity));
#endif
    }
    else
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail Error=%d\n", identity, Error));
#endif
    }
    return(Error);
}
#endif

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

/* ----------------------------------------------------------------------------
Name:   tuner_tunshdrv_Open_DTT7600()

Description:

Parameters:

Return Value:
---------------------------------------------------------------------------- */


#ifdef STTUNER_DRV_SHARED_TUN_DTT7600
ST_ErrorCode_t tuner_tunshdrv_Open_DTT7600(ST_DeviceName_t *DeviceName, TUNER_OpenParams_t *OpenParams, TUNER_Capability_t *Capability, TUNER_Handle_t *Handle)
{
	int i;
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STTUNER tunshdrv.c tuner_tuntdrv_Open_DTT7600()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    TUNSHDRV_InstanceData_t *Instance;
 
   
    Error = tuner_tunshdrv_Open(DeviceName, OpenParams, Handle);
    if (Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail, Error=%d\n", identity, Error));
#endif
        return(Error);
    }
     SEM_LOCK(Lock_InitTermOpenClose);
    Instance = TUNSHDRV_GetInstFromHandle(*Handle);
    if (Instance->TunerType != STTUNER_TUNER_DTT7600)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail no STTUNER_TUNER_DTT7600 for name (%s)\n", identity, Instance->DeviceName ));
#endif
        return(ST_ERROR_BAD_PARAMETER);
    }
     Instance->TunerRegVal = memory_allocate_clear(Instance->MemoryPartition,  DTT7600_NBREGS, sizeof( U8 ));
  
    
for ( i=0;i<DTT7600_NBREGS;i++)

	{
	Instance->TunerRegVal[i]=DTT7600_DefVal[i];
	
	}

    
    
   Instance->Status.IntermediateFrequency =44000;
   Instance->DeviceMap.Timeout   = IOREG_DEFAULT_TIMEOUT;
   Instance->DeviceMap.Registers = DTT7600_NBREGS;
   Instance->DeviceMap.Fields = DTT7600_NBFIELDS;
   Instance->DeviceMap.Mode = IOREG_MODE_NOSUBADR;
   Instance->DeviceMap.WrStart =RDTT7600_P_DIV1;
   Instance->DeviceMap.WrSize = 4;
   Instance->DeviceMap.RdStart = RDTT7600_STATUS;
   Instance->DeviceMap.RdSize =1;
   Error = STTUNER_IOREG_Open(&(Instance->DeviceMap));
   /*Check for error condition*/

  Error = STTUNER_IOREG_Reset(&(Instance->DeviceMap), Instance->IOHandle,DTT7600_DefVal,DTT7600_Address);
    /* now safe to unlock semaphore */
  SEM_UNLOCK(Lock_InitTermOpenClose);
    
  if (Error == ST_NO_ERROR)
   {
        Instance->TopLevelHandle = OpenParams->TopLevelHandle; /* mark as used */
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s opened ok\n", identity));
#endif
    }
    else
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail Error=%d\n", identity, Error));
#endif
    }
    return(Error);
}

#endif



/***********************************/
/* ------------------------------------------------------------------------- */
/* /\/\/\/\/\/\/\/\/\/\/\/\/\UTILITY Functions/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ */
/* ------------------------------------------------------------------------- */


TUNSHDRV_InstanceData_t *TUNSHDRV_GetInstFromHandle(TUNER_Handle_t Handle)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV_HANDLES
   const char *identity = "STTUNER tunshdrv.c TUNSHDRV_GetInstFromHandle()";
#endif
    TUNSHDRV_InstanceData_t *Instance;

    Instance = (TUNSHDRV_InstanceData_t *)Handle;
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV_HANDLES
    STTBX_Print(("%s block at 0x%08x\n", identity, Instance));
#endif

    return(Instance);
}


/*****************************************************
**FUNCTION	::	SharedTunerGetStepsize
**ACTION	::	Get tuner astep size
**PARAMS IN	::	NONE
**PARAMS OUT::	NONE
**RETURN	::	NONE
*****************************************************/

U32 SharedTunerGetStepsize(TUNSHDRV_InstanceData_t *Instance)
{
	U32 Stepsize = 0;
	U8 u8 = 0;
	
	
	switch(Instance->TunerType)
	  {
	  	#ifdef STTUNER_DRV_SHARED_TUN_TD1336 
	      case STTUNER_TUNER_TD1336:
		  u8 = STTUNER_IOREG_GetFieldVal(&(Instance->DeviceMap),FTD1336_RS,Instance->TunerRegVal) ; 
		  switch(u8)
		    {
				
			case 0:
			    Stepsize = 50000; /*50 KHz */
			     break;
			case 1:
			    Stepsize = 31250; /*31.25 KHz */
			    break; 
			case 3:
			    Stepsize = 62500; /* 62,5 KHz */
			    break; 
				 	
			default:
			    break;
		     }	
		 		
		    break;
		    #endif
		    #ifdef STTUNER_DRV_SHAR