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