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 <utility>
22
23 #include "common/bind.h"
24 #include "common/callback.h"
25 #include "hci/hci_layer.h"
26
27 namespace bluetooth {
28 namespace hci {
29
30 using common::Bind;
31 using common::BindOnce;
32 using common::Callback;
33 using common::Closure;
34 using common::OnceCallback;
35 using common::OnceClosure;
36 using os::Handler;
37
38 struct Controller::impl {
implbluetooth::hci::Controller::impl39 impl(Controller& module) : module_(module) {}
40
Startbluetooth::hci::Controller::impl41 void Start(hci::HciLayer* hci) {
42 hci_ = hci;
43 hci_->RegisterEventHandler(EventCode::NUMBER_OF_COMPLETED_PACKETS,
44 Bind(&Controller::impl::NumberOfCompletedPackets, common::Unretained(this)),
45 module_.GetHandler());
46
47 set_event_mask(kDefaultEventMask);
48 hci_->EnqueueCommand(ReadLocalNameBuilder::Create(),
49 BindOnce(&Controller::impl::read_local_name_complete_handler, common::Unretained(this)),
50 module_.GetHandler());
51 hci_->EnqueueCommand(
52 ReadLocalVersionInformationBuilder::Create(),
53 BindOnce(&Controller::impl::read_local_version_information_complete_handler, common::Unretained(this)),
54 module_.GetHandler());
55 hci_->EnqueueCommand(
56 ReadLocalSupportedCommandsBuilder::Create(),
57 BindOnce(&Controller::impl::read_local_supported_commands_complete_handler, common::Unretained(this)),
58 module_.GetHandler());
59 hci_->EnqueueCommand(
60 ReadLocalSupportedFeaturesBuilder::Create(),
61 BindOnce(&Controller::impl::read_local_supported_features_complete_handler, common::Unretained(this)),
62 module_.GetHandler());
63
64 // Wait for all extended features read
65 std::promise<void> features_promise;
66 auto features_future = features_promise.get_future();
67 hci_->EnqueueCommand(ReadLocalExtendedFeaturesBuilder::Create(0x00),
68 BindOnce(&Controller::impl::read_local_extended_features_complete_handler,
69 common::Unretained(this), std::move(features_promise)),
70 module_.GetHandler());
71 features_future.wait();
72
73 hci_->EnqueueCommand(ReadBufferSizeBuilder::Create(),
74 BindOnce(&Controller::impl::read_buffer_size_complete_handler, common::Unretained(this)),
75 module_.GetHandler());
76
77 hci_->EnqueueCommand(LeReadBufferSizeBuilder::Create(),
78 BindOnce(&Controller::impl::le_read_buffer_size_handler, common::Unretained(this)),
79 module_.GetHandler());
80
81 hci_->EnqueueCommand(
82 LeReadLocalSupportedFeaturesBuilder::Create(),
83 BindOnce(&Controller::impl::le_read_local_supported_features_handler, common::Unretained(this)),
84 module_.GetHandler());
85
86 hci_->EnqueueCommand(LeReadSupportedStatesBuilder::Create(),
87 BindOnce(&Controller::impl::le_read_supported_states_handler, common::Unretained(this)),
88 module_.GetHandler());
89
90 if (is_supported(OpCode::LE_READ_MAXIMUM_DATA_LENGTH)) {
91 hci_->EnqueueCommand(LeReadMaximumDataLengthBuilder::Create(),
92 BindOnce(&Controller::impl::le_read_maximum_data_length_handler, common::Unretained(this)),
93 module_.GetHandler());
94 }
95 if (is_supported(OpCode::LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH)) {
96 hci_->EnqueueCommand(
97 LeReadMaximumAdvertisingDataLengthBuilder::Create(),
98 BindOnce(&Controller::impl::le_read_maximum_advertising_data_length_handler, common::Unretained(this)),
99 module_.GetHandler());
100 }
101 if (is_supported(OpCode::LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS)) {
102 hci_->EnqueueCommand(
103 LeReadNumberOfSupportedAdvertisingSetsBuilder::Create(),
104 BindOnce(&Controller::impl::le_read_number_of_supported_advertising_sets_handler, common::Unretained(this)),
105 module_.GetHandler());
106 }
107
108 hci_->EnqueueCommand(LeGetVendorCapabilitiesBuilder::Create(),
109 BindOnce(&Controller::impl::le_get_vendor_capabilities_handler, common::Unretained(this)),
110 module_.GetHandler());
111
112 // We only need to synchronize the last read. Make BD_ADDR to be the last one.
113 std::promise<void> promise;
114 auto future = promise.get_future();
115 hci_->EnqueueCommand(
116 ReadBdAddrBuilder::Create(),
117 BindOnce(&Controller::impl::read_controller_mac_address_handler, common::Unretained(this), std::move(promise)),
118 module_.GetHandler());
119 future.wait();
120 }
121
Stopbluetooth::hci::Controller::impl122 void Stop() {
123 hci_->UnregisterEventHandler(EventCode::NUMBER_OF_COMPLETED_PACKETS);
124 hci_ = nullptr;
125 }
126
NumberOfCompletedPacketsbluetooth::hci::Controller::impl127 void NumberOfCompletedPackets(EventPacketView event) {
128 ASSERT(acl_credits_handler_ != nullptr);
129 auto complete_view = NumberOfCompletedPacketsView::Create(event);
130 ASSERT(complete_view.IsValid());
131 for (auto completed_packets : complete_view.GetCompletedPackets()) {
132 uint16_t handle = completed_packets.connection_handle_;
133 uint16_t credits = completed_packets.host_num_of_completed_packets_;
134 acl_credits_handler_->Post(Bind(acl_credits_callback_, handle, credits));
135 }
136 }
137
RegisterCompletedAclPacketsCallbackbluetooth::hci::Controller::impl138 void RegisterCompletedAclPacketsCallback(Callback<void(uint16_t /* handle */, uint16_t /* packets */)> cb,
139 Handler* handler) {
140 ASSERT(acl_credits_handler_ == nullptr);
141 acl_credits_callback_ = cb;
142 acl_credits_handler_ = handler;
143 }
144
read_local_name_complete_handlerbluetooth::hci::Controller::impl145 void read_local_name_complete_handler(CommandCompleteView view) {
146 auto complete_view = ReadLocalNameCompleteView::Create(view);
147 ASSERT(complete_view.IsValid());
148 ErrorCode status = complete_view.GetStatus();
149 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
150 std::array<uint8_t, 248> local_name_array = complete_view.GetLocalName();
151
152 local_name_ = std::string(local_name_array.begin(), local_name_array.end());
153 // erase \0
154 local_name_.erase(std::find(local_name_.begin(), local_name_.end(), '\0'), local_name_.end());
155 }
156
read_local_version_information_complete_handlerbluetooth::hci::Controller::impl157 void read_local_version_information_complete_handler(CommandCompleteView view) {
158 auto complete_view = ReadLocalVersionInformationCompleteView::Create(view);
159 ASSERT(complete_view.IsValid());
160 ErrorCode status = complete_view.GetStatus();
161 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
162
163 local_version_information_ = complete_view.GetLocalVersionInformation();
164 }
165
read_local_supported_commands_complete_handlerbluetooth::hci::Controller::impl166 void read_local_supported_commands_complete_handler(CommandCompleteView view) {
167 auto complete_view = ReadLocalSupportedCommandsCompleteView::Create(view);
168 ASSERT(complete_view.IsValid());
169 ErrorCode status = complete_view.GetStatus();
170 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
171 local_supported_commands_ = complete_view.GetSupportedCommands();
172 }
173
read_local_supported_features_complete_handlerbluetooth::hci::Controller::impl174 void read_local_supported_features_complete_handler(CommandCompleteView view) {
175 auto complete_view = ReadLocalSupportedFeaturesCompleteView::Create(view);
176 ASSERT(complete_view.IsValid());
177 ErrorCode status = complete_view.GetStatus();
178 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
179 local_supported_features_ = complete_view.GetLmpFeatures();
180 }
181
read_local_extended_features_complete_handlerbluetooth::hci::Controller::impl182 void read_local_extended_features_complete_handler(std::promise<void> promise, CommandCompleteView view) {
183 auto complete_view = ReadLocalExtendedFeaturesCompleteView::Create(view);
184 ASSERT(complete_view.IsValid());
185 ErrorCode status = complete_view.GetStatus();
186 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
187 uint8_t page_number = complete_view.GetPageNumber();
188 maximum_page_number_ = complete_view.GetMaximumPageNumber();
189 extended_lmp_features_array_.push_back(complete_view.GetExtendedLmpFeatures());
190
191 // Query all extended features
192 if (page_number < maximum_page_number_) {
193 page_number++;
194 hci_->EnqueueCommand(ReadLocalExtendedFeaturesBuilder::Create(page_number),
195 BindOnce(&Controller::impl::read_local_extended_features_complete_handler,
196 common::Unretained(this), std::move(promise)),
197 module_.GetHandler());
198 } else {
199 promise.set_value();
200 }
201 }
202
read_buffer_size_complete_handlerbluetooth::hci::Controller::impl203 void read_buffer_size_complete_handler(CommandCompleteView view) {
204 auto complete_view = ReadBufferSizeCompleteView::Create(view);
205 ASSERT(complete_view.IsValid());
206 ErrorCode status = complete_view.GetStatus();
207 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
208 acl_buffer_length_ = complete_view.GetAclDataPacketLength();
209 acl_buffers_ = complete_view.GetTotalNumAclDataPackets();
210
211 sco_buffer_length_ = complete_view.GetSynchronousDataPacketLength();
212 sco_buffers_ = complete_view.GetTotalNumSynchronousDataPackets();
213 }
214
read_controller_mac_address_handlerbluetooth::hci::Controller::impl215 void read_controller_mac_address_handler(std::promise<void> promise, CommandCompleteView view) {
216 auto complete_view = ReadBdAddrCompleteView::Create(view);
217 ASSERT(complete_view.IsValid());
218 ErrorCode status = complete_view.GetStatus();
219 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
220 mac_address_ = complete_view.GetBdAddr();
221 promise.set_value();
222 }
223
le_read_buffer_size_handlerbluetooth::hci::Controller::impl224 void le_read_buffer_size_handler(CommandCompleteView view) {
225 auto complete_view = LeReadBufferSizeCompleteView::Create(view);
226 ASSERT(complete_view.IsValid());
227 ErrorCode status = complete_view.GetStatus();
228 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
229 le_buffer_size_ = complete_view.GetLeBufferSize();
230 }
231
le_read_local_supported_features_handlerbluetooth::hci::Controller::impl232 void le_read_local_supported_features_handler(CommandCompleteView view) {
233 auto complete_view = LeReadLocalSupportedFeaturesCompleteView::Create(view);
234 ASSERT(complete_view.IsValid());
235 ErrorCode status = complete_view.GetStatus();
236 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
237 le_local_supported_features_ = complete_view.GetLeFeatures();
238 }
239
le_read_supported_states_handlerbluetooth::hci::Controller::impl240 void le_read_supported_states_handler(CommandCompleteView view) {
241 auto complete_view = LeReadSupportedStatesCompleteView::Create(view);
242 ASSERT(complete_view.IsValid());
243 ErrorCode status = complete_view.GetStatus();
244 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
245 le_supported_states_ = complete_view.GetLeStates();
246 }
247
le_read_maximum_data_length_handlerbluetooth::hci::Controller::impl248 void le_read_maximum_data_length_handler(CommandCompleteView view) {
249 auto complete_view = LeReadMaximumDataLengthCompleteView::Create(view);
250 ASSERT(complete_view.IsValid());
251 ErrorCode status = complete_view.GetStatus();
252 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
253 le_maximum_data_length_ = complete_view.GetLeMaximumDataLength();
254 }
255
le_read_maximum_advertising_data_length_handlerbluetooth::hci::Controller::impl256 void le_read_maximum_advertising_data_length_handler(CommandCompleteView view) {
257 auto complete_view = LeReadMaximumAdvertisingDataLengthCompleteView::Create(view);
258 ASSERT(complete_view.IsValid());
259 ErrorCode status = complete_view.GetStatus();
260 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
261 le_maximum_advertising_data_length_ = complete_view.GetMaximumAdvertisingDataLength();
262 }
263
le_read_number_of_supported_advertising_sets_handlerbluetooth::hci::Controller::impl264 void le_read_number_of_supported_advertising_sets_handler(CommandCompleteView view) {
265 auto complete_view = LeReadNumberOfSupportedAdvertisingSetsCompleteView::Create(view);
266 ASSERT(complete_view.IsValid());
267 ErrorCode status = complete_view.GetStatus();
268 ASSERT_LOG(status == ErrorCode::SUCCESS, "Status 0x%02hhx, %s", status, ErrorCodeText(status).c_str());
269 le_number_supported_advertising_sets_ = complete_view.GetNumberSupportedAdvertisingSets();
270 }
271
le_get_vendor_capabilities_handlerbluetooth::hci::Controller::impl272 void le_get_vendor_capabilities_handler(CommandCompleteView view) {
273 auto complete_view = LeGetVendorCapabilitiesCompleteView::Create(view);
274
275 vendor_capabilities_.is_supported_ = 0x00;
276 vendor_capabilities_.max_advt_instances_ = 0x00;
277 vendor_capabilities_.offloaded_resolution_of_private_address_ = 0x00;
278 vendor_capabilities_.total_scan_results_storage_ = 0x00;
279 vendor_capabilities_.max_irk_list_sz_ = 0x00;
280 vendor_capabilities_.filtering_support_ = 0x00;
281 vendor_capabilities_.max_filter_ = 0x00;
282 vendor_capabilities_.activity_energy_info_support_ = 0x00;
283 vendor_capabilities_.version_supported_ = 0x00;
284 vendor_capabilities_.version_supported_ = 0x00;
285 vendor_capabilities_.total_num_of_advt_tracked_ = 0x00;
286 vendor_capabilities_.extended_scan_support_ = 0x00;
287 vendor_capabilities_.debug_logging_supported_ = 0x00;
288 vendor_capabilities_.le_address_generation_offloading_support_ = 0x00;
289 vendor_capabilities_.a2dp_source_offload_capability_mask_ = 0x00;
290 vendor_capabilities_.bluetooth_quality_report_support_ = 0x00;
291
292 if (complete_view.IsValid()) {
293 vendor_capabilities_.is_supported_ = 0x01;
294
295 // v0.55
296 BaseVendorCapabilities base_vendor_capabilities = complete_view.GetBaseVendorCapabilities();
297 vendor_capabilities_.max_advt_instances_ = base_vendor_capabilities.max_advt_instances_;
298 vendor_capabilities_.offloaded_resolution_of_private_address_ =
299 base_vendor_capabilities.offloaded_resolution_of_private_address_;
300 vendor_capabilities_.total_scan_results_storage_ = base_vendor_capabilities.total_scan_results_storage_;
301 vendor_capabilities_.max_irk_list_sz_ = base_vendor_capabilities.max_irk_list_sz_;
302 vendor_capabilities_.filtering_support_ = base_vendor_capabilities.filtering_support_;
303 vendor_capabilities_.max_filter_ = base_vendor_capabilities.max_filter_;
304 vendor_capabilities_.activity_energy_info_support_ = base_vendor_capabilities.activity_energy_info_support_;
305 if (complete_view.GetPayload().size() == 0) {
306 vendor_capabilities_.version_supported_ = 55;
307 return;
308 }
309
310 // v0.95
311 auto v95 = LeGetVendorCapabilitiesComplete095View::Create(complete_view);
312 if (!v95.IsValid()) {
313 LOG_ERROR("invalid data for hci requirements v0.95");
314 return;
315 }
316 vendor_capabilities_.version_supported_ = v95.GetVersionSupported();
317 vendor_capabilities_.total_num_of_advt_tracked_ = v95.GetTotalNumOfAdvtTracked();
318 vendor_capabilities_.extended_scan_support_ = v95.GetExtendedScanSupport();
319 vendor_capabilities_.debug_logging_supported_ = v95.GetDebugLoggingSupported();
320 if (vendor_capabilities_.version_supported_ <= 95 || complete_view.GetPayload().size() == 0) {
321 return;
322 }
323
324 // v0.96
325 auto v96 = LeGetVendorCapabilitiesComplete096View::Create(v95);
326 if (!v96.IsValid()) {
327 LOG_ERROR("invalid data for hci requirements v0.96");
328 return;
329 }
330 vendor_capabilities_.le_address_generation_offloading_support_ = v96.GetLeAddressGenerationOffloadingSupport();
331 if (vendor_capabilities_.version_supported_ <= 96 || complete_view.GetPayload().size() == 0) {
332 return;
333 }
334
335 // v0.98
336 auto v98 = LeGetVendorCapabilitiesComplete098View::Create(v96);
337 if (!v98.IsValid()) {
338 LOG_ERROR("invalid data for hci requirements v0.98");
339 return;
340 }
341 vendor_capabilities_.a2dp_source_offload_capability_mask_ = v98.GetA2dpSourceOffloadCapabilityMask();
342 vendor_capabilities_.bluetooth_quality_report_support_ = v98.GetBluetoothQualityReportSupport();
343 }
344 }
345
set_event_maskbluetooth::hci::Controller::impl346 void set_event_mask(uint64_t event_mask) {
347 std::unique_ptr<SetEventMaskBuilder> packet = SetEventMaskBuilder::Create(event_mask);
348 hci_->EnqueueCommand(std::move(packet),
349 BindOnce(&Controller::impl::check_status<SetEventMaskCompleteView>, common::Unretained(this)),
350 module_.GetHandler());
351 }
352
resetbluetooth::hci::Controller::impl353 void reset() {
354 std::unique_ptr<ResetBuilder> packet = ResetBuilder::Create();
355 hci_->EnqueueCommand(std::move(packet),
356 BindOnce(&Controller::impl::check_status<ResetCompleteView>, common::Unretained(this)),
357 module_.GetHandler());
358 }
359
set_event_filterbluetooth::hci::Controller::impl360 void set_event_filter(std::unique_ptr<SetEventFilterBuilder> packet) {
361 hci_->EnqueueCommand(
362 std::move(packet),
363 BindOnce(&Controller::impl::check_status<SetEventFilterCompleteView>, common::Unretained(this)),
364 module_.GetHandler());
365 }
366
write_local_namebluetooth::hci::Controller::impl367 void write_local_name(std::string local_name) {
368 ASSERT(local_name.length() <= 248);
369 // Fill remaining char with 0
370 local_name.append(std::string(248 - local_name.length(), '\0'));
371 std::array<uint8_t, 248> local_name_array;
372 std::copy(std::begin(local_name), std::end(local_name), std::begin(local_name_array));
373
374 std::unique_ptr<WriteLocalNameBuilder> packet = WriteLocalNameBuilder::Create(local_name_array);
375 hci_->EnqueueCommand(
376 std::move(packet),
377 BindOnce(&Controller::impl::check_status<WriteLocalNameCompleteView>, common::Unretained(this)),
378 module_.GetHandler());
379 }
380
host_buffer_sizebluetooth::hci::Controller::impl381 void host_buffer_size(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
382 uint16_t host_total_num_acl_data_packets, uint16_t host_total_num_synchronous_data_packets) {
383 std::unique_ptr<HostBufferSizeBuilder> packet =
384 HostBufferSizeBuilder::Create(host_acl_data_packet_length, host_synchronous_data_packet_length,
385 host_total_num_acl_data_packets, host_total_num_synchronous_data_packets);
386 hci_->EnqueueCommand(
387 std::move(packet),
388 BindOnce(&Controller::impl::check_status<HostBufferSizeCompleteView>, common::Unretained(this)),
389 module_.GetHandler());
390 }
391
le_set_event_maskbluetooth::hci::Controller::impl392 void le_set_event_mask(uint64_t le_event_mask) {
393 std::unique_ptr<LeSetEventMaskBuilder> packet = LeSetEventMaskBuilder::Create(le_event_mask);
394 hci_->EnqueueCommand(
395 std::move(packet),
396 BindOnce(&Controller::impl::check_status<LeSetEventMaskCompleteView>, common::Unretained(this)),
397 module_.GetHandler());
398 }
399
400 template <class T>
check_statusbluetooth::hci::Controller::impl401 void check_status(CommandCompleteView view) {
402 ASSERT(view.IsValid());
403 auto status_view = T::Create(view);
404 ASSERT(status_view.IsValid());
405 ASSERT(status_view.GetStatus() == ErrorCode::SUCCESS);
406 }
407
408 #define OP_CODE_MAPPING(name) \
409 case OpCode::name: { \
410 uint16_t index = (uint16_t)OpCodeIndex::name; \
411 uint16_t byte_index = index / 10; \
412 uint16_t bit_index = index % 10; \
413 bool supported = local_supported_commands_[byte_index] & (1 << bit_index); \
414 if (!supported) { \
415 LOG_WARN("unsupported command opcode: 0x%04x", (uint16_t)OpCode::name); \
416 } \
417 return supported; \
418 }
419
is_supportedbluetooth::hci::Controller::impl420 bool is_supported(OpCode op_code) {
421 switch (op_code) {
422 OP_CODE_MAPPING(INQUIRY)
423 OP_CODE_MAPPING(INQUIRY_CANCEL)
424 OP_CODE_MAPPING(PERIODIC_INQUIRY_MODE)
425 OP_CODE_MAPPING(EXIT_PERIODIC_INQUIRY_MODE)
426 OP_CODE_MAPPING(CREATE_CONNECTION)
427 OP_CODE_MAPPING(DISCONNECT)
428 OP_CODE_MAPPING(CREATE_CONNECTION_CANCEL)
429 OP_CODE_MAPPING(ACCEPT_CONNECTION_REQUEST)
430 OP_CODE_MAPPING(REJECT_CONNECTION_REQUEST)
431 OP_CODE_MAPPING(LINK_KEY_REQUEST_REPLY)
432 OP_CODE_MAPPING(LINK_KEY_REQUEST_NEGATIVE_REPLY)
433 OP_CODE_MAPPING(PIN_CODE_REQUEST_REPLY)
434 OP_CODE_MAPPING(PIN_CODE_REQUEST_NEGATIVE_REPLY)
435 OP_CODE_MAPPING(CHANGE_CONNECTION_PACKET_TYPE)
436 OP_CODE_MAPPING(AUTHENTICATION_REQUESTED)
437 OP_CODE_MAPPING(SET_CONNECTION_ENCRYPTION)
438 OP_CODE_MAPPING(CHANGE_CONNECTION_LINK_KEY)
439 OP_CODE_MAPPING(MASTER_LINK_KEY)
440 OP_CODE_MAPPING(REMOTE_NAME_REQUEST)
441 OP_CODE_MAPPING(REMOTE_NAME_REQUEST_CANCEL)
442 OP_CODE_MAPPING(READ_REMOTE_SUPPORTED_FEATURES)
443 OP_CODE_MAPPING(READ_REMOTE_EXTENDED_FEATURES)
444 OP_CODE_MAPPING(READ_REMOTE_VERSION_INFORMATION)
445 OP_CODE_MAPPING(READ_CLOCK_OFFSET)
446 OP_CODE_MAPPING(READ_LMP_HANDLE)
447 OP_CODE_MAPPING(HOLD_MODE)
448 OP_CODE_MAPPING(SNIFF_MODE)
449 OP_CODE_MAPPING(EXIT_SNIFF_MODE)
450 OP_CODE_MAPPING(QOS_SETUP)
451 OP_CODE_MAPPING(ROLE_DISCOVERY)
452 OP_CODE_MAPPING(SWITCH_ROLE)
453 OP_CODE_MAPPING(READ_LINK_POLICY_SETTINGS)
454 OP_CODE_MAPPING(WRITE_LINK_POLICY_SETTINGS)
455 OP_CODE_MAPPING(READ_DEFAULT_LINK_POLICY_SETTINGS)
456 OP_CODE_MAPPING(WRITE_DEFAULT_LINK_POLICY_SETTINGS)
457 OP_CODE_MAPPING(FLOW_SPECIFICATION)
458 OP_CODE_MAPPING(SET_EVENT_MASK)
459 OP_CODE_MAPPING(RESET)
460 OP_CODE_MAPPING(SET_EVENT_FILTER)
461 OP_CODE_MAPPING(FLUSH)
462 OP_CODE_MAPPING(READ_PIN_TYPE)
463 OP_CODE_MAPPING(WRITE_PIN_TYPE)
464 OP_CODE_MAPPING(READ_STORED_LINK_KEY)
465 OP_CODE_MAPPING(WRITE_STORED_LINK_KEY)
466 OP_CODE_MAPPING(DELETE_STORED_LINK_KEY)
467 OP_CODE_MAPPING(WRITE_LOCAL_NAME)
468 OP_CODE_MAPPING(READ_LOCAL_NAME)
469 OP_CODE_MAPPING(READ_CONNECTION_ACCEPT_TIMEOUT)
470 OP_CODE_MAPPING(WRITE_CONNECTION_ACCEPT_TIMEOUT)
471 OP_CODE_MAPPING(READ_PAGE_TIMEOUT)
472 OP_CODE_MAPPING(WRITE_PAGE_TIMEOUT)
473 OP_CODE_MAPPING(READ_SCAN_ENABLE)
474 OP_CODE_MAPPING(WRITE_SCAN_ENABLE)
475 OP_CODE_MAPPING(READ_PAGE_SCAN_ACTIVITY)
476 OP_CODE_MAPPING(WRITE_PAGE_SCAN_ACTIVITY)
477 OP_CODE_MAPPING(READ_INQUIRY_SCAN_ACTIVITY)
478 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_ACTIVITY)
479 OP_CODE_MAPPING(READ_AUTHENTICATION_ENABLE)
480 OP_CODE_MAPPING(WRITE_AUTHENTICATION_ENABLE)
481 OP_CODE_MAPPING(READ_CLASS_OF_DEVICE)
482 OP_CODE_MAPPING(WRITE_CLASS_OF_DEVICE)
483 OP_CODE_MAPPING(READ_VOICE_SETTING)
484 OP_CODE_MAPPING(WRITE_VOICE_SETTING)
485 OP_CODE_MAPPING(READ_AUTOMATIC_FLUSH_TIMEOUT)
486 OP_CODE_MAPPING(WRITE_AUTOMATIC_FLUSH_TIMEOUT)
487 OP_CODE_MAPPING(READ_NUM_BROADCAST_RETRANSMITS)
488 OP_CODE_MAPPING(WRITE_NUM_BROADCAST_RETRANSMITS)
489 OP_CODE_MAPPING(READ_HOLD_MODE_ACTIVITY)
490 OP_CODE_MAPPING(WRITE_HOLD_MODE_ACTIVITY)
491 OP_CODE_MAPPING(READ_TRANSMIT_POWER_LEVEL)
492 OP_CODE_MAPPING(READ_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
493 OP_CODE_MAPPING(WRITE_SYNCHRONOUS_FLOW_CONTROL_ENABLE)
494 OP_CODE_MAPPING(SET_CONTROLLER_TO_HOST_FLOW_CONTROL)
495 OP_CODE_MAPPING(HOST_BUFFER_SIZE)
496 OP_CODE_MAPPING(HOST_NUM_COMPLETED_PACKETS)
497 OP_CODE_MAPPING(READ_LINK_SUPERVISION_TIMEOUT)
498 OP_CODE_MAPPING(WRITE_LINK_SUPERVISION_TIMEOUT)
499 OP_CODE_MAPPING(READ_NUMBER_OF_SUPPORTED_IAC)
500 OP_CODE_MAPPING(READ_CURRENT_IAC_LAP)
501 OP_CODE_MAPPING(WRITE_CURRENT_IAC_LAP)
502 OP_CODE_MAPPING(SET_AFH_HOST_CHANNEL_CLASSIFICATION)
503 OP_CODE_MAPPING(READ_INQUIRY_SCAN_TYPE)
504 OP_CODE_MAPPING(WRITE_INQUIRY_SCAN_TYPE)
505 OP_CODE_MAPPING(READ_INQUIRY_MODE)
506 OP_CODE_MAPPING(WRITE_INQUIRY_MODE)
507 OP_CODE_MAPPING(READ_PAGE_SCAN_TYPE)
508 OP_CODE_MAPPING(WRITE_PAGE_SCAN_TYPE)
509 OP_CODE_MAPPING(READ_AFH_CHANNEL_ASSESSMENT_MODE)
510 OP_CODE_MAPPING(WRITE_AFH_CHANNEL_ASSESSMENT_MODE)
511 OP_CODE_MAPPING(READ_LOCAL_VERSION_INFORMATION)
512 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_FEATURES)
513 OP_CODE_MAPPING(READ_LOCAL_EXTENDED_FEATURES)
514 OP_CODE_MAPPING(READ_BUFFER_SIZE)
515 OP_CODE_MAPPING(READ_BD_ADDR)
516 OP_CODE_MAPPING(READ_FAILED_CONTACT_COUNTER)
517 OP_CODE_MAPPING(RESET_FAILED_CONTACT_COUNTER)
518 OP_CODE_MAPPING(READ_LINK_QUALITY)
519 OP_CODE_MAPPING(READ_RSSI)
520 OP_CODE_MAPPING(READ_AFH_CHANNEL_MAP)
521 OP_CODE_MAPPING(READ_CLOCK)
522 OP_CODE_MAPPING(READ_LOOPBACK_MODE)
523 OP_CODE_MAPPING(WRITE_LOOPBACK_MODE)
524 OP_CODE_MAPPING(ENABLE_DEVICE_UNDER_TEST_MODE)
525 OP_CODE_MAPPING(SETUP_SYNCHRONOUS_CONNECTION)
526 OP_CODE_MAPPING(ACCEPT_SYNCHRONOUS_CONNECTION)
527 OP_CODE_MAPPING(REJECT_SYNCHRONOUS_CONNECTION)
528 OP_CODE_MAPPING(READ_EXTENDED_INQUIRY_RESPONSE)
529 OP_CODE_MAPPING(WRITE_EXTENDED_INQUIRY_RESPONSE)
530 OP_CODE_MAPPING(REFRESH_ENCRYPTION_KEY)
531 OP_CODE_MAPPING(SNIFF_SUBRATING)
532 OP_CODE_MAPPING(READ_SIMPLE_PAIRING_MODE)
533 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_MODE)
534 OP_CODE_MAPPING(READ_LOCAL_OOB_DATA)
535 OP_CODE_MAPPING(READ_INQUIRY_RESPONSE_TRANSMIT_POWER_LEVEL)
536 OP_CODE_MAPPING(WRITE_INQUIRY_TRANSMIT_POWER_LEVEL)
537 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_REPLY)
538 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_REPLY)
539 OP_CODE_MAPPING(USER_CONFIRMATION_REQUEST_NEGATIVE_REPLY)
540 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_REPLY)
541 OP_CODE_MAPPING(USER_PASSKEY_REQUEST_NEGATIVE_REPLY)
542 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_REPLY)
543 OP_CODE_MAPPING(WRITE_SIMPLE_PAIRING_DEBUG_MODE)
544 OP_CODE_MAPPING(REMOTE_OOB_DATA_REQUEST_NEGATIVE_REPLY)
545 OP_CODE_MAPPING(SEND_KEYPRESS_NOTIFICATION)
546 OP_CODE_MAPPING(IO_CAPABILITY_REQUEST_NEGATIVE_REPLY)
547 OP_CODE_MAPPING(READ_ENCRYPTION_KEY_SIZE)
548 OP_CODE_MAPPING(READ_DATA_BLOCK_SIZE)
549 OP_CODE_MAPPING(READ_LE_HOST_SUPPORT)
550 OP_CODE_MAPPING(WRITE_LE_HOST_SUPPORT)
551 OP_CODE_MAPPING(LE_SET_EVENT_MASK)
552 OP_CODE_MAPPING(LE_READ_BUFFER_SIZE)
553 OP_CODE_MAPPING(LE_READ_LOCAL_SUPPORTED_FEATURES)
554 OP_CODE_MAPPING(LE_SET_RANDOM_ADDRESS)
555 OP_CODE_MAPPING(LE_SET_ADVERTISING_PARAMETERS)
556 OP_CODE_MAPPING(LE_READ_ADVERTISING_CHANNEL_TX_POWER)
557 OP_CODE_MAPPING(LE_SET_ADVERTISING_DATA)
558 OP_CODE_MAPPING(LE_SET_SCAN_RESPONSE_DATA)
559 OP_CODE_MAPPING(LE_SET_ADVERTISING_ENABLE)
560 OP_CODE_MAPPING(LE_SET_SCAN_PARAMETERS)
561 OP_CODE_MAPPING(LE_SET_SCAN_ENABLE)
562 OP_CODE_MAPPING(LE_CREATE_CONNECTION)
563 OP_CODE_MAPPING(LE_CREATE_CONNECTION_CANCEL)
564 OP_CODE_MAPPING(LE_READ_WHITE_LIST_SIZE)
565 OP_CODE_MAPPING(LE_CLEAR_WHITE_LIST)
566 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_WHITE_LIST)
567 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_WHITE_LIST)
568 OP_CODE_MAPPING(LE_CONNECTION_UPDATE)
569 OP_CODE_MAPPING(LE_SET_HOST_CHANNEL_CLASSIFICATION)
570 OP_CODE_MAPPING(LE_READ_CHANNEL_MAP)
571 OP_CODE_MAPPING(LE_READ_REMOTE_FEATURES)
572 OP_CODE_MAPPING(LE_ENCRYPT)
573 OP_CODE_MAPPING(LE_RAND)
574 OP_CODE_MAPPING(LE_START_ENCRYPTION)
575 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_REPLY)
576 OP_CODE_MAPPING(LE_LONG_TERM_KEY_REQUEST_NEGATIVE_REPLY)
577 OP_CODE_MAPPING(LE_READ_SUPPORTED_STATES)
578 OP_CODE_MAPPING(LE_RECEIVER_TEST)
579 OP_CODE_MAPPING(LE_TRANSMITTER_TEST)
580 OP_CODE_MAPPING(LE_TEST_END)
581 OP_CODE_MAPPING(ENHANCED_SETUP_SYNCHRONOUS_CONNECTION)
582 OP_CODE_MAPPING(ENHANCED_ACCEPT_SYNCHRONOUS_CONNECTION)
583 OP_CODE_MAPPING(READ_LOCAL_SUPPORTED_CODECS)
584 OP_CODE_MAPPING(READ_SECURE_CONNECTIONS_HOST_SUPPORT)
585 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_HOST_SUPPORT)
586 OP_CODE_MAPPING(READ_LOCAL_OOB_EXTENDED_DATA)
587 OP_CODE_MAPPING(WRITE_SECURE_CONNECTIONS_TEST_MODE)
588 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_REPLY)
589 OP_CODE_MAPPING(LE_REMOTE_CONNECTION_PARAMETER_REQUEST_NEGATIVE_REPLY)
590 OP_CODE_MAPPING(LE_SET_DATA_LENGTH)
591 OP_CODE_MAPPING(LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH)
592 OP_CODE_MAPPING(LE_WRITE_SUGGESTED_DEFAULT_DATA_LENGTH)
593 OP_CODE_MAPPING(LE_READ_LOCAL_P_256_PUBLIC_KEY_COMMAND)
594 OP_CODE_MAPPING(LE_GENERATE_DHKEY_COMMAND_V1)
595 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_RESOLVING_LIST)
596 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_RESOLVING_LIST)
597 OP_CODE_MAPPING(LE_CLEAR_RESOLVING_LIST)
598 OP_CODE_MAPPING(LE_READ_RESOLVING_LIST_SIZE)
599 OP_CODE_MAPPING(LE_READ_PEER_RESOLVABLE_ADDRESS)
600 OP_CODE_MAPPING(LE_READ_LOCAL_RESOLVABLE_ADDRESS)
601 OP_CODE_MAPPING(LE_SET_ADDRESS_RESOLUTION_ENABLE)
602 OP_CODE_MAPPING(LE_SET_RESOLVABLE_PRIVATE_ADDRESS_TIMEOUT)
603 OP_CODE_MAPPING(LE_READ_MAXIMUM_DATA_LENGTH)
604 OP_CODE_MAPPING(LE_READ_PHY)
605 OP_CODE_MAPPING(LE_SET_DEFAULT_PHY)
606 OP_CODE_MAPPING(LE_SET_PHY)
607 OP_CODE_MAPPING(LE_ENHANCED_RECEIVER_TEST)
608 OP_CODE_MAPPING(LE_ENHANCED_TRANSMITTER_TEST)
609 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_RANDOM_ADDRESS)
610 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_PARAMETERS)
611 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_DATA)
612 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_SCAN_RESPONSE)
613 OP_CODE_MAPPING(LE_SET_EXTENDED_ADVERTISING_ENABLE)
614 OP_CODE_MAPPING(LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH)
615 OP_CODE_MAPPING(LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS)
616 OP_CODE_MAPPING(LE_REMOVE_ADVERTISING_SET)
617 OP_CODE_MAPPING(LE_CLEAR_ADVERTISING_SETS)
618 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_PARAM)
619 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_DATA)
620 OP_CODE_MAPPING(LE_SET_PERIODIC_ADVERTISING_ENABLE)
621 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_PARAMETERS)
622 OP_CODE_MAPPING(LE_SET_EXTENDED_SCAN_ENABLE)
623 OP_CODE_MAPPING(LE_EXTENDED_CREATE_CONNECTION)
624 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC)
625 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_CREATE_SYNC_CANCEL)
626 OP_CODE_MAPPING(LE_PERIODIC_ADVERTISING_TERMINATE_SYNC)
627 OP_CODE_MAPPING(LE_ADD_DEVICE_TO_PERIODIC_ADVERTISING_LIST)
628 OP_CODE_MAPPING(LE_REMOVE_DEVICE_FROM_PERIODIC_ADVERTISING_LIST)
629 OP_CODE_MAPPING(LE_CLEAR_PERIODIC_ADVERTISING_LIST)
630 OP_CODE_MAPPING(LE_READ_PERIODIC_ADVERTISING_LIST_SIZE)
631 OP_CODE_MAPPING(LE_READ_TRANSMIT_POWER)
632 OP_CODE_MAPPING(LE_READ_RF_PATH_COMPENSATION_POWER)
633 OP_CODE_MAPPING(LE_WRITE_RF_PATH_COMPENSATION_POWER)
634 OP_CODE_MAPPING(LE_SET_PRIVACY_MODE)
635 OP_CODE_MAPPING(LE_GENERATE_DHKEY_COMMAND)
636 // vendor specific
637 case OpCode::LE_GET_VENDOR_CAPABILITIES:
638 return vendor_capabilities_.is_supported_ == 0x01;
639 case OpCode::LE_MULTI_ADVT:
640 return vendor_capabilities_.max_advt_instances_ != 0x00;
641 case OpCode::LE_BATCH_SCAN:
642 return vendor_capabilities_.total_scan_results_storage_ != 0x00;
643 case OpCode::LE_ADV_FILTER:
644 return vendor_capabilities_.filtering_support_ == 0x01;
645 case OpCode::LE_TRACK_ADV:
646 return vendor_capabilities_.total_num_of_advt_tracked_ > 0;
647 case OpCode::LE_ENERGY_INFO:
648 return vendor_capabilities_.activity_energy_info_support_ == 0x01;
649 case OpCode::LE_EXTENDED_SCAN_PARAMS:
650 return vendor_capabilities_.extended_scan_support_ == 0x01;
651 case OpCode::CONTROLLER_DEBUG_INFO:
652 return vendor_capabilities_.debug_logging_supported_ == 0x01;
653 case OpCode::CONTROLLER_A2DP_OPCODE:
654 return vendor_capabilities_.a2dp_source_offload_capability_mask_ != 0x00;
655 case OpCode::CONTROLLER_BQR:
656 return vendor_capabilities_.bluetooth_quality_report_support_ == 0x01;
657 // undefined in local_supported_commands_
658 case OpCode::CREATE_NEW_UNIT_KEY:
659 case OpCode::READ_LOCAL_SUPPORTED_COMMANDS:
660 return true;
661 case OpCode::NONE:
662 return false;
663 }
664 return false;
665 }
666 #undef OP_CODE_MAPPING
667
668 Controller& module_;
669
670 HciLayer* hci_;
671
672 Callback<void(uint16_t, uint16_t)> acl_credits_callback_;
673 Handler* acl_credits_handler_ = nullptr;
674 LocalVersionInformation local_version_information_;
675 std::array<uint8_t, 64> local_supported_commands_;
676 uint64_t local_supported_features_;
677 uint8_t maximum_page_number_;
678 std::vector<uint64_t> extended_lmp_features_array_;
679 uint16_t acl_buffer_length_ = 0;
680 uint16_t acl_buffers_ = 0;
681 uint8_t sco_buffer_length_ = 0;
682 uint16_t sco_buffers_ = 0;
683 Address mac_address_;
684 std::string local_name_;
685 LeBufferSize le_buffer_size_;
686 uint64_t le_local_supported_features_;
687 uint64_t le_supported_states_;
688 LeMaximumDataLength le_maximum_data_length_;
689 uint16_t le_maximum_advertising_data_length_;
690 uint8_t le_number_supported_advertising_sets_;
691 VendorCapabilities vendor_capabilities_;
692 }; // namespace hci
693
Controller()694 Controller::Controller() : impl_(std::make_unique<impl>(*this)) {}
695
696 Controller::~Controller() = default;
697
RegisterCompletedAclPacketsCallback(Callback<void (uint16_t,uint16_t)> cb,Handler * handler)698 void Controller::RegisterCompletedAclPacketsCallback(Callback<void(uint16_t /* handle */, uint16_t /* packets */)> cb,
699 Handler* handler) {
700 impl_->RegisterCompletedAclPacketsCallback(cb, handler); // TODO hsz: why here?
701 }
702
GetControllerLocalName() const703 std::string Controller::GetControllerLocalName() const {
704 return impl_->local_name_;
705 }
706
GetControllerLocalVersionInformation() const707 LocalVersionInformation Controller::GetControllerLocalVersionInformation() const {
708 return impl_->local_version_information_;
709 }
710
GetControllerLocalSupportedCommands() const711 std::array<uint8_t, 64> Controller::GetControllerLocalSupportedCommands() const {
712 return impl_->local_supported_commands_;
713 }
714
GetControllerLocalExtendedFeaturesMaxPageNumber() const715 uint8_t Controller::GetControllerLocalExtendedFeaturesMaxPageNumber() const {
716 return impl_->maximum_page_number_;
717 }
718
GetControllerLocalSupportedFeatures() const719 uint64_t Controller::GetControllerLocalSupportedFeatures() const {
720 return impl_->local_supported_features_;
721 }
722
GetControllerLocalExtendedFeatures(uint8_t page_number) const723 uint64_t Controller::GetControllerLocalExtendedFeatures(uint8_t page_number) const {
724 if (page_number <= impl_->maximum_page_number_) {
725 return impl_->extended_lmp_features_array_[page_number];
726 }
727 return 0x00;
728 }
729
GetControllerAclPacketLength() const730 uint16_t Controller::GetControllerAclPacketLength() const {
731 return impl_->acl_buffer_length_;
732 }
733
GetControllerNumAclPacketBuffers() const734 uint16_t Controller::GetControllerNumAclPacketBuffers() const {
735 return impl_->acl_buffers_;
736 }
737
GetControllerScoPacketLength() const738 uint8_t Controller::GetControllerScoPacketLength() const {
739 return impl_->sco_buffer_length_;
740 }
741
GetControllerNumScoPacketBuffers() const742 uint16_t Controller::GetControllerNumScoPacketBuffers() const {
743 return impl_->sco_buffers_;
744 }
745
GetControllerMacAddress() const746 Address Controller::GetControllerMacAddress() const {
747 return impl_->mac_address_;
748 }
749
SetEventMask(uint64_t event_mask)750 void Controller::SetEventMask(uint64_t event_mask) {
751 GetHandler()->Post(common::BindOnce(&impl::set_event_mask, common::Unretained(impl_.get()), event_mask));
752 }
753
Reset()754 void Controller::Reset() {
755 GetHandler()->Post(common::BindOnce(&impl::reset, common::Unretained(impl_.get())));
756 }
757
SetEventFilterClearAll()758 void Controller::SetEventFilterClearAll() {
759 std::unique_ptr<SetEventFilterClearAllBuilder> packet = SetEventFilterClearAllBuilder::Create();
760 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
761 }
762
SetEventFilterInquiryResultAllDevices()763 void Controller::SetEventFilterInquiryResultAllDevices() {
764 std::unique_ptr<SetEventFilterInquiryResultAllDevicesBuilder> packet =
765 SetEventFilterInquiryResultAllDevicesBuilder::Create();
766 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
767 }
768
SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask)769 void Controller::SetEventFilterInquiryResultClassOfDevice(ClassOfDevice class_of_device,
770 ClassOfDevice class_of_device_mask) {
771 std::unique_ptr<SetEventFilterInquiryResultClassOfDeviceBuilder> packet =
772 SetEventFilterInquiryResultClassOfDeviceBuilder::Create(class_of_device, class_of_device_mask);
773 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
774 }
775
SetEventFilterInquiryResultAddress(Address address)776 void Controller::SetEventFilterInquiryResultAddress(Address address) {
777 std::unique_ptr<SetEventFilterInquiryResultAddressBuilder> packet =
778 SetEventFilterInquiryResultAddressBuilder::Create(address);
779 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
780 }
781
SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag)782 void Controller::SetEventFilterConnectionSetupAllDevices(AutoAcceptFlag auto_accept_flag) {
783 std::unique_ptr<SetEventFilterConnectionSetupAllDevicesBuilder> packet =
784 SetEventFilterConnectionSetupAllDevicesBuilder::Create(auto_accept_flag);
785 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
786 }
787
SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,ClassOfDevice class_of_device_mask,AutoAcceptFlag auto_accept_flag)788 void Controller::SetEventFilterConnectionSetupClassOfDevice(ClassOfDevice class_of_device,
789 ClassOfDevice class_of_device_mask,
790 AutoAcceptFlag auto_accept_flag) {
791 std::unique_ptr<SetEventFilterConnectionSetupClassOfDeviceBuilder> packet =
792 SetEventFilterConnectionSetupClassOfDeviceBuilder::Create(class_of_device, class_of_device_mask,
793 auto_accept_flag);
794 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
795 }
796
SetEventFilterConnectionSetupAddress(Address address,AutoAcceptFlag auto_accept_flag)797 void Controller::SetEventFilterConnectionSetupAddress(Address address, AutoAcceptFlag auto_accept_flag) {
798 std::unique_ptr<SetEventFilterConnectionSetupAddressBuilder> packet =
799 SetEventFilterConnectionSetupAddressBuilder::Create(address, auto_accept_flag);
800 GetHandler()->Post(common::BindOnce(&impl::set_event_filter, common::Unretained(impl_.get()), std::move(packet)));
801 }
802
WriteLocalName(std::string local_name)803 void Controller::WriteLocalName(std::string local_name) {
804 impl_->local_name_ = local_name;
805 GetHandler()->Post(common::BindOnce(&impl::write_local_name, common::Unretained(impl_.get()), local_name));
806 }
807
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)808 void Controller::HostBufferSize(uint16_t host_acl_data_packet_length, uint8_t host_synchronous_data_packet_length,
809 uint16_t host_total_num_acl_data_packets,
810 uint16_t host_total_num_synchronous_data_packets) {
811 GetHandler()->Post(common::BindOnce(&impl::host_buffer_size, common::Unretained(impl_.get()),
812 host_acl_data_packet_length, host_synchronous_data_packet_length,
813 host_total_num_acl_data_packets, host_total_num_synchronous_data_packets));
814 }
815
LeSetEventMask(uint64_t le_event_mask)816 void Controller::LeSetEventMask(uint64_t le_event_mask) {
817 GetHandler()->Post(common::BindOnce(&impl::le_set_event_mask, common::Unretained(impl_.get()), le_event_mask));
818 }
819
GetControllerLeBufferSize() const820 LeBufferSize Controller::GetControllerLeBufferSize() const {
821 return impl_->le_buffer_size_;
822 }
823
GetControllerLeLocalSupportedFeatures() const824 uint64_t Controller::GetControllerLeLocalSupportedFeatures() const {
825 return impl_->le_local_supported_features_;
826 }
827
GetControllerLeSupportedStates() const828 uint64_t Controller::GetControllerLeSupportedStates() const {
829 return impl_->le_supported_states_;
830 }
831
GetControllerLeMaximumDataLength() const832 LeMaximumDataLength Controller::GetControllerLeMaximumDataLength() const {
833 return impl_->le_maximum_data_length_;
834 }
835
GetControllerLeMaximumAdvertisingDataLength() const836 uint16_t Controller::GetControllerLeMaximumAdvertisingDataLength() const {
837 return impl_->le_maximum_advertising_data_length_;
838 }
839
GetControllerLeNumberOfSupportedAdverisingSets() const840 uint8_t Controller::GetControllerLeNumberOfSupportedAdverisingSets() const {
841 return impl_->le_number_supported_advertising_sets_;
842 }
843
GetControllerVendorCapabilities() const844 VendorCapabilities Controller::GetControllerVendorCapabilities() const {
845 return impl_->vendor_capabilities_;
846 }
847
IsSupported(bluetooth::hci::OpCode op_code) const848 bool Controller::IsSupported(bluetooth::hci::OpCode op_code) const {
849 return impl_->is_supported(op_code);
850 }
851
__anon28dbdb980102() 852 const ModuleFactory Controller::Factory = ModuleFactory([]() { return new Controller(); });
853
ListDependencies(ModuleList * list)854 void Controller::ListDependencies(ModuleList* list) {
855 list->add<hci::HciLayer>();
856 }
857
Start()858 void Controller::Start() {
859 impl_->Start(GetDependency<hci::HciLayer>());
860 }
861
Stop()862 void Controller::Stop() {
863 impl_->Stop();
864 }
865
ToString() const866 std::string Controller::ToString() const {
867 return "Controller";
868 }
869 } // namespace hci
870 } // namespace bluetooth
871