irframer.c

MTK平台绝密核心代码之 外设管理（红外线）

* DESCRIPTION
*	This function is to set baudrate as 9600
*  
* PARAMETERS
*  None 
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void Reset_Baudrate(void)
{
   if (set_baudrate == 1)
   {
      IR_SetBaudRate(IrPort.baud);
      set_baudrate = 0;
   }  
}   
 
/*************************************************************************
* FUNCTION
*	IR_FrameRxDone
*
* DESCRIPTION
*	This function is called when finishing receive a frame
*  
*
* PARAMETERS
*  None 
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void IR_FrameRxDone(void)
{
   kal_uint8 frame_index;  
   kal_uint16 frame_size;
   frame_size=DRV_Reg(IR_RX_FRAME_SIZE);
   /*check CRC error and receive frame size*/
   if((ir_crc_detect==KAL_FALSE)&&(irda_frame1_error==KAL_FALSE)&&(frame_size<=IRMAXDATASIZE))
   {
      frame_index=IrPort.rxdata_index;
      IrPort.rxdata_count[IrPort.rxdata_index] = DRV_Reg(IR_RX_FRAME_SIZE);
      IrPort.rxdata_index++;
      if (IrPort.rxdata_index == IrRingBufferLength)
         IrPort.rxdata_index = 0;
      IrPort.rxdata_count[IrPort.rxdata_index]= 0;
      Ir_DMA_RxInit((kal_uint32)IrPort.rxdata_buffer[IrPort.rxdata_index],IRMAXDATASIZE);
      IR_FrameProcess(frame_index);
   }
   else
   {
      Ir_DMA_RxInit((kal_uint32)IrPort.rxdata_buffer[IrPort.rxdata_index],IRMAXDATASIZE);
      ir_crc_detect=KAL_FALSE;
      irda_frame1_error=KAL_FALSE;
    }  
    }  
/*************************************************************************
* FUNCTION
*	IR_MaxTimeTimeout
*
* DESCRIPTION
*	This function is to handle max trun around timer interrupt
* 
* PARAMETERS
*  None
*
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
volatile kal_uint8 dbg_timeout=0;
void IR_MaxTimeTimeout(void)
{
   dbg_timeout=1;
   DRV_WriteReg(IR_COUNT_ENABLE,0);  
}   
/*************************************************************************
* FUNCTION
*	IR_StartMaxTime
*
* DESCRIPTION
*	This function is to start max trun around timer
* 
* PARAMETERS
*  None
*
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
static kal_uint16 max_time_count=32;
void IR_StartMaxTime(void)
{ 
   kal_uint32 i=0; 
   dbg_timeout=0;     
   DRV_WriteReg(IR_MAX_T,max_time_count);/*max turn around time*/
   DRV_WriteReg(IR_COUNT_ENABLE,1);
   while(dbg_timeout==0)
   {
      i++;  
      if(i>=10000)
         break;      
  }
   dbg_timeout=0;          
}  

static kal_uint16 min_time_count=5;
void IR_wait_min(void)
{ 
	kal_uint32 result=0;			
	GPT_Stop(3);
	GPT_Start(3);
	
	while(1)
	{
		result=GPT_return_current_count();
		if(result>=min_time_count)
			break;
	}	
	GPT_Stop(3); 
}  


/*************************************************************************
* FUNCTION
*	IR_StopMaxTime
*
* DESCRIPTION
*	This function is to stop max trun around timer
* 
* PARAMETERS
*  None
*
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
void IR_StopMaxTime(void)
{    
    DRV_WriteReg(IR_COUNT_ENABLE,0);    
}
/*************************************************************************
* FUNCTION
*	IR_HISR
*
* DESCRIPTION
*	This function is used to process irda interrupt
*  
*
* PARAMETERS
*  None
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
#ifdef IRDA_DEBUG 
kal_uint16 dbg_int_status[10];
kal_uint16 dbg_int_38status[10];
kal_uint16 dbg_frame1_status[10];
kal_uint8 dbg_int_count=0;
kal_uint16 rx_abort=0;
#endif
#undef dbg_print
#define dbg_print
volatile kal_uint8 dbg_rx_fifo_empty=0;
kal_uint16 irda_status;
void IR_HISR(void)
{
	#ifdef IRDA_DEBUG 
   /*interrupt status*/    
   dbg_int_status[dbg_int_count]=irda_status;/*34*/ 
   dbg_int_38status[dbg_int_count]=DRV_Reg(IR_LSR);/*38*/
   dbg_int_count++;
   dbg_int_count=dbg_int_count%10;    
   #endif
   if (irda_status & IR_STA_TXCOMPLETE)
   {
      IR_FrameTxDone();
   }  /*2*/
   
   if (irda_status & IR_STA_LSR)
   {
      kal_uint16 LSR;
      LSR = DRV_Reg(IR_LSR);
      if(LSR&IR_LSR_RXSIZE)
      	IR_FrameRxDone();
      #if defined(MT6228)||defined(MT6229) || defined(MT6230) 
      else if(LSR&IR_FRAME1_ERROR)
      {
      	irda_frame1_error=KAL_TRUE;
      	IR_FrameRxDone();         
      }	        	   
      if(LSR&IR_TX_UNDERRUN)
      	IR_FrameTxDone();
      #endif	      	
   }   /*1*/

   if (irda_status & IR_STA_FIFOTOUT)
   {
      IR_Receive();
   }  /*3*/
   
   if (irda_status & IR_STA_RXTRIG)
   {
      IR_Receive();
   }  /*4*/

   if (irda_status & IR_STA_RXCOMPLETE)/*RX Complete*/
   {      

   	static kal_uint8 crc_count=0;   	
		kal_uint8 rx_status=0;		
		#if defined(MT6228)||defined(MT6229) || defined(MT6230)
		static kal_uint32 rx_empty_cnt=0;
		/*IR_FIFO_STA*/		
		rx_empty_cnt=0;	   
   	do
      {
   		rx_empty_cnt++;
   		dbg_rx_fifo_empty=DRV_Reg(IR_FIFO_STA);
   		dbg_rx_fifo_empty&=0x1;
   		if(rx_empty_cnt==10000)
   		   break;
   	} while(!dbg_rx_fifo_empty);	
   	#endif
   	rx_status=DRV_Reg(IR_FRAME1_STA);
   	rx_status&=0x2;   
      media_busy_mark=1;
   	if(rx_status)
			crc_count++;   	         
      IR_FrameRxDone();
   }  /*5*/
   
   if (irda_status & IR_STA_TXTRIG)
   {
      IR_Transmit();
   }  /*4*/
   
   if (irda_status & IR_STA_MINTOUT)
   {
   }  /*6*/
   
   if (irda_status & IR_STA_MAXTOUT)
   {
      /*IR_MaxTimeTimeout();*/
   }  /*8*/
      
   if (irda_status & IR_STA_TXABORT)
   {      
      #if defined(MT6219)
      ir_crc_detect=KAL_TRUE; 
      #elif defined(MT6218B)
      if(INT_ecoVersion() > EN)
        ir_crc_detect=KAL_TRUE;                    
      #endif
   }  /*9*/       
   if (irda_status & IR_STA_RXABORT)/*RX Abort*/
   {
      #ifdef IRDA_DEBUG 
      rx_abort++;       
      #endif
   }  /*10*/   
   if (irda_status & IR_STA_THRESHTOUT)
   {
   }  /*11*/
   if (irda_status& IR_STA_2ND_RXCOMPLETE)/*2 frame complete*/
   {      
   }  
   IRQClearInt(IRQ_IrDA_CODE);
   IRQUnmask(IRQ_IrDA_CODE);
}

void IR_LISR(void)
{
   irda_status = DRV_Reg(IR_STA);

   IRQMask(IRQ_IrDA_CODE);  
   kal_activate_hisr(IrPort.hisr);
   //drv_active_hisr(DRV_IRDA_HISR_ID);
}
/*************************************************************************
* FUNCTION
*	IRFRAMER_Test
*
* DESCRIPTION
*	This function is only for test
*  
* PARAMETERS
*  None
*
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
void IRFRAMER_Test(void)
{
   InitBuf();
   IrLAP_LINK_init();
   IR_Init(CONTENTION_BAUD);
   init_irda_lmp();
   IAS_Disconnect_Indication();		
}
/*************************************************************************
* FUNCTION
*	IRDA_Open
*
* DESCRIPTION
*	This function is used by MMI to open irda 
*  
*
* PARAMETERS
*  None
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void IRDA_Open(void)
{    
   #ifdef DCM_ENABLE
   DCM_Disable(irda_dcm_handle);
   #endif   
   #if (defined(MT6219))||defined(MT6226M)||defined(MT6228)||defined(MT6229) || defined(MT6230)||defined(MT6226)||defined(MT6227)
   DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_IRDA,PDN_IRDA);
   #endif
   /*Power on*/
   DRV_WriteReg(IR_TRANSCEIVER_PDN,IR_POWER_ON);
   /*mode selection*/
   Ir_switch_to_sir();
   /*turn on UPLL and USB power*/            
   UPLL_Enable(UPLL_OWNER_IRDA);
   Ir_DMA_RxInit((kal_uint32)IrPort.rxdata_buffer[IrPort.rxdata_index],IRMAXDATASIZE);
   IRQUnmask(IRQ_IrDA_CODE);
}

/*************************************************************************
* FUNCTION
*	IRDA_Close
*
* DESCRIPTION
*	This function is used by MMI to close irda 
*  
*
* PARAMETERS
*  None
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void IRDA_Close(kal_uint32 baud)
{
   UPLL_Disable (UPLL_OWNER_IRDA);
   /*Interrupt*/
   IRQMask(IRQ_IrDA_CODE);
   
   /*The following are from IR_init*/
   #if (defined(MT6219))||defined(MT6226M)||defined(MT6228)||defined(MT6229) || defined(MT6230)||defined(MT6226)||defined(MT6227)
   DRVPDN_Disable(DRVPDN_CON1,DRVPDN_CON1_IRDA,PDN_IRDA);
   #endif 

   IrPort.baud = baud;
   
   
   /*Set up maxmum data size*/
   DRV_WriteReg(IR_RX_FRAME_MAX,IRMAXDATASIZE);
   /*Set up baud rate*/
   IR_SetBaudRate(baud);
   
   /*Clear HW FIFO*/
   /*tricky, make sure SIR mode*/
   #if defined(MT6228)||defined(MT6229) || defined(MT6230)
   if((DRV_Reg(IR_MODE)&0x7)==0)
   #endif
      IR_ClearFIFO();
   /*set up IrFramer in Rx state*/
   IR_RxEnable();         
   /*Set up the no. of BOFS*/ 
   DRV_WriteReg(IR_BOFS,IR_BOFS_INIVALUE);
   /*DMA mode*/
   DMA_Stop(irda_rx_dmaport);
   /*DMA initialize*/
   Ir_DMA_Initialize();
   /*Initialize the Interrupt*/
   DRV_WriteReg(IR_IRQ_ENABLE,IR_IRQ_ENABLE_DMANORMAL);       
   DRV_WriteReg(IR_INTTRIGGER,IR_INTTRIGGER_NORMAL);

   IrBuf_init(&(IrPort.Tx_Buffer),(kal_uint32 *)(IrPort.trxptr),(kal_uint16)IrRingBufferLength);
   #ifdef DCM_ENABLE
   DCM_Enable(irda_dcm_handle);
   #endif   
   /*Power off*/
   DRV_WriteReg(IR_TRANSCEIVER_PDN,IR_POWER_OFF); 
   #if (defined(MT6219))||defined(MT6226M)||defined(MT6228)||defined(MT6229) || defined(MT6230)||defined(MT6226)||defined(MT6227)
   DRVPDN_Enable(DRVPDN_CON1,DRVPDN_CON1_IRDA,PDN_IRDA);
   #endif

}