Merge changes I65399f4e,Iad27b185,Ia43609b6,I78a06be7,I8e518f2b, ... am: 7d33848015 am: 7180b66134 (49d4b3c4) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/dm/bta_dm_cfg.cc

+6 −5

Original line number	Diff line number	Diff line
		@@ -534,14 +534,15 @@ tBTA_DM_PM_TYPE_QUALIFIER tBTM_PM_PWR_MD bta_dm_pm_md[] = {
		* lowest latency */
		tBTA_DM_SSR_SPEC bta_dm_ssr_spec[] = {
		/max_lat, min_rmt_to, min_loc_to/
		{0, 0, 0}, /* BTA_DM_PM_SSR0 - do not use SSR */
		{0, 0, 0, "no_ssr"}, /* BTA_DM_PM_SSR0 - do not use SSR */
		/* BTA_DM_PM_SSR1 - HH, can NOT share entry with any other profile, seting
		default max latency and min remote timeout as 0, and always read
		individual device preference from HH module */
		{0, 0, 2},
		{1200, 2, 2}, /* BTA_DM_PM_SSR2 - others (as long as sniff is allowed)*/
		{360, 160, 1600}, /* BTA_DM_PM_SSR3 - HD */
		{1200, 65534, 65534} /* BTA_DM_PM_SSR4 - A2DP streaming */
		{0, 0, 2, "hid_host"},
		{1200, 2, 2, "sniff_capable"}, /* BTA_DM_PM_SSR2 - others (as long as sniff
		is allowed)*/
		{360, 160, 1600, "hid_device"}, /* BTA_DM_PM_SSR3 - HD */
		{1200, 65534, 65534, "a2dp"} /* BTA_DM_PM_SSR4 - A2DP streaming */
		};

		tBTA_DM_SSR_SPEC* p_bta_dm_ssr_spec = &bta_dm_ssr_spec[0];

system/bta/dm/bta_dm_int.h

+18 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#ifndef BTA_DM_INT_H
		#define BTA_DM_INT_H

		#include <base/strings/stringprintf.h>
		#include <memory>
		#include "bt_target.h"
		#include "bta/sys/bta_sys.h"
		@@ -167,11 +168,27 @@ typedef enum : uint8_t {
		BTA_DM_DI_INT_SNIFF = 0x02, /* set this bit if call BTM_SetPowerMode(sniff) &
		enter sniff mode */
		BTA_DM_DI_ACP_SNIFF = 0x04, /* set this bit if peer init sniff */
		BTA_DM_DI_UNUSED = 0x08,
		BTA_DM_DI_USE_SSR = 0x10, /* set this bit if ssr is supported for this link */
		BTA_DM_DI_AV_ACTIVE = 0x20, /* set this bit if AV is active for this link */
		} tBTA_DM_DEV_INFO_BITMASK;
		typedef uint8_t tBTA_DM_DEV_INFO;

		inline std::string device_info_text(tBTA_DM_DEV_INFO info) {
		const char* const device_info_text[] = {
		":set_sniff", ":int_sniff", ":acp_sniff",
		":unused", ":use_ssr", ":av_active",
		};

		std::string s = base::StringPrintf("0x%02x", info);
		if (info == BTA_DM_DI_NONE) return s + std::string(":none");
		for (size_t i = 0; i < sizeof(device_info_text) / sizeof(device_info_text[0]);
		i++) {
		if (info & (1u << i)) s += std::string(device_info_text[i]);
		}
		return s;
		}

		/* set power mode request type */
		#define BTA_DM_PM_RESTART 1
		#define BTA_DM_PM_NEW_REQ 2
		@@ -379,6 +396,7 @@ typedef struct {
		uint16_t max_lat;
		uint16_t min_rmt_to;
		uint16_t min_loc_to;
		const char* name{nullptr};
		} tBTA_DM_SSR_SPEC;

		typedef struct {

system/bta/dm/bta_dm_pm.cc

+56 −30

Original line number	Diff line number	Diff line
		@@ -336,10 +336,9 @@ static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
		tBTA_DM_PEER_DEVICE* p_dev;
		tBTA_DM_PM_REQ pm_req = BTA_DM_PM_NEW_REQ;

		APPL_TRACE_DEBUG("bta_dm_pm_cback: st(%d), id(%d), app(%d)", status, id,
		app_id);

		p_dev = bta_dm_find_peer_device(peer_addr);
		LOG_DEBUG("Power management callback status:%s[%hhu] id:%s[%d], app:%hhu",
		bta_sys_conn_status_text(status).c_str(), status,
		BtaIdSysText(id).c_str(), id, app_id);

		/* find if there is an power mode entry for the service */
		for (i = 1; i <= p_bta_dm_pm_cfg[0].app_id; i++) {
		@@ -350,10 +349,21 @@ static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
		}

		/* if no entries are there for the app_id and subsystem in p_bta_dm_pm_spec*/
		if (i > p_bta_dm_pm_cfg[0].app_id) return;
		if (i > p_bta_dm_pm_cfg[0].app_id) {
		LOG_DEBUG("Ignoring power management callback as no service entries exist");
		return;
		}

		LOG_DEBUG("Stopped all timers for service to device:%s id:%hhu",
		PRIVATE_ADDRESS(peer_addr), id);
		bta_dm_pm_stop_timer_by_srvc_id(peer_addr, id);
		/p_dev = bta_dm_find_peer_device(peer_addr);/

		p_dev = bta_dm_find_peer_device(peer_addr);
		if (p_dev) {
		LOG_DEBUG("Device info:%s", device_info_text(p_dev->info).c_str());
		} else {
		LOG_ERROR("Unable to find peer device...yet soldiering on...");
		}

		/* set SSR parameters on SYS CONN OPEN */
		int index = BTA_DM_PM_SSR0;
		@@ -441,11 +451,7 @@ static void bta_dm_pm_cback(tBTA_SYS_CONN_STATUS status, uint8_t id,
		p_dev->pm_mode_failed = 0;
		}

		if (p_bta_dm_ssr_spec[index].max_lat
		#if (BTA_HH_INCLUDED == TRUE)
		\|\| index == BTA_DM_PM_SSR_HH
		#endif
		) {
		if (p_bta_dm_ssr_spec[index].max_lat \|\| index == BTA_DM_PM_SSR_HH) {
		bta_dm_pm_ssr(peer_addr, index);
		} else {
		const controller_t* controller = controller_get_interface();
		@@ -709,6 +715,9 @@ static void bta_dm_pm_sniff(tBTA_DM_PEER_DEVICE* p_peer_dev, uint8_t index) {
		p_peer_dev->info);

		uint8_t* p_rem_feat = BTM_ReadRemoteFeatures(p_peer_dev->peer_bdaddr);
		LOG_DEBUG("Current power mode:%s[0x%x] peer_info:%s",
		power_mode_status_text(mode).c_str(), mode,
		device_info_text(p_peer_dev->info).c_str());

		const controller_t* controller = controller_get_interface();
		if (mode != BTM_PM_MD_SNIFF \|\|
		@@ -760,6 +769,8 @@ static void bta_dm_pm_ssr(const RawAddress& peer_addr, int ssr) {
		int ssr_index = ssr;
		tBTA_DM_SSR_SPEC* p_spec = &p_bta_dm_ssr_spec[ssr_index];

		LOG_DEBUG("Request to put link to device:%s into power_mode:%s",
		PRIVATE_ADDRESS(peer_addr), p_spec->name);
		/* go through the connected services */
		for (int i = 0; i < bta_dm_conn_srvcs.count; i++) {
		const tBTA_DM_SRVCS& service = bta_dm_conn_srvcs.conn_srvc[i];
		@@ -773,9 +784,10 @@ static void bta_dm_pm_ssr(const RawAddress& peer_addr, int ssr) {
		current_ssr_index = p_bta_dm_pm_spec[config.spec_idx].ssr;
		if ((config.id == service.id) && ((config.app_id == BTA_ALL_APP_ID) \|\|
		(config.app_id == service.app_id))) {
		LOG_INFO("Found connected service:%s app_id:%d peer:%s",
		LOG_INFO("Found connected service:%s app_id:%d peer:%s spec_name:%s",
		BtaIdSysText(service.id).c_str(), service.app_id,
		PRIVATE_ADDRESS(peer_addr));
		PRIVATE_ADDRESS(peer_addr),
		p_bta_dm_ssr_spec[current_ssr_index].name);
		break;
		}
		}
		@@ -793,16 +805,17 @@ static void bta_dm_pm_ssr(const RawAddress& peer_addr, int ssr) {
		#endif
		if (p_spec_cur->max_lat < p_spec->max_lat \|\|
		(ssr_index == BTA_DM_PM_SSR0 && current_ssr_index != BTA_DM_PM_SSR0)) {
		LOG_DEBUG(
		"Changing sniff subrating specification for %s from %s[%d] ==> "
		"%s[%d]",
		PRIVATE_ADDRESS(peer_addr), p_spec->name, ssr_index, p_spec_cur->name,
		current_ssr_index);
		ssr_index = current_ssr_index;
		p_spec = &p_bta_dm_ssr_spec[ssr_index];
		}
		}

		if (p_spec->max_lat) {
		LOG_DEBUG(
		"Max latency is non zero max_lat:0x%04x min_loc_to:0x%04x "
		"min_rmt_to:0x%04x",
		p_spec->max_lat, p_spec->min_loc_to, p_spec->min_rmt_to);
		/* Avoid SSR reset on device which has SCO connected */
		if (bta_dm_pm_is_sco_active()) {
		int idx = bta_dm_get_sco_index();
		@@ -815,37 +828,50 @@ static void bta_dm_pm_ssr(const RawAddress& peer_addr, int ssr) {
		}

		LOG_DEBUG(
		"Setting sniff subrating for device:%s max_lat:0x%04x "
		"min_loc_to:0x%04x min_rmt_to:0x%04x",
		PRIVATE_ADDRESS(peer_addr), p_spec->max_lat, p_spec->min_loc_to,
		p_spec->min_rmt_to);

		"Setting sniff subrating for device:%s spec_name:%s max_latency(s):%.2f"
		" min_local_timeout(s):%.2f min_remote_timeout(s):%.2f",
		PRIVATE_ADDRESS(peer_addr), p_spec->name,
		ticks_to_seconds(p_spec->max_lat), ticks_to_seconds(p_spec->min_loc_to),
		ticks_to_seconds(p_spec->min_rmt_to));
		/* set the SSR parameters. */
		BTM_SetSsrParams(peer_addr, p_spec->max_lat, p_spec->min_rmt_to,
		p_spec->min_loc_to);
		}
		}

		/*******************************************************************************
		*
		* Function bta_dm_pm_active
		*
		* Description Brings connection to active mode
		*
		*
		* Returns void
		*
		******************************************************************************/
		void bta_dm_pm_active(const RawAddress& peer_addr) {
		tBTM_PM_PWR_MD pm;

		memset((void*)&pm, 0, sizeof(pm));
		tBTM_PM_PWR_MD pm{
		.mode = BTM_PM_MD_ACTIVE,
		};

		/* switch to active mode */
		pm.mode = BTM_PM_MD_ACTIVE;
		tBTM_STATUS status = BTM_SetPowerMode(bta_dm_cb.pm_id, peer_addr, &pm);
		if (status != BTM_CMD_STORED && status != BTM_CMD_STARTED) {
		LOG_WARN("Unable to set active mode for device:%s",
		switch (status) {
		case BTM_CMD_STORED:
		LOG_DEBUG("Active power mode stored for execution later for remote:%s",
		PRIVATE_ADDRESS(peer_addr));
		break;
		case BTM_CMD_STARTED:
		LOG_DEBUG("Active power mode started for remote:%s",
		PRIVATE_ADDRESS(peer_addr));
		break;
		case BTM_SUCCESS:
		LOG_INFO("Active power mode already set for device:%s",
		PRIVATE_ADDRESS(peer_addr));
		break;
		default:
		LOG_WARN("Unable to set active power mode for device:%s status:%s",
		PRIVATE_ADDRESS(peer_addr), btm_status_text(status).c_str());
		break;
		}
		}

system/main/shim/acl.cc

+50 −0

Original line number	Diff line number	Diff line
		@@ -150,6 +150,8 @@ class ShimAclConnection {
		TRY_POSTING_ON_MAIN(send_data_upwards_, p_buf);
		}

		virtual void InitiateDisconnect(hci::DisconnectReason reason) = 0;

		protected:
		const uint16_t handle_{kInvalidHciHandle};
		os::Handler* handler_;
		@@ -340,6 +342,10 @@ class ClassicShimAclConnection

		hci::Address GetRemoteAddress() const { return connection_->GetAddress(); }

		void InitiateDisconnect(hci::DisconnectReason reason) override {
		connection_->Disconnect(reason);
		}

		private:
		OnDisconnect on_disconnect_;
		const shim::legacy::acl_classic_link_interface_t interface_;
		@@ -400,6 +406,10 @@ class LeShimAclConnection
		return connection_->GetRemoteAddress();
		}

		void InitiateDisconnect(hci::DisconnectReason reason) override {
		connection_->Disconnect(reason);
		}

		private:
		OnDisconnect on_disconnect_;
		const shim::legacy::acl_le_link_interface_t interface_;
		@@ -474,6 +484,11 @@ void DumpsysAcl(int fd) {
		common::ToString(acl_conn.peer_lmp_feature_valid[j]).c_str(),
		bd_features_text(acl_conn.peer_lmp_feature_pages[j]).c_str());
		}
		LOG_DUMPSYS(fd, " sniff_subrating:%s",
		common::ToString(HCI_SNIFF_SUB_RATE_SUPPORTED(
		acl_conn.peer_lmp_feature_pages[0]))
		.c_str());

		LOG_DUMPSYS(fd, "remote_addr:%s", acl_conn.remote_addr.ToString().c_str());
		LOG_DUMPSYS(fd, " handle:0x%04x", acl_conn.hci_handle);
		LOG_DUMPSYS(fd, " [le] active_remote_addr:%s",
		@@ -756,3 +771,38 @@ void bluetooth::shim::legacy::Acl::ConfigureLePrivacy(
		address_policy, empty_address_with_type, rotation_irk,
		minimum_rotation_time, maximum_rotation_time);
		}

		void bluetooth::shim::legacy::Acl::DisconnectClassic(uint16_t handle,
		tHCI_STATUS reason) {
		auto connection = pimpl_->handle_to_classic_connection_map_.find(handle);
		if (connection != pimpl_->handle_to_classic_connection_map_.end()) {
		auto remote_address = connection->second->GetRemoteAddress();
		connection->second->InitiateDisconnect(
		ToDisconnectReasonFromLegacy(reason));
		LOG_DEBUG("Disconnection initiated classic remote:%s handle:%hu",
		PRIVATE_ADDRESS(remote_address), handle);
		btm_cb.history_->Push("%-32s: %s classic", "Disconnection initiated",
		PRIVATE_ADDRESS(remote_address));
		} else {
		LOG_WARN("Unable to disconnect unknown classic connection handle:0x%04x",
		handle);
		}
		}

		void bluetooth::shim::legacy::Acl::DisconnectLe(uint16_t handle,
		tHCI_STATUS reason) {
		auto connection = pimpl_->handle_to_le_connection_map_.find(handle);
		if (connection != pimpl_->handle_to_le_connection_map_.end()) {
		auto remote_address_with_type =
		connection->second->GetRemoteAddressWithType();
		connection->second->InitiateDisconnect(
		ToDisconnectReasonFromLegacy(reason));
		LOG_DEBUG("Disconnection initiated le remote:%s handle:%hu",
		PRIVATE_ADDRESS(remote_address_with_type), handle);
		btm_cb.history_->Push("%-32s: %s le", "Disconnection initiated",
		PRIVATE_ADDRESS(remote_address_with_type));
		} else {
		LOG_WARN("Unable to disconnect unknown le connection handle:0x%04x",
		handle);
		}
		}

system/main/shim/acl.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -59,6 +59,9 @@ class Acl : public hci::acl_manager::ConnectionCallbacks,

		void ConfigureLePrivacy(bool is_le_privacy_enabled);

		void DisconnectClassic(uint16_t handle, tHCI_STATUS reason);
		void DisconnectLe(uint16_t handle, tHCI_STATUS reason);

		void Dump(int fd) const;

		protected: