wifi/1.0/default/wifi_chip.cpp

   1 /*
   2  * Copyright (C) 2016 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 <android-base/logging.h>
  18
  19 #include "hidl_return_util.h"
  20 #include "hidl_struct_util.h"
  21 #include "wifi_chip.h"
  22 #include "wifi_feature_flags.h"
  23 #include "wifi_status_util.h"
  24
  25 namespace {
  26 using android::sp;
  27 using android::hardware::hidl_vec;
  28 using android::hardware::hidl_string;
  29 using android::hardware::wifi::V1_0::ChipModeId;
  30 using android::hardware::wifi::V1_0::IWifiChip;
  31 using android::hardware::wifi::V1_0::IfaceType;
  32
  33 constexpr ChipModeId kStaChipModeId = 0;
  34 constexpr ChipModeId kApChipModeId = 1;
  35 constexpr ChipModeId kInvalidModeId = UINT32_MAX;
  36
  37 template <typename Iface>
  38 void invalidateAndClear(sp<Iface>& iface) {
  39   if (iface.get()) {
  40     iface->invalidate();
  41     iface.clear();
  42   }
  43 }
  44 }  // namepsace
  45
  46 namespace android {
  47 namespace hardware {
  48 namespace wifi {
  49 namespace V1_0 {
  50 namespace implementation {
  51 using hidl_return_util::validateAndCall;
  52
  53 WifiChip::WifiChip(
  54     ChipId chip_id,
  55     const std::weak_ptr<legacy_hal::WifiLegacyHal> legacy_hal,
  56     const std::weak_ptr<mode_controller::WifiModeController> mode_controller)
  57     : chip_id_(chip_id),
  58       legacy_hal_(legacy_hal),
  59       mode_controller_(mode_controller),
  60       is_valid_(true),
  61       current_mode_id_(kInvalidModeId),
  62       debug_ring_buffer_cb_registered_(false) {}
  63
  64 void WifiChip::invalidate() {
  65   invalidateAndRemoveAllIfaces();
  66   legacy_hal_.reset();
  67   event_cb_handler_.invalidate();
  68   is_valid_ = false;
  69 }
  70
  71 bool WifiChip::isValid() {
  72   return is_valid_;
  73 }
  74
  75 std::set<sp<IWifiChipEventCallback>> WifiChip::getEventCallbacks() {
  76   return event_cb_handler_.getCallbacks();
  77 }
  78
  79 Return<void> WifiChip::getId(getId_cb hidl_status_cb) {
  80   return validateAndCall(this,
  81                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
  82                          &WifiChip::getIdInternal,
  83                          hidl_status_cb);
  84 }
  85
  86 Return<void> WifiChip::registerEventCallback(
  87     const sp<IWifiChipEventCallback>& event_callback,
  88     registerEventCallback_cb hidl_status_cb) {
  89   return validateAndCall(this,
  90                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
  91                          &WifiChip::registerEventCallbackInternal,
  92                          hidl_status_cb,
  93                          event_callback);
  94 }
  95
  96 Return<void> WifiChip::getCapabilities(getCapabilities_cb hidl_status_cb) {
  97   return validateAndCall(this,
  98                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
  99                          &WifiChip::getCapabilitiesInternal,
 100                          hidl_status_cb);
 101 }
 102
 103 Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {
 104   return validateAndCall(this,
 105                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 106                          &WifiChip::getAvailableModesInternal,
 107                          hidl_status_cb);
 108 }
 109
 110 Return<void> WifiChip::configureChip(ChipModeId mode_id,
 111                                      configureChip_cb hidl_status_cb) {
 112   return validateAndCall(this,
 113                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 114                          &WifiChip::configureChipInternal,
 115                          hidl_status_cb,
 116                          mode_id);
 117 }
 118
 119 Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {
 120   return validateAndCall(this,
 121                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 122                          &WifiChip::getModeInternal,
 123                          hidl_status_cb);
 124 }
 125
 126 Return<void> WifiChip::requestChipDebugInfo(
 127     requestChipDebugInfo_cb hidl_status_cb) {
 128   return validateAndCall(this,
 129                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 130                          &WifiChip::requestChipDebugInfoInternal,
 131                          hidl_status_cb);
 132 }
 133
 134 Return<void> WifiChip::requestDriverDebugDump(
 135     requestDriverDebugDump_cb hidl_status_cb) {
 136   return validateAndCall(this,
 137                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 138                          &WifiChip::requestDriverDebugDumpInternal,
 139                          hidl_status_cb);
 140 }
 141
 142 Return<void> WifiChip::requestFirmwareDebugDump(
 143     requestFirmwareDebugDump_cb hidl_status_cb) {
 144   return validateAndCall(this,
 145                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 146                          &WifiChip::requestFirmwareDebugDumpInternal,
 147                          hidl_status_cb);
 148 }
 149
 150 Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {
 151   return validateAndCall(this,
 152                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 153                          &WifiChip::createApIfaceInternal,
 154                          hidl_status_cb);
 155 }
 156
 157 Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {
 158   return validateAndCall(this,
 159                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 160                          &WifiChip::getApIfaceNamesInternal,
 161                          hidl_status_cb);
 162 }
 163
 164 Return<void> WifiChip::getApIface(const hidl_string& ifname,
 165                                   getApIface_cb hidl_status_cb) {
 166   return validateAndCall(this,
 167                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 168                          &WifiChip::getApIfaceInternal,
 169                          hidl_status_cb,
 170                          ifname);
 171 }
 172
 173 Return<void> WifiChip::removeApIface(const hidl_string& ifname,
 174                                      removeApIface_cb hidl_status_cb) {
 175   return validateAndCall(this,
 176                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 177                          &WifiChip::removeApIfaceInternal,
 178                          hidl_status_cb,
 179                          ifname);
 180 }
 181
 182 Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {
 183   return validateAndCall(this,
 184                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 185                          &WifiChip::createNanIfaceInternal,
 186                          hidl_status_cb);
 187 }
 188
 189 Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {
 190   return validateAndCall(this,
 191                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 192                          &WifiChip::getNanIfaceNamesInternal,
 193                          hidl_status_cb);
 194 }
 195
 196 Return<void> WifiChip::getNanIface(const hidl_string& ifname,
 197                                    getNanIface_cb hidl_status_cb) {
 198   return validateAndCall(this,
 199                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 200                          &WifiChip::getNanIfaceInternal,
 201                          hidl_status_cb,
 202                          ifname);
 203 }
 204
 205 Return<void> WifiChip::removeNanIface(const hidl_string& ifname,
 206                                       removeNanIface_cb hidl_status_cb) {
 207   return validateAndCall(this,
 208                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 209                          &WifiChip::removeNanIfaceInternal,
 210                          hidl_status_cb,
 211                          ifname);
 212 }
 213
 214 Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {
 215   return validateAndCall(this,
 216                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 217                          &WifiChip::createP2pIfaceInternal,
 218                          hidl_status_cb);
 219 }
 220
 221 Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {
 222   return validateAndCall(this,
 223                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 224                          &WifiChip::getP2pIfaceNamesInternal,
 225                          hidl_status_cb);
 226 }
 227
 228 Return<void> WifiChip::getP2pIface(const hidl_string& ifname,
 229                                    getP2pIface_cb hidl_status_cb) {
 230   return validateAndCall(this,
 231                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 232                          &WifiChip::getP2pIfaceInternal,
 233                          hidl_status_cb,
 234                          ifname);
 235 }
 236
 237 Return<void> WifiChip::removeP2pIface(const hidl_string& ifname,
 238                                       removeP2pIface_cb hidl_status_cb) {
 239   return validateAndCall(this,
 240                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 241                          &WifiChip::removeP2pIfaceInternal,
 242                          hidl_status_cb,
 243                          ifname);
 244 }
 245
 246 Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {
 247   return validateAndCall(this,
 248                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 249                          &WifiChip::createStaIfaceInternal,
 250                          hidl_status_cb);
 251 }
 252
 253 Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {
 254   return validateAndCall(this,
 255                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 256                          &WifiChip::getStaIfaceNamesInternal,
 257                          hidl_status_cb);
 258 }
 259
 260 Return<void> WifiChip::getStaIface(const hidl_string& ifname,
 261                                    getStaIface_cb hidl_status_cb) {
 262   return validateAndCall(this,
 263                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 264                          &WifiChip::getStaIfaceInternal,
 265                          hidl_status_cb,
 266                          ifname);
 267 }
 268
 269 Return<void> WifiChip::removeStaIface(const hidl_string& ifname,
 270                                       removeStaIface_cb hidl_status_cb) {
 271   return validateAndCall(this,
 272                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 273                          &WifiChip::removeStaIfaceInternal,
 274                          hidl_status_cb,
 275                          ifname);
 276 }
 277
 278 Return<void> WifiChip::createRttController(
 279     const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {
 280   return validateAndCall(this,
 281                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 282                          &WifiChip::createRttControllerInternal,
 283                          hidl_status_cb,
 284                          bound_iface);
 285 }
 286
 287 Return<void> WifiChip::getDebugRingBuffersStatus(
 288     getDebugRingBuffersStatus_cb hidl_status_cb) {
 289   return validateAndCall(this,
 290                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 291                          &WifiChip::getDebugRingBuffersStatusInternal,
 292                          hidl_status_cb);
 293 }
 294
 295 Return<void> WifiChip::startLoggingToDebugRingBuffer(
 296     const hidl_string& ring_name,
 297     WifiDebugRingBufferVerboseLevel verbose_level,
 298     uint32_t max_interval_in_sec,
 299     uint32_t min_data_size_in_bytes,
 300     startLoggingToDebugRingBuffer_cb hidl_status_cb) {
 301   return validateAndCall(this,
 302                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 303                          &WifiChip::startLoggingToDebugRingBufferInternal,
 304                          hidl_status_cb,
 305                          ring_name,
 306                          verbose_level,
 307                          max_interval_in_sec,
 308                          min_data_size_in_bytes);
 309 }
 310
 311 Return<void> WifiChip::forceDumpToDebugRingBuffer(
 312     const hidl_string& ring_name,
 313     forceDumpToDebugRingBuffer_cb hidl_status_cb) {
 314   return validateAndCall(this,
 315                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 316                          &WifiChip::forceDumpToDebugRingBufferInternal,
 317                          hidl_status_cb,
 318                          ring_name);
 319 }
 320
 321 Return<void> WifiChip::stopLoggingToDebugRingBuffer(
 322     stopLoggingToDebugRingBuffer_cb hidl_status_cb) {
 323   return validateAndCall(this,
 324                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 325                          &WifiChip::stopLoggingToDebugRingBufferInternal,
 326                          hidl_status_cb);
 327 }
 328
 329 Return<void> WifiChip::getDebugHostWakeReasonStats(
 330     getDebugHostWakeReasonStats_cb hidl_status_cb) {
 331   return validateAndCall(this,
 332                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 333                          &WifiChip::getDebugHostWakeReasonStatsInternal,
 334                          hidl_status_cb);
 335 }
 336
 337 Return<void> WifiChip::enableDebugErrorAlerts(
 338     bool enable, enableDebugErrorAlerts_cb hidl_status_cb) {
 339   return validateAndCall(this,
 340                          WifiStatusCode::ERROR_WIFI_CHIP_INVALID,
 341                          &WifiChip::enableDebugErrorAlertsInternal,
 342                          hidl_status_cb,
 343                          enable);
 344 }
 345
 346 void WifiChip::invalidateAndRemoveAllIfaces() {
 347   invalidateAndClear(ap_iface_);
 348   invalidateAndClear(nan_iface_);
 349   invalidateAndClear(p2p_iface_);
 350   invalidateAndClear(sta_iface_);
 351   // Since all the ifaces are invalid now, all RTT controller objects
 352   // using those ifaces also need to be invalidated.
 353   for (const auto& rtt : rtt_controllers_) {
 354     rtt->invalidate();
 355   }
 356   rtt_controllers_.clear();
 357 }
 358
 359 std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {
 360   return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};
 361 }
 362
 363 WifiStatus WifiChip::registerEventCallbackInternal(
 364     const sp<IWifiChipEventCallback>& event_callback) {
 365   if (!event_cb_handler_.addCallback(event_callback)) {
 366     return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
 367   }
 368   return createWifiStatus(WifiStatusCode::SUCCESS);
 369 }
 370
 371 std::pair<WifiStatus, uint32_t> WifiChip::getCapabilitiesInternal() {
 372   legacy_hal::wifi_error legacy_status;
 373   uint32_t legacy_logger_feature_set;
 374   std::tie(legacy_status, legacy_logger_feature_set) =
 375       legacy_hal_.lock()->getLoggerSupportedFeatureSet();
 376   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 377     return {createWifiStatusFromLegacyError(legacy_status), 0};
 378   }
 379   uint32_t hidl_caps;
 380   if (!hidl_struct_util::convertLegacyFeaturesToHidlChipCapabilities(
 381           legacy_logger_feature_set, &hidl_caps)) {
 382     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), 0};
 383   }
 384   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_caps};
 385 }
 386
 387 std::pair<WifiStatus, std::vector<IWifiChip::ChipMode>>
 388 WifiChip::getAvailableModesInternal() {
 389   // The chip combination supported for current devices is fixed for now with
 390   // 2 separate modes of operation:
 391   // Mode 1 (STA mode): Will support 1 STA and 1 P2P or NAN iface operations
 392   // concurrently [NAN conditional on wifiHidlFeatureAware]
 393   // Mode 2 (AP mode): Will support 1 AP iface operations.
 394   // TODO (b/32997844): Read this from some device specific flags in the
 395   // makefile.
 396   // STA mode iface combinations.
 397   const IWifiChip::ChipIfaceCombinationLimit
 398       sta_chip_iface_combination_limit_1 = {{IfaceType::STA}, 1};
 399   IWifiChip::ChipIfaceCombinationLimit sta_chip_iface_combination_limit_2;
 400   if (WifiFeatureFlags::wifiHidlFeatureAware) {
 401     sta_chip_iface_combination_limit_2 = {{IfaceType::P2P, IfaceType::NAN},
 402                                           1};
 403   } else {
 404     sta_chip_iface_combination_limit_2 = {{IfaceType::P2P},
 405                                           1};
 406   }
 407   const IWifiChip::ChipIfaceCombination sta_chip_iface_combination = {
 408       {sta_chip_iface_combination_limit_1, sta_chip_iface_combination_limit_2}};
 409   const IWifiChip::ChipMode sta_chip_mode = {kStaChipModeId,
 410                                              {sta_chip_iface_combination}};
 411   // AP mode iface combinations.
 412   const IWifiChip::ChipIfaceCombinationLimit ap_chip_iface_combination_limit = {
 413       {IfaceType::AP}, 1};
 414   const IWifiChip::ChipIfaceCombination ap_chip_iface_combination = {
 415       {ap_chip_iface_combination_limit}};
 416   const IWifiChip::ChipMode ap_chip_mode = {kApChipModeId,
 417                                             {ap_chip_iface_combination}};
 418   return {createWifiStatus(WifiStatusCode::SUCCESS),
 419           {sta_chip_mode, ap_chip_mode}};
 420 }
 421
 422 WifiStatus WifiChip::configureChipInternal(ChipModeId mode_id) {
 423   if (mode_id != kStaChipModeId && mode_id != kApChipModeId) {
 424     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
 425   }
 426   if (mode_id == current_mode_id_) {
 427     LOG(DEBUG) << "Already in the specified mode " << mode_id;
 428     return createWifiStatus(WifiStatusCode::SUCCESS);
 429   }
 430   WifiStatus status = handleChipConfiguration(mode_id);
 431   if (status.code != WifiStatusCode::SUCCESS) {
 432     for (const auto& callback : event_cb_handler_.getCallbacks()) {
 433       if (!callback->onChipReconfigureFailure(status).isOk()) {
 434         LOG(ERROR) << "Failed to invoke onChipReconfigureFailure callback";
 435       }
 436     }
 437     return status;
 438   }
 439   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 440     if (!callback->onChipReconfigured(mode_id).isOk()) {
 441       LOG(ERROR) << "Failed to invoke onChipReconfigured callback";
 442     }
 443   }
 444   current_mode_id_ = mode_id;
 445   return status;
 446 }
 447
 448 std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {
 449   if (current_mode_id_ == kInvalidModeId) {
 450     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE),
 451             current_mode_id_};
 452   }
 453   return {createWifiStatus(WifiStatusCode::SUCCESS), current_mode_id_};
 454 }
 455
 456 std::pair<WifiStatus, IWifiChip::ChipDebugInfo>
 457 WifiChip::requestChipDebugInfoInternal() {
 458   IWifiChip::ChipDebugInfo result;
 459   legacy_hal::wifi_error legacy_status;
 460   std::string driver_desc;
 461   std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();
 462   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 463     LOG(ERROR) << "Failed to get driver version: "
 464                << legacyErrorToString(legacy_status);
 465     WifiStatus status = createWifiStatusFromLegacyError(
 466         legacy_status, "failed to get driver version");
 467     return {status, result};
 468   }
 469   result.driverDescription = driver_desc.c_str();
 470
 471   std::string firmware_desc;
 472   std::tie(legacy_status, firmware_desc) =
 473       legacy_hal_.lock()->getFirmwareVersion();
 474   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 475     LOG(ERROR) << "Failed to get firmware version: "
 476                << legacyErrorToString(legacy_status);
 477     WifiStatus status = createWifiStatusFromLegacyError(
 478         legacy_status, "failed to get firmware version");
 479     return {status, result};
 480   }
 481   result.firmwareDescription = firmware_desc.c_str();
 482
 483   return {createWifiStatus(WifiStatusCode::SUCCESS), result};
 484 }
 485
 486 std::pair<WifiStatus, std::vector<uint8_t>>
 487 WifiChip::requestDriverDebugDumpInternal() {
 488   legacy_hal::wifi_error legacy_status;
 489   std::vector<uint8_t> driver_dump;
 490   std::tie(legacy_status, driver_dump) =
 491       legacy_hal_.lock()->requestDriverMemoryDump();
 492   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 493     LOG(ERROR) << "Failed to get driver debug dump: "
 494                << legacyErrorToString(legacy_status);
 495     return {createWifiStatusFromLegacyError(legacy_status),
 496             std::vector<uint8_t>()};
 497   }
 498   return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};
 499 }
 500
 501 std::pair<WifiStatus, std::vector<uint8_t>>
 502 WifiChip::requestFirmwareDebugDumpInternal() {
 503   legacy_hal::wifi_error legacy_status;
 504   std::vector<uint8_t> firmware_dump;
 505   std::tie(legacy_status, firmware_dump) =
 506       legacy_hal_.lock()->requestFirmwareMemoryDump();
 507   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 508     LOG(ERROR) << "Failed to get firmware debug dump: "
 509                << legacyErrorToString(legacy_status);
 510     return {createWifiStatusFromLegacyError(legacy_status), {}};
 511   }
 512   return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};
 513 }
 514
 515 std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {
 516   if (current_mode_id_ != kApChipModeId || ap_iface_.get()) {
 517     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
 518   }
 519   std::string ifname = legacy_hal_.lock()->getApIfaceName();
 520   ap_iface_ = new WifiApIface(ifname, legacy_hal_);
 521   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 522     if (!callback->onIfaceAdded(IfaceType::AP, ifname).isOk()) {
 523       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
 524     }
 525   }
 526   return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};
 527 }
 528
 529 std::pair<WifiStatus, std::vector<hidl_string>>
 530 WifiChip::getApIfaceNamesInternal() {
 531   if (!ap_iface_.get()) {
 532     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
 533   }
 534   return {createWifiStatus(WifiStatusCode::SUCCESS),
 535           {legacy_hal_.lock()->getApIfaceName()}};
 536 }
 537
 538 std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::getApIfaceInternal(
 539     const std::string& ifname) {
 540   if (!ap_iface_.get() || (ifname != legacy_hal_.lock()->getApIfaceName())) {
 541     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
 542   }
 543   return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};
 544 }
 545
 546 WifiStatus WifiChip::removeApIfaceInternal(const std::string& ifname) {
 547   if (!ap_iface_.get() || (ifname != legacy_hal_.lock()->getApIfaceName())) {
 548     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
 549   }
 550   invalidateAndClear(ap_iface_);
 551   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 552     if (!callback->onIfaceRemoved(IfaceType::AP, ifname).isOk()) {
 553       LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
 554     }
 555   }
 556   return createWifiStatus(WifiStatusCode::SUCCESS);
 557 }
 558
 559 std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {
 560   // Only 1 of NAN or P2P iface can be active at a time.
 561   if (WifiFeatureFlags::wifiHidlFeatureAware) {
 562     if (current_mode_id_ != kStaChipModeId || nan_iface_.get() ||
 563         p2p_iface_.get()) {
 564       return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
 565     }
 566     std::string ifname = legacy_hal_.lock()->getNanIfaceName();
 567     nan_iface_ = new WifiNanIface(ifname, legacy_hal_);
 568     for (const auto& callback : event_cb_handler_.getCallbacks()) {
 569       if (!callback->onIfaceAdded(IfaceType::NAN, ifname).isOk()) {
 570         LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
 571       }
 572     }
 573     return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
 574   } else {
 575     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
 576   }
 577 }
 578
 579 std::pair<WifiStatus, std::vector<hidl_string>>
 580 WifiChip::getNanIfaceNamesInternal() {
 581   if (!nan_iface_.get()) {
 582     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
 583   }
 584   return {createWifiStatus(WifiStatusCode::SUCCESS),
 585           {legacy_hal_.lock()->getNanIfaceName()}};
 586 }
 587
 588 std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::getNanIfaceInternal(
 589     const std::string& ifname) {
 590   if (!nan_iface_.get() || (ifname != legacy_hal_.lock()->getNanIfaceName())) {
 591     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
 592   }
 593   return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};
 594 }
 595
 596 WifiStatus WifiChip::removeNanIfaceInternal(const std::string& ifname) {
 597   if (!nan_iface_.get() || (ifname != legacy_hal_.lock()->getNanIfaceName())) {
 598     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
 599   }
 600   invalidateAndClear(nan_iface_);
 601   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 602     if (!callback->onIfaceRemoved(IfaceType::NAN, ifname).isOk()) {
 603       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
 604     }
 605   }
 606   return createWifiStatus(WifiStatusCode::SUCCESS);
 607 }
 608
 609 std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {
 610   // Only 1 of NAN or P2P iface can be active at a time.
 611   if (current_mode_id_ != kStaChipModeId || p2p_iface_.get() ||
 612       nan_iface_.get()) {
 613     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
 614   }
 615   std::string ifname = legacy_hal_.lock()->getP2pIfaceName();
 616   p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);
 617   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 618     if (!callback->onIfaceAdded(IfaceType::P2P, ifname).isOk()) {
 619       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
 620     }
 621   }
 622   return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};
 623 }
 624
 625 std::pair<WifiStatus, std::vector<hidl_string>>
 626 WifiChip::getP2pIfaceNamesInternal() {
 627   if (!p2p_iface_.get()) {
 628     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
 629   }
 630   return {createWifiStatus(WifiStatusCode::SUCCESS),
 631           {legacy_hal_.lock()->getP2pIfaceName()}};
 632 }
 633
 634 std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(
 635     const std::string& ifname) {
 636   if (!p2p_iface_.get() || (ifname != legacy_hal_.lock()->getP2pIfaceName())) {
 637     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
 638   }
 639   return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};
 640 }
 641
 642 WifiStatus WifiChip::removeP2pIfaceInternal(const std::string& ifname) {
 643   if (!p2p_iface_.get() || (ifname != legacy_hal_.lock()->getP2pIfaceName())) {
 644     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
 645   }
 646   invalidateAndClear(p2p_iface_);
 647   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 648     if (!callback->onIfaceRemoved(IfaceType::P2P, ifname).isOk()) {
 649       LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
 650     }
 651   }
 652   return createWifiStatus(WifiStatusCode::SUCCESS);
 653 }
 654
 655 std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::createStaIfaceInternal() {
 656   if (current_mode_id_ != kStaChipModeId || sta_iface_.get()) {
 657     return {createWifiStatus(WifiStatusCode::ERROR_NOT_AVAILABLE), {}};
 658   }
 659   std::string ifname = legacy_hal_.lock()->getStaIfaceName();
 660   sta_iface_ = new WifiStaIface(ifname, legacy_hal_);
 661   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 662     if (!callback->onIfaceAdded(IfaceType::STA, ifname).isOk()) {
 663       LOG(ERROR) << "Failed to invoke onIfaceAdded callback";
 664     }
 665   }
 666   return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};
 667 }
 668
 669 std::pair<WifiStatus, std::vector<hidl_string>>
 670 WifiChip::getStaIfaceNamesInternal() {
 671   if (!sta_iface_.get()) {
 672     return {createWifiStatus(WifiStatusCode::SUCCESS), {}};
 673   }
 674   return {createWifiStatus(WifiStatusCode::SUCCESS),
 675           {legacy_hal_.lock()->getStaIfaceName()}};
 676 }
 677
 678 std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::getStaIfaceInternal(
 679     const std::string& ifname) {
 680   if (!sta_iface_.get() || (ifname != legacy_hal_.lock()->getStaIfaceName())) {
 681     return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};
 682   }
 683   return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};
 684 }
 685
 686 WifiStatus WifiChip::removeStaIfaceInternal(const std::string& ifname) {
 687   if (!sta_iface_.get() || (ifname != legacy_hal_.lock()->getStaIfaceName())) {
 688     return createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS);
 689   }
 690   invalidateAndClear(sta_iface_);
 691   for (const auto& callback : event_cb_handler_.getCallbacks()) {
 692     if (!callback->onIfaceRemoved(IfaceType::STA, ifname).isOk()) {
 693       LOG(ERROR) << "Failed to invoke onIfaceRemoved callback";
 694     }
 695   }
 696   return createWifiStatus(WifiStatusCode::SUCCESS);
 697 }
 698
 699 std::pair<WifiStatus, sp<IWifiRttController>>
 700 WifiChip::createRttControllerInternal(const sp<IWifiIface>& bound_iface) {
 701   sp<WifiRttController> rtt = new WifiRttController(bound_iface, legacy_hal_);
 702   rtt_controllers_.emplace_back(rtt);
 703   return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};
 704 }
 705
 706 std::pair<WifiStatus, std::vector<WifiDebugRingBufferStatus>>
 707 WifiChip::getDebugRingBuffersStatusInternal() {
 708   legacy_hal::wifi_error legacy_status;
 709   std::vector<legacy_hal::wifi_ring_buffer_status>
 710       legacy_ring_buffer_status_vec;
 711   std::tie(legacy_status, legacy_ring_buffer_status_vec) =
 712       legacy_hal_.lock()->getRingBuffersStatus();
 713   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 714     return {createWifiStatusFromLegacyError(legacy_status), {}};
 715   }
 716   std::vector<WifiDebugRingBufferStatus> hidl_ring_buffer_status_vec;
 717   if (!hidl_struct_util::convertLegacyVectorOfDebugRingBufferStatusToHidl(
 718           legacy_ring_buffer_status_vec, &hidl_ring_buffer_status_vec)) {
 719     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
 720   }
 721   return {createWifiStatus(WifiStatusCode::SUCCESS),
 722           hidl_ring_buffer_status_vec};
 723 }
 724
 725 WifiStatus WifiChip::startLoggingToDebugRingBufferInternal(
 726     const hidl_string& ring_name,
 727     WifiDebugRingBufferVerboseLevel verbose_level,
 728     uint32_t max_interval_in_sec,
 729     uint32_t min_data_size_in_bytes) {
 730   WifiStatus status = registerDebugRingBufferCallback();
 731   if (status.code != WifiStatusCode::SUCCESS) {
 732     return status;
 733   }
 734   legacy_hal::wifi_error legacy_status =
 735       legacy_hal_.lock()->startRingBufferLogging(
 736           ring_name,
 737           static_cast<
 738               std::underlying_type<WifiDebugRingBufferVerboseLevel>::type>(
 739               verbose_level),
 740           max_interval_in_sec,
 741           min_data_size_in_bytes);
 742   return createWifiStatusFromLegacyError(legacy_status);
 743 }
 744
 745 WifiStatus WifiChip::forceDumpToDebugRingBufferInternal(
 746     const hidl_string& ring_name) {
 747   WifiStatus status = registerDebugRingBufferCallback();
 748   if (status.code != WifiStatusCode::SUCCESS) {
 749     return status;
 750   }
 751   legacy_hal::wifi_error legacy_status =
 752       legacy_hal_.lock()->getRingBufferData(ring_name);
 753   return createWifiStatusFromLegacyError(legacy_status);
 754 }
 755
 756 WifiStatus WifiChip::stopLoggingToDebugRingBufferInternal() {
 757   legacy_hal::wifi_error legacy_status =
 758       legacy_hal_.lock()->deregisterRingBufferCallbackHandler();
 759   return createWifiStatusFromLegacyError(legacy_status);
 760 }
 761
 762 std::pair<WifiStatus, WifiDebugHostWakeReasonStats>
 763 WifiChip::getDebugHostWakeReasonStatsInternal() {
 764   legacy_hal::wifi_error legacy_status;
 765   legacy_hal::WakeReasonStats legacy_stats;
 766   std::tie(legacy_status, legacy_stats) =
 767       legacy_hal_.lock()->getWakeReasonStats();
 768   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 769     return {createWifiStatusFromLegacyError(legacy_status), {}};
 770   }
 771   WifiDebugHostWakeReasonStats hidl_stats;
 772   if (!hidl_struct_util::convertLegacyWakeReasonStatsToHidl(legacy_stats,
 773                                                             &hidl_stats)) {
 774     return {createWifiStatus(WifiStatusCode::ERROR_UNKNOWN), {}};
 775   }
 776   return {createWifiStatus(WifiStatusCode::SUCCESS), hidl_stats};
 777 }
 778
 779 WifiStatus WifiChip::enableDebugErrorAlertsInternal(bool enable) {
 780   legacy_hal::wifi_error legacy_status;
 781   if (enable) {
 782     android::wp<WifiChip> weak_ptr_this(this);
 783     const auto& on_alert_callback = [weak_ptr_this](
 784         int32_t error_code, std::vector<uint8_t> debug_data) {
 785       const auto shared_ptr_this = weak_ptr_this.promote();
 786       if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
 787         LOG(ERROR) << "Callback invoked on an invalid object";
 788         return;
 789       }
 790       for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
 791         if (!callback->onDebugErrorAlert(error_code, debug_data).isOk()) {
 792           LOG(ERROR) << "Failed to invoke onDebugErrorAlert callback";
 793         }
 794       }
 795     };
 796     legacy_status = legacy_hal_.lock()->registerErrorAlertCallbackHandler(
 797         on_alert_callback);
 798   } else {
 799     legacy_status = legacy_hal_.lock()->deregisterErrorAlertCallbackHandler();
 800   }
 801   return createWifiStatusFromLegacyError(legacy_status);
 802 }
 803
 804 WifiStatus WifiChip::handleChipConfiguration(ChipModeId mode_id) {
 805   // If the chip is already configured in a different mode, stop
 806   // the legacy HAL and then start it after firmware mode change.
 807   // Currently the underlying implementation has a deadlock issue.
 808   // We should return ERROR_NOT_SUPPORTED if chip is already configured in
 809   // a different mode.
 810   if (current_mode_id_ != kInvalidModeId) {
 811     // TODO(b/37446050): Fix the deadlock.
 812     return createWifiStatus(WifiStatusCode::ERROR_NOT_SUPPORTED);
 813   }
 814   bool success;
 815   if (mode_id == kStaChipModeId) {
 816     success = mode_controller_.lock()->changeFirmwareMode(IfaceType::STA);
 817   } else {
 818     success = mode_controller_.lock()->changeFirmwareMode(IfaceType::AP);
 819   }
 820   if (!success) {
 821     return createWifiStatus(WifiStatusCode::ERROR_UNKNOWN);
 822   }
 823   legacy_hal::wifi_error legacy_status = legacy_hal_.lock()->start();
 824   if (legacy_status != legacy_hal::WIFI_SUCCESS) {
 825     LOG(ERROR) << "Failed to start legacy HAL: "
 826                << legacyErrorToString(legacy_status);
 827     return createWifiStatusFromLegacyError(legacy_status);
 828   }
 829   return createWifiStatus(WifiStatusCode::SUCCESS);
 830 }
 831
 832 WifiStatus WifiChip::registerDebugRingBufferCallback() {
 833   if (debug_ring_buffer_cb_registered_) {
 834     return createWifiStatus(WifiStatusCode::SUCCESS);
 835   }
 836
 837   android::wp<WifiChip> weak_ptr_this(this);
 838   const auto& on_ring_buffer_data_callback = [weak_ptr_this](
 839       const std::string& /* name */,
 840       const std::vector<uint8_t>& data,
 841       const legacy_hal::wifi_ring_buffer_status& status) {
 842     const auto shared_ptr_this = weak_ptr_this.promote();
 843     if (!shared_ptr_this.get() || !shared_ptr_this->isValid()) {
 844       LOG(ERROR) << "Callback invoked on an invalid object";
 845       return;
 846     }
 847     WifiDebugRingBufferStatus hidl_status;
 848     if (!hidl_struct_util::convertLegacyDebugRingBufferStatusToHidl(
 849             status, &hidl_status)) {
 850       LOG(ERROR) << "Error converting ring buffer status";
 851       return;
 852     }
 853     for (const auto& callback : shared_ptr_this->getEventCallbacks()) {
 854       if (!callback->onDebugRingBufferDataAvailable(hidl_status, data).isOk()) {
 855         LOG(ERROR) << "Failed to invoke onDebugRingBufferDataAvailable"
 856                    << " callback on: " << toString(callback);
 857
 858       }
 859     }
 860   };
 861   legacy_hal::wifi_error legacy_status =
 862       legacy_hal_.lock()->registerRingBufferCallbackHandler(
 863           on_ring_buffer_data_callback);
 864
 865   if (legacy_status == legacy_hal::WIFI_SUCCESS) {
 866     debug_ring_buffer_cb_registered_ = true;
 867   }
 868   return createWifiStatusFromLegacyError(legacy_status);
 869 }
 870
 871 }  // namespace implementation
 872 }  // namespace V1_0
 873 }  // namespace wifi
 874 }  // namespace hardware
 875 }  // namespace android