1 /*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "hci/controller.h"
18
19 #include <future>
20 #include <memory>
21 #include <string>
22 #include <utility>
23
24 #include "common/init_flags.h"
25 #include "hci/hci_layer.h"
26 #include "hci_controller_generated.h"
27 #include "os/metrics.h"
28
29 namespace bluetooth {
30 namespace hci {
31
32 using os::Handler;
33
34 struct Controller::impl {
implbluetooth::hci::Controller::impl35 impl(Controller& module) : module_(module) {}
36
Startbluetooth::hci::Controller::impl37 void Start(hci::HciLayer* hci) {
38 hci_ = hci;
39 Handler* handler = module_.GetHandler();
40 hci_->RegisterEventHandler(
41 EventCode::NUMBER_OF_COMPLETED_PACKETS, handler->BindOn(this, &Controller::impl::NumberOfCompletedPackets));
42
43 le_set_event_mask(kDefaultLeEventMask);
44 set_event_mask(kDefaultEventMask);
45 write_le_host_support(Enable::ENABLED, Enable::DISABLED);
46 hci_->EnqueueCommand(ReadLocalNameBuilder::Create(),
47 handler->BindOnceOn(this, &Controller::impl::read_local_name_complete_handler));
48 hci_->EnqueueCommand(ReadLocalVersionInformationBuilder::Create(),
49 handler->BindOnceOn(this, &Controller::impl::read_local_version_information_complete_handler));
50 hci_->EnqueueCommand(ReadLocalSupportedCommandsBuilder::Create(),
51 handler->BindOnceOn(this, &Controller::impl::read_local_supported_commands_complete_handler));
52
53 hci_->EnqueueCommand(
54 LeReadLocalSupportedFeaturesBuilder::Create(),
55 handler->BindOnceOn(this, &Controller::impl::le_read_local_supported_features_handler));
56
57 hci_->EnqueueCommand(
58 LeReadSupportedStatesBuilder::Create(),
59 handler->BindOnceOn(this, &Controller::impl::le_read_supported_states_handler));
60
61 // Wait for all extended features read
62 std::promise<void> features_promise;
63 auto features_future = features_promise.get_future();
64 hci_->EnqueueCommand(ReadLocalExtendedFeaturesBuilder::Create(0x00),
65 handler->BindOnceOn(this, &Controller::impl::read_local_extended_features_complete_handler,
66 std::move(features_promise)));
67 features_future.wait();
68
69 hci_->EnqueueCommand(ReadBufferSizeBuilder::Create(),
70 handler->BindOnceOn(this, &Controller::impl::read_buffer_size_complete_handler));
71
72 if (is_supported(OpCode::LE_READ_BUFFER_SIZE_V2)) {
73 hci_->EnqueueCommand(
74 LeReadBufferSizeV2Builder::Create(),
75 handler->BindOnceOn(this, &Controller::impl::le_read_buffer_size_v2_handler));
76 } else {
77 hci_->EnqueueCommand(
78 LeReadBufferSizeV1Builder::Create(),
79 handler->BindOnceOn(this, &Controller::impl::le_read_buffer_size_handler));
80 }
81
82 hci_->EnqueueCommand(
83 LeReadFilterAcceptListSizeBuilder::Create(),
84 handler->BindOnceOn(this, &Controller::impl::le_read_connect_list_size_handler));
85
86 if (is_supported(OpCode::LE_READ_RESOLVING_LIST_SIZE) && module_.SupportsBlePrivacy()) {
87 hci_->EnqueueCommand(
88 LeReadResolvingListSizeBuilder::Create(),
89 handler->BindOnceOn(this, &Controller::impl::le_read_resolving_list_size_handler));
90 } else {
91 LOG_INFO("LE_READ_RESOLVING_LIST_SIZE not supported, defaulting to 0");
92 le_resolving_list_size_ = 0;
93 }
94
95 if (is_supported(OpCode::LE_READ_MAXIMUM_DATA_LENGTH) && module_.SupportsBleDataPacketLengthExtension()) {
96 hci_->EnqueueCommand(LeReadMaximumDataLengthBuilder::Create(),
97 handler->BindOnceOn(this, &Controller::impl::le_read_maximum_data_length_handler));
98 } else {
99 LOG_INFO("LE_READ_MAXIMUM_DATA_LENGTH not supported, defaulting to 0");
100 le_maximum_data_length_.supported_max_rx_octets_ = 0;
101 le_maximum_data_length_.supported_max_rx_time_ = 0;
102 le_maximum_data_length_.supported_max_tx_octets_ = 0;
103 le_maximum_data_length_.supported_max_tx_time_ = 0;
104 }
105
106 // SSP is managed by security layer once enabled
107 if (!common::init_flags::gd_security_is_enabled()) {
108 write_simple_pairing_mode(Enable::ENABLED);
109 if (module_.SupportsSecureConnections()) {
110 hci_->EnqueueCommand(
111 WriteSecureConnectionsHostSupportBuilder::Create(Enable::ENABLED),
112 handler->BindOnceOn(this, &Controller::impl::write_secure_connections_host_support_complete_handler));
113 }
114 }
115 if (is_supported(OpCode::LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH) && module_.SupportsBleDataPacketLengthExtension()) {
116 hci_->EnqueueCommand(
117 LeReadSuggestedDefaultDataLengthBuilder::Create(),
118 handler->BindOnceOn(this, &Controller::impl::le_read_suggested_default_data_length_handler));
119 } else {
120 LOG_INFO("LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH not supported, defaulting to 27 (0x1B)");
121 le_suggested_default_data_length_ = 27;
122 }
123
124 if (is_supported(OpCode::LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH) && module_.SupportsBleExtendedAdvertising()) {
125 hci_->EnqueueCommand(
126 LeReadMaximumAdvertisingDataLengthBuilder::Create(),
127 handler->BindOnceOn(this, &Controller::impl::le_read_maximum_advertising_data_length_handler));
128 } else {
129 LOG_INFO("LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH not supported, defaulting to 31 (0x1F)");
130 le_maximum_advertising_data_length_ = 31;
131 }
132
133 if (is_supported(OpCode::LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS) &&
134 module_.SupportsBleExtendedAdvertising()) {
135 hci_->EnqueueCommand(
136 LeReadNumberOfSupportedAdvertisingSetsBuilder::Create(),
137 handler->BindOnceOn(this, &Controller::impl::le_read_number_of_supported_advertising_sets_handler));
138 } else {
139 LOG_INFO("LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS not supported, defaulting to 1");
140 le_number_supported_advertising_sets_ = 1;
141 }
142
143 if (is_supported(OpCode::LE_READ_PERIODIC_ADVERTISING_LIST_SIZE) && module_.SupportsBlePeriodicAdvertising()) {
144 hci_->EnqueueCommand(
145 LeReadPeriodicAdvertiserListSizeBuilder::Create(),
146 handler->BindOnceOn(this, &Controller::impl::le_read_periodic_advertiser_list_size_handler));
147 } else {
148 LOG_INFO("LE_READ_PERIODIC_ADVERTISING_LIST_SIZE not supported, defaulting to 0");
149 le_periodic_advertiser_list_size_ = 0;
150 }
151 if (is_supported(OpCode::LE_SET_HOST_FEATURE) && module_.SupportsBleConnectedIsochronousStreamCentral()) {
152 hci_->EnqueueCommand(
153 LeSetHostFeatureBuilder::Create(LeHostFeatureBits::CONNECTED_ISO_STREAM_HOST_SUPPORT, Enable::ENABLED),
154 handler->BindOnceOn(this, &Controller::impl::le_set_host_feature_handler));
155 }
156
157 hci_->EnqueueCommand(LeGetVendorCapabilitiesBuilder::Create(),
158 handler->BindOnceOn(this, &Controller::impl::le_get_vendor_capabilities_handler));
159
160 // We only need to synchronize the last read. Make BD_ADDR to be the last one.
161 std::promise<void> promise;
162 auto future = promise.get_future();
163 hci_->EnqueueCommand(
164 ReadBdAddrBuilder::Create(),
165 handler->BindOnceOn(this, &Controller::impl::read_controller_mac_address_handler, std::move(promise)));
166 future.wait();
167 }
168
Stopbluetooth::hci::Controller::impl169 void Stop() {
170 if (bluetooth::common::init_flags::gd_core_is_enabled()) {
171 hci_->UnregisterEventHandler(EventCode::NUMBER_OF_COMPLETED_PACKETS);
172 }
173 hci_ = nullptr;
174 }
175
NumberOfCompletedPacketsbluetooth::hci::Controller::impl176 void NumberOfCompletedPackets(EventView event) {
177 if (acl_credits_callback_.IsEmpty()) {
178 LOG_WARN("Received event when AclManager is not listening");
179 return;
180 }
181 auto complete_view = NumberOfCompletedPacketsView::Create(event);
182 ASSERT(complete_view.IsValid());
183 for (auto completed_packets : complete_view.GetCompletedPackets()) {
184 uint16_t handle = completed_packets.connection_handle_;
185 uint16_t credits = completed_packets.host_num_of_completed_packets_;
186 acl_credits_callback_.Invoke(handle, credits);
187 if (!acl_monitor_credits_callback_.IsEmpty()) {
188 acl_monitor_credits_callback_.Invoke(handle, credits);
189 }
190 }
191 }
192
register_completed_acl_packets_callbackbluetooth::hci::Controller::impl193 void register_completed_acl_packets_callback(CompletedAclPacketsCallback callback) {
194 ASSERT(acl_credits_callback_.IsEmpty());
195 acl_credits_callback_ = callback;
196 }
197
unregister_completed_acl_packets_callbackbluetooth::hci::Controller::impl198 void unregister_completed_acl_packets_callback() {
199 ASSERT(!acl_credits_callback_.IsEmpty());
200 acl_credits_callback_ = {};
201 }
202
register_completed_monitor_acl_packets_callbackbluetooth::hci::Controller::impl203 void register_completed_monitor_acl_packets_callback(CompletedAclPacketsCallback callback) {
204 ASSERT(acl_monitor_credits_callback_.IsEmpty());
205 acl_monitor_credits_callback_ = callback;
206 }
207
unregister_completed_monitor_acl_packets_callbackbluetooth::hci::Controller::impl208 void unregister_completed_monitor_acl_packets_callback() {
209 ASSERT(!acl_monitor_credits_callback_.IsEmpty());
210 acl_monitor_credits_callback_ = {};
211 }
212
register_monitor_completed_acl_packets_callbackbluetooth::hci::Controller::impl213 void register_monitor_completed_acl_packets_callback(CompletedAclPacketsCallback callback) {
214 ASSERT(acl_monitor_credits_callback_.IsEmpty());
215 acl_monitor_credits_callback_ = callback;
216 }
217
unregister_monitor_completed_acl_packets_callbackbluetooth::hci::Controller::impl218 void unregister_monitor_completed_acl_packets_callback() {
219 ASSERT(!acl_monitor_credits_callback_.IsEmpty());
220 acl_monitor_credits_callback_ = {};
221 }
222
write_secure_connections_host_support_complete_handlerbluetooth::hci::Controller::impl223 void write_secure_connections_host_support_complete_handler(CommandCompleteView view) {
224 auto complete_view = WriteSecureConnectionsHostSupportCompleteView::Create(view);
225 ASSERT(complete_view.IsValid());
226 ErrorCode status = complete_view.GetStatus();
227 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
228 }
229
read_local_name_complete_handlerbluetooth::hci::Controller::impl230 void read_local_name_complete_handler(CommandCompleteView view) {
231 auto complete_view = ReadLocalNameCompleteView::Create(view);
232 ASSERT(complete_view.IsValid());
233 ErrorCode status = complete_view.GetStatus();
234 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
235 std::array<uint8_t, 248> local_name_array = complete_view.GetLocalName();
236
237 local_name_ = std::string(local_name_array.begin(), local_name_array.end());
238 // erase \0
239 local_name_.erase(std::find(local_name_.begin(), local_name_.end(), '\0'), local_name_.end());
240 }
241
read_local_version_information_complete_handlerbluetooth::hci::Controller::impl242 void read_local_version_information_complete_handler(CommandCompleteView view) {
243 auto complete_view = ReadLocalVersionInformationCompleteView::Create(view);
244 ASSERT(complete_view.IsValid());
245 ErrorCode status = complete_view.GetStatus();
246 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
247
248 local_version_information_ = complete_view.GetLocalVersionInformation();
249 bluetooth::os::LogMetricBluetoothLocalVersions(
250 local_version_information_.manufacturer_name_,
251 static_cast<uint8_t>(local_version_information_.lmp_version_),
252 local_version_information_.lmp_subversion_,
253 static_cast<uint8_t>(local_version_information_.hci_version_),
254 local_version_information_.hci_revision_);
255 }
256
read_local_supported_commands_complete_handlerbluetooth::hci::Controller::impl257 void read_local_supported_commands_complete_handler(CommandCompleteView view) {
258 auto complete_view = ReadLocalSupportedCommandsCompleteView::Create(view);
259 ASSERT(complete_view.IsValid());
260 ErrorCode status = complete_view.GetStatus();
261 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
262 local_supported_commands_ = complete_view.GetSupportedCommands();
263 }
264
read_local_extended_features_complete_handlerbluetooth::hci::Controller::impl265 void read_local_extended_features_complete_handler(std::promise<void> promise, CommandCompleteView view) {
266 auto complete_view = ReadLocalExtendedFeaturesCompleteView::Create(view);
267 ASSERT(complete_view.IsValid());
268 ErrorCode status = complete_view.GetStatus();
269 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
270 uint8_t page_number = complete_view.GetPageNumber();
271 extended_lmp_features_array_.push_back(complete_view.GetExtendedLmpFeatures());
272 bluetooth::os::LogMetricBluetoothLocalSupportedFeatures(page_number, complete_view.GetExtendedLmpFeatures());
273 // Query all extended features
274 if (page_number < complete_view.GetMaximumPageNumber()) {
275 page_number++;
276 hci_->EnqueueCommand(
277 ReadLocalExtendedFeaturesBuilder::Create(page_number),
278 module_.GetHandler()->BindOnceOn(this, &Controller::impl::read_local_extended_features_complete_handler,
279 std::move(promise)));
280 } else {
281 promise.set_value();
282 }
283 }
284
read_buffer_size_complete_handlerbluetooth::hci::Controller::impl285 void read_buffer_size_complete_handler(CommandCompleteView view) {
286 auto complete_view = ReadBufferSizeCompleteView::Create(view);
287 ASSERT(complete_view.IsValid());
288 ErrorCode status = complete_view.GetStatus();
289 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
290 acl_buffer_length_ = complete_view.GetAclDataPacketLength();
291 acl_buffers_ = complete_view.GetTotalNumAclDataPackets();
292
293 sco_buffer_length_ = complete_view.GetSynchronousDataPacketLength();
294 sco_buffers_ = complete_view.GetTotalNumSynchronousDataPackets();
295 }
296
read_controller_mac_address_handlerbluetooth::hci::Controller::impl297 void read_controller_mac_address_handler(std::promise<void> promise, CommandCompleteView view) {
298 auto complete_view = ReadBdAddrCompleteView::Create(view);
299 ASSERT(complete_view.IsValid());
300 ErrorCode status = complete_view.GetStatus();
301 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
302 mac_address_ = complete_view.GetBdAddr();
303 promise.set_value();
304 }
305
le_read_buffer_size_handlerbluetooth::hci::Controller::impl306 void le_read_buffer_size_handler(CommandCompleteView view) {
307 auto complete_view = LeReadBufferSizeV1CompleteView::Create(view);
308 ASSERT(complete_view.IsValid());
309 ErrorCode status = complete_view.GetStatus();
310 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
311 le_buffer_size_ = complete_view.GetLeBufferSize();
312
313 // If LE buffer size is zero, then buffers returned by Read_Buffer_Size are shared between BR/EDR and LE.
314 if (le_buffer_size_.total_num_le_packets_ == 0) {
315 ASSERT(acl_buffers_ != 0);
316 le_buffer_size_.total_num_le_packets_ = acl_buffers_ / 2;
317 acl_buffers_ -= le_buffer_size_.total_num_le_packets_;
318 le_buffer_size_.le_data_packet_length_ = acl_buffer_length_;
319 }
320 }
321
le_read_buffer_size_v2_handlerbluetooth::hci::Controller::impl322 void le_read_buffer_size_v2_handler(CommandCompleteView view) {
323 auto complete_view = LeReadBufferSizeV2CompleteView::Create(view);
324 ASSERT(complete_view.IsValid());
325 ErrorCode status = complete_view.GetStatus();
326 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
327 le_buffer_size_ = complete_view.GetLeBufferSize();
328 iso_buffer_size_ = complete_view.GetIsoBufferSize();
329
330 // If LE buffer size is zero, then buffers returned by Read_Buffer_Size are shared between BR/EDR and LE.
331 if (le_buffer_size_.total_num_le_packets_ == 0) {
332 ASSERT(acl_buffers_ != 0);
333 le_buffer_size_.total_num_le_packets_ = acl_buffers_ / 2;
334 acl_buffers_ -= le_buffer_size_.total_num_le_packets_;
335 le_buffer_size_.le_data_packet_length_ = acl_buffer_length_;
336 }
337 }
338
le_set_host_feature_handlerbluetooth::hci::Controller::impl339 void le_set_host_feature_handler(CommandCompleteView view) {
340 auto complete_view = LeSetHostFeatureCompleteView::Create(view);
341 ASSERT(complete_view.IsValid());
342 ErrorCode status = complete_view.GetStatus();
343 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
344 }
345
le_read_local_supported_features_handlerbluetooth::hci::Controller::impl346 void le_read_local_supported_features_handler(CommandCompleteView view) {
347 auto complete_view = LeReadLocalSupportedFeaturesCompleteView::Create(view);
348 ASSERT(complete_view.IsValid());
349 ErrorCode status = complete_view.GetStatus();
350 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
351 le_local_supported_features_ = complete_view.GetLeFeatures();
352 }
353
le_read_supported_states_handlerbluetooth::hci::Controller::impl354 void le_read_supported_states_handler(CommandCompleteView view) {
355 auto complete_view = LeReadSupportedStatesCompleteView::Create(view);
356 ASSERT(complete_view.IsValid());
357 ErrorCode status = complete_view.GetStatus();
358 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
359 le_supported_states_ = complete_view.GetLeStates();
360 }
361
le_read_connect_list_size_handlerbluetooth::hci::Controller::impl362 void le_read_connect_list_size_handler(CommandCompleteView view) {
363 auto complete_view = LeReadFilterAcceptListSizeCompleteView::Create(view);
364 ASSERT(complete_view.IsValid());
365 ErrorCode status = complete_view.GetStatus();
366 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
367 le_connect_list_size_ = complete_view.GetFilterAcceptListSize();
368 }
369
le_read_resolving_list_size_handlerbluetooth::hci::Controller::impl370 void le_read_resolving_list_size_handler(CommandCompleteView view) {
371 auto complete_view = LeReadResolvingListSizeCompleteView::Create(view);
372 ASSERT(complete_view.IsValid());
373 ErrorCode status = complete_view.GetStatus();
374 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
375 le_resolving_list_size_ = complete_view.GetResolvingListSize();
376 }
377
le_read_maximum_data_length_handlerbluetooth::hci::Controller::impl378 void le_read_maximum_data_length_handler(CommandCompleteView view) {
379 auto complete_view = LeReadMaximumDataLengthCompleteView::Create(view);
380 ASSERT(complete_view.IsValid());
381 ErrorCode status = complete_view.GetStatus();
382 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
383 le_maximum_data_length_ = complete_view.GetLeMaximumDataLength();
384 }
385
le_read_suggested_default_data_length_handlerbluetooth::hci::Controller::impl386 void le_read_suggested_default_data_length_handler(CommandCompleteView view) {
387 auto complete_view = LeReadSuggestedDefaultDataLengthCompleteView::Create(view);
388 ASSERT(complete_view.IsValid());
389 ErrorCode status = complete_view.GetStatus();
390 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
391 le_suggested_default_data_length_ = complete_view.GetTxOctets();
392 }
393
le_read_maximum_advertising_data_length_handlerbluetooth::hci::Controller::impl394 void le_read_maximum_advertising_data_length_handler(CommandCompleteView view) {
395 auto complete_view = LeReadMaximumAdvertisingDataLengthCompleteView::Create(view);
396 ASSERT(complete_view.IsValid());
397 ErrorCode status = complete_view.GetStatus();
398 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
399 le_maximum_advertising_data_length_ = complete_view.GetMaximumAdvertisingDataLength();
400 }
401
le_read_number_of_supported_advertising_sets_handlerbluetooth::hci::Controller::impl402 void le_read_number_of_supported_advertising_sets_handler(CommandCompleteView view) {
403 auto complete_view = LeReadNumberOfSupportedAdvertisingSetsCompleteView::Create(view);
404 ASSERT(complete_view.IsValid());
405 ErrorCode status = complete_view.GetStatus();
406 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
407 le_number_supported_advertising_sets_ = complete_view.GetNumberSupportedAdvertisingSets();
408 }
409
le_read_periodic_advertiser_list_size_handlerbluetooth::hci::Controller::impl410 void le_read_periodic_advertiser_list_size_handler(CommandCompleteView view) {
411 auto complete_view = LeReadPeriodicAdvertiserListSizeCompleteView::Create(view);
412 ASSERT(complete_view.IsValid());
413 ErrorCode status = complete_view.GetStatus();
414 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
415 le_periodic_advertiser_list_size_ = complete_view.GetPeriodicAdvertiserListSize();
416 }
417
le_get_vendor_capabilities_handlerbluetooth::hci::Controller::impl418 void le_get_vendor_capabilities_handler(CommandCompleteView view) {
419 auto complete_view = LeGetVendorCapabilitiesCompleteView::Create(view);
420
421 vendor_capabilities_.is_supported_ = 0x00;
422 vendor_capabilities_.max_advt_instances_ = 0x00;
423 vendor_capabilities_.offloaded_resolution_of_private_address_ = 0x00;
424 vendor_capabilities_.total_scan_results_storage_ = 0x00;
425 vendor_capabilities_.max_irk_list_sz_ = 0x00;
426 vendor_capabilities_.filtering_support_ = 0x00;
427 vendor_capabilities_.max_filter_ = 0x00;
428 vendor_capabilities_.activity_energy_info_support_ = 0x00;
429 vendor_capabilities_.version_supported_ = 0x00;
430 vendor_capabilities_.version_supported_ = 0x00;
431 vendor_capabilities_.total_num_of_advt_tracked_ = 0x00;
432 vendor_capabilities_.extended_scan_support_ = 0x00;
433 vendor_capabilities_.debug_logging_supported_ = 0x00;
434 vendor_capabilities_.le_address_generation_offloading_support_ = 0x00;
435 vendor_capabilities_.a2dp_source_offload_capability_mask_ = 0x00;
436 vendor_capabilities_.bluetooth_quality_report_support_ = 0x00;
437
438 if (complete_view.IsValid()) {
439 vendor_capabilities_.is_supported_ = 0x01;
440
441 // v0.55
442 BaseVendorCapabilities base_vendor_capabilities = complete_view.GetBaseVendorCapabilities();
443 vendor_capabilities_.max_advt_instances_ = base_vendor_capabilities.max_advt_instances_;
444 vendor_capabilities_.offloaded_resolution_of_private_address_ =
445 base_vendor_capabilities.offloaded_resolution_of_private_address_;
446 vendor_capabilities_.total_scan_results_storage_ = base_vendor_capabilities.total_scan_results_storage_;
447 vendor_capabilities_.max_irk_list_sz_ = base_vendor_capabilities.max_irk_list_sz_;
448 vendor_capabilities_.filtering_support_ = base_vendor_capabilities.filtering_support_;
449 vendor_capabilities_.max_filter_ = base_vendor_capabilities.max_filter_;
450 vendor_capabilities_.activity_energy_info_support_ = base_vendor_capabilities.activity_energy_info_support_;
451 if (complete_view.GetPayload().size() == 0) {
452 vendor_capabilities_.version_supported_ = 55;
453 return;
454 }
455
456 // v0.95
457 auto v95 = LeGetVendorCapabilitiesComplete095View::Create(complete_view);
458 if (!v95.IsValid()) {
459 LOG_ERROR("invalid data for hci requirements v0.95");
460 return;
461 }
462 vendor_capabilities_.version_supported_ = v95.GetVersionSupported();
463 vendor_capabilities_.total_num_of_advt_tracked_ = v95.GetTotalNumOfAdvtTracked();
464 vendor_capabilities_.extended_scan_support_ = v95.GetExtendedScanSupport();
465 vendor_capabilities_.debug_logging_supported_ = v95.GetDebugLoggingSupported();
466 if (vendor_capabilities_.version_supported_ <= 95 || complete_view.GetPayload().size() == 0) {
467 return;
468 }
469
470 // v0.96
471 auto v96 = LeGetVendorCapabilitiesComplete096View::Create(v95);
472 if (!v96.IsValid()) {
473 LOG_ERROR("invalid data for hci requirements v0.96");
474 return;
475 }
476 vendor_capabilities_.le_address_generation_offloading_support_ = v96.GetLeAddressGenerationOffloadingSupport();
477 if (vendor_capabilities_.version_supported_ <= 96 || complete_view.GetPayload().size() == 0) {
478 return;
479 }
480
481 // v0.98
482 auto v98 = LeGetVendorCapabilitiesComplete098View::Create(v96);
483 if (!v98.IsValid()) {
484 LOG_ERROR("invalid data for hci requirements v0.98");
485 return;
486 }
487 vendor_capabilities_.a2dp_source_offload_capability_mask_ = v98.GetA2dpSourceOffloadCapabilityMask();
488 vendor_capabilities_.bluetooth_quality_report_support_ = v98.GetBluetoothQualityReportSupport();
489 }
490 }
491
set_event_maskbluetooth::hci::Controller::impl492 void set_event_mask(uint64_t event_mask) {
493 std::unique_ptr<SetEventMaskBuilder> packet = SetEventMaskBuilder::Create(event_mask);
494 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
495 this, &Controller::impl::check_status<SetEventMaskCompleteView>));
496 }
497
write_le_host_supportbluetooth::hci::Controller::impl498 void write_le_host_support(Enable enable, Enable deprecated_host_bit) {
499 if (deprecated_host_bit == Enable::ENABLED) {
500 // Since Bluetooth Core Spec 4.1, this bit should be 0
501 LOG_WARN("Setting deprecated Simultaneous LE BR/EDR Host bit");
502 }
503 std::unique_ptr<WriteLeHostSupportBuilder> packet = WriteLeHostSupportBuilder::Create(enable, deprecated_host_bit);
504 hci_->EnqueueCommand(
505 std::move(packet),
506 module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<WriteLeHostSupportCompleteView>));
507 }
508
write_simple_pairing_modebluetooth::hci::Controller::impl509 void write_simple_pairing_mode(Enable enable) {
510 std::unique_ptr<WriteSimplePairingModeBuilder> packet = WriteSimplePairingModeBuilder::Create(enable);
511 hci_->EnqueueCommand(
512 std::move(packet),
513 module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<WriteSimplePairingModeCompleteView>));
514 }
515
resetbluetooth::hci::Controller::impl516 void reset() {
517 std::unique_ptr<ResetBuilder> packet = ResetBuilder::Create();
518 hci_->EnqueueCommand(std::move(packet),
519 module_.GetHandler()->BindOnceOn(this, &Controller::impl::check_status<ResetCompleteView>));
520 }
521
set_event_filterbluetooth::hci::Controller::impl522 void set_event_filter(std::unique_ptr<SetEventFilterBuilder> packet) {
523 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
524 this, &Controller::impl::check_status<SetEventFilterCompleteView>));
525 }
526
write_local_namebluetooth::hci::Controller::impl527 void write_local_name(std::string local_name) {
528 ASSERT(local_name.length() <= 248);
529 // Fill remaining char with 0
530 local_name.append(std::string(248 - local_name.length(), '\0'));
531 std::array<uint8_t, 248> local_name_array;
532 std::copy(std::begin(local_name), std::end(local_name), std::begin(local_name_array));
533
534 std::unique_ptr<WriteLocalNameBuilder> packet = WriteLocalNameBuilder::Create(local_name_array);
535 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
536 this, &Controller::impl::check_status<WriteLocalNameCompleteView>));
537 }
538
host_buffer_sizebluetooth::hci::Controller::impl539 void host_buffer_size(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
540 uint16_t host_total_num_acl_data_packets, uint16_t host_total_num_synchronous_data_packets) {
541 std::unique_ptr<HostBufferSizeBuilder> packet =
542 HostBufferSizeBuilder::Create(host_acl_data_packet_length, host_synchronous_data_packet_length,
543 host_total_num_acl_data_packets, host_total_num_synchronous_data_packets);
544 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
545 this, &Controller::impl::check_status<HostBufferSizeCompleteView>));
546 }
547
le_set_event_maskbluetooth::hci::Controller::impl548 void le_set_event_mask(uint64_t le_event_mask) {
549 std::unique_ptr<LeSetEventMaskBuilder> packet = LeSetEventMaskBuilder::Create(le_event_mask);
550 hci_->EnqueueCommand(std::move(packet), module_.GetHandler()->BindOnceOn(
551 this, &Controller::impl::check_status<LeSetEventMaskCompleteView>));
552 }
553
554 template <class T>
check_statusbluetooth::hci::Controller::impl555 void check_status(CommandCompleteView view) {
556 ASSERT(view.IsValid());
557 auto status_view = T::Create(view);
558 ASSERT(status_view.IsValid());
559 ASSERT(status_view.GetStatus() == ErrorCode::SUCCESS);
560 }
561
562 #define OP_CODE_MAPPING(name) \
563 case OpCode::name: { \
564 uint16_t index = (uint16_t)OpCodeIndex::name; \
565 uint16_t byte_index = index / 10; \
566 uint16_t bit_index = index % 10; \
567 bool supported = local_supported_commands_[byte_index] & (1 << bit_index); \
568 if (!supported) { \
569 LOG_DEBUG("unsupported command opcode: 0x%04x", (uint16_t)OpCode::name); \
570 } \
571 return supported; \
572 }
573
574 void Dump(
575 std::promise<flatbuffers::Offset<ControllerData>> promise, flatbuffers::FlatBufferBuilder* fb_builder) const;
576
is_supportedbluetooth::hci::Controller::impl577 bool is_supported(OpCode op_code) {
578 switch (op_code) {
579 OP_CODE_MAPPING(INQUIRY)
580 OP_CODE_MAPPING(INQUIRY_CANCEL)
581 OP_CODE_MAPPING(PERIODIC_INQUIRY_MODE)
582 OP_CODE_MAPPING(EXIT_PERIODIC_INQUIRY_MODE)
583 OP_CODE_MAPPING(CREATE_CONNECTION)
584 OP_CODE_MAPPING(DISCONNECT)
585 OP_CODE_MAPPING(CREATE_CONNECTION_CANCEL)
586 OP_CODE_MAPPING(ACCEPT_CONNECTION_REQUEST)
587 OP_CODE_MAPPING(REJECT_CONNECTION_REQUEST)
588 OP_CODE_MAPPING(LINK_KEY_REQUEST_REPLY)
589 OP_CODE_MAPPING(LINK_KEY_REQUEST_NEGATIVE_REPLY)
590 OP_CODE_MAPPING(PIN_CODE_REQUEST_REPLY)
591 OP_CODE_MAPPING(PIN_CODE_REQUEST_NEGATIVE_REPLY)
592 OP_CODE_MAPPING(CHANGE_CONNECTION_PACKET_TYPE)
593 OP_CODE_MAPPING(AUTHENTICATION_REQUESTED)
594 OP_CODE_MAPPING(SET_CONNECTION_ENCRYPTION)
595 OP_CODE_MAPPING(CHANGE_CONNECTION_LINK_KEY)
596 OP_CODE_MAPPING(CENTRAL_LINK_KEY)
597 OP_CODE_MAPPING(REMOTE_NAME_REQUEST)
598 OP_CODE_MAPPING(REMOTE_NAME_REQUEST_CANCEL)
599 OP_CODE_MAPPING(READ_REMOTE_SUPPORTED_FEATURES)
600 OP_CODE_MAPPING(READ_REMOTE_EXTENDED_FEATURES)
601 OP_CODE_MAPPING(READ_REMOTE_VERSION_INFORMATION)
602 OP_CODE_MAPPING(READ_CLOCK_OFFSET)
603 OP_CODE_MAPPING(READ_LMP_HANDLE)
604 OP_CODE_MAPPING(HOLD_MODE)
605 OP_CODE_MAPPING(SNIFF_MODE)
606 OP_CODE_MAPPING(EXIT_SNIFF_MODE)
607 OP_CODE_MAPPING(QOS_SETUP)
608 OP_CODE_MAPPING(ROLE_DISCOVERY)
609 OP_CODE_MAPPING(SWITCH_ROLE)
610 OP_CODE_MAPPING(READ_LINK_POLICY_SETTINGS)
611 OP_CODE_MAPPING(WRITE_LINK_POLICY_SETTINGS)
612 OP_CODE_MAPPING(READ_DEFAULT_LINK_POLICY_SETTINGS)
613 OP_CODE_MAPPING(WRITE_DEFAULT_LINK_POLICY_SETTINGS)
614 OP_CODE_MAPPING(FLOW_SPECIFICATION)
615 OP_CODE_MAPPING(SET_EVENT_MASK)
616 OP_CODE_MAPPING(RESET)
617 OP_CODE_MAPPING(SET_EVENT_FILTER)
618 OP_CODE_MAPPING(FLUSH)
619 OP_CODE_MAPPING(READ_PIN_TYPE)
620 OP_CODE_MAPPING(WRITE_PIN_TYPE)
621 OP_CODE_MAPPING(READ_STORED_LINK_KEY)
622 OP_CODE_MAPPING(WRITE_STORED_LINK_KEY)
623 OP_CODE_MAPPING(DELETE_STORED_LINK_KEY)
624 OP_CODE_MAPPING(WRITE_LOCAL_NAME)
625 OP_CODE_MAPPING(READ_LOCAL_NAME)
626 OP_CODE_MAPPING(READ_CONNECTION_ACCEPT_TIMEOUT)
627 OP_CODE_MAPPING(WRITE_CONNECTION_ACCEPT_TIMEOUT)
628 OP_CODE_MAPPING(READ_PAGE_TIMEOUT)
629 OP_CODE_MAPPING(WRITE_PAGE_TIMEOUT)
630 OP_CODE_MAPPING(READ_SCAN_ENABLE)
631 OP_CODE_MAPPING(WRITE_SCAN_ENABLE)
632 OP_CODE_MAPPING(READ_PAGE_SCAN_ACTIVITY)
633 OP_CODE_MAPPING(WRITE_PAGE_SCAN_ACTIVITY)
634 OP_CODE_MAPPING(READ_INQUIRY_SCAN_ACTIVITY)
635 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_ACTIVITY)
636 OP_CODE_MAPPING(READ_AUTHENTICATION_ENABLE)
637 OP_CODE_MAPPING(WRITE_AUTHENTICATION_ENABLE)
638 OP_CODE_MAPPING(READ_CLASS_OF_DEVICE)
639 OP_CODE_MAPPING(WRITE_CLASS_OF_DEVICE)
640 OP_CODE_MAPPING(READ_VOICE_SETTING)
641 OP_CODE_MAPPING(WRITE_VOICE_SETTING)
642 OP_CODE_MAPPING(READ_AUTOMATIC_FLUSH_TIMEOUT)
643 OP_CODE_MAPPING(WRITE_AUTOMATIC_FLUSH_TIMEOUT)
644 OP_CODE_MAPPING(READ_NUM_BROADCAST_RETRANSMITS)
645 OP_CODE_MAPPING(WRITE_NUM_BROADCAST_RETRANSMITS)
646 OP_CODE_MAPPING(READ_HOLD_MODE_ACTIVITY)
647 OP_CODE_MAPPING(WRITE_HOLD_MODE_ACTIVITY)
648 OP_CODE_MAPPING(READ_TRANSMIT_POWER_LEVEL)
649 OP_CODE_MAPPING(READ_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
650 OP_CODE_MAPPING(WRITE_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
651 OP_CODE_MAPPING(SET_CONTROLLER_TO_HOST_FLOW_CONTROL)
652 OP_CODE_MAPPING(HOST_BUFFER_SIZE)
653 OP_CODE_MAPPING(HOST_NUM_COMPLETED_PACKETS)
654 OP_CODE_MAPPING(READ_LINK_SUPERVISION_TIMEOUT)
655 OP_CODE_MAPPING(WRITE_LINK_SUPERVISION_TIMEOUT)
656 OP_CODE_MAPPING(READ_NUMBER_OF_SUPPORTED_IAC)
657 OP_CODE_MAPPING(READ_CURRENT_IAC_LAP)
658 OP_CODE_MAPPING(WRITE_CURRENT_IAC_LAP)
659 OP_CODE_MAPPING(SET_AFH_HOST_CHANNEL_CLASSIFICATION)
660 OP_CODE_MAPPING(READ_INQUIRY_SCAN_TYPE)
661 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_TYPE)
662 OP_CODE_MAPPING(READ_INQUIRY_MODE)
663 OP_CODE_MAPPING(WRITE_INQUIRY_MODE)
664 OP_CODE_MAPPING(READ_PAGE_SCAN_TYPE)
665 OP_CODE_MAPPING(WRITE_PAGE_SCAN_TYPE)
666 OP_CODE_MAPPING(READ_AFH_CHANNEL_ASSESSMENT_MODE)
667 OP_CODE_MAPPING(WRITE_AFH_CHANNEL_ASSESSMENT_MODE)
668 OP_CODE_MAPPING(READ_LOCAL_VERSION_INFORMATION)
669 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_FEATURES)
670 OP_CODE_MAPPING(READ_LOCAL_EXTENDED_FEATURES)
671 OP_CODE_MAPPING(READ_BUFFER_SIZE)
672 OP_CODE_MAPPING(READ_BD_ADDR)
673 OP_CODE_MAPPING(READ_FAILED_CONTACT_COUNTER)
674 OP_CODE_MAPPING(RESET_FAILED_CONTACT_COUNTER)
675 OP_CODE_MAPPING(READ_LINK_QUALITY)
676 OP_CODE_MAPPING(READ_RSSI)
677 OP_CODE_MAPPING(READ_AFH_CHANNEL_MAP)
678 OP_CODE_MAPPING(READ_CLOCK)
679 OP_CODE_MAPPING(READ_LOOPBACK_MODE)
680 OP_CODE_MAPPING(WRITE_LOOPBACK_MODE)
681 OP_CODE_MAPPING(ENABLE_DEVICE_UNDER_TEST_MODE)
682 OP_CODE_MAPPING(SETUP_SYNCHRONOUS_CONNECTION)
683 OP_CODE_MAPPING(ACCEPT_SYNCHRONOUS_CONNECTION)
684 OP_CODE_MAPPING(REJECT_SYNCHRONOUS_CONNECTION)
685 OP_CODE_MAPPING(READ_EXTENDED_INQUIRY_RESPONSE)
686 OP_CODE_MAPPING(WRITE_EXTENDED_INQUIRY_RESPONSE)
687 OP_CODE_MAPPING(REFRESH_ENCRYPTION_KEY)
688 OP_CODE_MAPPING(SNIFF_SUBRATING)
689 OP_CODE_MAPPING(READ_SIMPLE_PAIRING_MODE)
690 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_MODE)
691 OP_CODE_MAPPING(READ_LOCAL_OOB_DATA)
692 OP_CODE_MAPPING(READ_INQUIRY_RESPONSE_TRANSMIT_POWER_LEVEL)
693 OP_CODE_MAPPING(WRITE_INQUIRY_TRANSMIT_POWER_LEVEL)
694 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_REPLY)
695 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_REPLY)
696 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_NEGATIVE_REPLY)
697 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_REPLY)
698 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_NEGATIVE_REPLY)
699 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_REPLY)
700 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_DEBUG_MODE)
701 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY)
702 OP_CODE_MAPPING(SEND_KEYPRESS_NOTIFICATION)
703 OP_CODE_MAPPING(SET_EVENT_MASK_PAGE_2)
704 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_NEGATIVE_REPLY)
705 OP_CODE_MAPPING(REMOTE_OOB_EXTENDED_DATA_REQUEST_REPLY)
706 OP_CODE_MAPPING(READ_ENCRYPTION_KEY_SIZE)
707 OP_CODE_MAPPING(READ_DATA_BLOCK_SIZE)
708 OP_CODE_MAPPING(READ_LE_HOST_SUPPORT)
709 OP_CODE_MAPPING(WRITE_LE_HOST_SUPPORT)
710 OP_CODE_MAPPING(LE_SET_EVENT_MASK)
711 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE_V1)
712 OP_CODE_MAPPING(LE_READ_LOCAL_SUPPORTED_FEATURES)
713 OP_CODE_MAPPING(LE_SET_RANDOM_ADDRESS)
714 OP_CODE_MAPPING(LE_SET_ADVERTISING_PARAMETERS)
715 OP_CODE_MAPPING(LE_READ_ADVERTISING_PHYSICAL_CHANNEL_TX_POWER)
716 OP_CODE_MAPPING(LE_SET_ADVERTISING_DATA)
717 OP_CODE_MAPPING(LE_SET_SCAN_RESPONSE_DATA)
718 OP_CODE_MAPPING(LE_SET_ADVERTISING_ENABLE)
719 OP_CODE_MAPPING(LE_SET_SCAN_PARAMETERS)
720 OP_CODE_MAPPING(LE_SET_SCAN_ENABLE)
721 OP_CODE_MAPPING(LE_CREATE_CONNECTION)
722 OP_CODE_MAPPING(LE_CREATE_CONNECTION_CANCEL)
723 OP_CODE_MAPPING(LE_READ_FILTER_ACCEPT_LIST_SIZE)
724 OP_CODE_MAPPING(LE_CLEAR_FILTER_ACCEPT_LIST)
725 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_FILTER_ACCEPT_LIST)
726 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_FILTER_ACCEPT_LIST)
727 OP_CODE_MAPPING(LE_CONNECTION_UPDATE)
728 OP_CODE_MAPPING(LE_SET_HOST_CHANNEL_CLASSIFICATION)
729 OP_CODE_MAPPING(LE_READ_CHANNEL_MAP)
730 OP_CODE_MAPPING(LE_READ_REMOTE_FEATURES)
731 OP_CODE_MAPPING(LE_ENCRYPT)
732 OP_CODE_MAPPING(LE_RAND)
733 OP_CODE_MAPPING(LE_START_ENCRYPTION)
734 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_REPLY)
735 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_NEGATIVE_REPLY)
736 OP_CODE_MAPPING(LE_READ_SUPPORTED_STATES)
737 OP_CODE_MAPPING(LE_RECEIVER_TEST)
738 OP_CODE_MAPPING(LE_TRANSMITTER_TEST)
739 OP_CODE_MAPPING(LE_TEST_END)
740 OP_CODE_MAPPING(ENHANCED_SETUP_SYNCHRONOUS_CONNECTION)
741 OP_CODE_MAPPING(ENHANCED_ACCEPT_SYNCHRONOUS_CONNECTION)
742 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS_V1)
743 OP_CODE_MAPPING(READ_SECURE_CONNECTIONS_HOST_SUPPORT)
744 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_HOST_SUPPORT)
745 OP_CODE_MAPPING(READ_LOCAL_OOB_EXTENDED_DATA)
746 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_TEST_MODE)
747 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_REPLY)
748 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_NEGATIVE_REPLY)
749 OP_CODE_MAPPING(LE_SET_DATA_LENGTH)
750 OP_CODE_MAPPING(LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH)
751 OP_CODE_MAPPING(LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH)
752 OP_CODE_MAPPING(LE_READ_LOCAL_P_256_PUBLIC_KEY_COMMAND)
753 OP_CODE_MAPPING(LE_GENERATE_DHKEY_COMMAND_V1)
754 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_RESOLVING_LIST)
755 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_RESOLVING_LIST)
756 OP_CODE_MAPPING(LE_CLEAR_RESOLVING_LIST)
757 OP_CODE_MAPPING(LE_READ_RESOLVING_LIST_SIZE)
758 OP_CODE_MAPPING(LE_READ_PEER_RESOLVABLE_ADDRESS)
759 OP_CODE_MAPPING(LE_READ_LOCAL_RESOLVABLE_ADDRESS)
760 OP_CODE_MAPPING(LE_SET_ADDRESS_RESOLUTION_ENABLE)
761 OP_CODE_MAPPING(LE_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT)
762 OP_CODE_MAPPING(LE_READ_MAXIMUM_DATA_LENGTH)
763 OP_CODE_MAPPING(LE_READ_PHY)
764 OP_CODE_MAPPING(LE_SET_DEFAULT_PHY)
765 OP_CODE_MAPPING(LE_SET_PHY)
766 OP_CODE_MAPPING(LE_ENHANCED_RECEIVER_TEST)
767 OP_CODE_MAPPING(LE_ENHANCED_TRANSMITTER_TEST)
768 OP_CODE_MAPPING(LE_SET_ADVERTISING_SET_RANDOM_ADDRESS)
769 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_PARAMETERS)
770 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_DATA)
771 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_RESPONSE_DATA)
772 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_ENABLE)
773 OP_CODE_MAPPING(LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH)
774 OP_CODE_MAPPING(LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS)
775 OP_CODE_MAPPING(LE_REMOVE_ADVERTISING_SET)
776 OP_CODE_MAPPING(LE_CLEAR_ADVERTISING_SETS)
777 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_PARAM)
778 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_DATA)
779 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_ENABLE)
780 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_PARAMETERS)
781 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_ENABLE)
782 OP_CODE_MAPPING(LE_EXTENDED_CREATE_CONNECTION)
783 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC)
784 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC_CANCEL)
785 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_TERMINATE_SYNC)
786 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_PERIODIC_ADVERTISING_LIST)
787 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_PERIODIC_ADVERTISING_LIST)
788 OP_CODE_MAPPING(LE_CLEAR_PERIODIC_ADVERTISING_LIST)
789 OP_CODE_MAPPING(LE_READ_PERIODIC_ADVERTISING_LIST_SIZE)
790 OP_CODE_MAPPING(LE_READ_TRANSMIT_POWER)
791 OP_CODE_MAPPING(LE_READ_RF_PATH_COMPENSATION_POWER)
792 OP_CODE_MAPPING(LE_WRITE_RF_PATH_COMPENSATION_POWER)
793 OP_CODE_MAPPING(LE_SET_PRIVACY_MODE)
794 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_RECEIVE_ENABLE)
795 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_SYNC_TRANSFER)
796 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_SET_INFO_TRANSFER)
797 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS)
798 OP_CODE_MAPPING(LE_SET_DEFAULT_PERIODIC_ADVERTISING_SYNC_TRANSFER_PARAMETERS)
799 OP_CODE_MAPPING(LE_GENERATE_DHKEY_COMMAND)
800 OP_CODE_MAPPING(LE_MODIFY_SLEEP_CLOCK_ACCURACY)
801 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE_V2)
802 OP_CODE_MAPPING(LE_READ_ISO_TX_SYNC)
803 OP_CODE_MAPPING(LE_SET_CIG_PARAMETERS)
804 OP_CODE_MAPPING(LE_SET_CIG_PARAMETERS_TEST)
805 OP_CODE_MAPPING(LE_CREATE_CIS)
806 OP_CODE_MAPPING(LE_REMOVE_CIG)
807 OP_CODE_MAPPING(LE_ACCEPT_CIS_REQUEST)
808 OP_CODE_MAPPING(LE_REJECT_CIS_REQUEST)
809 OP_CODE_MAPPING(LE_CREATE_BIG)
810 OP_CODE_MAPPING(LE_TERMINATE_BIG)
811 OP_CODE_MAPPING(LE_BIG_CREATE_SYNC)
812 OP_CODE_MAPPING(LE_BIG_TERMINATE_SYNC)
813 OP_CODE_MAPPING(LE_REQUEST_PEER_SCA)
814 OP_CODE_MAPPING(LE_SETUP_ISO_DATA_PATH)
815 OP_CODE_MAPPING(LE_REMOVE_ISO_DATA_PATH)
816 OP_CODE_MAPPING(LE_SET_HOST_FEATURE)
817 OP_CODE_MAPPING(LE_READ_ISO_LINK_QUALITY)
818 OP_CODE_MAPPING(LE_ENHANCED_READ_TRANSMIT_POWER_LEVEL)
819 OP_CODE_MAPPING(LE_READ_REMOTE_TRANSMIT_POWER_LEVEL)
820 OP_CODE_MAPPING(LE_SET_PATH_LOSS_REPORTING_PARAMETERS)
821 OP_CODE_MAPPING(LE_SET_PATH_LOSS_REPORTING_ENABLE)
822 OP_CODE_MAPPING(LE_SET_TRANSMIT_POWER_REPORTING_ENABLE)
823 OP_CODE_MAPPING(SET_ECOSYSTEM_BASE_INTERVAL)
824 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS_V2)
825 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODEC_CAPABILITIES)
826 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CONTROLLER_DELAY)
827 OP_CODE_MAPPING(CONFIGURE_DATA_PATH)
828 OP_CODE_MAPPING(ENHANCED_FLUSH)
829 OP_CODE_MAPPING(LE_SET_DATA_RELATED_ADDRESS_CHANGES)
830 OP_CODE_MAPPING(LE_SET_DEFAULT_SUBRATE)
831 OP_CODE_MAPPING(LE_SUBRATE_REQUEST)
832 OP_CODE_MAPPING(SET_MIN_ENCRYPTION_KEY_SIZE)
833
834 // deprecated
835 case OpCode::ADD_SCO_CONNECTION:
836 return false;
837
838 // vendor specific
839 case OpCode::LE_GET_VENDOR_CAPABILITIES:
840 return vendor_capabilities_.is_supported_ == 0x01;
841 case OpCode::LE_MULTI_ADVT:
842 return vendor_capabilities_.max_advt_instances_ != 0x00;
843 case OpCode::LE_BATCH_SCAN:
844 return vendor_capabilities_.total_scan_results_storage_ != 0x00;
845 case OpCode::LE_ADV_FILTER:
846 return vendor_capabilities_.filtering_support_ == 0x01;
847 case OpCode::LE_ENERGY_INFO:
848 return vendor_capabilities_.activity_energy_info_support_ == 0x01;
849 case OpCode::LE_EXTENDED_SCAN_PARAMS:
850 return vendor_capabilities_.extended_scan_support_ == 0x01;
851 case OpCode::CONTROLLER_DEBUG_INFO:
852 return vendor_capabilities_.debug_logging_supported_ == 0x01;
853 case OpCode::CONTROLLER_A2DP_OPCODE:
854 return vendor_capabilities_.a2dp_source_offload_capability_mask_ != 0x00;
855 case OpCode::CONTROLLER_BQR:
856 return vendor_capabilities_.bluetooth_quality_report_support_ == 0x01;
857 // undefined in local_supported_commands_
858 case OpCode::READ_LOCAL_SUPPORTED_COMMANDS:
859 return true;
860 case OpCode::NONE:
861 return false;
862 }
863 return false;
864 }
865 #undef OP_CODE_MAPPING
866
867 Controller& module_;
868
869 HciLayer* hci_;
870
871 CompletedAclPacketsCallback acl_credits_callback_{};
872 CompletedAclPacketsCallback acl_monitor_credits_callback_{};
873 LocalVersionInformation local_version_information_{};
874 std::array<uint8_t, 64> local_supported_commands_{};
875 std::vector<uint64_t> extended_lmp_features_array_{};
876 uint16_t acl_buffer_length_{};
877 uint16_t acl_buffers_{};
878 uint8_t sco_buffer_length_{};
879 uint16_t sco_buffers_{};
880 Address mac_address_{};
881 std::string local_name_{};
882 LeBufferSize le_buffer_size_{};
883 LeBufferSize iso_buffer_size_{};
884 uint64_t le_local_supported_features_{};
885 uint64_t le_supported_states_{};
886 uint8_t le_connect_list_size_{};
887 uint8_t le_resolving_list_size_{};
888 LeMaximumDataLength le_maximum_data_length_{};
889 uint16_t le_maximum_advertising_data_length_{};
890 uint16_t le_suggested_default_data_length_{};
891 uint8_t le_number_supported_advertising_sets_{};
892 uint8_t le_periodic_advertiser_list_size_{};
893 VendorCapabilities vendor_capabilities_{};
894 }; // namespace hci
895
Controller()896 Controller::Controller() : impl_(std::make_unique<impl>(*this)) {}
897
898 Controller::~Controller() = default;
899
RegisterCompletedAclPacketsCallback(CompletedAclPacketsCallback cb)900 void Controller::RegisterCompletedAclPacketsCallback(CompletedAclPacketsCallback cb) {
901 CallOn(impl_.get(), &impl::register_completed_acl_packets_callback, cb);
902 }
903
UnregisterCompletedAclPacketsCallback()904 void Controller::UnregisterCompletedAclPacketsCallback() {
905 CallOn(impl_.get(), &impl::unregister_completed_acl_packets_callback);
906 }
907
RegisterCompletedMonitorAclPacketsCallback(CompletedAclPacketsCallback cb)908 void Controller::RegisterCompletedMonitorAclPacketsCallback(CompletedAclPacketsCallback cb) {
909 CallOn(impl_.get(), &impl::register_completed_monitor_acl_packets_callback, cb);
910 }
911
UnregisterCompletedMonitorAclPacketsCallback()912 void Controller::UnregisterCompletedMonitorAclPacketsCallback() {
913 CallOn(impl_.get(), &impl::unregister_completed_monitor_acl_packets_callback);
914 }
915
GetLocalName() const916 std::string Controller::GetLocalName() const {
917 return impl_->local_name_;
918 }
919
GetLocalVersionInformation() const920 LocalVersionInformation Controller::GetLocalVersionInformation() const {
921 return impl_->local_version_information_;
922 }
923
924 #define BIT(x) (0x1ULL << (x))
925
926 #define LOCAL_FEATURE_ACCESSOR(name, page, bit) \
927 bool Controller::name() const { \
928 return GetLocalFeatures(page) & BIT(bit); \
929 }
930
931 LOCAL_FEATURE_ACCESSOR(SupportsSimplePairing, 0, 51)
932 LOCAL_FEATURE_ACCESSOR(SupportsSecureConnections, 2, 8)
933 LOCAL_FEATURE_ACCESSOR(SupportsSimultaneousLeBrEdr, 0, 49)
934 LOCAL_FEATURE_ACCESSOR(SupportsInterlacedInquiryScan, 0, 28)
935 LOCAL_FEATURE_ACCESSOR(SupportsRssiWithInquiryResults, 0, 30)
936 LOCAL_FEATURE_ACCESSOR(SupportsExtendedInquiryResponse, 0, 48)
937 LOCAL_FEATURE_ACCESSOR(SupportsRoleSwitch, 0, 5)
938 LOCAL_FEATURE_ACCESSOR(Supports3SlotPackets, 0, 0)
939 LOCAL_FEATURE_ACCESSOR(Supports5SlotPackets, 0, 1)
940 LOCAL_FEATURE_ACCESSOR(SupportsClassic2mPhy, 0, 25)
941 LOCAL_FEATURE_ACCESSOR(SupportsClassic3mPhy, 0, 26)
942 LOCAL_FEATURE_ACCESSOR(Supports3SlotEdrPackets, 0, 39)
943 LOCAL_FEATURE_ACCESSOR(Supports5SlotEdrPackets, 0, 40)
944 LOCAL_FEATURE_ACCESSOR(SupportsSco, 0, 11)
945 LOCAL_FEATURE_ACCESSOR(SupportsHv2Packets, 0, 12)
946 LOCAL_FEATURE_ACCESSOR(SupportsHv3Packets, 0, 13)
947 LOCAL_FEATURE_ACCESSOR(SupportsEv3Packets, 0, 31)
948 LOCAL_FEATURE_ACCESSOR(SupportsEv4Packets, 0, 32)
949 LOCAL_FEATURE_ACCESSOR(SupportsEv5Packets, 0, 33)
950 LOCAL_FEATURE_ACCESSOR(SupportsEsco2mPhy, 0, 45)
951 LOCAL_FEATURE_ACCESSOR(SupportsEsco3mPhy, 0, 46)
952 LOCAL_FEATURE_ACCESSOR(Supports3SlotEscoEdrPackets, 0, 47)
953 LOCAL_FEATURE_ACCESSOR(SupportsHoldMode, 0, 6)
954 LOCAL_FEATURE_ACCESSOR(SupportsSniffMode, 0, 7)
955 LOCAL_FEATURE_ACCESSOR(SupportsParkMode, 0, 8)
956 LOCAL_FEATURE_ACCESSOR(SupportsNonFlushablePb, 0, 54)
957 LOCAL_FEATURE_ACCESSOR(SupportsSniffSubrating, 0, 41)
958 LOCAL_FEATURE_ACCESSOR(SupportsEncryptionPause, 0, 42)
959 LOCAL_FEATURE_ACCESSOR(SupportsBle, 0, 38)
960
961 #define LOCAL_LE_FEATURE_ACCESSOR(name, bit) \
962 bool Controller::name() const { \
963 return GetLocalLeFeatures() & BIT(bit); \
964 }
965
966 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleEncryption, 0)
967 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionParametersRequest, 1)
968 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedReject, 2)
969 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeripheralInitiatedFeaturesExchange, 3)
970 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePing, 4)
971 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleDataPacketLengthExtension, 5)
972 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePrivacy, 6)
973 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedScannerFilterPolicies, 7)
974 LOCAL_LE_FEATURE_ACCESSOR(SupportsBle2mPhy, 8)
975 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleStableModulationIndexTx, 9)
976 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleStableModulationIndexRx, 10)
977 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleCodedPhy, 11)
978 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleExtendedAdvertising, 12)
979 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertising, 13)
980 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleChannelSelectionAlgorithm2, 14)
981 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerClass1, 15)
982 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleMinimumUsedChannels, 16)
983 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionCteRequest, 17)
984 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionCteResponse, 18)
985 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionlessCteTransmitter, 19)
986 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectionlessCteReceiver, 20)
987 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleAntennaSwitchingDuringCteTx, 21)
988 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleAntennaSwitchingDuringCteRx, 22)
989 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleReceivingConstantToneExtensions, 23)
990 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingSyncTransferSender, 24)
991 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePeriodicAdvertisingSyncTransferRecipient, 25)
992 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleSleepClockAccuracyUpdates, 26)
993 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleRemotePublicKeyValidation, 27)
994 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectedIsochronousStreamCentral, 28)
995 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleConnectedIsochronousStreamPeripheral, 29)
996 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleIsochronousBroadcaster, 30)
997 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleSynchronizedReceiver, 31)
998 LOCAL_LE_FEATURE_ACCESSOR(SupportsBleIsochronousChannelsHostSupport, 32)
999 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerControlRequest, 33)
1000 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePowerChangeIndication, 34)
1001 LOCAL_LE_FEATURE_ACCESSOR(SupportsBlePathLossMonitoring, 35)
1002
GetLocalFeatures(uint8_t page_number) const1003 uint64_t Controller::GetLocalFeatures(uint8_t page_number) const {
1004 if (page_number < impl_->extended_lmp_features_array_.size()) {
1005 return impl_->extended_lmp_features_array_[page_number];
1006 }
1007 return 0x00;
1008 }
1009
GetAclPacketLength() const1010 uint16_t Controller::GetAclPacketLength() const {
1011 return impl_->acl_buffer_length_;
1012 }
1013
GetNumAclPacketBuffers() const1014 uint16_t Controller::GetNumAclPacketBuffers() const {
1015 return impl_->acl_buffers_;
1016 }
1017
GetScoPacketLength() const1018 uint8_t Controller::GetScoPacketLength() const {
1019 return impl_->sco_buffer_length_;
1020 }
1021
GetNumScoPacketBuffers() const1022 uint16_t Controller::GetNumScoPacketBuffers() const {
1023 return impl_->sco_buffers_;
1024 }
1025
GetMacAddress() const1026 Address Controller::GetMacAddress() const {
1027 return impl_->mac_address_;
1028 }
1029
SetEventMask(uint64_t event_mask)1030 void Controller::SetEventMask(uint64_t event_mask) {
1031 CallOn(impl_.get(), &impl::set_event_mask, event_mask);
1032 }
1033
Reset()1034 void Controller::Reset() {
1035 CallOn(impl_.get(), &impl::reset);
1036 }
1037
SetEventFilterClearAll()1038 void Controller::SetEventFilterClearAll() {
1039 std::unique_ptr<SetEventFilterClearAllBuilder> packet = SetEventFilterClearAllBuilder::Create();
1040 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1041 }
1042
SetEventFilterInquiryResultAllDevices()1043 void Controller::SetEventFilterInquiryResultAllDevices() {
1044 std::unique_ptr<SetEventFilterInquiryResultAllDevicesBuilder> packet =
1045 SetEventFilterInquiryResultAllDevicesBuilder::Create();
1046 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1047 }
1048
SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask)1049 void Controller::SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,
1050 ClassOfDevice class_of_device_mask) {
1051 std::unique_ptr<SetEventFilterInquiryResultClassOfDeviceBuilder> packet =
1052 SetEventFilterInquiryResultClassOfDeviceBuilder::Create(class_of_device, class_of_device_mask);
1053 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1054 }
1055
SetEventFilterInquiryResultAddress(Address address)1056 void Controller::SetEventFilterInquiryResultAddress(Address address) {
1057 std::unique_ptr<SetEventFilterInquiryResultAddressBuilder> packet =
1058 SetEventFilterInquiryResultAddressBuilder::Create(address);
1059 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1060 }
1061
SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag)1062 void Controller::SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag) {
1063 std::unique_ptr<SetEventFilterConnectionSetupAllDevicesBuilder> packet =
1064 SetEventFilterConnectionSetupAllDevicesBuilder::Create(auto_accept_flag);
1065 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1066 }
1067
SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask,AutoAcceptFlag auto_accept_flag)1068 void Controller::SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,
1069 ClassOfDevice class_of_device_mask,
1070 AutoAcceptFlag auto_accept_flag) {
1071 std::unique_ptr<SetEventFilterConnectionSetupClassOfDeviceBuilder> packet =
1072 SetEventFilterConnectionSetupClassOfDeviceBuilder::Create(class_of_device, class_of_device_mask,
1073 auto_accept_flag);
1074 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1075 }
1076
SetEventFilterConnectionSetupAddress(Address address,AutoAcceptFlag auto_accept_flag)1077 void Controller::SetEventFilterConnectionSetupAddress(Address address, AutoAcceptFlag auto_accept_flag) {
1078 std::unique_ptr<SetEventFilterConnectionSetupAddressBuilder> packet =
1079 SetEventFilterConnectionSetupAddressBuilder::Create(address, auto_accept_flag);
1080 CallOn(impl_.get(), &impl::set_event_filter, std::move(packet));
1081 }
1082
WriteLocalName(std::string local_name)1083 void Controller::WriteLocalName(std::string local_name) {
1084 impl_->local_name_ = local_name;
1085 CallOn(impl_.get(), &impl::write_local_name, local_name);
1086 }
1087
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)1088 void Controller::HostBufferSize(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
1089 uint16_t host_total_num_acl_data_packets,
1090 uint16_t host_total_num_synchronous_data_packets) {
1091 CallOn(
1092 impl_.get(),
1093 &impl::host_buffer_size,
1094 host_acl_data_packet_length,
1095 host_synchronous_data_packet_length,
1096 host_total_num_acl_data_packets,
1097 host_total_num_synchronous_data_packets);
1098 }
1099
LeSetEventMask(uint64_t le_event_mask)1100 void Controller::LeSetEventMask(uint64_t le_event_mask) {
1101 CallOn(impl_.get(), &impl::le_set_event_mask, le_event_mask);
1102 }
1103
GetLeBufferSize() const1104 LeBufferSize Controller::GetLeBufferSize() const {
1105 return impl_->le_buffer_size_;
1106 }
1107
GetLocalLeFeatures() const1108 uint64_t Controller::GetLocalLeFeatures() const {
1109 return impl_->le_local_supported_features_;
1110 }
1111
GetControllerIsoBufferSize() const1112 LeBufferSize Controller::GetControllerIsoBufferSize() const {
1113 return impl_->iso_buffer_size_;
1114 }
1115
GetControllerLeLocalSupportedFeatures() const1116 uint64_t Controller::GetControllerLeLocalSupportedFeatures() const {
1117 return impl_->le_local_supported_features_;
1118 }
1119
GetLeSupportedStates() const1120 uint64_t Controller::GetLeSupportedStates() const {
1121 return impl_->le_supported_states_;
1122 }
1123
GetLeFilterAcceptListSize() const1124 uint8_t Controller::GetLeFilterAcceptListSize() const {
1125 return impl_->le_connect_list_size_;
1126 }
1127
GetLeResolvingListSize() const1128 uint8_t Controller::GetLeResolvingListSize() const {
1129 return impl_->le_resolving_list_size_;
1130 }
1131
GetLeMaximumDataLength() const1132 LeMaximumDataLength Controller::GetLeMaximumDataLength() const {
1133 return impl_->le_maximum_data_length_;
1134 }
1135
GetLeMaximumAdvertisingDataLength() const1136 uint16_t Controller::GetLeMaximumAdvertisingDataLength() const {
1137 return impl_->le_maximum_advertising_data_length_;
1138 }
1139
GetLeSuggestedDefaultDataLength() const1140 uint16_t Controller::GetLeSuggestedDefaultDataLength() const {
1141 return impl_->le_suggested_default_data_length_;
1142 }
1143
GetLeNumberOfSupportedAdverisingSets() const1144 uint8_t Controller::GetLeNumberOfSupportedAdverisingSets() const {
1145 return impl_->le_number_supported_advertising_sets_;
1146 }
1147
GetVendorCapabilities() const1148 VendorCapabilities Controller::GetVendorCapabilities() const {
1149 return impl_->vendor_capabilities_;
1150 }
1151
GetLePeriodicAdvertiserListSize() const1152 uint8_t Controller::GetLePeriodicAdvertiserListSize() const {
1153 return impl_->le_periodic_advertiser_list_size_;
1154 }
1155
IsSupported(bluetooth::hci::OpCode op_code) const1156 bool Controller::IsSupported(bluetooth::hci::OpCode op_code) const {
1157 return impl_->is_supported(op_code);
1158 }
1159
__anon7b01d28f0102() 1160 const ModuleFactory Controller::Factory = ModuleFactory([]() { return new Controller(); });
1161
ListDependencies(ModuleList * list) const1162 void Controller::ListDependencies(ModuleList* list) const {
1163 list->add<hci::HciLayer>();
1164 }
1165
Start()1166 void Controller::Start() {
1167 impl_->Start(GetDependency<hci::HciLayer>());
1168 }
1169
Stop()1170 void Controller::Stop() {
1171 impl_->Stop();
1172 }
1173
ToString() const1174 std::string Controller::ToString() const {
1175 return "Controller";
1176 }
1177
Dump(std::promise<flatbuffers::Offset<ControllerData>> promise,flatbuffers::FlatBufferBuilder * fb_builder) const1178 void Controller::impl::Dump(
1179 std::promise<flatbuffers::Offset<ControllerData>> promise, flatbuffers::FlatBufferBuilder* fb_builder) const {
1180 ASSERT(fb_builder != nullptr);
1181 auto title = fb_builder->CreateString("----- Hci Controller Dumpsys -----");
1182
1183 auto local_version_information_data = CreateLocalVersionInformationData(
1184 *fb_builder,
1185 fb_builder->CreateString(HciVersionText(local_version_information_.hci_version_)),
1186 local_version_information_.hci_revision_,
1187 fb_builder->CreateString(LmpVersionText(local_version_information_.lmp_version_)),
1188 local_version_information_.manufacturer_name_,
1189 local_version_information_.lmp_subversion_);
1190
1191 auto acl_buffer_size_data = BufferSizeData(acl_buffer_length_, acl_buffers_);
1192
1193 auto sco_buffer_size_data = BufferSizeData(sco_buffer_length_, sco_buffers_);
1194
1195 auto le_buffer_size_data =
1196 BufferSizeData(le_buffer_size_.le_data_packet_length_, le_buffer_size_.total_num_le_packets_);
1197
1198 auto iso_buffer_size_data =
1199 BufferSizeData(iso_buffer_size_.le_data_packet_length_, iso_buffer_size_.total_num_le_packets_);
1200
1201 auto le_maximum_data_length_data = LeMaximumDataLengthData(
1202 le_maximum_data_length_.supported_max_tx_octets_,
1203 le_maximum_data_length_.supported_max_tx_time_,
1204 le_maximum_data_length_.supported_max_rx_octets_,
1205 le_maximum_data_length_.supported_max_rx_time_);
1206
1207 std::vector<LocalSupportedCommandsData> local_supported_commands_vector;
1208 for (uint8_t index = 0; index < local_supported_commands_.size(); index++) {
1209 local_supported_commands_vector.push_back(LocalSupportedCommandsData(index, local_supported_commands_[index]));
1210 }
1211 auto local_supported_commands_data = fb_builder->CreateVectorOfStructs(local_supported_commands_vector);
1212
1213 auto vendor_capabilities_data = VendorCapabilitiesData(
1214 vendor_capabilities_.is_supported_,
1215 vendor_capabilities_.max_advt_instances_,
1216 vendor_capabilities_.offloaded_resolution_of_private_address_,
1217 vendor_capabilities_.total_scan_results_storage_,
1218 vendor_capabilities_.max_irk_list_sz_,
1219 vendor_capabilities_.filtering_support_,
1220 vendor_capabilities_.max_filter_,
1221 vendor_capabilities_.activity_energy_info_support_,
1222 vendor_capabilities_.version_supported_,
1223 vendor_capabilities_.total_num_of_advt_tracked_,
1224 vendor_capabilities_.extended_scan_support_,
1225 vendor_capabilities_.debug_logging_supported_,
1226 vendor_capabilities_.le_address_generation_offloading_support_,
1227 vendor_capabilities_.a2dp_source_offload_capability_mask_,
1228 vendor_capabilities_.bluetooth_quality_report_support_);
1229
1230 auto extended_lmp_features_vector = fb_builder->CreateVector(extended_lmp_features_array_);
1231
1232 // Create the root table
1233 ControllerDataBuilder builder(*fb_builder);
1234
1235 builder.add_title(title);
1236 builder.add_local_version_information(local_version_information_data);
1237
1238 builder.add_acl_buffer_size(&acl_buffer_size_data);
1239 builder.add_sco_buffer_size(&sco_buffer_size_data);
1240 builder.add_iso_buffer_size(&iso_buffer_size_data);
1241 builder.add_le_buffer_size(&le_buffer_size_data);
1242
1243 builder.add_le_connect_list_size(le_connect_list_size_);
1244 builder.add_le_resolving_list_size(le_resolving_list_size_);
1245
1246 builder.add_le_maximum_data_length(&le_maximum_data_length_data);
1247 builder.add_le_maximum_advertising_data_length(le_maximum_advertising_data_length_);
1248 builder.add_le_suggested_default_data_length(le_suggested_default_data_length_);
1249 builder.add_le_number_supported_advertising_sets(le_number_supported_advertising_sets_);
1250 builder.add_le_periodic_advertiser_list_size(le_periodic_advertiser_list_size_);
1251
1252 builder.add_local_supported_commands(local_supported_commands_data);
1253 builder.add_extended_lmp_features_array(extended_lmp_features_vector);
1254 builder.add_le_local_supported_features(le_local_supported_features_);
1255 builder.add_le_supported_states(le_supported_states_);
1256 builder.add_vendor_capabilities(&vendor_capabilities_data);
1257
1258 flatbuffers::Offset<ControllerData> dumpsys_data = builder.Finish();
1259 promise.set_value(dumpsys_data);
1260 }
1261
GetDumpsysData(flatbuffers::FlatBufferBuilder * fb_builder) const1262 DumpsysDataFinisher Controller::GetDumpsysData(flatbuffers::FlatBufferBuilder* fb_builder) const {
1263 ASSERT(fb_builder != nullptr);
1264
1265 std::promise<flatbuffers::Offset<ControllerData>> promise;
1266 auto future = promise.get_future();
1267 impl_->Dump(std::move(promise), fb_builder);
1268
1269 auto dumpsys_data = future.get();
1270
1271 return [dumpsys_data](DumpsysDataBuilder* dumpsys_builder) {
1272 dumpsys_builder->add_hci_controller_dumpsys_data(dumpsys_data);
1273 };
1274 }
1275
1276 } // namespace hci
1277 } // namespace bluetooth
1278