1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "hci/controller.h"
18
19 #include <future>
20 #include <memory>
21 #include <string>
22 #include <utility>
23
24 #include "common/init_flags.h"
25 #include "hci/hci_layer.h"
26 #include "hci_controller_generated.h"
27 #include "os/metrics.h"
28 #include "os/system_properties.h"
29 #include "sysprops/sysprops_module.h"
30
31 namespace bluetooth {
32 namespace hci {
33
34 constexpr uint8_t kMinEncryptionKeySize = 7; // #define MIN_ENCRYPTION_KEY_SIZE 7
35
36 constexpr bool kDefaultVendorCapabilitiesEnabled = true;
37 static const std::string kPropertyVendorCapabilitiesEnabled =
38 "bluetooth.core.le.vendor_capabilities.enabled";
39
40 using os::Handler;
41
42 struct Controller::impl {
implbluetooth::hci::Controller::impl43 impl(Controller& module) : module_(module) {}
44
Startbluetooth::hci::Controller::impl45 void Start(hci::HciLayer* hci) {
46 hci_ = hci;
47 Handler* handler = module_.GetHandler();
48 hci_->RegisterEventHandler(
49 EventCode::NUMBER_OF_COMPLETED_PACKETS, handler->BindOn(this, &Controller::impl::NumberOfCompletedPackets));
50
51 set_event_mask(kDefaultEventMask);
52 write_le_host_support(Enable::ENABLED, Enable::DISABLED);
53 hci_->EnqueueCommand(ReadLocalNameBuilder::Create(),
54 handler->BindOnceOn(this, &Controller::impl::read_local_name_complete_handler));
55 hci_->EnqueueCommand(ReadLocalVersionInformationBuilder::Create(),
56 handler->BindOnceOn(this, &Controller::impl::read_local_version_information_complete_handler));
57 hci_->EnqueueCommand(ReadLocalSupportedCommandsBuilder::Create(),
58 handler->BindOnceOn(this, &Controller::impl::read_local_supported_commands_complete_handler));
59
60 hci_->EnqueueCommand(
61 LeReadLocalSupportedFeaturesBuilder::Create(),
62 handler->BindOnceOn(this, &Controller::impl::le_read_local_supported_features_handler));
63
64 hci_->EnqueueCommand(
65 LeReadSupportedStatesBuilder::Create(),
66 handler->BindOnceOn(this, &Controller::impl::le_read_supported_states_handler));
67
68 // Wait for all extended features read
69 std::promise<void> features_promise;
70 auto features_future = features_promise.get_future();
71
72 hci_->EnqueueCommand(ReadLocalExtendedFeaturesBuilder::Create(0x00),
73 handler->BindOnceOn(this, &Controller::impl::read_local_extended_features_complete_handler,
74 std::move(features_promise)));
75 features_future.wait();
76
77 le_set_event_mask(MaskLeEventMask(local_version_information_.hci_version_, kDefaultLeEventMask));
78
79 hci_->EnqueueCommand(ReadBufferSizeBuilder::Create(),
80 handler->BindOnceOn(this, &Controller::impl::read_buffer_size_complete_handler));
81
82 if (common::init_flags::set_min_encryption_is_enabled() && is_supported(OpCode::SET_MIN_ENCRYPTION_KEY_SIZE)) {
83 hci_->EnqueueCommand(
84 SetMinEncryptionKeySizeBuilder::Create(kMinEncryptionKeySize),
85 handler->BindOnceOn(this, &Controller::impl::set_min_encryption_key_size_handler));
86 }
87
88 if (is_supported(OpCode::LE_READ_BUFFER_SIZE_V2)) {
89 hci_->EnqueueCommand(
90 LeReadBufferSizeV2Builder::Create(),
91 handler->BindOnceOn(this, &Controller::impl::le_read_buffer_size_v2_handler));
92 } else {
93 hci_->EnqueueCommand(
94 LeReadBufferSizeV1Builder::Create(),
95 handler->BindOnceOn(this, &Controller::impl::le_read_buffer_size_handler));
96 }
97
98 hci_->EnqueueCommand(
99 LeReadFilterAcceptListSizeBuilder::Create(),
100 handler->BindOnceOn(this, &Controller::impl::le_read_connect_list_size_handler));
101
102 if (is_supported(OpCode::LE_READ_RESOLVING_LIST_SIZE) && module_.SupportsBlePrivacy()) {
103 hci_->EnqueueCommand(
104 LeReadResolvingListSizeBuilder::Create(),
105 handler->BindOnceOn(this, &Controller::impl::le_read_resolving_list_size_handler));
106 } else {
107 LOG_INFO("LE_READ_RESOLVING_LIST_SIZE not supported, defaulting to 0");
108 le_resolving_list_size_ = 0;
109 }
110
111 if (is_supported(OpCode::LE_READ_MAXIMUM_DATA_LENGTH) && module_.SupportsBleDataPacketLengthExtension()) {
112 hci_->EnqueueCommand(LeReadMaximumDataLengthBuilder::Create(),
113 handler->BindOnceOn(this, &Controller::impl::le_read_maximum_data_length_handler));
114 } else {
115 LOG_INFO("LE_READ_MAXIMUM_DATA_LENGTH not supported, defaulting to 0");
116 le_maximum_data_length_.supported_max_rx_octets_ = 0;
117 le_maximum_data_length_.supported_max_rx_time_ = 0;
118 le_maximum_data_length_.supported_max_tx_octets_ = 0;
119 le_maximum_data_length_.supported_max_tx_time_ = 0;
120 }
121
122 // SSP is managed by security layer once enabled
123 write_simple_pairing_mode(Enable::ENABLED);
124 if (module_.SupportsSecureConnections()) {
125 hci_->EnqueueCommand(
126 WriteSecureConnectionsHostSupportBuilder::Create(Enable::ENABLED),
127 handler->BindOnceOn(
128 this, &Controller::impl::write_secure_connections_host_support_complete_handler));
129 }
130 if (is_supported(OpCode::LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH) && module_.SupportsBleDataPacketLengthExtension()) {
131 hci_->EnqueueCommand(
132 LeReadSuggestedDefaultDataLengthBuilder::Create(),
133 handler->BindOnceOn(this, &Controller::impl::le_read_suggested_default_data_length_handler));
134 } else {
135 LOG_INFO("LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH not supported, defaulting to 27 (0x1B)");
136 le_suggested_default_data_length_ = 27;
137 }
138
139 if (is_supported(OpCode::LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH) && module_.SupportsBleExtendedAdvertising()) {
140 hci_->EnqueueCommand(
141 LeReadMaximumAdvertisingDataLengthBuilder::Create(),
142 handler->BindOnceOn(this, &Controller::impl::le_read_maximum_advertising_data_length_handler));
143 } else {
144 LOG_INFO("LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH not supported, defaulting to 31 (0x1F)");
145 le_maximum_advertising_data_length_ = 31;
146 }
147
148 if (is_supported(OpCode::LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS) &&
149 module_.SupportsBleExtendedAdvertising()) {
150 hci_->EnqueueCommand(
151 LeReadNumberOfSupportedAdvertisingSetsBuilder::Create(),
152 handler->BindOnceOn(this, &Controller::impl::le_read_number_of_supported_advertising_sets_handler));
153 } else {
154 LOG_INFO("LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS not supported, defaulting to 1");
155 le_number_supported_advertising_sets_ = 1;
156 }
157
158 if (is_supported(OpCode::LE_READ_PERIODIC_ADVERTISER_LIST_SIZE) &&
159 module_.SupportsBlePeriodicAdvertising()) {
160 hci_->EnqueueCommand(
161 LeReadPeriodicAdvertiserListSizeBuilder::Create(),
162 handler->BindOnceOn(this, &Controller::impl::le_read_periodic_advertiser_list_size_handler));
163 } else {
164 LOG_INFO("LE_READ_PERIODIC_ADVERTISER_LIST_SIZE not supported, defaulting to 0");
165 le_periodic_advertiser_list_size_ = 0;
166 }
167 if (is_supported(OpCode::LE_SET_HOST_FEATURE) && module_.SupportsBleConnectedIsochronousStreamCentral()) {
168 hci_->EnqueueCommand(
169 LeSetHostFeatureBuilder::Create(LeHostFeatureBits::CONNECTED_ISO_STREAM_HOST_SUPPORT, Enable::ENABLED),
170 handler->BindOnceOn(this, &Controller::impl::le_set_host_feature_handler));
171 }
172
173 if (common::init_flags::subrating_is_enabled() && is_supported(OpCode::LE_SET_HOST_FEATURE) &&
174 module_.SupportsBleConnectionSubrating()) {
175 hci_->EnqueueCommand(
176 LeSetHostFeatureBuilder::Create(
177 LeHostFeatureBits::CONNECTION_SUBRATING_HOST_SUPPORT, Enable::ENABLED),
178 handler->BindOnceOn(this, &Controller::impl::le_set_host_feature_handler));
179 }
180
181 if (is_supported(OpCode::READ_DEFAULT_ERRONEOUS_DATA_REPORTING)) {
182 hci_->EnqueueCommand(
183 ReadDefaultErroneousDataReportingBuilder::Create(),
184 handler->BindOnceOn(
185 this, &Controller::impl::read_default_erroneous_data_reporting_handler));
186 }
187
188 // Skip vendor capabilities check if configured.
189 if (os::GetSystemPropertyBool(
190 kPropertyVendorCapabilitiesEnabled, kDefaultVendorCapabilitiesEnabled)) {
191 hci_->EnqueueCommand(
192 LeGetVendorCapabilitiesBuilder::Create(),
193 handler->BindOnceOn(this, &Controller::impl::le_get_vendor_capabilities_handler));
194 } else {
195 vendor_capabilities_.is_supported_ = 0x00;
196 }
197
198 // We only need to synchronize the last read. Make BD_ADDR to be the last one.
199 std::promise<void> promise;
200 auto future = promise.get_future();
201 hci_->EnqueueCommand(
202 ReadBdAddrBuilder::Create(),
203 handler->BindOnceOn(this, &Controller::impl::read_controller_mac_address_handler, std::move(promise)));
204 future.wait();
205 }
206
Stopbluetooth::hci::Controller::impl207 void Stop() {
208 if (bluetooth::common::init_flags::gd_core_is_enabled()) {
209 hci_->UnregisterEventHandler(EventCode::NUMBER_OF_COMPLETED_PACKETS);
210 }
211 hci_ = nullptr;
212 }
213
NumberOfCompletedPacketsbluetooth::hci::Controller::impl214 void NumberOfCompletedPackets(EventView event) {
215 if (acl_credits_callback_.IsEmpty()) {
216 LOG_WARN("Received event when AclManager is not listening");
217 return;
218 }
219 auto complete_view = NumberOfCompletedPacketsView::Create(event);
220 ASSERT(complete_view.IsValid());
221 for (auto completed_packets : complete_view.GetCompletedPackets()) {
222 uint16_t handle = completed_packets.connection_handle_;
223 uint16_t credits = completed_packets.host_num_of_completed_packets_;
224 acl_credits_callback_.Invoke(handle, credits);
225 if (!acl_monitor_credits_callback_.IsEmpty()) {
226 acl_monitor_credits_callback_.Invoke(handle, credits);
227 }
228 }
229 }
230
register_completed_acl_packets_callbackbluetooth::hci::Controller::impl231 void register_completed_acl_packets_callback(CompletedAclPacketsCallback callback) {
232 ASSERT(acl_credits_callback_.IsEmpty());
233 acl_credits_callback_ = callback;
234 }
235
unregister_completed_acl_packets_callbackbluetooth::hci::Controller::impl236 void unregister_completed_acl_packets_callback() {
237 ASSERT(!acl_credits_callback_.IsEmpty());
238 acl_credits_callback_ = {};
239 }
240
register_completed_monitor_acl_packets_callbackbluetooth::hci::Controller::impl241 void register_completed_monitor_acl_packets_callback(CompletedAclPacketsCallback callback) {
242 ASSERT(acl_monitor_credits_callback_.IsEmpty());
243 acl_monitor_credits_callback_ = callback;
244 }
245
unregister_completed_monitor_acl_packets_callbackbluetooth::hci::Controller::impl246 void unregister_completed_monitor_acl_packets_callback() {
247 ASSERT(!acl_monitor_credits_callback_.IsEmpty());
248 acl_monitor_credits_callback_ = {};
249 }
250
register_monitor_completed_acl_packets_callbackbluetooth::hci::Controller::impl251 void register_monitor_completed_acl_packets_callback(CompletedAclPacketsCallback callback) {
252 ASSERT(acl_monitor_credits_callback_.IsEmpty());
253 acl_monitor_credits_callback_ = callback;
254 }
255
unregister_monitor_completed_acl_packets_callbackbluetooth::hci::Controller::impl256 void unregister_monitor_completed_acl_packets_callback() {
257 ASSERT(!acl_monitor_credits_callback_.IsEmpty());
258 acl_monitor_credits_callback_ = {};
259 }
260
write_secure_connections_host_support_complete_handlerbluetooth::hci::Controller::impl261 void write_secure_connections_host_support_complete_handler(CommandCompleteView view) {
262 auto complete_view = WriteSecureConnectionsHostSupportCompleteView::Create(view);
263 ASSERT(complete_view.IsValid());
264 ErrorCode status = complete_view.GetStatus();
265 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
266 }
267
read_local_name_complete_handlerbluetooth::hci::Controller::impl268 void read_local_name_complete_handler(CommandCompleteView view) {
269 auto complete_view = ReadLocalNameCompleteView::Create(view);
270 ASSERT(complete_view.IsValid());
271 ErrorCode status = complete_view.GetStatus();
272 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
273 std::array<uint8_t, 248> local_name_array = complete_view.GetLocalName();
274
275 local_name_ = std::string(local_name_array.begin(), local_name_array.end());
276 // erase \0
277 local_name_.erase(std::find(local_name_.begin(), local_name_.end(), '\0'), local_name_.end());
278 }
279
read_local_version_information_complete_handlerbluetooth::hci::Controller::impl280 void read_local_version_information_complete_handler(CommandCompleteView view) {
281 auto complete_view = ReadLocalVersionInformationCompleteView::Create(view);
282 ASSERT(complete_view.IsValid());
283 ErrorCode status = complete_view.GetStatus();
284 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
285
286 local_version_information_ = complete_view.GetLocalVersionInformation();
287 bluetooth::os::LogMetricBluetoothLocalVersions(
288 local_version_information_.manufacturer_name_,
289 static_cast<uint8_t>(local_version_information_.lmp_version_),
290 local_version_information_.lmp_subversion_,
291 static_cast<uint8_t>(local_version_information_.hci_version_),
292 local_version_information_.hci_revision_);
293 }
294
read_local_supported_commands_complete_handlerbluetooth::hci::Controller::impl295 void read_local_supported_commands_complete_handler(CommandCompleteView view) {
296 auto complete_view = ReadLocalSupportedCommandsCompleteView::Create(view);
297 ASSERT(complete_view.IsValid());
298 ErrorCode status = complete_view.GetStatus();
299 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
300 local_supported_commands_ = complete_view.GetSupportedCommands();
301 }
302
read_local_extended_features_complete_handlerbluetooth::hci::Controller::impl303 void read_local_extended_features_complete_handler(std::promise<void> promise, CommandCompleteView view) {
304 auto complete_view = ReadLocalExtendedFeaturesCompleteView::Create(view);
305 ASSERT(complete_view.IsValid());
306 ErrorCode status = complete_view.GetStatus();
307 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
308 uint8_t page_number = complete_view.GetPageNumber();
309 extended_lmp_features_array_.push_back(complete_view.GetExtendedLmpFeatures());
310 bluetooth::os::LogMetricBluetoothLocalSupportedFeatures(page_number, complete_view.GetExtendedLmpFeatures());
311 // Query all extended features
312 if (page_number < complete_view.GetMaximumPageNumber()) {
313 page_number++;
314 hci_->EnqueueCommand(
315 ReadLocalExtendedFeaturesBuilder::Create(page_number),
316 module_.GetHandler()->BindOnceOn(this, &Controller::impl::read_local_extended_features_complete_handler,
317 std::move(promise)));
318 } else {
319 promise.set_value();
320 }
321 }
322
read_buffer_size_complete_handlerbluetooth::hci::Controller::impl323 void read_buffer_size_complete_handler(CommandCompleteView view) {
324 auto complete_view = ReadBufferSizeCompleteView::Create(view);
325 ASSERT(complete_view.IsValid());
326 ErrorCode status = complete_view.GetStatus();
327 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
328 acl_buffer_length_ = complete_view.GetAclDataPacketLength();
329 acl_buffers_ = complete_view.GetTotalNumAclDataPackets();
330
331 sco_buffer_length_ = complete_view.GetSynchronousDataPacketLength();
332 sco_buffers_ = complete_view.GetTotalNumSynchronousDataPackets();
333 }
334
read_controller_mac_address_handlerbluetooth::hci::Controller::impl335 void read_controller_mac_address_handler(std::promise<void> promise, CommandCompleteView view) {
336 auto complete_view = ReadBdAddrCompleteView::Create(view);
337 ASSERT(complete_view.IsValid());
338 ErrorCode status = complete_view.GetStatus();
339 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
340 mac_address_ = complete_view.GetBdAddr();
341 promise.set_value();
342 }
343
le_read_buffer_size_handlerbluetooth::hci::Controller::impl344 void le_read_buffer_size_handler(CommandCompleteView view) {
345 auto complete_view = LeReadBufferSizeV1CompleteView::Create(view);
346 ASSERT(complete_view.IsValid());
347 ErrorCode status = complete_view.GetStatus();
348 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
349 le_buffer_size_ = complete_view.GetLeBufferSize();
350
351 // If LE buffer size is zero, then buffers returned by Read_Buffer_Size are shared between BR/EDR and LE.
352 if (le_buffer_size_.total_num_le_packets_ == 0) {
353 ASSERT(acl_buffers_ != 0);
354 le_buffer_size_.total_num_le_packets_ = acl_buffers_ / 2;
355 acl_buffers_ -= le_buffer_size_.total_num_le_packets_;
356 le_buffer_size_.le_data_packet_length_ = acl_buffer_length_;
357 }
358 }
359
set_min_encryption_key_size_handlerbluetooth::hci::Controller::impl360 void set_min_encryption_key_size_handler(CommandCompleteView view) {
361 auto complete_view = SetMinEncryptionKeySizeCompleteView::Create(view);
362 ASSERT(complete_view.IsValid());
363 ErrorCode status = complete_view.GetStatus();
364 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
365 }
366
le_read_buffer_size_v2_handlerbluetooth::hci::Controller::impl367 void le_read_buffer_size_v2_handler(CommandCompleteView view) {
368 auto complete_view = LeReadBufferSizeV2CompleteView::Create(view);
369 ASSERT(complete_view.IsValid());
370 ErrorCode status = complete_view.GetStatus();
371 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
372 le_buffer_size_ = complete_view.GetLeBufferSize();
373 iso_buffer_size_ = complete_view.GetIsoBufferSize();
374
375 // If LE buffer size is zero, then buffers returned by Read_Buffer_Size are shared between BR/EDR and LE.
376 if (le_buffer_size_.total_num_le_packets_ == 0) {
377 ASSERT(acl_buffers_ != 0);
378 le_buffer_size_.total_num_le_packets_ = acl_buffers_ / 2;
379 acl_buffers_ -= le_buffer_size_.total_num_le_packets_;
380 le_buffer_size_.le_data_packet_length_ = acl_buffer_length_;
381 }
382 }
383
le_set_host_feature_handlerbluetooth::hci::Controller::impl384 void le_set_host_feature_handler(CommandCompleteView view) {
385 auto complete_view = LeSetHostFeatureCompleteView::Create(view);
386 ASSERT(complete_view.IsValid());
387 ErrorCode status = complete_view.GetStatus();
388 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
389 }
390
read_default_erroneous_data_reporting_handlerbluetooth::hci::Controller::impl391 void read_default_erroneous_data_reporting_handler(CommandCompleteView view) {
392 ASSERT(view.GetCommandOpCode() == OpCode::READ_DEFAULT_ERRONEOUS_DATA_REPORTING);
393 auto complete_view = ReadDefaultErroneousDataReportingCompleteView::Create(view);
394 // Check to see that the opcode was correct.
395 // ASSERT(complete_view.IsValid()) is not used here to avoid process abort.
396 // Some devices, such as mokey_go32, may claim to support it but do not
397 // actually do so (b/277589118).
398 if (!complete_view.IsValid()) {
399 LOG_ERROR("invalid command complete view");
400 return;
401 }
402
403 ErrorCode status = complete_view.GetStatus();
404 // This is an optional feature to enhance audio quality. It is okay
405 // to just return if the status is not SUCCESS.
406 if (status != ErrorCode::SUCCESS) {
407 LOG_ERROR("Unexpected status: %s", ErrorCodeText(status).c_str());
408 return;
409 }
410
411 Enable erroneous_data_reporting = complete_view.GetErroneousDataReporting();
412 LOG_INFO("erroneous data reporting: %hhu", erroneous_data_reporting);
413
414 // Enable Erroneous Data Reporting if it is disabled and the write command is supported.
415 if (erroneous_data_reporting == Enable::DISABLED &&
416 is_supported(OpCode::WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING)) {
417 std::unique_ptr<WriteDefaultErroneousDataReportingBuilder> packet =
418 WriteDefaultErroneousDataReportingBuilder::Create(Enable::ENABLED);
419 hci_->EnqueueCommand(
420 std::move(packet),
421 module_.GetHandler()->BindOnceOn(
422 this, &Controller::impl::write_default_erroneous_data_reporting_handler));
423 }
424 }
425
write_default_erroneous_data_reporting_handlerbluetooth::hci::Controller::impl426 void write_default_erroneous_data_reporting_handler(CommandCompleteView view) {
427 ASSERT(view.GetCommandOpCode() == OpCode::WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING);
428 auto complete_view = WriteDefaultErroneousDataReportingCompleteView::Create(view);
429 // Check to see that the opcode was correct.
430 // ASSERT(complete_view.IsValid()) is not used here to avoid process abort.
431 // Some devices, such as mokey_go32, may claim to support it but do not
432 // actually do so (b/277589118).
433 if (!complete_view.IsValid()) {
434 LOG_ERROR("invalid command complete view");
435 return;
436 }
437
438 ErrorCode status = complete_view.GetStatus();
439 // This is an optional feature to enhance audio quality. It is okay
440 // to just return if the status is not SUCCESS.
441 if (status != ErrorCode::SUCCESS) {
442 LOG_ERROR("Unexpected status: %s", ErrorCodeText(status).c_str());
443 return;
444 }
445 }
446
le_read_local_supported_features_handlerbluetooth::hci::Controller::impl447 void le_read_local_supported_features_handler(CommandCompleteView view) {
448 auto complete_view = LeReadLocalSupportedFeaturesCompleteView::Create(view);
449 ASSERT(complete_view.IsValid());
450 ErrorCode status = complete_view.GetStatus();
451 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
452 le_local_supported_features_ = complete_view.GetLeFeatures();
453 }
454
le_read_supported_states_handlerbluetooth::hci::Controller::impl455 void le_read_supported_states_handler(CommandCompleteView view) {
456 auto complete_view = LeReadSupportedStatesCompleteView::Create(view);
457 ASSERT(complete_view.IsValid());
458 ErrorCode status = complete_view.GetStatus();
459 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
460 le_supported_states_ = complete_view.GetLeStates();
461 }
462
le_read_connect_list_size_handlerbluetooth::hci::Controller::impl463 void le_read_connect_list_size_handler(CommandCompleteView view) {
464 auto complete_view = LeReadFilterAcceptListSizeCompleteView::Create(view);
465 ASSERT(complete_view.IsValid());
466 ErrorCode status = complete_view.GetStatus();
467 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
468 le_connect_list_size_ = complete_view.GetFilterAcceptListSize();
469 }
470
le_read_resolving_list_size_handlerbluetooth::hci::Controller::impl471 void le_read_resolving_list_size_handler(CommandCompleteView view) {
472 auto complete_view = LeReadResolvingListSizeCompleteView::Create(view);
473 ASSERT(complete_view.IsValid());
474 ErrorCode status = complete_view.GetStatus();
475 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
476 le_resolving_list_size_ = complete_view.GetResolvingListSize();
477 }
478
le_read_maximum_data_length_handlerbluetooth::hci::Controller::impl479 void le_read_maximum_data_length_handler(CommandCompleteView view) {
480 auto complete_view = LeReadMaximumDataLengthCompleteView::Create(view);
481 ASSERT(complete_view.IsValid());
482 ErrorCode status = complete_view.GetStatus();
483 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
484 le_maximum_data_length_ = complete_view.GetLeMaximumDataLength();
485 }
486
le_read_suggested_default_data_length_handlerbluetooth::hci::Controller::impl487 void le_read_suggested_default_data_length_handler(CommandCompleteView view) {
488 auto complete_view = LeReadSuggestedDefaultDataLengthCompleteView::Create(view);
489 ASSERT(complete_view.IsValid());
490 ErrorCode status = complete_view.GetStatus();
491 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
492 le_suggested_default_data_length_ = complete_view.GetTxOctets();
493 }
494
le_read_maximum_advertising_data_length_handlerbluetooth::hci::Controller::impl495 void le_read_maximum_advertising_data_length_handler(CommandCompleteView view) {
496 auto complete_view = LeReadMaximumAdvertisingDataLengthCompleteView::Create(view);
497 ASSERT(complete_view.IsValid());
498 ErrorCode status = complete_view.GetStatus();
499 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
500 le_maximum_advertising_data_length_ = complete_view.GetMaximumAdvertisingDataLength();
501 }
502
le_read_number_of_supported_advertising_sets_handlerbluetooth::hci::Controller::impl503 void le_read_number_of_supported_advertising_sets_handler(CommandCompleteView view) {
504 auto complete_view = LeReadNumberOfSupportedAdvertisingSetsCompleteView::Create(view);
505 ASSERT(complete_view.IsValid());
506 ErrorCode status = complete_view.GetStatus();
507 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
508 le_number_supported_advertising_sets_ = complete_view.GetNumberSupportedAdvertisingSets();
509 }
510
le_read_periodic_advertiser_list_size_handlerbluetooth::hci::Controller::impl511 void le_read_periodic_advertiser_list_size_handler(CommandCompleteView view) {
512 auto complete_view = LeReadPeriodicAdvertiserListSizeCompleteView::Create(view);
513 ASSERT(complete_view.IsValid());
514 ErrorCode status = complete_view.GetStatus();
515 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
516 le_periodic_advertiser_list_size_ = complete_view.GetPeriodicAdvertiserListSize();
517 }
518
le_get_vendor_capabilities_handlerbluetooth::hci::Controller::impl519 void le_get_vendor_capabilities_handler(CommandCompleteView view) {
520 auto complete_view = LeGetVendorCapabilitiesCompleteView::Create(view);
521
522 vendor_capabilities_.is_supported_ = 0x00;
523 vendor_capabilities_.max_advt_instances_ = 0x00;
524 vendor_capabilities_.offloaded_resolution_of_private_address_ = 0x00;
525 vendor_capabilities_.total_scan_results_storage_ = 0x00;
526 vendor_capabilities_.max_irk_list_sz_ = 0x00;
527 vendor_capabilities_.filtering_support_ = 0x00;
528 vendor_capabilities_.max_filter_ = 0x00;
529 vendor_capabilities_.activity_energy_info_support_ = 0x00;
530 vendor_capabilities_.version_supported_ = 0x00;
531 vendor_capabilities_.version_supported_ = 0x00;
532 vendor_capabilities_.total_num_of_advt_tracked_ = 0x00;
533 vendor_capabilities_.extended_scan_support_ = 0x00;
534 vendor_capabilities_.debug_logging_supported_ = 0x00;
535 vendor_capabilities_.le_address_generation_offloading_support_ = 0x00;
536 vendor_capabilities_.a2dp_source_offload_capability_mask_ = 0x00;
537 vendor_capabilities_.bluetooth_quality_report_support_ = 0x00;
538
539 if (complete_view.IsValid()) {
540 vendor_capabilities_.is_supported_ = 0x01;
541
542 // v0.55
543 BaseVendorCapabilities base_vendor_capabilities = complete_view.GetBaseVendorCapabilities();
544 vendor_capabilities_.max_advt_instances_ = base_vendor_capabilities.max_advt_instances_;
545 vendor_capabilities_.offloaded_resolution_of_private_address_ =
546 base_vendor_capabilities.offloaded_resolution_of_private_address_;
547 vendor_capabilities_.total_scan_results_storage_ = base_vendor_capabilities.total_scan_results_storage_;
548 vendor_capabilities_.max_irk_list_sz_ = base_vendor_capabilities.max_irk_list_sz_;
549 vendor_capabilities_.filtering_support_ = base_vendor_capabilities.filtering_support_;
550 vendor_capabilities_.max_filter_ = base_vendor_capabilities.max_filter_;
551 vendor_capabilities_.activity_energy_info_support_ = base_vendor_capabilities.activity_energy_info_support_;
552 if (complete_view.GetPayload().size() == 0) {
553 vendor_capabilities_.version_supported_ = 55;
554 return;
555 }
556
557 // v0.95
558 auto v95 = LeGetVendorCapabilitiesComplete095View::Create(complete_view);
559 if (!v95.IsValid()) {
560 LOG_ERROR("invalid data for hci requirements v0.95");
561 return;
562 }
563 vendor_capabilities_.version_supported_ = v95.GetVersionSupported();
564 vendor_capabilities_.total_num_of_advt_tracked_ = v95.GetTotalNumOfAdvtTracked();
565 vendor_capabilities_.extended_scan_support_ = v95.GetExtendedScanSupport();
566 vendor_capabilities_.debug_logging_supported_ = v95.GetDebugLoggingSupported();
567 if (vendor_capabilities_.version_supported_ <= 95 || complete_view.GetPayload().size() == 0) {
568 return;
569 }
570
571 // v0.96
572 auto v96 = LeGetVendorCapabilitiesComplete096View::Create(v95);
573 if (!v96.IsValid()) {
574 LOG_ERROR("invalid data for hci requirements v0.96");
575 return;
576 }
577 vendor_capabilities_.le_address_generation_offloading_support_ = v96.GetLeAddressGenerationOffloadingSupport();
578 if (vendor_capabilities_.version_supported_ <= 96 || complete_view.GetPayload().size() == 0) {
579 return;
580 }
581
582 // v0.98
583 auto v98 = LeGetVendorCapabilitiesComplete098View::Create(v96);
584 if (!v98.IsValid()) {
585 LOG_ERROR("invalid data for hci requirements v0.98");
586 return;
587 }
588 vendor_capabilities_.a2dp_source_offload_capability_mask_ = v98.GetA2dpSourceOffloadCapabilityMask();
589 vendor_capabilities_.bluetooth_quality_report_support_ = v98.GetBluetoothQualityReportSupport();
590 }
591 }
592
set_event_maskbluetooth::hci::Controller::impl593 void set_event_mask(uint64_t event_mask) {
594 std::unique_ptr<SetEventMaskBuilder> packet = SetEventMaskBuilder::Create(event_mask);
595 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
596 this, &Controller::impl::check_status<SetEventMaskCompleteView>));
597 }
598
write_le_host_supportbluetooth::hci::Controller::impl599 void write_le_host_support(Enable enable, Enable deprecated_host_bit) {
600 if (deprecated_host_bit == Enable::ENABLED) {
601 // Since Bluetooth Core Spec 4.1, this bit should be 0
602 LOG_WARN("Setting deprecated Simultaneous LE BR/EDR Host bit");
603 }
604 std::unique_ptr<WriteLeHostSupportBuilder> packet = WriteLeHostSupportBuilder::Create(enable, deprecated_host_bit);
605 hci_->EnqueueCommand(
606 std::move(packet),
607 module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<WriteLeHostSupportCompleteView>));
608 }
609
write_simple_pairing_modebluetooth::hci::Controller::impl610 void write_simple_pairing_mode(Enable enable) {
611 std::unique_ptr<WriteSimplePairingModeBuilder> packet = WriteSimplePairingModeBuilder::Create(enable);
612 hci_->EnqueueCommand(
613 std::move(packet),
614 module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<WriteSimplePairingModeCompleteView>));
615 }
616
resetbluetooth::hci::Controller::impl617 void reset() {
618 std::unique_ptr<ResetBuilder> packet = ResetBuilder::Create();
619 hci_->EnqueueCommand(std::move(packet),
620 module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<ResetCompleteView>));
621 }
622
le_randbluetooth::hci::Controller::impl623 void le_rand(LeRandCallback cb) {
624 std::unique_ptr<LeRandBuilder> packet = LeRandBuilder::Create();
625 hci_->EnqueueCommand(
626 std::move(packet),
627 module_.GetHandler()->BindOnceOn(this, &Controller::impl::le_rand_cb<LeRandCompleteView>, cb));
628 }
629
630 template <class T>
le_rand_cbbluetooth::hci::Controller::impl631 void le_rand_cb(LeRandCallback cb, CommandCompleteView view) {
632 ASSERT(view.IsValid());
633 auto status_view = T::Create(view);
634 ASSERT(status_view.IsValid());
635 ASSERT(status_view.GetStatus() == ErrorCode::SUCCESS);
636 cb.Run(status_view.GetRandomNumber());
637 }
638
set_event_filterbluetooth::hci::Controller::impl639 void set_event_filter(std::unique_ptr<SetEventFilterBuilder> packet) {
640 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
641 this, &Controller::impl::check_status<SetEventFilterCompleteView>));
642 }
643
write_local_namebluetooth::hci::Controller::impl644 void write_local_name(std::string local_name) {
645 ASSERT(local_name.length() <= 248);
646 // Fill remaining char with 0
647 local_name.append(std::string(248 - local_name.length(), '\0'));
648 std::array<uint8_t, 248> local_name_array;
649 std::copy(std::begin(local_name), std::end(local_name), std::begin(local_name_array));
650
651 std::unique_ptr<WriteLocalNameBuilder> packet = WriteLocalNameBuilder::Create(local_name_array);
652 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
653 this, &Controller::impl::check_status<WriteLocalNameCompleteView>));
654 }
655
host_buffer_sizebluetooth::hci::Controller::impl656 void host_buffer_size(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
657 uint16_t host_total_num_acl_data_packets, uint16_t host_total_num_synchronous_data_packets) {
658 std::unique_ptr<HostBufferSizeBuilder> packet =
659 HostBufferSizeBuilder::Create(host_acl_data_packet_length, host_synchronous_data_packet_length,
660 host_total_num_acl_data_packets, host_total_num_synchronous_data_packets);
661 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
662 this, &Controller::impl::check_status<HostBufferSizeCompleteView>));
663 }
664
le_set_event_maskbluetooth::hci::Controller::impl665 void le_set_event_mask(uint64_t le_event_mask) {
666 std::unique_ptr<LeSetEventMaskBuilder> packet = LeSetEventMaskBuilder::Create(le_event_mask);
667 hci_->EnqueueCommand(
668 std::move(packet), module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_le_set_event_mask_status));
669 }
670
check_le_set_event_mask_statusbluetooth::hci::Controller::impl671 void check_le_set_event_mask_status(CommandCompleteView view) {
672 ASSERT(view.IsValid());
673 auto status_view = LeSetEventMaskCompleteView::Create(view);
674 ASSERT(status_view.IsValid());
675 auto status = status_view.GetStatus();
676 if (status != ErrorCode::SUCCESS) {
677 LOG_WARN("Unexpected return status %s", ErrorCodeText(status).c_str());
678 }
679 }
680
681 template <class T>
check_statusbluetooth::hci::Controller::impl682 void check_status(CommandCompleteView view) {
683 ASSERT(view.IsValid());
684 auto status_view = T::Create(view);
685 ASSERT(status_view.IsValid());
686 ASSERT(status_view.GetStatus() == ErrorCode::SUCCESS);
687 }
688
689 #define OP_CODE_MAPPING(name) \
690 case OpCode::name: { \
691 uint16_t index = (uint16_t)OpCodeIndex::name; \
692 uint16_t byte_index = index / 10; \
693 uint16_t bit_index = index % 10; \
694 bool supported = local_supported_commands_[byte_index] & (1 << bit_index); \
695 if (!supported) { \
696 LOG_DEBUG("unsupported command opcode: 0x%04x", (uint16_t)OpCode::name); \
697 } \
698 return supported; \
699 }
700
701 void Dump(
702 std::promise<flatbuffers::Offset<ControllerData>> promise, flatbuffers::FlatBufferBuilder* fb_builder) const;
703
is_supportedbluetooth::hci::Controller::impl704 bool is_supported(OpCode op_code) {
705 switch (op_code) {
706 OP_CODE_MAPPING(INQUIRY)
707 OP_CODE_MAPPING(INQUIRY_CANCEL)
708 OP_CODE_MAPPING(PERIODIC_INQUIRY_MODE)
709 OP_CODE_MAPPING(EXIT_PERIODIC_INQUIRY_MODE)
710 OP_CODE_MAPPING(CREATE_CONNECTION)
711 OP_CODE_MAPPING(DISCONNECT)
712 OP_CODE_MAPPING(CREATE_CONNECTION_CANCEL)
713 OP_CODE_MAPPING(ACCEPT_CONNECTION_REQUEST)
714 OP_CODE_MAPPING(REJECT_CONNECTION_REQUEST)
715 OP_CODE_MAPPING(LINK_KEY_REQUEST_REPLY)
716 OP_CODE_MAPPING(LINK_KEY_REQUEST_NEGATIVE_REPLY)
717 OP_CODE_MAPPING(PIN_CODE_REQUEST_REPLY)
718 OP_CODE_MAPPING(PIN_CODE_REQUEST_NEGATIVE_REPLY)
719 OP_CODE_MAPPING(CHANGE_CONNECTION_PACKET_TYPE)
720 OP_CODE_MAPPING(AUTHENTICATION_REQUESTED)
721 OP_CODE_MAPPING(SET_CONNECTION_ENCRYPTION)
722 OP_CODE_MAPPING(CHANGE_CONNECTION_LINK_KEY)
723 OP_CODE_MAPPING(CENTRAL_LINK_KEY)
724 OP_CODE_MAPPING(REMOTE_NAME_REQUEST)
725 OP_CODE_MAPPING(REMOTE_NAME_REQUEST_CANCEL)
726 OP_CODE_MAPPING(READ_REMOTE_SUPPORTED_FEATURES)
727 OP_CODE_MAPPING(READ_REMOTE_EXTENDED_FEATURES)
728 OP_CODE_MAPPING(READ_REMOTE_VERSION_INFORMATION)
729 OP_CODE_MAPPING(READ_CLOCK_OFFSET)
730 OP_CODE_MAPPING(READ_LMP_HANDLE)
731 OP_CODE_MAPPING(SETUP_SYNCHRONOUS_CONNECTION)
732 OP_CODE_MAPPING(ACCEPT_SYNCHRONOUS_CONNECTION)
733 OP_CODE_MAPPING(REJECT_SYNCHRONOUS_CONNECTION)
734 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_REPLY)
735 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_REPLY)
736 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_NEGATIVE_REPLY)
737 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_REPLY)
738 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_NEGATIVE_REPLY)
739 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_REPLY)
740 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY)
741 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_NEGATIVE_REPLY)
742 OP_CODE_MAPPING(ENHANCED_SETUP_SYNCHRONOUS_CONNECTION)
743 OP_CODE_MAPPING(ENHANCED_ACCEPT_SYNCHRONOUS_CONNECTION)
744 OP_CODE_MAPPING(TRUNCATED_PAGE)
745 OP_CODE_MAPPING(TRUNCATED_PAGE_CANCEL)
746 OP_CODE_MAPPING(SET_CONNECTIONLESS_PERIPHERAL_BROADCAST)
747 OP_CODE_MAPPING(SET_CONNECTIONLESS_PERIPHERAL_BROADCAST_RECEIVE)
748 OP_CODE_MAPPING(START_SYNCHRONIZATION_TRAIN)
749 OP_CODE_MAPPING(RECEIVE_SYNCHRONIZATION_TRAIN)
750 OP_CODE_MAPPING(REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY)
751 OP_CODE_MAPPING(HOLD_MODE)
752 OP_CODE_MAPPING(SNIFF_MODE)
753 OP_CODE_MAPPING(EXIT_SNIFF_MODE)
754 OP_CODE_MAPPING(QOS_SETUP)
755 OP_CODE_MAPPING(ROLE_DISCOVERY)
756 OP_CODE_MAPPING(SWITCH_ROLE)
757 OP_CODE_MAPPING(READ_LINK_POLICY_SETTINGS)
758 OP_CODE_MAPPING(WRITE_LINK_POLICY_SETTINGS)
759 OP_CODE_MAPPING(READ_DEFAULT_LINK_POLICY_SETTINGS)
760 OP_CODE_MAPPING(WRITE_DEFAULT_LINK_POLICY_SETTINGS)
761 OP_CODE_MAPPING(FLOW_SPECIFICATION)
762 OP_CODE_MAPPING(SNIFF_SUBRATING)
763 OP_CODE_MAPPING(SET_EVENT_MASK)
764 OP_CODE_MAPPING(RESET)
765 OP_CODE_MAPPING(SET_EVENT_FILTER)
766 OP_CODE_MAPPING(FLUSH)
767 OP_CODE_MAPPING(READ_PIN_TYPE)
768 OP_CODE_MAPPING(WRITE_PIN_TYPE)
769 OP_CODE_MAPPING(READ_STORED_LINK_KEY)
770 OP_CODE_MAPPING(WRITE_STORED_LINK_KEY)
771 OP_CODE_MAPPING(DELETE_STORED_LINK_KEY)
772 OP_CODE_MAPPING(WRITE_LOCAL_NAME)
773 OP_CODE_MAPPING(READ_LOCAL_NAME)
774 OP_CODE_MAPPING(READ_CONNECTION_ACCEPT_TIMEOUT)
775 OP_CODE_MAPPING(WRITE_CONNECTION_ACCEPT_TIMEOUT)
776 OP_CODE_MAPPING(READ_PAGE_TIMEOUT)
777 OP_CODE_MAPPING(WRITE_PAGE_TIMEOUT)
778 OP_CODE_MAPPING(READ_SCAN_ENABLE)
779 OP_CODE_MAPPING(WRITE_SCAN_ENABLE)
780 OP_CODE_MAPPING(READ_PAGE_SCAN_ACTIVITY)
781 OP_CODE_MAPPING(WRITE_PAGE_SCAN_ACTIVITY)
782 OP_CODE_MAPPING(READ_INQUIRY_SCAN_ACTIVITY)
783 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_ACTIVITY)
784 OP_CODE_MAPPING(READ_AUTHENTICATION_ENABLE)
785 OP_CODE_MAPPING(WRITE_AUTHENTICATION_ENABLE)
786 OP_CODE_MAPPING(READ_CLASS_OF_DEVICE)
787 OP_CODE_MAPPING(WRITE_CLASS_OF_DEVICE)
788 OP_CODE_MAPPING(READ_VOICE_SETTING)
789 OP_CODE_MAPPING(WRITE_VOICE_SETTING)
790 OP_CODE_MAPPING(READ_AUTOMATIC_FLUSH_TIMEOUT)
791 OP_CODE_MAPPING(WRITE_AUTOMATIC_FLUSH_TIMEOUT)
792 OP_CODE_MAPPING(READ_NUM_BROADCAST_RETRANSMITS)
793 OP_CODE_MAPPING(WRITE_NUM_BROADCAST_RETRANSMITS)
794 OP_CODE_MAPPING(READ_HOLD_MODE_ACTIVITY)
795 OP_CODE_MAPPING(WRITE_HOLD_MODE_ACTIVITY)
796 OP_CODE_MAPPING(READ_TRANSMIT_POWER_LEVEL)
797 OP_CODE_MAPPING(READ_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
798 OP_CODE_MAPPING(WRITE_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
799 OP_CODE_MAPPING(SET_CONTROLLER_TO_HOST_FLOW_CONTROL)
800 OP_CODE_MAPPING(HOST_BUFFER_SIZE)
801 OP_CODE_MAPPING(HOST_NUMBER_OF_COMPLETED_PACKETS)
802 OP_CODE_MAPPING(READ_LINK_SUPERVISION_TIMEOUT)
803 OP_CODE_MAPPING(WRITE_LINK_SUPERVISION_TIMEOUT)
804 OP_CODE_MAPPING(READ_NUMBER_OF_SUPPORTED_IAC)
805 OP_CODE_MAPPING(READ_CURRENT_IAC_LAP)
806 OP_CODE_MAPPING(WRITE_CURRENT_IAC_LAP)
807 OP_CODE_MAPPING(SET_AFH_HOST_CHANNEL_CLASSIFICATION)
808 OP_CODE_MAPPING(READ_INQUIRY_SCAN_TYPE)
809 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_TYPE)
810 OP_CODE_MAPPING(READ_INQUIRY_MODE)
811 OP_CODE_MAPPING(WRITE_INQUIRY_MODE)
812 OP_CODE_MAPPING(READ_PAGE_SCAN_TYPE)
813 OP_CODE_MAPPING(WRITE_PAGE_SCAN_TYPE)
814 OP_CODE_MAPPING(READ_AFH_CHANNEL_ASSESSMENT_MODE)
815 OP_CODE_MAPPING(WRITE_AFH_CHANNEL_ASSESSMENT_MODE)
816 OP_CODE_MAPPING(READ_EXTENDED_INQUIRY_RESPONSE)
817 OP_CODE_MAPPING(WRITE_EXTENDED_INQUIRY_RESPONSE)
818 OP_CODE_MAPPING(REFRESH_ENCRYPTION_KEY)
819 OP_CODE_MAPPING(READ_SIMPLE_PAIRING_MODE)
820 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_MODE)
821 OP_CODE_MAPPING(READ_LOCAL_OOB_DATA)
822 OP_CODE_MAPPING(READ_INQUIRY_RESPONSE_TRANSMIT_POWER_LEVEL)
823 OP_CODE_MAPPING(WRITE_INQUIRY_TRANSMIT_POWER_LEVEL)
824 OP_CODE_MAPPING(READ_DEFAULT_ERRONEOUS_DATA_REPORTING)
825 OP_CODE_MAPPING(WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING)
826 OP_CODE_MAPPING(ENHANCED_FLUSH)
827 OP_CODE_MAPPING(SEND_KEYPRESS_NOTIFICATION)
828 OP_CODE_MAPPING(SET_EVENT_MASK_PAGE_2)
829 OP_CODE_MAPPING(READ_FLOW_CONTROL_MODE)
830 OP_CODE_MAPPING(WRITE_FLOW_CONTROL_MODE)
831 OP_CODE_MAPPING(READ_ENHANCED_TRANSMIT_POWER_LEVEL)
832 OP_CODE_MAPPING(READ_LE_HOST_SUPPORT)
833 OP_CODE_MAPPING(WRITE_LE_HOST_SUPPORT)
834 OP_CODE_MAPPING(SET_MWS_CHANNEL_PARAMETERS)
835 OP_CODE_MAPPING(SET_EXTERNAL_FRAME_CONFIGURATION)
836 OP_CODE_MAPPING(SET_MWS_SIGNALING)
837 OP_CODE_MAPPING(SET_MWS_TRANSPORT_LAYER)
838 OP_CODE_MAPPING(SET_MWS_SCAN_FREQUENCY_TABLE)
839 OP_CODE_MAPPING(SET_MWS_PATTERN_CONFIGURATION)
840 OP_CODE_MAPPING(SET_RESERVED_LT_ADDR)
841 OP_CODE_MAPPING(DELETE_RESERVED_LT_ADDR)
842 OP_CODE_MAPPING(SET_CONNECTIONLESS_PERIPHERAL_BROADCAST_DATA)
843 OP_CODE_MAPPING(READ_SYNCHRONIZATION_TRAIN_PARAMETERS)
844 OP_CODE_MAPPING(WRITE_SYNCHRONIZATION_TRAIN_PARAMETERS)
845 OP_CODE_MAPPING(READ_SECURE_CONNECTIONS_HOST_SUPPORT)
846 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_HOST_SUPPORT)
847 OP_CODE_MAPPING(READ_AUTHENTICATED_PAYLOAD_TIMEOUT)
848 OP_CODE_MAPPING(WRITE_AUTHENTICATED_PAYLOAD_TIMEOUT)
849 OP_CODE_MAPPING(READ_LOCAL_OOB_EXTENDED_DATA)
850 OP_CODE_MAPPING(READ_EXTENDED_PAGE_TIMEOUT)
851 OP_CODE_MAPPING(WRITE_EXTENDED_PAGE_TIMEOUT)
852 OP_CODE_MAPPING(READ_EXTENDED_INQUIRY_LENGTH)
853 OP_CODE_MAPPING(WRITE_EXTENDED_INQUIRY_LENGTH)
854 OP_CODE_MAPPING(SET_ECOSYSTEM_BASE_INTERVAL)
855 OP_CODE_MAPPING(CONFIGURE_DATA_PATH)
856 OP_CODE_MAPPING(SET_MIN_ENCRYPTION_KEY_SIZE)
857 OP_CODE_MAPPING(READ_LOCAL_VERSION_INFORMATION)
858 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_FEATURES)
859 OP_CODE_MAPPING(READ_LOCAL_EXTENDED_FEATURES)
860 OP_CODE_MAPPING(READ_BUFFER_SIZE)
861 OP_CODE_MAPPING(READ_BD_ADDR)
862 OP_CODE_MAPPING(READ_DATA_BLOCK_SIZE)
863 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS_V1)
864 OP_CODE_MAPPING(READ_LOCAL_SIMPLE_PAIRING_OPTIONS)
865 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS_V2)
866 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODEC_CAPABILITIES)
867 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CONTROLLER_DELAY)
868 OP_CODE_MAPPING(READ_FAILED_CONTACT_COUNTER)
869 OP_CODE_MAPPING(RESET_FAILED_CONTACT_COUNTER)
870 OP_CODE_MAPPING(READ_LINK_QUALITY)
871 OP_CODE_MAPPING(READ_RSSI)
872 OP_CODE_MAPPING(READ_AFH_CHANNEL_MAP)
873 OP_CODE_MAPPING(READ_CLOCK)
874 OP_CODE_MAPPING(READ_ENCRYPTION_KEY_SIZE)
875 OP_CODE_MAPPING(GET_MWS_TRANSPORT_LAYER_CONFIGURATION)
876 OP_CODE_MAPPING(SET_TRIGGERED_CLOCK_CAPTURE)
877 OP_CODE_MAPPING(READ_LOOPBACK_MODE)
878 OP_CODE_MAPPING(WRITE_LOOPBACK_MODE)
879 OP_CODE_MAPPING(ENABLE_DEVICE_UNDER_TEST_MODE)
880 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_DEBUG_MODE)
881 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_TEST_MODE)
882 OP_CODE_MAPPING(LE_SET_EVENT_MASK)
883 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE_V1)
884 OP_CODE_MAPPING(LE_READ_LOCAL_SUPPORTED_FEATURES)
885 OP_CODE_MAPPING(LE_SET_RANDOM_ADDRESS)
886 OP_CODE_MAPPING(LE_SET_ADVERTISING_PARAMETERS)
887 OP_CODE_MAPPING(LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER)
888 OP_CODE_MAPPING(LE_SET_ADVERTISING_DATA)
889 OP_CODE_MAPPING(LE_SET_SCAN_RESPONSE_DATA)
890 OP_CODE_MAPPING(LE_SET_ADVERTISING_ENABLE)
891 OP_CODE_MAPPING(LE_SET_SCAN_PARAMETERS)
892 OP_CODE_MAPPING(LE_SET_SCAN_ENABLE)
893 OP_CODE_MAPPING(LE_CREATE_CONNECTION)
894 OP_CODE_MAPPING(LE_CREATE_CONNECTION_CANCEL)
895 OP_CODE_MAPPING(LE_READ_FILTER_ACCEPT_LIST_SIZE)
896 OP_CODE_MAPPING(LE_CLEAR_FILTER_ACCEPT_LIST)
897 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST)
898 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST)
899 OP_CODE_MAPPING(LE_CONNECTION_UPDATE)
900 OP_CODE_MAPPING(LE_SET_HOST_CHANNEL_CLASSIFICATION)
901 OP_CODE_MAPPING(LE_READ_CHANNEL_MAP)
902 OP_CODE_MAPPING(LE_READ_REMOTE_FEATURES)
903 OP_CODE_MAPPING(LE_ENCRYPT)
904 OP_CODE_MAPPING(LE_RAND)
905 OP_CODE_MAPPING(LE_START_ENCRYPTION)
906 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_REPLY)
907 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_NEGATIVE_REPLY)
908 OP_CODE_MAPPING(LE_READ_SUPPORTED_STATES)
909 OP_CODE_MAPPING(LE_RECEIVER_TEST_V1)
910 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V1)
911 OP_CODE_MAPPING(LE_TEST_END)
912 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_REPLY)
913 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_NEGATIVE_REPLY)
914 OP_CODE_MAPPING(LE_SET_DATA_LENGTH)
915 OP_CODE_MAPPING(LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH)
916 OP_CODE_MAPPING(LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH)
917 OP_CODE_MAPPING(LE_READ_LOCAL_P_256_PUBLIC_KEY)
918 OP_CODE_MAPPING(LE_GENERATE_DHKEY_V1)
919 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_RESOLVING_LIST)
920 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_RESOLVING_LIST)
921 OP_CODE_MAPPING(LE_CLEAR_RESOLVING_LIST)
922 OP_CODE_MAPPING(LE_READ_RESOLVING_LIST_SIZE)
923 OP_CODE_MAPPING(LE_READ_PEER_RESOLVABLE_ADDRESS)
924 OP_CODE_MAPPING(LE_READ_LOCAL_RESOLVABLE_ADDRESS)
925 OP_CODE_MAPPING(LE_SET_ADDRESS_RESOLUTION_ENABLE)
926 OP_CODE_MAPPING(LE_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT)
927 OP_CODE_MAPPING(LE_READ_MAXIMUM_DATA_LENGTH)
928 OP_CODE_MAPPING(LE_READ_PHY)
929 OP_CODE_MAPPING(LE_SET_DEFAULT_PHY)
930 OP_CODE_MAPPING(LE_SET_PHY)
931 OP_CODE_MAPPING(LE_RECEIVER_TEST_V2)
932 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V2)
933 OP_CODE_MAPPING(LE_SET_ADVERTISING_SET_RANDOM_ADDRESS)
934 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_PARAMETERS)
935 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_DATA)
936 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_RESPONSE_DATA)
937 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_ENABLE)
938 OP_CODE_MAPPING(LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH)
939 OP_CODE_MAPPING(LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS)
940 OP_CODE_MAPPING(LE_REMOVE_ADVERTISING_SET)
941 OP_CODE_MAPPING(LE_CLEAR_ADVERTISING_SETS)
942 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_PARAMETERS)
943 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_DATA)
944 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_ENABLE)
945 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_PARAMETERS)
946 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_ENABLE)
947 OP_CODE_MAPPING(LE_EXTENDED_CREATE_CONNECTION)
948 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC)
949 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC_CANCEL)
950 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_TERMINATE_SYNC)
951 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_PERIODIC_ADVERTISER_LIST)
952 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_PERIODIC_ADVERTISER_LIST)
953 OP_CODE_MAPPING(LE_CLEAR_PERIODIC_ADVERTISER_LIST)
954 OP_CODE_MAPPING(LE_READ_PERIODIC_ADVERTISER_LIST_SIZE)
955 OP_CODE_MAPPING(LE_READ_TRANSMIT_POWER)
956 OP_CODE_MAPPING(LE_READ_RF_PATH_COMPENSATION_POWER)
957 OP_CODE_MAPPING(LE_WRITE_RF_PATH_COMPENSATION_POWER)
958 OP_CODE_MAPPING(LE_SET_PRIVACY_MODE)
959 OP_CODE_MAPPING(LE_RECEIVER_TEST_V3)
960 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V3)
961 OP_CODE_MAPPING(LE_SET_CONNECTIONLESS_CTE_TRANSMIT_PARAMETERS)
962 OP_CODE_MAPPING(LE_SET_CONNECTIONLESS_CTE_TRANSMIT_ENABLE)
963 OP_CODE_MAPPING(LE_SET_CONNECTIONLESS_IQ_SAMPLING_ENABLE)
964 OP_CODE_MAPPING(LE_SET_CONNECTION_CTE_RECEIVE_PARAMETERS)
965 OP_CODE_MAPPING(LE_SET_CONNECTION_CTE_TRANSMIT_PARAMETERS)
966 OP_CODE_MAPPING(LE_CONNECTION_CTE_REQUEST_ENABLE)
967 OP_CODE_MAPPING(LE_CONNECTION_CTE_RESPONSE_ENABLE)
968 OP_CODE_MAPPING(LE_READ_ANTENNA_INFORMATION)
969 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_RECEIVE_ENABLE)
970 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_SYNC_TRANSFER)
971 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_SET_INFO_TRANSFER)
972 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS)
973 OP_CODE_MAPPING(LE_SET_DEFAULT_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS)
974 OP_CODE_MAPPING(LE_GENERATE_DHKEY_V2)
975 OP_CODE_MAPPING(LE_MODIFY_SLEEP_CLOCK_ACCURACY)
976 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE_V2)
977 OP_CODE_MAPPING(LE_READ_ISO_TX_SYNC)
978 OP_CODE_MAPPING(LE_SET_CIG_PARAMETERS)
979 OP_CODE_MAPPING(LE_SET_CIG_PARAMETERS_TEST)
980 OP_CODE_MAPPING(LE_CREATE_CIS)
981 OP_CODE_MAPPING(LE_REMOVE_CIG)
982 OP_CODE_MAPPING(LE_ACCEPT_CIS_REQUEST)
983 OP_CODE_MAPPING(LE_REJECT_CIS_REQUEST)
984 OP_CODE_MAPPING(LE_CREATE_BIG)
985 OP_CODE_MAPPING(LE_CREATE_BIG_TEST)
986 OP_CODE_MAPPING(LE_TERMINATE_BIG)
987 OP_CODE_MAPPING(LE_BIG_CREATE_SYNC)
988 OP_CODE_MAPPING(LE_BIG_TERMINATE_SYNC)
989 OP_CODE_MAPPING(LE_REQUEST_PEER_SCA)
990 OP_CODE_MAPPING(LE_SETUP_ISO_DATA_PATH)
991 OP_CODE_MAPPING(LE_REMOVE_ISO_DATA_PATH)
992 OP_CODE_MAPPING(LE_ISO_TRANSMIT_TEST)
993 OP_CODE_MAPPING(LE_ISO_RECEIVE_TEST)
994 OP_CODE_MAPPING(LE_ISO_READ_TEST_COUNTERS)
995 OP_CODE_MAPPING(LE_ISO_TEST_END)
996 OP_CODE_MAPPING(LE_SET_HOST_FEATURE)
997 OP_CODE_MAPPING(LE_READ_ISO_LINK_QUALITY)
998 OP_CODE_MAPPING(LE_ENHANCED_READ_TRANSMIT_POWER_LEVEL)
999 OP_CODE_MAPPING(LE_READ_REMOTE_TRANSMIT_POWER_LEVEL)
1000 OP_CODE_MAPPING(LE_SET_PATH_LOSS_REPORTING_PARAMETERS)
1001 OP_CODE_MAPPING(LE_SET_PATH_LOSS_REPORTING_ENABLE)
1002 OP_CODE_MAPPING(LE_SET_TRANSMIT_POWER_REPORTING_ENABLE)
1003 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V4)
1004 OP_CODE_MAPPING(LE_SET_DATA_RELATED_ADDRESS_CHANGES)
1005 OP_CODE_MAPPING(LE_SET_DEFAULT_SUBRATE)
1006 OP_CODE_MAPPING(LE_SUBRATE_REQUEST)
1007
1008 // deprecated
1009 case OpCode::ADD_SCO_CONNECTION:
1010 return false;
1011
1012 // vendor specific
1013 case OpCode::LE_GET_VENDOR_CAPABILITIES:
1014 return vendor_capabilities_.is_supported_ == 0x01;
1015 case OpCode::LE_MULTI_ADVT:
1016 return vendor_capabilities_.max_advt_instances_ != 0x00;
1017 case OpCode::LE_BATCH_SCAN:
1018 return vendor_capabilities_.total_scan_results_storage_ != 0x00;
1019 case OpCode::LE_ADV_FILTER:
1020 return vendor_capabilities_.filtering_support_ == 0x01;
1021 case OpCode::LE_ENERGY_INFO:
1022 return vendor_capabilities_.activity_energy_info_support_ == 0x01;
1023 case OpCode::LE_EXTENDED_SCAN_PARAMS:
1024 return vendor_capabilities_.extended_scan_support_ == 0x01;
1025 case OpCode::CONTROLLER_DEBUG_INFO:
1026 return vendor_capabilities_.debug_logging_supported_ == 0x01;
1027 case OpCode::CONTROLLER_A2DP_OPCODE:
1028 return vendor_capabilities_.a2dp_source_offload_capability_mask_ != 0x00;
1029 case OpCode::CONTROLLER_BQR:
1030 return vendor_capabilities_.bluetooth_quality_report_support_ == 0x01;
1031 // Before MSFT extension is fully supported, return false for the following MSFT_OPCODE_XXXX for now.
1032 case OpCode::MSFT_OPCODE_INTEL:
1033 return false;
1034 case OpCode::MSFT_OPCODE_MEDIATEK:
1035 return false;
1036 case OpCode::MSFT_OPCODE_QUALCOMM:
1037 return false;
1038 // undefined in local_supported_commands_
1039 case OpCode::READ_LOCAL_SUPPORTED_COMMANDS:
1040 return true;
1041 case OpCode::NONE:
1042 return false;
1043 }
1044 return false;
1045 }
1046 #undef OP_CODE_MAPPING
1047
1048 Controller& module_;
1049
1050 HciLayer* hci_;
1051
1052 CompletedAclPacketsCallback acl_credits_callback_{};
1053 CompletedAclPacketsCallback acl_monitor_credits_callback_{};
1054 LocalVersionInformation local_version_information_{};
1055 std::array<uint8_t, 64> local_supported_commands_{};
1056 std::vector<uint64_t> extended_lmp_features_array_{};
1057 uint16_t acl_buffer_length_{};
1058 uint16_t acl_buffers_{};
1059 uint8_t sco_buffer_length_{};
1060 uint16_t sco_buffers_{};
1061 Address mac_address_{};
1062 std::string local_name_{};
1063 LeBufferSize le_buffer_size_{};
1064 LeBufferSize iso_buffer_size_{};
1065 uint64_t le_local_supported_features_{};
1066 uint64_t le_supported_states_{};
1067 uint8_t le_connect_list_size_{};
1068 uint8_t le_resolving_list_size_{};
1069 LeMaximumDataLength le_maximum_data_length_{};
1070 uint16_t le_maximum_advertising_data_length_{};
1071 uint16_t le_suggested_default_data_length_{};
1072 uint8_t le_number_supported_advertising_sets_{};
1073 uint8_t le_periodic_advertiser_list_size_{};
1074 VendorCapabilities vendor_capabilities_{};
1075 }; // namespace hci
1076
Controller()1077 Controller::Controller() : impl_(std::make_unique<impl>(*this)) {}
1078
1079 Controller::~Controller() = default;
1080
RegisterCompletedAclPacketsCallback(CompletedAclPacketsCallback cb)1081 void Controller::RegisterCompletedAclPacketsCallback(CompletedAclPacketsCallback cb) {
1082 CallOn(impl_.get(), &impl::register_completed_acl_packets_callback, cb);
1083 }
1084
UnregisterCompletedAclPacketsCallback()1085 void Controller::UnregisterCompletedAclPacketsCallback() {
1086 CallOn(impl_.get(), &impl::unregister_completed_acl_packets_callback);
1087 }
1088
RegisterCompletedMonitorAclPacketsCallback(CompletedAclPacketsCallback cb)1089 void Controller::RegisterCompletedMonitorAclPacketsCallback(CompletedAclPacketsCallback cb) {
1090 CallOn(impl_.get(), &impl::register_completed_monitor_acl_packets_callback, cb);
1091 }
1092
UnregisterCompletedMonitorAclPacketsCallback()1093 void Controller::UnregisterCompletedMonitorAclPacketsCallback() {
1094 CallOn(impl_.get(), &impl::unregister_completed_monitor_acl_packets_callback);
1095 }
1096
GetLocalName() const1097 std::string Controller::GetLocalName() const {
1098 return impl_->local_name_;
1099 }
1100
GetLocalVersionInformation() const1101 LocalVersionInformation Controller::GetLocalVersionInformation() const {
1102 return impl_->local_version_information_;
1103 }
1104
1105 #define BIT(x) (0x1ULL << (x))
1106
1107 #define LOCAL_FEATURE_ACCESSOR(name, page, bit) \
1108 bool Controller::name() const { \
1109 return GetLocalFeatures(page) & BIT(bit); \
1110 }
1111
1112 LOCAL_FEATURE_ACCESSOR(Supports3SlotPackets, 0, 0)
1113 LOCAL_FEATURE_ACCESSOR(Supports5SlotPackets, 0, 1)
1114 LOCAL_FEATURE_ACCESSOR(SupportsRoleSwitch, 0, 5)
1115 LOCAL_FEATURE_ACCESSOR(SupportsHoldMode, 0, 6)
1116 LOCAL_FEATURE_ACCESSOR(SupportsSniffMode, 0, 7)
1117 LOCAL_FEATURE_ACCESSOR(SupportsParkMode, 0, 8)
1118 LOCAL_FEATURE_ACCESSOR(SupportsSco, 0, 11)
1119 LOCAL_FEATURE_ACCESSOR(SupportsHv2Packets, 0, 12)
1120 LOCAL_FEATURE_ACCESSOR(SupportsHv3Packets, 0, 13)
1121 LOCAL_FEATURE_ACCESSOR(SupportsClassic2mPhy, 0, 25)
1122 LOCAL_FEATURE_ACCESSOR(SupportsClassic3mPhy, 0, 26)
1123 LOCAL_FEATURE_ACCESSOR(SupportsInterlacedInquiryScan, 0, 28)
1124 LOCAL_FEATURE_ACCESSOR(SupportsRssiWithInquiryResults, 0, 30)
1125 LOCAL_FEATURE_ACCESSOR(SupportsEv3Packets, 0, 31)
1126 LOCAL_FEATURE_ACCESSOR(SupportsEv4Packets, 0, 32)
1127 LOCAL_FEATURE_ACCESSOR(SupportsEv5Packets, 0, 33)
1128 LOCAL_FEATURE_ACCESSOR(SupportsBle, 0, 38)
1129 LOCAL_FEATURE_ACCESSOR(Supports3SlotEdrPackets, 0, 39)
1130 LOCAL_FEATURE_ACCESSOR(Supports5SlotEdrPackets, 0, 40)
1131 LOCAL_FEATURE_ACCESSOR(SupportsSniffSubrating, 0, 41)
1132 LOCAL_FEATURE_ACCESSOR(SupportsEncryptionPause, 0, 42)
1133 LOCAL_FEATURE_ACCESSOR(SupportsEsco2mPhy, 0, 45)
1134 LOCAL_FEATURE_ACCESSOR(SupportsEsco3mPhy, 0, 46)
1135 LOCAL_FEATURE_ACCESSOR(Supports3SlotEscoEdrPackets, 0, 47)
1136 LOCAL_FEATURE_ACCESSOR(SupportsExtendedInquiryResponse, 0, 48)
1137 LOCAL_FEATURE_ACCESSOR(SupportsSimultaneousLeBrEdr, 0, 49)
1138 LOCAL_FEATURE_ACCESSOR(SupportsSimplePairing, 0, 51)
1139 LOCAL_FEATURE_ACCESSOR(SupportsNonFlushablePb, 0, 54)
1140
1141 LOCAL_FEATURE_ACCESSOR(SupportsSecureConnections, 2, 8)
1142
1143 #define LOCAL_LE_FEATURE_ACCESSOR(name, bit) \
1144 bool Controller::name() const { \
1145 return GetLocalLeFeatures() & BIT(bit); \
1146 }
1147
1148 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleEncryption, 0)
1149 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionParametersRequest, 1)
1150 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedReject, 2)
1151 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeripheralInitiatedFeaturesExchange, 3)
1152 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePing, 4)
1153 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleDataPacketLengthExtension, 5)
1154 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePrivacy, 6)
1155 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedScannerFilterPolicies, 7)
1156 LOCAL_LE_FEATURE_ACCESSOR(SupportsBle2mPhy, 8)
1157 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleStableModulationIndexTx, 9)
1158 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleStableModulationIndexRx, 10)
1159 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleCodedPhy, 11)
1160 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedAdvertising, 12)
1161 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertising, 13)
1162 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleChannelSelectionAlgorithm2, 14)
1163 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerClass1, 15)
1164 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleMinimumUsedChannels, 16)
1165 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionCteRequest, 17)
1166 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionCteResponse, 18)
1167 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionlessCteTransmitter, 19)
1168 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionlessCteReceiver, 20)
1169 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleAntennaSwitchingDuringCteTx, 21)
1170 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleAntennaSwitchingDuringCteRx, 22)
1171 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleReceivingConstantToneExtensions, 23)
1172 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingSyncTransferSender, 24)
1173 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingSyncTransferRecipient, 25)
1174 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleSleepClockAccuracyUpdates, 26)
1175 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleRemotePublicKeyValidation, 27)
1176 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectedIsochronousStreamCentral, 28)
1177 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectedIsochronousStreamPeripheral, 29)
1178 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleIsochronousBroadcaster, 30)
1179 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleSynchronizedReceiver, 31)
1180 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleIsochronousChannelsHostSupport, 32)
1181 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerControlRequest, 33)
1182 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerChangeIndication, 34)
1183 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePathLossMonitoring, 35)
1184 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingAdi, 36)
1185 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionSubrating, 37)
1186 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionSubratingHost, 38)
1187
GetLocalFeatures(uint8_t page_number) const1188 uint64_t Controller::GetLocalFeatures(uint8_t page_number) const {
1189 if (page_number < impl_->extended_lmp_features_array_.size()) {
1190 return impl_->extended_lmp_features_array_[page_number];
1191 }
1192 return 0x00;
1193 }
1194
GetAclPacketLength() const1195 uint16_t Controller::GetAclPacketLength() const {
1196 return impl_->acl_buffer_length_;
1197 }
1198
GetNumAclPacketBuffers() const1199 uint16_t Controller::GetNumAclPacketBuffers() const {
1200 return impl_->acl_buffers_;
1201 }
1202
GetScoPacketLength() const1203 uint8_t Controller::GetScoPacketLength() const {
1204 return impl_->sco_buffer_length_;
1205 }
1206
GetNumScoPacketBuffers() const1207 uint16_t Controller::GetNumScoPacketBuffers() const {
1208 return impl_->sco_buffers_;
1209 }
1210
GetMacAddress() const1211 Address Controller::GetMacAddress() const {
1212 return impl_->mac_address_;
1213 }
1214
SetEventMask(uint64_t event_mask)1215 void Controller::SetEventMask(uint64_t event_mask) {
1216 CallOn(impl_.get(), &impl::set_event_mask, event_mask);
1217 }
1218
Reset()1219 void Controller::Reset() {
1220 CallOn(impl_.get(), &impl::reset);
1221 }
1222
LeRand(LeRandCallback cb)1223 void Controller::LeRand(LeRandCallback cb) {
1224 CallOn(impl_.get(), &impl::le_rand, cb);
1225 }
1226
SetEventFilterClearAll()1227 void Controller::SetEventFilterClearAll() {
1228 std::unique_ptr<SetEventFilterClearAllBuilder> packet = SetEventFilterClearAllBuilder::Create();
1229 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1230 }
1231
SetEventFilterInquiryResultAllDevices()1232 void Controller::SetEventFilterInquiryResultAllDevices() {
1233 std::unique_ptr<SetEventFilterInquiryResultAllDevicesBuilder> packet =
1234 SetEventFilterInquiryResultAllDevicesBuilder::Create();
1235 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1236 }
1237
SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask)1238 void Controller::SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,
1239 ClassOfDevice class_of_device_mask) {
1240 std::unique_ptr<SetEventFilterInquiryResultClassOfDeviceBuilder> packet =
1241 SetEventFilterInquiryResultClassOfDeviceBuilder::Create(class_of_device, class_of_device_mask);
1242 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1243 }
1244
SetEventFilterInquiryResultAddress(Address address)1245 void Controller::SetEventFilterInquiryResultAddress(Address address) {
1246 std::unique_ptr<SetEventFilterInquiryResultAddressBuilder> packet =
1247 SetEventFilterInquiryResultAddressBuilder::Create(address);
1248 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1249 }
1250
SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag)1251 void Controller::SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag) {
1252 std::unique_ptr<SetEventFilterConnectionSetupAllDevicesBuilder> packet =
1253 SetEventFilterConnectionSetupAllDevicesBuilder::Create(auto_accept_flag);
1254 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1255 }
1256
SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask,AutoAcceptFlag auto_accept_flag)1257 void Controller::SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,
1258 ClassOfDevice class_of_device_mask,
1259 AutoAcceptFlag auto_accept_flag) {
1260 std::unique_ptr<SetEventFilterConnectionSetupClassOfDeviceBuilder> packet =
1261 SetEventFilterConnectionSetupClassOfDeviceBuilder::Create(class_of_device, class_of_device_mask,
1262 auto_accept_flag);
1263 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1264 }
1265
SetEventFilterConnectionSetupAddress(Address address,AutoAcceptFlag auto_accept_flag)1266 void Controller::SetEventFilterConnectionSetupAddress(Address address, AutoAcceptFlag auto_accept_flag) {
1267 std::unique_ptr<SetEventFilterConnectionSetupAddressBuilder> packet =
1268 SetEventFilterConnectionSetupAddressBuilder::Create(address, auto_accept_flag);
1269 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1270 }
1271
WriteLocalName(std::string local_name)1272 void Controller::WriteLocalName(std::string local_name) {
1273 impl_->local_name_ = local_name;
1274 CallOn(impl_.get(), &impl::write_local_name, local_name);
1275 }
1276
HostBufferSize(uint16_t host_acl_data_packet_length,uint8_t host_synchronous_data_packet_length,uint16_t host_total_num_acl_data_packets,uint16_t host_total_num_synchronous_data_packets)1277 void Controller::HostBufferSize(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
1278 uint16_t host_total_num_acl_data_packets,
1279 uint16_t host_total_num_synchronous_data_packets) {
1280 CallOn(
1281 impl_.get(),
1282 &impl::host_buffer_size,
1283 host_acl_data_packet_length,
1284 host_synchronous_data_packet_length,
1285 host_total_num_acl_data_packets,
1286 host_total_num_synchronous_data_packets);
1287 }
1288
LeSetEventMask(uint64_t le_event_mask)1289 void Controller::LeSetEventMask(uint64_t le_event_mask) {
1290 CallOn(impl_.get(), &impl::le_set_event_mask, le_event_mask);
1291 }
1292
GetLeBufferSize() const1293 LeBufferSize Controller::GetLeBufferSize() const {
1294 return impl_->le_buffer_size_;
1295 }
1296
GetLocalLeFeatures() const1297 uint64_t Controller::GetLocalLeFeatures() const {
1298 return impl_->le_local_supported_features_;
1299 }
1300
GetControllerIsoBufferSize() const1301 LeBufferSize Controller::GetControllerIsoBufferSize() const {
1302 return impl_->iso_buffer_size_;
1303 }
1304
GetControllerLeLocalSupportedFeatures() const1305 uint64_t Controller::GetControllerLeLocalSupportedFeatures() const {
1306 return impl_->le_local_supported_features_;
1307 }
1308
GetLeSupportedStates() const1309 uint64_t Controller::GetLeSupportedStates() const {
1310 return impl_->le_supported_states_;
1311 }
1312
GetLeFilterAcceptListSize() const1313 uint8_t Controller::GetLeFilterAcceptListSize() const {
1314 return impl_->le_connect_list_size_;
1315 }
1316
GetLeResolvingListSize() const1317 uint8_t Controller::GetLeResolvingListSize() const {
1318 return impl_->le_resolving_list_size_;
1319 }
1320
GetLeMaximumDataLength() const1321 LeMaximumDataLength Controller::GetLeMaximumDataLength() const {
1322 return impl_->le_maximum_data_length_;
1323 }
1324
GetLeMaximumAdvertisingDataLength() const1325 uint16_t Controller::GetLeMaximumAdvertisingDataLength() const {
1326 return impl_->le_maximum_advertising_data_length_;
1327 }
1328
GetLeSuggestedDefaultDataLength() const1329 uint16_t Controller::GetLeSuggestedDefaultDataLength() const {
1330 return impl_->le_suggested_default_data_length_;
1331 }
1332
GetLeNumberOfSupportedAdverisingSets() const1333 uint8_t Controller::GetLeNumberOfSupportedAdverisingSets() const {
1334 return impl_->le_number_supported_advertising_sets_;
1335 }
1336
GetVendorCapabilities() const1337 Controller::VendorCapabilities Controller::GetVendorCapabilities() const {
1338 return impl_->vendor_capabilities_;
1339 }
1340
GetLePeriodicAdvertiserListSize() const1341 uint8_t Controller::GetLePeriodicAdvertiserListSize() const {
1342 return impl_->le_periodic_advertiser_list_size_;
1343 }
1344
IsSupported(bluetooth::hci::OpCode op_code) const1345 bool Controller::IsSupported(bluetooth::hci::OpCode op_code) const {
1346 return impl_->is_supported(op_code);
1347 }
1348
__anon160ddea80102() 1349 const ModuleFactory Controller::Factory = ModuleFactory([]() { return new Controller(); });
1350
ListDependencies(ModuleList * list) const1351 void Controller::ListDependencies(ModuleList* list) const {
1352 list->add<hci::HciLayer>();
1353 list->add<sysprops::SyspropsModule>();
1354 }
1355
Start()1356 void Controller::Start() {
1357 impl_->Start(GetDependency<hci::HciLayer>());
1358 }
1359
Stop()1360 void Controller::Stop() {
1361 impl_->Stop();
1362 }
1363
ToString() const1364 std::string Controller::ToString() const {
1365 return "Controller";
1366 }
1367
Dump(std::promise<flatbuffers::Offset<ControllerData>> promise,flatbuffers::FlatBufferBuilder * fb_builder) const1368 void Controller::impl::Dump(
1369 std::promise<flatbuffers::Offset<ControllerData>> promise, flatbuffers::FlatBufferBuilder* fb_builder) const {
1370 ASSERT(fb_builder != nullptr);
1371 auto title = fb_builder->CreateString("----- Hci Controller Dumpsys -----");
1372
1373 auto local_version_information_data = CreateLocalVersionInformationData(
1374 *fb_builder,
1375 fb_builder->CreateString(HciVersionText(local_version_information_.hci_version_)),
1376 local_version_information_.hci_revision_,
1377 fb_builder->CreateString(LmpVersionText(local_version_information_.lmp_version_)),
1378 local_version_information_.manufacturer_name_,
1379 local_version_information_.lmp_subversion_);
1380
1381 auto acl_buffer_size_data = BufferSizeData(acl_buffer_length_, acl_buffers_);
1382
1383 auto sco_buffer_size_data = BufferSizeData(sco_buffer_length_, sco_buffers_);
1384
1385 auto le_buffer_size_data =
1386 BufferSizeData(le_buffer_size_.le_data_packet_length_, le_buffer_size_.total_num_le_packets_);
1387
1388 auto iso_buffer_size_data =
1389 BufferSizeData(iso_buffer_size_.le_data_packet_length_, iso_buffer_size_.total_num_le_packets_);
1390
1391 auto le_maximum_data_length_data = LeMaximumDataLengthData(
1392 le_maximum_data_length_.supported_max_tx_octets_,
1393 le_maximum_data_length_.supported_max_tx_time_,
1394 le_maximum_data_length_.supported_max_rx_octets_,
1395 le_maximum_data_length_.supported_max_rx_time_);
1396
1397 std::vector<LocalSupportedCommandsData> local_supported_commands_vector;
1398 for (uint8_t index = 0; index < local_supported_commands_.size(); index++) {
1399 local_supported_commands_vector.push_back(LocalSupportedCommandsData(index, local_supported_commands_[index]));
1400 }
1401 auto local_supported_commands_data = fb_builder->CreateVectorOfStructs(local_supported_commands_vector);
1402
1403 auto vendor_capabilities_data = VendorCapabilitiesData(
1404 vendor_capabilities_.is_supported_,
1405 vendor_capabilities_.max_advt_instances_,
1406 vendor_capabilities_.offloaded_resolution_of_private_address_,
1407 vendor_capabilities_.total_scan_results_storage_,
1408 vendor_capabilities_.max_irk_list_sz_,
1409 vendor_capabilities_.filtering_support_,
1410 vendor_capabilities_.max_filter_,
1411 vendor_capabilities_.activity_energy_info_support_,
1412 vendor_capabilities_.version_supported_,
1413 vendor_capabilities_.total_num_of_advt_tracked_,
1414 vendor_capabilities_.extended_scan_support_,
1415 vendor_capabilities_.debug_logging_supported_,
1416 vendor_capabilities_.le_address_generation_offloading_support_,
1417 vendor_capabilities_.a2dp_source_offload_capability_mask_,
1418 vendor_capabilities_.bluetooth_quality_report_support_);
1419
1420 auto extended_lmp_features_vector = fb_builder->CreateVector(extended_lmp_features_array_);
1421
1422 // Create the root table
1423 ControllerDataBuilder builder(*fb_builder);
1424
1425 builder.add_title(title);
1426 builder.add_local_version_information(local_version_information_data);
1427
1428 builder.add_acl_buffer_size(&acl_buffer_size_data);
1429 builder.add_sco_buffer_size(&sco_buffer_size_data);
1430 builder.add_iso_buffer_size(&iso_buffer_size_data);
1431 builder.add_le_buffer_size(&le_buffer_size_data);
1432
1433 builder.add_le_connect_list_size(le_connect_list_size_);
1434 builder.add_le_resolving_list_size(le_resolving_list_size_);
1435
1436 builder.add_le_maximum_data_length(&le_maximum_data_length_data);
1437 builder.add_le_maximum_advertising_data_length(le_maximum_advertising_data_length_);
1438 builder.add_le_suggested_default_data_length(le_suggested_default_data_length_);
1439 builder.add_le_number_supported_advertising_sets(le_number_supported_advertising_sets_);
1440 builder.add_le_periodic_advertiser_list_size(le_periodic_advertiser_list_size_);
1441
1442 builder.add_local_supported_commands(local_supported_commands_data);
1443 builder.add_extended_lmp_features_array(extended_lmp_features_vector);
1444 builder.add_le_local_supported_features(le_local_supported_features_);
1445 builder.add_le_supported_states(le_supported_states_);
1446 builder.add_vendor_capabilities(&vendor_capabilities_data);
1447
1448 flatbuffers::Offset<ControllerData> dumpsys_data = builder.Finish();
1449 promise.set_value(dumpsys_data);
1450 }
1451
GetDumpsysData(flatbuffers::FlatBufferBuilder * fb_builder) const1452 DumpsysDataFinisher Controller::GetDumpsysData(flatbuffers::FlatBufferBuilder* fb_builder) const {
1453 ASSERT(fb_builder != nullptr);
1454
1455 std::promise<flatbuffers::Offset<ControllerData>> promise;
1456 auto future = promise.get_future();
1457 impl_->Dump(std::move(promise), fb_builder);
1458
1459 auto dumpsys_data = future.get();
1460
1461 return [dumpsys_data](DumpsysDataBuilder* dumpsys_builder) {
1462 dumpsys_builder->add_hci_controller_dumpsys_data(dumpsys_data);
1463 };
1464 }
1465
1466 } // namespace hci
1467 } // namespace bluetooth
1468