1 /* 2 * Copyright 2015 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 #define LOG_TAG "dual_mode_controller" 18 19 #include "dual_mode_controller.h" 20 #include "device_factory.h" 21 22 #include <memory> 23 24 #include <base/logging.h> 25 #include "base/files/file_util.h" 26 #include "base/json/json_reader.h" 27 #include "base/values.h" 28 29 #include "osi/include/log.h" 30 #include "osi/include/osi.h" 31 #include "stack/include/hcidefs.h" 32 33 using std::vector; 34 35 namespace { 36 37 // Included in certain events to indicate success (specific to the event 38 // context). 39 const uint8_t kSuccessStatus = 0; 40 41 const uint8_t kUnknownHciCommand = 1; 42 43 // The location of the config file loaded to populate controller attributes. 44 const std::string kControllerPropertiesFile = 45 "/etc/bluetooth/controller_properties.json"; 46 47 void LogCommand(const char* command) { 48 LOG_INFO(LOG_TAG, "Controller performing command: %s", command); 49 } 50 51 } // namespace 52 53 namespace test_vendor_lib { 54 55 void DualModeController::AddControllerEvent(std::chrono::milliseconds delay, 56 const TaskCallback& task) { 57 controller_events_.push_back(schedule_task_(delay, task)); 58 } 59 60 void DualModeController::AddConnectionAction(const TaskCallback& task, 61 uint16_t handle) { 62 for (size_t i = 0; i < connections_.size(); i++) 63 if (*connections_[i] == handle) connections_[i]->AddAction(task); 64 } 65 66 void DualModeController::SendCommandCompleteSuccess( 67 uint16_t command_opcode) const { 68 send_event_(EventPacket::CreateCommandCompleteOnlyStatusEvent( 69 command_opcode, kSuccessStatus)); 70 } 71 72 void DualModeController::SendCommandCompleteOnlyStatus(uint16_t command_opcode, 73 uint8_t status) const { 74 send_event_(EventPacket::CreateCommandCompleteOnlyStatusEvent(command_opcode, 75 status)); 76 } 77 78 void DualModeController::SendCommandStatus(uint8_t status, 79 uint16_t command_opcode) const { 80 send_event_(EventPacket::CreateCommandStatusEvent(status, command_opcode)); 81 } 82 83 void DualModeController::SendCommandStatusSuccess( 84 uint16_t command_opcode) const { 85 SendCommandStatus(kSuccessStatus, command_opcode); 86 } 87 88 DualModeController::DualModeController() 89 : state_(kStandby), properties_(kControllerPropertiesFile) { 90 devices_ = {}; 91 92 vector<std::string> beacon = {"beacon", "be:ac:10:00:00:01", "1000"}; 93 TestChannelAdd(beacon); 94 95 vector<std::string> classic = {std::string("classic"), 96 std::string("c1:a5:51:c0:00:01")}; 97 TestChannelAdd(classic); 98 99 vector<std::string> keyboard = {std::string("keyboard"), 100 std::string("cc:1c:eb:0a:12:d1"), 101 std::string("500")}; 102 TestChannelAdd(keyboard); 103 104 le_scan_enable_ = 0; 105 le_connect_ = false; 106 107 loopback_mode_ = 0; 108 109 #define SET_HANDLER(opcode, method) \ 110 active_hci_commands_[opcode] = [this](const vector<uint8_t>& param) { \ 111 method(param); \ 112 }; 113 SET_HANDLER(HCI_RESET, HciReset); 114 SET_HANDLER(HCI_READ_BUFFER_SIZE, HciReadBufferSize); 115 SET_HANDLER(HCI_HOST_BUFFER_SIZE, HciHostBufferSize); 116 SET_HANDLER(HCI_READ_LOCAL_VERSION_INFO, HciReadLocalVersionInformation); 117 SET_HANDLER(HCI_READ_BD_ADDR, HciReadBdAddr); 118 SET_HANDLER(HCI_READ_LOCAL_SUPPORTED_CMDS, HciReadLocalSupportedCommands); 119 SET_HANDLER(HCI_READ_LOCAL_SUPPORTED_CODECS, HciReadLocalSupportedCodecs); 120 SET_HANDLER(HCI_READ_LOCAL_EXT_FEATURES, HciReadLocalExtendedFeatures); 121 SET_HANDLER(HCI_WRITE_SIMPLE_PAIRING_MODE, HciWriteSimplePairingMode); 122 SET_HANDLER(HCI_WRITE_LE_HOST_SUPPORT, HciWriteLeHostSupport); 123 SET_HANDLER(HCI_SET_EVENT_MASK, HciSetEventMask); 124 SET_HANDLER(HCI_WRITE_INQUIRY_MODE, HciWriteInquiryMode); 125 SET_HANDLER(HCI_WRITE_PAGESCAN_TYPE, HciWritePageScanType); 126 SET_HANDLER(HCI_WRITE_INQSCAN_TYPE, HciWriteInquiryScanType); 127 SET_HANDLER(HCI_WRITE_CLASS_OF_DEVICE, HciWriteClassOfDevice); 128 SET_HANDLER(HCI_WRITE_PAGE_TOUT, HciWritePageTimeout); 129 SET_HANDLER(HCI_WRITE_DEF_POLICY_SETTINGS, HciWriteDefaultLinkPolicySettings); 130 SET_HANDLER(HCI_READ_LOCAL_NAME, HciReadLocalName); 131 SET_HANDLER(HCI_CHANGE_LOCAL_NAME, HciWriteLocalName); 132 SET_HANDLER(HCI_WRITE_EXT_INQ_RESPONSE, HciWriteExtendedInquiryResponse); 133 SET_HANDLER(HCI_WRITE_VOICE_SETTINGS, HciWriteVoiceSetting); 134 SET_HANDLER(HCI_WRITE_CURRENT_IAC_LAP, HciWriteCurrentIacLap); 135 SET_HANDLER(HCI_WRITE_INQUIRYSCAN_CFG, HciWriteInquiryScanActivity); 136 SET_HANDLER(HCI_WRITE_SCAN_ENABLE, HciWriteScanEnable); 137 SET_HANDLER(HCI_SET_EVENT_FILTER, HciSetEventFilter); 138 SET_HANDLER(HCI_INQUIRY, HciInquiry); 139 SET_HANDLER(HCI_INQUIRY_CANCEL, HciInquiryCancel); 140 SET_HANDLER(HCI_DELETE_STORED_LINK_KEY, HciDeleteStoredLinkKey); 141 SET_HANDLER(HCI_RMT_NAME_REQUEST, HciRemoteNameRequest); 142 SET_HANDLER(HCI_BLE_SET_EVENT_MASK, HciLeSetEventMask); 143 SET_HANDLER(HCI_BLE_READ_BUFFER_SIZE, HciLeReadBufferSize); 144 SET_HANDLER(HCI_BLE_READ_LOCAL_SPT_FEAT, HciLeReadLocalSupportedFeatures); 145 SET_HANDLER(HCI_BLE_WRITE_RANDOM_ADDR, HciLeSetRandomAddress); 146 SET_HANDLER(HCI_BLE_WRITE_ADV_DATA, HciLeSetAdvertisingData); 147 SET_HANDLER(HCI_BLE_WRITE_ADV_PARAMS, HciLeSetAdvertisingParameters); 148 SET_HANDLER(HCI_BLE_WRITE_SCAN_PARAMS, HciLeSetScanParameters); 149 SET_HANDLER(HCI_BLE_WRITE_SCAN_ENABLE, HciLeSetScanEnable); 150 SET_HANDLER(HCI_BLE_CREATE_LL_CONN, HciLeCreateConnection); 151 SET_HANDLER(HCI_BLE_CREATE_CONN_CANCEL, HciLeConnectionCancel); 152 SET_HANDLER(HCI_BLE_READ_WHITE_LIST_SIZE, HciLeReadWhiteListSize); 153 SET_HANDLER(HCI_BLE_RAND, HciLeRand); 154 SET_HANDLER(HCI_BLE_READ_SUPPORTED_STATES, HciLeReadSupportedStates); 155 SET_HANDLER((HCI_GRP_VENDOR_SPECIFIC | 0x27), HciBleVendorSleepMode); 156 SET_HANDLER(HCI_BLE_VENDOR_CAP_OCF, HciBleVendorCap); 157 SET_HANDLER(HCI_BLE_MULTI_ADV_OCF, HciBleVendorMultiAdv); 158 SET_HANDLER((HCI_GRP_VENDOR_SPECIFIC | 0x155), HciBleVendor155); 159 SET_HANDLER(HCI_BLE_ADV_FILTER_OCF, HciBleAdvertisingFilter); 160 SET_HANDLER(HCI_BLE_ENERGY_INFO_OCF, HciBleEnergyInfo); 161 SET_HANDLER(HCI_BLE_EXTENDED_SCAN_PARAMS_OCF, HciBleExtendedScanParams); 162 // Testing Commands 163 SET_HANDLER(HCI_READ_LOOPBACK_MODE, HciReadLoopbackMode); 164 SET_HANDLER(HCI_WRITE_LOOPBACK_MODE, HciWriteLoopbackMode); 165 #undef SET_HANDLER 166 167 #define SET_TEST_HANDLER(command_name, method) \ 168 active_test_channel_commands_[command_name] = \ 169 [this](const vector<std::string>& param) { method(param); }; 170 SET_TEST_HANDLER("add", TestChannelAdd); 171 SET_TEST_HANDLER("del", TestChannelDel); 172 SET_TEST_HANDLER("list", TestChannelList); 173 #undef SET_TEST_HANDLER 174 } 175 176 void DualModeController::RegisterTaskScheduler( 177 std::function<AsyncTaskId(std::chrono::milliseconds, const TaskCallback&)> 178 oneshotScheduler) { 179 schedule_task_ = oneshotScheduler; 180 } 181 182 void DualModeController::RegisterPeriodicTaskScheduler( 183 std::function<AsyncTaskId(std::chrono::milliseconds, 184 std::chrono::milliseconds, const TaskCallback&)> 185 periodicScheduler) { 186 schedule_periodic_task_ = periodicScheduler; 187 } 188 189 void DualModeController::RegisterTaskCancel( 190 std::function<void(AsyncTaskId)> task_cancel) { 191 cancel_task_ = task_cancel; 192 } 193 194 void DualModeController::HandleTestChannelCommand( 195 const std::string& name, const vector<std::string>& args) { 196 if (active_test_channel_commands_.count(name) == 0) return; 197 active_test_channel_commands_[name](args); 198 } 199 200 void DualModeController::HandleAcl(std::unique_ptr<AclPacket> acl_packet) { 201 if (loopback_mode_ == HCI_LOOPBACK_MODE_LOCAL) { 202 uint16_t channel = acl_packet->GetChannel(); 203 send_acl_(std::move(acl_packet)); 204 send_event_(EventPacket::CreateNumberOfCompletedPacketsEvent(channel, 1)); 205 return; 206 } 207 } 208 209 void DualModeController::HandleSco(std::unique_ptr<ScoPacket> sco_packet) { 210 if (loopback_mode_ == HCI_LOOPBACK_MODE_LOCAL) { 211 uint16_t channel = sco_packet->GetChannel(); 212 send_sco_(std::move(sco_packet)); 213 send_event_(EventPacket::CreateNumberOfCompletedPacketsEvent(channel, 1)); 214 return; 215 } 216 } 217 218 void DualModeController::HandleCommand( 219 std::unique_ptr<CommandPacket> command_packet) { 220 uint16_t opcode = command_packet->GetOpcode(); 221 LOG_INFO(LOG_TAG, "Command opcode: 0x%04X, OGF: 0x%04X, OCF: 0x%04X", opcode, 222 command_packet->GetOGF(), command_packet->GetOCF()); 223 224 if (loopback_mode_ == HCI_LOOPBACK_MODE_LOCAL && 225 // Loopback exceptions. 226 opcode != HCI_RESET && opcode != HCI_SET_HC_TO_HOST_FLOW_CTRL && 227 opcode != HCI_HOST_BUFFER_SIZE && opcode != HCI_HOST_NUM_PACKETS_DONE && 228 opcode != HCI_READ_BUFFER_SIZE && opcode != HCI_READ_LOOPBACK_MODE && 229 opcode != HCI_WRITE_LOOPBACK_MODE) { 230 send_event_(EventPacket::CreateLoopbackCommandEvent( 231 opcode, command_packet->GetPayload())); 232 } else if (active_hci_commands_.count(opcode) > 0) { 233 active_hci_commands_[opcode](command_packet->GetPayload()); 234 } else { 235 SendCommandCompleteOnlyStatus(opcode, kUnknownHciCommand); 236 } 237 } 238 239 void DualModeController::RegisterEventChannel( 240 const std::function<void(std::unique_ptr<EventPacket>)>& callback) { 241 send_event_ = callback; 242 } 243 244 void DualModeController::RegisterAclChannel( 245 const std::function<void(std::unique_ptr<AclPacket>)>& callback) { 246 send_acl_ = callback; 247 } 248 249 void DualModeController::RegisterScoChannel( 250 const std::function<void(std::unique_ptr<ScoPacket>)>& callback) { 251 send_sco_ = callback; 252 } 253 254 void DualModeController::HandleTimerTick() { 255 if (state_ == kInquiry) PageScan(); 256 if (le_scan_enable_ || le_connect_) LeScan(); 257 Connections(); 258 for (size_t dev = 0; dev < devices_.size(); dev++) devices_[dev]->TimerTick(); 259 } 260 261 void DualModeController::SetTimerPeriod(std::chrono::milliseconds new_period) { 262 timer_period_ = new_period; 263 264 if (timer_tick_task_ == kInvalidTaskId) return; 265 266 // Restart the timer with the new period 267 StopTimer(); 268 StartTimer(); 269 } 270 271 static uint8_t GetRssi(size_t dev) { 272 // TODO: Model rssi somehow 273 return -((dev * 16) % 127); 274 } 275 276 static uint8_t LeGetHandle() { 277 static int handle = 0; 278 return handle++; 279 } 280 281 static uint8_t LeGetConnInterval() { return 1; } 282 283 static uint8_t LeGetConnLatency() { return 2; } 284 285 static uint8_t LeGetSupervisionTimeout() { return 3; } 286 287 void DualModeController::Connections() { 288 for (size_t i = 0; i < connections_.size(); i++) { 289 if (connections_[i]->Connected()) { 290 connections_[i]->SendToDevice(); 291 vector<uint8_t> data; 292 connections_[i]->ReceiveFromDevice(data); 293 // HandleConnectionData(data); 294 } 295 } 296 } 297 298 void DualModeController::LeScan() { 299 std::unique_ptr<EventPacket> le_adverts = 300 EventPacket::CreateLeAdvertisingReportEvent(); 301 vector<uint8_t> ad; 302 for (size_t dev = 0; dev < devices_.size(); dev++) { 303 uint8_t adv_type; 304 const BtAddress addr = devices_[dev]->GetBtAddress(); 305 uint8_t addr_type = devices_[dev]->GetAddressType(); 306 ad.clear(); 307 308 // Listen for Advertisements 309 if (devices_[dev]->IsAdvertisementAvailable( 310 std::chrono::milliseconds(le_scan_window_))) { 311 ad = devices_[dev]->GetAdvertisement(); 312 adv_type = devices_[dev]->GetAdvertisementType(); 313 if (le_scan_enable_ && !le_adverts->AddLeAdvertisingReport( 314 adv_type, addr_type, addr, ad, GetRssi(dev))) { 315 send_event_(std::move(le_adverts)); 316 le_adverts = EventPacket::CreateLeAdvertisingReportEvent(); 317 CHECK(le_adverts->AddLeAdvertisingReport(adv_type, addr_type, addr, ad, 318 GetRssi(dev))); 319 } 320 321 // Connect 322 if (le_connect_ && (adv_type == BTM_BLE_CONNECT_EVT || 323 adv_type == BTM_BLE_CONNECT_DIR_EVT)) { 324 LOG_INFO(LOG_TAG, "Connecting to device %d", static_cast<int>(dev)); 325 if (peer_address_ == addr && peer_address_type_ == addr_type && 326 devices_[dev]->LeConnect()) { 327 uint16_t handle = LeGetHandle(); 328 std::unique_ptr<EventPacket> event = 329 EventPacket::CreateLeConnectionCompleteEvent( 330 kSuccessStatus, handle, HCI_ROLE_MASTER, addr_type, addr, 331 LeGetConnInterval(), LeGetConnLatency(), 332 LeGetSupervisionTimeout()); 333 send_event_(std::move(event)); 334 le_connect_ = false; 335 336 connections_.push_back( 337 std::make_shared<Connection>(devices_[dev], handle)); 338 } 339 340 // TODO: Handle the white list (if (InWhiteList(dev))) 341 } 342 343 // Active scanning 344 if (le_scan_enable_ && le_scan_type_ == 1) { 345 ad.clear(); 346 if (devices_[dev]->HasScanResponse()) { 347 ad = devices_[dev]->GetScanResponse(); 348 if (!le_adverts->AddLeAdvertisingReport( 349 BTM_BLE_SCAN_RSP_EVT, addr_type, addr, ad, GetRssi(dev))) { 350 send_event_(std::move(le_adverts)); 351 le_adverts = EventPacket::CreateLeAdvertisingReportEvent(); 352 CHECK(le_adverts->AddLeAdvertisingReport( 353 BTM_BLE_SCAN_RSP_EVT, addr_type, addr, ad, GetRssi(dev))); 354 } 355 } 356 } 357 } 358 } 359 360 if (le_scan_enable_) send_event_(std::move(le_adverts)); 361 } 362 363 void DualModeController::PageScan() { 364 // Inquiry modes for specifiying inquiry result formats. 365 static const uint8_t kStandardInquiry = 0x00; 366 static const uint8_t kRssiInquiry = 0x01; 367 static const uint8_t kExtendedOrRssiInquiry = 0x02; 368 369 switch (inquiry_mode_) { 370 case (kStandardInquiry): { 371 std::unique_ptr<EventPacket> inquiry_result = 372 EventPacket::CreateInquiryResultEvent(); 373 for (size_t dev = 0; dev < devices_.size(); dev++) 374 // Scan for devices 375 if (devices_[dev]->IsPageScanAvailable()) { 376 bool result_added = inquiry_result->AddInquiryResult( 377 devices_[dev]->GetBtAddress(), 378 devices_[dev]->GetPageScanRepetitionMode(), 379 devices_[dev]->GetDeviceClass(), devices_[dev]->GetClockOffset()); 380 if (!result_added) { 381 send_event_(std::move(inquiry_result)); 382 inquiry_result = EventPacket::CreateInquiryResultEvent(); 383 result_added = inquiry_result->AddInquiryResult( 384 devices_[dev]->GetBtAddress(), 385 devices_[dev]->GetPageScanRepetitionMode(), 386 devices_[dev]->GetDeviceClass(), 387 devices_[dev]->GetClockOffset()); 388 CHECK(result_added); 389 } 390 } 391 } break; 392 393 case (kRssiInquiry): 394 LOG_INFO(LOG_TAG, "RSSI Inquiry Mode currently not supported."); 395 break; 396 397 case (kExtendedOrRssiInquiry): 398 for (size_t dev = 0; dev < devices_.size(); dev++) 399 if (devices_[dev]->IsPageScanAvailable()) { 400 send_event_(EventPacket::CreateExtendedInquiryResultEvent( 401 devices_[dev]->GetBtAddress(), 402 devices_[dev]->GetPageScanRepetitionMode(), 403 devices_[dev]->GetDeviceClass(), devices_[dev]->GetClockOffset(), 404 GetRssi(dev), devices_[dev]->GetExtendedInquiryData())); 405 } 406 break; 407 } 408 } 409 410 void DualModeController::StartTimer() { 411 LOG_ERROR(LOG_TAG, "StartTimer"); 412 timer_tick_task_ = schedule_periodic_task_( 413 std::chrono::milliseconds(0), timer_period_, 414 [this]() { DualModeController::HandleTimerTick(); }); 415 } 416 417 void DualModeController::StopTimer() { 418 LOG_ERROR(LOG_TAG, "StopTimer"); 419 cancel_task_(timer_tick_task_); 420 timer_tick_task_ = kInvalidTaskId; 421 } 422 423 void DualModeController::SetEventDelay(int64_t delay) { 424 if (delay < 0) delay = 0; 425 } 426 427 void DualModeController::TestChannelAdd(const vector<std::string>& args) { 428 LogCommand("TestChannel 'add'"); 429 430 std::shared_ptr<Device> new_dev = DeviceFactory::Create(args); 431 432 if (new_dev == NULL) { 433 LOG_ERROR(LOG_TAG, "TestChannel 'add' failed!"); 434 return; 435 } 436 437 devices_.push_back(new_dev); 438 } 439 440 void DualModeController::TestChannelDel(const vector<std::string>& args) { 441 LogCommand("TestChannel 'del'"); 442 443 size_t dev_index = std::stoi(args[0]); 444 445 if (dev_index >= devices_.size()) { 446 LOG_INFO(LOG_TAG, "TestChannel 'del': index %d out of range!", 447 static_cast<int>(dev_index)); 448 } else { 449 devices_.erase(devices_.begin() + dev_index); 450 } 451 } 452 453 void DualModeController::TestChannelList( 454 UNUSED_ATTR const vector<std::string>& args) const { 455 LogCommand("TestChannel 'list'"); 456 LOG_INFO(LOG_TAG, "Devices:"); 457 for (size_t dev = 0; dev < devices_.size(); dev++) { 458 LOG_INFO(LOG_TAG, "%d:", static_cast<int>(dev)); 459 devices_[dev]->ToString(); 460 } 461 } 462 463 void DualModeController::HciReset(const vector<uint8_t>& args) { 464 LogCommand("Reset"); 465 CHECK(args[0] == 0); // No arguments 466 state_ = kStandby; 467 if (timer_tick_task_ != kInvalidTaskId) { 468 LOG_INFO(LOG_TAG, "The timer was already running!"); 469 StopTimer(); 470 } 471 LOG_INFO(LOG_TAG, "Starting timer."); 472 StartTimer(); 473 474 SendCommandCompleteSuccess(HCI_RESET); 475 } 476 477 void DualModeController::HciReadBufferSize(const vector<uint8_t>& args) { 478 LogCommand("Read Buffer Size"); 479 CHECK(args[0] == 0); // No arguments 480 std::unique_ptr<EventPacket> command_complete = 481 EventPacket::CreateCommandCompleteReadBufferSize( 482 kSuccessStatus, properties_.GetAclDataPacketSize(), 483 properties_.GetSynchronousDataPacketSize(), 484 properties_.GetTotalNumAclDataPackets(), 485 properties_.GetTotalNumSynchronousDataPackets()); 486 487 send_event_(std::move(command_complete)); 488 } 489 490 void DualModeController::HciHostBufferSize(const vector<uint8_t>& args) { 491 LogCommand("Host Buffer Size"); 492 CHECK(args[0] == 7); // No arguments 493 SendCommandCompleteSuccess(HCI_HOST_BUFFER_SIZE); 494 } 495 496 void DualModeController::HciReadLocalVersionInformation( 497 const vector<uint8_t>& args) { 498 LogCommand("Read Local Version Information"); 499 CHECK(args[0] == 0); // No arguments 500 std::unique_ptr<EventPacket> command_complete = 501 EventPacket::CreateCommandCompleteReadLocalVersionInformation( 502 kSuccessStatus, properties_.GetVersion(), properties_.GetRevision(), 503 properties_.GetLmpPalVersion(), properties_.GetManufacturerName(), 504 properties_.GetLmpPalSubversion()); 505 send_event_(std::move(command_complete)); 506 } 507 508 void DualModeController::HciReadBdAddr(const vector<uint8_t>& args) { 509 CHECK(args[0] == 0); // No arguments 510 std::unique_ptr<EventPacket> command_complete = 511 EventPacket::CreateCommandCompleteReadBdAddr(kSuccessStatus, 512 properties_.GetAddress()); 513 send_event_(std::move(command_complete)); 514 } 515 516 void DualModeController::HciReadLocalSupportedCommands( 517 const vector<uint8_t>& args) { 518 LogCommand("Read Local Supported Commands"); 519 CHECK(args[0] == 0); // No arguments 520 std::unique_ptr<EventPacket> command_complete = 521 EventPacket::CreateCommandCompleteReadLocalSupportedCommands( 522 kSuccessStatus, properties_.GetLocalSupportedCommands()); 523 send_event_(std::move(command_complete)); 524 } 525 526 void DualModeController::HciReadLocalSupportedCodecs( 527 const vector<uint8_t>& args) { 528 LogCommand("Read Local Supported Codecs"); 529 CHECK(args[0] == 0); // No arguments 530 std::unique_ptr<EventPacket> command_complete = 531 EventPacket::CreateCommandCompleteReadLocalSupportedCodecs( 532 kSuccessStatus, properties_.GetSupportedCodecs(), 533 properties_.GetVendorSpecificCodecs()); 534 send_event_(std::move(command_complete)); 535 } 536 537 void DualModeController::HciReadLocalExtendedFeatures( 538 const vector<uint8_t>& args) { 539 LogCommand("Read Local Extended Features"); 540 CHECK(args.size() == 2); 541 std::unique_ptr<EventPacket> command_complete = 542 EventPacket::CreateCommandCompleteReadLocalExtendedFeatures( 543 kSuccessStatus, args[1], 544 properties_.GetLocalExtendedFeaturesMaximumPageNumber(), 545 properties_.GetLocalExtendedFeatures(args[1])); 546 send_event_(std::move(command_complete)); 547 } 548 549 void DualModeController::HciWriteSimplePairingMode( 550 UNUSED_ATTR const vector<uint8_t>& args) { 551 LogCommand("Write Simple Pairing Mode"); 552 SendCommandCompleteSuccess(HCI_WRITE_SIMPLE_PAIRING_MODE); 553 } 554 555 void DualModeController::HciWriteLeHostSupport( 556 UNUSED_ATTR const vector<uint8_t>& args) { 557 LogCommand("Write Le Host Support"); 558 SendCommandCompleteSuccess(HCI_WRITE_LE_HOST_SUPPORT); 559 } 560 561 void DualModeController::HciSetEventMask( 562 UNUSED_ATTR const vector<uint8_t>& args) { 563 LogCommand("Set Event Mask"); 564 SendCommandCompleteSuccess(HCI_SET_EVENT_MASK); 565 } 566 567 void DualModeController::HciWriteInquiryMode(const vector<uint8_t>& args) { 568 LogCommand("Write Inquiry Mode"); 569 CHECK(args.size() == 2); 570 inquiry_mode_ = args[1]; 571 SendCommandCompleteSuccess(HCI_WRITE_INQUIRY_MODE); 572 } 573 574 void DualModeController::HciWritePageScanType( 575 UNUSED_ATTR const vector<uint8_t>& args) { 576 LogCommand("Write Page Scan Type"); 577 SendCommandCompleteSuccess(HCI_WRITE_PAGESCAN_TYPE); 578 } 579 580 void DualModeController::HciWriteInquiryScanType( 581 UNUSED_ATTR const vector<uint8_t>& args) { 582 LogCommand("Write Inquiry Scan Type"); 583 SendCommandCompleteSuccess(HCI_WRITE_INQSCAN_TYPE); 584 } 585 586 void DualModeController::HciWriteClassOfDevice( 587 UNUSED_ATTR const vector<uint8_t>& args) { 588 LogCommand("Write Class Of Device"); 589 SendCommandCompleteSuccess(HCI_WRITE_CLASS_OF_DEVICE); 590 } 591 592 void DualModeController::HciWritePageTimeout( 593 UNUSED_ATTR const vector<uint8_t>& args) { 594 LogCommand("Write Page Timeout"); 595 SendCommandCompleteSuccess(HCI_WRITE_PAGE_TOUT); 596 } 597 598 void DualModeController::HciWriteDefaultLinkPolicySettings( 599 UNUSED_ATTR const vector<uint8_t>& args) { 600 LogCommand("Write Default Link Policy Settings"); 601 SendCommandCompleteSuccess(HCI_WRITE_DEF_POLICY_SETTINGS); 602 } 603 604 void DualModeController::HciReadLocalName( 605 UNUSED_ATTR const vector<uint8_t>& args) { 606 LogCommand("Get Local Name"); 607 std::unique_ptr<EventPacket> command_complete = 608 EventPacket::CreateCommandCompleteReadLocalName( 609 kSuccessStatus, properties_.GetLocalName()); 610 send_event_(std::move(command_complete)); 611 } 612 613 void DualModeController::HciWriteLocalName( 614 UNUSED_ATTR const vector<uint8_t>& args) { 615 LogCommand("Write Local Name"); 616 SendCommandCompleteSuccess(HCI_CHANGE_LOCAL_NAME); 617 } 618 619 void DualModeController::HciWriteExtendedInquiryResponse( 620 UNUSED_ATTR const vector<uint8_t>& args) { 621 LogCommand("Write Extended Inquiry Response"); 622 SendCommandCompleteSuccess(HCI_WRITE_EXT_INQ_RESPONSE); 623 } 624 625 void DualModeController::HciWriteVoiceSetting( 626 UNUSED_ATTR const vector<uint8_t>& args) { 627 LogCommand("Write Voice Setting"); 628 SendCommandCompleteSuccess(HCI_WRITE_VOICE_SETTINGS); 629 } 630 631 void DualModeController::HciWriteCurrentIacLap( 632 UNUSED_ATTR const vector<uint8_t>& args) { 633 LogCommand("Write Current IAC LAP"); 634 SendCommandCompleteSuccess(HCI_WRITE_CURRENT_IAC_LAP); 635 } 636 637 void DualModeController::HciWriteInquiryScanActivity( 638 UNUSED_ATTR const vector<uint8_t>& args) { 639 LogCommand("Write Inquiry Scan Activity"); 640 SendCommandCompleteSuccess(HCI_WRITE_INQUIRYSCAN_CFG); 641 } 642 643 void DualModeController::HciWriteScanEnable( 644 UNUSED_ATTR const vector<uint8_t>& args) { 645 LogCommand("Write Scan Enable"); 646 SendCommandCompleteSuccess(HCI_WRITE_SCAN_ENABLE); 647 } 648 649 void DualModeController::HciSetEventFilter( 650 UNUSED_ATTR const vector<uint8_t>& args) { 651 LogCommand("Set Event Filter"); 652 SendCommandCompleteSuccess(HCI_SET_EVENT_FILTER); 653 } 654 655 void DualModeController::HciInquiry(const vector<uint8_t>& args) { 656 LogCommand("Inquiry"); 657 CHECK(args.size() == 6); 658 state_ = kInquiry; 659 SendCommandStatusSuccess(HCI_INQUIRY); 660 inquiry_lap_[0] = args[1]; 661 inquiry_lap_[1] = args[2]; 662 inquiry_lap_[2] = args[3]; 663 664 AddControllerEvent(std::chrono::milliseconds(args[4] * 1280), 665 [this]() { DualModeController::InquiryTimeout(); }); 666 667 if (args[5] > 0) { 668 inquiry_responses_limited_ = true; 669 inquiry_num_responses_ = args[5]; 670 } 671 } 672 673 void DualModeController::HciInquiryCancel( 674 UNUSED_ATTR const vector<uint8_t>& args) { 675 LogCommand("Inquiry Cancel"); 676 CHECK(state_ == kInquiry); 677 state_ = kStandby; 678 SendCommandCompleteSuccess(HCI_INQUIRY_CANCEL); 679 } 680 681 void DualModeController::InquiryTimeout() { 682 LOG_INFO(LOG_TAG, "InquiryTimer fired"); 683 if (state_ == kInquiry) { 684 state_ = kStandby; 685 inquiry_responses_limited_ = false; 686 send_event_(EventPacket::CreateInquiryCompleteEvent(kSuccessStatus)); 687 } 688 } 689 690 void DualModeController::HciDeleteStoredLinkKey( 691 UNUSED_ATTR const vector<uint8_t>& args) { 692 LogCommand("Delete Stored Link Key"); 693 /* Check the last octect in |args|. If it is 0, delete only the link key for 694 * the given BD_ADDR. If is is 1, delete all stored link keys. */ 695 uint16_t deleted_keys = 1; 696 697 send_event_(EventPacket::CreateCommandCompleteDeleteStoredLinkKey( 698 kSuccessStatus, deleted_keys)); 699 } 700 701 void DualModeController::HciRemoteNameRequest( 702 UNUSED_ATTR const vector<uint8_t>& args) { 703 LogCommand("Remote Name Request"); 704 SendCommandStatusSuccess(HCI_RMT_NAME_REQUEST); 705 } 706 707 void DualModeController::HciLeSetEventMask(const vector<uint8_t>& args) { 708 LogCommand("LE SetEventMask"); 709 le_event_mask_ = args; 710 SendCommandCompleteSuccess(HCI_BLE_SET_EVENT_MASK); 711 } 712 713 void DualModeController::HciLeReadBufferSize( 714 UNUSED_ATTR const vector<uint8_t>& args) { 715 std::unique_ptr<EventPacket> command_complete = 716 EventPacket::CreateCommandCompleteLeReadBufferSize( 717 kSuccessStatus, properties_.GetLeDataPacketLength(), 718 properties_.GetTotalNumLeDataPackets()); 719 send_event_(std::move(command_complete)); 720 } 721 722 void DualModeController::HciLeReadLocalSupportedFeatures( 723 UNUSED_ATTR const vector<uint8_t>& args) { 724 std::unique_ptr<EventPacket> command_complete = 725 EventPacket::CreateCommandCompleteLeReadLocalSupportedFeatures( 726 kSuccessStatus, properties_.GetLeLocalSupportedFeatures()); 727 send_event_(std::move(command_complete)); 728 } 729 730 void DualModeController::HciLeSetRandomAddress(const vector<uint8_t>& args) { 731 LogCommand("LE SetRandomAddress"); 732 CHECK(args.size() == 7); 733 vector<uint8_t> new_addr = {args[1], args[2], args[3], 734 args[4], args[5], args[6]}; 735 CHECK(le_random_address_.FromVector(new_addr)); 736 SendCommandCompleteSuccess(HCI_BLE_WRITE_RANDOM_ADDR); 737 } 738 739 void DualModeController::HciLeSetAdvertisingParameters( 740 UNUSED_ATTR const vector<uint8_t>& args) { 741 LogCommand("LE SetAdvertisingParameters"); 742 SendCommandCompleteSuccess(HCI_BLE_WRITE_ADV_PARAMS); 743 } 744 745 void DualModeController::HciLeSetAdvertisingData( 746 UNUSED_ATTR const vector<uint8_t>& args) { 747 LogCommand("LE SetAdvertisingData"); 748 SendCommandCompleteSuccess(HCI_BLE_WRITE_ADV_DATA); 749 } 750 751 void DualModeController::HciLeSetScanParameters(const vector<uint8_t>& args) { 752 LogCommand("LE SetScanParameters"); 753 CHECK(args.size() == 8); 754 le_scan_type_ = args[1]; 755 le_scan_interval_ = args[2] | (args[3] << 8); 756 le_scan_window_ = args[4] | (args[5] << 8); 757 own_address_type_ = args[6]; 758 scanning_filter_policy_ = args[7]; 759 SendCommandCompleteSuccess(HCI_BLE_WRITE_SCAN_PARAMS); 760 } 761 762 void DualModeController::HciLeSetScanEnable(const vector<uint8_t>& args) { 763 LogCommand("LE SetScanEnable"); 764 CHECK(args.size() == 3); 765 le_scan_enable_ = args[1]; 766 filter_duplicates_ = args[2]; 767 SendCommandCompleteSuccess(HCI_BLE_WRITE_SCAN_ENABLE); 768 } 769 770 void DualModeController::HciLeCreateConnection(const vector<uint8_t>& args) { 771 LogCommand("LE CreateConnection"); 772 le_connect_ = true; 773 le_scan_interval_ = args[1] | (args[2] << 8); 774 le_scan_window_ = args[3] | (args[4] << 8); 775 initiator_filter_policy_ = args[5]; 776 777 if (initiator_filter_policy_ == 0) { // White list not used 778 peer_address_type_ = args[6]; 779 vector<uint8_t> peer_addr = {args[7], args[8], args[9], 780 args[10], args[11], args[12]}; 781 peer_address_.FromVector(peer_addr); 782 } 783 784 SendCommandStatusSuccess(HCI_BLE_CREATE_LL_CONN); 785 } 786 787 void DualModeController::HciLeConnectionCancel(const vector<uint8_t>& args) { 788 LogCommand("LE ConnectionCancel"); 789 CHECK(args[0] == 0); // No arguments 790 le_connect_ = false; 791 SendCommandStatusSuccess(HCI_BLE_CREATE_CONN_CANCEL); 792 } 793 794 void DualModeController::HciLeReadWhiteListSize(const vector<uint8_t>& args) { 795 LogCommand("LE ReadWhiteListSize"); 796 CHECK(args[0] == 0); // No arguments 797 std::unique_ptr<EventPacket> command_complete = 798 EventPacket::CreateCommandCompleteLeReadWhiteListSize( 799 kSuccessStatus, properties_.GetLeWhiteListSize()); 800 send_event_(std::move(command_complete)); 801 } 802 803 void DualModeController::HciLeReadRemoteUsedFeaturesB(uint16_t handle) { 804 uint64_t features; 805 LogCommand("LE ReadRemoteUsedFeatures Bottom half"); 806 807 for (size_t i = 0; i < connections_.size(); i++) 808 if (*connections_[i] == handle) 809 // TODO: 810 // features = connections_[i]->GetDevice()->GetUsedFeatures(); 811 features = 0xffffffffffffffff; 812 813 std::unique_ptr<EventPacket> event = 814 EventPacket::CreateLeRemoteUsedFeaturesEvent(kSuccessStatus, handle, 815 features); 816 send_event_(std::move(event)); 817 } 818 819 void DualModeController::HciLeReadRemoteUsedFeatures( 820 const vector<uint8_t>& args) { 821 LogCommand("LE ReadRemoteUsedFeatures"); 822 CHECK(args.size() == 3); 823 824 uint16_t handle = args[1] | (args[2] << 8); 825 826 AddConnectionAction( 827 [this, handle]() { 828 DualModeController::HciLeReadRemoteUsedFeaturesB(handle); 829 }, 830 handle); 831 832 SendCommandStatusSuccess(HCI_BLE_READ_REMOTE_FEAT); 833 } 834 835 void DualModeController::HciLeRand(UNUSED_ATTR const vector<uint8_t>& args) { 836 uint64_t random_val = rand(); 837 std::unique_ptr<EventPacket> command_complete = 838 EventPacket::CreateCommandCompleteLeRand(kSuccessStatus, random_val); 839 send_event_(std::move(command_complete)); 840 } 841 842 void DualModeController::HciLeReadSupportedStates( 843 UNUSED_ATTR const vector<uint8_t>& args) { 844 std::unique_ptr<EventPacket> command_complete = 845 EventPacket::CreateCommandCompleteLeReadSupportedStates( 846 kSuccessStatus, properties_.GetLeSupportedStates()); 847 send_event_(std::move(command_complete)); 848 } 849 850 void DualModeController::HciBleVendorSleepMode( 851 UNUSED_ATTR const vector<uint8_t>& args) { 852 SendCommandCompleteOnlyStatus(HCI_GRP_VENDOR_SPECIFIC | 0x27, 853 kUnknownHciCommand); 854 } 855 856 void DualModeController::HciBleVendorCap( 857 UNUSED_ATTR const vector<uint8_t>& args) { 858 vector<uint8_t> caps = properties_.GetLeVendorCap(); 859 if (caps.size() == 0) { 860 SendCommandCompleteOnlyStatus(HCI_BLE_VENDOR_CAP_OCF, kUnknownHciCommand); 861 return; 862 } 863 864 std::unique_ptr<EventPacket> command_complete = 865 EventPacket::CreateCommandCompleteLeVendorCap( 866 kSuccessStatus, properties_.GetLeVendorCap()); 867 send_event_(std::move(command_complete)); 868 } 869 870 void DualModeController::HciBleVendorMultiAdv( 871 UNUSED_ATTR const vector<uint8_t>& args) { 872 SendCommandCompleteOnlyStatus(HCI_BLE_MULTI_ADV_OCF, kUnknownHciCommand); 873 } 874 875 void DualModeController::HciBleVendor155( 876 UNUSED_ATTR const vector<uint8_t>& args) { 877 SendCommandCompleteOnlyStatus(HCI_GRP_VENDOR_SPECIFIC | 0x155, 878 kUnknownHciCommand); 879 } 880 881 void DualModeController::HciBleAdvertisingFilter( 882 UNUSED_ATTR const vector<uint8_t>& args) { 883 SendCommandCompleteOnlyStatus(HCI_BLE_ADV_FILTER_OCF, kUnknownHciCommand); 884 } 885 886 void DualModeController::HciBleEnergyInfo( 887 UNUSED_ATTR const vector<uint8_t>& args) { 888 SendCommandCompleteOnlyStatus(HCI_BLE_ENERGY_INFO_OCF, kUnknownHciCommand); 889 } 890 891 void DualModeController::HciBleExtendedScanParams( 892 UNUSED_ATTR const vector<uint8_t>& args) { 893 SendCommandCompleteOnlyStatus(HCI_BLE_EXTENDED_SCAN_PARAMS_OCF, 894 kUnknownHciCommand); 895 } 896 897 void DualModeController::HciReadLoopbackMode(const vector<uint8_t>& args) { 898 CHECK(args[0] == 0); // No arguments 899 std::unique_ptr<EventPacket> command_complete = 900 EventPacket::CreateCommandCompleteReadLoopbackMode(kSuccessStatus, 901 loopback_mode_); 902 send_event_(std::move(command_complete)); 903 } 904 905 void DualModeController::HciWriteLoopbackMode(const vector<uint8_t>& args) { 906 CHECK(args[0] == 1); 907 loopback_mode_ = args[1]; 908 // ACL channel 909 uint16_t acl_handle = 0x123; 910 send_event_(EventPacket::CreateConnectionCompleteEvent( 911 kSuccessStatus, acl_handle, properties_.GetAddress(), HCI_LINK_TYPE_ACL, 912 false)); 913 // SCO channel 914 uint16_t sco_handle = 0x345; 915 send_event_(EventPacket::CreateConnectionCompleteEvent( 916 kSuccessStatus, sco_handle, properties_.GetAddress(), HCI_LINK_TYPE_SCO, 917 false)); 918 SendCommandCompleteSuccess(HCI_WRITE_LOOPBACK_MODE); 919 } 920 921 } // namespace test_vendor_lib 922
