irframer.c

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

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/
#include 	"kal_release.h"       /*kal basic type*/
#include 	"stack_common.h"  
#include 	"stack_msgs.h"
#include 	"app_ltlcom.h"       /* Task message communiction */
#include 	"drv_comm.h"
#include     "reg_base.h"
#include    "bmd.h"
#include    "intrCtrl.h"
#include    "drvpdn.h"
#include    "stack_ltlcom.h"       /*msg_send_ext_queue.....definitions*/
#include    "stack_config.h"        /*MOD_IRDA_HISR==MOD_UART2_HISR*/
#include    "irda_enums.h"       /* irda enum */                     
#include    "gprs_flc_kal.h"  
#include    "gprs_flc_common_data_types.h"
#include    "flc_tunable_para.h"
#include    "irframer_hw.h"
#include    "irframer_sw.h"
#include    "gpio_hw.h"
#include    "dma_hw.h"
#include    "dma_sw.h"
#include    "irdahead.h"
#include    "stack_config.h"
#include    "kal_trace.h"                     
#include    "irda_trace.h"
#include    "drvpdn.h"
#include    "init.h"
#include    "gpio_sw.h"
#include    "gpt_sw.h"
#include    "irda_sw.h"
#include    "upll_ctrl.h"
#include    "drv_hisr.h"

/*IrPro issue*/
kal_uint8     test_flag;
kal_uint8     set_baudrate;
kal_uint8     set_bof_flag;
kal_uint8     irda_addtional_bof;
kal_uint8     IR_timer_owner;
FBUF          *PreBuffer;
FBUF          *rx_lap_frame;
const irda_customize_function_struct *irda_custom_ptr;
extern void IR_StartMaxTime(void);
/*For DMA grobal variable*/
extern kal_uint8 DMA_GetChannel(DMA_Master DMA_CODE);
/*TX*/
kal_uint8			   irda_tx_dmaport;
static DMA_INPUT     irda_tx_input;
static DMA_HWMENU    irda_tx_menu;
/*RX*/
kal_uint8			   irda_rx_dmaport;
static DMA_INPUT     irda_rx_input;
static DMA_HWMENU    irda_rx_menu;
/*CRC detect*/
static kal_bool ir_crc_detect=KAL_FALSE;
static kal_bool irda_frame1_error=KAL_FALSE;
   
/*IrFramer must use DMA channel*/
#ifdef MCU_13M
   #define   IrClock   13000000    /* 13M */
#endif   /*MCU_13M*/

#ifdef MCU_26M
   #define   IrClock   26000000    /* 26M */
#endif   /*MCU_26M*/

#ifdef MCU_52M
   #define   IrClock   52000000    /* 52M */
#endif   /*MCU_52M*/

#ifdef MCU_104M
   #define   IrClock  52000000    /* 104M */
#endif   /*MCU_104M*/


//#pragma arm section rwdata = "INTERNRW" , rodata = "INTERNCONST" , zidata = "INTERNZI"
IrDataStruct IrPort;
//#pragma arm section

kal_uint8 irda_fir=0;
kal_uint8 irda_mir=0;
kal_uint8 irda_mode_gpio=0;

#ifdef DCM_ENABLE
/*DCM control*/
extern kal_uint8 DCM_GetHandle(void);
extern void DCM_Disable(kal_uint8 handle);	
extern void DCM_Enable(kal_uint8 handle);
kal_uint8 irda_dcm_handle=0;
#endif

void ir_delay(kal_uint32 count)
{
   kal_uint32 i;
   for(i=0;i<count;i++){};      
}
/*SIR/MIR/FIR mode switch*/
/*************************************************************************
* FUNCTION
*	Ir_switch_to_sir
*
* DESCRIPTION
*	This function is used to switch transciver as SIR mode
*
* PARAMETERS
*  None 
*  
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
void Ir_switch_to_sir(void)
{
   irda_custom_ptr->irda_switch_to_sir();
}	
/*************************************************************************
* FUNCTION
*	Ir_switch_to_mir
*
* DESCRIPTION
*	This function is used to switch transciver as SIR mode
*
* PARAMETERS
*  None 
*  
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
void Ir_switch_to_mir(void)
{
   irda_custom_ptr->irda_switch_to_mir();
}
/*************************************************************************
* FUNCTION
*	Ir_switch_to_fir
*
* DESCRIPTION
*	This function is used to switch transciver as SIR mode
*
* PARAMETERS
*  None 
*  
* RETURNS
*  None 
*
* GLOBALS AFFECTED
*
*************************************************************************/
void Ir_switch_to_fir(void)
{
   irda_custom_ptr->irda_switch_to_fir();
}
/*DMA API*/
/*************************************************************************
* FUNCTION
*	Ir_DMA_RxInit
*
* DESCRIPTION
*	This function is used to set DMA RX path
*
* PARAMETERS
*  kal_uint32 addr
*  kal_uint16 count 
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void Ir_DMA_RxInit(kal_uint32 addr,kal_uint16 count)
{
   /*tricky*/
   if(IrPort.baud==4000000||IrPort.baud==576000||IrPort.baud==1152000)
   { 	
      //IR_ClearFIFO();
      DRV_WriteReg(IR_TX_EN,IR_TX_EN_DISABLE);     
      DRV_WriteReg(IR_RX_EN,(IR_RX_EN_NORMAL|IR_RX_EN_INVERT));   	
   }	
   else 
   {
      /*tricky, make sure SIR mode*/
      #if defined(MT6228)||defined(MT6229) || defined(MT6230)
      if((DRV_Reg(IR_MODE)&0x7)==0)
      #endif
      IR_ClearFIFO();
   IR_RxEnable();
   }   
   
   /*DMA RX Setting*/
   irda_rx_menu.addr = addr;
	irda_rx_input.count = count;
	irda_rx_input.type =  DMA_HWRX;
	DMA_Stop(irda_rx_dmaport);   
	DMA_Config(irda_rx_dmaport, &irda_rx_input, KAL_TRUE);
}
/*************************************************************************
* FUNCTION
*	Ir_DMA_TxInit
*
* DESCRIPTION
*	This function is used to set DMA TX path
*
* PARAMETERS
*  kal_uint32 addr
*  kal_uint16 count 
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void Ir_DMA_TxInit(kal_uint32 addr,kal_uint16 count)
{/*Transmit data to DMA*/

   DMA_Stop(irda_rx_dmaport);   
   /*tricky, make sure SIR mode*/
   #if defined(MT6228)||defined(MT6229) || defined(MT6230)
   if((DRV_Reg(IR_MODE)&0x7)==0)
   #endif
   IR_ClearFIFO();
   IR_TxEnable();
   DRV_WriteReg(IR_TX_FRAME_SIZE,count);
   /*DMA TX Setting*/
   irda_tx_menu.addr = addr;
	irda_tx_input.count = count;
	irda_tx_input.type =  DMA_HWTX;
	DMA_Stop(irda_tx_dmaport);
	DMA_Config(irda_tx_dmaport, &irda_tx_input, KAL_TRUE);
	
}
/*************************************************************************
* FUNCTION
*	Ir_DMA_Initialize
*
* DESCRIPTION
*	This function is used to initialize DMA
*
* PARAMETERS
*  None
*  
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void Ir_DMA_Initialize(void)
{
   
   static kal_bool is_initialized = KAL_FALSE;

	if(is_initialized) return;
	/*TX*/
	irda_tx_dmaport = DMA_GetChannel(DMA_IRDATX);
	irda_tx_menu.TMOD.burst_mode = 0;
	irda_tx_menu.master = DMA_IRDATX;
	irda_tx_menu.addr = NULL;

	irda_tx_input.type = DMA_HWTX;
	irda_tx_input.size = DMA_BYTE;
	irda_tx_input.count = 0;
	irda_tx_input.callback = NULL;
	irda_tx_input.menu = &irda_tx_menu;
	/*RX*/
	irda_rx_dmaport = DMA_GetChannel(DMA_IRDARX);
	irda_rx_menu.TMOD.burst_mode = 0;
	irda_rx_menu.master = DMA_IRDARX;
	irda_rx_menu.addr = NULL;

	irda_rx_input.type = DMA_HWRX;
	irda_rx_input.size = DMA_BYTE;
	irda_rx_input.count = 0;
	irda_rx_input.callback = NULL;
	irda_rx_input.menu = &irda_rx_menu;	

	is_initialized = KAL_TRUE;
	
   //Ir_DMA_RxInit((kal_uint32)IrPort.rxdata_buffer[IrPort.rxdata_index],IRMAXDATASIZE);
}
/*************************************************************************
* FUNCTION
*	IRDA_sendilm
*
* DESCRIPTION
*	This function is used to send msg to LAP 
*
* PARAMETERS
*  None
*  
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
void IRDA_sendilm(void)
{
   ilm_struct *IRDA_ilm;
  
   DRV_BuildPrimitive(IRDA_ilm,
                      //MOD_DRV_HISR,//MOD_IRDA_HISR,
                      MOD_IRDA_HISR,
                      MOD_LAP,
                      MSG_ID_IRDA_READY_TO_WRITE_IND,
                      NULL);
   msg_send_ext_queue(IRDA_ilm);
}      
/*************************************************************************
* FUNCTION
*	IR_FrameProcess
*
* DESCRIPTION
*	This function is used to process the receiving frame  
*
* PARAMETERS
*  kal_uint8 frame_index
*  
* RETURNS
*  None 
* GLOBALS AFFECTED
*
*************************************************************************/
kal_uint32 irda_drop_frame=0;
void IR_FrameProcess(kal_uint8 frame_index)
{
   kal_uint8  *tmpptr;
   kal_uint16 index;
   
   if(rx_lap_frame==0)
   {
      if((rx_lap_frame=IR_Getbuf() )==0)
      {
         ASSERT(0);
      }
      rx_lap_frame->type=RX_TYPE;
   }
   
   rx_lap_frame->size=IrPort.rxdata_count[frame_index];
   
   tmpptr=(kal_uint8  *)rx_lap_frame+FBUF_HEAD;
   for(index=0;index<rx_lap_frame->size;index++)
   {
      tmpptr[index] = IrPort.rxdata_buffer[frame_index][index];
   }
   if ((tmpptr[1]&0x01)==0)
   {
      /* I frames will go on a rx Q */
      rx_lap_frame->type=RX_DATA_TYPE; 
   }				 	
   if ( ((tmpptr[1]&0x0f)==0x0f)&&(tmpptr[0]&0x01)==1)
   {         /*XID C filed*/          /*C/R=1*/
	  /* test for u frame xid command */
	   Do_XID_response (rx_lap_frame); 
	   rx_lap_frame=0;	
	  }      		 	
   else if (!(QUEUE_FULL(decode_q,MAX_DECODE_FRAMES)))
   {
   	kal_uint32 frame_avail=0;
   		
   	QUEUE_AVAIL(decode_q,frame_avail,MAX_DECODE_FRAMES);
   	
   	if(frame_avail<=IRDA_DECODE_THRESHOLD)
   	{
         rx_lap_frame->type=DCQ_TYPE;
         QUEUE_ADD(decode_q,rx_lap_frame,MAX_DECODE_FRAMES);
			rx_lap_frame=0;
			IRDA_sendilm();/*inform IrDA Task*/
			irda_drop_frame=0;
		}
		else/*drop frame because IRDA can't consume frames in time*/
		{
			irda_drop_frame++;
			IR_Freebuf(rx_lap_frame);
			rx_lap_frame=0;			
		}			
   }
   else