diseqcdrv.c

st7710的tuner标准驱动

/* ----------------------------------------------------------------------------
File Name: diseqcdrv.c

Description: 

    
Copyright (C) 2004-2005 STMicroelectronics

History:
 
   date: 
version: 
 author: 
comment: 

date: 
version: 
 author: 
comment: 

date: 
version: 
 author: 
comment: 
    
Reference:

    
---------------------------------------------------------------------------- */


/* Includes ---------------------------------------------------------------- */

/* C libs */
#include <string.h>       

#include "stlite.h"     /* Standard includes */
#include "stcommon.h"
/* STAPI */
#include "sttbx.h"
#include "sttuner.h"                    

/* local to sttuner */
#include "util.h"       /* generic utility functions for sttuner */
#include "dbtypes.h"    /* data types for databases */
#include "sysdbase.h"   /* functions to accesss system data */

#include "diseqc.h"     

/* DISEQC register offset */
#define DISEQC_NUM_REGITERS 35 /*Number of diseqc registers*/



	/**Transmitter registers*/
#define DISEQC_TX_ENABLE  		 0x00/*  0x00  Enable message transmission */
#define DISEQC_TX_MESSAGE_CONFIG 	 0x01/* 0x04 Transmit message configuration*/
#define DISEQC_TX_PRE_SCALER 		 0x02/* 0x08 Holds the pre scaler value for transmission*/
#define DISEQC_TX_SUBCARRIER_DIV	 0x03/* 0x0C Holds the sub carrrier generation division value*/
#define DISEQC_TX_SILENCE_PERIOD	 0x04/* 0x10 Transmit message silence period*/
#define DISEQC_TX_DATA_BUFFER		 0x05/* 0x14 Transmit data buffer*/
#define DISEQC_TX_SYMBOL_PERIOD   	 0x06/* 0x18 Period of symbol to be transmitted */
#define DISEQC_TX_SYMBOL0_ONTIME  	 0x07 /*0x1C Symbol 0 on time period*/
#define DISEQC_TX_SYMBOL1_ONTIME  	 0x08/* 0x20 Symbol 1 on time period*/
#define DISEQC_TX_SOFT_RESET		 0x09/* 0x24 Soft resets the Tx section*/
#define DISEQC_TX_START			 0x0A/* 0x28 start message transmission*/
#define DISEQC_TX_INTERRUPT_ENABLE	 0x0B/* 0x2C Enable tx interrupt generation*/
#define DISEQC_TX_INTERRUPT_STATUS       0x0C/* 0x30 Tx interrupt status*/
#define DISEQC_TX_STATUS	         0x0D/* 0x34  Tx status */
#define DISEQC_TX_CLR_INTERRUPT_STATUS   0x0E/* 0x38 Tx clear interrupt status*/
#define DISEQC_RESERVED			 0x0F/* 0x3C reserved for future use*/
#define DISEQC_TX_AGC_CONTROL	     	 0x10/* 0x40  Tx AGC control*/

	/**Receiver registers*/
#define DISEQC_RX_ENABLE  		 0x20/*0x80  Enable receiving section */
#define DISEQC_RX_SAMPLING_PERIOD	 0x21/*0x84 Holds the sampling value*/	
#define DISEQC_RX_BYTE_COUNT		 0x22/*0x88 Number of bytes received*/
#define DISEQC_RX_SILENCE_PERIOD         0x23/*0x8C Receive message silence period*/
#define DISEQC_RX_DATA_BUFFER		 0x24/*0x90 Receive data buffer*/
#define DISEQC_RX_SYMBOL0_MIN_THRESHOLD  0x25/*0x94 Min. threshold for symbol 0 on time */
#define DISEQC_RX_SYMBOL0_MAX_THRESHOLD  0x26/*0x98 Max. threshold for symbol 0 on time*/
#define DISEQC_RX_SYMBOL1_MIN_THRESHOLD  0x27/*0x9C Min. threshold for symbol 1 on time*/
#define DISEQC_RX_SYMBOL1_MAX_THRESHOLD  0x28/*0xA0 Max. threshold for symbol 1 on time*/
#define DISEQC_RX_SOFTRESET		 0x29/*0xA4 Soft resets the Rx section*/
#define DISEQC_RX_INTERRUPT_ENABLE   	 0x2A/*0xA8 Enable Rx interrupt generation*/
#define DISEQC_RX_INTERRUPT_STATUS	 0x2B/*0xAC Rx interrupt status*/
#define DISEQC_RX_STATUS	         0x2C/*0xB0 Rx status*/
#define DISEQC_RX_CLR_INTERRUPT_STATUS   0x2D/*0xB4 Clear Rx interrupt status*/
#define DISEQC_RX_TIME_OUT	    	 0x2E/*0xB8 Rx timeout*/
#define DISEQC_RX_NOISE_SUPPRESS_WIDTH   0x2F/*0xBC Rx noise suppression width*/
#define DISEQC_POLARITY_INV		 0x30/*0xC0 Rx polarity inversion*/
#define DISEQC_SUBCARRIER_SUPRESS_ENABLE 0x31/*0xC4 Rx sub carrier supression enable*/



#ifdef ST_OS21
static semaphore_t *Lock_InitTermOpenClose; /* guard calls to the functions */
#else
static semaphore_t Lock_InitTermOpenClose; /* guard calls to the functions */
#endif
static BOOL        Installed = FALSE;

#ifdef ST_OS21
#define Delay_ms(x) task_delay((signed  int)((ST_GetClocksPerSecond()/1000)*x));
#else
#define Delay_ms(x) task_delay((unsigned int)((ST_GetClocksPerSecond()/1000)*x));
#endif 

volatile U32   *RegPtr;
static int Rx_array_ptr = 0;
U32 data_rx_array[20]; /*Maximum receive buffer size taken as 20. Can be changed according to the application*/
int gRx_byte_count; /*Byte counter register value to be stored*/
int gDiseqc_rx_status;/*Byte counter register value to be stored*/
/* ---------- per instance of driver ---------- */
typedef struct DISEQC_InstanceData_s
{
    ST_DeviceName_t        *DeviceName;           /* unique name for opening under */
    STTUNER_Handle_t       TopLevelHandle;       /* access tuner, lnb etc. using this */
    IOARCH_Handle_t        IOHandle;             /* instance access to I/O driver     */
        
    ST_Partition_t         *MemoryPartition;     /* which partition this data block belongs to */
    void                   *InstanceChainPrev;   /* previous data block in chain or NULL if not */
    void                   *InstanceChainNext;   /* next data block in chain or NULL if last */ 
    U32                    *BaseAddress;/*Base address for accessing the diseqc registers*/
#ifdef ST_OS21
    interrupt_name_t       InterruptNumber; /*Interrupt number for diseqc*/
#else 
    U32                    InterruptNumber;/*Interrupt number for diseqc*/
#endif
    U32                    InterruptLevel; /*interrupt level for diseqc*/
}DISEQC_InstanceData_t;


/* instance chain, the default boot value is invalid, to catch errors */
static DISEQC_InstanceData_t *InstanceChainTop = (DISEQC_InstanceData_t *)0x7fffffff;


semaphore_t *DISEQC_Tx_Ready,*DISEQC_Rx_last_byte_received;

/* functions --------------------------------------------------------------- */

/* API */
ST_ErrorCode_t diseqc_diseqcdrv_Init(ST_DeviceName_t *DeviceName, DISEQC_InitParams_t *InitParams);
ST_ErrorCode_t diseqc_diseqcdrv_Term(ST_DeviceName_t *DeviceName, DISEQC_TermParams_t *TermParams);

ST_ErrorCode_t diseqc_diseqcdrv_Open (ST_DeviceName_t *DeviceName, DISEQC_OpenParams_t  *OpenParams, DISEQC_Handle_t  *Handle,DISEQC_Capability_t *Capability);
ST_ErrorCode_t diseqc_diseqcdrv_Close(DISEQC_Handle_t  Handle, DISEQC_CloseParams_t *CloseParams);
ST_ErrorCode_t diseqc_diseqcdrv_SendReceive (DISEQC_Handle_t,STTUNER_DiSEqCSendPacket_t *pDiSEqCSendPacket,
						STTUNER_DiSEqCResponsePacket_t *pDiSEqCResponsePacket);
/* local functions --------------------------------------------------------- */

DISEQC_InstanceData_t *DISEQC_GetInstFromHandle(DISEQC_Handle_t Handle);


static void Diseqc_tx_interrupt_handler(void )
{
  U32  diseqc_tx_int_status;
  
  diseqc_tx_int_status = RegPtr[DISEQC_TX_INTERRUPT_STATUS]; 
   /* TX READY */
  if ( diseqc_tx_int_status & 0x08 )
  {
    RegPtr[DISEQC_TX_CLR_INTERRUPT_STATUS] = 0x08;
    RegPtr[DISEQC_TX_INTERRUPT_ENABLE] &= ~0x08;
    semaphore_signal(DISEQC_Tx_Ready);
  }
}

static U32 Swap_u32(U32 buffer)
{
  U32 TempData;
  int i;

  TempData = 0;
  if ( buffer > 0xffffff)
  {
    for ( i=0;i<32;i++)
	{
	  TempData |= (((buffer>>i)&1)<< (31-i));
	}
  }
  else if ( buffer > 0xffff)
  {
    for ( i=0;i<24;i++)
	{
	  TempData |= (((buffer>>i)&1)<< (23-i));
	}
  }
  else if ( buffer > 0xff)
  {
    for ( i=0;i<16;i++)
	{
	  TempData |= (((buffer>>i)&1)<< (15-i));
	}
  }
  else /* if (buffer < 0x1ff) */
  {
    for ( i=0;i<8;i++)
	{
	  TempData |= (((buffer>>i)&1)<< (7-i));
	}
  }

  return TempData;
}


static void Diseqc_rx_interrupt_handler( void )
{
  int diseqc_rx_int_status;
  int rx_fifo_status;
  int i;

  /* read the Rx interrupt status */
  gDiseqc_rx_status = RegPtr[DISEQC_RX_STATUS];
  diseqc_rx_int_status = RegPtr[DISEQC_RX_INTERRUPT_STATUS];
  
  /* RX LAST BYTE RECEIVED */
  if ( diseqc_rx_int_status & 0x010)
  {
    rx_fifo_status = (RegPtr[DISEQC_RX_STATUS]>>9)&0x7;
   
    if (rx_fifo_status != 0)
    {
      for (i=0; i<rx_fifo_status; i++)
       {
        data_rx_array[Rx_array_ptr] = RegPtr[DISEQC_RX_DATA_BUFFER];
       	gRx_byte_count = RegPtr[DISEQC_RX_BYTE_COUNT];
       	data_rx_array[Rx_array_ptr] = Swap_u32(data_rx_array[Rx_array_ptr]);
      	switch ( gRx_byte_count )
        {
	  case 0 :
	    data_rx_array[Rx_array_ptr] &= 0x00;
	    break;
	  case 1 :
	    data_rx_array[Rx_array_ptr] &= 0xff;
	    break;
	  case 2 :
	    data_rx_array[Rx_array_ptr] &= 0xffff;
	    break;
	  case 3 :
	    data_rx_array[Rx_array_ptr] &= 0xffffff;
	    break;
	}
		Rx_array_ptr++;
      }
    }
	/* clear the interrupt status */
    RegPtr[DISEQC_RX_CLR_INTERRUPT_STATUS] = 0x10;
    RegPtr[DISEQC_RX_INTERRUPT_ENABLE] &= ~0x10;

   semaphore_signal(DISEQC_Rx_last_byte_received);
  }
}


static void  DiseqcHandler(void)
{

 if ( (RegPtr[DISEQC_TX_INTERRUPT_STATUS] & 0x01) == 0x01)
  {
     Diseqc_tx_interrupt_handler ();
  }
  if ( (RegPtr[DISEQC_RX_INTERRUPT_STATUS] & 0x01) == 0x01)
  {
     Diseqc_rx_interrupt_handler ();
  }      
  
  return;
}

/* ----------------------------------------------------------------------------
Name: STTUNER_DRV_DISEQC_Install()

Description:
    
    
Parameters:

Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t STTUNER_DRV_DISEQC_5100_530X_Install(STTUNER_diseqc_dbase_t *Diseqc)
{

    ST_ErrorCode_t Error = ST_NO_ERROR;

    if(Installed == TRUE)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
        STTBX_Print(("%s fail driver already installed\n", identity));
#endif
        return(STTUNER_ERROR_INITSTATE);
    }
   
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
    STTBX_Print(("%s installing sat:diseqc...", identity));
#endif

    /* mark ID in database */
    Diseqc->ID = STTUNER_DISEQC_5100;

    /* map API */
    Diseqc->diseqc_Init = diseqc_diseqcdrv_Init;
    Diseqc->diseqc_Term = diseqc_diseqcdrv_Term;

    Diseqc->diseqc_Open  = diseqc_diseqcdrv_Open;
    Diseqc->diseqc_Close = diseqc_diseqcdrv_Close;
    
    Diseqc->diseqc_SendReceive = diseqc_diseqcdrv_SendReceive;
    
    
    InstanceChainTop = NULL;

#ifdef ST_OS21    
    Lock_InitTermOpenClose = semaphore_create_fifo(1);
#else
   semaphore_init_fifo(&Lock_InitTermOpenClose,1);
#endif
    Installed = TRUE;
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
    STTBX_Print(("ok\n"));
#endif

    return(Error);
}



/* ----------------------------------------------------------------------------
Name: STTUNER_DRV_DISEQC_unInstall()

Description:
   
    
Parameters:
    
Return Value:
---------------------------------------------------------------------------- */
ST_ErrorCode_t STTUNER_DRV_DISEQC_5100_530X_unInstall(STTUNER_diseqc_dbase_t *Diseqc)
{
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
   const char *identity = "STTUNER diseqc STTUNER_DRV_DISEQC_unInstall()";
#endif
    ST_ErrorCode_t Error = ST_NO_ERROR;

    if(Installed == FALSE)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
        STTBX_Print(("%s fail driver not installed\n", identity));
#endif
        return(STTUNER_ERROR_INITSTATE);
    }
   
    if(Diseqc->ID != STTUNER_DISEQC_5100)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
        STTBX_Print(("%s fail incorrect driver type\n", identity));
#endif
        return(STTUNER_ERROR_ID);
    }

    /* has all memory been freed, by Term() */
    if(InstanceChainTop != NULL)
    {
#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
        STTBX_Print(("%s fail at least one instance not terminated\n", identity));
#endif
        return(ST_ERROR_OPEN_HANDLE);
    }


#ifdef STTUNER_DEBUG_MODULE_SATDRV_DISEQC
    STTBX_Print(("%s uninstalling sat:diseqc...", identity));
#endif

    /* mark ID in database */
    Diseqc->ID = STTUNER_NO_DRIVER;