+
−/*
+
−+-------------------------------------------------------------------+
+
−| 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;
+
−}
+
−
+
−