Remove unused main::shim code (2c8fd40e) · Commits · e / os / android_packages_modules_Bluetooth

system/main/shim/btm_api.cc

+0 −505

Original line number	Diff line number	Diff line
		@@ -48,516 +48,11 @@
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		using bluetooth::common::MetricIdAllocator;

		#define BTIF_DM_DEFAULT_INQ_MAX_RESULTS 0
		#define BTIF_DM_DEFAULT_INQ_MAX_DURATION 10

		/**
		* Legacy bluetooth module global control block state
		*
		* Mutex is used to synchronize access from the shim
		* layer into the global control block. This is used
		* by the shim despite potentially arbitrary
		* unsynchronized access by the legacy stack.
		*/
		extern tBTM_CB btm_cb;
		std::mutex btm_cb_mutex_;

		bool btm_inq_find_bdaddr(const RawAddress& p_bda);
		extern tINQ_DB_ENT* btm_inq_db_find(const RawAddress& raw_address);
		extern tINQ_DB_ENT* btm_inq_db_new(const RawAddress& p_bda, bool is_ble);

		/**
		* Legacy bluetooth btm stack entry points
		*/
		void btm_acl_update_inquiry_status(uint8_t status);
		void btm_clear_all_pending_le_entry(void);
		void btm_clr_inq_result_flt(void);
		void btm_set_eir_uuid(const uint8_t* p_eir, tBTM_INQ_RESULTS* p_results);
		void btm_sort_inq_result(void);
		void btm_process_inq_complete(tHCI_STATUS status, uint8_t result_type);

		namespace {
		std::unordered_map<bluetooth::hci::AddressWithType, bt_bdname_t>
		address_name_map_;

		std::unordered_map<bluetooth::hci::IoCapability, int> gd_legacy_io_caps_map_ = {
		{bluetooth::hci::IoCapability::DISPLAY_ONLY, BTM_IO_CAP_OUT},
		{bluetooth::hci::IoCapability::DISPLAY_YES_NO, BTM_IO_CAP_IO},
		{bluetooth::hci::IoCapability::KEYBOARD_ONLY, BTM_IO_CAP_IN},
		{bluetooth::hci::IoCapability::NO_INPUT_NO_OUTPUT, BTM_IO_CAP_NONE},
		};

		std::unordered_map<bluetooth::hci::AuthenticationRequirements, int>
		gd_legacy_auth_reqs_map_ = {
		{bluetooth::hci::AuthenticationRequirements::NO_BONDING,
		BTM_AUTH_SP_NO},
		{bluetooth::hci::AuthenticationRequirements::NO_BONDING_MITM_PROTECTION,
		BTM_AUTH_SP_YES},
		{bluetooth::hci::AuthenticationRequirements::DEDICATED_BONDING,
		BTM_AUTH_AP_NO},
		{bluetooth::hci::AuthenticationRequirements::
		DEDICATED_BONDING_MITM_PROTECTION,
		BTM_AUTH_AP_YES},
		{bluetooth::hci::AuthenticationRequirements::GENERAL_BONDING,
		BTM_AUTH_SPGB_NO},
		{bluetooth::hci::AuthenticationRequirements::
		GENERAL_BONDING_MITM_PROTECTION,
		BTM_AUTH_SPGB_YES},
		};
		}

		class ShimUi : public bluetooth::security::UI {
		public:
		static ShimUi* GetInstance() {
		static ShimUi instance;
		return &instance;
		}

		ShimUi(const ShimUi&) = delete;
		ShimUi& operator=(const ShimUi&) = delete;

		void SetBtaCallbacks(const tBTM_APPL_INFO* bta_callbacks) {
		bta_callbacks_ = bta_callbacks;
		if (bta_callbacks->p_pin_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s pin_callback", __func__);
		}

		if (bta_callbacks->p_link_key_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s link_key_callback", __func__);
		}

		if (bta_callbacks->p_auth_complete_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s auth_complete_callback", __func__);
		}

		if (bta_callbacks->p_bond_cancel_cmpl_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s bond_cancel_complete_callback", __func__);
		}

		if (bta_callbacks->p_le_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s le_callback", __func__);
		}

		if (bta_callbacks->p_le_key_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s le_key_callback", __func__);
		}

		if (bta_callbacks->p_sirk_verification_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s sirk_verification_callback", __func__);
		}
		}

		void DisplayPairingPrompt(const bluetooth::hci::AddressWithType& address,
		std::string name) {
		waiting_for_pairing_prompt_ = true;
		bt_bdname_t legacy_name{0};
		memcpy(legacy_name.name, name.data(), name.length());
		// TODO(optedoblivion): Handle callback to BTA for BLE
		}

		void Cancel(const bluetooth::hci::AddressWithType& address) {
		LOG(WARNING) << " ■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■ " << __func__;
		}

		void HandleConfirm(bluetooth::security::ConfirmationData data) {
		const bluetooth::hci::AddressWithType& address = data.GetAddressWithType();
		uint32_t numeric_value = data.GetNumericValue();
		bt_bdname_t legacy_name{0};
		memcpy(legacy_name.name, data.GetName().data(), data.GetName().length());

		if (bta_callbacks_->p_sp_callback) {
		// Call sp_cback for IO_REQ
		tBTM_SP_IO_REQ io_req_evt_data;
		io_req_evt_data.bd_addr = bluetooth::ToRawAddress(address.GetAddress());
		// Local IO Caps (Phone is always DisplayYesNo)
		io_req_evt_data.io_cap = BTM_IO_CAP_IO;
		// Local Auth Reqs (Phone is always DEDICATED_BONDING)
		io_req_evt_data.auth_req = BTM_AUTH_AP_NO;
		io_req_evt_data.oob_data = BTM_OOB_NONE;
		(*bta_callbacks_->p_sp_callback)(BTM_SP_IO_REQ_EVT,
		(tBTM_SP_EVT_DATA*)&io_req_evt_data);

		// Call sp_cback for IO_RSP
		tBTM_SP_IO_RSP io_rsp_evt_data;
		io_rsp_evt_data.bd_addr = bluetooth::ToRawAddress(address.GetAddress());
		io_rsp_evt_data.io_cap = static_cast<tBTM_IO_CAP>(
		gd_legacy_io_caps_map_[data.GetRemoteIoCaps()]);
		io_rsp_evt_data.auth_req =
		gd_legacy_auth_reqs_map_[data.GetRemoteAuthReqs()];
		io_rsp_evt_data.auth_req = BTM_AUTH_AP_YES;
		io_rsp_evt_data.oob_data = BTM_OOB_NONE;
		(*bta_callbacks_->p_sp_callback)(BTM_SP_IO_RSP_EVT,
		(tBTM_SP_EVT_DATA*)&io_rsp_evt_data);

		// Call sp_cback for USER_CONFIRMATION
		tBTM_SP_EVT_DATA user_cfm_req_evt_data;
		user_cfm_req_evt_data.cfm_req.bd_addr =
		bluetooth::ToRawAddress(address.GetAddress());
		user_cfm_req_evt_data.cfm_req.num_val = numeric_value;
		// If we pop a dialog then it isn't just_works
		user_cfm_req_evt_data.cfm_req.just_works = data.IsJustWorks();

		address_name_map_.emplace(address, legacy_name);
		memcpy((char*)user_cfm_req_evt_data.cfm_req.bd_name, legacy_name.name,
		BD_NAME_LEN);

		(*bta_callbacks_->p_sp_callback)(BTM_SP_CFM_REQ_EVT,
		&user_cfm_req_evt_data);
		}
		}

		void DisplayConfirmValue(bluetooth::security::ConfirmationData data) {
		waiting_for_pairing_prompt_ = false;
		data.SetJustWorks(false);
		HandleConfirm(data);
		}

		void DisplayYesNoDialog(bluetooth::security::ConfirmationData data) {
		waiting_for_pairing_prompt_ = false;
		data.SetJustWorks(true);
		HandleConfirm(data);
		}

		void DisplayEnterPasskeyDialog(bluetooth::security::ConfirmationData data) {
		waiting_for_pairing_prompt_ = false;
		LOG_WARN("UNIMPLEMENTED, Passkey not supported in GD");
		}

		void DisplayPasskey(bluetooth::security::ConfirmationData data) {
		waiting_for_pairing_prompt_ = false;
		LOG_WARN("UNIMPLEMENTED, Passkey not supported in GD");
		}

		void DisplayEnterPinDialog(bluetooth::security::ConfirmationData data) {
		waiting_for_pairing_prompt_ = false;
		LOG_WARN("UNIMPLEMENTED, PIN not supported in GD");
		}

		bool waiting_for_pairing_prompt_ = false;

		private:
		ShimUi() : bta_callbacks_(nullptr) {}
		~ShimUi() {}
		const tBTM_APPL_INFO* bta_callbacks_;
		};

		ShimUi* shim_ui_ = nullptr;

		class ShimBondListener : public bluetooth::security::ISecurityManagerListener {
		public:
		static ShimBondListener* GetInstance() {
		static ShimBondListener instance;
		return &instance;
		}

		ShimBondListener(const ShimBondListener&) = delete;
		ShimBondListener& operator=(const ShimBondListener&) = delete;

		void SetBtaCallbacks(const tBTM_APPL_INFO* bta_callbacks) {
		bta_callbacks_ = bta_callbacks;
		if (bta_callbacks->p_pin_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s pin_callback", __func__);
		}

		if (bta_callbacks->p_link_key_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s link_key_callback", __func__);
		}

		if (bta_callbacks->p_auth_complete_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s auth_complete_callback", __func__);
		}

		if (bta_callbacks->p_bond_cancel_cmpl_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s bond_cancel_complete_callback", __func__);
		}

		if (bta_callbacks->p_le_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s le_callback", __func__);
		}

		if (bta_callbacks->p_le_key_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s le_key_callback", __func__);
		}

		if (bta_callbacks->p_sirk_verification_callback == nullptr) {
		LOG_INFO("UNIMPLEMENTED %s sirk_verification_callback", __func__);
		}
		}

		void OnDeviceBonded(bluetooth::hci::AddressWithType device) override {
		// Call sp_cback for LINK_KEY_NOTIFICATION
		// Call AUTHENTICATION_COMPLETE callback
		if (device.GetAddressType() ==
		bluetooth::hci::AddressType::PUBLIC_DEVICE_ADDRESS) {
		auto it = address_name_map_.find(device);
		bt_bdname_t tmp_name;
		if (it != address_name_map_.end()) {
		tmp_name = it->second;
		}
		BD_NAME name;
		memcpy((char*)name, tmp_name.name, BD_NAME_LEN);

		if (*bta_callbacks_->p_link_key_callback) {
		LinkKey key; // Never want to send the key to the stack
		(*bta_callbacks_->p_link_key_callback)(
		bluetooth::ToRawAddress(device.GetAddress()), 0, name, key,
		BTM_LKEY_TYPE_COMBINATION, false /* is_ctkd */);
		}
		if (*bta_callbacks_->p_auth_complete_callback) {
		(*bta_callbacks_->p_auth_complete_callback)(
		bluetooth::ToRawAddress(device.GetAddress()), 0, name, HCI_SUCCESS);
		}
		}
		bluetooth::shim::AllocateIdFromMetricIdAllocator(
		bluetooth::ToRawAddress(device.GetAddress()));
		bool is_saving_successful = bluetooth::shim::SaveDeviceOnMetricIdAllocator(
		bluetooth::ToRawAddress(device.GetAddress()));
		if (!is_saving_successful) {
		LOG(FATAL) << __func__ << ": Fail to save metric id for device "
		<< bluetooth::ToRawAddress(device.GetAddress());
		}
		}

		void OnDeviceUnbonded(bluetooth::hci::AddressWithType device) override {
		if (bta_callbacks_->p_bond_cancel_cmpl_callback) {
		(*bta_callbacks_->p_bond_cancel_cmpl_callback)(BTM_SUCCESS);
		}
		bluetooth::shim::ForgetDeviceFromMetricIdAllocator(
		bluetooth::ToRawAddress(device.GetAddress()));
		}

		void OnDeviceBondFailed(bluetooth::hci::AddressWithType device,
		bluetooth::security::PairingFailure status) override {
		auto it = address_name_map_.find(device);
		bt_bdname_t tmp_name;
		if (it != address_name_map_.end()) {
		tmp_name = it->second;
		}
		BD_NAME name;
		memcpy((char*)name, tmp_name.name, BD_NAME_LEN);

		if (bta_callbacks_->p_auth_complete_callback) {
		(*bta_callbacks_->p_auth_complete_callback)(
		bluetooth::ToRawAddress(device.GetAddress()), 0, name,
		HCI_ERR_AUTH_FAILURE);
		}
		}

		void OnEncryptionStateChanged(
		bluetooth::hci::EncryptionChangeView encryption_change_view) override {
		// TODO(optedoblivion): Find BTA callback for this to call
		}

		private:
		ShimBondListener() : bta_callbacks_(nullptr) {}
		~ShimBondListener() {}
		const tBTM_APPL_INFO* bta_callbacks_;
		};

		tBTM_STATUS bluetooth::shim::BTM_CancelRemoteDeviceName(void) {
		return Stack::GetInstance()->GetBtm()->CancelAllReadRemoteDeviceName();
		}

		tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbRead(const RawAddress& p_bda) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		return nullptr;
		}

		tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbFirst(void) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		return nullptr;
		}

		tBTM_INQ_INFO* bluetooth::shim::BTM_InqDbNext(tBTM_INQ_INFO* p_cur) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_cur != nullptr);
		return nullptr;
		}

		tBTM_STATUS bluetooth::shim::BTM_ClearInqDb(const RawAddress* p_bda) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		if (p_bda == nullptr) {
		// clear all entries
		} else {
		// clear specific entry
		}
		return BTM_NO_RESOURCES;
		}

		bool bluetooth::shim::BTM_HasEirService(const uint32_t* p_eir_uuid,
		uint16_t uuid16) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_eir_uuid != nullptr);
		return false;
		}

		void bluetooth::shim::BTM_AddEirService(uint32_t* p_eir_uuid, uint16_t uuid16) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_eir_uuid != nullptr);
		}

		void bluetooth::shim::BTM_ReadConnectionAddr(const RawAddress& remote_bda,
		RawAddress& local_conn_addr,
		tBLE_ADDR_TYPE* p_addr_type) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_addr_type != nullptr);
		}

		bool bluetooth::shim::BTM_ReadRemoteConnectionAddr(
		const RawAddress& pseudo_addr, RawAddress& conn_addr,
		tBLE_ADDR_TYPE* p_addr_type) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_addr_type != nullptr);
		return false;
		}

		void bluetooth::shim::BTM_BleSetConnScanParams(uint32_t scan_interval,
		uint32_t scan_window) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		}

		void bluetooth::shim::BTM_ReadDevInfo(const RawAddress& remote_bda,
		tBT_DEVICE_TYPE* p_dev_type,
		tBLE_ADDR_TYPE* p_addr_type) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_dev_type != nullptr);
		CHECK(p_addr_type != nullptr);
		}

		bool bluetooth::shim::BTM_ReadConnectedTransportAddress(
		RawAddress* remote_bda, tBT_TRANSPORT transport) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(remote_bda != nullptr);
		return false;
		}

		void bluetooth::shim::BTM_BleReceiverTest(uint8_t rx_freq,
		tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_cmd_cmpl_cback != nullptr);
		}

		void bluetooth::shim::BTM_BleTransmitterTest(uint8_t tx_freq,
		uint8_t test_data_len,
		uint8_t packet_payload,
		tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_cmd_cmpl_cback != nullptr);
		}

		void bluetooth::shim::BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_cmd_cmpl_cback != nullptr);
		}

		bool bluetooth::shim::BTM_GetLeSecurityState(const RawAddress& bd_addr,
		uint8_t* p_le_dev_sec_flags,
		uint8_t* p_le_key_size) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		CHECK(p_le_dev_sec_flags != nullptr);
		CHECK(p_le_key_size != nullptr);
		return false;
		}

		bool bluetooth::shim::BTM_BleSecurityProcedureIsRunning(
		const RawAddress& bd_addr) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		return false;
		}

		uint8_t bluetooth::shim::BTM_BleGetSupportedKeySize(const RawAddress& bd_addr) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		return 0;
		}

		void bluetooth::shim::BTM_BleAdvFilterParamSetup(
		tBTM_BLE_SCAN_COND_OP action, tBTM_BLE_PF_FILT_INDEX filt_index,
		std::unique_ptr<btgatt_filt_param_setup_t> p_filt_params,
		tBTM_BLE_PF_PARAM_CB cb) {
		LOG_INFO("UNIMPLEMENTED %s", __func__);
		}

		tBTM_STATUS bluetooth::shim::BTM_SecBond(const RawAddress& bd_addr,
		tBLE_ADDR_TYPE addr_type,
		tBT_TRANSPORT transport,
		tBT_DEVICE_TYPE device_type) {
		return Stack::GetInstance()->GetBtm()->CreateBond(bd_addr, addr_type,
		transport, device_type);
		}

		bool bluetooth::shim::BTM_SecAddDevice(const RawAddress& bd_addr,
		DEV_CLASS dev_class,
		const BD_NAME& bd_name,
		uint8_t* features, LinkKey* link_key,
		uint8_t key_type, uint8_t pin_length) {
		// Check if GD has a security record for the device
		return BTM_SUCCESS;
		}

		void bluetooth::shim::BTM_ConfirmReqReply(tBTM_STATUS res,
		const RawAddress& bd_addr) {
		// Send for both Classic and LE until we can determine the type
		bool accept = res == BTM_SUCCESS;
		hci::AddressWithType address = ToAddressWithType(bd_addr, BLE_ADDR_PUBLIC);
		hci::AddressWithType address2 = ToAddressWithType(bd_addr, BLE_ADDR_RANDOM);
		auto security_manager =
		bluetooth::shim::GetSecurityModule()->GetSecurityManager();
		if (ShimUi::GetInstance()->waiting_for_pairing_prompt_) {
		LOG(INFO) << "interpreting confirmation as pairing accept " << address;
		security_manager->OnPairingPromptAccepted(address, accept);
		security_manager->OnPairingPromptAccepted(address2, accept);
		ShimUi::GetInstance()->waiting_for_pairing_prompt_ = false;
		} else {
		LOG(INFO) << "interpreting confirmation as yes/no confirmation " << address;
		security_manager->OnConfirmYesNo(address, accept);
		security_manager->OnConfirmYesNo(address2, accept);
		}
		}

		uint16_t bluetooth::shim::BTM_GetHCIConnHandle(const RawAddress& remote_bda,
		tBT_TRANSPORT transport) {
		return Stack::GetInstance()->GetBtm()->GetAclHandle(remote_bda, transport);
		}

		void bluetooth::shim::BTM_SecClearSecurityFlags(const RawAddress& bd_addr) {
		// TODO(optedoblivion): Call RemoveBond on device address
		}

		bool bluetooth::shim::BTM_SecAddRmtNameNotifyCallback(
		tBTM_RMT_NAME_CALLBACK* p_callback) {
		// TODO(optedoblivion): keep track of callback
		LOG_WARN("Unimplemented");
		return true;
		}

		bool bluetooth::shim::BTM_SecDeleteRmtNameNotifyCallback(
		tBTM_RMT_NAME_CALLBACK* p_callback) {
		// TODO(optedoblivion): stop keeping track of callback
		LOG_WARN("Unimplemented");
		return true;
		}

		void bluetooth::shim::BTM_PINCodeReply(const RawAddress& bd_addr,
		tBTM_STATUS res, uint8_t pin_len,
		uint8_t* p_pin) {
		ASSERT_LOG(!bluetooth::shim::is_gd_shim_enabled(), "Unreachable code path");
		}

		void bluetooth::shim::BTM_RemoteOobDataReply(tBTM_STATUS res,
		const RawAddress& bd_addr,
		const Octet16& c,
		const Octet16& r) {
		ASSERT_LOG(!bluetooth::shim::is_gd_shim_enabled(), "Unreachable code path");
		}

		tBTM_STATUS bluetooth::shim::BTM_SetDeviceClass(DEV_CLASS dev_class) {
		// TODO(optedoblivion): see if we need this, I don't think we do
		LOG_WARN("Unimplemented");
		return BTM_SUCCESS;
		}

		tBTM_STATUS bluetooth::shim::BTM_ClearEventFilter() {
		controller_get_interface()->clear_event_filter();
		return BTM_SUCCESS;

system/stack/acl/btm_acl.cc

+0 −10

Original line number	Diff line number	Diff line
		@@ -2387,11 +2387,6 @@ bool acl_peer_supports_ble_connection_subrating_host(
		void BTM_ReadConnectionAddr(const RawAddress& remote_bda,
		RawAddress& local_conn_addr,
		tBLE_ADDR_TYPE* p_addr_type) {
		if (bluetooth::shim::is_gd_shim_enabled()) {
		return bluetooth::shim::BTM_ReadConnectionAddr(remote_bda, local_conn_addr,
		p_addr_type);
		}

		if (bluetooth::shim::is_gd_l2cap_enabled()) {
		bluetooth::shim::L2CA_ReadConnectionAddr(remote_bda, local_conn_addr,
		p_addr_type);
		@@ -2495,11 +2490,6 @@ bool acl_is_switch_role_idle(const RawAddress& bd_addr,
		bool BTM_ReadRemoteConnectionAddr(const RawAddress& pseudo_addr,
		RawAddress& conn_addr,
		tBLE_ADDR_TYPE* p_addr_type) {
		if (bluetooth::shim::is_gd_shim_enabled()) {
		return bluetooth::shim::BTM_ReadRemoteConnectionAddr(pseudo_addr, conn_addr,
		p_addr_type);
		}

		if (bluetooth::shim::is_gd_l2cap_enabled()) {
		return bluetooth::shim::L2CA_ReadRemoteConnectionAddr(
		pseudo_addr, conn_addr, p_addr_type);

system/stack/btm/btm_ble.cc

+0 −10

Original line number	Diff line number	Diff line
		@@ -585,9 +585,6 @@ bool BTM_ReadConnectedTransportAddress(RawAddress* remote_bda,
		*
		******************************************************************************/
		void BTM_BleReceiverTest(uint8_t rx_freq, tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		if (bluetooth::shim::is_gd_shim_enabled()) {
		return bluetooth::shim::BTM_BleReceiverTest(rx_freq, p_cmd_cmpl_cback);
		}
		btm_cb.devcb.p_le_test_cmd_cmpl_cb = p_cmd_cmpl_cback;

		btsnd_hcic_ble_receiver_test(rx_freq);
		@@ -609,10 +606,6 @@ void BTM_BleReceiverTest(uint8_t rx_freq, tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		void BTM_BleTransmitterTest(uint8_t tx_freq, uint8_t test_data_len,
		uint8_t packet_payload,
		tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		if (bluetooth::shim::is_gd_shim_enabled()) {
		return bluetooth::shim::BTM_BleTransmitterTest(
		tx_freq, test_data_len, packet_payload, p_cmd_cmpl_cback);
		}
		btm_cb.devcb.p_le_test_cmd_cmpl_cb = p_cmd_cmpl_cback;
		btsnd_hcic_ble_transmitter_test(tx_freq, test_data_len, packet_payload);
		}
		@@ -628,9 +621,6 @@ void BTM_BleTransmitterTest(uint8_t tx_freq, uint8_t test_data_len,
		*
		******************************************************************************/
		void BTM_BleTestEnd(tBTM_CMPL_CB* p_cmd_cmpl_cback) {
		if (bluetooth::shim::is_gd_shim_enabled()) {
		return bluetooth::shim::BTM_BleTestEnd(p_cmd_cmpl_cback);
		}
		btm_cb.devcb.p_le_test_cmd_cmpl_cb = p_cmd_cmpl_cback;

		btsnd_hcic_ble_test_end();