lmp.c

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

	{	/* message received from TTP is error */
		irda_ttp_flag = MSG_ID_LMP_CONNECT_CONFIRM;
		irda_error_code=IRDA_WRONG_CC_STATE_ERROR;

		if (irda_data_buffer)
			Freebuf(irda_data_buffer);
	}
	irda_lmp_flag = NULL_IRDA_LMP_MSG;
}	/* irda_ttp_to_lmp_msg() */

void lmp_send_msg_to_MMI(kal_uint16 msg)
{
   
   ilm_struct *irda_ilm;      
   DRV_BuildPrimitive(irda_ilm,
                      MOD_LMP,
                      MOD_MMI,
                      msg,
                      NULL);
   msg_send_ext_queue(irda_ilm);
   
}   

/*************************************************************************
* FUNCTION
*	irda_lmp_process_external_msg
*
* DESCRIPTION
*	Process extern msg to LMP
*
* PARAMETERS
*  ilm_struct rx_msg
* RETURNS
*  
*
* GLOBALS AFFECTED
*
*************************************************************************/
extern void obex_flc_release_callback(void);
void irda_lmp_process_external_msg(ilm_struct rx_msg)
{	/* from 3-wire raw, LPT SAP */
	kal_uint16 return_value;
	FBUF *tmpbuf=0;
	kal_uint8 *tmpptr;
	stack_timer_struct	*stack_timer_ptr;
	irda_local_para_struct *tmp_local_para=NULL;
   kal_uint8* pdu_ptr;
	kal_uint16 pdu_length;
	kal_uint8 data_tx;
	
	#ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG66); 
   #endif
	
	
   if(rx_msg.msg_id!=MSG_ID_IRDA_OPEN&&  
   rx_msg.msg_id!=MSG_ID_IRDA_CLOSE&& 
	rx_msg.msg_id!=MSG_ID_TIMER_EXPIRY)
	{
   if(rx_msg.local_para_ptr!=NULL)
   { 
   	tmp_local_para = (irda_local_para_struct *) rx_msg.local_para_ptr;	
   	local_lsap_sel = tmp_local_para->local_lsap_sel;
   	remote_lsap_sel=tmp_local_para->remote_lsap_sel;
   	lm_con[local_lsap_sel].sel=remote_lsap_sel;
   	lm_con[local_lsap_sel].discon_code=tmp_local_para->disconnect_reason;
	}
	}

	switch (rx_msg.msg_id)
	{
		case MSG_ID_LMP_DATA_REQUEST:
			if (lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_ACTIVE)
			{	
		      pdu_ptr=(kal_uint8 *) get_pdu_ptr(rx_msg.peer_buff_ptr, &pdu_length);
			   /*copy data and add size field*/
			   tmpbuf=Getbuf();
			   tmpbuf->size=pdu_length+2;/*2 for LMP header*/
			   tmpbuf->type=CONTROL_BUF_TYPE;/*special patten*/
			   /*copy data */
			   tmpptr=(kal_uint8 *)tmpbuf+FBUF_HEAD+4;/*2 for AC 2 for LMP */			   
			   xmemcpy((kal_uint8*)(tmpptr),(kal_uint8*)(pdu_ptr),(pdu_length));    
			   /*  add LM connect header */    
	    		tmpptr=(kal_uint8 *)tmpbuf+I_TX_PACKET_OFFSET;/*FBUF_HEAD+2*/			
				tmpptr[0]=lm_con[local_lsap_sel].sel; 	/*destination=remote*/
				tmpptr[1]=local_lsap_sel; 				/* source=local */
				
				data_tx=IrLAP_DATA_request(tmpbuf);				
				if(data_tx!=0)
				{
				   gprs_flc_free_peer_buff ( 
                               IRDA_DATA,
                               0,
                               GPRS_FLC_UL,
                               0,
                               rx_msg.peer_buff_ptr);
				}



				else
				{
				    ctrl_buff_cnt++;
				    QUEUE_ADD(ctrl_buff_q,rx_msg.peer_buff_ptr,MAX_TTP_FRAMES);
			       hold_peer_buff(rx_msg.peer_buff_ptr);
				}  
				   
			}
			else
			{
				lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,NULL,
											IRDA_WRONG_CC_STATE_ERROR);
			
            gprs_flc_free_peer_buff ( 
                               IRDA_DATA,
                               0,
                               GPRS_FLC_UL,
                               0,
                               rx_msg.peer_buff_ptr);

 	      }
		   break;
		case MSG_ID_LMP_CONNECT_REQUEST:

			return_value=lm_connect_request();
			if (return_value)/* lm_connect_request fail */
			{	
				if (return_value == IRDA_WRONG_SC_STATE)
					lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,0,IRDA_WRONG_SC_STATE_ERROR);
				else if (return_value == IRDA_WRONG_CC_STATE)
					lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,0,IRDA_WRONG_CC_STATE_ERROR);
				else if (return_value==IRDA_LSAP_CONNECT_IN_PROGRESS)
					lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,0,IRDA_LSAP_CONNECT_IN_PROGRESS_ERROR);
			}
		   break;
		case MSG_ID_LMP_CONNECT_RESPONSE:
			if (lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_INCOMING)
			{
				if (!tmpbuf)
				{
					tmpbuf=Getbuf();
					ASSERT(tmpbuf);
					tmpbuf->size=4;/*LMP header size*/
				}
				else
				{
					tmpbuf->size+=4;
				}	
				tmpptr=(kal_uint8 *)tmpbuf+I_TX_PACKET_OFFSET;
				/*  add LM connect header */
				tmpptr[0]=remote_lsap_sel|0x80;/*MSB is control bit*/
				tmpptr[1]=local_lsap_sel;
				tmpptr[2]=CONNECT_RESPONSE_CONFIRM_LM_PDU;
				tmpptr[3]=0;   		/* add reserved byte */
				data_tx=IrLAP_DATA_request(tmpbuf);
				if(data_tx==0)
				   lm_con[local_lsap_sel].cc_state=IRDA_LMP_CC_ACTIVE;
				/* enter data process for data exchange between two SAP */
			}
			else
			{
				lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,NULL,IRDA_WRONG_CC_STATE_ERROR);

			}
		   break;
		case MSG_ID_LMP_DISCONNECT_REQUEST:
			if ((lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_ACTIVE)||
				(lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_INCOMING)||
				 (lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_SETUP))
			{
				if (!tmpbuf)
				{
					tmpbuf=Getbuf();
					ASSERT(tmpbuf);
					tmpbuf->size=4;/*LMP header size*/
				}
				else
				{
					tmpbuf->size+=4;
				}	
	    		tmpptr=(kal_uint8 *)tmpbuf+I_TX_PACKET_OFFSET;
	 			/*  add LM connect header */
				tmpptr[0]=lm_con[local_lsap_sel].sel | 0x80; /*MSB is control bit*//*destination=remote*/
				tmpptr[1]=local_lsap_sel; /* source=local */
				tmpptr[2]=LM_DISCONNECT_OPCODE;
				tmpptr[3]=lm_con[local_lsap_sel].discon_code;	
				IrLMP_Disconnect_Reset(local_lsap_sel);				
				data_tx=IrLAP_DATA_request(tmpbuf);
			}
			else
			{
				lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,NULL,IRDA_WRONG_CC_STATE_ERROR);	
			}	
		   break;
		case MSG_ID_LMP_LINK_DISCONNECT_REQUEST:	/* comes from MMI to disconnect LAP */
			lm_link_disconnect_indication();		/* disconnect all LSAP connection */
			lm_link_disconnect_request();			/* send an LAP disconnect request */
		   break;		   
		case MSG_ID_IRDA_OPEN:
		   L1SM_SleepDisable(irda_PDNhandle);/*Disable sleep mode*/
		   IRDA_Open();
		   tmp_local_para = (irda_local_para_struct *) rx_msg.local_para_ptr;	
		   if(tmp_local_para->open_time!=0xffff)
		   {		     		  
		      irda_open_time= tmp_local_para->open_time;	  		     
		      stack_start_timer(&irda_context.irda_open_timer, IRDA_OPEN_TIMER_INDEX, 
		      (tmp_local_para->open_time*KAL_TICKS_1_MIN));
		   }   
		   else
		   {
		      stack_stop_timer(&irda_context.irda_open_timer); 
		   }   		      		   
		   irda_tun_on=KAL_TRUE;      		   
		   break;
		case MSG_ID_IRDA_CLOSE:
		   irda_tun_on=KAL_FALSE;      		   
		   IRDA_Close(CONTENTION_BAUD);                       /* turn off irda hw */
		   //IR_Init(CONTENTION_BAUD);								   
			lm_link_disconnect_request();			/* send an LAP disconnect request */						
         IrLAP_LINK_init();/*initialize LAP state*/
         init_irda_lmp();/*initialize LMP state*/
         init_irda_ttp();/*initialize TTP state*/
         IAS_Disconnect_Indication();/*initialize IAS state*/         
         InitBuf();         
         L1SM_SleepEnable(irda_PDNhandle);   /*Enable sleep mode*/         
		   break;		       		      
		case MSG_ID_TIMER_EXPIRY:	/* LSAP connection timeout */	
			stack_timer_ptr=(stack_timer_struct *) rx_msg.local_para_ptr;			         
         if(stack_is_time_out_valid(stack_timer_ptr) == KAL_TRUE)
         {
			   switch (stack_timer_ptr->timer_indx)
			   {
			   	case IRDA_OPEN_TIMER_INDEX:
			   	   irda_tun_on=KAL_FALSE;      		   
			   	   IRDA_Close(CONTENTION_BAUD);                       /* turn off irda hw */
		            //IR_Init(CONTENTION_BAUD);								   
			         lm_link_disconnect_request();			/* send an LAP disconnect request */						
                  IrLAP_LINK_init();/*initialize LAP state*/
                  init_irda_lmp();/*initialize LMP state*/
                  init_irda_ttp();/*initialize TTP state*/
                  IAS_Disconnect_Indication();/*initialize IAS state*/         
                  InitBuf();                           
			   	   lmp_send_msg_to_MMI(MSG_ID_IRDA_CLOSE_IND);
			   	   L1SM_SleepEnable(irda_PDNhandle);   /*Enable sleep mode*/         
			   	   break;   
			   	default:
			   	   break;   
			   }
			}   			
		   break;		   
		case MSG_ID_IAS_GET_REMOTE_LSAP_SEL:
			if (lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_ACTIVE)
			{			

				tmpbuf=Format_GetValueByClass_Packet(tmp_local_para->class_name_index, 
													 tmp_local_para->attribute_name_index);
	    		tmpptr=(kal_uint8 *)tmpbuf+I_TX_PACKET_OFFSET;
	 			/*  add LM connect header */
				tmpptr[0]=lm_con[local_lsap_sel].sel; 	/*destination=remote*/
				tmpptr[1]=local_lsap_sel; 				/* source=local */
				tmpbuf->size+=2; 						/* add header size */				
				IrLAP_DATA_request (tmpbuf);						
			}
			else
			{
				lmp_send_msg_to_upper_layer(MSG_ID_LMP_CONNECT_CONFIRM,NULL,IRDA_WRONG_CC_STATE_ERROR);
			}		
		   break;   
		 case MSG_ID_IRAP_LMP_DL_IRPDU_RESUME:/*80*/
		    if (lm_con[local_lsap_sel].cc_state==IRDA_LMP_CC_ACTIVE)
		    {	
		        process_rx_ctrl_q(local_lsap_sel);
		        process_ttp_tx_queue(local_lsap_sel);
		    }		    
  		    break;  
		default:
		   break;
	}
}	/* irda_lmp_process_external_msg() */


/*************************************************************************
* FUNCTION
*	lm_link_disconnect_request
*
* DESCRIPTION
*	Initiates a LAP disconnect request 
*
* PARAMETERS
*  
* RETURNS
*	
* GLOBALS AFFECTED
*
*************************************************************************/
void lm_link_disconnect_request(void)
{
	kal_uint8 i;
   #ifdef IRDA_KAL_TRACE  
     kal_trace(TRACE_FUNC, IRDA_MSG67); 
   #endif
	
   	 IrLAP_DISCONNECT_request();
    	
	    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;
	    }
	    sc_state=IRDA_LMP_SC_DISC;
	    irda_lmp_flow=IRDA_LMP_IDLE_FLOW;
	
}	/* lm_link_disconnect_request() */

/*************************************************************************
* FUNCTION
*	lm_link_disconnect_indication
*
* DESCRIPTION
*	Inform all upper layer that LAP connection is disconnected
*
* PARAMETERS
*  
* RETURNS
*  None
*
* GLOBALS AFFECTED
*  Transmit disconnect indication to all upper layer above LMP
*************************************************************************/
void lm_link_disconnect_indication(void)
{
	kal_uint8 i;
	
	#ifdef IRDA_KAL_TRACE  
      kal_trace(TRACE_FUNC, IRDA_MSG68); 
   #endif
	
	for (i=0;i<MAX_SEL;i++)
	{
		if ((lm_con[i].cc_state==IRDA_LMP_CC_INCOMING) ||
			(lm_con[i].cc_state==IRDA_LMP_CC_SETUP) ||
			(lm_con[i].cc_state==IRDA_LMP_CC_ACTIVE))
		{
			if (i==IAS_SERVER_LSAP_SEL)
				IAS_Disconnect_Indication();
			#if 0	
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
			#endif
			else if (i>=OBEX_LSAP_SEL)/*inform TTP layer*/
			{
				irda_ttp_flag =           MSG_ID_LMP_LINK_DISCONNECT_INDICATION;
				i=MAX_SEL;                    
			}
		}
	}
}	/* lm_link_disconnect_indication() */

/*************************************************************************
* FUNCTION
*	lm_connect_request
*
* DESCRIPTION
*	Initiates a LM connect request
*
* PARAMETERS
*  
* RETURNS
*	0 for success
   1 for wrong sc_state while cc_state in NOT_READY
	2 for wrong cc_state
*
* GLOBALS AFFECTED
*
*************************************************************************/

kal_uint16 lm_connect_request(void)
{
	kal_uint8 *tmpptr;
	
	
	//tmpptr=(kal_uint8 *) irda_data_buffer;
   #ifdef IRDA_KAL_TRACE  
      kal_trace(TRACE_FUNC, IRDA_MSG69); 
   #endif
   kal_prompt_trace(MOD_LMP,"sc_state, cc_state",sc_state, lm_con[local_lsap_sel].cc_state);
	switch(sc_state)
	{
	   case IRDA_LMP_SC_DISC:
	      lm_con[local_lsap_sel].sel=remote_lsap_sel;
			irda_lmp_flow=IRDA_LMP_LSAP_CONNECT_FLOW;
			current_lsap_sel=local_lsap_sel;
			//current_data_buffer=irda_data_buffer;
			conflict_flag = KAL_FALSE;
			genaddrbit = 0;
			lmp_discovery_log  = 0;
			discovery_retry_counter=DISCOVER_RETRY_COUNT;
			IrLAP_DISCOVERY_request();
			sc_state=IRDA_LMP_SC_DISCOVER;
			lm_con[local_lsap_sel].cc_state=IRDA_LMP_CC_NOT_READY;						
			return(IRDA_SUCCESS);	 
	   
	      break;
	   case IRDA_LMP_SC_ACTIVE:
	      switch (lm_con[local_lsap_sel].cc_state ) 
	      {     
	      	case IRDA_LMP_CC_READY:
	      		if (irda_lmp_flow==IRDA_LMP_IDLE_FLOW)
	      		{	/* to make sure that only on LSAP connect operation in progress */
	      			if (!irda_data_buffer)
	      			{
	      				irda_data_buffer=Getbuf();
	      				ASSERT(irda_data_buffer);
	      				irda_data_buffer->size=4;
	      			}
	      			else
	      			{
	      				irda_data_buffer->size+=4;
                  }
	         		tmpptr=(kal_uint8 *) (irda_data_buffer)+I_TX_PACKET_OFFSET;
	      			lm_con[local_lsap_sel].cc_state=IRDA_LMP_CC_SETUP;