line source
/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8417) $Workfile:: mfw_bta.c $|
| $Author:: Rm $Revision:: 1 $|
| CREATED: 04.01.01 $Modtime:: 4.01.01 15:14 $|
| STATE : code |
+--------------------------------------------------------------------+
MODULE : MFW_BTA
PURPOSE : This modul contains the additional functions for BT management.
*/
#define ENTITY_MFW
#include "mfw_sys.h"
#include "typedefs.h"
#include "vsi.h"
#include "custom.h"
#include "gsm.h"
#include "prim.h"
#include "p_btp.h"
#include "Bti.h"
#include "bti_btp.h"
#include "mfw_mfw.h"
#include "mfw_acie.h"
#include "mfw_bt.h"
#include "mfw_bta.h"
#include <string.h>
/* TI BT header */
#ifdef BT_INTERFACE
#include "rv_general.h"
#include "hsg_general.h"
#include "hsg_messages.h"
#include "rvm_api.h"
#include "bmi_api.h"
/*#ifdef PCA_6350*/
#include "pca_gw_mmi.h"
/*#endif*/
#endif /* BT_INTERFACE */
#ifdef _SIMULATION_
#include "bti_win.h"
#endif
/* global used structures */
T_MFW_BT_SERVICE_LST found_headset; /* list with found devices (headset) */
T_MFW_BT_DEVICE_LST service_list; /* list with service id's related to a bd_addr */
T_MFW_BT_SERVICE_LST found_dial_up; /* list with found services (dial_up) */
T_MFW_BT_SERVICE_LST found_fax; /* list with found services (fax) */
T_MFW_BT_SERVICE_LST found_opp; /* list with found services (OPP) */
T_MFW_BT_SERVICE_LST found_sync; /* list with found services (SYNC) */
T_MFW_BT_SERVICE_LST found_sync_cmd; /* list with found services (SYNC_CMD) */
T_MFW_BT_AUTHORIZATION_LIST authorized_devices_list; /* list of authorized devices */
char receiv_object_name[MFW_BT_OPP_OBJECT_NAME_MAX_LEN];/* static buffer for object name: limited with 256 characters */
char receiv_object_mime_type[MFW_BT_OPP_OBJECT_MIME_MAX_LEN];/* static buffer for MIME type of object: limited with 256 characters */
char receiv_sync_object_mime_type[MFW_BT_OPP_OBJECT_MIME_MAX_LEN];/* static buffer for MIME type of object: limited with 256 characters */
char sync_object_name[MFW_BT_OPP_OBJECT_NAME_MAX_LEN];/* static buffer for object name: limited with 256 characters */
char sync_object_location_id[MFW_BT_SYNC_OBJECT_IDENTIFIER];/* static buffer for sync object path on server: limited with 256 characters */
#ifdef _SIMULATION_
#define MFW_BT_OPP_BUFFER_LENGTH 10
static unsigned char server_syn_object[MFW_BT_OPP_BUFFER_LENGTH];
static char mfw_test_syn_obj[] = {'v', 'C', 'a', 'l', '\0'};
static char mfw_test_opp_obj_name[] = {'v', 'C', 'a', 'r', 'd', '\0'};
static char hsg_default_name [] ={'H', 'S', 'G', '1', '\0'};
static char client_obj_name [] ={'C', 'l', 'i', 'e', 'n', 't', '\0'};
static unsigned char server_business_card[MFW_BT_OPP_BUFFER_LENGTH];/* temporary field for the pulled server card */
static char server_default_name [] ={'S', 'e', 'r', 'v', 'e', 'r', '\0'};
static unsigned char server_buffer[MFW_BT_OPP_BUFFER_LENGTH];/* temporary field for received client objects at the server */
static unsigned char client_buffer[MFW_BT_OPP_BUFFER_LENGTH];/* temporary field for pushed client objects */
static unsigned char client_business_card[MFW_BT_OPP_BUFFER_LENGTH];/* temporary field for his own client card */
#endif
/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8445) MODULE: MFW_BTA |
| STATE : code ROUTINE: bta_response_cb |
+--------------------------------------------------------------------+
PURPOSE : Response Callback Handler (receive bt primitive directly)
Note that the input paramter opc will be casted to USHORT
as Bluetooth is currently still using 16bit opcodes.
*/
GLOBAL BOOL bta_response_cb (ULONG opc, void * data)
{
T_MFW_BT_PROFILE_CREATE_CNF *profile_create_cnf;
T_MFW_BT_PROFILE_DELETE_CNF *profile_delete_cnf;
T_MFW_BT_SERVICE_LST *id_ptr;
T_MFW_BT_DEVICE_LST *idd_ptr;
T_MFW_BT_SERVICE_ID *service_id;
T_MFW_BT_DEVICE_ID *dev_id;
T_MFW_BT_SERVICE_ID *help_id;
T_MFW_BT_DEVICE_ID *help_serv_id;
T_MFW_BT_PROFILE_CNF *profile_cnf_data;
T_MFW_BT_PIN_IND *pin_indication;
T_MFW_BT_DEV_PAIR_IND *pair_indication;
T_MFW_BT_DEVICE_IND *device_indication;
T_MFW_BT_SERVICE_IND *service_indication;
T_MFW_BT_REST_CONFIG *restore_configuration;
T_MFW_BT_DISCON_DUN_FAX_IND *disc_dun_fax_ind;
T_MFW_BT_CALL_STATUS_DUN_FAX *dun_call_state;
T_MFW_BT_AUTHORIZATION_IND *authorization_ind;
T_MFW_BT_OPP_PUT_CNF *opp_put_cnf;
T_MFW_BT_OPP_PUSH_CNF *opp_obj_push_cnf;
T_MFW_BT_OPP_PULL_CNF *opp_obj_pull_cnf;
T_MFW_BT_SERVICE_SEARCH_CNF *search_conf;
T_MFW_BT_DEVICE_SEARCH_CNF *dev_search_conf;
T_MFW_BT_CONNECT_IND *connect_ind;
T_MFW_BT_CONNECT_INF *connect_inf;
T_MFW_BT_CONNECT_CNF *connect_cnf;
T_MFW_BT_DISCONNECT_CNF *disconnect_cnf;
T_MFW_BT_DISCON_DUN_FAX_CNF *discon_dun_fax_cnf;
T_MFW_BT_DISCONNECT_IND *disconnect_ind;
T_MFW_BT_TRANSFER_AUDIO_OUT_CNF *audio_out_cnf;
T_MFW_BT_TRANSFER_AUDIO_IN_CNF *audio_in_cnf;
T_MFW_BT_OPP_PUT_IND *opp_put_ind;
T_MFW_BT_SRV_SYNC_CNF *srv_sync_cnf;
T_MFW_BT_SRV_SYNC_AUTH_IND * srv_sync_auth;
T_MFW_BT_SRV_SYNC_PULL_IND * srv_sync_pull_ind;
T_MFW_BT_SRV_SYNC_PUSH_IND * srv_sync_push_ind;
T_MFW_BT_SRV_SYNC_PUSH_CNF * srv_sync_push_cnf;
U8 len;
T_MFW_BT_CHNG_LOCAL_NAME *c_loc_name;
T_MFW_BT_READ_LOCAL_NAME *r_loc_name;
T_MFW_BT_REMOTE_DEV_INFO_RES *rem_dev_info;
T_MFW_BT_CHNG_CONNECTABLE_MODE *chng_cmode;
T_MFW_BT_CHNG_DISCOVERABLE_MODE *chng_dmode;
T_MFW_BT_READ_BD_ADDR *r_bd_addr;
/*#ifdef PCA_6350*/
T_MFW_BT_PCA_GW_STATUS_CFM *pca_gw_status;
T_MFW_BT_PCA_GW_LINK_MONITORING *pca_link_mon;
T_MFW_BT_PCA_GW_CALL_MONITORING *pca_call_mon;
T_MFW_BT_PCA_GW_HANGUP_CFM *pca_hangup;
/*#endif*/ /*PCA_6350*/
/* Cartman added begin */
T_MFW_BT_HSG_HEADSET_CONNECTION_IND *hsg_headset_connection_ind;
T_MFW_BT_HSG_SPECIFIC_CMD_CFM *hsg_specific_cmd_cfm;
T_MFW_BT_HSG_SAVE_LIST_CNF *hsg_save_list_cnf;
/* Cartman added end */
#ifdef _SIMULATION_
T_MFW_BT_SUBTYPE_DEV subtyp;
T_MFW_BT_SERVICE_TYPE service;
T_MFW_BT_SYNC_OBJECT syn_pull_obj, syn_push_obj;
T_MFW_BT_SYN_PASSWD mfw_sync_password[MFW_BT_PIN_MAX_LEN];
char * mfw_sync_password_ptr;
char j;
U8 headset_id, default_security;
T_MFW_BT_BD_ADDR client_address[MFW_BT_ADDR_MAX_LEN];
T_MFW_BT_BD_ADDR hsg_address[MFW_BT_ADDR_MAX_LEN];
T_MFW_BT_BD_ADDR server_address[MFW_BT_ADDR_MAX_LEN];
T_MFW_BT_BD_ADDR remote_address[MFW_BT_ADDR_MAX_LEN];
T_MFW_BT_SYN_OBJECT_STORE mfw_obj;
T_MFW_BT_SYNC_COMMAND mfw_syn_action;
T_MFW_BT_SYNC_SERVER_CONFIG syn_serv_config;
T_MFW_BT_SYN_OBJECT_STORE_ITEM mfw_obj_list, mfw_obj_list1;
T_MFW_BT_SYN_OBJECT_STORE_LIST mfw_obj_list_ptr, mfw_obj_list_ptr1;
T_MFW_BT_HSG_CLIENT_CONFIG client_config;
T_MFW_BT_HSG_SERVER_CONFIG server_conf;
T_MFW_BT_HSG_PHONE_NUMBER test_mfw_phone_list[4][30];
T_MFW_BT_HSG_KEY_LIST test_mfw_key_list[1];
T_MFW_BT_HSG_NAME hsg_name[MFW_BT_HSG_NAME_MAX_LEN];
T_MFW_BT_PRIORITY priority;
T_MFW_BT_CNF_ID headset_cnf_id;
BOOL rem_audio_ctr_supp_hsg;
BOOL mfw_keep_connection_opp;
T_MFW_BT_HEADSET_INFO hs_info;
U16 new_value;
T_MFW_BT_PARAM_NUMBER nb;
T_MFW_BT_CHANGE_PARA type;
T_MFW_BT_DUN_CONFIG dun_filter;
T_MFW_BT_FAX_CONFIG fax_filter;
T_MFW_BT_OPP_SERVER_CONFIG serv_config;
T_MFW_BT_OPP_PUT_RES opp_put_res;
T_MFW_BT_OPP_OBJECT receiv_obj, opp_push_obj, opp_pull_obj;
T_MFW_BT_PIN pin_code[MFW_BT_PIN_MAX_LEN];
T_MFW_BT_PIN_MODE pin_mode;
T_MFW_BT_RESULT_BT result_bt;
T_MFW_BT_PAIRABLE_MODE pair_mode;
T_MFW_BT_DEV_PAIR_LIST pairing_list;
T_MFW_BT_AUTHORIZATION_MASK auth_mask;
T_MFW_BT_AUTHORIZATION_MODE auth_mode;
T_MFW_BT_SECURITY_MODE sec_mode;
#endif
TRACE_FUNCTION ("mfw_bta:bta_response_cb()");
switch ((USHORT) opc)
{
case BTP_PROFILE_CREATE_CNF:
MALLOC(profile_create_cnf, sizeof(T_MFW_BT_PROFILE_CREATE_CNF));
profile_create_cnf->profile = ((T_BTP_PROFILE_CREATE_CNF *)data)->device;
bt_signal(BT_CREATE_PROFILE_CNF, profile_create_cnf);
MFREE(profile_create_cnf);
return TRUE;
case BTP_PROFILE_DELETE_CNF:
MALLOC(profile_delete_cnf, sizeof(T_MFW_BT_PROFILE_DELETE_CNF));
profile_delete_cnf->profile = ((T_BTP_PROFILE_DELETE_CNF *)data)->device;
bt_signal(BT_DELETE_PROFILE_CNF, profile_delete_cnf);
MFREE(profile_delete_cnf);
return TRUE;
case BTP_INIT_PROFILE_CNF:
/* BTI confirms initialization of profile */
MALLOC(profile_cnf_data, sizeof(T_MFW_BT_PROFILE_CNF));
memset(profile_cnf_data, 0, sizeof(T_MFW_BT_PROFILE_CNF));
profile_cnf_data->service = ((T_BTP_INIT_PROFILE_CNF *)data)->device;
profile_cnf_data->result_bd = ((T_BTP_INIT_PROFILE_CNF *)data)->result;
profile_cnf_data->action = ((T_BTP_INIT_PROFILE_CNF *)data)->action;
profile_cnf_data->subtype = ((T_BTP_INIT_PROFILE_CNF *)data)->subtype;
profile_cnf_data->mfw_opp_mode = ((T_BTP_INIT_PROFILE_CNF *)data)->opp_mode;
profile_cnf_data->mfw_sync_mode = ((T_BTP_INIT_PROFILE_CNF *)data)->sync_serv_mode;
profile_cnf_data->mfw_syn_aut_mode = ((T_BTP_INIT_PROFILE_CNF *)data)->sync_init_auth;
bt_signal(BT_INIT_PROFILE_CNF, profile_cnf_data);
#ifdef _SIMULATION_
if(profile_cnf_data->service EQ MFW_BT_SYNC)
{
TRACE_EVENT_P4("init cnf = %d, %d, %d, %d", profile_cnf_data->service, profile_cnf_data->subtype, profile_cnf_data->mfw_sync_mode, profile_cnf_data->mfw_syn_aut_mode);
}
else
{
TRACE_EVENT_P2("init cnf = %d, %d", profile_cnf_data->service, profile_cnf_data->subtype);
}
#endif
MFREE(profile_cnf_data);
return TRUE;
case BTP_DEINIT_PROFILE_CNF:
/* BTI confirms deinitialization of profile */
MALLOC(profile_cnf_data, sizeof(T_MFW_BT_PROFILE_CNF));
memset(profile_cnf_data, 0, sizeof(T_MFW_BT_PROFILE_CNF));
profile_cnf_data->service = ((T_BTP_DEINIT_PROFILE_CNF *)data)->device;
profile_cnf_data->result_bd = ((T_BTP_DEINIT_PROFILE_CNF *)data)->result;
profile_cnf_data->subtype = ((T_BTP_DEINIT_PROFILE_CNF *)data)->subtype;
profile_cnf_data->mfw_opp_mode = ((T_BTP_DEINIT_PROFILE_CNF *)data)->opp_mode;
profile_cnf_data->mfw_sync_mode = ((T_BTP_DEINIT_PROFILE_CNF *)data)->sync_serv_mode;
profile_cnf_data->mfw_syn_aut_mode = ((T_BTP_DEINIT_PROFILE_CNF *)data)->sync_init_auth;
bt_signal(BT_DEINIT_PROFILE_CNF, profile_cnf_data);
#ifdef _SIMULATION_
if(profile_cnf_data->service EQ MFW_BT_SYNC)
{
TRACE_EVENT_P4("deinit cnf = %d, %d, %d, %d", profile_cnf_data->service, profile_cnf_data->subtype, profile_cnf_data->mfw_sync_mode, profile_cnf_data->mfw_syn_aut_mode);
}
else
{
TRACE_EVENT_P2("deinit cnf = %d, %d", profile_cnf_data->service, profile_cnf_data->subtype);
}
#endif
MFREE(profile_cnf_data);
return TRUE;
}
switch ((USHORT) opc)
{
case BTP_RECONFIG_PROFILE_CNF:
/* BTI confirms reconfiguration of profile */
MALLOC(profile_cnf_data, sizeof(T_MFW_BT_PROFILE_CNF));
memset(profile_cnf_data, 0, sizeof(T_MFW_BT_PROFILE_CNF));
profile_cnf_data->service = ((T_BTP_RECONFIG_PROFILE_CNF *)data)->device;
profile_cnf_data->result_bd = ((T_BTP_RECONFIG_PROFILE_CNF *)data)->result;
profile_cnf_data->subtype = ((T_BTP_RECONFIG_PROFILE_CNF *)data)->subtype;
profile_cnf_data->mfw_opp_mode = ((T_BTP_RECONFIG_PROFILE_CNF *)data)->opp_mode;
profile_cnf_data->mfw_sync_mode = ((T_BTP_RECONFIG_PROFILE_CNF *)data)->sync_serv_mode;
profile_cnf_data->mfw_syn_aut_mode = ((T_BTP_RECONFIG_PROFILE_CNF *)data)->sync_init_auth;
bt_signal(BT_RECONFIG_PROFILE_CNF, profile_cnf_data);
#ifdef _SIMULATION_
if(profile_cnf_data->service EQ MFW_BT_SYNC)
{
TRACE_EVENT_P4("reconf cnf = %d, %d, %d, %d", profile_cnf_data->service, profile_cnf_data->subtype, profile_cnf_data->mfw_sync_mode, profile_cnf_data->mfw_syn_aut_mode);
}
else
{
TRACE_EVENT_P2("reconf cnf = %d, %d", profile_cnf_data->service, profile_cnf_data->subtype);
}
#endif
MFREE(profile_cnf_data);
return TRUE;
case BTP_RESTORE_LIST_RESULT:
/* BTI confirms restoring of default device list */
MALLOC(restore_configuration, sizeof(T_MFW_BT_REST_CONFIG));
memset(restore_configuration, 0, sizeof(T_MFW_BT_REST_CONFIG));
restore_configuration->service = ((T_BTP_RESTORE_LIST_RESULT *)data)->device;
restore_configuration->cause = ((T_BTP_RESTORE_LIST_RESULT *)data)->cause;
bt_signal(BT_RESTORE_LIST_RESULT, restore_configuration);
#ifdef _SIMULATION_
if(restore_configuration->cause EQ MFW_BT_REST_LIST_ERR)
{
TRACE_EVENT("restore list err");
}
else if(restore_configuration->cause EQ MFW_BT_REST_CONFIG_ERR)
{
TRACE_EVENT("restore conf err");
}
else
{
TRACE_EVENT("restore conf no err");
}
#endif
MFREE(restore_configuration);
return TRUE;
case BTP_RESTORE_CONF_RESULT:
/* BTI confirms restoring of configuration parameters */
MALLOC(restore_configuration, sizeof(T_MFW_BT_REST_CONFIG));
memset(restore_configuration, 0, sizeof(T_MFW_BT_REST_CONFIG));
restore_configuration->service = ((T_BTP_RESTORE_CONF_RESULT *)data)->device;
restore_configuration->cause = ((T_BTP_RESTORE_CONF_RESULT *)data)->cause;
bt_signal(BT_RESTORE_CONF_RESULT, restore_configuration);
#ifdef _SIMULATION_
if(restore_configuration->cause EQ MFW_BT_REST_LIST_ERR)
{
TRACE_EVENT("restore list err");
}
else if(restore_configuration->cause EQ MFW_BT_REST_CONFIG_ERR)
{
TRACE_EVENT("restore conf err");
}
else
{
TRACE_EVENT("restore conf no err");
}
#endif
MFREE(restore_configuration);
return TRUE;
case BTP_DEVICE_FOUND_IND:
/* BTI confirms finding of bluetooth device with bd_addr and service id's)*/
MALLOC(device_indication, sizeof(T_MFW_BT_DEVICE_IND));
memset(device_indication, 0, sizeof(T_MFW_BT_DEVICE_IND));
memcpy(device_indication->bd_addr, ((T_BTP_DEVICE_FOUND_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(device_indication->bd_name, ((T_BTP_DEVICE_FOUND_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(device_indication->cod, ((T_BTP_DEVICE_FOUND_IND *)data)->cod, MFW_BT_DEVICE_CLASS_LEN);
device_indication->num_services = ((T_BTP_DEVICE_FOUND_IND *)data)->num_services;
device_indication->services = ((T_BTP_DEVICE_FOUND_IND *)data)->services;
MALLOC(dev_id, sizeof(T_MFW_BT_DEVICE_ID));/* allocate memory for new device id */
if(!dev_id)
return FALSE; /* no more memory */
memset(dev_id, 0, sizeof(T_MFW_BT_DEVICE_ID));
idd_ptr = &service_list; /* pointer to list of services */
if(!idd_ptr->device_id) /* test if any device id exist */
{
idd_ptr->device_id = dev_id; /* append new device_id */
memcpy(idd_ptr->device_id->bd_addr, device_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(idd_ptr->device_id->bd_name, device_indication->bd_name, MFW_BT_NAME_MAX_LEN);/* new name */
memcpy(idd_ptr->device_id->cod, device_indication->cod, MFW_BT_DEVICE_CLASS_LEN);/* new cod */
idd_ptr->device_id->num_services = device_indication->num_services;
idd_ptr->device_id->services = device_indication->services;
idd_ptr->device_id->next = NULL; /* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P2("dev found ind = %x %s", service_list.device_id->services, service_list.device_id->bd_addr);
#endif
}
else
{
help_serv_id = idd_ptr->device_id;/* first element */
while(help_serv_id->next) /* look for next device_id */
{
help_serv_id = help_serv_id->next;
}
help_serv_id->next = dev_id;/* append new device_id */
memcpy(help_serv_id->next->bd_addr, device_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(help_serv_id->next->bd_name, device_indication->bd_name, MFW_BT_NAME_MAX_LEN);/* new name */
memcpy(help_serv_id->next->cod, device_indication->cod, MFW_BT_DEVICE_CLASS_LEN);/* new cod */
help_serv_id->next->num_services = device_indication->num_services;/* number of services */
help_serv_id->next->services = device_indication->services;/* service id bitmap */
help_serv_id->next->next = NULL;/* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P2("dev found ind = %x %s ", help_serv_id->next->services, help_serv_id->next->bd_addr);
#endif
}
bt_signal(BT_DEVICE_FOUND_IND, device_indication);
MFREE(device_indication);
return TRUE;
case BTP_SERVICE_FOUND_IND:
/* BTI confirms finding of service names and bd_addr to the desired device typ (service id)*/
MALLOC(service_indication, sizeof(T_MFW_BT_SERVICE_IND));
memset(service_indication, 0, sizeof(T_MFW_BT_SERVICE_IND));
service_indication->service = ((T_BTP_SERVICE_FOUND_IND *)data)->device;
memcpy(service_indication->bd_addr, ((T_BTP_SERVICE_FOUND_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(service_indication->bd_name, ((T_BTP_SERVICE_FOUND_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(service_indication->cod, ((T_BTP_SERVICE_FOUND_IND *)data)->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(service_indication->service_name, ((T_BTP_SERVICE_FOUND_IND *)data)->serv_name, MFW_BT_SERVICE_NAME_MAX_LEN);
/* information of new device(service) will be collected in list of found devices, but only after BT_SERVICE_SEARCH_CNF */
/* the list will be sent to MMI */
if(service_indication->service EQ MFW_BT_HEADSET)
{
MALLOC(service_id, sizeof(T_MFW_BT_SERVICE_ID));/* allocate memory for new device id */
if(!service_id)
return FALSE;
memset(service_id, 0, sizeof(T_MFW_BT_SERVICE_ID));
len = sizeof(service_indication->service_name);
id_ptr = &found_headset; /* pointer to list of founded headset devices */
if(!id_ptr->device_id) /* test if does any device id exist */
{
id_ptr->device_id = service_id; /* append new device_id */
memcpy(id_ptr->device_id->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
id_ptr->device_id->next = NULL; /* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("hsg found ind = %s", found_headset.device_id->bd_name);
#endif
}
else
{
help_id = id_ptr->device_id;/* first element */
while(help_id->next) /* look for next device_id */
{
help_id = help_id->next;
}
help_id->next = service_id;/* append new device_id */
memcpy(help_id->next->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
help_id->next->next = NULL;/* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("hsg found ind = %s", help_id->next->bd_name);
#endif
}
}
else if(service_indication->service EQ MFW_BT_DIAL_UP)
{
MALLOC(service_id, sizeof(T_MFW_BT_SERVICE_ID));/* allocate memory for new device id */
if(!service_id)
return FALSE;
memset(service_id, 0, sizeof(T_MFW_BT_SERVICE_ID));
len = sizeof(service_indication->service_name);
id_ptr = &found_dial_up; /* pointer to list of detected dial up network services */
if(!id_ptr->device_id) /* test if does any device id exist */
{
id_ptr->device_id = service_id; /* append new device_id */
memcpy(id_ptr->device_id->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
id_ptr->device_id->next = NULL; /* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("dun found ind = %s", found_dial_up.device_id->bd_name);
#endif
}
else
{
help_id = id_ptr->device_id;/* first element */
while(help_id->next) /* look for next device_id */
{
help_id = help_id->next;
}
help_id->next = service_id;/* append new device_id */
memcpy(help_id->next->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
help_id->next->next = NULL;/* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("dun found ind = %s", help_id->next->bd_name);
#endif
}
}
else if(service_indication->service EQ MFW_BT_FAX_GW)
{
MALLOC(service_id, sizeof(T_MFW_BT_SERVICE_ID));/* allocate memory for new device id */
if(!service_id)
return FALSE;
memset(service_id, 0, sizeof(T_MFW_BT_SERVICE_ID));
len = sizeof(service_indication->service_name);
id_ptr = &found_fax; /* pointer to list of detected fax services */
if(!id_ptr->device_id) /* test if does any device id exist */
{
id_ptr->device_id = service_id; /* append new device_id */
memcpy(id_ptr->device_id->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
id_ptr->device_id->next = NULL; /* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("fax found ind = %s", found_fax.device_id->bd_name);
#endif
}
else
{
help_id = id_ptr->device_id;/* first element */
while(help_id->next) /* look for next device_id */
{
help_id = help_id->next;
}
help_id->next = service_id;/* append new device_id */
memcpy(help_id->next->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
help_id->next->next = NULL;/* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("fax found ind = %s", help_id->next->bd_name);
#endif
}
}
else if(service_indication->service EQ MFW_BT_OPP)
{
MALLOC(service_id, sizeof(T_MFW_BT_SERVICE_ID));/* allocate memory for new device id */
if(!service_id)
return FALSE;
memset(service_id, 0, sizeof(T_MFW_BT_SERVICE_ID));
len = sizeof(service_indication->service_name);
id_ptr = &found_opp; /* pointer to list of detected opp services */
if(!id_ptr->device_id) /* test if does any device id exist */
{
id_ptr->device_id = service_id; /* append new device_id */
memcpy(id_ptr->device_id->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
id_ptr->device_id->next = NULL; /* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("opp found ind = %s", found_opp.device_id->bd_name);
#endif
}
else
{
help_id = id_ptr->device_id;/* first element */
while(help_id->next) /* look for next device_id */
{
help_id = help_id->next;
}
help_id->next = service_id;/* append new device_id */
memcpy(help_id->next->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
help_id->next->next = NULL;/* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("opp found ind = %s", help_id->next->bd_name);
#endif
}
}
else if(service_indication->service EQ MFW_BT_SYNC)
{
MALLOC(service_id, sizeof(T_MFW_BT_SERVICE_ID));/* allocate memory for new device id */
if(!service_id)
return FALSE;
memset(service_id, 0, sizeof(T_MFW_BT_SERVICE_ID));
len = sizeof(service_indication->service_name);
id_ptr = &found_sync; /* pointer to list of detected SYNC services */
if(!id_ptr->device_id) /* test if does any device id exist */
{
id_ptr->device_id = service_id; /* append new device_id */
memcpy(id_ptr->device_id->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
id_ptr->device_id->next = NULL; /* finish chain */
}
else
{
help_id = id_ptr->device_id;/* first element */
while(help_id->next) /* look for next device_id */
{
help_id = help_id->next;
}
help_id->next = service_id;/* append new device_id */
memcpy(help_id->next->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
help_id->next->next = NULL;/* finish chain */
}
}
else if(service_indication->service EQ MFW_BT_SYNC_CMD)
{
MALLOC(service_id, sizeof(T_MFW_BT_SERVICE_ID));/* allocate memory for new device id */
if(!service_id)
return FALSE;
memset(service_id, 0, sizeof(T_MFW_BT_SERVICE_ID));
len = sizeof(service_indication->service_name);
id_ptr = &found_sync_cmd; /* pointer to list of detected SYNC services with SYN commands support */
if(!id_ptr->device_id) /* test if does any device id exist */
{
id_ptr->device_id = service_id; /* append new device_id */
memcpy(id_ptr->device_id->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
id_ptr->device_id->next = NULL; /* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("sync found ind = %s", found_sync_cmd.device_id->bd_name);
#endif
}
else
{
help_id = id_ptr->device_id;/* first element */
while(help_id->next) /* look for next device_id */
{
help_id = help_id->next;
}
help_id->next = service_id;/* append new device_id */
memcpy(help_id->next->bd_addr, service_indication->bd_addr, MFW_BT_ADDR_MAX_LEN);/* new address */
memcpy(id_ptr->device_id->bd_name, service_indication->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(id_ptr->device_id->cod, service_indication->cod, MFW_BT_DEVICE_CLASS_LEN);
memcpy(id_ptr->device_id->service_name, service_indication->service_name, MFW_BT_SERVICE_NAME_MAX_LEN);/* new name */
help_id->next->next = NULL;/* finish chain */
#ifdef _SIMULATION_
TRACE_EVENT_P1("sync found ind = %s", help_id->next->bd_name);
#endif
}
}
bt_signal(BT_SERVICE_FOUND_IND, service_indication);
MFREE(service_indication);
return TRUE;
case BTP_SERVICE_SEARCH_CNF:
/* BTI confirms finish of search of services */
MALLOC(search_conf, sizeof(T_MFW_BT_SERVICE_SEARCH_CNF));
memset(search_conf, 0, sizeof(T_MFW_BT_SERVICE_SEARCH_CNF));
search_conf->service = ((T_BTP_SERVICE_SEARCH_CNF *)data)->device;
bt_signal(BT_SERVICE_SEARCH_CNF, search_conf);
#ifdef _SIMULATION_
TRACE_EVENT("sync search cnf");
#endif
MFREE(search_conf);
return TRUE;
case BTP_DEVICE_SEARCH_CNF:
/* BTI confirms finish of search of devices */
MALLOC(dev_search_conf, sizeof(T_MFW_BT_DEVICE_SEARCH_CNF));
memset(dev_search_conf, 0, sizeof(T_MFW_BT_DEVICE_SEARCH_CNF));
dev_search_conf->result = ((T_BTP_DEVICE_SEARCH_CNF *)data)->result;
bt_signal(BT_DEVICE_SEARCH_CNF, dev_search_conf);
MFREE(dev_search_conf);
return TRUE;
case BTP_CONNECT_DEVICE_CNF:
/* BTI confirms connection */
MALLOC(connect_cnf, sizeof(T_MFW_BT_CONNECT_CNF));
memset(connect_cnf, 0, sizeof(T_MFW_BT_CONNECT_CNF));
connect_cnf->service = ((T_BTP_CONNECT_DEVICE_CNF *)data)->device;
memcpy(connect_cnf->bd_addr, ((T_BTP_CONNECT_DEVICE_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
connect_cnf->result_bd = ((T_BTP_CONNECT_DEVICE_CNF *)data)->result;
connect_cnf->cnf_id = ((T_BTP_CONNECT_DEVICE_CNF *)data)->cnf_id;
connect_cnf->cause = ((T_BTP_CONNECT_DEVICE_CNF *)data)->cause;
bt_signal(BT_CONNECT_DEVICE_CNF, connect_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P4("conn cnf = %d, %d, %d, %s", connect_cnf->service, connect_cnf->result_bd, connect_cnf->cause, connect_cnf->bd_addr);
#endif
MFREE(connect_cnf);
return TRUE;
case BTP_CONNECT_DEVICE_IND:
/* BTI indicates that a remote device wants to establish a connection */
MALLOC(connect_ind, sizeof(T_MFW_BT_CONNECT_IND));
memset(connect_ind, 0, sizeof(T_MFW_BT_CONNECT_IND));
connect_ind->service = ((T_BTP_CONNECT_DEVICE_IND *)data)->device;
connect_ind->mfw_src_id = ((T_BTP_CONNECT_DEVICE_IND *)data)->src_id;
switch(connect_ind->service)
{
case MFW_BT_SYNC_CMD:
memcpy(connect_ind->bd_addr, ((T_BTP_CONNECT_DEVICE_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(connect_ind->bd_name, ((T_BTP_CONNECT_DEVICE_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
connect_ind->ind_id = ((T_BTP_CONNECT_DEVICE_IND *)data)->ind_id;
break;
case MFW_BT_HEADSET:
if(connect_ind->mfw_src_id NEQ MFW_BT_GSM_NETWORK) /* indication from remote headset */
{
connect_ind->ind_id = ((T_BTP_CONNECT_DEVICE_IND *)data)->ind_id;
memcpy(connect_ind->bd_addr, ((T_BTP_CONNECT_DEVICE_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
}
break;
default:
break;
}
bt_signal(BT_CONNECT_DEVICE_IND, connect_ind);
#ifdef _SIMULATION_
if((connect_ind->service EQ MFW_BT_SYNC_CMD) OR (connect_ind->service EQ MFW_BT_HEADSET))
{
TRACE_EVENT_P3("conn ind = %d %d %s", connect_ind->service, connect_ind->mfw_src_id, connect_ind->bd_addr);
}
else
TRACE_EVENT_P2("conn ind = %d %d", connect_ind->service, connect_ind->mfw_src_id);
#endif
MFREE(connect_ind);
return TRUE;
case BTP_PIN_IND:
/* BTI indicates that a pin code is needed */
MALLOC(pin_indication, sizeof(T_MFW_BT_PIN_IND));
memset(pin_indication, 0, sizeof(T_MFW_BT_PIN_IND));
memcpy(pin_indication->bd_addr, ((T_BTP_PIN_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(pin_indication->bd_name, ((T_BTP_PIN_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
bt_signal(BT_PIN_IND, pin_indication);
#ifdef _SIMULATION_
TRACE_EVENT_P2("pin = %s %s", pin_indication->bd_name, pin_indication->bd_addr);
#endif
MFREE(pin_indication);
return TRUE;
case BTP_AUTHORIZATION_IND:
/* BTI indicates that a authorization reply is needed */
MALLOC(authorization_ind, sizeof(T_MFW_BT_AUTHORIZATION_IND));
memset(authorization_ind, 0, sizeof(T_MFW_BT_AUTHORIZATION_IND));
memcpy(authorization_ind->bd_addr, ((T_BTP_AUTHORIZATION_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(authorization_ind->bd_name, ((T_BTP_AUTHORIZATION_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(authorization_ind->appli_name, ((T_BTP_AUTHORIZATION_IND *)data)->appli_name, MFW_BT_APPL_NAME_MAX_LEN);
authorization_ind->auth_mask_mfw = ((T_BTP_AUTHORIZATION_IND *)data)->authorization_mask_serv;
authorization_ind->connection_dir = ((T_BTP_AUTHORIZATION_IND *)data)->incom_conn;
bt_signal(BT_AUTHORIZATION_IND, authorization_ind);
#ifdef _SIMULATION_
TRACE_EVENT_P4("author ind = %x %d %s %s", authorization_ind->auth_mask_mfw, authorization_ind->connection_dir, authorization_ind->bd_name, authorization_ind->appli_name);
#endif
MFREE(authorization_ind);
return TRUE;
case BTP_TRANSFER_AUDIO_OUT_CNF:
/* BTI confirms audio connection to device */
MALLOC(audio_out_cnf, sizeof(T_MFW_BT_TRANSFER_AUDIO_OUT_CNF));
memset(audio_out_cnf, 0, sizeof(T_MFW_BT_TRANSFER_AUDIO_OUT_CNF));
audio_out_cnf->service = ((T_BTP_TRANSFER_AUDIO_OUT_CNF *)data)->device;
audio_out_cnf->result_bd = ((T_BTP_TRANSFER_AUDIO_OUT_CNF *)data)->result;
memcpy(audio_out_cnf->bd_addr, ((T_BTP_TRANSFER_AUDIO_OUT_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
audio_out_cnf->cnf_id = ((T_BTP_TRANSFER_AUDIO_OUT_CNF *)data)->cnf_id;
bt_signal(BT_TRANSFER_AUDIO_OUT_CNF, audio_out_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P2("audio out cnf = %d, %s", audio_out_cnf->service, audio_out_cnf->bd_addr);
#endif
MFREE(audio_out_cnf);
return TRUE;
case BTP_TRANSFER_AUDIO_IN_CNF:
/* BTI confirms audio connection from headset */
MALLOC(audio_in_cnf, sizeof(T_MFW_BT_TRANSFER_AUDIO_IN_CNF));
memset(audio_in_cnf, 0, sizeof(T_MFW_BT_TRANSFER_AUDIO_IN_CNF));
audio_in_cnf->service = ((T_BTP_TRANSFER_AUDIO_IN_CNF *)data)->device;
audio_in_cnf->result_bd = ((T_BTP_TRANSFER_AUDIO_IN_CNF *)data)->result;
memcpy(audio_in_cnf->bd_addr, ((T_BTP_TRANSFER_AUDIO_IN_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
bt_signal(BT_TRANSFER_AUDIO_IN_CNF, audio_in_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P2("audio in cnf = %d, %s", audio_in_cnf->service, audio_in_cnf->bd_addr);
#endif
MFREE(audio_in_cnf);
return TRUE;
case BTP_DISCONNECT_DEVICE_CNF:
/* BTI confirms disconnection for profile hsg */
MALLOC(disconnect_cnf, sizeof(T_MFW_BT_DISCONNECT_CNF));
memset(disconnect_cnf, 0, sizeof(T_MFW_BT_DISCONNECT_CNF));
disconnect_cnf->service = ((T_BTP_DISCONNECT_DEVICE_CNF *)data)->device;
disconnect_cnf->cnf_id = ((T_BTP_DISCONNECT_DEVICE_CNF *)data)->cnf_id;
memcpy(disconnect_cnf->bd_addr, ((T_BTP_DISCONNECT_DEVICE_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
bt_signal(BT_DISCONNECT_DEVICE_CNF, disconnect_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P3("disconn cnf = %d, %d, %s", disconnect_cnf->service, disconnect_cnf->cnf_id, disconnect_cnf->bd_addr);
#endif
MFREE(disconnect_cnf);
return TRUE;
case BTP_DISCON_DUN_FAX_CNF:
/* BTI confirms disconnection for profile dun/fax */
MALLOC(discon_dun_fax_cnf, sizeof(T_MFW_BT_DISCON_DUN_FAX_CNF));
memset(discon_dun_fax_cnf, 0, sizeof(T_MFW_BT_DISCON_DUN_FAX_CNF));
discon_dun_fax_cnf->service = ((T_BTP_DISCON_DUN_FAX_CNF *)data)->device;
discon_dun_fax_cnf->result_bd = ((T_BTP_DISCON_DUN_FAX_CNF *)data)->cause;
bt_signal(BT_DISCON_DUN_FAX_CNF, discon_dun_fax_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P2("disconn cnf = %d, %d", discon_dun_fax_cnf->service, discon_dun_fax_cnf->result_bd);
#endif
MFREE(discon_dun_fax_cnf);
return TRUE;
case BTP_DISCONNECT_DEVICE_IND:
/* BTI indicats disconnection from headset*/
MALLOC(disconnect_ind, sizeof(T_MFW_BT_DISCONNECT_IND));
memset(disconnect_ind, 0, sizeof(T_MFW_BT_DISCONNECT_IND));
disconnect_ind->service = ((T_BTP_DISCONNECT_DEVICE_IND *)data)->device;
disconnect_ind->ind_id = ((T_BTP_DISCONNECT_DEVICE_IND *)data)->ind_id;
memcpy(disconnect_ind->bd_addr, ((T_BTP_DISCONNECT_DEVICE_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
bt_signal(BT_DISCONNECT_DEVICE_IND, disconnect_ind);
#ifdef _SIMULATION_
TRACE_EVENT_P3("disconn ind hsg = %d, %d, %s", disconnect_ind->service, disconnect_ind->ind_id, disconnect_ind->bd_addr);
#endif
MFREE(disconnect_ind);
return TRUE;
case BTP_DISCON_DUN_FAX_IND:
/* BTI indicates disconnection from remote dun/fax */
MALLOC(disc_dun_fax_ind, sizeof(T_MFW_BT_DISCON_DUN_FAX_IND));
memset(disc_dun_fax_ind, 0, sizeof(T_MFW_BT_DISCON_DUN_FAX_IND));
disc_dun_fax_ind->service = ((T_BTP_DISCON_DUN_FAX_IND *)data)->device;
bt_signal(BT_DISCON_DUN_FAX_IND, disc_dun_fax_ind);
#ifdef _SIMULATION_
TRACE_EVENT_P1("disconn ind dun = %d", disc_dun_fax_ind->service);
#endif
MFREE(disc_dun_fax_ind);
return TRUE;
case BTP_DEVICE_PAIRED_IND:
/* BTI indicates that a pin code is needed */
MALLOC(pair_indication, sizeof(T_MFW_BT_DEV_PAIR_IND));
memset(pair_indication, 0, sizeof(T_MFW_BT_DEV_PAIR_IND));
memcpy(pair_indication->rem_bd_addr, ((T_BTP_DEVICE_PAIRED_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(pair_indication->rem_bd_name, ((T_BTP_DEVICE_PAIRED_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
pair_indication->pair_res = ((T_BTP_DEVICE_PAIRED_IND *)data)->pair_result;
bt_signal(BT_DEVICE_PAIRED_IND, pair_indication);
#ifdef _SIMULATION_
TRACE_EVENT_P2("pair ind = %d %s", pair_indication->pair_res, pair_indication->rem_bd_name);
#endif
MFREE(pair_indication);
return TRUE;
case BTP_TRUSTED_DEV_LIST_FULL:
/* BTI indicates that list of trusted devices is full */
bt_signal(BT_TRUSTED_DEV_LIST_FULL, NULL);
#ifdef _SIMULATION_
TRACE_EVENT("TRUSTED_DEV_LIST_FULL");
#endif
return TRUE;
case BTP_CALL_MONITORING_STATUS:
/* BTI indicates call monitoring messages by dun/fax */
MALLOC(dun_call_state, sizeof(T_MFW_BT_CALL_STATUS_DUN_FAX));
memset(dun_call_state, 0, sizeof(T_MFW_BT_CALL_STATUS_DUN_FAX));
dun_call_state->service = ((T_BTP_CALL_MONITORING_STATUS *)data)->device;
switch(((T_BTP_CALL_MONITORING_STATUS *)data)->call_status)
{
case BTI_DUN_CALL_IN_PRO:
dun_call_state->call_state = MFW_BT_CALL_IN_PROGRESS;
break;
case BTI_DUN_CALL_ESTABLISHED:
dun_call_state->call_state = MFW_BT_CALL_ESTABLISHED;
break;
case BTI_DUN_CALL_PAUSED:
dun_call_state->call_state = MFW_BT_CALL_PAUSED;
break;
case BTI_DUN_CALL_RESUMED:
dun_call_state->call_state = MFW_BT_CALL_RESUMED;
break;
case BTI_DUN_CALL_HANGUP_IN_PR:
dun_call_state->call_state = MFW_BT_HANGUP_IN_PROGRESS;
break;
case BTI_DUN_CALL_RELEASED:
dun_call_state->call_state = MFW_BT_CALL_RELEASED;
break;
case BTI_FAX_CALL_IN_PRO:
dun_call_state->call_state = MFW_BT_CALL_IN_PROGRESS;
break;
case BTI_FAX_CALL_ESTABLISHED:
dun_call_state->call_state = MFW_BT_CALL_ESTABLISHED;
break;
case BTI_FAX_CALL_HANGUP_IN_PR:
dun_call_state->call_state = MFW_BT_HANGUP_IN_PROGRESS;
break;
case BTI_FAX_CALL_RELEASED:
dun_call_state->call_state = MFW_BT_CALL_RELEASED;
break;
default:
break;
}
bt_signal(BT_CALL_MONITORING_STATUS, dun_call_state);
#ifdef _SIMULATION_
TRACE_EVENT_P2("dun call monit = %d %d", dun_call_state->service, dun_call_state->call_state);
#endif
MFREE(dun_call_state);
return TRUE;
case BTP_OPP_SERV_PUT_IND:
/* BTI indicates that a put response is needed (OPP server) */
MALLOC(opp_put_ind, sizeof(T_MFW_BT_OPP_PUT_IND));
memset(opp_put_ind, 0, sizeof(T_MFW_BT_OPP_PUT_IND));
opp_put_ind->service = ((T_BTP_OPP_SERV_PUT_IND *)data)->device;
opp_put_ind->subtype = ((T_BTP_OPP_SERV_PUT_IND *)data)->subtype;
memcpy(opp_put_ind->bd_addr, ((T_BTP_OPP_SERV_PUT_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memset(&receiv_object_name, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_object_name, &((T_BTP_OPP_SERV_PUT_IND *)data)->object_name, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);
/* from string in Primitive to static buffer in MFW, pointer to MMI */
opp_put_ind->mfw_opp_object.mfw_object_name = receiv_object_name;
opp_put_ind->mfw_opp_object.mfw_object_length = ((T_BTP_OPP_SERV_PUT_IND *)data)->object_length;
bt_signal(BT_OPP_SERV_PUT_IND, opp_put_ind);
#ifdef _SIMULATION_
TRACE_EVENT_P3("opp put ind = %d, %d, %s", opp_put_ind->service, opp_put_ind->subtype, receiv_object_name);
#endif
MFREE(opp_put_ind);
return TRUE;
case BTP_OPP_SERV_PUT_CNF:
/* BTI indicates that an object push procedure is finished or cancelled */
MALLOC(opp_put_cnf, sizeof(T_MFW_BT_OPP_PUT_CNF));
memset(opp_put_cnf, 0, sizeof(T_MFW_BT_OPP_PUT_CNF));
opp_put_cnf->service = ((T_BTP_OPP_SERV_PUT_CNF *)data)->device;
opp_put_cnf->subtype = ((T_BTP_OPP_SERV_PUT_CNF *)data)->subtype;
memcpy(opp_put_cnf->bd_addr, ((T_BTP_OPP_SERV_PUT_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
opp_put_cnf->mfw_opp_object.mfw_object_type = ((T_BTP_OPP_SERV_PUT_CNF *)data)->object_type;
memset(&receiv_object_name, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_object_name, &((T_BTP_OPP_SERV_PUT_CNF *)data)->object_name, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);
opp_put_cnf->mfw_opp_object.mfw_object_name = receiv_object_name;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
opp_put_cnf->mfw_opp_object.mfw_object_length = ((T_BTP_OPP_SERV_PUT_CNF *)data)->object_length;
opp_put_cnf->error_cause = ((T_BTP_OPP_SERV_PUT_CNF *)data)->cause;
bt_signal(BT_OPP_SERV_PUT_CNF, opp_put_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P3("opp put cnf = %d, %d, %s", opp_put_cnf->service, opp_put_cnf->subtype, receiv_object_name);
#endif
MFREE(opp_put_cnf);
return TRUE;
case BTP_OPP_OBJECT_PUSH_CNF:
/* BTI indicates that an object push procedure is finished or cancelled */
MALLOC(opp_obj_push_cnf, sizeof(T_MFW_BT_OPP_PUSH_CNF));
memset(opp_obj_push_cnf, 0, sizeof(T_MFW_BT_OPP_PUSH_CNF));
opp_obj_push_cnf->service = ((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->device;
opp_obj_push_cnf->subtype = ((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->subtype;
memcpy(opp_obj_push_cnf->bd_addr, ((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
opp_obj_push_cnf->mfw_opp_object.mfw_object_type = ((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->object_type;
memset(&receiv_object_name, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_object_name, &((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->object_name, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);
opp_obj_push_cnf->mfw_opp_object.mfw_object_name = receiv_object_name;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
memset(&receiv_object_mime_type, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_object_mime_type, &((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->object_m_t, MFW_BT_OPP_OBJECT_MIME_MAX_LEN);
opp_obj_push_cnf->mfw_opp_object.mfw_object_mime_type = receiv_object_mime_type;/* same comment like for ...object_name */
opp_obj_push_cnf->mfw_opp_object.mfw_object_length = ((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->object_length;
opp_obj_push_cnf->error_cause = ((T_BTP_OPP_OBJECT_PUSH_CNF *)data)->cause;
bt_signal(BT_OPP_OBJECT_PUSH_CNF, opp_obj_push_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P3("opp push cnf = %d, %d, %s", opp_obj_push_cnf->service, opp_obj_push_cnf->subtype, receiv_object_name);
#endif
MFREE(opp_obj_push_cnf);
return TRUE;
case BTP_OPP_OBJECT_PULL_CNF:
/* BTI indicates that an object push procedure is finished or cancelled */
MALLOC(opp_obj_pull_cnf, sizeof(T_MFW_BT_OPP_PULL_CNF));
memset(opp_obj_pull_cnf, 0, sizeof(T_MFW_BT_OPP_PULL_CNF));
opp_obj_pull_cnf->service = ((T_BTP_OPP_OBJECT_PULL_CNF *)data)->device;
opp_obj_pull_cnf->subtype = ((T_BTP_OPP_OBJECT_PULL_CNF *)data)->subtype;
memcpy(opp_obj_pull_cnf->bd_addr, ((T_BTP_OPP_OBJECT_PULL_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
opp_obj_pull_cnf->mfw_opp_object.mfw_object_type = ((T_BTP_OPP_OBJECT_PULL_CNF *)data)->object_type;
memset(&receiv_object_name, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_object_name, &((T_BTP_OPP_OBJECT_PULL_CNF *)data)->object_name, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);
opp_obj_pull_cnf->mfw_opp_object.mfw_object_name = receiv_object_name;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
memset(&receiv_object_mime_type, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_object_mime_type, &((T_BTP_OPP_OBJECT_PULL_CNF *)data)->object_m_t, MFW_BT_OPP_OBJECT_MIME_MAX_LEN);
opp_obj_pull_cnf->mfw_opp_object.mfw_object_mime_type = receiv_object_mime_type;/* same comment like for ...object_name */
opp_obj_pull_cnf->mfw_opp_object.mfw_object_length = ((T_BTP_OPP_OBJECT_PULL_CNF *)data)->object_length;
opp_obj_pull_cnf->error_cause = ((T_BTP_OPP_OBJECT_PULL_CNF *)data)->cause;
bt_signal(BT_OPP_OBJECT_PULL_CNF, opp_obj_pull_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P3("opp pull cnf = %d, %d, %s", opp_obj_pull_cnf->service, opp_obj_pull_cnf->subtype, receiv_object_name);
#endif
MFREE(opp_obj_pull_cnf);
return TRUE;
case BTP_SRV_SYNC_CNF:
/* BTI indicates that synchronization operation completes (initiated by client or server) */
MALLOC(srv_sync_cnf, sizeof(T_MFW_BT_SRV_SYNC_CNF));
memset(srv_sync_cnf, 0, sizeof(T_MFW_BT_SRV_SYNC_CNF));
srv_sync_cnf->service = ((T_BTP_SRV_SYNC_CNF *)data)->device;
srv_sync_cnf->subtype = ((T_BTP_SRV_SYNC_CNF *)data)->subtype;
memcpy(srv_sync_cnf->mfw_client_bd_addr, ((T_BTP_SRV_SYNC_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(srv_sync_cnf->mfw_client_name, ((T_BTP_SRV_SYNC_CNF *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
srv_sync_cnf->mfw_error_state = ((T_BTP_SRV_SYNC_CNF *)data)->cause;
bt_signal(BT_SRV_SYNC_CNF, srv_sync_cnf);
MFREE(srv_sync_cnf);
return TRUE;
case BTP_SRV_SYNC_AUTH_IND:
/* BTI indicates that synchronization operation completes (initiated by client or server) */
MALLOC(srv_sync_auth, sizeof(T_MFW_BT_SRV_SYNC_AUTH_IND));
memset(srv_sync_auth, 0, sizeof(T_MFW_BT_SRV_SYNC_AUTH_IND));
srv_sync_auth->service = ((T_BTP_SRV_SYNC_AUTH_IND *)data)->device;
srv_sync_auth->subtype = ((T_BTP_SRV_SYNC_AUTH_IND *)data)->subtype;
memcpy(srv_sync_auth->mfw_client_bd_addr, ((T_BTP_SRV_SYNC_AUTH_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(srv_sync_auth->mfw_client_name, ((T_BTP_SRV_SYNC_AUTH_IND *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
bt_signal(BT_SRV_SYNC_AUTH_IND, srv_sync_auth);
#ifdef _SIMULATION_
TRACE_EVENT_P3("sync auth ind = %d, %d, %s", srv_sync_auth->service, srv_sync_auth->subtype, srv_sync_auth->mfw_client_bd_addr);
#endif
MFREE(srv_sync_auth);
return TRUE;
case BTP_SRV_SYNC_PULL_IND:
/* BTI indicates that the client requests to pull an object from the sync server */
MALLOC(srv_sync_pull_ind, sizeof(T_MFW_BT_SRV_SYNC_PULL_IND));
memset(srv_sync_pull_ind, 0, sizeof(T_MFW_BT_SRV_SYNC_PULL_IND));
srv_sync_pull_ind->service = ((T_BTP_SRV_SYNC_PULL_IND *)data)->device;
srv_sync_pull_ind->subtype = ((T_BTP_SRV_SYNC_PULL_IND *)data)->subtype;
memcpy(srv_sync_pull_ind->mfw_client_bd_addr, ((T_BTP_SRV_SYNC_PULL_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
srv_sync_pull_ind->mfw_object_id.mfw_object_size = ((T_BTP_SRV_SYNC_PULL_IND *)data)->object_id_size;
memset(&sync_object_location_id, 0, MFW_BT_SYNC_OBJECT_IDENTIFIER);/* limited with 256 characters */
memcpy(&sync_object_location_id, &((T_BTP_SRV_SYNC_PULL_IND *)data)->object_id_loc, MFW_BT_SYNC_OBJECT_IDENTIFIER);
srv_sync_pull_ind->mfw_object_id.mfw_location = sync_object_location_id;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
bt_signal(BT_SRV_SYNC_PULL_IND, srv_sync_pull_ind);
#ifdef _SIMULATION_
TRACE_EVENT_P3("sync pull ind = %d, %d, %d", srv_sync_pull_ind->service, srv_sync_pull_ind->subtype, srv_sync_pull_ind->mfw_object_id.mfw_object_size);
#endif
MFREE(srv_sync_pull_ind);
return TRUE;
case BTP_SRV_SYNC_PUSH_IND:
/* BTI indicates that the client requests to pull an object from the sync server */
MALLOC(srv_sync_push_ind, sizeof(T_MFW_BT_SRV_SYNC_PUSH_IND));
memset(srv_sync_push_ind, 0, sizeof(T_MFW_BT_SRV_SYNC_PUSH_IND));
srv_sync_push_ind->service = ((T_BTP_SRV_SYNC_PUSH_IND *)data)->device;
srv_sync_push_ind->subtype = ((T_BTP_SRV_SYNC_PUSH_IND *)data)->subtype;
memcpy(srv_sync_push_ind->mfw_client_bd_addr, ((T_BTP_SRV_SYNC_PUSH_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
srv_sync_push_ind->mfw_object_id.mfw_object_size = ((T_BTP_SRV_SYNC_PUSH_IND *)data)->object_id_size;
memset(&sync_object_location_id, 0, MFW_BT_SYNC_OBJECT_IDENTIFIER);/* limited with 256 characters */
memcpy(&sync_object_location_id, &((T_BTP_SRV_SYNC_PUSH_IND *)data)->object_id_loc, MFW_BT_SYNC_OBJECT_IDENTIFIER);
srv_sync_push_ind->mfw_object_id.mfw_location = sync_object_location_id;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
bt_signal(BT_SRV_SYNC_PUSH_IND, srv_sync_push_ind);
#ifdef _SIMULATION_
TRACE_EVENT_P3("sync push ind = %d, %d, %d", srv_sync_push_ind->service, srv_sync_push_ind->subtype, srv_sync_push_ind->mfw_object_id.mfw_object_size);
#endif
MFREE(srv_sync_push_ind);
return TRUE;
case BTP_SRV_SYNC_PUSH_CNF:
/* BTI indicates that the client requests to pull an object from the sync server */
MALLOC(srv_sync_push_cnf, sizeof(T_MFW_BT_SRV_SYNC_PUSH_CNF));
memset(srv_sync_push_cnf, 0, sizeof(T_MFW_BT_SRV_SYNC_PUSH_CNF));
srv_sync_push_cnf->service = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->device;
srv_sync_push_cnf->subtype = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->subtype;
memcpy(srv_sync_push_cnf->mfw_client_bd_addr, ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
srv_sync_push_cnf->mfw_object.mfw_object_type = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_type;
memset(&sync_object_name, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&sync_object_name, &((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_name, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);
srv_sync_push_cnf->mfw_object.mfw_object_name = sync_object_name;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
memset(&receiv_sync_object_mime_type, 0, MFW_BT_OPP_OBJECT_NAME_MAX_LEN);/* limited with 256 characters */
memcpy(&receiv_sync_object_mime_type, &((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_m_t, MFW_BT_OPP_OBJECT_MIME_MAX_LEN);
srv_sync_push_cnf->mfw_object.mfw_object_mime_type = receiv_sync_object_mime_type;/* same comment like for ...object_name */
srv_sync_push_cnf->mfw_object.mfw_object_length = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_length;
srv_sync_push_cnf->mfw_object_id.mfw_object_size = ((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_id_size;
memset(&sync_object_location_id, 0, MFW_BT_SYNC_OBJECT_IDENTIFIER);/* limited with 256 characters */
memcpy(&sync_object_location_id, &((T_BTP_SRV_SYNC_PUSH_CNF *)data)->object_id_loc, MFW_BT_SYNC_OBJECT_IDENTIFIER);
srv_sync_push_cnf->mfw_object_id.mfw_location = sync_object_location_id;/* from string in Primitive to static buffer in MFW (pointer is not possible in Primitive), pointer of buffer */
bt_signal(BT_SRV_SYNC_PUSH_CNF, srv_sync_push_cnf);
#ifdef _SIMULATION_
TRACE_EVENT_P3("sync push cnf = %d, %d, %s", srv_sync_push_cnf->service, srv_sync_push_cnf->subtype, srv_sync_push_cnf->mfw_client_bd_addr);
#endif
MFREE(srv_sync_push_cnf);
return TRUE;
case BTP_CONNECT_DEVICE_INF:
/* BTI indicates that hsg manages a connection on RFCOMM level */
MALLOC(connect_inf, sizeof(T_MFW_BT_CONNECT_INF));
memset(connect_inf, 0, sizeof(T_MFW_BT_CONNECT_INF));
connect_inf->service = ((T_BTP_CONNECT_DEVICE_INF *)data)->device;
connect_inf->ind_id = ((T_BTP_CONNECT_DEVICE_INF *)data)->ind_id;
if(connect_inf->ind_id EQ MFW_BT_INVALID_HEADSET_ID)
{
memcpy(connect_inf->bd_addr, ((T_BTP_CONNECT_DEVICE_INF *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
}
bt_signal(BT_CONNECT_DEVICE_INF, connect_inf);
#ifdef _SIMULATION_
TRACE_EVENT_P3("conn inf = %d %d %s", connect_inf->service, connect_inf->ind_id, connect_inf->bd_addr);
#endif
MFREE(connect_inf);
return TRUE;
/* BT CTRL */
case BTP_CHNG_LOCAL_NAME:
MALLOC(c_loc_name, sizeof(T_MFW_BT_CHNG_LOCAL_NAME));
c_loc_name->success = ((T_BTP_CHNG_LOCAL_NAME *)data)->success;
bt_signal(BT_CHNG_LOCAL_NAME, c_loc_name);
MFREE(c_loc_name);
return TRUE;
case BTP_READ_LOCAL_NAME:
MALLOC(r_loc_name, sizeof(T_MFW_BT_READ_LOCAL_NAME));
r_loc_name->success = ((T_BTP_READ_LOCAL_NAME *)data)->success;
memcpy(r_loc_name->bd_name, ((T_BTP_READ_LOCAL_NAME *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
bt_signal(BT_READ_LOCAL_NAME, r_loc_name);
MFREE(r_loc_name);
return TRUE;
case BTP_REMOTE_DEV_INFO_RES:
MALLOC(rem_dev_info, sizeof(T_MFW_BT_REMOTE_DEV_INFO_RES));
rem_dev_info->success = ((T_BTP_REMOTE_DEV_INFO_RES *)data)->success;
memcpy(rem_dev_info->bd_addr, ((T_BTP_REMOTE_DEV_INFO_RES *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
memcpy(rem_dev_info->bd_name, ((T_BTP_REMOTE_DEV_INFO_RES *)data)->bd_name, MFW_BT_NAME_MAX_LEN);
memcpy(rem_dev_info->cod, ((T_BTP_REMOTE_DEV_INFO_RES *)data)->cod, MFW_BT_DEVICE_CLASS_LEN);
bt_signal(BT_REMOTE_DEV_INFO_RES, rem_dev_info);
MFREE(rem_dev_info);
return TRUE;
case BTP_CHNG_CONNECTABLE_MODE:
MALLOC(chng_cmode, sizeof(T_MFW_BT_CHNG_CONNECTABLE_MODE));
chng_cmode->success = ((T_BTP_CHNG_CONNECTABLE_MODE *)data)->success;
chng_cmode->mode = (T_MFW_BT_CONNECTABLE_MODE)((T_BTP_CHNG_CONNECTABLE_MODE *)data)->mode;
chng_cmode->scan_interval = ((T_BTP_CHNG_CONNECTABLE_MODE *)data)->scan_interval;
chng_cmode->scan_window = ((T_BTP_CHNG_CONNECTABLE_MODE *)data)->scan_window;
bt_signal(BT_CHNG_CONNECTABLE_MODE, chng_cmode);
MFREE(chng_cmode);
return TRUE;
case BTP_CHNG_DISCOVERABLE_MODE:
MALLOC(chng_dmode, sizeof(T_MFW_BT_CHNG_DISCOVERABLE_MODE));
chng_dmode->success = ((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->success;
chng_dmode->mode = (T_MFW_BT_DISCOVERABLE_MODE)((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->mode;
chng_dmode->scan_interval = ((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->scan_interval;
chng_dmode->scan_window = ((T_BTP_CHNG_DISCOVERABLE_MODE *)data)->scan_window;
bt_signal(BT_CHNG_DISCOVERABLE_MODE, chng_dmode);
MFREE(chng_dmode);
return TRUE;
case BTP_READ_BD_ADDR:
MALLOC(r_bd_addr, sizeof(T_MFW_BT_READ_BD_ADDR));
r_bd_addr->success = ((T_BTP_READ_BD_ADDR *)data)->success;
memcpy(r_bd_addr->bd_addr, ((T_BTP_READ_BD_ADDR *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
bt_signal(BT_READ_BD_ADDR, r_bd_addr);
MFREE(r_bd_addr);
return TRUE;
/*#ifdef PCA_6350*/
case BTP_PCA_EVENT:
if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_STATUS_CFM)
{
MALLOC(pca_gw_status, sizeof(T_MFW_BT_PCA_GW_STATUS_CFM));
pca_gw_status->status = ((T_BTP_PCA_EVENT*)data)->pca_gw_status;
bt_signal(BT_PCA_GW_STATUS_CFM, pca_gw_status);
return TRUE;
}
if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_LINK_MONITORING)
{
MALLOC(pca_link_mon, sizeof(T_MFW_BT_PCA_GW_LINK_MONITORING));
pca_link_mon->link_status = ((T_BTP_PCA_EVENT*)data)->pca_link_status;
memcpy(pca_link_mon->bd_addr, ((T_BTP_PCA_EVENT *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
bt_signal(BT_PCA_GW_LINK_MONITORING, pca_link_mon);
return TRUE;
}
if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_CALL_MONITORING)
{
MALLOC(pca_call_mon, sizeof(T_MFW_BT_PCA_GW_CALL_MONITORING));
pca_call_mon->call_status = ((T_BTP_PCA_EVENT*)data)->pca_call_status;
bt_signal(BT_PCA_GW_CALL_MONITORING, pca_call_mon);
return TRUE;
}
if (((T_BTP_PCA_EVENT*)data)->pca_event == BTI_PCA_GW_HANGUP_CFM)
{
MALLOC(pca_hangup, sizeof(T_MFW_BT_PCA_GW_HANGUP_CFM));
pca_hangup->hangup = ((T_BTP_PCA_EVENT*)data)->pca_hangup;
bt_signal(BT_PCA_GW_HANGUP_CFM, pca_hangup);
return TRUE;
}
/* Cartman added begin */
case BTP_HSG_HEADSET_CONNECTION_IND:
MALLOC(hsg_headset_connection_ind, sizeof(T_MFW_BT_HSG_HEADSET_CONNECTION_IND));
memset(hsg_headset_connection_ind, 0, sizeof(T_MFW_BT_HSG_HEADSET_CONNECTION_IND));
hsg_headset_connection_ind->service = ((T_BTP_HSG_HEADSET_CONNECTION_IND *)data)->device;
hsg_headset_connection_ind->ind_id = ((T_BTP_HSG_HEADSET_CONNECTION_IND *)data)->ind_id;
memcpy(hsg_headset_connection_ind->bd_addr, ((T_BTP_HSG_HEADSET_CONNECTION_IND *)data)->bd_addr, MFW_BT_ADDR_MAX_LEN);
bt_signal(BT_HSG_HEADSET_CONNECTION_IND, hsg_headset_connection_ind);
return TRUE;
case BTP_HSG_SPECIFIC_CMD_RDY:
MALLOC(hsg_specific_cmd_cfm, sizeof(T_MFW_BT_HSG_SPECIFIC_CMD_CFM));
memcpy(hsg_specific_cmd_cfm->cmd,((T_BTP_HSG_SPECIFIC_CMD_RDY *)data)->cmd,100);
bt_signal(BT_HSG_SPECIFIC_CMD_CFM,hsg_specific_cmd_cfm);
return TRUE;
case BTP_HSG_SAVE_LIST_CNF:
MALLOC(hsg_save_list_cnf, sizeof(T_MFW_BT_HSG_SAVE_LIST_CNF));
hsg_save_list_cnf->result=((T_BTP_HSG_SAVE_LIST_CNF *)data)->result;
bt_signal(BT_HSG_SAVE_LIST_CNF,hsg_save_list_cnf);
return TRUE;
/* Cartman added end */
/*#endif*/ /* PCA_6350 */
}
#ifdef _SIMULATION_
/*
* kk 12.01.01
* these primitives are available only for testing. they describe
* function calls (loopbacked to ACI/MFW) made from MFW
*/
switch ((USHORT) opc)
{
case BTP_INIT_PROFILE_REQ:
TRACE_EVENT("bta_response_cb:BTP_INIT_PROFILE_REQ");
return TRUE;
case BTP_DEINIT_PROFILE_REQ:
TRACE_EVENT("bta_response_cb:BTP_DEINIT_PROFILE_REQ");
return TRUE;
case BTP_DEVICE_SEARCH_REQ:
TRACE_EVENT("bta_response_cb:BTP_DEVICE_SEARCH_REQ");
return TRUE;
case BTP_CONNECT_DEVICE_REQ:
TRACE_EVENT("bta_response_cb:BTP_CONNECT_DEVICE_REQ");
return TRUE;
case BTP_CONNECT_DEVICE_RES:
TRACE_EVENT("bta_response_cb:BTP_CONNECT_DEVICE_RES");
return TRUE;
case BTP_DISCONNECT_DEVICE_REQ:
TRACE_EVENT("bta_response_cb:BTP_DISCONNECT_DEVICE_REQ");
return TRUE;
case BTP_TRANSFER_AUDIO_IN_REQ:
TRACE_EVENT("bta_response_cb:BTP_TRANSFER_AUDIO_IN_REQ");
return TRUE;
case BTP_TRANSFER_AUDIO_OUT_REQ:
TRACE_EVENT("bta_response_cb:BTP_TRANSFER_AUDIO_OUT_REQ");
return TRUE;
case BTP_RECONFIG_PROFILE_REQ:
TRACE_EVENT("bta_response_cb:BTP_RECONFIG_PROFILE_REQ");
return TRUE;
case BTI_SEND_DATA_TEST:
TRACE_EVENT("BTI_SEND_DATA_TEST");
{
UBYTE buf[2048];
memset(buf, 0, 2048);
memcpy(buf, ((T_BTI_SEND_DATA_TEST *)data)->ind_data, ((T_BTI_SEND_DATA_TEST *)data)->len);
bti_simulate_dti_data_ind(((T_BTI_SEND_DATA_TEST *)data)->port_nb, ((T_BTI_SEND_DATA_TEST *)data)->len, buf);
}
return TRUE;
case BTI_GET_DATA_TEST:
TRACE_EVENT("BTI_GET_DATA_TEST");
{
UBYTE buf[2048];
memset(buf, 0, 2048);
memcpy(buf, ((T_BTI_GET_DATA_TEST *)data)->ind_data, ((T_BTI_GET_DATA_TEST *)data)->len);
bti_simulate_data_bt_to_gsm(((T_BTI_GET_DATA_TEST *)data)->port_nb, ((T_BTI_GET_DATA_TEST *)data)->len, buf);
}
return TRUE;
/* for test bluetooth without BMI/MMI ******************************************/
case BTP_SRV_SYNC_TEST:/* test SYNC profile */
TRACE_EVENT("bta_response_cb:BTP_SRV_SYNC_TEST");
switch(((T_BTP_SRV_SYNC_TEST *)data)->func_id)
{
case 1:/* start bluetooth primitive SYN_SERVER_SYNC_COMPLETE */
bti_syn_server_sync_compl();
break;
case 2: /* start bluetooth function syn_server_sync_termination() */
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
if(bt_syn_s_sync_terminate(service, subtyp) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:sync termination Failure");
}
else
TRACE_EVENT("sync termination ok");
break;
case 3: /* start bluetooth function syn_server_get_response() */
memset(&syn_pull_obj, 0, sizeof(syn_pull_obj));
memset(&server_syn_object, 0, MFW_BT_OPP_BUFFER_LENGTH);
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
syn_pull_obj.mfw_buffer_start = server_syn_object;
syn_pull_obj.mfw_buffer_size = sizeof(&server_syn_object);
syn_pull_obj.mfw_object_type = MFW_BT_BUFFER;/* store pulled object in buffer */
syn_pull_obj.mfw_path = NULL;
syn_pull_obj.mfw_object_length = sizeof(&server_syn_object);
syn_pull_obj.mfw_object_mime_type = NULL;/* MIME directory information only for object_type: MFW_BT_PATH */
if(bt_syn_s_pull_resp(service, subtyp, syn_pull_obj) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:sync pull response Failure");
}
else
TRACE_EVENT("sync pull response ok");
break;
case 4:/* start bluetooth primitive SYN_SERVER_PUT_REQUEST with TRACE_EVENT in mfw_bta */
bti_sync_put_req();
break;
case 5:/* start bluetooth primitive SYN_SERVER_PUT_CFM with TRACE_EVENT in mfw_bta */
bti_syn_server_put_confirm();
break;
case 6:/* start bluetooth primitive SYN_SERVER_GET_REQUEST with TRACE_EVENT in mfw_bta */
bti_sync_get_req();
break;
case 7:/* start bluetooth primitive SYN_SERVER_AUTHENTICATION_REQUEST with TRACE_EVENT in mfw_bta */
bti_sync_auth_req();
break;
case 8:/* start bluetooth primitive SYN_SERVER_CLIENT_IS_CONNECTED with TRACE_EVENT in mfw_bta */
bti_sync_client_con_ind();
break;
case 9: /* start bluetooth function syn_server_put_response() */
memset(&syn_push_obj, 0, sizeof(syn_push_obj));
memset(&server_syn_object, 0, MFW_BT_OPP_BUFFER_LENGTH);
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
syn_push_obj.mfw_buffer_start = server_syn_object;
syn_push_obj.mfw_buffer_size = sizeof(&server_syn_object);
syn_push_obj.mfw_object_type = MFW_BT_BUFFER;/* store pushed object in buffer */
syn_push_obj.mfw_path = NULL;
syn_push_obj.mfw_object_length = sizeof(&server_syn_object);
syn_push_obj.mfw_object_mime_type = NULL;/* MIME directory information only for object_type: MFW_BT_PATH */
if(bt_syn_s_push_resp(service, subtyp, syn_push_obj) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync push response Failure");
}
else
TRACE_EVENT("sync push response ok");
break;
case 10: /* start bluetooth function syn_server_authentication_response() */
memset(mfw_sync_password, 0, MFW_BT_PIN_MAX_LEN);
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
for(j=0;j<10;j++)
mfw_sync_password[j] = j | 0x30;
mfw_sync_password_ptr = &mfw_sync_password[0];
if(bt_syn_s_auth_res(service, subtyp, mfw_sync_password_ptr) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:sync authentication response Failure");
}
else
TRACE_EVENT("sync authentication response ok");
break;
case 11: /* start bluetooth function syn_server_send_sync_command() */
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
mfw_obj = mfw_test_syn_obj;/* object which will be supposed to be synchronized */
mfw_syn_action = MFW_BT_SYNC_CO_SYNC; /* request synchronization by specified SYNC client */
/* specified client address by browsing SYNC Server with SYNC command support */
memset(&client_address, 0xdd, MFW_BT_ADDR_MAX_LEN);/* example */
if(bt_syn_s_send_com(service, subtyp, mfw_syn_action, mfw_obj, client_address) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync server send command Failure");
}
else
TRACE_EVENT("sync server send command ok");
break;
case 12: /* start bluetooth function syn_server_enable() */
/* receive bluetooth primitive BTP_INIT_PROFILE_CNF in BTI */
memset(&syn_serv_config, 0, sizeof(syn_serv_config));
service = MFW_BT_SYNC;
mfw_obj_list.object_store = mfw_test_syn_obj;
mfw_obj_list.next_object = NULL;
mfw_obj_list_ptr = &mfw_obj_list;
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
/* default value SYNC server mode */
syn_serv_config.mfw_syn_srv_mode = MFW_BT_SYNC_GEN_MODE;
/* default value SYNC server authentication mode */
syn_serv_config.mfw_syn_srv_auth_mode = MFW_BT_SYNC_INIT_AUTH_MODE;
if(bt_init_profile_syn_s(service, subtyp, mfw_obj_list_ptr, syn_serv_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync server enable Failure");
}
else
TRACE_EVENT("sync server enable ok");
break;
case 13: /* start bluetooth SYNC server application function rvm_start_application() and syn_server_enable() */
/* receive bluetooth primitive SYN_SERVER_CFM in BTI */
service = MFW_BT_SYNC;
if(bt_start_profile_application((T_BTI_DEVICE_TYPE)service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:sync server start and enable Failure");
}
else
TRACE_EVENT("sync server start and enable ok");
break;
case 14: /* start bluetooth function syn_server_disable() */
/* receive bluetooth primitive SYN_SERVER_CFM in BTI */
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync server disable Failure");
}
else
TRACE_EVENT("sync server disable ok");
break;
case 15: /* start bluetooth function syn_server_enable() */
/* receive bluetooth primitive SYN_SERVER_CFM in BTI */
memset(&syn_serv_config, 0, sizeof(syn_serv_config));
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
mfw_obj_list.object_store = mfw_test_syn_obj;
mfw_obj_list1.object_store = mfw_test_syn_obj;
mfw_obj_list_ptr1 = &mfw_obj_list1;
mfw_obj_list.next_object = mfw_obj_list_ptr1;
mfw_obj_list1.next_object = NULL;
mfw_obj_list_ptr = &mfw_obj_list;
syn_serv_config.mfw_syn_srv_mode = MFW_BT_SYNC_INIT_MODE;/* change in test is not possible that means it is not changed in call back func */
syn_serv_config.mfw_syn_srv_auth_mode = MFW_BT_SYNC_NO_INIT_AUTH_MODE;/* change in test is not possible that means it is not changed in call back func */
if(bt_reconf_profile_syn_s(service, subtyp, mfw_obj_list_ptr1, syn_serv_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync server reconfiguration Failure");
}
else
TRACE_EVENT("sync server reconfiguration ok");
break;
case 16: /* start bluetooth SYNC server application function syn_server_disable() and rvm_stop_application()*/
service = MFW_BT_SYNC;
subtyp = MFW_BT_SERVER;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync server disable and stop application Failure");
}
else
TRACE_EVENT("sync server disable and stop application ok");
break;
case 17: /* start bluetooth function bmi_service_browse() for sync client with SYNC command support*/
service = MFW_BT_SYNC_CMD;
if(bt_service_search(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:sync search sync client Failure");
}
else
TRACE_EVENT("sync search sync client ok");
break;
case 18: /* start mfw function bt_clear_list_found_serv() of found sync */
service = MFW_BT_SYNC_CMD;
if(bt_clear_list_found_serv(service) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:sync list del Failure");
}
else
TRACE_EVENT("sync list del ok");
break;
}
return TRUE;
case BTP_SRV_OPP_TEST:/* test OPP profile, server */
TRACE_EVENT("bta_response_cb:BTP_SRV_OPP_TEST");
switch(((T_BTP_SRV_OPP_TEST *)data)->func_id)
{
case 1: /* start bluetooth OPP server and client application function
rvm_start_application() and opp_server_enable() and opp_client_enable() */
/* receive bluetooth primitive OPP_SERVER_CFM/OPP_CLIENT_CFM in BTI*/
service = MFW_BT_OPP;
if(bt_start_profile_application((T_BTI_DEVICE_TYPE)service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:opp client + server start and enable Failure");
}
else
TRACE_EVENT("opp client + server start and enable ok");
break;
case 2: /* start bluetooth OPP server application function opp_server_enable()*/
/* receive bluetooth primitive OPP_SERVER_CFM in BTI */
/* initialize opp server */
memset(&serv_config, 0, sizeof(serv_config));
subtyp = MFW_BT_SERVER;
service = MFW_BT_OPP;
/* example for default business card;mfw_path and mime_type parameters are NULL because
mode MFW_BT_OPP_BUFFER_MODE */
serv_config.mfw_opp_mode = MFW_BT_OPP_BUFFER_MODE;/* OPP server mode */
serv_config.mfw_inbox_path = NULL;/* not use file system currently */
serv_config.mfw_opp_object.mfw_object_type = MFW_BT_BUFFER;/* server_business_card in buffer */
serv_config.mfw_opp_object.mfw_buffer_start = server_business_card;
serv_config.mfw_opp_object.mfw_buffer_size = sizeof(&server_business_card);
serv_config.mfw_opp_object.mfw_object_name = server_default_name;
serv_config.mfw_opp_object.mfw_object_length = sizeof(server_business_card);
serv_config.mfw_opp_object.mfw_path = NULL;
serv_config.mfw_opp_object.mfw_object_mime_type = NULL;/* MIME directory information only for object_type: MFW_BT_PATH */
if(bt_init_profile_opp(service, subtyp, serv_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp server initialize Failure");
}
else
TRACE_EVENT("opp server initialize ok");
break;
case 3: /* start bluetooth function opp_server_disable() */
/* receive bluetooth primitive OPP_SERVER_CFM in BTI */
subtyp = MFW_BT_SERVER;
service = MFW_BT_OPP;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp server disable Failure");
}
else
TRACE_EVENT("opp server disable ok");
break;
case 4: /* start bluetooth OPP server application function opp_server_enable()*/
/* receive bluetooth primitive OPP_SERVER_CFM in BTI */
/* reconfigure opp server */
memset(&serv_config, 0, sizeof(serv_config));
subtyp = MFW_BT_SERVER;
service = MFW_BT_OPP;
/* example for default business card;mfw_path and mime_type parameters are NULL because
mode MFW_BT_OPP_BUFFER_MODE */
serv_config.mfw_opp_mode = MFW_BT_OPP_BUFFER_MODE;/* OPP server mode */
serv_config.mfw_inbox_path = NULL;/* not use file system currently */
serv_config.mfw_opp_object.mfw_object_type = MFW_BT_BUFFER;/* bmi_server_business_card in buffer */
serv_config.mfw_opp_object.mfw_buffer_start = server_business_card;
serv_config.mfw_opp_object.mfw_buffer_size = sizeof(&server_business_card);
serv_config.mfw_opp_object.mfw_object_name = server_default_name;
serv_config.mfw_opp_object.mfw_path = NULL;
serv_config.mfw_opp_object.mfw_object_mime_type = NULL;/* MIME directory information only for object_type: MFW_BT_PATH */
serv_config.mfw_opp_object.mfw_object_length = sizeof(server_business_card);
if(bt_reconf_profile_opp(service, subtyp, serv_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp server reconfigure Failure");
}
else
TRACE_EVENT("opp server reconfigure ok");
break;
case 5: /* start bluetooth OPP server application function opp_server_disable() and rvm_stop_application()*/
service = MFW_BT_OPP;
subtyp = MFW_BT_SERVER;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp server disable and stop application Failure");
}
else
TRACE_EVENT("opp server disable and stop application ok");
break;
case 6: /* start bluetooth OPP server application function opp_server_put_response()*/
/* reply to OPP_SERVER_PUT_REQUEST of remote opp client(about server)*/
service = MFW_BT_OPP;
subtyp = MFW_BT_SERVER;
memset(&receiv_obj, 0, sizeof(receiv_obj));
opp_put_res = MFW_BT_OPP_CONTINUE;/* positive response */
receiv_obj.mfw_object_type = MFW_BT_BUFFER;
/* requested location for store of objects*/
receiv_obj.mfw_buffer_start = server_buffer;
/* with respect to object length delivered in BTP_OPP_SERV_PUT_IND;it can be bigger or smaller (loss data) - MMI decision */
receiv_obj.mfw_buffer_size = sizeof(&server_buffer);
receiv_obj.mfw_path = NULL;
/* with respect to delivered object name in BTP_OPP_SERV_PUT_IND */
receiv_obj.mfw_object_name = mfw_test_opp_obj_name;
/* with respect to delivered object length in BTP_OPP_SERV_PUT_IND */
receiv_obj.mfw_object_length = sizeof(&server_buffer);
if(bt_opp_put_reply(service, subtyp, opp_put_res, receiv_obj) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:opp response to put request Failure");
}
else
TRACE_EVENT("opp response to put request ok");
break;
case 7: /* start bluetooth primitive OPP_SERVER_PUT_REQUEST with TRACE_EVENT in mfw_bta */
bti_opp_s_put_req();
break;
case 8: /* start bluetooth primitive OPP_SERVER_PUT_CFM with TRACE_EVENT in mfw_bta */
bti_opp_server_put_cnf();
break;
}
return TRUE;
case BTP_CL_OPP_TEST:/* test OPP profile, client */
TRACE_EVENT("bta_response_cb:BTP_CL_OPP_TEST");
switch(((T_BTP_CL_OPP_TEST *)data)->func_id)
{
case 1: /* start bluetooth OPP client application function opp_client_enable()*/
/* receive bluetooth primitive OPP_CLIENT_CFM in BTI */
/* initialize opp client */
memset(&serv_config, 0, sizeof(serv_config));
subtyp = MFW_BT_CLIENT;
service = MFW_BT_OPP;
if(bt_init_profile_opp(service, subtyp, serv_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp client initialize Failure");
}
else
TRACE_EVENT("opp client initialize ok");
break;
case 2: /* start bluetooth function opp_client_disable() */
/* receive bluetooth primitive OPP_CLIENT_CFM in BTI */
subtyp = MFW_BT_CLIENT;
service = MFW_BT_OPP;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp client disable Failure");
}
else
TRACE_EVENT("opp client disable ok");
break;
case 3: /* start bluetooth function bmi_service_browse() for OPP server
because only servers are registered in data base and clients
has to look for remote OPP server */
service = MFW_BT_OPP;
if(bt_service_search(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp search Failure");
}
else
TRACE_EVENT("opp search client ok");
break;
case 4: /* start mfw function bt_clear_list_found_serv() of found opp */
service = MFW_BT_OPP;
if(bt_clear_list_found_serv(service) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:opp list del Failure");
}
else
TRACE_EVENT("opp list del ok");
break;
case 5: /* start bluetooth OPP client application function opp_client_disable() and rvm_stop_application()*/
service = MFW_BT_OPP;
subtyp = MFW_BT_CLIENT;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp client disable and stop application Failure");
}
else
TRACE_EVENT("opp client disable and stop application ok");
break;
case 6: /* start bluetooth OPP client application function opp_push_object() */
/* push object to a specific server */
memset(&opp_push_obj, 0, sizeof(opp_push_obj));
service = MFW_BT_OPP;
subtyp = MFW_BT_CLIENT;
memset(&server_address, 0xaa, MFW_BT_ADDR_MAX_LEN);/* OPP address with help of browsing procedure */
mfw_keep_connection_opp = FALSE; /* first block is also last block */
/* mfw_keep_connection_opp = TRUE; further blocks will follow */
opp_push_obj.mfw_buffer_start = client_buffer;/* content: client object which is desired to push */
opp_push_obj.mfw_buffer_size = sizeof(&client_buffer);
opp_push_obj.mfw_object_type = MFW_BT_BUFFER;
opp_push_obj.mfw_path = NULL;
opp_push_obj.mfw_object_name = client_obj_name;
opp_push_obj.mfw_object_length = sizeof(&client_buffer);
opp_push_obj.mfw_object_mime_type = NULL;/* MMI must know the mime_type of pushed object */
if(bt_opp_push_object(service, subtyp, server_address, mfw_keep_connection_opp, opp_push_obj) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp client pushs an object Failure");
}
else
TRACE_EVENT("opp client pushs an object ok");
break;
case 7: /* start bluetooth primitive OPP_OBJECT_PUSH_CFM with TRACE_EVENT in mfw_bta */
bti_opp_client_push_cnf();
break;
case 8: /* start bluetooth OPP client application function opp_pull_object() */
/* pull object from a specific server */
memset(&opp_pull_obj, 0, sizeof(opp_pull_obj));
service = MFW_BT_OPP;
subtyp = MFW_BT_CLIENT;
memset(&server_address, 0xaa, MFW_BT_ADDR_MAX_LEN);
/* the specific server address can received
with help of function bt_service_search(service) and BT_SERVICE_SEARCH_CNF */
mfw_keep_connection_opp = FALSE; /* first block is also last block */
/* mfw_keep_connection_opp = TRUE; further pull procedures will follow; MMI decision */
opp_pull_obj.mfw_buffer_start = server_business_card;
opp_pull_obj.mfw_buffer_size = sizeof(&server_business_card);
opp_pull_obj.mfw_object_type = MFW_BT_BUFFER;/* store pulled object in buffer */
opp_pull_obj.mfw_path = NULL;
opp_pull_obj.mfw_object_length = sizeof(&server_business_card);
opp_pull_obj.mfw_object_mime_type = NULL;/* MMI must know the mime_type of pulled object; it is only a test value */
if(bt_opp_pull_object(service, subtyp, server_address, mfw_keep_connection_opp, opp_pull_obj) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp client pulls an object Failure");
}
else
TRACE_EVENT("opp client pulls an object ok");
break;
case 9: /* start bluetooth primitive OPP_OBJECT_PULL_CFM with TRACE_EVENT in mfw_bta */
bti_opp_client_pull_cnf();
break;
case 10: /* start bluetooth OPP client application function opp_exchange_card() */
/* push an object to a specific server and pull object from a specific server */
memset(&opp_push_obj, 0, sizeof(opp_push_obj));
memset(&opp_pull_obj, 0, sizeof(opp_pull_obj));
service = MFW_BT_OPP;
subtyp = MFW_BT_CLIENT;
memset(&server_address, 0xaa, MFW_BT_ADDR_MAX_LEN);
/* the specific server address can received
with help of function bt_service_search(service) and BT_SERVICE_SEARCH_CNF */
mfw_keep_connection_opp = FALSE; /* first block is also last block */
/* mfw_keep_connection_opp = TRUE; further blocks will follow */
opp_push_obj.mfw_buffer_start = client_business_card;
opp_push_obj.mfw_buffer_size = sizeof(&client_business_card);
opp_push_obj.mfw_object_type = MFW_BT_BUFFER;
opp_push_obj.mfw_path = NULL;
opp_push_obj.mfw_object_name = client_obj_name;
opp_push_obj.mfw_object_length = sizeof(&client_buffer);
opp_push_obj.mfw_object_mime_type = NULL;
opp_pull_obj.mfw_buffer_start = server_business_card;
opp_pull_obj.mfw_buffer_size = sizeof(&server_business_card);
opp_pull_obj.mfw_object_type = MFW_BT_BUFFER;
opp_pull_obj.mfw_path = NULL;
opp_pull_obj.mfw_object_length = sizeof(&server_business_card);
opp_pull_obj.mfw_object_mime_type = NULL;
if(bt_opp_exch_objects(service, subtyp, opp_push_obj, opp_pull_obj, server_address, mfw_keep_connection_opp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:opp client and server exchange object Failure");
}
else
TRACE_EVENT("opp client and server exchange an object ok");
break;
}
return TRUE;
case BTP_CL_HSG_TEST:/* test HSG profile, client and common hsg features */
TRACE_EVENT("bta_response_cb:BTP_CL_HSG_TEST");
switch(((T_BTP_CL_HSG_TEST *)data)->func_id)
{
case 1: /* start bluetooth HSG server and client application function rvm_start_application()
and hsg_client_enable() and hsg_server_enable() */
/* receive bluetooth primitive HSG_CLIENT_ENABLE_CFM/HSG_SERVER_ENABLE_CFM in BTI */
service = MFW_BT_HEADSET;
if(bt_start_profile_application((T_BTI_DEVICE_TYPE)service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:hsg client + server start and enable Failure");
}
else
TRACE_EVENT("hsg client + server start and enable ok");
break;
case 2: /* start bluetooth HSG client application function hsg_client_enable()*/
/* receive bluetooth primitive HSG_CLIENT_ENABLE_CFM in BTI */
/* initialize headset client */
memset(&client_config, 0, sizeof(client_config));
service = MFW_BT_HEADSET;
client_config.config_mode = MFW_BT_AUTO_OUTG_DEF_CONN_ON;
if(bt_init_profile_hsg_cl(service, client_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg client initialize Failure");
}
else
TRACE_EVENT("hsg client initialize ok");
break;
case 3: /* start bluetooth HSG client application function hsg_client_enable()*/
/* receive bluetooth primitive HSG_CLIENT_ENABLE_CFM in BTI */
/* reconfigure headset client */
memset(&client_config, 0, sizeof(client_config));
service = MFW_BT_HEADSET;
client_config.config_mode = MFW_BT_AUTO_OUTG_DEF_CONN_OFF;
if(bt_reconfig_profile_hsg_cl(service, client_config) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg client reconfigure Failure");
}
else
TRACE_EVENT("hsg client reconfigure ok");
break;
case 4: /* start bluetooth HSG client application function hsg_get_configs()*/
/* get state of connection mode for headset client */
memset(&client_config, 0, sizeof(client_config));
service = MFW_BT_HEADSET;
if(bt_get_auto_connect(service, &client_config) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:hsg client connection mode Failure");
}
else
{
TRACE_EVENT_P1("connect mode = %d", client_config.config_mode);
}
break;
case 5: /* start bluetooth HSG client application function hsg_get_configs()*/
/* get headset client and server configuration */
memset(&server_conf, 0, sizeof(server_conf));
memset(&client_config, 0, sizeof(client_config));
service = MFW_BT_HEADSET;
if(bt_get_config(service, &client_config, &server_conf) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:hsg client and server configuration failure");
}
else
{
TRACE_EVENT_P1("client connect mode = %d", client_config.config_mode);
TRACE_EVENT_P1("server number phone list = %d", server_conf.nb_phone);
}
break;
case 6: /* start bluetooth HSG client application function hsg_client_enable()*/
/* set state of connection mode for headset client */
service = MFW_BT_HEADSET;
if(bt_auto_connect(service, MFW_BT_AUTO_CONNECT_ON) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:hsg client set connection mode failure");
}
else
TRACE_EVENT("hsg client set connection mode ok");
break;
case 7: /* start bluetooth function hsg_client_disable() */
/* receive bluetooth primitive HSG_CLIENT_ENABLE_CFM in BTI */
service = MFW_BT_HEADSET;
subtyp = MFW_BT_CLIENT;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg client disable Failure");
}
else
TRACE_EVENT("hsg client disable ok");
break;
case 8: /* start bluetooth HSG client application function hsg_client_disable() and rvm_stop_application()*/
service = MFW_BT_HEADSET;
subtyp = MFW_BT_CLIENT;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg client disable and stop application Failure");
}
else
TRACE_EVENT("hsg client disable and stop application ok");
break;
case 9: /* start bluetooth HSG client application function hsg_out_connection_transfer()*/
service = MFW_BT_HEADSET;
for(j =0;j<MFW_BT_ADDR_MAX_LEN;j++)
hsg_address[j] = 0xbb;
headset_id = MFW_BT_INVALID_HEADSET_ID;
if(bt_transfer_audio_out(service, headset_id, hsg_address) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:transfer audio out Failure");
}
else
TRACE_EVENT("transfer audio out ok");
break;
case 10: /* start bluetooth HSG client application function hsg_in_connection_transfer()*/
service = MFW_BT_HEADSET;
if(bt_transfer_audio_in(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:transfer audio in Failure");
}
else
TRACE_EVENT("transfer audio in ok");
break;
case 11: /* start bluetooth HSG client application function hsg_save_config()*/
/* not supported TI 5.3.0 BT */
service = MFW_BT_HEADSET;
if(bt_save_config(service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:save hsg config Failure");
}
else
TRACE_EVENT("save hsg config ok");
break;
case 12: /* start bluetooth HSG client application function hsg_restore_config()*/
/* not supported TI 5.3.0 BT */
service = MFW_BT_HEADSET;
if(bt_restore_config(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:restore hsg config Failure");
}
else
TRACE_EVENT("restore hsg config ok");
break;
case 13: /* start bluetooth HSG client application function hsg_save_default_list()*/
/* save in non-volatile memory, not supported TI 5.3.0 BT */
service = MFW_BT_HEADSET;
if(bt_save_default_list(service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:save hsg def list Failure");
}
else
TRACE_EVENT("save hsg def list ok");
break;
case 14: /* start bluetooth HSG client application function hsg_restore_default_list()*/
/* save in non-volatile memory, not supported TI 5.3.0 BT */
service = MFW_BT_HEADSET;
if( bt_restore_default_list(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:restore hsg def list Failure");
}
else
TRACE_EVENT("restore hsg def list ok");
break;
case 15: /* start bluetooth primitive HSG_DEVICE_CONNECTION_IND */
bti_conn_ind_hsg();
break;
case 16: /* start bluetooth primitive HSG_HEADSET_CONNECTION_CLOSED */
bti_hsg_disconnect();
break;
case 17: /* start bluetooth primitive HSG_CONNECTION_FAILED */
bti_hsg_connect_failed();
break;
case 18: /* start bluetooth primitive HSG_GSM_CONNECTION_IND */
bti_hsg_gsm_connect_ind();
break;
}
return TRUE;
case BTP_SRV_HSG_TEST:/* test HSG profile, server and common hsg functions */
TRACE_EVENT("bta_response_cb:BTP_SRV_HSG_TEST");
switch(((T_BTP_SRV_HSG_TEST *)data)->func_id)
{
case 1: /* start bluetooth HSG server application function hsg_server_enable()*/
/* receive bluetooth primitive HSG_SERVER_ENABLE_CFM in BTI */
/* initialize headset server */
memset(&server_conf, 0, sizeof(server_conf));
memset(test_mfw_key_list, 0, sizeof(test_mfw_key_list));
test_mfw_key_list[0] = 0xFE; /* f.e.KEY_F1 */
memset(test_mfw_phone_list, 0, sizeof(test_mfw_phone_list));
for(j=0;j<4;j++)
test_mfw_phone_list[1][j] = j | 0x30;
service = MFW_BT_HEADSET;
server_conf.serv_con_conf = 0; /* TI not used */
server_conf.conn_break = MFW_BT_CONN_SCAN_BREAK_DEFAULT_VALUE;
server_conf.conn_time = MFW_BT_CONN_SCAN_TIME_DEFAULT_VALUE;
server_conf.nb_phone = 1;/* currently only one number from remote headset is supported */
memcpy(server_conf.mfw_phone_list, test_mfw_phone_list, sizeof(test_mfw_phone_list));
memcpy(server_conf.mfw_key_list, test_mfw_key_list, sizeof(test_mfw_key_list));
if(bt_init_profile_hsg_serv(service, server_conf) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg server initialize Failure");
}
else
TRACE_EVENT("hsg server initialize ok");
break;
case 2: /* start bluetooth HSG server application function hsg_server_enable()*/
/* receive bluetooth primitive HSG_SERVER_ENABLE_CFM in BTI */
/* reconfigure headset server */
memset(&server_conf, 0, sizeof(server_conf));
memset(test_mfw_key_list, 0, sizeof(test_mfw_key_list));
test_mfw_key_list[0] = 0xFE; /* f.e. KEY_F1 */
memset(test_mfw_phone_list, 0, sizeof(test_mfw_phone_list));
for(j=0;j<4;j++)
test_mfw_phone_list[1][j] = j | 0x30;
service = MFW_BT_HEADSET;
server_conf.serv_con_conf = 0; /* TI not used */
server_conf.conn_break = MFW_BT_CONN_SCAN_BREAK_DEFAULT_VALUE;
server_conf.conn_time = MFW_BT_CONN_SCAN_TIME_DEFAULT_VALUE;
server_conf.nb_phone = 1;/* currently only one number from remote headset is supported */
memcpy(server_conf.mfw_phone_list, test_mfw_phone_list, sizeof(test_mfw_phone_list));
memcpy(server_conf.mfw_key_list, test_mfw_key_list, sizeof(test_mfw_key_list));
if(bt_reconfig_profile_hsg_serv(service, server_conf) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg server reconfigure Failure");
}
else
TRACE_EVENT("hsg server reconfigure ok");
break;
case 3: /* start bluetooth function hsg_server_disable() */
/* receive bluetooth primitive HSG_SERVER_ENABLE_CFM in BTI */
service = MFW_BT_HEADSET;
subtyp = MFW_BT_SERVER;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg server disable Failure");
}
else
TRACE_EVENT("hsg server disable ok");
break;
case 4: /* start bluetooth HSG client application function hsg_server_disable() and rvm_stop_application()*/
service = MFW_BT_HEADSET;
subtyp = MFW_BT_SERVER;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:hsg server disable and stop application Failure");
}
else
TRACE_EVENT("hsg server disable and stop application ok");
break;
case 5: /* start bluetooth HSG client application function hsg_add_default_headset()*/
memset(&hsg_name, 0, sizeof(hsg_name));
service = MFW_BT_HEADSET;
for(j =0;j<MFW_BT_ADDR_MAX_LEN;j++)
hsg_address[j] = 0xbb;/* address of new add headset */
strcpy(hsg_name, hsg_default_name);/* name of new add headset */
priority = 2;/* desired priority of new add headset in list */
rem_audio_ctr_supp_hsg = TRUE;/* headset supports remote audio control */
if(bt_set_pref_headset(service, hsg_address, hsg_name, priority, rem_audio_ctr_supp_hsg, &headset_cnf_id) NEQ MFW_BT_OK)
/* get id in default headset list */
{
TRACE_EVENT("mfw_bta:hsg add default headset Failure");
}
else
TRACE_EVENT_P1("add hsg: id = %d", headset_cnf_id);
break;
case 6: /* start bluetooth function bmi_service_browse() for headset */
service = MFW_BT_HEADSET;
if(bt_service_search(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:headset search Failure");
}
else
TRACE_EVENT("headset search ok");
break;
case 7: /* start bluetooth function hsg_remove_default_headset() */
headset_id = 1;
service = MFW_BT_HEADSET;
if(bt_reset_pref_hsg(service, headset_id) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:remove headset Failure");
}
else
TRACE_EVENT("remove headset ok");
break;
case 8: /* start bluetooth function hsg_get_default_headset_info() */
memset(&hs_info, 0, sizeof(hs_info));
headset_id = 3;
service = MFW_BT_HEADSET;
if(bt_get_default_service_info(service, headset_id, &hs_info) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:get headset info Failure");
}
else
TRACE_EVENT_P4("hsg info: %d %d %s %s", hs_info.priority, hs_info.mfw_remote_audio_control_support, hs_info.hsg_name, hs_info.bd_addr);
break;
case 9: /* start bluetooth function hsg_change_default_headset_info() */
service = MFW_BT_HEADSET;
headset_id = 3;
priority = 4;
if(bt_set_prio_default_service(service, headset_id, priority) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:change headset info Failure");
}
else
TRACE_EVENT("change headset info ok");
break;
case 10: /* start bluetooth function hsg_connect() */
service = MFW_BT_HEADSET;
for(j =0;j<MFW_BT_ADDR_MAX_LEN;j++)
hsg_address[j] = 0xbb;
headset_id = MFW_BT_INVALID_HEADSET_ID;
if(bt_connect_hsg(service, headset_id, hsg_address, 0) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:connect headset Failure");
}
else
TRACE_EVENT("connect headset ok");
break;
case 11: /* start bluetooth function hsg_disconnect() */
service = MFW_BT_HEADSET;
if(bt_disconnect_service(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:disconnect headset Failure");
}
else
TRACE_EVENT("disconnect headset ok");
break;
case 12: /* start bluetooth function hsg_update_params() */
service = MFW_BT_HEADSET;
nb = MFW_BT_SPEAKER_GAIN;/* MFW_BT_MIC_GAIN */
type = MFW_BT_PARA_INC; /* MFW_BT_PARA_SET */
new_value = 0;
if(bt_set_param_headset(service, nb, type, new_value) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set params headset Failure");
}
else
TRACE_EVENT("set params headset ok");
break;
case 13: /* start mfw function bt_clear_list_found_serv() of found hsg */
service = MFW_BT_HEADSET;
if(bt_clear_list_found_serv(service) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:hsg list del Failure");
}
else
TRACE_EVENT("hsg list del ok");
break;
case 14: /* start bluetooth primitive HSG_DEVICE_CONNECTION_PERFORMED */
bti_hsg_dev_connect_inf();
break;
case 15: /* start mfw function hsg_is_default_headset()*/
service = MFW_BT_HEADSET;
for(j =0;j<MFW_BT_ADDR_MAX_LEN;j++)
hsg_address[j] = 0xbb;
if(bt_is_pref_headset(service, hsg_address, &headset_cnf_id) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:hsg list del Failure");
}
else
{
if(headset_cnf_id EQ MFW_BT_INVALID_HEADSET_ID)
{
TRACE_EVENT("hsg not in default list");
}
else
{
TRACE_EVENT_P1("hsg id in default list:%d", headset_cnf_id);
}
}
break;
}
return TRUE;
case BTP_FAX_TEST:/* test FAX profile */
TRACE_EVENT("bta_response_cb:BTP_FAX_TEST");
switch(((T_BTP_FAX_TEST *)data)->func_id)
{
case 1:/*start bluetooth function fax_gw_config()*/
service = MFW_BT_FAX_GW;
fax_filter.link_event = MFW_BT_LINK_MONIT_ON;
fax_filter.call_event = MFW_BT_CALL_MONIT_ON;
if(bt_init_profile_fax(service, fax_filter) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:init fax Failure");
}
else
TRACE_EVENT("init fax ok");
break;
case 2: /* start bluetooth fax application function
rvm_start_application(), fax_gw_enable(), fax_gw_config() */
/* receive bluetooth primitive FAX_GW_STATUS_CFM in BTI */
service = MFW_BT_FAX_GW;
if(bt_start_profile_application((T_BTI_DEVICE_TYPE)service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:fax server start and enable Failure");
}
else
TRACE_EVENT("fax start and enable ok");
break;
case 3:/* start bluetooth function fax_gw_config()*/
service = MFW_BT_FAX_GW;
fax_filter.link_event = MFW_BT_LINK_MONIT_OFF;
fax_filter.call_event = MFW_BT_CALL_MONIT_OFF;
if(bt_reconfig_profile_fax(service, fax_filter) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:reconfig fax Failure");
}
else
TRACE_EVENT("reconfig fax ok");
break;
case 4: /* start bluetooth FAX application function fax_gw_disable() and rvm_stop_application()*/
service = MFW_BT_FAX_GW;
subtyp = MFW_BT_NO_SUBTYPE;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:fax disable and stop application Failure");
}
else
TRACE_EVENT("fax disable and stop application ok");
break;
case 5: /* start bluetooth function fax_gw_disable() */
service = MFW_BT_FAX_GW;
subtyp = MFW_BT_NO_SUBTYPE;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:deinit fax Failure");
}
else
TRACE_EVENT("deinit fax ok");
break;
case 6: /* start bluetooth function bmi_service_browse() for FAX */
service = MFW_BT_FAX_GW;
if(bt_service_search(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:search fax Failure");
}
else
TRACE_EVENT("search fax ok");
break;
case 7: /* start bluetooth function bmi_service_browse() for FAX and delete list of found fax*/
service = MFW_BT_FAX_GW;
if(bt_clear_list_found_serv(service) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:search/delete fax Failure");
}
else
TRACE_EVENT("search/delete fax ok");
break;
case 8: /* start bluetooth function fax_gw_hangup() */
service = MFW_BT_FAX_GW;
if(bt_disconnect_service(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:disconn req fax Failure");
}
else
TRACE_EVENT("disconn req fax ok");
break;
case 9: /* start bluetooth primitive FAX_GW_LINK_MONITORING:FAX_GW_CONNECTED */
bti_conn_ind_fax();
break;
case 10: /* start bluetooth primitive FAX_GW_LINK_MONITORING:FAX_GW_NOT_CONNECTED */
bti_fax_disconnect();
break;
case 11: /* start bluetooth primitive FAX_GW_CALL_MONITORING:FAX_GW_CALL_IN_PROGRESS */
bti_fax_call_mon();
break;
}
return TRUE;
case BTP_DUN_TEST:/* test DUN profile */
TRACE_EVENT("bta_response_cb:BTP_DUN_TEST");
switch(((T_BTP_DUN_TEST *)data)->func_id)
{
case 1: /* start bluetooth function dun_gw_config() */
service = MFW_BT_DIAL_UP;
dun_filter.link_event = MFW_BT_LINK_MONIT_ON;
dun_filter.call_event = MFW_BT_CALL_MONIT_ON;
if(bt_init_profile_dun(service, dun_filter) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:init dun Failure");
}
else
TRACE_EVENT("init dun ok");
break;
case 2: /* start bluetooth dial up application function
rvm_start_application(), dun_gw_enable(), dun_gw_config() */
/* receive bluetooth primitive DUN_GW_STATUS_CFM in BTI */
service = MFW_BT_DIAL_UP;
if(bt_start_profile_application((T_BTI_DEVICE_TYPE)service) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:dun server start and enable Failure");
}
else
TRACE_EVENT("dun start and enable ok");
break;
case 3: /* start bluetooth function dun_gw_config() */
service = MFW_BT_DIAL_UP;
dun_filter.link_event = MFW_BT_LINK_MONIT_ON;
dun_filter.call_event = MFW_BT_CALL_MONIT_ON;
if(bt_reconfig_profile_dun(service, dun_filter) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:reconf dun Failure");
}
else
TRACE_EVENT("reconf dun ok");
break;
case 4: /* start bluetooth function dun_gw_disable() */
service = MFW_BT_DIAL_UP;
subtyp = MFW_BT_NO_SUBTYPE;
if(bt_deinit_profile(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:deinit dun Failure");
}
else
TRACE_EVENT("deinit dun ok");
break;
case 5: /* start bluetooth DUN application function dun_gw_disable() and rvm_stop_application()*/
service = MFW_BT_DIAL_UP;
subtyp = MFW_BT_NO_SUBTYPE;
if(bt_stop_profile_application(service, subtyp) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:stop dun Failure");
}
else
TRACE_EVENT("stop dun ok");
break;
case 6: /* start bluetooth function bmi_service_browse() for DUN */
service = MFW_BT_DIAL_UP;
if(bt_service_search(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:search dun Failure");
}
else
TRACE_EVENT("search dun ok");
break;
case 7: /* start bluetooth function bmi_service_browse() for DUN and delete list of found dun*/
service = MFW_BT_DIAL_UP;
if(bt_clear_list_found_serv(service) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:search/delete dun Failure");
}
else
TRACE_EVENT("search/delete dun ok");
break;
case 8: /* start bluetooth function dun_gw_hangup() */
service = MFW_BT_DIAL_UP;
if(bt_disconnect_service(service) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:disconn req dun Failure");
}
else
TRACE_EVENT("disconn req dun ok");
break;
case 9: /* start bluetooth primitive DUN_GW_LINK_MONITORING:DUN_GW_NOT_CONNECTED */
bti_dun_disconnect();
break;
case 10: /* start bluetooth primitive DUN_GW_LINK_MONITORING:DUN_GW_CONNECTED */
bti_conn_ind_dun();
break;
case 11: /* start bluetooth primitive DUN_GW_CALL_MONITORING:DUN_GW_CALL_IN_PROGRESS ... */
bti_dun_call_mon();
break;
}
return TRUE;
case BTP_SEC_BROWS_TEST:/* test browsing and security bluetooth function */
TRACE_EVENT("bta_response_cb:BTP_SEC_BROWS_TEST");
switch(((T_BTP_SEC_BROWS_TEST *)data)->func_id)
{
case 1:/* register in security managment of bluetooth */
if(bt_register_sm() NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:SCM register Failure");
}
else
TRACE_EVENT("SCM register ok");
break;
case 2:/* set general security mode of bluetooth device with default value */
if(bt_set_security_mode(MFW_BT_SECURITY_MODE_2) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:SCM sec mode Failure");
}
else
TRACE_EVENT("SCM sec mode ok");
break;
case 3:/* set bluetooth device in pairable mode */
if(bt_set_pair_mode (MFW_BT_PAIRABLE) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:SCM pair mode Failure");
}
else
TRACE_EVENT("SCM pair mode ok");
break;
case 4:/* search bluetooth devices with their services */
if(bt_device_search() NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:search devices Failure");
}
else
TRACE_EVENT("search devices ok");
break;
case 5:/* terminate browsing procedure */
if(bt_search_abort() NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:search abort Failure");
}
else
TRACE_EVENT("search abort ok");
break;
case 6: /* start bluetooth primitive SCM_PIN_CODE_REQUEST */
bti_send_pin_request();
break;
case 7: /* start bluetooth function scm_pin_code_reply() */
memset(&hsg_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
memset(&pin_code, 0x35, MFW_BT_PIN_MAX_LEN);
pin_mode = PIN_PROVIDED;
result_bt = bt_send_pin(hsg_address, pin_code, pin_mode);
if(result_bt EQ MFW_BT_INVALID_PARA)
{
TRACE_EVENT("mfw_bta:Wrong Pin");
}
else if(result_bt NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:pin Failure");
}
else
TRACE_EVENT("pin ok");
break;
case 8: /* start bluetooth primitive SCM_DEVICE_PAIRED_RESULT */
bti_pin_code_cnf();
break;
case 9: /* start bluetooth function scm_get_next_authorized_device() for sync */
memset(&authorized_devices_list, 0, sizeof(authorized_devices_list));
auth_mask = MFW_SERVICE_SYNC_C;
if(bt_authorized_devices(&authorized_devices_list, auth_mask) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:auth list Failure");
}
else
TRACE_EVENT_P3("auth sync:%d %x %s", authorized_devices_list.count, authorized_devices_list.auth_devices[1].mask_authorization, authorized_devices_list.auth_devices[1].remote_bd_addr);
break;
case 10: /* start bluetooth function scm_get_next_authorized_device() for opp */
memset(&authorized_devices_list, 0, sizeof(authorized_devices_list));
auth_mask = MFW_SERVICE_OPP;
if(bt_authorized_devices(&authorized_devices_list, auth_mask) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:auth list Failure");
}
else
TRACE_EVENT_P3("auth opp:%d %x %s", authorized_devices_list.count, authorized_devices_list.auth_devices[1].mask_authorization, authorized_devices_list.auth_devices[1].remote_bd_addr);
break;
case 11: /* start bluetooth function scm_get_next_authorized_device() for fax */
memset(&authorized_devices_list, 0, sizeof(authorized_devices_list));
auth_mask = MFW_SERVICE_FAX;
if(bt_authorized_devices(&authorized_devices_list, auth_mask) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:auth list Failure");
}
else
TRACE_EVENT_P3("auth fax:%d %x %s", authorized_devices_list.count, authorized_devices_list.auth_devices[1].mask_authorization, authorized_devices_list.auth_devices[1].remote_bd_addr);
break;
case 12: /* start bluetooth function scm_get_next_authorized_device() for hsg */
memset(&authorized_devices_list, 0, sizeof(authorized_devices_list));
auth_mask = MFW_SERVICE_HSG;
if(bt_authorized_devices(&authorized_devices_list, auth_mask) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:auth list Failure");
}
else
TRACE_EVENT_P3("auth hsg:%d %x %s", authorized_devices_list.count, authorized_devices_list.auth_devices[1].mask_authorization, authorized_devices_list.auth_devices[1].remote_bd_addr);
break;
case 13: /* start bluetooth function scm_get_next_authorized_device() for dun */
memset(&authorized_devices_list, 0, sizeof(authorized_devices_list));
auth_mask = MFW_SERVICE_DUN;
if(bt_authorized_devices(&authorized_devices_list, auth_mask) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:auth list Failure");
}
else
TRACE_EVENT_P3("auth dun:%d %x %s", authorized_devices_list.count, authorized_devices_list.auth_devices[1].mask_authorization, authorized_devices_list.auth_devices[1].remote_bd_addr);
break;
case 14: /* start bluetooth function scm_get_next_authorized_device() for all existing services */
memset(&authorized_devices_list, 0, sizeof(authorized_devices_list));
if(bt_list_auth_dev(&authorized_devices_list) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:auth list Failure");
}
else
TRACE_EVENT_P1("auth list:%d", authorized_devices_list.count);
break;
case 15: /* start bluetooth function scm_set_device_authorization() for sync */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_SYNC_C;
if(bt_del_authorization(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:del auth Failure");
}
else
TRACE_EVENT("del auth ok");
break;
case 16: /* start bluetooth function scm_set_device_authorization() for dun */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_DUN;
if(bt_del_authorization(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:del auth Failure");
}
else
TRACE_EVENT("del auth ok");
break;
case 17: /* start bluetooth function scm_set_device_authorization() for fax */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_FAX;
if(bt_del_authorization(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:del auth Failure");
}
else
TRACE_EVENT("del auth ok");
break;
case 18: /* start bluetooth function scm_set_device_authorization() for opp */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_OPP;
if(bt_del_authorization(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:del auth Failure");
}
else
TRACE_EVENT("del auth ok");
break;
case 19: /* start bluetooth function scm_set_device_authorization() for hsg */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_HSG;
if(bt_del_authorization(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:del auth Failure");
}
else
TRACE_EVENT("del auth ok");
break;
case 20: /* start bluetooth function scm_set_device_authorization() for hsg */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
if(bt_del_authorizations_device(remote_address) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:del authorization device Failure");
}
else
TRACE_EVENT("del authorization device auth ok");
break;
case 21: /* start bluetooth function scm_set_security_mode() */
sec_mode = MFW_BT_SECURITY_MODE_3;
if(bt_set_security_mode(sec_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set common security level Failure");
}
else
TRACE_EVENT("set common security level ok");
break;
case 22: /* start bluetooth function scm_set_default_security_requirements() */
default_security = MFW_BT_INCOM_AUTHENTICATION | MFW_BT_INCOM_AUTHORIZATION |MFW_BT_OUTGO_ENCRYPTION;
if(bt_set_default_security(default_security) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set default security values Failure");
}
else
TRACE_EVENT("set default security values ok");
break;
case 23:/* deregister in security managment of bluetooth */
if(bt_deregister_sm() NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:SCM deregister Failure");
}
else
TRACE_EVENT("SCM deregister ok");
break;
}
return TRUE;
case BTP_OTHER_TEST:/* test common bluetooth function (lists) */
TRACE_EVENT("bta_response_cb:BTP_OTHER_TEST");
switch(((T_BTP_OTHER_TEST *)data)->func_id)
{
case 1:/* delete list of found bluetooth devices */
if(bt_clear_list_found_dev() NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:clear device list Failure");
}
else
TRACE_EVENT("clear device list ok");
break;
case 2:/* delete lists of found bluetooth services */
if(bt_clear_all_lists_found_serv() NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:clear service lists Failure");
}
else
TRACE_EVENT("clear service lists ok");
break;
case 3:/* start bluetooth function scm_set_pairable_mode() */
pair_mode = MFW_BT_PAIRABLE;
if(bt_set_pair_mode(pair_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set pair mode Failure");
}
else
TRACE_EVENT("set pair mode on ok");
break;
case 4:/* start bluetooth function scm_set_pairable_mode() */
pair_mode = MFW_BT_NON_PAIRABLE;
if(bt_set_pair_mode(pair_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set pair mode Failure");
}
else
TRACE_EVENT("set pair mode off ok");
break;
case 5:/* start bluetooth function scm_start_pairing() */
memset(&hsg_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
memset(&pin_code, 0x35, MFW_BT_PIN_MAX_LEN);
pin_mode = PIN_PROVIDED;
if(bt_start_pairing(hsg_address, pin_code, pin_mode) NEQ MFW_BT_EXECUTE)
{
TRACE_EVENT("mfw_bta:start pairing mode Failure");
}
else
TRACE_EVENT("start pairing ok");
break;
case 6: /* start bluetooth primitive SCM_DEVICE_PAIRED_RESULT */
bti_pairing_cnf();
break;
case 7:/* start bluetooth function scm_is_device_paired() */
memset(&hsg_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
if(bt_check_pair(hsg_address) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:check pairing Failure");
}
else
TRACE_EVENT("check pairing ok");
break;
case 8:/* start bluetooth function scm_get_next_paired_device() */
memset(&pairing_list, 0, sizeof(T_MFW_BT_DEV_PAIR_LIST));
if(bt_list_paired_dev(&pairing_list) NEQ MFW_BT_RET_OK)
{
TRACE_EVENT("mfw_bta:pairing list Failure");
}
else
TRACE_EVENT("pairing list ok");
break;
case 9:/* start bluetooth function scm_delete_paired_device() */
memset(&hsg_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
if(bt_delete_paired_device(hsg_address) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:delete paired device Failure");
}
else
TRACE_EVENT("delete paired devicet ok");
break;
case 10: /* start bluetooth primitive SCM_AUTHORIZATION_REQUEST for profile sync */
bti_send_sync_authorization_request();
break;
case 11: /* start bluetooth primitive SCM_AUTHORIZATION_REQUEST for profile hsg */
bti_send_hsg_authorization_request();
break;
case 12: /* start bluetooth primitive SCM_AUTHORIZATION_REQUEST for profile fsx */
bti_send_fax_authorization_request();
break;
case 13: /* start bluetooth primitive SCM_AUTHORIZATION_REQUEST for profile dun */
bti_send_dun_authorization_request();
break;
case 14: /* start bluetooth primitive SCM_AUTHORIZATION_REQUEST for profile opp */
bti_send_opp_authorization_request();
break;
case 15: /* start bluetooth function scm_authorization_reply() for sync */
auth_mode = MFW_BT_AUTHORIZED_ONCE;
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_SYNC_C;
if(bt_authorization_reply(remote_address, auth_mask, auth_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:auth reply sync Failure");
}
else
TRACE_EVENT("auth reply sync ok");
break;
case 16: /* start bluetooth function scm_authorization_reply() for hsg */
auth_mode = MFW_BT_AUTHORIZED_ONCE;
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_HSG;
if(bt_authorization_reply(remote_address, auth_mask, auth_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:auth reply hsg Failure");
}
else
TRACE_EVENT("auth reply hsg ok");
break;
case 17: /* start bluetooth function scm_authorization_reply() for dun */
auth_mode = MFW_BT_AUTHORIZED_ONCE;
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_DUN;
if(bt_authorization_reply(remote_address, auth_mask, auth_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:auth reply dun Failure");
}
else
TRACE_EVENT("auth reply dun ok");
break;
case 18: /* start bluetooth function scm_authorization_reply() for fax */
auth_mode = MFW_BT_AUTHORIZED_ONCE;
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_FAX;
if(bt_authorization_reply(remote_address, auth_mask, auth_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:auth reply fax Failure");
}
else
TRACE_EVENT("auth reply fax ok");
break;
case 19: /* start bluetooth function scm_authorization_reply() for opp */
auth_mode = MFW_BT_AUTHORIZED_ONCE;
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_OPP;
if(bt_authorization_reply(remote_address, auth_mask, auth_mode) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:auth reply opp Failure");
}
else
TRACE_EVENT("auth reply opp ok");
break;
case 20: /* start bluetooth function scm_get_device_authorization() */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
if(bt_get_authorization_device(remote_address, &auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:get device authorizations Failure");
}
else
{
TRACE_EVENT_P1("get authorizations:%x", auth_mask);
}
break;
case 21: /* start bluetooth function scm_set_device_authorization() for fax */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_FAX;
if(bt_set_authorization_device(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set device authorization Failure");
}
else
TRACE_EVENT("set authorization ok");
break;
case 22: /* start bluetooth function scm_set_device_authorization() for dun */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_DUN;
if(bt_set_authorization_device(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set device authorization Failure");
}
else
TRACE_EVENT("set authorization ok");
break;
case 23: /* start bluetooth function scm_set_device_authorization() for hsg */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_HSG;
if(bt_set_authorization_device(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set device authorization Failure");
}
else
TRACE_EVENT("set authorization ok");
break;
case 24: /* start bluetooth function scm_set_device_authorization() for opp */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_OPP;
if(bt_set_authorization_device(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set device authorization Failure");
}
else
TRACE_EVENT("set authorization ok");
break;
case 25: /* start bluetooth function scm_set_device_authorization() for sync */
memset(&remote_address, 0xcc, MFW_BT_ADDR_MAX_LEN);
auth_mask = MFW_SERVICE_SYNC_C;
if(bt_set_authorization_device(remote_address, auth_mask) NEQ MFW_BT_OK)
{
TRACE_EVENT("mfw_bta:set device authorization Failure");
}
else
TRACE_EVENT("set authorization ok");
break;
}
return TRUE;
/* end for test bluetooth without BMI/MMI ******************************************/
}
#endif
return FALSE; /* not processed by extension */
}