tunerapi.c

sigma_designs的tuner驱动

/*
 *
 *  tuner.c
 *  wrapper
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ALLOW_OS_CODE 1
#include "rmdef/rmdef.h"
#include "llad/include/gbus.h"

#include "../../helper/helper.h"

#include "tunerapi.h"
#include "tuner.h"

#include "../hardware/tu1216.h"
#include "../hardware/tuv1236d.h"
#include "../hardware/fq1216me.h"

#ifdef DEBUG
#define TUNERAPI_VERSION	"tunerapi-1.3.0-debug"
#else
#define TUNERAPI_VERSION	"tunerapi-1.3.0"
#endif

#define TUNERAPI_MAXTUNERS	10
#define TUNERAPI_STARTCONTEXT	0x80800000

TUNER_CONFIG* g_pTunerList[TUNERAPI_MAXTUNERS];
RMuint32	g_uNumTuners = 0;
RMuint32	g_uLastContext = TUNERAPI_STARTCONTEXT;
RMuint32	g_uNumTU1216Tuners = 0;
RMuint8 g_aTU1216Tuners[TUNERAPI_TU1216_MAXUNITS] =
{ 0, 0};

RMuint32 FindTuner(TUNERAPI_CONTEXT context);
RMuint32 FindEmptyIndex(void);

//-------------------------------------------------------------------------------
RMuint32 FindTuner(TUNERAPI_CONTEXT context)
{
	RMuint32 i;

	for( i = 0; i < TUNERAPI_MAXTUNERS; i++ )
	{
		if ( g_pTunerList[i] != NULL )
			if( (g_pTunerList[i])->TunerContext == context )
				return i;
	}
	return TUNERAPI_MAXTUNERS;
}


RMuint32 FindEmptyIndex(void)
{
	RMuint32 i;
	
	for( i = 0; i < TUNERAPI_MAXTUNERS; i++ )
	{
		if ( g_pTunerList[i] == NULL )
			return i;
	}
	
	return TUNERAPI_MAXTUNERS;
}

/* Exported interfaces */
/*------------------------------------------------------------------------------*/
RMstatus tunerapiOpen(TUNERAPI_CFG* pTunerApiCfg, TUNERAPI_CONTEXT *pContext)
{
	RMstatus s;
	RMuint32 uTunerIndex;
	
	TUNER_CONFIG* pNewTuner;

	DPRINT(("tunerapiOpen() version: %s\n", TUNERAPI_VERSION ));

	if( pTunerApiCfg == NULL )
		return RM_INVALID_PARAMETER;
		
	if( pContext == NULL )
		return RM_INVALID_PARAMETER;
		
		
	if( (*pContext) != 0 )
	{ //Reopen
		DPRINT(("tunerapiOpen() reopen on context 0x%lx\n", *pContext));
		if( ( uTunerIndex = FindTuner(*pContext)) == TUNERAPI_MAXTUNERS )
		{
			DPRINT(("tunerapiOpen() !REOPEN unable to find context 0x%lx\n", *pContext));
			return RM_INVALID_PARAMETER;
		}
		
		assert( memset(&((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters), 0, sizeof(FREQUENCY_PARAM_T)) != NULL );
		assert( memset(&((g_pTunerList[uTunerIndex])->NextScanParam_T), 0, sizeof(SCAN_PARAM_T)) != NULL );

		// Allow to change the Mode and the input
		(g_pTunerList[uTunerIndex])->nTunerMode = pTunerApiCfg->nTunerMode;
		(g_pTunerList[uTunerIndex])->nTunerInput = pTunerApiCfg->nTunerInput;
		
		if( (s = (*((g_pTunerList[uTunerIndex])->pTunerInit)) ( g_pTunerList[uTunerIndex], 1)) != RM_OK )
		{
			DPRINT(("tunerapiOpen() !REOPEN TunerInit() failed %d\n", s));
			// invalid state here, it is up to the upper layer to decide what to do
			return RM_ERROR;
		}
	} //Reopen End
	else
	{ //NewTuner
		if( g_uNumTuners == TUNERAPI_MAXTUNERS )
		{
			DPRINT(("tunerapiOpen() max tuners reached %ld\n", g_uNumTuners ));
			return RM_ERROR;
		}

		if( g_uNumTuners == 0 )
		{
			RMuint32 i;

			for( i = 0; i < TUNERAPI_MAXTUNERS; i++ )
				g_pTunerList[i] = NULL;
		}

		if( (pNewTuner = malloc(sizeof(TUNER_CONFIG))) == NULL )
		{
			DPRINT(("tunerapiOpen() can't allocate configuration memory\n"));
			return RM_ERROR;
		}

		assert( memset(pNewTuner, 0 , sizeof(TUNER_CONFIG)) != NULL );

		pNewTuner->nTunerMode = pTunerApiCfg->nTunerMode;
		pNewTuner->nTunerModel = pTunerApiCfg->nTunerModel;
		pNewTuner->nTunerInput = pTunerApiCfg->nTunerInput;
		pNewTuner->pI2Cal_Context = pTunerApiCfg->pI2Cal_Context;

		switch( pTunerApiCfg->nTunerModel )
		{
			RMuint8 i;

		case TunerModel_Philips_FQ1216ME:
			pNewTuner->pTunerInit = &fq1216me_Init;
			pNewTuner->pTunerSetFrequency = &fq1216me_SetFrequency;
			pNewTuner->pTunerGetData = &fq1216me_GetData;
			pNewTuner->pTunerScan = &fq1216me_Scan;
			pNewTuner->pTunerClose = &fq1216me_Close;

			pNewTuner->IfI2cAddr = (pTunerApiCfg->I2CAddress)[0];
			pNewTuner->PllI2cAddr = (pTunerApiCfg->I2CAddress)[1];
			break;

		case TunerModel_Philips_TUV1236D:
			pNewTuner->pTunerInit = &tuv1236d_Init;
			pNewTuner->pTunerSetFrequency = &tuv1236d_SetFrequency;
			pNewTuner->pTunerGetData = &tuv1236d_GetData;
			pNewTuner->pTunerScan = &tuv1236d_Scan;
			pNewTuner->pTunerClose = &tuv1236d_Close;

			pNewTuner->DmI2cAddr = (pTunerApiCfg->I2CAddress)[0];
			pNewTuner->AuxI2cAddr = (pTunerApiCfg->I2CAddress)[1];
			break;

		case TunerModel_Philips_TU1216:
			for( i = 0; i < TUNERAPI_TU1216_MAXUNITS; i++ )
			{
				if ( g_aTU1216Tuners[i] == 0 )
				{
				pNewTuner->uTunerId = i;
				break;
				}
			}
			if( i == TUNERAPI_TU1216_MAXUNITS )
			{
				free(pNewTuner);
				DPRINT(("tunerOpen !TunerInit() too many TU1216 tuners\n"));
				return RM_ERROR;
			}

			pNewTuner->pTunerInit = &tu1216_Init;
			pNewTuner->pTunerSetFrequency = &tu1216_SetFrequency;
			pNewTuner->pTunerGetData = &tu1216_GetData;
			pNewTuner->pTunerScan = &tu1216_Scan;
			pNewTuner->pTunerClose = &tu1216_Close;

			pNewTuner->DmI2cAddr = (pTunerApiCfg->I2CAddress)[0];
			pNewTuner->PllI2cAddr = (pTunerApiCfg->I2CAddress)[1];

			break;

		default:
			DPRINT(("tunerOpen() !tuner not supported\n"));
			free(pNewTuner);
			return RM_INVALID_PARAMETER;
			break;
		}


		if( (s = (*(pNewTuner->pTunerInit))(pNewTuner, 0)) != RM_OK )
		{
			free(pNewTuner);
			DPRINT(("tunerOpen !TunerInit() failed %d\n", s));
			return RM_ERROR;
		}

		if( (uTunerIndex = FindEmptyIndex()) == TUNERAPI_MAXTUNERS )
		{
			free(pNewTuner);
			DPRINT(("tunerapiOpen() index error\n"));
			return RM_ERROR;
		}

		pNewTuner->TunerContext = g_uLastContext;
		*pContext = g_uLastContext;
		g_uLastContext++;

		if( pNewTuner->nTunerModel == TunerModel_Philips_TU1216 )
		{
			assert( pNewTuner->uTunerId < TUNERAPI_TU1216_MAXUNITS );
			g_aTU1216Tuners[pNewTuner->uTunerId] = 1;
		}

		g_uNumTuners++;
		g_pTunerList[uTunerIndex] = pNewTuner;
	} //NewTuner End
	
	return RM_OK;
}



RMstatus tunerapiClose(TUNERAPI_CONTEXT context)
{
	RMstatus s;
	RMuint32 uTunerIndex;
	
	if( ( uTunerIndex = FindTuner(context)) == TUNERAPI_MAXTUNERS )
	{
		DPRINT(("tunerapiClose() unable to find context 0x%lx\n", context));
		return RM_INVALID_PARAMETER;
	}
	
	if( (s = ((*((g_pTunerList[uTunerIndex])->pTunerClose)) (g_pTunerList[uTunerIndex]))) != RM_OK )
		DPRINT(("tunerapiClose() TunerClose() Failed on context 0x%lx\n", context));

	if( (g_pTunerList[uTunerIndex])->nTunerModel == TunerModel_Philips_TU1216 )
        {
                assert( (g_pTunerList[uTunerIndex])->uTunerId < TUNERAPI_TU1216_MAXUNITS );
                assert( g_aTU1216Tuners[(g_pTunerList[uTunerIndex])->uTunerId] == 1);
                g_aTU1216Tuners[(g_pTunerList[uTunerIndex])->uTunerId] = 0;
        }

	free(g_pTunerList[uTunerIndex]);
	g_pTunerList[uTunerIndex] = NULL;
	
	g_uNumTuners--;
	
	return s;
}



RMstatus tunerapiSetProperty(TUNERAPI_CONTEXT context, TUNERAPI_PROPERTY nProperty, TUNERAPI_PROPERTY_DATA_U *pData_U)
{
	RMuint32 uTunerIndex;
	//RMstatus s;

	if( ( uTunerIndex = FindTuner(context)) == TUNERAPI_MAXTUNERS )
	{
		DPRINT(("tunerapiSetProperty() unable to find context 0x%lx\n", context));
		return RM_INVALID_PARAMETER;
	}
	
	if( pData_U == NULL )
	{
		DPRINT(("tunerapiSetProperty() context 0x%lx, data field null\n", context));
		return RM_INVALID_PARAMETER;
	}
	
	switch( nProperty )
	{
	/*case TunerApiProperty_TuneFrequency:
		if( (s = ((*((g_pTunerList[uTunerIndex])->pTunerSetFrequency)) (g_pTunerList[uTunerIndex], pData_U->uFrequency, &((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters) ))) != RM_OK )
			DPRINT(("tunerapiSetProperty() TunerSetFrequency() Failed on context 0x%lx with %d\n", context, s));
		return s;
		break;*/
	/*
  case TunerApiProperty_DvbT_ChannelSpacing:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).uDvbTChannelSpacing = pData_U->uFrequency;
		return RM_OK;
		break;*/

	case TunerApiProperty_ChannelSpacing:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).uChannelSpacing = pData_U->uFrequency;
		return RM_OK;
		//break;
		
	case TunerApiProperty_DvbT_RfOffset:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTRFOffset = pData_U->nDvbTRFOffset;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_SpectralInversion:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTSpectralInversion = pData_U->nDvbTSpectralInversion;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_Modulation:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTModulation = pData_U->nDvbTModulation;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_GuardInterval:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTGuardInterval = pData_U->nDvbTGuardInterval;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_FftCarrierMode:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTFft = pData_U->nDvbTFft;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_Hierarchy:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTHierarchy = pData_U->nDvbTHierarchy;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_Priority:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTPriority = pData_U->nDvbTPriority;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_VitDepuncHighRate:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTDepuncHighRate = pData_U->nDvbTDepuncRate;
		return RM_OK;
		break;
	
	case TunerApiProperty_DvbT_VitDepuncLowRate:
		((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters).nDvbTDepuncLowRate = pData_U->nDvbTDepuncRate;
		return RM_OK;
		break;
		
	default:
		// set next frequency and scan parameters
		return RM_ERROR;
		break;
	}
}



RMstatus tunerapiGetProperty(TUNERAPI_CONTEXT context, TUNERAPI_PROPERTY nProperty, TUNERAPI_PROPERTY_DATA_U *pData_U)
{
	RMuint32 uTunerIndex;
	RMstatus s = RM_OK;

	TUNERAPI_PROPERTY_DATA_U tunerdata_U;
	
	if( ( uTunerIndex = FindTuner(context)) == TUNERAPI_MAXTUNERS )
	{
		DPRINT(("tunerapiGetProperty() unable to find context 0x%lx\n", context));
		return RM_INVALID_PARAMETER;
	}
	
	if( pData_U == NULL )
	{
		DPRINT(("tunerapiGetProperty() context 0x%lx, data field null\n", context));
		return RM_INVALID_PARAMETER;
	}
	
	switch( nProperty )
	{		
	case TunerApiProperty_TunerLowestFrequency:
		pData_U->uFrequency = g_pTunerList[uTunerIndex]->uLowFrequency;
		break;
		
	case TunerApiProperty_TunerHighestFrequency:
		pData_U->uFrequency = g_pTunerList[uTunerIndex]->uHighFrequency;
		break;

	case TunerApiProperty_TuneFrequency:
		// Tune Frequency is set in the hardware modules
		// You can't/SHOUD NOT SET it at the tunerapi level.
		pData_U->uFrequency = g_pTunerList[uTunerIndex]->uCurrentFrequency;
		break;

  	// All Tuners
	case TunerApiProperty_SignalStatus:
	case TunerApiProperty_ChannelSpacing:
	// Digital
	case TunerApiProperty_SignalStrength:
	// Analog
	case TunerApiProperty_AnalogStatusBits:
	// DVB-T
	case TunerApiProperty_DvbT_RfOffset:
	case TunerApiProperty_DvbT_SpectralInversion:
	case TunerApiProperty_DvbT_Modulation:
	case TunerApiProperty_DvbT_GuardInterval:
	case TunerApiProperty_DvbT_FftCarrierMode:
	case TunerApiProperty_DvbT_Hierarchy:
	case TunerApiProperty_DvbT_Priority:
	case TunerApiProperty_DvbT_VitDepuncHighRate:
	case TunerApiProperty_DvbT_VitDepuncLowRate:
	case TunerApiProperty_DvbT_TrueFrequency:
		if( (s = ((*((g_pTunerList[uTunerIndex])->pTunerGetData)) (g_pTunerList[uTunerIndex], nProperty, &tunerdata_U ))) == RM_OK )
			*pData_U = tunerdata_U;
		// else s = RM_ERROR or some other error field
		break;

				
	default:
		DPRINT(("tunerapiGetProperty() invalid property\n"));
		// set next frequency and scan parameters
		s = RM_ERROR;
		break;
	}
	
	return s;
}


// set frequency AND start acquisition
RMstatus tunerapiTune(TUNERAPI_CONTEXT context, RMuint32 uFrequency)
{
	RMuint32 uTunerIndex;
	RMstatus s;

        if( ( uTunerIndex = FindTuner(context)) == TUNERAPI_MAXTUNERS )
	{
		DPRINT(("tunerapiTune() unable to find context 0x%lx\n", context));
		return RM_INVALID_PARAMETER;
	}

        if( (uFrequency > (g_pTunerList[uTunerIndex])->uHighFrequency) ||
            (uFrequency < (g_pTunerList[uTunerIndex])->uLowFrequency) )
        {
                DPRINT(("tunerapiTune() invalid frequency = %ld\n", uFrequency));
                return RM_INVALID_PARAMETER;
        }

	if( (s = ((*((g_pTunerList[uTunerIndex])->pTunerSetFrequency)) (g_pTunerList[uTunerIndex], uFrequency, &((g_pTunerList[uTunerIndex])->NextSetFrequencyParameters) ))) != RM_OK )
		DPRINT(("tunerapiTune() TunerSetFrequency() Failed on context 0x%lx with %d\n", context, s));
	return s;
}


RMstatus tunerapiScan(TUNERAPI_CONTEXT context, RMuint32 uStart, RMuint32 uEnd, SCAN_RESULT_T *pScanResult_T)
{
	RMuint32 uTunerIndex;
	RMstatus s;
	

	if( pScanResult_T == NULL )
		return RM_INVALID_PARAMETER;
	
	if( ( uTunerIndex = FindTuner(context)) == TUNERAPI_MAXTUNERS )
	{
		DPRINT(("tunerapiScan() unable to find context 0x%lx\n", context));
		return RM_INVALID_PARAMETER;
	}

	if( 	(uStart != 0) &&
		( uStart < (g_pTunerList[uTunerIndex])->uLowFrequency) )
		return RM_INVALID_PARAMETER;
		
	if( uEnd > (g_pTunerList[uTunerIndex])->uHighFrequency )
		return RM_INVALID_PARAMETER;
	
	s = (*((g_pTunerList[uTunerIndex])->pTunerScan)) (g_pTunerList[uTunerIndex], uStart, uEnd, &((g_pTunerList[uTunerIndex])->NextScanParam_T), pScanResult_T );
	
	return s;
}