1 /*
2 * Copyright (C) 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 <android_bluetooth_sysprop.h>
20 #include <bluetooth/log.h>
21 #include <com_android_bluetooth_flags.h>
22
23 #include <future>
24 #include <memory>
25 #include <string>
26 #include <utility>
27
28 #include "hci/controller_interface.h"
29 #include "hci/event_checkers.h"
30 #include "hci/hci_layer.h"
31 #include "os/metrics.h"
32 #include "os/system_properties.h"
33 #include "stack/include/hcidefs.h"
34 #if TARGET_FLOSS
35 #include "sysprops/sysprops_module.h"
36 #endif
37
38 namespace bluetooth {
39 namespace hci {
40
41 constexpr int kMinEncryptionKeySize = 7;
42 constexpr int kMinEncryptionKeySizeDefault = kMinEncryptionKeySize;
43 constexpr int kMaxEncryptionKeySize = 16;
44
45 constexpr bool kDefaultVendorCapabilitiesEnabled = true;
46 constexpr bool kDefaultRpaOffload = false;
47
48 static const std::string kPropertyVendorCapabilitiesEnabled =
49 "bluetooth.core.le.vendor_capabilities.enabled";
50 static const std::string kPropertyRpaOffload = "bluetooth.core.le.rpa_offload";
51
52 using os::Handler;
53
54 struct Controller::impl {
implbluetooth::hci::Controller::impl55 impl(Controller& module) : module_(module) {}
56
Startbluetooth::hci::Controller::impl57 void Start(hci::HciLayer* hci) {
58 hci_ = hci;
59 Handler* handler = module_.GetHandler();
60 hci_->RegisterEventHandler(EventCode::NUMBER_OF_COMPLETED_PACKETS,
61 handler->BindOn(this, &Controller::impl::NumberOfCompletedPackets));
62
63 set_event_mask(kDefaultEventMask);
64 set_event_mask_page_2(kDefaultEventMaskPage2);
65
66 write_le_host_support(Enable::ENABLED, Enable::DISABLED);
67 hci_->EnqueueCommand(
68 ReadLocalNameBuilder::Create(),
69 handler->BindOnceOn(this, &Controller::impl::read_local_name_complete_handler));
70 hci_->EnqueueCommand(
71 ReadLocalVersionInformationBuilder::Create(),
72 handler->BindOnceOn(
73 this, &Controller::impl::read_local_version_information_complete_handler));
74 hci_->EnqueueCommand(
75 ReadLocalSupportedCommandsBuilder::Create(),
76 handler->BindOnceOn(this,
77 &Controller::impl::read_local_supported_commands_complete_handler));
78
79 hci_->EnqueueCommand(
80 LeReadLocalSupportedFeaturesBuilder::Create(),
81 handler->BindOnceOn(this, &Controller::impl::le_read_local_supported_features_handler));
82
83 hci_->EnqueueCommand(
84 LeReadSupportedStatesBuilder::Create(),
85 handler->BindOnceOn(this, &Controller::impl::le_read_supported_states_handler));
86
87 // Wait for all extended features read
88 std::promise<void> features_promise;
89 auto features_future = features_promise.get_future();
90
91 hci_->EnqueueCommand(
92 ReadLocalExtendedFeaturesBuilder::Create(0x00),
93 handler->BindOnceOn(this,
94 &Controller::impl::read_local_extended_features_complete_handler,
95 std::move(features_promise)));
96 features_future.wait();
97
98 if (com::android::bluetooth::flags::channel_sounding_in_stack() &&
99 module_.SupportsBleChannelSounding()) {
100 le_set_event_mask(MaskLeEventMask(local_version_information_.hci_version_,
101 kDefaultLeEventMask | kLeCSEventMask));
102 } else {
103 le_set_event_mask(
104 MaskLeEventMask(local_version_information_.hci_version_, kDefaultLeEventMask));
105 }
106
107 hci_->EnqueueCommand(
108 ReadBufferSizeBuilder::Create(),
109 handler->BindOnceOn(this, &Controller::impl::read_buffer_size_complete_handler));
110
111 if (is_supported(OpCode::SET_MIN_ENCRYPTION_KEY_SIZE)) {
112 uint8_t min_key_size =
113 (uint8_t)std::min(std::max(android::sysprop::bluetooth::Gap::min_key_size().value_or(
114 kMinEncryptionKeySizeDefault),
115 kMinEncryptionKeySize),
116 kMaxEncryptionKeySize);
117 hci_->EnqueueCommand(
118 SetMinEncryptionKeySizeBuilder::Create(min_key_size),
119 handler->BindOnceOn(this, &Controller::impl::set_min_encryption_key_size_handler));
120 }
121
122 if (is_supported(OpCode::LE_READ_BUFFER_SIZE_V2)) {
123 hci_->EnqueueCommand(
124 LeReadBufferSizeV2Builder::Create(),
125 handler->BindOnceOn(this, &Controller::impl::le_read_buffer_size_v2_handler));
126 } else {
127 hci_->EnqueueCommand(
128 LeReadBufferSizeV1Builder::Create(),
129 handler->BindOnceOn(this, &Controller::impl::le_read_buffer_size_handler));
130 }
131
132 if (is_supported(OpCode::READ_LOCAL_SUPPORTED_CODECS_V1)) {
133 hci_->EnqueueCommand(
134 ReadLocalSupportedCodecsV1Builder::Create(),
135 handler->BindOnceOn(this, &Controller::impl::read_local_supported_codecs_v1_handler));
136 }
137
138 hci_->EnqueueCommand(
139 LeReadFilterAcceptListSizeBuilder::Create(),
140 handler->BindOnceOn(this, &Controller::impl::le_read_accept_list_size_handler));
141
142 if (is_supported(OpCode::LE_READ_RESOLVING_LIST_SIZE) && module_.SupportsBlePrivacy()) {
143 hci_->EnqueueCommand(
144 LeReadResolvingListSizeBuilder::Create(),
145 handler->BindOnceOn(this, &Controller::impl::le_read_resolving_list_size_handler));
146 } else {
147 log::info("LE_READ_RESOLVING_LIST_SIZE not supported, defaulting to 0");
148 le_resolving_list_size_ = 0;
149 }
150
151 if (is_supported(OpCode::LE_READ_MAXIMUM_DATA_LENGTH) &&
152 module_.SupportsBleDataPacketLengthExtension()) {
153 hci_->EnqueueCommand(
154 LeReadMaximumDataLengthBuilder::Create(),
155 handler->BindOnceOn(this, &Controller::impl::le_read_maximum_data_length_handler));
156 } else {
157 log::info("LE_READ_MAXIMUM_DATA_LENGTH not supported, defaulting to 0");
158 le_maximum_data_length_.supported_max_rx_octets_ = 0;
159 le_maximum_data_length_.supported_max_rx_time_ = 0;
160 le_maximum_data_length_.supported_max_tx_octets_ = 0;
161 le_maximum_data_length_.supported_max_tx_time_ = 0;
162 }
163
164 // SSP is managed by security layer once enabled
165 write_simple_pairing_mode(Enable::ENABLED);
166 if (module_.SupportsSecureConnections()) {
167 hci_->EnqueueCommand(
168 WriteSecureConnectionsHostSupportBuilder::Create(Enable::ENABLED),
169 handler->BindOnceOn(
170 this,
171 &Controller::impl::write_secure_connections_host_support_complete_handler));
172 }
173 if (is_supported(OpCode::LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH) &&
174 module_.SupportsBleDataPacketLengthExtension()) {
175 hci_->EnqueueCommand(
176 LeReadSuggestedDefaultDataLengthBuilder::Create(),
177 handler->BindOnceOn(
178 this, &Controller::impl::le_read_suggested_default_data_length_handler));
179 } else {
180 log::info("LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH not supported, defaulting to 27 (0x1B)");
181 le_suggested_default_data_length_ = 27;
182 }
183
184 if (is_supported(OpCode::LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH) &&
185 module_.SupportsBleExtendedAdvertising()) {
186 hci_->EnqueueCommand(
187 LeReadMaximumAdvertisingDataLengthBuilder::Create(),
188 handler->BindOnceOn(
189 this, &Controller::impl::le_read_maximum_advertising_data_length_handler));
190 } else {
191 log::info("LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH not supported, defaulting to 31 (0x1F)");
192 le_maximum_advertising_data_length_ = 31;
193 }
194
195 if (is_supported(OpCode::LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS) &&
196 module_.SupportsBleExtendedAdvertising()) {
197 hci_->EnqueueCommand(
198 LeReadNumberOfSupportedAdvertisingSetsBuilder::Create(),
199 handler->BindOnceOn(
200 this,
201 &Controller::impl::le_read_number_of_supported_advertising_sets_handler));
202 } else {
203 log::info("LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS not supported, defaulting to 1");
204 le_number_supported_advertising_sets_ = 1;
205 }
206
207 if (is_supported(OpCode::LE_READ_PERIODIC_ADVERTISER_LIST_SIZE) &&
208 module_.SupportsBlePeriodicAdvertising()) {
209 hci_->EnqueueCommand(
210 LeReadPeriodicAdvertiserListSizeBuilder::Create(),
211 handler->BindOnceOn(
212 this, &Controller::impl::le_read_periodic_advertiser_list_size_handler));
213 } else {
214 log::info("LE_READ_PERIODIC_ADVERTISER_LIST_SIZE not supported, defaulting to 0");
215 le_periodic_advertiser_list_size_ = 0;
216 }
217 if (is_supported(OpCode::LE_SET_HOST_FEATURE) &&
218 module_.SupportsBleConnectedIsochronousStreamCentral()) {
219 hci_->EnqueueCommand(
220 LeSetHostFeatureBuilder::Create(LeHostFeatureBits::CONNECTED_ISO_STREAM_HOST_SUPPORT,
221 Enable::ENABLED),
222 handler->BindOnceOn(this, &Controller::impl::le_set_host_feature_handler));
223 }
224
225 if (is_supported(OpCode::LE_SET_HOST_FEATURE) && module_.SupportsBleConnectionSubrating()) {
226 hci_->EnqueueCommand(
227 LeSetHostFeatureBuilder::Create(LeHostFeatureBits::CONNECTION_SUBRATING_HOST_SUPPORT,
228 Enable::ENABLED),
229 handler->BindOnceOn(this, &Controller::impl::le_set_host_feature_handler));
230 }
231
232 if (com::android::bluetooth::flags::channel_sounding_in_stack() &&
233 module_.SupportsBleChannelSounding()) {
234 hci_->EnqueueCommand(
235 LeSetHostFeatureBuilder::Create(LeHostFeatureBits::CHANNEL_SOUNDING_HOST_SUPPORT,
236 Enable::ENABLED),
237 handler->BindOnceOn(this, &Controller::impl::le_set_host_feature_handler));
238 }
239
240 if (is_supported(OpCode::READ_DEFAULT_ERRONEOUS_DATA_REPORTING)) {
241 hci_->EnqueueCommand(
242 ReadDefaultErroneousDataReportingBuilder::Create(),
243 handler->BindOnceOn(
244 this, &Controller::impl::read_default_erroneous_data_reporting_handler));
245 }
246
247 // Skip vendor capabilities check if configured.
248 if (os::GetSystemPropertyBool(kPropertyVendorCapabilitiesEnabled,
249 kDefaultVendorCapabilitiesEnabled)) {
250 // More commands can be enqueued from le_get_vendor_capabilities_handler
251 std::promise<void> vendor_promise;
252 auto vendor_future = vendor_promise.get_future();
253 hci_->EnqueueCommand(
254 LeGetVendorCapabilitiesBuilder::Create(),
255 handler->BindOnceOn(this, &Controller::impl::le_get_vendor_capabilities_handler,
256 std::move(vendor_promise)));
257 vendor_future.wait();
258 } else {
259 vendor_capabilities_.is_supported_ = 0x00;
260 }
261
262 // We only need to synchronize the last read. Make BD_ADDR to be the last one.
263 std::promise<void> promise;
264 auto future = promise.get_future();
265 hci_->EnqueueCommand(
266 ReadBdAddrBuilder::Create(),
267 handler->BindOnceOn(this, &Controller::impl::read_controller_mac_address_handler,
268 std::move(promise)));
269 future.wait();
270 }
271
Stopbluetooth::hci::Controller::impl272 void Stop() { hci_ = nullptr; }
273
NumberOfCompletedPacketsbluetooth::hci::Controller::impl274 void NumberOfCompletedPackets(EventView event) {
275 if (!acl_credits_callback_) {
276 log::warn("Received event when AclManager is not listening");
277 return;
278 }
279 auto complete_view = NumberOfCompletedPacketsView::Create(event);
280 ASSERT(complete_view.IsValid());
281 for (auto completed_packets : complete_view.GetCompletedPackets()) {
282 uint16_t handle = completed_packets.connection_handle_;
283 uint16_t credits = completed_packets.host_num_of_completed_packets_;
284 acl_credits_callback_(handle, credits);
285 if (acl_monitor_credits_callback_) {
286 acl_monitor_credits_callback_(handle, credits);
287 }
288 }
289 }
290
register_completed_acl_packets_callbackbluetooth::hci::Controller::impl291 void register_completed_acl_packets_callback(CompletedAclPacketsCallback callback) {
292 ASSERT(!acl_credits_callback_);
293 acl_credits_callback_ = callback;
294 }
295
unregister_completed_acl_packets_callbackbluetooth::hci::Controller::impl296 void unregister_completed_acl_packets_callback() {
297 ASSERT(acl_credits_callback_);
298 acl_credits_callback_ = {};
299 }
300
register_completed_monitor_acl_packets_callbackbluetooth::hci::Controller::impl301 void register_completed_monitor_acl_packets_callback(CompletedAclPacketsCallback callback) {
302 ASSERT(!acl_monitor_credits_callback_);
303 acl_monitor_credits_callback_ = callback;
304 }
305
unregister_completed_monitor_acl_packets_callbackbluetooth::hci::Controller::impl306 void unregister_completed_monitor_acl_packets_callback() {
307 ASSERT(acl_monitor_credits_callback_);
308 acl_monitor_credits_callback_ = {};
309 }
310
register_monitor_completed_acl_packets_callbackbluetooth::hci::Controller::impl311 void register_monitor_completed_acl_packets_callback(CompletedAclPacketsCallback callback) {
312 ASSERT(!acl_monitor_credits_callback_);
313 acl_monitor_credits_callback_ = callback;
314 }
315
unregister_monitor_completed_acl_packets_callbackbluetooth::hci::Controller::impl316 void unregister_monitor_completed_acl_packets_callback() {
317 ASSERT(acl_monitor_credits_callback_);
318 acl_monitor_credits_callback_ = {};
319 }
320
write_secure_connections_host_support_complete_handlerbluetooth::hci::Controller::impl321 void write_secure_connections_host_support_complete_handler(CommandCompleteView view) {
322 auto complete_view = WriteSecureConnectionsHostSupportCompleteView::Create(view);
323 ASSERT(complete_view.IsValid());
324 ErrorCode status = complete_view.GetStatus();
325 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
326 }
327
read_local_name_complete_handlerbluetooth::hci::Controller::impl328 void read_local_name_complete_handler(CommandCompleteView view) {
329 auto complete_view = ReadLocalNameCompleteView::Create(view);
330 ASSERT(complete_view.IsValid());
331 ErrorCode status = complete_view.GetStatus();
332 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
333 std::array<uint8_t, 248> local_name_array = complete_view.GetLocalName();
334
335 local_name_ = std::string(local_name_array.begin(), local_name_array.end());
336 // erase \0
337 local_name_.erase(std::find(local_name_.begin(), local_name_.end(), '\0'), local_name_.end());
338 }
339
read_local_version_information_complete_handlerbluetooth::hci::Controller::impl340 void read_local_version_information_complete_handler(CommandCompleteView view) {
341 auto complete_view = ReadLocalVersionInformationCompleteView::Create(view);
342 ASSERT(complete_view.IsValid());
343 ErrorCode status = complete_view.GetStatus();
344 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
345
346 local_version_information_ = complete_view.GetLocalVersionInformation();
347 bluetooth::os::LogMetricBluetoothLocalVersions(
348 local_version_information_.manufacturer_name_,
349 static_cast<uint8_t>(local_version_information_.lmp_version_),
350 local_version_information_.lmp_subversion_,
351 static_cast<uint8_t>(local_version_information_.hci_version_),
352 local_version_information_.hci_revision_);
353 }
354
read_local_supported_commands_complete_handlerbluetooth::hci::Controller::impl355 void read_local_supported_commands_complete_handler(CommandCompleteView view) {
356 auto complete_view = ReadLocalSupportedCommandsCompleteView::Create(view);
357 ASSERT(complete_view.IsValid());
358 ErrorCode status = complete_view.GetStatus();
359 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
360 local_supported_commands_ = complete_view.GetSupportedCommands();
361 }
362
read_local_extended_features_complete_handlerbluetooth::hci::Controller::impl363 void read_local_extended_features_complete_handler(std::promise<void> promise,
364 CommandCompleteView view) {
365 auto complete_view = ReadLocalExtendedFeaturesCompleteView::Create(view);
366 ASSERT(complete_view.IsValid());
367 ErrorCode status = complete_view.GetStatus();
368 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
369 uint8_t page_number = complete_view.GetPageNumber();
370 extended_lmp_features_array_.push_back(complete_view.GetExtendedLmpFeatures());
371 if (page_number == 0 && local_version_information_.manufacturer_name_ == LMP_COMPID_INTEL &&
372 local_version_information_.lmp_version_ == LmpVersion::V_4_2 &&
373 local_version_information_.lmp_subversion_ == LMP_SUBVERSION_INTEL_AC7265) {
374 // Override the packet boundary feature bit on Intel AC7265 because it don't support well.
375 extended_lmp_features_array_.back() &=
376 ~static_cast<uint64_t>(LMPFeaturesPage0Bits::NON_FLUSHABLE_PACKET_BOUNDARY_FLAG);
377 }
378 bluetooth::os::LogMetricBluetoothLocalSupportedFeatures(page_number,
379 complete_view.GetExtendedLmpFeatures());
380 // Query all extended features
381 if (page_number < complete_view.GetMaximumPageNumber()) {
382 page_number++;
383 hci_->EnqueueCommand(
384 ReadLocalExtendedFeaturesBuilder::Create(page_number),
385 module_.GetHandler()->BindOnceOn(
386 this, &Controller::impl::read_local_extended_features_complete_handler,
387 std::move(promise)));
388 } else {
389 promise.set_value();
390 }
391 }
392
read_buffer_size_complete_handlerbluetooth::hci::Controller::impl393 void read_buffer_size_complete_handler(CommandCompleteView view) {
394 auto complete_view = ReadBufferSizeCompleteView::Create(view);
395 ASSERT(complete_view.IsValid());
396 ErrorCode status = complete_view.GetStatus();
397 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
398 acl_buffer_length_ = complete_view.GetAclDataPacketLength();
399 acl_buffers_ = complete_view.GetTotalNumAclDataPackets();
400
401 sco_buffer_length_ = complete_view.GetSynchronousDataPacketLength();
402 sco_buffers_ = complete_view.GetTotalNumSynchronousDataPackets();
403 }
404
read_controller_mac_address_handlerbluetooth::hci::Controller::impl405 void read_controller_mac_address_handler(std::promise<void> promise, CommandCompleteView view) {
406 auto complete_view = ReadBdAddrCompleteView::Create(view);
407 ASSERT(complete_view.IsValid());
408 ErrorCode status = complete_view.GetStatus();
409 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
410 mac_address_ = complete_view.GetBdAddr();
411 promise.set_value();
412 }
413
le_read_buffer_size_handlerbluetooth::hci::Controller::impl414 void le_read_buffer_size_handler(CommandCompleteView view) {
415 auto complete_view = LeReadBufferSizeV1CompleteView::Create(view);
416 ASSERT(complete_view.IsValid());
417 ErrorCode status = complete_view.GetStatus();
418 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
419 le_buffer_size_ = complete_view.GetLeBufferSize();
420
421 // If LE buffer size is zero, then buffers returned by Read_Buffer_Size are shared between
422 // BR/EDR and LE.
423 if (le_buffer_size_.total_num_le_packets_ == 0) {
424 ASSERT(acl_buffers_ != 0);
425 le_buffer_size_.total_num_le_packets_ = acl_buffers_ / 2;
426 acl_buffers_ -= le_buffer_size_.total_num_le_packets_;
427 le_buffer_size_.le_data_packet_length_ = acl_buffer_length_;
428 }
429 }
430
read_local_supported_codecs_v1_handlerbluetooth::hci::Controller::impl431 void read_local_supported_codecs_v1_handler(CommandCompleteView view) {
432 auto complete_view = ReadLocalSupportedCodecsV1CompleteView::Create(view);
433 ASSERT(complete_view.IsValid());
434 ErrorCode status = complete_view.GetStatus();
435 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
436 local_supported_codec_ids_ = complete_view.GetSupportedCodecs();
437 local_supported_vendor_codec_ids_ = complete_view.GetVendorSpecificCodecs();
438 }
439
set_min_encryption_key_size_handlerbluetooth::hci::Controller::impl440 void set_min_encryption_key_size_handler(CommandCompleteView view) {
441 auto complete_view = SetMinEncryptionKeySizeCompleteView::Create(view);
442 ASSERT(complete_view.IsValid());
443 ErrorCode status = complete_view.GetStatus();
444 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
445 }
446
le_read_buffer_size_v2_handlerbluetooth::hci::Controller::impl447 void le_read_buffer_size_v2_handler(CommandCompleteView view) {
448 auto complete_view = LeReadBufferSizeV2CompleteView::Create(view);
449 ASSERT(complete_view.IsValid());
450 ErrorCode status = complete_view.GetStatus();
451 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
452 le_buffer_size_ = complete_view.GetLeBufferSize();
453 iso_buffer_size_ = complete_view.GetIsoBufferSize();
454
455 // If LE buffer size is zero, then buffers returned by Read_Buffer_Size are shared between
456 // BR/EDR and LE.
457 if (le_buffer_size_.total_num_le_packets_ == 0) {
458 ASSERT(acl_buffers_ != 0);
459 le_buffer_size_.total_num_le_packets_ = acl_buffers_ / 2;
460 acl_buffers_ -= le_buffer_size_.total_num_le_packets_;
461 le_buffer_size_.le_data_packet_length_ = acl_buffer_length_;
462 }
463 }
464
le_set_host_feature_handlerbluetooth::hci::Controller::impl465 void le_set_host_feature_handler(CommandCompleteView view) {
466 auto complete_view = LeSetHostFeatureCompleteView::Create(view);
467 ASSERT(complete_view.IsValid());
468 ErrorCode status = complete_view.GetStatus();
469 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
470 }
471
read_default_erroneous_data_reporting_handlerbluetooth::hci::Controller::impl472 void read_default_erroneous_data_reporting_handler(CommandCompleteView view) {
473 ASSERT(view.GetCommandOpCode() == OpCode::READ_DEFAULT_ERRONEOUS_DATA_REPORTING);
474 auto complete_view = ReadDefaultErroneousDataReportingCompleteView::Create(view);
475 // Check to see that the opcode was correct.
476 // log::assert_that is not used here to avoid process abort.
477 // Some devices, such as mokey_go32, may claim to support it but do not
478 // actually do so (b/277589118).
479 if (!complete_view.IsValid()) {
480 log::error("invalid command complete view");
481 return;
482 }
483
484 ErrorCode status = complete_view.GetStatus();
485 // This is an optional feature to enhance audio quality. It is okay
486 // to just return if the status is not SUCCESS.
487 if (status != ErrorCode::SUCCESS) {
488 log::error("Unexpected status: {}", ErrorCodeText(status));
489 return;
490 }
491
492 Enable erroneous_data_reporting = complete_view.GetErroneousDataReporting();
493 log::info("erroneous data reporting: {}", erroneous_data_reporting);
494
495 // Enable Erroneous Data Reporting if it is disabled and the write command is supported.
496 if (erroneous_data_reporting == Enable::DISABLED &&
497 is_supported(OpCode::WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING)) {
498 std::unique_ptr<WriteDefaultErroneousDataReportingBuilder> packet =
499 WriteDefaultErroneousDataReportingBuilder::Create(Enable::ENABLED);
500 hci_->EnqueueCommand(
501 std::move(packet),
502 module_.GetHandler()->BindOnceOn(
503 this, &Controller::impl::write_default_erroneous_data_reporting_handler));
504 }
505 }
506
write_default_erroneous_data_reporting_handlerbluetooth::hci::Controller::impl507 void write_default_erroneous_data_reporting_handler(CommandCompleteView view) {
508 ASSERT(view.GetCommandOpCode() == OpCode::WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING);
509 auto complete_view = WriteDefaultErroneousDataReportingCompleteView::Create(view);
510 // Check to see that the opcode was correct.
511 // log::assert_that is not used here to avoid process abort.
512 // Some devices, such as mokey_go32, may claim to support it but do not
513 // actually do so (b/277589118).
514 if (!complete_view.IsValid()) {
515 log::error("invalid command complete view");
516 return;
517 }
518
519 ErrorCode status = complete_view.GetStatus();
520 // This is an optional feature to enhance audio quality. It is okay
521 // to just return if the status is not SUCCESS.
522 if (status != ErrorCode::SUCCESS) {
523 log::error("Unexpected status: {}", ErrorCodeText(status));
524 return;
525 }
526 }
527
le_read_local_supported_features_handlerbluetooth::hci::Controller::impl528 void le_read_local_supported_features_handler(CommandCompleteView view) {
529 auto complete_view = LeReadLocalSupportedFeaturesCompleteView::Create(view);
530 ASSERT(complete_view.IsValid());
531 ErrorCode status = complete_view.GetStatus();
532 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", status, ErrorCodeText(status));
533 le_local_supported_features_ = complete_view.GetLeFeatures();
534 }
535
le_read_supported_states_handlerbluetooth::hci::Controller::impl536 void le_read_supported_states_handler(CommandCompleteView view) {
537 auto complete_view = LeReadSupportedStatesCompleteView::Create(view);
538 ASSERT(complete_view.IsValid());
539 ErrorCode status = complete_view.GetStatus();
540 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
541 le_supported_states_ = complete_view.GetLeStates();
542 }
543
le_read_accept_list_size_handlerbluetooth::hci::Controller::impl544 void le_read_accept_list_size_handler(CommandCompleteView view) {
545 auto complete_view = LeReadFilterAcceptListSizeCompleteView::Create(view);
546 ASSERT(complete_view.IsValid());
547 ErrorCode status = complete_view.GetStatus();
548 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
549 le_accept_list_size_ = complete_view.GetFilterAcceptListSize();
550 }
551
le_read_resolving_list_size_handlerbluetooth::hci::Controller::impl552 void le_read_resolving_list_size_handler(CommandCompleteView view) {
553 auto complete_view = LeReadResolvingListSizeCompleteView::Create(view);
554 ASSERT(complete_view.IsValid());
555 ErrorCode status = complete_view.GetStatus();
556 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
557 le_resolving_list_size_ = complete_view.GetResolvingListSize();
558 }
559
le_read_maximum_data_length_handlerbluetooth::hci::Controller::impl560 void le_read_maximum_data_length_handler(CommandCompleteView view) {
561 auto complete_view = LeReadMaximumDataLengthCompleteView::Create(view);
562 ASSERT(complete_view.IsValid());
563 ErrorCode status = complete_view.GetStatus();
564 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
565 le_maximum_data_length_ = complete_view.GetLeMaximumDataLength();
566 }
567
le_read_suggested_default_data_length_handlerbluetooth::hci::Controller::impl568 void le_read_suggested_default_data_length_handler(CommandCompleteView view) {
569 auto complete_view = LeReadSuggestedDefaultDataLengthCompleteView::Create(view);
570 ASSERT(complete_view.IsValid());
571 ErrorCode status = complete_view.GetStatus();
572 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
573 le_suggested_default_data_length_ = complete_view.GetTxOctets();
574 }
575
le_read_maximum_advertising_data_length_handlerbluetooth::hci::Controller::impl576 void le_read_maximum_advertising_data_length_handler(CommandCompleteView view) {
577 auto complete_view = LeReadMaximumAdvertisingDataLengthCompleteView::Create(view);
578 ASSERT(complete_view.IsValid());
579 ErrorCode status = complete_view.GetStatus();
580 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
581 le_maximum_advertising_data_length_ = complete_view.GetMaximumAdvertisingDataLength();
582 }
583
le_read_number_of_supported_advertising_sets_handlerbluetooth::hci::Controller::impl584 void le_read_number_of_supported_advertising_sets_handler(CommandCompleteView view) {
585 auto complete_view = LeReadNumberOfSupportedAdvertisingSetsCompleteView::Create(view);
586 ASSERT(complete_view.IsValid());
587 ErrorCode status = complete_view.GetStatus();
588 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
589 le_number_supported_advertising_sets_ = complete_view.GetNumberSupportedAdvertisingSets();
590 }
591
le_read_periodic_advertiser_list_size_handlerbluetooth::hci::Controller::impl592 void le_read_periodic_advertiser_list_size_handler(CommandCompleteView view) {
593 auto complete_view = LeReadPeriodicAdvertiserListSizeCompleteView::Create(view);
594 ASSERT(complete_view.IsValid());
595 ErrorCode status = complete_view.GetStatus();
596 log::assert_that(status == ErrorCode::SUCCESS, "Status {}", ErrorCodeText(status));
597 le_periodic_advertiser_list_size_ = complete_view.GetPeriodicAdvertiserListSize();
598 }
599
le_get_vendor_capabilities_handlerbluetooth::hci::Controller::impl600 void le_get_vendor_capabilities_handler(std::promise<void> vendor_promise,
601 CommandCompleteView view) {
602 auto complete_view = LeGetVendorCapabilitiesCompleteView::Create(view);
603
604 vendor_capabilities_.is_supported_ = 0x00;
605 vendor_capabilities_.max_advt_instances_ = 0x00;
606 vendor_capabilities_.offloaded_resolution_of_private_address_ = 0x00;
607 vendor_capabilities_.total_scan_results_storage_ = 0x00;
608 vendor_capabilities_.max_irk_list_sz_ = 0x00;
609 vendor_capabilities_.filtering_support_ = 0x00;
610 vendor_capabilities_.max_filter_ = 0x00;
611 vendor_capabilities_.activity_energy_info_support_ = 0x00;
612 vendor_capabilities_.version_supported_ = 0x00;
613 vendor_capabilities_.version_supported_ = 0x00;
614 vendor_capabilities_.total_num_of_advt_tracked_ = 0x00;
615 vendor_capabilities_.extended_scan_support_ = 0x00;
616 vendor_capabilities_.debug_logging_supported_ = 0x00;
617 vendor_capabilities_.le_address_generation_offloading_support_ = 0x00;
618 vendor_capabilities_.a2dp_source_offload_capability_mask_ = 0x00;
619 vendor_capabilities_.bluetooth_quality_report_support_ = 0x00;
620 vendor_capabilities_.a2dp_offload_v2_support_ = 0x00;
621
622 if (!complete_view.IsValid()) {
623 vendor_promise.set_value();
624 return;
625 }
626 vendor_capabilities_.is_supported_ = 0x01;
627
628 // v0.55
629 BaseVendorCapabilities base_vendor_capabilities = complete_view.GetBaseVendorCapabilities();
630 vendor_capabilities_.max_advt_instances_ = base_vendor_capabilities.max_advt_instances_;
631 vendor_capabilities_.offloaded_resolution_of_private_address_ =
632 base_vendor_capabilities.offloaded_resolution_of_private_address_;
633 vendor_capabilities_.total_scan_results_storage_ =
634 base_vendor_capabilities.total_scan_results_storage_;
635 vendor_capabilities_.max_irk_list_sz_ = base_vendor_capabilities.max_irk_list_sz_;
636 vendor_capabilities_.filtering_support_ = base_vendor_capabilities.filtering_support_;
637 vendor_capabilities_.max_filter_ = base_vendor_capabilities.max_filter_;
638 vendor_capabilities_.activity_energy_info_support_ =
639 base_vendor_capabilities.activity_energy_info_support_;
640
641 if (complete_view.GetPayload().size() == 0) {
642 vendor_capabilities_.version_supported_ = 55;
643 vendor_promise.set_value();
644 return;
645 }
646
647 // v0.95
648 auto v95 = LeGetVendorCapabilitiesComplete095View::Create(complete_view);
649 if (!v95.IsValid()) {
650 log::info("invalid data for hci requirements v0.95");
651 vendor_promise.set_value();
652 return;
653 }
654 vendor_capabilities_.version_supported_ = v95.GetVersionSupported();
655 vendor_capabilities_.total_num_of_advt_tracked_ = v95.GetTotalNumOfAdvtTracked();
656 vendor_capabilities_.extended_scan_support_ = v95.GetExtendedScanSupport();
657 vendor_capabilities_.debug_logging_supported_ = v95.GetDebugLoggingSupported();
658 if (vendor_capabilities_.version_supported_ <= 95 || complete_view.GetPayload().size() == 0) {
659 vendor_promise.set_value();
660 return;
661 }
662
663 // v0.96
664 auto v96 = LeGetVendorCapabilitiesComplete096View::Create(v95);
665 if (!v96.IsValid()) {
666 log::info("invalid data for hci requirements v0.96");
667 vendor_promise.set_value();
668 return;
669 }
670 vendor_capabilities_.le_address_generation_offloading_support_ =
671 v96.GetLeAddressGenerationOffloadingSupport();
672 if (vendor_capabilities_.version_supported_ <= 96 || complete_view.GetPayload().size() == 0) {
673 vendor_promise.set_value();
674 return;
675 }
676
677 // v0.98
678 auto v98 = LeGetVendorCapabilitiesComplete098View::Create(v96);
679 if (!v98.IsValid()) {
680 log::info("invalid data for hci requirements v0.98");
681 vendor_promise.set_value();
682 return;
683 }
684 vendor_capabilities_.a2dp_source_offload_capability_mask_ =
685 v98.GetA2dpSourceOffloadCapabilityMask();
686 vendor_capabilities_.bluetooth_quality_report_support_ = v98.GetBluetoothQualityReportSupport();
687
688 // v1.03
689 auto v103 = LeGetVendorCapabilitiesComplete103View::Create(v98);
690 if (!v103.IsValid()) {
691 log::info("invalid data for hci requirements v1.03");
692 vendor_promise.set_value();
693 return;
694 }
695 vendor_capabilities_.dynamic_audio_buffer_support_ = v103.GetDynamicAudioBufferSupport();
696
697 // v1.04
698 auto v104 = LeGetVendorCapabilitiesComplete104View::Create(v103);
699 if (!v104.IsValid()) {
700 log::info("invalid data for hci requirements v1.04");
701 } else {
702 vendor_capabilities_.a2dp_offload_v2_support_ = v104.GetA2dpOffloadV2Support();
703 }
704
705 if (vendor_capabilities_.dynamic_audio_buffer_support_) {
706 hci_->EnqueueCommand(
707 DabGetAudioBufferTimeCapabilityBuilder::Create(),
708 module_.GetHandler()->BindOnceOn(
709 this, &Controller::impl::le_get_dynamic_audio_buffer_support_handler,
710 std::move(vendor_promise)));
711 return;
712 }
713
714 vendor_promise.set_value();
715 }
716
le_get_dynamic_audio_buffer_support_handlerbluetooth::hci::Controller::impl717 void le_get_dynamic_audio_buffer_support_handler(std::promise<void> vendor_promise,
718 CommandCompleteView view) {
719 vendor_promise.set_value();
720 auto dab_complete_view = DynamicAudioBufferCompleteView::Create(view);
721 if (!dab_complete_view.IsValid()) {
722 log::warn("Invalid command complete");
723 return;
724 }
725
726 if (dab_complete_view.GetStatus() != ErrorCode::SUCCESS) {
727 log::warn("Unexpected error code {}", ErrorCodeText(dab_complete_view.GetStatus()));
728 return;
729 }
730
731 auto complete_view = DabGetAudioBufferTimeCapabilityCompleteView::Create(dab_complete_view);
732 if (!complete_view.IsValid()) {
733 log::warn("Invalid get complete");
734 return;
735 }
736 dab_supported_codecs_ = complete_view.GetAudioCodecTypeSupported();
737 dab_codec_capabilities_ = complete_view.GetAudioCodecCapabilities();
738 }
739
set_controller_dab_audio_buffer_time_completebluetooth::hci::Controller::impl740 void set_controller_dab_audio_buffer_time_complete(CommandCompleteView complete) {
741 auto dab_complete = DynamicAudioBufferCompleteView::Create(complete);
742 if (!dab_complete.IsValid()) {
743 log::warn("Invalid command complete");
744 return;
745 }
746
747 if (dab_complete.GetStatus() != ErrorCode::SUCCESS) {
748 log::warn("Unexpected return code {}", ErrorCodeText(dab_complete.GetStatus()));
749 return;
750 }
751
752 auto dab_set_complete = DabSetAudioBufferTimeCompleteView::Create(dab_complete);
753
754 if (!dab_set_complete.IsValid()) {
755 log::warn("Invalid set complete");
756 return;
757 }
758
759 log::info("Configured Media Tx Buffer, time returned = {}",
760 dab_set_complete.GetCurrentBufferTimeMs());
761 }
762
set_controller_dab_audio_buffer_timebluetooth::hci::Controller::impl763 void set_controller_dab_audio_buffer_time(uint16_t buffer_time_ms) {
764 hci_->EnqueueCommand(
765 DabSetAudioBufferTimeBuilder::Create(buffer_time_ms),
766 module_.GetHandler()->BindOnceOn(
767 this, &Controller::impl::set_controller_dab_audio_buffer_time_complete));
768 }
769
set_event_maskbluetooth::hci::Controller::impl770 void set_event_mask(uint64_t event_mask) {
771 std::unique_ptr<SetEventMaskBuilder> packet = SetEventMaskBuilder::Create(event_mask);
772 hci_->EnqueueCommand(std::move(packet),
773 module_.GetHandler()->BindOnce(check_complete<SetEventMaskCompleteView>));
774 }
775
set_event_mask_page_2bluetooth::hci::Controller::impl776 void set_event_mask_page_2(uint64_t event_mask_page_2) {
777 std::unique_ptr<SetEventMaskPage2Builder> packet =
778 SetEventMaskPage2Builder::Create(event_mask_page_2);
779 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnce(
780 check_complete<SetEventMaskPage2CompleteView>));
781 }
782
write_le_host_supportbluetooth::hci::Controller::impl783 void write_le_host_support(Enable enable, Enable deprecated_host_bit) {
784 if (deprecated_host_bit == Enable::ENABLED) {
785 // Since Bluetooth Core Spec 4.1, this bit should be 0
786 log::warn("Setting deprecated Simultaneous LE BR/EDR Host bit");
787 }
788 std::unique_ptr<WriteLeHostSupportBuilder> packet =
789 WriteLeHostSupportBuilder::Create(enable, deprecated_host_bit);
790 hci_->EnqueueCommand(
791 std::move(packet),
792 module_.GetHandler()->BindOnce(check_complete<WriteLeHostSupportCompleteView>));
793 }
794
write_simple_pairing_modebluetooth::hci::Controller::impl795 void write_simple_pairing_mode(Enable enable) {
796 std::unique_ptr<WriteSimplePairingModeBuilder> packet =
797 WriteSimplePairingModeBuilder::Create(enable);
798 hci_->EnqueueCommand(
799 std::move(packet),
800 module_.GetHandler()->BindOnce(check_complete<WriteSimplePairingModeCompleteView>));
801 }
802
resetbluetooth::hci::Controller::impl803 void reset() {
804 std::unique_ptr<ResetBuilder> packet = ResetBuilder::Create();
805 hci_->EnqueueCommand(std::move(packet),
806 module_.GetHandler()->BindOnce(check_complete<ResetCompleteView>));
807 }
808
le_randbluetooth::hci::Controller::impl809 void le_rand(LeRandCallback cb) {
810 std::unique_ptr<LeRandBuilder> packet = LeRandBuilder::Create();
811 hci_->EnqueueCommand(
812 std::move(packet),
813 module_.GetHandler()->BindOnceOn(this, &Controller::impl::le_rand_cb, std::move(cb)));
814 }
815
le_rand_cbbluetooth::hci::Controller::impl816 void le_rand_cb(LeRandCallback cb, CommandCompleteView view) {
817 ASSERT(view.IsValid());
818 auto status_view = LeRandCompleteView::Create(view);
819 ASSERT(status_view.IsValid());
820 ASSERT(status_view.GetStatus() == ErrorCode::SUCCESS);
821 std::move(cb)(status_view.GetRandomNumber());
822 }
823
set_event_filterbluetooth::hci::Controller::impl824 void set_event_filter(std::unique_ptr<SetEventFilterBuilder> packet) {
825 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnce(
826 check_complete<SetEventFilterCompleteView>));
827 }
828
write_local_namebluetooth::hci::Controller::impl829 void write_local_name(std::string local_name) {
830 ASSERT(local_name.length() <= 248);
831 // Fill remaining char with 0
832 local_name.append(std::string(248 - local_name.length(), '\0'));
833 std::array<uint8_t, 248> local_name_array;
834 std::copy(std::begin(local_name), std::end(local_name), std::begin(local_name_array));
835
836 std::unique_ptr<WriteLocalNameBuilder> packet = WriteLocalNameBuilder::Create(local_name_array);
837 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnce(
838 check_complete<WriteLocalNameCompleteView>));
839 }
840
host_buffer_sizebluetooth::hci::Controller::impl841 void host_buffer_size(uint16_t host_acl_data_packet_length,
842 uint8_t host_synchronous_data_packet_length,
843 uint16_t host_total_num_acl_data_packets,
844 uint16_t host_total_num_synchronous_data_packets) {
845 std::unique_ptr<HostBufferSizeBuilder> packet = HostBufferSizeBuilder::Create(
846 host_acl_data_packet_length, host_synchronous_data_packet_length,
847 host_total_num_acl_data_packets, host_total_num_synchronous_data_packets);
848 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnce(
849 check_complete<HostBufferSizeCompleteView>));
850 }
851
le_set_event_maskbluetooth::hci::Controller::impl852 void le_set_event_mask(uint64_t le_event_mask) {
853 std::unique_ptr<LeSetEventMaskBuilder> packet = LeSetEventMaskBuilder::Create(le_event_mask);
854 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnce(
855 check_complete<LeSetEventMaskCompleteView>));
856 }
857
858 #define OP_CODE_MAPPING(name) \
859 case OpCode::name: { \
860 uint16_t index = (uint16_t)OpCodeIndex::name; \
861 uint16_t byte_index = index / 10; \
862 uint16_t bit_index = index % 10; \
863 bool supported = local_supported_commands_[byte_index] & (1 << bit_index); \
864 if (!supported) { \
865 log::debug("unsupported command opcode: 0x{:04x}", (uint16_t)OpCode::name); \
866 } \
867 return supported; \
868 }
869
is_supportedbluetooth::hci::Controller::impl870 bool is_supported(OpCode op_code) {
871 switch (op_code) {
872 OP_CODE_MAPPING(INQUIRY)
873 OP_CODE_MAPPING(INQUIRY_CANCEL)
874 OP_CODE_MAPPING(PERIODIC_INQUIRY_MODE)
875 OP_CODE_MAPPING(EXIT_PERIODIC_INQUIRY_MODE)
876 OP_CODE_MAPPING(CREATE_CONNECTION)
877 OP_CODE_MAPPING(DISCONNECT)
878 OP_CODE_MAPPING(CREATE_CONNECTION_CANCEL)
879 OP_CODE_MAPPING(ACCEPT_CONNECTION_REQUEST)
880 OP_CODE_MAPPING(REJECT_CONNECTION_REQUEST)
881 OP_CODE_MAPPING(LINK_KEY_REQUEST_REPLY)
882 OP_CODE_MAPPING(LINK_KEY_REQUEST_NEGATIVE_REPLY)
883 OP_CODE_MAPPING(PIN_CODE_REQUEST_REPLY)
884 OP_CODE_MAPPING(PIN_CODE_REQUEST_NEGATIVE_REPLY)
885 OP_CODE_MAPPING(CHANGE_CONNECTION_PACKET_TYPE)
886 OP_CODE_MAPPING(AUTHENTICATION_REQUESTED)
887 OP_CODE_MAPPING(SET_CONNECTION_ENCRYPTION)
888 OP_CODE_MAPPING(CHANGE_CONNECTION_LINK_KEY)
889 OP_CODE_MAPPING(CENTRAL_LINK_KEY)
890 OP_CODE_MAPPING(REMOTE_NAME_REQUEST)
891 OP_CODE_MAPPING(REMOTE_NAME_REQUEST_CANCEL)
892 OP_CODE_MAPPING(READ_REMOTE_SUPPORTED_FEATURES)
893 OP_CODE_MAPPING(READ_REMOTE_EXTENDED_FEATURES)
894 OP_CODE_MAPPING(READ_REMOTE_VERSION_INFORMATION)
895 OP_CODE_MAPPING(READ_CLOCK_OFFSET)
896 OP_CODE_MAPPING(READ_LMP_HANDLE)
897 OP_CODE_MAPPING(SETUP_SYNCHRONOUS_CONNECTION)
898 OP_CODE_MAPPING(ACCEPT_SYNCHRONOUS_CONNECTION)
899 OP_CODE_MAPPING(REJECT_SYNCHRONOUS_CONNECTION)
900 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_REPLY)
901 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_REPLY)
902 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_NEGATIVE_REPLY)
903 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_REPLY)
904 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_NEGATIVE_REPLY)
905 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_REPLY)
906 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY)
907 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_NEGATIVE_REPLY)
908 OP_CODE_MAPPING(ENHANCED_SETUP_SYNCHRONOUS_CONNECTION)
909 OP_CODE_MAPPING(ENHANCED_ACCEPT_SYNCHRONOUS_CONNECTION)
910 OP_CODE_MAPPING(TRUNCATED_PAGE)
911 OP_CODE_MAPPING(TRUNCATED_PAGE_CANCEL)
912 OP_CODE_MAPPING(SET_CONNECTIONLESS_PERIPHERAL_BROADCAST)
913 OP_CODE_MAPPING(SET_CONNECTIONLESS_PERIPHERAL_BROADCAST_RECEIVE)
914 OP_CODE_MAPPING(START_SYNCHRONIZATION_TRAIN)
915 OP_CODE_MAPPING(RECEIVE_SYNCHRONIZATION_TRAIN)
916 OP_CODE_MAPPING(REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY)
917 OP_CODE_MAPPING(HOLD_MODE)
918 OP_CODE_MAPPING(SNIFF_MODE)
919 OP_CODE_MAPPING(EXIT_SNIFF_MODE)
920 OP_CODE_MAPPING(PARK_STATE)
921 OP_CODE_MAPPING(EXIT_PARK_STATE)
922 OP_CODE_MAPPING(QOS_SETUP)
923 OP_CODE_MAPPING(ROLE_DISCOVERY)
924 OP_CODE_MAPPING(SWITCH_ROLE)
925 OP_CODE_MAPPING(READ_LINK_POLICY_SETTINGS)
926 OP_CODE_MAPPING(WRITE_LINK_POLICY_SETTINGS)
927 OP_CODE_MAPPING(READ_DEFAULT_LINK_POLICY_SETTINGS)
928 OP_CODE_MAPPING(WRITE_DEFAULT_LINK_POLICY_SETTINGS)
929 OP_CODE_MAPPING(FLOW_SPECIFICATION)
930 OP_CODE_MAPPING(SNIFF_SUBRATING)
931 OP_CODE_MAPPING(SET_EVENT_MASK)
932 OP_CODE_MAPPING(RESET)
933 OP_CODE_MAPPING(SET_EVENT_FILTER)
934 OP_CODE_MAPPING(FLUSH)
935 OP_CODE_MAPPING(READ_PIN_TYPE)
936 OP_CODE_MAPPING(WRITE_PIN_TYPE)
937 OP_CODE_MAPPING(READ_STORED_LINK_KEY)
938 OP_CODE_MAPPING(WRITE_STORED_LINK_KEY)
939 OP_CODE_MAPPING(DELETE_STORED_LINK_KEY)
940 OP_CODE_MAPPING(WRITE_LOCAL_NAME)
941 OP_CODE_MAPPING(READ_LOCAL_NAME)
942 OP_CODE_MAPPING(READ_CONNECTION_ACCEPT_TIMEOUT)
943 OP_CODE_MAPPING(WRITE_CONNECTION_ACCEPT_TIMEOUT)
944 OP_CODE_MAPPING(READ_PAGE_TIMEOUT)
945 OP_CODE_MAPPING(WRITE_PAGE_TIMEOUT)
946 OP_CODE_MAPPING(READ_SCAN_ENABLE)
947 OP_CODE_MAPPING(WRITE_SCAN_ENABLE)
948 OP_CODE_MAPPING(READ_PAGE_SCAN_ACTIVITY)
949 OP_CODE_MAPPING(WRITE_PAGE_SCAN_ACTIVITY)
950 OP_CODE_MAPPING(READ_INQUIRY_SCAN_ACTIVITY)
951 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_ACTIVITY)
952 OP_CODE_MAPPING(READ_AUTHENTICATION_ENABLE)
953 OP_CODE_MAPPING(WRITE_AUTHENTICATION_ENABLE)
954 OP_CODE_MAPPING(READ_CLASS_OF_DEVICE)
955 OP_CODE_MAPPING(WRITE_CLASS_OF_DEVICE)
956 OP_CODE_MAPPING(READ_VOICE_SETTING)
957 OP_CODE_MAPPING(WRITE_VOICE_SETTING)
958 OP_CODE_MAPPING(READ_AUTOMATIC_FLUSH_TIMEOUT)
959 OP_CODE_MAPPING(WRITE_AUTOMATIC_FLUSH_TIMEOUT)
960 OP_CODE_MAPPING(READ_NUM_BROADCAST_RETRANSMITS)
961 OP_CODE_MAPPING(WRITE_NUM_BROADCAST_RETRANSMITS)
962 OP_CODE_MAPPING(READ_HOLD_MODE_ACTIVITY)
963 OP_CODE_MAPPING(WRITE_HOLD_MODE_ACTIVITY)
964 OP_CODE_MAPPING(READ_TRANSMIT_POWER_LEVEL)
965 OP_CODE_MAPPING(READ_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
966 OP_CODE_MAPPING(WRITE_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
967 OP_CODE_MAPPING(SET_CONTROLLER_TO_HOST_FLOW_CONTROL)
968 OP_CODE_MAPPING(HOST_BUFFER_SIZE)
969 OP_CODE_MAPPING(HOST_NUMBER_OF_COMPLETED_PACKETS)
970 OP_CODE_MAPPING(READ_LINK_SUPERVISION_TIMEOUT)
971 OP_CODE_MAPPING(WRITE_LINK_SUPERVISION_TIMEOUT)
972 OP_CODE_MAPPING(READ_NUMBER_OF_SUPPORTED_IAC)
973 OP_CODE_MAPPING(READ_CURRENT_IAC_LAP)
974 OP_CODE_MAPPING(WRITE_CURRENT_IAC_LAP)
975 OP_CODE_MAPPING(SET_AFH_HOST_CHANNEL_CLASSIFICATION)
976 OP_CODE_MAPPING(READ_INQUIRY_SCAN_TYPE)
977 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_TYPE)
978 OP_CODE_MAPPING(READ_INQUIRY_MODE)
979 OP_CODE_MAPPING(WRITE_INQUIRY_MODE)
980 OP_CODE_MAPPING(READ_PAGE_SCAN_TYPE)
981 OP_CODE_MAPPING(WRITE_PAGE_SCAN_TYPE)
982 OP_CODE_MAPPING(READ_AFH_CHANNEL_ASSESSMENT_MODE)
983 OP_CODE_MAPPING(WRITE_AFH_CHANNEL_ASSESSMENT_MODE)
984 OP_CODE_MAPPING(READ_EXTENDED_INQUIRY_RESPONSE)
985 OP_CODE_MAPPING(WRITE_EXTENDED_INQUIRY_RESPONSE)
986 OP_CODE_MAPPING(REFRESH_ENCRYPTION_KEY)
987 OP_CODE_MAPPING(READ_SIMPLE_PAIRING_MODE)
988 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_MODE)
989 OP_CODE_MAPPING(READ_LOCAL_OOB_DATA)
990 OP_CODE_MAPPING(READ_INQUIRY_RESPONSE_TRANSMIT_POWER_LEVEL)
991 OP_CODE_MAPPING(WRITE_INQUIRY_TRANSMIT_POWER_LEVEL)
992 OP_CODE_MAPPING(READ_DEFAULT_ERRONEOUS_DATA_REPORTING)
993 OP_CODE_MAPPING(WRITE_DEFAULT_ERRONEOUS_DATA_REPORTING)
994 OP_CODE_MAPPING(ENHANCED_FLUSH)
995 OP_CODE_MAPPING(SEND_KEYPRESS_NOTIFICATION)
996 OP_CODE_MAPPING(SET_EVENT_MASK_PAGE_2)
997 OP_CODE_MAPPING(READ_FLOW_CONTROL_MODE)
998 OP_CODE_MAPPING(WRITE_FLOW_CONTROL_MODE)
999 OP_CODE_MAPPING(READ_ENHANCED_TRANSMIT_POWER_LEVEL)
1000 OP_CODE_MAPPING(READ_LE_HOST_SUPPORT)
1001 OP_CODE_MAPPING(WRITE_LE_HOST_SUPPORT)
1002 OP_CODE_MAPPING(SET_MWS_CHANNEL_PARAMETERS)
1003 OP_CODE_MAPPING(SET_EXTERNAL_FRAME_CONFIGURATION)
1004 OP_CODE_MAPPING(SET_MWS_SIGNALING)
1005 OP_CODE_MAPPING(SET_MWS_TRANSPORT_LAYER)
1006 OP_CODE_MAPPING(SET_MWS_SCAN_FREQUENCY_TABLE)
1007 OP_CODE_MAPPING(SET_MWS_PATTERN_CONFIGURATION)
1008 OP_CODE_MAPPING(SET_RESERVED_LT_ADDR)
1009 OP_CODE_MAPPING(DELETE_RESERVED_LT_ADDR)
1010 OP_CODE_MAPPING(SET_CONNECTIONLESS_PERIPHERAL_BROADCAST_DATA)
1011 OP_CODE_MAPPING(READ_SYNCHRONIZATION_TRAIN_PARAMETERS)
1012 OP_CODE_MAPPING(WRITE_SYNCHRONIZATION_TRAIN_PARAMETERS)
1013 OP_CODE_MAPPING(READ_SECURE_CONNECTIONS_HOST_SUPPORT)
1014 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_HOST_SUPPORT)
1015 OP_CODE_MAPPING(READ_AUTHENTICATED_PAYLOAD_TIMEOUT)
1016 OP_CODE_MAPPING(WRITE_AUTHENTICATED_PAYLOAD_TIMEOUT)
1017 OP_CODE_MAPPING(READ_LOCAL_OOB_EXTENDED_DATA)
1018 OP_CODE_MAPPING(READ_EXTENDED_PAGE_TIMEOUT)
1019 OP_CODE_MAPPING(WRITE_EXTENDED_PAGE_TIMEOUT)
1020 OP_CODE_MAPPING(READ_EXTENDED_INQUIRY_LENGTH)
1021 OP_CODE_MAPPING(WRITE_EXTENDED_INQUIRY_LENGTH)
1022 OP_CODE_MAPPING(SET_ECOSYSTEM_BASE_INTERVAL)
1023 OP_CODE_MAPPING(CONFIGURE_DATA_PATH)
1024 OP_CODE_MAPPING(SET_MIN_ENCRYPTION_KEY_SIZE)
1025 OP_CODE_MAPPING(READ_LOCAL_VERSION_INFORMATION)
1026 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_FEATURES)
1027 OP_CODE_MAPPING(READ_LOCAL_EXTENDED_FEATURES)
1028 OP_CODE_MAPPING(READ_BUFFER_SIZE)
1029 OP_CODE_MAPPING(READ_BD_ADDR)
1030 OP_CODE_MAPPING(READ_DATA_BLOCK_SIZE)
1031 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS_V1)
1032 OP_CODE_MAPPING(READ_LOCAL_SIMPLE_PAIRING_OPTIONS)
1033 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS_V2)
1034 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODEC_CAPABILITIES)
1035 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CONTROLLER_DELAY)
1036 OP_CODE_MAPPING(READ_FAILED_CONTACT_COUNTER)
1037 OP_CODE_MAPPING(RESET_FAILED_CONTACT_COUNTER)
1038 OP_CODE_MAPPING(READ_LINK_QUALITY)
1039 OP_CODE_MAPPING(READ_RSSI)
1040 OP_CODE_MAPPING(READ_AFH_CHANNEL_MAP)
1041 OP_CODE_MAPPING(READ_CLOCK)
1042 OP_CODE_MAPPING(READ_ENCRYPTION_KEY_SIZE)
1043 OP_CODE_MAPPING(GET_MWS_TRANSPORT_LAYER_CONFIGURATION)
1044 OP_CODE_MAPPING(SET_TRIGGERED_CLOCK_CAPTURE)
1045 OP_CODE_MAPPING(READ_LOOPBACK_MODE)
1046 OP_CODE_MAPPING(WRITE_LOOPBACK_MODE)
1047 OP_CODE_MAPPING(ENABLE_DEVICE_UNDER_TEST_MODE)
1048 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_DEBUG_MODE)
1049 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_TEST_MODE)
1050 OP_CODE_MAPPING(LE_SET_EVENT_MASK)
1051 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE_V1)
1052 OP_CODE_MAPPING(LE_READ_LOCAL_SUPPORTED_FEATURES)
1053 OP_CODE_MAPPING(LE_SET_RANDOM_ADDRESS)
1054 OP_CODE_MAPPING(LE_SET_ADVERTISING_PARAMETERS)
1055 OP_CODE_MAPPING(LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER)
1056 OP_CODE_MAPPING(LE_SET_ADVERTISING_DATA)
1057 OP_CODE_MAPPING(LE_SET_SCAN_RESPONSE_DATA)
1058 OP_CODE_MAPPING(LE_SET_ADVERTISING_ENABLE)
1059 OP_CODE_MAPPING(LE_SET_SCAN_PARAMETERS)
1060 OP_CODE_MAPPING(LE_SET_SCAN_ENABLE)
1061 OP_CODE_MAPPING(LE_CREATE_CONNECTION)
1062 OP_CODE_MAPPING(LE_CREATE_CONNECTION_CANCEL)
1063 OP_CODE_MAPPING(LE_READ_FILTER_ACCEPT_LIST_SIZE)
1064 OP_CODE_MAPPING(LE_CLEAR_FILTER_ACCEPT_LIST)
1065 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST)
1066 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST)
1067 OP_CODE_MAPPING(LE_CONNECTION_UPDATE)
1068 OP_CODE_MAPPING(LE_SET_HOST_CHANNEL_CLASSIFICATION)
1069 OP_CODE_MAPPING(LE_READ_CHANNEL_MAP)
1070 OP_CODE_MAPPING(LE_READ_REMOTE_FEATURES)
1071 OP_CODE_MAPPING(LE_ENCRYPT)
1072 OP_CODE_MAPPING(LE_RAND)
1073 OP_CODE_MAPPING(LE_START_ENCRYPTION)
1074 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_REPLY)
1075 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_NEGATIVE_REPLY)
1076 OP_CODE_MAPPING(LE_READ_SUPPORTED_STATES)
1077 OP_CODE_MAPPING(LE_RECEIVER_TEST_V1)
1078 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V1)
1079 OP_CODE_MAPPING(LE_TEST_END)
1080 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_REPLY)
1081 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_NEGATIVE_REPLY)
1082 OP_CODE_MAPPING(LE_SET_DATA_LENGTH)
1083 OP_CODE_MAPPING(LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH)
1084 OP_CODE_MAPPING(LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH)
1085 OP_CODE_MAPPING(LE_READ_LOCAL_P_256_PUBLIC_KEY)
1086 OP_CODE_MAPPING(LE_GENERATE_DHKEY_V1)
1087 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_RESOLVING_LIST)
1088 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_RESOLVING_LIST)
1089 OP_CODE_MAPPING(LE_CLEAR_RESOLVING_LIST)
1090 OP_CODE_MAPPING(LE_READ_RESOLVING_LIST_SIZE)
1091 OP_CODE_MAPPING(LE_READ_PEER_RESOLVABLE_ADDRESS)
1092 OP_CODE_MAPPING(LE_READ_LOCAL_RESOLVABLE_ADDRESS)
1093 OP_CODE_MAPPING(LE_SET_ADDRESS_RESOLUTION_ENABLE)
1094 OP_CODE_MAPPING(LE_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT)
1095 OP_CODE_MAPPING(LE_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT_V2)
1096 OP_CODE_MAPPING(LE_READ_MAXIMUM_DATA_LENGTH)
1097 OP_CODE_MAPPING(LE_READ_PHY)
1098 OP_CODE_MAPPING(LE_SET_DEFAULT_PHY)
1099 OP_CODE_MAPPING(LE_SET_PHY)
1100 OP_CODE_MAPPING(LE_RECEIVER_TEST_V2)
1101 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V2)
1102 OP_CODE_MAPPING(LE_SET_ADVERTISING_SET_RANDOM_ADDRESS)
1103 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_PARAMETERS)
1104 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_DATA)
1105 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_RESPONSE_DATA)
1106 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_ENABLE)
1107 OP_CODE_MAPPING(LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH)
1108 OP_CODE_MAPPING(LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS)
1109 OP_CODE_MAPPING(LE_REMOVE_ADVERTISING_SET)
1110 OP_CODE_MAPPING(LE_CLEAR_ADVERTISING_SETS)
1111 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_PARAMETERS)
1112 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_DATA)
1113 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_ENABLE)
1114 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_PARAMETERS)
1115 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_ENABLE)
1116 OP_CODE_MAPPING(LE_EXTENDED_CREATE_CONNECTION)
1117 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC)
1118 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC_CANCEL)
1119 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_TERMINATE_SYNC)
1120 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_PERIODIC_ADVERTISER_LIST)
1121 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_PERIODIC_ADVERTISER_LIST)
1122 OP_CODE_MAPPING(LE_CLEAR_PERIODIC_ADVERTISER_LIST)
1123 OP_CODE_MAPPING(LE_READ_PERIODIC_ADVERTISER_LIST_SIZE)
1124 OP_CODE_MAPPING(LE_READ_TRANSMIT_POWER)
1125 OP_CODE_MAPPING(LE_READ_RF_PATH_COMPENSATION_POWER)
1126 OP_CODE_MAPPING(LE_WRITE_RF_PATH_COMPENSATION_POWER)
1127 OP_CODE_MAPPING(LE_SET_PRIVACY_MODE)
1128 OP_CODE_MAPPING(LE_RECEIVER_TEST_V3)
1129 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V3)
1130 OP_CODE_MAPPING(LE_SET_CONNECTIONLESS_CTE_TRANSMIT_PARAMETERS)
1131 OP_CODE_MAPPING(LE_SET_CONNECTIONLESS_CTE_TRANSMIT_ENABLE)
1132 OP_CODE_MAPPING(LE_SET_CONNECTIONLESS_IQ_SAMPLING_ENABLE)
1133 OP_CODE_MAPPING(LE_SET_CONNECTION_CTE_RECEIVE_PARAMETERS)
1134 OP_CODE_MAPPING(LE_SET_CONNECTION_CTE_TRANSMIT_PARAMETERS)
1135 OP_CODE_MAPPING(LE_CONNECTION_CTE_REQUEST_ENABLE)
1136 OP_CODE_MAPPING(LE_CONNECTION_CTE_RESPONSE_ENABLE)
1137 OP_CODE_MAPPING(LE_READ_ANTENNA_INFORMATION)
1138 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_RECEIVE_ENABLE)
1139 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_SYNC_TRANSFER)
1140 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_SET_INFO_TRANSFER)
1141 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS)
1142 OP_CODE_MAPPING(LE_SET_DEFAULT_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS)
1143 OP_CODE_MAPPING(LE_GENERATE_DHKEY_V2)
1144 OP_CODE_MAPPING(LE_MODIFY_SLEEP_CLOCK_ACCURACY)
1145 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE_V2)
1146 OP_CODE_MAPPING(LE_READ_ISO_TX_SYNC)
1147 OP_CODE_MAPPING(LE_SET_CIG_PARAMETERS)
1148 OP_CODE_MAPPING(LE_SET_CIG_PARAMETERS_TEST)
1149 OP_CODE_MAPPING(LE_CREATE_CIS)
1150 OP_CODE_MAPPING(LE_REMOVE_CIG)
1151 OP_CODE_MAPPING(LE_ACCEPT_CIS_REQUEST)
1152 OP_CODE_MAPPING(LE_REJECT_CIS_REQUEST)
1153 OP_CODE_MAPPING(LE_CREATE_BIG)
1154 OP_CODE_MAPPING(LE_CREATE_BIG_TEST)
1155 OP_CODE_MAPPING(LE_TERMINATE_BIG)
1156 OP_CODE_MAPPING(LE_BIG_CREATE_SYNC)
1157 OP_CODE_MAPPING(LE_BIG_TERMINATE_SYNC)
1158 OP_CODE_MAPPING(LE_REQUEST_PEER_SCA)
1159 OP_CODE_MAPPING(LE_SETUP_ISO_DATA_PATH)
1160 OP_CODE_MAPPING(LE_REMOVE_ISO_DATA_PATH)
1161 OP_CODE_MAPPING(LE_ISO_TRANSMIT_TEST)
1162 OP_CODE_MAPPING(LE_ISO_RECEIVE_TEST)
1163 OP_CODE_MAPPING(LE_ISO_READ_TEST_COUNTERS)
1164 OP_CODE_MAPPING(LE_ISO_TEST_END)
1165 OP_CODE_MAPPING(LE_SET_HOST_FEATURE)
1166 OP_CODE_MAPPING(LE_READ_ISO_LINK_QUALITY)
1167 OP_CODE_MAPPING(LE_ENHANCED_READ_TRANSMIT_POWER_LEVEL)
1168 OP_CODE_MAPPING(LE_READ_REMOTE_TRANSMIT_POWER_LEVEL)
1169 OP_CODE_MAPPING(LE_SET_PATH_LOSS_REPORTING_PARAMETERS)
1170 OP_CODE_MAPPING(LE_SET_PATH_LOSS_REPORTING_ENABLE)
1171 OP_CODE_MAPPING(LE_SET_TRANSMIT_POWER_REPORTING_ENABLE)
1172 OP_CODE_MAPPING(LE_TRANSMITTER_TEST_V4)
1173 OP_CODE_MAPPING(LE_SET_DATA_RELATED_ADDRESS_CHANGES)
1174 OP_CODE_MAPPING(LE_SET_DEFAULT_SUBRATE)
1175 OP_CODE_MAPPING(LE_SUBRATE_REQUEST)
1176
1177 // deprecated
1178 case OpCode::ADD_SCO_CONNECTION:
1179 return false;
1180
1181 // vendor specific
1182 case OpCode::LE_GET_VENDOR_CAPABILITIES:
1183 return vendor_capabilities_.is_supported_ == 0x01;
1184 case OpCode::LE_MULTI_ADVT:
1185 return vendor_capabilities_.max_advt_instances_ != 0x00;
1186 case OpCode::LE_BATCH_SCAN:
1187 return vendor_capabilities_.total_scan_results_storage_ != 0x00;
1188 case OpCode::LE_ADV_FILTER:
1189 return vendor_capabilities_.filtering_support_ == 0x01;
1190 case OpCode::LE_ENERGY_INFO:
1191 return vendor_capabilities_.activity_energy_info_support_ == 0x01;
1192 case OpCode::LE_EXTENDED_SCAN_PARAMS:
1193 return vendor_capabilities_.extended_scan_support_ == 0x01;
1194 case OpCode::CONTROLLER_DEBUG_INFO:
1195 return vendor_capabilities_.debug_logging_supported_ == 0x01;
1196 case OpCode::CONTROLLER_A2DP_OPCODE:
1197 return vendor_capabilities_.a2dp_source_offload_capability_mask_ != 0x00;
1198 case OpCode::CONTROLLER_BQR:
1199 return vendor_capabilities_.bluetooth_quality_report_support_ == 0x01;
1200 case OpCode::DYNAMIC_AUDIO_BUFFER:
1201 return vendor_capabilities_.dynamic_audio_buffer_support_ > 0x00;
1202 // Before MSFT extension is fully supported, return false for the following MSFT_OPCODE_XXXX
1203 // for now.
1204 case OpCode::MSFT_OPCODE_INTEL:
1205 return false;
1206 case OpCode::MSFT_OPCODE_MEDIATEK:
1207 return false;
1208 case OpCode::MSFT_OPCODE_QUALCOMM:
1209 return false;
1210 // undefined in local_supported_commands_
1211 case OpCode::READ_LOCAL_SUPPORTED_COMMANDS:
1212 return true;
1213 case OpCode::NONE:
1214 return false;
1215 case OpCode::LE_CS_READ_LOCAL_SUPPORTED_CAPABILITIES:
1216 case OpCode::LE_CS_READ_REMOTE_SUPPORTED_CAPABILITIES:
1217 case OpCode::LE_CS_WRITE_CACHED_REMOTE_SUPPORTED_CAPABILITIES:
1218 case OpCode::LE_CS_SECURITY_ENABLE:
1219 case OpCode::LE_CS_SET_DEFAULT_SETTINGS:
1220 case OpCode::LE_CS_READ_REMOTE_FAE_TABLE:
1221 case OpCode::LE_CS_WRITE_CACHED_REMOTE_FAE_TABLE:
1222 case OpCode::LE_CS_CREATE_CONFIG:
1223 case OpCode::LE_CS_REMOVE_CONFIG:
1224 case OpCode::LE_CS_SET_CHANNEL_CLASSIFICATION:
1225 case OpCode::LE_CS_PROCEDURE_ENABLE:
1226 case OpCode::LE_CS_TEST:
1227 case OpCode::LE_CS_TEST_END:
1228 case OpCode::LE_CS_SET_PROCEDURE_PARAMETERS:
1229 // TODO add to OP_CODE_MAPPING list
1230 return false;
1231 }
1232 return false;
1233 }
1234 #undef OP_CODE_MAPPING
1235
1236 template <typename OutputT>
1237 void dump(OutputT&& out) const;
1238
1239 Controller& module_;
1240
1241 HciLayer* hci_;
1242
1243 CompletedAclPacketsCallback acl_credits_callback_{};
1244 CompletedAclPacketsCallback acl_monitor_credits_callback_{};
1245 LocalVersionInformation local_version_information_{};
1246 std::array<uint8_t, 64> local_supported_commands_{};
1247 std::vector<uint64_t> extended_lmp_features_array_{};
1248 uint16_t acl_buffer_length_{};
1249 uint16_t acl_buffers_{};
1250 uint8_t sco_buffer_length_{};
1251 uint16_t sco_buffers_{};
1252 Address mac_address_{};
1253 std::string local_name_{};
1254 LeBufferSize le_buffer_size_{};
1255 std::vector<uint8_t> local_supported_codec_ids_{};
1256 std::vector<uint32_t> local_supported_vendor_codec_ids_{};
1257 LeBufferSize iso_buffer_size_{};
1258 uint64_t le_local_supported_features_{};
1259 uint64_t le_supported_states_{};
1260 uint8_t le_accept_list_size_{};
1261 uint8_t le_resolving_list_size_{};
1262 LeMaximumDataLength le_maximum_data_length_{};
1263 uint16_t le_maximum_advertising_data_length_{};
1264 uint16_t le_suggested_default_data_length_{};
1265 uint8_t le_number_supported_advertising_sets_{};
1266 uint8_t le_periodic_advertiser_list_size_{};
1267 VendorCapabilities vendor_capabilities_{};
1268 uint32_t dab_supported_codecs_{};
1269 std::array<DynamicAudioBufferCodecCapability, 32> dab_codec_capabilities_{};
1270 }; // namespace hci
1271
Controller()1272 Controller::Controller() : impl_(std::make_unique<impl>(*this)) {}
1273
1274 Controller::~Controller() = default;
1275
RegisterCompletedAclPacketsCallback(CompletedAclPacketsCallback cb)1276 void Controller::RegisterCompletedAclPacketsCallback(CompletedAclPacketsCallback cb) {
1277 CallOn(impl_.get(), &impl::register_completed_acl_packets_callback, cb);
1278 }
1279
UnregisterCompletedAclPacketsCallback()1280 void Controller::UnregisterCompletedAclPacketsCallback() {
1281 CallOn(impl_.get(), &impl::unregister_completed_acl_packets_callback);
1282 }
1283
RegisterCompletedMonitorAclPacketsCallback(CompletedAclPacketsCallback cb)1284 void Controller::RegisterCompletedMonitorAclPacketsCallback(CompletedAclPacketsCallback cb) {
1285 CallOn(impl_.get(), &impl::register_completed_monitor_acl_packets_callback, cb);
1286 }
1287
UnregisterCompletedMonitorAclPacketsCallback()1288 void Controller::UnregisterCompletedMonitorAclPacketsCallback() {
1289 CallOn(impl_.get(), &impl::unregister_completed_monitor_acl_packets_callback);
1290 }
1291
GetLocalName() const1292 std::string Controller::GetLocalName() const { return impl_->local_name_; }
1293
GetLocalVersionInformation() const1294 LocalVersionInformation Controller::GetLocalVersionInformation() const {
1295 return impl_->local_version_information_;
1296 }
1297
GetLocalSupportedBrEdrCodecIds() const1298 std::vector<uint8_t> Controller::GetLocalSupportedBrEdrCodecIds() const {
1299 return impl_->local_supported_codec_ids_;
1300 }
1301
1302 #define BIT(x) (0x1ULL << (x))
1303
1304 #define LOCAL_FEATURE_ACCESSOR(name, page, bit) \
1305 bool Controller::name() const { return GetLocalFeatures(page) & BIT(bit); }
1306
1307 LOCAL_FEATURE_ACCESSOR(Supports3SlotPackets, 0, 0)
1308 LOCAL_FEATURE_ACCESSOR(Supports5SlotPackets, 0, 1)
1309 LOCAL_FEATURE_ACCESSOR(SupportsRoleSwitch, 0, 5)
1310 LOCAL_FEATURE_ACCESSOR(SupportsHoldMode, 0, 6)
1311 LOCAL_FEATURE_ACCESSOR(SupportsSniffMode, 0, 7)
1312 LOCAL_FEATURE_ACCESSOR(SupportsParkMode, 0, 8)
1313 LOCAL_FEATURE_ACCESSOR(SupportsSco, 0, 11)
1314 LOCAL_FEATURE_ACCESSOR(SupportsHv2Packets, 0, 12)
1315 LOCAL_FEATURE_ACCESSOR(SupportsHv3Packets, 0, 13)
1316 LOCAL_FEATURE_ACCESSOR(SupportsClassic2mPhy, 0, 25)
1317 LOCAL_FEATURE_ACCESSOR(SupportsClassic3mPhy, 0, 26)
1318 LOCAL_FEATURE_ACCESSOR(SupportsInterlacedInquiryScan, 0, 28)
1319 LOCAL_FEATURE_ACCESSOR(SupportsRssiWithInquiryResults, 0, 30)
1320 LOCAL_FEATURE_ACCESSOR(SupportsEv3Packets, 0, 31)
1321 LOCAL_FEATURE_ACCESSOR(SupportsEv4Packets, 0, 32)
1322 LOCAL_FEATURE_ACCESSOR(SupportsEv5Packets, 0, 33)
1323 LOCAL_FEATURE_ACCESSOR(SupportsBle, 0, 38)
1324 LOCAL_FEATURE_ACCESSOR(Supports3SlotEdrPackets, 0, 39)
1325 LOCAL_FEATURE_ACCESSOR(Supports5SlotEdrPackets, 0, 40)
1326 LOCAL_FEATURE_ACCESSOR(SupportsSniffSubrating, 0, 41)
1327 LOCAL_FEATURE_ACCESSOR(SupportsEncryptionPause, 0, 42)
1328 LOCAL_FEATURE_ACCESSOR(SupportsEsco2mPhy, 0, 45)
1329 LOCAL_FEATURE_ACCESSOR(SupportsEsco3mPhy, 0, 46)
1330 LOCAL_FEATURE_ACCESSOR(Supports3SlotEscoEdrPackets, 0, 47)
1331 LOCAL_FEATURE_ACCESSOR(SupportsExtendedInquiryResponse, 0, 48)
1332 LOCAL_FEATURE_ACCESSOR(SupportsSimultaneousLeBrEdr, 0, 49)
1333 LOCAL_FEATURE_ACCESSOR(SupportsSimplePairing, 0, 51)
1334 LOCAL_FEATURE_ACCESSOR(SupportsNonFlushablePb, 0, 54)
1335
1336 LOCAL_FEATURE_ACCESSOR(SupportsSecureConnections, 2, 8)
1337
1338 #define LOCAL_LE_FEATURE_ACCESSOR(name, bit) \
1339 bool Controller::name() const { return GetLocalLeFeatures() & BIT(bit); }
1340
1341 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleEncryption, 0)
1342 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionParametersRequest, 1)
1343 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedReject, 2)
1344 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeripheralInitiatedFeaturesExchange, 3)
1345 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePing, 4)
1346 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleDataPacketLengthExtension, 5)
1347 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePrivacy, 6)
1348 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedScannerFilterPolicies, 7)
1349 LOCAL_LE_FEATURE_ACCESSOR(SupportsBle2mPhy, 8)
1350 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleStableModulationIndexTx, 9)
1351 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleStableModulationIndexRx, 10)
1352 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleCodedPhy, 11)
1353 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedAdvertising, 12)
1354 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertising, 13)
1355 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleChannelSelectionAlgorithm2, 14)
1356 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerClass1, 15)
1357 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleMinimumUsedChannels, 16)
1358 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionCteRequest, 17)
1359 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionCteResponse, 18)
1360 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionlessCteTransmitter, 19)
1361 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionlessCteReceiver, 20)
1362 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleAntennaSwitchingDuringCteTx, 21)
1363 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleAntennaSwitchingDuringCteRx, 22)
1364 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleReceivingConstantToneExtensions, 23)
1365 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingSyncTransferSender, 24)
1366 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingSyncTransferRecipient, 25)
1367 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleSleepClockAccuracyUpdates, 26)
1368 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleRemotePublicKeyValidation, 27)
1369 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectedIsochronousStreamCentral, 28)
1370 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectedIsochronousStreamPeripheral, 29)
1371 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleIsochronousBroadcaster, 30)
1372 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleSynchronizedReceiver, 31)
1373 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleIsochronousChannelsHostSupport, 32)
1374 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerControlRequest, 33)
1375 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerChangeIndication, 34)
1376 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePathLossMonitoring, 35)
1377 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingAdi, 36)
1378 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionSubrating, 37)
1379 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionSubratingHost, 38)
1380 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleChannelSounding, 46)
1381
GetLocalFeatures(uint8_t page_number) const1382 uint64_t Controller::GetLocalFeatures(uint8_t page_number) const {
1383 if (page_number < impl_->extended_lmp_features_array_.size()) {
1384 return impl_->extended_lmp_features_array_[page_number];
1385 }
1386 return 0x00;
1387 }
1388
GetAclPacketLength() const1389 uint16_t Controller::GetAclPacketLength() const { return impl_->acl_buffer_length_; }
1390
GetNumAclPacketBuffers() const1391 uint16_t Controller::GetNumAclPacketBuffers() const { return impl_->acl_buffers_; }
1392
GetScoPacketLength() const1393 uint8_t Controller::GetScoPacketLength() const { return impl_->sco_buffer_length_; }
1394
GetNumScoPacketBuffers() const1395 uint16_t Controller::GetNumScoPacketBuffers() const { return impl_->sco_buffers_; }
1396
GetMacAddress() const1397 Address Controller::GetMacAddress() const { return impl_->mac_address_; }
1398
SetEventMask(uint64_t event_mask)1399 void Controller::SetEventMask(uint64_t event_mask) {
1400 CallOn(impl_.get(), &impl::set_event_mask, event_mask);
1401 }
1402
Reset()1403 void Controller::Reset() { CallOn(impl_.get(), &impl::reset); }
1404
LeRand(LeRandCallback cb)1405 void Controller::LeRand(LeRandCallback cb) { CallOn(impl_.get(), &impl::le_rand, std::move(cb)); }
1406
SetEventFilterClearAll()1407 void Controller::SetEventFilterClearAll() {
1408 std::unique_ptr<SetEventFilterClearAllBuilder> packet = SetEventFilterClearAllBuilder::Create();
1409 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1410 }
1411
SetEventFilterInquiryResultAllDevices()1412 void Controller::SetEventFilterInquiryResultAllDevices() {
1413 std::unique_ptr<SetEventFilterInquiryResultAllDevicesBuilder> packet =
1414 SetEventFilterInquiryResultAllDevicesBuilder::Create();
1415 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1416 }
1417
SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask)1418 void Controller::SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,
1419 ClassOfDevice class_of_device_mask) {
1420 std::unique_ptr<SetEventFilterInquiryResultClassOfDeviceBuilder> packet =
1421 SetEventFilterInquiryResultClassOfDeviceBuilder::Create(class_of_device,
1422 class_of_device_mask);
1423 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1424 }
1425
SetEventFilterInquiryResultAddress(Address address)1426 void Controller::SetEventFilterInquiryResultAddress(Address address) {
1427 std::unique_ptr<SetEventFilterInquiryResultAddressBuilder> packet =
1428 SetEventFilterInquiryResultAddressBuilder::Create(address);
1429 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1430 }
1431
SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag)1432 void Controller::SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag) {
1433 std::unique_ptr<SetEventFilterConnectionSetupAllDevicesBuilder> packet =
1434 SetEventFilterConnectionSetupAllDevicesBuilder::Create(auto_accept_flag);
1435 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1436 }
1437
SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask,AutoAcceptFlag auto_accept_flag)1438 void Controller::SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,
1439 ClassOfDevice class_of_device_mask,
1440 AutoAcceptFlag auto_accept_flag) {
1441 std::unique_ptr<SetEventFilterConnectionSetupClassOfDeviceBuilder> packet =
1442 SetEventFilterConnectionSetupClassOfDeviceBuilder::Create(
1443 class_of_device, class_of_device_mask, auto_accept_flag);
1444 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1445 }
1446
SetEventFilterConnectionSetupAddress(Address address,AutoAcceptFlag auto_accept_flag)1447 void Controller::SetEventFilterConnectionSetupAddress(Address address,
1448 AutoAcceptFlag auto_accept_flag) {
1449 std::unique_ptr<SetEventFilterConnectionSetupAddressBuilder> packet =
1450 SetEventFilterConnectionSetupAddressBuilder::Create(address, auto_accept_flag);
1451 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1452 }
1453
WriteLocalName(std::string local_name)1454 void Controller::WriteLocalName(std::string local_name) {
1455 impl_->local_name_ = local_name;
1456 CallOn(impl_.get(), &impl::write_local_name, local_name);
1457 }
1458
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)1459 void Controller::HostBufferSize(uint16_t host_acl_data_packet_length,
1460 uint8_t host_synchronous_data_packet_length,
1461 uint16_t host_total_num_acl_data_packets,
1462 uint16_t host_total_num_synchronous_data_packets) {
1463 CallOn(impl_.get(), &impl::host_buffer_size, host_acl_data_packet_length,
1464 host_synchronous_data_packet_length, host_total_num_acl_data_packets,
1465 host_total_num_synchronous_data_packets);
1466 }
1467
LeSetEventMask(uint64_t le_event_mask)1468 void Controller::LeSetEventMask(uint64_t le_event_mask) {
1469 CallOn(impl_.get(), &impl::le_set_event_mask, le_event_mask);
1470 }
1471
GetLeBufferSize() const1472 LeBufferSize Controller::GetLeBufferSize() const { return impl_->le_buffer_size_; }
1473
GetLocalLeFeatures() const1474 uint64_t Controller::GetLocalLeFeatures() const { return impl_->le_local_supported_features_; }
1475
GetControllerIsoBufferSize() const1476 LeBufferSize Controller::GetControllerIsoBufferSize() const { return impl_->iso_buffer_size_; }
1477
GetControllerLeLocalSupportedFeatures() const1478 uint64_t Controller::GetControllerLeLocalSupportedFeatures() const {
1479 return impl_->le_local_supported_features_;
1480 }
1481
GetLeSupportedStates() const1482 uint64_t Controller::GetLeSupportedStates() const { return impl_->le_supported_states_; }
1483
GetLeFilterAcceptListSize() const1484 uint8_t Controller::GetLeFilterAcceptListSize() const { return impl_->le_accept_list_size_; }
1485
GetLeResolvingListSize() const1486 uint8_t Controller::GetLeResolvingListSize() const { return impl_->le_resolving_list_size_; }
1487
GetLeMaximumDataLength() const1488 LeMaximumDataLength Controller::GetLeMaximumDataLength() const {
1489 return impl_->le_maximum_data_length_;
1490 }
1491
GetLeMaximumAdvertisingDataLength() const1492 uint16_t Controller::GetLeMaximumAdvertisingDataLength() const {
1493 return impl_->le_maximum_advertising_data_length_;
1494 }
1495
GetLeSuggestedDefaultDataLength() const1496 uint16_t Controller::GetLeSuggestedDefaultDataLength() const {
1497 return impl_->le_suggested_default_data_length_;
1498 }
1499
GetLeNumberOfSupportedAdverisingSets() const1500 uint8_t Controller::GetLeNumberOfSupportedAdverisingSets() const {
1501 return impl_->le_number_supported_advertising_sets_;
1502 }
1503
GetVendorCapabilities() const1504 Controller::VendorCapabilities Controller::GetVendorCapabilities() const {
1505 return impl_->vendor_capabilities_;
1506 }
1507
GetDabSupportedCodecs() const1508 uint32_t Controller::GetDabSupportedCodecs() const { return impl_->dab_supported_codecs_; }
1509
GetDabCodecCapabilities() const1510 const std::array<DynamicAudioBufferCodecCapability, 32>& Controller::GetDabCodecCapabilities()
1511 const {
1512 return impl_->dab_codec_capabilities_;
1513 }
1514
SetDabAudioBufferTime(uint16_t buffer_time_ms)1515 void Controller::SetDabAudioBufferTime(uint16_t buffer_time_ms) {
1516 if (impl_->vendor_capabilities_.dynamic_audio_buffer_support_ == 0) {
1517 log::warn("Dynamic Audio Buffer not supported");
1518 return;
1519 }
1520 impl_->set_controller_dab_audio_buffer_time(buffer_time_ms);
1521 }
1522
GetLePeriodicAdvertiserListSize() const1523 uint8_t Controller::GetLePeriodicAdvertiserListSize() const {
1524 return impl_->le_periodic_advertiser_list_size_;
1525 }
1526
IsSupported(bluetooth::hci::OpCode op_code) const1527 bool Controller::IsSupported(bluetooth::hci::OpCode op_code) const {
1528 return impl_->is_supported(op_code);
1529 }
1530
MaskLeEventMask(HciVersion version,uint64_t mask)1531 uint64_t Controller::MaskLeEventMask(HciVersion version, uint64_t mask) {
1532 if (version >= HciVersion::V_5_3) {
1533 return mask;
1534 } else if (version >= HciVersion::V_5_2) {
1535 return mask & kLeEventMask52;
1536 } else if (version >= HciVersion::V_5_1) {
1537 return mask & kLeEventMask51;
1538 } else if (version >= HciVersion::V_5_0) {
1539 return mask & kLeEventMask50;
1540 } else if (version >= HciVersion::V_4_2) {
1541 return mask & kLeEventMask42;
1542 } else {
1543 return mask & kLeEventMask41;
1544 }
1545 }
1546
IsRpaGenerationSupported(void) const1547 bool Controller::IsRpaGenerationSupported(void) const {
1548 static const bool rpa_supported =
1549 com::android::bluetooth::flags::rpa_offload_to_bt_controller() &&
1550 os::GetSystemPropertyBool(kPropertyRpaOffload, kDefaultRpaOffload) &&
1551 IsSupported(OpCode::LE_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT_V2);
1552
1553 return rpa_supported;
1554 }
1555
__anonfcffa8990102() 1556 const ModuleFactory Controller::Factory = ModuleFactory([]() { return new Controller(); });
1557
ListDependencies(ModuleList * list) const1558 void Controller::ListDependencies(ModuleList* list) const {
1559 list->add<hci::HciLayer>();
1560 #if TARGET_FLOSS
1561 list->add<sysprops::SyspropsModule>();
1562 #endif
1563 }
1564
Start()1565 void Controller::Start() { impl_->Start(GetDependency<hci::HciLayer>()); }
1566
Stop()1567 void Controller::Stop() { impl_->Stop(); }
1568
ToString() const1569 std::string Controller::ToString() const { return "Controller"; }
1570
1571 template <typename OutputT>
dump(OutputT && out) const1572 void Controller::impl::dump(OutputT&& out) const {
1573 std::format_to(out, "\nHCI Controller Dumpsys:\n");
1574
1575 std::format_to(out,
1576 " local_version_information:\n"
1577 " hci_version: {}\n"
1578 " hci_revision: 0x{:x}\n"
1579 " lmp_version: {}\n"
1580 " lmp_subversion: 0x{:x}\n"
1581 " manufacturer_name: {}\n",
1582 HciVersionText(local_version_information_.hci_version_),
1583 local_version_information_.hci_revision_,
1584 LmpVersionText(local_version_information_.lmp_version_),
1585 local_version_information_.lmp_subversion_,
1586 local_version_information_.manufacturer_name_);
1587
1588 std::format_to(out,
1589 " buffer_size:\n"
1590 " acl_data_packet_length: {}\n"
1591 " total_num_acl_data_packets: {}\n"
1592 " sco_data_packet_length: {}\n"
1593 " total_num_sco_data_packets: {}\n",
1594 acl_buffer_length_, acl_buffers_, sco_buffer_length_, sco_buffers_);
1595
1596 std::format_to(out,
1597 " le_buffer_size:\n"
1598 " le_acl_data_packet_length: {}\n"
1599 " total_num_le_acl_data_packets: {}\n"
1600 " iso_data_packet_length: {}\n"
1601 " total_num_iso_data_packets: {}\n",
1602 le_buffer_size_.le_data_packet_length_, le_buffer_size_.total_num_le_packets_,
1603 iso_buffer_size_.le_data_packet_length_, iso_buffer_size_.total_num_le_packets_);
1604
1605 std::format_to(out,
1606 " le_maximum_data_length:\n"
1607 " supported_max_tx_octets: {}\n"
1608 " supported_max_tx_time: {}\n"
1609 " supported_max_rx_octets: {}\n"
1610 " supported_max_rx_time: {}\n",
1611 le_maximum_data_length_.supported_max_tx_octets_,
1612 le_maximum_data_length_.supported_max_tx_time_,
1613 le_maximum_data_length_.supported_max_rx_octets_,
1614 le_maximum_data_length_.supported_max_rx_time_);
1615
1616 std::format_to(out,
1617 " le_accept_list_size: {}\n"
1618 " le_resolving_list_size: {}\n"
1619 " le_maximum_advertising_data_length: {}\n"
1620 " le_suggested_default_data_length: {}\n"
1621 " le_number_supported_advertising_sets: {}\n"
1622 " le_periodic_advertiser_list_size: {}\n"
1623 " le_supported_states: 0x{:016x}\n",
1624 le_accept_list_size_, le_resolving_list_size_, le_maximum_advertising_data_length_,
1625 le_suggested_default_data_length_, le_number_supported_advertising_sets_,
1626 le_periodic_advertiser_list_size_, le_supported_states_);
1627
1628 std::format_to(out,
1629 " local_supported_features:\n"
1630 " page0: 0x{:016x}\n"
1631 " page1: 0x{:016x}\n"
1632 " page2: 0x{:016x}\n"
1633 " le_local_supported_features:\n"
1634 " page0: 0x{:016x}\n",
1635 extended_lmp_features_array_[0], extended_lmp_features_array_[1],
1636 extended_lmp_features_array_[2], le_local_supported_features_);
1637
1638 std::format_to(out, " local_supported_commands: [");
1639 for (size_t i = 0; i < local_supported_commands_.size(); i++) {
1640 if ((i % 8) == 0) {
1641 std::format_to(out, "\n ");
1642 }
1643 std::format_to(out, " 0x{:02x},", local_supported_commands_[i]);
1644 }
1645 std::format_to(out, "\n ]\n");
1646
1647 std::format_to(
1648 out,
1649 " vendor_capabilities:\n"
1650 " is_supported: {}\n"
1651 " max_adv_instances: {}\n"
1652 " offloaded_resolution_of_private_addresses: {}\n"
1653 " total_scan_result_storage: {}\n"
1654 " max_irk_list_size: {}\n"
1655 " filtering_support: {}\n"
1656 " max_filter: {}\n"
1657 " activity_energy_info_support: {}\n"
1658 " version_supported: {}\n"
1659 " total_num_of_advt_tracked: {}\n"
1660 " extended_scan_support: {}\n"
1661 " debug_logging_supported: {}\n"
1662 " le_address_generation_offloading_support: {}\n"
1663 " a2dp_source_offload_capability_mask: {}\n"
1664 " bluetooth_quality_report_support: {}\n"
1665 " dynamic_audio_buffer_support: {}\n"
1666 " a2dp_offload_v2_support: {}\n",
1667 vendor_capabilities_.is_supported_, vendor_capabilities_.max_advt_instances_,
1668 vendor_capabilities_.offloaded_resolution_of_private_address_,
1669 vendor_capabilities_.total_scan_results_storage_, vendor_capabilities_.max_irk_list_sz_,
1670 vendor_capabilities_.filtering_support_, vendor_capabilities_.max_filter_,
1671 vendor_capabilities_.activity_energy_info_support_,
1672 vendor_capabilities_.version_supported_, vendor_capabilities_.total_num_of_advt_tracked_,
1673 vendor_capabilities_.extended_scan_support_,
1674 vendor_capabilities_.debug_logging_supported_,
1675 vendor_capabilities_.le_address_generation_offloading_support_,
1676 vendor_capabilities_.a2dp_source_offload_capability_mask_,
1677 vendor_capabilities_.bluetooth_quality_report_support_,
1678 vendor_capabilities_.dynamic_audio_buffer_support_,
1679 vendor_capabilities_.a2dp_offload_v2_support_);
1680 }
1681
Dump(int fd) const1682 void Controller::Dump(int fd) const {
1683 std::string out;
1684 impl_->dump(std::back_inserter(out));
1685 dprintf(fd, "%s", out.c_str());
1686 }
1687
1688 } // namespace hci
1689 } // namespace bluetooth
1690