Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c9b1f317 authored by Roshan Pius's avatar Roshan Pius Committed by android-build-merger
Browse files

wifi: Use hidl_return_util functions in WifiChip am: 3c86852a am: 70221582 am: 01f66f52 

am: 81b9b066

Change-Id: I8368f49b1044417ef3f48fdbab942441b3fa4899
parents a9a44ed9 81b9b066

wifi/1.0/default/wifi_chip.cpp

+269 −271
Original line number Diff line number Diff line
@@ -14,10 +14,10 @@ 
 * limitations under the License.

 */



#include "wifi_chip.h"



#include <android-base/logging.h>



#include "hidl_return_util.h"

#include "wifi_chip.h"

#include "wifi_status_util.h"



namespace {
@@ -25,14 +25,6 @@ using android::sp; 
using android::hardware::hidl_vec;

using android::hardware::hidl_string;



std::vector<hidl_string> createHidlVecOfIfaceNames(const std::string& ifname) {

  std::vector<hidl_string> ifnames;

  if (!ifname.empty()) {

    ifnames.emplace_back(ifname);

  }

  return ifnames;

}



template <typename Iface>

void invalidateAndClear(sp<Iface>& iface) {

  if (iface.get()) {
@@ -47,6 +39,7 @@ namespace hardware { 
namespace wifi {

namespace V1_0 {

namespace implementation {

using hidl_return_util::validateAndCall;



WifiChip::WifiChip(ChipId chip_id,

                   const std::weak_ptr<WifiLegacyHal> legacy_hal)
@@ -59,75 +52,220 @@ void WifiChip::invalidate() { 
  is_valid_ = false;

}



Return<void> WifiChip::getId(getId_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   UINT32_MAX);

    return Void();

bool WifiChip::isValid() {

  return is_valid_;

}

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), chip_id_);

  return Void();



Return<void> WifiChip::getId(getId_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getIdInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::registerEventCallback(

    const sp<IWifiChipEventCallback>& event_callback,

    registerEventCallback_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID));

    return Void();

  }

  // TODO(b/31632518): remove the callback when the client is destroyed

  event_callbacks_.emplace_back(event_callback);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS));

  return Void();

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::registerEventCallbackInternal,

                         hidl_status_cb,

                         event_callback);

}



Return<void> WifiChip::getAvailableModes(getAvailableModes_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<ChipMode>());

    return Void();

  }

  // TODO add implementation

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 hidl_vec<ChipMode>());

  return Void();

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getAvailableModesInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::configureChip(uint32_t /*mode_id*/,

Return<void> WifiChip::configureChip(uint32_t mode_id,

                                     configureChip_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID));

    return Void();

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::configureChipInternal,

                         hidl_status_cb,

                         mode_id);

}



  invalidateAndRemoveAllIfaces();

  // TODO add implementation

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS));

  return Void();

Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getModeInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getMode(getMode_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   UINT32_MAX);

    return Void();

Return<void> WifiChip::requestChipDebugInfo(

    requestChipDebugInfo_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::requestChipDebugInfoInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::requestDriverDebugDump(

    requestDriverDebugDump_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::requestDriverDebugDumpInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::requestFirmwareDebugDump(

    requestFirmwareDebugDump_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::requestFirmwareDebugDumpInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::createApIfaceInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getApIfaceNamesInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getApIface(const hidl_string& ifname,

                                  getApIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getApIfaceInternal,

                         hidl_status_cb,

                         ifname);

}



Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::createNanIfaceInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getNanIfaceNamesInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getNanIface(const hidl_string& ifname,

                                   getNanIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getNanIfaceInternal,

                         hidl_status_cb,

                         ifname);

}



Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::createP2pIfaceInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getP2pIfaceNamesInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getP2pIface(const hidl_string& ifname,

                                   getP2pIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getP2pIfaceInternal,

                         hidl_status_cb,

                         ifname);

}



Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::createStaIfaceInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getStaIfaceNamesInternal,

                         hidl_status_cb);

}



Return<void> WifiChip::getStaIface(const hidl_string& ifname,

                                   getStaIface_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::getStaIfaceInternal,

                         hidl_status_cb,

                         ifname);

}



Return<void> WifiChip::createRttController(

    const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {

  return validateAndCall(this,

                         WifiStatusCode::ERROR_WIFI_CHIP_INVALID,

                         &WifiChip::createRttControllerInternal,

                         hidl_status_cb,

                         bound_iface);

}



void WifiChip::invalidateAndRemoveAllIfaces() {

  invalidateAndClear(ap_iface_);

  invalidateAndClear(nan_iface_);

  invalidateAndClear(p2p_iface_);

  invalidateAndClear(sta_iface_);

  // Since all the ifaces are invalid now, all RTT controller objects

  // using those ifaces also need to be invalidated.

  for (const auto& rtt : rtt_controllers_) {

    rtt->invalidate();

  }

  rtt_controllers_.clear();

}



std::pair<WifiStatus, ChipId> WifiChip::getIdInternal() {

  return {createWifiStatus(WifiStatusCode::SUCCESS), chip_id_};

}



WifiStatus WifiChip::registerEventCallbackInternal(

    const sp<IWifiChipEventCallback>& event_callback) {

  // TODO(b/31632518): remove the callback when the client is destroyed

  event_callbacks_.emplace_back(event_callback);

  return createWifiStatus(WifiStatusCode::SUCCESS);

}



std::pair<WifiStatus, std::vector<IWifiChip::ChipMode>>

WifiChip::getAvailableModesInternal() {

  // TODO add implementation

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), 0);

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS),

          std::vector<IWifiChip::ChipMode>()};

}



Return<void> WifiChip::requestChipDebugInfo(

    requestChipDebugInfo_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   IWifiChip::ChipDebugInfo());

    return Void();

WifiStatus WifiChip::configureChipInternal(uint32_t /* mode_id */) {

  invalidateAndRemoveAllIfaces();

  // TODO add implementation

  return createWifiStatus(WifiStatusCode::SUCCESS);

}



  IWifiChip::ChipDebugInfo result;

std::pair<WifiStatus, uint32_t> WifiChip::getModeInternal() {

  // TODO add implementation

  return {createWifiStatus(WifiStatusCode::SUCCESS), 0};

}



std::pair<WifiStatus, IWifiChip::ChipDebugInfo>

WifiChip::requestChipDebugInfoInternal() {

  IWifiChip::ChipDebugInfo result;

  wifi_error legacy_status;

  std::string driver_desc;

  std::tie(legacy_status, driver_desc) = legacy_hal_.lock()->getDriverVersion();
@@ -136,8 +274,7 @@ Return<void> WifiChip::requestChipDebugInfo( 
               << legacyErrorToString(legacy_status);

    WifiStatus status = createWifiStatusFromLegacyError(

        legacy_status, "failed to get driver version");

    hidl_status_cb(status, result);

    return Void();

    return {status, result};

  }

  result.driverDescription = driver_desc.c_str();
@@ -149,288 +286,149 @@ Return<void> WifiChip::requestChipDebugInfo( 
               << legacyErrorToString(legacy_status);

    WifiStatus status = createWifiStatusFromLegacyError(

        legacy_status, "failed to get firmware version");

    hidl_status_cb(status, result);

    return Void();

    return {status, result};

  }

  result.firmwareDescription = firmware_desc.c_str();



  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), result);

  return Void();

}



Return<void> WifiChip::requestDriverDebugDump(

    requestDriverDebugDump_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<uint8_t>());

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), result};

}



std::pair<WifiStatus, std::vector<uint8_t>>

WifiChip::requestDriverDebugDumpInternal() {

  wifi_error legacy_status;

  std::vector<char> driver_dump;

  std::vector<uint8_t> driver_dump;

  std::tie(legacy_status, driver_dump) =

      legacy_hal_.lock()->requestDriverMemoryDump();

  if (legacy_status != WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get driver debug dump: "

               << legacyErrorToString(legacy_status);

    hidl_status_cb(createWifiStatusFromLegacyError(legacy_status),

                   hidl_vec<uint8_t>());

    return Void();

  }



  hidl_vec<uint8_t> hidl_data;

  hidl_data.setToExternal(reinterpret_cast<uint8_t*>(driver_dump.data()),

                          driver_dump.size());

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), hidl_data);

  return Void();

    return {createWifiStatusFromLegacyError(legacy_status),

            std::vector<uint8_t>()};

  }



Return<void> WifiChip::requestFirmwareDebugDump(

    requestFirmwareDebugDump_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<uint8_t>());

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), driver_dump};

}



std::pair<WifiStatus, std::vector<uint8_t>>

WifiChip::requestFirmwareDebugDumpInternal() {

  wifi_error legacy_status;

  std::vector<char> firmware_dump;

  std::vector<uint8_t> firmware_dump;

  std::tie(legacy_status, firmware_dump) =

      legacy_hal_.lock()->requestFirmwareMemoryDump();

  if (legacy_status != WIFI_SUCCESS) {

    LOG(ERROR) << "Failed to get firmware debug dump: "

               << legacyErrorToString(legacy_status);

    hidl_status_cb(createWifiStatusFromLegacyError(legacy_status),

                   hidl_vec<uint8_t>());

    return Void();

    return {createWifiStatusFromLegacyError(legacy_status),

            std::vector<uint8_t>()};

  }



  hidl_vec<uint8_t> hidl_data;

  hidl_data.setToExternal(reinterpret_cast<uint8_t*>(firmware_dump.data()),

                          firmware_dump.size());

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), hidl_data);

  return Void();

}



Return<void> WifiChip::createApIface(createApIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), firmware_dump};

}



std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::createApIfaceInternal() {

  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getApIfaceName();

  ap_iface_ = new WifiApIface(ifname, legacy_hal_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_);

  return Void();

}



Return<void> WifiChip::getApIfaceNames(getApIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};

}



  std::string ifname;

  if (ap_iface_.get()) {

    ifname = legacy_hal_.lock()->getApIfaceName().c_str();

std::pair<WifiStatus, std::vector<hidl_string>>

WifiChip::getApIfaceNamesInternal() {

  if (!ap_iface_.get()) {

    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS),

          {legacy_hal_.lock()->getApIfaceName()}};

}



Return<void> WifiChip::getApIface(const hidl_string& ifname,

                                  getApIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (ap_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getApIfaceName())) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_);

  } else {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

  }

  return Void();

std::pair<WifiStatus, sp<IWifiApIface>> WifiChip::getApIfaceInternal(

    const hidl_string& ifname) {

  if (!ap_iface_.get() ||

      (ifname.c_str() != legacy_hal_.lock()->getApIfaceName())) {

    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};

  }



Return<void> WifiChip::createNanIface(createNanIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), ap_iface_};

}



std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::createNanIfaceInternal() {

  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getNanIfaceName();

  nan_iface_ = new WifiNanIface(ifname, legacy_hal_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_);

  return Void();

}



Return<void> WifiChip::getNanIfaceNames(getNanIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};

}



  std::string ifname;

  if (nan_iface_.get()) {

    ifname = legacy_hal_.lock()->getNanIfaceName().c_str();

std::pair<WifiStatus, std::vector<hidl_string>>

WifiChip::getNanIfaceNamesInternal() {

  if (!nan_iface_.get()) {

    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS),

          {legacy_hal_.lock()->getNanIfaceName()}};

}



Return<void> WifiChip::getNanIface(const hidl_string& ifname,

                                   getNanIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (nan_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getNanIfaceName())) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_);

  } else {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

std::pair<WifiStatus, sp<IWifiNanIface>> WifiChip::getNanIfaceInternal(

    const hidl_string& ifname) {

  if (!nan_iface_.get() ||

      (ifname.c_str() != legacy_hal_.lock()->getNanIfaceName())) {

    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};

  }

  return Void();

}



Return<void> WifiChip::createP2pIface(createP2pIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), nan_iface_};

}



std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::createP2pIfaceInternal() {

  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getP2pIfaceName();

  p2p_iface_ = new WifiP2pIface(ifname, legacy_hal_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_);

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};

}



Return<void> WifiChip::getP2pIfaceNames(getP2pIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

std::pair<WifiStatus, std::vector<hidl_string>>

WifiChip::getP2pIfaceNamesInternal() {

  if (!p2p_iface_.get()) {

    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};

  }



  std::string ifname;

  if (p2p_iface_.get()) {

    ifname = legacy_hal_.lock()->getP2pIfaceName().c_str();

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS),

          {legacy_hal_.lock()->getP2pIfaceName()}};

}



Return<void> WifiChip::getP2pIface(const hidl_string& ifname,

                                   getP2pIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  }



  if (p2p_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getP2pIfaceName())) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_);

  } else {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

std::pair<WifiStatus, sp<IWifiP2pIface>> WifiChip::getP2pIfaceInternal(

    const hidl_string& ifname) {

  if (!p2p_iface_.get() ||

      (ifname.c_str() != legacy_hal_.lock()->getP2pIfaceName())) {

    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};

  }

  return Void();

}



Return<void> WifiChip::createStaIface(createStaIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), p2p_iface_};

}



std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::createStaIfaceInternal() {

  // TODO(b/31997422): Disallow this based on the chip combination.

  std::string ifname = legacy_hal_.lock()->getStaIfaceName();

  sta_iface_ = new WifiStaIface(ifname, legacy_hal_);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_);

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};

}



Return<void> WifiChip::getStaIfaceNames(getStaIfaceNames_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   hidl_vec<hidl_string>());

    return Void();

  }



  std::string ifname;

  if (sta_iface_.get()) {

    ifname = legacy_hal_.lock()->getStaIfaceName().c_str();

  }

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS),

                 createHidlVecOfIfaceNames(ifname));

  return Void();

std::pair<WifiStatus, std::vector<hidl_string>>

WifiChip::getStaIfaceNamesInternal() {

  if (!sta_iface_.get()) {

    return {createWifiStatus(WifiStatusCode::SUCCESS), {}};

  }



Return<void> WifiChip::getStaIface(const hidl_string& ifname,

                                   getStaIface_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS),

          {legacy_hal_.lock()->getStaIfaceName()}};

}



  if (sta_iface_.get() &&

      (ifname.c_str() == legacy_hal_.lock()->getStaIfaceName())) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_);

  } else {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS),

                   nullptr);

std::pair<WifiStatus, sp<IWifiStaIface>> WifiChip::getStaIfaceInternal(

    const hidl_string& ifname) {

  if (!sta_iface_.get() ||

      (ifname.c_str() != legacy_hal_.lock()->getStaIfaceName())) {

    return {createWifiStatus(WifiStatusCode::ERROR_INVALID_ARGS), nullptr};

  }

  return Void();

}



Return<void> WifiChip::createRttController(

    const sp<IWifiIface>& bound_iface, createRttController_cb hidl_status_cb) {

  if (!is_valid_) {

    hidl_status_cb(createWifiStatus(WifiStatusCode::ERROR_WIFI_CHIP_INVALID),

                   nullptr);

    return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), sta_iface_};

}



std::pair<WifiStatus, sp<IWifiRttController>>

WifiChip::createRttControllerInternal(const sp<IWifiIface>& bound_iface) {

  sp<WifiRttController> rtt = new WifiRttController(bound_iface, legacy_hal_);

  rtt_controllers_.emplace_back(rtt);

  hidl_status_cb(createWifiStatus(WifiStatusCode::SUCCESS), rtt);

  return Void();

  return {createWifiStatus(WifiStatusCode::SUCCESS), rtt};

}



void WifiChip::invalidateAndRemoveAllIfaces() {

  invalidateAndClear(ap_iface_);

  invalidateAndClear(nan_iface_);

  invalidateAndClear(p2p_iface_);

  invalidateAndClear(sta_iface_);

  // Since all the ifaces are invalid now, all RTT controller objects

  // using those ifaces also need to be invalidated.

  for (const auto& rtt : rtt_controllers_) {

    rtt->invalidate();

  }

  rtt_controllers_.clear();

}



}  // namespace implementation

}  // namespace V1_0

}  // namespace wifi

wifi/1.0/default/wifi_chip.h

+32 −0

File changed.

Preview size limit exceeded, changes collapsed.

wifi/1.0/default/wifi_legacy_hal.cpp

+10 −6

File changed.

Preview size limit exceeded, changes collapsed.

wifi/1.0/default/wifi_legacy_hal.h

+2 −2
Original line number Diff line number Diff line
@@ -49,8 +49,8 @@ class WifiLegacyHal { 
  // Wrappers for all the functions in the legacy HAL function table.

  std::pair<wifi_error, std::string> getDriverVersion();

  std::pair<wifi_error, std::string> getFirmwareVersion();

  std::pair<wifi_error, std::vector<char>> requestDriverMemoryDump();

  std::pair<wifi_error, std::vector<char>> requestFirmwareMemoryDump();

  std::pair<wifi_error, std::vector<uint8_t>> requestDriverMemoryDump();

  std::pair<wifi_error, std::vector<uint8_t>> requestFirmwareMemoryDump();



 private:

  static const uint32_t kMaxVersionStringLength;