--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/mfw/mfw_bt_dm.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,1214 @@
+/*
++-------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8445)		$Workfile:: mfw_bt_dm.c			$|
+| $Author:: NDH						$Revision::  1						$|
+| CREATED: 22.04.04					$Modtime:: 22.04.04 11:07			$|
+| STATE  : code														 |
++-------------------------------------------------------------------+
+
+
+   MODULE  : MFW_BT_DM
+
+   PURPOSE : This module contains the functions for MFW Bluetooth Device Manager Profile
+
+
+*/
+
+#define ENTITY_MFW
+
+#include <string.h>
+
+#if defined (NEW_FRAME)
+
+#include "typedefs.h"
+#include "vsi.h"
+#include "pei.h"
+#include "custom.h"
+#include "gsm.h"
+
+#else
+
+#include "STDDEFS.H"
+#include "custom.h"
+#include "gsm.h"
+#include "vsi.h"
+
+#endif
+
+#include "bta_riviera.h"
+#include "mfw_bte.h"
+#include "mfw_bt_dm.h"
+#include "mfw_bt_geh.h"
+#include "mfw_bt_flash.h"
+
+
+T_MFW_BT_CB 			mfw_bt_cb;
+
+/* file where is stored bd address of the device to connect */
+#ifndef MFW_BT_BD_ADDR_FILE
+#define MFW_BT_BD_ADDR_FILE "/bt/remote_bd"
+#endif
+
+static T_MFW_BT_STATUS mfw_bt_dm_trust_device(BOOLEAN is_trusted, BD_ADDR bd_addr);
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_set_visibility
+
+ $Description:		set visibility of local BT device
+
+ $Returns:		T_MFW_BT_STATUS. Success or fail.	
+
+ $Arguments:		is_visible: new visibility setting. is_temp: define whether it is a temporary
+ 				modification ( TRUE ) or a permanent one ( FALSE ).
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_set_visibility( BOOL is_visible, BOOL is_temp)
+{
+	/* other devices will be able to find this device during an inquiry */
+	if( mfw_bt_cb.is_started == TRUE )
+		BTA_DmSetVisibility( 	(is_visible)?BTA_DM_GENERAL_DISC:BTA_DM_NON_DISC, 
+    								BTA_DM_CONN);	
+
+	if( is_temp == TRUE)
+		/* it looks like this is only a temporary change  => don't store that in flash! */
+		return MFW_BT_SUCCESS;
+
+	/* update to nvram and mfw_bt_cfg */
+    	return mfw_bt_store_visibility( is_visible );
+}
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_get_visibility
+
+ $Description:		get visibility of local BT device
+
+ $Returns:		TRUE if visible, FALSE if not.
+
+ $Arguments:		none
+
+*******************************************************************************/
+BOOL mfw_bt_dm_get_visibility( void )
+{
+	return mfw_bt_read_visibility( );
+}
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_get_local_name
+
+ $Description:		read  local BT device name
+
+ $Returns:		a pointer to a string. NULL if no name available. One should make a copy of
+ 				string if he wants to use it/modify it. 
+
+ $Arguments:		none
+
+*******************************************************************************/
+UINT8 * mfw_bt_dm_get_local_name( void )
+{
+	return mfw_bt_read_local_name();
+}
+
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_set_local_name
+
+ $Description:		set local BT device name
+
+ $Returns:		T_MFW_BT_STATUS	
+
+ $Arguments:		new name. Pointer to a string. This string is copied locally. Buffer is not freed.
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_set_local_name( INT8 *name )
+{
+	if( strlen((char*)name) == 0 )
+	{
+		/* BMI should never ever send back an empty string, except at start-up */
+		if( mfw_bt_cb.is_name_requested == FALSE )
+			return MFW_BT_FAIL;
+		
+		/* we are here, this means:
+			- it's a start-up
+			- apparently, the local name was never set. => it's the first start-up
+			- the user don't really want to use BT as he cancelled the setting.
+		=> this means we do want to stop BT... So go for it!  :o)  */
+		mfw_bt_disable( );
+		return MFW_BT_SUCCESS;
+	}	
+
+	if( mfw_bt_cb.is_name_requested == TRUE )
+		mfw_bt_cb.is_name_requested = FALSE;
+
+	if( strlen((char*)name) > MFW_BT_NAME_LENGTH )
+		return MFW_BT_INVALID_DATA;
+	
+	if( mfw_bt_cb.is_started )
+		BTA_DmSetDeviceName( (char*)name );
+	/* update to nv memory and mfw_bt_cfg with new name */
+	return mfw_bt_store_local_name( (char*) name );
+}
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_get_bt_status
+
+ $Description:		get the status of the local Bluetooth system. Used at start-up to decide whether
+ 				or not we want BT to be started by default.
+
+ $Returns:		MFW_BT_SUCCESS is BT is started. 0 if OFF	
+
+ $Arguments:		
+
+*******************************************************************************/
+BOOL mfw_bt_dm_get_bt_status( void )
+{
+	return mfw_bt_read_status( );
+
+}
+
+
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_pin_code
+
+ $Description:		used by BMI to send back a pin code
+
+ $Returns:		T_MFW_BT_STATUS. 	MFW_BT_NOT_INITIALISED is BT is not started.
+
+ $Arguments:		pin code and pin code length. This data is copied.
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_pin_code(UINT8* pin_code, UINT8 pin_len)
+{
+	BOOLEAN accept = TRUE;
+
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+	
+	if(pin_len == 0)
+	    accept = FALSE;
+	BTA_DmPinReply( 	mfw_bt_cb.peer_bdaddr, 
+	                			accept,   
+	                			pin_len, 
+	                			pin_code);
+
+	return MFW_BT_SUCCESS;
+}
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_bond
+
+ $Description:		used by BMI to send a pin code in order to establish a bonding with a 
+ 				remote device.
+
+ $Returns:		T_MFW_BT_STATUS. MFW_BT_NOT_INITIALISED is BT is not started.
+ 				
+
+ $Arguments:		BD_ADDR of the remote device, pin code and pin code length. Data is copied.
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_bond(BD_ADDR bd_addr, UINT8* pin_code, UINT8 pin_len )
+{
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+	
+
+	MFW_BT_TRACE("try to bond with stored device");
+	if(pin_len != 0)
+	{
+		/* now tell the BT stack */
+		BTA_DmBond (	bd_addr,	pin_len,  pin_code );		
+		return MFW_BT_SUCCESS;		
+	}
+	else
+	{
+		MFW_BT_TRACE("  [ mfw_bt dm bond]: no pin code entered!");
+		return MFW_BT_FAIL;
+	}
+
+}
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_authorize_resp
+
+ $Description:		used to answer to an authorization request
+
+ $Returns:		T_MFW_BT_STATUS. SUCCESS/FAIL, but also:
+ 				MFW_BT_NOT_INITIALISED is BT is not started. 
+ 				MFW_BT_INVALID_DATA if auth value is not correct.
+ 				MFW_BT_UNKNOWN_DEVICE if BD_addr is not recognized.
+ 				MFW_BT_DATA_BASE_FULL if there are already too many devices in the DB.
+ 				
+
+ $Arguments:		MFW_BT_AUTH_FAIL to refuse, 
+ 				MFW_BT_AUTH_ONCE to grant access temporarily,
+ 				MFW_BT_AUTH_ALWAYS to grant permanent access
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_authorize_resp( T_MFW_BT_AUTHORIZE auth)
+{
+	T_MFW_BT_STATUS status;
+	
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+	
+	switch (auth)
+	{
+	case MFW_BT_AUTH_FAIL:
+		/* reject */
+		BTA_DmAuthorizeReply(	mfw_bt_cb.peer_bdaddr, 
+								mfw_bt_cb.peer_service,
+		                     			BTA_DM_NOT_AUTH);
+		mfw_bt_dm_trust_device( FALSE, mfw_bt_cb.peer_bdaddr );
+		break;
+		
+	case MFW_BT_AUTH_ALWAYS:
+		/*
+		** CQ22024 : Set the device as Trusted, and Authorise it for this an all subsequent connections
+		**			If writing to the Flash fails, proceed with the authorisation anyway.
+		*/
+		status = mfw_bt_dm_trust_device( TRUE, mfw_bt_cb.peer_bdaddr );
+
+		/*
+		** Even if we fail to write the information to the FLASH, we should continue with the
+		** Authorisation procedure. If the device is unknown, the device will remain Authorised as
+		** long as the Handset is not powered down (Not ideal, but better than refusing Authorisation all together)
+		*/
+		BTA_DmAuthorizeReply(	mfw_bt_cb.peer_bdaddr, 
+								mfw_bt_cb.peer_service,
+								BTA_DM_AUTH_PERM);
+		break;
+		
+	case MFW_BT_AUTH_ONCE:
+		/* CQ22024 : tell the BT stack we authorize the device, but for this connection only */
+		BTA_DmAuthorizeReply(	mfw_bt_cb.peer_bdaddr, 
+								mfw_bt_cb.peer_service,
+								BTA_DM_AUTH_TEMP);
+		break;
+
+	default:
+		return MFW_BT_INVALID_DATA;
+	}
+	return MFW_BT_SUCCESS;
+}
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_sig_strength
+
+ $Description:		ask for the link quality
+
+ $Returns:		T_MFW_BT_STATUS. MFW_BT_NOT_INITIALISED if BT is not started.
+
+ $Arguments:		T_MFW_BT_DM_SIG_STRENGTH sig_strength,  UINT16 period, 	BOOLEAN is_on
+				See BTA documentation for more details.
+				
+*******************************************************************************/
+T_MFW_BT_STATUS	mfw_bt_dm_sig_strength (	T_MFW_BT_DM_SIG_STRENGTH sig_strength,
+													UINT16 period,
+													BOOLEAN is_on )
+{
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+	BTA_DmSignalStrength((tBTA_SIG_STRENGTH_MASK) sig_strength,  period,  is_on);
+	return MFW_BT_SUCCESS;
+}
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_get_known_devices
+
+ $Description:		used by BMI to get the list of known devices for a specified condition: either a 
+ 				service mask, either a bd address ( union ). 
+ 				MFW will fill in the variables: pp_device => table of known devices
+ 				number_of_devices => number of devices.
+ 				MFW will allocate memory for each device found. It's up to BMI to free it!
+
+ $Returns:		T_MFW_BT_STATUS. 
+ 				If BD_ADDR is specified, might return MFW_BT_UNKNOWN_DEVICE.
+ 				 The answers will be returned using BMI signals:
+ 				- E_BT_DM_INQ_CMPL with the number of devices
+ 				- E_BT_DM_DISC_RES for each device
+ 				- then E_BT_DM_DISC_CMPL when it's done.
+ 
+ $Arguments:		BD_ADDR if looking for a particular device. services if looking for a 
+ 				category of device. If bd_addr is specified, ignore services. If services set
+ 				to 0, will return all the known devices.
+
+*******************************************************************************/
+void mfw_bt_dm_get_known_devices ( 	BD_ADDR bd_addr,
+											T_MFW_BT_SERVICE_MASK services)
+{
+	T_MFW_BT_REM_DEVICE *ptr_db_device[MFW_BT_NUM_REM_DEVICE];
+	UINT8 i, number_of_devices;
+	T_MFW_BT_DM_INQ_CMPL inq_cmpl_res;
+	T_MFW_BT_STATUS status;
+	BD_ADDR null_bd_addr;
+	
+	number_of_devices = 0;
+	memset(&null_bd_addr[0], 0x00, sizeof(BD_ADDR));
+	
+	/* we have a BT address, try to find the related data */
+	/* CQ21834 : cannot treat bd_addr as a pointer, because it is passed by value. Use MemCmp */
+	if( memcmp(&bd_addr[0], &null_bd_addr[0], sizeof(BD_ADDR)) != 0 )
+	{
+		ptr_db_device[0] = mfw_bt_get_device_info(bd_addr);
+		
+		if(ptr_db_device[0] != NULL)
+		{
+			if((ptr_db_device[0])->is_new == FALSE)
+				number_of_devices = 1;
+		}
+	}
+	else
+	{
+		/* Now we want to find all the devices which support the given services */
+		mfw_bt_get_device_by_service(services, &ptr_db_device[0], &number_of_devices );
+	}
+
+	/* first send the number of found devices. this is important! BMI shouldn't do anything
+	before he gets all the answer */
+	inq_cmpl_res.num_resps = number_of_devices;
+	mfw_bt_signal( E_BT_DM_INQ_CMPL, (void*)&inq_cmpl_res);
+	
+	if (number_of_devices > 0)
+	{
+		/*
+		** CQ21834 : The incorrect structure was being used for the signal, so the data was never received by the BMI.
+		*/
+		T_MFW_BT_DM_DISC_RES disc_res;
+
+		/* now for each device found, send a signal to BMI. This will copy the data! */	
+		for( i=0; i<number_of_devices; i++ )
+		{
+			memcpy((void *)&disc_res, (void *)ptr_db_device[i], sizeof(disc_res));
+
+			mfw_bt_signal( E_BT_DM_DISC_RES, (void *)&disc_res);
+		}
+
+		mfw_bt_signal( E_BT_DM_DISC_CMPL, NULL);
+	}
+	
+	return;
+	
+}
+
+
+
+
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_trust_device
+
+ $Description:		specify whether a remote device should or not be trusted ( => access granted )
+
+ $Returns:		T_MFW_BT_STATUS	
+ 				success, failure, MFW_BT_UNKNOWN_DEVICE
+
+ $Arguments:		BOOLEAN for the permission; BD address of the remote device
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_trust_device(BOOLEAN is_trusted, BD_ADDR bd_addr)
+{
+	T_MFW_BT_REM_DEVICE * p_device;
+	T_MFW_BT_STATUS status;
+	
+	/* check if we know this device*/
+	if(( p_device = mfw_bt_get_device_info(bd_addr)) == NULL )
+		/* unknown device... */
+		return MFW_BT_UNKNOWN_DEVICE;
+		
+	p_device->is_trusted = is_trusted;
+	if (( status = mfw_bt_flash_store_device(p_device)) != MFW_BT_SUCCESS )
+		return status;
+
+	/* update BTA with new settings */
+	if( mfw_bt_cb.is_started )
+	{
+		if(p_device->link_key_present)
+			BTA_DmAddDevice(bd_addr, p_device->link_key, BTA_ALL_SERVICE_MASK, is_trusted);
+		else 
+			BTA_DmAddDevice(bd_addr, NULL, BTA_ALL_SERVICE_MASK, is_trusted);
+	}
+
+	return MFW_BT_SUCCESS;
+ }
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_delete_device
+
+ $Description:		remove a device from the local DB
+ 
+ $Returns:		T_MFW_BT_STATUS ( MFW_BT_SUCCESS, MFW_BT_FAIL, MFW_BT_UNKNOWN_DEVICE )	
+
+ $Arguments:		BD address
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_delete_device(BD_ADDR bd_addr)
+{
+	if( mfw_bt_cb.is_started )
+		BTA_DmRemoveDevice (bd_addr);
+	return mfw_bt_flash_delete_device(bd_addr);
+}
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_add_device
+
+ $Description:		This will store permanently a device in Flash.
+
+ $Returns:		T_MFW_BT_STATUS
+ 				errors: MFW_BT_UNKNOWN_DEVICE, MFW_BT_DATA_BASE_FULL, 
+ 				
+
+ $Arguments:		new BD address
+
+*******************************************************************************/
+ T_MFW_BT_STATUS mfw_bt_dm_add_device(BD_ADDR bd_addr)
+{
+	T_MFW_BT_REM_DEVICE *p_device;
+	T_MFW_BT_STATUS status;
+	
+	MFW_BT_TRACE("mfw_bt_dm_add_device()");
+
+	/* get the info about this device */
+	if( ( p_device = mfw_bt_get_device_info( bd_addr)) == NULL)
+		return MFW_BT_UNKNOWN_DEVICE;
+	
+	if( p_device->is_new == TRUE )
+	{
+		/*
+		** CQ21834 : Ensure that the is_new value is set before writing the data to Flash, so that it will be
+		**			set correctly when  the handset is restarted.
+		*/
+		p_device->is_new = FALSE;
+		if((status = mfw_bt_flash_store_device(p_device))!=MFW_BT_SUCCESS)
+			return status;
+	}
+	
+	/* update BTA device database */
+	if( mfw_bt_cb.is_started )
+	{
+		if(p_device->link_key_present)
+			BTA_DmAddDevice(p_device->bd_addr, p_device->link_key,
+		                    p_device->trusted_services, p_device->is_trusted);
+		else 
+		    	BTA_DmAddDevice(p_device->bd_addr, NULL,
+		                    p_device->trusted_services, p_device->is_trusted);
+	}
+	return MFW_BT_SUCCESS;
+
+}
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_rename_device
+
+ $Description:		modify the friendly name of a known ( already stored ) remote device
+
+ $Returns:		T_MFW_BT_STATUS.
+ 				MFW_BT_UNKNOWN_DEVICE, DATA_BASE_FULL, MFW_BT_INVALID_DATA...
+
+ $Arguments:		bd address of the remote device and the new name associated
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_rename_device(BD_ADDR bd_addr, UINT8* new_name)
+{
+	T_MFW_BT_REM_DEVICE *p_device;
+
+	if( ( p_device = mfw_bt_get_device_info( bd_addr)) == NULL )
+		return MFW_BT_UNKNOWN_DEVICE;
+	/* if this device is new ( == in the inq DB ), we don't want to do anything */
+	if( p_device->is_new == TRUE )
+		return MFW_BT_FAIL;
+	/* verify the string is OK */
+	if( strlen( (char*)new_name ) > MFW_BT_NAME_LENGTH )
+		return MFW_BT_INVALID_DATA;
+	strcpy(p_device->friendly_name, (char*)new_name );
+	return mfw_bt_flash_store_device(p_device);
+	
+}
+
+
+
+
+
+
+/*
+**  Functions used to interact with the BT "search engine"
+*/
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_discover_device
+
+ $Description:		Discovers services on a device
+
+ $Returns:		T_MFW_BT_STATUS. MFW_BT_NOT_INITIALISED if BT not started.	
+
+ $Arguments:		bd address of the remote device to discover
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_discover_device(BD_ADDR bd_addr)
+{
+
+    	T_MFW_BT_SERVICE_MASK client_services;
+
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+
+	/* remember it's an inquiry */
+	mfw_bt_cb.is_discovery = TRUE;
+	
+	/* we need to find only services for which we can be in client role, plus HS/HF */
+	client_services = ((BTA_SUPPORTED_CLIENT_SERVICES & \
+	                                ~( BTA_DUN_SERVICE_MASK | BTA_FAX_SERVICE_MASK )) \
+	                                | BTA_HSP_SERVICE_MASK | BTA_HFP_SERVICE_MASK );
+
+	BTA_DmDiscover(bd_addr, BTA_ALL_SERVICE_MASK, (tBTA_DM_SEARCH_CBACK*)mfw_bt_dm_search_cb);
+
+	return MFW_BT_SUCCESS;
+}
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_is_discover
+
+ $Description:	Checks if we are in discovering services process
+
+ $Returns:		
+
+ $Arguments:	None
+
+*******************************************************************************/
+UINT8 mfw_bt_dm_is_discover(void)
+{
+	return mfw_bt_cb.is_discovery;
+}
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_cancel_search
+
+ $Description:		cancel an ongoing search
+
+ $Returns:		MFW_BT_NOT_INITIALISED if BT not started.	
+
+ $Arguments:		
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_cancel_search( void )
+{
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+    	BTA_DmSearchCancel();
+	return MFW_BT_SUCCESS;		
+}
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_search
+
+ $Description:		Searches for devices supporting the services specified. If services = 0, will 
+ 				return all the found devices regardless of their functionalities.
+
+ $Returns:		MFW_BT_NOT_INITIALISED if BT not started.	
+
+ $Arguments:		services. If
+
+*******************************************************************************/
+T_MFW_BT_STATUS mfw_bt_dm_search(T_MFW_BT_SERVICE_MASK services)
+{
+	tBTA_DM_INQ inq_params;
+	UINT8 inq_index;
+
+	if( mfw_bt_cb.is_started != TRUE )
+		return MFW_BT_NOT_INITIALISED;
+	mfw_bt_cb.is_discovery = FALSE;
+	inq_params.mode = 0;
+	inq_params.duration = MFW_BT_DEFAULT_INQ_DURATION;
+	inq_params.max_resps = MFW_BT_NUM_REM_DEVICE;
+	inq_params.filter_type = BTA_DM_INQ_CLR;
+
+	/* "initialize" the inquiry data base */
+	mfw_bt_clean_inq_db( );
+	/* store the services we are looking for, so that we can filter the results */
+	mfw_bt_cb.search_services = services;
+	/* find nearby devices */
+	BTA_DmSearch(&inq_params, services, mfw_bt_dm_search_cb );
+	return MFW_BT_SUCCESS;		
+	
+}
+
+
+
+
+/*
+** MFW Bluetooth Device Manager Signal Handler Function Definitions
+*/
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_security_hndlr
+
+ $Description:		This function recieves the BTA DM Security events from the Generic Event Handler
+ 				and either processes them in their entirety or passes them to the MMI for further
+ 				processing.
+
+ $Returns:		MFW_BT_SUCCESS	: The signal was handled successfully
+
+ $Arguments:		event	: Event Id returned from the Bluetooth Module
+ 				data		: pointer to the relevant data returned from the Mluetooth Module
+
+*******************************************************************************/
+T_MFW_BT_STATUS	mfw_bt_dm_security_hndlr (T_MFW_BT_DM_SEC_EVT event, T_MFW_BT_DM_SEC_SIG_DATA *data)
+{
+	T_MFW_BT_STATUS retVal = MFW_BT_SUCCESS;
+	
+	MFW_BT_TRACE("mfw_bt_dm_security_hndlr");
+
+	switch (event)
+	{
+		case BTA_DM_SYS_START_EVT:
+		{
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_SYS_START_EVT event received");
+			/* now enable bluetooth functionalities before calling other BTA API */
+			BTA_EnableBluetooth(&mfw_bt_dm_security_cb);  
+		}
+		break;			
+			
+		case BTA_DM_ENABLE_EVT:
+		{
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_ENABLE_EVT event received");
+			/* call the enable call-back */
+			mfw_bt_enable_cb( );
+		}
+		break;
+
+		case BTA_DM_DISABLE_EVT:
+		{
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_DISABLE_EVT event received");
+
+			/* stop the BT chipset */
+			BTA_SysStop();
+
+			/* we won't use BT anymore => free the event handler */
+			mfw_bt_ge_disable();
+			
+			/* store the new settings */
+			mfw_bt_store_status(FALSE);
+			mfw_bt_cb.is_started = FALSE;
+			
+			/* and tell BMI */
+			mfw_bt_signal(E_BT_DISABLE_CMPL, (void *)0);
+		}
+		break;
+
+		case BTA_DM_PIN_REQ_EVT:
+		{
+			/* store the BD ADDR of the remote device */
+			bdcpy(mfw_bt_cb.peer_bdaddr, data->pin_req.bd_addr);
+			/* and forward the signal to BMI */
+			mfw_bt_signal(E_BT_DM_PIN_REQ, data);
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_PIN_REQ_EVT event received");
+		}
+		break;
+
+		case BTA_DM_AUTH_CMPL_EVT:
+		{	
+			T_MFW_BT_DM_AUTH_CMPL data_auth;
+			T_MFW_BT_REM_DEVICE device;
+			T_MFW_BT_REM_DEVICE *p_device;
+
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_AUTH_CMPL_EVT event received");
+			/* first, give some feedback to BMI */
+			/* => copy data */
+			memcpy(data_auth.bd_addr, data->auth_cmpl.bd_addr, BD_ADDR_LEN); 
+			if( strlen((char*)data->auth_cmpl.bd_name) != 0 )
+				mfwStrncpy((char*)data_auth.bd_name, (const char*)data->auth_cmpl.bd_name, MFW_BT_NAME_LENGTH);
+			data_auth.is_success = data->auth_cmpl.success;
+			/* and forward it */
+			mfw_bt_signal(E_BT_DM_AUTH_CMPL, (void*)&data_auth);
+
+			/* now see if we have to update our data base */
+			p_device = mfw_bt_get_device_info(data->auth_cmpl.bd_addr);
+			if( p_device == NULL )
+			{	
+				/* we don't know this device ... */ 
+				if ( data->auth_cmpl.success == FALSE )
+					/* ... and auth has been rejected: get away from here... */
+					break;			
+				
+				/* ... but it's trusted. So add it to our DB. This means we have to create a 
+				real T_MFW_BT_REM_DEVICE entity, which will be copied */
+				p_device = &device;
+				memset(&device, 0, sizeof( T_MFW_BT_REM_DEVICE ) );
+			}
+				
+			/* ok, now  update our local DB: get the info we received */
+			memcpy(p_device->bd_addr, data->auth_cmpl.bd_addr, BD_ADDR_LEN); 
+			if( strlen((char*)data->auth_cmpl.bd_name) != 0 )
+				mfwStrncpy((char*)p_device->name, (const char*)data->auth_cmpl.bd_name, MFW_BT_NAME_LENGTH);
+			memcpy(p_device->link_key, data->auth_cmpl.key, LINK_KEY_LEN );
+			p_device->link_key_present = data->auth_cmpl.key_present;
+
+			/* we don't modify the other fields => either the already stored ones will be used, 
+			either for a new device they will be set to zero. */
+			
+			mfw_bt_flash_store_device( p_device );			
+		}
+		break;
+
+		case BTA_DM_AUTHORIZE_EVT:
+		{
+			/* keep a trace of the information??? */
+			bdcpy(mfw_bt_cb.peer_bdaddr, data->authorize.bd_addr);
+			strncpy((char*)mfw_bt_cb.peer_name, (char*)data->authorize.bd_name, MFW_BT_NAME_LENGTH);
+			mfw_bt_cb.peer_service = data->authorize.service;
+			/*and forward it to BMI */
+			mfw_bt_signal(E_BT_DM_AUTHORIZE_REQ, data );
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_AUTHORIZE_EVT event received");
+		}
+		break;
+
+		case BTA_DM_LINK_UP_EVT:
+		{	
+			/* this is only a "HW" connection, so no service or name needed. Just show BT is busy */
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_LINK_UP_EVT event received");
+			mfw_bt_signal(E_BT_DM_LINK_UP, data );
+		}
+		break;
+
+		case BTA_DM_LINK_DOWN_EVT:
+		{	
+			/* just to know BT is idle again */
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_LINK_DOWN_EVT event received");
+			mfw_bt_signal(E_BT_DM_LINK_DOWN, data );
+		}
+		break;
+
+		case BTA_DM_SIG_STRENGTH_EVT:
+		{	
+			/* ok, we receive a signal strength indication. Great. */
+			MFW_BT_TRACE("mfw_bt_dm_security_hndlr > BTA_DM_SIG_STRENGTH_EVT event received");
+			mfw_bt_signal(E_BT_DM_SIG_STRENGTH_IND, data );
+		}	
+		break;
+
+		default:
+		{
+			/*
+			** Unexpected Event, set the data sized to -1 to exit with no further action
+			*/
+			MFW_BT_TRACE_P1("mfw_bt_dm_security_b > Unexpected Event %d", event);
+			retVal = MFW_BT_INVALID_EVENT;
+		}
+		break;
+			
+	}
+
+	return retVal;
+}
+
+
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_search_hndlr
+
+ $Description:		This function recieves the BTA DM Search events from the Generic Event Handler
+ 				and either processes them in their entirety or passes them to the MMI for further
+ 				processing.
+
+ $Returns:		MFW_BT_SUCCESS	: The signal was handled successfully
+
+ $Arguments:		event	: Event Id returned from the Bluetooth Module
+ 				data		: pointer to the relevant data returned from the Mluetooth Module
+
+*******************************************************************************/
+T_MFW_BT_STATUS	mfw_bt_dm_search_hndlr (T_MFW_BT_DM_SRCH_EVT event, T_MFW_BT_DM_SRCH_SIG_DATA *data)
+{
+	T_MFW_BT_STATUS retVal = MFW_BT_SUCCESS;
+	
+	MFW_BT_TRACE("mfw_bt_dm_search_hndlr");
+
+	/*
+	** Set the expected data size according to the received event
+	*/
+	switch (event)
+	{
+		case BTA_DM_INQ_RES_EVT:
+			{
+				MFW_BT_TRACE("mfw_bt_dm_search_hndlr > BTA_DM_INQ_RES_EVT event received");
+				/* we just received a BD address... Don't even forward this to BMI */
+			    	MFW_BT_TRACE_P6("DB_ADDR: msg_str%02x:%02x:%02x:%02x:%02x:%02x\n",
+									data->inq_res.bd_addr[0], data->inq_res.bd_addr[1],
+							              data->inq_res.bd_addr[2], data->inq_res.bd_addr[3],
+							              data->inq_res.bd_addr[4], data->inq_res.bd_addr[5]);
+				mfw_bt_add_inq_device( &(data->inq_res) );
+			}
+			break;
+
+		case BTA_DM_INQ_CMPL_EVT:
+			mfw_bt_signal( E_BT_DM_INQ_CMPL, (void*)&data->inq_cmpl);
+			MFW_BT_TRACE("mfw_bt_dm_search_hndlr > BTA_DM_INQ_CMPL_EVT event received");
+			break;
+
+		case BTA_DM_DISC_RES_EVT:
+		{
+			T_MFW_BT_DM_DISC_RES disc_res_data;
+			T_MFW_BT_REM_DEVICE *p_device_rec = NULL;	/*CQ21834 : Not Just needed for discovery, but search also */
+
+			/*
+			** Do some preliminary initialisation, so that if nothing changes we send the right information
+			*/
+			memset(&disc_res_data, 0x00, sizeof(T_MFW_BT_DM_DISC_RES));
+			
+			memcpy(disc_res_data.bd_addr, data->disc_res.bd_addr, sizeof(BD_ADDR));
+			memcpy(disc_res_data.name, data->disc_res.bd_name, MFW_BT_NAME_LENGTH);
+			disc_res_data.services = data->disc_res.services;	
+			disc_res_data.is_new = TRUE;
+
+			/* if we are doing a discovery on a device */
+			if(mfw_bt_cb.is_discovery == TRUE)
+			{
+				if(data->disc_res.services == 0 )
+				{
+				    MFW_BT_TRACE("No service found");
+				}
+				else
+				{
+		                	p_device_rec = mfw_bt_get_device_info(data->disc_res.bd_addr );
+		                	if(p_device_rec)
+			              {
+			              	/* we really should find our device! */ 
+						p_device_rec->services = data->disc_res.services;
+							
+			              	if( p_device_rec->is_new)
+							mfw_bt_add_disc_device((T_MFW_BT_DM_DISC_RES*) p_device_rec);
+						else
+							mfw_bt_flash_store_device(p_device_rec);
+						/* forward the info to BMI */
+
+						/*
+						** Reset the information for the signal from the known or already discovered database
+						*/
+						memcpy(&disc_res_data, p_device_rec, sizeof(T_MFW_BT_DM_DISC_RES));
+			              }
+		            	}
+		        }
+		        /* we are doing device search. We receive the information about all the found devices. 
+				Let's verify if we specified services to look for => if yes, filter the results */
+		        else if( mfw_bt_cb.search_services == 0 ||  
+					(mfw_bt_cb.search_services & data->disc_res.services))
+		        {		
+			/*
+			** CQ21834 : Check to determine whether the device is already known, if so get (and update)
+			** 			the information in th eKnown Devices Database
+			*/
+	                p_device_rec = mfw_bt_get_device_info(data->disc_res.bd_addr );
+
+			/*
+			** p_device_rec should not be NULL because the device was added to the inquiry database when the inq result
+			** was recieved if it was not already in the known device database.
+			*/
+	                if (p_device_rec->is_new == FALSE)
+		          {
+		            MFW_BT_TRACE("BTA_DM_DISC_RES_EVT > This device is known");
+				
+		            if (strncmp(p_device_rec->name, (char *)&data->disc_res.bd_name, MFW_BT_NAME_LENGTH) != 0)
+	              	{
+	              		mfwStrncpy(p_device_rec->name, (char *)&data->disc_res.bd_name, MFW_BT_NAME_LENGTH);
+	              	}
+
+		            /* Update the device details! */ 
+		                    p_device_rec->services |= data->disc_res.services;
+				mfw_bt_flash_store_device(p_device_rec);
+
+		            memcpy(&disc_res_data, p_device_rec, sizeof(T_MFW_BT_DM_DISC_RES));
+	                }
+
+		        /*
+			** CQ21834: update our database whether the device is known or not, so that if the user removes it from the
+			** known device database, we will still have the details available.
+			*/
+		        	mfw_bt_add_disc_device( (T_MFW_BT_DM_DISC_RES*) &disc_res_data);
+		       }
+		       
+			MFW_BT_TRACE("mfw_bt_dm_search_hndlr > BTA_DM_DISC_RES_EVT event received");
+			/* and forward the event to BMI */
+			mfw_bt_signal( E_BT_DM_DISC_RES, (void*)&disc_res_data);			
+		}
+		break;
+
+		case BTA_DM_DISC_CMPL_EVT:
+			mfw_bt_signal( E_BT_DM_DISC_CMPL, NULL );
+			MFW_BT_TRACE("mfw_bt_dm_search_hndlr > BTA_DM_DISC_CMPL_EVT event received");
+			break;
+
+		case BTA_DM_SEARCH_CANCEL_CMPL_EVT:
+			/* currently, we don't do anything when a search is cancelled. Should we? */
+			MFW_BT_TRACE("mfw_bt_dm_search_hndlr > BTA_DM_SEARCH_CANCEL_CMPL_EVT event received");
+			break;
+
+		default:
+			/*
+			** Unexpected Event, setthe data sized to -1 to exit with no further action
+			*/
+			MFW_BT_TRACE_P1("mfw_bt_dm_search_hndlr > Unexpected Event %d", event);
+			retVal = MFW_BT_INVALID_EVENT;
+			
+	}
+
+	return retVal;
+}
+
+
+
+
+
+/*
+** MFW Bluetooth Device Manager Callback Function Definitions
+*/
+/*******************************************************************************
+
+ $Function:		mfw_bt_dm_security_b
+
+ $Description:		This is the Device Manager Security Callback function, a pointer to it is passed
+ 				to the Bluetooth Module in the BTA DM Enable function and it is used to return
+ 				information from the Bluetooth Module
+
+ $Returns:		None
+
+ $Arguments:		event	: Event Id returned from the Bluetooth Module
+ 				data		: pointer to the relevant data returned from the Mluetooth Module
+
+*******************************************************************************/
+void	mfw_bt_dm_security_cb(T_MFW_BT_DM_SEC_EVT event, T_MFW_BT_DM_SEC_SIG_DATA *data)
+{
+	int dataLen;
+	T_MFW_BT_STATUS	geRetVal = MFW_BT_SUCCESS;
+
+	MFW_BT_TRACE("mfw_bt_dm_security_b");
+
+	/*
+	** Set the expected data size according to the received event
+	*/
+	switch (event)
+	{
+		case BTA_DM_SYS_START_EVT:
+			dataLen = 0;
+			break;
+		case BTA_DM_ENABLE_EVT:
+			dataLen = sizeof(tBTA_DM_ENABLE);
+			break;
+
+		case BTA_DM_DISABLE_EVT:
+			dataLen = 0;
+			break;
+
+		case BTA_DM_PIN_REQ_EVT:
+			dataLen = sizeof(tBTA_DM_PIN_REQ);
+			break;
+
+		case BTA_DM_AUTH_CMPL_EVT:
+			dataLen = sizeof(tBTA_DM_AUTH_CMPL);
+			break;
+
+		case BTA_DM_AUTHORIZE_EVT:
+			dataLen = sizeof(tBTA_DM_AUTHORIZE);
+			break;
+
+		case BTA_DM_LINK_UP_EVT:
+			dataLen = sizeof(tBTA_DM_LINK_UP);
+			break;
+
+		case BTA_DM_LINK_DOWN_EVT:
+			dataLen = sizeof(tBTA_DM_LINK_DOWN);
+			break;
+
+		case BTA_DM_SIG_STRENGTH_EVT:
+			dataLen = sizeof(tBTA_DM_SIG_STRENGTH);
+			break;
+
+		default:
+			/*
+			** Unexpected Event, setthe data sized to -1 to exit with no further action
+			*/
+			MFW_BT_TRACE_P1("mfw_bt_dm_security_b > Unexpected Event %d", event);
+			dataLen = -1;
+			
+	}
+
+
+	if (dataLen > 0)
+	{
+		/*
+		** Data is expected with the received signal
+		*/
+		if ((void *)data == (void *)0)
+		{
+			/*
+			** The data pointer is NULL, report the error
+			*/
+			MFW_BT_TRACE_P1("mfw_bt_dm_security_b > Event : %d, Data Pointer is NULL, but data is expected", event);
+		}
+		else
+		{
+			/*
+			** Post the event and data to the Generic event handler
+			*/
+			geRetVal = mfw_bt_ge_post_event(MFW_BT_DM_SECURITY, (ULONG)event, (void *)data, dataLen);
+		}
+	}
+	else if (dataLen == 0)
+	{
+		/*
+		** There is no expected data with the received signal, post the event to the Generic event handler
+		*/
+		geRetVal = mfw_bt_ge_post_event(MFW_BT_DM_SECURITY, (ULONG)event, (void *)0, 0);
+	}
+
+	if (geRetVal != MFW_BT_SUCCESS)
+	{
+		/*
+		** There is an error, but there is nothing that can be done other than to report it.
+		*/
+		MFW_BT_TRACE_P1("mfw_bt_dm_security_b > Failed to post the event. Error %d", geRetVal);
+	}
+
+	return;
+}
+
+
+/*******************************************************************************
+
+ $Function:		mfw_bt_Dm_Search_Cb
+
+ $Description:		This is the Device Manager Search Callback function, a pointer to it is passed
+ 				to the Bluetooth Module in the BTA DM Search and Discover functions and it is
+ 				used to return information from the Bluetooth Module
+
+ $Returns:		None
+
+ $Arguments:		event	: Event Id returned from the Bluetooth Module
+ 				data		: pointer to the relevant data returned from the Mluetooth Module
+
+*******************************************************************************/
+void	mfw_bt_dm_search_cb(T_MFW_BT_DM_SRCH_EVT event, T_MFW_BT_DM_SRCH_SIG_DATA *data)
+{
+	int dataLen;
+	T_MFW_BT_STATUS	geRetVal = MFW_BT_SUCCESS;
+
+	MFW_BT_TRACE("mfw_bt_Dm_Search_Cb");
+
+	/*
+	** Set the expected data size according to the received event
+	*/
+	switch (event)
+	{
+		case BTA_DM_INQ_RES_EVT:
+			dataLen = sizeof(tBTA_DM_INQ_RES);
+			break;
+
+		case BTA_DM_INQ_CMPL_EVT:
+			dataLen = sizeof(tBTA_DM_INQ_CMPL);
+			break;
+
+		case BTA_DM_DISC_RES_EVT:
+			dataLen = sizeof(tBTA_DM_DISC_RES);
+			break;
+
+		case BTA_DM_DISC_CMPL_EVT:
+			dataLen = 0;
+			break;
+
+		case BTA_DM_SEARCH_CANCEL_CMPL_EVT:
+			dataLen = 0;
+			break;
+
+
+		default:
+			/*
+			** Unexpected Event, setthe data sized to -1 to exit with no further action
+			*/
+			MFW_BT_TRACE_P1("mfw_bt_Dm_Search_Cb > Unexpected Event %d", event);
+			dataLen = -1;
+			
+	}
+
+
+	if (dataLen > 0)
+	{
+		/*
+		** Data is expected with the received signal
+		*/
+		if ((void *)data == (void *)0)
+		{
+			/*
+			** The data pointer is NULL, report the error
+			*/
+			MFW_BT_TRACE_P1("mfw_bt_Dm_Search_Cb > Event : %d, Data Pointer is NULL, but data is expected", event);
+		}
+		else
+		{
+			/*
+			** Post the event and data to the Generic event handler
+			*/
+			geRetVal = mfw_bt_ge_post_event(MFW_BT_DM_SEARCH, (ULONG)event, (void *)data, dataLen);
+		}
+	}
+	else if (dataLen == 0)
+	{
+		/*
+		** There is no expected data with the received signal, post the event to the Generic event handler
+		*/
+		geRetVal = mfw_bt_ge_post_event(MFW_BT_DM_SEARCH, (ULONG)event, (void *)0, 0);
+	}
+
+	if (geRetVal != MFW_BT_SUCCESS)
+	{
+		/*
+		** There is an error, but there is nothing that can be done other than to report it.
+		*/
+		MFW_BT_TRACE_P1("mfw_bt_Dm_Search_Cb > Failed to post the event. Error %d", geRetVal);
+	}
+
+	return;
+}
+
+