diseqcdrv.c

st7710的tuner标准驱动

    /* FOR TRANSMISSION THIS CODE SHOULD BE DONE ONCE*/
  
     /*generate a 22Khz sub carrier frequency */
     RegPtr[DISEQC_TX_PRE_SCALER] = 0x02;
     RegPtr[DISEQC_TX_SUBCARRIER_DIV] = 0x4b9/*0x5E7*/ /*1511*/ ;/*106Mhz of system clock frequency*/   
        
    /* Configure the symbol period time to 1.5ms */
    RegPtr[DISEQC_TX_SYMBOL_PERIOD]= 0x21;
    
    /*configure symbol 0 and symbol 1 on time .... may be confussing between 0 and 1???? */
    RegPtr[DISEQC_TX_SYMBOL0_ONTIME] = 0x16;/*1 ms*/
    RegPtr[DISEQC_TX_SYMBOL1_ONTIME] = 0x0B;/* 0.5ms*/
    /*disable soft reset*/
    RegPtr[DISEQC_TX_SOFT_RESET] = 0x00; 
    
    /*Now enable the transmission section*/
    RegPtr[DISEQC_TX_ENABLE] = 0x00; 

    /*Disable all Tx interrupts*/
    RegPtr[DISEQC_TX_INTERRUPT_ENABLE] = 0x00 ;  

  
 
    /* FOR RECEIVING THIS CODE SHOULD BE DONE ONCE*/
    /*configure the sampling period time*/
    RegPtr[DISEQC_RX_SAMPLING_PERIOD] = 0x12e6;/* System clock  106Mhz,sampling frequency 22Khz*/
   	 
    RegPtr[DISEQC_POLARITY_INV] = 0x01;/*Polarity inverted*/
   	 
   	 /*configure the silence period time*/
    RegPtr[DISEQC_RX_SILENCE_PERIOD] = 0x113;/*12.5 ms  silence period for 22Khz sampling clock*/
   	 
    /*configure the min , max symbol 0 ,1 threshold period*/
    RegPtr[DISEQC_RX_SYMBOL0_MIN_THRESHOLD] = 0x11 ;/* 0.77ms for 22Khz sampling clock*/ 
    RegPtr[DISEQC_RX_SYMBOL0_MAX_THRESHOLD] = 0x1a;/*  1.18ms for 22Khz sampling clock*/ 
    RegPtr[DISEQC_RX_SYMBOL1_MIN_THRESHOLD] = 0x06 ;/* 0.27ms for 22Khz sampling clock*/ 
    RegPtr[DISEQC_RX_SYMBOL1_MAX_THRESHOLD] = 0x0f ;/* 0.68ms for 22Khz sampling clock*/ 
   	 
    RegPtr[DISEQC_RX_TIME_OUT] = 0x6e ;
    RegPtr[DISEQC_RX_NOISE_SUPPRESS_WIDTH] = 0x02;
    /*disable the soft reset */
    RegPtr[DISEQC_RX_SOFTRESET] =0x00;
    /*enable the receive section */
    RegPtr[DISEQC_RX_ENABLE] =0x00;
    /* Set DISEQC capability*/ 
    Capability->DISEQC_Mode = STTUNER_DISEQC_DEFAULT;
    Capability->DISEQC_VER = STTUNER_DISEQC_VER_2_0;
    
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
    STTBX_Print(("%s opened ok\n", identity));
#endif

    SEM_UNLOCK(Lock_InitTermOpenClose);
    return(Error);
}   



/* ----------------------------------------------------------------------------
Name: diseqc_diseqcdrv_Close()

Description:
    
Parameters:
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t diseqc_diseqcdrv_Close(DISEQC_Handle_t Handle, DISEQC_CloseParams_t *CloseParams)
{
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
   const char *identity = "STTUNER diseqc diseqc_diseqcdrv_Close()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    DISEQC_InstanceData_t     *Instance;

    /* private driver instance data */
    Instance = DISEQC_GetInstFromHandle(Handle);

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

    SEM_LOCK(Lock_InitTermOpenClose);

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

    if(Instance->TopLevelHandle == STTUNER_MAX_HANDLES)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
        STTBX_Print(("%s fail driver instance not open\n", identity));
#endif
        SEM_UNLOCK(Lock_InitTermOpenClose);
        return(ST_ERROR_OPEN_HANDLE);
    }


    Instance->TopLevelHandle = STTUNER_MAX_HANDLES;

#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
    STTBX_Print(("%s closed\n", identity));
#endif

    SEM_UNLOCK(Lock_InitTermOpenClose);
    return(Error);
}   


/* ----------------------------------------------------------------------------
Name: diseqc_diseqcdrv_SendReceive()

Description:
     
   
Parameters:
         Handle -- DISEQC Handle
    
Return Value: Instance pointer
---------------------------------------------------------------------------- */

ST_ErrorCode_t diseqc_diseqcdrv_SendReceive (DISEQC_Handle_t Handle,STTUNER_DiSEqCSendPacket_t *pDiSEqCSendPacket,
						STTUNER_DiSEqCResponsePacket_t *pDiSEqCResponsePacket)
{
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
   const char *identity = "STTUNER diseqc diseqc_diseqcdrv_SendReceive()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;
    DISEQC_InstanceData_t   *Instance;
    int i,j;
    U8 *TempTxData,NumWord;
    LNB_Handle_t LHandle;
    STTUNER_InstanceDbase_t *Inst;
#ifdef ST_OS21
    osclock_t Rx_delay,Rx_TimeOut,Tx_delay,Tx_TimeOut;
#else
    clock_t Rx_delay,Rx_TimeOut,Tx_delay,Tx_TimeOut;
#endif
    /* private driver instance data */
    Instance = DISEQC_GetInstFromHandle(Handle);
    RegPtr = Instance->BaseAddress;
   
    
    if(pDiSEqCSendPacket->uc_TotalNoOfBytes)
    {
    if ((TempTxData = memory_allocate_clear(Instance->MemoryPartition,pDiSEqCSendPacket->uc_TotalNoOfBytes,1)) == NULL)
       {
       	#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
        STTBX_Print(("%s fail memory allocation not done\n", identity));
        #endif
        return(ST_ERROR_NO_MEMORY);
       }
    }

    /*Set LNBH21 in Tx mode */
    Inst = STTUNER_GetDrvInst();
    LHandle = Inst[Instance->TopLevelHandle].Sat.Lnb.DrvHandle;
   
    Error = (Inst[Instance->TopLevelHandle].Sat.Lnb.Driver->lnb_setttxmode)(LHandle,STTUNER_LNB_TX);
    if (Error != ST_NO_ERROR)
     {
     	#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
         STTBX_Print(("%s fail driver lnbh ttx mode not set\n", identity));
        #endif
        return(Error);		
     }
   
   if(pDiSEqCSendPacket->uc_msecBeforeNextCommand == 0)
   {
   	pDiSEqCSendPacket->uc_msecBeforeNextCommand = 1;
   }
    /*Configure the silence period between messages*/
    RegPtr[DISEQC_TX_SILENCE_PERIOD]= pDiSEqCSendPacket->uc_msecBeforeNextCommand*22; 
   
    switch (pDiSEqCSendPacket->DiSEqCCommandType)
    {
    case STTUNER_DiSEqC_COMMAND:
    	RegPtr[DISEQC_TX_MESSAGE_CONFIG]= 0x00;
    	RegPtr[DISEQC_TX_MESSAGE_CONFIG] = (pDiSEqCSendPacket->uc_TotalNoOfBytes)<<2;    	
    	break;
    case STTUNER_DiSEqC_TONE_BURST_SEND_0_MODULATED:
    /*case STTUNER_DiSEqC_TONE_BURST_SEND_1:*/
      	RegPtr[DISEQC_TX_MESSAGE_CONFIG]= 0x03;
  	RegPtr[DISEQC_TX_MESSAGE_CONFIG]= RegPtr[DISEQC_TX_MESSAGE_CONFIG] |(0x09<<9);
        break;
   /* case STTUNER_DiSEqC_TONE_BURST_OFF_F22_HIGH:*/
    case STTUNER_DiSEqC_TONE_BURST_SEND_0_UNMODULATED:
    	RegPtr[DISEQC_TX_MESSAGE_CONFIG]= 0x01;
        RegPtr[DISEQC_TX_MESSAGE_CONFIG] = RegPtr[DISEQC_TX_MESSAGE_CONFIG] | (0x09<<9);
        break;
    case STTUNER_DiSEqC_CONTINUOUS_TONE_BURST_ON:
        RegPtr[DISEQC_TX_MESSAGE_CONFIG]= 0x010000;
         /*Now enable the transmission section*/
        RegPtr[DISEQC_TX_ENABLE] = 0x01; 
        return (ST_NO_ERROR);
    case STTUNER_DiSEqC_TONE_BURST_OFF_F22_LOW:
    case STTUNER_DiSEqC_TONE_BURST_OFF:
        RegPtr[DISEQC_TX_MESSAGE_CONFIG]= 0x00;
        /*Now enable the transmission section*/
        RegPtr[DISEQC_TX_ENABLE] = 0x01; 
        return (ST_NO_ERROR);
     default:
        break;/*STTUNER_ERROR_UNSUPPORTED_MESSAGE_TYPE*/;
    }
    
    
    /*During transmission ,disable reception */
       RegPtr[DISEQC_RX_ENABLE] = 0x00;
       RegPtr[DISEQC_RX_INTERRUPT_ENABLE] = 0x00;

if (pDiSEqCSendPacket->DiSEqCCommandType == STTUNER_DiSEqC_COMMAND)
{
          /*Check for total number of words to be sent*/
         NumWord = pDiSEqCSendPacket->uc_TotalNoOfBytes/4;
         if (pDiSEqCSendPacket->uc_TotalNoOfBytes%4 != 0)
         {
   	   NumWord +=1;
         }
       
        /*Software work around for MSB to LSB conversion*/
        for(i=0;i<pDiSEqCSendPacket->uc_TotalNoOfBytes;i++)
         {   	   
          for(j=0;j<8;j++)
           {
     	    TempTxData[i] = (TempTxData[i]|(((*(pDiSEqCSendPacket->pFrmAddCmdData+i)>>j)&0x01)<<(7-j)));
           }   
         }
   
      
       /*get the current fifo status*/
  
      for (i =0; i < NumWord; i++)  
       {
         RegPtr[DISEQC_TX_DATA_BUFFER] = *(U32 *)TempTxData;
         TempTxData = TempTxData+4;
       }
}       
   /*Now enable the transmission section*/
   RegPtr[DISEQC_TX_ENABLE] = 0x01; 
   
   
   /*Clear interrupt status for Tx Ready*/
   RegPtr[DISEQC_TX_CLR_INTERRUPT_STATUS] = 0x09;
   
   Tx_delay = time_now();
   /* Start transmission of the new message */
   RegPtr[DISEQC_TX_START] = 0x01;
   /*Enable interrupt for Tx ready*/
   RegPtr[DISEQC_TX_INTERRUPT_ENABLE] = 0x09 ;
  
   
   
    /* wait for transmission to complete */ /*Wait for 1 second*/
	    Tx_TimeOut = time_plus(Tx_delay, ST_GetClocksPerSecond());
    /*Wait for the Tx to transmit data*/
  if( semaphore_wait_timeout(DISEQC_Tx_Ready,&Tx_TimeOut) == -1)
  {
     #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
            STTBX_Print(("%s fail diseqc transmitter Transmission timeout occured\n", identity));
     #endif             
    	     return STTUNER_ERROR_DISEQC_TIMEOUT;    
  }
   /*Now disable  the transmission section*/
    RegPtr[DISEQC_TX_ENABLE] = 0x00;     

   if(*pDiSEqCSendPacket->pFrmAddCmdData == FB_COMMAND_REPLY
      || *pDiSEqCSendPacket->pFrmAddCmdData == FB_COMMAND_REPLY_REPEATED)
   {
   	/*reset  byte count register value */
   	gRx_byte_count = 0;
   
   	
   	/*Now set the LNBH21 into Rx mode */   
         Error = (Inst[Instance->TopLevelHandle].Sat.Lnb.Driver->lnb_setttxmode)(LHandle,STTUNER_LNB_RX);
        if (Error != ST_NO_ERROR)
	{
	  #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
             STTBX_Print(("%s fail driver lnbh ttx mode not set\n", identity));
           #endif
	 return(Error);		
	}   	
	
   	Rx_delay = time_now();
   	/*enable the receive section */
   	 RegPtr[DISEQC_RX_ENABLE] =0x01;
   	/*Enable the receiver interrupt generation*/
        RegPtr[DISEQC_RX_INTERRUPT_ENABLE] = 0x11 ;   	
       
        /* wait for receive complete */
	    Rx_TimeOut = time_plus(Rx_delay, ST_GetClocksPerSecond());

       if(semaphore_wait_timeout(DISEQC_Rx_last_byte_received,&Rx_TimeOut)!=-1)
        {
          /*Check for Parity/Symbol/Code Error*/
         if ((gDiseqc_rx_status & 0x80)>>7  )
         {
           #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
            STTBX_Print(("%s fail diseqc receiver SYMBOL error occured\n", identity));
           #endif             
    	     return STTUNER_ERROR_DISEQC_SYMBOL;    	   
    	 }
    	 
    	 if((gDiseqc_rx_status & 0x20)>>5)
    	 {
    	   #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
            STTBX_Print(("%s fail diseqc receiver CODE error occured\n", identity));
           #endif    	     
    	     return STTUNER_ERROR_DISEQC_CODE;    	
    	 }
    	 if ((gDiseqc_rx_status & 0x40)>>6)
    	 {
    	   #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
            STTBX_Print(("%s fail diseqc receiver PARITY error occured\n", identity));
           #endif
    	   return  STTUNER_ERROR_DISEQC_PARITY;    	    
    	 }
          if ( Rx_array_ptr > 0)
	      {
	      	
	        pDiSEqCResponsePacket->uc_TotalBytesReceived = gRx_byte_count;
	      
                if ((pDiSEqCResponsePacket->ReceivedFrmAddData = memory_allocate_clear(Instance->MemoryPartition,pDiSEqCResponsePacket->uc_TotalBytesReceived ,1)) == NULL)
    		  {
       		    #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
                      STTBX_Print(("%s fail memory allocation not done\n", identity));
                    #endif
                   return(ST_ERROR_NO_MEMORY);
                 }          
               pDiSEqCResponsePacket->ReceivedFrmAddData = (U8 *)data_rx_array;                                   
	       Rx_array_ptr = 0;
	      }
         }
         else
         {
           #ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
             STTBX_Print(("%s fail diseqc receiver no message recieved\n", identity));
           #endif
           return STTUNER_ERROR_DISEQC_TIMEOUT ;
         }
         
        /*Now Disable reception */
        RegPtr[DISEQC_RX_ENABLE] =0x00;
      	 /*Enable the receiver interrupt generation*/
        RegPtr[DISEQC_RX_INTERRUPT_ENABLE] = 0x00 ;
        
}
    return ST_NO_ERROR;
}						


/* ----------------------------------------------------------------------------
Name: DISEQC_GetInstFromHandle()

Description:     
   
Parameters:   
Return Value: Instance pointer
---------------------------------------------------------------------------- */
DISEQC_InstanceData_t *DISEQC_GetInstFromHandle(DISEQC_Handle_t Handle)
{

    DISEQC_InstanceData_t *Instance;
    Instance = (DISEQC_InstanceData_t *)Handle;
    return(Instance);
}