rmmi_bt.c

最新MTK手机软件源码

void rmmi_bt_send_cwup(void)
{
	if( rmmi_wakeup_flag == KAL_TRUE )
	{
		rmmi_bt_wakeok_hdlr(NULL);
	}
	else
	{
		kal_trace(TRACE_GROUP_3, RMMI_BT_CWUP );
		RMMI_BT_LOG_STATE();

		rmmi_bt_write_to_uart((kal_uint8*)"AT+CWUP");
		rmmi_bt_start_timer(5);
	}
}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_cwup_timeout_hdlr
*
* DESCRIPTION
*   This function is the timeout handler after no response for last "AT+CWUP"
*   Therefore send the "AT+CWUP" again.
*****************************************************************************/
void rmmi_bt_cwup_timeout_hdlr(void)
{
	kal_trace(TRACE_GROUP_3, RMMI_BT_CWUP_TOUT, L4C_PTR->event_id[0] );
	RMMI_BT_LOG_STATE();

	L4C_PTR->event_id[0] = 0;
   	//rmmi_bt_stop_timer(); 
   	rmmi_bt_send_cwup();
}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_start_timer
*
* DESCRIPTION
*   This function starts a timer for waiting the "WAKEOK"
*****************************************************************************/
void rmmi_bt_start_timer(kal_uint8 time) //time unit is 100ms
{
	L4C_PTR->event_id[0] = evshed_set_event (L4C_PTR->event_scheduler_ptr,
					      	(kal_timer_func_ptr)rmmi_bt_cwup_timeout_hdlr,
				            	NULL, ((KAL_TICKS_100_MSEC)*time));

	kal_trace(TRACE_GROUP_3, RMMI_BT_CWUP_TSTART, L4C_PTR->event_id[0] );
	RMMI_BT_LOG_STATE();

}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_stop_timer
*
* DESCRIPTION
*   This function stops the timer 
*****************************************************************************/
void rmmi_bt_stop_timer(void)
{
   	if (L4C_PTR->event_id[0] != 0)
   	{
		kal_trace(TRACE_GROUP_3, RMMI_BT_CWUP_TSTOP, L4C_PTR->event_id[0] );
		RMMI_BT_LOG_STATE();

       	evshed_cancel_event (L4C_PTR->event_scheduler_ptr, &(L4C_PTR->event_id[0]));
       	L4C_PTR->event_id[0] = 0;
   	}
}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_poll_data_select_timeout_hdlr
*
* DESCRIPTION
*****************************************************************************/

void rmmi_bt_poll_data_select_timeout_hdlr(void)
{
	kal_int8 pre_data_select;
	static kal_int8 data_select;
	kal_uint8 zero_addr[6];
	kal_bool ret_val;


	kal_prompt_trace(MOD_L4C, "data select timer timeout" );
	kal_mem_set(zero_addr, 0, 6);

	data_select_timer = 0;
	pre_data_select = data_select;
	data_select = GPIO_ReadIO(BT_GetDataSelGpio());
	kal_prompt_trace(MOD_L4C, "pre data select = %d, data select = %d ", pre_data_select , data_select);
	if(pre_data_select == 1 && data_select==0 )
	{

	    uart_plugout_ind_struct *param_ptr;
	    ilm_struct *ilmPtr;    
		kal_prompt_trace(MOD_L4C, "data select disconnected" );

    	    param_ptr = (uart_plugout_ind_struct*) construct_local_para(sizeof(uart_plugout_ind_struct), TD_CTRL);
	    param_ptr->port = PS_UART_PORT;
		
	    ilmPtr = allocate_ilm(MOD_L4C);
	    ilmPtr->dest_mod_id = /*MOD_PPP*/UART_GetOwnerID(PS_UART_PORT);
	    ilmPtr->src_mod_id = MOD_L4C;
	    ilmPtr->sap_id = NULL;
	    
	    ilmPtr->msg_id = MSG_ID_UART_PLUGOUT_IND;
	    ilmPtr->local_para_ptr = (local_para_struct *)param_ptr/*NULL*/;
	    ilmPtr->peer_buff_ptr = NULL;
	    msg_send_ext_queue( ilmPtr);    

		if( RMMI_PTR->BT_as_serial_port == KAL_TRUE )
		{
			kal_prompt_trace(MOD_L4C, "pull DisGpio low" );			
			UART_ClrRxBuffer (PS_UART_PORT, MOD_L4C);
	   		UART_ClrRxBuffer (L4C_PTR->uart_port_value, MOD_L4C);
			RMMI_PTR->BT_as_serial_port = KAL_FALSE;
			PS_UART_PORT = L4C_PTR->uart_port_value; /* set uart back to uart1/uart2*/

			//default : pull DisGpio low (we might have pulled it high when MMI request disconnect.
			GPIO_WriteIO(0, BT_GetDscGpio());
			RMMI_BT_STATE_CHANGE( RMMI_BT_IDLE );
			l4c_bt_rf_conn_lind(NULL, zero_addr, BT_RFC_CONN_DISCONN);

		}
		rmmi_bt_poll_data_select_stop_timer();

	}
	else
	{
   		rmmi_bt_poll_data_select_start_timer(5); 
	}
}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_poll_data_select_start_timer
*
* DESCRIPTION
*   This function starts a timer for waiting the "WAKEOK"
*****************************************************************************/
void rmmi_bt_poll_data_select_start_timer(kal_uint8 time) //time unit is 100ms
{
	data_select_timer = evshed_set_event (L4C_PTR->event_scheduler_ptr,
					      	(kal_timer_func_ptr)rmmi_bt_poll_data_select_timeout_hdlr,
				            	NULL, ((KAL_TICKS_100_MSEC)*time));

	kal_prompt_trace(MOD_L4C, "data select timer start" );

}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_stop_timer
*
* DESCRIPTION
*   This function stops the timer 
*****************************************************************************/
void rmmi_bt_poll_data_select_stop_timer(void)
{
   	if (data_select_timer != 0)
   	{
		kal_prompt_trace(MOD_L4C, "data select timer stop" );

       	evshed_cancel_event (L4C_PTR->event_scheduler_ptr, &(data_select_timer));
       	data_select_timer = 0;
   	}
}
extern kal_bool  bt_state; /*interrupt level*/


void rmmi_bt_eint_hdlr(void)
{
   kal_uint8 channel;
   /*disable sleep mode, use kal_prompt instead of kal_trace, because kal_trace block in interrupt service routine */
   //kal_prompt_trace(MOD_L4C, "==[RMMI_BT]== BT_CMD_EINT" );
   channel = custom_eint_get_channel(bt_eint_chann);
   if( rmmi_hostwk_flag == KAL_FALSE )
   {
   
     //L1SM_SleepDisable(rmmi_aux_PDNhandle);
     L1SM_SleepDisable(rmmi_bt_l1sm_handle);
	  l4c_bt_start_hostwksig_timer();

   }
   bt_state=!bt_state;   
   EINT_Set_Polarity(channel,bt_state);
   /*disable sleep mode, use kal_prompt instead of kal_trace, because kal_trace block in interrupt service routine */
   kal_prompt_trace(MOD_L4C, "==[RMMI_BT]== BT_CMD_EINT" );
   
}
/*****************************************************************************
* FUNCTION
*  rmmi_bt_cmd_queue_init
*
* DESCRIPTION
*   This function is to init cmd queue 
*****************************************************************************/
void rmmi_bt_cmd_queue_init(void)
{
	kal_uint8 i;
	
	rmmi_bt_cmd_queue.cmd_count = 0;

	for(i=0; i < RMMI_BT_MAX_CMD_QUEUE_CNT; i++)
		rmmi_bt_cmd_queue.bt_cmd_queue[i].bt_cmd = NULL;
}

UART_PORT rmmi_BT_GetPort_Setting(UARTDCBStruct *DCB)
{
	return BT_GetPort_Setting(DCB);
}

kal_uint8 rmmi_BT_GetResetGpio(void)
{
	return BT_GetResetGpio();
}

void rmmi_bt_pwron(void)
{
	bt_pwron();
}

void rmmi_bt_pwroff(void)
{
	bt_pwroff();
}
/*****************************************************************************
* FUNCTION
*  rmmi_bt_add_cmd_to_queue
*
* DESCRIPTION
*   This function is to add cmd to queue 
*****************************************************************************/
void rmmi_bt_add_cmd_to_queue(kal_uint8* string)
{
	if(rmmi_bt_cmd_queue.cmd_count >= RMMI_BT_MAX_CMD_QUEUE_CNT)
	{
		//RMMI_BT_ASSERT(0);
		kal_trace(TRACE_WARNING,RMMI_BT_WARNING_INDICATION);
	}
	rmmi_bt_cmd_queue.bt_cmd_queue[rmmi_bt_cmd_queue.cmd_count].bt_cmd = (kal_uint8*)get_ctrl_buffer(strlen((char*)string)+1);
	kal_mem_cpy(rmmi_bt_cmd_queue.bt_cmd_queue[rmmi_bt_cmd_queue.cmd_count].bt_cmd, string, strlen((char*)string)+1);
	(rmmi_bt_cmd_queue.cmd_count)++;

}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_is_rfc_connected
*
* DESCRIPTION
*   This function is to check if rfc is connected or not 
*****************************************************************************/
kal_bool	rmmi_bt_get_bc_state(void)
{
	if(RMMI_PTR->BT_action == RMMI_BT_CONNECTED)
		return KAL_TRUE;
	else
		return KAL_FALSE;
}


/*****************************************************************************
* FUNCTION
*  l4c_bt_pwron_req()
* DESCRIPTION
*
* PARAMETERS
*
* RETURNS
*  none.
* GLOBALS AFFECTED
*  none.
*****************************************************************************/
 void l4c_bt_pwron_req(kal_uint8 src_id, kal_uint8* my_bd_addr, kal_uint8* name, kal_uint8 visibility, bt_authenticate_type_enum auth)
{
	kal_uint8 bd_addr[3][10];
	kal_uint8 buffer[50];

	kal_trace(TRACE_GROUP_3, RMMI_BT_POWERON );

	RMMI_PTR->BT_visible = visibility;
	RMMI_PTR->BT_auth = auth;
	kal_mem_cpy(RMMI_PTR->BT_addr, my_bd_addr, 6);
	kal_mem_cpy(RMMI_PTR->BT_name, name, 40);
	
	RMMI_PTR->BT_as_serial_port = KAL_FALSE;
	RMMI_PTR->BT_action = RMMI_BT_PWRON;
	RMMI_PTR->BT_ctrl_src = LMMI_SRC;
	//MCU sleep mode is dsiable in bt pwr on req
	//shall enable sleep mode while BT chip warm reset
	//after warm reset, bt will send wake-up signal to ensure host is ready to receive data(EINT3---disable sleep mode)
	//L1SM_SleepDisable(rmmi_aux_PDNhandle);
	L1SM_SleepDisable(rmmi_bt_l1sm_handle);


	bt_register_hisr(rmmi_bt_eint_hdlr);

#ifdef __BT_DEBUG__

	/* BT_DEBUG: if BT logging is required, open file for later */
	if (BT_GetLogStatus()) 
	{
		WCHAR filename[128];
		kal_uint8 cnt=0;
		kal_uint32 ret, len;
		kal_uint8 idx_buf[8];

		kal_wsprintf( filename, "%s",BT_LOG_FOLDER );
		RMMI_PTR->BT_file_handle = FS_Open(filename, FS_READ_ONLY );
		if( RMMI_PTR->BT_file_handle <= 0 )
		{
			if( FS_CreateDir( filename ) != FS_NO_ERROR )
				kal_print("open BT log folder fail");
		}
		else
		{
			FS_Close(RMMI_PTR->BT_file_handle);
 	 		RMMI_PTR->BT_file_handle = 0;
		}
/*mtk00924 avoid L4 over busy*/
		kal_wsprintf( filename, "%s%s00.%s",BT_LOG_FOLDER, BT_LOG_FILENAME, BT_LOG_FILEEXT );
 	 	RMMI_PTR->BT_file_handle = FS_Open(filename, FS_READ_WRITE );
		if( RMMI_PTR->BT_file_handle )
		{
			/* read file idx */
			kal_mem_set(idx_buf, 0, sizeof(idx_buf));
			ret = FS_Read(RMMI_PTR->BT_file_handle, (void *)idx_buf, 2, &len );
			idx_buf[2]='\0';
			if( ret == FS_NO_ERROR )
			{
				cnt = (kal_uint8)atoi(idx_buf);
				if( ++cnt >= 10 )
				{
					cnt = 0;
				}
				else
				{
					kal_sprintf( (kal_char*)idx_buf, "%02d\r\n", cnt);
					FS_Seek( RMMI_PTR->BT_file_handle, 0,  FS_FILE_BEGIN );
				  	ret = FS_Write(RMMI_PTR->BT_file_handle,
				  					(kal_uint8 *)idx_buf, 
				  					4,
				  					&len );
				}
			}
			else
			{
				/* file index = 0 */
				cnt = 0;
			}
			FS_Close( RMMI_PTR->BT_file_handle );
			RMMI_PTR->BT_file_handle = NULL;
		}
		else
		{
			cnt = 0;
		}

		kal_wsprintf( filename, "%s%s%02d.%s",BT_LOG_FOLDER, BT_LOG_FILENAME, cnt, BT_LOG_FILEEXT );
 	 	RMMI_PTR->BT_file_handle = FS_Open(filename, FS_CREATE|FS_READ_WRITE );
		if( RMMI_PTR->BT_file_handle )
		{
			kal_int32 ret_v;
			kal_uint32 len;
			t_rtc st_t;
			kal_char str_buf[128];

			if( cnt == 0 )
			{
				/* create file 00 with index */
			  	ret = FS_Write(RMMI_PTR->BT_file_handle,
			  					(kal_uint8 *)"00\r\n", 
			  					4,
			  					&len );
			}

			kal_print("Start BT logging: BTlog_XX.txt");

			RTC_GetTime( &st_t );
			kal_sprintf( str_buf, "=== [Start Log: 20%02d-%02d-%02d %02d:%02d:%02d ] ===\r\n", \
				st_t.rtc_year, st_t.rtc_mon, st_t.rtc_day, \
				st_t.rtc_hour, st_t.rtc_min, st_t.rtc_sec );

		  	ret_v = FS_Write(RMMI_PTR->BT_file_handle,
			  					(kal_uint8 *)str_buf, 
			  					strlen(str_buf),
			  					&len );
		}
		else
			kal_print("open BT log file fail");
/*mtk00924 avoid L4 over busy*/			

#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
#endif /* 0 */	

	}

#endif /* __BT_DEBUG__ */

	/* Refer to CSR Known Issues and Solution Memo, AT+CWUP should not sent during power on config */
	rmmi_wakeup_flag = KAL_TRUE;

#if ((defined(MT6318)) || (defined(MT6305)))
	bt_pwron();
	GPIO_WriteIO(1, BT_GetResetGpio());
	l4c_bt_start_guard_timer(); //start guard timer in case no reponse from BT chip
	return;
	
#else
	/* following is only for EVB Maintrunk testing, 
		which is the case that BT cannot power on/off by software 
		(GPIO is not connected with BT power 
		ONLY FOR DEVELOP PHASE */
	print_as_hex(&RMMI_PTR->BT_addr[0], bd_addr[0], 3);