Merge changes from topic "bt-gd-vse" am: 6f49da27c8 am: 2a06ea64af (53acb672) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/hci_layer.cc

+52 −43

Original line number	Diff line number	Diff line
		@@ -87,14 +87,17 @@ class CommandQueueEntry {
		struct HciLayer::impl {
		impl(hal::HciHal* hal, HciLayer& module) : hal_(hal), module_(module) {
		hci_timeout_alarm_ = new Alarm(module.GetHandler());
		hci_abort_alarm_ = new Alarm(module.GetHandler());
		}

		~impl() {
		incoming_acl_buffer_.Clear();
		incoming_iso_buffer_.Clear();
		if (hci_timeout_alarm_ != nullptr) {
		delete hci_timeout_alarm_;
		}
		if (hci_abort_alarm_ != nullptr) {
		delete hci_abort_alarm_;
		}
		command_queue_.clear();
		}

		@@ -165,12 +168,15 @@ struct HciLayer::impl {
		command_queue_.front().GetCallback<TResponse>()->Invoke(move(response_view));
		command_queue_.pop_front();
		waiting_command_ = OpCode::NONE;
		if (hci_timeout_alarm_ != nullptr) {
		hci_timeout_alarm_->Cancel();
		send_next_command();
		}
		}

		void on_hci_timeout(OpCode op_code) {
		LOG_ERROR("Timed out waiting for 0x%02hx (%s)", op_code, OpCodeText(op_code).c_str());
		// TODO: LogMetricHciTimeoutEvent(static_cast<uint32_t>(op_code));

		LOG_ERROR("Flushing %zd waiting commands", command_queue_.size());
		// Clear any waiting commands (there is an abort coming anyway)
		@@ -180,8 +186,17 @@ struct HciLayer::impl {
		enqueue_command(
		ControllerDebugInfoBuilder::Create(), module_.GetHandler()->BindOnce(&fail_if_reset_complete_not_success));
		// Don't time out for this one;
		if (hci_timeout_alarm_ != nullptr) {
		hci_timeout_alarm_->Cancel();
		delete hci_timeout_alarm_;
		hci_timeout_alarm_ = nullptr;
		}
		if (hci_abort_alarm_ == nullptr) {
		hci_abort_alarm_ = new Alarm(module_.GetHandler());
		hci_abort_alarm_->Schedule(BindOnce(&abort_after_time_out, op_code), kHciTimeoutRestartMs);
		} else {
		LOG_WARN("Unable to schedul abort timer");
		}
		}

		void send_next_command() {
		@@ -204,7 +219,11 @@ struct HciLayer::impl {
		OpCode op_code = cmd_view.GetOpCode();
		waiting_command_ = op_code;
		command_credits_ = 0; // Only allow one outstanding command
		if (hci_timeout_alarm_ != nullptr) {
		hci_timeout_alarm_->Schedule(BindOnce(&impl::on_hci_timeout, common::Unretained(this), op_code), kHciTimeoutMs);
		} else {
		LOG_WARN("%s sent without an hci-timeout timer", OpCodeText(op_code).c_str());
		}
		}

		void register_event(EventCode event, ContextualCallback<void(EventView)> handler) {
		@@ -245,23 +264,38 @@ struct HciLayer::impl {
		subevent_handlers_.erase(subevent_handlers_.find(event));
		}

		void register_vendor_specific_event(
		VseSubeventCode vse_subevent_code, ContextualCallback<void(VendorSpecificEventView)> event_handler) {
		ASSERT_LOG(
		vendor_specific_event_handlers_.count(vse_subevent_code) == 0,
		"Can not register a second handler for %02hhx (%s)",
		vse_subevent_code,
		VseSubeventCodeText(vse_subevent_code).c_str());
		vendor_specific_event_handlers_[vse_subevent_code] = event_handler;
		static void abort_after_root_inflammation(uint8_t vse_error) {
		ASSERT_LOG(false, "Root inflammation with reason 0x%02hhx", vse_error);
		}

		void unregister_vendor_specific_event(VseSubeventCode vse_subevent_code) {
		vendor_specific_event_handlers_.erase(vendor_specific_event_handlers_.find(vse_subevent_code));
		void handle_root_inflammation(uint8_t vse_error_reason) {
		// Add Logging for crash reason
		if (hci_timeout_alarm_ != nullptr) {
		hci_timeout_alarm_->Cancel();
		delete hci_timeout_alarm_;
		hci_timeout_alarm_ = nullptr;
		}
		LOG_ERROR("Received a Root Inflammation Event, scheduling an abort");
		if (hci_abort_alarm_ == nullptr) {
		hci_abort_alarm_ = new Alarm(module_.GetHandler());
		hci_abort_alarm_->Schedule(BindOnce(&abort_after_root_inflammation, vse_error_reason), kHciTimeoutRestartMs);
		} else {
		LOG_WARN("Abort timer already scheduled");
		}
		}

		void on_hci_event(EventView event) {
		ASSERT(event.IsValid());
		EventCode event_code = event.GetEventCode();
		// Root Inflamation is a special case, since it aborts here
		if (event_code == EventCode::VENDOR_SPECIFIC) {
		auto inflammation = BqrRootInflammationEventView::Create(
		BqrLinkQualityEventView::Create(BqrEventView::Create(VendorSpecificEventView::Create(event))));
		if (inflammation.IsValid()) {
		handle_root_inflammation(inflammation.GetVendorSpecificErrorCode());
		return;
		}
		}
		ASSERT_LOG(
		event_handlers_.find(event_code) != event_handlers_.end(),
		"Unhandled event of type 0x%02hhx (%s)",
		@@ -282,20 +316,6 @@ struct HciLayer::impl {
		subevent_handlers_[subevent_code].Invoke(meta_event_view);
		}

		void on_vendor_specific_event(EventView event) {
		VendorSpecificEventView vendor_specific_event_view = VendorSpecificEventView::Create(event);
		ASSERT(vendor_specific_event_view.IsValid());
		VseSubeventCode vse_subevent_code = vendor_specific_event_view.GetSubeventCode();
		if (vendor_specific_event_handlers_.find(vse_subevent_code) == vendor_specific_event_handlers_.end()) {
		LOG_ERROR(
		"Unhandled vendor specific event of type 0x%02hhx (%s)",
		vse_subevent_code,
		VseSubeventCodeText(vse_subevent_code).c_str());
		return;
		}
		vendor_specific_event_handlers_[vse_subevent_code].Invoke(vendor_specific_event_view);
		}

		hal::HciHal* hal_;
		HciLayer& module_;

		@@ -304,7 +324,6 @@ struct HciLayer::impl {

		std::map<EventCode, ContextualCallback<void(EventView)>> event_handlers_;
		std::map<SubeventCode, ContextualCallback<void(LeMetaEventView)>> subevent_handlers_;
		std::map<VseSubeventCode, ContextualCallback<void(VendorSpecificEventView)>> vendor_specific_event_handlers_;
		OpCode waiting_command_{OpCode::NONE};
		uint8_t command_credits_{1}; // Send reset first
		Alarm* hci_timeout_alarm_{nullptr};
		@@ -391,15 +410,6 @@ void HciLayer::UnregisterLeEventHandler(SubeventCode event) {
		CallOn(impl_, &impl::unregister_le_event, event);
		}

		void HciLayer::RegisterVendorSpecificEventHandler(
		VseSubeventCode vse_subevent_code, common::ContextualCallback<void(VendorSpecificEventView)> event_handler) {
		CallOn(impl_, &impl::register_vendor_specific_event, vse_subevent_code, event_handler);
		}

		void HciLayer::UnregisterVendorSpecificEventHandler(VseSubeventCode vse_subevent_code) {
		CallOn(impl_, &impl::unregister_vendor_specific_event, vse_subevent_code);
		}

		void HciLayer::on_disconnection_complete(EventView event_view) {
		auto disconnection_view = DisconnectionCompleteView::Create(event_view);
		if (!disconnection_view.IsValid()) {
		@@ -526,7 +536,6 @@ void HciLayer::Start() {
		auto drop_packet = handler->BindOn(impl_, &impl::drop);
		RegisterEventHandler(EventCode::PAGE_SCAN_REPETITION_MODE_CHANGE, drop_packet);
		RegisterEventHandler(EventCode::MAX_SLOTS_CHANGE, drop_packet);
		RegisterEventHandler(EventCode::VENDOR_SPECIFIC, handler->BindOn(impl_, &impl::on_vendor_specific_event));

		EnqueueCommand(ResetBuilder::Create(), handler->BindOnce(&fail_if_reset_complete_not_success));
		hal->registerIncomingPacketCallback(hal_callbacks_);

system/gd/hci/hci_layer.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -67,11 +67,6 @@ class HciLayer : public Module, public CommandInterface<CommandBuilder> {

		virtual void UnregisterLeEventHandler(SubeventCode subevent_code);

		virtual void RegisterVendorSpecificEventHandler(
		VseSubeventCode vse_subevent_code, common::ContextualCallback<void(VendorSpecificEventView)> event_handler);

		virtual void UnregisterVendorSpecificEventHandler(VseSubeventCode vse_subevent_code);

		virtual SecurityInterface* GetSecurityInterface(common::ContextualCallback<void(EventView)> event_handler);

		virtual LeSecurityInterface* GetLeSecurityInterface(common::ContextualCallback<void(LeMetaEventView)> event_handler);

system/gd/hci/hci_layer_test.cc

+0 −96

Original line number	Diff line number	Diff line
		@@ -17,7 +17,6 @@
		#include "hci/hci_layer.h"

		#include <gtest/gtest.h>

		#include <list>
		#include <memory>

		@@ -270,15 +269,6 @@ class DependsOnHci : public Module {
		return packetview;
		}

		void RegisterVendorSpecificEvent(VseSubeventCode event) {
		hci_->RegisterVendorSpecificEventHandler(
		event, GetHandler()->BindOn(this, &DependsOnHci::handle_event<VendorSpecificEventView>));
		}

		void UnregisterVendorSpecificEvent(VseSubeventCode event) {
		hci_->UnregisterVendorSpecificEventHandler(event);
		}

		void Start() {
		hci_ = GetDependency<HciLayer>();
		hci_->RegisterEventHandler(
		@@ -459,92 +449,6 @@ TEST_F(HciTest, leMetaEvent) {
		ASSERT_TRUE(LeConnectionCompleteView::Create(LeMetaEventView::Create(EventView::Create(event))).IsValid());
		}

		TEST_F(HciTest, vendorSpecificEventRegistration) {
		auto event_future = upper->GetReceivedEventFuture();

		upper->RegisterVendorSpecificEvent(VseSubeventCode::BQR_EVENT);

		// Send a vendor specific event
		hal->callbacks->hciEventReceived(GetPacketBytes(BqrLinkQualityEventBuilder::Create(
		QualityReportId::A2DP_AUDIO_CHOPPY,
		BqrPacketType::TYPE_2DH1,
		/* handle */ 0x123,
		Role::CENTRAL,
		/* TX_Power_Level */ 0x05,
		/* RSSI */ 65,
		/* SNR */ 30,
		/* Unused_AFH_Channel_Count */ 0,
		/* AFH_Select_Unideal_Channel_Count */ 0,
		/* LSTO */ 12,
		/* Connection_Piconet_Clock */ 42,
		/* Retransmission_Count */ 1,
		/* No_RX_Count */ 1,
		/* NAK_Count */ 1,
		/* Last_TX_ACK_Timestamp */ 123456,
		/* Flow_Off_Count */ 78910,
		/* Last_Flow_On_Timestamp */ 123457,
		/* Buffer_Overflow_Bytes */ 42,
		/* Buffer_Underflow_Bytes */ 24,
		/* Vendor Specific Parameter */ std::make_unique<RawBuilder>())));

		// Wait for the event
		auto event_status = event_future.wait_for(kTimeout);
		ASSERT_EQ(event_status, std::future_status::ready);

		auto event = upper->GetReceivedEvent();
		ASSERT_TRUE(
		BqrLinkQualityEventView::Create(BqrEventView::Create(VendorSpecificEventView::Create(EventView::Create(event))))
		.IsValid());

		// Now test if we can unregister the vendor specific event handler
		event_future = upper->GetReceivedEventFuture();

		upper->UnregisterVendorSpecificEvent(VseSubeventCode::BQR_EVENT);

		hal->callbacks->hciEventReceived(GetPacketBytes(BqrLinkQualityEventBuilder::Create(
		QualityReportId::A2DP_AUDIO_CHOPPY,
		BqrPacketType::TYPE_2DH1,
		/* handle */ 0x123,
		Role::CENTRAL,
		/* TX_Power_Level */ 0x05,
		/* RSSI */ 65,
		/* SNR */ 30,
		/* Unused_AFH_Channel_Count */ 0,
		/* AFH_Select_Unideal_Channel_Count */ 0,
		/* LSTO */ 12,
		/* Connection_Piconet_Clock */ 42,
		/* Retransmission_Count */ 1,
		/* No_RX_Count */ 1,
		/* NAK_Count */ 1,
		/* Last_TX_ACK_Timestamp */ 123456,
		/* Flow_Off_Count */ 78910,
		/* Last_Flow_On_Timestamp */ 123457,
		/* Buffer_Overflow_Bytes */ 42,
		/* Buffer_Underflow_Bytes */ 24,
		/* Vendor Specific Parameter */ std::make_unique<RawBuilder>())));

		// Wait for unregistered event should timeout
		event_status = event_future.wait_for(kTimeout);
		ASSERT_NE(event_status, std::future_status::ready);
		}

		TEST_F(HciTest, vendorSpecificEventUnknown) {
		auto event_future = upper->GetReceivedEventFuture();

		upper->RegisterVendorSpecificEvent(VseSubeventCode::BQR_EVENT);

		// Send a vendor specific event
		// Make sure 0xFE is not used for any VSE, if not change this value to an unused one
		auto raw_builder = std::make_unique<RawBuilder>();
		raw_builder->AddOctets1(42);
		hal->callbacks->hciEventReceived(
		GetPacketBytes(VendorSpecificEventBuilder::Create(static_cast<VseSubeventCode>(0xFE), std::move(raw_builder))));

		// Wait for the event should timeout
		auto event_status = event_future.wait_for(kTimeout);
		ASSERT_NE(event_status, std::future_status::ready);
		}

		TEST_F(HciTest, hciTimeOut) {
		auto event_future = upper->GetReceivedEventFuture();
		auto reset_command_future = hal->GetSentCommandFuture();

system/main/shim/hci_layer.cc

+13 −60

Original line number	Diff line number	Diff line
		@@ -54,8 +54,7 @@ static base::Callback<void(const base::Location&, BT_HDR*)> send_data_upwards;
		static const packet_fragmenter_t* packet_fragmenter;

		namespace {
		bool is_valid_event_code(uint8_t event_code_raw) {
		auto event_code = static_cast<bluetooth::hci::EventCode>(event_code_raw);
		bool is_valid_event_code(bluetooth::hci::EventCode event_code) {
		switch (event_code) {
		case bluetooth::hci::EventCode::INQUIRY_COMPLETE:
		case bluetooth::hci::EventCode::INQUIRY_RESULT:
		@@ -116,9 +115,7 @@ bool is_valid_event_code(uint8_t event_code_raw) {
		return false;
		};

		bool is_valid_subevent_code(uint8_t subevent_code_raw) {
		auto subevent_code =
		static_cast<bluetooth::hci::SubeventCode>(subevent_code_raw);
		bool is_valid_subevent_code(bluetooth::hci::SubeventCode subevent_code) {
		switch (subevent_code) {
		case bluetooth::hci::SubeventCode::CONNECTION_COMPLETE:
		case bluetooth::hci::SubeventCode::CONNECTION_UPDATE_COMPLETE:
		@@ -161,19 +158,6 @@ bool is_valid_subevent_code(uint8_t subevent_code_raw) {
		}
		}

		bool is_valid_vendor_specific_event(uint8_t vse_code_raw) {
		auto vse_code = static_cast<bluetooth::hci::VseSubeventCode>(vse_code_raw);
		switch (vse_code) {
		case bluetooth::hci::VseSubeventCode::BQR_EVENT:
		case bluetooth::hci::VseSubeventCode::BLE_THRESHOLD:
		case bluetooth::hci::VseSubeventCode::BLE_TRACKING:
		case bluetooth::hci::VseSubeventCode::DEBUG_INFO:
		return true;
		default:
		return false;
		}
		}

		static bool event_already_registered_in_hci_layer(
		bluetooth::hci::EventCode event_code) {
		switch (event_code) {
		@@ -181,8 +165,6 @@ static bool event_already_registered_in_hci_layer(
		case bluetooth::hci::EventCode::COMMAND_STATUS:
		case bluetooth::hci::EventCode::PAGE_SCAN_REPETITION_MODE_CHANGE:
		case bluetooth::hci::EventCode::MAX_SLOTS_CHANGE:
		case bluetooth::hci::EventCode::VENDOR_SPECIFIC:
		return bluetooth::shim::is_gd_hci_enabled();
		case bluetooth::hci::EventCode::DISCONNECTION_COMPLETE:
		case bluetooth::hci::EventCode::READ_REMOTE_VERSION_INFORMATION_COMPLETE:
		case bluetooth::hci::EventCode::LE_META_EVENT:
		@@ -354,16 +336,6 @@ static void subevent_callback(
		&le_meta_event_view));
		}

		static void vendor_specific_event_callback(
		bluetooth::hci::VendorSpecificEventView vendor_specific_event_view) {
		if (!send_data_upwards) {
		return;
		}
		send_data_upwards.Run(
		FROM_HERE,
		WrapPacketAndCopy(MSG_HC_TO_STACK_HCI_EVT, &vendor_specific_event_view));
		}

		void OnTransmitPacketCommandComplete(command_complete_cb complete_callback,
		void* context,
		bluetooth::hci::CommandCompleteView view) {
		@@ -453,13 +425,6 @@ static void register_le_event(bluetooth::hci::SubeventCode subevent_code) {
		subevent_code, handler->Bind(subevent_callback));
		}

		static void register_vendor_specific_event(
		bluetooth::hci::VseSubeventCode vse_code) {
		auto handler = bluetooth::shim::GetGdShimHandler();
		bluetooth::shim::GetHciLayer()->RegisterVendorSpecificEventHandler(
		vse_code, handler->Bind(vendor_specific_event_callback));
		}

		static void acl_data_callback() {
		if (hci_queue_end == nullptr) {
		return;
		@@ -504,11 +469,12 @@ static void on_shutting_down() {
		!bluetooth::shim::is_gd_l2cap_enabled()) {
		hci_queue_end->UnregisterDequeue();
		}
		for (uint8_t event_code_raw = 0; event_code_raw < 0xFF; event_code_raw++) {
		if (!is_valid_event_code(event_code_raw)) {
		for (uint16_t event_code_raw = 0; event_code_raw < 0x100;
		event_code_raw++) {
		auto event_code = static_cast<bluetooth::hci::EventCode>(event_code_raw);
		if (!is_valid_event_code(event_code)) {
		continue;
		}
		auto event_code = static_cast<bluetooth::hci::EventCode>(event_code_raw);
		if (event_already_registered_in_hci_layer(event_code)) {
		continue;
		} else if (event_already_registered_in_le_advertising_manager(
		@@ -747,11 +713,11 @@ void bluetooth::shim::hci_on_reset_complete() {
		::rust::hci_on_reset_complete();
		}

		for (uint8_t event_code_raw = 0; event_code_raw < 0xFF; event_code_raw++) {
		if (!is_valid_event_code(event_code_raw)) {
		for (uint16_t event_code_raw = 0; event_code_raw < 0x100; event_code_raw++) {
		auto event_code = static_cast<bluetooth::hci::EventCode>(event_code_raw);
		if (!is_valid_event_code(event_code)) {
		continue;
		}
		auto event_code = static_cast<bluetooth::hci::EventCode>(event_code_raw);
		if (event_already_registered_in_acl_layer(event_code)) {
		continue;
		} else if (event_already_registered_in_controller_layer(event_code)) {
		@@ -771,13 +737,13 @@ void bluetooth::shim::hci_on_reset_complete() {
		}
		}

		for (uint8_t subevent_code_raw = 0; subevent_code_raw < 0xFF;
		for (uint16_t subevent_code_raw = 0; subevent_code_raw < 0x100;
		subevent_code_raw++) {
		if (!is_valid_subevent_code(subevent_code_raw)) {
		continue;
		}
		auto subevent_code =
		static_cast<bluetooth::hci::SubeventCode>(subevent_code_raw);
		if (!is_valid_subevent_code(subevent_code)) {
		continue;
		}
		if (subevent_already_registered_in_le_hci_layer(subevent_code)) {
		continue;
		}
		@@ -789,19 +755,6 @@ void bluetooth::shim::hci_on_reset_complete() {
		}
		}

		for (uint8_t vse_code_raw = 0; vse_code_raw < 0xFF; vse_code_raw++) {
		if (!is_valid_vendor_specific_event(vse_code_raw)) {
		continue;
		}
		auto vse_code = static_cast<bluetooth::hci::VseSubeventCode>(vse_code_raw);
		if (bluetooth::common::init_flags::gd_rust_is_enabled()) {
		// TODO(b/183057550): Need Rust HCI implementation for VSE
		// ::rust::register_vendor_specific_event(vse_code_raw);
		} else {
		cpp::register_vendor_specific_event(vse_code);
		}
		}

		if (bluetooth::shim::is_gd_acl_enabled()) {
		return;
		}

system/stack/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -716,6 +716,7 @@ cc_test {
		"test/btm/stack_btm_test.cc",
		"test/common/mock_bta_dm_act.cc",
		"test/common/mock_bta_sys_conn.cc",
		"test/common/mock_btif_bqr.cc",
		"test/common/mock_btif_dm.cc",
		"test/common/mock_btif_storage.cc",
		"test/common/mock_btu_hcif.cc",