/*
+--------------------------------------------------------------------+
| PROJECT: MMI-Framework (8445)         $Workfile:: mfw_bt.c        $|
| $Author:: Rm                          $Revision::  1              $|
| CREATED: 03.01.01                     $Modtime:: 03.01.01 17:21   $|
| STATE  : code                                                      |
+--------------------------------------------------------------------+


   MODULE  : MFW_BT

   PURPOSE : This modul contains the functions for MFW-BT management.


*/
#define ENTITY_MFW

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "typedefs.h"
#include "vsi.h"
#include "pei.h"
#include "custom.h"
#include "gsm.h"

#include "p_btp.h"
#include "Bti.h"
#include "bti_btp.h"
#include "bti_cb.h"

#include "mfw_mfw.h"
#include "mfw_bt.h"
#include "mfw_bta.h"
#include "mfw_acie.h"
#include "mfw_win.h"

/* static used structures/variables */
EXTERN MfwHdr * current_mfw_elem;

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_init            |
+--------------------------------------------------------------------+

  PURPOSE : initialize BT manager

*/
int bt_init (void)
{
  TRACE_FUNCTION("mfw_bt:bt_init()");
  /*
   * install prim handler (primitives directly to MFW)
   */
  pSlotBt = aci_create(bta_response_cb,NULL);
  /*
  * initialize internal lists for found services
  */
  found_headset.service = MFW_BT_HEADSET;
  found_headset.device_id = NULL;
  found_dial_up.service = MFW_BT_DIAL_UP;
  found_dial_up.device_id = NULL;
  found_fax.service = MFW_BT_FAX_GW;
  found_fax.device_id = NULL;
  found_opp.service = MFW_BT_OPP;
  found_opp.device_id = NULL;
  found_sync.service = MFW_BT_SYNC;
  found_sync.device_id = NULL;
  found_sync_cmd.service = MFW_BT_SYNC_CMD;
  found_sync_cmd.device_id = NULL;
  return TRUE;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_exit            |
+--------------------------------------------------------------------+

  PURPOSE : finalize BT manager

*/
void bt_exit (void)
{
  TRACE_FUNCTION("bt_exit()");
  /*
   * remove prim handler
   */
  aci_delete(pSlotBt);
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_create          |
+--------------------------------------------------------------------+

  PURPOSE : create BT event handler and control block

*/
T_MFW_HND bt_create (MfwHnd hWin, MfwEvt event, MfwCb cbfunc)
{
  MfwHdr *hdr;
  T_MFW_BT *bt_para;
  MfwHdr *insert_status =0;

  TRACE_FUNCTION("bt_create()");

  hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
  bt_para = (T_MFW_BT *) mfwAlloc(sizeof(T_MFW_BT));

  if (!hdr || !bt_para)
  	{
    	TRACE_ERROR("ERROR: bt_create() Mem Alloc Failed.");
			
	   	if(hdr)
   			mfwFree((U8*)hdr,sizeof(MfwHdr));

   		if(bt_para)
   			mfwFree((U8*)bt_para,sizeof(T_MFW_BT));
   		
	   	return 0;
  	}

  bt_para->emask = event;
  bt_para->handler = cbfunc;            /* event callback function */

  hdr->data = bt_para;
  hdr->type = MfwTypBt;

  insert_status= mfwInsert((MfwHdr *) hWin,hdr); /* handle is brought in chain */
  if(!insert_status)
	{
  		TRACE_ERROR("ERROR: bt_create() Failed to Install Handler. ");
   		mfwFree((U8*)hdr,sizeof(MfwHdr));
   		mfwFree((U8*)bt_para,sizeof(T_MFW_BT));
		return 0;
  	}
    return insert_status;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_delete          |
+--------------------------------------------------------------------+

  PURPOSE : delete BT event handler and control block, free Memory

*/
MfwRes bt_delete (MfwHnd h)
{
  TRACE_FUNCTION("bt_delete()");

  if (!h || !((MfwHdr *) h)->data)
    return MfwResIllHnd;

  if (!mfwRemove((MfwHdr *) h))
  return MfwResIllHnd;

  mfwFree((U8 *) ((MfwHdr *) h)->data,sizeof(T_MFW_BT));
  mfwFree((U8 *) h,sizeof(MfwHdr));

  return MfwResOk;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_signal          |
+--------------------------------------------------------------------+

  PURPOSE : Send a signal to MMI

*/
void bt_signal (MfwEvt event, void *para)
{	/*MC, SPR 1389, we have to enable the display whenever 
	we send an event up to the MMI*/
	UBYTE temp = dspl_Enable(0);

  	TRACE_FUNCTION ("bt_signal()");

	  if (mfwSignallingMethod EQ 0) /* default search method (old bmi design) */
	  {
	    if (mfwFocus)               /* look for element in focussed chain */
	      if (bt_sign_exec(mfwFocus,event,para))
	      { dspl_Enable(temp);/*MC, SPR 1389*/
	        return;
	      }
	    if (mfwRoot)                /* look for element in root */
	      bt_sign_exec(mfwRoot,event,para);
	  }
	  else /* new bmi design */
	  {
	    MfwHdr * h = 0;
	    /*
	     * Focus set, then start here
	     */
	    if (mfwFocus)
	      h = mfwFocus;
	      /*
	       * Focus not set, then start root
	       */
	    if (!h)
	      h = mfwRoot;
	    /*
	     * No elements available, return
	     */
	    while (h)
	    {
	      /*
	       * Signal consumed, then return
	       */
	      if (bt_sign_exec (h, event, para))
	      { dspl_Enable(temp);/*MC, SPR 1389*/
	        return;
	      }
	      /*
	       * All windows tried inclusive root
	       */
	      if (h == mfwRoot)
	      { dspl_Enable(temp);/*MC, SPR 1389*/
	        return;
	      }
	      /*
	       * get parent window
	       */
	      h = mfwParent(mfwParent(h));
	      if(h)
	        h = ((MfwWin * )(h->data))->elems;
	    }
	    bt_sign_exec (mfwRoot, event, para);
	  }
	  dspl_Enable(temp);/*MC, SPR 1389*/
	
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_sign_exec       |
+--------------------------------------------------------------------+

  PURPOSE : Send a signal if BT management handler

*/
int bt_sign_exec (MfwHdr *cur_elem, MfwEvt event, T_MFW_BT_PARA *para)
{
  T_MFW_BT_SERVICE_SEARCH_CNF * search_confirmation_ptr;
  T_MFW_BT_DEVICE_SEARCH_CNF * dev_search_conf_ptr;
  T_MFW_BT_DISCONNECT_CNF * discon_ptr;
  T_MFW_BT_DISCON_DUN_FAX_CNF * discon_dun_fax_ptr;
  T_MFW_BT_DISCON_DUN_FAX_IND * discon_dun_fax_ind_ptr;
  T_MFW_BT_DISCONNECT_IND * discon_i_ptr;
  T_MFW_BT_CONNECT_CNF * connect_ptr;
  T_MFW_BT_SRV_SYNC_CNF * srv_sync_complete;
  T_MFW_BT_SRV_SYNC_AUTH_IND * srv_sync_auth_ind;
  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;
  T_MFW_BT_BD_ADDR dummy_address[MFW_BT_ADDR_MAX_LEN];

  memset(&dummy_address,0,sizeof(dummy_address));

  TRACE_FUNCTION("bt_sign_exec()");

  while (cur_elem)
  {
    if (cur_elem->type EQ MfwTypBt)
    {
      T_MFW_BT *bt_data;
      bt_data = (T_MFW_BT *) cur_elem->data;
      if (bt_data->emask & event)
      {
        bt_data->event = event;
        switch (event)
        {

          case BT_CREATE_PROFILE_CNF:
            memcpy(&bt_data->para.prof_create_cnf, para,sizeof(T_MFW_BT_PROFILE_CREATE_CNF));
            break;

          case BT_DELETE_PROFILE_CNF:
            memcpy(&bt_data->para.prof_delete_cnf, para,sizeof(T_MFW_BT_PROFILE_DELETE_CNF));
            break;

          case BT_INIT_PROFILE_CNF:   /* confirms initialize/reconfiguration of service profile  */
            memcpy(&bt_data->para.profile,
                   para,sizeof(T_MFW_BT_PROFILE_CNF));
            /* service,result_bd,subtype(,mfw_opp_mode,mfw_sync_mode,mfw_syn_aut_mode) with event BT_INIT_PROFILE_CNF to MMI */
            break;

          case BT_DEINIT_PROFILE_CNF:/* confirms deinitialize profile  */
            memcpy(&bt_data->para.profile,
                   para,sizeof(T_MFW_BT_PROFILE_CNF));
            /* service,result_bd,subtype(,mfw_opp_mode,mfw_sync_mode,mfw_syn_aut_mode) with event BT_DEINIT_PROFILE_CNF to MMI */
            break;
        }

        switch (event)
        {
          case BT_RESTORE_LIST_RESULT:/* result restoring default service list  */
            memcpy(&bt_data->para.restore_conf,
                   para,sizeof(T_MFW_BT_REST_CONFIG));
            /* service and cause with event BT_RESTORE_LIST_RESULT to MMI */
            break;

          case BT_RESTORE_CONF_RESULT:/* result restoring configuration parameter  */
            memcpy(&bt_data->para.restore_conf,
                   para,sizeof(T_MFW_BT_REST_CONFIG));
            /* service and cause with event BT_RESTORE_CONF_RESULT to MMI */
            break;

          case BT_SERVICE_SEARCH_CNF:
            search_confirmation_ptr = (T_MFW_BT_SERVICE_SEARCH_CNF *)para;
            if(search_confirmation_ptr->service EQ MFW_BT_HEADSET)
            {
              /* pointer of list of detected hs to mmi */
              bt_data->para.service_lst_p.list_ptr = &found_headset;
            }
            else if(search_confirmation_ptr->service EQ MFW_BT_DIAL_UP)
            {
              /* pointer of list of detected dial up  to mmi */
              bt_data->para.service_lst_p.list_ptr = &found_dial_up;
            }
            else if(search_confirmation_ptr->service EQ MFW_BT_FAX_GW)
            {
              /* pointer of list of detected fax  to mmi */
              bt_data->para.service_lst_p.list_ptr = &found_fax;
            }
            else if(search_confirmation_ptr->service EQ MFW_BT_OPP)
            {
              /* pointer of list of detected opp  to mmi */
              bt_data->para.service_lst_p.list_ptr = &found_opp;
            }
            else if(search_confirmation_ptr->service EQ MFW_BT_SYNC)
            {
              /* pointer of list of detected sync  server  to mmi */
              bt_data->para.service_lst_p.list_ptr = &found_sync;
            }
            else if(search_confirmation_ptr->service EQ MFW_BT_SYNC_CMD)
            {
              /* pointer of list of detected sync server with command support  to mmi */
              bt_data->para.service_lst_p.list_ptr = &found_sync_cmd;
            }
            break;

          case BT_DEVICE_SEARCH_CNF:
            dev_search_conf_ptr = (T_MFW_BT_DEVICE_SEARCH_CNF *)para;
            if(dev_search_conf_ptr->result EQ BTI_OK)
            {/* pointer of list of found services to mmi */
              bt_data->para.device_lst_p.list_ptr = &service_list;
            }
            break;

          case BT_DEVICE_FOUND_IND: /* new device was found */
            memcpy(&bt_data->para.device_ind, para, sizeof(T_MFW_BT_DEVICE_IND));
            break;

          case BT_SERVICE_FOUND_IND: /* new service was found */
            memcpy(&bt_data->para.service_ind, para, sizeof(T_MFW_BT_SERVICE_IND));
            break;

          case BT_CONNECT_DEVICE_CNF:
            connect_ptr = (T_MFW_BT_CONNECT_CNF *)para;
            if(connect_ptr->service EQ MFW_BT_HEADSET)
            {
              memcpy(&bt_data->para.connect_cnf,
                     para,sizeof(T_MFW_BT_CONNECT_CNF));
            }
            else
              return FALSE;
            break;

          case BT_SRV_SYNC_CNF:
            srv_sync_complete = (T_MFW_BT_SRV_SYNC_CNF *)para;
            if(srv_sync_complete->service EQ MFW_BT_SYNC)
            {
              memcpy(&bt_data->para.srv_sync_cnf,
                     para,sizeof(T_MFW_BT_SRV_SYNC_CNF));
            }
            else
              return FALSE;
            break;

          case BT_SRV_SYNC_AUTH_IND:
            srv_sync_auth_ind = (T_MFW_BT_SRV_SYNC_AUTH_IND *)para;
            if(srv_sync_auth_ind->service EQ MFW_BT_SYNC)
            {
              memcpy(&bt_data->para.srv_sync_auth,
                     para,sizeof(T_MFW_BT_SRV_SYNC_AUTH_IND));
            }
            else
              return FALSE;
            break;

          case BT_SRV_SYNC_PULL_IND:
            srv_sync_pull_ind = (T_MFW_BT_SRV_SYNC_PULL_IND *)para;
            if(srv_sync_pull_ind->service EQ MFW_BT_SYNC)
            {
              memcpy(&bt_data->para.sync_pull_ind,
                     para,sizeof(T_MFW_BT_SRV_SYNC_PULL_IND));
            }
            else
              return FALSE;
            break;

          case BT_SRV_SYNC_PUSH_IND:
            srv_sync_push_ind = (T_MFW_BT_SRV_SYNC_PUSH_IND *)para;
            if(srv_sync_push_ind->service EQ MFW_BT_SYNC)
            {
              memcpy(&bt_data->para.sync_push_ind,
                     para,sizeof(T_MFW_BT_SRV_SYNC_PUSH_IND));
            }
            else
              return FALSE;
            break;

          case BT_SRV_SYNC_PUSH_CNF:
            srv_sync_push_cnf = (T_MFW_BT_SRV_SYNC_PUSH_CNF *)para;
            if(srv_sync_push_cnf->service EQ MFW_BT_SYNC)
            {
              memcpy(&bt_data->para.sync_push_cnf,
                     para,sizeof(T_MFW_BT_SRV_SYNC_PUSH_CNF));
            }
            else
              return FALSE;
            break;
        }

        switch (event)
        {

          case BT_HSG_SPECIFIC_CMD_CFM:
            memcpy(&bt_data->para.hsg_specific_cmd_cfm, para,sizeof(T_MFW_BT_HSG_SPECIFIC_CMD_CFM));
            break;

          case BT_HSG_HEADSET_CONNECTION_IND:
            memcpy(&bt_data->para.hsg_headset_connection_ind, para,sizeof(T_MFW_BT_HSG_HEADSET_CONNECTION_IND));
            break;

          case BT_HSG_SAVE_LIST_CNF:
            memcpy(&bt_data->para.hsg_save_list_cnf, para,sizeof(T_MFW_BT_HSG_SAVE_LIST_CNF));
            break;
        }

        switch (event)
        {
          case BT_CONNECT_DEVICE_IND:
             memcpy(&bt_data->para.connect_indication,
                   para,sizeof(T_MFW_BT_CONNECT_IND));
            /* service with event BT_CONNECT_DEVICE_IND to MMI */
              break;

          case BT_CONNECT_DEVICE_INF:
             memcpy(&bt_data->para.connect_information,
                   para,sizeof(T_MFW_BT_CONNECT_INF));
            /* service with event BT_CONNECT_DEVICE_INF to MMI */
              break;


          case BT_DISCONNECT_DEVICE_CNF:
            discon_ptr = (T_MFW_BT_DISCONNECT_CNF *)para;
            if(discon_ptr->service EQ MFW_BT_HEADSET)
            {
              /* confirms disconnection */
              memcpy(&bt_data->para.disconnect_cnf,
                     para,sizeof(T_MFW_BT_DISCONNECT_CNF));
              /* service, addr with event BT_DISCONNECT_DEVICE_CNF to MMI */
              break;
            }
            else
              return FALSE;

          case BT_DISCON_DUN_FAX_CNF:
            discon_dun_fax_ptr = (T_MFW_BT_DISCON_DUN_FAX_CNF *)para;
            if((discon_dun_fax_ptr->service EQ MFW_BT_DIAL_UP) OR
               (discon_dun_fax_ptr->service EQ MFW_BT_FAX_GW))
            {
              /* confirms disconnection by remote dial up/fax */
              memcpy(&bt_data->para.disc_dun_fax_cnf,
                     para,sizeof(T_MFW_BT_DISCON_DUN_FAX_CNF));
              /* device, result with event BT_DISCON_DUN_FAX_CNF to MMI */
              break;
            }
            else
              return FALSE;

          case BT_DISCONNECT_DEVICE_IND:
            discon_i_ptr = (T_MFW_BT_DISCONNECT_IND *)para;
            if(discon_i_ptr->service EQ MFW_BT_HEADSET)
            {
              /* confirms indication */
              memcpy(&bt_data->para.disconnect_ind,
                     para,sizeof(T_MFW_BT_DISCONNECT_IND));
              /* service, addr, error_cause with event BT_DISCONNECT_DEVICE_IND to MMI */
              break;
            }
            else
              return FALSE;

          case BT_DISCON_DUN_FAX_IND:
            discon_dun_fax_ind_ptr = (T_MFW_BT_DISCON_DUN_FAX_IND *)para;
            if((discon_dun_fax_ind_ptr->service EQ MFW_BT_DIAL_UP) OR
              (discon_dun_fax_ind_ptr->service EQ MFW_BT_FAX_GW))
            {
              /* indicats disconnection by remote dial up */
              memcpy(&bt_data->para.con_dun_fax_ind,
                     para,sizeof(T_MFW_BT_DISCON_DUN_FAX_IND));
              /* device, result with event BT_DISCON_DUN_FAX_IND to MMI */
              break;
            }
            else
              return FALSE;
        }

        switch (event) /* BT CTRL */
        {
          case BT_CHNG_LOCAL_NAME:
            memcpy(&bt_data->para.chng_local_name, para, sizeof(T_MFW_BT_CHNG_LOCAL_NAME));
            break;

          case BT_READ_LOCAL_NAME:
            memcpy(&bt_data->para.read_local_name, para, sizeof(T_MFW_BT_READ_LOCAL_NAME));
            break;

          case BT_REMOTE_DEV_INFO_RES:
            memcpy(&bt_data->para.remote_dev_info, para, sizeof(T_MFW_BT_REMOTE_DEV_INFO_RES));
            break;

          case BT_CHNG_CONNECTABLE_MODE:
            memcpy(&bt_data->para.chng_conn_mode, para, sizeof(T_MFW_BT_CHNG_CONNECTABLE_MODE));
            break;

          case BT_CHNG_DISCOVERABLE_MODE:
            memcpy(&bt_data->para.chng_disc_mode, para, sizeof(T_MFW_BT_CHNG_DISCOVERABLE_MODE));
            break;

          case BT_READ_BD_ADDR:
            memcpy(&bt_data->para.read_bd_addr, para, sizeof(T_MFW_BT_READ_BD_ADDR));
            break;

          case BT_TRUSTED_DEV_LIST_FULL:
            break;

        }

        switch (event)
        {

          case BT_TRANSFER_AUDIO_IN_CNF:
            /* confirms transfer audio out */
            memcpy(&bt_data->para.audio_in_cnf,
                   para,sizeof(T_MFW_BT_TRANSFER_AUDIO_IN_CNF));
            /* service, addr with event BT_TRANSFER_AUDIO_IN_CNF to MMI */
            break;

          case BT_TRANSFER_AUDIO_OUT_CNF:
            /* confirms transfer audio in */
            memcpy(&bt_data->para.audio_out_cnf,
                   para,sizeof(T_MFW_BT_TRANSFER_AUDIO_OUT_CNF));
            /* service, addr with event BT_TRANSFER_AUDIO_OUT_CNF to MMI */
            break;

          case BT_AUTHORIZATION_IND:
            /* indicats remote device authorization request */
            memcpy(&bt_data->para.authoriz_ind,
                   para,sizeof(T_MFW_BT_AUTHORIZATION_IND));
            /* addr,remote name,service name, authorization_mask,connection_dir with event BT_AUTHORIZATION_IND to MMI */
            break;

          case BT_PIN_IND:
            /* indicats remote pin request */
            memcpy(&bt_data->para.pin_ind,
                   para,sizeof(T_MFW_BT_PIN_IND));
            /* addr,name with event BT_PIN_IND to MMI */
            break;

          case BT_RECONFIG_PROFILE_CNF:
            /* confirm reconfiguration profile  */
            memcpy(&bt_data->para.profile,
                   para,sizeof(T_MFW_BT_PROFILE_CNF));
            /* service, result_bd(,mfw_opp_mode,mfw_sync_mode,mfw_syn_aut_mode) with event BT_RECONFIG_PROFILE_CNF to MMI */
            break;

          case BT_DEVICE_PAIRED_IND:
            /* confirm pairing procedure  */
            memcpy(&bt_data->para.pair_ind,
                   para,sizeof(T_MFW_BT_DEV_PAIR_IND));
            /* remote addr, remote name and pair_res with event BT_DEVICE_PAIRED_IND to MMI */
            break;

          case BT_CALL_MONITORING_STATUS:
            /* indicats call monitoring events by dun/fax */
            memcpy(&bt_data->para.call_status,
                   para,sizeof(T_MFW_BT_CALL_STATUS_DUN_FAX));
            /* device and call status with event BT_CALL_MONITORING_STATUS to MMI */
            break;

          case BT_OPP_SERV_PUT_IND:
            /* indicats put request by opp server */
            memcpy(&bt_data->para.opp_s_obj,
                   para,sizeof(T_MFW_BT_OPP_PUT_IND));
            /* device,subtype,client_addr,object with event BT_OPP_SERV_PUT_IND to MMI */
            break;

          case BT_OPP_SERV_PUT_CNF:
            /* indicats put request by opp server (server side) */
            memcpy(&bt_data->para.opp_s_obj_cnf,
                   para,sizeof(T_MFW_BT_OPP_PUT_CNF));
            /* device,subtype,client_addr,object,error with event BT_OPP_SERV_PUT_CNF to MMI */
            break;

          case BT_OPP_OBJECT_PUSH_CNF:
            /* indicats push object to opp server (client side)*/
            memcpy(&bt_data->para.opp_cl_push_ob_cnf,
                   para,sizeof(T_MFW_BT_OPP_PUSH_CNF));
            /* device,subtype,server_addr,object,error with event BT_OPP_OBJECT_PUSH_CNF to MMI */
            break;

          case BT_OPP_OBJECT_PULL_CNF:
            /* indicats push object from opp server (client side)*/
            memcpy(&bt_data->para.opp_cl_pull_ob_cnf,
                   para,sizeof(T_MFW_BT_OPP_PULL_CNF));
            /* device,subtype,server_addr,object,error with event BT_OPP_OBJECT_PULL_CNF to MMI */
            break;
          }

/*#ifdef PCA_6350*/
        switch (event)
        {
          case BT_PCA_GW_STATUS_CFM:
            memcpy(&bt_data->para.pca_gw_status, para, sizeof(T_MFW_BT_PCA_GW_STATUS_CFM));
            break;
          case BT_PCA_GW_LINK_MONITORING:
            memcpy(&bt_data->para.pca_link_mon, para, sizeof(T_MFW_BT_PCA_GW_LINK_MONITORING));
            break;
          case BT_PCA_GW_CALL_MONITORING:
            memcpy(&bt_data->para.pca_call_mon, para, sizeof(T_MFW_BT_PCA_GW_CALL_MONITORING));
            break;
          case BT_PCA_GW_HANGUP_CFM:
            memcpy(&bt_data->para.pca_hangup, para, sizeof(T_MFW_BT_PCA_GW_HANGUP_CFM));
            break;
        }
/*#endif*/ /* PCA_6350 */
        if (bt_data->handler)
        {
          current_mfw_elem = cur_elem;
          /* to call back function in mmi  */
          if ((*(bt_data->handler))(bt_data->event,
              (void *) &bt_data->para))
          return TRUE;
        }
      }
    }/* next element for look for type of handle */
    cur_elem = cur_elem->next;
  }
  return FALSE;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE : bt_init_profile_hsg_cl|
+--------------------------------------------------------------------+

  PURPOSE : configure and initialize a BT headset profile in client mode

*/
T_MFW_BT_RESULT_BT bt_init_profile_hsg_cl (T_MFW_BT_SERVICE_TYPE service,
                                  T_MFW_BT_HSG_CLIENT_CONFIG mfw_config)
{
  T_BTI_HSG_CLIENT_CONF bt_config;

  TRACE_FUNCTION ("bt_init_profile_hsg_cl()");

  memset(&bt_config,0,sizeof(bt_config));

  if(service EQ MFW_BT_HEADSET)
  {
    /* type of connection:
    ***  MFW_BT_AUTO_OUTG_DEF_CONN_OFF or
         MFW_BT_AUTO_OUTG_DEF_CONN_ON
        (connection with default pre-defined headset as soon as it receives a
        RING command from GSM)
    ***
    */
    switch(mfw_config.config_mode)
    {
        case MFW_BT_AUTO_OUTG_DEF_CONN_OFF:
          bt_config.config_mode = BTI_AUTO_OUTG_DEF_CONN_OFF;
          break;
        case MFW_BT_AUTO_OUTG_DEF_CONN_ON:
          bt_config.config_mode = BTI_AUTO_OUTG_DEF_CONN_ON;
          break;
    }

    bt_config.security = mfw_config.security;

    switch(btibtp_init_profile_hsg_req_cl((T_BTI_DEVICE_TYPE)service,bt_config))
    {/* BTP_INIT_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_init_profile_hsg_serv|
+----------------------------------------------------------------------+

  PURPOSE : configure and initialize a BT headset profile in server mode

*/
T_MFW_BT_RESULT_BT bt_init_profile_hsg_serv (T_MFW_BT_SERVICE_TYPE service,
                                  T_MFW_BT_HSG_SERVER_CONFIG mfw_config)
{
  T_BTI_HSG_SERVER_CONF bt_config;

  TRACE_FUNCTION ("bt_init_profile_hsg_serv()");

  memset(&bt_config,0,sizeof(bt_config));

  if(service EQ MFW_BT_HEADSET)
  {
    bt_config.conn_config = mfw_config.serv_con_conf;
    /* length scan of connection requests of remote headsets *
    /* default value: MFW_BT_CONN_SCAN_TIME_DEFAULT_VALUE */
    bt_config.conn_time = mfw_config.conn_time;
    /* period between 2 scans of connection of remote headsets */
    /* default value: MFW_BT_CONN_SCAN_BREAK_DEFAULT_VALUE */
    bt_config.conn_break= mfw_config.conn_break;
    /* number of phone number in phone list */
    bt_config.nb_phone = mfw_config.nb_phone;
    /* phone number list of remote headset */
    memcpy(bt_config.phon_list,mfw_config.mfw_phone_list,sizeof(mfw_config.mfw_phone_list));
    /* associatd key list of  remote headset */
    memcpy(bt_config.key_list,mfw_config.mfw_key_list,sizeof(mfw_config.mfw_key_list));

    bt_config.security = mfw_config.security;

    switch(btibtp_init_profile_hsg_req_serv((T_BTI_DEVICE_TYPE)service,bt_config))
    {/* BTP_INIT_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_init_profile_dun|
+--------------------------------------------------------------------+

  PURPOSE : configure and initialize a BT dialup profile

*/
T_MFW_BT_RESULT_BT bt_init_profile_dun (T_MFW_BT_SERVICE_TYPE service,
                                     T_MFW_BT_DUN_CONFIG dun_filter)
{
  T_BTI_DUN_CONF dun_config;

  TRACE_FUNCTION ("bt_init_profile_dun()");

  memset(&dun_config,0,sizeof(dun_config));

  if(service EQ MFW_BT_DIAL_UP)
  {/* show status of BT link - informs if a serial port is opened between DUN-DT and DUN-GW */
    if((dun_filter.link_event EQ BTI_DUN_LINK_MONIT_ON) OR
       (dun_filter.link_event EQ BTI_DUN_LINK_MONIT_OFF))
    {
      dun_config.link_filter = dun_filter.link_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_init_profile_dun()");
        return MFW_BT_FAIL;
    }
    /* show status of data call */
    if((dun_filter.call_event EQ BTI_DUN_CALL_MONIT_ON) OR
       (dun_filter.call_event EQ BTI_DUN_CALL_MONIT_OFF))
    {
      dun_config.call_filter = dun_filter.call_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_init_profile_dun()");
        return MFW_BT_FAIL;
    }

    switch(btibtp_init_profile_dun_req((T_BTI_DEVICE_TYPE)service,dun_config))
    {/* BTP_INIT_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_init_profile_fax|
+--------------------------------------------------------------------+

  PURPOSE : configure and initialize a BT fax gateway profile

*/
T_MFW_BT_RESULT_BT bt_init_profile_fax (T_MFW_BT_SERVICE_TYPE service,
                                     T_MFW_BT_FAX_CONFIG fax_filter)
{
  T_BTI_FAX_CONF fax_config;

  TRACE_FUNCTION ("bt_init_profile_fax()");

  memset(&fax_config,0,sizeof(fax_config));

  if(service EQ MFW_BT_FAX_GW)
  {/* show status of BT link - informs if a serial port is opened between FAX-DT and FAX-GW */
    if((fax_filter.link_event EQ BTI_FAX_LINK_MONIT_ON) OR
       (fax_filter.link_event EQ BTI_FAX_LINK_MONIT_OFF))
    {
      fax_config.link_filter = fax_filter.link_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_init_profile_fax()");
        return MFW_BT_FAIL;
    }
    /* show status of data call */
    if((fax_filter.call_event EQ BTI_FAX_CALL_MONIT_ON) OR
       (fax_filter.call_event EQ BTI_FAX_CALL_MONIT_OFF))
    {
      fax_config.call_filter = fax_filter.call_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_init_profile_fax()");
        return MFW_BT_FAIL;
    }

    switch(btibtp_init_profile_fax_req((T_BTI_DEVICE_TYPE)service,fax_config))
    {/* BTP_INIT_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_init_profile_opp|
+--------------------------------------------------------------------+

  PURPOSE : configure and initialize a BT OPP client or server
*/
T_MFW_BT_RESULT_BT bt_init_profile_opp (T_MFW_BT_SERVICE_TYPE service,
                                        T_MFW_BT_SUBTYPE_DEV subtype,
                                        T_MFW_BT_OPP_SERVER_CONFIG serv_config)
{
  T_BTI_OPP_SERVER_CONFIG bt_opp_s_conf;

  TRACE_FUNCTION ("bt_init_profile_opp()");

  memset(&bt_opp_s_conf,0,sizeof(bt_opp_s_conf));

  if(service EQ MFW_BT_OPP)
  {
    if(subtype EQ MFW_BT_CLIENT)
    {
      switch(btibtp_init_profile_opp_cl())
      {/* BTP_INIT_PROFILE_REQ to BT */
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else if(subtype EQ MFW_BT_SERVER)
    {
      /* mode of OPP server:
         MFW_BT_OPP_NO_MODE: no OPP server mode
         MFW_BT_OPP_SILENT_MODE: OPP server stores objects as files without alerting the user
         MFW_BT_OPP_FILE_MODE: OPP server stores objects as files with alerting user
         MFW_BT_OPP_BUFFER_MODE: OPP server asks for a buffer to store the each object
      */

      switch(serv_config.mfw_opp_mode)
      {
        case MFW_BT_OPP_NO_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_NO_OPP_MODE;
          break;
        case MFW_BT_OPP_BUFFER_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_OPP_EVENT_BUFFER_MODE;
          break;
        case MFW_BT_OPP_FILE_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_OPP_EVENT_FILE_MODE;
          break;
        case MFW_BT_OPP_SILENT_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_OPP_SILENT_FILE_MODE;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* this function change the parameter of the existing OPP server */
      /* initalizing of an OBEX server and service, registration in SDP and enabling of OPP server took place
      after switching power on */
      switch(serv_config.mfw_opp_object.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object is stored in buffer */
          bt_opp_s_conf.bt_object.bt_object_type = BTI_TYPE_BUFFER;
          bt_opp_s_conf.bt_object.bt_buffer_start = serv_config.mfw_opp_object.mfw_buffer_start;
          bt_opp_s_conf.bt_object.bt_buffer_size = serv_config.mfw_opp_object.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object is stored in file system */
          bt_opp_s_conf.bt_object.bt_object_type = BTI_TYPE_PATH;
          /* path of default_business_card of server */
          bt_opp_s_conf.bt_object.bt_path = serv_config.mfw_opp_object.mfw_path;
          /* path of inbox folder in file system of OPP server */
          bt_opp_s_conf.bt_inbox_path = serv_config.mfw_inbox_path;
          break;
        default:
          return MFW_BT_FAIL;

      }
      /* MIME type of object, null-terminated string */
      bt_opp_s_conf.bt_object.bt_object_mime_type = serv_config.mfw_opp_object.mfw_object_mime_type;
      /* name of default_business_card of server */
      bt_opp_s_conf.bt_object.bt_object_name = serv_config.mfw_opp_object.mfw_object_name;
      /* length of default_business_card of server */
      bt_opp_s_conf.bt_object.bt_object_length = serv_config.mfw_opp_object.mfw_object_length;

      switch(btibtp_init_profile_opp_s(bt_opp_s_conf))
      {/* BTP_INIT_PROFILE_REQ to BT */
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_init_profile_syn_s   |
+----------------------------------------------------------------------+

  PURPOSE : configure and initialize a BT SYNC profile in server mode

*/
T_MFW_BT_RESULT_BT bt_init_profile_syn_s (T_MFW_BT_SERVICE_TYPE service,
                                          T_MFW_BT_SUBTYPE_DEV subtype,
                                  T_MFW_BT_SYN_OBJECT_STORE_LIST list_availabe_objects,
                                  T_MFW_BT_SYNC_SERVER_CONFIG mfw_config)
{
  T_BTI_SYNC_SERVER_CONFIG bt_config;
  T_BTI_SYN_OBJECT_STORE_LIST bt_list_sync_objects;
  TRACE_FUNCTION ("bt_init_profile_syn_s()");

  memset(&bt_config,0,sizeof(bt_config));
  bt_list_sync_objects = (T_BTI_SYN_OBJECT_STORE_LIST)list_availabe_objects;

  if(service EQ MFW_BT_SYNC)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      switch(mfw_config.mfw_syn_srv_mode)
      {
        case MFW_BT_SYNC_GEN_MODE:
          /* general SYNC server mode, for devices
          which are made discoverable continuously or for no
          specific conditions, the server is in connectable mode; the Sync
          client connects the server and starts the synchronization */
          bt_config.bt_sync_srv_mode = mfw_config.mfw_syn_srv_mode;
          break;
        case MFW_BT_SYNC_INIT_MODE:
          /* limited inquiry scan for devices which
          are made discoverable only for a limited period of time or
          for specific conditions; the server is in connectable and pairable mode */
          bt_config.bt_sync_srv_mode = mfw_config.mfw_syn_srv_mode;
          break;
        default:
          return MFW_BT_FAIL;
      }
      switch(mfw_config.mfw_syn_srv_auth_mode)
      {
        case MFW_BT_SYNC_INIT_AUTH_MODE:
          /* server initiates authentication */
          bt_config.bt_sync_aut_mode = mfw_config.mfw_syn_srv_auth_mode;
          break;
        case MFW_BT_SYNC_NO_INIT_AUTH_MODE:
          /* server does not initiate authentication*/
          bt_config.bt_sync_aut_mode = mfw_config.mfw_syn_srv_auth_mode;
          break;
        default:
          return MFW_BT_FAIL;
      }

      switch(btibtp_init_profile_sync_req_serv(bt_list_sync_objects,bt_config))
      { /* BTP_INIT_PROFILE_REQ to BT */
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)      MODULE  : MFW_BT               |
| STATE   : code                      ROUTINE : bt_reconf_profile_opp|
+--------------------------------------------------------------------+

  PURPOSE : reconfigure a BT OPP in server mode
*/
T_MFW_BT_RESULT_BT bt_reconf_profile_opp (T_MFW_BT_SERVICE_TYPE service,
                                        T_MFW_BT_SUBTYPE_DEV subtype,
                                        T_MFW_BT_OPP_SERVER_CONFIG serv_config)
{
  T_BTI_OPP_SERVER_CONFIG bt_opp_s_conf;

  TRACE_FUNCTION ("bt_init_profile_opp()");

  memset(&bt_opp_s_conf,0,sizeof(bt_opp_s_conf));
  if(service EQ MFW_BT_OPP)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      /* mode of OPP server:
         MFW_BT_OPP_NO_MODE: no OPP server mode
         MFW_BT_OPP_SILENT_MODE: OPP server stores objects as fileswithout alerting the user
         MFW_BT_OPP_FILE_MODE: OPP server stores objects as fileswith alerting user
         MFW_BT_OPP_BUFFER_MODE: OPP server asks for a buffer to store the each object
      */
      switch(serv_config.mfw_opp_mode)
      {
        case MFW_BT_OPP_NO_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_NO_OPP_MODE;
          break;
        case MFW_BT_OPP_BUFFER_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_OPP_EVENT_BUFFER_MODE;
          break;
        case MFW_BT_OPP_FILE_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_OPP_EVENT_FILE_MODE;
          break;
        case MFW_BT_OPP_SILENT_MODE:
          bt_opp_s_conf.bt_opp_mode = BTI_OPP_SILENT_FILE_MODE;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* this function change the parameter of the existing OPP server */
      switch(serv_config.mfw_opp_object.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object is stored in buffer */
          bt_opp_s_conf.bt_object.bt_object_type = BTI_TYPE_BUFFER;
          bt_opp_s_conf.bt_object.bt_buffer_start = serv_config.mfw_opp_object.mfw_buffer_start;
          bt_opp_s_conf.bt_object.bt_buffer_size = serv_config.mfw_opp_object.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object is stored in file system */
          bt_opp_s_conf.bt_object.bt_object_type = BTI_TYPE_PATH;
          /* path of default_business_card of server */
          bt_opp_s_conf.bt_object.bt_path = serv_config.mfw_opp_object.mfw_path;
          /* path of inbox folder in file system of OPP server */
          bt_opp_s_conf.bt_inbox_path = serv_config.mfw_inbox_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* MIME type of object, null-terminated string */
      bt_opp_s_conf.bt_object.bt_object_mime_type = serv_config.mfw_opp_object.mfw_object_mime_type;
      /* name of default_business_card of server */
      bt_opp_s_conf.bt_object.bt_object_name = serv_config.mfw_opp_object.mfw_object_name;
      /* length of default_business_card of server */
      bt_opp_s_conf.bt_object.bt_object_length = serv_config.mfw_opp_object.mfw_object_length;

      switch(btibtp_reconf_profile_opp_s(bt_opp_s_conf))
      {/* BTP_RECONFIG_PROFILE_REQ to BT */
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_reconf_profile_syn_s   |
+----------------------------------------------------------------------+

  PURPOSE : reconfigure a BT SYNC profile in server mode

*/
T_MFW_BT_RESULT_BT bt_reconf_profile_syn_s (T_MFW_BT_SERVICE_TYPE service,
                                          T_MFW_BT_SUBTYPE_DEV subtype,
                                  T_MFW_BT_SYN_OBJECT_STORE_LIST list_availabe_objects,
                                  T_MFW_BT_SYNC_SERVER_CONFIG mfw_config)
{
  T_BTI_SYNC_SERVER_CONFIG bt_config;
  T_BTI_SYN_OBJECT_STORE_LIST bt_list_sync_objects;
  TRACE_FUNCTION ("bt_reconf_profile_syn_s()");

  memset(&bt_config,0,sizeof(bt_config));
  bt_list_sync_objects = (T_BTI_SYN_OBJECT_STORE_LIST)list_availabe_objects;

  if(service EQ MFW_BT_SYNC)
  {
    switch(mfw_config.mfw_syn_srv_mode)
    {
      case MFW_BT_SYNC_GEN_MODE:
        /* general SYNC server mode, for devices
        which are made discoverable continuously or for no
        specific conditions */
        bt_config.bt_sync_srv_mode = mfw_config.mfw_syn_srv_mode;
        break;
      case MFW_BT_SYNC_INIT_MODE:
        /* limited inquiry scan for devices which
        are made discoverable only for a limited period of time or
        for specific conditions */
        bt_config.bt_sync_srv_mode = mfw_config.mfw_syn_srv_mode;
        break;
      default:
        return MFW_BT_FAIL;
    }
    switch(mfw_config.mfw_syn_srv_auth_mode)
    {
      case MFW_BT_SYNC_INIT_AUTH_MODE:
        /* server initiates authentication */
        bt_config.bt_sync_aut_mode = mfw_config.mfw_syn_srv_auth_mode;
        break;
      case MFW_BT_SYNC_NO_INIT_AUTH_MODE:
        /* server does not initiate authentication*/
        bt_config.bt_sync_aut_mode = mfw_config.mfw_syn_srv_auth_mode;
        break;
      default:
        return MFW_BT_FAIL;
    }

    switch(btibtp_reconf_profile_sync_req_serv(bt_list_sync_objects,bt_config))
    { /* BTP_RECONFIG_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE : bt_deinit_profile  |
+--------------------------------------------------------------------+

  PURPOSE : deinitialize a BT profile, not stop of profile application

*/
T_MFW_BT_RESULT_BT bt_deinit_profile (T_MFW_BT_SERVICE_TYPE service,T_MFW_BT_SUBTYPE_DEV subtype)
{
  TRACE_FUNCTION ("bt_deinit_profile()");

  if((service EQ MFW_BT_HEADSET) OR
     (service EQ MFW_BT_DIAL_UP) OR
     (service EQ MFW_BT_FAX_GW)  OR
     (service EQ MFW_BT_OPP)  OR
     (service EQ MFW_BT_SYNC))
  {
    if((subtype EQ MFW_BT_CLIENT) OR
       (subtype EQ MFW_BT_SERVER) OR
       (subtype EQ MFW_BT_NO_SUBTYPE))
    {
      switch(btibtp_deinit_profile_req((T_BTI_DEVICE_TYPE)service,(T_BTI_DEVICE_SUBTYP)subtype))
      { /* BTP_DEINIT_PROFILE_REQ to BT */
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
  }
  return MFW_BT_FAIL;
}

/*
+-----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)    MODULE  : MFW_BT                    |
| STATE   : code                    ROUTINE : bt_reconfig_profile_hsg_cl|
+-----------------------------------------------------------------------+

  PURPOSE : reconfigure a BT profile headset in client mode

*/
T_MFW_BT_RESULT_BT bt_reconfig_profile_hsg_cl (T_MFW_BT_SERVICE_TYPE service,
                                     T_MFW_BT_HSG_CLIENT_CONFIG config)
{
  T_BTI_HSG_CLIENT_CONF bt_config;

  TRACE_FUNCTION ("bt_reconfig_profile_hsg_cl()");

  memset(&bt_config,0,sizeof(bt_config));

  if(service EQ MFW_BT_HEADSET)
  {/* reconfiguration is only accepted when no outgoing call is in processing */
    switch(config.config_mode)
    {
      case MFW_BT_AUTO_OUTG_DEF_CONN_OFF:
        bt_config.config_mode = BTI_AUTO_OUTG_DEF_CONN_OFF;
        break;
      case MFW_BT_AUTO_OUTG_DEF_CONN_ON:
        bt_config.config_mode = BTI_AUTO_OUTG_DEF_CONN_ON;
        break;
    }

    bt_config.security = config.security;

    switch(btibtp_reconfig_profile_req_cl((T_BTI_DEVICE_TYPE)service,bt_config))
    { /* BTP_RECONF_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                      |
| STATE   : code                     ROUTINE : bt_reconfig_profile_hsg_serv|
+--------------------------------------------------------------------------+

  PURPOSE : reconfigure a BT headset profile in server mode

*/
T_MFW_BT_RESULT_BT bt_reconfig_profile_hsg_serv (T_MFW_BT_SERVICE_TYPE service,
                                  T_MFW_BT_HSG_SERVER_CONFIG mfw_config)
{
  T_BTI_HSG_SERVER_CONF bt_config;

  TRACE_FUNCTION ("bt_reconfig_profile_hsg_serv()");

  memset(&bt_config,0,sizeof(bt_config));

  if(service EQ MFW_BT_HEADSET)
  {
    bt_config.conn_config = mfw_config.serv_con_conf;
    /* length scan of connection requests of remote headsets *
    /* default value: MFW_BT_CONN_SCAN_TIME_DEFAULT_VALUE */
    bt_config.conn_time = mfw_config.conn_time;
    /* period between 2 scans of connection of remote headsets */
    /* default value: MFW_BT_CONN_SCAN_BREAK_DEFAULT_VALUE */
    bt_config.conn_break= mfw_config.conn_break;
    /* number of phone number in phone list */
    bt_config.nb_phone = mfw_config.nb_phone;
    /* phone number list of remote headset */
    memcpy(bt_config.phon_list,mfw_config.mfw_phone_list,sizeof(mfw_config.mfw_phone_list));
    /* associatd key list of  remote headset */
    memcpy(bt_config.key_list,mfw_config.mfw_key_list,sizeof(mfw_config.mfw_key_list));

    bt_config.security = mfw_config.security;

    switch(btibtp_reconfig_profile_req_serv((T_BTI_DEVICE_TYPE)service,bt_config))
    {/* BTP_INIT_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)    MODULE  : MFW_BT                 |
| STATE   : code                    ROUTINE : bt_reconfig_profile_dun|
+--------------------------------------------------------------------+

  PURPOSE : reconfigure a BT profile

*/
T_MFW_BT_RESULT_BT bt_reconfig_profile_dun (T_MFW_BT_SERVICE_TYPE service,
                                     T_MFW_BT_DUN_CONFIG dun_filter)
{
  T_BTI_DUN_CONF dun_config;

  TRACE_FUNCTION ("bt_reconfig_profile_dun()");

  memset(&dun_config,0,sizeof(dun_config));

  if(service EQ MFW_BT_DIAL_UP )
  {/* show status of BT link - informs if a serial port is opened between DUN-DT and DUN-GW */
    if((dun_filter.link_event EQ BTI_DUN_LINK_MONIT_ON) OR
       (dun_filter.link_event EQ BTI_DUN_LINK_MONIT_OFF))
    {
      dun_config.link_filter = dun_filter.link_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_reconfig_profile_dun()");
        return MFW_BT_FAIL;
    }
    /* show status of data call */
    if((dun_filter.call_event EQ BTI_DUN_CALL_MONIT_ON) OR
       (dun_filter.call_event EQ BTI_DUN_CALL_MONIT_OFF))
    {
      dun_config.call_filter = dun_filter.call_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_reconfig_profile_dun()");
        return MFW_BT_FAIL;
    }

    switch(btibtp_reconf_profile_dun_req((T_BTI_DEVICE_TYPE)service,dun_config))
    { /* BTP_RECONF_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)    MODULE  : MFW_BT                 |
| STATE   : code                    ROUTINE : bt_reconfig_profile_fax|
+--------------------------------------------------------------------+

  PURPOSE : reconfigure a BT profile

*/
T_MFW_BT_RESULT_BT bt_reconfig_profile_fax (T_MFW_BT_SERVICE_TYPE service,
                                     T_MFW_BT_FAX_CONFIG fax_filter)
{
  T_BTI_FAX_CONF fax_config;

  TRACE_FUNCTION ("bt_reconfig_profile_fax()");

  memset(&fax_config,0,sizeof(fax_config));

  if(service EQ MFW_BT_FAX_GW )
  {/* show status of BT link - informs if a serial port is opened between FAX-DT and FAX-GW */
    if((fax_filter.link_event EQ BTI_FAX_LINK_MONIT_ON) OR
       (fax_filter.link_event EQ BTI_FAX_LINK_MONIT_OFF))
    {
      fax_config.link_filter = fax_filter.link_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_reconfig_profile_fax()");
        return MFW_BT_FAIL;
    }
    /* show status of data call */
    if((fax_filter.call_event EQ BTI_FAX_CALL_MONIT_ON) OR
       (fax_filter.call_event EQ BTI_FAX_CALL_MONIT_OFF))
    {
      fax_config.call_filter = fax_filter.call_event;
    }
    else
    {
        TRACE_EVENT ("Error:bt_reconfig_profile_fax()");
        return MFW_BT_FAIL;
    }

    switch(btibtp_reconf_profile_fax_req((T_BTI_DEVICE_TYPE)service,fax_config))
    { /* BTP_RECONF_PROFILE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE : bt_service_search|
+--------------------------------------------------------------------+

  PURPOSE : request search of services and their service names

*/
T_MFW_BT_RESULT_BT  bt_service_search(T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_service_search()");

  if((service EQ MFW_BT_HEADSET) OR
     (service EQ MFW_BT_DIAL_UP) OR
     (service EQ MFW_BT_FAX_GW) OR
     (service EQ MFW_BT_OPP) OR
     (service EQ MFW_BT_SYNC_CMD))
  {/* start browsing procedure */
    switch(btibtp_service_search_req((T_BTI_DEVICE_TYPE)service, SERVICE_SEARCH))
    {
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE : bt_device_search |
+--------------------------------------------------------------------+

  PURPOSE : request search of devices and their service id's

*/
T_MFW_BT_RESULT_BT  bt_device_search(void)
{

  TRACE_FUNCTION ("bt_device_search()");

  /* start browsing procedure */
  switch(btibtp_device_search_req(DEVICE_SEARCH))
  {
    case BTP_OK:
      return MFW_BT_EXECUTE;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE : bt_extended_search |
+--------------------------------------------------------------------+

  PURPOSE : request search of devices and their service id's

*/
T_MFW_BT_RESULT_BT  bt_extended_search(UINT8 inq_length,
                     UINT8                  max_num_of_responses,
                     T_MFW_DEVICE_CLASS     class_of_device[],
                     BOOLEAN                need_device_name,
                     BOOLEAN                need_services,
                     T_MFW_SERVICE_ID       service_id)
{

  TRACE_FUNCTION ("bt_extended_search()");

  /* start browsing procedure */
  switch(btibtp_extended_search_req(inq_length, max_num_of_responses,
                                    class_of_device, need_device_name,
                                    need_services, service_id))
  {
    case BTP_OK:
      return MFW_BT_EXECUTE;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE : bt_search_abort  |
+--------------------------------------------------------------------+

  PURPOSE : start abort of browsing procedure

*/
T_MFW_BT_RESULT_BT bt_search_abort(void)
{
  TRACE_FUNCTION ("bt_search_abort()");

  switch(btibtp_search_abort())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE : bt_connect_hsg        |
+--------------------------------------------------------------------+

  PURPOSE : request connection with the service headset

*/
T_MFW_BT_RESULT_BT  bt_connect_hsg (T_MFW_BT_SERVICE_TYPE service,
                                    T_MFW_BT_REQ_ID req_id,
                                    T_MFW_BT_BD_ADDR bd_addr[], UINT8 mode)
{
  TRACE_FUNCTION ("bt_connect_hsg()");

  /*
  *** if req_id equal MFW_BT_DEFAULT_HEADSET_ID: headset gateway will
                      automatically select a headset from the default headset list
      if req_id equal MFW_BT_INVALID_HEADSET_ID: headset gateway will try to
                      connect to the headset whose BT headset address is in bd_addr
      otherwise headset gateway will call the headset related to headset_id
                      in the default headset list
  ***
  */
   /* BTP_CONNECT_DEVICE_REQ to BT */
  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_connect_hsg_req(req_id, bd_addr, mode))
    {
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)         MODULE  : MFW_BT            |
| STATE   : code                         ROUTINE :bt_get_auto_connect|
+--------------------------------------------------------------------+

  PURPOSE : get state automatic connection on/off for headset gateway
*/

T_MFW_BT_RESULT_BT bt_get_auto_connect(T_MFW_BT_SERVICE_TYPE service,
                                    T_MFW_BT_HSG_CLIENT_CONFIG *conf)
{
  T_MFW_BT_HSG_CLIENT_CONFIG client_conf;
  T_MFW_BT_HSG_SERVER_CONFIG server_conf;
  T_MFW_BT_RESULT_BT result;

  TRACE_FUNCTION ("bt_get_auto_connect()");

  memset(&client_conf,0,sizeof(client_conf));
  memset(&server_conf,0,sizeof(server_conf));

  result = bt_get_config((T_BTI_DEVICE_TYPE)service,&client_conf,&server_conf);

  if(result EQ MFW_BT_OK)
  {
    conf->config_mode = (T_MFW_BT_CONFIG_MODE)client_conf.config_mode;
  }
  return result;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)            MODULE  : MFW_BT         |
| STATE   : code                            ROUTINE :bt_auto_connect |
+--------------------------------------------------------------------+

  PURPOSE : set feature automatic connection on/off for headset gateway
*/

T_MFW_BT_RESULT_BT bt_auto_connect(T_MFW_BT_SERVICE_TYPE service,
                                T_MFW_BT_AUTO_CONNECT_STATE set_state)
{
  T_MFW_BT_HSG_CLIENT_CONFIG client_conf;
  T_MFW_BT_HSG_SERVER_CONFIG server_conf;
  T_MFW_BT_RESULT_BT result;

  TRACE_FUNCTION ("bt_auto_connect()");

  memset(&client_conf,0,sizeof(client_conf));
  memset(&server_conf,0,sizeof(server_conf));

  if(set_state EQ MFW_BT_AUTO_CONNECT_ON OR
     set_state EQ MFW_BT_AUTO_CONNECT_OFF)
  {/* read state of config_mode */
    result = bt_get_config((T_BTI_DEVICE_TYPE)service,&client_conf,&server_conf);
    if(result NEQ MFW_BT_OK)
    {
      return result;
    }
    else
    {
      if(set_state EQ MFW_BT_AUTO_CONNECT_ON)
      {
        if(client_conf.config_mode NEQ MFW_BT_AUTO_OUTG_DEF_CONN_ON)
        {/*  connection with default pre-defined headset as soon as it receives a
             RING command from GSM)*/
          client_conf.config_mode = MFW_BT_AUTO_OUTG_DEF_CONN_ON;
          return (bt_reconfig_profile_hsg_cl(service,client_conf));
        }
      }
      else
      {
        if(client_conf.config_mode EQ MFW_BT_AUTO_OUTG_DEF_CONN_ON)
        {
          client_conf.config_mode = MFW_BT_AUTO_OUTG_DEF_CONN_OFF;
          return (bt_reconfig_profile_hsg_cl(service,client_conf));
        }
      }
    }
  }
  else
    return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)         MODULE  : MFW_BT            |
| STATE   : code                        ROUTINE :bt_set_pref_headset |
+--------------------------------------------------------------------+

  PURPOSE : add preferred headset in default headset list
*/

T_MFW_BT_RESULT_BT bt_set_pref_headset(T_MFW_BT_SERVICE_TYPE service,
                                       T_MFW_BT_BD_ADDR bd_addr[],
                                       T_MFW_BT_HSG_NAME hsg_name[],
                                       T_MFW_BT_PRIORITY priority,
                                       BOOL rem_audio_ctr_supp_hsg,
                                       T_MFW_BT_CNF_ID * headset_cnf_id)
{
  T_MFW_BT_CNF_ID cnf_id = 0;

  TRACE_FUNCTION ("bt_set_pref_service()");

  if(service EQ MFW_BT_HEADSET)
  {
    if(priority <= MFW_HSG_HEADSET_MAX_PRIORITY)
    {
      switch(btibtp_set_default_headset(bd_addr,hsg_name,priority,rem_audio_ctr_supp_hsg,&cnf_id))
      /* add headset in default headset list */
      {
        case BTP_OK:
          *headset_cnf_id = cnf_id;
          return MFW_BT_OK;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_HSG_ALREADY_STOR:
          return MFW_BT_HSG_ALREADY_STORED;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_INVALID_PARA;
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)         MODULE  : MFW_BT            |
| STATE   : code                         ROUTINE :bt_is_pref_headset |
+--------------------------------------------------------------------+

  PURPOSE : check if preferred headset is in default headset list
*/

T_MFW_BT_RESULT_BT bt_is_pref_headset(T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_BD_ADDR bd_addr[],
                                      T_MFW_BT_CNF_ID * headset_cnf_id)
{
  T_MFW_BT_CNF_ID cnf_id = 0;

  TRACE_FUNCTION ("bt_is_pref_headset()");

  if(service EQ MFW_BT_HEADSET)
  {
      switch(btibtp_query_default_headset(bd_addr,&cnf_id))
      /* add headset in default headset list */
      {
        case BTP_OK:
          *headset_cnf_id = cnf_id;
          return MFW_BT_OK;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_HSG_ALREADY_STOR:
          return MFW_BT_HSG_ALREADY_STORED;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
  }
  else
    return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE :bt_reset_pref_hsg |
+--------------------------------------------------------------------+

  PURPOSE : delete current entry of a preferred headset
*/

T_MFW_BT_RESULT_BT  bt_reset_pref_hsg(T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_DEV_ID dev_id)
{
  TRACE_FUNCTION ("bt_reset_pref_hsg()");
  if(service EQ MFW_BT_HEADSET)
  {
    /* parameter: dev_id equal headset_id in default headset list */
    switch(btibtp_delete_default_headset(dev_id))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)       MODULE  : MFW_BT              |
| STATE   : code                       ROUTINE :bt_disconnect_service|
+--------------------------------------------------------------------+

  PURPOSE : request disconnect of service

*/
T_MFW_BT_RESULT_BT bt_disconnect_service (T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_disconnect_service()");

  if((service EQ MFW_BT_HEADSET) OR
     (service EQ MFW_BT_DIAL_UP) OR
     (service EQ MFW_BT_FAX_GW))
  {
    switch(btibtp_disconnect_service_req((T_BTI_DEVICE_TYPE)service))
    { /* BTP_DISCONNECT_DEVICE_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)                MODULE  : MFW_BT     |
| STATE   : code                                ROUTINE :bt_send_pin |
+--------------------------------------------------------------------+

  PURPOSE : send the pin requesting by bt (for authorization)

*/
T_MFW_BT_RESULT_BT bt_send_pin (T_MFW_BT_BD_ADDR bd_addr[],
                             T_MFW_BT_PIN pin_code[],
                             T_MFW_BT_PIN_MODE pin_mode)
{
  UBYTE user_pin_code_length=4;

  TRACE_FUNCTION ("bt_send_pin()");

  if(pin_mode EQ PIN_PROVIDED)
  {     /* BTP_PIN_RES to BT */
    user_pin_code_length = strlen((const char *)pin_code);

    switch(btibtp_pin_res(user_pin_code_length, pin_code, bd_addr))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
  {/* if device isn't able to provide a PIN code */
    /* BTP_PIN_RES to BT */
    switch(btibtp_pin_res(0,0,bd_addr))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_authorization_reply |
+--------------------------------------------------------------------+

  PURPOSE : reply the authorization requesting by bt

*/
T_MFW_BT_RESULT_BT bt_authorization_reply (T_MFW_BT_BD_ADDR bd_addr[],
                                           T_MFW_BT_AUTHORIZATION_MASK mfw_auth_mask,
                                           T_MFW_BT_AUTHORIZATION_MODE auth_mode)
{
  T_BTI_AUTHORIZATION_MASK author_mask = 0;
  T_BTI_APPLI_NAME service_name[BTI_APPLI_NAME_LENGTH];
  U8 len;

  TRACE_FUNCTION ("bt_authorization_reply()");

  memset(service_name,0,BTI_APPLI_NAME_LENGTH);
  /*
  *** MFW_BT_AUTHORIZED_ONCE : remote device is granted access to the service once time
      MFW_BT_AUTHORIZED_ALWAYS:remote device is granted access to the service always
      MFW_BT_UNAUTHORIZED: local device does not give access to the service
  ***
  */
  if((auth_mode EQ MFW_BT_AUTHORIZED_ONCE) OR
     (auth_mode EQ MFW_BT_AUTHORIZED_ALWAYS) OR
     (auth_mode EQ MFW_BT_UNAUTHORIZED))
  {
    switch(mfw_auth_mask)
    {/* mask refer to the service (mask about BT_AUTHORIZATION_IND in MMI) */
      case MFW_SERVICE_HSG:
        memcpy(service_name,MFW_BT_SERV_HSG,sizeof(MFW_BT_SERV_HSG));
        len = sizeof(MFW_BT_SERV_HSG);
        break;
      case MFW_SERVICE_DUN:
        memcpy(service_name,MFW_BT_SERV_DUN,sizeof(MFW_BT_SERV_DUN));
        len = sizeof(MFW_BT_SERV_DUN);
        break;
      case MFW_SERVICE_FAX:
        memcpy(service_name,MFW_BT_SERV_FAX,sizeof(MFW_BT_SERV_FAX));
        len = sizeof(MFW_BT_SERV_FAX);
        break;
      case MFW_SERVICE_OPP:
        memcpy(service_name,MFW_BT_SERV_OPP,sizeof(MFW_BT_SERV_OPP));
        len = sizeof(MFW_BT_SERV_OPP);
        break;
      case MFW_SERVICE_SYNC_C:
        memcpy(service_name,MFW_BT_SERV_SYNC_C,sizeof(MFW_BT_SERV_SYNC_C));
        len = sizeof(MFW_BT_SERV_SYNC_C);
        break;
      default:
        return MFW_BT_NOK;
    }
    /* because authorization mask is SCM-depend MFW requests specify mask */
    if(btibtp_get_authorization_mask(service_name,len,&author_mask) NEQ BTP_OK)
    {
      TRACE_EVENT ("Error:bt_authorization_reply()");
      return MFW_BT_NOK;
    }
    else
    {
      switch(btibtp_authorization_reply(bd_addr,author_mask,auth_mode))
      {
        case BTP_OK:
          return MFW_BT_OK;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE  : MFW_BT                    |
| STATE   : code                 ROUTINE :bt_get_authorization_device|
+--------------------------------------------------------------------+

  PURPOSE:get authorizations to access available services on local device
*/
T_MFW_BT_RESULT_BT bt_get_authorization_device (T_MFW_BT_BD_ADDR bd_addr[],
                                            T_MFW_BT_AUTHORIZATION_MASK * mask)
{
  T_BTI_AUTHORIZATION_MASK author_mask,mask_hsg,mask_dun,mask_fax,mask_sync_cmd,mask_opp,auth_mask;

  T_BTI_APPLI_NAME service_name[BTI_APPLI_NAME_LENGTH];

  TRACE_FUNCTION ("bt_get_authorization_device()");

  memset(service_name,0,BTI_APPLI_NAME_LENGTH);
  author_mask = mask_hsg = mask_dun = mask_fax = mask_sync_cmd = mask_opp = auth_mask =0;

  switch(btibtp_get_authorization(bd_addr,&auth_mask))
  {/* auth_mask contains bits for several services, bits are SCM dependent */
    case BTP_OK:
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }

  memcpy(service_name,MFW_BT_SERV_DUN,sizeof(MFW_BT_SERV_DUN));
  switch(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_DUN),&author_mask))
  {/* get mask for service dial-up */
    case BTP_OK:
      mask_dun =  author_mask;
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
  memcpy(service_name,MFW_BT_SERV_HSG,sizeof(MFW_BT_SERV_HSG));
  switch(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_HSG),&author_mask))
  {/* get mask for service headset gateway */
    case BTP_OK:
      mask_hsg =  author_mask;
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
  memcpy(service_name,MFW_BT_SERV_FAX,sizeof(MFW_BT_SERV_FAX));
  switch(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_FAX),&author_mask))
  {/* get mask for service fax gateway */
    case BTP_OK:
      mask_fax =  author_mask;
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }

  memcpy(service_name,MFW_BT_SERV_OPP,sizeof(MFW_BT_SERV_OPP));
  switch(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_OPP),&author_mask))
  {/* get mask for service opp object push profile */
    case BTP_OK:
      mask_opp =  author_mask;
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }

  memcpy(service_name,MFW_BT_SERV_SYNC_C,sizeof(MFW_BT_SERV_SYNC_C));
  switch(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_SYNC_C),&author_mask))
  {/* get mask for service SYNC server with SYNC command support */
    case BTP_OK:
      mask_sync_cmd =  author_mask;
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
  *mask = 0;
  /* assemble mask for MMI */
  if((auth_mask & mask_hsg) EQ mask_hsg)
  {
    *mask = *mask | MFW_SERVICE_HSG;
  }
  if((auth_mask & mask_dun) EQ mask_dun)
  {
    *mask = *mask | MFW_SERVICE_DUN;
  }
  if((auth_mask & mask_fax) EQ mask_fax)
  {
    *mask = *mask | MFW_SERVICE_FAX;
  }
  if((auth_mask & mask_opp) EQ mask_opp)
  {
    *mask = *mask | MFW_SERVICE_OPP;
  }
  if((auth_mask & mask_sync_cmd) EQ mask_sync_cmd)
  {
    *mask = *mask | MFW_SERVICE_SYNC_C;
  }
  return MFW_BT_OK;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE  : MFW_BT                    |
| STATE   : code                 ROUTINE :bt_set_authorization_device|
+--------------------------------------------------------------------+

  PURPOSE:set authorization mask to access available service on local device
*/
T_MFW_BT_RESULT_BT bt_set_authorization_device (T_MFW_BT_BD_ADDR bd_addr[],
                                            T_MFW_BT_AUTHORIZATION_MASK mask)
{
  T_BTI_AUTHORIZATION_MASK author_mask = 0;
  T_BTI_APPLI_NAME service_name[BTI_APPLI_NAME_LENGTH];
  U8 len;

  TRACE_FUNCTION ("bt_set_authorization_device()");

  memset(service_name,0,BTI_APPLI_NAME_LENGTH);

  switch(mask)
  {
    case MFW_SERVICE_DUN:
      memcpy(service_name,MFW_BT_SERV_DUN,sizeof(MFW_BT_SERV_DUN));
      len = sizeof(MFW_BT_SERV_DUN);
      break;
    case MFW_SERVICE_HSG:
      memcpy(service_name,MFW_BT_SERV_HSG,sizeof(MFW_BT_SERV_HSG));
      len = sizeof(MFW_BT_SERV_HSG);
      break;
    case MFW_SERVICE_FAX:
      memcpy(service_name,MFW_BT_SERV_FAX,sizeof(MFW_BT_SERV_FAX));
      len = sizeof(MFW_BT_SERV_FAX);
      break;
    case MFW_SERVICE_OPP:
      memcpy(service_name,MFW_BT_SERV_OPP,sizeof(MFW_BT_SERV_OPP));
      len = sizeof(MFW_BT_SERV_OPP);
      break;
    case MFW_SERVICE_SYNC_C:
      memcpy(service_name,MFW_BT_SERV_SYNC_C,sizeof(MFW_BT_SERV_SYNC_C));
      len = sizeof(MFW_BT_SERV_SYNC_C);
      break;
    default:
      return MFW_BT_NOK;
  }

  if(btibtp_get_authorization_mask(service_name,len,&author_mask) NEQ BTP_OK)
  {/* get SCM dependent mask for specified service */
    TRACE_EVENT ("Error:bt_list_auth_dev()");
    return MFW_BT_RET_FAIL;
  }

  switch(btibtp_set_authorization(bd_addr,author_mask))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE  : MFW_BT                     |
| STATE   : code                 ROUTINE :bt_del_authorizations_device|
+---------------------------------------------------------------------+

  PURPOSE:delete all authorizations to access available services on local device
*/
T_MFW_BT_RESULT_BT bt_del_authorizations_device (T_MFW_BT_BD_ADDR bd_addr[])
{
  TRACE_FUNCTION ("bt_del_authorizations_device()");

  switch(btibtp_set_authorization(bd_addr,0))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)       MODULE  : MFW_BT              |
| STATE   : code                       ROUTINE :bt_del_authorization |
+--------------------------------------------------------------------+

  PURPOSE:delete an authorization to access available service on local device
*/
T_MFW_BT_RESULT_BT bt_del_authorization (T_MFW_BT_BD_ADDR bd_addr[],T_MFW_BT_AUTHORIZATION_MASK service_mask)
{
  T_BTI_AUTHORIZATION_MASK auth_mask,author_mask = 0;
  T_BTI_APPLI_NAME service_name[BTI_APPLI_NAME_LENGTH];
  U8 len;

  TRACE_EVENT ("bt_del_authorization()");

  memset(service_name,0,BTI_APPLI_NAME_LENGTH);

  switch(btibtp_get_authorization(bd_addr,&auth_mask))
  {/* give authorization mask with all authorizations of remote device */
    case BTP_OK:
      break;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }

  switch(service_mask)
  {
    case MFW_SERVICE_DUN:
      memcpy(service_name,MFW_BT_SERV_DUN,sizeof(MFW_BT_SERV_DUN));
      len = sizeof(MFW_BT_SERV_DUN);
      break;
    case MFW_SERVICE_HSG:
      memcpy(service_name,MFW_BT_SERV_HSG,sizeof(MFW_BT_SERV_HSG));
      len = sizeof(MFW_BT_SERV_HSG);
      break;
    case MFW_SERVICE_FAX:
      memcpy(service_name,MFW_BT_SERV_FAX,sizeof(MFW_BT_SERV_FAX));
      len = sizeof(MFW_BT_SERV_FAX);
      break;
    case MFW_SERVICE_OPP:
      memcpy(service_name,MFW_BT_SERV_OPP,sizeof(MFW_BT_SERV_OPP));
      len = sizeof(MFW_BT_SERV_OPP);
      break;
    case MFW_SERVICE_SYNC_C:
      memcpy(service_name,MFW_BT_SERV_SYNC_C,sizeof(MFW_BT_SERV_SYNC_C));
      len = sizeof(MFW_BT_SERV_SYNC_C);
      break;
    default:
      return MFW_BT_NOK;
  }

  if(btibtp_get_authorization_mask(service_name,len,&author_mask) NEQ BTP_OK)
  {/* give SCM dependent authorization mask for specified service */
    TRACE_EVENT ("Error:bt_list_auth_dev()");
    return MFW_BT_RET_FAIL;
  }
  else
  {
    if((auth_mask & author_mask) EQ author_mask)
    {
      auth_mask= auth_mask & ~author_mask;/* delete the specified authorization in mask*/
    }
    else
      return MFW_BT_INVALID_PARA;
  }

  switch(btibtp_set_authorization(bd_addr,auth_mask))
  {/* set authorization mask for remote device again */
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)           MODULE  : MFW_BT          |
| STATE   : code                           ROUTINE :bt_start_pairing |
+--------------------------------------------------------------------+

  PURPOSE : start pairing procedure

*/
T_MFW_BT_RESULT_BT bt_start_pairing (T_MFW_BT_BD_ADDR bd_addr[],
                                  T_MFW_BT_PIN pin_code[],
                                  T_MFW_BT_PIN_MODE pin_mode)
{
  UBYTE user_pin_code_length=4;

  TRACE_FUNCTION ("bt_start_pairing()");

  if(pin_mode EQ PIN_PROVIDED)
  {/* pairing provides to a link key between the gateway and the remote device */

    user_pin_code_length = strlen((const char *)pin_code);

    switch(btibtp_start_pairing(user_pin_code_length, pin_code, bd_addr))
    {
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;/* wrong pin */
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
  {/* if device isn't able to provide a PIN code */
    switch(btibtp_start_pairing(0,0,bd_addr))
    {
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)    MODULE  : MFW_BT                 |
| STATE   : code                    ROUTINE :bt_delete_paired_device |
+--------------------------------------------------------------------+

  PURPOSE : delete paired device from the paired devices database

*/
T_MFW_BT_RESULT_BT bt_delete_paired_device (T_MFW_BT_BD_ADDR bd_addr[])
{
  TRACE_FUNCTION ("bt_delete_paired_device()");

  switch(btibtp_delete_paired_device(bd_addr))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)              MODULE  : MFW_BT       |
| STATE   : code                              ROUTINE :bt_check_pair |
+--------------------------------------------------------------------+

  PURPOSE : check whether the device in the data base exists

*/
T_MFW_BT_RESULT_BT bt_check_pair (T_MFW_BT_BD_ADDR bd_addr[])
{
  TRACE_FUNCTION ("bt_check_pair()");

  switch(btibtp_check_pairing_state(bd_addr))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}
#ifdef _SIMULATION_
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)       MODULE  : MFW_BT              |
| STATE   : code                       ROUTINE :bt_transfer_audio_in |
+--------------------------------------------------------------------+

  PURPOSE : request transfer audio from headset to phone(headset gateway)

*/
T_MFW_BT_RESULT_BT bt_transfer_audio_in (T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_transfer_audio_in()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_transfer_audio_in_req((T_BTI_DEVICE_TYPE)service))
    {  /* BTP_TRANSFER_AUDIO_IN_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)       MODULE  : MFW_BT              |
| STATE   : code                       ROUTINE :bt_transfer_audio_out|
+--------------------------------------------------------------------+

  PURPOSE : request transfer audio from headset gateway(phone)to the
            remote headset
*/

T_MFW_BT_RESULT_BT bt_transfer_audio_out(T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_REQ_ID req_id,
                                      T_MFW_BT_BD_ADDR bd_addr[])
{
  TRACE_FUNCTION ("bt_transfer_audio_out()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_transfer_audio_out_req((T_BTI_DEVICE_TYPE)service,req_id,bd_addr))
    { /* BTP_TRANSFER_AUDIO_OUT_REQ to BT */
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  return MFW_BT_FAIL;
}
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)       MODULE  : MFW_BT              |
| STATE   : code                       ROUTINE :bt_list_paired_dev   |
+--------------------------------------------------------------------+

  PURPOSE : list all paired devices

*/
T_MFW_BT_RETURN  bt_list_paired_dev(T_MFW_BT_DEV_PAIR_LIST * pair_list)
{
  T_BT_DEV_PAIR_LIST paired_dev_list;
  U8 i;

  TRACE_FUNCTION ("bt_list_paired_dev()");

  memset(&paired_dev_list,0,sizeof(paired_dev_list));
   /* get list of devices of paired database */
  if(btibtp_list_paired_dev(&paired_dev_list) NEQ BTP_OK)
  {
    TRACE_EVENT ("Error:bt_list_paired_dev()");
    return MFW_BT_RET_FAIL;
  }
  else
  {
    pair_list->count = paired_dev_list.pair_counter;/* number of devices */
    for(i = 0;i<paired_dev_list.pair_counter; i++)
      memcpy(pair_list->paired_bd_addr[i],paired_dev_list.paired_addr[i],MFW_BT_ADDR_MAX_LEN);

    return MFW_BT_RET_OK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)         MODULE  : MFW_BT            |
| STATE   : code                         ROUTINE :bt_list_auth_dev   |
+--------------------------------------------------------------------+

  PURPOSE : list all devices of authorization database with their
            masks of available services on the local device

*/
T_MFW_BT_RETURN  bt_list_auth_dev(T_MFW_BT_AUTHORIZATION_LIST * authorization_list)
{
  T_BT_DEV_AUTHORIZATION_LIST auth_dev_list;
  U8 i;
  T_BTI_AUTHORIZATION_MASK mask_hsg,mask_dun,mask_fax,author_mask = 0;
  T_BTI_AUTHORIZATION_MASK mask_opp,mask_sync_cmd = 0;
  T_BTI_APPLI_NAME service_name[BTI_APPLI_NAME_LENGTH];

  TRACE_FUNCTION ("bt_list_auth_dev()");

  memset(&auth_dev_list,0,sizeof(auth_dev_list));
  memset(service_name,0,BTI_APPLI_NAME_LENGTH);
   /* get list of devices of authorization database */
  if(btibtp_list_auth_dev(&auth_dev_list) NEQ BTP_OK)
  {
    TRACE_EVENT ("Error:bt_list_auth_dev()");
    return MFW_BT_RET_FAIL;
  }
  else
  {
    memcpy(service_name,MFW_BT_SERV_DUN,sizeof(MFW_BT_SERV_DUN));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_DUN),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service DUN */
      TRACE_EVENT ("Error:bt_list_auth_dev()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_dun = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_HSG,sizeof(MFW_BT_SERV_HSG));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_HSG),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service HSG */
      TRACE_EVENT ("Error:bt_list_auth_dev()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_hsg = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_FAX,sizeof(MFW_BT_SERV_FAX));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_FAX),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service FAX */
      TRACE_EVENT ("Error:bt_list_auth_dev()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_fax = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_OPP,sizeof(MFW_BT_SERV_OPP));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_OPP),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service OPP */
      TRACE_EVENT ("Error:bt_list_auth_dev()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_opp = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_SYNC_C,sizeof(MFW_BT_SERV_SYNC_C));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_SYNC_C),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service SYNC server with SYNC command support */
      TRACE_EVENT ("Error:bt_list_auth_dev()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_sync_cmd = author_mask;
    }

    authorization_list->count = auth_dev_list.auth_counter;
    for(i = 0;i<auth_dev_list.auth_counter; i++)
    {
      memcpy(authorization_list->auth_devices[i].remote_bd_addr,auth_dev_list.auth_el[i].remote_addr,MFW_BT_ADDR_MAX_LEN);
      /* assemble mask for each device */
      if((auth_dev_list.auth_el[i].mask_auth & mask_hsg) EQ mask_hsg)
      {
        authorization_list->auth_devices[i].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_HSG;
      }

      if((auth_dev_list.auth_el[i].mask_auth & mask_dun) EQ mask_dun)
      {
        authorization_list->auth_devices[i].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_DUN;
      }

      if((auth_dev_list.auth_el[i].mask_auth & mask_fax) EQ mask_fax)
      {
        authorization_list->auth_devices[i].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_FAX;
      }

      if((auth_dev_list.auth_el[i].mask_auth & mask_opp) EQ mask_opp)
      {
        authorization_list->auth_devices[i].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_OPP;
      }

      if((auth_dev_list.auth_el[i].mask_auth & mask_sync_cmd) EQ mask_sync_cmd)
      {
        authorization_list->auth_devices[i].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_SYNC_C;
      }
    }
    return MFW_BT_RET_OK;
  }
}

/*
+-------------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)         MODULE  : MFW_BT                 |
| STATE   : code                         ROUTINE :bt_authorized_devices   |
+-------------------------------------------------------------------------+

  PURPOSE : list all devices of authorization database with desired
            authorization (service_mask)
*/
T_MFW_BT_RETURN  bt_authorized_devices(T_MFW_BT_AUTHORIZATION_LIST * authorization_list,T_MFW_BT_AUTHORIZATION_MASK service_mask )
{
  T_BT_DEV_AUTHORIZATION_LIST auth_dev_list;
  U8 i,j;
  T_BTI_AUTHORIZATION_MASK author_mask,mask_hsg,mask_dun,mask_fax,mask_opp = 0;
  T_BTI_AUTHORIZATION_MASK mask_sync_cmd = 0;
  T_BTI_APPLI_NAME service_name[BTI_APPLI_NAME_LENGTH];

  TRACE_EVENT ("bt_authorized_devices()");

  memset(&auth_dev_list,0,sizeof(auth_dev_list));
  memset(service_name,0,BTI_APPLI_NAME_LENGTH);
   /* get list of devices of authorization database */
  if(btibtp_list_auth_dev(&auth_dev_list) NEQ BTP_OK)
  {
    TRACE_EVENT ("Error:bt_authorized_devices()");
    return MFW_BT_RET_FAIL;
  }
  else
  {
    memcpy(service_name,MFW_BT_SERV_DUN,sizeof(MFW_BT_SERV_DUN));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_DUN),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service DUN */
      TRACE_EVENT ("Error:bt_authorized_devices()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_dun = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_HSG,sizeof(MFW_BT_SERV_HSG));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_HSG),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service HSG */
      TRACE_EVENT ("Error:bt_authorized_devices()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_hsg = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_FAX,sizeof(MFW_BT_SERV_FAX));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_FAX),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service FAX */
      TRACE_EVENT ("Error:bt_authorized_devices()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_fax = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_OPP,sizeof(MFW_BT_SERV_OPP));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_OPP),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service OPP */
      TRACE_EVENT ("Error:bt_authorized_devices()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_opp = author_mask;
    }
    memcpy(service_name,MFW_BT_SERV_SYNC_C,sizeof(MFW_BT_SERV_SYNC_C));
    if(btibtp_get_authorization_mask(service_name,sizeof(MFW_BT_SERV_SYNC_C),&author_mask) NEQ BTP_OK)
    {/* get SCM-dependent authorization mask of service SYNC server with SYN command support */
      TRACE_EVENT ("Error:bt_authorized_devices()");
      return MFW_BT_RET_FAIL;
    }
    else
    {
      mask_sync_cmd = author_mask;
    }

    for(i=0,j=0;i<auth_dev_list.auth_counter; i++)
    {
      switch(service_mask)
      {
        case MFW_SERVICE_HSG:
          if((auth_dev_list.auth_el[i].mask_auth & mask_hsg) EQ mask_hsg)
          {
            authorization_list->auth_devices[j].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_HSG;
            memcpy(authorization_list->auth_devices[j].remote_bd_addr,auth_dev_list.auth_el[i].remote_addr,MFW_BT_ADDR_MAX_LEN);
            authorization_list->count++;
            j++;
          }
          break;
        case MFW_SERVICE_DUN:
          if((auth_dev_list.auth_el[i].mask_auth & mask_dun) EQ mask_dun)
          {
            authorization_list->auth_devices[j].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_DUN;
            memcpy(authorization_list->auth_devices[j].remote_bd_addr,auth_dev_list.auth_el[i].remote_addr,MFW_BT_ADDR_MAX_LEN);
            authorization_list->count++;
            j++;
          }
          break;
        case MFW_SERVICE_FAX:
          if((auth_dev_list.auth_el[i].mask_auth & mask_fax) EQ mask_fax)
          {
            authorization_list->auth_devices[j].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_FAX;
            memcpy(authorization_list->auth_devices[j].remote_bd_addr,auth_dev_list.auth_el[i].remote_addr,MFW_BT_ADDR_MAX_LEN);
            authorization_list->count++;
            j++;
          }
          break;
        case MFW_SERVICE_OPP:
          if((auth_dev_list.auth_el[i].mask_auth & mask_opp) EQ mask_opp)
          {
            authorization_list->auth_devices[j].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_OPP;
            memcpy(authorization_list->auth_devices[j].remote_bd_addr,auth_dev_list.auth_el[i].remote_addr,MFW_BT_ADDR_MAX_LEN);
            authorization_list->count++;
            j++;
          }
          break;
        case MFW_SERVICE_SYNC_C:
          if((auth_dev_list.auth_el[i].mask_auth & mask_sync_cmd) EQ mask_sync_cmd)
          {
            authorization_list->auth_devices[j].mask_authorization = authorization_list->auth_devices[i].mask_authorization | MFW_SERVICE_SYNC_C;
            memcpy(authorization_list->auth_devices[j].remote_bd_addr,auth_dev_list.auth_el[i].remote_addr,MFW_BT_ADDR_MAX_LEN);
            authorization_list->count++;
            j++;
          }
          break;
        default:
          return MFW_BT_RET_FAIL;
      }
    }
    return MFW_BT_RET_OK;
  }
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_clear_list_found_dev|
+--------------------------------------------------------------------+

  PURPOSE : clear list of found devices with theirs service id's

*/
T_MFW_BT_RETURN bt_clear_list_found_dev (void)
{
  T_MFW_BT_DEVICE_ID *help_ptr;
  T_MFW_BT_DEVICE_ID *help_h_ptr;

  TRACE_FUNCTION ("bt_clear_list_found_dev()");

  if(service_list.device_id) /* check:is list of found hs empty ?*/
  {
    help_ptr = service_list.device_id->next;
    MFREE(service_list.device_id);   /* free memory first element */
    service_list.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr);               /* free next elements */
      help_ptr = help_h_ptr;
      service_list.device_id = help_ptr;
    }
  }
  return MFW_BT_RET_OK;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)MODULE  : MFW_BT                     |
| STATE   : code               ROUTINE :bt_clear_all_lists_found_serv|
+--------------------------------------------------------------------+

  PURPOSE : clear all list of found  services

*/
T_MFW_BT_RETURN bt_clear_all_lists_found_serv (void)
{
  T_MFW_BT_SERVICE_ID *help_ptr;
  T_MFW_BT_SERVICE_ID *help_h_ptr;

  TRACE_FUNCTION ("bt_clear_all_lists_found_serv()");

  if(found_headset.device_id)  /* check: is list of found hs empty ? */
  {
    help_ptr = found_headset.device_id->next;
    MFREE(found_headset.device_id->bd_name);/* free name of first element */
    MFREE(found_headset.device_id);         /* free memory first element */
    found_headset.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr->bd_name);          /* free name of next elements */
      MFREE(help_ptr);                   /* free next elements */
      help_ptr = help_h_ptr;
      found_headset.device_id = help_ptr;
    }
  }
  if(found_dial_up.device_id)/* check: is list of found dun empty ? */
  {
    help_ptr = found_dial_up.device_id->next;
    MFREE(found_dial_up.device_id->bd_name);/* free name of first element */
    MFREE(found_dial_up.device_id);       /* free memory first element */
    found_dial_up.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr->bd_name);          /* free name of next elements */
      MFREE(help_ptr);                   /* free next elements */
      help_ptr = help_h_ptr;
      found_dial_up.device_id = help_ptr;
    }
  }
  if(found_fax.device_id)/* check: is list of found fax empty ? */
  {
    help_ptr = found_fax.device_id->next;
    MFREE(found_fax.device_id->bd_name);/* free name of first element */
    MFREE(found_fax.device_id);       /* free memory first element */
    found_fax.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr->bd_name);          /* free name of next elements */
      MFREE(help_ptr);                   /* free next elements */
      help_ptr = help_h_ptr;
      found_fax.device_id = help_ptr;
    }
  }
  if(found_opp.device_id)/* check: is list of found OPP  empty ? */
  {
    help_ptr = found_opp.device_id->next;
    MFREE(found_opp.device_id->bd_name);/* free name of first element */
    MFREE(found_opp.device_id);       /* free memory first element */
    found_opp.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr->bd_name);          /* free name of next elements */
      MFREE(help_ptr);                   /* free next elements */
      help_ptr = help_h_ptr;
      found_opp.device_id = help_ptr;
    }
  }
  if(found_sync.device_id)/* check: is list of found SYNC server empty ? */
  {
    help_ptr = found_sync.device_id->next;
    MFREE(found_sync.device_id->bd_name);/* free name of first element */
    MFREE(found_sync.device_id);       /* free memory first element */
    found_sync.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr->bd_name);          /* free name of next elements */
      MFREE(help_ptr);                   /* free next elements */
      help_ptr = help_h_ptr;
      found_sync.device_id = help_ptr;
    }
  }
  if(found_sync_cmd.device_id)/* check: is list of found SYNC_CMD server  empty ? */
  {
    help_ptr = found_sync_cmd.device_id->next;
    MFREE(found_sync_cmd.device_id->bd_name);/* free name of first element */
    MFREE(found_sync_cmd.device_id);       /* free memory first element */
    found_sync_cmd.device_id = help_ptr;
    while(help_ptr)
    {
      help_h_ptr = help_ptr->next;
      MFREE(help_ptr->bd_name);          /* free name of next elements */
      MFREE(help_ptr);                   /* free next elements */
      help_ptr = help_h_ptr;
      found_sync_cmd.device_id = help_ptr;
    }
  }
  return MFW_BT_RET_OK;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)    MODULE  : MFW_BT                 |
| STATE   : code                    ROUTINE :bt_clear_list_found_serv|
+--------------------------------------------------------------------+

  PURPOSE : clear list of specific found service

*/
T_MFW_BT_RETURN bt_clear_list_found_serv (T_MFW_BT_SERVICE_TYPE service)
{
  T_MFW_BT_SERVICE_ID *help_ptr;
  T_MFW_BT_SERVICE_ID *help_h_ptr;

  TRACE_FUNCTION ("bt_clear_list_found_serv()");

  if(service EQ MFW_BT_HEADSET)
  {
    if(found_headset.device_id)  /* check: is list of found hs  empty ? */
    {
      help_ptr = found_headset.device_id->next;
      MFREE(found_headset.device_id->bd_name);/* free name of first element */
      MFREE(found_headset.device_id);   /* free memory first element */
      found_headset.device_id = help_ptr;
      while(help_ptr)
      {
        help_h_ptr = help_ptr->next;
        MFREE(help_ptr->bd_name);         /* free name of next elements */
        MFREE(help_ptr);               /* free next elements */
        help_ptr = help_h_ptr;
        found_headset.device_id = help_ptr;
      }
    }
    return MFW_BT_RET_OK;
  }
  else if(service EQ MFW_BT_DIAL_UP)
  {/* check: is list of found dun   empty ? */
    if(found_dial_up.device_id)
    {
      help_ptr = found_dial_up.device_id->next;
      MFREE(found_dial_up.device_id->bd_name);/* free name of first element */
      MFREE(found_dial_up.device_id);   /* free memory first element */
      found_dial_up.device_id = help_ptr;
      while(help_ptr)
      {
        help_h_ptr = help_ptr->next;
        MFREE(help_ptr->bd_name);      /* free name of next elements */
        MFREE(help_ptr);               /* free next elements */
        help_ptr = help_h_ptr;
        found_dial_up.device_id = help_ptr;
      }
    }
    return MFW_BT_RET_OK;
  }
  else if(service EQ MFW_BT_FAX_GW)
  {/* check: is list of found fax empty ? */
    if(found_fax.device_id)
    {
      help_ptr = found_fax.device_id->next;
      MFREE(found_fax.device_id->bd_name);/* free name of first element */
      MFREE(found_fax.device_id);   /* free memory first element */
      found_fax.device_id = help_ptr;
      while(help_ptr)
      {
        help_h_ptr = help_ptr->next;
        MFREE(help_ptr->bd_name);      /* free name of next elements */
        MFREE(help_ptr);               /* free next elements */
        help_ptr = help_h_ptr;
        found_fax.device_id = help_ptr;
      }
    }
    return MFW_BT_RET_OK;
  }
  else if(service EQ MFW_BT_OPP)
  {/* check: is list of found OPP  empty ? */
    if(found_opp.device_id)
    {
      help_ptr = found_opp.device_id->next;
      MFREE(found_opp.device_id->bd_name);/* free name of first element */
      MFREE(found_opp.device_id);   /* free memory first element */
      found_opp.device_id = help_ptr;
      while(help_ptr)
      {
        help_h_ptr = help_ptr->next;
        MFREE(help_ptr->bd_name);      /* free name of next elements */
        MFREE(help_ptr);               /* free next elements */
        help_ptr = help_h_ptr;
        found_opp.device_id = help_ptr;
      }
    }
    return MFW_BT_RET_OK;
  }
  else if(service EQ MFW_BT_SYNC)
  {/* check: is list of found SYNC server  empty ? */
    if(found_sync.device_id)
    {
      help_ptr = found_sync.device_id->next;
      MFREE(found_sync.device_id->bd_name);/* free name of first element */
      MFREE(found_sync.device_id);   /* free memory first element */
      found_sync.device_id = help_ptr;
      while(help_ptr)
      {
        help_h_ptr = help_ptr->next;
        MFREE(help_ptr->bd_name);      /* free name of next elements */
        MFREE(help_ptr);               /* free next elements */
        help_ptr = help_h_ptr;
        found_sync.device_id = help_ptr;
      }
    }
    return MFW_BT_RET_OK;
  }
  else if(service EQ MFW_BT_SYNC_CMD)
  {/* check:is list of found SYNC server with support SYN commands  empty ? */
    if(found_sync_cmd.device_id)
    {
      help_ptr = found_sync_cmd.device_id->next;
      MFREE(found_sync_cmd.device_id->bd_name);/* free name of first element */
      MFREE(found_sync_cmd.device_id);   /* free memory first element */
      found_sync_cmd.device_id = help_ptr;
      while(help_ptr)
      {
        help_h_ptr = help_ptr->next;
        MFREE(help_ptr->bd_name);      /* free name of next elements */
        MFREE(help_ptr);               /* free next elements */
        help_ptr = help_h_ptr;
        found_sync_cmd.device_id = help_ptr;
      }
    }
    return MFW_BT_RET_OK;
  }
  else
    return MFW_BT_RET_FAIL;
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE :bt_set_param_headset|
+--------------------------------------------------------------------+

  PURPOSE:remote control of speaker or microphone gain (profile headset)
*/

T_MFW_BT_RESULT_BT bt_set_param_headset (T_MFW_BT_SERVICE_TYPE service,
                                         T_MFW_BT_PARAM_NUMBER nb,
                                         T_MFW_BT_CHANGE_PARA type,
                                         U16 new_value)
{
  TRACE_FUNCTION ("bt_set_param_headset()");
  if(service EQ MFW_BT_HEADSET)
  {
    /* update parameter speaker or microphone */
    if((nb EQ MFW_BT_MIC_GAIN) OR
       (nb EQ MFW_BT_SPEAKER_GAIN))
    {/* increase or decrease (+1/-1) or set new value */
      if((type EQ MFW_BT_PARA_INC) OR
         (type EQ MFW_BT_PARA_DEC) OR
         (type EQ MFW_BT_PARA_SET))
      {
        if(type EQ MFW_BT_PARA_SET)
        {/* for set value valid value is needed */
          if(!new_value)
          {
            return MFW_BT_NOK;
          }
        }

        switch(btibtp_set_param_headset(nb,type,new_value))
        {
          case BTP_OK:
            return MFW_BT_OK;
          case BTP_INVALID_PARAMETER:
            return MFW_BT_INVALID_PARA;
          case BTP_NOT_SUPP:
            return MFW_BT_NO_SUPP;
          case BTP_NOT_READY:
            return MFW_BT_NOT_READY;
          case BTP_INT_ERR:
            return MFW_BT_INT_ERR;
          case BTP_MEMORY_ERR:
            return MFW_BT_MEM_ERR;
          case BTP_NOK:
            return MFW_BT_NOK;
        }
      }
      else
        return MFW_BT_NOK;
    }
    else
       return MFW_BT_FAIL;
  }
  else
     return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE  : MFW_BT                    |
| STATE   : code                 ROUTINE :bt_get_default_service_info|
+--------------------------------------------------------------------+

  PURPOSE:get device info from default headset list
*/
T_MFW_BT_RESULT_BT bt_get_default_service_info (T_MFW_BT_SERVICE_TYPE service,
                                            T_MFW_BT_DEV_ID dev_id,
                                            T_MFW_BT_HEADSET_INFO *hs_info)
{
  T_BTI_HSG_DEFAULT_INFO headset_info;

  TRACE_FUNCTION ("bt_get_default_service_info()");

  memset(&headset_info,0,sizeof(headset_info));

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_get_headset_info(dev_id,&headset_info))
    {
      case BTP_OK:
        hs_info->priority = headset_info.priority;
        memcpy(hs_info->bd_addr,headset_info.bd_addr,sizeof(headset_info.bd_addr));
        memcpy(hs_info->hsg_name,headset_info.name,MFW_BT_HSG_NAME_MAX_LEN);
        hs_info->mfw_remote_audio_control_support = headset_info.bt_remote_audio_control_support;
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE  : MFW_BT                    |
| STATE   : code                 ROUTINE :bt_set_prio_default_service|
+--------------------------------------------------------------------+

  PURPOSE:set priority in default headset list
*/
T_MFW_BT_RESULT_BT bt_set_prio_default_service (T_MFW_BT_SERVICE_TYPE service,
                                  T_MFW_BT_DEV_ID dev_id,
                                  T_MFW_BT_PRIORITY priority)
{
  TRACE_FUNCTION ("bt_set_prio_default_service()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_set_prio_default_headset(dev_id,priority))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
  {
    TRACE_EVENT ("bt_set_prio_default_service:Error");
    return MFW_BT_FAIL;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)            MODULE  : MFW_BT         |
| STATE   : code                            ROUTINE :bt_get_config   |
+--------------------------------------------------------------------+

  PURPOSE:get configuration parameters of bluetooth profile headset
*/
T_MFW_BT_RESULT_BT  bt_get_config (T_MFW_BT_SERVICE_TYPE service,
                                T_MFW_BT_HSG_CLIENT_CONFIG *client_conf,
                                T_MFW_BT_HSG_SERVER_CONFIG *server_conf)
{
  T_BTI_HSG_CLIENT_CONF bt_client_conf;
  T_BTI_HSG_SERVER_CONF bt_server_conf;

  TRACE_FUNCTION ("bt_get_config()");

  memset(&bt_client_conf,0,sizeof(bt_client_conf));
  memset(&bt_server_conf,0,sizeof(bt_server_conf));

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_get_config((T_BTI_DEVICE_TYPE)service,&bt_client_conf,&bt_server_conf))
    {
      case BTP_OK:
        switch(bt_client_conf.config_mode)
        {
          case BTI_AUTO_OUTG_DEF_CONN_OFF:
            client_conf->config_mode = MFW_BT_AUTO_OUTG_DEF_CONN_OFF;
            break;
          case BTI_AUTO_OUTG_DEF_CONN_ON:
            client_conf->config_mode = MFW_BT_AUTO_OUTG_DEF_CONN_ON;
            break;
          default:
            return MFW_BT_INVALID_PARA;
        }
        client_conf->security = bt_client_conf.security;

        server_conf->security = bt_server_conf.security;
        server_conf->serv_con_conf = bt_server_conf.conn_config;
        server_conf->conn_break = bt_server_conf.conn_break;
        server_conf->conn_time = bt_server_conf.conn_time;
        server_conf->nb_phone = bt_server_conf.nb_phone;
        memcpy(server_conf->mfw_phone_list,bt_server_conf.phon_list,sizeof(bt_server_conf.phon_list));
        memcpy(server_conf->mfw_key_list,bt_server_conf.key_list,sizeof(bt_server_conf.key_list));
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}
#ifdef _SIMULATION_
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)            MODULE  : MFW_BT         |
| STATE   : code                            ROUTINE :bt_save_config  |
+--------------------------------------------------------------------+

  PURPOSE:save configuration parameters of bluetooth profile headset
*/
T_MFW_BT_RESULT_BT  bt_save_config (T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_save_config()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_save_config((T_BTI_DEVICE_TYPE)service))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)           MODULE  : MFW_BT          |
| STATE   : code                           ROUTINE :bt_restore_config|
+--------------------------------------------------------------------+

  PURPOSE:restore configuration parameters of bluetooth profile headset
*/
T_MFW_BT_RESULT_BT  bt_restore_config (T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_restore_config()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_restore_config((T_BTI_DEVICE_TYPE)service))
    {
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)        MODULE  : MFW_BT             |
| STATE   : code                        ROUTINE :bt_save_default_list|
+--------------------------------------------------------------------+

  PURPOSE: save default headset list in non-volatile memory
*/
T_MFW_BT_RESULT_BT  bt_save_default_list (T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_save_default_list()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_save_def_list((T_BTI_DEVICE_TYPE)service))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_restore_default_list|
+--------------------------------------------------------------------+

  PURPOSE: restore default headset list from non-volatile memory
*/
T_MFW_BT_RESULT_BT bt_restore_default_list (T_MFW_BT_SERVICE_TYPE service)
{
  TRACE_FUNCTION ("bt_restore_default_list()");

  if(service EQ MFW_BT_HEADSET)
  {
    switch(btibtp_restore_def_list((T_BTI_DEVICE_TYPE)service))
    {
      case BTP_OK:
        return MFW_BT_EXECUTE;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}
#endif
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE : bt_set_security_mode  |
+--------------------------------------------------------------------+

  PURPOSE: set common security mode
*/
T_MFW_BT_RESULT_BT  bt_set_security_mode (T_MFW_BT_SECURITY_MODE sec_mode)
{
  TRACE_FUNCTION ("bt_set_security_mode()");

  /* security mode 1: local device will never initiate any security procedure,
                      only services which registered their security requirements
                      as no-security, will be usable
     security mode 2: local device shall initiate security procedure
                      according to the requirements of the requested service
     security mode 3: local device will initiate security procedures
                      before setting up the link and informing the host,
                      some services with no security requirements may be unusable */
  if((sec_mode EQ MFW_BT_SECURITY_MODE_1) OR
     (sec_mode EQ MFW_BT_SECURITY_MODE_2) OR
     (sec_mode EQ MFW_BT_SECURITY_MODE_3))
  {
    switch(btibtp_set_sec_mode((T_BTI_SM_SECURITY_MODE)sec_mode))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)         MODULE  : MFW_BT            |
| STATE   : code                         ROUTINE : bt_set_pair_mode  |
+--------------------------------------------------------------------+

  PURPOSE: set pairing mode
*/
T_MFW_BT_RESULT_BT  bt_set_pair_mode (T_MFW_BT_PAIRABLE_MODE pair_mode)
{
  TRACE_FUNCTION ("bt_set_pair_mode()");

  if((pair_mode EQ MFW_BT_PAIRABLE) OR
     (pair_mode EQ MFW_BT_NON_PAIRABLE))
  {
    switch(btibtp_set_pair_mode((T_BTI_SM_PAIRABLE_MODE)pair_mode))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;
      case BTP_NOT_SUPP:
        return MFW_BT_NO_SUPP;
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;
      case BTP_NOK:
        return MFW_BT_NOK;
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+------------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)      MODULE  : MFW_BT                   |
| STATE   : code                      ROUTINE : bt_set_default_security  |
+------------------------------------------------------------------------+

  PURPOSE: set default security requirements
*/
T_MFW_BT_RESULT_BT  bt_set_default_security (U8 security_level)
{
  TRACE_FUNCTION ("bt_set_default_security()");

  /* set security level of BT protocol stack for incoming and outgoing
     connections - this determines the security level needed to access
     any unregistered services */

  switch(btibtp_set_default_security(security_level))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE : MFW_BT                     |
| STATE   : code                 ROUTINE:bt_start_profile_application|
+--------------------------------------------------------------------+

  PURPOSE : start bluetooth application

*/
T_MFW_BT_RESULT_BT  bt_start_profile_application (T_MFW_BT_SERVICE_TYPE service)
{
  /* start to activate bluetooth profiles, create resources and the profile
     instance */

  TRACE_FUNCTION ("bt_start_profile_application()");

  if((service EQ MFW_BT_HEADSET) OR
     (service EQ MFW_BT_DIAL_UP) OR
     (service EQ MFW_BT_FAX_GW) OR
     (service EQ MFW_BT_OPP) OR
     (service EQ MFW_BT_SYNC) OR
     (service EQ MFW_BT_PCA_GW))
  {
    switch(btibtp_start((T_BTI_DEVICE_TYPE) service))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;/* appli_name is not known by BTE */
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;/* appli_name is already running */
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;/* appli_name does not have a get_info function */
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;/* problem of memory in BTE */
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445) MODULE : MFW_BT                     |
| STATE   : code                 ROUTINE:bt_stop_profile_application |
+--------------------------------------------------------------------+

  PURPOSE : start bluetooth application

*/
T_MFW_BT_RESULT_BT  bt_stop_profile_application (T_MFW_BT_SERVICE_TYPE service)
{
  /* start to activate bluetooth profiles, create resources and the profile
     instance */

  TRACE_FUNCTION ("bt_stop_profile_application()");

  if((service EQ MFW_BT_HEADSET) OR
     (service EQ MFW_BT_DIAL_UP) OR
     (service EQ MFW_BT_FAX_GW) OR
     (service EQ MFW_BT_OPP) OR
     (service EQ MFW_BT_SYNC) OR
     (service EQ MFW_BT_PCA_GW))
  {
    switch(btibtp_stop((T_BTI_DEVICE_TYPE) service))
    {
      case BTP_OK:
        return MFW_BT_OK;
      case BTP_INVALID_PARAMETER:
        return MFW_BT_INVALID_PARA;/* appli_name is not known by BTE */
      case BTP_NOT_READY:
        return MFW_BT_NOT_READY;/* appli_name is already running */
      case BTP_INT_ERR:
        return MFW_BT_INT_ERR;/* appli_name does not have a get_info function */
      case BTP_MEMORY_ERR:
        return MFW_BT_MEM_ERR;/* problem of memory in BTE */
    }
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE : bt_register_sm   |
+--------------------------------------------------------------------+

  PURPOSE : start bluetooth security manager

*/
T_MFW_BT_RESULT_BT bt_register_sm (void)
{
  TRACE_FUNCTION ("bt_register_sm()");

  /* mandatory registration in order to handle requests from SCM -
     Security Manager - authentication and authorization */

  switch(btibtp_register_sm())/* set callback function */
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      TRACE_EVENT ("Error:bt_register_sm()");
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)          MODULE  : MFW_BT           |
| STATE   : code                          ROUTINE : bt_deregister_sm |
+--------------------------------------------------------------------+

  PURPOSE : stop bluetooth security manager

*/
T_MFW_BT_RESULT_BT bt_deregister_sm(void)
{
  TRACE_EVENT ("bt_deregister_sm()");

  /* mandatory deregistration  */

  switch(btibtp_deregister_sm())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      TRACE_EVENT ("Error:bt_deregister_sm()");
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}
/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_opp_put_reply       |
+--------------------------------------------------------------------+

  PURPOSE : reply the put requesting by opp client (about server)
*/
T_MFW_BT_RESULT_BT bt_opp_put_reply ( T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype,
                                      T_MFW_BT_OPP_PUT_RES opp_put_res,
                                      T_MFW_BT_OPP_OBJECT received_obj)
{
  T_BTI_OPP_OBJECT bti_opp_object;
  T_BTI_OPP_PUT_RES bti_opp_put_res;

  TRACE_EVENT ("bt_opp_put_reply()");

  memset(&bti_opp_object,0,sizeof(T_BTI_OPP_OBJECT));

  if(service EQ MFW_BT_OPP)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      /*
      *** MFW_BT_OPP_CONTINUE : positive response
          MFW_BT_OPP_R_ENTITY_TOO_L:negative response,the request is too big
          MFW_BT_OPP_FORBIDDEN: negative response, put is rejected
      ***
      */
      if(opp_put_res EQ MFW_BT_OPP_CONTINUE)
      {
        switch(received_obj.mfw_object_type)
        {
          case MFW_BT_BUFFER:/* object will be supposed to be stored in buffer */
            bti_opp_object.bt_object_type = BTI_TYPE_BUFFER;
            bti_opp_object.bt_buffer_start = received_obj.mfw_buffer_start;
            bti_opp_object.bt_buffer_size = received_obj.mfw_buffer_size;
            break;
          case MFW_BT_PATH:/* object will be supposed to be stored in file system */
            bti_opp_object.bt_object_type = BTI_TYPE_PATH;
            bti_opp_object.bt_path = received_obj.mfw_path;
            break;
          default:
            return MFW_BT_FAIL;
        }
        bti_opp_object.bt_object_name = received_obj.mfw_object_name;
        bti_opp_object.bt_object_length = received_obj.mfw_object_length;

        switch(btibtp_opp_put_resp((T_BTI_OPP_PUT_RES)opp_put_res,bti_opp_object))
        {
          case BTP_OK:
            return MFW_BT_OK;
          case BTP_INVALID_PARAMETER:
            return MFW_BT_INVALID_PARA;
          case BTP_NOT_SUPP:
            return MFW_BT_NO_SUPP;
          case BTP_NOT_READY:
            return MFW_BT_NOT_READY;
          case BTP_INT_ERR:
            return MFW_BT_INT_ERR;
          case BTP_MEMORY_ERR:
            return MFW_BT_MEM_ERR;
          case BTP_NOK:
            return MFW_BT_NOK;
        }
      }
      else if((opp_put_res EQ MFW_BT_OPP_R_ENTITY_TOO_L) OR
              (opp_put_res EQ MFW_BT_OPP_FORBIDDEN))
      {
        switch(opp_put_res)
        {
          case MFW_BT_OPP_R_ENTITY_TOO_L:
            bti_opp_put_res = BTI_OPP_TOO_LARGE;
            break;
          case MFW_BT_OPP_FORBIDDEN:
            bti_opp_put_res = BTI_OPP_FORBIDDEN;
            break;
          default:
            return MFW_BT_FAIL;
        }
        switch(btibtp_opp_put_resp(bti_opp_put_res,bti_opp_object))
        {
          case BTP_OK:
            return MFW_BT_OK;
          case BTP_INVALID_PARAMETER:
            return MFW_BT_INVALID_PARA;
          case BTP_NOT_SUPP:
            return MFW_BT_NO_SUPP;
          case BTP_NOT_READY:
            return MFW_BT_NOT_READY;
          case BTP_INT_ERR:
            return MFW_BT_INT_ERR;
          case BTP_MEMORY_ERR:
            return MFW_BT_MEM_ERR;
          case BTP_NOK:
            return MFW_BT_NOK;
        }
      }
      else
        return MFW_BT_FAIL;
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_opp_push_object     |
+--------------------------------------------------------------------+

  PURPOSE : push an object to OPP server

*/
T_MFW_BT_RESULT_BT bt_opp_push_object (T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype,
                                      T_MFW_BT_BD_ADDR server_address[],
                                      BOOL mfw_keep_connection,
                                      T_MFW_BT_OPP_OBJECT mfw_obj_to_push)
{
  T_BTI_OPP_OBJECT bti_opp_object_to_push;

  TRACE_FUNCTION ("bt_opp_push_object()");

  memset(&bti_opp_object_to_push,0,sizeof(T_BTI_OPP_OBJECT));

  if(service EQ MFW_BT_OPP)
  {
    if(subtype EQ MFW_BT_CLIENT)
    {
      switch(mfw_obj_to_push.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object to be sent is stored in buffer */
          bti_opp_object_to_push.bt_object_type = BTI_TYPE_BUFFER;
          bti_opp_object_to_push.bt_buffer_start = mfw_obj_to_push.mfw_buffer_start;
          bti_opp_object_to_push.bt_buffer_size = mfw_obj_to_push.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object to be sent is stored in file system */
          bti_opp_object_to_push.bt_object_type = BTI_TYPE_PATH;
          bti_opp_object_to_push.bt_path = mfw_obj_to_push.mfw_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* MIME type of object to be sent */
      bti_opp_object_to_push.bt_object_mime_type = mfw_obj_to_push.mfw_object_mime_type;
      /* name of object to be sent */
      bti_opp_object_to_push.bt_object_name = mfw_obj_to_push.mfw_object_name;
      /* length of object to be sent */
      bti_opp_object_to_push.bt_object_length = mfw_obj_to_push.mfw_object_length;

      switch(btibtp_opp_push_object(bti_opp_object_to_push,server_address,mfw_keep_connection))
      {
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_opp_pull_object     |
+--------------------------------------------------------------------+

  PURPOSE : pull an default server object from OPP server

*/
T_MFW_BT_RESULT_BT bt_opp_pull_object (T_MFW_BT_SERVICE_TYPE service,
                                       T_MFW_BT_SUBTYPE_DEV subtype,
                                       T_MFW_BT_BD_ADDR server_address[],
                                       BOOL mfw_keep_connection,
                                       T_MFW_BT_OPP_OBJECT mfw_obj_to_pull)
{
  T_BTI_OPP_OBJECT bti_opp_object_to_pull;

  TRACE_FUNCTION ("bt_opp_pull_object()");

  memset(&bti_opp_object_to_pull,0,sizeof(T_BTI_OPP_OBJECT));

  if(service EQ MFW_BT_OPP)
  {
    if(subtype EQ MFW_BT_CLIENT)
    {
      switch(mfw_obj_to_pull.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object to be pulled will be supposed to be stored in buffer */
          bti_opp_object_to_pull.bt_object_type = BTI_TYPE_BUFFER;
          bti_opp_object_to_pull.bt_buffer_start = mfw_obj_to_pull.mfw_buffer_start;
          bti_opp_object_to_pull.bt_buffer_size = mfw_obj_to_pull.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object to be pulled will be supposed to be stored in file system */
          bti_opp_object_to_pull.bt_object_type = BTI_TYPE_PATH;
          bti_opp_object_to_pull.bt_path = mfw_obj_to_pull.mfw_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* MIME type of object to be pulled */
      bti_opp_object_to_pull.bt_object_mime_type = mfw_obj_to_pull.mfw_object_mime_type;
      /* name of object to be pulled */
      bti_opp_object_to_pull.bt_object_length = mfw_obj_to_pull.mfw_object_length;
      /* length of object to be pulled */
      bti_opp_object_to_pull.bt_object_name = mfw_obj_to_pull.mfw_object_name;
      switch(btibtp_opp_pull_object(bti_opp_object_to_pull,server_address,mfw_keep_connection))
      {
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                |
| STATE   : code                     ROUTINE :bt_opp_exch_objects    |
+--------------------------------------------------------------------+

  PURPOSE : exchange business cards with OPP server

*/
T_MFW_BT_RESULT_BT bt_opp_exch_objects (T_MFW_BT_SERVICE_TYPE service,
                                        T_MFW_BT_SUBTYPE_DEV subtype,
                                        T_MFW_BT_OPP_OBJECT obj_to_push,
                                        T_MFW_BT_OPP_OBJECT obj_to_pull,
                                        T_MFW_BT_BD_ADDR server_address[],
                                        BOOL mfw_keep_connection)
{
  T_BTI_OPP_OBJECT bti_opp_object_to_pull;
  T_BTI_OPP_OBJECT bti_opp_object_to_push;

  TRACE_FUNCTION ("bt_opp_exch_objects()");

  memset(&bti_opp_object_to_push,0,sizeof(T_BTI_OPP_OBJECT));
  memset(&bti_opp_object_to_pull,0,sizeof(T_BTI_OPP_OBJECT));

  if(service EQ MFW_BT_OPP)
  {
    if(subtype EQ MFW_BT_CLIENT)
    {
      switch(obj_to_push.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object to be pushed is stored in buffer */
          bti_opp_object_to_push.bt_object_type = BTI_TYPE_BUFFER;
          bti_opp_object_to_push.bt_buffer_start = obj_to_push.mfw_buffer_start;
          bti_opp_object_to_push.bt_buffer_size = obj_to_push.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object to be pushed is stored in file system */
          bti_opp_object_to_push.bt_object_type = BTI_TYPE_PATH;
          bti_opp_object_to_push.bt_path = obj_to_push.mfw_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* MIME type of object to be pushed */
      bti_opp_object_to_push.bt_object_mime_type = obj_to_push.mfw_object_mime_type;
      /* name of object to be pushed */
      bti_opp_object_to_push.bt_object_name = obj_to_push.mfw_object_name;
      /* length of object to be pushed */
      bti_opp_object_to_push.bt_object_length = obj_to_push.mfw_object_length;

      switch(obj_to_pull.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object to be pulled will be supposed to be stored in buffer */
          bti_opp_object_to_pull.bt_object_type = BTI_TYPE_BUFFER;
          bti_opp_object_to_pull.bt_buffer_start = obj_to_pull.mfw_buffer_start;
          bti_opp_object_to_pull.bt_buffer_size = obj_to_pull.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object to be pulled will be supposed to be stored in file system */
          bti_opp_object_to_pull.bt_object_type = BTI_TYPE_PATH;
          bti_opp_object_to_pull.bt_path = obj_to_pull.mfw_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /*  MIME type of object to be pulled */
      bti_opp_object_to_pull.bt_object_mime_type = obj_to_pull.mfw_object_mime_type;
      /*  length of object to be pulled */
      bti_opp_object_to_pull.bt_object_length = obj_to_pull.mfw_object_length;
      /*  name of object to be pulled */
      bti_opp_object_to_pull.bt_object_name = obj_to_pull.mfw_object_name;

      switch(btibtp_opp_exch_objects(bti_opp_object_to_push,bti_opp_object_to_pull,
                                     server_address,mfw_keep_connection))
      {
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_syn_s_send_com       |
+----------------------------------------------------------------------+

  PURPOSE : SYNC server send SYN command to SYNC client with
            SYNC command support

*/
T_MFW_BT_RESULT_BT bt_syn_s_send_com (T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype,
                                      T_MFW_BT_SYNC_COMMAND sync_comm,
                                      T_MFW_BT_SYN_OBJECT_STORE sync_object,
                                      T_MFW_BT_BD_ADDR sync_client_address[])
{
  T_BTI_SYNC_COMMAND bt_sync_com;
  T_BTI_SYN_OBJECT_STORE bt_sync_object;

  TRACE_FUNCTION ("bt_syn_s_send_com()");

  bt_sync_object = (T_BTI_SYN_OBJECT_STORE)sync_object;

  if(service EQ MFW_BT_SYNC)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      switch(sync_comm)
      {
        case MFW_BT_SYNC_CO_SYNC:
          /* SYNC server push command: SYNC synchronization initiated by Server */
          bt_sync_com = sync_comm;
          break;
        case MFW_BT_SYNC_CO_PUT:
          /* SYNC server push command: PUT */
          bt_sync_com = sync_comm;
          break;
        default:
          return MFW_BT_FAIL;
      }

      switch(btibtp_sync_ser_send_com(bt_sync_com,bt_sync_object,sync_client_address))
      {
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_syn_s_auth_res       |
+----------------------------------------------------------------------+

  PURPOSE : SYNC server sends authentication response

*/
T_MFW_BT_RESULT_BT bt_syn_s_auth_res (T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype,
                                      T_MFW_BT_SYN_PASSWD * mfw_sync_password)
{
  TRACE_FUNCTION ("bt_syn_s_auth_res()");

  if(service EQ MFW_BT_SYNC)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      if(mfw_sync_password)
      {
        switch(btibtp_sync_ser_auth_res(mfw_sync_password))
        {
          case BTP_OK:
            return MFW_BT_OK;
          case BTP_INVALID_PARAMETER:
            return MFW_BT_INVALID_PARA;
          case BTP_NOT_SUPP:
            return MFW_BT_NO_SUPP;
          case BTP_NOT_READY:
            return MFW_BT_NOT_READY;
          case BTP_INT_ERR:
            return MFW_BT_INT_ERR;
          case BTP_MEMORY_ERR:
            return MFW_BT_MEM_ERR;
          case BTP_NOK:
            return MFW_BT_NOK;
        }
      }
      else
        return MFW_BT_INVALID_PARA;
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_syn_s_sync_terminate |
+----------------------------------------------------------------------+

  PURPOSE : SYNC server terminates synchronization

*/
T_MFW_BT_RESULT_BT bt_syn_s_sync_terminate (T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype)
{
  TRACE_FUNCTION ("bt_syn_s_sync_terminate()");

  if(service EQ MFW_BT_SYNC)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      switch(btibtp_sync_syn_terminate())
      {
        case BTP_OK:
          return MFW_BT_OK;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_syn_s_pull_resp      |
+----------------------------------------------------------------------+

  PURPOSE : SYNC server sends pull request response

*/
T_MFW_BT_RESULT_BT bt_syn_s_pull_resp (T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype,
                                      T_MFW_BT_SYNC_OBJECT mfw_syn_pull_obj)
{
  T_BTI_SYNC_OBJECT syn_pull_object;

  TRACE_FUNCTION ("bt_syn_s_pull_resp()");

  memset(&syn_pull_object,0,sizeof(syn_pull_object));

  if(service EQ MFW_BT_SYNC)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      switch(mfw_syn_pull_obj.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object to be pulled will be supposed to be stored in buffer */
          syn_pull_object.bt_object_type = BTI_TYPE_BUFFER;
          syn_pull_object.bt_buffer_start = mfw_syn_pull_obj.mfw_buffer_start;
          syn_pull_object.bt_buffer_size = mfw_syn_pull_obj.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object to be pulled will be supposed to be stored in file system */
          syn_pull_object.bt_object_type = BTI_TYPE_PATH;
          syn_pull_object.bt_path = mfw_syn_pull_obj.mfw_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* MIME type of object to be pulled */
      syn_pull_object.bt_object_mime_type = mfw_syn_pull_obj.mfw_object_mime_type;
      /* name of object to be pulled */
      syn_pull_object.bt_object_length = mfw_syn_pull_obj.mfw_object_length;
      /* length of object to be pulled */
      syn_pull_object.bt_object_name = mfw_syn_pull_obj.mfw_object_name;

      switch(btibtp_sync_ser_pull_res(syn_pull_object))
      {
        case BTP_OK:
          return MFW_BT_OK;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE : bt_syn_s_push_resp      |
+----------------------------------------------------------------------+

  PURPOSE : SYNC server sends push request response

*/
T_MFW_BT_RESULT_BT bt_syn_s_push_resp (T_MFW_BT_SERVICE_TYPE service,
                                      T_MFW_BT_SUBTYPE_DEV subtype,
                                      T_MFW_BT_SYNC_OBJECT mfw_syn_push_obj)
{
  T_BTI_SYNC_OBJECT syn_push_object;

  TRACE_FUNCTION ("bt_syn_s_push_resp()");

  memset(&syn_push_object,0,sizeof(syn_push_object));

  if(service EQ MFW_BT_SYNC)
  {
    if(subtype EQ MFW_BT_SERVER)
    {
      switch(mfw_syn_push_obj.mfw_object_type)
      {
        case MFW_BT_BUFFER:/* object to be pulled will be supposed to be stored in buffer */
          syn_push_object.bt_object_type = BTI_TYPE_BUFFER;
          syn_push_object.bt_buffer_start = mfw_syn_push_obj.mfw_buffer_start;
          syn_push_object.bt_buffer_size = mfw_syn_push_obj.mfw_buffer_size;
          break;
        case MFW_BT_PATH:/* object to be pulled will be supposed to be stored in file system */
          syn_push_object.bt_object_type = BTI_TYPE_PATH;
          syn_push_object.bt_path = mfw_syn_push_obj.mfw_path;
          break;
        default:
          return MFW_BT_FAIL;
      }
      /* MIME type of object to be pulled */
      syn_push_object.bt_object_mime_type = mfw_syn_push_obj.mfw_object_mime_type;
      /* name of object to be pulled */
      syn_push_object.bt_object_length = mfw_syn_push_obj.mfw_object_length;
      /* length of object to be pulled */
      syn_push_object.bt_object_name = mfw_syn_push_obj.mfw_object_name;

      switch(btibtp_sync_ser_push_res(syn_push_object))
      {
        case BTP_OK:
          return MFW_BT_EXECUTE;
        case BTP_INVALID_PARAMETER:
          return MFW_BT_INVALID_PARA;
        case BTP_NOT_SUPP:
          return MFW_BT_NO_SUPP;
        case BTP_NOT_READY:
          return MFW_BT_NOT_READY;
        case BTP_INT_ERR:
          return MFW_BT_INT_ERR;
        case BTP_MEMORY_ERR:
          return MFW_BT_MEM_ERR;
        case BTP_NOK:
          return MFW_BT_NOK;
      }
    }
    else
      return MFW_BT_FAIL;
  }
  else
    return MFW_BT_FAIL;
}

/* BT CTRL */

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_set_conn_mode(T_MFW_BT_CONNECTABLE_MODE cmode,
                           UINT16 scan_interval,
                           UINT16 scan_window)
{
  TRACE_FUNCTION ("bt_set_conn_mode()");

  switch(btibtp_set_conn_mode(cmode, scan_interval, scan_window))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }

}


/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_set_disc_mode(T_MFW_BT_DISCOVERABLE_MODE dmode,
                           UINT16 scan_interval,
                           UINT16 scan_window)
{
  TRACE_FUNCTION ("bt_set_disc_mode()");

  switch(btibtp_set_disc_mode(dmode, scan_interval, scan_window))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_get_local_name(void)
{
  TRACE_FUNCTION ("bt_get_local_name()");

  switch(btibtp_get_local_name())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_set_local_name(T_MFW_BT_BD_NAME name[])
{
  TRACE_FUNCTION ("bt_set_local_name()");

  switch(btibtp_set_local_name(name))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_get_bd_addr(void)
{
  TRACE_FUNCTION ("bt_get_bd_addr()");

  switch(btibtp_get_bd_addr())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_get_remote_dev_info(T_MFW_BT_BD_ADDR bd_addr[])
{
  TRACE_FUNCTION ("bt_get_remote_dev_info()");

  switch(btibtp_get_remote_dev_info(bd_addr))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_start_btctrl(void)
{
  TRACE_FUNCTION ("bt_start_btctrl()");

  switch(btibtp_start_btctrl())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_stop_btctrl(void)
{
  TRACE_FUNCTION ("bt_stop_btctrl()");

  switch(btibtp_stop_btctrl())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/* enable profiles */
/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_enable_hsg_profile(void)
{
  TRACE_FUNCTION ("bt_enable_hsg_profile()");
  switch(btibtp_enable_hsg_profile())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_enable_dun_profile(void)
{
  TRACE_FUNCTION ("bt_enable_dun_profile()");
  switch(btibtp_enable_dun_profile())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_enable_fax_profile(void)
{
  TRACE_FUNCTION ("bt_enable_fax_profile()");
  switch(btibtp_enable_fax_profile())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_hsg_client_disable(void)
{
  TRACE_FUNCTION ("bt_hsg_client_disable()");
  switch(btibtp_hsg_client_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_hsg_server_disable(void)
{
  TRACE_FUNCTION ("bt_hsg_server_disable()");
  switch(btibtp_hsg_server_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_dun_gw_disable(void)
{
  TRACE_FUNCTION ("bt_dun_gw_disable()");
  switch(btibtp_dun_gw_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_fax_gw_disable(void)
{
  TRACE_FUNCTION ("bt_fax_gw_disable()");
  switch(btibtp_fax_gw_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_opp_client_disable(void)
{
  TRACE_FUNCTION ("bt_opp_client_disable()");
  switch(btibtp_opp_client_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_opp_server_disable(void)
{
  TRACE_FUNCTION ("bt_opp_server_disable()");
  switch(btibtp_opp_server_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*
+----------------------------------------------------------------------+
| PROJECT : MMI-Framework (8445)     MODULE  : MFW_BT                  |
| STATE   : code                     ROUTINE :                         |
+----------------------------------------------------------------------+

  PURPOSE :
*/
T_MFW_BT_RESULT_BT bt_syn_server_disable(void)
{
  TRACE_FUNCTION ("bt_syn_server_disable()");
  switch(btibtp_syn_server_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

/*#ifdef PCA_6350*/
T_MFW_BT_RESULT_BT bt_pca_gw_enable (void)
{
  TRACE_FUNCTION ("bt_pca_gw_enable()");
  switch(btibtp_pca_gw_enable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

T_MFW_BT_RESULT_BT bt_pca_gw_config (T_MFW_BT_PCA_CONFIG event_filters)
{
  T_BTI_PCA_CONF events;
  TRACE_FUNCTION ("bt_pca_gw_config()");

  events.link_filter = (T_BTI_PCA_LINK_EVENT)event_filters.link_event;
  events.call_filter = (T_BTI_PCA_CALL_EVENT)event_filters.call_event;

  switch(btibtp_pca_gw_config (events))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

T_MFW_BT_RESULT_BT bt_pca_gw_security (UINT8  security_level)
{
  TRACE_FUNCTION ("bt_pca_gw_security()");
  switch(btibtp_pca_gw_security (security_level))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

T_MFW_BT_RESULT_BT bt_pca_gw_hangup (void)
{
  TRACE_FUNCTION ("bt_pca_gw_hangup()");
  switch(btibtp_pca_gw_hangup())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}

T_MFW_BT_RESULT_BT bt_pca_gw_disable (void)
{
  TRACE_FUNCTION ("bt_pca_gw_disable()");
  switch(btibtp_pca_gw_disable())
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}


/*#endif*/ /* PCA_6350 */


/* Cartman added begin */

T_MFW_BT_RESULT_BT bt_hsg_connect_network (T_MFW_BT_HSG_CONNECT_NETWORK_ANSWER network_answer,
                                                  T_MFW_BT_HSG_CONNECT_NETWORK_TYPE network_type,
                                                  T_MFW_BT_HSG_PHONE_NUMBER phone_nb[])
{
  TRACE_FUNCTION ("bt_hsg_connect_network()");
  switch(btibtp_hsg_connect_network(network_answer,network_type,phone_nb))
  {
    case BTP_OK:
      return MFW_BT_EXECUTE;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}


T_MFW_BT_RESULT_BT bt_hsg_send_specific_cmd_to_hs (T_MFW_BT_HSG_SPECIFIC_CMD_TYPE command_type,
                                                  T_MFW_BT_HSG_CMD_TO_HS cmd[])
{
  TRACE_FUNCTION ("bt_hsg_send_specific_cmd_to_hs()");
  switch(btibtp_hsg_send_specific_cmd_to_hs(command_type,cmd))
  {
    case BTP_OK:
      return MFW_BT_EXECUTE;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}


T_MFW_BT_RESULT_BT bt_dun_gw_security (UINT8  security_level)
{
  TRACE_FUNCTION ("bt_dun_gw_security()");
  switch(btibtp_dun_gw_security (security_level))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}


T_MFW_BT_RESULT_BT bt_opp_client_security (UINT8  security_level)
{
  TRACE_FUNCTION ("bt_opp_client_security()");
  switch(btibtp_opp_client_security (security_level))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}


T_MFW_BT_RESULT_BT bt_opp_server_security (UINT8  security_level)
{
  TRACE_FUNCTION ("bt_opp_server_security()");
  switch(btibtp_opp_server_security (security_level))
  {
    case BTP_OK:
      return MFW_BT_OK;
    case BTP_INVALID_PARAMETER:
      return MFW_BT_INVALID_PARA;
    case BTP_NOT_SUPP:
      return MFW_BT_NO_SUPP;
    case BTP_NOT_READY:
      return MFW_BT_NOT_READY;
    case BTP_INT_ERR:
      return MFW_BT_INT_ERR;
    case BTP_MEMORY_ERR:
      return MFW_BT_MEM_ERR;
    case BTP_NOK:
      return MFW_BT_NOK;
  }
}


/* Cartman added end */