uart.c

uart全功能实现.实现如下函数: U_Open, U_Close, U_GetBytes, U_PutBytes, U_GetBytesAvail, U_GetTxRoomL

kal_uint8 uart_initialize[MAX_UART_PORT_NUM];
#endif /*DRV_DEBUG*/


kal_uint8 send_Txilm[MAX_UART_PORT_NUM] = {
   KAL_FALSE,
   KAL_FALSE,
#ifdef __UART3_SUPPORT__
   KAL_FALSE
#endif   /*__UART3_SUPPORT__*/
};

kal_uint8 send_Rxilm[MAX_UART_PORT_NUM] = {
   KAL_TRUE,
   KAL_TRUE,
#ifdef __UART3_SUPPORT__
   KAL_TRUE
#endif   /*__UART3_SUPPORT__*/

};

const VOID_FUNC UART_HISR[MAX_UART_PORT_NUM] =
{
   UART1_HISR,
   UART2_HISR,
#ifdef __UART3_SUPPORT__
   UART3_HISR
#endif   /*__UART3_SUPPORT__*/
};

const kal_uint32 UART_BaseAddr[MAX_UART_PORT_NUM] =
{
   UART1_base,
   UART2_base,
#ifdef __UART3_SUPPORT__
   UART3_base
#endif   /*__UART3_SUPPORT__*/
};
#ifdef __DMA_UART_VIRTUAL_FIFO__
kal_bool UART_VFIFO_support[MAX_UART_PORT_NUM] =
{ 
   KAL_TRUE, 
   KAL_TRUE,//KAL_TRUE, 
#ifdef __UART3_SUPPORT__
   KAL_TRUE,//KAL_FALSE
#endif   /*__UART3_SUPPORT__*/
};
#else
kal_bool UART_VFIFO_support[MAX_UART_PORT_NUM] =
{
   KAL_FALSE,
   KAL_FALSE,
#ifdef __UART3_SUPPORT__
   KAL_FALSE
#endif   /*__UART3_SUPPORT__*/
};
#endif/*__DMA_UART_VIRTUAL_FIFO__*/

kal_uint8 uart_escape_state=0;
#ifdef __MTK_TARGET__
extern int INT_QueryExceptionStatus(void);
#endif
void UART_Calback(void *parameter);
void U_ConfigEscape (UART_PORT port, kal_uint8 EscChar, kal_uint16 ESCGuardtime);
/*UART Customization */
extern const UART_customize_function_struct *UART_GetFunc(void);
const UART_customize_function_struct *UartCustomFunc;
const UART_rings_struct *UART_rings;

void uart_customize_init(void)
{
	/* retreive the function table */
   UartCustomFunc=UART_GetFunc();
	/* use the entry in function table to retreive desired information */
   UART_rings = UartCustomFunc->UART_Get_Data();
   #ifdef __DMA_UART_VIRTUAL_FIFO__   
   U_configure_DMA_VFIFO();
   #endif

}  
/*check if chip can support auto escape*/

kal_bool uart_support_autoescape(void)
{      
	#if (defined(MT6205B)||defined(MT6208)|| defined(FPGA)) 
      return KAL_FALSE;	
	#elif (defined(MT6218B)) 	
	   if(INT_ecoVersion()>EN)
	      return KAL_TRUE;	
	   else      
	      return KAL_FALSE;	
	#elif (defined(MT6219)) 	
	   if(INT_ecoVersion()>BV)
	      return KAL_TRUE;	
	   else      
	      return KAL_FALSE;		   
	#else  /*not support auto escape*/	
	   return KAL_TRUE;	
	#endif
}

#if ( (defined(MT6218))||defined(MT6226M) || (defined(MT6218B)) || (defined(MT6219))||(defined(MT6217))||(defined(MT6228))|| defined(MT6229)|| (defined(MT6226))|| (defined(MT6227)) )
kal_uint8 uart_update_race_check;
void UART2_update_index_save(kal_uint32 type, kal_uint32 index)
{
   ASSERT(uart_update_race_check == 0);
   uart_update_race_check = 1;
   uart2_index_save.type = type;
   uart2_index_save.index = index;
   uart_update_race_check = 0;
}
#endif

void UART_sendilm(UART_PORT port, msg_type msgid)
{
   ilm_struct *UART_ilm;
   void *port_ptr=0;      
   
   /*TY adds the following decription 20041013
     The first if check is to avoid the case that owenr is UARTX_HISR*/   
   if (UARTPort[port].ownerid != UARTPort[port].UART_id)
   {
	   switch(msgid)
	   {
	   	case MSG_ID_UART_READY_TO_READ_IND:
	   	{	   		 	
	   		uart_ready_to_read_ind_struct *tmp;      
	   		tmp = (uart_ready_to_read_ind_struct *) 
	   		construct_local_para(sizeof(uart_ready_to_read_ind_struct),TD_UL);
	   		tmp->port = port;   		
	   		port_ptr = tmp;   	
	   	}	
	   	break;	
	   	case MSG_ID_UART_READY_TO_WRITE_IND:      		
	   	{
	   		uart_ready_to_write_ind_struct *tmp;      
	   		tmp = (uart_ready_to_write_ind_struct *) 
	   		construct_local_para(sizeof(uart_ready_to_write_ind_struct),TD_UL);
	   		tmp->port = port;   		
	   		port_ptr = tmp;
	   	}	   	
	   	break;
	   	case MSG_ID_UART_DSR_CHANGE_IND:   	   		
	   	{
	   		uart_dsr_change_ind_struct *tmp;      
	   		tmp = (uart_dsr_change_ind_struct *) 
	   		construct_local_para(sizeof(uart_dsr_change_ind_struct),TD_UL);
	   		tmp->port = port;   		
	   		port_ptr = tmp;   		
	   	}	
	   	break;
	   	case MSG_ID_UART_ESCAPE_DETECTED_IND:   	
	   	{
	   		uart_escape_detected_ind_struct *tmp;      
	   		tmp = (uart_escape_detected_ind_struct *) 
	   		construct_local_para(sizeof(uart_escape_detected_ind_struct),TD_UL);
	   		tmp->port = port;   		
	   		port_ptr = tmp;   		
	   	}	
	   	break;
	   	default:
	   	break;   	
	   }         
      DRV_BuildPrimitive(UART_ilm,
                         MOD_DRV_HISR,//UARTPort[port].UART_id,
                         UARTPort[port].ownerid,
                         msgid,
                         port_ptr);

      msg_send_ext_queue(UART_ilm);
   }
}

void U_ClrRxBuffer(UART_PORT port)  /*clear sw buffer*/
{
   kal_uint32 savedMask;
#ifdef MT6208
   kal_uint16 UART_IER_HW_NORMALINTS[MAX_UART_PORT_NUM] = {
      UART1_IER_HW_NORMALINTS,
      UART2_IER_HW_NORMALINTS
   };
   kal_uint16 UART_IER_SW_NORMALINTS[MAX_UART_PORT_NUM] = {
      UART1_IER_SW_NORMALINTS,
      UART2_IER_SW_NORMALINTS
   };
#endif   /*MT6208*/

   savedMask = SaveAndSetIRQMask();
   BWrite_addr(UARTPort[port].Rx_Buffer) = 0;
   BRead_addr(UARTPort[port].Rx_Buffer) = 0;

#ifdef MT6208
   if (UARTPort[port].DCB.flowControl == fc_none)
      DRV_WriteReg(UART_IER(UART_BaseAddr[port]),UART_IER_HW_NORMALINTS[port]);
   else
   {
      if (UARTPort[port].DCB.flowControl == fc_hw)
         DRV_WriteReg(UART_IER(UART_BaseAddr[port]),UART_IER_HW_NORMALINTS[port]);
      else
      {
         if (UARTPort[port].DCB.flowControl == fc_sw)
            DRV_WriteReg(UART_IER(UART_BaseAddr[port]),UART_IER_SW_NORMALINTS[port]);
      }
   }
#else /*!MT6208*/
   if (UARTPort[port].DCB.flowControl == fc_none)
      DRV_WriteReg(UART_IER(UART_BaseAddr[port]),IER_HW_NORMALINTS);
   else
   {
      if (UARTPort[port].DCB.flowControl == fc_hw)
         DRV_WriteReg(UART_IER(UART_BaseAddr[port]),IER_HW_NORMALINTS);
      else
      {
         if (UARTPort[port].DCB.flowControl == fc_sw)
            DRV_WriteReg(UART_IER(UART_BaseAddr[port]),IER_SW_NORMALINTS);
      }
   }
#endif   /*MT6208*/
   send_Rxilm[port] = KAL_TRUE;
   RestoreIRQMask(savedMask);
}

void U_ClrTxBuffer(UART_PORT port)  /*clear sw buffer*/
{
   kal_uint32 savedMask;
#ifdef MT6208
   kal_uint16 UART_IER_HW_NORMALINTS[MAX_UART_PORT_NUM] = {
      UART1_IER_HW_NORMALINTS,
      UART2_IER_HW_NORMALINTS
   };
   kal_uint16 UART_IER_SW_NORMALINTS[MAX_UART_PORT_NUM] = {
      UART1_IER_SW_NORMALINTS,
      UART2_IER_SW_NORMALINTS
   };
#endif   /*MT6208*/

   savedMask = SaveAndSetIRQMask();

   BWrite_addr(UARTPort[port].Tx_Buffer) = 0;
   BRead_addr(UARTPort[port].Tx_Buffer) = 0;

#ifdef MT6208
   if (UARTPort[port].DCB.flowControl == fc_none)
      DRV_WriteReg(UART_IER(UART_BaseAddr[port]),UART_IER_HW_NORMALINTS[port]);
   else
   {
      if (UARTPort[port].DCB.flowControl == fc_hw)
         DRV_WriteReg(UART_IER(UART_BaseAddr[port]),UART_IER_HW_NORMALINTS[port]);
      else
      {
         if (UARTPort[port].DCB.flowControl == fc_sw)
            DRV_WriteReg(UART_IER(UART_BaseAddr[port]),UART_IER_SW_NORMALINTS[port]);
      }
   }
#else /*!MT6208*/
   if (UARTPort[port].DCB.flowControl == fc_none)
      DRV_WriteReg(UART_IER(UART_BaseAddr[port]),IER_HW_NORMALINTS);
   else
   {
      if (UARTPort[port].DCB.flowControl == fc_hw)
         DRV_WriteReg(UART_IER(UART_BaseAddr[port]),IER_HW_NORMALINTS);
      else
      {
         if (UARTPort[port].DCB.flowControl == fc_sw)
            DRV_WriteReg(UART_IER(UART_BaseAddr[port]),IER_SW_NORMALINTS);
      }
   }
#endif   /*MT6208*/
   send_Txilm[port] = KAL_TRUE;
   RestoreIRQMask(savedMask);
}
void UART_EnableTX(UART_PORT port, kal_bool enable)
{
   UARTPort[port].EnableTX= enable;
   if(enable == KAL_TRUE)
        EnableTxIntr(UART_BaseAddr[port]);
}

void UART_SleepOnTx_Enable(UART_PORT port, UART_SLEEP_ON_TX enable_flag)
{
   #if ( (defined(MT6205B)) || (defined(MT6208)) )
   UARTPort[port].sleep_on_tx = enable_flag;
   #else
   UARTPort[port].sleep_on_tx = uart_sleep_on_tx_allow;
   #endif
}

kal_uint16 U_GetBytesAvail(UART_PORT port)
{	
   kal_uint16 real_count;   
   Buf_GetBytesAvail(&(UARTPort[port].Rx_Buffer),real_count);
   return real_count;
}

kal_uint16 U_GetTxRoomLeft(UART_PORT port)
{
   kal_uint16 real_count;   
   Buf_GetRoomLeft(&(UARTPort[port].Tx_Buffer),real_count);   
   return real_count;
}

#ifndef __PRODUCTION_RELEASE__
#ifdef __MTK_TARGET__
#pragma arm section code = "INTERNCODE"
#endif /* __MTK_TARGET__ */
#endif   /*__PRODUCTION_RELEASE__*/
#ifndef __ROMSA_SUPPORT__ /* Note: for ROM code */
kal_uint16 U_GetTxISRRoomLeft(UART_PORT port)
{
   kal_uint16 real_count;
   
   Buf_GetRoomLeft(&(UARTPort[port].Tx_Buffer_ISR),real_count);

   /*temp solution: to cover L1 trace bug*/
   if(real_count<=16)
   	real_count=0;
   else
     real_count-=16;
     
   return real_count;
}
#endif /* Note: for ROM code */
#ifndef __PRODUCTION_RELEASE__
#ifdef __MTK_TARGET__
#pragma arm section code
#endif /* __MTK_TARGET__ */
#endif   /*__PRODUCTION_RELEASE__*/
/* Note: for ROM code start */
#ifdef __ROMSA_SUPPORT__
/*for MCUROM*/
kal_uint16 U_ROM_GetTxISRRoomLeft(UART_PORT port)
{
   kal_uint16 real_count;
   //#ifdef __DMA_UART_VIRTUAL_FIFO__
   if(UART_VFIFO_support[port])
   	real_count=DMA_GetVFIFO_Roomleft(UARTPort[port].Tx_DMA_Ch);
   //#else
   else
      Buf_GetRoomLeft(&(UARTPort[port].Tx_Buffer_ISR),real_count);
   //#endif
   return real_count;
}
UARTStruct *U_ROM_GetUARTPort(UART_PORT port)
{
   return &UARTPort[port];
}

kal_uint8 *U_ROM_GetUART_TXilm(UART_PORT port)
{
   return &send_Txilm[port];
}

void U_ROM_InformUARTOwner(UART_PORT port)
{
   send_Txilm[port] = KAL_TRUE;

   //#ifdef __DMA_UART_VIRTUAL_FIFO__
   if(UART_VFIFO_support[port])
   DMA_EnableINT(UARTPort[port].Tx_DMA_Ch);
   //#endif
}


void U_ROM_PushDataToBuf(UART_PORT port, kal_uint8 *data, kal_uint32 real_count)
{
   kal_uint32  index;

   for (index = 0; index < real_count; index++)
   {
      //#ifdef __DMA_UART_VIRTUAL_FIFO__
      if(UART_VFIFO_support[port])
      {
      	DMA_TASK_PUSH(UARTPort[port].Tx_DMA_Ch,*(data+index));
      }	
      //#else      
      else   
      {   
      	Buf_Push(&(UARTPort[port].Tx_Buffer_ISR),*(data+index));
      }	
      //#endif
   }
   if(UART_VFIFO_support[port]==KAL_FALSE)/*not support VFIFO*/
   	U_ROM_EnableTxIntr(port);
}
void U_ROM_EnableTxIntr(UART_PORT port)
{
   switch(port)
   {
      case uart_port1:
         EnableTxIntr(UART_BaseAddr[port]);
         break;
      case uart_port2:
         if (UART2_Intr_is_Running == KAL_FALSE)
         {
            EnableTxIntr(UART_BaseAddr[port]);
         }
         break;
      case uart_port3:
         EnableTxIntr(UART_BaseAddr[port]);
         break;
      default:
         ASSERT(0);
         break;
   }
}
#endif

#if ( (defined(MT6205)) || (defined(MT6205B)) )
kal_bool UART2DMA_Ini(kal_bool Tx)      //(KAL_TRUE ==> transmit, KAL_FALSE ==> receive)
{
        if (Tx == KAL_TRUE)
        {
           if (DMA1_CheckRunStat())
                        return KAL_FALSE;

                if (DMA1_CheckITStat())
                        return KAL_FALSE;

                //Size = 8bit, sinc en, dinc disable, hw management, 1 trans/dma cycle, USB master,Interrupt enable
                DRV_WriteReg(DMA1_CONTRL,DMA_CON_UART2TxNormal);
        }
        else
        {
           if (DMA2_CheckRunStat())
                        return KAL_FALSE;

                if (DMA2_CheckITStat())
                        return KAL_FALSE;
                //Size = 8bit, sinc disable, dinc enable, hw management, 1 trans/dma cycle, USB master,Interrupt enable
                DRV_WriteReg(DMA2_CONTRL,DMA_CON_UART2RxNormal);
        }
        return KAL_TRUE;
}
#endif   /*MT6205,MT6205B*/
/*
* FUNCTION
*  GetUARTByte
*
* DESCRIPTION
*     This function is to read data from UART
*
* CALLS
*  This function is to receive data through UART
*
* PARAMETERS
*  None
*
* RETURNS
*  the data from UART
*