tunshdrv.c

st7710的tuner标准驱动

            #endif

#ifdef STTUNER_DRV_SHARED_TUN_DTT7600 
           case STTUNER_TUNER_DTT7600:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s installing sat:tuner:FQD1236...", identity));
#endif
            if (Installed_DTT7600 == TRUE)
            {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
                STTBX_Print(("%s fail already installed\n",identity));
#endif
                return(STTUNER_ERROR_INITSTATE);
            }

            Tuner->ID = STTUNER_TUNER_DTT7600;
            Tuner->tuner_Open = tuner_tunshdrv_Open_DTT7600;
            Installed_DTT7600 = TRUE;
            break;
            #endif


         default:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s incorrect tuner index", identity));
#endif
            return(ST_ERROR_UNKNOWN_DEVICE);
            break;
     }
    
    /* map API */
    Tuner->tuner_Init  = tuner_tunshdrv_Init;
    Tuner->tuner_Term  = tuner_tunshdrv_Term;
    Tuner->tuner_Close = tuner_tunshdrv_Close;

    Tuner->tuner_SetFrequency  = tuner_tunshdrv_SetFrequency; 
    Tuner->tuner_GetStatus     = tuner_tunshdrv_GetStatus;
    Tuner->tuner_IsTunerLocked = tuner_tunshdrv_IsTunerLocked;   
    Tuner->tuner_SetBandWidth  = tuner_tunshdrv_SetBandWidth;          

    Tuner->tuner_ioaccess = tuner_tunshdrv_ioaccess;
    Tuner->tuner_ioctl    = tuner_tunshdrv_ioctl;

    InstanceChainTop = NULL; 
#if defined(ST_OS21) || defined(ST_OSLINUX)
   Lock_InitTermOpenClose = semaphore_create_fifo(1);
#else
    semaphore_init_fifo(&Lock_InitTermOpenClose, 1);
#endif      

    Installed = TRUE;

#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("ok\n"));
#endif    
    return(Error);
}



/* ----------------------------------------------------------------------------
Name: STTUNER_DRV_TUNER_NONE_UnInstall()

Description:
    uninstall a shared device driver.
    
Parameters:
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t STTUNER_DRV_TUNER_TUNSHDRV_UnInstall(STTUNER_tuner_dbase_t  *Tuner, STTUNER_TunerType_t TunerType)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STLNB tunshdrv.c STTUNER_DRV_TUNER_TUNSHDRV_UnInstall()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;

    if(Installed == FALSE)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail driver not installed\n", identity));
#endif
        return(STTUNER_ERROR_INITSTATE);
    }
   
    switch(TunerType)
    {
    	#ifdef STTUNER_DRV_SHARED_TUN_TD1336 
        case STTUNER_TUNER_TD1336:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s uninstalling ter:tuner:TD1336\n", identity));
#endif
            Installed_TD1336 = FALSE;
            break;
           #endif 
            #ifdef STTUNER_DRV_SHARED_TUN_FQD1236 
         case STTUNER_TUNER_FQD1236:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s uninstalling ter:tuner:FQD1236\n", identity));
#endif
            Installed_FQD1236 = FALSE;
            break;
             #endif 
            #ifdef STTUNER_DRV_SHARED_TUN_T2000 
            case STTUNER_TUNER_T2000:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s uninstalling ter:tuner:T2000\n", identity));
#endif
            Installed_T2000 = FALSE;
            break;
             #endif 
             
             #ifdef STTUNER_DRV_SHARED_TUN_DTT7600 
            case STTUNER_TUNER_DTT7600:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s uninstalling ter:tuner:DTT7600\n", identity));
#endif
            Installed_DTT7600 = FALSE;
            break;
             #endif 
      default:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s incorrect tuner index", identity));
#endif
            return(ST_ERROR_UNKNOWN_DEVICE);
            break;
     }

    Tuner->ID = STTUNER_NO_DRIVER;

    /* unmap API */
    Tuner->tuner_Init  = NULL;
    Tuner->tuner_Term  = NULL;
    Tuner->tuner_Open  = NULL;
    Tuner->tuner_Close = NULL;

    Tuner->tuner_SetFrequency  = NULL; 
    Tuner->tuner_GetStatus     = NULL;
    Tuner->tuner_IsTunerLocked = NULL;   
    Tuner->tuner_SetBandWidth  = NULL;          

    Tuner->tuner_ioaccess = NULL;
    Tuner->tuner_ioctl    = NULL;

    if(Installed_TD1336 == FALSE)
     {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("<"));
#endif

#if defined(ST_OS21) || defined(ST_OSLINUX)
       semaphore_delete(Lock_InitTermOpenClose);
#else
        semaphore_delete(&Lock_InitTermOpenClose);
#endif

#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print((">"));
#endif
       InstanceChainTop = (TUNSHDRV_InstanceData_t *)0x7ffffffe;
       Installed = FALSE;
     }

#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("ok\n"));
#endif

    return(Error);
}
   


/* ------------------------------------------------------------------------- */
/* /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ API /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\ */
/* ------------------------------------------------------------------------- */


   
/* ----------------------------------------------------------------------------
Name: tuner_tunshdrv_Init()

Description:
    
Parameters:
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t tuner_tunshdrv_Init(ST_DeviceName_t *DeviceName, TUNER_InitParams_t *InitParams)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STTUNER tunshdrv.c tuner_shdrv_Init()";
#endif

    ST_ErrorCode_t Error = ST_NO_ERROR;
    TUNSHDRV_InstanceData_t *InstanceNew, *Instance;

    if(Installed == FALSE)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail no driver installed\n", identity));
#endif
        return(STTUNER_ERROR_INITSTATE);
    }

    /* now safe to lock semaphore */
    SEM_LOCK(Lock_InitTermOpenClose);

    /* ---------- check params ---------- */
    Error = STTUNER_Util_CheckPtrNull(InitParams->MemoryPartition);
    if( Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail MemoryPartition not valid\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(Error);
    }

    Error = STTUNER_Util_CheckPtrNull(DeviceName);
    if( Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail DeviceName not valid\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(Error);
    }

    InstanceNew = memory_allocate_clear(InitParams->MemoryPartition, 1, sizeof( TUNSHDRV_InstanceData_t ));
    if (InstanceNew == NULL)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail memory allocation InstanceNew\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(ST_ERROR_NO_MEMORY);
    }

    /* slot into chain */
    if (InstanceChainTop == NULL)
    {
        InstanceNew->InstanceChainPrev = NULL; /* no previous instance */
        InstanceChainTop = InstanceNew;
    }
    else    /* tag onto last data block in chain */
    {
        Instance = InstanceChainTop;

        while(Instance->InstanceChainNext != NULL)
        {
            Instance = Instance->InstanceChainNext;   /* next block */
        }
        Instance->InstanceChainNext     = (void *)InstanceNew;
        InstanceNew->InstanceChainPrev  = (void *)Instance;
    }

    InstanceNew->DeviceName          = DeviceName;
    InstanceNew->TopLevelHandle      = STTUNER_MAX_HANDLES;
    InstanceNew->IOHandle            = InitParams->IOHandle;
    InstanceNew->MemoryPartition     = InitParams->MemoryPartition;
    InstanceNew->InstanceChainNext   = NULL; /* always last in the chain */
    InstanceNew->TunerType           = InitParams->TunerType;
    InstanceNew->DeviceMap.MemoryPartition = InitParams->MemoryPartition;;
   
    switch(InstanceNew->TunerType)
    {
        
        #ifdef STTUNER_DRV_SHARED_TUN_TD1336
        case STTUNER_TUNER_TD1336:
            InstanceNew->PLLType = TUNER_PLL_TD1336;
            break; 
         #endif
         #ifdef STTUNER_DRV_SHARED_TUN_FQD1236   
        case STTUNER_TUNER_FQD1236:
            InstanceNew->PLLType = TUNER_PLL_FQD1236;
            break; 
            #endif 
            #ifdef STTUNER_DRV_SHARED_TUN_T2000 
         case STTUNER_TUNER_T2000:
            InstanceNew->PLLType = TUNER_PLL_T2000;
            break; 
            #endif   
            
            #ifdef STTUNER_DRV_SHARED_TUN_DTT7600 
         case STTUNER_TUNER_DTT7600:
            InstanceNew->PLLType = TUNER_PLL_DTT7600;
            break; 
            #endif  
                   
            default:
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s incorrect tuner index", identity));
#endif
            return(ST_ERROR_UNKNOWN_DEVICE);
            break;
    }

#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
    STTBX_Print(("%s allocated & initalized block named '%s' at 0x%08x (%d bytes) for  tuner ID=%d\n", identity, InstanceNew->DeviceName, InstanceNew, sizeof( TUNSHDRV_InstanceData_t ), InstanceNew->TunerType ));
#endif

    SEM_UNLOCK(Lock_InitTermOpenClose);
    return(Error);
}   



/* ----------------------------------------------------------------------------
Name: tuner_tunshdrv_Term()

Description:
    
Parameters:
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t tuner_tunshdrv_Term(ST_DeviceName_t *DeviceName, TUNER_TermParams_t *TermParams)
{
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
   const char *identity = "STTUNER tunshdrv.c tuner_tunshdrv_Term()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    TUNSHDRV_InstanceData_t *Instance, *InstancePrev, *InstanceNext;

    if(Installed == FALSE)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail driver not installed\n", identity));
#endif
        return(STTUNER_ERROR_INITSTATE);
    }

    /* now safe to lock semaphore */
    SEM_LOCK(Lock_InitTermOpenClose);

    /* ---------- check params ---------- */
    Error = STTUNER_Util_CheckPtrNull(TermParams);      
    if( Error != ST_NO_ERROR)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail TermParams not valid\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(Error);
    }

    /* ---------- check that at least one init has taken place ---------- */
    if(InstanceChainTop == NULL)
    {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
        STTBX_Print(("%s fail nothing initalized\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(STTUNER_ERROR_INITSTATE);
    }


    /* reap next matching DeviceName */
    Instance = InstanceChainTop;
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
    STTBX_Print(("Looking (%s)", Instance->DeviceName));
#endif
    while(1)
    {
        if ( strcmp((char *)Instance->DeviceName, (char *)DeviceName) == 0)
        {
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("]\n"));
#endif
            /* found so now xlink prev and next(if applicable) and deallocate memory */
            InstancePrev = Instance->InstanceChainPrev;
            InstanceNext = Instance->InstanceChainNext;

            /* if instance to delete is first in chain */
            if (Instance->InstanceChainPrev == NULL)
            {
                InstanceChainTop = InstanceNext;        /* which would be NULL if last block to be term'd */
                if (InstanceNext != NULL)
                {
                InstanceNext->InstanceChainPrev = NULL; /* now top of chain, no previous instance */
                }
            }
            else
            {   /* safe to set value for prev instaance (because there IS one) */
                InstancePrev->InstanceChainNext = InstanceNext;
            }

            /* if there is a next block in the chain */
            if (InstanceNext != NULL)
            {
                InstanceNext->InstanceChainPrev = InstancePrev;
            }
            /*Deallocate memory for ioreg */
            
            Error = STTUNER_IOREG_Close(&Instance->DeviceMap);
           if (Error != ST_NO_ERROR)
            {
	   #ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s fail deallocate register database\n", identity));
	   #endif
           SEM_UNLOCK(Lock_InitTermOpenClose);
           return(Error);           
           }
         
            memory_deallocate(Instance->MemoryPartition, Instance);
            memory_deallocate(Instance->MemoryPartition, Instance->TunerRegVal);
            
#ifdef STTUNER_DEBUG_MODULE_SHARED_TUNSHDRV
            STTBX_Print(("%s freed block at %0x%08x\n", identity, (U32)Instance ));