rmmi_bt.c

最新MTK手机软件源码

			 && RMMI_PTR->BT_action <= RMMI_BT_FORCE_SCAN_WAIT  )
	{
		/* Do nothing */
	}
	else
	{
		/* Do nothing */
	}

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


	l4c_bt_rf_conn_lind(NULL, addr, status);
	
}

void rmmi_bt_cscostat_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	status;

	status = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_PTR->s_reg.s3);

	kal_trace(TRACE_GROUP_3, RMMI_BT_SCOSTAT, status );
	RMMI_BT_LOG_STATE();

	if( RMMI_PTR->BT_action != RMMI_BT_CONNECTED && RMMI_PTR->BT_action != RMMI_BT_SCO_WAIT)
		return;

	if( status == BT_SCO_CONN_COMPLETE )
	{
		rmmi_wakeup_flag = KAL_TRUE;
		l4c_bt_stop_wkdur_timer();

		/* Refer to CSR Known Issues and Solution Memo B4892 */
		/* Should send CSTAT in the begining of SCO establish */
		//l4c_bt_start_sco_protection();


	}
	else
	{
		l4c_bt_start_wkdur_timer();
		//l4c_bt_stop_sco_protection();
	}

	l4c_bt_sco_state_lind(NULL, status);
}


void rmmi_bt_vgs_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	level;

 	level = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_PTR->s_reg.s3);

	kal_trace(TRACE_GROUP_3, RMMI_BT_VGS, level );
	RMMI_BT_LOG_STATE();

	l4c_bt_volume_level_lind(level);
}

void rmmi_bt_ckpd_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	keycode;

	keycode = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_PTR->s_reg.s3);

	kal_trace(TRACE_GROUP_3, RMMI_BT_CKPD, keycode );
	RMMI_BT_LOG_STATE();


	l4c_bt_ckpd_lind(keycode, 0);
}

void rmmi_bt_cprofile_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	status;

 	status = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_PTR->s_reg.s3);

	kal_trace(TRACE_GROUP_3, RMMI_BT_PROF, status );
	RMMI_BT_LOG_STATE();


	if ((status == BT_PROF_SPP) ||(status == BT_PROF_DUN) || (status == BT_PROF_FAX))
	{
		UART_PORT bt_port;
		UARTDCBStruct bt_dcb;
   		bt_port = BT_GetPort_Setting(&bt_dcb);
   		
		RMMI_PTR->BT_as_serial_port = KAL_TRUE;
#ifdef __UART3_SUPPORT__		
		UART_ClrRxBuffer (PS_UART_PORT, MOD_L4C);
   		UART_ClrRxBuffer (bt_port, MOD_L4C);
		L4C_PTR->uart_port_value = PS_UART_PORT;
	   	PS_UART_PORT = bt_port; /* set uart to bt port*/
#endif

		//Start Timer to poll DataSelect GPIO
		rmmi_bt_poll_data_select_start_timer(5);
	}


	if( RMMI_PTR->BT_action == RMMI_BT_CONNECTED )
	{
		l4c_bt_prof_conn_lind(status);
	}
	else
	{
		kal_trace(TRACE_GROUP_3, RMMI_BT_WARNING_STAT );
	}



}

void rmmi_bt_nrec_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	string[20];

	kal_trace(TRACE_GROUP_3, RMMI_BT_NREC );
	RMMI_BT_LOG_STATE();
	kal_sprintf((char*)string, "ERROR");
	rmmi_bt_send_btcmd(string);	

}

void rmmi_bt_bvra_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	string[20];

	kal_trace(TRACE_GROUP_3, RMMI_BT_BVRA );
	RMMI_BT_LOG_STATE();
	kal_sprintf((char*)string, "ERROR");
	rmmi_bt_send_btcmd(string);	

}

void rmmi_bt_binq_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	string[20];

	kal_trace(TRACE_GROUP_3, RMMI_BT_BINQ );
	RMMI_BT_LOG_STATE();
	kal_sprintf((char*)string, "ERROR");
	rmmi_bt_send_btcmd(string);		

}

void rmmi_bt_cstat_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	conn_status;
	kal_uint8 sco_status;

 	conn_status = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_COMMA);
 	sco_status = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_PTR->s_reg.s3);
 	
	kal_trace(TRACE_GROUP_3, RMMI_BT_CSTAT, conn_status, sco_status );
	RMMI_BT_LOG_STATE();
	l4c_bt_clear_guard_timer();
		
	if( RMMI_PTR->BT_rmmi_rsp_flag == KAL_TRUE )
	{
		RMMI_PTR->BT_rmmi_rsp_flag = KAL_FALSE;
	    l4c_bt_get_state_lrsp(conn_status, sco_status);
	}

	if( RMMI_PTR->BT_action == RMMI_BT_GET_STAT )
	{
		rmmi_bt_error_recover(RMMI_PTR->BT_err_act, RMMI_PTR->BT_err_reason, conn_status, sco_status );
	}
	else if( RMMI_PTR->BT_action == RMMI_BT_FORCE_IDLE )
	{
		if( conn_status == BT_GATEWAY_IDLE )
		{
			l4c_bt_force_idle_lrsp(1, 0);
		}
		else
		{
			//RMMI_BT_ASSERT(0);
			kal_trace(TRACE_WARNING,RMMI_BT_WARNING_INDICATION);
		}
	}
	else if( RMMI_PTR->BT_action == RMMI_BT_FORCE_SCAN )
	{
		if( conn_status == BT_GATEWAY_CONNECTABLE || conn_status == BT_GATEWAY_DISCOVERBABLE )
		{
			l4c_bt_force_scan_lrsp(1, 0);
		}
		else if( conn_status == BT_GATEWAY_IDLE )
		{
			kal_uint8 string[20];
			
		 	if (RMMI_PTR->BT_visible == 0 ) /* 0: connectable */
			{ 
				kal_sprintf((char*)string, "AT+CCSR=%u", RMMI_PTR->BT_auth);
				rmmi_bt_send_btcmd(string);
			 	RMMI_BT_STATE_CHANGE( RMMI_BT_FORCE_SCAN_WAIT );
			 	l4c_bt_start_guard_timer();

			}
			else if( RMMI_PTR->BT_visible == 1 ) /* 1: visable */
			{
				kal_sprintf((char*)string, "AT+CDIS=%u", RMMI_PTR->BT_auth);
				rmmi_bt_send_btcmd(string);
			 	RMMI_BT_STATE_CHANGE( RMMI_BT_FORCE_SCAN_WAIT );
			 	l4c_bt_start_guard_timer();
			}
			else
			{
				l4c_bt_force_scan_lrsp(1, 0);
			}
		}
		else
		{
			//RMMI_BT_ASSERT(0);
			kal_trace(TRACE_WARNING,RMMI_BT_WARNING_INDICATION);
		}
	}
	else if( RMMI_PTR->BT_action == RMMI_BT_CONNECTED  
	 	  || RMMI_PTR->BT_action == RMMI_BT_FORCE_SCAN_WAIT  )
	{
		/* Ignore, Do nothing */
	}
	else
	{
		//allow to recieve cstatus ind in any BT state
		//RMMI_BT_ASSERT(0);
	}

}

void rmmi_bt_cbd_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	string[20];

	kal_trace(TRACE_GROUP_3, RMMI_BT_CBD );
	RMMI_BT_LOG_STATE();
	kal_sprintf((char*)string, "ERROR");
	rmmi_bt_send_btcmd(string);		
}

void rmmi_bt_getps_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_bool 	ret_val;
	kal_uint8 data[40];

	kal_trace(TRACE_GROUP_3, RMMI_BT_GETPS );
	RMMI_BT_LOG_STATE();
	
	ret_val = rmmi_bt_str_validator(source_string_ptr, RMMI_COMMA, 40, data, KAL_FALSE);
	if (ret_val == KAL_FALSE)
		kal_mem_set(data, 0, 40);
	l4c_bt_get_pskey_lrsp(data);
}

void rmmi_bt_lname_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8	string[20];
	
	kal_trace(TRACE_GROUP_3, RMMI_BT_LNAME );
	RMMI_BT_LOG_STATE();
	kal_sprintf((char*)string, "ERROR");
	rmmi_bt_send_btcmd(string);		
}

void rmmi_bt_rnr_hdlr (rmmi_string_struct *source_string_ptr)
{
	kal_uint8 name[40];
	kal_bool	ret_val;

	kal_trace(TRACE_GROUP_3, RMMI_BT_RNR );
	RMMI_BT_LOG_STATE();

	ret_val = rmmi_bt_str_validator(source_string_ptr, RMMI_COMMA, 40, name, KAL_FALSE);
	if (ret_val == KAL_FALSE)
		kal_mem_set(name, 0, 40);
	// send to MMI
}

void rmmi_bt_dlist_hdlr(rmmi_string_struct *source_string_ptr)
{
	kal_uint8 index;
	kal_uint8 addr[6];
	kal_bool	ret_val;
	bt_trust_device_struct device[1];

	kal_trace(TRACE_GROUP_3, RMMI_BT_TRLST );
	RMMI_BT_LOG_STATE();
	
	index = (kal_uint8)rmmi_int_validator(source_string_ptr, RMMI_COMMA);
	ret_val = rmmi_bt_hex_validator(source_string_ptr, RMMI_COMMA, 6, addr);
	if (ret_val == KAL_FALSE)
	{
		kal_mem_set(addr, 0, 6);
	}
	device[0].index = index;
	kal_mem_cpy(device[0].bd_addr, addr, 6);	
	l4c_bt_get_tr_dev_lrsp(1, device);
}


void rmmi_bt_wakeok_hdlr (rmmi_string_struct *source_string_ptr)
{

	kal_uint8	buffer[50];
	kal_uint8	i,num_cmd;

	kal_trace(TRACE_GROUP_3, RMMI_BT_WAKEOK );
	RMMI_BT_LOG_STATE();

	/* stop cwup timer */
	rmmi_bt_stop_timer();
	l4c_bt_stop_wkdur_timer();
	l4c_bt_start_wkdur_timer();
	
	/* send last string */
	if (RMMI_PTR->BT_string != NULL)
	{
		rmmi_bt_write_to_uart(RMMI_PTR->BT_string);
		free_ctrl_buffer(RMMI_PTR->BT_string);
		RMMI_PTR->BT_string = NULL;
		num_cmd = rmmi_bt_cmd_queue.cmd_count;
		for(i=0; i < num_cmd; i++)
		{	
			rmmi_bt_write_to_uart(rmmi_bt_cmd_queue.bt_cmd_queue[i].bt_cmd);
			free_ctrl_buffer(rmmi_bt_cmd_queue.bt_cmd_queue[i].bt_cmd);
			rmmi_bt_cmd_queue.bt_cmd_queue[i].bt_cmd = NULL;
			(rmmi_bt_cmd_queue.cmd_count)--;
		}
	}
}


void rmmi_bt_send_btcmd(kal_uint8 *string)
{
#ifdef __RMMI_BT_DEBUG__
	ASSERT (RMMI_PTR->BT_as_serial_port == KAL_FALSE );
#endif
	if (RMMI_PTR->BT_as_serial_port == KAL_FALSE )
	{
		#if 0
/* under construction !*/
/* under construction !*/
		#endif
			//add cmd to queue
			if (RMMI_PTR->BT_string != NULL)
			{
				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_add_cmd_to_queue(string);
				/* wake up bt module again */
				rmmi_bt_send_cwup();
				return;
			}
		#if 0
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
/* under construction !*/
		#endif

		RMMI_PTR->BT_string = (kal_uint8*)get_ctrl_buffer(strlen((char*)string)+1);
		kal_mem_cpy(RMMI_PTR->BT_string, string, strlen((char*)string)+1);

		/* wake up bt module first */
		rmmi_bt_send_cwup();
	}
}

/*****************************************************************************
* FUNCTION
*  rmmi_bt_write_to_uart
*
* DESCRIPTION
*   This function append <CR> to the string, 
*   then write to UART and send to Bluetooth chip.
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*  none.
*****************************************************************************/
void rmmi_bt_write_to_uart(kal_uint8 *string)
{
	kal_uint8* buffer;
	kal_uint8 len;
	
	buffer = (kal_uint8*)get_ctrl_buffer(strlen((char*)string)+3);
   	RMMI_PTR->arg_list[0] = (void *)string;
   	RMMI_PTR->arg_list[1] = (void *)&RMMI_PTR->s_reg.s3;
	len = rmmi_fast_string_print ( buffer, (kal_uint8 *)"%s%c", RMMI_PTR->arg_list, 2 );//append <CR>

	/* debug information */
	kal_trace(TRACE_GROUP_3, RMMI_BT_WRITE, buffer[0],
												buffer[1],
												buffer[2],
												buffer[3],
												buffer[4],
												buffer[5],
												buffer[6],
												buffer[7],
												buffer[8],
												buffer[9],
												buffer[10],
												buffer[11] );		

#ifdef __BT_DEBUG__

	//BT_DEBUG: write the sending command to the log file
	if (RMMI_PTR->BT_file_handle >0)
	{
		kal_int32 ret_v;
		kal_uint16 str_len;
		kal_uint32 len;
		str_len = strlen((char*)string)+1;
		ret_v = FS_Write(RMMI_PTR->BT_file_handle,
						buffer,
			  			str_len,
			  			&len );
		if((str_len != len) || (ret_v != FS_NO_ERROR))
			kal_print("Write to BT log fail");
	}
	
#endif

	/* Begin: write to Bluetooth port  */
	RMMI_PTR->BT_port = KAL_TRUE;
	rmmi_write_to_uart(buffer, len, KAL_FALSE);
	RMMI_PTR->BT_port = KAL_FALSE;
	/* End : write to Bluetooth port */
	
	free_ctrl_buffer(buffer);
}


/*****************************************************************************
* FUNCTION
*  rmmi_bt_send_cwup
*
* DESCRIPTION
*   This function send "AT+CWUP" to BT chip,
*   in order to wake up the chip before sending other commands
*****************************************************************************/