lmp.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).
*
*****************************************************************************/

/*****************************************************************************
 *
 * Filename:
 * ---------    
 *    LMP.c
 *
 * Project:
 * --------
 *   Maui_Software
 *
 * Description:
 * ------------
 *   This file contains the Link Management Protocol of IrDA 
 *
 * Author:
 * -------
 * -------
 *
 *****************************************************************************/
#include "kal_release.h"      /* Basic data type */
//#include "kal_nucleus_common_defs.h"/*tick transition*/
#include "stack_common.h"
#include "stack_msgs.h"
#include "app_ltlcom.h"       /* Task message communiction */
#include "stack_timer.h"      /* Stack timer */
#include "irda_enums.h"       /* irda enum */  
#include "gprs_flc_kal.h"  
#include "gprs_flc_common_data_types.h"
#include "flc_tunable_para.h"
#include "irconfig.h"	      /* IrPro system configuration */
#include "lap.h"	            /* LAP source header file */
#include "lmp.h"	            /* LMP source header file */
#include "ttp.h"
#include "iap_p.h"	         /* IAP primary stack header file */
#include "iap_s.h"	         /* IAP secondary stack header file */
#include "iastab.h"	         /* IAS table configuraton header file */
#include "support.h"	         /* system support functions */
#include "externs.h"	         /* system external definitions */
#include "irda.h"
#include "irframer_sw.h"
#include "drv_comm.h"
#include "stack_config.h"
#include "kal_trace.h"                     
#include "irda_trace.h"


extern void   L1SM_SleepEnable( kal_uint8 handle );
extern void   L1SM_SleepDisable( kal_uint8 handle );
CDAT lm_con[MAX_SEL];  
kal_uint8 sc_state;       	/* station control state machine */
kal_uint8 conflict_flag; 	/* used during discovery resolution */
kal_uint8 genaddrbit;		/* for address conflicts, if set, the XID_CMD frame 
							         will ask remote devices to generate device address again */
kal_uint8 discovery_retry_counter;		/* number of retry to send discovery request */
LOG *lmp_discovery_log;        				/* pointer to the discovery log */
FBUF *irda_data_buffer, *current_data_buffer;
kal_uint8 local_lsap_sel, remote_lsap_sel;     
kal_uint8 current_lsap_sel;
kal_uint32 remote_device_address;        /*remote device address*/
 
kal_uint8 irda_lmp_flow;
kal_uint8 irda_error_code;
kal_uint16 irda_lmp_flag;
module_type module_id_mapping[MAX_SEL];
kal_uint16 irda_open_time=0xffff;/*record open period*/
extern kal_uint8  irda_PDNhandle;
kal_bool irda_tun_on=KAL_FALSE;

void IrLMP_Disconnect_Reset(kal_uint8 local)
{
   #ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG60); 
   #endif
	lm_con[local].sel = 0xff;  
	lm_con[local].stat = LM_CONNECTION_IDLE;  
	lm_con[local].cc_state = IRDA_LMP_CC_READY; 
	lm_con[local].discon_code = 0; 
   irda_lmp_flow=IRDA_LMP_IDLE_FLOW;
}   

kal_uint8 IrLMP_Connect_Request(kal_uint8 local, kal_uint8 remote, FBUF *frame)
{  
	 kal_uint8 *tmpptr;
	 kal_uint8 data_tx; 
   #ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG61); 
   #endif
	frame->size+=4;
   
	tmpptr=(kal_uint8 *) (frame)+I_TX_PACKET_OFFSET;	
	/*  add LM connect header */
	tmpptr[0]=remote|0x80;
	tmpptr[1]=local;
	tmpptr[2]=CONNECT_REQUEST_INDICATION_LM_PDU;
	tmpptr[3]=0;  /* add reserved byte */
	data_tx=IrLAP_DATA_request(frame);
	if(data_tx==0)
	{
	   lm_con[local].cc_state=IRDA_LMP_CC_SETUP;
	   irda_lmp_flow=IRDA_LMP_LSAP_CONNECT_FLOW;
	   return(0);
	}
	else
	   return(1);
	
}   
kal_uint8 IrLMP_DisConnect_Request(kal_uint8 local, kal_uint8 remote, FBUF *frame)
{
    FBUF *tmpbuf=0;
	 kal_uint8 *tmpptr;
	 kal_uint8 data_tx; 
	
	#ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG62); 
   #endif
		tmpbuf=Getbuf();
	
		tmpbuf->size=4;
	
	tmpptr=(kal_uint8 *) tmpbuf + I_TX_PACKET_OFFSET;
	tmpptr[0] = (0x80|remote);
	tmpptr[1] = local;
	tmpptr[2] = DISCONNECT_LM_PDU;
	tmpptr[3] = DISCONNECT_REASON_USER_REQUEST;
	IrLMP_Disconnect_Reset(local);	
	data_tx=IrLAP_DATA_request(tmpbuf);
	return(0);
	

}
kal_uint8 IrLMP_Data_Request(kal_uint8 local, kal_uint8 remote, FBUF *frame)
{
	 kal_uint8 *tmpptr;
	 kal_uint8 data_tx; 
   #ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG63); 
   #endif	 

	frame->size+=2;					
	tmpptr= (kal_uint8 *) (frame)+I_TX_PACKET_OFFSET;
	tmpptr[0] = remote;
	tmpptr[1] = local;
	data_tx=IrLAP_DATA_request(frame);
	if(data_tx==0)
	   return(0);
	else
	   return(1);   
		
}
kal_uint8 IrLMP_Connect_Response(kal_uint8 local, kal_uint8 remote, FBUF *frame)
{
	kal_uint8 *tmpptr;
	kal_uint8 data_tx; 
	
   #ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG64); 
   #endif	 	
	frame->size+=4;
		
	tmpptr= (kal_uint8 *) (frame)+I_TX_PACKET_OFFSET;
	tmpptr[0] = (remote | 0x80);
	tmpptr[1] = local;
	tmpptr[2] = CONNECT_RESPONSE_CONFIRM_LM_PDU;
	tmpptr[3] = 0;
	data_tx=IrLAP_DATA_request(frame);
	if(data_tx==0)
	{
	   lm_con[local].cc_state=IRDA_LMP_CC_ACTIVE;
	   return(0);	   
   }
   else
      return(1);
}

/*************************************************************************
* FUNCTION
*	init_irda_lmp
*
* DESCRIPTION
*	Initial LMP stack  
*
* PARAMETERS
*  
* RETURNS
*  None
* GLOBALS AFFECTED
*
*************************************************************************/
void init_irda_lmp( void )
{ 
	kal_uint8 i;

	lmp_discovery_log = 0;			/* ptr to log, set during discovery */
	for (i=0;i<MAX_SEL;i++)
	{
		lm_con[i].sel = 0xff;  
		lm_con[i].stat = LM_CONNECTION_IDLE;  
		lm_con[i].cc_state = IRDA_LMP_CC_NOT_READY; 
		lm_con[i].discon_code = 0; 
	}
	lm_con[IAS_SERVER_LSAP_SEL].control=0;
	lm_con[IAS_CLIENT_LSAP_SEL].control=QUEUE_MASK;
	
	
	lm_con[OBEX_LSAP_SEL].control=TTP_MASK;
	lm_con[COMMX_LSAP_SEL].control=TTP_MASK|COMMX_MASK;
	#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
   #endif
	
	sc_state = IRDA_LMP_SC_DISC;
	irda_lmp_flow=IRDA_LMP_IDLE_FLOW;
	if((irda_data_buffer!=0)&&(irda_data_buffer->stat==B_ALLOC))
	   Freebuf(irda_data_buffer);

	 
	 
	irda_data_buffer=0;	/* pointer to NULL */
	current_data_buffer=0;
	remote_device_address=NULL_DEVICE_ADDRESS;
	irda_lmp_flag=NULL_IRDA_LMP_MSG;

	discovery_retry_counter=0;
}	/* init_irda_lmp() */


/*************************************************************************
* FUNCTION
*	irda_ttp_lmp_main
*
* DESCRIPTION
*	Process irda_lmp_flag and irda_ttp_flag 
*
* PARAMETERS
*  None
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/ 
void irda_ttp_lmp_main(void)
{
	while (irda_lmp_flag || irda_ttp_flag)
	{
	   /*irda_lmp_flag*/
		if ((irda_lmp_flag>=MSG_ID_LAP_DISCOVERY_INDICATION) &&
			(irda_lmp_flag<=MSG_ID_LAP_DISCOVERY_MEDIA_BUSY_ERROR))	/*LAP->LMP*/
			irda_lap_to_lmp_msg(); /*LMP process LAP's events*/
		else if ((irda_lmp_flag>=MSG_ID_LMP_DATA_REQUEST) &&
				 (irda_lmp_flag<=MSG_ID_LMP_LINK_DISCONNECT_REQUEST))	/*TTP -> LMP*/
			irda_ttp_to_lmp_msg();/*LMP process TTP's events*/
      /*irda_ttp_flag*/
		if ((irda_ttp_flag>=MSG_ID_LMP_DATA_INDICATION) &&/*LMP->TTP*/
			(irda_ttp_flag<=MSG_ID_LMP_LINK_DISCONNECT_INDICATION))
			irda_lmp_to_ttp_msg();/*TTP process TTP's events*/
	}
}	/* irda_ttp_lmp_main() */
/*************************************************************************
* FUNCTION
*	irda_ttp_to_lmp_msg
*
* DESCRIPTION
*	Process I frame from LAP according SC_State and CC_State 
*
* PARAMETERS
*  None
* RETURNS
*  None
*
* GLOBALS AFFECTED
*
*************************************************************************/ 
void irda_lap_to_lmp_msg(void)
{
	kal_uint8 return_lm_pdu,i;
	FBUF *tmpbuf;
	kal_uint8 *tmpptr;	
	kal_uint16 old_lmp_flag; 
	kal_uint16 return_value;
   kal_uint8 data_tx; 
	
	#ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG65); 
   #endif	 
	old_lmp_flag=irda_lmp_flag;
	if (irda_lmp_flag==MSG_ID_LAP_DATA_INDICATION)
	{	/* LM-PDU */
		return_lm_pdu=lmp_data_indication_parse();
		if ((return_lm_pdu==ACCESS_MODE_REQUEST_INDICATION_LM_PDU) ||
			(return_lm_pdu==ACCESS_MODE_RESPONSE_CONFIRM_LM_PDU))
		{	/* the Access mode change doesn't support now */
			if(0!=irda_data_buffer) 
			{
			   Freebuf(irda_data_buffer);
			   irda_data_buffer=0;
			}   
			else
			   ASSERT(0);   			
		}
		else if ((return_lm_pdu==BAD_LOCAL_LSAP_SEL_LM_PDU)||
				 (return_lm_pdu==BAD_LM_PDU))
		{	/* unknown data, drop it */
			if(0!=irda_data_buffer)
			{ 
			   Freebuf(irda_data_buffer);
			   irda_data_buffer=0;
			}   
			else
			   ASSERT(0);
		}
		else/*Normal case*/
		{	/* Connect, Disconnect and Data LM-PDU */
			switch (lm_con[local_lsap_sel].cc_state)
			{
				case IRDA_LMP_CC_SETUP:
					/* p61, SETUP state */
					if (return_lm_pdu==CONNECT_RESPONSE_CONFIRM_LM_PDU)
					{	
						irda_lmp_flow=IRDA_LMP_IDLE_FLOW;
						lm_con[local_lsap_sel].cc_state=IRDA_LMP_CC_ACTIVE;
						if (lm_con[local_lsap_sel].control & TTP_MASK)
               	{	/* to TTP */
	                  lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,/*?????*/
													irda_data_buffer,IRDA_SUCCESS);
                  }
                  else
                  {
						   lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,
													NULL,IRDA_SUCCESS);
                     if(irda_data_buffer!=0)													
                     {
                        Freebuf(irda_data_buffer);														
                        irda_data_buffer=0;
                      }  
                     else  
                        ASSERT(0);
						}							
																			
					}
					else if ((return_lm_pdu==CONNECT_REQUEST_INDICATION_LM_PDU) ||
							 (return_lm_pdu==DISCONNECT_LM_PDU))
					{	
						irda_lmp_flow=IRDA_LMP_IDLE_FLOW;					
						lmp_send_msg_to_upper_layer(MSG_ID_LMP_LSAP_DISCONNECT_INDICATION,
													NULL,IRDA_SUCCESS);/*TY modified this */
													
						if(irda_data_buffer!=0)													
						{
                     Freebuf(irda_data_buffer);	
                     irda_data_buffer=0;
                  }   
                  else  
                     ASSERT(0);                     
					}
					else if (return_lm_pdu==DATA_LM_PDU)
					{	/* wrong case, drop the frame directly */
						if(irda_data_buffer!=0)	
						{												
                     Freebuf(irda_data_buffer);	
                     irda_data_buffer=0;
                  }   
                  else  
                     ASSERT(0);                     
					}
					else if(irda_data_buffer!=0)/*add a check*/	
					{												
                     Freebuf(irda_data_buffer);	
                     irda_data_buffer=0;
               }
				   break;
				case IRDA_LMP_CC_INCOMING:
					/* in such case, all IrLAP Data indication are error and drop the frame directly */
					/* p60, CONNECT state */
				   if(0!=irda_data_buffer) 
				   {
			         Freebuf(irda_data_buffer);
			         irda_data_buffer=0;
			      }   
			      else
			         ASSERT(0);	
				   break;
				case IRDA_LMP_CC_ACTIVE:
					switch (return_lm_pdu)
					{	/* p60, DTR state */
						case DATA_LM_PDU:	
							if (lm_con[local_lsap_sel].sel==remote_lsap_sel)